Fix imgui renderer once and for all

Finally solved the problems with the imgui renderer after a long chat with clankers. Fixed some other stuff as well.

Reminder to keep the rendered_this_frame check as that's what solved it. Probably a deeper issue down there that caused us to render twice, but whatever.

glium_platform/src/platform.rs

@@ -75,6 +75,11 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
         };
         self.engine.initialize(ctx.clone());
         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()));
+
             match event {
                 Event::WindowEvent { event, .. } => match event {
                     WindowEvent::CloseRequested => {
@@ -93,9 +98,10 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
                             debug_ui_buffer,
                         };
 
-                        for (system_id, system) in self.rendering_system_manager.systems.iter_mut() {
-                            system.render(&mut context);
-                        }
+                        self.rendering_system_manager
+                            .systems
+                            .iter_mut()
+                            .for_each(|(_, system)| system.render(&mut context));
                         target.finish().unwrap();
                     }
                     _ => {},
@@ -104,6 +110,10 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
                     let mut ctx2 = ctx.clone();
                     ctx2.current_event = event.clone();
                     self.engine.update(ctx2);
+                    self.rendering_system_manager
+                        .systems
+                        .iter_mut()
+                        .for_each(|(_, system)| system.prepare_frame(&mut self.window));
                     self.window.request_redraw();
                 }
                 _ => {},

glium_platform/src/render/debug_ui.rs

@@ -1,70 +1,55 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::sync::Arc;
 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::raw_window_handle::DisplayHandle;
 use winit::window::Window;
-use anyhow::{Result};
+use winit::event::Event;
+use glium::Frame;
 use crate::RenderingSystem;
 use crate::system::RenderingContext;
-use glium::Frame;
-use raidillon_core::DebugUIBuffer;
 
 pub struct ImguiBridge {
     imgui: ImguiContext,
     platform: WinitPlatform,
     renderer: ImguiGliumRenderer,
-}
-
-impl ImguiBridge {
-    pub fn render<F>(&mut self, target: &mut Frame, window: &Window, build_ui: F)
-    where
-        F: FnOnce(&imgui::Ui),
-    {
-        let ui = self.imgui.frame();
-
-        build_ui(&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");
-    // }
+    last_frame: Instant,
+    rendered_this_frame: bool,
 }
 
 impl RenderingSystem for ImguiBridge {
-    fn render(&mut self, ctx: &mut RenderingContext) {
-        let mut ui = self.imgui.frame();
+    fn handle_event(&mut self, window: &mut Window, event: Event<()>) {
+        self.platform.handle_event(self.imgui.io_mut(), window, &event);
+    }
 
-        ctx.debug_ui_buffer.borrow_mut().write_buffer(&mut ui);
+    fn prepare_frame(&mut self, window: &mut 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;
+        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.borrow().write_buffer(&ui);
 
         self.platform.prepare_render(&ui, ctx.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: &glium::winit::window::Window) -> Self
-    where
-        Self: Sized,
-    {
+    fn initialize(display: &Display<WindowSurface>, window: &Window) -> Self {
         let mut imgui = ImguiContext::create();
         imgui.set_ini_filename(None);
         let mut platform = WinitPlatform::new(&mut imgui);
@@ -76,6 +61,8 @@ impl RenderingSystem for ImguiBridge {
             imgui,
             platform,
             renderer,
+            last_frame: Instant::now(),
+            rendered_this_frame: false,
         }
     }
-}
+}

glium_platform/src/system.rs

@@ -19,6 +19,8 @@ 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 render(&mut self, ctx: &mut RenderingContext);
     fn initialize(display: &Display<WindowSurface>, window: &glium::winit::window::Window) -> Self where Self: Sized;
 }