summaryrefslogtreecommitdiffstats
path: root/servo/components/style/color
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--servo/components/style/color/convert.rs888
-rw-r--r--servo/components/style/color/mix.rs475
-rw-r--r--servo/components/style/color/mod.rs465
3 files changed, 1828 insertions, 0 deletions
diff --git a/servo/components/style/color/convert.rs b/servo/components/style/color/convert.rs
new file mode 100644
index 0000000000..4fa037f9d6
--- /dev/null
+++ b/servo/components/style/color/convert.rs
@@ -0,0 +1,888 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Color conversion algorithms.
+//!
+//! Algorithms, matrices and constants are from the [color-4] specification,
+//! unless otherwise specified:
+//!
+//! https://drafts.csswg.org/css-color-4/#color-conversion-code
+//!
+//! NOTE: Matrices has to be transposed from the examples in the spec for use
+//! with the `euclid` library.
+
+use crate::color::ColorComponents;
+use std::f32::consts::PI;
+
+type Transform = euclid::default::Transform3D<f32>;
+type Vector = euclid::default::Vector3D<f32>;
+
+const RAD_PER_DEG: f32 = PI / 180.0;
+const DEG_PER_RAD: f32 = 180.0 / PI;
+
+/// Normalize hue into [0, 360).
+#[inline]
+fn normalize_hue(hue: f32) -> f32 {
+ hue - 360. * (hue / 360.).floor()
+}
+
+/// Calculate the hue from RGB components and return it along with the min and
+/// max RGB values.
+#[inline]
+fn rgb_to_hue_min_max(red: f32, green: f32, blue: f32) -> (f32, f32, f32) {
+ let max = red.max(green).max(blue);
+ let min = red.min(green).min(blue);
+
+ let delta = max - min;
+
+ let hue = if delta != 0.0 {
+ 60.0 * if max == red {
+ (green - blue) / delta + if green < blue { 6.0 } else { 0.0 }
+ } else if max == green {
+ (blue - red) / delta + 2.0
+ } else {
+ (red - green) / delta + 4.0
+ }
+ } else {
+ f32::NAN
+ };
+
+ (hue, min, max)
+}
+
+/// Convert a hue value into red, green, blue components.
+#[inline]
+fn hue_to_rgb(t1: f32, t2: f32, hue: f32) -> f32 {
+ let hue = normalize_hue(hue);
+
+ if hue * 6.0 < 360.0 {
+ t1 + (t2 - t1) * hue / 60.0
+ } else if hue * 2.0 < 360.0 {
+ t2
+ } else if hue * 3.0 < 720.0 {
+ t1 + (t2 - t1) * (240.0 - hue) / 60.0
+ } else {
+ t1
+ }
+}
+
+/// Convert from HSL notation to RGB notation.
+/// https://drafts.csswg.org/css-color-4/#hsl-to-rgb
+#[inline]
+pub fn hsl_to_rgb(from: &ColorComponents) -> ColorComponents {
+ let ColorComponents(hue, saturation, lightness) = *from;
+
+ let t2 = if lightness <= 0.5 {
+ lightness * (saturation + 1.0)
+ } else {
+ lightness + saturation - lightness * saturation
+ };
+ let t1 = lightness * 2.0 - t2;
+
+ ColorComponents(
+ hue_to_rgb(t1, t2, hue + 120.0),
+ hue_to_rgb(t1, t2, hue),
+ hue_to_rgb(t1, t2, hue - 120.0),
+ )
+}
+
+/// Convert from RGB notation to HSL notation.
+/// https://drafts.csswg.org/css-color-4/#rgb-to-hsl
+pub fn rgb_to_hsl(from: &ColorComponents) -> ColorComponents {
+ let ColorComponents(red, green, blue) = *from;
+
+ let (hue, min, max) = rgb_to_hue_min_max(red, green, blue);
+
+ let lightness = (min + max) / 2.0;
+ let delta = max - min;
+
+ let saturation = if delta != 0.0 {
+ if lightness == 0.0 || lightness == 1.0 {
+ 0.0
+ } else {
+ (max - lightness) / lightness.min(1.0 - lightness)
+ }
+ } else {
+ 0.0
+ };
+
+ ColorComponents(hue, saturation, lightness)
+}
+
+/// Convert from HWB notation to RGB notation.
+/// https://drafts.csswg.org/css-color-4/#hwb-to-rgb
+#[inline]
+pub fn hwb_to_rgb(from: &ColorComponents) -> ColorComponents {
+ let ColorComponents(hue, whiteness, blackness) = *from;
+
+ if whiteness + blackness > 1.0 {
+ let gray = whiteness / (whiteness + blackness);
+ return ColorComponents(gray, gray, gray);
+ }
+
+ let x = 1.0 - whiteness - blackness;
+ hsl_to_rgb(&ColorComponents(hue, 1.0, 0.5)).map(|v| v * x + whiteness)
+}
+
+/// Convert from RGB notation to HWB notation.
+/// https://drafts.csswg.org/css-color-4/#rgb-to-hwb
+#[inline]
+pub fn rgb_to_hwb(from: &ColorComponents) -> ColorComponents {
+ let ColorComponents(red, green, blue) = *from;
+
+ let (hue, min, max) = rgb_to_hue_min_max(red, green, blue);
+
+ let whiteness = min;
+ let blackness = 1.0 - max;
+
+ ColorComponents(hue, whiteness, blackness)
+}
+
+/// Convert from Lab to Lch. This calculation works for both Lab and Olab.
+/// <https://drafts.csswg.org/css-color-4/#color-conversion-code>
+#[inline]
+pub fn lab_to_lch(from: &ColorComponents) -> ColorComponents {
+ let ColorComponents(lightness, a, b) = *from;
+
+ let hue = normalize_hue(b.atan2(a) * 180.0 / PI);
+ let chroma = (a.powf(2.0) + b.powf(2.0)).sqrt();
+
+ ColorComponents(lightness, chroma, hue)
+}
+
+/// Convert from Lch to Lab. This calculation works for both Lch and Oklch.
+/// <https://drafts.csswg.org/css-color-4/#color-conversion-code>
+#[inline]
+pub fn lch_to_lab(from: &ColorComponents) -> ColorComponents {
+ let ColorComponents(lightness, chroma, hue) = *from;
+
+ let a = chroma * (hue * PI / 180.0).cos();
+ let b = chroma * (hue * PI / 180.0).sin();
+
+ ColorComponents(lightness, a, b)
+}
+
+#[inline]
+fn transform(from: &ColorComponents, mat: &Transform) -> ColorComponents {
+ let result = mat.transform_vector3d(Vector::new(from.0, from.1, from.2));
+ ColorComponents(result.x, result.y, result.z)
+}
+
+fn xyz_d65_to_xyz_d50(from: &ColorComponents) -> ColorComponents {
+ #[rustfmt::skip]
+ const MAT: Transform = Transform::new(
+ 1.0479298208405488, 0.029627815688159344, -0.009243058152591178, 0.0,
+ 0.022946793341019088, 0.990434484573249, 0.015055144896577895, 0.0,
+ -0.05019222954313557, -0.01707382502938514, 0.7518742899580008, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ transform(from, &MAT)
+}
+
+fn xyz_d50_to_xyz_d65(from: &ColorComponents) -> ColorComponents {
+ #[rustfmt::skip]
+ const MAT: Transform = Transform::new(
+ 0.9554734527042182, -0.028369706963208136, 0.012314001688319899, 0.0,
+ -0.023098536874261423, 1.0099954580058226, -0.020507696433477912, 0.0,
+ 0.0632593086610217, 0.021041398966943008, 1.3303659366080753, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ transform(from, &MAT)
+}
+
+/// A reference white that is used during color conversion.
+pub enum WhitePoint {
+ /// D50 white reference.
+ D50,
+ /// D65 white reference.
+ D65,
+}
+
+fn convert_white_point(from: WhitePoint, to: WhitePoint, components: &mut ColorComponents) {
+ match (from, to) {
+ (WhitePoint::D50, WhitePoint::D65) => *components = xyz_d50_to_xyz_d65(components),
+ (WhitePoint::D65, WhitePoint::D50) => *components = xyz_d65_to_xyz_d50(components),
+
+ _ => {},
+ }
+}
+
+/// A trait that allows conversion of color spaces to and from XYZ coordinate
+/// space with a specified white point.
+///
+/// Allows following the specified method of converting between color spaces:
+/// - Convert to values to sRGB linear light.
+/// - Convert to XYZ coordinate space.
+/// - Adjust white point to target white point.
+/// - Convert to sRGB linear light in target color space.
+/// - Convert to sRGB gamma encoded in target color space.
+///
+/// https://drafts.csswg.org/css-color-4/#color-conversion
+pub trait ColorSpaceConversion {
+ /// The white point that the implementer is represented in.
+ const WHITE_POINT: WhitePoint;
+
+ /// Convert the components from sRGB gamma encoded values to sRGB linear
+ /// light values.
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents;
+
+ /// Convert the components from sRGB linear light values to XYZ coordinate
+ /// space.
+ fn to_xyz(from: &ColorComponents) -> ColorComponents;
+
+ /// Convert the components from XYZ coordinate space to sRGB linear light
+ /// values.
+ fn from_xyz(from: &ColorComponents) -> ColorComponents;
+
+ /// Convert the components from sRGB linear light values to sRGB gamma
+ /// encoded values.
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents;
+}
+
+/// Convert the color components from the specified color space to XYZ and
+/// return the components and the white point they are in.
+pub fn to_xyz<From: ColorSpaceConversion>(from: &ColorComponents) -> (ColorComponents, WhitePoint) {
+ // Convert the color components where in-gamut values are in the range
+ // [0 - 1] to linear light (un-companded) form.
+ let result = From::to_linear_light(from);
+
+ // Convert the color components from the source color space to XYZ.
+ (From::to_xyz(&result), From::WHITE_POINT)
+}
+
+/// Convert the color components from XYZ at the given white point to the
+/// specified color space.
+pub fn from_xyz<To: ColorSpaceConversion>(
+ from: &ColorComponents,
+ white_point: WhitePoint,
+) -> ColorComponents {
+ let mut xyz = from.clone();
+
+ // Convert the white point if needed.
+ convert_white_point(white_point, To::WHITE_POINT, &mut xyz);
+
+ // Convert the color from XYZ to the target color space.
+ let result = To::from_xyz(&xyz);
+
+ // Convert the color components of linear-light values in the range
+ // [0 - 1] to a gamma corrected form.
+ To::to_gamma_encoded(&result)
+}
+
+/// The sRGB color space.
+/// https://drafts.csswg.org/css-color-4/#predefined-sRGB
+pub struct Srgb;
+
+impl Srgb {
+ #[rustfmt::skip]
+ const TO_XYZ: Transform = Transform::new(
+ 0.4123907992659595, 0.21263900587151036, 0.01933081871559185, 0.0,
+ 0.35758433938387796, 0.7151686787677559, 0.11919477979462599, 0.0,
+ 0.1804807884018343, 0.07219231536073371, 0.9505321522496606, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ #[rustfmt::skip]
+ const FROM_XYZ: Transform = Transform::new(
+ 3.2409699419045213, -0.9692436362808798, 0.05563007969699361, 0.0,
+ -1.5373831775700935, 1.8759675015077206, -0.20397695888897657, 0.0,
+ -0.4986107602930033, 0.04155505740717561, 1.0569715142428786, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+}
+
+impl ColorSpaceConversion for Srgb {
+ const WHITE_POINT: WhitePoint = WhitePoint::D65;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ from.clone().map(|value| {
+ let abs = value.abs();
+
+ if abs < 0.04045 {
+ value / 12.92
+ } else {
+ value.signum() * ((abs + 0.055) / 1.055).powf(2.4)
+ }
+ })
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::TO_XYZ)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::FROM_XYZ)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ from.clone().map(|value| {
+ let abs = value.abs();
+
+ if abs > 0.0031308 {
+ value.signum() * (1.055 * abs.powf(1.0 / 2.4) - 0.055)
+ } else {
+ 12.92 * value
+ }
+ })
+ }
+}
+
+/// Color specified with hue, saturation and lightness components.
+pub struct Hsl;
+
+impl ColorSpaceConversion for Hsl {
+ const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ Srgb::to_linear_light(&hsl_to_rgb(from))
+ }
+
+ #[inline]
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ Srgb::to_xyz(from)
+ }
+
+ #[inline]
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ Srgb::from_xyz(from)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ rgb_to_hsl(&Srgb::to_gamma_encoded(from))
+ }
+}
+
+/// Color specified with hue, whiteness and blackness components.
+pub struct Hwb;
+
+impl ColorSpaceConversion for Hwb {
+ const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ Srgb::to_linear_light(&hwb_to_rgb(from))
+ }
+
+ #[inline]
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ Srgb::to_xyz(from)
+ }
+
+ #[inline]
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ Srgb::from_xyz(from)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ rgb_to_hwb(&Srgb::to_gamma_encoded(from))
+ }
+}
+
+/// The same as sRGB color space, except the transfer function is linear light.
+/// https://drafts.csswg.org/css-color-4/#predefined-sRGB-linear
+pub struct SrgbLinear;
+
+impl ColorSpaceConversion for SrgbLinear {
+ const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ // Already in linear light form.
+ from.clone()
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ Srgb::to_xyz(from)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ Srgb::from_xyz(from)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ // Stay in linear light form.
+ from.clone()
+ }
+}
+
+/// The Display-P3 color space.
+/// https://drafts.csswg.org/css-color-4/#predefined-display-p3
+pub struct DisplayP3;
+
+impl DisplayP3 {
+ #[rustfmt::skip]
+ const TO_XYZ: Transform = Transform::new(
+ 0.48657094864821626, 0.22897456406974884, 0.0, 0.0,
+ 0.26566769316909294, 0.6917385218365062, 0.045113381858902575, 0.0,
+ 0.1982172852343625, 0.079286914093745, 1.0439443689009757, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ #[rustfmt::skip]
+ const FROM_XYZ: Transform = Transform::new(
+ 2.4934969119414245, -0.829488969561575, 0.035845830243784335, 0.0,
+ -0.9313836179191236, 1.7626640603183468, -0.07617238926804171, 0.0,
+ -0.40271078445071684, 0.02362468584194359, 0.9568845240076873, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+}
+
+impl ColorSpaceConversion for DisplayP3 {
+ const WHITE_POINT: WhitePoint = WhitePoint::D65;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ Srgb::to_linear_light(from)
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::TO_XYZ)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::FROM_XYZ)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ Srgb::to_gamma_encoded(from)
+ }
+}
+
+/// The a98-rgb color space.
+/// https://drafts.csswg.org/css-color-4/#predefined-a98-rgb
+pub struct A98Rgb;
+
+impl A98Rgb {
+ #[rustfmt::skip]
+ const TO_XYZ: Transform = Transform::new(
+ 0.5766690429101308, 0.29734497525053616, 0.027031361386412378, 0.0,
+ 0.18555823790654627, 0.627363566255466, 0.07068885253582714, 0.0,
+ 0.18822864623499472, 0.07529145849399789, 0.9913375368376389, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ #[rustfmt::skip]
+ const FROM_XYZ: Transform = Transform::new(
+ 2.041587903810746, -0.9692436362808798, 0.013444280632031024, 0.0,
+ -0.5650069742788596, 1.8759675015077206, -0.11836239223101824, 0.0,
+ -0.3447313507783295, 0.04155505740717561, 1.0151749943912054, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+}
+
+impl ColorSpaceConversion for A98Rgb {
+ const WHITE_POINT: WhitePoint = WhitePoint::D65;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ from.clone().map(|v| v.signum() * v.abs().powf(2.19921875))
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::TO_XYZ)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::FROM_XYZ)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ .map(|v| v.signum() * v.abs().powf(0.4547069271758437))
+ }
+}
+
+/// The ProPhoto RGB color space.
+/// https://drafts.csswg.org/css-color-4/#predefined-prophoto-rgb
+pub struct ProphotoRgb;
+
+impl ProphotoRgb {
+ #[rustfmt::skip]
+ const TO_XYZ: Transform = Transform::new(
+ 0.7977604896723027, 0.2880711282292934, 0.0, 0.0,
+ 0.13518583717574031, 0.7118432178101014, 0.0, 0.0,
+ 0.0313493495815248, 0.00008565396060525902, 0.8251046025104601, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ #[rustfmt::skip]
+ const FROM_XYZ: Transform = Transform::new(
+ 1.3457989731028281, -0.5446224939028347, 0.0, 0.0,
+ -0.25558010007997534, 1.5082327413132781, 0.0, 0.0,
+ -0.05110628506753401, 0.02053603239147973, 1.2119675456389454, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+}
+
+impl ColorSpaceConversion for ProphotoRgb {
+ const WHITE_POINT: WhitePoint = WhitePoint::D50;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ from.clone().map(|value| {
+ const ET2: f32 = 16.0 / 512.0;
+
+ let abs = value.abs();
+
+ if abs <= ET2 {
+ value / 16.0
+ } else {
+ value.signum() * abs.powf(1.8)
+ }
+ })
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::TO_XYZ)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::FROM_XYZ)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ const ET: f32 = 1.0 / 512.0;
+
+ from.clone().map(|v| {
+ let abs = v.abs();
+ if abs >= ET {
+ v.signum() * abs.powf(1.0 / 1.8)
+ } else {
+ 16.0 * v
+ }
+ })
+ }
+}
+
+/// The Rec.2020 color space.
+/// https://drafts.csswg.org/css-color-4/#predefined-rec2020
+pub struct Rec2020;
+
+impl Rec2020 {
+ const ALPHA: f32 = 1.09929682680944;
+ const BETA: f32 = 0.018053968510807;
+
+ #[rustfmt::skip]
+ const TO_XYZ: Transform = Transform::new(
+ 0.6369580483012913, 0.26270021201126703, 0.0, 0.0,
+ 0.14461690358620838, 0.677998071518871, 0.028072693049087508, 0.0,
+ 0.16888097516417205, 0.059301716469861945, 1.0609850577107909, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ #[rustfmt::skip]
+ const FROM_XYZ: Transform = Transform::new(
+ 1.7166511879712676, -0.666684351832489, 0.017639857445310915, 0.0,
+ -0.3556707837763924, 1.616481236634939, -0.042770613257808655, 0.0,
+ -0.2533662813736598, 0.01576854581391113, 0.942103121235474, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+}
+
+impl ColorSpaceConversion for Rec2020 {
+ const WHITE_POINT: WhitePoint = WhitePoint::D65;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ from.clone().map(|value| {
+ let abs = value.abs();
+
+ if abs < Self::BETA * 4.5 {
+ value / 4.5
+ } else {
+ value.signum() * ((abs + Self::ALPHA - 1.0) / Self::ALPHA).powf(1.0 / 0.45)
+ }
+ })
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::TO_XYZ)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ transform(from, &Self::FROM_XYZ)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ from.clone().map(|v| {
+ let abs = v.abs();
+
+ if abs > Self::BETA {
+ v.signum() * (Self::ALPHA * abs.powf(0.45) - (Self::ALPHA - 1.0))
+ } else {
+ 4.5 * v
+ }
+ })
+ }
+}
+
+/// A color in the XYZ coordinate space with a D50 white reference.
+/// https://drafts.csswg.org/css-color-4/#predefined-xyz
+pub struct XyzD50;
+
+impl ColorSpaceConversion for XyzD50 {
+ const WHITE_POINT: WhitePoint = WhitePoint::D50;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ }
+}
+
+/// A color in the XYZ coordinate space with a D65 white reference.
+/// https://drafts.csswg.org/css-color-4/#predefined-xyz
+pub struct XyzD65;
+
+impl ColorSpaceConversion for XyzD65 {
+ const WHITE_POINT: WhitePoint = WhitePoint::D65;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ from.clone()
+ }
+}
+
+/// The Lab color space.
+/// https://drafts.csswg.org/css-color-4/#specifying-lab-lch
+pub struct Lab;
+
+impl Lab {
+ const KAPPA: f32 = 24389.0 / 27.0;
+ const EPSILON: f32 = 216.0 / 24389.0;
+ const WHITE: ColorComponents = ColorComponents(0.96422, 1.0, 0.82521);
+}
+
+impl ColorSpaceConversion for Lab {
+ const WHITE_POINT: WhitePoint = WhitePoint::D50;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ // No need for conversion.
+ from.clone()
+ }
+
+ /// Convert a CIELAB color to XYZ as specified in [1] and [2].
+ ///
+ /// [1]: https://drafts.csswg.org/css-color/#lab-to-predefined
+ /// [2]: https://drafts.csswg.org/css-color/#color-conversion-code
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ let f1 = (from.0 + 16.0) / 116.0;
+ let f0 = (from.1 / 500.0) + f1;
+ let f2 = f1 - from.2 / 200.0;
+
+ let x = if f0.powf(3.0) > Self::EPSILON {
+ f0.powf(3.)
+ } else {
+ (116.0 * f0 - 16.0) / Self::KAPPA
+ };
+ let y = if from.0 > Self::KAPPA * Self::EPSILON {
+ ((from.0 + 16.0) / 116.0).powf(3.0)
+ } else {
+ from.0 / Self::KAPPA
+ };
+ let z = if f2.powf(3.0) > Self::EPSILON {
+ f2.powf(3.0)
+ } else {
+ (116.0 * f2 - 16.0) / Self::KAPPA
+ };
+
+ ColorComponents(x * Self::WHITE.0, y * Self::WHITE.1, z * Self::WHITE.2)
+ }
+
+ /// Convert an XYZ colour to LAB as specified in [1] and [2].
+ ///
+ /// [1]: https://drafts.csswg.org/css-color/#rgb-to-lab
+ /// [2]: https://drafts.csswg.org/css-color/#color-conversion-code
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ macro_rules! compute_f {
+ ($value:expr) => {{
+ if $value > Self::EPSILON {
+ $value.cbrt()
+ } else {
+ (Self::KAPPA * $value + 16.0) / 116.0
+ }
+ }};
+ }
+
+ // 4. Convert D50-adapted XYZ to Lab.
+ let f = [
+ compute_f!(from.0 / Self::WHITE.0),
+ compute_f!(from.1 / Self::WHITE.1),
+ compute_f!(from.2 / Self::WHITE.2),
+ ];
+
+ let lightness = 116.0 * f[1] - 16.0;
+ let a = 500.0 * (f[0] - f[1]);
+ let b = 200.0 * (f[1] - f[2]);
+
+ ColorComponents(lightness, a, b)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ // No need for conversion.
+ from.clone()
+ }
+}
+
+/// The Lch color space.
+/// https://drafts.csswg.org/css-color-4/#specifying-lab-lch
+pub struct Lch;
+
+impl ColorSpaceConversion for Lch {
+ const WHITE_POINT: WhitePoint = Lab::WHITE_POINT;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ // No need for conversion.
+ from.clone()
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ // Convert LCH to Lab first.
+ let hue = from.2 * RAD_PER_DEG;
+ let a = from.1 * hue.cos();
+ let b = from.1 * hue.sin();
+
+ let lab = ColorComponents(from.0, a, b);
+
+ // Then convert the Lab to XYZ.
+ Lab::to_xyz(&lab)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ // First convert the XYZ to LAB.
+ let ColorComponents(lightness, a, b) = Lab::from_xyz(&from);
+
+ // Then conver the Lab to LCH.
+ let hue = b.atan2(a) * DEG_PER_RAD;
+ let chroma = (a * a + b * b).sqrt();
+
+ ColorComponents(lightness, chroma, hue)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ // No need for conversion.
+ from.clone()
+ }
+}
+
+/// The Oklab color space.
+/// https://drafts.csswg.org/css-color-4/#specifying-oklab-oklch
+pub struct Oklab;
+
+impl Oklab {
+ #[rustfmt::skip]
+ const XYZ_TO_LMS: Transform = Transform::new(
+ 0.8190224432164319, 0.0329836671980271, 0.048177199566046255, 0.0,
+ 0.3619062562801221, 0.9292868468965546, 0.26423952494422764, 0.0,
+ -0.12887378261216414, 0.03614466816999844, 0.6335478258136937, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ #[rustfmt::skip]
+ const LMS_TO_OKLAB: Transform = Transform::new(
+ 0.2104542553, 1.9779984951, 0.0259040371, 0.0,
+ 0.7936177850, -2.4285922050, 0.7827717662, 0.0,
+ -0.0040720468, 0.4505937099, -0.8086757660, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ #[rustfmt::skip]
+ const LMS_TO_XYZ: Transform = Transform::new(
+ 1.2268798733741557, -0.04057576262431372, -0.07637294974672142, 0.0,
+ -0.5578149965554813, 1.1122868293970594, -0.4214933239627914, 0.0,
+ 0.28139105017721583, -0.07171106666151701, 1.5869240244272418, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+
+ #[rustfmt::skip]
+ const OKLAB_TO_LMS: Transform = Transform::new(
+ 0.99999999845051981432, 1.0000000088817607767, 1.0000000546724109177, 0.0,
+ 0.39633779217376785678, -0.1055613423236563494, -0.089484182094965759684, 0.0,
+ 0.21580375806075880339, -0.063854174771705903402, -1.2914855378640917399, 0.0,
+ 0.0, 0.0, 0.0, 1.0,
+ );
+}
+
+impl ColorSpaceConversion for Oklab {
+ const WHITE_POINT: WhitePoint = WhitePoint::D65;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ // No need for conversion.
+ from.clone()
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ let lms = transform(&from, &Self::OKLAB_TO_LMS);
+ let lms = lms.map(|v| v.powf(3.0));
+ transform(&lms, &Self::LMS_TO_XYZ)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ let lms = transform(&from, &Self::XYZ_TO_LMS);
+ let lms = lms.map(|v| v.cbrt());
+ transform(&lms, &Self::LMS_TO_OKLAB)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ // No need for conversion.
+ from.clone()
+ }
+}
+
+/// The Oklch color space.
+/// https://drafts.csswg.org/css-color-4/#specifying-oklab-oklch
+pub struct Oklch;
+
+impl ColorSpaceConversion for Oklch {
+ const WHITE_POINT: WhitePoint = Oklab::WHITE_POINT;
+
+ fn to_linear_light(from: &ColorComponents) -> ColorComponents {
+ // No need for conversion.
+ from.clone()
+ }
+
+ fn to_xyz(from: &ColorComponents) -> ColorComponents {
+ // First convert OkLCH to Oklab.
+ let hue = from.2 * RAD_PER_DEG;
+ let a = from.1 * hue.cos();
+ let b = from.1 * hue.sin();
+ let oklab = ColorComponents(from.0, a, b);
+
+ // Then convert Oklab to XYZ.
+ Oklab::to_xyz(&oklab)
+ }
+
+ fn from_xyz(from: &ColorComponents) -> ColorComponents {
+ // First convert XYZ to Oklab.
+ let ColorComponents(lightness, a, b) = Oklab::from_xyz(&from);
+
+ // Then convert Oklab to OkLCH.
+ let hue = b.atan2(a) * DEG_PER_RAD;
+ let chroma = (a * a + b * b).sqrt();
+
+ ColorComponents(lightness, chroma, hue)
+ }
+
+ fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
+ // No need for conversion.
+ from.clone()
+ }
+}
diff --git a/servo/components/style/color/mix.rs b/servo/components/style/color/mix.rs
new file mode 100644
index 0000000000..455d025265
--- /dev/null
+++ b/servo/components/style/color/mix.rs
@@ -0,0 +1,475 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Color mixing/interpolation.
+
+use super::{AbsoluteColor, ColorComponents, ColorFlags, ColorSpace};
+use crate::parser::{Parse, ParserContext};
+use cssparser::Parser;
+use std::fmt::{self, Write};
+use style_traits::{CssWriter, ParseError, ToCss};
+
+/// A hue-interpolation-method as defined in [1].
+///
+/// [1]: https://drafts.csswg.org/css-color-4/#typedef-hue-interpolation-method
+#[derive(
+ Clone,
+ Copy,
+ Debug,
+ Eq,
+ MallocSizeOf,
+ Parse,
+ PartialEq,
+ ToAnimatedValue,
+ ToComputedValue,
+ ToCss,
+ ToResolvedValue,
+ ToShmem,
+)]
+#[repr(u8)]
+pub enum HueInterpolationMethod {
+ /// https://drafts.csswg.org/css-color-4/#shorter
+ Shorter,
+ /// https://drafts.csswg.org/css-color-4/#longer
+ Longer,
+ /// https://drafts.csswg.org/css-color-4/#increasing
+ Increasing,
+ /// https://drafts.csswg.org/css-color-4/#decreasing
+ Decreasing,
+ /// https://drafts.csswg.org/css-color-4/#specified
+ Specified,
+}
+
+/// https://drafts.csswg.org/css-color-4/#color-interpolation-method
+#[derive(
+ Clone,
+ Copy,
+ Debug,
+ Eq,
+ MallocSizeOf,
+ PartialEq,
+ ToShmem,
+ ToAnimatedValue,
+ ToComputedValue,
+ ToResolvedValue,
+)]
+#[repr(C)]
+pub struct ColorInterpolationMethod {
+ /// The color-space the interpolation should be done in.
+ pub space: ColorSpace,
+ /// The hue interpolation method.
+ pub hue: HueInterpolationMethod,
+}
+
+impl ColorInterpolationMethod {
+ /// Returns the srgb interpolation method.
+ pub const fn srgb() -> Self {
+ Self {
+ space: ColorSpace::Srgb,
+ hue: HueInterpolationMethod::Shorter,
+ }
+ }
+
+ /// Return the oklab interpolation method used for default color
+ /// interpolcation.
+ pub const fn oklab() -> Self {
+ Self {
+ space: ColorSpace::Oklab,
+ hue: HueInterpolationMethod::Shorter,
+ }
+ }
+
+ /// Decides the best method for interpolating between the given colors.
+ /// https://drafts.csswg.org/css-color-4/#interpolation-space
+ pub fn best_interpolation_between(left: &AbsoluteColor, right: &AbsoluteColor) -> Self {
+ // The preferred color space to use for interpolating colors is Oklab.
+ // However, if either of the colors are in legacy rgb(), hsl() or hwb(),
+ // then interpolation is done in sRGB.
+ if !left.is_legacy_color() || !right.is_legacy_color() {
+ Self::oklab()
+ } else {
+ Self::srgb()
+ }
+ }
+}
+
+impl Parse for ColorInterpolationMethod {
+ fn parse<'i, 't>(
+ _: &ParserContext,
+ input: &mut Parser<'i, 't>,
+ ) -> Result<Self, ParseError<'i>> {
+ input.expect_ident_matching("in")?;
+ let space = ColorSpace::parse(input)?;
+ // https://drafts.csswg.org/css-color-4/#hue-interpolation
+ // Unless otherwise specified, if no specific hue interpolation
+ // algorithm is selected by the host syntax, the default is shorter.
+ let hue = if space.is_polar() {
+ input
+ .try_parse(|input| -> Result<_, ParseError<'i>> {
+ let hue = HueInterpolationMethod::parse(input)?;
+ input.expect_ident_matching("hue")?;
+ Ok(hue)
+ })
+ .unwrap_or(HueInterpolationMethod::Shorter)
+ } else {
+ HueInterpolationMethod::Shorter
+ };
+ Ok(Self { space, hue })
+ }
+}
+
+impl ToCss for ColorInterpolationMethod {
+ fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+ where
+ W: Write,
+ {
+ dest.write_str("in ")?;
+ self.space.to_css(dest)?;
+ if self.hue != HueInterpolationMethod::Shorter {
+ dest.write_char(' ')?;
+ self.hue.to_css(dest)?;
+ dest.write_str(" hue")?;
+ }
+ Ok(())
+ }
+}
+
+/// Mix two colors into one.
+pub fn mix(
+ interpolation: ColorInterpolationMethod,
+ left_color: &AbsoluteColor,
+ mut left_weight: f32,
+ right_color: &AbsoluteColor,
+ mut right_weight: f32,
+ normalize_weights: bool,
+) -> AbsoluteColor {
+ // https://drafts.csswg.org/css-color-5/#color-mix-percent-norm
+ let mut alpha_multiplier = 1.0;
+ if normalize_weights {
+ let sum = left_weight + right_weight;
+ if sum != 1.0 {
+ let scale = 1.0 / sum;
+ left_weight *= scale;
+ right_weight *= scale;
+ if sum < 1.0 {
+ alpha_multiplier = sum;
+ }
+ }
+ }
+
+ mix_in(
+ interpolation.space,
+ left_color,
+ left_weight,
+ right_color,
+ right_weight,
+ interpolation.hue,
+ alpha_multiplier,
+ )
+}
+
+/// What the outcome of each component should be in a mix result.
+#[derive(Clone, Copy)]
+#[repr(u8)]
+enum ComponentMixOutcome {
+ /// Mix the left and right sides to give the result.
+ Mix,
+ /// Carry the left side forward to the result.
+ UseLeft,
+ /// Carry the right side forward to the result.
+ UseRight,
+ /// The resulting component should also be none.
+ None,
+}
+
+impl ComponentMixOutcome {
+ fn from_colors(
+ left: &AbsoluteColor,
+ right: &AbsoluteColor,
+ flags_to_check: ColorFlags,
+ ) -> Self {
+ match (
+ left.flags.contains(flags_to_check),
+ right.flags.contains(flags_to_check),
+ ) {
+ (true, true) => Self::None,
+ (true, false) => Self::UseRight,
+ (false, true) => Self::UseLeft,
+ (false, false) => Self::Mix,
+ }
+ }
+}
+
+fn mix_in(
+ color_space: ColorSpace,
+ left_color: &AbsoluteColor,
+ left_weight: f32,
+ right_color: &AbsoluteColor,
+ right_weight: f32,
+ hue_interpolation: HueInterpolationMethod,
+ alpha_multiplier: f32,
+) -> AbsoluteColor {
+ let outcomes = [
+ ComponentMixOutcome::from_colors(left_color, right_color, ColorFlags::C1_IS_NONE),
+ ComponentMixOutcome::from_colors(left_color, right_color, ColorFlags::C2_IS_NONE),
+ ComponentMixOutcome::from_colors(left_color, right_color, ColorFlags::C3_IS_NONE),
+ ComponentMixOutcome::from_colors(left_color, right_color, ColorFlags::ALPHA_IS_NONE),
+ ];
+
+ // Convert both colors into the interpolation color space.
+ let left = left_color.to_color_space(color_space);
+ let left = left.raw_components();
+
+ let right = right_color.to_color_space(color_space);
+ let right = right.raw_components();
+
+ let (result, result_flags) = interpolate_premultiplied(
+ &left,
+ left_weight,
+ &right,
+ right_weight,
+ color_space.hue_index(),
+ hue_interpolation,
+ &outcomes,
+ );
+
+ let alpha = if alpha_multiplier != 1.0 {
+ result[3] * alpha_multiplier
+ } else {
+ result[3]
+ };
+
+ // FIXME: In rare cases we end up with 0.999995 in the alpha channel,
+ // so we reduce the precision to avoid serializing to
+ // rgba(?, ?, ?, 1). This is not ideal, so we should look into
+ // ways to avoid it. Maybe pre-multiply all color components and
+ // then divide after calculations?
+ let alpha = (alpha * 1000.0).round() / 1000.0;
+
+ let mut result = AbsoluteColor::new(
+ color_space,
+ ColorComponents(result[0], result[1], result[2]),
+ alpha,
+ );
+
+ result.flags = result_flags;
+ // If both sides are legacy RGB, then the result stays in legacy RGB.
+ if !left_color.is_legacy_color() || !right_color.is_legacy_color() {
+ result.flags.insert(ColorFlags::AS_COLOR_FUNCTION);
+ }
+
+ result
+}
+
+fn interpolate_premultiplied_component(
+ left: f32,
+ left_weight: f32,
+ left_alpha: f32,
+ right: f32,
+ right_weight: f32,
+ right_alpha: f32,
+) -> f32 {
+ left * left_weight * left_alpha + right * right_weight * right_alpha
+}
+
+// Normalize hue into [0, 360)
+#[inline]
+fn normalize_hue(v: f32) -> f32 {
+ v - 360. * (v / 360.).floor()
+}
+
+fn adjust_hue(left: &mut f32, right: &mut f32, hue_interpolation: HueInterpolationMethod) {
+ // Adjust the hue angle as per
+ // https://drafts.csswg.org/css-color/#hue-interpolation.
+ //
+ // If both hue angles are NAN, they should be set to 0. Otherwise, if a
+ // single hue angle is NAN, it should use the other hue angle.
+ if left.is_nan() {
+ if right.is_nan() {
+ *left = 0.;
+ *right = 0.;
+ } else {
+ *left = *right;
+ }
+ } else if right.is_nan() {
+ *right = *left;
+ }
+
+ if hue_interpolation == HueInterpolationMethod::Specified {
+ // Angles are not adjusted. They are interpolated like any other
+ // component.
+ return;
+ }
+
+ *left = normalize_hue(*left);
+ *right = normalize_hue(*right);
+
+ match hue_interpolation {
+ // https://drafts.csswg.org/css-color/#shorter
+ HueInterpolationMethod::Shorter => {
+ let delta = *right - *left;
+
+ if delta > 180. {
+ *left += 360.;
+ } else if delta < -180. {
+ *right += 360.;
+ }
+ },
+ // https://drafts.csswg.org/css-color/#longer
+ HueInterpolationMethod::Longer => {
+ let delta = *right - *left;
+ if 0. < delta && delta < 180. {
+ *left += 360.;
+ } else if -180. < delta && delta < 0. {
+ *right += 360.;
+ }
+ },
+ // https://drafts.csswg.org/css-color/#increasing
+ HueInterpolationMethod::Increasing => {
+ if *right < *left {
+ *right += 360.;
+ }
+ },
+ // https://drafts.csswg.org/css-color/#decreasing
+ HueInterpolationMethod::Decreasing => {
+ if *left < *right {
+ *left += 360.;
+ }
+ },
+ HueInterpolationMethod::Specified => unreachable!("Handled above"),
+ }
+}
+
+fn interpolate_hue(
+ mut left: f32,
+ left_weight: f32,
+ mut right: f32,
+ right_weight: f32,
+ hue_interpolation: HueInterpolationMethod,
+) -> f32 {
+ adjust_hue(&mut left, &mut right, hue_interpolation);
+ left * left_weight + right * right_weight
+}
+
+struct InterpolatedAlpha {
+ /// The adjusted left alpha value.
+ left: f32,
+ /// The adjusted right alpha value.
+ right: f32,
+ /// The interpolated alpha value.
+ interpolated: f32,
+ /// Whether the alpha component should be `none`.
+ is_none: bool,
+}
+
+fn interpolate_alpha(
+ left: f32,
+ left_weight: f32,
+ right: f32,
+ right_weight: f32,
+ outcome: ComponentMixOutcome,
+) -> InterpolatedAlpha {
+ // <https://drafts.csswg.org/css-color-4/#interpolation-missing>
+ let mut result = match outcome {
+ ComponentMixOutcome::Mix => {
+ let interpolated = left * left_weight + right * right_weight;
+ InterpolatedAlpha {
+ left,
+ right,
+ interpolated,
+ is_none: false,
+ }
+ },
+ ComponentMixOutcome::UseLeft => InterpolatedAlpha {
+ left,
+ right: left,
+ interpolated: left,
+ is_none: false,
+ },
+ ComponentMixOutcome::UseRight => InterpolatedAlpha {
+ left: right,
+ right,
+ interpolated: right,
+ is_none: false,
+ },
+ ComponentMixOutcome::None => InterpolatedAlpha {
+ left: 1.0,
+ right: 1.0,
+ interpolated: 0.0,
+ is_none: true,
+ },
+ };
+
+ // Clip all alpha values to [0.0..1.0].
+ result.left = result.left.clamp(0.0, 1.0);
+ result.right = result.right.clamp(0.0, 1.0);
+ result.interpolated = result.interpolated.clamp(0.0, 1.0);
+
+ result
+}
+
+fn interpolate_premultiplied(
+ left: &[f32; 4],
+ left_weight: f32,
+ right: &[f32; 4],
+ right_weight: f32,
+ hue_index: Option<usize>,
+ hue_interpolation: HueInterpolationMethod,
+ outcomes: &[ComponentMixOutcome; 4],
+) -> ([f32; 4], ColorFlags) {
+ let alpha = interpolate_alpha(left[3], left_weight, right[3], right_weight, outcomes[3]);
+ let mut flags = if alpha.is_none {
+ ColorFlags::ALPHA_IS_NONE
+ } else {
+ ColorFlags::empty()
+ };
+
+ let mut result = [0.; 4];
+
+ for i in 0..3 {
+ match outcomes[i] {
+ ComponentMixOutcome::Mix => {
+ let is_hue = hue_index == Some(i);
+ result[i] = if is_hue {
+ normalize_hue(interpolate_hue(
+ left[i],
+ left_weight,
+ right[i],
+ right_weight,
+ hue_interpolation,
+ ))
+ } else {
+ let interpolated = interpolate_premultiplied_component(
+ left[i],
+ left_weight,
+ alpha.left,
+ right[i],
+ right_weight,
+ alpha.right,
+ );
+
+ if alpha.interpolated == 0.0 {
+ interpolated
+ } else {
+ interpolated / alpha.interpolated
+ }
+ };
+ },
+ ComponentMixOutcome::UseLeft => result[i] = left[i],
+ ComponentMixOutcome::UseRight => result[i] = right[i],
+ ComponentMixOutcome::None => {
+ result[i] = 0.0;
+ match i {
+ 0 => flags.insert(ColorFlags::C1_IS_NONE),
+ 1 => flags.insert(ColorFlags::C2_IS_NONE),
+ 2 => flags.insert(ColorFlags::C3_IS_NONE),
+ _ => unreachable!(),
+ }
+ },
+ }
+ }
+ result[3] = alpha.interpolated;
+
+ (result, flags)
+}
diff --git a/servo/components/style/color/mod.rs b/servo/components/style/color/mod.rs
new file mode 100644
index 0000000000..f8ceee9703
--- /dev/null
+++ b/servo/components/style/color/mod.rs
@@ -0,0 +1,465 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Color support functions.
+
+/// cbindgen:ignore
+pub mod convert;
+pub mod mix;
+
+use std::fmt::{self, Write};
+use style_traits::{CssWriter, ToCss};
+
+/// The 3 components that make up a color. (Does not include the alpha component)
+#[derive(Copy, Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]
+#[repr(C)]
+pub struct ColorComponents(pub f32, pub f32, pub f32);
+
+impl ColorComponents {
+ /// Apply a function to each of the 3 components of the color.
+ pub fn map(self, f: impl Fn(f32) -> f32) -> Self {
+ Self(f(self.0), f(self.1), f(self.2))
+ }
+}
+
+/// A color space representation in the CSS specification.
+///
+/// https://drafts.csswg.org/css-color-4/#typedef-color-space
+#[derive(
+ Clone,
+ Copy,
+ Debug,
+ Eq,
+ MallocSizeOf,
+ Parse,
+ PartialEq,
+ ToAnimatedValue,
+ ToComputedValue,
+ ToCss,
+ ToResolvedValue,
+ ToShmem,
+)]
+#[repr(u8)]
+pub enum ColorSpace {
+ /// A color specified in the sRGB color space with either the rgb/rgba(..)
+ /// functions or the newer color(srgb ..) function. If the color(..)
+ /// function is used, the AS_COLOR_FUNCTION flag will be set. Examples:
+ /// "color(srgb 0.691 0.139 0.259)", "rgb(176, 35, 66)"
+ Srgb = 0,
+ /// A color specified in the Hsl notation in the sRGB color space, e.g.
+ /// "hsl(289.18 93.136% 65.531%)"
+ /// https://drafts.csswg.org/css-color-4/#the-hsl-notation
+ Hsl,
+ /// A color specified in the Hwb notation in the sRGB color space, e.g.
+ /// "hwb(740deg 20% 30%)"
+ /// https://drafts.csswg.org/css-color-4/#the-hwb-notation
+ Hwb,
+ /// A color specified in the Lab color format, e.g.
+ /// "lab(29.2345% 39.3825 20.0664)".
+ /// https://w3c.github.io/csswg-drafts/css-color-4/#lab-colors
+ Lab,
+ /// A color specified in the Lch color format, e.g.
+ /// "lch(29.2345% 44.2 27)".
+ /// https://w3c.github.io/csswg-drafts/css-color-4/#lch-colors
+ Lch,
+ /// A color specified in the Oklab color format, e.g.
+ /// "oklab(40.101% 0.1147 0.0453)".
+ /// https://w3c.github.io/csswg-drafts/css-color-4/#lab-colors
+ Oklab,
+ /// A color specified in the Oklch color format, e.g.
+ /// "oklch(40.101% 0.12332 21.555)".
+ /// https://w3c.github.io/csswg-drafts/css-color-4/#lch-colors
+ Oklch,
+ /// A color specified with the color(..) function and the "srgb-linear"
+ /// color space, e.g. "color(srgb-linear 0.435 0.017 0.055)".
+ SrgbLinear,
+ /// A color specified with the color(..) function and the "display-p3"
+ /// color space, e.g. "color(display-p3 0.84 0.19 0.72)".
+ DisplayP3,
+ /// A color specified with the color(..) function and the "a98-rgb" color
+ /// space, e.g. "color(a98-rgb 0.44091 0.49971 0.37408)".
+ A98Rgb,
+ /// A color specified with the color(..) function and the "prophoto-rgb"
+ /// color space, e.g. "color(prophoto-rgb 0.36589 0.41717 0.31333)".
+ ProphotoRgb,
+ /// A color specified with the color(..) function and the "rec2020" color
+ /// space, e.g. "color(rec2020 0.42210 0.47580 0.35605)".
+ Rec2020,
+ /// A color specified with the color(..) function and the "xyz-d50" color
+ /// space, e.g. "color(xyz-d50 0.2005 0.14089 0.4472)".
+ XyzD50,
+ /// A color specified with the color(..) function and the "xyz-d65" or "xyz"
+ /// color space, e.g. "color(xyz-d65 0.21661 0.14602 0.59452)".
+ /// NOTE: https://drafts.csswg.org/css-color-4/#resolving-color-function-values
+ /// specifies that `xyz` is an alias for the `xyz-d65` color space.
+ #[parse(aliases = "xyz")]
+ XyzD65,
+}
+
+impl ColorSpace {
+ /// Returns whether this is a `<rectangular-color-space>`.
+ #[inline]
+ pub fn is_rectangular(&self) -> bool {
+ !self.is_polar()
+ }
+
+ /// Returns whether this is a `<polar-color-space>`.
+ #[inline]
+ pub fn is_polar(&self) -> bool {
+ matches!(self, Self::Hsl | Self::Hwb | Self::Lch | Self::Oklch)
+ }
+
+ /// Returns an index of the hue component in the color space, otherwise
+ /// `None`.
+ #[inline]
+ pub fn hue_index(&self) -> Option<usize> {
+ match self {
+ Self::Hsl | Self::Hwb => Some(0),
+ Self::Lch | Self::Oklch => Some(2),
+
+ _ => {
+ debug_assert!(!self.is_polar());
+ None
+ },
+ }
+ }
+}
+
+bitflags! {
+ /// Flags used when serializing colors.
+ #[derive(Clone, Copy, Default, MallocSizeOf, PartialEq, ToShmem)]
+ #[repr(C)]
+ pub struct ColorFlags : u8 {
+ /// If set, serializes sRGB colors into `color(srgb ...)` instead of
+ /// `rgba(...)`.
+ const AS_COLOR_FUNCTION = 1 << 0;
+ /// Whether the 1st color component is `none`.
+ const C1_IS_NONE = 1 << 1;
+ /// Whether the 2nd color component is `none`.
+ const C2_IS_NONE = 1 << 2;
+ /// Whether the 3rd color component is `none`.
+ const C3_IS_NONE = 1 << 3;
+ /// Whether the alpha component is `none`.
+ const ALPHA_IS_NONE = 1 << 4;
+ }
+}
+
+/// An absolutely specified color, using either rgb(), rgba(), lab(), lch(),
+/// oklab(), oklch() or color().
+#[derive(Copy, Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]
+#[repr(C)]
+pub struct AbsoluteColor {
+ /// The 3 components that make up colors in any color space.
+ pub components: ColorComponents,
+ /// The alpha component of the color.
+ pub alpha: f32,
+ /// The current color space that the components represent.
+ pub color_space: ColorSpace,
+ /// Extra flags used durring serialization of this color.
+ pub flags: ColorFlags,
+}
+
+/// Given an [`AbsoluteColor`], return the 4 float components as the type given,
+/// e.g.:
+///
+/// ```rust
+/// let srgb = AbsoluteColor::new(ColorSpace::Srgb, 1.0, 0.0, 0.0, 0.0);
+/// let floats = color_components_as!(&srgb, [f32; 4]); // [1.0, 0.0, 0.0, 0.0]
+/// ```
+macro_rules! color_components_as {
+ ($c:expr, $t:ty) => {{
+ // This macro is not an inline function, because we can't use the
+ // generic type ($t) in a constant expression as per:
+ // https://github.com/rust-lang/rust/issues/76560
+ const_assert_eq!(std::mem::size_of::<$t>(), std::mem::size_of::<[f32; 4]>());
+ const_assert_eq!(std::mem::align_of::<$t>(), std::mem::align_of::<[f32; 4]>());
+ const_assert!(std::mem::size_of::<AbsoluteColor>() >= std::mem::size_of::<$t>());
+ const_assert_eq!(
+ std::mem::align_of::<AbsoluteColor>(),
+ std::mem::align_of::<$t>()
+ );
+
+ std::mem::transmute::<&ColorComponents, &$t>(&$c.components)
+ }};
+}
+
+impl AbsoluteColor {
+ /// Create a new [`AbsoluteColor`] with the given [`ColorSpace`] and
+ /// components.
+ pub fn new(color_space: ColorSpace, components: ColorComponents, alpha: f32) -> Self {
+ let mut components = components;
+
+ // Lightness must not be less than 0.
+ if matches!(
+ color_space,
+ ColorSpace::Lab | ColorSpace::Lch | ColorSpace::Oklab | ColorSpace::Oklch
+ ) {
+ components.0 = components.0.max(0.0);
+ }
+
+ // Chroma must not be less than 0.
+ if matches!(color_space, ColorSpace::Lch | ColorSpace::Oklch) {
+ components.1 = components.1.max(0.0);
+ }
+
+ Self {
+ components,
+ alpha: alpha.clamp(0.0, 1.0),
+ color_space,
+ flags: ColorFlags::empty(),
+ }
+ }
+
+ /// Create a new [`AbsoluteColor`] from rgba values in the sRGB color space.
+ pub fn srgb(red: f32, green: f32, blue: f32, alpha: f32) -> Self {
+ Self::new(ColorSpace::Srgb, ColorComponents(red, green, blue), alpha)
+ }
+
+ /// Create a new transparent color.
+ pub fn transparent() -> Self {
+ Self::srgb(0.0, 0.0, 0.0, 0.0)
+ }
+
+ /// Create a new opaque black color.
+ pub fn black() -> Self {
+ Self::srgb(0.0, 0.0, 0.0, 1.0)
+ }
+
+ /// Create a new opaque white color.
+ pub fn white() -> Self {
+ Self::srgb(1.0, 1.0, 1.0, 1.0)
+ }
+
+ /// Return all the components of the color in an array. (Includes alpha)
+ #[inline]
+ pub fn raw_components(&self) -> &[f32; 4] {
+ unsafe { color_components_as!(self, [f32; 4]) }
+ }
+
+ /// Returns true if this color is in one of the legacy color formats.
+ #[inline]
+ pub fn is_legacy_color(&self) -> bool {
+ // rgb(), rgba(), hsl(), hsla(), hwb(), hwba()
+ match self.color_space {
+ ColorSpace::Srgb => !self.flags.contains(ColorFlags::AS_COLOR_FUNCTION),
+ ColorSpace::Hsl | ColorSpace::Hwb => true,
+ _ => false,
+ }
+ }
+
+ /// Return the alpha component.
+ #[inline]
+ pub fn alpha(&self) -> f32 {
+ self.alpha
+ }
+
+ /// Convert this color to the specified color space.
+ pub fn to_color_space(&self, color_space: ColorSpace) -> Self {
+ use ColorSpace::*;
+
+ if self.color_space == color_space {
+ return self.clone();
+ }
+
+ // We have simplified conversions that do not need to convert to XYZ
+ // first. This improves performance, because it skips 2 matrix
+ // multiplications and reduces float rounding errors.
+ match (self.color_space, color_space) {
+ (Srgb, Hsl) => {
+ return Self::new(
+ color_space,
+ convert::rgb_to_hsl(&self.components),
+ self.alpha,
+ );
+ },
+
+ (Srgb, Hwb) => {
+ return Self::new(
+ color_space,
+ convert::rgb_to_hwb(&self.components),
+ self.alpha,
+ );
+ },
+
+ (Hsl, Srgb) => {
+ return Self::new(
+ color_space,
+ convert::hsl_to_rgb(&self.components),
+ self.alpha,
+ );
+ },
+
+ (Hwb, Srgb) => {
+ return Self::new(
+ color_space,
+ convert::hwb_to_rgb(&self.components),
+ self.alpha,
+ );
+ },
+
+ (Lab, Lch) | (Oklab, Oklch) => {
+ return Self::new(
+ color_space,
+ convert::lab_to_lch(&self.components),
+ self.alpha,
+ );
+ },
+
+ (Lch, Lab) | (Oklch, Oklab) => {
+ return Self::new(
+ color_space,
+ convert::lch_to_lab(&self.components),
+ self.alpha,
+ );
+ },
+
+ _ => {},
+ }
+
+ let (xyz, white_point) = match self.color_space {
+ Lab => convert::to_xyz::<convert::Lab>(&self.components),
+ Lch => convert::to_xyz::<convert::Lch>(&self.components),
+ Oklab => convert::to_xyz::<convert::Oklab>(&self.components),
+ Oklch => convert::to_xyz::<convert::Oklch>(&self.components),
+ Srgb => convert::to_xyz::<convert::Srgb>(&self.components),
+ Hsl => convert::to_xyz::<convert::Hsl>(&self.components),
+ Hwb => convert::to_xyz::<convert::Hwb>(&self.components),
+ SrgbLinear => convert::to_xyz::<convert::SrgbLinear>(&self.components),
+ DisplayP3 => convert::to_xyz::<convert::DisplayP3>(&self.components),
+ A98Rgb => convert::to_xyz::<convert::A98Rgb>(&self.components),
+ ProphotoRgb => convert::to_xyz::<convert::ProphotoRgb>(&self.components),
+ Rec2020 => convert::to_xyz::<convert::Rec2020>(&self.components),
+ XyzD50 => convert::to_xyz::<convert::XyzD50>(&self.components),
+ XyzD65 => convert::to_xyz::<convert::XyzD65>(&self.components),
+ };
+
+ let result = match color_space {
+ Lab => convert::from_xyz::<convert::Lab>(&xyz, white_point),
+ Lch => convert::from_xyz::<convert::Lch>(&xyz, white_point),
+ Oklab => convert::from_xyz::<convert::Oklab>(&xyz, white_point),
+ Oklch => convert::from_xyz::<convert::Oklch>(&xyz, white_point),
+ Srgb => convert::from_xyz::<convert::Srgb>(&xyz, white_point),
+ Hsl => convert::from_xyz::<convert::Hsl>(&xyz, white_point),
+ Hwb => convert::from_xyz::<convert::Hwb>(&xyz, white_point),
+ SrgbLinear => convert::from_xyz::<convert::SrgbLinear>(&xyz, white_point),
+ DisplayP3 => convert::from_xyz::<convert::DisplayP3>(&xyz, white_point),
+ A98Rgb => convert::from_xyz::<convert::A98Rgb>(&xyz, white_point),
+ ProphotoRgb => convert::from_xyz::<convert::ProphotoRgb>(&xyz, white_point),
+ Rec2020 => convert::from_xyz::<convert::Rec2020>(&xyz, white_point),
+ XyzD50 => convert::from_xyz::<convert::XyzD50>(&xyz, white_point),
+ XyzD65 => convert::from_xyz::<convert::XyzD65>(&xyz, white_point),
+ };
+
+ Self::new(color_space, result, self.alpha)
+ }
+}
+
+impl From<cssparser::PredefinedColorSpace> for ColorSpace {
+ fn from(value: cssparser::PredefinedColorSpace) -> Self {
+ match value {
+ cssparser::PredefinedColorSpace::Srgb => ColorSpace::Srgb,
+ cssparser::PredefinedColorSpace::SrgbLinear => ColorSpace::SrgbLinear,
+ cssparser::PredefinedColorSpace::DisplayP3 => ColorSpace::DisplayP3,
+ cssparser::PredefinedColorSpace::A98Rgb => ColorSpace::A98Rgb,
+ cssparser::PredefinedColorSpace::ProphotoRgb => ColorSpace::ProphotoRgb,
+ cssparser::PredefinedColorSpace::Rec2020 => ColorSpace::Rec2020,
+ cssparser::PredefinedColorSpace::XyzD50 => ColorSpace::XyzD50,
+ cssparser::PredefinedColorSpace::XyzD65 => ColorSpace::XyzD65,
+ }
+ }
+}
+
+impl ToCss for AbsoluteColor {
+ fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+ where
+ W: Write,
+ {
+ macro_rules! value_or_none {
+ ($v:expr,$flag:tt) => {{
+ if self.flags.contains(ColorFlags::$flag) {
+ None
+ } else {
+ Some($v)
+ }
+ }};
+ }
+
+ let maybe_c1 = value_or_none!(self.components.0, C1_IS_NONE);
+ let maybe_c2 = value_or_none!(self.components.1, C2_IS_NONE);
+ let maybe_c3 = value_or_none!(self.components.2, C3_IS_NONE);
+ let maybe_alpha = value_or_none!(self.alpha, ALPHA_IS_NONE);
+
+ match self.color_space {
+ ColorSpace::Hsl => {
+ let rgb = convert::hsl_to_rgb(&self.components);
+ Self::new(ColorSpace::Srgb, rgb, self.alpha).to_css(dest)
+ },
+
+ ColorSpace::Hwb => {
+ let rgb = convert::hwb_to_rgb(&self.components);
+
+ Self::new(ColorSpace::Srgb, rgb, self.alpha).to_css(dest)
+ },
+
+ ColorSpace::Srgb if !self.flags.contains(ColorFlags::AS_COLOR_FUNCTION) => {
+ // Althought we are passing Option<_> in here, the to_css fn
+ // knows that the "none" keyword is not supported in the
+ // rgb/rgba legacy syntax.
+ cssparser::ToCss::to_css(
+ &cssparser::RGBA::from_floats(maybe_c1, maybe_c2, maybe_c3, maybe_alpha),
+ dest,
+ )
+ },
+ ColorSpace::Lab => cssparser::ToCss::to_css(
+ &cssparser::Lab::new(maybe_c1, maybe_c2, maybe_c3, maybe_alpha),
+ dest,
+ ),
+ ColorSpace::Lch => cssparser::ToCss::to_css(
+ &cssparser::Lch::new(maybe_c1, maybe_c2, maybe_c3, maybe_alpha),
+ dest,
+ ),
+ ColorSpace::Oklab => cssparser::ToCss::to_css(
+ &cssparser::Oklab::new(maybe_c1, maybe_c2, maybe_c3, maybe_alpha),
+ dest,
+ ),
+ ColorSpace::Oklch => cssparser::ToCss::to_css(
+ &cssparser::Oklch::new(maybe_c1, maybe_c2, maybe_c3, maybe_alpha),
+ dest,
+ ),
+ _ => {
+ let color_space = match self.color_space {
+ ColorSpace::Srgb => {
+ debug_assert!(
+ self.flags.contains(ColorFlags::AS_COLOR_FUNCTION),
+ "The case without this flag should be handled in the wrapping match case!!"
+ );
+
+ cssparser::PredefinedColorSpace::Srgb
+ },
+ ColorSpace::SrgbLinear => cssparser::PredefinedColorSpace::SrgbLinear,
+ ColorSpace::DisplayP3 => cssparser::PredefinedColorSpace::DisplayP3,
+ ColorSpace::A98Rgb => cssparser::PredefinedColorSpace::A98Rgb,
+ ColorSpace::ProphotoRgb => cssparser::PredefinedColorSpace::ProphotoRgb,
+ ColorSpace::Rec2020 => cssparser::PredefinedColorSpace::Rec2020,
+ ColorSpace::XyzD50 => cssparser::PredefinedColorSpace::XyzD50,
+ ColorSpace::XyzD65 => cssparser::PredefinedColorSpace::XyzD65,
+
+ _ => {
+ unreachable!("other color spaces do not support color() syntax")
+ },
+ };
+
+ let color_function = cssparser::ColorFunction {
+ color_space,
+ c1: maybe_c1,
+ c2: maybe_c2,
+ c3: maybe_c3,
+ alpha: maybe_alpha,
+ };
+ let color = cssparser::Color::ColorFunction(color_function);
+ cssparser::ToCss::to_css(&color, dest)
+ },
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-16 04:04:58 +0000