wip: Changes of the week

- Move engine to a different crate
- Add engine trait
- Refactor the rest of the codebase to work with these changes
- Add debug ui buffer, use it to finish imgui support

engine/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "raidillon_engine"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+raidillon_assets = { path = "../asset" }
+raidillon_core = { path = "../core" }
+raidillon_platform = { path = "../platform" }
+winit = "0.30.12"
+hecs = "0.10.5"
+indexmap = "2.10.0"

engine/src/engine.rs

@@ -0,0 +1,83 @@
+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};
+
+pub struct Engine {
+    pub scene_manager: SceneManager,
+    pub system_manager: SystemManager,
+    debug_ui_buffer: Rc<RefCell<DebugUIBuffer>>,
+}
+
+impl EngineTrait for Engine {
+    fn new() -> Self {
+        let scene_manager = SceneManager::new();
+        let system_manager = SystemManager::new();
+        Self {
+            scene_manager,
+            system_manager,
+            debug_ui_buffer: Rc::new(RefCell::new(DebugUIBuffer::new())),
+        }
+    }
+
+    /// 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() {
+            system.initialize();
+        }
+
+        let mut ctx = SystemContext {
+            scene: self.scene_manager.current_mut(),
+            platform_context,
+            debug_ui_buffer: self.debug_ui_buffer.clone(),
+        };
+
+        // Engine Loading Stage 2: load world
+        for (system_id, system) in self.system_manager.systems.iter_mut() {
+            system.load_world(&mut ctx);
+        }
+    }
+
+    /// Update the engine
+    fn 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(),
+        };
+
+        for (system_id, system) in self.system_manager.systems.iter_mut() {
+            system.update(&mut ctx);
+        }
+    }
+
+    // pub fn build_system_context(&mut self) -> SystemContext {
+    //     SystemContext {
+    //         scene: self.scene_manager.current_mut(),
+    //     }
+    // }
+
+    fn current_scene_mut(&mut self) -> &mut Scene {
+        self.scene_manager.current_mut()
+    }
+
+    fn get_debug_ui_buffer(&self) -> Rc<RefCell<DebugUIBuffer>> {   
+        self.debug_ui_buffer.clone()
+    }
+
+    fn reset_debug_ui_buffer(&mut self) {
+        self.debug_ui_buffer.borrow_mut().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())
+    }
+}

engine/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod engine;
+pub mod system;
+
+pub use crate::engine::Engine;

engine/src/system.rs

@@ -0,0 +1,42 @@
+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::DebugUIBuffer;
+
+pub struct SystemContext<'a> {
+    // TODO: time delta etc.
+    pub scene: &'a mut Scene,
+    pub platform_context: PlatformContext,
+    pub debug_ui_buffer: Rc<RefCell<DebugUIBuffer>>,
+}
+
+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 update(&mut self, ctx: &mut SystemContext);
+}
+
+pub type SystemID = &'static str;
+pub struct SystemManager {
+    pub systems: IndexMap<SystemID, Box<dyn System>>,
+}
+
+impl SystemManager {
+    pub fn new() -> Self {
+        let systems = IndexMap::default();
+        Self { systems }
+    }
+
+    pub fn add_system(&mut self, id: SystemID, system: Box<dyn System>) {
+        self.systems.insert(id, system);
+    }
+
+    pub fn remove_system(&mut self, id: SystemID) {
+        self.systems.shift_remove(&id);
+    }
+}