Enum ColorSpaceTag 

#[non_exhaustive]
#[repr(u8)]
pub enum ColorSpaceTag {
    Srgb = 0,
    LinearSrgb = 1,
    Lab = 2,
    Lch = 3,
    Hsl = 4,
    Hwb = 5,
    Oklab = 6,
    Oklch = 7,
    DisplayP3 = 8,
    A98Rgb = 9,
    ProphotoRgb = 10,
    Rec2020 = 11,
    Aces2065_1 = 15,
    AcesCg = 12,
    XyzD50 = 13,
    XyzD65 = 14,
}

The color space tag for dynamic colors.

This represents a fixed set of known color spaces. The set contains all color spaces in the CSS Color 4 spec and includes some other color spaces useful for computer graphics.

The integer values of these variants can change in breaking releases.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Srgb = 0

The Srgb color space.

LinearSrgb = 1

The LinearSrgb color space.

Lab = 2

The Lab color space.

Lch = 3

The Lch color space.

Hsl = 4

The Hsl color space.

Hwb = 5

The Hwb color space.

Oklab = 6

The Oklab color space.

Oklch = 7

The Oklch color space.

DisplayP3 = 8

The DisplayP3 color space.

A98Rgb = 9

The A98Rgb color space.

ProphotoRgb = 10

The ProphotoRgb color space.

Rec2020 = 11

The Rec2020 color space.

Aces2065_1 = 15

The Aces2065_1 color space.

AcesCg = 12

The AcesCg color space.

XyzD50 = 13

The XyzD50 color space.

XyzD65 = 14

The XyzD65 color space.

Implementations

impl ColorSpaceTag

pub(crate) fn layout(self) -> ColorSpaceLayout

pub(crate) fn same_analogous(self, other: Self) -> bool

Whether all components of the two color spaces are analogous. See also Section 12.2 of CSS Color 4, defining which components are analogous: https://www.w3.org/TR/2024/CRD-css-color-4-20240213/#interpolation-missing.

Note: if color spaces are the same, then they’re also analogous, but in that case we wouldn’t do the conversion, so this function is not guaranteed to return the correct answer in those cases.

pub(crate) fn l_missing(self, missing: Missing) -> bool

pub(crate) fn set_l_missing( self, missing: &mut Missing, components: &mut [f32; 4], )

pub(crate) fn c_missing(self, missing: Missing) -> bool

pub(crate) fn set_c_missing( self, missing: &mut Missing, components: &mut [f32; 4], )

pub(crate) fn h_missing(self, missing: Missing) -> bool

pub(crate) fn set_h_missing( self, missing: &mut Missing, components: &mut [f32; 4], )

pub fn from_linear_srgb(self, rgb: [f32; 3]) -> [f32; 3]

Convert an opaque color from linear sRGB.

This is the tagged counterpart of ColorSpace::from_linear_srgb.

pub fn to_linear_srgb(self, src: [f32; 3]) -> [f32; 3]

Convert an opaque color to linear sRGB.

This is the tagged counterpart of ColorSpace::to_linear_srgb.

pub fn convert(self, target: Self, src: [f32; 3]) -> [f32; 3]

Convert the color components into the target color space.

This is the tagged counterpart of ColorSpace::convert.

pub fn from_linear_srgb_absolute(self, rgb: [f32; 3]) -> [f32; 3]

Convert an opaque color from linear sRGB, without chromatic adaptation.

For most use-cases you should consider using the chromatically-adapting ColorSpaceTag::from_linear_srgb instead.

This is the tagged counterpart of ColorSpace::from_linear_srgb_absolute.

pub fn to_linear_srgb_absolute(self, src: [f32; 3]) -> [f32; 3]

Convert an opaque color to linear sRGB, without chromatic adaptation.

For most use-cases you should consider using the chromatically-adapting ColorSpaceTag::to_linear_srgb instead.

This is the tagged counterpart of ColorSpace::to_linear_srgb_absolute.

pub fn convert_absolute(self, target: Self, src: [f32; 3]) -> [f32; 3]

Convert the color components into the target color space, without chromatic adaptation.

For most use-cases you should consider using the chromatically-adapting ColorSpaceTag::convert instead.

This is the tagged counterpart of ColorSpace::convert_absolute. See the documentation on ColorSpace::convert_absolute for more information.

pub fn chromatically_adapt( self, src: [f32; 3], from: Chromaticity, to: Chromaticity, ) -> [f32; 3]

Chromatically adapt the color between the given white point chromaticities.

This is the tagged counterpart of ColorSpace::chromatically_adapt.

The color is assumed to be under a reference white point of from and is chromatically adapted to the given white point to. The linear Bradford transform is used to perform the chromatic adaptation.

pub fn scale_chroma(self, src: [f32; 3], scale: f32) -> [f32; 3]

Scale the chroma by the given amount.

This is the tagged counterpart of ColorSpace::scale_chroma.

pub fn clip(self, src: [f32; 3]) -> [f32; 3]

Clip the color’s components to fit within the natural gamut of the color space.

See ColorSpace::clip for more details.

Trait Implementations

impl CheckedBitPattern for ColorSpaceTag

type Bits = u8

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during is_valid_bit_pattern.

fn is_valid_bit_pattern(bits: &u8) -> bool

If this function returns true, then it must be valid to reinterpret bits as &Self.

impl Clone for ColorSpaceTag

fn clone(&self) -> ColorSpaceTag

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Contiguous for ColorSpaceTag

const MIN_VALUE: u8 = 0u8

The lower inclusive bound for valid instances of this type.

const MAX_VALUE: u8 = 15u8

The upper inclusive bound for valid instances of this type.

type Int = u8

The primitive integer type with an identical representation to this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl Debug for ColorSpaceTag

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<A98Rgb> for ColorSpaceTag

fn from(_: A98Rgb) -> Self

Converts to this type from the input type.

impl From<Aces2065_1> for ColorSpaceTag

fn from(_: Aces2065_1) -> Self

Converts to this type from the input type.

impl From<AcesCg> for ColorSpaceTag

fn from(_: AcesCg) -> Self

Converts to this type from the input type.

impl From<DisplayP3> for ColorSpaceTag

fn from(_: DisplayP3) -> Self

Converts to this type from the input type.

impl From<Hsl> for ColorSpaceTag

fn from(_: Hsl) -> Self

Converts to this type from the input type.

impl From<Hwb> for ColorSpaceTag

fn from(_: Hwb) -> Self

Converts to this type from the input type.

impl From<Lab> for ColorSpaceTag

fn from(_: Lab) -> Self

Converts to this type from the input type.

impl From<Lch> for ColorSpaceTag

fn from(_: Lch) -> Self

Converts to this type from the input type.

impl From<LinearSrgb> for ColorSpaceTag

fn from(_: LinearSrgb) -> Self

Converts to this type from the input type.

impl From<Oklab> for ColorSpaceTag

fn from(_: Oklab) -> Self

Converts to this type from the input type.

impl From<Oklch> for ColorSpaceTag

fn from(_: Oklch) -> Self

Converts to this type from the input type.

impl From<ProphotoRgb> for ColorSpaceTag

fn from(_: ProphotoRgb) -> Self

Converts to this type from the input type.

impl From<Rec2020> for ColorSpaceTag

fn from(_: Rec2020) -> Self

Converts to this type from the input type.

impl From<Srgb> for ColorSpaceTag

fn from(_: Srgb) -> Self

Converts to this type from the input type.

impl From<XyzD50> for ColorSpaceTag

fn from(_: XyzD50) -> Self

Converts to this type from the input type.

impl From<XyzD65> for ColorSpaceTag

fn from(_: XyzD65) -> Self

Converts to this type from the input type.

impl FromStr for ColorSpaceTag

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for ColorSpaceTag

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ColorSpaceTag

fn eq(&self, other: &ColorSpaceTag) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Zeroable for ColorSpaceTag

fn zeroed() -> Self

Calls zeroed.

impl Copy for ColorSpaceTag

impl Eq for ColorSpaceTag

impl NoUninit for ColorSpaceTag

impl StructuralPartialEq for ColorSpaceTag