Merge branch 'master' into nix-dev-shell-use-flake-compat

Author: TrueDoctor

Cargo.lock

@@ -154,6 +154,8 @@ tinyvec = { version = "1", features = ["std"] }
 criterion = { version = "0.5", features = ["html_reports"] }
 iai-callgrind = { version = "0.12.3" }
 ndarray = "0.16.1"
+strum = { version = "0.26.3", features = ["derive"] }
+dirs = "6.0"
 
 [profile.dev]
 opt-level = 1

Cargo.toml

@@ -30,3 +30,4 @@ tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 tracing = "0.1.41"
 bytemuck = { version = "1.23.1", features = ["derive"] }
 include_dir = "0.7.4"
+dirs.workspace = true

desktop/Cargo.toml

@@ -1,41 +1,53 @@
 use crate::CustomEvent;
-use crate::WindowState;
-use crate::WindowStateHandle;
+use crate::FrameBuffer;
+use crate::WindowSize;
 use crate::render::GraphicsState;
 use std::sync::Arc;
+use std::sync::mpsc::Sender;
 use std::time::Duration;
 use std::time::Instant;
 use winit::application::ApplicationHandler;
+use winit::dpi::PhysicalSize;
 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;
 
 use crate::cef;
 
 pub(crate) struct WinitApp {
-	pub(crate) window_state: WindowStateHandle,
 	pub(crate) cef_context: cef::Context<cef::Initialized>,
 	pub(crate) window: Option<Arc<Window>>,
 	cef_schedule: Option<Instant>,
+	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(window_state: WindowStateHandle, cef_context: cef::Context<cef::Initialized>) -> Self {
+	pub(crate) fn new(cef_context: cef::Context<cef::Initialized>, window_size_sender: Sender<WindowSize>, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
 		Self {
-			window_state,
 			cef_context,
 			window: None,
 			cef_schedule: Some(Instant::now()),
+			_viewport_frame_buffer: None,
+			ui_frame_buffer: None,
+			graphics_state: None,
+			window_size_sender,
+			event_loop_proxy,
 		}
 	}
 }
 
 impl ApplicationHandler<CustomEvent> for WinitApp {
 	fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
-		let timeout = Instant::now() + Duration::from_millis(10);
+		// Set a timeout in case we miss any cef schedule requests
+		let timeout = Instant::now() + Duration::from_millis(100);
 		let wait_until = timeout.min(self.cef_schedule.unwrap_or(timeout));
 		event_loop.set_control_flow(ControlFlow::WaitUntil(wait_until));
 	}
@@ -50,37 +62,42 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 	}
 
 	fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-		self.window_state
-			.with(|s| {
-				if let WindowState { width: Some(w), height: Some(h), .. } = s {
-					let window = Arc::new(
-						event_loop
-							.create_window(
-								Window::default_attributes()
-									.with_title("CEF Offscreen Rendering")
-									.with_inner_size(winit::dpi::LogicalSize::new(*w as u32, *h as u32)),
-							)
-							.unwrap(),
-					);
-					let graphics_state = pollster::block_on(GraphicsState::new(window.clone()));
+		let window = Arc::new(
+			event_loop
+				.create_window(
+					Window::default_attributes()
+						.with_title("CEF Offscreen Rendering")
+						.with_inner_size(winit::dpi::LogicalSize::new(1200, 800)),
+				)
+				.unwrap(),
+		);
+		let graphics_state = pollster::block_on(GraphicsState::new(window.clone()));
 
-					self.window = Some(window.clone());
-					s.graphics_state = Some(graphics_state);
+		self.window = Some(window);
+		self.graphics_state = Some(graphics_state);
 
-					tracing::info!("Winit window created and ready");
-				}
-			})
-			.unwrap();
+		tracing::info!("Winit window created and ready");
 	}
 
 	fn user_event(&mut self, _: &ActiveEventLoop, event: CustomEvent) {
 		match event {
-			CustomEvent::UiUpdate => {
+			CustomEvent::UiUpdate(frame_buffer) => {
+				if let Some(graphics_state) = self.graphics_state.as_mut() {
+					graphics_state.update_texture(&frame_buffer);
+				}
+				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);
 			}
 		}
@@ -94,58 +111,33 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 				tracing::info!("The close button was pressed; stopping");
 				event_loop.exit();
 			}
-			WindowEvent::Resized(physical_size) => {
-				self.window_state
-					.with(|s| {
-						let width = physical_size.width as usize;
-						let height = physical_size.height as usize;
-						s.width = Some(width);
-						s.height = Some(height);
-						if let Some(graphics_state) = &mut s.graphics_state {
-							graphics_state.resize(width, height);
-						}
-					})
-					.unwrap();
+			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 => {
-				self.cef_context.work();
+				let Some(ref mut graphics_state) = self.graphics_state else { return };
+				// Only rerender once we have a new ui texture to display
 
-				self.window_state
-					.with(|s| {
-						if let WindowState {
-							width: Some(width),
-							height: Some(height),
-							graphics_state: Some(graphics_state),
-							ui_frame_buffer: ui_fb,
-							..
-						} = s
-						{
-							if let Some(fb) = &*ui_fb {
-								graphics_state.update_texture(fb);
-								if fb.width() != *width && fb.height() != *height {
-									graphics_state.resize(*width, *height);
-								}
-							} else if let Some(window) = &self.window {
-								window.request_redraw();
-							}
-
-							match graphics_state.render() {
-								Ok(_) => {}
-								Err(wgpu::SurfaceError::Lost) => {
-									graphics_state.resize(*width, *height);
-								}
-								Err(wgpu::SurfaceError::OutOfMemory) => {
-									event_loop.exit();
-								}
-								Err(e) => tracing::error!("{:?}", e),
-							}
-						}
-					})
-					.unwrap();
+				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),
+				}
 			}
 			_ => {}
 		}
+
+		// Notify cef of possible input events
+		self.cef_context.work();
 	}
 }