bevy_dioxus_sync 0.1.0

Top crate for bevy-dioxus interop through syncronization
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

use std::collections::HashMap;

// use crate::hooks::one_component_kind::hook::BevyComponentsSignals;
use crate::{
    panels::{DioxusPanel, PanelUpdateKind},
    plugins::DioxusAppKind,
};
use async_std::task::sleep;
use bevy_dioxus_hooks::{
    asset::BevyAssetsRegistry, component::component_single::hook::BevyComponentsRegistry,
    resource::hook::ResourceRegistry,
};
use bevy_dioxus_interop::{BevyCommandQueueTx, InfoRefershRateMS};
use bevy_ecs::entity::Entity;
use dioxus_core::Element;
use dioxus_core_macro::rsx;
use dioxus_hooks::{use_context_provider, use_future};
use dioxus_signals::*;

#[derive(Clone, Default)]
pub struct DioxusPanels(pub Signal<HashMap<Entity, DioxusPanel>>);

pub enum AppKind {}

pub fn dioxus_app(app_kind: DioxusAppKind) -> Element {
    let props = match app_kind {
        DioxusAppKind::NativeBevy(bevy_props) => {
            let dioxus_props = bevy_props.dioxus_props.clone();
            let update_frequency = 1000;
            let register_updates = use_context_provider(|| bevy_props.clone());
            let mut dioxus_panels = use_context_provider(|| DioxusPanels::default());

            let _command_queue_tx =
                use_context_provider(|| BevyCommandQueueTx(bevy_props.command_queues_tx.clone()));
            use_future(move || {
                {
                    let value = register_updates.dioxus_panel_updates.clone();
                    async move {
                        loop {
                            // Update UI every 1s in this demo.
                            sleep(std::time::Duration::from_millis(update_frequency)).await;

                            while let Ok(messages) = value.try_recv() {
                                let mut dioxus_panels = dioxus_panels.0.write();
                                for update in messages.0 {
                                    match update.value {
                                        PanelUpdateKind::Add(dioxus_panel) => {
                                            dioxus_panels.insert(update.key, dioxus_panel);
                                        }
                                        PanelUpdateKind::Remove => {
                                            dioxus_panels.remove(&update.key);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            });
            dioxus_props
        }
        DioxusAppKind::NativeOnly(props) => props,
    };
    let refresh_rate_ms = 1000 / props.fps.clone();

    let _info_refresh_rate = use_context_provider(|| InfoRefershRateMS(refresh_rate_ms.into()));

    let main_window_ui = props.main_window_ui.clone();

    let _resource_registers = use_context_provider(|| ResourceRegistry::default());
    // let component_signals = use_context_provider(|| BevyComponentsSignals::default());
    // let _asset_singletons = use_context_provider(|| BevyAssetsSignals::default());
    let _asset_registers = use_context_provider(|| BevyAssetsRegistry::default());
    let _component_registers = use_context_provider(|| BevyComponentsRegistry::default());

    rsx! {
        {main_window_ui.map(|n| n())},
        // for (_, panel_kind) in dioxus_panels.0.read().clone() {
        //     {panel_kind.element_marker.as_ref().element()}
        // }
    }
}