colstodian 0.1.0-rc.3

An opinionated, practical color management library for games and graphics.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Structs that act as bags of named components which [`Color`][super::Color]s of different color spaces
//! may be `Deref`erenced to in order to gain more appropriate dot syntax for that color space.
//!
//! For example, a [`Color`][super::Color] in the [`ICtCpPQ`][super::ICtCpPQ] color space can be `Deref`'d to [`ICtCp`], allowing you
//! to do things like `color.i` or `color.ct`.

use core::fmt;

/// A bag of components with an alpha channel. Some `ColorAlpha`s will Deref
/// to this so that you can use `.alpha` and `.col.{component_name}`.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct ColAlpha<T> {
    pub col: T,
    pub alpha: f32,
}

impl<T: fmt::Display> fmt::Display for ColAlpha<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}, Alpha: {}", self.col, self.alpha)
    }
}

macro_rules! impl_bytemuck {
    ($($inner:ident),+) => {
        $(
            unsafe impl bytemuck::Zeroable for $inner {}
            unsafe impl bytemuck::Pod for $inner {}

            unsafe impl bytemuck::Zeroable for ColAlpha<$inner> {}
            unsafe impl bytemuck::Pod for ColAlpha<$inner> {}
        )+
    }
}

impl_bytemuck!(Rgb, ICtCp, Xyz, Lab, LCh);

/// A bag of components with names R, G, B. Some `Color`s with RGB color spaces
/// will `Deref`/`DerefMut` to this struct so that you can access their components with dot-syntax.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct Rgb {
    pub r: f32,
    pub g: f32,
    pub b: f32,
}

impl fmt::Display for Rgb {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "R: {}, G: {}, B: {}", self.r, self.g, self.b)
    }
}

/// A bag of components with names I (Intensity), Ct (Chroma-Tritan), Cp (Chroma-Protan). Some `Color`s
/// will `Deref`/`DerefMut` to this struct so that you can access their components with dot-syntax.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct ICtCp {
    pub i: f32,
    pub ct: f32,
    pub cp: f32,
}

impl fmt::Display for ICtCp {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "I: {}, Ct: {}, Cp: {}", self.i, self.ct, self.cp)
    }
}

/// A bag of components with names X, Y, Z. Some `Color`s with XYZ color spaces
/// will `Deref`/`DerefMut` to this struct so that you can access their components with dot-syntax.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct Xyz {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

impl fmt::Display for Xyz {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "X: {}, Y: {}, Z: {}", self.x, self.y, self.z)
    }
}

/// A bag of components with names L (Luminance), a (green-red chroma), b (blue-yellow chroma).
/// Some `Color`s with XYZ color spaces will `Deref`/`DerefMut` to this struct so that you can
/// access their components with dot-syntax.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct Lab {
    pub l: f32,
    pub a: f32,
    pub b: f32,
}

impl fmt::Display for Lab {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "L: {}, a: {}, b: {}", self.l, self.a, self.b)
    }
}

/// A bag of components with names L (Luminance), C (chroma), h (hue).
/// Some `Color`s with XYZ color spaces will `Deref`/`DerefMut` to this struct so that you can
/// access their components with dot-syntax.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct LCh {
    pub l: f32,
    pub c: f32,
    pub h: f32,
}

impl fmt::Display for LCh {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "L: {}, C: {}, h: {}", self.l, self.c, self.h)
    }
}