Promote vector meshes from experimental by removing it from preferences

Author: Keavon

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

@@ -210,7 +210,7 @@ pub fn path_endpoint_overlays(document: &DocumentMessageHandler, shape_editor: &
 		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));
 
-		for point in vector.anchor_endpoints() {
+		for point in vector.extendable_points() {
 			let Some(position) = vector.point_domain.position_from_id(point) else { continue };
 			let position = transform.transform_point2(position);
 			overlay_context.manipulator_anchor(position, is_selected(selected, ManipulatorPointId::Anchor(point)), None);

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

@@ -421,68 +421,6 @@ impl ShapeState {
 		(point.as_handle().is_some() && self.ignore_handles) || (point.as_anchor().is_some() && self.ignore_anchors)
 	}
 
-	/// Applies a dummy vector modification to the layer. In the case where a group containing some vector data is selected, this triggers the creation of a «Flatten Path» node.
-	fn add_dummy_modification_to_trigger_graph_reorganization(layer: LayerNodeIdentifier, start_point: PointId, _end_point: PointId, responses: &mut VecDeque<Message>) {
-		// Apply a zero-delta to one of the points to trigger reorganization
-		let dummy_modification = VectorModificationType::ApplyPointDelta {
-			point: start_point,
-			delta: DVec2::ZERO,
-		};
-		responses.add(GraphOperationMessage::Vector {
-			layer,
-			modification_type: dummy_modification,
-		});
-		responses.add(NodeGraphMessage::RunDocumentGraph);
-	}
-
-	fn defer_connect_points_by_position(
-		document: &DocumentMessageHandler,
-		layer1: LayerNodeIdentifier,
-		start_point: PointId,
-		layer2: LayerNodeIdentifier,
-		end_point: PointId,
-		target_layer: LayerNodeIdentifier,
-		responses: &mut VecDeque<Message>,
-	) {
-		// 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);
-
-		let (Some(start_local), Some(end_local)) = (start_local_pos, end_local_pos) else {
-			warn!("Unable to resolve point ids for joining");
-			return;
-		};
-		// Transform positions to document/world space
-		// These positions are stable (won't change during reorganization)
-		let start_pos = start_transform.transform_point2(start_local);
-		let end_pos = end_transform.transform_point2(end_local);
-
-		// Defer position-based connection to run after reorganization completes
-		// By then, PointIds will be stable with their new remapped values
-		responses.add(DeferMessage::AfterGraphRun {
-			messages: vec![
-				ToolMessage::Path(PathToolMessage::ConnectPointsByPosition {
-					layer: target_layer,
-					start_position: start_pos,
-					end_position: end_pos,
-				})
-				.into(),
-			],
-		});
-	}
-
-	fn handle_grouped_transform_close_path(document: &DocumentMessageHandler, layer: LayerNodeIdentifier, start_point: PointId, end_point: PointId, responses: &mut VecDeque<Message>) {
-		// This zero-delta modification triggers point domain reorganization
-		Self::add_dummy_modification_to_trigger_graph_reorganization(layer, start_point, end_point, responses);
-
-		// Use the helper to defer the connection until after reorganization
-		Self::defer_connect_points_by_position(document, layer, start_point, layer, end_point, layer, responses);
-	}
-
 	pub fn close_selected_path(&self, document: &DocumentMessageHandler, responses: &mut VecDeque<Message>) {
 		// First collect all selected anchor points across all layers
 		let all_selected_points: Vec<(LayerNodeIdentifier, PointId)> = self

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

@@ -44,7 +44,7 @@ where
 	for layer in layers {
 		let viewspace = document.metadata().transform_to_viewport(layer);
 		let Some(vector) = document.network_interface.compute_modified_vector(layer) else { continue };
-		for id in vector.anchor_points() {
+		for id in vector.extendable_points() {
 			if exclude(id) {
 				continue;
 			}

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

@@ -828,7 +828,7 @@ impl PathToolData {
 						.filter(|handle| handle.length(&vector) < 1e-6)
 						.map(|handle| handle.to_manipulator_point())
 						.collect::<Vec<_>>();
-					let endpoint = vector.anchor_endpoints().any(|anchor| point == anchor);
+					let endpoint = vector.extendable_points_no_vector_meshes().any(|anchor| point == anchor);
 
 					if drag_zero_handle && (handles.len() == 1 && !endpoint) {
 						shape_editor.deselect_all_points();

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

@@ -652,7 +652,7 @@ impl PenToolData {
 	}
 
 	fn close_path_on_point(&mut self, snap_data: SnapData, vector: &Vector, document: &DocumentMessageHandler, id: PointId, transform: &DAffine2) -> bool {
-		for id in vector.anchor_points().filter(|&point| point != id) {
+		for id in vector.extendable_points().filter(|&point| point != id) {
 			let Some(pos) = vector.point_domain.position_from_id(id) else { continue };
 			let transformed_distance_between_squared = transform.transform_point2(pos).distance_squared(transform.transform_point2(self.next_point));
 			let snap_point_tolerance_squared = crate::consts::SNAP_POINT_TOLERANCE.powi(2);
@@ -701,7 +701,7 @@ impl PenToolData {
 		let vector = document.network_interface.compute_modified_vector(layer)?;
 		let start = self.latest_point()?.id;
 		let transform = document.metadata().document_to_viewport * transform;
-		for id in vector.anchor_points().filter(|&point| point != start) {
+		for id in vector.extendable_points().filter(|&point| point != start) {
 			let Some(pos) = vector.point_domain.position_from_id(id) else { continue };
 			let transformed_distance_between_squared = transform.transform_point2(pos).distance_squared(transform.transform_point2(next_point));
 			let snap_point_tolerance_squared = crate::consts::SNAP_POINT_TOLERANCE.powi(2);
@@ -1126,7 +1126,7 @@ impl PenToolData {
 		let layer = selected_layers.next().filter(|_| selected_layers.next().is_none()).or(self.current_layer)?;
 		let vector = document.network_interface.compute_modified_vector(layer)?;
 		let transform = document.metadata().document_to_viewport * transform;
-		for point in vector.anchor_points() {
+		for point in vector.extendable_points() {
 			let Some(pos) = vector.point_domain.position_from_id(point) else { continue };
 			let transformed_distance_between_squared = transform.transform_point2(pos).distance_squared(transform.transform_point2(self.next_point));
 			let snap_point_tolerance_squared = crate::consts::SNAP_POINT_TOLERANCE.powi(2);
@@ -1755,7 +1755,7 @@ impl Fsm for PenToolFsmState {
 					if let Some(layer) = layer
 						&& let Some(mut vector) = document.network_interface.compute_modified_vector(layer)
 					{
-						let closest_point = vector.anchor_points().filter(|&id| id != start).find(|&id| {
+						let closest_point = vector.extendable_points().filter(|&id| id != start).find(|&id| {
 							vector.point_domain.position_from_id(id).is_some_and(|pos| {
 								let dist_sq = transform.transform_point2(pos).distance_squared(transform.transform_point2(next_point));
 								dist_sq < crate::consts::SNAP_POINT_TOLERANCE.powi(2)

node-graph/libraries/vector-types/src/vector/vector_types.rs

@@ -364,14 +364,22 @@ impl<Upstream> Vector<Upstream> {
 		number != 0
 	}
 
-	/// Iterator over all anchor points.
-	pub fn anchor_points(&self) -> impl Iterator<Item = PointId> + '_ {
+	/// Points that can be extended from.
+	///
+	/// This may be points with more than one connection because of vector meshes.
+	pub fn extendable_points(&self) -> impl Iterator<Item = PointId> + '_ {
 		self.point_domain.ids().iter().copied()
 	}
 
-	/// Anchor points at the ends of open subpaths. These are points with exactly one connection by a segment to another anchor.
-	pub fn anchor_endpoints(&self) -> impl Iterator<Item = PointId> + '_ {
-		self.anchor_points().enumerate().filter(|&(index, _)| self.segment_domain.connected_count(index) == 1).map(|(_, id)| id)
+	// TODO: Avoid needing this special function that's used in only one place. See: <https://github.com/GraphiteEditor/Graphite/commit/6e7f218068a55cc22659ee2cf4f0f2cf26d37774#r173283173>
+	/// Points that can be extended from.
+	///
+	/// This includes only points with exactly one connection because vector meshes are ignored.
+	pub fn extendable_points_no_vector_meshes(&self) -> impl Iterator<Item = PointId> + '_ {
+		self.extendable_points()
+			.enumerate()
+			.filter(|&(index, _)| self.segment_domain.connected_count(index) == 1)
+			.map(|(_, id)| id)
 	}
 
 	/// Computes if all the connected handles are colinear for an anchor, or if that handle is colinear for a handle.