-
Notifications
You must be signed in to change notification settings - Fork 59
/
mod.rs
145 lines (123 loc) · 3.4 KB
/
mod.rs
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
//!RGB types, spaces and standards.
use alpha::Alpha;
use float::Float;
use core::any::Any;
use {Component, Yxy};
use white_point::WhitePoint;
use encoding::{Linear, TransferFn};
pub use self::rgb::{Rgb, Rgba};
//mod linear;
mod rgb;
///Nonlinear sRGB.
pub type Srgb<T = f32> = Rgb<::encoding::Srgb, T>;
///Nonlinear sRGB with an alpha component.
pub type Srgba<T = f32> = Rgba<::encoding::Srgb, T>;
///Linear sRGB.
pub type LinSrgb<T = f32> = Rgb<Linear<::encoding::Srgb>, T>;
///Linear sRGB with an alpha component.
pub type LinSrgba<T = f32> = Rgba<Linear<::encoding::Srgb>, T>;
/// Gamma 2.2 encoded sRGB.
pub type GammaSrgb<T = f32> = Rgb<::encoding::Gamma<::encoding::Srgb>, T>;
/// Gamma 2.2 encoded sRGB with an alpha component.
pub type GammaSrgba<T = f32> = Rgba<::encoding::Gamma<::encoding::Srgb>, T>;
///An RGB space and a transfer function.
pub trait RgbStandard {
///The RGB color space.
type Space: RgbSpace;
///The transfer function for the color components.
type TransferFn: TransferFn;
}
impl<S: RgbSpace, T: TransferFn> RgbStandard for (S, T) {
type Space = S;
type TransferFn = T;
}
impl<P: Primaries, W: WhitePoint, T: TransferFn> RgbStandard for (P, W, T) {
type Space = (P, W);
type TransferFn = T;
}
///A set of primaries and a white point.
pub trait RgbSpace {
///The primaries of the RGB color space.
type Primaries: Primaries;
///The white point of the RGB color space.
type WhitePoint: WhitePoint;
}
impl<P: Primaries, W: WhitePoint> RgbSpace for (P, W) {
type Primaries = P;
type WhitePoint = W;
}
///Represents the red, green and blue primaries of an RGB space.
pub trait Primaries: Any {
///Primary red.
fn red<Wp: WhitePoint, T: Component + Float>() -> Yxy<Wp, T>;
///Primary green.
fn green<Wp: WhitePoint, T: Component + Float>() -> Yxy<Wp, T>;
///Primary blue.
fn blue<Wp: WhitePoint, T: Component + Float>() -> Yxy<Wp, T>;
}
impl<T, U> From<LinSrgb<T>> for Srgb<U>
where
T: Component + Float,
U: Component,
{
fn from(lin_srgb: LinSrgb<T>) -> Self {
let non_lin = Srgb::<T>::from_linear(lin_srgb);
non_lin.into_format()
}
}
impl<T, U> From<Srgb<T>> for LinSrgb<U>
where
T: Component + Float,
U: Component,
{
fn from(srgb: Srgb<T>) -> Self {
srgb.into_linear()
.into_format()
}
}
impl<T, U> From<LinSrgb<T>> for Srgba<U>
where
T: Component + Float,
U: Component,
{
fn from(lin_srgb: LinSrgb<T>) -> Self {
let color = lin_srgb.into();
let alpha = U::max_intensity();
Alpha { color, alpha }
}
}
impl<T, U> From<LinSrgba<T>> for Srgba<U>
where
T: Component + Float,
U: Component,
{
fn from(lin_srgba: LinSrgba<T>) -> Self {
let (r, g, b, a) = lin_srgba.into();
let color = LinSrgb::new(r, g, b).into();
let alpha = a.convert();
Alpha { color, alpha }
}
}
impl<T, U> From<Srgb<T>> for LinSrgba<U>
where
T: Component + Float,
U: Component,
{
fn from(srgb: Srgb<T>) -> Self {
let color = srgb.into();
let alpha = U::max_intensity();
Alpha { color, alpha }
}
}
impl<T, U> From<Srgba<T>> for LinSrgba<U>
where
T: Component + Float,
U: Component,
{
fn from(srgba: Srgba<T>) -> Self {
let (r, g, b, a) = srgba.into();
let color = Srgb::new(r, g, b).into();
let alpha = a.convert();
Alpha { color, alpha }
}
}