Struct Color

pub struct Color<T: Storage>(/* private fields */);

An RGBA color backed by a u32.

There are multiple storage formats to choose from, see the crate level documentation for more info.

Examples

type RGBA = inku::Color<inku::RGBA>;
assert_eq!(RGBA::new(0xfacadeff).to_u32(), 0xfacadeff);

// 4 bytes
assert_eq!(4, std::mem::size_of::<RGBA>());

Implementations

impl<T: Storage> Color<T>

pub fn new(color: u32) -> Self

Initializes a new Color from a u32.

Examples

type Color = inku::Color<inku::ZRGB>;
let color = Color::new(0x000000);

Using ZRGB, the u32 is treated as follows:

0x00000000
  ^^ ignored (zeroed out)
    ^^ red
      ^^ green
        ^^ blue

pub fn lighten(self, percent: f64) -> Self

Lightens the color by translating to HSL color space then adjusting the lightness value.

Panics

Panics if percent is not between 0.0 and 1.0

pub fn darken(self, percent: f64) -> Self

Darkens the color by translating to HSL color space then adjusting the lightness value.

Panics

Panics if percent is not between 0.0 and 1.0

pub fn saturate(self, percent: f64) -> Self

Increases saturation of the color by translating to HSL color space then adjusting the saturation value.

Panics

Panics if percent is not between 0.0 and 1.0

pub fn desaturate(self, percent: f64) -> Self

Decreases saturation of the color by translating to HSL color space then adjusting the saturation value.

Panics

Panics if percent is not between 0.0 and 1.0

pub fn rotate_hue(self, amount: f64) -> Self

Rotate the hue by translating to HSL color space then adjusting the hue value. Takes a value between 0.0 and 360.0.

pub fn to_u32(self) -> u32

Returns the underlying u32.

pub fn brightness(self) -> f64

The percieved brightness of the color (a number between 0.0 and 1.0).

pub fn is_light(self) -> bool

Determine whether a color is perceived as a light color (percieved brightness is greater than 0.5).

pub fn map<F>(&self, f: F) -> Self

where F: Fn(u8, u8, u8, u8) -> (u8, u8, u8, u8),

Maps (r1, g1, b1, a1) to (r2, g2, b2, a2) by applying a function to the channels.

Examples

let color = Color::<RGBA>::new(0x00000011);
assert_eq!(
    color.map(|r, g, b, a| (r, g, b, a + 0x22)).to_u32(),
    0x00000033
);

const F: fn(u8, u8, u8, u8) -> (u8, u8, u8, u8) = |r, g, b, a| {
    assert_eq!(r, 0x22);
    assert_eq!(g, 0x33);
    assert_eq!(b, 0x44);
    assert_eq!(a, 0x00);
    (1, 2, 3, 4)
};
let color = Color::<ZRGB>::new(0x11223344);
assert_eq!(color.map(F).to_u32(), 0x00010203);

Trait Implementations

impl<T: Clone + Storage> Clone for Color<T>

fn clone(&self) -> Color<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Storage> Debug for Color<T>

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

Formats the value using the given formatter.

impl<T: Default + Storage> Default for Color<T>

fn default() -> Color<T>

Returns the “default value” for a type.

impl<T: Storage> From<(u8, u8, u8)> for Color<T>

fn from(rgb: (u8, u8, u8)) -> Self

Converts to this type from the input type.

impl<T: Storage> From<(u8, u8, u8, u8)> for Color<T>

fn from(rgba: (u8, u8, u8, u8)) -> Self

Converts to this type from the input type.

impl<T: Storage> From<Color<T>> for (u8, u8, u8)

fn from(color: Color<T>) -> (u8, u8, u8)

Converts to this type from the input type.

impl<T: Storage> From<Color<T>> for (u8, u8, u8, u8)

fn from(color: Color<T>) -> (u8, u8, u8, u8)

Converts to this type from the input type.

impl<T: Storage> From<Color<T>> for u32

fn from(color: Color<T>) -> u32

Converts to this type from the input type.

impl<T: Storage> From<u32> for Color<T>

fn from(color: u32) -> Self

Converts to this type from the input type.

impl<T: Hash + Storage> Hash for Color<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq + Storage> PartialEq for Color<T>

fn eq(&self, other: &Color<T>) -> 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<T: Copy + Storage> Copy for Color<T>

impl<T: Storage> StructuralPartialEq for Color<T>