Fix Path tool's Path node transform calculation by skipping local transform based on first instance source ID (#2843)

* First instance source id

* Set source node id and migrations

Author: 0HyperCube

editor/src/dispatcher.rs

@@ -140,6 +140,7 @@ impl Dispatcher {
 					let graphene_std::renderer::RenderMetadata {
 						upstream_footprints: footprints,
 						local_transforms,
+						first_instance_source_id,
 						click_targets,
 						clip_targets,
 					} = render_metadata;
@@ -149,6 +150,7 @@ impl Dispatcher {
 						DocumentMessage::UpdateUpstreamTransforms {
 							upstream_footprints: footprints,
 							local_transforms,
+							first_instance_source_id,
 						},
 						DocumentMessage::UpdateClickTargets { click_targets },
 						DocumentMessage::UpdateClipTargets { clip_targets },

editor/src/messages/portfolio/document/document_message.rs

@@ -182,6 +182,7 @@ pub enum DocumentMessage {
 	UpdateUpstreamTransforms {
 		upstream_footprints: HashMap<NodeId, Footprint>,
 		local_transforms: HashMap<NodeId, DAffine2>,
+		first_instance_source_id: HashMap<NodeId, Option<NodeId>>,
 	},
 	UpdateClickTargets {
 		click_targets: HashMap<NodeId, Vec<ClickTarget>>,

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -1305,8 +1305,10 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 			DocumentMessage::UpdateUpstreamTransforms {
 				upstream_footprints,
 				local_transforms,
+				first_instance_source_id,
 			} => {
 				self.network_interface.update_transforms(upstream_footprints, local_transforms);
+				self.network_interface.update_first_instance_source_id(first_instance_source_id);
 			}
 			DocumentMessage::UpdateClickTargets { click_targets } => {
 				// TODO: Allow non layer nodes to have click targets

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

@@ -1472,7 +1472,11 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 								..Default::default()
 							},
 							DocumentNode {
-								inputs: vec![NodeInput::node(NodeId(0), 0), NodeInput::network(concrete!(graphene_std::vector::VectorModification), 1)],
+								inputs: vec![
+									NodeInput::node(NodeId(0), 0),
+									NodeInput::network(concrete!(graphene_std::vector::VectorModification), 1),
+									NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::DocumentNodePath),
+								],
 								manual_composition: Some(generic!(T)),
 								implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_core::vector::vector_data::modification::PathModifyNode")),
 								..Default::default()

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

@@ -119,7 +119,7 @@ pub fn path_overlays(document: &DocumentMessageHandler, draw_handles: DrawHandle
 
 	for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
 		let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { continue };
-		let transform = document.metadata().transform_to_viewport(layer);
+		let transform = document.metadata().transform_to_viewport_if_feeds(layer, &document.network_interface);
 		if display_path {
 			overlay_context.outline_vector(&vector_data, transform);
 		}
@@ -196,7 +196,7 @@ pub fn path_endpoint_overlays(document: &DocumentMessageHandler, shape_editor: &
 			continue;
 		};
 		//let document_to_viewport = document.navigation_handler.calculate_offset_transform(overlay_context.size / 2., &document.document_ptz);
-		let transform = document.metadata().transform_to_viewport(layer);
+		let transform = document.metadata().transform_to_viewport_if_feeds(layer, &document.network_interface);
 		let selected = shape_editor.selected_shape_state.get(&layer);
 		let is_selected = |selected: Option<&SelectedLayerState>, point: ManipulatorPointId| selected.is_some_and(|selected| selected.is_point_selected(point));
 

editor/src/messages/portfolio/document/utility_types/document_metadata.rs

@@ -1,6 +1,8 @@
 use super::network_interface::NodeNetworkInterface;
 use crate::messages::portfolio::document::graph_operation::transform_utils;
 use crate::messages::portfolio::document::graph_operation::utility_types::ModifyInputsContext;
+use crate::messages::portfolio::document::utility_types::network_interface::FlowType;
+use crate::messages::tool::common_functionality::graph_modification_utils;
 use glam::{DAffine2, DVec2};
 use graph_craft::document::NodeId;
 use graphene_std::math::quad::Quad;
@@ -16,10 +18,11 @@ use std::num::NonZeroU64;
 
 // TODO: To avoid storing a stateful snapshot of some other system's state (which is easily to accidentally get out of sync),
 // TODO: it might be better to have a system that can query the state of the node network on demand.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct DocumentMetadata {
 	pub upstream_footprints: HashMap<NodeId, Footprint>,
 	pub local_transforms: HashMap<NodeId, DAffine2>,
+	pub first_instance_source_ids: HashMap<NodeId, Option<NodeId>>,
 	pub structure: HashMap<LayerNodeIdentifier, NodeRelations>,
 	pub click_targets: HashMap<LayerNodeIdentifier, Vec<ClickTarget>>,
 	pub clip_targets: HashSet<NodeId>,
@@ -28,20 +31,6 @@ pub struct DocumentMetadata {
 	pub document_to_viewport: DAffine2,
 }
 
-impl Default for DocumentMetadata {
-	fn default() -> Self {
-		Self {
-			upstream_footprints: HashMap::new(),
-			local_transforms: HashMap::new(),
-			structure: HashMap::new(),
-			vector_modify: HashMap::new(),
-			click_targets: HashMap::new(),
-			clip_targets: HashSet::new(),
-			document_to_viewport: DAffine2::IDENTITY,
-		}
-	}
-}
-
 // =================================
 // DocumentMetadata: Layer iterators
 // =================================
@@ -91,6 +80,36 @@ impl DocumentMetadata {
 		footprint * local_transform
 	}
 
+	pub fn transform_to_viewport_if_feeds(&self, layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> DAffine2 {
+		// We're not allowed to convert the root parent to a node id
+		if layer == LayerNodeIdentifier::ROOT_PARENT {
+			return self.document_to_viewport;
+		}
+
+		let footprint = self.upstream_footprints.get(&layer.to_node()).map(|footprint| footprint.transform).unwrap_or(self.document_to_viewport);
+
+		let mut use_local = true;
+		let graph_layer = graph_modification_utils::NodeGraphLayer::new(layer, network_interface);
+		if let Some(path_node) = graph_layer.upstream_node_id_from_name("Path") {
+			if let Some(&source) = self.first_instance_source_ids.get(&layer.to_node()) {
+				if !network_interface
+					.upstream_flow_back_from_nodes(vec![path_node], &[], FlowType::HorizontalFlow)
+					.any(|upstream| Some(upstream) == source)
+				{
+					use_local = false;
+					info!("Local transform is invalid — using the identity for the local transform instead")
+				}
+			}
+		}
+		let local_transform = use_local.then(|| self.local_transforms.get(&layer.to_node()).copied()).flatten().unwrap_or_default();
+
+		footprint * local_transform
+	}
+
+	pub fn transform_to_document_if_feeds(&self, layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> DAffine2 {
+		self.document_to_viewport.inverse() * self.transform_to_viewport_if_feeds(layer, network_interface)
+	}
+
 	pub fn transform_to_viewport_with_first_transform_node_if_group(&self, layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> DAffine2 {
 		let footprint = self.upstream_footprints.get(&layer.to_node()).map(|footprint| footprint.transform).unwrap_or(self.document_to_viewport);
 		let local_transform = self.local_transforms.get(&layer.to_node()).copied();

editor/src/messages/portfolio/document/utility_types/network_interface.rs

@@ -60,6 +60,27 @@ impl PartialEq for NodeNetworkInterface {
 	}
 }
 
+impl NodeNetworkInterface {
+	/// Add DocumentNodePath input to the PathModifyNode protonode
+	pub fn migrate_path_modify_node(&mut self) {
+		fix_network(&mut self.network);
+		fn fix_network(network: &mut NodeNetwork) {
+			for node in network.nodes.values_mut() {
+				if let Some(network) = node.implementation.get_network_mut() {
+					fix_network(network);
+				}
+				if let DocumentNodeImplementation::ProtoNode(protonode) = &node.implementation {
+					if protonode.name.contains("PathModifyNode") {
+						if node.inputs.len() < 3 {
+							node.inputs.push(NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::DocumentNodePath));
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
 // Public immutable getters for the network interface
 impl NodeNetworkInterface {
 	// TODO: Make private and use .field_name getter methods
@@ -3513,6 +3534,11 @@ impl NodeNetworkInterface {
 		self.document_metadata.local_transforms = local_transforms;
 	}
 
+	/// Update the cached first instance source id of the layers
+	pub fn update_first_instance_source_id(&mut self, new: HashMap<NodeId, Option<NodeId>>) {
+		self.document_metadata.first_instance_source_ids = new;
+	}
+
 	/// Update the cached click targets of the layers
 	pub fn update_click_targets(&mut self, new_click_targets: HashMap<LayerNodeIdentifier, Vec<ClickTarget>>) {
 		self.document_metadata.click_targets = new_click_targets;

editor/src/messages/portfolio/document_migration.rs

@@ -190,6 +190,8 @@ pub fn document_migration_reset_node_definition(document_serialized_content: &st
 }
 
 pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_node_definitions_on_open: bool) {
+	document.network_interface.migrate_path_modify_node();
+
 	let network = document.network_interface.document_network().clone();
 
 	// Apply string replacements to each node

editor/src/messages/tool/common_functionality/shape_editor.rs

@@ -212,15 +212,15 @@ impl ClosestSegment {
 		self.bezier_point_to_viewport
 	}
 
-	pub fn closest_point(&self, document_metadata: &DocumentMetadata) -> DVec2 {
-		let transform = document_metadata.transform_to_viewport(self.layer);
+	pub fn closest_point(&self, document_metadata: &DocumentMetadata, network_interface: &NodeNetworkInterface) -> DVec2 {
+		let transform = document_metadata.transform_to_viewport_if_feeds(self.layer, network_interface);
 		let bezier_point = self.bezier.evaluate(TValue::Parametric(self.t));
 		transform.transform_point2(bezier_point)
 	}
 
 	/// Updates this [`ClosestSegment`] with the viewport-space location of the closest point on the segment to the given mouse position.
-	pub fn update_closest_point(&mut self, document_metadata: &DocumentMetadata, mouse_position: DVec2) {
-		let transform = document_metadata.transform_to_viewport(self.layer);
+	pub fn update_closest_point(&mut self, document_metadata: &DocumentMetadata, network_interface: &NodeNetworkInterface, mouse_position: DVec2) {
+		let transform = document_metadata.transform_to_viewport_if_feeds(self.layer, network_interface);
 		let layer_mouse_pos = transform.inverse().transform_point2(mouse_position);
 
 		let t = self.bezier.project(layer_mouse_pos).clamp(0., 1.);
@@ -239,9 +239,9 @@ impl ClosestSegment {
 		tolerance.powi(2) < self.distance_squared(mouse_position)
 	}
 
-	pub fn handle_positions(&self, document_metadata: &DocumentMetadata) -> (Option<DVec2>, Option<DVec2>) {
+	pub fn handle_positions(&self, document_metadata: &DocumentMetadata, network_interface: &NodeNetworkInterface) -> (Option<DVec2>, Option<DVec2>) {
 		// Transform to viewport space
-		let transform = document_metadata.transform_to_viewport(self.layer);
+		let transform = document_metadata.transform_to_viewport_if_feeds(self.layer, network_interface);
 
 		// Split the Bezier at the parameter `t`
 		let [first, second] = self.bezier.split(TValue::Parametric(self.t));
@@ -307,7 +307,7 @@ impl ClosestSegment {
 	}
 
 	pub fn calculate_perp(&self, document: &DocumentMessageHandler) -> DVec2 {
-		let tangent = if let (Some(handle1), Some(handle2)) = self.handle_positions(document.metadata()) {
+		let tangent = if let (Some(handle1), Some(handle2)) = self.handle_positions(document.metadata(), &document.network_interface) {
 			(handle1 - handle2).try_normalize()
 		} else {
 			let [first_point, last_point] = self.points();
@@ -339,7 +339,7 @@ impl ClosestSegment {
 		break_colinear_molding: bool,
 		temporary_adjacent_handles_while_molding: Option<[Option<HandleId>; 2]>,
 	) -> Option<[Option<HandleId>; 2]> {
-		let transform = document.metadata().transform_to_viewport(self.layer);
+		let transform = document.metadata().transform_to_viewport_if_feeds(self.layer, &document.network_interface);
 
 		let start = self.bezier.start;
 		let end = self.bezier.end;
@@ -507,7 +507,7 @@ impl ShapeState {
 				continue;
 			};
 
-			let to_document = document.metadata().transform_to_document(*layer);
+			let to_document = document.metadata().transform_to_document_if_feeds(*layer, &document.network_interface);
 
 			for &selected in &state.selected_points {
 				let source = match selected {
@@ -564,7 +564,11 @@ impl ShapeState {
 			let already_selected = selected_shape_state.is_point_selected(manipulator_point_id);
 
 			// Offset to snap the selected point to the cursor
-			let offset = mouse_position - network_interface.document_metadata().transform_to_viewport(layer).transform_point2(point_position);
+			let offset = mouse_position
+				- network_interface
+					.document_metadata()
+					.transform_to_viewport_if_feeds(layer, network_interface)
+					.transform_point2(point_position);
 
 			// This is selecting the manipulator only for now, next to generalize to points
 
@@ -621,7 +625,11 @@ impl ShapeState {
 			let already_selected = selected_shape_state.is_point_selected(manipulator_point_id);
 
 			// Offset to snap the selected point to the cursor
-			let offset = mouse_position - network_interface.document_metadata().transform_to_viewport(layer).transform_point2(point_position);
+			let offset = mouse_position
+				- network_interface
+					.document_metadata()
+					.transform_to_viewport_if_feeds(layer, network_interface)
+					.transform_point2(point_position);
 
 			// Gather current selection information
 			let points = self
@@ -653,7 +661,7 @@ impl ShapeState {
 		let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else {
 			return;
 		};
-		let to_viewport = document.metadata().transform_to_viewport(layer);
+		let to_viewport = document.metadata().transform_to_viewport_if_feeds(layer, &document.network_interface);
 		let layer_mouse = to_viewport.inverse().transform_point2(mouse);
 		let state = self.selected_shape_state.entry(layer).or_default();
 
@@ -875,7 +883,7 @@ impl ShapeState {
 		}
 
 		let vector_data = network_interface.compute_modified_vector(layer)?;
-		let transform = network_interface.document_metadata().transform_to_document(layer).inverse();
+		let transform = network_interface.document_metadata().transform_to_document_if_feeds(layer, network_interface).inverse();
 		let position = transform.transform_point2(new_position);
 		let current_position = point.get_position(&vector_data)?;
 		let delta = position - current_position;
@@ -1026,7 +1034,7 @@ impl ShapeState {
 			let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else {
 				continue;
 			};
-			let transform = document.metadata().transform_to_document(layer);
+			let transform = document.metadata().transform_to_document_if_feeds(layer, &document.network_interface);
 
 			for &point in layer_state.selected_points.iter() {
 				let Some(handles) = point.get_handle_pair(&vector_data) else { continue };
@@ -1116,8 +1124,8 @@ impl ShapeState {
 
 			let opposing_handles = handle_lengths.as_ref().and_then(|handle_lengths| handle_lengths.get(&layer));
 
-			let transform_to_viewport_space = document.metadata().transform_to_viewport(layer);
-			let transform_to_document_space = document.metadata().transform_to_document(layer);
+			let transform_to_viewport_space = document.metadata().transform_to_viewport_if_feeds(layer, &document.network_interface);
+			let transform_to_document_space = document.metadata().transform_to_document_if_feeds(layer, &document.network_interface);
 			let delta_transform = if in_viewport_space {
 				transform_to_viewport_space
 			} else {
@@ -1210,7 +1218,7 @@ impl ShapeState {
 			.iter()
 			.filter_map(|(&layer, state)| {
 				let vector_data = document.network_interface.compute_modified_vector(layer)?;
-				let transform = document.metadata().transform_to_document(layer);
+				let transform = document.metadata().transform_to_document_if_feeds(layer, &document.network_interface);
 				let opposing_handle_lengths = vector_data
 					.colinear_manipulators
 					.iter()
@@ -1575,7 +1583,7 @@ impl ShapeState {
 		let mut manipulator_point = None;
 
 		let vector_data = network_interface.compute_modified_vector(layer)?;
-		let viewspace = network_interface.document_metadata().transform_to_viewport(layer);
+		let viewspace = network_interface.document_metadata().transform_to_viewport_if_feeds(layer, network_interface);
 
 		// Handles
 		for (segment_id, bezier, _, _) in vector_data.segment_bezier_iter() {
@@ -1611,7 +1619,7 @@ impl ShapeState {
 
 	/// Find the `t` value along the path segment we have clicked upon, together with that segment ID.
 	fn closest_segment(&self, network_interface: &NodeNetworkInterface, layer: LayerNodeIdentifier, position: glam::DVec2, tolerance: f64) -> Option<ClosestSegment> {
-		let transform = network_interface.document_metadata().transform_to_viewport(layer);
+		let transform = network_interface.document_metadata().transform_to_viewport_if_feeds(layer, network_interface);
 		let layer_pos = transform.inverse().transform_point2(position);
 
 		let tolerance = tolerance + 0.5;
@@ -1785,7 +1793,7 @@ impl ShapeState {
 	pub fn flip_smooth_sharp(&self, network_interface: &NodeNetworkInterface, target: glam::DVec2, tolerance: f64, responses: &mut VecDeque<Message>) -> bool {
 		let mut process_layer = |layer| {
 			let vector_data = network_interface.compute_modified_vector(layer)?;
-			let transform_to_screenspace = network_interface.document_metadata().transform_to_viewport(layer);
+			let transform_to_screenspace = network_interface.document_metadata().transform_to_viewport_if_feeds(layer, network_interface);
 
 			let mut result = None;
 			let mut closest_distance_squared = tolerance * tolerance;
@@ -1889,7 +1897,7 @@ impl ShapeState {
 
 			let vector_data = network_interface.compute_modified_vector(layer);
 			let Some(vector_data) = vector_data else { continue };
-			let transform = network_interface.document_metadata().transform_to_viewport(layer);
+			let transform = network_interface.document_metadata().transform_to_viewport_if_feeds(layer, network_interface);
 
 			assert_eq!(vector_data.segment_domain.ids().len(), vector_data.start_point().count());
 			assert_eq!(vector_data.segment_domain.ids().len(), vector_data.end_point().count());