raui 0.70.17

Renderer Agnostic User Interface
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

// Make sure you have seen `render_workers` code example first, because this is an evolution of that.

use raui_app::{
    Vertex,
    app::declarative::DeclarativeApp,
    components::canvas::{CanvasProps, DrawOnCanvasMessage, RequestCanvasRedrawMessage, canvas},
    render_worker::RenderWorkerTaskContext,
    third_party::spitfire_glow::{
        graphics::GraphicsBatch,
        renderer::{GlowBlending, GlowUniformValue},
    },
};
use raui_core::{
    make_widget, pre_hooks,
    widget::{context::WidgetContext, node::WidgetNode, utils::Color},
};

fn use_my_canvas(ctx: &mut WidgetContext) {
    ctx.life_cycle.change(|ctx| {
        // canvas will send redraw request on mount and resize.
        // we can react with sending drawing task message to canvas.
        for msg in ctx.messenger.messages {
            if msg
                .as_any()
                .downcast_ref::<RequestCanvasRedrawMessage>()
                .is_some()
            {
                ctx.messenger.write(
                    ctx.id.to_owned(),
                    DrawOnCanvasMessage::function(render_task),
                );
            }
        }
    });
}

#[pre_hooks(use_my_canvas)]
fn my_canvas(mut ctx: WidgetContext) -> WidgetNode {
    // we are specializing canvas widget by simply executing canvas
    // widget function in place, so we have easier times sending
    // drawing task to canvas by its id.
    canvas(ctx)
}

fn main() {
    let tree = make_widget!(my_canvas).with_props(CanvasProps {
        color: Color {
            r: 0.0,
            g: 0.0,
            b: 0.0,
            a: 0.5,
        },
        clear: true,
    });

    DeclarativeApp::simple("Canvas", tree);
}

fn render_task(ctx: RenderWorkerTaskContext) {
    ctx.graphics.state.stream.batch_optimized(GraphicsBatch {
        shader: Some(ctx.colored_shader.clone()),
        uniforms: [(
            "u_projection_view".into(),
            GlowUniformValue::M4(
                ctx.graphics
                    .state
                    .main_camera
                    .world_matrix()
                    .into_col_array(),
            ),
        )]
        .into_iter()
        .collect(),
        textures: Default::default(),
        blending: GlowBlending::Alpha,
        scissor: None,
        wireframe: false,
    });
    ctx.graphics.state.stream.quad([
        Vertex {
            position: [50.0, 50.0],
            uv: [0.0, 0.0, 0.0],
            color: [1.0, 0.0, 0.0, 1.0],
        },
        Vertex {
            position: [ctx.graphics.state.main_camera.screen_size.x - 50.0, 50.0],
            uv: [0.0, 0.0, 0.0],
            color: [0.0, 1.0, 0.0, 1.0],
        },
        Vertex {
            position: [
                ctx.graphics.state.main_camera.screen_size.x - 50.0,
                ctx.graphics.state.main_camera.screen_size.y - 50.0,
            ],
            uv: [0.0, 0.0, 0.0],
            color: [0.0, 0.0, 1.0, 1.0],
        },
        Vertex {
            position: [50.0, ctx.graphics.state.main_camera.screen_size.y - 50.0],
            uv: [0.0, 0.0, 0.0],
            color: [1.0, 1.0, 0.0, 1.0],
        },
    ]);
}