devotee 0.1.47

Visualization 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
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
146

use devotee_backend::BackendImage;

use super::{Image, PixelsIterator};
use crate::util::vector::Vector;

/// Sprite of fixed dimensions.
#[derive(Clone, Copy, Debug)]
pub struct Sprite<P, const W: usize, const H: usize> {
    data: [[P; W]; H],
}

impl<P, const W: usize, const H: usize> Sprite<P, W, H>
where
    P: Copy,
{
    /// Create new Sprite with given color for each pixel.
    pub const fn with_color(color: P) -> Self {
        let data = [[color; W]; H];
        Self { data }
    }

    /// Create new Sprite with given data.
    pub const fn with_data(data: [[P; W]; H]) -> Self {
        Self { data }
    }
}

impl<P, const W: usize, const H: usize> Image for Sprite<P, W, H>
where
    P: Copy,
{
    type Pixel = P;
    type PixelRef<'a> = &'a P where P:'a;
    type PixelMut<'a> = &'a mut P where P:'a;
    fn pixel(&self, position: Vector<i32>) -> Option<&P> {
        if position.x() < 0 || position.y() < 0 {
            return None;
        }
        let (x, y) = (position.x() as usize, position.y() as usize);
        if x >= W || y >= H {
            None
        } else {
            Some(&self.data[y][x])
        }
    }

    fn pixel_mut(&mut self, position: Vector<i32>) -> Option<&mut P> {
        if position.x() < 0 || position.y() < 0 {
            return None;
        }
        let (x, y) = (position.x() as usize, position.y() as usize);
        if x >= W || y >= H {
            None
        } else {
            Some(&mut self.data[y][x])
        }
    }

    unsafe fn unsafe_pixel(&self, position: Vector<i32>) -> &P {
        let (x, y) = (position.x() as usize, position.y() as usize);
        &self.data[y][x]
    }

    unsafe fn unsafe_pixel_mut(&mut self, position: Vector<i32>) -> &mut P {
        let (x, y) = (position.x() as usize, position.y() as usize);
        &mut self.data[y][x]
    }

    fn width(&self) -> i32 {
        W as i32
    }

    fn height(&self) -> i32 {
        H as i32
    }

    fn clear(&mut self, color: P) {
        self.data = [[color; W]; H];
    }
}

impl<P, const W: usize, const H: usize> Default for Sprite<P, W, H>
where
    P: Default + Copy,
{
    fn default() -> Self {
        Self::with_color(Default::default())
    }
}

impl<'a, P: 'a, const W: usize, const H: usize> PixelsIterator<'a, P> for Sprite<P, W, H>
where
    P: Copy,
{
    type Iterator = SpriteIter<'a, P, W, H>;

    fn pixels(&'a self) -> Self::Iterator {
        SpriteIter {
            sprite: self,
            index: 0,
        }
    }
}

/// An Iterator over pixels in a sprite, left to right, top to bottom.
pub struct SpriteIter<'a, P, const W: usize, const H: usize> {
    sprite: &'a Sprite<P, W, H>,
    index: usize,
}

impl<'a, P, const W: usize, const H: usize> Iterator for SpriteIter<'a, P, W, H> {
    type Item = &'a P;

    fn next(&mut self) -> Option<Self::Item> {
        let current = self.index;
        if current < W * H {
            self.index += 1;
            Some(&self.sprite.data[current / W][current % W])
        } else {
            None
        }
    }
}

impl<'a, P: 'a, const W: usize, const H: usize> BackendImage<'a, P> for Sprite<P, W, H>
where
    P: Copy,
{
    type Iterator = SpriteIter<'a, P, W, H>;

    unsafe fn pixel_unsafe(&self, x: u32, y: u32) -> &P {
        Image::unsafe_pixel(self, Vector::new(x as i32, y as i32))
    }

    fn width(&self) -> u32 {
        W as u32
    }

    fn height(&self) -> u32 {
        H as u32
    }

    fn pixels(&'a self) -> Self::Iterator {
        PixelsIterator::pixels(self)
    }
}