Struct D3Color 

pub struct D3Color {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
}

RGB color with alpha channel and interpolation support

Example

use d3rs::color::D3Color;

let red = D3Color::rgb(255, 0, 0);
let blue = D3Color::from_hex(0x0000ff);
let purple = red.interpolate(&blue, 0.5);

Fields

r: f32

Red component (0.0 - 1.0)

g: f32

Green component (0.0 - 1.0)

b: f32

Blue component (0.0 - 1.0)

a: f32

Alpha component (0.0 - 1.0)

Implementations

impl D3Color

pub fn rgb(r: u8, g: u8, b: u8) -> D3Color

Create a color from RGB values (0-255)

Example

use d3rs::color::D3Color;

let red = D3Color::rgb(255, 0, 0);

pub fn rgba(r: u8, g: u8, b: u8, a: u8) -> D3Color

Create a color from RGBA values (0-255)

Example

use d3rs::color::D3Color;

let semi_transparent_red = D3Color::rgba(255, 0, 0, 128);

pub fn from_hex(hex: u32) -> D3Color

Create a color from a hex value (0xRRGGBB)

Example

use d3rs::color::D3Color;

let orange = D3Color::from_hex(0xff5500);

pub fn from_rgb_f32(r: f32, g: f32, b: f32) -> D3Color

Create a color from RGB floats (0.0 - 1.0)

Example

use d3rs::color::D3Color;

let red = D3Color::from_rgb_f32(1.0, 0.0, 0.0);

pub fn from_rgba_f32(r: f32, g: f32, b: f32, a: f32) -> D3Color

Create a color from RGBA floats (0.0 - 1.0)

pub fn to_rgba(&self) -> Rgba

Convert to GPUI Rgba type

Example

use d3rs::color::D3Color;

let color = D3Color::rgb(255, 128, 0);
let gpui_color = color.to_rgba();

pub fn from_rgba(rgba: Rgba) -> D3Color

Create from GPUI Rgba type

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

Set the alpha channel

Example

use d3rs::color::D3Color;

let semi_transparent = D3Color::rgb(255, 0, 0).with_alpha(0.5);

pub fn interpolate(&self, other: &D3Color, t: f32) -> D3Color

Linear interpolation between two colors

t should be in the range [0.0, 1.0], where:

• 0.0 returns self
• 1.0 returns other
• 0.5 returns the midpoint

Example

use d3rs::color::D3Color;

let red = D3Color::rgb(255, 0, 0);
let blue = D3Color::rgb(0, 0, 255);
let purple = red.interpolate(&blue, 0.5);

pub fn lighten(&self, amount: f32) -> D3Color

Lighten the color by a factor (0.0 - 1.0)

pub fn darken(&self, amount: f32) -> D3Color

Darken the color by a factor (0.0 - 1.0)

pub fn to_hex(&self) -> String

Convert to a hex color string (e.g., “#ff0000”)

Example

use d3rs::color::D3Color;

let red = D3Color::rgb(255, 0, 0);
assert_eq!(red.to_hex(), "#ff0000");

pub fn to_hex_alpha(&self) -> String

Convert to a hex color string with alpha (e.g., “#ff000080”)

Example

use d3rs::color::D3Color;

let red = D3Color::rgba(255, 0, 0, 128);
assert_eq!(red.to_hex_alpha(), "#ff000080");

pub fn luminance(&self) -> f32

Get the luminance of the color (0.0 to 1.0)

Uses the relative luminance formula from WCAG 2.0.

Example

use d3rs::color::D3Color;

let white = D3Color::rgb(255, 255, 255);
let black = D3Color::rgb(0, 0, 0);
assert!(white.luminance() > 0.9);
assert!(black.luminance() < 0.1);

pub fn brighter(&self, k: f32) -> D3Color

Make the color brighter by a factor

Factor of 1.0 increases brightness by ~18% (similar to d3.brighter).

pub fn darker(&self, k: f32) -> D3Color

Make the color darker by a factor

Factor of 1.0 decreases brightness by ~18% (similar to d3.darker).

pub fn with_opacity(&self, opacity: f32) -> D3Color

Set the opacity (alpha channel)

pub fn opacity(&self) -> f32

Get the opacity (alias for alpha)

pub fn from_hsl(h: f32, s: f32, l: f32) -> D3Color

Create a color from HSL values

• h: Hue in degrees (0-360)
• s: Saturation (0-1)
• l: Lightness (0-1)

Example

use d3rs::color::D3Color;

let red = D3Color::from_hsl(0.0, 1.0, 0.5);
assert_eq!(red.to_hex(), "#ff0000");

Trait Implementations

impl Clone for D3Color

fn clone(&self) -> D3Color

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for D3Color

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

Formats the value using the given formatter.

impl PartialEq for D3Color

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

impl StructuralPartialEq for D3Color