shura 0.6.0

A fast cross-plattform 2D component-based game framework
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
130
131
132
133
134

#[cfg(feature = "physics")]
use crate::physics::World;

use crate::{
    ComponentManager, Context, ScreenConfig, Shura, StateManager, Vector, WorldCamera,
    WorldCameraScale,
};

/// Origin of a [Scene]
pub trait SceneCreator {
    fn new_id(&self) -> u32;
    fn create(self: Box<Self>, shura: &mut Shura) -> Scene;
}

/// Create a new [Scene] from scratch
pub struct NewScene<N: 'static + FnMut(&mut Context)> {
    pub id: u32,
    pub init: N,
}

impl<N: 'static + FnMut(&mut Context)> NewScene<N> {
    pub fn new(id: u32, init: N) -> NewScene<N> {
        Self { id, init }
    }
}

impl<N: 'static + FnMut(&mut Context)> SceneCreator for NewScene<N> {
    fn new_id(&self) -> u32 {
        self.id
    }

    fn create(mut self: Box<Self>, shura: &mut Shura) -> Scene {
        let mint: mint::Vector2<u32> = shura.window.inner_size().into();
        let window_size: Vector<u32> = mint.into();
        let mut scene = Scene::new(window_size, self.id);
        scene.id = self.id;
        scene.started = true;
        scene.resized = true;
        scene.switched = true;
        let mut ctx = Context::new(shura, &mut scene);
        (self.init)(&mut ctx);
        return scene;
    }
}

/// Add a [Scene] that previously has been removed.
pub struct RecycleScene<N: 'static + FnMut(&mut Context)> {
    pub id: u32,
    pub scene: Scene,
    pub init: N,
}

impl<N: 'static + FnMut(&mut Context)> RecycleScene<N> {
    pub fn new(id: u32, scene: Scene, init: N) -> RecycleScene<N> {
        Self { id, scene, init }
    }
}

impl<N: 'static + FnMut(&mut Context)> SceneCreator for RecycleScene<N> {
    fn new_id(&self) -> u32 {
        self.id
    }

    fn create(mut self: Box<Self>, shura: &mut Shura) -> Scene {
        let mint: mint::Vector2<u32> = shura.window.inner_size().into();
        let window_size: Vector<u32> = mint.into();
        self.scene.world_camera.resize(window_size);
        self.scene.id = self.id;
        self.scene.started = true;
        self.scene.resized = true;
        self.scene.switched = true;
        let mut ctx = Context::new(shura, &mut self.scene);
        (self.init)(&mut ctx);
        return self.scene;
    }
}

#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
/// Scene owning its own [Components](ComponentManager), [Configurations](ScreenConfig), callbacks(resized, switched, started),
/// [states](StateManager) and [camera](WorldCamera) identified by an Id
pub struct Scene {
    pub(crate) id: u32,
    pub(crate) resized: bool,
    pub(crate) switched: bool,
    pub(crate) started: bool,
    pub render_components: bool,
    pub screen_config: ScreenConfig,
    pub world_camera: WorldCamera,
    pub components: ComponentManager,
    #[cfg_attr(feature = "serde", serde(skip))]
    #[cfg_attr(feature = "serde", serde(default))]
    pub states: StateManager,
    #[cfg(feature = "physics")]
    pub world: World,
}

impl Scene {
    pub const DEFAULT_VERTICAL_CAMERA_FOV: f32 = 3.0;
    pub(crate) fn new(window_size: Vector<u32>, id: u32) -> Self {
        Self {
            render_components: true,
            id: id,
            switched: true,
            resized: true,
            started: true,
            world_camera: WorldCamera::new(
                Default::default(),
                WorldCameraScale::Min(Self::DEFAULT_VERTICAL_CAMERA_FOV),
                window_size,
            ),
            components: ComponentManager::new(),
            screen_config: ScreenConfig::new(),
            states: StateManager::default(),
            #[cfg(feature = "physics")]
            world: World::new(),
        }
    }

    pub fn resized(&self) -> bool {
        self.resized
    }

    pub fn switched(&self) -> bool {
        self.switched
    }

    pub fn started(&self) -> bool {
        self.started
    }

    pub fn id(&self) -> u32 {
        self.id
    }
}