vger 0.4.0

2D GPU renderer for dynamic UIs
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
115
116
117
118
119

use crate::color::*;
use crate::defs::*;

#[derive(Clone, Copy)]
#[repr(C)]
pub struct Paint {
    xform: LocalTransform, // mat3x2<f32>

    glow: f32,
    pub image: i32,

    inner_color: Color, // vec4<f32>
    outer_color: Color, // vec4<f32>
}

impl Paint {
    #[allow(dead_code)]
    pub fn apply(&self, p: LocalPoint) -> Color {
        let local_point = self.xform.transform_point(p);
        let d = local_point
            .clamp(LocalPoint::zero(), LocalPoint::new(1.0, 1.0))
            .x;

        self.inner_color.mix(self.outer_color, d)
    }

    pub fn solid_color(color: Color) -> Self {
        Self {
            xform: LocalTransform::identity(),
            inner_color: color,
            outer_color: color,
            image: -1,
            glow: 0.0,
        }
    }

    pub fn linear_gradient(
        start: LocalPoint,
        end: LocalPoint,
        inner_color: Color,
        outer_color: Color,
        glow: f32,
    ) -> Self {
        // Calculate transform aligned to the line
        let mut d = end - start;
        if d.length() < 0.0001 {
            d = LocalVector::new(0.0, 1.0);
        }

        let xform = LocalTransform::new(d.x, d.y, -d.y, d.x, start.x, start.y)
            .inverse()
            .unwrap();

        Self {
            xform,
            inner_color,
            outer_color,
            image: -1,
            glow,
        }
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_paint_size() {
        assert_eq!(std::mem::size_of::<Paint>(), 64);
    }

    #[test]
    fn test_linear_gradient() {
        {
            let paint = Paint::linear_gradient(
                LocalPoint::new(0.0, 0.0),
                LocalPoint::new(1.0, 0.0),
                Color::gray(0.0),
                Color::gray(1.0),
                0.0,
            );

            assert_eq!(paint.apply(LocalPoint::new(0.0, 0.0)), Color::gray(0.0));
            assert_eq!(paint.apply(LocalPoint::new(0.5, 0.0)), Color::gray(0.5));
            assert_eq!(paint.apply(LocalPoint::new(1.0, 0.0)), Color::gray(1.0));
        }

        {
            let paint = Paint::linear_gradient(
                LocalPoint::new(0.0, 0.0),
                LocalPoint::new(0.0, 1.0),
                Color::gray(0.0),
                Color::gray(1.0),
                0.0,
            );

            assert_eq!(paint.apply(LocalPoint::new(0.0, 0.0)), Color::gray(0.0));
            assert_eq!(paint.apply(LocalPoint::new(0.0, 1.0)), Color::gray(1.0));
        }

        {
            let paint = Paint::linear_gradient(
                LocalPoint::new(1.0, 0.0),
                LocalPoint::new(2.0, 0.0),
                Color::gray(0.0),
                Color::gray(1.0),
                0.0,
            );

            assert_eq!(paint.apply(LocalPoint::new(0.0, 0.0)), Color::gray(0.0));
            assert_eq!(paint.apply(LocalPoint::new(1.0, 0.0)), Color::gray(0.0));
            assert_eq!(paint.apply(LocalPoint::new(1.5, 0.0)), Color::gray(0.5));
            assert_eq!(paint.apply(LocalPoint::new(2.0, 0.0)), Color::gray(1.0));
            assert_eq!(paint.apply(LocalPoint::new(3.0, 0.0)), Color::gray(1.0));
        }
    }
}