Throttle invisible window repaints to prevent high CPU usage

Schedule a 100ms heartbeat for invisible windows so they keep
processing viewport commands (e.g. Visible(true)) without spinning
the event loop. Also skip ControlFlow::Poll for invisible windows
and throttle their RequestRepaint events.

Closes #7776

Author: gcailly

crates/eframe/src/native/glow_integration.rs

@@ -744,9 +744,11 @@ impl GlowWinitRunning<'_> {
 
         integration.maybe_autosave(app.as_mut(), Some(&window));
 
-        if window.is_minimized() == Some(true) {
+        if window.is_minimized() == Some(true) || window.is_visible() == Some(false) {
             // On Mac, a minimized Window uses up all CPU:
             // https://github.com/emilk/egui/issues/325
+            // On Windows, an invisible window also uses up all CPU:
+            // https://github.com/emilk/egui/issues/7776
             profiling::scope!("minimized_sleep");
             std::thread::sleep(std::time::Duration::from_millis(10));
         }

crates/eframe/src/native/run.rs

@@ -185,19 +185,18 @@ impl<T: WinitApp> WinitAppWrapper<T> {
                     return true; // not yet ready
                 }
 
-                event_loop.set_control_flow(ControlFlow::Poll);
-
                 if let Some(window) = self.winit_app.window(*window_id) {
-                    log::trace!("request_redraw for {window_id:?}");
-                    window.request_redraw();
-
                     // On Windows, invisible windows don't receive RedrawRequested
                     // events, so pending viewport commands (e.g. Visible(true)) would
                     // never be processed. We collect these windows to paint them
                     // directly below.
                     // See: https://github.com/emilk/egui/issues/5229
                     if window.is_visible() == Some(false) {
                         invisible_window_ids.push(*window_id);
+                    } else {
+                        log::trace!("request_redraw for {window_id:?}");
+                        event_loop.set_control_flow(ControlFlow::Poll);
+                        window.request_redraw();
                     }
                 } else {
                     log::trace!("No window found for {window_id:?}");
@@ -208,11 +207,24 @@ impl<T: WinitApp> WinitAppWrapper<T> {
         // Paint invisible windows directly, since they won't receive
         // RedrawRequested events on Windows. This ensures that viewport
         // commands like Visible(true) are still processed.
-        for window_id in invisible_window_ids {
-            let event_result = self.winit_app.run_ui_and_paint(event_loop, window_id);
+        for window_id in &invisible_window_ids {
+            let event_result = self.winit_app.run_ui_and_paint(event_loop, *window_id);
             self.handle_event_result(event_loop, event_result);
         }
 
+        // Schedule a throttled repaint for invisible windows so they keep
+        // processing viewport commands even when egui doesn't request repaints.
+        // See: https://github.com/emilk/egui/issues/7776
+        if !invisible_window_ids.is_empty() {
+            let next_paint = Instant::now() + std::time::Duration::from_millis(100);
+            for window_id in &invisible_window_ids {
+                self.windows_next_repaint_times
+                    .entry(*window_id)
+                    .and_modify(|t| *t = (*t).min(next_paint))
+                    .or_insert(next_paint);
+            }
+        }
+
         let next_repaint_time = self.windows_next_repaint_times.values().min().copied();
         if let Some(next_repaint_time) = next_repaint_time {
             event_loop.set_control_flow(ControlFlow::WaitUntil(next_repaint_time));
@@ -289,6 +301,16 @@ impl<T: WinitApp> ApplicationHandler<UserEvent> for WinitAppWrapper<T> {
                         if let Some(window_id) =
                             self.winit_app.window_id_from_viewport_id(viewport_id)
                         {
+                            // Throttle repaints for invisible windows to prevent
+                            // high CPU usage on Windows.
+                            // See: https://github.com/emilk/egui/issues/7776
+                            let when = if let Some(window) = self.winit_app.window(window_id)
+                                && window.is_visible() == Some(false)
+                            {
+                                when.max(Instant::now() + std::time::Duration::from_millis(100))
+                            } else {
+                                when
+                            };
                             Ok(EventResult::RepaintAt(window_id, when))
                         } else {
                             Ok(EventResult::Wait)

crates/eframe/src/native/wgpu_integration.rs

@@ -748,10 +748,12 @@ impl WgpuWinitRunning<'_> {
         integration.maybe_autosave(app.as_mut(), window.map(|w| w.as_ref()));
 
         if let Some(window) = window
-            && window.is_minimized() == Some(true)
+            && (window.is_minimized() == Some(true) || window.is_visible() == Some(false))
         {
             // On Mac, a minimized Window uses up all CPU:
             // https://github.com/emilk/egui/issues/325
+            // On Windows, an invisible window also uses up all CPU:
+            // https://github.com/emilk/egui/issues/7776
             profiling::scope!("minimized_sleep");
             std::thread::sleep(std::time::Duration::from_millis(10));
         }