devotee 0.2.0-beta.32

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

use devotee::input::winit_input::KeyboardMouse;
use devotee::util::vector::Vector;
use devotee::visual::adapter::CopyConverter;
use devotee::visual::adapter::generic::Adapter;
use devotee::visual::{Paint, Painter};
use devotee_backend::Middleware;
use devotee_backend::middling::InputHandler;
use devotee_backend_pixels::{
    Error, PixelsBackend, PixelsContext, PixelsEvent, PixelsEventContext, PixelsEventControl,
    PixelsInit, PixelsSurface,
};
use winit::keyboard::KeyCode;

fn main() -> Result<(), Error> {
    let basic = Basic::default();
    let mut backend = PixelsBackend::new(basic);

    backend.run()
}

#[derive(Default)]
pub struct Basic {
    input: KeyboardMouse,
    position: Option<Vector<i32>>,
}

impl
    Middleware<
        PixelsInit<'_>,
        PixelsContext<'_>,
        PixelsSurface<'_, '_>,
        PixelsEvent,
        PixelsEventContext<'_, '_>,
        PixelsEventControl<'_>,
    > for Basic
{
    fn on_init(&mut self, init: &mut PixelsInit<'_>) {
        init.set_render_window_size(160, 120);
        init.window().set_title("Basic demo: press ESC to exit");
    }

    fn on_update(&mut self, context: &mut PixelsContext<'_>) {
        self.position = self.input.mouse().position();

        if self.input.keyboard().just_pressed(KeyCode::Escape) {
            context.shutdown();
        }

        InputHandler::<_, PixelsEventContext>::update(&mut self.input);
    }

    fn on_render(&mut self, surface: &mut PixelsSurface<'_, '_>) {
        let converter = CopyConverter::new();
        let mut adapter = Adapter::new(surface, &converter);

        let mut painter = Painter::new(&mut adapter);
        painter.clear([0x20, 0x40, 0x60, 0xff]);

        if let Some(position) = self.position {
            painter.line((0, 0).into(), position, &[0xff, 0xff, 0xff, 0xff]);
            painter.line(
                (159, 119).into(),
                position,
                &mut |_, [r, g, b, a]: [u8; 4]| [b, r, g, a],
            );
            painter.mod_pixel((80, 60).into(), &[0xff, 0x00, 0x00, 0xff]);
            painter.line((80, 60).into(), position, &[0x00, 0x00, 0x00, 0xff]);
        }
    }

    fn on_event(
        &mut self,
        event: PixelsEvent,
        event_context: &PixelsEventContext<'_, '_>,
        _: &mut PixelsEventControl<'_>,
    ) -> Option<PixelsEvent> {
        if let PixelsEvent::Window(window_event) = event {
            self.input
                .handle_event(window_event, event_context)
                .map(PixelsEvent::Window)
        } else {
            Some(event)
        }
    }
}