Merge branch 'master' into qr-code-shape

Author: jsjgdh

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

@@ -139,7 +139,8 @@ impl FrameTimeInfo {
 	}
 
 	pub fn advance_timestamp(&mut self, next_timestamp: Duration) {
-		debug_assert!(next_timestamp >= self.timestamp);
+		// Guard against non-monotonic timestamps from the browser (Keavon observed this once in Chrome)
+		let next_timestamp = next_timestamp.max(self.timestamp);
 
 		self.prev_timestamp = Some(self.timestamp);
 		self.timestamp = next_timestamp;

editor/src/messages/portfolio/document/graph_operation/transform_utils.rs

@@ -3,44 +3,21 @@ use glam::{DAffine2, DVec2};
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{NodeId, NodeInput};
 use graphene_std::subpath::Subpath;
+use graphene_std::transform::Transform;
 use graphene_std::vector::PointId;
 
-/// Convert an affine transform into the tuple `(scale, angle, translation, shear)` assuming `shear.y = 0`.
-pub fn compute_scale_angle_translation_shear(transform: DAffine2) -> (DVec2, f64, DVec2, DVec2) {
-	let x_axis = transform.matrix2.x_axis;
-	let y_axis = transform.matrix2.y_axis;
-
-	// Assuming there is no vertical shear
-	let angle = x_axis.y.atan2(x_axis.x);
-	let (sin, cos) = angle.sin_cos();
-	let scale_x = if cos.abs() > 1e-10 { x_axis.x / cos } else { x_axis.y / sin };
-
-	let mut shear_x = (sin * y_axis.y + cos * y_axis.x) / (sin * sin * scale_x + cos * cos * scale_x);
-	if !shear_x.is_finite() {
-		shear_x = 0.;
-	}
-	let scale_y = if cos.abs() > 1e-10 {
-		(y_axis.y - scale_x * sin * shear_x) / cos
-	} else {
-		(scale_x * cos * shear_x - y_axis.x) / sin
-	};
-	let translation = transform.translation;
-	let scale = DVec2::new(scale_x, scale_y);
-	let shear = DVec2::new(shear_x, 0.);
-	(scale, angle, translation, shear)
-}
-
 /// Update the inputs of the transform node to match a new transform
 pub fn update_transform(network_interface: &mut NodeNetworkInterface, node_id: &NodeId, transform: DAffine2) {
-	let (scale, rotation, translation, shear) = compute_scale_angle_translation_shear(transform);
+	let (rotation, scale, skew) = transform.decompose_rotation_scale_skew();
+	let translation = transform.translation;
 
 	let rotation = rotation.to_degrees();
-	let shear = DVec2::new(shear.x.atan().to_degrees(), shear.y.atan().to_degrees());
+	let skew = DVec2::new(skew.atan().to_degrees(), 0.);
 
 	network_interface.set_input(&InputConnector::node(*node_id, 1), NodeInput::value(TaggedValue::DVec2(translation), false), &[]);
 	network_interface.set_input(&InputConnector::node(*node_id, 2), NodeInput::value(TaggedValue::F64(rotation), false), &[]);
 	network_interface.set_input(&InputConnector::node(*node_id, 3), NodeInput::value(TaggedValue::DVec2(scale), false), &[]);
-	network_interface.set_input(&InputConnector::node(*node_id, 4), NodeInput::value(TaggedValue::DVec2(shear), false), &[]);
+	network_interface.set_input(&InputConnector::node(*node_id, 4), NodeInput::value(TaggedValue::DVec2(skew), false), &[]);
 }
 
 // TODO: This should be extracted from the graph at the location of the transform node.
@@ -81,12 +58,12 @@ pub fn get_current_transform(inputs: &[NodeInput]) -> DAffine2 {
 	};
 	let rotation = if let Some(&TaggedValue::F64(rotation)) = inputs[2].as_value() { rotation } else { 0. };
 	let scale = if let Some(&TaggedValue::DVec2(scale)) = inputs[3].as_value() { scale } else { DVec2::ONE };
-	let shear = if let Some(&TaggedValue::DVec2(shear)) = inputs[4].as_value() { shear } else { DVec2::ZERO };
+	let skew = if let Some(&TaggedValue::DVec2(skew)) = inputs[4].as_value() { skew } else { DVec2::ZERO };
 
 	let rotation = rotation.to_radians();
-	let shear = DVec2::new(shear.x.to_radians().tan(), shear.y.to_radians().tan());
+	let skew = DVec2::new(skew.x.to_radians().tan(), skew.y.to_radians().tan());
 
-	DAffine2::from_scale_angle_translation(scale, rotation, translation) * DAffine2::from_cols_array(&[1., shear.y, shear.x, 1., 0., 0.])
+	DAffine2::from_scale_angle_translation(scale, rotation, translation) * DAffine2::from_cols_array(&[1., skew.y, skew.x, 1., 0., 0.])
 }
 
 /// Extract the current normalized pivot from the layer
@@ -135,31 +112,32 @@ mod tests {
 	/// ```
 	#[test]
 	fn derive_transform() {
-		for shear_x in -10..=10 {
-			let shear_x = (shear_x as f64) / 2.;
+		for skew_x in -10..=10 {
+			let skew_x = (skew_x as f64) / 2.;
 			for angle in (0..=360).step_by(15) {
 				let angle = (angle as f64).to_radians();
 				for scale_x in 1..10 {
 					let scale_x = (scale_x as f64) / 5.;
 					for scale_y in 1..10 {
 						let scale_y = (scale_y as f64) / 5.;
 
-						let shear = DVec2::new(shear_x, 0.);
+						let skew = DVec2::new(skew_x, 0.);
 						let scale = DVec2::new(scale_x, scale_y);
 						let translate = DVec2::new(5666., 644.);
 
 						let original_transform = DAffine2::from_cols(
-							DVec2::new(scale.x * angle.cos() - scale.y * angle.sin() * shear.y, scale.x * angle.sin() + scale.y * angle.cos() * shear.y),
-							DVec2::new(scale.x * angle.cos() * shear.x - scale.y * angle.sin(), scale.x * angle.sin() * shear.x + scale.y * angle.cos()),
+							DVec2::new(scale.x * angle.cos() - scale.y * angle.sin() * skew.y, scale.x * angle.sin() + scale.y * angle.cos() * skew.y),
+							DVec2::new(scale.x * angle.cos() * skew.x - scale.y * angle.sin(), scale.x * angle.sin() * skew.x + scale.y * angle.cos()),
 							translate,
 						);
 
-						let (new_scale, new_angle, new_translation, new_shear) = compute_scale_angle_translation_shear(original_transform);
-						let new_transform = DAffine2::from_scale_angle_translation(new_scale, new_angle, new_translation) * DAffine2::from_cols_array(&[1., new_shear.y, new_shear.x, 1., 0., 0.]);
+						let (new_angle, new_scale, new_skew) = original_transform.decompose_rotation_scale_skew();
+						let new_translation = original_transform.translation;
+						let new_transform = DAffine2::from_scale_angle_translation(new_scale, new_angle, new_translation) * DAffine2::from_cols_array(&[1., 0., new_skew, 1., 0., 0.]);
 
 						assert!(
 							new_transform.abs_diff_eq(original_transform, 1e-10),
-							"original_transform {original_transform} new_transform {new_transform} / scale {scale} new_scale {new_scale} / angle {angle} new_angle {new_angle} / shear {shear} / new_shear {new_shear}",
+							"original_transform {original_transform} new_transform {new_transform} / scale {scale} new_scale {new_scale} / angle {angle} new_angle {new_angle} / skew {skew} / new_skew {new_skew}",
 						);
 					}
 				}

editor/src/messages/portfolio/document/node_graph/node_properties.rs

@@ -23,7 +23,7 @@ use graphene_std::raster::{
 };
 use graphene_std::table::{Table, TableRow};
 use graphene_std::text::{Font, TextAlign};
-use graphene_std::transform::{Footprint, ReferencePoint, Transform};
+use graphene_std::transform::{Footprint, ReferencePoint, ScaleType, Transform};
 use graphene_std::vector::QRCodeErrorCorrectionLevel;
 use graphene_std::vector::misc::BooleanOperation;
 use graphene_std::vector::misc::{ArcType, CentroidType, ExtrudeJoiningAlgorithm, GridType, MergeByDistanceAlgorithm, PointSpacingType, RowsOrColumns, SpiralType};
@@ -265,6 +265,7 @@ pub(crate) fn property_from_type(
 						Some(x) if x == TypeId::of::<CentroidType>() => enum_choice::<CentroidType>().for_socket(default_info).property_row(),
 						Some(x) if x == TypeId::of::<LuminanceCalculation>() => enum_choice::<LuminanceCalculation>().for_socket(default_info).property_row(),
 						Some(x) if x == TypeId::of::<QRCodeErrorCorrectionLevel>() => enum_choice::<QRCodeErrorCorrectionLevel>().for_socket(default_info).property_row(),
+						Some(x) if x == TypeId::of::<ScaleType>() => enum_choice::<ScaleType>().for_socket(default_info).property_row(),
 						// =====
 						// OTHER
 						// =====
@@ -566,8 +567,8 @@ pub fn transform_widget(parameter_widgets_info: ParameterWidgetsInfo, extra_widg
 
 	let widgets = if let Some(&TaggedValue::DAffine2(transform)) = input.as_non_exposed_value() {
 		let translation = transform.translation;
-		let rotation = transform.decompose_rotation();
-		let scale = transform.decompose_scale();
+		let (rotation, scale, skew) = transform.decompose_rotation_scale_skew();
+		let skew_matrix = DAffine2::from_cols_array(&[1., 0., skew, 1., 0., 0.]);
 
 		location_widgets.extend_from_slice(&[
 			NumberInput::new(Some(translation.x))
@@ -608,7 +609,7 @@ pub fn transform_widget(parameter_widgets_info: ParameterWidgetsInfo, extra_widg
 			.range_max(Some(180.))
 			.on_update(update_value(
 				move |r: &NumberInput| {
-					let transform = DAffine2::from_scale_angle_translation(scale, r.value.map(|r| r.to_radians()).unwrap_or(rotation), translation);
+					let transform = DAffine2::from_scale_angle_translation(scale, r.value.map(|r| r.to_radians()).unwrap_or(rotation), translation) * skew_matrix;
 					TaggedValue::DAffine2(transform)
 				},
 				node_id,
@@ -623,7 +624,7 @@ pub fn transform_widget(parameter_widgets_info: ParameterWidgetsInfo, extra_widg
 				.unit("x")
 				.on_update(update_value(
 					move |w: &NumberInput| {
-						let transform = DAffine2::from_scale_angle_translation(DVec2::new(w.value.unwrap_or(scale.x), scale.y), rotation, translation);
+						let transform = DAffine2::from_scale_angle_translation(DVec2::new(w.value.unwrap_or(scale.x), scale.y), rotation, translation) * skew_matrix;
 						TaggedValue::DAffine2(transform)
 					},
 					node_id,
@@ -637,7 +638,7 @@ pub fn transform_widget(parameter_widgets_info: ParameterWidgetsInfo, extra_widg
 				.unit("x")
 				.on_update(update_value(
 					move |h: &NumberInput| {
-						let transform = DAffine2::from_scale_angle_translation(DVec2::new(scale.x, h.value.unwrap_or(scale.y)), rotation, translation);
+						let transform = DAffine2::from_scale_angle_translation(DVec2::new(scale.x, h.value.unwrap_or(scale.y)), rotation, translation) * skew_matrix;
 						TaggedValue::DAffine2(transform)
 					},
 					node_id,

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

@@ -4005,6 +4005,14 @@ impl NodeNetworkInterface {
 				}
 			}
 			(_, NodeInput::Node { node_id: upstream_node_id, .. }) => {
+				// If the old input wasn't exposed but the new one is (`Node` inputs are always exposed),
+				// the node's port count changed, so its click targets need to be recomputed
+				if !old_input.is_exposed()
+					&& let InputConnector::Node { node_id, .. } = input_connector
+				{
+					self.unload_node_click_targets(node_id, network_path);
+				}
+
 				// Load structure if the change is to the document network and to the first or second
 				if network_path.is_empty() {
 					if matches!(input_connector, InputConnector::Export(0)) {

editor/src/messages/portfolio/document_migration.rs

@@ -12,6 +12,7 @@ use graphene_std::ProtoNodeIdentifier;
 use graphene_std::subpath::Subpath;
 use graphene_std::table::Table;
 use graphene_std::text::{TextAlign, TypesettingConfig};
+use graphene_std::transform::ScaleType;
 use graphene_std::uuid::NodeId;
 use graphene_std::vector::Vector;
 use graphene_std::vector::style::{PaintOrder, StrokeAlign};
@@ -1848,6 +1849,17 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 		document.network_interface.set_context_features(node_id, network_path, context_features);
 	}
 
+	// Add the "Scale Type" parameter to the "Decompose Scale" node
+	if reference == DefinitionIdentifier::ProtoNode(graphene_std::transform_nodes::decompose_scale::IDENTIFIER) && inputs_count == 1 {
+		let mut node_template = resolve_document_node_type(&reference)?.default_node_template();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
+
+		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
+		document
+			.network_interface
+			.set_input(&InputConnector::node(*node_id, 1), NodeInput::value(TaggedValue::ScaleType(ScaleType::Magnitude), false), network_path);
+	}
+
 	// ==================================
 	// PUT ALL MIGRATIONS ABOVE THIS LINE
 	// ==================================

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

@@ -212,16 +212,15 @@ impl SelectedEdges {
 				let original_from_pivot = updated - pivot; // The original vector from the point to the pivot
 				let mut scale_factor = new_from_pivot / original_from_pivot;
 
-				// Constrain should always scale by the same factor in x and y
+				// Constrain should always scale by the same factor in x and y.
+				// When one axis of `original_from_pivot` is near zero (e.g. for a line's degenerate bounding box),
+				// the scale factor for that axis is numerically unstable, so we copy from the more stable axis.
 				if constrain {
-					// When the point is on the pivot, we simply copy the other axis.
-					if original_from_pivot.x.abs() < 1e-5 {
+					if original_from_pivot.x.abs() < original_from_pivot.y.abs() {
 						scale_factor.x = scale_factor.y;
-					} else if original_from_pivot.y.abs() < 1e-5 {
+					} else {
 						scale_factor.y = scale_factor.x;
 					}
-
-					debug_assert!((scale_factor.x - scale_factor.y).abs() < 1e-5);
 				}
 
 				if !(self.left || self.right || constrain) {