fix: use position-based lookup when joining paths from different layers

Author: Ayush2k02

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

@@ -462,26 +462,28 @@ impl ShapeState {
 			} else {
 				// Different layers: merge first, then create segment
 
-				// Get the indices of the selected points in their respective vectors
-				let start_index = document.network_interface.compute_modified_vector(layer1)
-					.and_then(|v| v.point_domain.resolve_id(start_point));
-				let end_index = document.network_interface.compute_modified_vector(layer2)
-					.and_then(|v| v.point_domain.resolve_id(end_point));
-
-				// Get the number of points in layer1 (this will be the offset for layer2 points after merge)
-				let layer1_point_count = document.network_interface.compute_modified_vector(layer1)
-					.map(|v| v.point_domain.ids().len());
-
-				if let (Some(start_idx), Some(end_idx), Some(point_offset)) = (start_index, end_index, layer1_point_count) {
-					// Merge the layers
+				// Get the local positions of the selected points
+				let start_local_pos = document.network_interface.compute_modified_vector(layer1)
+					.and_then(|v| v.point_domain.position_from_id(start_point));
+				let end_local_pos = document.network_interface.compute_modified_vector(layer2)
+					.and_then(|v| v.point_domain.position_from_id(end_point));
+
+				// Transform to document/world space
+				let start_transform = document.metadata().transform_to_document(layer1);
+				let end_transform = document.metadata().transform_to_document(layer2);
+
+				if let (Some(start_local), Some(end_local)) = (start_local_pos, end_local_pos) {
+					let start_pos = start_transform.transform_point2(start_local);
+					let end_pos = end_transform.transform_point2(end_local);
+
 					merge_layers(document, layer1, layer2, responses);
 
-					// After the graph runs and the merge is complete, restore selection and close path
+					// Connect the points
 					responses.add(DeferMessage::AfterGraphRun {
-						messages: vec![ToolMessage::Path(PathToolMessage::RestoreSelectionAndClosePath {
+						messages: vec![ToolMessage::Path(PathToolMessage::ConnectPointsByPosition {
 							layer: layer1,
-							start_index: start_idx,
-							end_index: end_idx + point_offset,
+							start_position: start_pos,
+							end_position: end_pos,
 						}).into()],
 					});
 				}

editor/src/messages/tool/tool_messages/path_tool.rs

@@ -73,10 +73,10 @@ pub enum PathToolMessage {
 	},
 	Escape,
 	ClosePath,
-	RestoreSelectionAndClosePath {
+	ConnectPointsByPosition {
 		layer: LayerNodeIdentifier,
-		start_index: usize,
-		end_index: usize,
+		start_position: DVec2,
+		end_position: DVec2,
 	},
 	DoubleClick {
 		extend_selection: Key,
@@ -2674,32 +2674,43 @@ impl Fsm for PathToolFsmState {
 
 				self
 			}
-			(_, PathToolMessage::RestoreSelectionAndClosePath { layer, start_index, end_index }) => {
+			(_, PathToolMessage::ConnectPointsByPosition { layer, start_position, end_position }) => {
 				// Get the merged vector
 				let Some(vector) = document.network_interface.compute_modified_vector(layer) else {
 					return self;
 				};
 
-				// Get the point IDs at the calculated indices
+				// Find points by their positions (with small tolerance for floating point comparison)
+				const POSITION_TOLERANCE: f64 = 0.01;
+
+				let positions = vector.point_domain.positions();
 				let point_ids = vector.point_domain.ids();
 
-				if start_index >= point_ids.len() || end_index >= point_ids.len() {
-					return self;
-				}
+				let mut start_point_id = None;
+				let mut end_point_id = None;
 
-				let start_point_id = point_ids[start_index];
-				let end_point_id = point_ids[end_index];
+				for (i, &pos) in positions.iter().enumerate() {
+					if start_point_id.is_none() && (pos - start_position).length() < POSITION_TOLERANCE {
+						start_point_id = Some(point_ids[i]);
+					}
+					if end_point_id.is_none() && (pos - end_position).length() < POSITION_TOLERANCE {
+						end_point_id = Some(point_ids[i]);
+					}
+					if start_point_id.is_some() && end_point_id.is_some() {
+						break;
+					}
+				}
 
-				// Clear existing selection and select the merged layer
-				shape_editor.deselect_all_points();
-				shape_editor.set_selected_layers(vec![layer]);
+				if let (Some(start_id), Some(end_id)) = (start_point_id, end_point_id) {
+					// Clear existing selection 
+					shape_editor.deselect_all_points();
+					shape_editor.set_selected_layers(vec![layer]);
 
-				// Select the two points
-				shape_editor.select_point_by_layer_and_id(ManipulatorPointId::Anchor(start_point_id), layer);
-				shape_editor.select_point_by_layer_and_id(ManipulatorPointId::Anchor(end_point_id), layer);
+					shape_editor.select_point_by_layer_and_id(ManipulatorPointId::Anchor(start_id), layer);
+					shape_editor.select_point_by_layer_and_id(ManipulatorPointId::Anchor(end_id), layer);
 
-				// Now call ClosePath which will see the selection and create the segment
-				responses.add(PathToolMessage::ClosePath);
+					responses.add(PathToolMessage::ClosePath);
+				}
 
 				self
 			}