Merge branch 'master' into bevel-algo

Author: Keavon

editor/src/messages/input_mapper/utility_types/input_mouse.rs

@@ -6,6 +6,7 @@ use glam::DVec2;
 use std::collections::VecDeque;
 
 // Origin is top left
+pub type DocumentPosition = DVec2;
 pub type ViewportPosition = DVec2;
 pub type EditorPosition = DVec2;
 

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

@@ -2321,7 +2321,7 @@ pub struct ClickXRayIter<'a> {
 }
 
 fn quad_to_path_lib_segments(quad: Quad) -> Vec<path_bool_lib::PathSegment> {
-	quad.edges().into_iter().map(|[start, end]| path_bool_lib::PathSegment::Line(start, end)).collect()
+	quad.all_edges().into_iter().map(|[start, end]| path_bool_lib::PathSegment::Line(start, end)).collect()
 }
 
 fn click_targets_to_path_lib_segments<'a>(click_targets: impl Iterator<Item = &'a ClickTarget>, transform: DAffine2) -> Vec<path_bool_lib::PathSegment> {

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

@@ -653,6 +653,10 @@ impl PTZ {
 		(((self.tilt + std::f64::consts::PI) % std::f64::consts::TAU) + std::f64::consts::TAU) % std::f64::consts::TAU - std::f64::consts::PI
 	}
 
+	pub fn unmodified_tilt(&self) -> f64 {
+		self.tilt
+	}
+
 	/// Set a new tilt angle in radians.
 	pub fn set_tilt(&mut self, tilt: f64) {
 		self.tilt = tilt;

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

@@ -14,6 +14,7 @@ use graphene_std::vector::{HandleId, PointId};
 
 use glam::{DAffine2, DMat2, DVec2};
 use std::collections::{HashMap, VecDeque};
+use std::f64::consts::PI;
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 struct AnchorPoint {
@@ -305,17 +306,17 @@ pub enum TransformOperation {
 }
 
 impl TransformOperation {
-	pub fn apply_transform_operation(&self, selected: &mut Selected, increment_mode: bool, local: bool, quad: Quad, transform: DAffine2) {
+	pub fn apply_transform_operation(&self, selected: &mut Selected, increment_mode: bool, local: bool, quad: Quad, transform: DAffine2, pivot: DVec2, local_transform: DAffine2) {
 		let local_axis_transform_angle = (quad.top_left() - quad.top_right()).to_angle();
 		if self != &TransformOperation::None {
 			let transformation = match self {
 				TransformOperation::Grabbing(translation) => {
-					let translate = DAffine2::from_translation(transform.transform_vector2(translation.to_dvec(transform, increment_mode)));
+					let translate = DAffine2::from_translation(transform.transform_vector2(translation.to_dvec(local_transform, increment_mode)));
 					if local {
 						let resolved_angle = if local_axis_transform_angle > 0. {
-							local_axis_transform_angle - std::f64::consts::PI
-						} else {
 							local_axis_transform_angle
+						} else {
+							local_axis_transform_angle - PI
 						};
 						DAffine2::from_angle(resolved_angle) * translate * DAffine2::from_angle(-resolved_angle)
 					} else {
@@ -333,7 +334,7 @@ impl TransformOperation {
 				TransformOperation::None => unreachable!(),
 			};
 
-			selected.update_transforms(transformation);
+			selected.update_transforms(transformation, Some(pivot));
 			self.hints(selected.responses, local);
 		}
 	}
@@ -350,7 +351,7 @@ impl TransformOperation {
 		self.is_constraint_to_axis() || !matches!(self, TransformOperation::Grabbing(_))
 	}
 
-	pub fn constrain_axis(&mut self, axis: Axis, selected: &mut Selected, increment_mode: bool, mut local: bool, quad: Quad, transform: DAffine2) -> bool {
+	pub fn constrain_axis(&mut self, axis: Axis, selected: &mut Selected, increment_mode: bool, mut local: bool, quad: Quad, transform: DAffine2, pivot: DVec2, local_transform: DAffine2) -> bool {
 		(*self, local) = match self {
 			TransformOperation::Grabbing(translation) => {
 				let (translation, local) = translation.with_constraint(axis, local);
@@ -362,19 +363,19 @@ impl TransformOperation {
 			}
 			_ => (*self, false),
 		};
-		self.apply_transform_operation(selected, increment_mode, local, quad, transform);
+		self.apply_transform_operation(selected, increment_mode, local, quad, transform, pivot, local_transform);
 		local
 	}
 
-	pub fn grs_typed(&mut self, typed: Option<f64>, selected: &mut Selected, increment_mode: bool, local: bool, quad: Quad, transform: DAffine2) {
+	pub fn grs_typed(&mut self, typed: Option<f64>, selected: &mut Selected, increment_mode: bool, local: bool, quad: Quad, transform: DAffine2, pivot: DVec2, local_transform: DAffine2) {
 		match self {
 			TransformOperation::None => (),
 			TransformOperation::Grabbing(translation) => translation.typed_distance = typed,
 			TransformOperation::Rotating(rotation) => rotation.typed_angle = typed,
 			TransformOperation::Scaling(scale) => scale.typed_factor = typed,
 		};
 
-		self.apply_transform_operation(selected, increment_mode, local, quad, transform);
+		self.apply_transform_operation(selected, increment_mode, local, quad, transform, pivot, local_transform);
 	}
 
 	pub fn hints(&self, responses: &mut VecDeque<Message>, local: bool) {
@@ -456,15 +457,15 @@ impl TransformOperation {
 		}
 	}
 
-	pub fn negate(&mut self, selected: &mut Selected, increment_mode: bool, local: bool, quad: Quad, transform: DAffine2) {
+	pub fn negate(&mut self, selected: &mut Selected, increment_mode: bool, local: bool, quad: Quad, transform: DAffine2, pivot: DVec2, local_transform: DAffine2) {
 		if *self != TransformOperation::None {
 			*self = match self {
 				TransformOperation::Scaling(scale) => TransformOperation::Scaling(scale.negate()),
 				TransformOperation::Rotating(rotation) => TransformOperation::Rotating(rotation.negate()),
 				TransformOperation::Grabbing(translation) => TransformOperation::Grabbing(translation.negate()),
 				_ => *self,
 			};
-			self.apply_transform_operation(selected, increment_mode, local, quad, transform);
+			self.apply_transform_operation(selected, increment_mode, local, quad, transform, pivot, local_transform);
 		}
 	}
 }
@@ -590,11 +591,14 @@ impl<'a> Selected<'a> {
 			responses.add(GraphOperationMessage::Vector { layer, modification_type });
 
 			if let Some((id, initial)) = handle.mirror {
-				let direction = viewspace.transform_vector2(new_pos_viewport - relative).try_normalize();
-				let length = viewspace.transform_vector2(initial - relative).length();
-				let new_relative = direction.map_or(initial - relative, |direction| viewspace.inverse().transform_vector2(-direction * length));
-				let modification_type = id.set_relative_position(new_relative);
-				responses.add(GraphOperationMessage::Vector { layer, modification_type });
+				// When the handle is scaled to zero, don't update the mirror handle
+				if (new_pos_viewport - relative).length_squared() > f64::EPSILON {
+					let direction = viewspace.transform_vector2(new_pos_viewport - relative).try_normalize();
+					let length = viewspace.transform_vector2(initial - relative).length();
+					let new_relative = direction.map_or(initial - relative, |direction| viewspace.inverse().transform_vector2(-direction * length));
+					let modification_type = id.set_relative_position(new_relative);
+					responses.add(GraphOperationMessage::Vector { layer, modification_type });
+				}
 			}
 		}
 	}
@@ -624,8 +628,8 @@ impl<'a> Selected<'a> {
 		}
 	}
 
-	pub fn update_transforms(&mut self, delta: DAffine2) {
-		let pivot = DAffine2::from_translation(*self.pivot);
+	pub fn update_transforms(&mut self, delta: DAffine2, pivot: Option<DVec2>) {
+		let pivot = DAffine2::from_translation(pivot.unwrap_or_else(|| *self.pivot));
 		let transformation = pivot * delta * pivot.inverse();
 		match self.tool_type {
 			ToolType::Pen => self.apply_transform_pen(transformation),

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

@@ -1,4 +1,5 @@
 use crate::consts::{COMPASS_ROSE_ARROW_CLICK_TARGET_ANGLE, COMPASS_ROSE_HOVER_RING_DIAMETER, COMPASS_ROSE_RING_INNER_DIAMETER};
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::prelude::DocumentMessageHandler;
 
 use glam::{DAffine2, DVec2};
@@ -10,9 +11,27 @@ pub struct CompassRose {
 }
 
 impl CompassRose {
-	pub fn refresh_transform(&mut self, document: &DocumentMessageHandler) {
-		let [min, max] = document.selected_visible_and_unlock_layers_bounding_box_viewport().unwrap_or([DVec2::ZERO, DVec2::ONE]);
-		self.compass_center = (DAffine2::from_translation(min) * DAffine2::from_scale(max - min)).transform_point2(DVec2::splat(0.5));
+	fn get_layer_pivot_transform(layer: LayerNodeIdentifier, document: &DocumentMessageHandler) -> DAffine2 {
+		let [min, max] = document.metadata().nonzero_bounding_box(layer);
+
+		let bounds_transform = DAffine2::from_translation(min) * DAffine2::from_scale(max - min);
+		let layer_transform = document.metadata().transform_to_viewport(layer);
+		layer_transform * bounds_transform
+	}
+	pub fn refresh_position(&mut self, document: &DocumentMessageHandler) {
+		let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
+		let mut layers = selected_nodes.selected_visible_and_unlocked_layers(&document.network_interface);
+
+		let Some(first) = layers.next() else { return };
+		let count = layers.count() + 1;
+		let transform = if count == 1 {
+			Self::get_layer_pivot_transform(first, document)
+		} else {
+			let [min, max] = document.selected_visible_and_unlock_layers_bounding_box_viewport().unwrap_or([DVec2::ZERO, DVec2::ONE]);
+			DAffine2::from_translation(min) * DAffine2::from_scale(max - min)
+		};
+
+		self.compass_center = transform.transform_point2(DVec2::splat(0.5));
 	}
 
 	pub fn compass_rose_position(&self) -> DVec2 {

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

@@ -111,11 +111,12 @@ impl Pivot {
 			.selected_visible_and_unlocked_layers(&document.network_interface)
 		{
 			let transform = Self::get_layer_pivot_transform(layer, document);
+			// Only update the pivot when computed position is finite.
+			if transform.matrix2.determinant().abs() <= f64::EPSILON {
+				return;
+			};
 			let pivot = transform.inverse().transform_point2(position);
-			// Only update the pivot when computed position is finite. Infinite can happen when scale is 0.
-			if pivot.is_finite() {
-				responses.add(GraphOperationMessage::TransformSetPivot { layer, pivot });
-			}
+			responses.add(GraphOperationMessage::TransformSetPivot { layer, pivot });
 		}
 	}
 

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

@@ -733,14 +733,16 @@ impl ShapeState {
 	}
 
 	/// Move the selected points by dragging the mouse.
+	#[allow(clippy::too_many_arguments)]
 	pub fn move_selected_points(
 		&self,
 		handle_lengths: Option<OpposingHandleLengths>,
 		document: &DocumentMessageHandler,
 		delta: DVec2,
 		equidistant: bool,
-		responses: &mut VecDeque<Message>,
 		in_viewport_space: bool,
+		opposite_handle_position: Option<DVec2>,
+		responses: &mut VecDeque<Message>,
 	) {
 		for (&layer, state) in &self.selected_shape_state {
 			let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { continue };
@@ -791,6 +793,11 @@ impl ShapeState {
 
 				let new_relative = if equidistant {
 					-(handle_position - anchor_position)
+				}
+				// If the handle is very close to the anchor, return the original position
+				else if (handle_position - anchor_position).length_squared() < f64::EPSILON * 1e5 {
+					let Some(opposite_handle_position) = opposite_handle_position else { continue };
+					opposite_handle_position - anchor_position
 				} else {
 					// TODO: Is this equivalent to `transform_to_document_space`? If changed, the before and after should be tested.
 					let transform = document.metadata().document_to_viewport.inverse() * transform_to_viewport_space;