Refactor system registration to use TypeIds

engine/src/engine.rs

@@ -1,12 +1,10 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-use winit::event::Event;
 use raidillon_core::scene::{Scene, SceneManager};
 use crate::system::{SystemContext, SystemManager};
-use raidillon_assets::{ModelManager, ModelManagerRef};
 use raidillon_core::context::PlatformContext;
 use raidillon_core::DebugUIBuffer;
-use raidillon_core::engine::{EngineTrait};
+use raidillon_core::engine::EngineTrait;
 
 pub struct Engine {
     pub scene_manager: SceneManager,
@@ -28,7 +26,7 @@ impl EngineTrait for Engine {
     /// Initialize systems, load the world.
     fn initialize(&mut self, platform_context: PlatformContext) {
         // Engine Loading Stage 1: initialize systems
-        for (system_id, system) in self.system_manager.systems.iter_mut() {
+        for system in self.system_manager.systems.values_mut() {
             system.initialize();
         }
 
@@ -39,7 +37,7 @@ impl EngineTrait for Engine {
         };
 
         // Engine Loading Stage 2: load world
-        for (system_id, system) in self.system_manager.systems.iter_mut() {
+        for system in self.system_manager.systems.values_mut() {
             system.load_world(&mut ctx);
         }
     }
@@ -53,7 +51,7 @@ impl EngineTrait for Engine {
             debug_ui_buffer: self.debug_ui_buffer.clone(),
         };
 
-        for (system_id, system) in self.system_manager.systems.iter_mut() {
+        for system in self.system_manager.systems.values_mut() {
             system.update(&mut ctx);
         }
     }

engine/src/system.rs

@@ -1,9 +1,9 @@
+use std::any::TypeId;
 use std::cell::RefCell;
 use std::rc::Rc;
-use raidillon_core::scene::Scene;
 use indexmap::IndexMap;
-use winit::event::Event;
 use raidillon_core::context::PlatformContext;
+use raidillon_core::scene::Scene;
 use raidillon_core::DebugUIBuffer;
 
 pub struct SystemContext<'a> {
@@ -17,26 +17,27 @@ pub trait System {
     /// Initialize the system.
     fn initialize(&mut self) {}
     /// Spawn the first entities of the world.
-    fn load_world(&mut self, ctx: &mut SystemContext) {}
+    fn load_world(&mut self, _ctx: &mut SystemContext) {}
-    fn update(&mut self, ctx: &mut SystemContext) {}
+    fn update(&mut self, _ctx: &mut SystemContext) {}
 }
 
-pub type SystemID = &'static str;
 pub struct SystemManager {
-    pub systems: IndexMap<SystemID, Box<dyn System>>,
+    pub systems: IndexMap<TypeId, Box<dyn System>>,
 }
 
 impl SystemManager {
     pub fn new() -> Self {
-        let systems = IndexMap::default();
+        Self {
-        Self { systems }
+            systems: IndexMap::default(),
+        }
     }
 
-    pub fn add_system(&mut self, id: SystemID, system: Box<dyn System>) {
+    pub fn add<S: System + Default + 'static>(&mut self) {
-        self.systems.insert(id, system);
+        self.systems
+            .insert(TypeId::of::<S>(), Box::new(S::default()));
     }
 
-    pub fn remove_system(&mut self, id: SystemID) {
+    pub fn remove<S: 'static>(&mut self) {
-        self.systems.shift_remove(&id);
+        self.systems.shift_remove(&TypeId::of::<S>());
     }
 }

game/src/main.rs

@@ -1,4 +1,3 @@
-use std::path::Path;
 use glam::{Quat, Vec3};
 use raidillon_engine::{Engine, system::System};
 use raidillon_engine::system::SystemContext;
@@ -10,31 +9,32 @@ use raidillon_ecs::Transform;
 use raidillon_core::scene::Scene;
 #[cfg(feature = "glium")]
 use raidillon_glium::GliumPlatform;
-use raidillon_core::DebugUIBuffer;
 use winit::event::{Event, WindowEvent};
 
 const TEST_GLTF: &str = "pink-monkey.gltf";
 
-const RENDERING_TEST_SYSTEM: &str = "rendering_test_system";
-
-const UPDATE_ASPECT_RATIO_SYSTEM: &str = "update_aspect_ratio_system";
-
 const MAIN_SCENE_ID: &str = "main_scene";
 
+#[derive(Default)]
 struct UpdateAspectRatioSystem;
 impl System for UpdateAspectRatioSystem {
     fn initialize(&mut self) {}
 
-    fn load_world(&mut self, ctx: &mut SystemContext) {}
+    fn load_world(&mut self, _ctx: &mut SystemContext) {}
 
     fn update(&mut self, ctx: &mut SystemContext) {
         // FIXME: Need an event handler rework for systems.
         match &ctx.platform_context.current_event {
             Event::WindowEvent { event, .. } => match event {
                 WindowEvent::Resized(sz) => {
-                    let _ = ctx.scene.world.query_mut::<&mut Camera>().into_iter().map(|mut cam| {
+                    let _ = ctx
-                        cam.1.aspect = sz.width as f32 / sz.height as f32;
+                        .scene
-                    });
+                        .world
+                        .query_mut::<&mut Camera>()
+                        .into_iter()
+                        .map(|(_, cam)| {
+                            cam.aspect = sz.width as f32 / sz.height as f32;
+                        });
                 }
                 _ => {}
             },
@@ -43,6 +43,7 @@ impl System for UpdateAspectRatioSystem {
     }
 }
 
+#[derive(Default)]
 struct RenderingTestSystem;
 impl System for RenderingTestSystem {
     fn initialize(&mut self) {}
@@ -82,10 +83,8 @@ impl System for RenderingTestSystem {
 fn main() {
     let mut engine = Engine::new();
     // Define systems
-    // engine.system_manager.add_system("spawn_chunks".to_string(), ChunkSystem);
+    engine.system_manager.add::<RenderingTestSystem>();
-    // engine.system_manager.add_system("movement".to_string(), MovementSystem);
+    engine.system_manager.add::<UpdateAspectRatioSystem>();
-    engine.system_manager.add_system(RENDERING_TEST_SYSTEM, Box::new(RenderingTestSystem));
-    engine.system_manager.add_system(UPDATE_ASPECT_RATIO_SYSTEM, Box::new(UpdateAspectRatioSystem));
 
     // Set up the scene
     let main_scene = Scene::new(
@@ -97,7 +96,7 @@ fn main() {
 
     #[cfg(feature = "glium")]
     {
-        let mut platform = GliumPlatform::initialize(
+        let platform = GliumPlatform::initialize(
             engine,
             "Raidillon".to_string(),
             1920,

glium_platform/src/platform.rs

@@ -1,25 +1,19 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-use std::str::FromStr;
-use std::sync::{Arc, RwLock};
 use raidillon_platform::{Platform, PlatformContext};
+use glium::backend::glutin::Display;
+use glium::backend::glutin::SimpleWindowBuilder;
+use glium::glutin::surface::WindowSurface;
 use glium::winit::event_loop::EventLoop;
 use glium::winit::window::Window;
-use glium::backend::glutin::Display;
-use glium::glutin::surface::WindowSurface;
-use glium::backend::glutin::SimpleWindowBuilder;
 use glium::Surface;
-use crate::system::{RenderingSystemManager, RenderingSystem, RenderingContext, SystemID};
+use crate::system::{RenderingContext, RenderingSystemManager};
 use winit::event::{Event, WindowEvent};
-use raidillon_assets::{ModelManager, ModelManagerRef};
+use raidillon_assets::ModelManagerRef;
 use raidillon_core::engine::EngineTrait;
-use raidillon_engine::Engine;
-use crate::{GliumAssetManager};
 use crate::render::debug_ui::ImguiBridge;
 use crate::render::BasicMeshRenderingSystem;
-
+use crate::GliumAssetManager;
-pub const MESH_RENDERER: &str = "mesh_renderer";
-pub const DEBUG_UI_RENDERER: &str = "debug_ui_renderer";
 
 pub struct GliumPlatform<E: EngineTrait> {
     event_loop: EventLoop<()>,
@@ -45,15 +39,8 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
         let mut rendering_system_manager = RenderingSystemManager::new();
 
         // Install rendering systems
-        rendering_system_manager.add_system(
+        rendering_system_manager.add::<BasicMeshRenderingSystem>(&display, &window);
-            MESH_RENDERER,
+        rendering_system_manager.add::<ImguiBridge>(&display, &window);
-            Box::new(BasicMeshRenderingSystem::initialize(&display, &window))
-        );
-
-        rendering_system_manager.add_system(
-            DEBUG_UI_RENDERER,
-            Box::new(ImguiBridge::initialize(&display, &window)),
-        );
 
         Self {
             event_loop,
@@ -77,8 +64,8 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
         let _ = &self.event_loop.run(move |event, el| {
             self.rendering_system_manager
                 .systems
-                .iter_mut()
+                .values_mut()
-                .for_each(|(_, system)| system.handle_event(&mut self.window, event.clone()));
+                .for_each(|system| system.handle_event(&mut self.window, event.clone()));
 
             match event {
                 Event::WindowEvent { event, .. } => match event {
@@ -100,8 +87,8 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
 
                         self.rendering_system_manager
                             .systems
-                            .iter_mut()
+                            .values_mut()
-                            .for_each(|(_, system)| system.render(&mut context));
+                            .for_each(|system| system.render(&mut context));
                         target.finish().unwrap();
                     }
                     _ => {},
@@ -112,8 +99,8 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
                     self.engine.update(ctx2);
                     self.rendering_system_manager
                         .systems
-                        .iter_mut()
+                        .values_mut()
-                        .for_each(|(_, system)| system.prepare_frame(&mut self.window));
+                        .for_each(|system| system.prepare_frame(&mut self.window));
                     self.window.request_redraw();
                 }
                 _ => {},

glium_platform/src/system.rs

@@ -1,12 +1,12 @@
+use std::any::TypeId;
 use std::cell::RefCell;
 use std::rc::Rc;
-use raidillon_core::scene::Scene;
+use indexmap::IndexMap;
 use glium::{Display, Frame};
 use glium::glutin::surface::WindowSurface;
-use indexmap::IndexMap;
 use raidillon_assets::ModelManagerRef;
 use raidillon_core::DebugUIBuffer;
-use crate::GliumAssetManager;
+use raidillon_core::scene::Scene;
 
 pub struct RenderingContext<'a> {
     pub scene: &'a Scene,
@@ -19,16 +19,21 @@ pub struct RenderingContext<'a> {
 /// The internal "rendering system" trait of glium_platform.
 /// This is unrelated to the main System trait in core.
 pub trait RenderingSystem {
-    fn handle_event(&mut self, window: &mut glium::winit::window::Window, event: winit::event::Event<()>) {}
+    fn handle_event(
-    fn prepare_frame(&mut self, window: &mut glium::winit::window::Window) {}
+        &mut self,
+        _window: &mut glium::winit::window::Window,
+        _event: winit::event::Event<()>,
+    ) {
+    }
+    fn prepare_frame(&mut self, _window: &mut glium::winit::window::Window) {}
     fn render(&mut self, ctx: &mut RenderingContext);
-    fn initialize(display: &Display<WindowSurface>, window: &glium::winit::window::Window) -> Self where Self: Sized;
+    fn initialize(display: &Display<WindowSurface>, window: &glium::winit::window::Window) -> Self
+    where
+        Self: Sized;
 }
 
-pub type SystemID = &'static str;
-
 pub struct RenderingSystemManager {
-    pub systems: IndexMap<SystemID, Box<dyn RenderingSystem>>,
+    pub systems: IndexMap<TypeId, Box<dyn RenderingSystem>>,
 }
 
 impl RenderingSystemManager {
@@ -37,11 +42,16 @@ impl RenderingSystemManager {
             systems: IndexMap::default(),
         }
     }
-    pub fn add_system(&mut self, id: SystemID, system: Box<dyn RenderingSystem>) {
+
-        self.systems.insert(id, system);
+    pub fn add<R>(&mut self, display: &Display<WindowSurface>, window: &glium::winit::window::Window)
+    where
+        R: RenderingSystem + 'static,
+    {
+        let system = R::initialize(display, window);
+        self.systems.insert(TypeId::of::<R>(), Box::new(system));
     }
 
-    pub fn remove_system(&mut self, id: SystemID) {
+    pub fn remove<R: 'static>(&mut self) {
-        self.systems.shift_remove(&id);
+        self.systems.shift_remove(&TypeId::of::<R>());
     }
 }