Merge branch 'master' into gg_sliding

Author: 4adex

Cargo.lock

@@ -7,6 +7,7 @@ members = [
 	"node-graph/gapplication-io",
 	"node-graph/gbrush",
 	"node-graph/gcore",
+	"node-graph/gcore-shaders",
 	"node-graph/gstd",
 	"node-graph/gmath-nodes",
 	"node-graph/gpath-bool",
@@ -28,6 +29,7 @@ default-members = [
 	"frontend/wasm",
 	"node-graph/gbrush",
 	"node-graph/gcore",
+	"node-graph/gcore-shaders",
 	"node-graph/gstd",
 	"node-graph/gmath-nodes",
 	"node-graph/gpath-bool",
@@ -50,6 +52,7 @@ path-bool = { path = "libraries/path-bool" }
 graphene-application-io = { path = "node-graph/gapplication-io" }
 graphene-brush = { path = "node-graph/gbrush" }
 graphene-core = { path = "node-graph/gcore" }
+graphene-core-shaders = { path = "node-graph/gcore-shaders" }
 graphene-math-nodes = { path = "node-graph/gmath-nodes" }
 graphene-path-bool = { path = "node-graph/gpath-bool" }
 graph-craft = { path = "node-graph/graph-craft" }
@@ -156,12 +159,17 @@ iai-callgrind = { version = "0.12.3" }
 ndarray = "0.16.1"
 strum = { version = "0.26.3", features = ["derive"] }
 dirs = "6.0"
+cef = "138.5.0"
+include_dir = "0.7.4"
+tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
+tracing = "0.1.41"
 
 [profile.dev]
 opt-level = 1
 
 [profile.dev.package]
 graphite-editor = { opt-level = 1 }
+graphene-core-shaders = { opt-level = 1 }
 graphene-core = { opt-level = 1 }
 graphene-std = { opt-level = 1 }
 interpreted-executor = { opt-level = 1 } # This is a mitigation for https://github.com/rustwasm/wasm-pack/issues/981 which is needed because the node_registry function is too large

Cargo.toml

@@ -9,25 +9,23 @@ edition = "2024"
 rust-version = "1.87"
 
 [features]
-default = ["gpu"]
-gpu = ["graphite-editor/gpu"]
+# default = ["gpu"]
+# gpu = ["graphite-editor/gpu"]
 
 [dependencies]
 # Local dependencies
-graphite-editor = { path = "../editor", features = [
-	"gpu",
-	"ron",
-	"vello",
-	"decouple-execution",
-] }
+# graphite-editor = { path = "../editor", features = [
+# 	"gpu",
+# 	"ron",
+# 	"vello",
+# 	"decouple-execution",
+# ] }
 wgpu = { workspace = true }
 winit = { workspace = true, features = ["serde"] }
-base64.workspace = true
-thiserror.workspace = true
-pollster = "0.3"
-cef = "138.5.0"
-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
+thiserror = { workspace = true }
+futures = { workspace = true }
+cef = { workspace = true }
+include_dir = { workspace = true }
+tracing-subscriber = { workspace = true }
+tracing = { workspace = true }
+dirs = {workspace = true}

desktop/Cargo.toml

@@ -1,7 +1,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;
@@ -12,7 +12,6 @@ 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;
 
@@ -22,33 +21,34 @@ 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,
 }
 
 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>, wgpu_context: WgpuContext) -> Self {
 		Self {
 			cef_context,
 			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,
+			wgpu_context,
 		}
 	}
 }
 
 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));
 	}
 
@@ -71,7 +71,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);
@@ -81,24 +81,21 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 
 	fn user_event(&mut self, _: &ActiveEventLoop, event: CustomEvent) {
 		match event {
-			CustomEvent::UiUpdate(frame_buffer) => {
+			CustomEvent::UiUpdate(texture) => {
 				if let Some(graphics_state) = self.graphics_state.as_mut() {
-					graphics_state.update_texture(&frame_buffer);
+					graphics_state.bind_texture(&texture);
+					graphics_state.resize(texture.width(), texture.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)));
+				} else {
+					self.cef_schedule = Some(instant);
 				}
-				self.cef_schedule = Some(instant);
 			}
 		}
 	}
@@ -113,9 +110,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/app.rs

@@ -1,4 +1,4 @@
-use crate::{CustomEvent, FrameBuffer};
+use crate::{CustomEvent, WgpuContext, render::FrameBufferRef};
 use std::{
 	sync::{Arc, Mutex, mpsc::Receiver},
 	time::Instant,
@@ -15,7 +15,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);
@@ -37,6 +37,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>,
@@ -51,10 +52,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,
 		}
 	}
 }
@@ -71,8 +73,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));
 	}
 
 	fn schedule_cef_message_loop_work(&self, scheduled_time: std::time::Instant) {

desktop/src/cef.rs

@@ -1,4 +1,4 @@
-use cef::sys::CEF_API_VERSION_LAST;
+use cef::sys::{CEF_API_VERSION_LAST, cef_resultcode_t};
 use cef::{App, BrowserSettings, Client, DictionaryValue, ImplBrowser, ImplBrowserHost, ImplCommandLine, RenderHandler, RequestContext, WindowInfo, browser_host_create_browser_sync, initialize};
 use cef::{Browser, CefString, Settings, api_hash, args::Args, execute_process};
 use thiserror::Error;
@@ -74,7 +74,11 @@ impl Context<Setup> {
 
 		let result = initialize(Some(self.args.as_main_args()), Some(&settings), Some(&mut cef_app), std::ptr::null_mut());
 		if result != 1 {
-			return Err(InitError::InitializationFailed);
+			let cef_exit_code = cef::get_exit_code() as u32;
+			if cef_exit_code == cef_resultcode_t::CEF_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED as u32 {
+				return Err(InitError::AlreadyRunning);
+			}
+			return Err(InitError::InitializationFailed(cef_exit_code));
 		}
 
 		let render_handler = RenderHandlerImpl::new(event_handler.clone());
@@ -146,5 +150,7 @@ pub(crate) enum SetupError {
 #[derive(Error, Debug)]
 pub(crate) enum InitError {
 	#[error("initialization failed")]
-	InitializationFailed,
+	InitializationFailed(u32),
+	#[error("Another instance is already running")]
+	AlreadyRunning,
 }