mirui 0.9.2

A lightweight, no_std ECS-driven UI framework for embedded, desktop, and WebAssembly
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

use mirui::draw::texture::{ColorFormat, Texture};
use mirui::draw::{DrawCommand, Renderer, SwRenderer};
use mirui::types::{Color, Fixed, Rect, Transform};
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::pixels::PixelFormatEnum;

const W: u32 = 480;
const H: u32 = 320;

fn main() {
    let sdl = sdl2::init().unwrap();
    let video = sdl.video().unwrap();
    let window = video
        .window("mirui - hello", W, H)
        .position_centered()
        .build()
        .unwrap();
    let mut canvas = window.into_canvas().build().unwrap();
    let texture_creator = canvas.texture_creator();
    let mut texture = texture_creator
        .create_texture_streaming(PixelFormatEnum::RGBA32, W, H)
        .unwrap();

    let mut buf = vec![0u8; (W * H * 4) as usize];
    let clip = Rect {
        x: Fixed::ZERO,
        y: Fixed::ZERO,
        w: Fixed::from_int(W as i32),
        h: Fixed::from_int(H as i32),
    };

    // Draw with mirui's SwRenderer
    let mut renderer = SwRenderer::new(Texture::new(
        &mut buf,
        W as u16,
        H as u16,
        ColorFormat::ARGB8888,
    ));

    // Background
    renderer.draw(
        &DrawCommand::Fill {
            area: Rect {
                x: Fixed::ZERO,
                y: Fixed::ZERO,
                w: Fixed::from_int(W as i32),
                h: Fixed::from_int(H as i32),
            },
            transform: Transform::IDENTITY,
            quad: None,
            color: Color::rgb(30, 30, 46),
            radius: Fixed::ZERO,
            opa: 255,
        },
        &clip,
    );

    // Blue rectangle
    renderer.draw(
        &DrawCommand::Fill {
            area: Rect {
                x: Fixed::from_int(40),
                y: Fixed::from_int(40),
                w: Fixed::from_int(200),
                h: Fixed::from_int(120),
            },
            transform: Transform::IDENTITY,
            quad: None,
            color: Color::rgb(88, 166, 255),
            radius: Fixed::ZERO,
            opa: 255,
        },
        &clip,
    );

    // Green rectangle
    renderer.draw(
        &DrawCommand::Fill {
            area: Rect {
                x: Fixed::from_int(140),
                y: Fixed::from_int(100),
                w: Fixed::from_int(200),
                h: Fixed::from_int(120),
            },
            transform: Transform::IDENTITY,
            quad: None,
            color: Color::rgb(63, 185, 80),
            radius: Fixed::ZERO,
            opa: 200,
        },
        &clip,
    );

    // Red rectangle
    renderer.draw(
        &DrawCommand::Fill {
            area: Rect {
                x: Fixed::from_int(240),
                y: Fixed::from_int(160),
                w: Fixed::from_int(200),
                h: Fixed::from_int(120),
            },
            transform: Transform::IDENTITY,
            quad: None,
            color: Color::rgb(248, 81, 73),
            radius: Fixed::ZERO,
            opa: 180,
        },
        &clip,
    );

    renderer.flush();

    // Blit to SDL
    texture.update(None, &buf, (W * 4) as usize).unwrap();
    canvas.copy(&texture, None, None).unwrap();
    canvas.present();

    // Event loop
    let mut event_pump = sdl.event_pump().unwrap();
    'running: loop {
        for event in event_pump.poll_iter() {
            match event {
                Event::Quit { .. }
                | Event::KeyDown {
                    keycode: Some(Keycode::Escape),
                    ..
                } => break 'running,
                _ => {}
            }
        }
        std::thread::sleep(std::time::Duration::from_millis(16));
    }
}