Struct Color 

#[repr(C)]
pub struct Color {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
}

Straight RGBA components in linear sRGB, normally in the range [0, 1].

Fields

r: f32

Red component (0.0 to 1.0)

g: f32

Green component (0.0 to 1.0)

b: f32

Blue component (0.0 to 1.0)

a: f32

Alpha (transparency) component (0.0 = fully transparent, 1.0 = fully opaque)

Implementations

impl Color

pub const TRANSPARENT: Self

Fully transparent color (0, 0, 0, 0).

pub const BLACK: Self

Pure black color (0, 0, 0, 1).

pub const WHITE: Self

Pure white color (1, 1, 1, 1).

pub const RED: Self

Pure red color (1, 0, 0, 1).

pub const GREEN: Self

Pure green color (0, 1, 0, 1).

pub const BLUE: Self

Pure blue color (0, 0, 1, 1).

pub const GRAY: Self

Gray color (0.12, 0.12, 0.12, 1).

pub const GREY: Self = Self::GRAY

Alias for Color::GRAY.

pub const TEAL: Self

Teal color (0, 0.5, 0.5, 1).

pub const ORANGE: Self

Orange color (1, 0.5, 0, 1).

pub const fn new(r: f32, g: f32, b: f32, a: f32) -> Self

Creates a new Color from four f32 values (red, green, blue, alpha).

pub const fn from_rgb(r: f32, g: f32, b: f32) -> Self

Creates a new opaque Color from three f32 values (red, green, blue).

pub const fn from_rgba_u8(r: u8, g: u8, b: u8, a: u8) -> Self

Normalizes byte RGBA components to [0, 1] without sRGB decoding.

pub const fn from_rgb_u8(r: u8, g: u8, b: u8) -> Self

Normalizes byte RGB components without sRGB decoding; alpha is 1.

pub const fn to_array(self) -> [f32; 4]

Converts the color to an array of [f32; 4].

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

Sets the alpha (transparency) component of the color.

pub fn blend_over(self, overlay: Color, overlay_alpha: f32) -> Self

Composites overlay over this base color using straight RGBA values.

overlay_alpha scales the overlay’s own alpha. Transparent colors do not darken the result, and a fully transparent result returns transparent black.

Parameters

• overlay - The color to be composited on top of self.
• overlay_alpha - Opacity of the overlay in range [0.0, 1.0].

Returns

A new Color representing the blended result.

pub fn lerp(&self, other: &Self, t: f32) -> Self

Interpolates linear components, clamping t to [0, 1].

Trait Implementations

impl Clone for Color

fn clone(&self) -> Color

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Color

impl Debug for Color

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

Formats the value using the given formatter.

impl Default for Color

The default color is fully transparent.

fn default() -> Self

Returns the “default value” for a type.

impl From<Color> for [f32; 4]

Converts from a Color to a 4-element f32 array [r, g, b, a].

fn from(color: Color) -> Self

Converts to this type from the input type.

impl From<[f32; 3]> for Color

Converts from a 3-element f32 array [r, g, b] to an opaque Color.

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

Converts to this type from the input type.

impl From<[f32; 4]> for Color

Converts from a 4-element f32 array [r, g, b, a] to a Color.

fn from([r, g, b, a]: [f32; 4]) -> Self

Converts to this type from the input type.

impl From<[u8; 3]> for Color

Converts from a 3-element u8 array [r, g, b] to an opaque Color.

fn from([r, g, b]: [u8; 3]) -> Self

Converts to this type from the input type.

impl From<[u8; 4]> for Color

Converts from a 4-element u8 array [r, g, b, a] to a Color.

fn from([r, g, b, a]: [u8; 4]) -> Self

Converts to this type from the input type.

impl PartialEq for Color

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

Equality operator ==.

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

Inequality operator !=.

impl Pod for Color

impl StructuralPartialEq for Color

impl Zeroable for Color

fn zeroed() -> Self

Calls zeroed.