Upload frame buffer directly to gpu texture

Author: TrueDoctor

desktop/src/app.rs

@@ -2,6 +2,7 @@ use crate::CustomEvent;
 use crate::FrameBuffer;
 use crate::WindowSize;
 use crate::render::GraphicsState;
+use crate::render::WgpuContext;
 use std::sync::Arc;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
@@ -27,10 +28,11 @@ pub(crate) struct WinitApp {
 	_viewport_frame_buffer: Option<FrameBuffer>,
 	graphics_state: Option<GraphicsState>,
 	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>) -> Self {
+	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,
@@ -40,6 +42,7 @@ impl WinitApp {
 			graphics_state: None,
 			window_size_sender,
 			event_loop_proxy,
+			wgpu_context,
 		}
 	}
 }
@@ -73,7 +76,7 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 				)
 				.unwrap(),
 		);
-		let graphics_state = pollster::block_on(GraphicsState::new(window.clone()));
+		let graphics_state = GraphicsState::new(window.clone(), self.wgpu_context.clone());
 
 		self.window = Some(window);
 		self.graphics_state = Some(graphics_state);
@@ -83,11 +86,12 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 
 	fn user_event(&mut self, _: &ActiveEventLoop, event: CustomEvent) {
 		match event {
-			CustomEvent::UiUpdate(frame_buffer) => {
+			CustomEvent::UiUpdate((texture, width, height)) => {
 				if let Some(graphics_state) = self.graphics_state.as_mut() {
-					graphics_state.update_texture(&frame_buffer);
+					graphics_state.bind_texture(&texture);
+					graphics_state.resize(width, height);
 				}
-				self.ui_frame_buffer = Some(frame_buffer);
+				// self.ui_frame_buffer = Some(frame_buffer);
 				if let Some(window) = &self.window {
 					window.request_redraw();
 				}
@@ -115,9 +119,6 @@ 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();
 			}
 

desktop/src/cef.rs

@@ -1,4 +1,7 @@
-use crate::{CustomEvent, FrameBuffer};
+use crate::{
+	CustomEvent, FrameBuffer, WgpuContext,
+	render::{FrameBufferRef, GraphicsState},
+};
 use std::{
 	sync::{Arc, Mutex, mpsc::Receiver},
 	time::Instant,
@@ -14,7 +17,7 @@ use winit::event_loop::EventLoopProxy;
 
 pub(crate) trait CefEventHandler: Clone {
 	fn window_size(&self) -> WindowSize;
-	fn draw(&self, frame_buffer: FrameBuffer);
+	fn draw<'a>(&self, frame_buffer: FrameBufferRef<'a>);
 	/// Scheudule the main event loop to run the cef event loop after the timeout
 	///  [`_cef_browser_process_handler_t::on_schedule_message_pump_work`] for more documentation.
 	fn schedule_cef_message_loop_work(&self, scheduled_time: Instant);
@@ -36,6 +39,7 @@ impl WindowSize {
 pub(crate) struct CefHandler {
 	window_size_receiver: Arc<Mutex<WindowSizeReceiver>>,
 	event_loop_proxy: EventLoopProxy<CustomEvent>,
+	wgpu_context: WgpuContext,
 }
 struct WindowSizeReceiver {
 	receiver: Receiver<WindowSize>,
@@ -50,10 +54,11 @@ impl WindowSizeReceiver {
 	}
 }
 impl CefHandler {
-	pub(crate) fn new(window_size_receiver: Receiver<WindowSize>, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
+	pub(crate) fn new(window_size_receiver: Receiver<WindowSize>, event_loop_proxy: EventLoopProxy<CustomEvent>, wgpu_context: WgpuContext) -> Self {
 		Self {
 			window_size_receiver: Arc::new(Mutex::new(WindowSizeReceiver::new(window_size_receiver))),
 			event_loop_proxy,
+			wgpu_context,
 		}
 	}
 }
@@ -70,8 +75,44 @@ impl CefEventHandler for CefHandler {
 		}
 		*window_size
 	}
-	fn draw(&self, frame_buffer: FrameBuffer) {
-		let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate(frame_buffer));
+	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.wgpu_context.queue.write_texture(
+			wgpu::TexelCopyTextureInfo {
+				texture: &texture,
+				mip_level: 0,
+				origin: wgpu::Origin3d::ZERO,
+				aspect: wgpu::TextureAspect::All,
+			},
+			frame_buffer.buffer(),
+			wgpu::TexelCopyBufferLayout {
+				offset: 0,
+				bytes_per_row: Some(4 * width),
+				rows_per_image: Some(height),
+			},
+			wgpu::Extent3d {
+				width,
+				height,
+				depth_or_array_layers: 1,
+			},
+		);
+
+		let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate((texture, width, height)));
 	}
 
 	fn schedule_cef_message_loop_work(&self, scheduled_time: std::time::Instant) {

desktop/src/cef/internal/render_handler.rs

@@ -4,6 +4,7 @@ use cef::{Browser, ImplRenderHandler, PaintElementType, Rect, WrapRenderHandler}
 
 use crate::FrameBuffer;
 use crate::cef::CefEventHandler;
+use crate::render::FrameBufferRef;
 
 pub(crate) struct RenderHandlerImpl<H: CefEventHandler> {
 	object: *mut RcImpl<_cef_render_handler_t, Self>,
@@ -42,7 +43,7 @@ impl<H: CefEventHandler> ImplRenderHandler for RenderHandlerImpl<H> {
 	) {
 		let buffer_size = (width * height * 4) as usize;
 		let buffer_slice = unsafe { std::slice::from_raw_parts(buffer, buffer_size) };
-		let frame_buffer = FrameBuffer::new(buffer_slice.to_vec(), width as usize, height as usize).expect("Failed to create frame buffer");
+		let frame_buffer = FrameBufferRef::new(buffer_slice, width as usize, height as usize).expect("Failed to create frame buffer");
 
 		self.event_handler.draw(frame_buffer)
 	}

desktop/src/main.rs

@@ -9,14 +9,14 @@ mod cef;
 use cef::{Setup, WindowSize};
 
 mod render;
-use render::FrameBuffer;
+use render::{FrameBuffer, WgpuContext};
 
 mod app;
 use app::WinitApp;
 
 #[derive(Debug)]
 pub(crate) enum CustomEvent {
-	UiUpdate(FrameBuffer),
+	UiUpdate((wgpu::Texture, u32, u32)),
 	ScheduleBrowserWork(Instant),
 }
 
@@ -36,7 +36,8 @@ fn main() {
 
 	let (send, recv) = std::sync::mpsc::channel();
 
-	let cef_context = match cef_context.init(cef::CefHandler::new(recv, event_loop.create_proxy())) {
+	let wgpu_context = pollster::block_on(WgpuContext::new());
+	let cef_context = match cef_context.init(cef::CefHandler::new(recv, event_loop.create_proxy(), wgpu_context.clone())) {
 		Ok(c) => c,
 		Err(cef::InitError::InitializationFailed) => {
 			tracing::error!("Cef initialization failed");
@@ -46,7 +47,7 @@ fn main() {
 
 	tracing::info!("Cef initialized successfully");
 
-	let mut winit_app = WinitApp::new(cef_context, send, event_loop.create_proxy());
+	let mut winit_app = WinitApp::new(cef_context, send, event_loop.create_proxy(), wgpu_context);
 
 	event_loop.run_app(&mut winit_app).unwrap();
 }