pixeli 0.2.1

This crate provides common pixel types and traits for working with them.
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

use crate::*;

macro_rules! between {
    ($from_type:ident, $self_type:ident, {$($bit:ident),*}) => {
        impl<R, S> From<$from_type<R>> for $self_type<S> where R: Into<S> {
            fn from(value: $from_type<R>) -> Self {
                Self{$($bit: value.$bit.into()),*}
            }
        }
    };
}

between!(Rgba, Rgb, {r, g, b});
between!(Argb, Rgb, {r, g, b});
between!(Bgra, Rgb, {r, g, b});
between!(Abgr, Rgb, {r, g, b});
between!(Bgr, Rgb, {r, g, b});

between!(Rgba, Bgr, {r, g, b});
between!(Argb, Bgr, {r, g, b});
between!(Bgra, Bgr, {r, g, b});
between!(Abgr, Bgr, {r, g, b});
between!(Rgb, Bgr, {r, g, b});

between!(Argb, Rgba, {r, g, b, a});
between!(Bgra, Rgba, {r, g, b, a});
between!(Abgr, Rgba, {r, g, b, a});

between!(Rgba, Argb, {r, g, b, a});
between!(Bgra, Argb, {r, g, b, a});
between!(Abgr, Argb, {r, g, b, a});

between!(Rgba, Bgra, {r, g, b, a});
between!(Argb, Bgra, {r, g, b, a});
between!(Abgr, Bgra, {r, g, b, a});

between!(Rgba, Abgr, {r, g, b, a});
between!(Argb, Abgr, {r, g, b, a});
between!(Bgra, Abgr, {r, g, b, a});

between!(GrayAlpha, Gray, { gray });

macro_rules! with_array {
    ($type:ident, $length:literal, [$($bit:ident),*]) => {
        impl<R, S> From<$type<R>> for [S; $length] where R: Into<S> {
            fn from(value: $type<R>) -> Self {
                [$(value.$bit.into()),*]
            }
        }
        impl<R, S> From<[R; $length]> for $type<S> where R: Into<S> {
            fn from(value: [R; $length]) -> Self {
                let mut iter = value.into_iter();
                Self{$($bit: iter.next().unwrap().into()),*}
            }
        }
    };
}

with_array!(Rgb, 3, [r, g, b]);
with_array!(Bgr, 3, [b, g, r]);
with_array!(Rgba, 4, [r, g, b, a]);
with_array!(Argb, 4, [a, r, g, b]);
with_array!(Bgra, 4, [b, g, r, a]);
with_array!(Abgr, 4, [a, b, g, r]);
with_array!(Gray, 1, [gray]);
with_array!(GrayAlpha, 2, [gray, a]);