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

use devotee::app;
use devotee::app::config;
use devotee::app::context::Context;
use devotee::app::input::key_mouse::{KeyMouse, VirtualKeyCode};
use devotee::app::root::Root;
use devotee::app::setup;
use devotee::util::vector::Vector;
use devotee::visual::canvas::Canvas;
use devotee::visual::color;
use devotee::visual::prelude::*;
use devotee_backend_softbuffer::SoftbufferBackend;

const BOX_BOUNDARIES: (i32, i32) = (16, 128 - 16);
const INTERNAL_RADIUS: i32 = 8;

fn main() {
    let init_config = setup::Builder::<Config>::new()
        .with_render_target(Canvas::with_resolution(Default::default(), 128, 128))
        .with_input(Default::default())
        .with_root_constructor(|_| Default::default())
        .with_title("minimal")
        .with_scale(2);
    let app = app::App::<_, SoftbufferBackend>::with_setup(init_config).unwrap();

    app.run();
}

struct Config;

impl config::Config for Config {
    type Root = Minimal;
    type Converter = Converter;
    type Input = KeyMouse;
    type RenderTarget = Canvas<Color>;

    fn converter() -> Self::Converter {
        Converter
    }

    fn background_color() -> Color {
        Color([0x00, 0x00, 0x80])
    }
}

#[derive(Default)]
struct Minimal {
    position: Vector<i32>,
}

impl Root<Config> for Minimal {
    fn update(&mut self, update: &mut Context<Config>) {
        if update.input().keys().just_pressed(VirtualKeyCode::Escape) {
            update.shutdown();
        }

        if let Some(pos) = update.input().mouse().position() {
            *self.position.x_mut() = pos.x().clamp(
                BOX_BOUNDARIES.0 + INTERNAL_RADIUS,
                BOX_BOUNDARIES.1 - INTERNAL_RADIUS - 1,
            );
            *self.position.y_mut() = pos.y().clamp(
                BOX_BOUNDARIES.0 + INTERNAL_RADIUS,
                BOX_BOUNDARIES.1 - INTERNAL_RADIUS - 1,
            );
        }
    }

    fn render(&self, render: &mut Canvas<Color>) {
        let mut render = render.painter();

        render.clear(Color([0x00, 0x00, 0x80]));

        render.rect(
            (BOX_BOUNDARIES.0, BOX_BOUNDARIES.0),
            (BOX_BOUNDARIES.1, BOX_BOUNDARIES.1),
            paint(Color([0xff, 0xff, 0xff])),
        );
        render.circle_f(
            self.position,
            INTERNAL_RADIUS,
            paint(Color([0x80, 0x80, 0x80])),
        );
        render.line(
            (64, 64).into(),
            self.position,
            paint(Color([0xff, 0xff, 0xff])),
        );
        render.line(
            self.position,
            (64, 64).into(),
            paint(Color([0x00, 0xff, 0x00])),
        );
        render.mod_pixel((64, 64), paint(Color([0xff, 0x00, 0x00])));
        render.mod_pixel(self.position, paint(Color([0xff, 0x00, 0x00])));
    }
}

#[derive(Clone, Copy, Default)]
struct Color([u8; 3]);

struct Converter;

impl color::Converter for Converter {
    type Palette = Color;
    fn convert(&self, color: &Self::Palette) -> u32 {
        ((color.0[0] as u32) << 16) | ((color.0[1] as u32) << 8) | (color.0[2] as u32)
    }
}