Repaint screen less often

src/app.rs

@@ -394,12 +394,6 @@ impl ApplicationHandler<UserEvent> for Application {
         }
     }
 
-    fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
-        if let Some(viewport) = self.viewports.get(&ViewportId::ROOT) {
-            viewport.window.request_redraw();
-        }
-    }
-
     fn window_event(
         &mut self,
         event_loop: &ActiveEventLoop,
@@ -418,7 +412,7 @@ impl ApplicationHandler<UserEvent> for Application {
         if close_requested && viewport_id == ViewportId::ROOT {
             event_loop.exit();
         }
-        if response.repaint {
+        if response.repaint && !matches!(event, WindowEvent::RedrawRequested) {
             viewport.window.request_redraw();
         }
         if !response.consumed {

src/graphics.rs

@@ -5,14 +5,19 @@ use std::{
         mpsc,
     },
     thread,
+    time::Instant,
 };
 
 use anyhow::{Result, bail};
+use egui::ViewportId;
 use itertools::Itertools as _;
 use wgpu::{
     Device, Extent3d, Origin3d, Queue, TexelCopyBufferLayout, TexelCopyTextureInfo, Texture,
     TextureDescriptor, TextureFormat, TextureUsages, TextureView, TextureViewDescriptor,
 };
+use winit::event_loop::EventLoopProxy;
+
+use crate::app::UserEvent;
 
 #[derive(Debug)]
 pub struct TextureSink {
@@ -21,7 +26,11 @@ pub struct TextureSink {
 }
 
 impl TextureSink {
-    pub fn new(device: &Device, queue: Queue) -> (Self, TextureView) {
+    pub fn new(
+        device: &Device,
+        queue: Queue,
+        proxy: EventLoopProxy<UserEvent>,
+    ) -> (Self, TextureView) {
         let texture = Self::create_texture(device);
         let view = texture.create_view(&TextureViewDescriptor::default());
         let buffers = Arc::new(BufferPool::new());
@@ -37,6 +46,12 @@ impl TextureSink {
                     local_buf.copy_from_slice(bytes.as_slice());
                 }
                 Self::write_texture(&queue, &texture, local_buf.as_slice());
+                if proxy
+                    .send_event(UserEvent::RequestRedraw(ViewportId::ROOT, Instant::now()))
+                    .is_err()
+                {
+                    break;
+                }
             }
         });
         let sink = Self { buffers, sink };

src/main.rs

@@ -134,7 +134,7 @@ fn main() -> Result<()> {
         })?;
 
     let event_loop = EventLoop::with_user_event().build().unwrap();
-    event_loop.set_control_flow(ControlFlow::Poll);
+    event_loop.set_control_flow(ControlFlow::Wait);
     let proxy = event_loop.create_proxy();
     let handle = event_loop.owned_display_handle();
     event_loop.run_app(&mut Application::new(

src/window/game.rs

@@ -803,12 +803,11 @@ impl AppWindow for GameWindow {
             true
         });
         self.child_states.save(ui);
-        ui.request_repaint_after(Duration::from_millis(10));
     }
 
     fn on_init(&mut self, args: InitArgs) {
         if self.screen.is_none() {
-            let (screen, sink) = GameScreen::init(args.render_state);
+            let (screen, sink) = GameScreen::init(args.render_state, self.proxy.clone());
             self.client.send_command(EmulatorCommand::ConnectToSim(
                 self.sim_id,
                 sink,

src/window/game_screen.rs

@@ -3,8 +3,9 @@ use std::{collections::HashMap, sync::Arc};
 use egui::{Color32, Rgba, Vec2, Widget};
 use serde::{Deserialize, Serialize};
 use wgpu::{BindGroup, BindGroupLayout, Buffer, RenderPipeline, util::DeviceExt as _};
+use winit::event_loop::EventLoopProxy;
 
-use crate::graphics::TextureSink;
+use crate::{app::UserEvent, graphics::TextureSink};
 
 pub struct GameScreen {
     bind_group: Arc<BindGroup>,
@@ -116,11 +117,14 @@ impl GameScreen {
             });
     }
 
-    pub fn init(render_state: &egui_wgpu::RenderState) -> (Self, TextureSink) {
+    pub fn init(
+        render_state: &egui_wgpu::RenderState,
+        proxy: EventLoopProxy<UserEvent>,
+    ) -> (Self, TextureSink) {
         let device = &render_state.device;
         let queue = &render_state.queue;
 
-        let (sink, texture_view) = TextureSink::new(device, queue.clone());
+        let (sink, texture_view) = TextureSink::new(device, queue.clone(), proxy);
         let sampler = device.create_sampler(&wgpu::SamplerDescriptor::default());
         let colors = Colors::new(
             Color32::from_rgb(0xff, 0x00, 0x00),