devotee 0.2.0-beta.33

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

use backend::middling::Surface;
use ugly_graphics::{image, strategy};

/// An adapter that wraps [`Surface`] to provide [`Image`](`image::Image`) and
/// [`ImageMut`](`image::ImageMut`) traits.
pub struct SurfaceAdapter<'a, P> {
    surface: &'a mut dyn Surface<Texel = P>,
}

impl<'a, P> SurfaceAdapter<'a, P> {
    /// Create new [`SurfaceAdapter`] instance.
    pub fn new(surface: &'a mut dyn Surface<Texel = P>) -> Self {
        Self { surface }
    }
}

impl<P> image::Dimensions for SurfaceAdapter<'_, P> {
    fn dimensions(&self) -> (u32, u32) {
        (self.surface.width(), self.surface.height())
    }
}

impl<P> image::Image for SurfaceAdapter<'_, P> {
    type Pixel = P;

    fn pixel(&self, (x, y): (u32, u32)) -> Option<Self::Pixel> {
        self.surface.texel(x, y)
    }
}

impl<P> image::ImageMut for SurfaceAdapter<'_, P>
where
    P: Clone,
{
    type Pixel = P;

    fn set_pixel(&mut self, (x, y): (u32, u32), value: Self::Pixel) {
        self.surface.set_texel(x, y, value);
    }

    fn modify_pixel(&mut self, (x, y): (u32, u32), function: strategy::Modify<Self::Pixel>) {
        if let Some(texel) = self.surface.texel(x, y) {
            self.surface.set_texel(x, y, (function)(texel));
        }
    }

    fn set_horizontal_line(&mut self, (x, y): (u32, u32), total: u32, value: Self::Pixel) {
        for x in x..x + total {
            self.set_pixel((x, y), value.clone());
        }
    }

    fn modify_horizontal_line(
        &mut self,
        (x, y): (u32, u32),
        total: u32,
        function: strategy::Modify<Self::Pixel>,
    ) {
        for x in x..x + total {
            self.modify_pixel((x, y), function);
        }
    }

    fn set(&mut self, value: Self::Pixel) {
        self.surface.clear(value);
    }

    fn modify(&mut self, function: strategy::Modify<Self::Pixel>) {
        for y in 0..self.surface.height() {
            for x in 0..self.surface.width() {
                self.modify_pixel((x, y), function);
            }
        }
    }
}