Remove surface and window from ApplicationIo (#3941)

* Remove surface and window from ApplicationIo

* Seperate Wasm and Native ApplicationIo

* Fix warnings

* Fix tests

* Remove redundant PlatformApplicationIo::new_offscreen

* Fixup

* Remove unused From implementaitions for ApplicationIo

Author: timon-schelling

Cargo.lock

@@ -89,6 +89,8 @@ 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
 rustc-hash = "2.0"

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/Cargo.toml

@@ -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));
 	}
 
@@ -51,7 +51,7 @@ impl DesktopWrapper {
 	pub async fn execute_node_graph() -> NodeGraphExecutionResult {
 		let result = graphite_editor::node_graph_executor::run_node_graph().await;
 		match result {
-			(true, texture) => NodeGraphExecutionResult::HasRun(texture.map(|t| t.texture)),
+			(true, texture) => NodeGraphExecutionResult::HasRun(texture.map(Into::into)),
 			(false, _) => NodeGraphExecutionResult::NotRun,
 		}
 	}

desktop/wrapper/src/lib.rs

@@ -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/Cargo.toml

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

editor/src/messages/frontend/frontend_message.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()
 							},
 						]
@@ -1010,8 +1010,8 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 						exports: vec![NodeInput::node(NodeId(2), 0)],
 						nodes: [
 							DocumentNode {
-								inputs: vec![NodeInput::scope("editor-api")],
-								implementation: DocumentNodeImplementation::ProtoNode(wasm_application_io::create_surface::IDENTIFIER),
+								inputs: vec![],
+								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/node_graph/document_node_definitions.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/portfolio/document/overlays/utility_functions.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/messages/preferences/preferences_message_handler.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, format_transform_matrix};
+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(_) => {}
 			}
 		}
 
@@ -397,12 +397,11 @@ impl NodeGraphExecutor {
 				responses.add(FrontendMessage::UpdateImageData { image_data });
 				responses.add(FrontendMessage::UpdateDocumentArtwork { svg });
 			}
-			RenderOutputType::CanvasFrame(frame) => {
-				let matrix = format_transform_matrix(frame.transform);
-				let transform = if matrix.is_empty() { String::new() } else { format!(" transform=\"{matrix}\"") };
+			#[cfg(target_family = "wasm")]
+			RenderOutputType::CanvasFrame { canvas_id, resolution } => {
 				let svg = format!(
-					r#"<svg><foreignObject width="{}" height="{}"{transform}><div data-canvas-placeholder="{}" data-is-viewport="true"></div></foreignObject></svg>"#,
-					frame.resolution.x, frame.resolution.y, frame.surface_id.0,
+					r#"<svg><foreignObject width="{}" height="{}"><div data-canvas-placeholder="{}" data-is-viewport="true"></div></foreignObject></svg>"#,
+					resolution.x, resolution.y, canvas_id,
 				);
 				responses.add(FrontendMessage::UpdateDocumentArtwork { svg });
 			}