Remove surface and window from ApplicationIo

Author: timon-schelling

Cargo.lock

@@ -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" }
+graphene-canvas-utils = { path = "node-graph/libraries/canvas-utils" }
 
 # Workspace dependencies
 rustc-hash = "2.0"

Cargo.toml

@@ -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

@@ -1067,8 +1067,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(wasm_application_io::create_canvas::IDENTIFIER),
 								skip_deduplication: true,
 								..Default::default()
 							},

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

@@ -7,7 +7,7 @@ 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;
@@ -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 });
 			}

editor/src/node_graph_executor.rs

@@ -19,6 +19,8 @@ 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};
@@ -58,7 +60,7 @@ pub struct NodeRuntime {
 
 	/// Cached surface for Wasm viewport rendering (reused across frames)
 	#[cfg(all(target_family = "wasm", feature = "gpu"))]
-	wasm_viewport_surface: Option<wgpu_executor::WgpuSurface>,
+	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"))]
 	current_viewport_texture: Option<ImageTexture>,
@@ -146,7 +148,7 @@ impl NodeRuntime {
 			vector_modify: Default::default(),
 			inspect_state: None,
 			#[cfg(all(target_family = "wasm", feature = "gpu"))]
-			wasm_viewport_surface: None,
+			wasm_canvas_cache: CanvasSurfaceHandle::new(),
 			#[cfg(all(target_family = "wasm", feature = "gpu"))]
 			current_viewport_texture: None,
 		}
@@ -280,7 +282,7 @@ impl NodeRuntime {
 								.gpu_executor()
 								.expect("GPU executor should be available when we receive a texture");
 
-							let raster_cpu = Raster::new_gpu(image_texture.texture.as_ref().clone()).convert(Footprint::BOUNDLESS, executor).await;
+							let raster_cpu = Raster::new_gpu(image_texture.as_ref().clone()).convert(Footprint::BOUNDLESS, executor).await;
 
 							let (data, width, height) = raster_cpu.to_flat_u8();
 
@@ -304,7 +306,7 @@ impl NodeRuntime {
 								.gpu_executor()
 								.expect("GPU executor should be available when we receive a texture");
 
-							let raster_cpu = Raster::new_gpu(image_texture.texture.as_ref().clone()).convert(Footprint::BOUNDLESS, executor).await;
+							let raster_cpu = Raster::new_gpu(image_texture.as_ref().clone()).convert(Footprint::BOUNDLESS, executor).await;
 
 							self.sender.send_eyedropper_preview(raster_cpu);
 							continue;
@@ -318,83 +320,20 @@ impl NodeRuntime {
 							data: RenderOutputType::Texture(image_texture),
 							metadata,
 						})) if !render_config.for_export => {
-							// On Wasm, for viewport rendering, blit the texture to a surface and return a CanvasFrame
+							self.current_viewport_texture = Some(image_texture.clone());
+
 							let app_io = self.editor_api.application_io.as_ref().unwrap();
 							let executor = app_io.gpu_executor().expect("GPU executor should be available when we receive a texture");
 
-							// Get or create the cached surface
-							if self.wasm_viewport_surface.is_none() {
-								let surface_handle = app_io.create_window();
-								let wasm_surface = executor
-									.create_surface(graphene_std::wasm_application_io::WasmSurfaceHandle {
-										surface: surface_handle.surface.clone(),
-										window_id: surface_handle.window_id,
-									})
-									.expect("Failed to create surface");
-								self.wasm_viewport_surface = Some(Arc::new(wasm_surface));
-							}
-
-							let surface = self.wasm_viewport_surface.as_ref().unwrap();
-
-							// Use logical resolution for CSS sizing, physical resolution for the actual surface/texture
-							let physical_resolution = render_config.viewport.resolution;
-							let logical_resolution = physical_resolution.as_dvec2() / render_config.scale;
-
-							// Blit the texture to the surface
-							let mut encoder = executor.context.device.create_command_encoder(&vello::wgpu::CommandEncoderDescriptor {
-								label: Some("Texture to Surface Blit"),
-							});
-
-							// Configure the surface at physical resolution (for HiDPI displays)
-							let surface_inner = &surface.surface.inner;
-							let surface_caps = surface_inner.get_capabilities(&executor.context.adapter);
-							surface_inner.configure(
-								&executor.context.device,
-								&vello::wgpu::SurfaceConfiguration {
-									usage: vello::wgpu::TextureUsages::RENDER_ATTACHMENT | vello::wgpu::TextureUsages::COPY_DST,
-									format: vello::wgpu::TextureFormat::Rgba8Unorm,
-									width: physical_resolution.x,
-									height: physical_resolution.y,
-									present_mode: surface_caps.present_modes[0],
-									alpha_mode: vello::wgpu::CompositeAlphaMode::PreMultiplied,
-									view_formats: vec![],
-									desired_maximum_frame_latency: 2,
-								},
-							);
-
-							let surface_texture = surface_inner.get_current_texture().expect("Failed to get surface texture");
-							self.current_viewport_texture = Some(image_texture.clone());
-
-							encoder.copy_texture_to_texture(
-								vello::wgpu::TexelCopyTextureInfoBase {
-									texture: image_texture.texture.as_ref(),
-									mip_level: 0,
-									origin: Default::default(),
-									aspect: Default::default(),
-								},
-								vello::wgpu::TexelCopyTextureInfoBase {
-									texture: &surface_texture.texture,
-									mip_level: 0,
-									origin: Default::default(),
-									aspect: Default::default(),
-								},
-								image_texture.texture.size(),
-							);
-
-							executor.context.queue.submit([encoder.finish()]);
-							surface_texture.present();
-
-							// TODO: Figure out if we can explicityl destroy the wgpu texture here to reduce the allocation pressure. We might also be able to use a texture allocation pool
-
-							let frame = graphene_std::application_io::SurfaceFrame {
-								surface_id: surface.window_id,
-								resolution: logical_resolution,
-								transform: glam::DAffine2::IDENTITY,
-							};
+							self.wasm_canvas_cache.present(&image_texture, executor);
 
+							let logical_resolution = render_config.viewport.resolution.as_dvec2() / render_config.scale;
 							(
 								Ok(TaggedValue::RenderOutput(RenderOutput {
-									data: RenderOutputType::CanvasFrame(frame),
+									data: RenderOutputType::CanvasFrame {
+										canvas_id: self.wasm_canvas_cache.id(),
+										resolution: logical_resolution,
+									},
 									metadata,
 								})),
 								None,

editor/src/node_graph_executor/runtime.rs

@@ -10,7 +10,6 @@ use dyn_any::DynAny;
 pub use dyn_any::StaticType;
 use glam::{Affine2, Vec2};
 pub use glam::{DAffine2, DVec2, IVec2, UVec2};
-use graphene_application_io::{ImageTexture, SurfaceFrame};
 use graphic_types::Artboard;
 use graphic_types::Graphic;
 use graphic_types::Vector;
@@ -40,7 +39,6 @@ macro_rules! tagged_value {
 			None,
 			$( $(#[$meta] ) *$identifier( $ty ), )*
 			RenderOutput(RenderOutput),
-			SurfaceFrame(SurfaceFrame),
 			#[serde(skip)]
 			EditorApi(Arc<WasmEditorApi>)
 		}
@@ -54,7 +52,6 @@ macro_rules! tagged_value {
 					Self::None => {}
 					$( Self::$identifier(x) => {x.hash(state)}),*
 					Self::RenderOutput(x) => x.hash(state),
-					Self::SurfaceFrame(x) => x.hash(state),
 					Self::EditorApi(x) => x.hash(state),
 				}
 			}
@@ -66,7 +63,6 @@ macro_rules! tagged_value {
 					Self::None => Box::new(()),
 					$( Self::$identifier(x) => Box::new(x), )*
 					Self::RenderOutput(x) => Box::new(x),
-					Self::SurfaceFrame(x) => Box::new(x),
 					Self::EditorApi(x) => Box::new(x),
 				}
 			}
@@ -76,7 +72,6 @@ macro_rules! tagged_value {
 					Self::None => Arc::new(()),
 					$( Self::$identifier(x) => Arc::new(x), )*
 					Self::RenderOutput(x) => Arc::new(x),
-					Self::SurfaceFrame(x) => Arc::new(x),
 					Self::EditorApi(x) => Arc::new(x),
 				}
 			}
@@ -86,7 +81,6 @@ macro_rules! tagged_value {
 					Self::None => concrete!(()),
 					$( Self::$identifier(_) => concrete!($ty), )*
 					Self::RenderOutput(_) => concrete!(RenderOutput),
-					Self::SurfaceFrame(_) => concrete!(SurfaceFrame),
 					Self::EditorApi(_) => concrete!(&WasmEditorApi)
 				}
 			}
@@ -99,8 +93,6 @@ macro_rules! tagged_value {
 					x if x == TypeId::of::<()>() => Ok(TaggedValue::None),
 					$( x if x == TypeId::of::<$ty>() => Ok(TaggedValue::$identifier(*downcast(input).unwrap())), )*
 					x if x == TypeId::of::<RenderOutput>() => Ok(TaggedValue::RenderOutput(*downcast(input).unwrap())),
-					x if x == TypeId::of::<SurfaceFrame>() => Ok(TaggedValue::SurfaceFrame(*downcast(input).unwrap())),
-
 
 					_ => Err(format!("Cannot convert {:?} to TaggedValue", DynAny::type_name(input.as_ref()))),
 				}
@@ -113,8 +105,7 @@ macro_rules! tagged_value {
 					x if x == TypeId::of::<()>() => Ok(TaggedValue::None),
 					$( x if x == TypeId::of::<$ty>() => Ok(TaggedValue::$identifier(<$ty as Clone>::clone(input.downcast_ref().unwrap()))), )*
 					x if x == TypeId::of::<RenderOutput>() => Ok(TaggedValue::RenderOutput(RenderOutput::clone(input.downcast_ref().unwrap()))),
-					x if x == TypeId::of::<SurfaceFrame>() => Ok(TaggedValue::SurfaceFrame(SurfaceFrame::clone(input.downcast_ref().unwrap()))),
-					_ => Err(format!("Cannot convert {:?} to TaggedValue",std::any::type_name_of_val(input))),
+					_ => Err(format!("Cannot convert {:?} to TaggedValue", std::any::type_name_of_val(input))),
 				}
 			}
 			/// Returns a TaggedValue from the type, where that value is its type's `Default::default()`
@@ -145,7 +136,6 @@ macro_rules! tagged_value {
 					Self::None => "()".to_string(),
 					$( Self::$identifier(x) => format!("{:?}", x), )*
 					Self::RenderOutput(_) => "RenderOutput".to_string(),
-					Self::SurfaceFrame(_) => "SurfaceFrame".to_string(),
 					Self::EditorApi(_) => "WasmEditorApi".to_string(),
 				}
 			}
@@ -477,11 +467,10 @@ pub struct RenderOutput {
 	pub metadata: RenderMetadata,
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, dyn_any::DynAny, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, dyn_any::DynAny, serde::Serialize, serde::Deserialize)]
 pub enum RenderOutputType {
-	CanvasFrame(SurfaceFrame),
 	#[serde(skip)]
-	Texture(ImageTexture),
+	Texture(graphene_application_io::ImageTexture),
 	#[serde(skip)]
 	Buffer {
 		data: Vec<u8>,
@@ -492,8 +481,35 @@ pub enum RenderOutputType {
 		svg: String,
 		image_data: Vec<(u64, Image<Color>)>,
 	},
+	#[cfg(target_family = "wasm")]
+	CanvasFrame {
+		canvas_id: u64,
+		resolution: DVec2,
+	},
 }
 
+impl Hash for RenderOutputType {
+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+		match self {
+			Self::Texture(texture) => {
+				texture.hash(state);
+			}
+			Self::Buffer { data, width, height } => {
+				data.hash(state);
+				width.hash(state);
+				height.hash(state);
+			}
+			Self::Svg { svg, image_data } => {
+				svg.hash(state);
+				image_data.hash(state);
+			}
+			#[cfg(target_family = "wasm")]
+			Self::CanvasFrame { canvas_id, .. } => {
+				canvas_id.hash(state);
+			}
+		}
+	}
+}
 impl Hash for RenderOutput {
 	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
 		self.data.hash(state)