Enum bevy_color::prelude::Color

pub enum Color {
    Srgba(Srgba),
    LinearRgba(LinearRgba),
    Hsla(Hsla),
    Hsva(Hsva),
    Hwba(Hwba),
    Laba(Laba),
    Lcha(Lcha),
    Oklaba(Oklaba),
    Oklcha(Oklcha),
    Xyza(Xyza),
}

An enumerated type that can represent any of the color types in this crate.

This is useful when you need to store a color in a data structure that can’t be generic over the color type.

Conversion

Conversion between the various color spaces is achieved using Rust’s native From trait. Because certain color spaces are defined by their transformation to and from another space, these From implementations reflect that set of definitions.

let color = Srgba::rgb(0.5, 0.5, 0.5);

// Using From explicitly
let linear_color = LinearRgba::from(color);

// Using Into
let linear_color: LinearRgba = color.into();

For example, the sRGB space is defined by its relationship with Linear RGB, and HWB by its with sRGB. As such, it is the responsibility of sRGB to provide From implementations for Linear RGB, and HWB for sRGB. To then provide conversion between Linear RGB and HWB directly, HWB is responsible for implementing these conversions, delegating to sRGB as an intermediatory. This ensures that all conversions take the shortest path between any two spaces, and limit the proliferation of domain specific knowledge for each color space to their respective definitions.

Operations

Color supports all the standard color operations, such as mixing, luminance and hue adjustment, clamping, and diffing. These operations delegate to the concrete color space contained by Color, but will convert to Oklch for operations which aren’t supported in the current space. After performing the operation, if a conversion was required, the result will be converted back into the original color space.

let red_hsv = Color::hsv(0., 1., 1.);
let red_srgb = Color::srgb(1., 0., 0.);

// HSV has a definition of hue, so it will be returned.
red_hsv.hue();

// SRGB doesn't have a native definition for hue.
// Converts to Oklch and returns that result.
red_srgb.hue();

Oklch has been chosen as the intermediary space in cases where conversion is required due to its perceptual uniformity and broad support for Bevy’s color operations. To avoid the cost of repeated conversion, and ensure consistent results where that is desired, first convert this Color into your desired color space.

Variants

Srgba(Srgba)

A color in the sRGB color space with alpha.

LinearRgba(LinearRgba)

A color in the linear sRGB color space with alpha.

Hsla(Hsla)

A color in the HSL color space with alpha.

Hsva(Hsva)

A color in the HSV color space with alpha.

Hwba(Hwba)

A color in the HWB color space with alpha.

Laba(Laba)

A color in the LAB color space with alpha.

Lcha(Lcha)

A color in the LCH color space with alpha.

Oklaba(Oklaba)

A color in the Oklab color space with alpha.

Oklcha(Oklcha)

A color in the Oklch color space with alpha.

Xyza(Xyza)

A color in the XYZ color space with alpha.

Implementations

impl Color

pub fn to_linear(&self) -> LinearRgba

Return the color as a linear RGBA color.

pub fn to_srgba(&self) -> Srgba

Return the color as an SRGBA color.

pub const fn rgba(red: f32, green: f32, blue: f32, alpha: f32) -> Self

👎Deprecated: Use Color::srgba instead

Creates a new Color object storing a Srgba color.

pub const fn srgba(red: f32, green: f32, blue: f32, alpha: f32) -> Self

Creates a new Color object storing a Srgba color.

pub const fn rgb(red: f32, green: f32, blue: f32) -> Self

👎Deprecated: Use Color::srgb instead

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

Creates a new Color object storing a Srgba color with an alpha of 1.0.

pub fn rgb_from_array([r, g, b]: [f32; 3]) -> Self

👎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 srgb_from_array(array: [f32; 3]) -> Self

Reads an array of floats to creates a new Color object storing a Srgba color with an alpha of 1.0.

pub fn rgba_u8(red: u8, green: u8, blue: u8, alpha: u8) -> Self

👎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 srgba_u8(red: u8, green: u8, blue: u8, alpha: u8) -> Self

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 rgb_u8(red: u8, green: u8, blue: u8) -> Self

👎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 srgb_u8(red: u8, green: u8, blue: u8) -> Self

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 const fn rbga_linear(red: f32, green: f32, blue: f32, alpha: f32) -> Self

👎Deprecated: Use Color::linear_rgba instead.

Creates a new Color object storing a LinearRgba color.

pub const fn linear_rgba(red: f32, green: f32, blue: f32, alpha: f32) -> Self

Creates a new Color object storing a LinearRgba color.

pub const fn rgb_linear(red: f32, green: f32, blue: f32) -> Self

👎Deprecated: Use Color::linear_rgb instead.

Creates a new Color object storing a LinearRgba color with an alpha of 1.0.

pub const fn linear_rgb(red: f32, green: f32, blue: f32) -> Self

Creates a new Color object storing a LinearRgba color with an alpha of 1.0.

pub const fn hsla(hue: f32, saturation: f32, lightness: f32, alpha: f32) -> Self

Creates a new Color object storing a Hsla color.

pub const fn hsl(hue: f32, saturation: f32, lightness: f32) -> Self

Creates a new Color object storing a Hsla color with an alpha of 1.0.

pub const fn hsva(hue: f32, saturation: f32, value: f32, alpha: f32) -> Self

Creates a new Color object storing a Hsva color.

pub const fn hsv(hue: f32, saturation: f32, value: f32) -> Self

Creates a new Color object storing a Hsva color with an alpha of 1.0.

pub const fn hwba(hue: f32, whiteness: f32, blackness: f32, alpha: f32) -> Self

Creates a new Color object storing a Hwba color.

pub const fn hwb(hue: f32, whiteness: f32, blackness: f32) -> Self

Creates a new Color object storing a Hwba color with an alpha of 1.0.

pub const fn laba(lightness: f32, a: f32, b: f32, alpha: f32) -> Self

Creates a new Color object storing a Laba color.

pub const fn lab(lightness: f32, a: f32, b: f32) -> Self

Creates a new Color object storing a Laba color with an alpha of 1.0.

pub const fn lcha(lightness: f32, chroma: f32, hue: f32, alpha: f32) -> Self

Creates a new Color object storing a Lcha color.

pub const fn lch(lightness: f32, chroma: f32, hue: f32) -> Self

Creates a new Color object storing a Lcha color with an alpha of 1.0.

pub const fn oklaba(lightness: f32, a: f32, b: f32, alpha: f32) -> Self

Creates a new Color object storing a Oklaba color.

pub const fn oklab(lightness: f32, a: f32, b: f32) -> Self

Creates a new Color object storing a Oklaba color with an alpha of 1.0.

pub const fn oklcha(lightness: f32, chroma: f32, hue: f32, alpha: f32) -> Self

Creates a new Color object storing a Oklcha color.

pub const fn oklch(lightness: f32, chroma: f32, hue: f32) -> Self

Creates a new Color object storing a Oklcha color with an alpha of 1.0.

pub const fn xyza(x: f32, y: f32, z: f32, alpha: f32) -> Self

Creates a new Color object storing a Xyza color.

pub const fn xyz(x: f32, y: f32, z: f32) -> Self

Creates a new Color object storing a Xyza color with an alpha of 1.0.

pub const WHITE: Self = _

A fully white Color::LinearRgba color with an alpha of 1.0.

pub const BLACK: Self = _

A fully black Color::LinearRgba color with an alpha of 1.0.

pub const NONE: Self = _

A fully transparent Color::LinearRgba color with 0 red, green and blue.

Trait Implementations

impl Alpha for Color

fn with_alpha(&self, alpha: f32) -> Self

Return a new version of this color with the given alpha value.

fn alpha(&self) -> f32

Return a the alpha component of this color.

fn set_alpha(&mut self, alpha: f32)

Sets the alpha component of this color.

fn is_fully_transparent(&self) -> bool

Is the alpha component of this color less than or equal to 0.0?

fn is_fully_opaque(&self) -> bool

Is the alpha component of this color greater than or equal to 1.0?

impl Clone for Color

fn clone(&self) -> Color

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Color

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

Formats the value using the given formatter.

impl Default for Color

fn default() -> Self

A fully white Color::LinearRgba color with an alpha of 1.0.

impl<'de> Deserialize<'de> for Color

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Enum for Color

where Self: Any + Send + Sync, Srgba: FromReflect + TypePath + RegisterForReflection, LinearRgba: FromReflect + TypePath + RegisterForReflection, Hsla: FromReflect + TypePath + RegisterForReflection, Hsva: FromReflect + TypePath + RegisterForReflection, Hwba: FromReflect + TypePath + RegisterForReflection, Laba: FromReflect + TypePath + RegisterForReflection, Lcha: FromReflect + TypePath + RegisterForReflection, Oklaba: FromReflect + TypePath + RegisterForReflection, Oklcha: FromReflect + TypePath + RegisterForReflection, Xyza: FromReflect + TypePath + RegisterForReflection,

fn field(&self, __name_param: &str) -> Option<&dyn Reflect>

Returns a reference to the value of the field (in the current variant) with the given name.

fn field_at(&self, __index_param: usize) -> Option<&dyn Reflect>

Returns a reference to the value of the field (in the current variant) at the given index.

fn field_mut(&mut self, __name_param: &str) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field (in the current variant) with the given name.

fn field_at_mut(&mut self, __index_param: usize) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field (in the current variant) at the given index.

fn index_of(&self, __name_param: &str) -> Option<usize>

Returns the index of the field (in the current variant) with the given name.

fn name_at(&self, __index_param: usize) -> Option<&str>

Returns the name of the field (in the current variant) with the given index.

fn iter_fields(&self) -> VariantFieldIter<'_>

Returns an iterator over the values of the current variant’s fields.

fn field_len(&self) -> usize

Returns the number of fields in the current variant.

fn variant_name(&self) -> &str

The name of the current variant.

fn variant_index(&self) -> usize

The index of the current variant.

fn variant_type(&self) -> VariantType

The type of the current variant.

fn clone_dynamic(&self) -> DynamicEnum

fn is_variant(&self, variant_type: VariantType) -> bool

Returns true if the current variant’s type matches the given one.

fn variant_path(&self) -> String

Returns the full path to the current variant.

impl EuclideanDistance for Color

fn distance_squared(&self, other: &Self) -> f32

Distance squared from self to other.

fn distance(&self, other: &Self) -> f32

Distance from self to other.

impl From<Color> for Hsla

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Hsva

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Hwba

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Laba

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Lcha

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for LinearRgba

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Oklaba

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Oklcha

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Srgba

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Xyza

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<Hsla> for Color

fn from(value: Hsla) -> Self

Converts to this type from the input type.

impl From<Hsva> for Color

fn from(value: Hsva) -> Self

Converts to this type from the input type.

impl From<Hwba> for Color

fn from(value: Hwba) -> Self

Converts to this type from the input type.

impl From<Laba> for Color

fn from(value: Laba) -> Self

Converts to this type from the input type.

impl From<Lcha> for Color

fn from(value: Lcha) -> Self

Converts to this type from the input type.

impl From<LinearRgba> for Color

fn from(value: LinearRgba) -> Self

Converts to this type from the input type.

impl From<Oklaba> for Color

fn from(value: Oklaba) -> Self

Converts to this type from the input type.

impl From<Oklcha> for Color

fn from(value: Oklcha) -> Self

Converts to this type from the input type.

impl From<Srgba> for Color

fn from(value: Srgba) -> Self

Converts to this type from the input type.

impl From<Xyza> for Color

fn from(value: Xyza) -> Self

Converts to this type from the input type.

impl FromReflect for Color

where Self: Any + Send + Sync, Srgba: FromReflect + TypePath + RegisterForReflection, LinearRgba: FromReflect + TypePath + RegisterForReflection, Hsla: FromReflect + TypePath + RegisterForReflection, Hsva: FromReflect + TypePath + RegisterForReflection, Hwba: FromReflect + TypePath + RegisterForReflection, Laba: FromReflect + TypePath + RegisterForReflection, Lcha: FromReflect + TypePath + RegisterForReflection, Oklaba: FromReflect + TypePath + RegisterForReflection, Oklcha: FromReflect + TypePath + RegisterForReflection, Xyza: FromReflect + TypePath + RegisterForReflection,

fn from_reflect(__param0: &dyn Reflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for Color

where Self: Any + Send + Sync, Srgba: FromReflect + TypePath + RegisterForReflection, LinearRgba: FromReflect + TypePath + RegisterForReflection, Hsla: FromReflect + TypePath + RegisterForReflection, Hsva: FromReflect + TypePath + RegisterForReflection, Hwba: FromReflect + TypePath + RegisterForReflection, Laba: FromReflect + TypePath + RegisterForReflection, Lcha: FromReflect + TypePath + RegisterForReflection, Oklaba: FromReflect + TypePath + RegisterForReflection, Oklcha: FromReflect + TypePath + RegisterForReflection, Xyza: FromReflect + TypePath + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Hue for Color

fn with_hue(&self, hue: f32) -> Self

Return a new version of this color with the hue channel set to the given value.

fn hue(&self) -> f32

Return the hue of this color [0.0, 360.0].

fn set_hue(&mut self, hue: f32)

Sets the hue of this color.

fn rotate_hue(&self, degrees: f32) -> Self

Return a new version of this color with the hue channel rotated by the given degrees.

impl Luminance for Color

fn luminance(&self) -> f32

Return the luminance of this color (0.0 - 1.0).

fn with_luminance(&self, value: f32) -> Self

Return a new version of this color with the given luminance. The resulting color will be clamped to the valid range for the color space; for some color spaces, clamping may cause the hue or chroma to change.

fn darker(&self, amount: f32) -> Self

Return a darker version of this color. The amount should be between 0.0 and 1.0. The amount represents an absolute decrease in luminance, and is distributive: color.darker(a).darker(b) == color.darker(a + b). Colors are clamped to black if the amount would cause them to go below black.

fn lighter(&self, amount: f32) -> Self

Return a lighter version of this color. The amount should be between 0.0 and 1.0. The amount represents an absolute increase in luminance, and is distributive: color.lighter(a).lighter(b) == color.lighter(a + b). Colors are clamped to white if the amount would cause them to go above white.

impl Mix for Color

fn mix(&self, other: &Self, factor: f32) -> Self

Linearly interpolate between this and another color, by factor. Factor should be between 0.0 and 1.0.

fn mix_assign(&mut self, other: Self, factor: f32)

Linearly interpolate between this and another color, by factor, storing the result in this color. Factor should be between 0.0 and 1.0.

impl PartialEq for Color

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Reflect for Color

where Self: Any + Send + Sync, Srgba: FromReflect + TypePath + RegisterForReflection, LinearRgba: FromReflect + TypePath + RegisterForReflection, Hsla: FromReflect + TypePath + RegisterForReflection, Hsva: FromReflect + TypePath + RegisterForReflection, Hwba: FromReflect + TypePath + RegisterForReflection, Laba: FromReflect + TypePath + RegisterForReflection, Lcha: FromReflect + TypePath + RegisterForReflection, Oklaba: FromReflect + TypePath + RegisterForReflection, Oklcha: FromReflect + TypePath + RegisterForReflection, Xyza: FromReflect + TypePath + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

fn set( &mut self, __value_param: Box<dyn Reflect> ) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

fn try_apply(&mut self, __value_param: &dyn Reflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn apply(&mut self, value: &(dyn Reflect + 'static))

Applies a reflected value to this value.

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Serialize for Color

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypePath for Color

where Self: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Color

where Self: Any + Send + Sync, Srgba: FromReflect + TypePath + RegisterForReflection, LinearRgba: FromReflect + TypePath + RegisterForReflection, Hsla: FromReflect + TypePath + RegisterForReflection, Hsva: FromReflect + TypePath + RegisterForReflection, Hwba: FromReflect + TypePath + RegisterForReflection, Laba: FromReflect + TypePath + RegisterForReflection, Lcha: FromReflect + TypePath + RegisterForReflection, Oklaba: FromReflect + TypePath + RegisterForReflection, Oklcha: FromReflect + TypePath + RegisterForReflection, Xyza: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Color

impl StructuralPartialEq for Color