dip 0.2.1

Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust.
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

use dip::{
    bevy::{
        log::{self, LogPlugin},
        time::TimePlugin,
    },
    prelude::*,
};

/// This example illustrates how to customize render setting
fn main() {
    App::new()
        .add_plugin(LogPlugin)
        .add_plugin(TimePlugin)
        .add_plugin(DesktopPlugin::<UiState, UiAction, NoAsyncAction>::new(Root))
        .add_plugin(UiStatePlugin)
        .add_plugin(UiActionPlugin)
        .add_system(increment_frame)
        .add_system(update_render_mode)
        .run();
}

#[allow(non_snake_case)]
fn Root(cx: Scope) -> Element {
    let window = use_window::<UiAction, NoAsyncAction>(&cx);

    let frame = use_read(&cx, FRAME);
    let render_mode = use_read(&cx, RENDER_MODE);

    cx.render(rsx! {
        h1 { "Window: Render Mode" }

        select {
            value: format_args!("{:?}", render_mode),
            onchange: |e| {
                log::trace!("onchange: {:#?}", e.value.as_str());
                match e.value.as_str() {
                    "Application" => { window.send(UiAction::application()) }
                    "Game" => { window.send(UiAction::game()) }
                    _ => {}
                }
            },
            option {
                value: "Application",
                "Application"
            }
            option {
                value: "Game",
                "Game"
            }
        }

        div {
            style: "background: #ddd; padding: 1rem;",
            p { [format_args!("Mode: {:?}", render_mode)] }
            p { [format_args!("Frame: {}", frame.value)] }
        }
    })
}

#[ui_state]
struct UiState {
    frame: Frame,
    render_mode: RenderMode,
}

#[ui_action]
impl ActionCreator {
    fn application() -> RenderMode {
        RenderMode::Application
    }

    fn game() -> RenderMode {
        RenderMode::Game
    }
}

#[derive(Clone, Debug, Default)]
pub struct Frame {
    value: u32,
}

#[derive(Clone, Debug)]
pub enum RenderMode {
    Application,
    Game,
}

impl Default for RenderMode {
    fn default() -> Self {
        Self::Application
    }
}

fn increment_frame(mut frame: ResMut<Frame>) {
    frame.value += 1;
    log::trace!("update_frame system: frame: {}", frame.value);
}

fn update_render_mode(
    mut actions: EventReader<RenderMode>,
    mut render_mode: ResMut<RenderMode>,
    mut desktop_settings: NonSendMut<DesktopSettings<NoRootProps>>,
) {
    for mode in actions.iter() {
        *render_mode = mode.clone();
        *desktop_settings = match mode {
            RenderMode::Application => DesktopSettings::application(),
            RenderMode::Game => DesktopSettings::game(),
        };
    }
}