rfw 0.2.0

Rendering framework for implementing new rendering algorithms and creating graphics applications.
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

use crate::schedule::RunOnce;
use crate::{ecs::schedule::SystemDescriptor, Instance};
pub use bevy_ecs::{prelude::*, *};
pub use bevy_tasks::ComputeTaskPool;

pub trait Bundle {
    fn init(self, instance: &mut Instance);
}

pub trait Plugin: Send + Sync {
    fn init(&mut self, instance: &mut crate::Instance);
}

pub struct Scheduler {
    schedule: Schedule,
}

impl std::fmt::Debug for Scheduler {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Scheduler").finish()
    }
}

impl Default for Scheduler {
    fn default() -> Self {
        let mut schedule: Schedule = Default::default();
        schedule.add_stage(
            CoreStage::Startup,
            Schedule::default()
                .with_run_criteria(RunOnce::default())
                .with_stage(StartupStage::PreStartup, SystemStage::parallel())
                .with_stage(StartupStage::Startup, SystemStage::parallel())
                .with_stage(StartupStage::PostStartup, SystemStage::parallel()),
        );
        schedule.add_stage(CoreStage::PreUpdate, SystemStage::parallel());
        schedule.add_stage(CoreStage::Update, SystemStage::parallel());
        schedule.add_stage(CoreStage::PostUpdate, SystemStage::parallel());

        Self { schedule }
    }
}

/// The names of the default App startup stages
#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
pub enum StartupStage {
    /// Name of app stage that runs once before the startup stage
    PreStartup,
    /// Name of app stage that runs once when an app starts up
    Startup,
    /// Name of app stage that runs once after the startup stage
    PostStartup,
}

/// The names of the default App stages
#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
pub enum CoreStage {
    /// Runs once at the beginning of the app.
    Startup,
    /// Name of app stage that runs before all other app stages
    /// Name of app stage responsible for performing setup before an update. Runs before UPDATE.
    PreUpdate,
    /// Name of app stage responsible for doing most app logic. Systems should be registered here
    /// by default.
    Update,
    /// Name of app stage responsible for processing the results of UPDATE. Runs after UPDATE.
    PostUpdate,
}

#[allow(dead_code)]
impl Scheduler {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn add_startup_system(
        &mut self,
        stage_label: impl StageLabel,
        system: impl Into<SystemDescriptor>,
    ) {
        self.schedule
            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
                schedule.add_system_to_stage(stage_label, system)
            });
    }

    pub fn add_system(
        &mut self,
        stage_label: impl StageLabel,
        system: impl Into<SystemDescriptor>,
    ) {
        self.schedule.add_system_to_stage(stage_label, system);
    }

    pub fn add_system_set(&mut self, stage_label: impl StageLabel, system: SystemSet) {
        self.schedule.add_system_set_to_stage(stage_label, system);
    }

    pub fn run(&mut self, resources: &mut World) {
        self.schedule.run_once(resources);
    }
}