Replace contexts with resources

- Implements a new macro to generate code for a new structure: TypeMap
- TypeMaps are wrappers for HashMaps that use TypeIDs as keys.
- Refactor the entire codebase to use the new resource structures.
- This commit is the first step towards getting rid of "god context objects everywhere".

engine/src/engine.rs

@@ -3,15 +3,22 @@ use std::rc::Rc;
 use raidillon_core::scene::{Scene, SceneManager};
 use crate::system::{SystemContext, SystemManager};
 use raidillon_platform::PlatformContext;
-use raidillon_core::DebugUIBuffer;
+use raidillon_core::{define_typemap, DebugUIBuffer};
 use raidillon_core::engine::EngineTrait;
 use crate::input::InputState;
+use crate::resources::EngineResources;
 
 pub struct Engine {
     pub scene_manager: SceneManager,
     pub system_manager: SystemManager,
-    debug_ui_buffer: Rc<RefCell<DebugUIBuffer>>,
-    input_state: Rc<RefCell<InputState>>,
+    pub resources: EngineResources,
+}
+
+impl Engine {
+    fn load_default_resources(&mut self) {
+        let input = InputState::default();
+        self.resources.insert(input);
+    }
 }
 
 impl EngineTrait for Engine {
@@ -19,12 +26,13 @@ impl EngineTrait for Engine {
     fn new() -> Self {
         let scene_manager = SceneManager::new();
         let system_manager = SystemManager::new();
-        Self {
+        let mut s = Self {
             scene_manager,
             system_manager,
-            debug_ui_buffer: Rc::new(RefCell::new(DebugUIBuffer::new())),
-            input_state: Default::default(),
-        }
+            resources: EngineResources::new(),
+        };
+        s.load_default_resources();
+        s
     }
 
     /// Initialize systems, load the world.
@@ -33,60 +41,35 @@ impl EngineTrait for Engine {
         for system in self.system_manager.systems.values_mut() {
             system.initialize();
         }
-
-        let mut ctx = SystemContext {
-            scene: self.scene_manager.current_mut(),
-            platform_context,
-            debug_ui_buffer: self.debug_ui_buffer.clone(),
-            input_state: self.input_state.clone(),
-        };
-
+        self.resources.insert(platform_context);
         // Engine Loading Stage 2: load world
         for system in self.system_manager.systems.values_mut() {
-            system.load_world(&mut ctx);
+            system.load_world(&mut self.resources, &mut self.scene_manager.current_mut());
         }
     }
 
     /// Update the engine
     fn frame_update(&mut self, platform_context: PlatformContext) {
-        self.debug_ui_buffer.borrow_mut().reset_buffer();
-        let mut ctx = SystemContext {
-            scene: self.scene_manager.current_mut(),
-            platform_context,
-            debug_ui_buffer: self.debug_ui_buffer.clone(),
-            input_state: self.input_state.clone(),
-        };
+        self.scene_manager.current_mut().resources.get_mut::<DebugUIBuffer>().unwrap().reset_buffer();
+        self.resources.insert(platform_context);
 
         for system in self.system_manager.systems.values_mut() {
-            system.frame_update(&mut ctx);
+            system.frame_update(&mut self.resources, &mut self.scene_manager.current_mut());
         }
     }
 
     fn fixed_update(&mut self, platform_context: PlatformContext) {
-        let mut ctx = SystemContext {
-            scene: self.scene_manager.current_mut(),
-            platform_context,
-            debug_ui_buffer: self.debug_ui_buffer.clone(),
-            input_state: self.input_state.clone(),
-        };
-
+        self.resources.insert(platform_context);
         for system in self.system_manager.systems.values_mut() {
-            system.fixed_update(&mut ctx);
+            system.fixed_update(&mut self.resources, &mut self.scene_manager.current_mut());
         }
     }
 
     fn handle_event(&mut self, platform_context: PlatformContext) {
-        self.input_state.borrow_mut().handle_event(&platform_context.current_event);
-
-        let mut ctx = SystemContext {
-            scene: self.scene_manager.current_mut(),
-            platform_context,
-            debug_ui_buffer: self.debug_ui_buffer.clone(),
-            input_state: self.input_state.clone(),
-        };
-
+        // self.input_state.borrow_mut().handle_event(&platform_context.current_event);
+        self.resources.insert(platform_context);
         for system in self.system_manager.systems.values_mut() {
-            system.handle_event(&mut ctx);
+            system.handle_event(&mut self.resources, &mut self.scene_manager.current_mut());
         }
     }
 
@@ -100,16 +83,20 @@ impl EngineTrait for Engine {
         self.scene_manager.current_mut()
     }
 
-    fn get_debug_ui_buffer(&self) -> Rc<RefCell<DebugUIBuffer>> {
-        self.debug_ui_buffer.clone()
+    fn current_scene(&self) -> &Scene {
+        self.scene_manager.current()
+    }
+
+    fn get_debug_ui_buffer(&self) -> &DebugUIBuffer {
+        self.scene_manager.current().resources.get::<DebugUIBuffer>().unwrap()
     }
 
     fn reset_debug_ui_buffer(&mut self) {
-        self.debug_ui_buffer.borrow_mut().reset_buffer();
+        self.scene_manager.current_mut().resources.get_mut::<DebugUIBuffer>().unwrap().reset_buffer();
     }
 
-    fn scene_and_debug_ui_buffer_mut(&mut self) -> (&mut Scene, Rc<RefCell<DebugUIBuffer>>) {
-        let (sm, dub) = (&mut self.scene_manager, &mut self.debug_ui_buffer);
-        (sm.current_mut(), dub.clone())
-    }
+    // fn scene_and_debug_ui_buffer_mut(&mut self) -> (&mut Scene, &DebugUIBuffer) {
+    //     let (sm, dub) = (&mut self.scene_manager, self.scene_manager.current().resources.get::<DebugUIBuffer>().unwrap());
+    //     (sm.current_mut(), dub)
+    // }
 }