Struct LinearRgba 

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

Represents a color in a linear RGBA color space using f32 components.

This struct is the standard color representation within Khora.
Using a linear color space is crucial for correct lighting, shading, and blending. The f32 components allow for High Dynamic Range (HDR) colors, where component values can exceed 1.0.

#[repr(C)] ensures a consistent memory layout, which is important when passing color data to graphics APIs.

Fields

r: f32

The red component in linear space.

g: f32

The green component in linear space.

b: f32

The blue component in linear space.

a: f32

The alpha (opacity) component (linear, but not gamma-corrected).

Implementations

impl LinearRgba

pub const RED: LinearRgba

Opaque red ([1.0, 0.0, 0.0, 1.0]).

pub const GREEN: LinearRgba

Opaque green ([0.0, 1.0, 0.0, 1.0]).

pub const BLUE: LinearRgba

Opaque blue ([0.0, 0.0, 1.0, 1.0]).

pub const YELLOW: LinearRgba

Opaque yellow ([1.0, 1.0, 0.0, 1.0]).

pub const CYAN: LinearRgba

Opaque cyan ([0.0, 1.0, 1.0, 1.0]).

pub const MAGENTA: LinearRgba

Opaque magenta ([1.0, 0.0, 1.0, 1.0]).

pub const WHITE: LinearRgba

Opaque white ([1.0, 1.0, 1.0, 1.0]).

pub const BLACK: LinearRgba

Opaque black ([0.0, 0.0, 0.0, 1.0]).

pub const TRANSPARENT: LinearRgba

Fully transparent black ([0.0, 0.0, 0.0, 0.0]).

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

Creates a new LinearRgba with explicit RGBA values.

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

Creates a new opaque LinearRgba (alpha = 1.0).

pub const fn gray(value: f32) -> LinearRgba

Creates an opaque grayscale color where every channel equals value. Equivalent to LinearRgba::rgb(value, value, value).

impl LinearRgba

pub fn from_vec4(v: Vec4) -> LinearRgba

Creates a LinearRgba from a Vec4.

pub fn to_vec4(&self) -> Vec4

Converts this LinearRgba to a Vec4.

pub fn from_hex(hex: &str) -> LinearRgba

Creates a LinearRgba from an sRGB hex string (#RRGGBB or #RRGGBBAA).

The RGB channels are converted to linear space. Alpha is normalized but not gamma corrected.

Panics

Panics if the hex string is malformed.

Example

use khora_core::math::color::LinearRgba;
let color = LinearRgba::from_hex("#6495ED");

pub fn to_hex(&self) -> String

Converts this linear color to an sRGB hex string (#RRGGBBAA).

The RGB channels are gamma corrected to sRGB. Alpha is kept linear.

pub fn from_srgb(r: f32, g: f32, b: f32) -> LinearRgba

Creates a LinearRgba by converting from normalized sRGB components.

pub fn to_srgb(&self) -> LinearRgba

Converts this linear color to sRGB components.

pub fn from_oklch(l: f32, c: f32, h: f32) -> LinearRgba

Creates a LinearRgba from OKLCH coordinates.

• l — perceptual lightness in [0, 1]
• c — chroma (typically [0, 0.4]; values above ~0.37 may be out of sRGB gamut and get clamped)
• h — hue in degrees

OKLCH is the perceptual cylindrical form of OKLab — same hue reads the same brightness across the spectrum. This is the space the Khora design system is authored in (see docs/src/design/editor.md and the mdBook CSS).

The output is an opaque color (a = 1.0); use Self::with_alpha to layer transparency on top.

pub fn from_oklab(l: f32, a: f32, b: f32) -> LinearRgba

Creates a LinearRgba from OKLab coordinates (l, a, b).

Implements Björn Ottosson’s reference transform (https://bottosson.github.io/posts/oklab/): OKLab → linear LMS (cube each axis) → linear sRGB (M2 matrix). The result is the same as the CSS oklab() function in linear-light space.

pub fn premultiplied(self) -> LinearRgba

Returns the same color premultiplied by its alpha — every RGB channel is scaled by a. Premultiplied alpha is what most graphics APIs (and egui) expect at the blending stage.

pub fn unpremultiplied(self) -> LinearRgba

Inverse of Self::premultiplied — divides each RGB channel by a (no-op when a == 0). Use to recover unassociated alpha from a premultiplied buffer.

impl LinearRgba

pub fn with_alpha(&self, a: f32) -> LinearRgba

Returns a new color with the same RGB components but a different alpha.

pub fn lerp(start: LinearRgba, end: LinearRgba, t: f32) -> LinearRgba

Linearly interpolates between two colors. The factor t is clamped to [0.0, 1.0].

Trait Implementations

impl Add for LinearRgba

fn add(self, rhs: LinearRgba) -> <LinearRgba as Add>::Output

Adds two colors component-wise.

type Output = LinearRgba

The resulting type after applying the + operator.

impl<'__de, __Context> BorrowDecode<'__de, __Context> for LinearRgba

fn borrow_decode<__D>(decoder: &mut __D) -> Result<LinearRgba, DecodeError>

where __D: BorrowDecoder<'__de, Context = __Context>,

Attempt to decode this type with the given BorrowDecode.

impl Clone for LinearRgba

fn clone(&self) -> LinearRgba

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinearRgba

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for LinearRgba

fn decode<__D>(decoder: &mut __D) -> Result<LinearRgba, DecodeError>

where __D: Decoder<Context = __Context>,

Attempt to decode this type with the given Decode.

impl Default for LinearRgba

fn default() -> LinearRgba

Returns opaque white by default.

impl<'de> Deserialize<'de> for LinearRgba

fn deserialize<__D>( __deserializer: __D, ) -> Result<LinearRgba, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<f32> for LinearRgba

fn div(self, scalar: f32) -> <LinearRgba as Div<f32>>::Output

Divides all components by a scalar.

type Output = LinearRgba

The resulting type after applying the / operator.

impl Encode for LinearRgba

fn encode<__E>(&self, encoder: &mut __E) -> Result<(), EncodeError>

where __E: Encoder,

Encode a given type.

impl Mul<f32> for LinearRgba

fn mul(self, scalar: f32) -> <LinearRgba as Mul<f32>>::Output

Multiplies all components by a scalar.

type Output = LinearRgba

The resulting type after applying the * operator.

impl Mul for LinearRgba

fn mul(self, rhs: LinearRgba) -> <LinearRgba as Mul>::Output

Multiplies two colors component-wise (modulation).

type Output = LinearRgba

The resulting type after applying the * operator.

impl PartialEq for LinearRgba

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for LinearRgba

fn sub(self, rhs: LinearRgba) -> <LinearRgba as Sub>::Output

Subtracts two colors component-wise.

type Output = LinearRgba

The resulting type after applying the - operator.

impl Zeroable for LinearRgba

fn zeroed() -> Self

Calls zeroed.

impl Copy for LinearRgba

impl Pod for LinearRgba

impl StructuralPartialEq for LinearRgba