Seperate wasm and native application io

Author: timon-schelling

Cargo.toml

@@ -89,6 +89,7 @@ interpreted-executor = { path = "node-graph/interpreted-executor" }
 node-macro = { path = "node-graph/node-macro" }
 wgpu-executor = { path = "node-graph/libraries/wgpu-executor" }
 graphite-proc-macros = { path = "proc-macros" }
+graphite-editor = { path = "editor" }
 graphene-canvas-utils = { path = "node-graph/libraries/canvas-utils" }
 
 # Workspace dependencies

desktop/wrapper/Cargo.toml

@@ -13,9 +13,7 @@ gpu = ["graphite-editor/gpu", "graphene-std/shader-nodes"]
 
 [dependencies]
 # Local dependencies
-graphite-editor = { path = "../../editor", features = [
-	"gpu",
-] }
+graphite-editor = { workspace = true }
 graphene-std = { workspace = true }
 graph-craft = { workspace = true }
 wgpu-executor = { workspace = true }

desktop/wrapper/src/lib.rs

@@ -1,4 +1,4 @@
-use graph_craft::wasm_application_io::WasmApplicationIo;
+use graph_craft::application_io::PlatformApplicationIo;
 use graphite_editor::application::{Editor, Environment, Host, Platform};
 use graphite_editor::messages::prelude::{FrontendMessage, Message};
 use message_dispatcher::DesktopWrapperMessageDispatcher;
@@ -38,7 +38,7 @@ impl DesktopWrapper {
 	}
 
 	pub fn init(&self, wgpu_context: WgpuContext) {
-		let application_io = WasmApplicationIo::new_with_context(wgpu_context);
+		let application_io = PlatformApplicationIo::new_with_context(wgpu_context);
 		futures::executor::block_on(graphite_editor::node_graph_executor::replace_application_io(application_io));
 	}
 

editor/Cargo.toml

@@ -11,9 +11,9 @@ repository = "https://github.com/GraphiteEditor/Graphite"
 license = "Apache-2.0"
 
 [features]
-default = ["wasm", "gpu"]
-wasm = ["wasm-bindgen", "graphene-std/wasm"]
-gpu = ["interpreted-executor/gpu", "wgpu-executor"]
+default = ["gpu"]
+wasm = ["graphene-std/wasm", "interpreted-executor/wasm", "dep:wasm-bindgen"]
+gpu = ["interpreted-executor/gpu", "dep:wgpu-executor"]
 
 [dependencies]
 # Local dependencies

editor/src/messages/frontend/frontend_message.rs

@@ -130,7 +130,7 @@ pub enum FrontendMessage {
 	TriggerOpen,
 	TriggerImport,
 	TriggerSavePreferences {
-		#[tsify(type = "unknown")]
+		#[cfg_attr(feature = "wasm", tsify(type = "unknown"))]
 		preferences: PreferencesMessageHandler,
 	},
 	TriggerSaveActiveDocument {

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -947,12 +947,12 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 						nodes: [
 							DocumentNode {
 								inputs: vec![NodeInput::value(TaggedValue::None, false), NodeInput::scope("editor-api"), NodeInput::import(concrete!(String), 1)],
-								implementation: DocumentNodeImplementation::ProtoNode(wasm_application_io::load_resource::IDENTIFIER),
+								implementation: DocumentNodeImplementation::ProtoNode(platform_application_io::load_resource::IDENTIFIER),
 								..Default::default()
 							},
 							DocumentNode {
 								inputs: vec![NodeInput::node(NodeId(0), 0)],
-								implementation: DocumentNodeImplementation::ProtoNode(wasm_application_io::decode_image::IDENTIFIER),
+								implementation: DocumentNodeImplementation::ProtoNode(platform_application_io::decode_image::IDENTIFIER),
 								..Default::default()
 							},
 						]
@@ -1011,7 +1011,7 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 						nodes: [
 							DocumentNode {
 								inputs: vec![],
-								implementation: DocumentNodeImplementation::ProtoNode(wasm_application_io::create_canvas::IDENTIFIER),
+								implementation: DocumentNodeImplementation::ProtoNode(platform_application_io::create_canvas::IDENTIFIER),
 								skip_deduplication: true,
 								..Default::default()
 							},
@@ -1022,7 +1022,7 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 							},
 							DocumentNode {
 								inputs: vec![NodeInput::import(generic!(T), 0), NodeInput::import(concrete!(Footprint), 1), NodeInput::node(NodeId(1), 0)],
-								implementation: DocumentNodeImplementation::ProtoNode(wasm_application_io::rasterize::IDENTIFIER),
+								implementation: DocumentNodeImplementation::ProtoNode(platform_application_io::rasterize::IDENTIFIER),
 								..Default::default()
 							},
 						]

editor/src/messages/portfolio/document/overlays/utility_functions.rs

@@ -11,15 +11,18 @@ use graphene_std::vector::misc::ManipulatorPointId;
 use graphene_std::vector::{PointId, SegmentId, Vector};
 use std::collections::HashMap;
 use std::sync::{LazyLock, Mutex};
+#[cfg(target_family = "wasm")]
 use wasm_bindgen::JsCast;
 
+#[cfg(target_family = "wasm")]
 pub fn overlay_canvas_element() -> Option<web_sys::HtmlCanvasElement> {
 	let window = web_sys::window()?;
 	let document = window.document()?;
 	let canvas = document.query_selector("[data-overlays-canvas]").ok().flatten()?;
 	canvas.dyn_into::<web_sys::HtmlCanvasElement>().ok()
 }
 
+#[cfg(target_family = "wasm")]
 pub fn overlay_canvas_context() -> web_sys::CanvasRenderingContext2d {
 	let create_context = || {
 		let context = overlay_canvas_element()?.get_context("2d").ok().flatten()?;

editor/src/messages/preferences/preferences_message_handler.rs

@@ -4,7 +4,7 @@ use crate::messages::portfolio::document::utility_types::wires::GraphWireStyle;
 use crate::messages::preferences::SelectionMode;
 use crate::messages::prelude::*;
 use crate::messages::tool::utility_types::ToolType;
-use graph_craft::wasm_application_io::EditorPreferences;
+use graph_craft::application_io::EditorPreferences;
 
 #[derive(ExtractField)]
 pub struct PreferencesMessageContext<'a> {
@@ -51,7 +51,7 @@ impl PreferencesMessageHandler {
 	}
 
 	pub fn supports_wgpu(&self) -> bool {
-		graph_craft::wasm_application_io::wgpu_available().unwrap_or_default()
+		graph_craft::application_io::wgpu_available().unwrap_or_default()
 	}
 }
 

editor/src/node_graph_executor.rs

@@ -1,17 +1,16 @@
 use crate::messages::frontend::utility_types::{ExportBounds, FileType};
 use crate::messages::prelude::*;
 use glam::{DAffine2, DVec2, UVec2};
-use graph_craft::document::value::{RenderOutput, TaggedValue};
+use graph_craft::application_io::EditorPreferences;
+use graph_craft::document::value::{RenderOutput, RenderOutputType, TaggedValue};
 use graph_craft::document::{DocumentNode, DocumentNodeImplementation, NodeId, NodeInput};
 use graph_craft::proto::GraphErrors;
-use graph_craft::wasm_application_io::EditorPreferences;
 use graphene_std::application_io::{NodeGraphUpdateMessage, RenderConfig, TimingInformation};
 use graphene_std::raster::{CPU, Raster};
 use graphene_std::renderer::RenderMetadata;
 use graphene_std::text::FontCache;
 use graphene_std::transform::Footprint;
 use graphene_std::vector::Vector;
-use graphene_std::wasm_application_io::RenderOutputType;
 use interpreted_executor::dynamic_executor::ResolvedDocumentNodeTypesDelta;
 
 mod runtime_io;
@@ -380,6 +379,7 @@ impl NodeGraphExecutor {
 					let (data, width, height) = raster.to_flat_u8();
 					responses.add(EyedropperToolMessage::PreviewImage { data, width, height });
 				}
+				NodeGraphUpdate::NodeGraphUpdateMessage(_) => {}
 			}
 		}
 

editor/src/node_graph_executor/runtime.rs

@@ -1,27 +1,25 @@
 use super::*;
 use crate::messages::frontend::utility_types::{ExportBounds, FileType};
 use glam::{DAffine2, UVec2};
-use graph_craft::document::value::TaggedValue;
+use graph_craft::application_io::{PlatformApplicationIo, PlatformEditorApi};
+use graph_craft::document::value::{RenderOutput, RenderOutputType, TaggedValue};
 use graph_craft::document::{NodeId, NodeNetwork};
 use graph_craft::graphene_compiler::Compiler;
 use graph_craft::proto::GraphErrors;
-use graph_craft::wasm_application_io::EditorPreferences;
 use graph_craft::{ProtoNodeIdentifier, concrete};
 use graphene_std::application_io::{ApplicationIo, ExportFormat, ImageTexture, NodeGraphUpdateMessage, NodeGraphUpdateSender, RenderConfig};
 use graphene_std::bounds::RenderBoundingBox;
 use graphene_std::memo::IORecord;
 use graphene_std::ops::Convert;
+#[cfg(all(target_family = "wasm", feature = "gpu", feature = "wasm"))]
+use graphene_std::platform_application_io::canvas_utils::{Canvas, CanvasSurface, CanvasSurfaceHandle};
 use graphene_std::raster_types::Raster;
-use graphene_std::renderer::{Render, RenderParams, SvgRender};
-use graphene_std::renderer::{RenderSvgSegmentList, SvgSegment};
+use graphene_std::renderer::{Render, RenderParams, RenderSvgSegmentList, SvgRender, SvgSegment};
 use graphene_std::table::{Table, TableRow};
 use graphene_std::text::FontCache;
 use graphene_std::transform::RenderQuality;
 use graphene_std::vector::Vector;
 use graphene_std::vector::style::RenderMode;
-#[cfg(target_family = "wasm")]
-use graphene_std::wasm_application_io::canvas_utils::{Canvas, CanvasSurface, CanvasSurfaceHandle};
-use graphene_std::wasm_application_io::{RenderOutputType, WasmApplicationIo, WasmEditorApi};
 use graphene_std::{Artboard, Context, Graphic};
 use interpreted_executor::dynamic_executor::{DynamicExecutor, IntrospectError, ResolvedDocumentNodeTypesDelta};
 use interpreted_executor::util::wrap_network_in_scope;
@@ -30,7 +28,7 @@ use std::sync::Arc;
 use std::sync::mpsc::{Receiver, Sender};
 
 /// Persistent data between graph executions. It's updated via message passing from the editor thread with [`GraphRuntimeRequest`]`.
-/// Some of these fields are put into a [`WasmEditorApi`] which is passed to the final compiled graph network upon each execution.
+/// Some of these fields are put into a [`PlatformEditorApi`] which is passed to the final compiled graph network upon each execution.
 /// Once the implementation is finished, this will live in a separate thread. Right now it's part of the main JS thread, but its own separate JS stack frame independent from the editor.
 pub struct NodeRuntime {
 	#[cfg(test)]
@@ -43,7 +41,7 @@ pub struct NodeRuntime {
 	old_graph: Option<NodeNetwork>,
 	update_thumbnails: bool,
 
-	editor_api: Arc<WasmEditorApi>,
+	editor_api: Arc<PlatformEditorApi>,
 	node_graph_errors: GraphErrors,
 	monitor_nodes: Vec<Vec<NodeId>>,
 
@@ -59,10 +57,10 @@ pub struct NodeRuntime {
 	vector_modify: HashMap<NodeId, Vector>,
 
 	/// Cached surface for Wasm viewport rendering (reused across frames)
-	#[cfg(all(target_family = "wasm", feature = "gpu"))]
+	#[cfg(all(target_family = "wasm", feature = "gpu", feature = "wasm"))]
 	wasm_canvas_cache: CanvasSurfaceHandle,
 	/// Currently displayed texture, the runtime keeps a reference to it to avoid the texture getting destroyed while it is still in use.
-	#[cfg(all(target_family = "wasm", feature = "gpu"))]
+	#[cfg(all(target_family = "wasm", feature = "gpu", feature = "wasm"))]
 	current_viewport_texture: Option<ImageTexture>,
 }
 
@@ -130,7 +128,7 @@ impl NodeRuntime {
 			old_graph: None,
 			update_thumbnails: true,
 
-			editor_api: WasmEditorApi {
+			editor_api: PlatformEditorApi {
 				font_cache: FontCache::default(),
 				editor_preferences: Box::new(EditorPreferences::default()),
 				node_graph_message_sender: Box::new(InternalNodeGraphUpdateSender(sender)),
@@ -156,11 +154,11 @@ impl NodeRuntime {
 
 	pub async fn run(&mut self) -> Option<ImageTexture> {
 		if self.editor_api.application_io.is_none() {
-			self.editor_api = WasmEditorApi {
+			self.editor_api = PlatformEditorApi {
 				#[cfg(all(not(test), target_family = "wasm"))]
-				application_io: Some(WasmApplicationIo::new().await.into()),
+				application_io: Some(PlatformApplicationIo::new().await.into()),
 				#[cfg(any(test, not(target_family = "wasm")))]
-				application_io: Some(WasmApplicationIo::new_offscreen().await.into()),
+				application_io: Some(PlatformApplicationIo::new_offscreen().await.into()),
 				font_cache: self.editor_api.font_cache.clone(),
 				node_graph_message_sender: Box::new(self.sender.clone()),
 				editor_preferences: Box::new(self.editor_preferences.clone()),
@@ -210,7 +208,7 @@ impl NodeRuntime {
 		for request in requests {
 			match request {
 				GraphRuntimeRequest::FontCacheUpdate(font_cache) => {
-					self.editor_api = WasmEditorApi {
+					self.editor_api = PlatformEditorApi {
 						font_cache,
 						application_io: self.editor_api.application_io.clone(),
 						node_graph_message_sender: Box::new(self.sender.clone()),
@@ -224,7 +222,7 @@ impl NodeRuntime {
 				}
 				GraphRuntimeRequest::EditorPreferencesUpdate(preferences) => {
 					self.editor_preferences = preferences.clone();
-					self.editor_api = WasmEditorApi {
+					self.editor_api = PlatformEditorApi {
 						font_cache: self.editor_api.font_cache.clone(),
 						application_io: self.editor_api.application_io.clone(),
 						node_graph_message_sender: Box::new(self.sender.clone()),
@@ -531,10 +529,10 @@ pub async fn replace_node_runtime(runtime: NodeRuntime) -> Option<NodeRuntime> {
 	let mut node_runtime = NODE_RUNTIME.lock();
 	node_runtime.replace(runtime)
 }
-pub async fn replace_application_io(application_io: WasmApplicationIo) {
+pub async fn replace_application_io(application_io: PlatformApplicationIo) {
 	let mut node_runtime = NODE_RUNTIME.lock();
 	if let Some(node_runtime) = &mut *node_runtime {
-		node_runtime.editor_api = WasmEditorApi {
+		node_runtime.editor_api = PlatformEditorApi {
 			font_cache: node_runtime.editor_api.font_cache.clone(),
 			application_io: Some(application_io.into()),
 			node_graph_message_sender: Box::new(node_runtime.sender.clone()),