dunge 0.3.5

Typesafe and portable 3d render library
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

//! Color types.

use bytemuck::{Pod, Zeroable};

/// A linear RGB color.
pub type Rgb = Color<3>;

/// A linear RGBA color.
pub type Rgba = Color<4>;

/// A linear RGB(A) color.
#[repr(transparent)]
#[derive(Clone, Copy)]
pub struct Color<const N: usize>(pub [f32; N]);

impl<const N: usize> Color<N> {
    /// Creates a linear `Color` from sRGB(A) color.
    pub fn from_standard(col: [f32; N]) -> Self {
        fn to_linear(c: f32) -> f32 {
            if c > 0.04045 {
                ((c + 0.055) / 1.055).powf(2.4)
            } else {
                c / 12.92
            }
        }

        Self(col.map(to_linear))
    }

    /// Creates a linear `Color` from a linear bytes.
    pub fn from_bytes(col: [u8; N]) -> Self {
        Self(col.map(to_f32_color))
    }

    /// Creates a linear `Color` from a sRGB(A) bytes.
    pub fn from_standard_bytes(col: [u8; N]) -> Self {
        Self::from_standard(col.map(to_f32_color))
    }
}

impl Color<4> {
    pub(crate) fn wgpu(self) -> wgpu::Color {
        let [r, g, b, a] = self.0.map(f64::from);
        wgpu::Color { r, g, b, a }
    }
}

// SAFETY: `Color` is repr transparent
// so if `[f32; N]: Zeroable` then `Color<N>: Zeroable`.
unsafe impl<const N: usize> Zeroable for Color<N> where [f32; N]: Zeroable {}

// SAFETY: `Color` is repr transparent
// so if `[f32; N]: Pod` then `Color<N>: Pod`.
unsafe impl<const N: usize> Pod for Color<N> where [f32; N]: Pod {}

fn to_f32_color(c: u8) -> f32 {
    f32::from(c) / f32::from(u8::MAX)
}

pub trait ColorExt {
    fn rgb_from_bytes(self, rgb: [u8; 3]) -> Rgb;
    fn rgba_from_bytes(self, rgba: [u8; 4]) -> Rgba;
}