Improve snapping with better snap target names, tooltips, cleaner overlay labels, code cleanup

editor/src/messages/tool/common_functionality/snapping/alignment_snapper.rs

@@ -19,7 +19,7 @@ impl AlignmentSnapper {
 		let document = snap_data.document;
 
 		self.bounding_box_points.clear();
-		if !document.snapping_state.bounds.align {
+		if !document.snapping_state.bounding_box.align_with_corner_point {
 			return;
 		}
 
@@ -28,7 +28,7 @@ impl AlignmentSnapper {
 				continue;
 			}
 
-			if document.snapping_state.target_enabled(SnapTarget::Artboard(ArtboardSnapTarget::Corner)) {
+			if document.snapping_state.target_enabled(SnapTarget::Artboard(ArtboardSnapTarget::CornerPoint)) {
 				let Some(bounds) = document.metadata().bounding_box_with_transform(layer, document.metadata().transform_to_document(layer)) else {
 					continue;
 				};
@@ -52,7 +52,7 @@ impl AlignmentSnapper {
 
 	pub fn snap_bbox_points(&mut self, snap_data: &mut SnapData, point: &SnapCandidatePoint, snap_results: &mut SnapResults, constraint: SnapConstraint, config: SnapTypeConfiguration) {
 		self.collect_bounding_box_points(snap_data, !config.use_existing_candidates);
-		let unselected_geometry = if snap_data.document.snapping_state.target_enabled(SnapTarget::Alignment(AlignmentSnapTarget::Handle)) {
+		let unselected_geometry = if snap_data.document.snapping_state.target_enabled(SnapTarget::Alignment(AlignmentSnapTarget::AlignWithAnchorPoint)) {
 			snap_data.node_snap_cache.map(|cache| cache.unselected.as_slice()).unwrap_or(&[])
 		} else {
 			&[]
@@ -77,9 +77,9 @@ impl AlignmentSnapper {
 				[DVec2::new(point.document_point.x, target_position.y), DVec2::new(target_position.x, point.document_point.y)].map(Some)
 			};
 
-			let target_geometry = matches!(target_point.target, SnapTarget::Geometry(_));
-			let updated_target = if target_geometry {
-				SnapTarget::Alignment(AlignmentSnapTarget::Handle)
+			let target_path = matches!(target_point.target, SnapTarget::Path(_));
+			let updated_target = if target_path {
+				SnapTarget::Alignment(AlignmentSnapTarget::AlignWithAnchorPoint)
 			} else {
 				target_point.target
 			};
@@ -90,7 +90,7 @@ impl AlignmentSnapper {
 				if distance_to_snapped < tolerance && snap_x.as_ref().map_or(true, |point| distance_to_align_target < point.distance_to_align_target) {
 					snap_x = Some(SnappedPoint {
 						snapped_point_document: point_on_x,
-						source: point.source, //ToDo map source
+						source: point.source, // TODO(0Hypercube): map source
 						target: updated_target,
 						target_bounds: target_point.quad,
 						distance: distance_to_snapped,
@@ -109,7 +109,7 @@ impl AlignmentSnapper {
 				if distance_to_snapped < tolerance && snap_y.as_ref().map_or(true, |point| distance_to_align_target < point.distance_to_align_target) {
 					snap_y = Some(SnappedPoint {
 						snapped_point_document: point_on_y,
-						source: point.source, //ToDo map source
+						source: point.source, // TODO(0Hypercube): map source
 						target: updated_target,
 						target_bounds: target_point.quad,
 						distance: distance_to_snapped,
@@ -137,7 +137,7 @@ impl AlignmentSnapper {
 				snap_results.points.push(SnappedPoint {
 					snapped_point_document: intersection,
 					source: point.source, // TODO: map source
-					target: SnapTarget::Alignment(AlignmentSnapTarget::Intersection),
+					target: SnapTarget::Alignment(AlignmentSnapTarget::IntersectionPoint),
 					target_bounds: snap_x.target_bounds,
 					distance,
 					tolerance,
@@ -154,22 +154,23 @@ impl AlignmentSnapper {
 			_ => {}
 		}
 	}
+
 	pub fn free_snap(&mut self, snap_data: &mut SnapData, point: &SnapCandidatePoint, snap_results: &mut SnapResults, config: SnapTypeConfiguration) {
 		let is_bbox = matches!(point.source, SnapSource::BoundingBox(_));
-		let is_geometry = matches!(point.source, SnapSource::Geometry(_));
-		let geometry_selected = snap_data.has_manipulators();
+		let is_path = matches!(point.source, SnapSource::Path(_));
+		let path_selected = snap_data.has_manipulators();
 
-		if is_bbox || (is_geometry && geometry_selected) || (is_geometry && point.alignment) {
+		if is_bbox || (is_path && path_selected) || (is_path && point.alignment) {
 			self.snap_bbox_points(snap_data, point, snap_results, SnapConstraint::None, config);
 		}
 	}
 
 	pub fn constrained_snap(&mut self, snap_data: &mut SnapData, point: &SnapCandidatePoint, snap_results: &mut SnapResults, constraint: SnapConstraint, config: SnapTypeConfiguration) {
 		let is_bbox = matches!(point.source, SnapSource::BoundingBox(_));
-		let is_geometry = matches!(point.source, SnapSource::Geometry(_));
-		let geometry_selected = snap_data.has_manipulators();
+		let is_path = matches!(point.source, SnapSource::Path(_));
+		let path_selected = snap_data.has_manipulators();
 
-		if is_bbox || (is_geometry && geometry_selected) || (is_geometry && point.alignment) {
+		if is_bbox || (is_path && path_selected) || (is_path && point.alignment) {
 			self.snap_bbox_points(snap_data, point, snap_results, constraint, config);
 		}
 	}

editor/src/messages/tool/common_functionality/snapping/distribution_snapper.rs

@@ -210,7 +210,7 @@ impl DistributionSnapper {
 				let mut final_point = x;
 				final_point.snapped_point_document += y.snapped_point_document - point.document_point;
 				final_point.source_bounds = Some(final_bounds.into());
-				final_point.target = SnapTarget::Distribution(DistributionSnapTarget::Xy);
+				final_point.target = SnapTarget::DistributeEvenly(DistributionSnapTarget::XY);
 				final_point.distribution_boxes_y = y.distribution_boxes_y;
 				final_point.distribution_equal_distance_y = y.distribution_equal_distance_y;
 				final_point.distance = (final_point.distance * final_point.distance + y.distance * y.distance).sqrt();
@@ -325,7 +325,7 @@ impl DistributionSnapper {
 
 	pub fn free_snap(&mut self, snap_data: &mut SnapData, point: &SnapCandidatePoint, snap_results: &mut SnapResults, config: SnapTypeConfiguration) {
 		let Some(bounds) = config.bbox else { return };
-		if point.source != SnapSource::BoundingBox(BoundingBoxSnapSource::Center) || !snap_data.document.snapping_state.bounds.distribute {
+		if point.source != SnapSource::BoundingBox(BoundingBoxSnapSource::CenterPoint) || !snap_data.document.snapping_state.bounding_box.distribute_evenly {
 			return;
 		}
 
@@ -335,7 +335,7 @@ impl DistributionSnapper {
 
 	pub fn constrained_snap(&mut self, snap_data: &mut SnapData, point: &SnapCandidatePoint, snap_results: &mut SnapResults, constraint: SnapConstraint, config: SnapTypeConfiguration) {
 		let Some(bounds) = config.bbox else { return };
-		if point.source != SnapSource::BoundingBox(BoundingBoxSnapSource::Center) || !snap_data.document.snapping_state.bounds.distribute {
+		if point.source != SnapSource::BoundingBox(BoundingBoxSnapSource::CenterPoint) || !snap_data.document.snapping_state.bounding_box.distribute_evenly {
 			return;
 		}
 

editor/src/messages/tool/common_functionality/snapping/layer_snapper.rs

@@ -15,7 +15,6 @@ pub struct LayerSnapper {
 	points_to_snap: Vec<SnapCandidatePoint>,
 	paths_to_snap: Vec<SnapCandidatePath>,
 }
-
 impl LayerSnapper {
 	pub fn add_layer_bounds(&mut self, document: &DocumentMessageHandler, layer: LayerNodeIdentifier, target: SnapTarget) {
 		if !document.snapping_state.target_enabled(target) {
@@ -49,6 +48,7 @@ impl LayerSnapper {
 			});
 		}
 	}
+
 	pub fn collect_paths(&mut self, snap_data: &mut SnapData, first_point: bool) {
 		if !first_point {
 			return;
@@ -60,7 +60,7 @@ impl LayerSnapper {
 			if !document.network_interface.is_artboard(&layer.to_node(), &[]) || snap_data.ignore.contains(&layer) {
 				continue;
 			}
-			self.add_layer_bounds(document, layer, SnapTarget::Artboard(ArtboardSnapTarget::Edge));
+			self.add_layer_bounds(document, layer, SnapTarget::Artboard(ArtboardSnapTarget::AlongEdge));
 		}
 		for &layer in snap_data.get_candidates() {
 			let transform = document.metadata().transform_to_document(layer);
@@ -68,8 +68,7 @@ impl LayerSnapper {
 				continue;
 			}
 
-			if document.snapping_state.target_enabled(SnapTarget::Geometry(GeometrySnapTarget::Intersection)) || document.snapping_state.target_enabled(SnapTarget::Geometry(GeometrySnapTarget::Path))
-			{
+			if document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::IntersectionPoint)) || document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::AlongPath)) {
 				for subpath in document.metadata().layer_outline(layer) {
 					for (start_index, curve) in subpath.iter().enumerate() {
 						let document_curve = curve.apply_transformation(|p| transform.transform_point2(p));
@@ -81,23 +80,24 @@ impl LayerSnapper {
 							document_curve,
 							layer,
 							start,
-							target: SnapTarget::Geometry(GeometrySnapTarget::Path),
+							target: SnapTarget::Path(PathSnapTarget::AlongPath),
 							bounds: None,
 						});
 					}
 				}
 			}
 			if !snap_data.ignore_bounds(layer) {
-				self.add_layer_bounds(document, layer, SnapTarget::BoundingBox(BoundingBoxSnapTarget::Edge));
+				self.add_layer_bounds(document, layer, SnapTarget::BoundingBox(BoundingBoxSnapTarget::AlongEdge));
 			}
 		}
 	}
+
 	pub fn free_snap_paths(&mut self, snap_data: &mut SnapData, point: &SnapCandidatePoint, snap_results: &mut SnapResults, config: SnapTypeConfiguration) {
 		self.collect_paths(snap_data, !config.use_existing_candidates);
 
 		let document = snap_data.document;
-		let normals = document.snapping_state.target_enabled(SnapTarget::Geometry(GeometrySnapTarget::Normal));
-		let tangents = document.snapping_state.target_enabled(SnapTarget::Geometry(GeometrySnapTarget::Tangent));
+		let normals = document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::NormalToPath));
+		let tangents = document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::TangentToPath));
 		let tolerance = snap_tolerance(document);
 
 		for path in &self.paths_to_snap {
@@ -187,7 +187,7 @@ impl LayerSnapper {
 				return;
 			}
 
-			if document.snapping_state.target_enabled(SnapTarget::Artboard(ArtboardSnapTarget::Corner)) {
+			if document.snapping_state.target_enabled(SnapTarget::Artboard(ArtboardSnapTarget::CornerPoint)) {
 				let Some(bounds) = document
 					.network_interface
 					.document_metadata()
@@ -217,6 +217,7 @@ impl LayerSnapper {
 			get_bbox_points(quad, &mut self.points_to_snap, values, document);
 		}
 	}
+
 	pub fn snap_anchors(&mut self, snap_data: &mut SnapData, point: &SnapCandidatePoint, snap_results: &mut SnapResults, c: SnapConstraint, constrained_point: DVec2) {
 		let mut best = None;
 		for candidate in &self.points_to_snap {
@@ -251,6 +252,7 @@ impl LayerSnapper {
 			snap_results.points.push(result);
 		}
 	}
+
 	pub fn free_snap(&mut self, snap_data: &mut SnapData, point: &SnapCandidatePoint, snap_results: &mut SnapResults, config: SnapTypeConfiguration) {
 		self.collect_anchors(snap_data, !config.use_existing_candidates);
 		self.snap_anchors(snap_data, point, snap_results, SnapConstraint::None, point.document_point);
@@ -275,7 +277,7 @@ fn normals_and_tangents(path: &SnapCandidatePath, normals: bool, tangents: bool,
 				}
 				snap_results.points.push(SnappedPoint {
 					snapped_point_document: normal_point,
-					target: SnapTarget::Geometry(GeometrySnapTarget::Normal),
+					target: SnapTarget::Path(PathSnapTarget::NormalToPath),
 					distance,
 					tolerance,
 					curves: [Some(path.document_curve), None],
@@ -296,7 +298,7 @@ fn normals_and_tangents(path: &SnapCandidatePath, normals: bool, tangents: bool,
 				}
 				snap_results.points.push(SnappedPoint {
 					snapped_point_document: tangent_point,
-					target: SnapTarget::Geometry(GeometrySnapTarget::Tangent),
+					target: SnapTarget::Path(PathSnapTarget::TangentToPath),
 					distance,
 					tolerance,
 					curves: [Some(path.document_curve), None],
@@ -317,6 +319,7 @@ struct SnapCandidatePath {
 	target: SnapTarget,
 	bounds: Option<Quad>,
 }
+
 #[derive(Clone, Debug, Default)]
 pub struct SnapCandidatePoint {
 	pub document_point: DVec2,
@@ -330,6 +333,7 @@ impl SnapCandidatePoint {
 	pub fn new(document_point: DVec2, source: SnapSource, target: SnapTarget) -> Self {
 		Self::new_quad(document_point, source, target, None, true)
 	}
+
 	pub fn new_quad(document_point: DVec2, source: SnapSource, target: SnapTarget, quad: Option<Quad>, alignment: bool) -> Self {
 		Self {
 			document_point,
@@ -340,18 +344,22 @@ impl SnapCandidatePoint {
 			..Default::default()
 		}
 	}
+
 	pub fn new_source(document_point: DVec2, source: SnapSource) -> Self {
 		Self::new(document_point, source, SnapTarget::None)
 	}
+
 	pub fn handle(document_point: DVec2) -> Self {
-		Self::new_source(document_point, SnapSource::Geometry(GeometrySnapSource::AnchorWithFreeHandles))
+		Self::new_source(document_point, SnapSource::Path(PathSnapSource::AnchorPointWithFreeHandles))
 	}
+
 	pub fn handle_neighbors(document_point: DVec2, neighbors: impl Into<Vec<DVec2>>) -> Self {
-		let mut point = Self::new_source(document_point, SnapSource::Geometry(GeometrySnapSource::AnchorWithFreeHandles));
+		let mut point = Self::new_source(document_point, SnapSource::Path(PathSnapSource::AnchorPointWithFreeHandles));
 		point.neighbors = neighbors.into();
 		point
 	}
 }
+
 #[derive(Default)]
 pub struct BBoxSnapValues {
 	corner_source: SnapSource,
@@ -363,41 +371,42 @@ pub struct BBoxSnapValues {
 }
 impl BBoxSnapValues {
 	pub const BOUNDING_BOX: Self = Self {
-		corner_source: SnapSource::BoundingBox(BoundingBoxSnapSource::Corner),
-		corner_target: SnapTarget::BoundingBox(BoundingBoxSnapTarget::Corner),
+		corner_source: SnapSource::BoundingBox(BoundingBoxSnapSource::CornerPoint),
+		corner_target: SnapTarget::BoundingBox(BoundingBoxSnapTarget::CornerPoint),
 		edge_source: SnapSource::BoundingBox(BoundingBoxSnapSource::EdgeMidpoint),
 		edge_target: SnapTarget::BoundingBox(BoundingBoxSnapTarget::EdgeMidpoint),
-		center_source: SnapSource::BoundingBox(BoundingBoxSnapSource::Center),
-		center_target: SnapTarget::BoundingBox(BoundingBoxSnapTarget::Center),
+		center_source: SnapSource::BoundingBox(BoundingBoxSnapSource::CenterPoint),
+		center_target: SnapTarget::BoundingBox(BoundingBoxSnapTarget::CenterPoint),
 	};
 
 	pub const ARTBOARD: Self = Self {
-		corner_source: SnapSource::Artboard(ArtboardSnapSource::Corner),
-		corner_target: SnapTarget::Artboard(ArtboardSnapTarget::Corner),
+		corner_source: SnapSource::Artboard(ArtboardSnapSource::CornerPoint),
+		corner_target: SnapTarget::Artboard(ArtboardSnapTarget::CornerPoint),
 		edge_source: SnapSource::None,
 		edge_target: SnapTarget::None,
-		center_source: SnapSource::Artboard(ArtboardSnapSource::Center),
-		center_target: SnapTarget::Artboard(ArtboardSnapTarget::Center),
+		center_source: SnapSource::Artboard(ArtboardSnapSource::CenterPoint),
+		center_target: SnapTarget::Artboard(ArtboardSnapTarget::CenterPoint),
 	};
 
 	pub const ALIGN_BOUNDING_BOX: Self = Self {
-		corner_source: SnapSource::Alignment(AlignmentSnapSource::BoundsCorner),
-		corner_target: SnapTarget::Alignment(AlignmentSnapTarget::BoundsCorner),
+		corner_source: SnapSource::Alignment(AlignmentSnapSource::BoundingBoxCornerPoint),
+		corner_target: SnapTarget::Alignment(AlignmentSnapTarget::BoundingBoxCornerPoint),
 		edge_source: SnapSource::None,
 		edge_target: SnapTarget::None,
-		center_source: SnapSource::Alignment(AlignmentSnapSource::BoundsCenter),
-		center_target: SnapTarget::Alignment(AlignmentSnapTarget::BoundsCenter),
+		center_source: SnapSource::Alignment(AlignmentSnapSource::BoundingBoxCenterPoint),
+		center_target: SnapTarget::Alignment(AlignmentSnapTarget::BoundingBoxCenterPoint),
 	};
 
 	pub const ALIGN_ARTBOARD: Self = Self {
-		corner_source: SnapSource::Alignment(AlignmentSnapSource::ArtboardCorner),
-		corner_target: SnapTarget::Alignment(AlignmentSnapTarget::ArtboardCorner),
+		corner_source: SnapSource::Alignment(AlignmentSnapSource::ArtboardCornerPoint),
+		corner_target: SnapTarget::Alignment(AlignmentSnapTarget::ArtboardCornerPoint),
 		edge_source: SnapSource::None,
 		edge_target: SnapTarget::None,
-		center_source: SnapSource::Alignment(AlignmentSnapSource::ArtboardCenter),
-		center_target: SnapTarget::Alignment(AlignmentSnapTarget::ArtboardCenter),
+		center_source: SnapSource::Alignment(AlignmentSnapSource::ArtboardCenterPoint),
+		center_target: SnapTarget::Alignment(AlignmentSnapTarget::ArtboardCenterPoint),
 	};
 }
+
 pub fn get_bbox_points(quad: Quad, points: &mut Vec<SnapCandidatePoint>, values: BBoxSnapValues, document: &DocumentMessageHandler) {
 	for index in 0..4 {
 		let start = quad.0[index];
@@ -409,6 +418,7 @@ pub fn get_bbox_points(quad: Quad, points: &mut Vec<SnapCandidatePoint>, values:
 			points.push(SnapCandidatePoint::new_quad((start + end) / 2., values.edge_source, values.edge_target, Some(quad), false));
 		}
 	}
+
 	if document.snapping_state.target_enabled(values.center_target) {
 		points.push(SnapCandidatePoint::new_quad(quad.center(), values.center_source, values.center_target, Some(quad), false));
 	}
@@ -417,10 +427,12 @@ pub fn get_bbox_points(quad: Quad, points: &mut Vec<SnapCandidatePoint>, values:
 fn handle_not_under(to_document: DAffine2) -> impl Fn(&DVec2) -> bool {
 	move |&offset: &DVec2| to_document.transform_vector2(offset).length_squared() >= HIDE_HANDLE_DISTANCE * HIDE_HANDLE_DISTANCE
 }
+
 fn subpath_anchor_snap_points(layer: LayerNodeIdentifier, subpath: &Subpath<PointId>, snap_data: &SnapData, points: &mut Vec<SnapCandidatePoint>, to_document: DAffine2) {
 	let document = snap_data.document;
+
 	// Midpoints of linear segments
-	if document.snapping_state.target_enabled(SnapTarget::Geometry(GeometrySnapTarget::LineMidpoint)) {
+	if document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::LineMidpoint)) {
 		for (index, curve) in subpath.iter().enumerate() {
 			if snap_data.ignore_manipulator(layer, subpath.manipulator_groups()[index].id) || snap_data.ignore_manipulator(layer, subpath.manipulator_groups()[(index + 1) % subpath.len()].id) {
 				continue;
@@ -434,12 +446,13 @@ fn subpath_anchor_snap_points(layer: LayerNodeIdentifier, subpath: &Subpath<Poin
 			if in_handle.is_none() && out_handle.is_none() {
 				points.push(SnapCandidatePoint::new(
 					to_document.transform_point2(curve.start() * 0.5 + curve.end * 0.5),
-					SnapSource::Geometry(GeometrySnapSource::LineMidpoint),
-					SnapTarget::Geometry(GeometrySnapTarget::LineMidpoint),
+					SnapSource::Path(PathSnapSource::LineMidpoint),
+					SnapTarget::Path(PathSnapTarget::LineMidpoint),
 				));
 			}
 		}
 	}
+
 	// Anchors
 	for (index, group) in subpath.manipulator_groups().iter().enumerate() {
 		if snap_data.ignore_manipulator(layer, group.id) {
@@ -452,19 +465,20 @@ fn subpath_anchor_snap_points(layer: LayerNodeIdentifier, subpath: &Subpath<Poin
 
 		let colinear = are_manipulator_handles_colinear(group, to_document, subpath, index);
 
-		if colinear && document.snapping_state.target_enabled(SnapTarget::Geometry(GeometrySnapTarget::AnchorWithColinearHandles)) {
-			// Colinear handles
+		// Colinear handles
+		if colinear && document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::AnchorPointWithColinearHandles)) {
 			points.push(SnapCandidatePoint::new(
 				to_document.transform_point2(group.anchor),
-				SnapSource::Geometry(GeometrySnapSource::AnchorWithColinearHandles),
-				SnapTarget::Geometry(GeometrySnapTarget::AnchorWithColinearHandles),
+				SnapSource::Path(PathSnapSource::AnchorPointWithColinearHandles),
+				SnapTarget::Path(PathSnapTarget::AnchorPointWithColinearHandles),
 			));
-		} else if !colinear && document.snapping_state.target_enabled(SnapTarget::Geometry(GeometrySnapTarget::AnchorWithFreeHandles)) {
-			// Free handles
+		}
+		// Free handles
+		else if !colinear && document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::AnchorPointWithFreeHandles)) {
 			points.push(SnapCandidatePoint::new(
 				to_document.transform_point2(group.anchor),
-				SnapSource::Geometry(GeometrySnapSource::AnchorWithFreeHandles),
-				SnapTarget::Geometry(GeometrySnapTarget::AnchorWithFreeHandles),
+				SnapSource::Path(PathSnapSource::AnchorPointWithFreeHandles),
+				SnapTarget::Path(PathSnapTarget::AnchorPointWithFreeHandles),
 			));
 		}
 	}

editor/src/messages/tool/common_functionality/snapping/snap_results.rs

@@ -63,7 +63,7 @@ impl SnappedPoint {
 		Self {
 			snapped_point_document: point.document_point + translation,
 			source: point.source,
-			target: SnapTarget::Distribution(target),
+			target: SnapTarget::DistributeEvenly(target),
 			distribution_boxes_x,
 			distribution_equal_distance_x: is_x.then_some(distances.equal),
 			distribution_boxes_y,