Migrate from LegacyColor to bevy_color::Color

crates/bevy_color/src/color.rs

@@ -45,6 +45,12 @@ impl Color {
         (*self).into()
     }
 
+    #[deprecated = "Use `Color::srgba` instead"]
+    /// Creates a new [`Color`] object storing a [`Srgba`] color.
+    pub const fn rgba(red: f32, green: f32, blue: f32, alpha: f32) -> Self {
+        Self::srgba(red, green, blue, alpha)
+    }
+
     /// Creates a new [`Color`] object storing a [`Srgba`] color.
     pub const fn srgba(red: f32, green: f32, blue: f32, alpha: f32) -> Self {
         Self::Srgba(Srgba {
@@ -55,6 +61,12 @@ impl Color {
         })
     }
 
+    #[deprecated = "Use `Color::srgb` instead"]
+    /// Creates a new [`Color`] object storing a [`Srgba`] color with an alpha of 1.0.
+    pub const fn rgb(red: f32, green: f32, blue: f32) -> Self {
+        Self::srgb(red, green, blue)
+    }
+
     /// Creates a new [`Color`] object storing a [`Srgba`] color with an alpha of 1.0.
     pub const fn srgb(red: f32, green: f32, blue: f32) -> Self {
         Self::Srgba(Srgba {
@@ -65,6 +77,67 @@ impl Color {
         })
     }
 
+    #[deprecated = "Use `Color::srgb_from_array` instead"]
+    /// Reads an array of floats to creates a new [`Color`] object storing a [`Srgba`] color with an alpha of 1.0.
+    pub fn rgb_from_array(array: [f32; 3]) -> Self {
+        Self::Srgba(Srgba {
+            red: array[0],
+            green: array[1],
+            blue: array[2],
+            alpha: 1.0,
+        })
+    }
+
+    /// Reads an array of floats to creates a new [`Color`] object storing a [`Srgba`] color with an alpha of 1.0.
+    pub fn srgb_from_array(array: [f32; 3]) -> Self {
+        Self::Srgba(Srgba {
+            red: array[0],
+            green: array[1],
+            blue: array[2],
+            alpha: 1.0,
+        })
+    }
+
+    #[deprecated = "Use `Color::srgba_u8` instead"]
+    /// Creates a new [`Color`] object storing a [`Srgba`] color from [`u8`] values.
+    ///
+    /// A value of 0 is interpreted as 0.0, and a value of 255 is interpreted as 1.0.
+    pub fn rgba_u8(red: u8, green: u8, blue: u8, alpha: u8) -> Self {
+        Self::srgba_u8(red, green, blue, alpha)
+    }
+
+    /// Creates a new [`Color`] object storing a [`Srgba`] color from [`u8`] values.
+    ///
+    /// A value of 0 is interpreted as 0.0, and a value of 255 is interpreted as 1.0.
+    pub fn srgba_u8(red: u8, green: u8, blue: u8, alpha: u8) -> Self {
+        Self::Srgba(Srgba {
+            red: red as f32 / 255.0,
+            green: green as f32 / 255.0,
+            blue: blue as f32 / 255.0,
+            alpha: alpha as f32 / 255.0,
+        })
+    }
+
+    #[deprecated = "Use `Color::srgb_u8` instead"]
+    /// Creates a new [`Color`] object storing a [`Srgba`] color from [`u8`] values with an alpha of 1.0.
+    ///
+    /// A value of 0 is interpreted as 0.0, and a value of 255 is interpreted as 1.0.
+    pub fn rgb_u8(red: u8, green: u8, blue: u8) -> Self {
+        Self::srgb_u8(red, green, blue)
+    }
+
+    /// Creates a new [`Color`] object storing a [`Srgba`] color from [`u8`] values with an alpha of 1.0.
+    ///
+    /// A value of 0 is interpreted as 0.0, and a value of 255 is interpreted as 1.0.
+    pub fn srgb_u8(red: u8, green: u8, blue: u8) -> Self {
+        Self::Srgba(Srgba {
+            red: red as f32 / 255.0,
+            green: green as f32 / 255.0,
+            blue: blue as f32 / 255.0,
+            alpha: 1.0,
+        })
+    }
+
     /// Createsa new [`Color`] object storing a [`LinearRgba`] color.
     pub const fn linear_rgba(red: f32, green: f32, blue: f32, alpha: f32) -> Self {
         Self::LinearRgba(LinearRgba {
@@ -286,6 +359,20 @@ impl Alpha for Color {
             Color::Xyza(x) => x.alpha(),
         }
     }
+
+    fn set_alpha(&mut self, alpha: f32) {
+        match self {
+            Color::Srgba(x) => x.set_alpha(alpha),
+            Color::LinearRgba(x) => x.set_alpha(alpha),
+            Color::Hsla(x) => x.set_alpha(alpha),
+            Color::Hsva(x) => x.set_alpha(alpha),
+            Color::Hwba(x) => x.set_alpha(alpha),
+            Color::Laba(x) => x.set_alpha(alpha),
+            Color::Lcha(x) => x.set_alpha(alpha),
+            Color::Oklaba(x) => x.set_alpha(alpha),
+            Color::Xyza(x) => x.set_alpha(alpha),
+        }
+    }
 }
 
 impl From<Srgba> for Color {

crates/bevy_color/src/color_ops.rs

@@ -47,4 +47,17 @@ pub trait Alpha: Sized {
 
     /// Return a the alpha component of this color.
     fn alpha(&self) -> f32;
+
+    /// Sets the alpha component of this color.
+    fn set_alpha(&mut self, alpha: f32);
+
+    /// Is the alpha component of this color less than or equal to 0.0?
+    fn is_fully_transparent(&self) -> bool {
+        self.alpha() <= 0.0
+    }
+
+    /// Is the alpha component of this color greater than or equal to 1.0?
+    fn is_fully_opaque(&self) -> bool {
+        self.alpha() >= 1.0
+    }
 }

crates/bevy_color/src/hsla.rs

@@ -105,6 +105,11 @@ impl Alpha for Hsla {
     fn alpha(&self) -> f32 {
         self.alpha
     }
+
+    #[inline]
+    fn set_alpha(&mut self, alpha: f32) {
+        self.alpha = alpha;
+    }
 }
 
 impl Luminance for Hsla {

crates/bevy_color/src/hsva.rs

@@ -84,6 +84,11 @@ impl Alpha for Hsva {
     fn alpha(&self) -> f32 {
         self.alpha
     }
+
+    #[inline]
+    fn set_alpha(&mut self, alpha: f32) {
+        self.alpha = alpha;
+    }
 }
 
 impl From<Hsva> for Hwba {

crates/bevy_color/src/hwba.rs

@@ -88,6 +88,11 @@ impl Alpha for Hwba {
     fn alpha(&self) -> f32 {
         self.alpha
     }
+
+    #[inline]
+    fn set_alpha(&mut self, alpha: f32) {
+        self.alpha = alpha;
+    }
 }
 
 impl From<Srgba> for Hwba {

crates/bevy_color/src/laba.rs

@@ -103,6 +103,11 @@ impl Alpha for Laba {
     fn alpha(&self) -> f32 {
         self.alpha
     }
+
+    #[inline]
+    fn set_alpha(&mut self, alpha: f32) {
+        self.alpha = alpha;
+    }
 }
 
 impl Luminance for Laba {

crates/bevy_color/src/lcha.rs

@@ -101,6 +101,11 @@ impl Alpha for Lcha {
     fn alpha(&self) -> f32 {
         self.alpha
     }
+
+    #[inline]
+    fn set_alpha(&mut self, alpha: f32) {
+        self.alpha = alpha;
+    }
 }
 
 impl Luminance for Lcha {

crates/bevy_color/src/linear_rgba.rs

@@ -1,3 +1,5 @@
+use std::ops::{Add, AddAssign, Div, Mul, Sub, SubAssign};
+
 use crate::{color_difference::EuclideanDistance, Alpha, Luminance, Mix, StandardColor};
 use bevy_math::Vec4;
 use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
@@ -50,6 +52,30 @@ impl LinearRgba {
         alpha: 0.0,
     };
 
+    /// A fully red color with full alpha.
+    pub const RED: Self = Self {
+        red: 1.0,
+        green: 0.0,
+        blue: 0.0,
+        alpha: 1.0,
+    };
+
+    /// A fully green color with full alpha.
+    pub const GREEN: Self = Self {
+        red: 0.0,
+        green: 1.0,
+        blue: 0.0,
+        alpha: 1.0,
+    };
+
+    /// A fully blue color with full alpha.
+    pub const BLUE: Self = Self {
+        red: 0.0,
+        green: 0.0,
+        blue: 1.0,
+        alpha: 1.0,
+    };
+
     /// An invalid color.
     ///
     /// This type can be used to represent an invalid color value;
@@ -127,6 +153,26 @@ impl LinearRgba {
             self.mix_assign(Self::new(1.0, 1.0, 1.0, self.alpha), adjustment);
         }
     }
+
+    /// Converts the color into a [f32; 4] array in RGBA order.
+    ///
+    /// This is useful for passing the color to a shader.
+    pub fn to_f32_array(&self) -> [f32; 4] {
+        [self.red, self.green, self.blue, self.alpha]
+    }
+
+    /// Converts this color to a u32.
+    ///
+    /// Maps the RGBA channels in RGBA order to a little-endian byte array (GPUs are little-endian).
+    /// `A` will be the most significant byte and `R` the least significant.
+    pub fn as_u32(&self) -> u32 {
+        u32::from_le_bytes([
+            (self.red * 255.0) as u8,
+            (self.green * 255.0) as u8,
+            (self.blue * 255.0) as u8,
+            (self.alpha * 255.0) as u8,
+        ])
+    }
 }
 
 impl Default for LinearRgba {
@@ -193,6 +239,11 @@ impl Alpha for LinearRgba {
     fn alpha(&self) -> f32 {
         self.alpha
     }
+
+    #[inline]
+    fn set_alpha(&mut self, alpha: f32) {
+        self.alpha = alpha;
+    }
 }
 
 impl EuclideanDistance for LinearRgba {
@@ -228,6 +279,90 @@ impl From<LinearRgba> for wgpu::Color {
     }
 }
 
+/// All color channels are scaled directly,
+/// but alpha is unchanged.
+///
+/// Values are not clamped.
+impl Mul<f32> for LinearRgba {
+    type Output = Self;
+
+    fn mul(self, rhs: f32) -> Self {
+        Self {
+            red: self.red * rhs,
+            green: self.green * rhs,
+            blue: self.blue * rhs,
+            alpha: self.alpha,
+        }
+    }
+}
+
+impl Mul<LinearRgba> for f32 {
+    type Output = LinearRgba;
+
+    fn mul(self, rhs: LinearRgba) -> LinearRgba {
+        rhs * self
+    }
+}
+
+/// All color channels are scaled directly,
+/// but alpha is unchanged.
+///
+/// Values are not clamped.
+impl Div<f32> for LinearRgba {
+    type Output = Self;
+
+    fn div(self, rhs: f32) -> Self {
+        Self {
+            red: self.red / rhs,
+            green: self.green / rhs,
+            blue: self.blue / rhs,
+            alpha: self.alpha,
+        }
+    }
+}
+
+/// All color channels are added directly,
+/// but alpha is the average of the two alphas.
+impl Add<LinearRgba> for LinearRgba {
+    type Output = LinearRgba;
+
+    fn add(self, rhs: LinearRgba) -> LinearRgba {
+        LinearRgba {
+            red: self.red + rhs.red,
+            green: self.green + rhs.green,
+            blue: self.blue + rhs.blue,
+            alpha: (self.alpha + rhs.alpha) / 2.0,
+        }
+    }
+}
+
+impl AddAssign<LinearRgba> for LinearRgba {
+    fn add_assign(&mut self, rhs: LinearRgba) {
+        *self = *self + rhs;
+    }
+}
+
+/// All color channels are subtracted directly,
+/// but alpha is the average of the two alphas.
+impl Sub<LinearRgba> for LinearRgba {
+    type Output = LinearRgba;
+
+    fn sub(self, rhs: LinearRgba) -> LinearRgba {
+        LinearRgba {
+            red: self.red - rhs.red,
+            green: self.green - rhs.green,
+            blue: self.blue - rhs.blue,
+            alpha: (self.alpha + rhs.alpha) / 2.0,
+        }
+    }
+}
+
+impl SubAssign<LinearRgba> for LinearRgba {
+    fn sub_assign(&mut self, rhs: LinearRgba) {
+        *self = *self - rhs;
+    }
+}
+
 // [`LinearRgba`] is intended to be used with shaders
 // So it's the only color type that implements [`ShaderType`] to make it easier to use inside shaders
 impl encase::ShaderType for LinearRgba {

crates/bevy_color/src/oklaba.rs

@@ -99,6 +99,11 @@ impl Alpha for Oklaba {
     fn alpha(&self) -> f32 {
         self.alpha
     }
+
+    #[inline]
+    fn set_alpha(&mut self, alpha: f32) {
+        self.alpha = alpha;
+    }
 }
 
 impl Luminance for Oklaba {