Refactored redraw/update handling

Tracking redraw vs update needed to be more granular so that WakeUp
could be used to trigger Window::update() without causing a refresh.

app/src/lib.rs

@@ -31,7 +31,7 @@ pub use self::{
     application::{Application, SingleWindowApplication},
     error::Error,
     runtime::Runtime,
-    window::{event, RedrawStatus, Window, WindowBuilder, WindowCreator},
+    window::{event, RedrawRequester, RedrawStatus, Window, WindowBuilder, WindowCreator},
 };
 
 /// A collection of commonly used exports provided by this crate.
@@ -41,8 +41,8 @@ pub mod prelude {
             DeviceId, ElementState, Event, EventStatus, InputEvent, MouseButton, MouseScrollDelta,
             ScanCode, TouchPhase, VirtualKeyCode,
         },
-        Application, Error, RedrawStatus, Runtime, SingleWindowApplication, Window, WindowBuilder,
-        WindowCreator,
+        Application, Error, RedrawRequester, RedrawStatus, Runtime, SingleWindowApplication,
+        Window, WindowBuilder, WindowCreator,
     };
 }
 

app/src/window.rs

@@ -18,10 +18,10 @@ use crate::Error;
 
 /// Types for event handling.
 pub mod event;
-pub mod open;
+mod open;
 mod runtime_window;
 
-pub use open::{OpenWindow, RedrawStatus};
+pub use open::{OpenWindow, RedrawRequester, RedrawStatus};
 pub use runtime_window::{opened_first_window, RuntimeWindow, RuntimeWindowConfig};
 pub use winit::window::Icon;
 
@@ -38,7 +38,7 @@ pub enum CloseResponse {
 /// Trait to implement a Window
 pub trait Window: Send + Sync + 'static {
     /// Called when the window is being initilaized.
-    fn initialize(&mut self, _scene: &Target) -> crate::Result<()>
+    fn initialize(&mut self, _scene: &Target, _redrawer: RedrawRequester) -> crate::Result<()>
     where
         Self: Sized,
     {

app/src/window/open.rs

@@ -19,11 +19,32 @@ pub struct OpenWindow<T: Window> {
     scene: Arc<Scene>,
 }
 
+/// Allows requesting window refreshes outside of the event loop.
+#[derive(Clone, Debug)]
+pub struct RedrawRequester {
+    event_sender: Sender<WindowEvent>,
+}
+
+impl RedrawRequester {
+    /// Requests the window refresh itself. This will trigger [`Window::update`]
+    /// before rendering.
+    pub fn request_redraw(&self) {
+        let _ = self.event_sender.send(WindowEvent::RedrawRequested);
+    }
+
+    /// Wakes the event loop, without necessarily redrawing.
+    pub fn awaken(&self) {
+        let _ = self.event_sender.send(WindowEvent::WakeUp);
+    }
+}
+
 /// Tracks when a window should be redrawn. Allows for rendering a frame
 /// immediately as well as scheduling a refresh in the future.
+#[derive(Debug)]
 pub struct RedrawStatus {
     next_redraw_target: RedrawTarget,
     needs_render: bool,
+    needs_update: bool,
     event_sender: Sender<WindowEvent>,
 }
 
@@ -37,6 +58,14 @@ impl RedrawStatus {
         }
     }
 
+    /// Triggers an update as soon as possible. Does not affect redrawing.
+    pub fn set_needs_update(&mut self) {
+        if !self.needs_render {
+            self.needs_render = true;
+            let _ = self.event_sender.send(WindowEvent::WakeUp);
+        }
+    }
+
     /// Estimates the next redraw instant by adding `duration` to
     /// `Instant::now()`. If this is later than the current estimate, it
     /// will be ignored.
@@ -57,6 +86,14 @@ impl RedrawStatus {
                 },
         }
     }
+
+    /// Returns a redraw requester that can be used outside of the event loop.
+    #[must_use]
+    pub fn redraw_requester(&self) -> RedrawRequester {
+        RedrawRequester {
+            event_sender: self.event_sender.clone(),
+        }
+    }
 }
 
 impl<T: Window> OpenWindow<T> {
@@ -66,6 +103,7 @@ impl<T: Window> OpenWindow<T> {
             scene: Arc::new(scene),
             redraw_status: RedrawStatus {
                 needs_render: true,
+                needs_update: true,
                 next_redraw_target: RedrawTarget::None,
                 event_sender,
             },
@@ -77,6 +115,10 @@ impl<T: Window> OpenWindow<T> {
         self.redraw_status.next_redraw_target = RedrawTarget::None;
     }
 
+    pub(crate) fn set_has_updated(&mut self) {
+        self.redraw_status.needs_update = false;
+    }
+
     pub(crate) fn initialize_redraw_target(&mut self, target_fps: Option<u16>) {
         if let RedrawTarget::None = self.redraw_status.next_redraw_target {
             match target_fps {
@@ -98,7 +140,11 @@ impl<T: Window> OpenWindow<T> {
         self.redraw_status.next_redraw_target
     }
 
-    pub fn needs_render(&self) -> bool {
+    pub(crate) fn can_wait_for_events(&self) -> bool {
+        !self.should_redraw_now() && !self.redraw_status.needs_update
+    }
+
+    pub(crate) fn should_redraw_now(&self) -> bool {
         self.redraw_status.needs_render
             || match self.redraw_status.next_redraw_target {
                 RedrawTarget::Never | RedrawTarget::None => false,
@@ -120,29 +166,35 @@ impl<T: Window> OpenWindow<T> {
     }
 
     pub(crate) fn initialize(&mut self) -> crate::Result<()> {
-        self.window.initialize(&Target {
-            scene: self.scene.clone(),
-            clip: None,
-            offset: None,
-        })?;
+        self.window.initialize(
+            &Target {
+                scene: self.scene.clone(),
+                clip: None,
+                offset: None,
+            },
+            self.redraw_status.redraw_requester(),
+        )?;
 
         Ok(())
     }
 
     pub(crate) fn render(&mut self) -> crate::Result<()> {
+        // Clear the redraw target first, so that if something inside of render
+        // (or another thread) requests a redraw it will still be honored.
+        self.clear_redraw_target();
+
         self.window.render(&Target {
             scene: self.scene.clone(),
             clip: None,
             offset: None,
         })?;
 
-        self.clear_redraw_target();
-
         Ok(())
     }
 
     pub(crate) fn update(&mut self, target_fps: Option<u16>) -> crate::Result<()> {
         self.initialize_redraw_target(target_fps);
+        self.set_has_updated();
 
         self.window.update(
             &Target {

app/src/window/runtime_window.rs

@@ -220,7 +220,7 @@ impl RuntimeWindow {
         #[cfg(not(target_arch = "wasm32"))]
         {
             let next_redraw_target = window.next_redraw_target();
-            if window.needs_render() {
+            if !window.can_wait_for_events() {
                 Self::next_window_event_non_blocking(event_receiver)
             } else if let Some(redraw_at) = next_redraw_target.next_update_instant() {
                 let timeout_target = redraw_at.timeout_target();
@@ -262,7 +262,9 @@ impl RuntimeWindow {
                 Err(_) => return Ok(()),
             } {
                 match event {
-                    WindowEvent::WakeUp => {}
+                    WindowEvent::WakeUp => {
+                        window.redraw_status.set_needs_update();
+                    }
                     WindowEvent::SystemThemeChanged(system_theme) => {
                         window.scene_mut().set_system_theme(system_theme);
                         window.redraw_status.set_needs_redraw();
@@ -321,7 +323,7 @@ impl RuntimeWindow {
 
                 window.update(target_fps)?;
 
-                if window.needs_render() {
+                if window.should_redraw_now() {
                     window.render()?;
                     window.scene_mut().end_frame();
                 }

core/src/frame_renderer.rs

@@ -131,7 +131,7 @@ where
     ) -> crate::Result<DynamicImage> {
         let mut frame_renderer = Self::new(renderer, Arc::default(), scene_event_receiver);
         let mut frame = Frame::default();
-        frame.update(&frame_renderer.scene_event_receiver);
+        let _ = frame.update(&frame_renderer.scene_event_receiver);
         frame_renderer.render_frame(&mut frame)?;
         if let Destination::Texture { output, .. } = frame_renderer.destination {
             let data = output.slice(..);
@@ -197,9 +197,12 @@ where
                 }
                 return;
             }
-            frame.update(&self.scene_event_receiver);
-            self.render_frame(&mut frame)
-                .expect("Error rendering window");
+            if frame.update(&self.scene_event_receiver) {
+                self.render_frame(&mut frame)
+                    .expect("Error rendering window");
+            } else {
+                self.keep_running.store(false, Ordering::SeqCst)
+            }
         }
     }
 

core/src/frame_renderer/frame.rs

@@ -28,9 +28,13 @@ struct FrameReceiver {
 }
 
 impl FrameReceiver {
-    pub fn get_latest_frame(&mut self, receiver: &flume::Receiver<SceneEvent>) -> Vec<Element> {
+    pub fn get_latest_frame(
+        &mut self,
+        receiver: &flume::Receiver<SceneEvent>,
+    ) -> Option<Vec<Element>> {
         // Receive a frame, blocking until we get an EndFrame
-        while let Ok(evt) = receiver.recv() {
+        loop {
+            let evt = receiver.recv().ok()?;
             if self.process_scene_event(evt) {
                 // New frame
                 break;
@@ -45,7 +49,7 @@ impl FrameReceiver {
                 latest_frame = std::mem::replace(&mut self.elements, Vec::new());
             }
         }
-        latest_frame
+        Some(latest_frame)
     }
 
     fn process_scene_event(&mut self, event: SceneEvent) -> bool {
@@ -120,8 +124,12 @@ impl FrameBatch {
 
 impl Frame {
     #[instrument(name = "Frame::update", level = "trace", skip(self, event_receiver))]
-    pub fn update(&mut self, event_receiver: &flume::Receiver<SceneEvent>) {
-        let elements = self.receiver.get_latest_frame(event_receiver);
+    #[must_use]
+    pub fn update(&mut self, event_receiver: &flume::Receiver<SceneEvent>) -> bool {
+        let elements = match self.receiver.get_latest_frame(event_receiver) {
+            Some(elements) => elements,
+            None => return false,
+        };
         self.size = self.receiver.size;
         self.commands.clear();
 
@@ -208,6 +216,8 @@ impl Frame {
         for id in dead_texture_ids {
             self.textures.remove(&id);
         }
+
+        true
     }
 
     fn commit_batch(&mut self, batch: Option<FrameBatch>) -> Option<FrameBatch> {

kludgine/examples/isometric.rs

@@ -16,7 +16,7 @@ impl WindowCreator for Isometric {
 }
 static MAP_SIZE: u32 = 100;
 impl Window for Isometric {
-    fn initialize(&mut self, _scene: &Target) -> kludgine::Result<()> {
+    fn initialize(&mut self, _scene: &Target, _requester: RedrawRequester) -> kludgine::Result<()> {
         self.load_assets()?;
         // self.zoom = 1.0;
         // self.x = MAP_SIZE as f32 * 32.0 / 2.0;

kludgine/examples/orthotiles.rs

@@ -1,4 +1,5 @@
 use kludgine::prelude::*;
+use kludgine_app::RedrawRequester;
 
 fn main() {
     SingleWindowApplication::run(OrthoTiles::default());
@@ -25,7 +26,7 @@ impl Window for OrthoTiles {
         Some(60)
     }
 
-    fn initialize(&mut self, _scene: &Target) -> kludgine::Result<()> {
+    fn initialize(&mut self, _scene: &Target, _requester: RedrawRequester) -> kludgine::Result<()> {
         self.load_assets()?;
         self.zoom = 1.0;
         // self.position.x = MAP_SIZE as f32 * 32.0 / 2.0;

kludgine/examples/simple.rs

@@ -21,7 +21,7 @@ impl Window for Simple {
         Some(60)
     }
 
-    fn initialize(&mut self, _scene: &Target) -> kludgine::Result<()> {
+    fn initialize(&mut self, _scene: &Target, _requester: RedrawRequester) -> kludgine::Result<()> {
         let texture = Texture::load("kludgine/examples/assets/k.png")?;
         self.source_sprite = Some(SpriteSource::entire_texture(texture));
         Ok(())

kludgine/examples/sprite_sheets.rs

@@ -33,7 +33,7 @@ enum StickGuy {
 }
 
 impl Window for SpriteSheetExample {
-    fn initialize(&mut self, _scene: &Target) -> kludgine::Result<()> {
+    fn initialize(&mut self, _scene: &Target, _requester: RedrawRequester) -> kludgine::Result<()> {
         let texture = include_texture!("assets/stickguy.png")?;
         let sheet = SpriteSheet::new(texture, Size::new(32, 32), vec![
             StickGuy::Idle1,