1// Copyright 2006 The Android Open Source Project
2// Copyright 2020 Yevhenii Reizner
3//
4// Use of this source code is governed by a BSD-style license that can be
5// found in the LICENSE file.
6
7use tiny_skia_path::{NormalizedF32, Scalar};
8
9/// 8-bit type for an alpha value. 255 is 100% opaque, zero is 100% transparent.
10pub type AlphaU8 = u8;
11
12/// Represents fully transparent AlphaU8 value.
13pub const ALPHA_U8_TRANSPARENT: AlphaU8 = 0x00;
14
15/// Represents fully opaque AlphaU8 value.
16pub const ALPHA_U8_OPAQUE: AlphaU8 = 0xFF;
17
18/// Represents fully transparent Alpha value.
19pub const ALPHA_TRANSPARENT: NormalizedF32 = NormalizedF32::ZERO;
20
21/// Represents fully opaque Alpha value.
22pub const ALPHA_OPAQUE: NormalizedF32 = NormalizedF32::ONE;
23
24/// A 32-bit RGBA color value.
25///
26/// Byteorder: RGBA (relevant for bytemuck casts)
27#[repr(transparent)]
28#[derive(Copy, Clone, PartialEq)]
29pub struct ColorU8([u8; 4]);
30
31impl ColorU8 {
32 /// Creates a new color.
33 pub const fn from_rgba(r: u8, g: u8, b: u8, a: u8) -> Self {
34 ColorU8([r, g, b, a])
35 }
36
37 /// Returns color's red component.
38 pub const fn red(self) -> u8 {
39 self.0[0]
40 }
41
42 /// Returns color's green component.
43 pub const fn green(self) -> u8 {
44 self.0[1]
45 }
46
47 /// Returns color's blue component.
48 pub const fn blue(self) -> u8 {
49 self.0[2]
50 }
51
52 /// Returns color's alpha component.
53 pub const fn alpha(self) -> u8 {
54 self.0[3]
55 }
56
57 /// Check that color is opaque.
58 ///
59 /// Alpha == 255
60 pub fn is_opaque(&self) -> bool {
61 self.alpha() == ALPHA_U8_OPAQUE
62 }
63
64 /// Converts into a premultiplied color.
65 pub fn premultiply(&self) -> PremultipliedColorU8 {
66 let a = self.alpha();
67 if a != ALPHA_U8_OPAQUE {
68 PremultipliedColorU8::from_rgba_unchecked(
69 premultiply_u8(self.red(), a),
70 premultiply_u8(self.green(), a),
71 premultiply_u8(self.blue(), a),
72 a,
73 )
74 } else {
75 PremultipliedColorU8::from_rgba_unchecked(self.red(), self.green(), self.blue(), a)
76 }
77 }
78}
79
80impl core::fmt::Debug for ColorU8 {
81 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
82 f&mut DebugStruct<'_, '_>.debug_struct("ColorU8")
83 .field("r", &self.red())
84 .field("g", &self.green())
85 .field("b", &self.blue())
86 .field(name:"a", &self.alpha())
87 .finish()
88 }
89}
90
91/// A 32-bit premultiplied RGBA color value.
92///
93/// Byteorder: RGBA (relevant for bytemuck casts)
94#[repr(transparent)]
95#[derive(Copy, Clone, PartialEq)]
96pub struct PremultipliedColorU8([u8; 4]);
97
98// Perfectly safe, since [u8; 4] is already Pod.
99unsafe impl bytemuck::Zeroable for PremultipliedColorU8 {}
100unsafe impl bytemuck::Pod for PremultipliedColorU8 {}
101
102impl PremultipliedColorU8 {
103 /// A transparent color.
104 pub const TRANSPARENT: Self = PremultipliedColorU8::from_rgba_unchecked(0, 0, 0, 0);
105
106 /// Creates a new premultiplied color.
107 ///
108 /// RGB components must be <= alpha.
109 pub fn from_rgba(r: u8, g: u8, b: u8, a: u8) -> Option<Self> {
110 if r <= a && g <= a && b <= a {
111 Some(PremultipliedColorU8([r, g, b, a]))
112 } else {
113 None
114 }
115 }
116
117 /// Creates a new color.
118 pub(crate) const fn from_rgba_unchecked(r: u8, g: u8, b: u8, a: u8) -> Self {
119 PremultipliedColorU8([r, g, b, a])
120 }
121
122 /// Returns color's red component.
123 ///
124 /// The value is <= alpha.
125 pub const fn red(self) -> u8 {
126 self.0[0]
127 }
128
129 /// Returns color's green component.
130 ///
131 /// The value is <= alpha.
132 pub const fn green(self) -> u8 {
133 self.0[1]
134 }
135
136 /// Returns color's blue component.
137 ///
138 /// The value is <= alpha.
139 pub const fn blue(self) -> u8 {
140 self.0[2]
141 }
142
143 /// Returns color's alpha component.
144 pub const fn alpha(self) -> u8 {
145 self.0[3]
146 }
147
148 /// Check that color is opaque.
149 ///
150 /// Alpha == 255
151 pub fn is_opaque(&self) -> bool {
152 self.alpha() == ALPHA_U8_OPAQUE
153 }
154
155 /// Returns a demultiplied color.
156 pub fn demultiply(&self) -> ColorU8 {
157 let alpha = self.alpha();
158 if alpha == ALPHA_U8_OPAQUE {
159 ColorU8(self.0)
160 } else {
161 let a = alpha as f64 / 255.0;
162 ColorU8::from_rgba(
163 (self.red() as f64 / a + 0.5) as u8,
164 (self.green() as f64 / a + 0.5) as u8,
165 (self.blue() as f64 / a + 0.5) as u8,
166 alpha,
167 )
168 }
169 }
170}
171
172impl core::fmt::Debug for PremultipliedColorU8 {
173 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
174 f&mut DebugStruct<'_, '_>.debug_struct("PremultipliedColorU8")
175 .field("r", &self.red())
176 .field("g", &self.green())
177 .field("b", &self.blue())
178 .field(name:"a", &self.alpha())
179 .finish()
180 }
181}
182
183/// An RGBA color value, holding four floating point components.
184///
185/// # Guarantees
186///
187/// - All values are in 0..=1 range.
188#[derive(Copy, Clone, PartialEq, Debug)]
189pub struct Color {
190 r: NormalizedF32,
191 g: NormalizedF32,
192 b: NormalizedF32,
193 a: NormalizedF32,
194}
195
196const NV_ZERO: NormalizedF32 = NormalizedF32::ZERO;
197const NV_ONE: NormalizedF32 = NormalizedF32::ONE;
198
199impl Color {
200 /// A transparent color.
201 pub const TRANSPARENT: Color = Color {
202 r: NV_ZERO,
203 g: NV_ZERO,
204 b: NV_ZERO,
205 a: NV_ZERO,
206 };
207 /// A black color.
208 pub const BLACK: Color = Color {
209 r: NV_ZERO,
210 g: NV_ZERO,
211 b: NV_ZERO,
212 a: NV_ONE,
213 };
214 /// A white color.
215 pub const WHITE: Color = Color {
216 r: NV_ONE,
217 g: NV_ONE,
218 b: NV_ONE,
219 a: NV_ONE,
220 };
221
222 /// Creates a new color from 4 components.
223 ///
224 /// All values must be in 0..=1 range.
225 pub fn from_rgba(r: f32, g: f32, b: f32, a: f32) -> Option<Self> {
226 Some(Color {
227 r: NormalizedF32::new(r)?,
228 g: NormalizedF32::new(g)?,
229 b: NormalizedF32::new(b)?,
230 a: NormalizedF32::new(a)?,
231 })
232 }
233
234 /// Creates a new color from 4 components.
235 ///
236 /// u8 will be divided by 255 to get the float component.
237 pub fn from_rgba8(r: u8, g: u8, b: u8, a: u8) -> Self {
238 Color {
239 r: NormalizedF32::new_u8(r),
240 g: NormalizedF32::new_u8(g),
241 b: NormalizedF32::new_u8(b),
242 a: NormalizedF32::new_u8(a),
243 }
244 }
245
246 /// Returns color's red component.
247 ///
248 /// The value is guarantee to be in a 0..=1 range.
249 pub fn red(&self) -> f32 {
250 self.r.get()
251 }
252
253 /// Returns color's green component.
254 ///
255 /// The value is guarantee to be in a 0..=1 range.
256 pub fn green(&self) -> f32 {
257 self.g.get()
258 }
259
260 /// Returns color's blue component.
261 ///
262 /// The value is guarantee to be in a 0..=1 range.
263 pub fn blue(&self) -> f32 {
264 self.b.get()
265 }
266
267 /// Returns color's alpha component.
268 ///
269 /// The value is guarantee to be in a 0..=1 range.
270 pub fn alpha(&self) -> f32 {
271 self.a.get()
272 }
273
274 /// Sets the red component value.
275 ///
276 /// The new value will be clipped to the 0..=1 range.
277 pub fn set_red(&mut self, c: f32) {
278 self.r = NormalizedF32::new_clamped(c);
279 }
280
281 /// Sets the green component value.
282 ///
283 /// The new value will be clipped to the 0..=1 range.
284 pub fn set_green(&mut self, c: f32) {
285 self.g = NormalizedF32::new_clamped(c);
286 }
287
288 /// Sets the blue component value.
289 ///
290 /// The new value will be clipped to the 0..=1 range.
291 pub fn set_blue(&mut self, c: f32) {
292 self.b = NormalizedF32::new_clamped(c);
293 }
294
295 /// Sets the alpha component value.
296 ///
297 /// The new value will be clipped to the 0..=1 range.
298 pub fn set_alpha(&mut self, c: f32) {
299 self.a = NormalizedF32::new_clamped(c);
300 }
301
302 /// Shifts color's opacity.
303 ///
304 /// Essentially, multiplies color's alpha by opacity.
305 ///
306 /// `opacity` will be clamped to the 0..=1 range first.
307 /// The final alpha will also be clamped.
308 pub fn apply_opacity(&mut self, opacity: f32) {
309 self.a = NormalizedF32::new_clamped(self.a.get() * opacity.bound(0.0, 1.0));
310 }
311
312 /// Check that color is opaque.
313 ///
314 /// Alpha == 1.0
315 pub fn is_opaque(&self) -> bool {
316 self.a == ALPHA_OPAQUE
317 }
318
319 /// Converts into a premultiplied color.
320 pub fn premultiply(&self) -> PremultipliedColor {
321 if self.is_opaque() {
322 PremultipliedColor {
323 r: self.r,
324 g: self.g,
325 b: self.b,
326 a: self.a,
327 }
328 } else {
329 PremultipliedColor {
330 r: NormalizedF32::new_clamped(self.r.get() * self.a.get()),
331 g: NormalizedF32::new_clamped(self.g.get() * self.a.get()),
332 b: NormalizedF32::new_clamped(self.b.get() * self.a.get()),
333 a: self.a,
334 }
335 }
336 }
337
338 /// Converts into `ColorU8`.
339 pub fn to_color_u8(&self) -> ColorU8 {
340 let c = color_f32_to_u8(self.r, self.g, self.b, self.a);
341 ColorU8::from_rgba(c[0], c[1], c[2], c[3])
342 }
343}
344
345/// A premultiplied RGBA color value, holding four floating point components.
346///
347/// # Guarantees
348///
349/// - All values are in 0..=1 range.
350/// - RGB components are <= A.
351#[derive(Copy, Clone, PartialEq, Debug)]
352pub struct PremultipliedColor {
353 r: NormalizedF32,
354 g: NormalizedF32,
355 b: NormalizedF32,
356 a: NormalizedF32,
357}
358
359impl PremultipliedColor {
360 /// Returns color's red component.
361 ///
362 /// - The value is guarantee to be in a 0..=1 range.
363 /// - The value is <= alpha.
364 pub fn red(&self) -> f32 {
365 self.r.get()
366 }
367
368 /// Returns color's green component.
369 ///
370 /// - The value is guarantee to be in a 0..=1 range.
371 /// - The value is <= alpha.
372 pub fn green(&self) -> f32 {
373 self.g.get()
374 }
375
376 /// Returns color's blue component.
377 ///
378 /// - The value is guarantee to be in a 0..=1 range.
379 /// - The value is <= alpha.
380 pub fn blue(&self) -> f32 {
381 self.b.get()
382 }
383
384 /// Returns color's alpha component.
385 ///
386 /// - The value is guarantee to be in a 0..=1 range.
387 pub fn alpha(&self) -> f32 {
388 self.a.get()
389 }
390
391 /// Returns a demultiplied color.
392 pub fn demultiply(&self) -> Color {
393 let a = self.a.get();
394 if a == 0.0 {
395 Color::TRANSPARENT
396 } else {
397 Color {
398 r: NormalizedF32::new_clamped(self.r.get() / a),
399 g: NormalizedF32::new_clamped(self.g.get() / a),
400 b: NormalizedF32::new_clamped(self.b.get() / a),
401 a: self.a,
402 }
403 }
404 }
405
406 /// Converts into `PremultipliedColorU8`.
407 pub fn to_color_u8(&self) -> PremultipliedColorU8 {
408 let c = color_f32_to_u8(self.r, self.g, self.b, self.a);
409 PremultipliedColorU8::from_rgba_unchecked(c[0], c[1], c[2], c[3])
410 }
411}
412
413/// Return a*b/255, rounding any fractional bits.
414pub fn premultiply_u8(c: u8, a: u8) -> u8 {
415 let prod: u32 = u32::from(c) * u32::from(a) + 128;
416 ((prod + (prod >> 8)) >> 8) as u8
417}
418
419fn color_f32_to_u8(
420 r: NormalizedF32,
421 g: NormalizedF32,
422 b: NormalizedF32,
423 a: NormalizedF32,
424) -> [u8; 4] {
425 [
426 (r.get() * 255.0 + 0.5) as u8,
427 (g.get() * 255.0 + 0.5) as u8,
428 (b.get() * 255.0 + 0.5) as u8,
429 (a.get() * 255.0 + 0.5) as u8,
430 ]
431}
432
433#[cfg(test)]
434mod tests {
435 use super::*;
436
437 #[test]
438 fn premultiply_u8() {
439 assert_eq!(
440 ColorU8::from_rgba(10, 20, 30, 40).premultiply(),
441 PremultipliedColorU8::from_rgba_unchecked(2, 3, 5, 40)
442 );
443 }
444
445 #[test]
446 fn premultiply_u8_opaque() {
447 assert_eq!(
448 ColorU8::from_rgba(10, 20, 30, 255).premultiply(),
449 PremultipliedColorU8::from_rgba_unchecked(10, 20, 30, 255)
450 );
451 }
452
453 #[test]
454 fn demultiply_u8_1() {
455 assert_eq!(
456 PremultipliedColorU8::from_rgba_unchecked(2, 3, 5, 40).demultiply(),
457 ColorU8::from_rgba(13, 19, 32, 40)
458 );
459 }
460
461 #[test]
462 fn demultiply_u8_2() {
463 assert_eq!(
464 PremultipliedColorU8::from_rgba_unchecked(10, 20, 30, 255).demultiply(),
465 ColorU8::from_rgba(10, 20, 30, 255)
466 );
467 }
468
469 #[test]
470 fn demultiply_u8_3() {
471 assert_eq!(
472 PremultipliedColorU8::from_rgba_unchecked(153, 99, 54, 180).demultiply(),
473 ColorU8::from_rgba(217, 140, 77, 180)
474 );
475 }
476
477 #[test]
478 fn bytemuck_casts_rgba() {
479 let slice = &[
480 PremultipliedColorU8::from_rgba_unchecked(0, 1, 2, 3),
481 PremultipliedColorU8::from_rgba_unchecked(10, 11, 12, 13),
482 ];
483 let bytes: &[u8] = bytemuck::cast_slice(slice);
484 assert_eq!(bytes, &[0, 1, 2, 3, 10, 11, 12, 13]);
485 }
486}
487