egui support

- New Resource, EguiQueue: Utility to queue egui ui builders
- New Rendering System, EguiRenderer: Utilizes a modified egui_glium
  library to render egui UI
- Adjusted RenderingSystem trait and RenderingContext structure to
  provide event_loop and egui_queue.
- Various minor adjusments

glium_platform/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2024"
 [dependencies]
 anyhow = "1.0.98"
 glam = "0.30.5"
-glium = { version = "0.35.0", features = ["glutin_backend", "simple_window_builder"] }
+glium = { version = "0.36.0", features = ["glutin_backend", "simple_window_builder"] }
 gltf = { version = "1.4.1", features = ["import", "utils", "KHR_texture_transform"] }
 raidillon_platform = { path = "../platform" }
 raidillon_core = { path = "../core" }
@@ -15,8 +15,7 @@ raidillon_ecs = { path = "../ecs" }
 raidillon_engine = { path = "../engine" }
 winit = "0.30.12"
 indexmap = "2.10.0"
-imgui = "0.12.0"
-imgui-winit-support = "0.13.0"
-imgui-glium-renderer = "0.13.0"
 exr = "1.73.0"
 image = { version = "0.25.8", default-features = false, features = ["exr"] }
+egui = "0.33.2"
+egui_glium = { version = "0.31.1", git = "https://github.com/reo6/egui_glium.git" }

glium_platform/src/platform.rs

@@ -14,11 +14,11 @@ use raidillon_assets::ModelManagerRef;
 use raidillon_core::engine::EngineTrait;
 use raidillon_core::time;
 use raidillon_core::time::Time;
-use crate::render::debug_ui::ImguiBridge;
-use crate::render::{BasicMeshRenderingSystem, SkyboxRenderingSystem};
+use crate::render::{BasicMeshRenderingSystem, EguiRenderer, SkyboxRenderingSystem};
 use crate::GliumAssetManager;
 use glam::Vec3;
 use winit::event::DeviceEvent::MouseMotion;
+use raidillon_core::EguiQueue;
 
 pub struct GliumPlatform<E: EngineTrait<PlatformCtx = PlatformContext>> {
     event_loop: EventLoop<()>,
@@ -28,6 +28,7 @@ pub struct GliumPlatform<E: EngineTrait<PlatformCtx = PlatformContext>> {
     asset_manager: ModelManagerRef,
     engine: E,
     time: time::Time,
+    egui_queue: Rc<RefCell<EguiQueue>>,
 }
 
 impl<E: EngineTrait<PlatformCtx = PlatformContext>> Platform<E> for GliumPlatform<E> {
@@ -50,9 +51,11 @@ impl<E: EngineTrait<PlatformCtx = PlatformContext>> Platform<E> for GliumPlatfor
         let window = Arc::new(Mutex::new(window));
 
         // Install rendering systems in order
-        rendering_system_manager.add::<SkyboxRenderingSystem>(&display, window.clone());
-        rendering_system_manager.add::<BasicMeshRenderingSystem>(&display, window.clone());
-        rendering_system_manager.add::<ImguiBridge>(&display, window.clone());
+        rendering_system_manager.add::<SkyboxRenderingSystem>(&display, window.clone(), &event_loop);
+        rendering_system_manager.add::<BasicMeshRenderingSystem>(&display, window.clone(), &event_loop);
+        rendering_system_manager.add::<EguiRenderer>(&display, window.clone(), &event_loop);
+
+        let egui_queue = Rc::new(RefCell::new(EguiQueue::new()));
 
         Self {
             event_loop,
@@ -62,6 +65,7 @@ impl<E: EngineTrait<PlatformCtx = PlatformContext>> Platform<E> for GliumPlatfor
             asset_manager,
             engine,
             time,
+            egui_queue,
         }
     }
 
@@ -77,6 +81,7 @@ impl<E: EngineTrait<PlatformCtx = PlatformContext>> Platform<E> for GliumPlatfor
             frame_height: h as f32,
             time_ctx: self.construct_time_ctx(),
             window: self.window.clone(),
+            egui_queue: self.egui_queue.clone(),
         };
         self.engine.initialize(ctx.clone());
         let _ = &self.event_loop.run(move |event, el| {
@@ -105,9 +110,11 @@ impl<E: EngineTrait<PlatformCtx = PlatformContext>> Platform<E> for GliumPlatfor
                         let mut context = RenderingContext {
                             scene,
                             target: &mut target,
+                            display: &self.display,
                             asset_manager: self.asset_manager.clone(),
                             window: self.window.clone(),
                             debug_ui_buffer,
+                            egui_queue: self.egui_queue.clone(),
                             env_light_dir: Vec3::new(0.0, -1.0, 0.0),
                         };
 

glium_platform/src/render/basic.rs

@@ -9,6 +9,8 @@ use raidillon_assets::include_shader;
 pub use raidillon_platform::Camera;
 use glam::Vec3;
 use glium::uniforms::{MagnifySamplerFilter, MinifySamplerFilter, SamplerWrapFunction};
+use winit::event::Event;
+use winit::event_loop::EventLoop;
 use raidillon_ecs::{Transform, ModelID};
 use raidillon_ecs::components::ModelHandle;
 use crate::model::Model;
@@ -21,7 +23,7 @@ pub struct BasicMeshRenderingSystem {
 }
 
 impl RenderingSystem for BasicMeshRenderingSystem {
-    fn initialize(display: &Display<WindowSurface>, _window: Arc<Mutex<glium::winit::window::Window>>) -> Self {
+    fn initialize(display: &Display<WindowSurface>, _window: Arc<Mutex<glium::winit::window::Window>>, event_loop: &EventLoop<()>) -> 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,75 +0,0 @@
-use std::sync::{Arc, Mutex};
-use std::time::Instant;
-use glium::Display;
-use glium::glutin::surface::WindowSurface;
-use imgui::{Context as ImguiContext};
-use imgui_winit_support::{HiDpiMode, WinitPlatform};
-use imgui_glium_renderer::Renderer as ImguiGliumRenderer;
-use winit::window::Window;
-use winit::event::Event;
-use glium::Frame;
-use crate::RenderingSystem;
-use crate::system::RenderingContext;
-
-pub struct ImguiBridge {
-    imgui: ImguiContext,
-    platform: WinitPlatform,
-    renderer: ImguiGliumRenderer,
-    last_frame: Instant,
-    rendered_this_frame: bool,
-}
-
-impl RenderingSystem for ImguiBridge {
-    fn handle_event(&mut self, window: Arc<Mutex<Window>>, event: Event<()>) {
-        let window = window.lock().unwrap();
-        self.platform.handle_event(self.imgui.io_mut(), &*window, &event);
-    }
-
-    fn prepare_frame(&mut self, window: Arc<Mutex<Window>>) {
-        self.rendered_this_frame = false;
-        let now = Instant::now();
-        self.imgui.io_mut().update_delta_time(now - self.last_frame);
-        self.last_frame = now;
-        let window = window.lock().unwrap();
-        self.platform
-            .prepare_frame(self.imgui.io_mut(), &*window)
-            .expect("Failed to prepare frame");
-    }
-
-    fn render(&mut self, ctx: &mut RenderingContext) {
-        if self.rendered_this_frame { return; }
-        self.rendered_this_frame = true;
-
-        let ui = self.imgui.frame();
-        ctx.debug_ui_buffer.write_buffer(&ui);
-
-        {
-            let window = ctx.window.lock().unwrap();
-            self.platform.prepare_render(&ui, &*window);
-        }
-        let draw_data = self.imgui.render();
-        if draw_data.total_vtx_count == 0 && draw_data.total_idx_count == 0 {
-            return;
-        }
-
-        self.renderer.render(ctx.target, draw_data).expect("imgui rendering failed");
-    }
-
-    fn initialize(display: &Display<WindowSurface>, window: Arc<Mutex<Window>>) -> Self {
-        let mut imgui = ImguiContext::create();
-        imgui.set_ini_filename(None);
-        let mut platform = WinitPlatform::new(&mut imgui);
-        let window = window.lock().unwrap();
-        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,
-            last_frame: Instant::now(),
-            rendered_this_frame: false,
-        }
-    }
-}

glium_platform/src/render/egui.rs

@@ -0,0 +1,46 @@
+use std::sync::{Arc, Mutex};
+use egui::ViewportId;
+use glium::{Display, Frame};
+use glium::glutin::surface::WindowSurface;
+use winit::window::Window;
+use crate::RenderingSystem;
+use crate::system::RenderingContext;
+use egui_glium::EguiGlium;
+use winit::event::{Event, WindowEvent};
+use winit::event_loop::EventLoop;
+
+pub struct EguiRenderer {
+    egui_glium: EguiGlium,
+}
+
+impl RenderingSystem for EguiRenderer {
+    fn initialize(display: &Display<WindowSurface>, window: Arc<Mutex<Window>>, event_loop: &EventLoop<()>) -> Self
+    where
+        Self: Sized,
+    {
+        let window = window.lock().unwrap();
+        let egui_glium = EguiGlium::new(ViewportId::ROOT, &display, &window, &event_loop);
+
+        Self { egui_glium }
+    }
+
+    fn render(&mut self, ctx: &mut RenderingContext) {
+        let window = ctx.window.lock().unwrap();
+
+        self.egui_glium.run(&window, |egui_ctx| {
+            ctx.egui_queue.borrow_mut().run(egui_ctx);
+        });
+
+        self.egui_glium.paint(ctx.display, ctx.target);
+    }
+
+    fn handle_event(&mut self, window: Arc<Mutex<Window>>, event: Event<()>) {
+        let window = window.lock().unwrap();
+        match event {
+            Event::WindowEvent { event, .. } => {
+                let _ = self.egui_glium.on_event(&window, &event);
+            }
+            _ => {},
+        }
+    }
+}

glium_platform/src/render/mod.rs

@@ -1,6 +1,7 @@
 mod basic;
-pub mod debug_ui;
 mod skybox;
+mod egui;
 
 pub use basic::BasicMeshRenderingSystem;
 pub use skybox::SkyboxRenderingSystem;
+pub use egui::EguiRenderer;

glium_platform/src/render/skybox.rs

@@ -8,6 +8,7 @@ use glium::index::PrimitiveType;
 use glium::texture::{RawImage2d, SrgbTexture2d, Texture2d};
 use glium::uniform;
 use glam::{Mat4, Vec2, Vec3};
+use winit::event_loop::EventLoop;
 use raidillon_assets::include_shader;
 use crate::system::RenderingContext;
 use crate::RenderingSystem;
@@ -109,7 +110,7 @@ impl SkyboxRenderingSystem {
 }
 
 impl RenderingSystem for SkyboxRenderingSystem {
-	fn initialize(display: &Display<WindowSurface>, _window: Arc<Mutex<glium::winit::window::Window>>) -> Self {
+	fn initialize(display: &Display<WindowSurface>, _window: Arc<Mutex<glium::winit::window::Window>>, event_loop: &EventLoop<()>) -> Self {
 		const VERT_SRC: &str = include_shader!("skybox.vert");
 		const FRAG_SRC: &str = include_shader!("skybox.frag");
 		let program = Program::from_source(display, VERT_SRC, FRAG_SRC, None).unwrap();

glium_platform/src/system.rs

@@ -6,16 +6,19 @@ use indexmap::IndexMap;
 use glium::{Display, Frame};
 use glium::glutin::surface::WindowSurface;
 use raidillon_assets::ModelManagerRef;
-use raidillon_core::{define_typemap, DebugUIBuffer};
+use raidillon_core::{define_typemap, DebugUIBuffer, EguiQueue};
 use raidillon_core::scene::Scene;
 use glam::Vec3;
+use winit::event_loop::EventLoop;
 
 pub struct RenderingContext<'a> {
     pub scene: &'a Scene,
     pub target: &'a mut Frame,
     pub window: Arc<Mutex<glium::winit::window::Window>>,
+    pub display: &'a Display<WindowSurface>,
     pub asset_manager: ModelManagerRef,
     pub debug_ui_buffer: &'a DebugUIBuffer,
+    pub egui_queue: Rc<RefCell<EguiQueue>>,
     pub env_light_dir: Vec3,
 }
 
@@ -30,7 +33,7 @@ pub trait RenderingSystem {
     }
     fn prepare_frame(&mut self, _window: Arc<Mutex<glium::winit::window::Window>>) {}
     fn render(&mut self, ctx: &mut RenderingContext);
-    fn initialize(display: &Display<WindowSurface>, window: Arc<Mutex<glium::winit::window::Window>>) -> Self
+    fn initialize(display: &Display<WindowSurface>, window: Arc<Mutex<glium::winit::window::Window>>, event_loop: &EventLoop<()>) -> Self
     where
         Self: Sized;
 }
@@ -48,11 +51,11 @@ impl RenderingSystemManager {
         }
     }
 
-    pub fn add<R>(&mut self, display: &Display<WindowSurface>, window: Arc<Mutex<glium::winit::window::Window>>)
+    pub fn add<R>(&mut self, display: &Display<WindowSurface>, window: Arc<Mutex<glium::winit::window::Window>>, event_loop: &EventLoop<()>)
     where
         R: RenderingSystem + 'static,
     {
-        let system = R::initialize(display, window);
+        let system = R::initialize(display, window, event_loop);
         self.systems.insert(TypeId::of::<R>(), Box::new(system));
     }