From 6a10035f153dae907c42d60825fae81a91866920 Mon Sep 17 00:00:00 2001
From: Matt Thompson <matt@boondocker.io>
Date: Sat, 22 Feb 2025 16:39:17 -0800
Subject: [PATCH 1/7] Fixes missed RequestRedraw events in about_to_wait()

This fixes RequestRedraw events that can be missed in `about_to_wait()` which was reading from the cursor before `run_app_update()` is called.

This adds a subsequent read to update the redraw_requested flag if any `RequestRedraw` were sent.

Was reported in #16817
---
 crates/bevy_winit/src/state.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/crates/bevy_winit/src/state.rs b/crates/bevy_winit/src/state.rs
index f2e2a09a6e..60ccff3538 100644
--- a/crates/bevy_winit/src/state.rs
+++ b/crates/bevy_winit/src/state.rs
@@ -651,6 +651,15 @@ impl<T: Event> WinitAppRunnerState<T> {
                 #[cfg(not(feature = "custom_cursor"))]
                 self.update_cursors();
                 self.ran_update_since_last_redraw = true;
+
+                // Read RequestRedraw events that may have been sent during the update
+                if let Some(app_redraw_events) =
+                    self.world().get_resource::<Events<RequestRedraw>>()
+                {
+                    if redraw_event_reader.read(app_redraw_events).last().is_some() {
+                        self.redraw_requested = true;
+                    }
+                }
             } else {
                 self.redraw_requested = true;
             }

From 81f82377949af1e58c087362855778a5e99a5e7c Mon Sep 17 00:00:00 2001
From: Aaron Loucks <aloucks@cofront.net>
Date: Sat, 22 Mar 2025 19:15:44 -0400
Subject: [PATCH 2/7] Add test for missed request redraw events

---
 Cargo.toml                             |  8 +++
 tests/window/desktop_request_redraw.rs | 87 ++++++++++++++++++++++++++
 2 files changed, 95 insertions(+)
 create mode 100644 tests/window/desktop_request_redraw.rs

diff --git a/Cargo.toml b/Cargo.toml
index af2d9d356c..cb14720a69 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3635,6 +3635,14 @@ doc-scrape-examples = true
 [package.metadata.example.minimizing]
 hidden = true
 
+[[example]]
+name = "desktop_request_redraw"
+path = "tests/window/desktop_request_redraw.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.desktop_request_redraw]
+hidden = true
+
 [[example]]
 name = "window_resizing"
 path = "examples/window/window_resizing.rs"
diff --git a/tests/window/desktop_request_redraw.rs b/tests/window/desktop_request_redraw.rs
new file mode 100644
index 0000000000..cb0ab38f1d
--- /dev/null
+++ b/tests/window/desktop_request_redraw.rs
@@ -0,0 +1,87 @@
+//! Desktop request redraw
+use bevy::{prelude::*, window::RequestRedraw, winit::WinitSettings};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(MeshPickingPlugin)
+        .insert_resource(WinitSettings::desktop_app())
+        .add_systems(Startup, setup)
+        .add_systems(Update, (update, redraw.after(update)))
+        .run();
+}
+
+#[derive(Component)]
+struct AnimationActive;
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 5.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    commands.spawn((
+        PointLight {
+            intensity: 1e6,
+            ..Default::default()
+        },
+        Transform::from_xyz(-1.0, 5.0, 1.0),
+    ));
+
+    let node = Node {
+        display: Display::Block,
+        padding: UiRect::all(Val::Px(10.0)),
+        row_gap: Val::Px(10.0),
+        ..Default::default()
+    };
+
+    commands.spawn((
+        node.clone(),
+        children![
+            (
+                node.clone(),
+                children![Text::new("Right click cube to pause animation")]
+            ),
+            (
+                node.clone(),
+                children![Text::new("Left click cube to start animation")]
+            )
+        ],
+    ));
+
+    commands
+        .spawn((
+            Mesh3d(meshes.add(Cuboid::from_length(1.0))),
+            MeshMaterial3d(materials.add(Color::WHITE)),
+            AnimationActive,
+        ))
+        .observe(
+            |trigger: Trigger<Pointer<Click>>, mut commands: Commands| match trigger.button {
+                PointerButton::Primary => {
+                    commands.entity(trigger.target()).insert(AnimationActive);
+                }
+                PointerButton::Secondary => {
+                    commands
+                        .entity(trigger.target())
+                        .remove::<AnimationActive>();
+                }
+                _ => {}
+            },
+        );
+}
+
+fn update(time: Res<Time>, mut query: Query<&mut Transform, With<AnimationActive>>) {
+    if let Ok(mut transform) = query.single_mut() {
+        transform.rotate_x(time.delta_secs().min(1.0 / 60.0));
+    }
+}
+
+fn redraw(mut commands: Commands, query: Query<Entity, With<AnimationActive>>) {
+    if query.iter().next().is_some() {
+        commands.send_event(RequestRedraw);
+    }
+}

From 1d3dee374469dae3240acc94998827720b11c995 Mon Sep 17 00:00:00 2001
From: Aaron Loucks <aloucks@cofront.net>
Date: Sat, 22 Mar 2025 19:17:34 -0400
Subject: [PATCH 3/7] Prevent reading RequestRedraw events before the world
 update

They are now read after the world update.
---
 crates/bevy_winit/src/state.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/crates/bevy_winit/src/state.rs b/crates/bevy_winit/src/state.rs
index 60ccff3538..ffab9ff6dc 100644
--- a/crates/bevy_winit/src/state.rs
+++ b/crates/bevy_winit/src/state.rs
@@ -541,12 +541,6 @@ impl<T: Event> WinitAppRunnerState<T> {
         let mut focused_windows_state: SystemState<(Res<WinitSettings>, Query<(Entity, &Window)>)> =
             SystemState::new(self.world_mut());
 
-        if let Some(app_redraw_events) = self.world().get_resource::<Events<RequestRedraw>>() {
-            if redraw_event_reader.read(app_redraw_events).last().is_some() {
-                self.redraw_requested = true;
-            }
-        }
-
         let (config, windows) = focused_windows_state.get(self.world());
         let focused = windows.iter().any(|(_, window)| window.focused);
 

From da40715bf180d20d80c514cfd1164c1438f84be8 Mon Sep 17 00:00:00 2001
From: Aaron Loucks <aloucks@cofront.net>
Date: Tue, 25 Mar 2025 16:36:56 -0400
Subject: [PATCH 4/7] Add FPS overlay to desktop_request_redraw test

---
 Cargo.toml                             |  1 +
 tests/window/desktop_request_redraw.rs | 24 +++++++++++++++++++++++-
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index cb14720a69..aad213062d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3639,6 +3639,7 @@ hidden = true
 name = "desktop_request_redraw"
 path = "tests/window/desktop_request_redraw.rs"
 doc-scrape-examples = true
+required-features = ["bevy_dev_tools"]
 
 [package.metadata.example.desktop_request_redraw]
 hidden = true
diff --git a/tests/window/desktop_request_redraw.rs b/tests/window/desktop_request_redraw.rs
index cb0ab38f1d..61c5ee5c66 100644
--- a/tests/window/desktop_request_redraw.rs
+++ b/tests/window/desktop_request_redraw.rs
@@ -1,10 +1,32 @@
 //! Desktop request redraw
-use bevy::{prelude::*, window::RequestRedraw, winit::WinitSettings};
+use bevy::{
+    dev_tools::fps_overlay::{FpsOverlayConfig, FpsOverlayPlugin},
+    prelude::*,
+    window::RequestRedraw,
+    winit::WinitSettings,
+};
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_plugins(MeshPickingPlugin)
+        // Enable the FPS overlay with a high resolution refresh interval. This makes it
+        // easier to validate that UpdateMode is behaving correctly when desktop_app is used.
+        // The FPS counter should essentially pause when the cube is not rotating and should
+        // update rapidly when the cube is rotating or there is input (e.g. moving the mouse).
+        //
+        // Left and Right clicking the cube should roggle rotation on/off.
+        .add_plugins(FpsOverlayPlugin {
+            config: FpsOverlayConfig {
+                text_config: TextFont {
+                    font_size: 12.0,
+                    ..default()
+                },
+                text_color: Color::srgb(0.0, 1.0, 0.0),
+                refresh_interval: core::time::Duration::from_millis(16),
+                ..default()
+            },
+        })
         .insert_resource(WinitSettings::desktop_app())
         .add_systems(Startup, setup)
         .add_systems(Update, (update, redraw.after(update)))

From 61ba0fbfb6aa30d9249fe0376318f107e3c24cf3 Mon Sep 17 00:00:00 2001
From: Aaron Loucks <aloucks@cofront.net>
Date: Sat, 29 Mar 2025 11:44:26 -0400
Subject: [PATCH 5/7] Process WindowCloseRequested events after app update

Pressing the window close button when in a reactive UpdateMode
isn't handled until the reactive wait timeout is triggered or
the user triggers some other device event. This change adds an
explict check for the WindowCloseRequested event to trigger
another app update to process it.
---
 crates/bevy_winit/src/state.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/crates/bevy_winit/src/state.rs b/crates/bevy_winit/src/state.rs
index ffab9ff6dc..155e7aa072 100644
--- a/crates/bevy_winit/src/state.rs
+++ b/crates/bevy_winit/src/state.rs
@@ -537,6 +537,7 @@ impl<T: Event> ApplicationHandler<T> for WinitAppRunnerState<T> {
 impl<T: Event> WinitAppRunnerState<T> {
     fn redraw_requested(&mut self, event_loop: &ActiveEventLoop) {
         let mut redraw_event_reader = EventCursor::<RequestRedraw>::default();
+        let mut close_event_reader = EventCursor::<WindowCloseRequested>::default();
 
         let mut focused_windows_state: SystemState<(Res<WinitSettings>, Query<(Entity, &Window)>)> =
             SystemState::new(self.world_mut());
@@ -662,6 +663,19 @@ impl<T: Event> WinitAppRunnerState<T> {
             let (config, windows) = focused_windows_state.get(self.world());
             let focused = windows.iter().any(|(_, window)| window.focused);
             update_mode = config.update_mode(focused);
+
+            // Running the app may have produced WindowCloseRequested events that should be processed
+            if let Some(close_request_events) =
+                self.world().get_resource::<Events<WindowCloseRequested>>()
+            {
+                if close_event_reader
+                    .read(close_request_events)
+                    .last()
+                    .is_some()
+                {
+                    self.redraw_requested = true;
+                }
+            }
         }
 
         // The update mode could have been changed, so we need to redraw and force an update

From bf645cff7951ff8f056070c15e2adc1fa04f6d27 Mon Sep 17 00:00:00 2001
From: Aaron Loucks <aloucks@cofront.net>
Date: Sat, 29 Mar 2025 11:49:54 -0400
Subject: [PATCH 6/7] Move RequestRedraw check

---
 crates/bevy_winit/src/state.rs | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_winit/src/state.rs b/crates/bevy_winit/src/state.rs
index 155e7aa072..3e3bd3ba28 100644
--- a/crates/bevy_winit/src/state.rs
+++ b/crates/bevy_winit/src/state.rs
@@ -646,15 +646,6 @@ impl<T: Event> WinitAppRunnerState<T> {
                 #[cfg(not(feature = "custom_cursor"))]
                 self.update_cursors();
                 self.ran_update_since_last_redraw = true;
-
-                // Read RequestRedraw events that may have been sent during the update
-                if let Some(app_redraw_events) =
-                    self.world().get_resource::<Events<RequestRedraw>>()
-                {
-                    if redraw_event_reader.read(app_redraw_events).last().is_some() {
-                        self.redraw_requested = true;
-                    }
-                }
             } else {
                 self.redraw_requested = true;
             }
@@ -676,6 +667,13 @@ impl<T: Event> WinitAppRunnerState<T> {
                     self.redraw_requested = true;
                 }
             }
+
+            // Read RequestRedraw events that may have been sent during the update
+            if let Some(app_redraw_events) = self.world().get_resource::<Events<RequestRedraw>>() {
+                if redraw_event_reader.read(app_redraw_events).last().is_some() {
+                    self.redraw_requested = true;
+                }
+            }
         }
 
         // The update mode could have been changed, so we need to redraw and force an update

From 4c116a90e65f92930f5a2d0f2f27d511806a6ae9 Mon Sep 17 00:00:00 2001
From: Aaron Loucks <aloucks@cofront.net>
Date: Sat, 29 Mar 2025 11:52:33 -0400
Subject: [PATCH 7/7] Reorder request_redraw checks so that the update_mode
 logic is localized

---
 crates/bevy_winit/src/state.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_winit/src/state.rs b/crates/bevy_winit/src/state.rs
index 3e3bd3ba28..ac97edf2ce 100644
--- a/crates/bevy_winit/src/state.rs
+++ b/crates/bevy_winit/src/state.rs
@@ -650,10 +650,12 @@ impl<T: Event> WinitAppRunnerState<T> {
                 self.redraw_requested = true;
             }
 
-            // Running the app may have changed the WinitSettings resource, so we have to re-extract it.
-            let (config, windows) = focused_windows_state.get(self.world());
-            let focused = windows.iter().any(|(_, window)| window.focused);
-            update_mode = config.update_mode(focused);
+            // Read RequestRedraw events that may have been sent during the update
+            if let Some(app_redraw_events) = self.world().get_resource::<Events<RequestRedraw>>() {
+                if redraw_event_reader.read(app_redraw_events).last().is_some() {
+                    self.redraw_requested = true;
+                }
+            }
 
             // Running the app may have produced WindowCloseRequested events that should be processed
             if let Some(close_request_events) =
@@ -668,12 +670,10 @@ impl<T: Event> WinitAppRunnerState<T> {
                 }
             }
 
-            // Read RequestRedraw events that may have been sent during the update
-            if let Some(app_redraw_events) = self.world().get_resource::<Events<RequestRedraw>>() {
-                if redraw_event_reader.read(app_redraw_events).last().is_some() {
-                    self.redraw_requested = true;
-                }
-            }
+            // Running the app may have changed the WinitSettings resource, so we have to re-extract it.
+            let (config, windows) = focused_windows_state.get(self.world());
+            let focused = windows.iter().any(|(_, window)| window.focused);
+            update_mode = config.update_mode(focused);
         }
 
         // The update mode could have been changed, so we need to redraw and force an update