feat: add layers (#21)

README.md

@@ -4,4 +4,3 @@ Scion is a minimalist, **easy** to use, modulable game engine built on top of le
 
 
 
-

examples/hello-world/main.rs

@@ -1,27 +1,36 @@
 use scion::application::Scion;
 use scion::legion::{system, Resources, World};
 use scion::utils::time::Time;
-use log::{info};
+use log::info;
 use scion::utils::window::WindowDimensions;
 
 
 use scion::renderer::{RendererType, ScionRenderer};
 use miniquad::Context;
+use scion::game_layer::{SimpleGameLayer, GameLayer, GameLayerType};
+use scion::legion::systems::ParallelRunnable;
+use scion::renderer::bidimensional::triangle::Triangle;
 
 #[system]
 fn time(#[resource] time: &Time) {
-    info!("Last frame duration : {:?}", time.delta_duration());
+    info!("Time elapsed in the last frame : {:?}", time.delta_duration())
 }
 
-#[system]
-fn screen(#[resource] screen_dimension: &WindowDimensions) {
-    info!("Screen dimension : {:?}", screen_dimension);
+#[derive(Default)]
+struct Layer;
+impl SimpleGameLayer for Layer {
+    fn on_start(&mut self, world: &mut World, _resource: &mut Resources) {
+        world.push((Triangle,));
+    }
+
+    fn update(&mut self, _world: &mut World, _resource: &mut Resources) {
+        info!("Hello from game Layer");
+    }
 }
 
 fn main() {
     Scion::app()
         .with_system(time_system())
-        .with_system(screen_system())
-        .with_renderer(RendererType::Scion2D)
+        .with_game_layer(GameLayer::weak::<Layer>())
         .run();
 }

src/application.rs

@@ -9,13 +9,15 @@ use crate::utils::window::WindowDimensions;
 use crate::renderer::{RendererType, ScionRenderer};
 
 use crate::renderer::bidimensional::triangle::Triangle;
+use crate::game_layer::{GameLayer, SimpleGameLayer, GameLayerType, LayerAction};
 
 /// `Scion` is the entry point of any application made with Scion engine.
 pub struct Scion {
     config: ScionConfig,
     world: World,
     resources: Resources,
     schedule: Schedule,
+    game_layers: Vec<Box<GameLayer>>,
     context: Option<Context>,
     renderer: Box<dyn ScionRenderer>,
 }
@@ -60,30 +62,56 @@ impl Scion {
         let screen_size = context.screen_size();
         self.context = Some(context);
         self.resources.insert(Time::default());
-
         self.resources.insert(WindowDimensions::new(screen_size));
-        self.world.push((Triangle,));
+
+        self.apply_layers_action(LayerAction::START);
         self
     }
 
     fn next_frame(&mut self) {
+        self.apply_layers_action(LayerAction::UPDATE);
         self.resources.get_mut::<Time>().expect("Time is an internal resource and can't be missing").frame();
         self.schedule.execute(&mut self.world, &mut self.resources);
+        self.apply_layers_action(LayerAction::LATE_UPDATE);
+    }
+
+    fn apply_layers_action(&mut self, action: LayerAction) {
+        let layers_len = self.game_layers.len();
+        if layers_len > 0 {
+            for layer_index in (0..layers_len).rev(){
+                let current_layer = self.game_layers.get_mut(layer_index).expect("We just checked the len");
+                match &mut current_layer.layer {
+                    GameLayerType::Strong(simple_layer) | GameLayerType::Weak(simple_layer) => {
+                        match action {
+                            LayerAction::UPDATE => simple_layer.update(&mut self.world, &mut self.resources),
+                            LayerAction::START => simple_layer.on_start(&mut self.world, &mut self.resources),
+                            LayerAction::STOP => simple_layer.on_stop(&mut self.world, &mut self.resources),
+                            LayerAction::LATE_UPDATE => simple_layer.late_update(&mut self.world, &mut self.resources),
+                        };
+                    }
+                }
+                if let GameLayerType::Strong(_) = current_layer.layer{
+                    break;
+                }
+            }
+        }
     }
 }
 
 pub struct ScionBuilder {
     config: ScionConfig,
     schedule_builder: Builder,
-    renderer: RendererType
+    renderer: RendererType,
+    game_layers: Vec<Box<GameLayer>>
 }
 
 impl ScionBuilder {
     fn new(config: ScionConfig) -> Self {
         Self {
             config,
             schedule_builder: Default::default(),
-            renderer: Default::default()
+            renderer: Default::default(),
+            game_layers: Default::default()
         }
     }
 
@@ -110,13 +138,19 @@ impl ScionBuilder {
         self
     }
 
+    pub fn with_game_layer(mut self, game_layer: Box<GameLayer>) -> Self{
+        self.game_layers.push(game_layer);
+        self
+    }
+
     /// Builds, setups and runs the Scion application
     pub fn run(mut self) {
         let scion = Scion {
             config: self.config,
             world: Default::default(),
             resources: Default::default(),
             schedule: self.schedule_builder.build(),
+            game_layers: self.game_layers,
             context: None,
             renderer: self.renderer.into_boxed_renderer()
         };

src/game_layer.rs

@@ -0,0 +1,36 @@
+use legion::{Resources, World};
+use std::fmt::Debug;
+
+/// Trait to implement in order to create a `GameLayer`.
+pub trait SimpleGameLayer {
+    fn on_start(&mut self, _world: &mut World, _resource: &mut Resources) {}
+    fn update(&mut self, _world: &mut World, _resource: &mut Resources) {}
+    fn late_update(&mut self, _world: &mut World, _resource: &mut Resources) {}
+    fn on_stop(&mut self, _world: &mut World, _resource: &mut Resources) {}
+}
+
+pub(crate) enum LayerAction {
+    UPDATE, START, STOP, LATE_UPDATE
+}
+
+pub struct GameLayer{
+    pub(crate) layer: GameLayerType
+}
+
+impl GameLayer {
+    pub fn weak<T: SimpleGameLayer + Default + 'static>() -> Box<GameLayer> {
+        Box::new(GameLayer{layer: GameLayerType::Weak(Box::new(T::default()))})
+    }
+
+    pub fn strong<T: SimpleGameLayer + Default + 'static>() -> Box<GameLayer> {
+        Box::new(GameLayer{layer: GameLayerType::Strong(Box::new(T::default()))})
+    }
+}
+
+/// The `GameLayer` determines if the layer is blocking the execution queue.
+pub enum GameLayerType {
+    /// All the layers that are under the `STRONG` Layers won't be executed.
+    Strong(Box<dyn SimpleGameLayer>),
+    /// The next layer under a `WEAK` layer will be executed
+    Weak(Box<dyn SimpleGameLayer>),
+}

src/lib.rs

@@ -4,4 +4,5 @@ pub use legion;
 pub mod application;
 pub mod config;
 pub mod utils;
-pub mod renderer;
+pub mod renderer;
+pub mod game_layer;

src/renderer/mod.rs

@@ -1,5 +1,4 @@
 pub mod bidimensional;
-use log::*;
 use miniquad::Context;
 use legion::{World, Resources};
 
@@ -29,8 +28,8 @@ impl Default for RendererType{
 impl RendererType{
     pub(crate) fn into_boxed_renderer(self) -> Box<dyn ScionRenderer>{
         match self{
-            RendererType::Scion2D => { warn!("scion2S");Box::new(bidimensional::renderer::Scion2D) }
-            RendererType::Custom(boxed) => { warn!("Boxed"); boxed }
+            RendererType::Scion2D => { Box::new(bidimensional::renderer::Scion2D) }
+            RendererType::Custom(boxed) => { boxed }
         }
     }
 }