UI texture caching

Author: adamgerhant

desktop/src/app.rs

@@ -19,29 +19,28 @@ use winit::window::WindowId;
 use crate::cef;
 
 pub(crate) struct WinitApp {
-	pub(crate) cef_context: cef::Context<cef::Initialized>,
-	pub(crate) window: Option<Arc<Window>>,
-	cef_schedule: Option<Instant>,
-	_ui_frame_buffer: Option<wgpu::Texture>,
-	window_size_sender: Sender<WindowSize>,
-	_viewport_frame_buffer: Option<wgpu::Texture>,
+	window: Option<Arc<Window>>,
+	cef_context: cef::Context<cef::Initialized>,
+	wgpu_context: WgpuContext,
+	// Caches the resulting texture from CEF and the node graph output to render to the window
 	graphics_state: Option<GraphicsState>,
+	// Read back from the GPU, and will be used to check if inputs are sent to the browser
+	// ui_overlay_frame_buffer: Option<FrameBuffer>,
+	window_size_sender: Sender<WindowSize>,
+	cef_schedule: Option<Instant>,
 	event_loop_proxy: EventLoopProxy<CustomEvent>,
-	wgpu_context: WgpuContext,
 }
 
 impl WinitApp {
 	pub(crate) fn new(cef_context: cef::Context<cef::Initialized>, window_size_sender: Sender<WindowSize>, event_loop_proxy: EventLoopProxy<CustomEvent>, wgpu_context: WgpuContext) -> Self {
 		Self {
-			cef_context,
 			window: None,
-			cef_schedule: Some(Instant::now()),
-			_viewport_frame_buffer: None,
-			_ui_frame_buffer: None,
+			cef_context,
+			wgpu_context,
 			graphics_state: None,
 			window_size_sender,
+			cef_schedule: Some(Instant::now()),
 			event_loop_proxy,
-			wgpu_context,
 		}
 	}
 }
@@ -87,7 +86,7 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 			CustomEvent::UiUpdate((texture, width, height)) => {
 				if let Some(graphics_state) = self.graphics_state.as_mut() {
 					graphics_state.bind_texture(&texture);
-					graphics_state.resize(width, height);
+					graphics_state.try_resize(width, height);
 				}
 				if let Some(window) = &self.window {
 					window.request_redraw();
@@ -96,6 +95,7 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 			CustomEvent::ScheduleBrowserWork(instant) => {
 				if instant < Instant::now() {
 					self.cef_context.work();
+					// This seems pointless, it just schedules work in 10ms but doesnt loop
 					let _ = self.event_loop_proxy.send_event(CustomEvent::ScheduleBrowserWork(Instant::now() + Duration::from_millis(10)));
 				}
 				self.cef_schedule = Some(instant);
@@ -134,6 +134,7 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 			_ => {}
 		}
 
+		// Remove this since window events should not be tied to CEF
 		// Notify cef of possible input events
 		self.cef_context.work();
 	}

desktop/src/cef.rs

@@ -38,7 +38,9 @@ pub(crate) struct CefHandler {
 	window_size_receiver: Arc<Mutex<WindowSizeReceiver>>,
 	event_loop_proxy: EventLoopProxy<CustomEvent>,
 	wgpu_context: WgpuContext,
+	cached_ui_texture: Arc<Mutex<Option<wgpu::Texture>>>,
 }
+
 struct WindowSizeReceiver {
 	receiver: Receiver<WindowSize>,
 	window_size: WindowSize,
@@ -57,8 +59,37 @@ impl CefHandler {
 			window_size_receiver: Arc::new(Mutex::new(WindowSizeReceiver::new(window_size_receiver))),
 			event_loop_proxy,
 			wgpu_context,
+			cached_ui_texture: Arc::new(Mutex::new(None.into())),
 		}
 	}
+
+	fn try_resize_texture(&self, width: u32, height: u32) {
+		let create_new_texture = self.cached_ui_texture.lock().unwrap().as_ref().map_or(true, |texture| {
+			let size = texture.size();
+			size.width != width || size.height != height
+		});
+
+		if create_new_texture {
+			self.create_texture(width, height);
+		}
+	}
+
+	fn create_texture(&self, width: u32, height: u32) {
+		*self.cached_ui_texture.lock().unwrap() = Some(self.wgpu_context.device.create_texture(&wgpu::TextureDescriptor {
+			label: Some("CEF Texture"),
+			size: wgpu::Extent3d {
+				width,
+				height,
+				depth_or_array_layers: 1,
+			},
+			mip_level_count: 1,
+			sample_count: 1,
+			dimension: wgpu::TextureDimension::D2,
+			format: wgpu::TextureFormat::Bgra8UnormSrgb,
+			usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+			view_formats: &[],
+		}));
+	}
 }
 
 impl CefEventHandler for CefHandler {
@@ -76,23 +107,12 @@ impl CefEventHandler for CefHandler {
 	fn draw<'a>(&self, frame_buffer: FrameBufferRef<'a>) {
 		let width = frame_buffer.width() as u32;
 		let height = frame_buffer.height() as u32;
-		let texture = self.wgpu_context.device.create_texture(&wgpu::TextureDescriptor {
-			label: Some("CEF Texture"),
-			size: wgpu::Extent3d {
-				width,
-				height,
-				depth_or_array_layers: 1,
-			},
-			mip_level_count: 1,
-			sample_count: 1,
-			dimension: wgpu::TextureDimension::D2,
-			format: wgpu::TextureFormat::Bgra8UnormSrgb,
-			usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-			view_formats: &[],
-		});
+		self.try_resize_texture(width, height);
+		let binding = self.cached_ui_texture.lock().unwrap();
+		let texture = binding.as_ref().expect("Texture must be initialized before drawing");
 		self.wgpu_context.queue.write_texture(
 			wgpu::TexelCopyTextureInfo {
-				texture: &texture,
+				texture,
 				mip_level: 0,
 				origin: wgpu::Origin3d::ZERO,
 				aspect: wgpu::TextureAspect::All,
@@ -110,7 +130,7 @@ impl CefEventHandler for CefHandler {
 			},
 		);
 
-		let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate((texture, width, height)));
+		let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate((texture.clone(), width, height)));
 	}
 
 	fn schedule_cef_message_loop_work(&self, scheduled_time: std::time::Instant) {

desktop/src/render.rs

@@ -99,8 +99,7 @@ pub(crate) struct GraphicsState {
 	surface: wgpu::Surface<'static>,
 	context: WgpuContext,
 	config: wgpu::SurfaceConfiguration,
-	texture: Option<wgpu::Texture>,
-	bind_group: Option<wgpu::BindGroup>,
+	ui_overlay_bind_group: Option<wgpu::BindGroup>,
 	render_pipeline: wgpu::RenderPipeline,
 	sampler: wgpu::Sampler,
 }
@@ -211,14 +210,13 @@ impl GraphicsState {
 			surface,
 			context,
 			config,
-			texture: None,
-			bind_group: None,
+			ui_overlay_bind_group: None,
 			render_pipeline,
 			sampler,
 		}
 	}
 
-	pub(crate) fn resize(&mut self, width: u32, height: u32) {
+	pub(crate) fn try_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;
@@ -228,9 +226,7 @@ impl GraphicsState {
 
 	pub(crate) fn bind_texture(&mut self, texture: &wgpu::Texture) {
 		let bind_group = self.create_bindgroup(texture);
-		self.texture = Some(texture.clone());
-
-		self.bind_group = Some(bind_group);
+		self.ui_overlay_bind_group = Some(bind_group);
 	}
 
 	fn create_bindgroup(&self, texture: &wgpu::Texture) -> wgpu::BindGroup {
@@ -275,7 +271,7 @@ impl GraphicsState {
 			});
 
 			render_pass.set_pipeline(&self.render_pipeline);
-			if let Some(bind_group) = &self.bind_group {
+			if let Some(bind_group) = &self.ui_overlay_bind_group {
 				render_pass.set_bind_group(0, bind_group, &[]);
 				render_pass.draw(0..6, 0..1); // Draw 3 vertices for fullscreen triangle
 			} else {