turbine_process3d 0.8.0

Processing for the Turbine game engine
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

//! Helper functions for colors.

use crate::{Rgb, Rgba};

#[inline(always)]
fn component_srgb_to_linear(f: f32) -> f32 {
    if f <= 0.04045 {
        f / 12.92
    } else {
        ((f + 0.055) / 1.055).powf(2.4)
    }
}

/// Converts gamma (brightness) from sRGB to linear color space.
///
/// sRGB is the default color space for image editors, pictures, internet etc.
/// Linear gamma yields better results when doing math with colors.
pub fn rgb_gamma_srgb_to_linear(c: Rgb) -> Rgb {
    [
        component_srgb_to_linear(c[0]),
        component_srgb_to_linear(c[1]),
        component_srgb_to_linear(c[2]),
    ]
}

/// Converts gamma (brightness) from sRGB to linear color space.
///
/// sRGB is the default color space for image editors, pictures, internet etc.
/// Linear gamma yields better results when doing math with colors.
pub fn rgba_gamma_srgb_to_linear(c: Rgba) -> Rgba {
    [
        component_srgb_to_linear(c[0]),
        component_srgb_to_linear(c[1]),
        component_srgb_to_linear(c[2]),
        c[3],
    ]
}

#[inline(always)]
fn component_linear_to_srgb(f: f32) -> f32 {
    if f <= 0.0031308 {
        f * 12.92
    } else {
        1.055 * f.powf(1.0 / 2.4) - 0.055
    }
}

/// Converts gamma (brightness) of a color from linear color space to sRGB.
///
/// sRGB is the default color space for image editors, pictures, internet etc.
/// Linear gamma yields better results when doing math with colors.
pub fn rgb_gamma_linear_to_srgb(c: Rgb) -> Rgb {
    [
        component_linear_to_srgb(c[0]),
        component_linear_to_srgb(c[1]),
        component_linear_to_srgb(c[2]),
    ]
}

/// Converts gamma (brightness) of a color from linear color space to sRGB.
///
/// sRGB is the default color space for image editors, pictures, internet etc.
/// Linear gamma yields better results when doing math with colors.
pub fn rgba_gamma_linear_to_srgb(c: Rgba) -> Rgba {
    [
        component_linear_to_srgb(c[0]),
        component_linear_to_srgb(c[1]),
        component_linear_to_srgb(c[2]),
        c[3],
    ]
}

/// Converts color to `f32` precision.
pub fn rgba_to_f32(a: Rgba<u8>) -> Rgba {
    [
        (a[0] as f32) / 255.0,
        (a[1] as f32) / 255.0,
        (a[2] as f32) / 255.0,
        (a[3] as f32) / 255.0,
    ]
}

/// Converts color to `u8` precision.
pub fn rgba_to_u8(a: Rgba) -> Rgba<u8> {
    [
        (a[0] * 255.0) as u8,
        (a[1] * 255.0) as u8,
        (a[2] * 255.0) as u8,
        (a[3] * 255.0) as u8,
    ]
}

/// Alpha blending over operation in linear color space.
pub fn rgba_alpha_blending_linear_over(a: Rgba, b: Rgba) -> Rgba {
    let alpha = a[3] + b[3] * (1.0 - a[3]);
    [
        a[0] * a[3] + b[0] * b[3] * (1.0 - a[3]),
        a[1] * a[3] + b[1] * b[3] * (1.0 - a[3]),
        a[2] * a[3] + b[2] * b[3] * (1.0 - a[3]),
        alpha,
    ]
}

/// Alpha blending over operation in sRGB color space.
pub fn rgba_alpha_blending_srgb_over(a: Rgba, b: Rgba) -> Rgba {
    let a = rgba_gamma_srgb_to_linear(a);
    let b = rgba_gamma_srgb_to_linear(b);
    rgba_gamma_linear_to_srgb(rgba_alpha_blending_linear_over(a, b))
}

/// Alpha blending over operation in sRGB color space with `u8` precision.
pub fn rgba_alpha_blending_srgb_over_u8(a: Rgba<u8>, b: Rgba<u8>) -> Rgba<u8> {
    rgba_to_u8(rgba_alpha_blending_srgb_over(rgba_to_f32(a), rgba_to_f32(b)))
}