Struct Color 

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

A color in the linear sRGB color space with an alpha component.

This struct represents a color using four floating-point components: red, green, blue, and alpha (transparency). Values are typically in the range [0.0, 1.0], where:

• 0.0 represents no intensity (black for RGB, fully transparent for alpha)
• 1.0 represents full intensity (full color for RGB, fully opaque for alpha)

The struct is designed to be GPU-friendly with a C-compatible memory layout, making it suitable for direct use in shaders and graphics pipelines.

Memory Layout

The struct uses #[repr(C)] to ensure a predictable memory layout that matches the expected format for GPU buffers and shader uniforms.

Examples

use tessera_ui::Color;

// Using predefined colors
let red = Color::RED;
let white = Color::WHITE;
let transparent = Color::TRANSPARENT;

// Creating custom colors
let purple = Color::new(0.5, 0.0, 0.5, 1.0);
let semi_transparent_blue = Color::new(0.0, 0.0, 1.0, 0.5);

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).

This color is completely invisible and is often used as a default or for creating transparent backgrounds.

pub const BLACK: Self

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

Represents the absence of all light, fully opaque.

pub const WHITE: Self

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

Represents the presence of all light at full intensity, fully opaque.

pub const RED: Self

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

Full intensity red with no green or blue components, fully opaque.

pub const GREEN: Self

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

Full intensity green with no red or blue components, fully opaque.

pub const BLUE: Self

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

Full intensity blue with no red or green components, fully opaque.

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).

Parameters

• r - Red component, typically in range [0.0, 1.0]
• g - Green component, typically in range [0.0, 1.0]
• b - Blue component, typically in range [0.0, 1.0]
• a - Alpha (transparency) component, typically in range [0.0, 1.0]

Examples

use tessera_ui::Color;

let red = Color::new(1.0, 0.0, 0.0, 1.0);
let semi_transparent_blue = Color::new(0.0, 0.0, 1.0, 0.5);
let custom_color = Color::new(0.3, 0.7, 0.2, 0.8);

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

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

The alpha component is automatically set to 1.0 (fully opaque).

Parameters

• r - Red component, typically in range [0.0, 1.0]
• g - Green component, typically in range [0.0, 1.0]
• b - Blue component, typically in range [0.0, 1.0]

Examples

use tessera_ui::Color;

let purple = Color::from_rgb(0.5, 0.0, 0.5);
let orange = Color::from_rgb(1.0, 0.5, 0.0);

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

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

This is convenient for working with traditional 8-bit color values commonly used in image formats and color pickers.

Parameters

• r - Red component in range [0, 255]
• g - Green component in range [0, 255]
• b - Blue component in range [0, 255]
• a - Alpha component in range [0, 255] (0 = transparent, 255 = opaque)

Examples

use tessera_ui::Color;

let red = Color::from_rgba_u8(255, 0, 0, 255);
let semi_transparent_blue = Color::from_rgba_u8(0, 0, 255, 128);
let custom_color = Color::from_rgba_u8(76, 178, 51, 204);

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

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

The alpha component is automatically set to 255 (fully opaque). This is convenient for working with traditional RGB color values.

Parameters

• r - Red component in range [0, 255]
• g - Green component in range [0, 255]
• b - Blue component in range [0, 255]

Examples

use tessera_ui::Color;

let purple = Color::from_rgb_u8(128, 0, 128);
let orange = Color::from_rgb_u8(255, 165, 0);
let dark_green = Color::from_rgb_u8(0, 100, 0);

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

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

This is useful for interfacing with graphics APIs and shaders that expect color data in array format.

Returns

An array [r, g, b, a] where each component is an f32 value.

Examples

use tessera_ui::Color;

let color = Color::new(0.5, 0.3, 0.8, 1.0);
let array = color.to_array();
assert_eq!(array, [0.5, 0.3, 0.8, 1.0]);

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

Sets the alpha (transparency) component of the color.

Returns

A new Color instance with the updated alpha value.

Examples

use tessera_ui::Color;

let color = Color::new(0.5, 0.3, 0.8, 1.0);
let semi_transparent_color = color.with_alpha(0.5);

assert_eq!(semi_transparent_color.a, 0.5);

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

Linearly interpolates between two colors.

Arguments

• other - The target color to interpolate towards.
• t - The interpolation factor, typically in the range [0.0, 1.0].

Returns

A new Color that is the result of the interpolation.

Examples

use tessera_ui::Color;

let color1 = Color::new(1.0, 0.0, 0.0, 1.0); // Red
let color2 = Color::new(0.0, 0.0, 1.0, 1.0); // Blue
let interpolated = color1.lerp(&color2, 0.5);

assert_eq!(interpolated, Color::new(0.5, 0.0, 0.5, 1.0)); // Purple

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 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.

This implementation returns Color::TRANSPARENT, which is often the most sensible default for UI elements that may not have an explicit color specified.

Examples

use tessera_ui::Color;

let default_color = Color::default();
assert_eq!(default_color, Color::TRANSPARENT);

fn default() -> Self

Returns the “default value” for a type.

impl From<[f32; 3]> for Color

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

The alpha component is automatically set to 1.0 (fully opaque).

Examples

use tessera_ui::Color;

let color: Color = [0.5, 0.3, 0.8].into();
assert_eq!(color, Color::new(0.5, 0.3, 0.8, 1.0));

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.

Examples

use tessera_ui::Color;

let color: Color = [0.5, 0.3, 0.8, 1.0].into();
assert_eq!(color, Color::new(0.5, 0.3, 0.8, 1.0));

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.

Each component is converted from the range [0, 255] to [0.0, 1.0]. The alpha component is automatically set to 1.0 (fully opaque).

Examples

use tessera_ui::Color;

let color: Color = [255, 128, 64].into();
assert_eq!(color, Color::from_rgb_u8(255, 128, 64));

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.

Each component is converted from the range [0, 255] to [0.0, 1.0].

Examples

use tessera_ui::Color;

let color: Color = [255, 128, 64, 255].into();
assert_eq!(color, Color::from_rgba_u8(255, 128, 64, 255));

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

Converts to this type from the input type.

impl From<Color> for [f32; 4]

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

Examples

use tessera_ui::Color;

let color = Color::new(0.5, 0.3, 0.8, 1.0);
let array: [f32; 4] = color.into();
assert_eq!(array, [0.5, 0.3, 0.8, 1.0]);

fn from(color: Color) -> Self

Converts to this type from the input type.

impl PartialEq for Color

fn eq(&self, other: &Color) -> 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 Color

fn zeroed() -> Self

Calls zeroed.

impl Copy for Color

impl Pod for Color

impl StructuralPartialEq for Color