Struct Color 

pub struct Color(pub f32, pub f32, pub f32, pub f32);

Tuple Fields

0: f32

1: f32

2: f32

3: f32

Implementations

impl Color

pub const BLACK: Color

pub const WHITE: Color

pub const RED: Color

pub const GREEN: Color

pub const BLUE: Color

pub const TRANSPARENT: Color

pub const fn rgb(r: f32, g: f32, b: f32) -> Color

pub const fn rgba(r: f32, g: f32, b: f32, a: f32) -> Color

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

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

pub fn r(&self) -> f32

pub fn g(&self) -> f32

pub fn b(&self) -> f32

pub fn a(&self) -> f32

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

pub fn srgb_8bit(self) -> Color

This colour as the platform’s colour type actually holds it: eight bits per channel.

androidx.compose.ui.graphics.Color is a float-shaped API over an 8-bit value. Building one in the sRGB space snaps every channel on the spot — the bytecode of ColorKt.Color(float, float, float, float, ColorSpace) is coerceIn(0f, 1f), * 255.0f, + 0.5f, f2i, packed into an ARGB int — so a colour an app computes in float is already a whole channel value before anything paints with it, and the rasterizer never sees the fraction.

A renderer that carries the fraction to the framebuffer instead leaves the rounding to whatever converts float to unorm there. That agrees nearly everywhere and disagrees on an exact half. It is not a rare shape: a theme that lerps between two byte colours lands on one routinely — mix(rail, background, 0.55) puts a Wear settings capsule at exactly 22.5/255 on green, where this rule gives 23 and a converter that breaks ties to even gives 22. One level, and then the row’s layer alpha multiplies it and keeps it.

Ties go up, which is what (int)(x + 0.5f), Skia’s SkScalarRoundToInt and Rust’s f32::round all give for a channel clamped into 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<(), Error>

Formats the value using the given formatter.

impl Lerp for Color

fn lerp(&self, target: &Color, fraction: f32) -> Color

Linearly interpolate each RGBA channel, including alpha.

Jetpack Compose’s default Color lerp converts through the Oklab color space before interpolating. Cranpose colors carry no color-space information, so this implementation interpolates each channel linearly in the color’s own (linear RGBA) space instead. For typical UI fades between colors in the same space this closely matches Compose’s behavior; the results are clamped to [0.0, 1.0] per channel so overshooting springs still produce valid colors, matching Compose’s gamut coercion.

impl PartialEq for Color

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

Equality operator ==.

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

Inequality operator !=.

impl RenderHash for Color

fn render_hash(&self) -> u64

impl SpringScalar for Color

Colors spring as four independent channels, mirroring how Compose animates Color as an AnimationVector4D. Channels are clamped back into [0, 1] when the vector is rebuilt, so overshooting springs still produce valid colors (Compose’s gamut coercion).

const DIMENSIONS: usize = 4

Number of animated dimensions (1..=4).

fn dimension(&self, index: usize) -> f32

Reads dimension index (index < Self::DIMENSIONS).

fn from_dimensions(dimensions: [f32; 4]) -> Color

Rebuilds a value from per-dimension floats (indices beyond Self::DIMENSIONS are ignored).

impl StructuralPartialEq for Color