scion 0.6.0

Game making library on top of wgpu, winit, legion
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
123
124
125
126
127
128
129

use atomic_refcell::AtomicRefMut;
use legion::{
    storage::ComponentTypeId,
    systems::{CommandBuffer, ResourceSet, ResourceTypeId, Runnable, SystemId, UnsafeResources},
    world::{ArchetypeAccess, WorldId},
    Read, Resources, World,
};

use crate::core::scene::SceneController;
use crate::{
    core::{
        components::maths::camera::DefaultCamera,
        resources::{
            asset_manager::AssetManager, audio::Audio, events::Events,
            inputs::inputs_controller::InputsController, time::Timers, window::Window,
        },
        state::GameState,
    },
    legion::Entity,
};

pub(crate) struct PausableSystem<S> {
    pub(crate) system: S,
    pub(crate) decider: Box<fn(GameState) -> bool>,
    pub(crate) resource_reads: Vec<ResourceTypeId>,
}

impl<S> Runnable for PausableSystem<S>
where
    S: Runnable,
{
    fn name(&self) -> Option<&SystemId> {
        self.system.name()
    }

    fn reads(&self) -> (&[ResourceTypeId], &[ComponentTypeId]) {
        let (_, components) = self.system.reads();
        (&self.resource_reads[..], components)
    }

    fn writes(&self) -> (&[ResourceTypeId], &[ComponentTypeId]) {
        self.system.writes()
    }

    fn prepare(&mut self, world: &World) {
        self.system.prepare(world)
    }

    fn accesses_archetypes(&self) -> &ArchetypeAccess {
        self.system.accesses_archetypes()
    }

    unsafe fn run_unsafe(&mut self, world: &World, resources: &UnsafeResources) {
        let resources_static = &*(resources as *const UnsafeResources);
        let resource_to_check = Read::<GameState>::fetch_unchecked(resources_static);

        if (self.decider)(*resource_to_check) {
            return;
        } else {
        }

        self.system.run_unsafe(world, resources);
    }

    fn command_buffer_mut(&mut self, world: WorldId) -> Option<&mut CommandBuffer> {
        self.system.command_buffer_mut(world)
    }
}

pub trait ScionResourcesExtension {
    fn assets(&mut self) -> AtomicRefMut<AssetManager>;
    fn timers(&mut self) -> AtomicRefMut<Timers>;
    fn inputs(&mut self) -> AtomicRefMut<InputsController>;
    fn events(&mut self) -> AtomicRefMut<Events>;
    fn audio(&mut self) -> AtomicRefMut<Audio>;
    fn window(&mut self) -> AtomicRefMut<Window>;
    fn scene_controller(&mut self) -> AtomicRefMut<SceneController>;
}

impl ScionResourcesExtension for Resources {
    /// retrieves the asset manager from the resources.
    fn assets(&mut self) -> AtomicRefMut<AssetManager> {
        self.get_mut::<AssetManager>()
            .expect("The engine is missing the mandatory asset manager resource")
    }

    /// retrieves the timers resource from the resources.
    fn timers(&mut self) -> AtomicRefMut<Timers> {
        self.get_mut::<Timers>().expect("The engine is missing the mandatory timers resource")
    }

    /// retrieves the inputs resource from the resources
    fn inputs(&mut self) -> AtomicRefMut<InputsController> {
        self.get_mut::<InputsController>()
            .expect("The engine is missing the mandatory inputs controller resource")
    }

    /// retrieves the events resource from the resources
    fn events(&mut self) -> AtomicRefMut<Events> {
        self.get_mut::<Events>().expect("The engine is missing the mandatory events resource")
    }

    /// retrieves the audio player from the resources
    fn audio(&mut self) -> AtomicRefMut<Audio> {
        self.get_mut::<Audio>().expect("The engine is missing the mandatory audio player resource")
    }

    /// retrieves the window from the resources
    fn window(&mut self) -> AtomicRefMut<Window> {
        self.get_mut::<Window>().expect("The engine is missing the mandatory window resource")
    }

    /// retrieves the window from the resources
    fn scene_controller(&mut self) -> AtomicRefMut<SceneController> {
        self.get_mut::<SceneController>()
            .expect("The engine is missing the mandatory scene controller resource")
    }
}

pub trait ScionWorldExtension {
    fn add_default_camera(&mut self) -> Entity;
}

impl ScionWorldExtension for World {
    /// Adds a default camera that will be bind to the window size
    fn add_default_camera(&mut self) -> Entity {
        self.push((DefaultCamera,))
    }
}