fix distribution snapper visualization going far from layers

Author: moOsama76

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

@@ -196,8 +196,8 @@ impl DistributionSnapper {
 		let mut snap_x: Option<SnappedPoint> = None;
 		let mut snap_y: Option<SnappedPoint> = None;
 
-		self.x(consider_x, bounds, tolerance, &mut snap_x, point);
-		self.y(consider_y, bounds, tolerance, &mut snap_y, point);
+		self.horizontal_snap(consider_x, bounds, tolerance / 2., &mut snap_x, point);
+		self.vertical_snap(consider_y, bounds, tolerance / 2., &mut snap_y, point);
 
 		match (snap_x, snap_y) {
 			(Some(x), Some(y)) => {
@@ -220,7 +220,7 @@ impl DistributionSnapper {
 		}
 	}
 
-	fn x(&self, consider_x: bool, bounds: Rect, tolerance: f64, snap_x: &mut Option<SnappedPoint>, point: &SnapCandidatePoint) {
+	fn horizontal_snap(&self, consider_x: bool, bounds: Rect, tolerance: f64, snap_x: &mut Option<SnappedPoint>, point: &SnapCandidatePoint) {
 		// Right
 		if consider_x && !self.right.is_empty() {
 			let (equal_dist, mut vec_right) = Self::top_level_matches(bounds, &self.right, tolerance, dist_right);
@@ -269,7 +269,7 @@ impl DistributionSnapper {
 		}
 	}
 
-	fn y(&self, consider_y: bool, bounds: Rect, tolerance: f64, snap_y: &mut Option<SnappedPoint>, point: &SnapCandidatePoint) {
+	fn vertical_snap(&self, consider_y: bool, bounds: Rect, tolerance: f64, snap_y: &mut Option<SnappedPoint>, point: &SnapCandidatePoint) {
 		// Down
 		if consider_y && !self.down.is_empty() {
 			let (equal_dist, mut vec_down) = Self::top_level_matches(bounds, &self.down, tolerance, dist_down);
@@ -322,7 +322,24 @@ 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 };
+		let Some(config_bbox) = config.bbox else { return };
+		let Some(layer_bbox) = snap_data
+			.document
+			.metadata()
+			.bounding_box_document(
+				snap_data
+					.document
+					.network_interface
+					.selected_nodes()
+					.selected_unlocked_layers(&snap_data.document.network_interface)
+					.next()
+					.expect("No selected layers"),
+			)
+			.map(|bbox| Rect::from_box(bbox))
+		else {
+			return;
+		};
+		let bounds = config_bbox.intersection(layer_bbox).expect("No Intersection");
 		if point.source != SnapSource::BoundingBox(BoundingBoxSnapSource::CenterPoint) || !snap_data.document.snapping_state.bounding_box.distribute_evenly {
 			return;
 		}

node-graph/gcore/src/graphic_element/renderer/rect.rs

@@ -67,14 +67,31 @@ impl Rect {
 		Self::from_box([self[0] - delta, self[1] + delta])
 	}
 
-	/// Expand a rect by a certain amount on top/bottom and on left/right
+	/// Checks if two rects intersect
 	#[must_use]
 	pub fn intersects(&self, other: Self) -> bool {
 		let [mina, maxa] = [self[0].min(self[1]), self[0].max(self[1])];
 		let [minb, maxb] = [other[0].min(other[1]), other[0].max(other[1])];
 		mina.x <= maxb.x && minb.x <= maxa.x && mina.y <= maxb.y && minb.y <= maxa.y
 	}
 
+	/// Find intersection
+	#[must_use]
+	pub fn intersection(&self, other: Self) -> Option<Rect> {
+		if !self.intersects(other) {
+			return None;
+		}
+		let [mina, maxa] = [self[0].min(self[1]), self[0].max(self[1])];
+		let [minb, maxb] = [other[0].min(other[1]), other[0].max(other[1])];
+
+		let min_x = mina.x.max(minb.x);
+		let min_y = mina.y.max(minb.y);
+		let max_x = maxa.x.min(maxb.x);
+		let max_y = maxa.y.min(maxb.y);
+
+		Some(Rect::from_box([DVec2::new(min_x, min_y), DVec2::new(max_x, max_y)]))
+	}
+
 	/// Does this rect contain a point
 	#[must_use]
 	pub fn contains(&self, p: DVec2) -> bool {