adam changes

Author: adamgerhant

Cargo.lock

@@ -1,66 +1,9 @@
 [workspace]
 members = [
-	"editor",
 	"desktop",
-	"proc-macros",
-	"frontend/wasm",
-	"node-graph/gapplication-io",
-	"node-graph/gbrush",
-	"node-graph/gcore",
-	"node-graph/gstd",
-	"node-graph/gmath-nodes",
-	"node-graph/gpath-bool",
-	"node-graph/graph-craft",
-	"node-graph/graphene-cli",
-	"node-graph/graster-nodes",
-	"node-graph/gsvg-renderer",
-	"node-graph/interpreted-executor",
-	"node-graph/node-macro",
-	"node-graph/preprocessor",
-	"libraries/dyn-any",
-	"libraries/path-bool",
-	"libraries/bezier-rs",
-	"libraries/math-parser",
-	"website/other/bezier-rs-demos/wasm",
-]
-default-members = [
-	"editor",
-	"frontend/wasm",
-	"node-graph/gbrush",
-	"node-graph/gcore",
-	"node-graph/gstd",
-	"node-graph/gmath-nodes",
-	"node-graph/gpath-bool",
-	"node-graph/graph-craft",
-	"node-graph/graphene-cli",
-	"node-graph/graster-nodes",
-	"node-graph/gsvg-renderer",
-	"node-graph/interpreted-executor",
-	"node-graph/node-macro",
 ]
 resolver = "2"
-
 [workspace.dependencies]
-# Local dependencies
-bezier-rs = { path = "libraries/bezier-rs", features = ["dyn-any", "serde"] }
-dyn-any = { path = "libraries/dyn-any", features = ["derive", "glam", "reqwest", "log-bad-types", "rc"] }
-preprocessor = { path = "node-graph/preprocessor"}
-math-parser = { path = "libraries/math-parser" }
-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-math-nodes = { path = "node-graph/gmath-nodes" }
-graphene-path-bool = { path = "node-graph/gpath-bool" }
-graph-craft = { path = "node-graph/graph-craft" }
-graphene-raster-nodes = { path = "node-graph/graster-nodes" }
-graphene-std = { path = "node-graph/gstd" }
-graphene-svg-renderer = { path = "node-graph/gsvg-renderer" }
-interpreted-executor = { path = "node-graph/interpreted-executor" }
-node-macro = { path = "node-graph/node-macro" }
-wgpu-executor = { path = "node-graph/wgpu-executor" }
-graphite-proc-macros = { path = "proc-macros" }
-
 # Workspace dependencies
 rustc-hash = "2.0"
 bytemuck = { version = "1.13", features = ["derive"] }
@@ -69,6 +12,8 @@ serde_json = "1.0"
 serde-wasm-bindgen = "0.6"
 reqwest = { version = "0.12", features = ["blocking", "rustls-tls", "json"] }
 futures = "0.3"
+cef = "138.5.0"
+include_dir = "0.7.4"
 env_logger = "0.11"
 log = "0.4"
 bitflags = { version = "2.4", features = ["serde"] }

Cargo.toml

@@ -8,25 +8,10 @@ repository = ""
 edition = "2021"
 rust-version = "1.79"
 
-[features]
-default = ["gpu"]
-gpu = ["graphite-editor/gpu"]
-
 [dependencies]
-# Local dependencies
-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"
+thiserror = { workspace = true }
+futures = { workspace = true }
+cef = { workspace = true }
+include_dir = { workspace = true }

desktop/Cargo.toml

@@ -1,7 +1,8 @@
 use std::fs::metadata;
 
 fn main() {
-	let frontend_dir = format!("{}/../frontend/dist", env!("CARGO_MANIFEST_DIR"));
+	let frontend_dir = format!("{}/../frontend-native/dist", env!("CARGO_MANIFEST_DIR"));
+	println!("frontend_dir: {}", frontend_dir);
 	metadata(&frontend_dir).expect("Failed to find frontend directory. Please build the frontend first.");
 	metadata(format!("{}/index.html", &frontend_dir)).expect("Failed to find index.html in frontend directory.");
 

desktop/build.rs

@@ -4,10 +4,14 @@ use cef::{browser_host_create_browser_sync, initialize, BrowserSettings, Diction
 use thiserror::Error;
 use winit::event::WindowEvent;
 
+use crate::cef::internal::OffscreenRenderHandler;
+use crate::render::FrameBufferHandle;
+use crate::WindowStateHandle;
+
 use super::input::{handle_window_event, InputState};
 use super::EventHandler;
 
-use super::internal::{AppImpl, ClientImpl, NonBrowserAppImpl, RenderHandlerImpl};
+use super::internal::{AppImpl, ClientImpl, OffscreenApp, RenderHandlerImpl};
 
 pub(crate) struct Setup {}
 pub(crate) struct Initialized {}
@@ -37,7 +41,7 @@ impl Context<Setup> {
 		let is_browser_process = cmd.has_switch(Some(&switch)) != 1;
 		if !is_browser_process {
 			let process_type = CefString::from(&cmd.switch_value(Some(&switch)));
-			let mut app = NonBrowserAppImpl::new();
+			let mut app = OffscreenApp::new();
 			let ret = execute_process(Some(args.as_main_args()), Some(&mut app), std::ptr::null_mut());
 			if ret >= 0 {
 				return Err(SetupError::SubprocessFailed(process_type.to_string()));
@@ -53,19 +57,8 @@ impl Context<Setup> {
 		})
 	}
 
-	pub(crate) fn init(self, event_handler: impl EventHandler) -> Result<Context<Initialized>, InitError> {
-		let mut settings = Settings::default();
-		settings.windowless_rendering_enabled = 1;
-		settings.multi_threaded_message_loop = 0;
-
-		let mut cef_app = AppImpl::new(event_handler.clone());
-
-		let res = initialize(Some(self.args.as_main_args()), Some(&settings), Some(&mut cef_app), std::ptr::null_mut());
-		if res != 1 {
-			return Err(InitError::InitializationFailed);
-		}
-
-		let render_handler = RenderHandlerImpl::new(event_handler.clone());
+	pub(crate) fn init(self, frame_buffer: FrameBufferHandle) -> Result<Context<Initialized>, InitError> {
+		let render_handler = OffscreenRenderHandler::new(frame_buffer);
 		let mut client = ClientImpl::new(render_handler);
 
 		let url = CefString::from("graphite://frontend/");

desktop/src/cef/context.rs

@@ -23,7 +23,7 @@ pub(crate) fn handle_window_event(context: &mut Context<Initialized>, event: &Wi
 
 				context.input_state.update_mouse_position(position);
 				let mouse_event: MouseEvent = (&context.input_state).into();
-				browser.host().unwrap().send_mouse_move_event(Some(&mouse_event), 0);
+				// browser.host().unwrap().send_mouse_move_event(Some(&mouse_event), 0);
 			}
 		}
 		WindowEvent::MouseInput { state, button, .. } => {

desktop/src/cef/input/mod.rs

@@ -1,31 +1,35 @@
 use cef::rc::{Rc, RcImpl};
 use cef::sys::{_cef_app_t, cef_base_ref_counted_t};
-use cef::{App, BrowserProcessHandler, ImplApp, SchemeRegistrar, WrapApp};
+use cef::{App, BrowserProcessHandler, Frame, ImplApp, SchemeRegistrar, WrapApp};
 
 use crate::cef::scheme_handler::GraphiteSchemeHandlerFactory;
 use crate::cef::EventHandler;
+use crate::render::{FrameBuffer, FrameBufferHandle};
 
-use super::browser_process_handler::BrowserProcessHandlerImpl;
+use super::browser_process_handler::OffscreenBrowserProcessHandler;
 
-pub(crate) struct AppImpl<H: EventHandler> {
-	object: *mut RcImpl<_cef_app_t, Self>,
-	event_handler: H,
+struct OffscreenApp {
+	object: *mut RcImpl<cef_dll_sys::_cef_app_t, Self>,
+	frame_buffer: Arc<Mutex<FrameBuffer>>,
 }
-impl<H: EventHandler> AppImpl<H> {
-	pub(crate) fn new(event_handler: H) -> App {
+
+impl OffscreenApp {
+	fn new(frame_buffer: Arc<Mutex<FrameBuffer>>) -> App {
 		App::new(Self {
 			object: std::ptr::null_mut(),
-			event_handler,
+			frame_buffer,
 		})
 	}
 }
 
-impl<H: EventHandler> ImplApp for AppImpl<H> {
+impl ImplApp for OffscreenApp {
 	fn browser_process_handler(&self) -> Option<BrowserProcessHandler> {
-		Some(BrowserProcessHandlerImpl::new(self.event_handler.clone()))
+		println!("browser_process_handler");
+		Some(OffscreenBrowserProcessHandler::new(self.frame_buffer.clone()))
 	}
 
 	fn on_register_custom_schemes(&self, registrar: Option<&mut SchemeRegistrar>) {
+		println!("on_register_custom_schemes");
 		GraphiteSchemeHandlerFactory::register_schemes(registrar);
 	}
 

desktop/src/cef/internal/app.rs

@@ -3,22 +3,17 @@ use cef::sys::{_cef_browser_process_handler_t, cef_base_ref_counted_t, cef_brows
 use cef::{BrowserProcessHandler, CefString, ImplBrowserProcessHandler, SchemeHandlerFactory, WrapBrowserProcessHandler};
 
 use crate::cef::scheme_handler::GraphiteSchemeHandlerFactory;
-use crate::cef::EventHandler;
 
-pub(crate) struct BrowserProcessHandlerImpl<H: EventHandler> {
+pub(crate) struct OffscreenBrowserProcessHandler {
 	object: *mut RcImpl<cef_browser_process_handler_t, Self>,
-	event_handler: H,
 }
-impl<H: EventHandler> BrowserProcessHandlerImpl<H> {
-	pub(crate) fn new(event_handler: H) -> BrowserProcessHandler {
-		BrowserProcessHandler::new(Self {
-			object: std::ptr::null_mut(),
-			event_handler,
-		})
+impl OffscreenBrowserProcessHandler {
+	pub(crate) fn new() -> BrowserProcessHandler {
+		BrowserProcessHandler::new(Self { object: std::ptr::null_mut() })
 	}
 }
 
-impl<H: EventHandler> ImplBrowserProcessHandler for BrowserProcessHandlerImpl<H> {
+impl ImplBrowserProcessHandler for OffscreenBrowserProcessHandler {
 	fn on_context_initialized(&self) {
 		cef::register_scheme_handler_factory(Some(&CefString::from("graphite")), None, Some(&mut SchemeHandlerFactory::new(GraphiteSchemeHandlerFactory::new())));
 	}
@@ -28,27 +23,24 @@ impl<H: EventHandler> ImplBrowserProcessHandler for BrowserProcessHandlerImpl<H>
 	}
 }
 
-impl<H: EventHandler> Clone for BrowserProcessHandlerImpl<H> {
+impl Clone for OffscreenBrowserProcessHandler {
 	fn clone(&self) -> Self {
 		unsafe {
 			let rc_impl = &mut *self.object;
 			rc_impl.interface.add_ref();
 		}
-		Self {
-			object: self.object,
-			event_handler: self.event_handler.clone(),
-		}
+		Self { object: self.object }
 	}
 }
-impl<H: EventHandler> Rc for BrowserProcessHandlerImpl<H> {
+impl Rc for OffscreenBrowserProcessHandler {
 	fn as_base(&self) -> &cef_base_ref_counted_t {
 		unsafe {
 			let base = &*self.object;
 			std::mem::transmute(&base.cef_object)
 		}
 	}
 }
-impl<H: EventHandler> WrapBrowserProcessHandler for BrowserProcessHandlerImpl<H> {
+impl WrapBrowserProcessHandler for OffscreenBrowserProcessHandler {
 	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_browser_process_handler_t, Self>) {
 		self.object = object;
 	}

desktop/src/cef/internal/browser_process_handler.rs

@@ -2,6 +2,7 @@ use cef::rc::{Rc, RcImpl};
 use cef::sys::{_cef_client_t, cef_base_ref_counted_t};
 use cef::{Client, ImplClient, RenderHandler, WrapClient};
 
+
 pub(crate) struct ClientImpl {
 	object: *mut RcImpl<_cef_client_t, Self>,
 	render_handler: RenderHandler,

desktop/src/cef/internal/client.rs

@@ -1,10 +1,8 @@
-mod app;
 mod browser_process_handler;
 mod client;
-mod non_browser_app;
+mod offscreen_app;
 mod render_handler;
 
-pub(crate) use app::AppImpl;
 pub(crate) use client::ClientImpl;
-pub(crate) use non_browser_app::NonBrowserAppImpl;
-pub(crate) use render_handler::RenderHandlerImpl;
+pub(crate) use offscreen_app::OffscreenApp;
+pub(crate) use render_handler::OffscreenRenderHandler;