Add InterpolationDistribution parameter to Morph with weighted progression, swap parameter orders, and rename shear to skew

Author: Keavon

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

@@ -188,9 +188,9 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageContext<'_>> for
 				network_interface.move_layer_to_stack(layer, parent, insert_index, &[]);
 				network_interface.move_layer_to_stack(blend_path_layer, parent, insert_index + 1, &[]);
 
-				// Connect the Path node's output to the Blend Shapes node's Path parameter input (input 1).
+				// Connect the Path node's output to the Blend Shapes node's Path parameter input (input 2).
 				// Done after move_layer_to_stack so chain nodes have correct positions when converted to absolute.
-				network_interface.set_input(&InputConnector::node(blend_shapes_node_id, 1), NodeInput::node(path_node_id, 0), &[]);
+				network_interface.set_input(&InputConnector::node(blend_shapes_node_id, 2), NodeInput::node(path_node_id, 0), &[]);
 
 				responses.add(NodeGraphMessage::SetDisplayNameImpl {
 					node_id: id,

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

@@ -159,7 +159,8 @@ impl<'a> ModifyInputsContext<'a> {
 	pub fn insert_blend_shapes_data(&mut self, layer: LayerNodeIdentifier, count: f64) -> NodeId {
 		let blend_shapes = resolve_network_node_type("Blend Shapes").expect("Blend Shapes node does not exist").node_template_input_override([
 			Some(NodeInput::value(TaggedValue::Graphic(Default::default()), true)),
-			Some(NodeInput::value(TaggedValue::Vector(Default::default()), true)),
+			None,
+			None,
 			Some(NodeInput::value(TaggedValue::F64(count), false)),
 		]);
 
@@ -176,6 +177,7 @@ impl<'a> ModifyInputsContext<'a> {
 			.node_template_input_override([
 				Some(NodeInput::value(TaggedValue::Graphic(Default::default()), true)),
 				Some(NodeInput::value(TaggedValue::F64(0.5), false)),
+				None,
 				Some(NodeInput::value(TaggedValue::Vector(Default::default()), false)),
 			]);
 

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

@@ -472,7 +472,7 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 							// 0: Separate Subpaths (split path into individual subpaths)
 							DocumentNode {
 								implementation: DocumentNodeImplementation::ProtoNode(vector::separate_subpaths::IDENTIFIER),
-								inputs: vec![NodeInput::import(generic!(T), 1)],
+								inputs: vec![NodeInput::import(generic!(T), 2)],
 								..Default::default()
 							},
 							// 1: Count Elements (number of subpaths)
@@ -490,7 +490,7 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 							// 3: Floor (integer count per subpath)
 							DocumentNode {
 								implementation: DocumentNodeImplementation::ProtoNode(math_nodes::floor::IDENTIFIER),
-								inputs: vec![NodeInput::import(concrete!(f64), 2)],
+								inputs: vec![NodeInput::import(concrete!(f64), 3)],
 								..Default::default()
 							},
 							// 4: Multiply (total_instances = count × subpath_count)
@@ -532,7 +532,7 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 							// 10: Path Is Closed (check if current subpath is closed)
 							DocumentNode {
 								implementation: DocumentNodeImplementation::ProtoNode(vector::path_is_closed::IDENTIFIER),
-								inputs: vec![NodeInput::import(generic!(T), 1), NodeInput::node(NodeId(8), 0)],
+								inputs: vec![NodeInput::import(generic!(T), 2), NodeInput::node(NodeId(8), 0)],
 								..Default::default()
 							},
 							// 11: Switch (closed → count, open → count - 1 as denominator)
@@ -559,16 +559,21 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 								inputs: vec![NodeInput::node(NodeId(8), 0), NodeInput::node(NodeId(13), 0)],
 								..Default::default()
 							},
-							// 15: Morph (content, progression, path)
+							// 15: Morph (content, progression, distribution, path)
 							DocumentNode {
 								implementation: DocumentNodeImplementation::ProtoNode(vector::morph::IDENTIFIER),
-								inputs: vec![NodeInput::import(generic!(T), 0), NodeInput::node(NodeId(14), 0), NodeInput::import(generic!(T), 1)],
+								inputs: vec![
+									NodeInput::import(generic!(T), 0),
+									NodeInput::node(NodeId(14), 0),
+									NodeInput::import(concrete!(vector::misc::InterpolationDistribution), 1),
+									NodeInput::import(generic!(T), 2),
+								],
 								..Default::default()
 							},
 							// 16: Repeat
 							DocumentNode {
 								implementation: DocumentNodeImplementation::ProtoNode(repeat_nodes::repeat::IDENTIFIER),
-								inputs: vec![NodeInput::node(NodeId(15), 0), NodeInput::node(NodeId(4), 0), NodeInput::import(generic!(T), 3)],
+								inputs: vec![NodeInput::node(NodeId(15), 0), NodeInput::node(NodeId(4), 0), NodeInput::import(generic!(T), 4)],
 								..Default::default()
 							},
 							// 17: Max (clamp count to at least 1)
@@ -586,14 +591,21 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 					}),
 					inputs: vec![
 						NodeInput::value(TaggedValue::Vector(Default::default()), true),
+						NodeInput::value(TaggedValue::InterpolationDistribution(Default::default()), false),
 						NodeInput::value(TaggedValue::Vector(Default::default()), false),
 						NodeInput::value(TaggedValue::F64(10.), false),
 						NodeInput::value(TaggedValue::Bool(Default::default()), false),
 					],
 					..Default::default()
 				},
 				persistent_node_metadata: DocumentNodePersistentMetadata {
-					input_metadata: vec![("Content", "TODO").into(), ("Path", "TODO").into(), ("Count", "TODO").into(), ("Reverse", "TODO").into()],
+					input_metadata: vec![
+						("Content", "TODO").into(),
+						("Distribution", "TODO").into(),
+						("Path", "TODO").into(),
+						("Count", "TODO").into(),
+						("Reverse", "TODO").into(),
+					],
 					output_names: vec!["Out".to_string()],
 					node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(0, 0)),
 					network_metadata: Some(NodeNetworkMetadata {

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

@@ -26,7 +26,7 @@ use graphene_std::text::{Font, TextAlign};
 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};
+use graphene_std::vector::misc::{ArcType, CentroidType, ExtrudeJoiningAlgorithm, GridType, InterpolationDistribution, MergeByDistanceAlgorithm, PointSpacingType, RowsOrColumns, SpiralType};
 use graphene_std::vector::style::{Fill, FillChoice, FillType, GradientStops, GradientType, PaintOrder, StrokeAlign, StrokeCap, StrokeJoin};
 
 pub(crate) fn string_properties(text: &str) -> Vec<LayoutGroup> {
@@ -266,6 +266,7 @@ pub(crate) fn property_from_type(
 						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(),
+						Some(x) if x == TypeId::of::<InterpolationDistribution>() => enum_choice::<InterpolationDistribution>().for_socket(default_info).property_row(),
 						// =====
 						// OTHER
 						// =====

editor/src/messages/portfolio/document_migration.rs

@@ -1669,9 +1669,10 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 	// The old version would zip the source and target table rows, interpoleating each pair together.
 	// The migrated version will instead deeply flatten both merged tables and morph sequentially between all source vectors and all target vector elements.
 	// This migration assumes most usages didn't involve multiple parallel vector elements, and instead morphed from a single source to a single target vector element.
-	// The new signature has 3 inputs too, so we distinguish by checking if input 2 is an f64 (old `time` param) vs a Table<Vector> (new `path` param).
+	// The new signature has 4 inputs too, so we distinguish by checking if input 2 is an f64 (old `time` param) vs an InterpolationSpacing (new `distribution` param).
 	let is_old_morph = reference == DefinitionIdentifier::ProtoNode(graphene_std::vector::morph::IDENTIFIER)
-		&& (inputs_count == 4 || (inputs_count == 3 && node.inputs.get(2).and_then(|i| i.as_value()).is_some_and(|v| matches!(v, TaggedValue::F64(_)))));
+		&& ((inputs_count == 3 && node.inputs.get(2).and_then(|i| i.as_value()).is_some_and(|v| matches!(v, TaggedValue::F64(_))))
+			|| (inputs_count == 4 && node.inputs.get(2).and_then(|i| i.as_value()).is_some_and(|v| matches!(v, TaggedValue::F64(_)))));
 	if is_old_morph {
 		// 3 inputs - old signature (#3405):
 		// async fn morph(_: impl Ctx, source: Table<Vector>, #[expose] target: Table<Vector>, #[default(0.5)] time: Fraction) -> Table<Vector> { ... }
@@ -1680,7 +1681,7 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 		// async fn morph(_: impl Ctx, source: Table<Vector>, #[expose] target: Table<Vector>, #[default(0.5)] time: Fraction, #[min(0.)] start_index: IntegerCount) -> Table<Vector> { ... }
 		//
 		// New signature:
-		// async fn morph<I: IntoGraphicTable>(_: impl Ctx, #[implementations(Table<Graphic>, Table<Vector>)] content: I, progression: Progression, path: Table<Vector>) -> Table<Vector> { ... }
+		// async fn morph<I: IntoGraphicTable>(_: impl Ctx, content: I, progression: Progression, distribution: InterpolationDistribution, path: Table<Vector>) -> Table<Vector> { ... }
 
 		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)?;

node-graph/graph-craft/src/document/value.rs

@@ -260,6 +260,7 @@ tagged_value! {
 	ExtrudeJoiningAlgorithm(vector::misc::ExtrudeJoiningAlgorithm),
 	PointSpacingType(vector::misc::PointSpacingType),
 	SpiralType(vector::misc::SpiralType),
+	InterpolationDistribution(vector::misc::InterpolationDistribution),
 	#[serde(alias = "LineCap")]
 	StrokeCap(vector::style::StrokeCap),
 	#[serde(alias = "LineJoin")]

node-graph/interpreted-executor/src/node_registry.rs

@@ -135,6 +135,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::CentroidType]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::text::TextAlign]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::transform::ScaleType]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::InterpolationDistribution]),
 		// Context nullification
 		#[cfg(feature = "gpu")]
 		async_node!(graphene_core::context_modification::ContextModificationNode<_, _>, input: Context, fn_params: [Context => &WasmEditorApi, Context => graphene_std::ContextFeatures]),
@@ -229,6 +230,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::BooleanOperation]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::text::TextAlign]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::transform::ScaleType]),
+		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::InterpolationDistribution]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => RenderIntermediate]),
 	];
 	// =============

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

@@ -554,3 +554,21 @@ pub enum SpiralType {
 	Archimedean,
 	Logarithmic,
 }
+
+/// Controls how the morph/blend progression spends its time along the interpolation path, allowing for constant speed/spacing with respect to different parameters of change.
+#[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, node_macro::ChoiceType)]
+#[widget(Dropdown)]
+pub enum InterpolationDistribution {
+	/// All objects occupy an equal portion of the progression range, regardless of their changing distances, angles, sizes, or slants.
+	#[default]
+	Objects,
+	/// All distances along the interpolation path are covered at a constant rate, meaning more time is spent traversing further distances.
+	Distances,
+	/// All angles of rotation between objects are covered at a constant rate, meaning more time is spent turning through larger angles.
+	Angles,
+	/// All sizes of expansion/contraction between objects are covered at a constant rate, meaning more time is spent scaling through larger (logarithmic) changes in size.
+	Sizes,
+	/// All slants (changes in skew angle) between objects are covered at a constant rate, meaning more time is spent skewing through larger changes in slant.
+	Slants,
+}