Struct Color 

pub struct Color { /* private fields */ }

An RGBA color value, holding four floating point components.

Guarantees

• All values are in 0..=1 range.

Implementations

impl Color

pub const TRANSPARENT: Color

A transparent color.

pub const BLACK: Color

A black color.

pub const WHITE: Color

A white color.

pub fn from_rgba(r: f32, g: f32, b: f32, a: f32) -> Option<Color>

Creates a new color from 4 components.

All values must be in 0..=1 range.

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

Creates a new color from 4 components.

u8 will be divided by 255 to get the float component.

pub fn red(&self) -> f32

Returns color’s red component.

The value is guarantee to be in a 0..=1 range.

pub fn green(&self) -> f32

Returns color’s green component.

The value is guarantee to be in a 0..=1 range.

pub fn blue(&self) -> f32

Returns color’s blue component.

The value is guarantee to be in a 0..=1 range.

pub fn alpha(&self) -> f32

Returns color’s alpha component.

The value is guarantee to be in a 0..=1 range.

pub fn set_red(&mut self, c: f32)

Sets the red component value.

The new value will be clipped to the 0..=1 range.

pub fn set_green(&mut self, c: f32)

Sets the green component value.

The new value will be clipped to the 0..=1 range.

pub fn set_blue(&mut self, c: f32)

Sets the blue component value.

The new value will be clipped to the 0..=1 range.

pub fn set_alpha(&mut self, c: f32)

Sets the alpha component value.

The new value will be clipped to the 0..=1 range.

pub fn apply_opacity(&mut self, opacity: f32)

Shifts color’s opacity.

Essentially, multiplies color’s alpha by opacity.

opacity will be clamped to the 0..=1 range first. The final alpha will also be clamped.

pub fn is_opaque(&self) -> bool

Check that color is opaque.

Alpha == 1.0

pub fn premultiply(&self) -> PremultipliedColor

Converts into a premultiplied color.

pub fn to_color_u8(&self) -> ColorU8

Converts into ColorU8.

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 Colorful for Color

fn jiggle_xy(&self, x: u32, y: u32, mean: f32, std: f32) -> Color

Perturb a color based on its position on the canvas. The perturbation is done by adding a random number from a normal distribution with the given mean and standard deviation to each of the color’s components.

fn jiggle_xy_lightness(&self, x: u32, y: u32, mean: f32, std: f32) -> Color

Perturb a color’s lightness based on its position on the canvas. The perturbation is done by adding a random number from a normal distribution with the given mean and standard deviation to the color’s lightness.

fn jiggle_xy_saturation(&self, x: u32, y: u32, mean: f32, std: f32) -> Color

Perturb a color’s saturation based on its position on the canvas. The perturbation is done by adding a random number from a normal distribution with the given mean and standard deviation to the color’s saturation.

fn jiggle_xy_hue(&self, x: u32, y: u32, mean: f32, std: f32) -> Color

Perturb a color’s hue based on its position on the canvas. The perturbation is done by adding a random number from a normal distribution with the given mean and standard deviation to the color’s hue.

fn grayscale(&self) -> Color

Convert a color to grayscale.

fn rotate_hue(&self, degrees: f32) -> Color

Rotate the hue of a color by the given number of degrees.

fn tighten(&self) -> Color

Change the lighness of a color to it’s square, i.e. tightening it away from lighter or darker which ever is closer.

fn spread(&self) -> Color

Change the lighness of a color to it’s square root, i.e. spreading it towards lighter or darker which ever is closer.

fn tint(&self, t: f32) -> Color

Tint a color by mixing it with white. 0 is no white, 1 is all white.

fn tone(&self, t: f32) -> Color

Tone a color by mixing it with gray. 0 is no gray, 1 is all gray.

fn shade(&self, t: f32) -> Color

Shade a color by mixing it with black. 0 is no black, 1 is all black.

fn saturate(&self, factor: f32) -> Color

Saturate a color by the given factor.

fn saturate_fixed(&self, amount: f32) -> Color

Saturate a color a fixed abount.

fn lighten(&self, factor: f32) -> Color

Lighten a color by the given factor.

fn lighten_fixed(&self, amount: f32) -> Color

Lighten a color a fixed abount.

fn lerp(&self, color2: &Color, t: f32) -> Color

Linearly interpolate between two colors in a linear color space and convert back to sRGBA.

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

Same as origingal color with a new alpha.

fn as_f32s(&self) -> (f32, f32, f32, f32)

A tuple of the color’s rgba components as f32s.

fn as_u8s(&self) -> (u8, u8, u8, u8)

A tuple of the color’s rgba components as u8s.

fn darken(&self, factor: f32) -> Self

where Self: Sized,

Darken a color by the given factor.

fn darken_fixed(&self, amount: f32) -> Self

where Self: Sized,

Darken a color a fixed abount.

fn desaturate(&self, factor: f32) -> Self

where Self: Sized,

Desaturate a color by the given factor.

fn desaturate_fixed(&self, amount: f32) -> Self

where Self: Sized,

Desaturate a color a fixed abount.

impl ConvertColor for Color

fn to_color(&self) -> Color

fn from_color(color: &Color) -> Color

impl Debug for Color

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

Formats the value using the given formatter.

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 Copy for Color

impl StructuralPartialEq for Color