Schedule self render if texture is outdated

Author: TrueDoctor

desktop/src/app.rs

@@ -12,6 +12,7 @@ use winit::event::StartCause;
 use winit::event::WindowEvent;
 use winit::event_loop::ActiveEventLoop;
 use winit::event_loop::ControlFlow;
+use winit::event_loop::EventLoopProxy;
 use winit::window::Window;
 use winit::window::WindowId;
 
@@ -21,35 +22,24 @@ pub(crate) struct WinitApp {
 	pub(crate) cef_context: cef::Context<cef::Initialized>,
 	pub(crate) window: Option<Arc<Window>>,
 	cef_schedule: Option<Instant>,
-	ui_dirty: bool,
 	ui_frame_buffer: Option<FrameBuffer>,
 	window_size_sender: Sender<WindowSize>,
 	_viewport_frame_buffer: Option<FrameBuffer>,
 	graphics_state: Option<GraphicsState>,
+	event_loop_proxy: EventLoopProxy<CustomEvent>,
 }
 
 impl WinitApp {
-	pub(crate) fn new(cef_context: cef::Context<cef::Initialized>, window_size_sender: Sender<WindowSize>) -> Self {
+	pub(crate) fn new(cef_context: cef::Context<cef::Initialized>, window_size_sender: Sender<WindowSize>, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
 		Self {
 			cef_context,
 			window: None,
 			cef_schedule: Some(Instant::now()),
 			_viewport_frame_buffer: None,
 			ui_frame_buffer: None,
-			ui_dirty: false,
 			graphics_state: None,
 			window_size_sender,
-		}
-	}
-	fn run_cef(&mut self) {
-		if self.ui_frame_buffer.is_none() {
-			self.cef_context.work();
-		}
-		if let Some(schedule) = self.cef_schedule
-			&& schedule < Instant::now()
-		{
-			self.cef_schedule = None;
-			self.cef_context.work();
+			event_loop_proxy,
 		}
 	}
 }
@@ -62,7 +52,15 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 	}
 
 	fn new_events(&mut self, _event_loop: &ActiveEventLoop, _cause: StartCause) {
-		self.run_cef();
+		if self.ui_frame_buffer.is_none() {
+			self.cef_context.work();
+		}
+		if let Some(schedule) = self.cef_schedule
+			&& schedule < Instant::now()
+		{
+			self.cef_schedule = None;
+			self.cef_context.work();
+		}
 	}
 
 	fn resumed(&mut self, event_loop: &ActiveEventLoop) {
@@ -84,26 +82,30 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 	}
 
 	fn user_event(&mut self, _: &ActiveEventLoop, event: CustomEvent) {
-		self.run_cef();
 		match event {
 			CustomEvent::UiUpdate(frame_buffer) => {
 				if let Some(graphics_state) = self.graphics_state.as_mut() {
 					graphics_state.update_texture(&frame_buffer);
-					self.ui_dirty = true;
 				}
 				self.ui_frame_buffer = Some(frame_buffer);
 				if let Some(window) = &self.window {
 					window.request_redraw();
 				}
 			}
 			CustomEvent::ScheduleBrowserWork(instant) => {
+				if let Some(graphics_state) = self.graphics_state.as_mut()
+					&& let Some(frame_buffer) = &self.ui_frame_buffer
+					&& graphics_state.ui_texture_outdated(frame_buffer)
+				{
+					self.cef_context.work();
+					let _ = self.event_loop_proxy.send_event(CustomEvent::ScheduleBrowserWork(Instant::now() + Duration::from_millis(1)));
+				}
 				self.cef_schedule = Some(instant);
 			}
 		}
 	}
 
 	fn window_event(&mut self, event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {
-		self.run_cef();
 		let Some(event) = self.cef_context.handle_window_event(event) else { return };
 
 		match event {
@@ -113,25 +115,25 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 			}
 			WindowEvent::Resized(PhysicalSize { width, height }) => {
 				let _ = self.window_size_sender.send(WindowSize::new(width as usize, height as usize));
+				if let Some(ref mut graphics_state) = self.graphics_state {
+					graphics_state.resize(width, height);
+				}
 				self.cef_context.notify_of_resize();
 			}
 
 			WindowEvent::RedrawRequested => {
 				let Some(ref mut graphics_state) = self.graphics_state else { return };
 				// Only rerender once we have a new ui texture to display
-				if self.ui_dirty {
-					self.ui_dirty = false;
 
-					match graphics_state.render() {
-						Ok(_) => {}
-						Err(wgpu::SurfaceError::Lost) => {
-							tracing::warn!("lost surface");
-						}
-						Err(wgpu::SurfaceError::OutOfMemory) => {
-							event_loop.exit();
-						}
-						Err(e) => tracing::error!("{:?}", e),
+				match graphics_state.render() {
+					Ok(_) => {}
+					Err(wgpu::SurfaceError::Lost) => {
+						tracing::warn!("lost surface");
+					}
+					Err(wgpu::SurfaceError::OutOfMemory) => {
+						event_loop.exit();
 					}
+					Err(e) => tracing::error!("{:?}", e),
 				}
 			}
 			_ => {}

desktop/src/cef.rs

@@ -76,6 +76,5 @@ impl CefEventHandler for CefHandler {
 
 	fn schedule_cef_message_loop_work(&self, scheduled_time: std::time::Instant) {
 		let _ = self.event_loop_proxy.send_event(CustomEvent::ScheduleBrowserWork(scheduled_time));
-		println!("browser scheduled work");
 	}
 }

desktop/src/main.rs

@@ -46,7 +46,7 @@ fn main() {
 
 	tracing::info!("Cef initialized successfully");
 
-	let mut winit_app = WinitApp::new(cef_context, send);
+	let mut winit_app = WinitApp::new(cef_context, send, event_loop.create_proxy());
 
 	event_loop.run_app(&mut winit_app).unwrap();
 }

desktop/src/render.rs

@@ -223,11 +223,13 @@ impl GraphicsState {
 		graphics_state
 	}
 
-	pub(crate) fn update_texture(&mut self, frame_buffer: &FrameBuffer) {
-		let data = frame_buffer.buffer();
+	pub(crate) fn ui_texture_outdated(&self, frame_buffer: &FrameBuffer) -> bool {
 		let width = frame_buffer.width() as u32;
 		let height = frame_buffer.height() as u32;
 
+		self.config.width != width || self.config.height != height
+	}
+	pub(crate) fn resize(&mut self, width: u32, height: u32) {
 		if width > 0 && height > 0 && (self.config.width != width || self.config.height != height) {
 			self.config.width = width;
 			self.config.height = height;
@@ -248,6 +250,14 @@ impl GraphicsState {
 			});
 			self.texture = Some(texture);
 		}
+	}
+
+	pub(crate) fn update_texture(&mut self, frame_buffer: &FrameBuffer) {
+		let data = frame_buffer.buffer();
+		let width = frame_buffer.width() as u32;
+		let height = frame_buffer.height() as u32;
+
+		self.resize(width, height);
 
 		let Some(ref texture) = self.texture else { return };