birdy 0.1.10

Screenshot tool
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

use crate::point::Point;

pub fn draw_triangle_filled(
    canvas: &mut [u8],
    a: (usize, usize),
    b: (usize, usize),
    c: (usize, usize),
    width: usize,
    color: (u8, u8, u8, u8),
) {
    let mut vs = [a, b, c];
    vs.sort_by(|a, b| a.1.cmp(&b.1));

    let total_height = vs[2].1 - vs[0].1;
    for i in 0..total_height {
        let second_half = i > vs[1].1 - vs[0].1 || vs[1].1 == vs[0].1;

        let segment_height = if second_half {
            vs[2].1 - vs[1].1
        } else {
            vs[1].1 - vs[0].1 + 1
        };

        let alpha = i as f64 / total_height as f64;

        let beta = (i as f64
            - (if second_half {
                vs[1].1 as f64 - vs[0].1 as f64
            } else {
                0 as f64
            }))
            / segment_height as f64;

        // TODO(kakoc): refactor ugly
        let a = {
            let _two = Point {
                x: vs[2].0 as i32,
                y: vs[2].1 as i32,
            };
            let _zero = Point {
                x: vs[0].0 as i32,
                y: vs[0].1 as i32,
            };
            let s = _two - _zero;
            Into::<Point<f64>>::into(_zero)
                + ((Point::<f64> {
                    x: s.x.into(),
                    y: s.y.into(),
                }) * alpha)
        };

        let b = {
            if second_half {
                let _two = Point {
                    x: vs[2].0 as i32,
                    y: vs[2].1 as i32,
                };
                let _one = Point {
                    x: vs[1].0 as i32,
                    y: vs[1].1 as i32,
                };
                let s = _two - _one;
                Into::<Point<f64>>::into(_one)
                    + ((Point::<f64> {
                        x: s.x.into(),
                        y: s.y.into(),
                    }) * beta)
            } else {
                let _one = Point {
                    x: vs[1].0 as i32,
                    y: vs[1].1 as i32,
                };
                let _zero = Point {
                    x: vs[0].0 as i32,
                    y: vs[0].1 as i32,
                };
                let s = _one - _zero;
                Into::<Point<f64>>::into(_zero)
                    + ((Point::<f64> {
                        x: s.x.into(),
                        y: s.y.into(),
                    }) * beta)
            }
        };

        let (a, b) = if a.x > b.x { (b, a) } else { (a, b) };

        for j in a.x as usize..=b.x as usize {
            let red = color.0;
            let green = color.1;
            let blue = color.2;
            let alpha = color.3;

            canvas[(vs[0].1 + i) * (width * 4) + (j * 4)] = red;
            canvas[((vs[0].1 + i) * (width * 4) + (j * 4)) + 1] = green;
            canvas[((vs[0].1 + i) * (width * 4) + (j * 4)) + 2] = blue;
            canvas[((vs[0].1 + i) * (width * 4) + (j * 4)) + 3] = alpha;
        }
    }
}