Create RColor type to directly wrap SDL_Color

moralrecordings · moralrecordings · commit 7c68dd3cf31c · 2022-03-10T19:56:48.000+08:00
diff --git a/examples/animation.rs b/examples/animation.rs
@@ -24,7 +24,7 @@ fn main() -> Result<(), String> {
         .map_err(|e| e.to_string())?;
     let texture_creator = canvas.texture_creator();
 
-    canvas.set_draw_color(sdl2::pixels::Color::RGBA(0, 0, 0, 255));
+    canvas.set_draw_color(sdl2::pixels::RColor::RGBA(0, 0, 0, 255));
 
     let timer = sdl_context.timer()?;
 
diff --git a/src/sdl2/pixels.rs b/src/sdl2/pixels.rs
@@ -1,6 +1,8 @@
 use crate::sys;
-use std::convert::TryFrom;
+use std::convert::{AsMut, AsRef, TryFrom};
+use std::hash::{Hash, Hasher};
 use std::mem::transmute;
+use std::ops::{Deref, DerefMut};
 
 use crate::get_error;
 
@@ -41,15 +43,18 @@ impl Palette {
 
     /// Creates a palette from the provided colors
     #[doc(alias = "SDL_SetPaletteColors")]
-    pub fn with_colors(colors: &[Color]) -> Result<Self, String> {
+    pub fn with_colors<C>(colors: &[C]) -> Result<Self, String>
+    where
+        C: Copy + Into<RColor>,
+    {
         let pal = Self::new(colors.len())?;
 
         // Already validated, so don't check again
         let ncolors = colors.len() as ::libc::c_int;
 
         let result = unsafe {
             let mut raw_colors: Vec<sys::SDL_Color> =
-                colors.iter().map(|color| color.raw()).collect();
+                colors.iter().map(|color| (*color).into().raw).collect();
 
             let pal_ptr = (&mut raw_colors[0]) as *mut sys::SDL_Color;
 
@@ -85,21 +90,23 @@ impl_raw_accessors!((Palette, *mut sys::SDL_Palette));
 
 #[test]
 fn create_palette() {
-    let colors: Vec<_> = (0..0xff).map(|u| Color::RGB(u, 0, 0xff - u)).collect();
+    let colors: Vec<_> = (0..0xff).map(|u| RColor::RGB(u, 0, 0xff - u)).collect();
 
     let palette = Palette::with_colors(&colors).unwrap();
 
     assert!(palette.len() == 255);
 }
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+#[deprecated(since = "0.35.3", note = "Users should instead use RColor")]
 pub struct Color {
     pub r: u8,
     pub g: u8,
     pub b: u8,
     pub a: u8,
 }
 
+#[allow(deprecated)]
 impl Color {
     #[inline]
     #[allow(non_snake_case)]
@@ -163,30 +170,187 @@ impl Color {
     pub const CYAN: Color = Color::RGBA(0, 255, 255, 255);
 }
 
+#[allow(deprecated)]
 impl Into<sys::SDL_Color> for Color {
     fn into(self) -> sys::SDL_Color {
         self.raw()
     }
 }
 
+#[allow(deprecated)]
 impl From<sys::SDL_Color> for Color {
     fn from(raw: sys::SDL_Color) -> Color {
         Color::RGBA(raw.r, raw.g, raw.b, raw.a)
     }
 }
 
+#[allow(deprecated)]
 impl From<(u8, u8, u8)> for Color {
     fn from((r, g, b): (u8, u8, u8)) -> Color {
         Color::RGB(r, g, b)
     }
 }
 
+#[allow(deprecated)]
 impl From<(u8, u8, u8, u8)> for Color {
     fn from((r, g, b, a): (u8, u8, u8, u8)) -> Color {
         Color::RGBA(r, g, b, a)
     }
 }
 
+#[allow(deprecated)]
+impl Into<RColor> for Color {
+    fn into(self) -> RColor {
+        RColor::RGBA(self.r, self.g, self.b, self.a)
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct RColor {
+    raw: sys::SDL_Color,
+}
+
+impl RColor {
+    #[inline]
+    #[allow(non_snake_case)]
+    pub const fn RGB(r: u8, g: u8, b: u8) -> RColor {
+        RColor {
+            raw: sys::SDL_Color { r, g, b, a: 0xff },
+        }
+    }
+
+    #[inline]
+    #[allow(non_snake_case)]
+    pub const fn RGBA(r: u8, g: u8, b: u8, a: u8) -> RColor {
+        RColor {
+            raw: sys::SDL_Color { r, g, b, a },
+        }
+    }
+
+    #[doc(alias = "SDL_MapRGBA")]
+    pub fn to_u32(self, format: &PixelFormat) -> u32 {
+        unsafe { sys::SDL_MapRGBA(format.raw, self.raw.r, self.raw.g, self.raw.b, self.raw.a) }
+    }
+
+    #[doc(alias = "SDL_GetRGBA")]
+    pub fn from_u32(format: &PixelFormat, pixel: u32) -> RColor {
+        let (mut r, mut g, mut b, mut a) = (0, 0, 0, 0);
+
+        unsafe { sys::SDL_GetRGBA(pixel, format.raw, &mut r, &mut g, &mut b, &mut a) };
+        RColor::RGBA(r, g, b, a)
+    }
+
+    pub fn invert(self) -> RColor {
+        RColor::RGBA(
+            255 - self.raw.r,
+            255 - self.raw.g,
+            255 - self.raw.b,
+            255 - self.raw.a,
+        )
+    }
+
+    #[inline]
+    pub const fn rgb(self) -> (u8, u8, u8) {
+        (self.raw.r, self.raw.g, self.raw.b)
+    }
+
+    #[inline]
+    pub const fn rgba(self) -> (u8, u8, u8, u8) {
+        (self.raw.r, self.raw.g, self.raw.b, self.raw.a)
+    }
+
+    #[inline]
+    pub const fn raw(self) -> sys::SDL_Color {
+        self.raw
+    }
+
+    pub const WHITE: RColor = RColor::RGBA(255, 255, 255, 255);
+    pub const BLACK: RColor = RColor::RGBA(0, 0, 0, 255);
+    pub const GRAY: RColor = RColor::RGBA(128, 128, 128, 255);
+    pub const GREY: RColor = RColor::GRAY;
+    pub const RED: RColor = RColor::RGBA(255, 0, 0, 255);
+    pub const GREEN: RColor = RColor::RGBA(0, 255, 0, 255);
+    pub const BLUE: RColor = RColor::RGBA(0, 0, 255, 255);
+    pub const MAGENTA: RColor = RColor::RGBA(255, 0, 255, 255);
+    pub const YELLOW: RColor = RColor::RGBA(255, 255, 0, 255);
+    pub const CYAN: RColor = RColor::RGBA(0, 255, 255, 255);
+}
+
+impl ::std::fmt::Debug for RColor {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+        return write!(
+            fmt,
+            "RColor {{ r: {}, g: {}, b: {}, a: {} }}",
+            self.raw.r, self.raw.g, self.raw.b, self.raw.a
+        );
+    }
+}
+
+impl PartialEq for RColor {
+    fn eq(&self, other: &RColor) -> bool {
+        self.raw.r == other.raw.r
+            && self.raw.g == other.raw.g
+            && self.raw.b == other.raw.b
+            && self.raw.a == other.raw.a
+    }
+}
+
+impl Eq for RColor {}
+
+impl Hash for RColor {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.raw.r.hash(state);
+        self.raw.g.hash(state);
+        self.raw.b.hash(state);
+        self.raw.a.hash(state);
+    }
+}
+
+impl Deref for RColor {
+    type Target = sys::SDL_Color;
+
+    fn deref(&self) -> &sys::SDL_Color {
+        &self.raw
+    }
+}
+
+impl DerefMut for RColor {
+    fn deref_mut(&mut self) -> &mut sys::SDL_Color {
+        &mut self.raw
+    }
+}
+
+impl AsRef<sys::SDL_Color> for RColor {
+    fn as_ref(&self) -> &sys::SDL_Color {
+        &self.raw
+    }
+}
+
+impl AsMut<sys::SDL_Color> for RColor {
+    fn as_mut(&mut self) -> &mut sys::SDL_Color {
+        &mut self.raw
+    }
+}
+
+impl Into<sys::SDL_Color> for RColor {
+    fn into(self) -> sys::SDL_Color {
+        self.raw
+    }
+}
+
+impl From<sys::SDL_Color> for RColor {
+    fn from(raw: sys::SDL_Color) -> RColor {
+        RColor { raw }
+    }
+}
+
+#[allow(deprecated)]
+impl Into<Color> for RColor {
+    fn into(self) -> Color {
+        Color::RGBA(self.raw.r, self.raw.g, self.raw.b, self.raw.a)
+    }
+}
+
 pub struct PixelMasks {
     /// Bits per pixel; usually 15, 16, or 32
     pub bpp: u8,
diff --git a/src/sdl2/render.rs b/src/sdl2/render.rs
@@ -163,18 +163,21 @@ impl Into<sys::SDL_Vertex> for Vertex {
 }
 
 impl Vertex {
-    pub fn new(position: FPoint, color: pixels::Color, tex_coord: FPoint) -> Vertex {
+    pub fn new<C>(position: FPoint, color: C, tex_coord: FPoint) -> Vertex
+    where
+        C: Copy + Into<pixels::RColor>,
+    {
         Vertex {
             raw: sys::SDL_Vertex {
                 position: position.into(),
-                color: color.into(),
+                color: color.into().raw(),
                 tex_coord: tex_coord.into(),
             },
         }
     }
 
     pub fn from_ll(raw: sys::SDL_Vertex) -> Vertex {
-        Vertex::new(raw.position.into(), raw.color.into(), raw.tex_coord.into())
+        Vertex::new(raw.position.into(), raw.color, raw.tex_coord.into())
     }
 
     #[doc(alias = "SDL_Vertex")]
@@ -192,7 +195,7 @@ impl Vertex {
         self.raw.position.into()
     }
 
-    pub fn color(self) -> pixels::Color {
+    pub fn color(self) -> pixels::RColor {
         self.raw.color.into()
     }
 
@@ -408,7 +411,7 @@ impl<'s> RenderTarget for Surface<'s> {
 /// ```rust,no_run
 /// # use sdl2::render::Canvas;
 /// # use sdl2::video::Window;
-/// # use sdl2::pixels::Color;
+/// # use sdl2::pixels::RColor;
 /// # use sdl2::rect::Rect;
 /// # let sdl_context = sdl2::init().unwrap();
 /// # let video_subsystem = sdl_context.video().unwrap();
@@ -420,12 +423,12 @@ impl<'s> RenderTarget for Surface<'s> {
 ///     // render faster than your display rate (usually 60Hz or 144Hz)
 ///     .build().unwrap();
 ///
-/// canvas.set_draw_color(Color::RGB(0, 0, 0));
+/// canvas.set_draw_color(RColor::RGB(0, 0, 0));
 /// // fills the canvas with the color we set in `set_draw_color`.
 /// canvas.clear();
 ///
 /// // change the color of our drawing with a gold-color ...
-/// canvas.set_draw_color(Color::RGB(255, 210, 0));
+/// canvas.set_draw_color(RColor::RGB(255, 210, 0));
 /// // A draw a rectangle which almost fills our window with it !
 /// canvas.fill_rect(Rect::new(10, 10, 780, 580));
 ///
@@ -609,17 +612,17 @@ impl<T: RenderTarget> Canvas<T> {
     /// ```rust,no_run
     /// # use sdl2::render::{Canvas, Texture};
     /// # use sdl2::video::Window;
-    /// # use sdl2::pixels::Color;
+    /// # use sdl2::pixels::RColor;
     /// # use sdl2::rect::Rect;
     /// # let mut canvas : Canvas<Window> = unimplemented!();
     /// let texture_creator = canvas.texture_creator();
     /// let mut texture = texture_creator
     ///     .create_texture_target(texture_creator.default_pixel_format(), 150, 150)
     ///     .unwrap();
     /// let result = canvas.with_texture_canvas(&mut texture, |texture_canvas| {
-    ///     texture_canvas.set_draw_color(Color::RGBA(0, 0, 0, 255));
+    ///     texture_canvas.set_draw_color(RColor::RGBA(0, 0, 0, 255));
     ///     texture_canvas.clear();
-    ///     texture_canvas.set_draw_color(Color::RGBA(255, 0, 0, 255));
+    ///     texture_canvas.set_draw_color(RColor::RGBA(255, 0, 0, 255));
     ///     texture_canvas.fill_rect(Rect::new(50, 50, 50, 50)).unwrap();
     /// });
     /// ```
@@ -665,7 +668,7 @@ impl<T: RenderTarget> Canvas<T> {
     /// Let's create two textures, one which will be yellow, and the other will be white
     ///
     /// ```rust,no_run
-    /// # use sdl2::pixels::Color;
+    /// # use sdl2::pixels::RColor;
     /// # use sdl2::rect::Rect;
     /// # use sdl2::video::Window;
     /// # use sdl2::render::{Canvas, Texture};
@@ -688,10 +691,10 @@ impl<T: RenderTarget> Canvas<T> {
     ///     canvas.with_multiple_texture_canvas(textures.iter(), |texture_canvas, user_context| {
     ///     match *user_context {
     ///         TextureColor::White => {
-    ///             texture_canvas.set_draw_color(Color::RGB(255, 255, 255));
+    ///             texture_canvas.set_draw_color(RColor::RGB(255, 255, 255));
     ///         },
     ///         TextureColor::Yellow => {
-    ///             texture_canvas.set_draw_color(Color::RGB(255, 255, 0));
+    ///             texture_canvas.set_draw_color(RColor::RGB(255, 255, 0));
     ///         }
     ///     };
     ///     texture_canvas.clear();
@@ -1083,7 +1086,7 @@ impl<T: RenderTarget> Canvas<T> {
 
     /// Sets the color used for drawing operations (Rect, Line and Clear).
     #[doc(alias = "SDL_SetRenderDrawColor")]
-    pub fn set_draw_color<C: Into<pixels::Color>>(&mut self, color: C) {
+    pub fn set_draw_color<C: Into<pixels::RColor>>(&mut self, color: C) {
         let (r, g, b, a) = color.into().rgba();
         let ret = unsafe { sys::SDL_SetRenderDrawColor(self.raw, r, g, b, a) };
         // Should only fail on an invalid renderer
@@ -1094,7 +1097,7 @@ impl<T: RenderTarget> Canvas<T> {
 
     /// Gets the color used for drawing operations (Rect, Line and Clear).
     #[doc(alias = "SDL_GetRenderDrawColor")]
-    pub fn draw_color(&self) -> pixels::Color {
+    pub fn draw_color(&self) -> pixels::RColor {
         let (mut r, mut g, mut b, mut a) = (0, 0, 0, 0);
         let ret = unsafe {
             sys::SDL_GetRenderDrawColor(self.context.raw, &mut r, &mut g, &mut b, &mut a)
@@ -1103,7 +1106,7 @@ impl<T: RenderTarget> Canvas<T> {
         if ret != 0 {
             panic!("{}", get_error())
         } else {
-            pixels::Color::RGBA(r, g, b, a)
+            pixels::RColor::RGBA(r, g, b, a)
         }
     }
 
@@ -1602,7 +1605,7 @@ impl<T: RenderTarget> Canvas<T> {
         texture: &Texture,
         xy: &[f32],
         xy_stride: i32,
-        color: &[sys::SDL_Color],
+        color: &[pixels::RColor],
         color_stride: i32,
         uv: &[f32],
         uv_stride: i32,
diff --git a/src/sdl2/surface.rs b/src/sdl2/surface.rs
