quaso 0.54.1

Toolset for making Micro Games quickly
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

use crate::{
    audio::Audio,
    game::{GameGlobals, GameJobs, GameStateChange, GameSubsystem},
    gc::Heartbeat,
};
use anput::universe::Universe;
use keket::database::AssetDatabase;
use moirai::queue::JobQueue;
use nodio::graph::Graph;
use spitfire_draw::{context::DrawContext, utils::Vertex};
use spitfire_glow::graphics::Graphics;
use spitfire_gui::context::GuiContext;
use spitfire_input::InputContext;

pub struct GameContext<'a> {
    pub graphics: &'a mut Graphics<Vertex>,
    pub draw: &'a mut DrawContext,
    pub gui: &'a mut GuiContext,
    pub input: &'a mut InputContext,
    pub state_change: &'a mut GameStateChange,
    pub assets: &'a mut AssetDatabase,
    pub audio: &'a mut Audio,
    pub globals: &'a mut GameGlobals,
    pub jobs: Option<&'a GameJobs>,
    pub update_queue: &'a JobQueue,
    pub fixed_update_queue: &'a JobQueue,
    pub draw_queue: &'a JobQueue,
    pub draw_gui_queue: &'a JobQueue,
    pub universe: &'a mut Universe,
    pub graph: &'a mut Graph,
    pub state_heartbeat: &'a Heartbeat,
    pub subsystems: GameSubsystems<'a>,
    pub time: f32,
    pub frame: usize,
}

impl<'a> GameContext<'a> {
    pub(crate) fn fork(other: &'a mut Self) -> Self {
        Self {
            graphics: other.graphics,
            draw: other.draw,
            gui: other.gui,
            input: other.input,
            state_change: other.state_change,
            assets: other.assets,
            audio: other.audio,
            globals: other.globals,
            jobs: None,
            update_queue: other.update_queue,
            fixed_update_queue: other.fixed_update_queue,
            draw_queue: other.draw_queue,
            draw_gui_queue: other.draw_gui_queue,
            universe: other.universe,
            graph: other.graph,
            state_heartbeat: other.state_heartbeat,
            subsystems: GameSubsystems {
                subsystems: other.subsystems.subsystems,
            },
            time: other.time,
            frame: other.frame,
        }
    }
}

pub struct GameSubsystems<'a> {
    pub subsystems: &'a mut [Box<dyn GameSubsystem>],
}

impl<'a> GameSubsystems<'a> {
    pub fn get<T: GameSubsystem + 'static>(&self) -> Option<&T> {
        for subsystem in self.subsystems.iter() {
            if let Some(specific) = subsystem.as_any().downcast_ref::<T>() {
                return Some(specific);
            }
        }
        None
    }

    pub fn get_mut<T: GameSubsystem + 'static>(&mut self) -> Option<&mut T> {
        for subsystem in self.subsystems.iter_mut() {
            if let Some(specific) = subsystem.as_any_mut().downcast_mut::<T>() {
                return Some(specific);
            }
        }
        None
    }
}