Cleanup code

Author: TrueDoctor

desktop/src/app.rs

@@ -1,5 +1,4 @@
 use crate::CustomEvent;
-use crate::FrameBuffer;
 use crate::WindowSize;
 use crate::render::GraphicsState;
 use crate::render::WgpuContext;
@@ -23,9 +22,9 @@ 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<FrameBuffer>,
+	_ui_frame_buffer: Option<wgpu::Texture>,
 	window_size_sender: Sender<WindowSize>,
-	_viewport_frame_buffer: Option<FrameBuffer>,
+	_viewport_frame_buffer: Option<wgpu::Texture>,
 	graphics_state: Option<GraphicsState>,
 	event_loop_proxy: EventLoopProxy<CustomEvent>,
 	wgpu_context: WgpuContext,
@@ -38,7 +37,7 @@ impl WinitApp {
 			window: None,
 			cef_schedule: Some(Instant::now()),
 			_viewport_frame_buffer: None,
-			ui_frame_buffer: None,
+			_ui_frame_buffer: None,
 			graphics_state: None,
 			window_size_sender,
 			event_loop_proxy,
@@ -50,8 +49,9 @@ impl WinitApp {
 impl ApplicationHandler<CustomEvent> for WinitApp {
 	fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
 		// Set a timeout in case we miss any cef schedule requests
-		let timeout = Instant::now() + Duration::from_millis(100);
+		let timeout = Instant::now() + Duration::from_millis(10);
 		let wait_until = timeout.min(self.cef_schedule.unwrap_or(timeout));
+		self.cef_context.work();
 		event_loop.set_control_flow(ControlFlow::WaitUntil(wait_until));
 	}
 
@@ -89,18 +89,14 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 					graphics_state.bind_texture(&texture);
 					graphics_state.resize(width, height);
 				}
-				// 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)
-				{
+				if instant < Instant::now() {
 					self.cef_context.work();
-					let _ = self.event_loop_proxy.send_event(CustomEvent::ScheduleBrowserWork(Instant::now() + Duration::from_millis(1)));
+					let _ = self.event_loop_proxy.send_event(CustomEvent::ScheduleBrowserWork(Instant::now() + Duration::from_millis(10)));
 				}
 				self.cef_schedule = Some(instant);
 			}

desktop/src/cef.rs

@@ -1,7 +1,4 @@
-use crate::{
-	CustomEvent, FrameBuffer, WgpuContext,
-	render::{FrameBufferRef, GraphicsState},
-};
+use crate::{CustomEvent, WgpuContext, render::FrameBufferRef};
 use std::{
 	sync::{Arc, Mutex, mpsc::Receiver},
 	time::Instant,

desktop/src/cef/internal/render_handler.rs

@@ -2,7 +2,6 @@ use cef::rc::{Rc, RcImpl};
 use cef::sys::{_cef_render_handler_t, cef_base_ref_counted_t};
 use cef::{Browser, ImplRenderHandler, PaintElementType, Rect, WrapRenderHandler};
 
-use crate::FrameBuffer;
 use crate::cef::CefEventHandler;
 use crate::render::FrameBufferRef;
 

desktop/src/main.rs

@@ -9,7 +9,7 @@ mod cef;
 use cef::{Setup, WindowSize};
 
 mod render;
-use render::{FrameBuffer, WgpuContext};
+use render::WgpuContext;
 
 mod app;
 use app::WinitApp;

desktop/src/render.rs

@@ -3,21 +3,6 @@ use std::sync::Arc;
 use thiserror::Error;
 use winit::window::Window;
 
-pub(crate) struct FrameBuffer {
-	buffer: Vec<u8>,
-	width: usize,
-	height: usize,
-}
-impl std::fmt::Debug for FrameBuffer {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		f.debug_struct("FrameBuffer")
-			.field("width", &self.width)
-			.field("height", &self.height)
-			.field("len", &self.buffer.len())
-			.finish()
-	}
-}
-
 pub(crate) struct FrameBufferRef<'a> {
 	buffer: &'a [u8],
 	width: usize,
@@ -70,38 +55,6 @@ pub(crate) enum FrameBufferError {
 	InvalidSize { buffer_size: usize, expected_size: usize, width: usize, height: usize },
 }
 
-impl FrameBuffer {
-	pub(crate) fn new(buffer: Vec<u8>, width: usize, height: usize) -> Result<Self, FrameBufferError> {
-		let fb = Self { buffer, width, height };
-		fb.validate_size()?;
-		Ok(fb)
-	}
-
-	pub(crate) fn buffer(&self) -> &[u8] {
-		&self.buffer
-	}
-
-	pub(crate) fn width(&self) -> usize {
-		self.width
-	}
-
-	pub(crate) fn height(&self) -> usize {
-		self.height
-	}
-
-	fn validate_size(&self) -> Result<(), FrameBufferError> {
-		if self.buffer.len() != self.width * self.height * 4 {
-			Err(FrameBufferError::InvalidSize {
-				buffer_size: self.buffer.len(),
-				expected_size: self.width * self.height * 4,
-				width: self.width,
-				height: self.height,
-			})
-		} else {
-			Ok(())
-		}
-	}
-}
 #[derive(Debug, Clone)]
 pub(crate) struct WgpuContext {
 	pub(crate) device: wgpu::Device,
@@ -265,38 +218,17 @@ impl GraphicsState {
 		}
 	}
 
-	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;
 			self.surface.configure(&self.context.device, &self.config);
-			// let texture = self.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.texture = Some(texture);
 		}
 	}
 
 	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);
 	}