Further cleanup

Author: TrueDoctor

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

@@ -882,70 +882,6 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			properties: None,
 		},
 		#[cfg(feature = "gpu")]
-		DocumentNodeDefinition {
-			identifier: "Create GPU Surface",
-			category: "Debug: GPU",
-			node_template: NodeTemplate {
-				document_node: DocumentNode {
-					implementation: DocumentNodeImplementation::Network(NodeNetwork {
-						exports: vec![NodeInput::node(NodeId(1), 0)],
-						nodes: [
-							DocumentNode {
-								inputs: vec![NodeInput::scope("editor-api")],
-								implementation: DocumentNodeImplementation::ProtoNode(wgpu_executor::create_gpu_surface::IDENTIFIER),
-								..Default::default()
-							},
-							DocumentNode {
-								inputs: vec![NodeInput::node(NodeId(0), 0)],
-								implementation: DocumentNodeImplementation::ProtoNode(memo::memo::IDENTIFIER),
-								..Default::default()
-							},
-						]
-						.into_iter()
-						.enumerate()
-						.map(|(id, node)| (NodeId(id as u64), node))
-						.collect(),
-						..Default::default()
-					}),
-					..Default::default()
-				},
-				persistent_node_metadata: DocumentNodePersistentMetadata {
-					output_names: vec!["GPU Surface".to_string()],
-					network_metadata: Some(NodeNetworkMetadata {
-						persistent_metadata: NodeNetworkPersistentMetadata {
-							node_metadata: [
-								DocumentNodeMetadata {
-									persistent_metadata: DocumentNodePersistentMetadata {
-										display_name: "Create GPU Surface".to_string(),
-										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(0, 0)),
-										..Default::default()
-									},
-									..Default::default()
-								},
-								DocumentNodeMetadata {
-									persistent_metadata: DocumentNodePersistentMetadata {
-										display_name: "Cache".to_string(),
-										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(7, 0)),
-										..Default::default()
-									},
-									..Default::default()
-								},
-							]
-							.into_iter()
-							.enumerate()
-							.map(|(id, node)| (NodeId(id as u64), node))
-							.collect(),
-							..Default::default()
-						},
-						..Default::default()
-					}),
-					..Default::default()
-				},
-			},
-			description: Cow::Borrowed("TODO"),
-			properties: None,
-		},
-		#[cfg(feature = "gpu")]
 		DocumentNodeDefinition {
 			identifier: "Upload Texture",
 			category: "Debug: GPU",

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -366,7 +366,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageContext<'_>> for Portfolio
 
 					let scale = viewport.scale();
 					// Use exact physical dimensions from browser (via ResizeObserver's devicePixelContentBoxSize)
-					let physical_resolution = viewport.size().to_physical().into_dvec2().as_uvec2();
+					let physical_resolution = viewport.size().to_physical().into_dvec2().round().as_uvec2();
 
 					if let Ok(message) = self.executor.submit_node_graph_evaluation(
 						self.documents.get_mut(document_id).expect("Tried to render non-existent document"),

editor/src/node_graph_executor.rs

@@ -421,8 +421,8 @@ impl NodeGraphExecutor {
 				let matrix = format_transform_matrix(frame.transform);
 				let transform = if matrix.is_empty() { String::new() } else { format!(" transform=\"{matrix}\"") };
 				let svg = format!(
-					r#"<svg><foreignObject width="{}" height="{}"{transform}><div data-canvas-placeholder="{}" data-physical-width="{}" data-physical-height="{}" data-is-viewport="true"></div></foreignObject></svg>"#,
-					frame.resolution.x, frame.resolution.y, frame.surface_id.0, frame.physical_resolution.x, frame.physical_resolution.y
+					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,
 				);
 				self.last_svg_canvas = Some(frame);
 				responses.add(FrontendMessage::UpdateDocumentArtwork { svg });

editor/src/node_graph_executor/runtime.rs

@@ -330,7 +330,6 @@ impl NodeRuntime {
 							let frame = graphene_std::application_io::SurfaceFrame {
 								surface_id: surface.window_id,
 								resolution: logical_resolution,
-								physical_resolution,
 								transform: glam::DAffine2::IDENTITY,
 							};
 

frontend/src/components/panels/Document.svelte

@@ -206,8 +206,8 @@
 			// Get logical dimensions from foreignObject parent (set by backend)
 			const foreignObject = placeholder.parentElement;
 			if (!foreignObject) return;
-			const logicalWidth = parseInt(foreignObject.getAttribute("width") || "0");
-			const logicalHeight = parseInt(foreignObject.getAttribute("height") || "0");
+			const logicalWidth = parseFloat(foreignObject.getAttribute("width") || "0");
+			const logicalHeight = parseFloat(foreignObject.getAttribute("height") || "0");
 
 			// Clone canvas for repeated instances (layers that appear multiple times)
 			// Viewport canvas is marked with data-is-viewport and should never be cloned

node-graph/interpreted-executor/src/node_registry.rs

@@ -6,8 +6,6 @@ use graph_craft::proto::{NodeConstructor, TypeErasedBox};
 use graphene_std::Artboard;
 use graphene_std::Context;
 use graphene_std::Graphic;
-#[cfg(feature = "gpu")]
-use graphene_std::any::DowncastBothNode;
 use graphene_std::any::DynAnyNode;
 use graphene_std::application_io::{ImageTexture, SurfaceFrame};
 use graphene_std::brush::brush_cache::BrushCache;
@@ -234,28 +232,6 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => path_bool_nodes::BooleanOperation]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::text::TextAlign]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => RenderIntermediate]),
-		// =======================
-		// CREATE GPU SURFACE NODE
-		// =======================
-		#[cfg(feature = "gpu")]
-		(
-			ProtoNodeIdentifier::new(stringify!(wgpu_executor::CreateGpuSurfaceNode<_>)),
-			|args| {
-				Box::pin(async move {
-					let editor_api: DowncastBothNode<Context, &WasmEditorApi> = DowncastBothNode::new(args[0].clone());
-					let node = <wgpu_executor::CreateGpuSurfaceNode<_>>::new(editor_api);
-					let any: DynAnyNode<Context, _, _> = DynAnyNode::new(node);
-					Box::new(any) as TypeErasedBox
-				})
-			},
-			{
-				let node = <wgpu_executor::CreateGpuSurfaceNode<_>>::new(graphene_std::any::PanicNode::<Context, dyn_any::DynFuture<'static, &WasmEditorApi>>::new());
-				let params = vec![fn_type_fut!(Context, &WasmEditorApi)];
-				let mut node_io = <wgpu_executor::CreateGpuSurfaceNode<_> as NodeIO<'_, Context>>::to_async_node_io(&node, params);
-				node_io.call_argument = concrete!(<Context as StaticType>::Static);
-				node_io
-			},
-		),
 	];
 	// =============
 	// CONVERT NODES

node-graph/libraries/application-io/src/lib.rs

@@ -25,8 +25,6 @@ pub struct SurfaceFrame {
 	pub surface_id: SurfaceId,
 	/// Logical resolution in CSS pixels (used for foreignObject dimensions)
 	pub resolution: DVec2,
-	/// Physical resolution in device pixels (used for actual canvas/texture dimensions)
-	pub physical_resolution: UVec2,
 	pub transform: DAffine2,
 }
 
@@ -109,7 +107,6 @@ impl<S: Size> From<SurfaceHandleFrame<S>> for SurfaceFrame {
 			surface_id: x.surface_handle.window_id,
 			transform: x.transform,
 			resolution: size.into(),
-			physical_resolution: size,
 		}
 	}
 }

node-graph/nodes/gstd/src/render_node.rs

@@ -133,7 +133,7 @@ async fn render<'a: 'n>(ctx: impl Ctx + ExtractFootprint + ExtractVarArgs, edito
 
 	let scale = render_params.scale;
 	let physical_resolution = render_params.footprint.resolution;
-	let logical_resolution = (render_params.footprint.resolution.as_dvec2() / scale);
+	let logical_resolution = render_params.footprint.resolution.as_dvec2() / scale;
 
 	let RenderIntermediate { ty, mut metadata, contains_artboard } = data;
 	metadata.apply_transform(footprint.transform);

node-graph/wgpu-executor/src/lib.rs

@@ -4,7 +4,7 @@ pub mod texture_conversion;
 
 use crate::shader_runtime::ShaderRuntime;
 use anyhow::Result;
-use core_types::{Color, Ctx};
+use core_types::Color;
 use dyn_any::StaticType;
 use futures::lock::Mutex;
 use glam::UVec2;
@@ -176,10 +176,3 @@ impl WgpuExecutor {
 }
 
 pub type WindowHandle = Arc<SurfaceHandle<Window>>;
-
-#[node_macro::node(skip_impl)]
-fn create_gpu_surface<'a: 'n, Io: ApplicationIo<Executor = WgpuExecutor, Surface = Window> + 'a + Send + Sync>(_: impl Ctx + 'a, editor_api: &'a EditorApi<Io>) -> Option<WgpuSurface> {
-	let canvas = editor_api.application_io.as_ref()?.window()?;
-	let executor = editor_api.application_io.as_ref()?.gpu_executor()?;
-	Some(Arc::new(executor.create_surface(canvas).ok()?))
-}