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

glium_platform/Cargo.toml

@@ -12,6 +12,7 @@ raidillon_platform = { path = "../platform" }
 raidillon_core = { path = "../core" }
 raidillon_assets = { path = "../asset" }
 raidillon_ecs = { path = "../ecs" }
+raidillon_engine = { path = "../engine" }
 winit = "0.30.12"
 indexmap = "2.10.0"
 imgui = "0.12.0"

glium_platform/src/platform.rs

@@ -12,25 +12,26 @@ use glium::Surface;
 use crate::system::{RenderingSystemManager, RenderingSystem, RenderingContext, SystemID};
 use winit::event::{Event, WindowEvent};
 use raidillon_assets::{ModelManager, ModelManagerRef};
-use raidillon_core::Engine;
+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";
 
-pub struct GliumPlatform {
+pub struct GliumPlatform<E: EngineTrait> {
     event_loop: EventLoop<()>,
     window: Window,
     display: Display<WindowSurface>,
     rendering_system_manager: RenderingSystemManager,
     asset_manager: ModelManagerRef,
-    engine: Engine,
-    imgui_bridge: ImguiBridge,
+    engine: E,
 }
 
-impl Platform for GliumPlatform {
-    fn initialize(mut engine: Engine, title: String, width: u32, height: u32) -> Self {
+impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
+    fn initialize(mut engine: E, title: String, width: u32, height: u32) -> Self {
         let event_loop = glium::winit::event_loop::EventLoop::builder()
             .build()
             .expect("create event-loop");
@@ -46,10 +47,13 @@ impl Platform for GliumPlatform {
         // Install rendering systems
         rendering_system_manager.add_system(
             MESH_RENDERER,
-            Box::new(BasicMeshRenderingSystem::initialize(&display))
+            Box::new(BasicMeshRenderingSystem::initialize(&display, &window))
         );
 
-        let imgui_bridge = ImguiBridge::new(&display, &window).unwrap();
+        rendering_system_manager.add_system(
+            DEBUG_UI_RENDERER,
+            Box::new(ImguiBridge::initialize(&display, &window)),
+        );
 
         Self {
             event_loop,
@@ -58,7 +62,6 @@ impl Platform for GliumPlatform {
             rendering_system_manager,
             asset_manager,
             engine,
-            imgui_bridge,
         }
     }
 
@@ -81,11 +84,13 @@ impl Platform for GliumPlatform {
                     WindowEvent::RedrawRequested => {
                         let mut target = self.display.draw();
                         target.clear_color_and_depth((0.1, 0.1, 0.15, 1.0), 1.0);
-                        // TODO: let mut context;
+                        let (scene_mut, debug_ui_buffer) = self.engine.scene_and_debug_ui_buffer_mut();
                         let mut context = RenderingContext {
-                            scene: self.engine.scene_manager.current_mut(),
+                            scene: scene_mut,
                             target: &mut target,
                             asset_manager: self.asset_manager.clone(),
+                            window: &mut self.window,
+                            debug_ui_buffer,
                         };
 
                         for (system_id, system) in self.rendering_system_manager.systems.iter_mut() {

glium_platform/src/render/basic.rs

@@ -20,7 +20,7 @@ pub struct BasicMeshRenderingSystem {
 }
 
 impl RenderingSystem for BasicMeshRenderingSystem {
-    fn initialize(display: &Display<WindowSurface>) -> Self {
+    fn initialize(display: &Display<WindowSurface>, _window: &glium::winit::window::Window) -> Self {
         const VERT_SRC: &str = include_shader!("gl_textured.vert");
         const FRAG_SRC: &str = include_shader!("gl_textured.frag");
 

glium_platform/src/render/debug_ui.rs

@@ -1,5 +1,6 @@
 use std::cell::RefCell;
 use std::rc::Rc;
+use std::sync::Arc;
 use std::time::Instant;
 use glium::Display;
 use glium::glutin::surface::WindowSurface;
@@ -8,10 +9,11 @@ use imgui_winit_support::{HiDpiMode, WinitPlatform};
 use imgui_glium_renderer::Renderer as ImguiGliumRenderer;
 use winit::raw_window_handle::DisplayHandle;
 use winit::window::Window;
-use anyhow::Result;
+use anyhow::{Result};
 use crate::RenderingSystem;
 use crate::system::RenderingContext;
 use glium::Frame;
+use raidillon_core::DebugUIBuffer;
 
 pub struct ImguiBridge {
     imgui: ImguiContext,
@@ -20,21 +22,6 @@ pub struct ImguiBridge {
 }
 
 impl ImguiBridge {
-    pub fn new(display: &Display<WindowSurface>, window: &Window) -> Result<Self> {
-        let mut imgui = ImguiContext::create();
-        imgui.set_ini_filename(None);
-        let mut platform = WinitPlatform::new(&mut imgui);
-        platform.attach_window(imgui.io_mut(), window, HiDpiMode::Default);
-        imgui.fonts().add_font(&[imgui::FontSource::DefaultFontData { config: None }]);
-        let renderer = ImguiGliumRenderer::new(&mut imgui, display)?;
-
-        Ok(Self {
-            imgui,
-            platform,
-            renderer,
-        })
-    }
-
     pub fn render<F>(&mut self, target: &mut Frame, window: &Window, build_ui: F)
     where
         F: FnOnce(&imgui::Ui),
@@ -52,26 +39,43 @@ impl ImguiBridge {
             .expect("imgui rendering failed");
     }
 
-    pub fn initialize_frame(&mut self) -> &mut imgui::Ui {
-        self.imgui.frame()
-    }
-
-    pub fn finish_frame(&mut self, target: &mut Frame, window: &Window, ui: imgui::Ui) {
-        self.platform.prepare_render(&ui, window);
-        let draw_data = self.imgui.render();
-        self.renderer.render(target, draw_data).expect("imgui rendering failed");
-    }
+    // pub fn initialize_frame(&mut self) -> &mut imgui::Ui {
+    //     self.imgui.frame()
+    // }
+    //
+    // pub fn finish_frame(&mut self, target: &mut Frame, window: &Window, ui: imgui::Ui) {
+    //     self.platform.prepare_render(&ui, window);
+    //     let draw_data = self.imgui.render();
+    //     self.renderer.render(target, draw_data).expect("imgui rendering failed");
+    // }
 }
 
 impl RenderingSystem for ImguiBridge {
     fn render(&mut self, ctx: &mut RenderingContext) {
-        todo!()
+        let mut ui = self.imgui.frame();
+
+        ctx.debug_ui_buffer.borrow_mut().write_buffer(&mut ui);
+
+        self.platform.prepare_render(&ui, ctx.window);
+        let draw_data = self.imgui.render();
+        self.renderer.render(ctx.target, draw_data).expect("imgui rendering failed");
     }
 
-    fn initialize(display: &Display<WindowSurface>) -> Self
+    fn initialize(display: &Display<WindowSurface>, window: &glium::winit::window::Window) -> Self
     where
         Self: Sized,
     {
-        todo!()
+        let mut imgui = ImguiContext::create();
+        imgui.set_ini_filename(None);
+        let mut platform = WinitPlatform::new(&mut imgui);
+        platform.attach_window(imgui.io_mut(), window, HiDpiMode::Default);
+        imgui.fonts().add_font(&[imgui::FontSource::DefaultFontData { config: None }]);
+        let renderer = ImguiGliumRenderer::new(&mut imgui, display).unwrap();
+
+        Self {
+            imgui,
+            platform,
+            renderer,
+        }
     }
 }

glium_platform/src/system.rs

@@ -1,23 +1,26 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-use raidillon_core::Scene;
+use raidillon_core::scene::Scene;
 use glium::{Display, Frame};
 use glium::glutin::surface::WindowSurface;
 use indexmap::IndexMap;
 use raidillon_assets::ModelManagerRef;
+use raidillon_core::DebugUIBuffer;
 use crate::GliumAssetManager;
 
 pub struct RenderingContext<'a> {
     pub scene: &'a Scene,
     pub target: &'a mut Frame,
+    pub window: &'a mut glium::winit::window::Window,
     pub asset_manager: ModelManagerRef,
+    pub debug_ui_buffer: Rc<RefCell<DebugUIBuffer>>,
 }
 
 /// The internal "rendering system" trait of glium_platform.
 /// This is unrelated to the main System trait in core.
 pub trait RenderingSystem {
     fn render(&mut self, ctx: &mut RenderingContext);
-    fn initialize(display: &Display<WindowSurface>) -> Self where Self: Sized;
+    fn initialize(display: &Display<WindowSurface>, window: &glium::winit::window::Window) -> Self where Self: Sized;
 }
 
 pub type SystemID = &'static str;