Refactor system registration to use TypeIds

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;
-
-pub const MESH_RENDERER: &str = "mesh_renderer";
-pub const DEBUG_UI_RENDERER: &str = "debug_ui_renderer";
+use crate::GliumAssetManager;
 
 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(
-            MESH_RENDERER,
-            Box::new(BasicMeshRenderingSystem::initialize(&display, &window))
-        );
-
-        rendering_system_manager.add_system(
-            DEBUG_UI_RENDERER,
-            Box::new(ImguiBridge::initialize(&display, &window)),
-        );
+        rendering_system_manager.add::<BasicMeshRenderingSystem>(&display, &window);
+        rendering_system_manager.add::<ImguiBridge>(&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()
-                .for_each(|(_, system)| system.handle_event(&mut self.window, event.clone()));
+                .values_mut()
+                .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()
-                            .for_each(|(_, system)| system.render(&mut context));
+                            .values_mut()
+                            .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()
-                        .for_each(|(_, system)| system.prepare_frame(&mut self.window));
+                        .values_mut()
+                        .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 prepare_frame(&mut self, window: &mut glium::winit::window::Window) {}
+    fn handle_event(
+        &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) {
-        self.systems.shift_remove(&id);
+    pub fn remove<R: 'static>(&mut self) {
+        self.systems.shift_remove(&TypeId::of::<R>());
     }
 }