Made bevy_color a dependency of bevy_render (#12105)

# Objective

- Fixes #12068

## Solution

- Split `bevy_render::color::colorspace` across the various space
implementations in `bevy_color` as appropriate.
- Moved `From` implementations involving
`bevy_render::color::LegacyColor` into `bevy_render::color`

## Migration Guide

###
`bevy_render::color::colorspace::SrgbColorSpace::<f32>::linear_to_nonlinear_srgb`

Use `bevy_color::color::gamma_function_inverse`

###
`bevy_render::color::colorspace::SrgbColorSpace::<f32>::nonlinear_to_linear_srgb`

Use `bevy_color::color::gamma_function`

###
`bevy_render::color::colorspace::SrgbColorSpace::<u8>::linear_to_nonlinear_srgb`

Modify the `u8` value to instead be an `f32` (`|x| x as f32 / 255.`),
use `bevy_color::color::gamma_function_inverse`, and back again.

###
`bevy_render::color::colorspace::SrgbColorSpace::<u8>::nonlinear_to_linear_srgb`

Modify the `u8` value to instead be an `f32` (`|x| x as f32 / 255.`),
use `bevy_color::color::gamma_function`, and back again.

###
`bevy_render::color::colorspace::HslRepresentation::hsl_to_nonlinear_srgb`

Use `Hsla`'s implementation of `Into<Srgba>`

###
`bevy_render::color::colorspace::HslRepresentation::nonlinear_srgb_to_hsl`

Use `Srgba`'s implementation of `Into<Hsla>`

###
`bevy_render::color::colorspace::LchRepresentation::lch_to_nonlinear_srgb`

Use `Lcha`'s implementation of `Into<Srgba>`

###
`bevy_render::color::colorspace::LchRepresentation::nonlinear_srgb_to_lch`

Use `Srgba`'s implementation of `Into<Lcha>`

Author: bushrat011899

crates/bevy_color/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_color"
-version = "0.13.0"
+version = "0.14.0-dev"
 edition = "2021"
 description = "Types for representing and manipulating color values"
 homepage = "https://bevyengine.org"
@@ -13,8 +13,8 @@ bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
   "bevy",
 ] }
-bevy_render = { path = "../bevy_render", version = "0.14.0-dev" }
 serde = "1.0"
+thiserror = "1.0"
 
 [lints]
 workspace = true

crates/bevy_color/src/color.rs

@@ -1,6 +1,5 @@
 use crate::{Alpha, Hsla, Lcha, LinearRgba, Oklaba, Srgba, StandardColor, Xyza};
 use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
-use bevy_render::color::LegacyColor;
 use serde::{Deserialize, Serialize};
 
 /// An enumerated type that can represent any of the color types in this crate.
@@ -29,14 +28,7 @@ impl StandardColor for Color {}
 impl Color {
     /// Return the color as a linear RGBA color.
     pub fn linear(&self) -> LinearRgba {
-        match self {
-            Color::Srgba(srgba) => (*srgba).into(),
-            Color::LinearRgba(linear) => *linear,
-            Color::Hsla(hsla) => (*hsla).into(),
-            Color::Lcha(lcha) => (*lcha).into(),
-            Color::Oklaba(oklab) => (*oklab).into(),
-            Color::Xyza(xyza) => (*xyza).into(),
-        }
+        (*self).into()
     }
 }
 
@@ -142,9 +134,9 @@ impl From<Color> for Hsla {
             Color::Srgba(srgba) => srgba.into(),
             Color::LinearRgba(linear) => linear.into(),
             Color::Hsla(hsla) => hsla,
-            Color::Lcha(lcha) => LinearRgba::from(lcha).into(),
-            Color::Oklaba(oklab) => LinearRgba::from(oklab).into(),
-            Color::Xyza(xyza) => LinearRgba::from(xyza).into(),
+            Color::Lcha(lcha) => lcha.into(),
+            Color::Oklaba(oklab) => oklab.into(),
+            Color::Xyza(xyza) => xyza.into(),
         }
     }
 }
@@ -154,10 +146,10 @@ impl From<Color> for Lcha {
         match value {
             Color::Srgba(srgba) => srgba.into(),
             Color::LinearRgba(linear) => linear.into(),
-            Color::Hsla(hsla) => Srgba::from(hsla).into(),
+            Color::Hsla(hsla) => hsla.into(),
             Color::Lcha(lcha) => lcha,
-            Color::Oklaba(oklab) => LinearRgba::from(oklab).into(),
-            Color::Xyza(xyza) => LinearRgba::from(xyza).into(),
+            Color::Oklaba(oklab) => oklab.into(),
+            Color::Xyza(xyza) => xyza.into(),
         }
     }
 }
@@ -167,10 +159,10 @@ impl From<Color> for Oklaba {
         match value {
             Color::Srgba(srgba) => srgba.into(),
             Color::LinearRgba(linear) => linear.into(),
-            Color::Hsla(hsla) => Srgba::from(hsla).into(),
-            Color::Lcha(lcha) => LinearRgba::from(lcha).into(),
+            Color::Hsla(hsla) => hsla.into(),
+            Color::Lcha(lcha) => lcha.into(),
             Color::Oklaba(oklab) => oklab,
-            Color::Xyza(xyza) => LinearRgba::from(xyza).into(),
+            Color::Xyza(xyza) => xyza.into(),
         }
     }
 }
@@ -187,27 +179,3 @@ impl From<Color> for Xyza {
         }
     }
 }
-
-impl From<LegacyColor> for Color {
-    fn from(value: LegacyColor) -> Self {
-        match value {
-            LegacyColor::Rgba { .. } => Srgba::from(value).into(),
-            LegacyColor::RgbaLinear { .. } => LinearRgba::from(value).into(),
-            LegacyColor::Hsla { .. } => Hsla::from(value).into(),
-            LegacyColor::Lcha { .. } => Lcha::from(value).into(),
-        }
-    }
-}
-
-impl From<Color> for LegacyColor {
-    fn from(value: Color) -> Self {
-        match value {
-            Color::Srgba(x) => x.into(),
-            Color::LinearRgba(x) => x.into(),
-            Color::Hsla(x) => x.into(),
-            Color::Lcha(x) => x.into(),
-            Color::Oklaba(x) => x.into(),
-            Color::Xyza(x) => x.into(),
-        }
-    }
-}

crates/bevy_color/src/hsla.rs

@@ -1,6 +1,5 @@
 use crate::{Alpha, Lcha, LinearRgba, Luminance, Mix, Oklaba, Srgba, StandardColor};
 use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
-use bevy_render::color::HslRepresentation;
 use serde::{Deserialize, Serialize};
 
 /// Color in Hue-Saturation-Lightness color space with alpha
@@ -129,35 +128,72 @@ impl Luminance for Hsla {
 }
 
 impl From<Srgba> for Hsla {
-    fn from(value: Srgba) -> Self {
-        let (h, s, l) =
-            HslRepresentation::nonlinear_srgb_to_hsl([value.red, value.green, value.blue]);
-        Self::new(h, s, l, value.alpha)
-    }
-}
+    fn from(
+        Srgba {
+            red,
+            green,
+            blue,
+            alpha,
+        }: Srgba,
+    ) -> Self {
+        // https://en.wikipedia.org/wiki/HSL_and_HSV#From_RGB
+        let x_max = red.max(green.max(blue));
+        let x_min = red.min(green.min(blue));
+        let chroma = x_max - x_min;
+        let lightness = (x_max + x_min) / 2.0;
+        let hue = if chroma == 0.0 {
+            0.0
+        } else if red == x_max {
+            60.0 * (green - blue) / chroma
+        } else if green == x_max {
+            60.0 * (2.0 + (blue - red) / chroma)
+        } else {
+            60.0 * (4.0 + (red - green) / chroma)
+        };
+        let hue = if hue < 0.0 { 360.0 + hue } else { hue };
+        let saturation = if lightness <= 0.0 || lightness >= 1.0 {
+            0.0
+        } else {
+            (x_max - lightness) / lightness.min(1.0 - lightness)
+        };
 
-impl From<Hsla> for bevy_render::color::LegacyColor {
-    fn from(value: Hsla) -> Self {
-        bevy_render::color::LegacyColor::Hsla {
-            hue: value.hue,
-            saturation: value.saturation,
-            lightness: value.lightness,
-            alpha: value.alpha,
-        }
+        Self::new(hue, saturation, lightness, alpha)
     }
 }
 
-impl From<bevy_render::color::LegacyColor> for Hsla {
-    fn from(value: bevy_render::color::LegacyColor) -> Self {
-        match value.as_hsla() {
-            bevy_render::color::LegacyColor::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => Hsla::new(hue, saturation, lightness, alpha),
-            _ => unreachable!(),
-        }
+impl From<Hsla> for Srgba {
+    fn from(
+        Hsla {
+            hue,
+            saturation,
+            lightness,
+            alpha,
+        }: Hsla,
+    ) -> Self {
+        // https://en.wikipedia.org/wiki/HSL_and_HSV#HSL_to_RGB
+        let chroma = (1.0 - (2.0 * lightness - 1.0).abs()) * saturation;
+        let hue_prime = hue / 60.0;
+        let largest_component = chroma * (1.0 - (hue_prime % 2.0 - 1.0).abs());
+        let (r_temp, g_temp, b_temp) = if hue_prime < 1.0 {
+            (chroma, largest_component, 0.0)
+        } else if hue_prime < 2.0 {
+            (largest_component, chroma, 0.0)
+        } else if hue_prime < 3.0 {
+            (0.0, chroma, largest_component)
+        } else if hue_prime < 4.0 {
+            (0.0, largest_component, chroma)
+        } else if hue_prime < 5.0 {
+            (largest_component, 0.0, chroma)
+        } else {
+            (chroma, 0.0, largest_component)
+        };
+        let lightness_match = lightness - chroma / 2.0;
+
+        let red = r_temp + lightness_match;
+        let green = g_temp + lightness_match;
+        let blue = b_temp + lightness_match;
+
+        Self::new(red, green, blue, alpha)
     }
 }
 

crates/bevy_color/src/lcha.rs

@@ -1,6 +1,5 @@
-use crate::{Alpha, Hsla, LinearRgba, Luminance, Mix, Oklaba, Srgba, StandardColor};
+use crate::{Alpha, Hsla, LinearRgba, Luminance, Mix, Oklaba, Srgba, StandardColor, Xyza};
 use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
-use bevy_render::color::LchRepresentation;
 use serde::{Deserialize, Serialize};
 
 /// Color in LCH color space, with alpha
@@ -67,6 +66,16 @@ impl Lcha {
     pub const fn with_lightness(self, lightness: f32) -> Self {
         Self { lightness, ..self }
     }
+
+    /// CIE Epsilon Constant
+    ///
+    /// See [Continuity (16) (17)](http://brucelindbloom.com/index.html?LContinuity.html)
+    pub const CIE_EPSILON: f32 = 216.0 / 24389.0;
+
+    /// CIE Kappa Constant
+    ///
+    /// See [Continuity (16) (17)](http://brucelindbloom.com/index.html?LContinuity.html)
+    pub const CIE_KAPPA: f32 = 24389.0 / 27.0;
 }
 
 impl Default for Lcha {
@@ -129,19 +138,116 @@ impl Luminance for Lcha {
     }
 }
 
+impl From<Lcha> for Xyza {
+    fn from(
+        Lcha {
+            lightness,
+            chroma,
+            hue,
+            alpha,
+        }: Lcha,
+    ) -> Self {
+        let lightness = lightness * 100.0;
+        let chroma = chroma * 100.0;
+
+        // convert LCH to Lab
+        // http://www.brucelindbloom.com/index.html?Eqn_LCH_to_Lab.html
+        let l = lightness;
+        let a = chroma * hue.to_radians().cos();
+        let b = chroma * hue.to_radians().sin();
+
+        // convert Lab to XYZ
+        // http://www.brucelindbloom.com/index.html?Eqn_Lab_to_XYZ.html
+        let fy = (l + 16.0) / 116.0;
+        let fx = a / 500.0 + fy;
+        let fz = fy - b / 200.0;
+        let xr = {
+            let fx3 = fx.powf(3.0);
+
+            if fx3 > Lcha::CIE_EPSILON {
+                fx3
+            } else {
+                (116.0 * fx - 16.0) / Lcha::CIE_KAPPA
+            }
+        };
+        let yr = if l > Lcha::CIE_EPSILON * Lcha::CIE_KAPPA {
+            ((l + 16.0) / 116.0).powf(3.0)
+        } else {
+            l / Lcha::CIE_KAPPA
+        };
+        let zr = {
+            let fz3 = fz.powf(3.0);
+
+            if fz3 > Lcha::CIE_EPSILON {
+                fz3
+            } else {
+                (116.0 * fz - 16.0) / Lcha::CIE_KAPPA
+            }
+        };
+        let x = xr * Xyza::D65_WHITE.x;
+        let y = yr * Xyza::D65_WHITE.y;
+        let z = zr * Xyza::D65_WHITE.z;
+
+        Xyza::new(x, y, z, alpha)
+    }
+}
+
+impl From<Xyza> for Lcha {
+    fn from(Xyza { x, y, z, alpha }: Xyza) -> Self {
+        // XYZ to Lab
+        // http://www.brucelindbloom.com/index.html?Eqn_XYZ_to_Lab.html
+        let xr = x / Xyza::D65_WHITE.x;
+        let yr = y / Xyza::D65_WHITE.y;
+        let zr = z / Xyza::D65_WHITE.z;
+        let fx = if xr > Lcha::CIE_EPSILON {
+            xr.cbrt()
+        } else {
+            (Lcha::CIE_KAPPA * xr + 16.0) / 116.0
+        };
+        let fy = if yr > Lcha::CIE_EPSILON {
+            yr.cbrt()
+        } else {
+            (Lcha::CIE_KAPPA * yr + 16.0) / 116.0
+        };
+        let fz = if yr > Lcha::CIE_EPSILON {
+            zr.cbrt()
+        } else {
+            (Lcha::CIE_KAPPA * zr + 16.0) / 116.0
+        };
+        let l = 116.0 * fy - 16.0;
+        let a = 500.0 * (fx - fy);
+        let b = 200.0 * (fy - fz);
+
+        // Lab to LCH
+        // http://www.brucelindbloom.com/index.html?Eqn_Lab_to_LCH.html
+        let c = (a.powf(2.0) + b.powf(2.0)).sqrt();
+        let h = {
+            let h = b.to_radians().atan2(a.to_radians()).to_degrees();
+
+            if h < 0.0 {
+                h + 360.0
+            } else {
+                h
+            }
+        };
+
+        let lightness = (l / 100.0).clamp(0.0, 1.5);
+        let chroma = (c / 100.0).clamp(0.0, 1.5);
+        let hue = h;
+
+        Lcha::new(lightness, chroma, hue, alpha)
+    }
+}
+
 impl From<Srgba> for Lcha {
     fn from(value: Srgba) -> Self {
-        let (l, c, h) =
-            LchRepresentation::nonlinear_srgb_to_lch([value.red, value.green, value.blue]);
-        Lcha::new(l, c, h, value.alpha)
+        Xyza::from(value).into()
     }
 }
 
 impl From<Lcha> for Srgba {
     fn from(value: Lcha) -> Self {
-        let [r, g, b] =
-            LchRepresentation::lch_to_nonlinear_srgb(value.lightness, value.chroma, value.hue);
-        Srgba::new(r, g, b, value.alpha)
+        Xyza::from(value).into()
     }
 }
 
@@ -157,31 +263,6 @@ impl From<Lcha> for LinearRgba {
     }
 }
 
-impl From<Lcha> for bevy_render::color::LegacyColor {
-    fn from(value: Lcha) -> Self {
-        bevy_render::color::LegacyColor::Lcha {
-            hue: value.hue,
-            chroma: value.chroma,
-            lightness: value.lightness,
-            alpha: value.alpha,
-        }
-    }
-}
-
-impl From<bevy_render::color::LegacyColor> for Lcha {
-    fn from(value: bevy_render::color::LegacyColor) -> Self {
-        match value.as_lcha() {
-            bevy_render::color::LegacyColor::Lcha {
-                hue,
-                chroma,
-                lightness,
-                alpha,
-            } => Lcha::new(hue, chroma, lightness, alpha),
-            _ => unreachable!(),
-        }
-    }
-}
-
 impl From<Oklaba> for Lcha {
     fn from(value: Oklaba) -> Self {
         Srgba::from(value).into()