simplify

Author: jacob-pro

app/src/gui/epi.rs

@@ -10,23 +10,4 @@ pub trait App {
     ///
     /// To force a repaint, call [`egui::Context::request_repaint`] at any time (e.g. from another thread).
     fn update(&mut self, ctx: &egui::Context);
-
-    /// Background color values for the app, e.g. what is sent to `gl.clearColor`.
-    ///
-    /// This is the background of your windows if you don't set a central panel.
-    ///
-    /// ATTENTION:
-    /// Since these float values go to the render as-is, any color space conversion as done
-    /// e.g. by converting from [`egui::Color32`] to [`egui::Rgba`] may cause incorrect results.
-    /// egui recommends that rendering backends use a normal "gamma-space" (non-sRGB-aware) blending,
-    ///  which means the values you return here should also be in `sRGB` gamma-space in the 0-1 range.
-    /// You can use [`egui::Color32::to_normalized_gamma_f32`] for this.
-    fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
-        // NOTE: a bright gray makes the shadows of the windows look weird.
-        // We use a bit of transparency so that if the user switches on the
-        // `transparent()` option they get immediate results.
-        egui::Color32::from_rgba_unmultiplied(12, 12, 12, 180).to_normalized_gamma_f32()
-
-        // _visuals.window_fill() would also be a natural choice
-    }
 }

app/src/gui/wgpu_app.rs

@@ -1,32 +1,20 @@
 //! Note that this file contains two similar paths - one for [`glow`], one for [`wgpu`].
 //! When making changes to one you often also want to apply it to the other.
 
-use std::time::Instant;
-
-use egui_winit::winit;
-use std::sync::Arc;
-use winit::event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget};
-
 use super::epi;
 use crate::common::APP_NAME;
-use crate::run;
+use crate::UserEvent;
 use egui_winit::egui;
 use egui_winit::egui::Visuals;
-use egui_winit::winit::event::Event;
-
-#[derive(Debug)]
-pub enum UserEvent {
-    OpenWindow,
-    Exit,
-    RequestRepaint {
-        when: Instant,
-        /// What the frame number was when the repaint was _requested_.
-        frame_nr: u64,
-    },
-}
+use egui_winit::winit;
+use egui_winit::winit::event::{Event, WindowEvent};
+use std::sync::Arc;
+use std::time::Instant;
+use winit::event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget};
 
 #[derive(Debug)]
-pub enum EventResult {
+pub enum NextPaint {
+    /// Wait for an event
     Wait,
 
     /// Causes a synchronous repaint inside the event handler. This should only
@@ -42,8 +30,10 @@ pub enum EventResult {
     /// cause any delay like `RepaintNow`.
     RepaintNext,
 
+    /// Repaint at a particular time
     RepaintAt(Instant),
 
+    /// Exit the event loop
     Exit,
 }
 
@@ -57,6 +47,12 @@ struct WgpuWinitRunning {
     egui_winit: egui_winit::State,
 }
 
+impl Drop for WgpuWinitRunning {
+    fn drop(&mut self) {
+        self.painter.destroy();
+    }
+}
+
 pub type AppCreator = Box<dyn Fn() -> Box<dyn epi::App>>;
 
 pub struct WgpuWinitApp {
@@ -74,10 +70,10 @@ impl WgpuWinitApp {
         }
     }
 
-    pub fn init_run_state(
+    pub fn launch_window(
         &mut self,
         event_loop: &EventLoopWindowTarget<UserEvent>,
-    ) -> anyhow::Result<()> {
+    ) -> anyhow::Result<NextPaint> {
         let window = winit::window::WindowBuilder::new()
             .with_decorations(true)
             .with_resizable(true)
@@ -114,7 +110,6 @@ impl WgpuWinitApp {
 
         let event_loop_proxy = self.repaint_proxy.clone();
         egui_ctx.set_request_repaint_callback(move |info| {
-            log::trace!("request_repaint_callback: {info:?}");
             let when = Instant::now() + info.after;
             let frame_nr = info.current_frame_nr;
             event_loop_proxy
@@ -134,7 +129,7 @@ impl WgpuWinitApp {
             egui_winit,
         });
 
-        Ok(())
+        Ok(NextPaint::RepaintNow)
     }
 
     pub fn frame_nr(&self) -> u64 {
@@ -145,13 +140,7 @@ impl WgpuWinitApp {
         self.running.as_ref().map(|r| &r.window)
     }
 
-    pub fn destroy(&mut self) {
-        if let Some(mut running) = self.running.take() {
-            running.painter.destroy();
-        }
-    }
-
-    pub fn run_ui_and_paint(&mut self) -> EventResult {
+    pub fn paint(&mut self) -> NextPaint {
         if let Some(running) = &mut self.running {
             let raw_input = running.egui_winit.take_egui_input(&running.window);
 
@@ -178,57 +167,45 @@ impl WgpuWinitApp {
 
             let clipped_primitives = { running.egui_ctx.tessellate(shapes) };
 
+            let clear_color =
+                egui::Color32::from_rgba_unmultiplied(12, 12, 12, 180).to_normalized_gamma_f32();
+
             running.painter.paint_and_update_textures(
                 running.egui_ctx.pixels_per_point(),
-                running.app.clear_color(&running.egui_ctx.style().visuals),
+                clear_color,
                 &clipped_primitives,
                 &textures_delta,
                 false,
             );
 
-            let control_flow = if repaint_after.is_zero() {
-                EventResult::RepaintNext
-            } else if let Some(repaint_after_instant) =
-                Instant::now().checked_add(repaint_after)
-            {
-                // if repaint_after is something huge and can't be added to Instant,
-                // we will use `ControlFlow::Wait` instead.
-                // technically, this might lead to some weird corner cases where the user *WANTS*
-                // winit to use `WaitUntil(MAX_INSTANT)` explicitly. they can roll their own
-                // egui backend impl i guess.
-                EventResult::RepaintAt(repaint_after_instant)
+            if repaint_after.is_zero() {
+                NextPaint::RepaintNext
+            } else if let Some(repaint_after_instant) = Instant::now().checked_add(repaint_after) {
+                NextPaint::RepaintAt(repaint_after_instant)
             } else {
-                EventResult::Wait
-            };
-
-            if running.window.is_minimized() == Some(true) {
-                // On Mac, a minimized Window uses up all CPU:
-                // https://github.com/emilk/egui/issues/325
-                // crate::profile_scope!("bg_sleep");
-                std::thread::sleep(std::time::Duration::from_millis(10));
+                NextPaint::Wait
             }
-
-            control_flow
         } else {
-            EventResult::Wait
+            NextPaint::Wait
         }
     }
 
     pub fn on_event(
         &mut self,
         event_loop: &EventLoopWindowTarget<UserEvent>,
         event: &Event<'_, UserEvent>,
-    ) -> anyhow::Result<EventResult> {
+    ) -> anyhow::Result<NextPaint> {
         Ok(match event {
-            e if matches!(e, Event::Resumed)
-                || matches!(e, Event::UserEvent(UserEvent::OpenWindow)) =>
-            {
-                if self.running.is_none() {
-                    self.init_run_state(event_loop)?;
-                }
-                EventResult::RepaintNow
+            // When the window is closed, we destroy the Window
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => {
+                self.running = None;
+                NextPaint::Wait
             }
-            Event::Suspended => EventResult::Wait,
+
+            Event::Resumed if self.running.is_none() => self.launch_window(event_loop)?,
 
             Event::WindowEvent { event, .. } => {
                 if let Some(running) = &mut self.running {
@@ -248,7 +225,7 @@ impl WgpuWinitApp {
                     let mut repaint_asap = false;
 
                     match &event {
-                        winit::event::WindowEvent::Resized(physical_size) => {
+                        WindowEvent::Resized(physical_size) => {
                             repaint_asap = true;
 
                             // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
@@ -260,21 +237,17 @@ impl WgpuWinitApp {
                                     .on_window_resized(physical_size.width, physical_size.height);
                             }
                         }
-                        winit::event::WindowEvent::ScaleFactorChanged {
-                            new_inner_size, ..
-                        } => {
+                        WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                             repaint_asap = true;
                             running
                                 .painter
                                 .on_window_resized(new_inner_size.width, new_inner_size.height);
                         }
-                        winit::event::WindowEvent::CloseRequested => {
+                        WindowEvent::CloseRequested => {
                             log::debug!("Received WindowEvent::CloseRequested");
-                            return Ok(EventResult::Exit);
+                            return Ok(NextPaint::Exit);
                         }
-                        winit::event::WindowEvent::ThemeChanged(winit_theme)
-                            if running.follow_system_theme =>
-                        {
+                        WindowEvent::ThemeChanged(winit_theme) if running.follow_system_theme => {
                             let visuals = visuals_from_winit_theme(*winit_theme);
                             running.egui_ctx.set_visuals(visuals);
                         }
@@ -285,19 +258,19 @@ impl WgpuWinitApp {
 
                     if event_response.repaint {
                         if repaint_asap {
-                            EventResult::RepaintNow
+                            NextPaint::RepaintNow
                         } else {
-                            EventResult::RepaintNext
+                            NextPaint::RepaintNext
                         }
                     } else {
-                        EventResult::Wait
+                        NextPaint::Wait
                     }
                 } else {
-                    EventResult::Wait
+                    NextPaint::Wait
                 }
             }
 
-            _ => EventResult::Wait,
+            _ => NextPaint::Wait,
         })
     }
 }