Don't round logical coordinates

Author: TrueDoctor

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -21,6 +21,7 @@ use crate::messages::prelude::*;
 use crate::messages::tool::common_functionality::graph_modification_utils;
 use crate::messages::tool::common_functionality::utility_functions::make_path_editable_is_allowed;
 use crate::messages::tool::utility_types::{HintData, HintGroup, ToolType};
+use crate::messages::viewport::ToPhysical;
 use crate::node_graph_executor::{ExportConfig, NodeGraphExecutor};
 use derivative::*;
 use glam::{DAffine2, DVec2};
@@ -364,15 +365,12 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageContext<'_>> for Portfolio
 					let node_to_inspect = self.node_to_inspect();
 
 					let scale = viewport.scale();
-					// Use logical dimensions for viewport resolution (foreignObject sizing)
-					let logical_resolution = viewport.size().into_dvec2().ceil().as_uvec2();
 					// Use exact physical dimensions from browser (via ResizeObserver's devicePixelContentBoxSize)
-					let physical_resolution = viewport.physical_size_uvec2();
+					let physical_resolution = viewport.size().to_physical().into_dvec2().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"),
 						*document_id,
-						logical_resolution,
 						physical_resolution,
 						scale,
 						timing_information,
@@ -974,14 +972,12 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageContext<'_>> for Portfolio
 				};
 
 				let scale = viewport.scale();
-				// Use logical dimensions for viewport resolution (foreignObject sizing)
-				let logical_resolution = viewport.size().into_dvec2().ceil().as_uvec2();
 				// Use exact physical dimensions from browser (via ResizeObserver's devicePixelContentBoxSize)
-				let physical_resolution = viewport.physical_size_uvec2();
+				let physical_resolution = viewport.size().to_physical().into_dvec2().round().as_uvec2();
 
 				let result = self
 					.executor
-					.submit_node_graph_evaluation(document, document_id, logical_resolution, physical_resolution, scale, timing_information, node_to_inspect, ignore_hash);
+					.submit_node_graph_evaluation(document, document_id, physical_resolution, scale, timing_information, node_to_inspect, ignore_hash);
 
 				match result {
 					Err(description) => {

editor/src/messages/viewport/viewport_message.rs

@@ -3,14 +3,6 @@ use crate::messages::prelude::*;
 #[impl_message(Message, Viewport)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ViewportMessage {
-	Update {
-		x: f64,
-		y: f64,
-		width: f64,
-		height: f64,
-		scale: f64,
-		physical_width: f64,
-		physical_height: f64,
-	},
+	Update { x: f64, y: f64, width: f64, height: f64, scale: f64 },
 	RepropagateUpdate,
 }

editor/src/messages/viewport/viewport_message_handler.rs

@@ -6,8 +6,6 @@ use crate::messages::tool::tool_messages::tool_prelude::DVec2;
 #[derive(Debug, PartialEq, Clone, Copy, serde::Serialize, serde::Deserialize, specta::Type, ExtractField)]
 pub struct ViewportMessageHandler {
 	bounds: Bounds,
-	// Physical bounds in device pixels (exact pixel dimensions from browser)
-	physical_bounds: Bounds,
 	// Ratio of logical pixels to physical pixels
 	scale: f64,
 }
@@ -18,10 +16,6 @@ impl Default for ViewportMessageHandler {
 				offset: Point { x: 0.0, y: 0.0 },
 				size: Point { x: 0.0, y: 0.0 },
 			},
-			physical_bounds: Bounds {
-				offset: Point { x: 0.0, y: 0.0 },
-				size: Point { x: 0.0, y: 0.0 },
-			},
 			scale: 1.0,
 		}
 	}
@@ -31,29 +25,14 @@ impl Default for ViewportMessageHandler {
 impl MessageHandler<ViewportMessage, ()> for ViewportMessageHandler {
 	fn process_message(&mut self, message: ViewportMessage, responses: &mut VecDeque<Message>, _: ()) {
 		match message {
-			ViewportMessage::Update {
-				x,
-				y,
-				width,
-				height,
-				scale,
-				physical_width,
-				physical_height,
-			} => {
+			ViewportMessage::Update { x, y, width, height, scale } => {
 				assert_ne!(scale, 0.0, "Viewport scale cannot be zero");
 				self.scale = scale;
 
 				self.bounds = Bounds {
 					offset: Point { x, y },
 					size: Point { x: width, y: height },
 				};
-				self.physical_bounds = Bounds {
-					offset: Point { x, y },
-					size: Point {
-						x: physical_width,
-						y: physical_height,
-					},
-				};
 				responses.add(NodeGraphMessage::UpdateNodeGraphWidth);
 			}
 			ViewportMessage::RepropagateUpdate => {}
@@ -102,11 +81,6 @@ impl ViewportMessageHandler {
 		self.bounds.size().into_scaled(self.scale)
 	}
 
-	pub fn physical_size_uvec2(&self) -> glam::UVec2 {
-		let size = self.physical_bounds.size();
-		glam::UVec2::new(size.x.ceil() as u32, size.y.ceil() as u32)
-	}
-
 	#[expect(private_bounds)]
 	pub fn logical<T: Into<Point>>(&self, point: T) -> LogicalPoint {
 		point.into().convert_to_logical(self.scale)

editor/src/node_graph_executor.rs

@@ -138,7 +138,6 @@ impl NodeGraphExecutor {
 		document: &mut DocumentMessageHandler,
 		document_id: DocumentId,
 		viewport_resolution: UVec2,
-		physical_viewport_resolution: UVec2,
 		viewport_scale: f64,
 		time: TimingInformation,
 	) -> Result<Message, String> {
@@ -149,7 +148,6 @@ impl NodeGraphExecutor {
 		};
 		let render_config = RenderConfig {
 			viewport,
-			physical_viewport_resolution,
 			scale: viewport_scale,
 			time,
 			export_format: graphene_std::application_io::ExportFormat::Raster,
@@ -173,14 +171,13 @@ impl NodeGraphExecutor {
 		document: &mut DocumentMessageHandler,
 		document_id: DocumentId,
 		viewport_resolution: UVec2,
-		physical_viewport_resolution: UVec2,
 		viewport_scale: f64,
 		time: TimingInformation,
 		node_to_inspect: Option<NodeId>,
 		ignore_hash: bool,
 	) -> Result<Message, String> {
 		self.update_node_graph(document, node_to_inspect, ignore_hash)?;
-		self.submit_current_node_graph_evaluation(document, document_id, viewport_resolution, physical_viewport_resolution, viewport_scale, time)
+		self.submit_current_node_graph_evaluation(document, document_id, viewport_resolution, viewport_scale, time)
 	}
 
 	/// Evaluates a node graph for export
@@ -209,8 +206,6 @@ impl NodeGraphExecutor {
 				transform,
 				..Default::default()
 			},
-			// For export, logical and physical are the same (no HiDPI scaling)
-			physical_viewport_resolution: resolution,
 			scale: export_config.scale_factor,
 			time: Default::default(),
 			export_format,
@@ -425,10 +420,9 @@ impl NodeGraphExecutor {
 				}
 				let matrix = format_transform_matrix(frame.transform);
 				let transform = if matrix.is_empty() { String::new() } else { format!(" transform=\"{matrix}\"") };
-				// Mark viewport canvas with data attribute so it won't be cloned for repeated instances
 				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="{}"{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
 				);
 				self.last_svg_canvas = Some(frame);
 				responses.add(FrontendMessage::UpdateDocumentArtwork { svg });

editor/src/node_graph_executor/runtime.rs

@@ -289,8 +289,8 @@ impl NodeRuntime {
 							let surface = self.wasm_viewport_surface.as_ref().unwrap();
 
 							// Use logical resolution for CSS sizing, physical resolution for the actual surface/texture
-							let logical_resolution = render_config.viewport.resolution;
-							let physical_resolution = render_config.physical_viewport_resolution;
+							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 {

frontend/src/utility-functions/viewports.ts

@@ -39,9 +39,11 @@ export function setupViewportResizeObserver(editor: Editor) {
 			// Get viewport position
 			const bounds = entry.target.getBoundingClientRect();
 
+			const scale = physicalWidth / logicalWidth;
+
 			// Send both logical and physical dimensions to the backend
 			// Logical dimensions are used for CSS/SVG sizing, physical for GPU textures
-			editor.handle.updateViewport(bounds.x, bounds.y, logicalWidth, logicalHeight, devicePixelRatio, physicalWidth, physicalHeight);
+			editor.handle.updateViewport(bounds.x, bounds.y, logicalWidth, logicalHeight, scale);
 		}
 	});
 

frontend/wasm/src/editor_api.rs

@@ -518,16 +518,8 @@ impl EditorHandle {
 
 	/// Send new viewport info to the backend
 	#[wasm_bindgen(js_name = updateViewport)]
-	pub fn update_viewport(&self, x: f64, y: f64, width: f64, height: f64, scale: f64, physical_width: f64, physical_height: f64) {
-		let message = ViewportMessage::Update {
-			x,
-			y,
-			width,
-			height,
-			scale,
-			physical_width,
-			physical_height,
-		};
+	pub fn update_viewport(&self, x: f64, y: f64, width: f64, height: f64, scale: f64) {
+		let message = ViewportMessage::Update { x, y, width, height, scale };
 		self.dispatch(message);
 	}
 

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

@@ -1,6 +1,6 @@
 use core_types::transform::Footprint;
 use dyn_any::{DynAny, StaticType, StaticTypeSized};
-use glam::{DAffine2, UVec2};
+use glam::{DAffine2, DVec2, UVec2};
 use std::fmt::Debug;
 use std::future::Future;
 use std::hash::{Hash, Hasher};
@@ -24,7 +24,7 @@ impl std::fmt::Display for SurfaceId {
 pub struct SurfaceFrame {
 	pub surface_id: SurfaceId,
 	/// Logical resolution in CSS pixels (used for foreignObject dimensions)
-	pub resolution: UVec2,
+	pub resolution: DVec2,
 	/// Physical resolution in device pixels (used for actual canvas/texture dimensions)
 	pub physical_resolution: UVec2,
 	pub transform: DAffine2,
@@ -108,7 +108,7 @@ impl<S: Size> From<SurfaceHandleFrame<S>> for SurfaceFrame {
 		Self {
 			surface_id: x.surface_handle.window_id,
 			transform: x.transform,
-			resolution: size,
+			resolution: size.into(),
 			physical_resolution: size,
 		}
 	}
@@ -239,8 +239,6 @@ pub struct TimingInformation {
 #[derive(Debug, Default, Clone, Copy, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
 pub struct RenderConfig {
 	pub viewport: Footprint,
-	/// Physical viewport resolution in device pixels (from ResizeObserver's devicePixelContentBoxSize)
-	pub physical_viewport_resolution: UVec2,
 	pub scale: f64,
 	pub export_format: ExportFormat,
 	pub time: TimingInformation,

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

@@ -120,11 +120,7 @@ async fn create_context<'a: 'n>(
 }
 
 #[node_macro::node(category(""))]
-async fn render<'a: 'n>(
-	ctx: impl Ctx + ExtractFootprint + ExtractVarArgs,
-	editor_api: &'a WasmEditorApi,
-	data: RenderIntermediate,
-) -> RenderOutput {
+async fn render<'a: 'n>(ctx: impl Ctx + ExtractFootprint + ExtractVarArgs, editor_api: &'a WasmEditorApi, data: RenderIntermediate) -> RenderOutput {
 	let footprint = ctx.footprint();
 	let render_params = ctx
 		.vararg(0)
@@ -135,6 +131,10 @@ async fn render<'a: 'n>(
 	render_params.footprint = *footprint;
 	let render_params = &render_params;
 
+	let scale = render_params.scale;
+	let physical_resolution = render_params.footprint.resolution;
+	let logical_resolution = (render_params.footprint.resolution.as_dvec2() / scale).round().as_uvec2();
+
 	let RenderIntermediate { ty, mut metadata, contains_artboard } = data;
 	metadata.apply_transform(footprint.transform);
 
@@ -145,8 +145,8 @@ async fn render<'a: 'n>(
 				rendering.leaf_tag("rect", |attributes| {
 					attributes.push("x", "0");
 					attributes.push("y", "0");
-					attributes.push("width", footprint.resolution.x.to_string());
-					attributes.push("height", footprint.resolution.y.to_string());
+					attributes.push("width", logical_resolution.x.to_string());
+					attributes.push("height", logical_resolution.y.to_string());
 					let matrix = format_transform_matrix(footprint.transform.inverse());
 					if !matrix.is_empty() {
 						attributes.push("transform", matrix);
@@ -158,7 +158,7 @@ async fn render<'a: 'n>(
 			rendering.image_data = svg_data.1.clone();
 			rendering.svg_defs = svg_data.2.clone();
 
-			rendering.wrap_with_transform(footprint.transform, Some(footprint.resolution.as_dvec2()));
+			rendering.wrap_with_transform(footprint.transform, Some(logical_resolution.as_dvec2()));
 			RenderOutputType::Svg {
 				svg: rendering.svg.to_svg_string(),
 				image_data: rendering.image_data,
@@ -170,21 +170,16 @@ async fn render<'a: 'n>(
 			};
 			let (child, context) = Arc::as_ref(vello_data);
 
-			// Always apply scale when rendering to texture
-			let scale = render_params.scale;
-
 			let scale_transform = glam::DAffine2::from_scale(glam::DVec2::splat(scale));
 			let footprint_transform = scale_transform * footprint.transform;
 			let footprint_transform_vello = vello::kurbo::Affine::new(footprint_transform.to_cols_array());
 
 			let mut scene = vello::Scene::new();
 			scene.append(child, Some(footprint_transform_vello));
 
-			let resolution = (footprint.resolution.as_dvec2() * scale).as_uvec2();
-
 			// We now replace all transforms which are supposed to be infinite with a transform which covers the entire viewport
 			// See <https://xi.zulipchat.com/#narrow/channel/197075-vello/topic/Full.20screen.20color.2Fgradients/near/538435044> for more detail
-			let scaled_infinite_transform = vello::kurbo::Affine::scale_non_uniform(resolution.x as f64, resolution.y as f64);
+			let scaled_infinite_transform = vello::kurbo::Affine::scale_non_uniform(physical_resolution.x as f64, physical_resolution.y as f64);
 			let encoding = scene.encoding_mut();
 			for transform in encoding.transforms.iter_mut() {
 				if transform.matrix[0] == f32::INFINITY {
@@ -198,7 +193,10 @@ async fn render<'a: 'n>(
 			}
 
 			// Always render to texture (unified path for both WASM and desktop)
-			let texture = exec.render_vello_scene_to_texture(&scene, resolution, context, background).await.expect("Failed to render Vello scene");
+			let texture = exec
+				.render_vello_scene_to_texture(&scene, physical_resolution, context, background)
+				.await
+				.expect("Failed to render Vello scene");
 
 			RenderOutputType::Texture(ImageTexture { texture })
 		}