Cleanup code and improve latency / frame pacing

Author: TrueDoctor

desktop/Cargo.toml

@@ -9,9 +9,19 @@ edition = "2024"
 rust-version = "1.87"
 
 [features]
-default = ["gpu",]
+default = ["gpu"]
 gpu = ["graphite-editor/gpu"]
-accelerated_paint = ["ash", "libc", "windows", "objc2-io-surface", "objc2-metal", "core-foundation"]
+
+# Hardware acceleration features
+accelerated_paint = ["ash"]
+accelerated_paint_dmabuf = ["accelerated_paint", "libc"]
+accelerated_paint_d3d11 = ["accelerated_paint", "windows"]
+accelerated_paint_iosurface = ["accelerated_paint", "objc2-io-surface", "objc2-metal", "core-foundation"]
+
+# Platform-specific feature bundles
+accelerated_paint_linux = ["accelerated_paint_dmabuf"]
+accelerated_paint_windows = ["accelerated_paint_d3d11"]
+accelerated_paint_macos = ["accelerated_paint_iosurface"]
 
 [dependencies]
 # # Local dependencies
@@ -44,7 +54,6 @@ image = { workspace = true }
 
 # Hardware acceleration dependencies
 ash = { version = "0.38", optional = true }
-libc = { version = "0.2", optional = true }
 
 # Windows-specific dependencies
 [target.'cfg(windows)'.dependencies]
@@ -60,3 +69,7 @@ windows = { version = "0.58", features = [
 objc2-io-surface = { version = "0.3", optional = true }
 objc2-metal = { version = "0.3", optional = true }
 core-foundation = { version = "0.9", optional = true }
+
+# Linux-specific dependencies
+[target.'cfg(target_os = "linux")'.dependencies]
+libc = { version = "0.2", optional = true }

desktop/src/app.rs

@@ -15,12 +15,12 @@ use graphite_editor::messages::prelude::*;
 use std::fs;
 use std::sync::Arc;
 use std::sync::mpsc::Sender;
+use std::sync::mpsc::SyncSender;
 use std::thread;
 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;
@@ -41,10 +41,23 @@ pub(crate) struct WinitApp {
 	editor: Editor,
 	last_ui_update: Instant,
 	avg_frame_time: f32,
+	start_render_sender: SyncSender<()>,
 }
 
 impl WinitApp {
 	pub(crate) fn new(cef_context: cef::Context<cef::Initialized>, window_size_sender: Sender<WindowSize>, wgpu_context: WgpuContext, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
+		let rendering_loop_proxy = event_loop_proxy.clone();
+		let (start_render_sender, start_render_receiver) = std::sync::mpsc::sync_channel(1);
+		std::thread::spawn(move || {
+			loop {
+				let (has_run, texture) = futures::executor::block_on(graphite_editor::node_graph_executor::run_node_graph());
+				if has_run {
+					let _ = rendering_loop_proxy.send_event(CustomEvent::NodeGraphRan(texture.map(|t| (*t.texture).clone())));
+				}
+				let _ = start_render_receiver.recv();
+			}
+		});
+
 		Self {
 			cef_context,
 			window: None,
@@ -56,6 +69,7 @@ impl WinitApp {
 			editor: Editor::new(),
 			last_ui_update: Instant::now(),
 			avg_frame_time: 0.,
+			start_render_sender,
 		}
 	}
 
@@ -153,23 +167,20 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 		// Set a timeout in case we miss any cef schedule requests
 		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));
-	}
-
-	fn new_events(&mut self, _event_loop: &ActiveEventLoop, cause: StartCause) {
 		if let Some(schedule) = self.cef_schedule
 			&& schedule < Instant::now()
 		{
 			self.cef_schedule = None;
-			self.cef_context.work();
-		}
-		if let StartCause::ResumeTimeReached { .. } = cause {
-			if let Some(window) = &self.window {
-				window.request_redraw();
+			// Poll cef message loop multiple times to avoid message loop starvation
+			for _ in 0..10 {
+				self.cef_context.work();
 			}
 		}
+		if let Some(window) = &self.window.as_ref() {
+			window.request_redraw();
+		}
+
+		event_loop.set_control_flow(ControlFlow::WaitUntil(wait_until));
 	}
 
 	fn resumed(&mut self, event_loop: &ActiveEventLoop) {
@@ -211,8 +222,9 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 					graphics_state.bind_ui_texture(texture);
 					let elapsed = self.last_ui_update.elapsed().as_secs_f32();
 					self.last_ui_update = Instant::now();
-					self.avg_frame_time = (self.avg_frame_time * 3. + elapsed) / 4.;
-					println!("ui fps: {:.2}", 1. / self.avg_frame_time);
+					if elapsed < 0.5 {
+						self.avg_frame_time = (self.avg_frame_time * 3. + elapsed) / 4.;
+					}
 				}
 				if let Some(window) = &self.window {
 					window.request_redraw();
@@ -357,16 +369,18 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 			WindowEvent::RedrawRequested => {
 				let Some(ref mut graphics_state) = self.graphics_state else { return };
 				// Only rerender once we have a new ui texture to display
-
-				match graphics_state.render() {
-					Ok(_) => {}
-					Err(wgpu::SurfaceError::Lost) => {
-						tracing::warn!("lost surface");
-					}
-					Err(wgpu::SurfaceError::OutOfMemory) => {
-						event_loop.exit();
+				if let Some(window) = &self.window {
+					match graphics_state.render(window.as_ref()) {
+						Ok(_) => {}
+						Err(wgpu::SurfaceError::Lost) => {
+							tracing::warn!("lost surface");
+						}
+						Err(wgpu::SurfaceError::OutOfMemory) => {
+							event_loop.exit();
+						}
+						Err(e) => tracing::error!("{:?}", e),
 					}
-					Err(e) => tracing::error!("{:?}", e),
+					let _ = self.start_render_sender.try_send(());
 				}
 			}
 			_ => {}

desktop/src/cef.rs

@@ -1,3 +1,33 @@
+//! CEF (Chromium Embedded Framework) integration for Graphite Desktop
+//!
+//! This module provides CEF browser integration with hardware-accelerated texture sharing.
+//!
+//! # Hardware Acceleration
+//!
+//! The texture import system supports platform-specific hardware acceleration:
+//!
+//! - **Linux**: DMA-BUF via Vulkan external memory (`accelerated_paint_dmabuf` feature)
+//! - **Windows**: D3D11 shared textures via Vulkan interop (`accelerated_paint_d3d11` feature)
+//! - **macOS**: IOSurface via Metal/Vulkan interop (`accelerated_paint_iosurface` feature)
+//!
+//! ## Feature Configuration
+//!
+//! Enable hardware acceleration with:
+//! ```toml
+//! [dependencies]
+//! graphite-desktop = { features = ["accelerated_paint"] }
+//! ```
+//!
+//! Or enable platform-specific support:
+//! ```toml
+//! [dependencies]
+//! graphite-desktop = { features = ["accelerated_paint_linux"] }    # Linux only
+//! graphite-desktop = { features = ["accelerated_paint_windows"] }  # Windows only
+//! graphite-desktop = { features = ["accelerated_paint_macos"] }    # macOS only
+//! ```
+//!
+//! The system gracefully falls back to CPU textures when hardware acceleration is unavailable.
+
 use crate::{CustomEvent, WgpuContext, render::FrameBufferRef};
 use std::{
 	sync::{Arc, Mutex, mpsc::Receiver},
@@ -6,26 +36,18 @@ use std::{
 
 mod context;
 mod dirs;
-mod dmabuf;
-#[cfg(target_os = "windows")]
-mod d3d11;
-#[cfg(target_os = "macos")]
-mod iosurface;
 mod input;
 mod internal;
 mod ipc;
 mod platform;
 mod scheme_handler;
+#[cfg(feature = "accelerated_paint")]
+mod texture_import;
 mod utility;
 
 pub(crate) use context::{Context, InitError, Initialized, Setup, SetupError};
 use winit::event_loop::EventLoopProxy;
 
-#[cfg(target_os = "windows")]
-use crate::cef::d3d11::D3D11SharedTexture;
-#[cfg(target_os = "macos")]
-use crate::cef::iosurface::IOSurfaceTexture;
-
 pub(crate) trait CefEventHandler: Clone {
 	fn window_size(&self) -> WindowSize;
 	fn draw<'a>(&self, frame_buffer: FrameBufferRef<'a>);
@@ -147,71 +169,12 @@ impl CefEventHandler for CefHandler {
 
 	#[cfg(feature = "accelerated_paint")]
 	fn on_accelerated_paint(&self, shared_handle: internal::render_handler::SharedTextureHandle) {
-		#[cfg(target_os = "linux")]
-		use crate::cef::dmabuf::DmaBufTexture;
-
-		match shared_handle {
-			#[cfg(target_os = "linux")]
-			internal::render_handler::SharedTextureHandle::DmaBuf {
-				fds,
-				format,
-				modifier,
-				width,
-				height,
-				strides,
-				offsets,
-			} => {
-				let dmabuf_texture = DmaBufTexture {
-					fds,
-					format,
-					modifier,
-					width,
-					height,
-					strides,
-					offsets,
-				};
-				match dmabuf_texture.import_to_wgpu(&self.wgpu_context.device) {
-					Ok(texture) => {
-						let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate(texture));
-					}
-					Err(e) => {
-						tracing::error!("Failed to import DMA-BUF texture: {}", e);
-					}
-				}
-			}
-			#[cfg(target_os = "windows")]
-			internal::render_handler::SharedTextureHandle::D3D11 { handle, format, width, height } => {
-				let d3d11_texture = D3D11SharedTexture {
-					handle,
-					width,
-					height,
-					format,
-				};
-				match d3d11_texture.import_to_wgpu(&self.wgpu_context.device) {
-					Ok(texture) => {
-						let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate(texture));
-					}
-					Err(e) => {
-						tracing::error!("Failed to import D3D11 shared texture: {}", e);
-					}
-				}
+		match self::texture_import::import_texture(shared_handle, &self.wgpu_context.device) {
+			Ok(texture) => {
+				let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate(texture));
 			}
-			#[cfg(target_os = "macos")]
-			internal::render_handler::SharedTextureHandle::IOSurface { handle, format, width, height } => {
-				let iosurface_texture = IOSurfaceTexture {
-					handle,
-					width,
-					height,
-					format,
-				};
-				match iosurface_texture.import_to_wgpu(&self.wgpu_context.device) {
-					Ok(texture) => {
-						let _ = self.event_loop_proxy.send_event(CustomEvent::UiUpdate(texture));
-					}
-					Err(e) => {
-						tracing::error!("Failed to import IOSurface texture: {}", e);
-					}
-				}
+			Err(e) => {
+				tracing::error!("Failed to import shared texture: {}", e);
 			}
 		}
 	}

desktop/src/cef/internal/browser_process_app.rs

@@ -40,7 +40,7 @@ impl<H: CefEventHandler + Clone> ImplApp for BrowserProcessAppImpl<H> {
 				cmd.append_switch(Some(&CefString::from("disable-gpu")));
 				cmd.append_switch(Some(&CefString::from("disable-gpu-compositing")));
 			}
-			
+
 			#[cfg(feature = "accelerated_paint")]
 			{
 				// Enable GPU acceleration switches for better performance

desktop/src/cef/internal/render_handler.rs

@@ -5,7 +5,7 @@ use cef::{Browser, ImplRenderHandler, PaintElementType, Rect, WrapRenderHandler}
 use crate::cef::CefEventHandler;
 use crate::render::FrameBufferRef;
 
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux", feature = "accelerated_paint"))]
 use std::os::fd::RawFd;
 #[cfg(all(feature = "accelerated_paint", any(target_os = "windows", target_os = "macos")))]
 use std::os::raw::c_void;