bevy_dexterous_developer_library 0.3.0

A modular hot reload system for 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
112
113
114
115
116
117
118
119
120
121
122

use super::types::*;
use bevy::{
    prelude::{App, OnEnter, OnExit, Startup},
    state::app::AppExtStates,
};

pub struct ReloadableAppContents<'a>(&'a mut App);

impl ReloadableElementsSetup for bevy::app::App {
    fn setup_reloadable_elements<T: super::ReloadableSetup>(&mut self) -> &mut Self {
        {
            let mut contents = ReloadableAppContents(self);
            T::default_function(&mut contents);
        }
        self
    }
}

impl<'a> private::ReloadableAppSealed for ReloadableAppContents<'a> {}

impl<'a> ReloadableApp for ReloadableAppContents<'a> {
    fn add_systems<M, L: bevy::ecs::schedule::ScheduleLabel + Eq + std::hash::Hash + Clone>(
        &mut self,
        schedule: L,
        systems: impl bevy::prelude::IntoSystemConfigs<M>,
    ) -> &mut Self {
        self.0.add_systems(schedule, systems);
        self
    }

    fn register_serializable_resource<R: bevy::prelude::Resource + ReplacableType>(
        &mut self,
    ) -> &mut Self {
        self
    }

    fn init_serializable_resource<R: ReplacableType + bevy::prelude::Resource + Default>(
        &mut self,
    ) -> &mut Self {
        self.0.init_resource::<R>();
        self
    }

    fn insert_serializable_resource<R: ReplacableType + bevy::prelude::Resource>(
        &mut self,
        value: R,
    ) -> &mut Self {
        self.0.insert_resource(value);
        self
    }

    fn reset_resource<R: bevy::prelude::Resource + Default>(&mut self) -> &mut Self {
        self.0.init_resource::<R>();
        self
    }

    fn reset_resource_to_value<R: bevy::prelude::Resource>(&mut self, value: R) -> &mut Self {
        self.0.insert_resource(value);
        self
    }

    fn register_serializable_component<C: super::ReplacableType + bevy::prelude::Component>(
        &mut self,
    ) -> &mut Self {
        self
    }

    fn clear_marked_on_reload<C: bevy::prelude::Component>(&mut self) -> &mut Self {
        self
    }

    fn reset_setup<C: bevy::prelude::Component, M>(
        &mut self,
        systems: impl bevy::prelude::IntoSystemConfigs<M>,
    ) -> &mut Self {
        self.0.add_systems(Startup, systems);
        self
    }

    fn reset_setup_in_state<C: bevy::prelude::Component, S: bevy::prelude::States, M>(
        &mut self,
        state: S,
        systems: impl bevy::prelude::IntoSystemConfigs<M>,
    ) -> &mut Self {
        self.0
            .add_systems(OnEnter(state.clone()), systems)
            .add_systems(OnExit(state), clear_marked_system::<C>);
        self
    }

    fn add_event<T: bevy::prelude::Event>(&mut self) -> &mut Self {
        self.0.add_event::<T>();
        self
    }

    fn insert_state<S: bevy::state::state::FreelyMutableState + ReplacableType>(
        &mut self,
        state: S,
    ) -> &mut Self {
        self.0.insert_state::<S>(state);
        self
    }

    fn add_sub_state<S: bevy::state::state::SubStates + ReplacableType>(&mut self) -> &mut Self {
        self.0.add_sub_state::<S>();
        self
    }

    fn add_computed_state<S: bevy::state::state::ComputedStates + ReplacableType>(
        &mut self,
    ) -> &mut Self {
        self.0.add_computed_state::<S>();
        self
    }

    fn enable_state_scoped_entities<S: bevy::state::state::States + ReplacableType>(
        &mut self,
    ) -> &mut Self {
        self.0.enable_state_scoped_entities::<S>();
        self
    }
}