Add the Reverse parameter to the Morph node

Author: Keavon

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

@@ -178,6 +178,7 @@ impl<'a> ModifyInputsContext<'a> {
 				Some(NodeInput::value(TaggedValue::Graphic(Default::default()), true)),
 				Some(NodeInput::value(TaggedValue::F64(0.5), false)),
 				None,
+				None,
 				Some(NodeInput::value(TaggedValue::Vector(Default::default()), false)),
 			]);
 

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

@@ -559,12 +559,13 @@ 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, distribution, path)
+							// 15: Morph (content, progression, reverse, distribution, path)
 							DocumentNode {
 								implementation: DocumentNodeImplementation::ProtoNode(vector::morph::IDENTIFIER),
 								inputs: vec![
 									NodeInput::import(generic!(T), 0),
 									NodeInput::node(NodeId(14), 0),
+									NodeInput::value(TaggedValue::Bool(false), false),
 									NodeInput::import(concrete!(vector::misc::InterpolationDistribution), 1),
 									NodeInput::import(generic!(T), 2),
 								],

editor/src/messages/portfolio/document_migration.rs

@@ -1669,19 +1669,16 @@ 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 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 == 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 {
+	// The new v3 signature has 5 inputs, so 3 or 4 inputs can only be old v1 versions.
+	if reference == DefinitionIdentifier::ProtoNode(graphene_std::vector::morph::IDENTIFIER) && (inputs_count == 3 || inputs_count == 4) {
 		// 3 inputs - old signature (#3405):
 		// async fn morph(_: impl Ctx, source: Table<Vector>, #[expose] target: Table<Vector>, #[default(0.5)] time: Fraction) -> Table<Vector> { ... }
 		//
 		// 4 inputs - even older signature (commit 80b8df8d4298b6669f124b929ce61bfabfc44e41):
 		// 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, content: I, progression: Progression, distribution: InterpolationDistribution, path: Table<Vector>) -> Table<Vector> { ... }
+		// async fn morph<I: IntoGraphicTable>(_: impl Ctx, content: I, progression: Progression, reverse: bool, 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)?;
@@ -1720,7 +1717,7 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 		inputs_count = 3;
 	}
 
-	// Migrate from the v2 "Morph" node (2 inputs: content, progression) to the v3 "Morph" node (3 inputs: content, progression, path).
+	// Migrate from the v2 "Morph" node (2 inputs: content, progression) to the v3 "Morph" node (5 inputs: content, progression, reverse, distribution, path).
 	// The old progression used integer part for pair selection (range 0..N-1 where N is the number of content objects).
 	// The new progression uses fractional 0..1 for euclidean traversal through all objects.
 	// We insert Count Elements → Subtract 1 → Divide to remap: new_progression = old_progression / max(N - 1, 1).

node-graph/nodes/vector/src/vector_nodes.rs

@@ -1949,6 +1949,8 @@ async fn morph<I: IntoGraphicTable + 'n + Send + Clone>(
 	content: I,
 	/// The fractional part [0, 1) traverses the morph uniformly along the path. If the control path has multiple subpaths, each added integer selects the next subpath.
 	progression: Progression,
+	/// Swap the direction of the progression between objects or along the control path.
+	reverse: bool,
 	/// The parameter of change that influences the interpolation speed between each object. Equal slices in this parameter correspond to the rate of progression through the morph. This must be set to a parameter that changes.
 	///
 	/// "Objects" morphs through each group element at an equal rate. "Distances" keeps constant speed with time between objects proportional to their distances. "Angles" keeps constant rotational speed. "Sizes" keeps constant shrink/growth speed. "Slants" keeps constant shearing angle speed.
@@ -2102,6 +2104,7 @@ async fn morph<I: IntoGraphicTable + 'n + Send + Clone>(
 	// Select which subpath to use based on the integer part of progression (like the 'Position on Path' node)
 	let progression = progression.max(0.);
 	let subpath_count = control_bezpaths.len() as f64;
+	let progression = if reverse { subpath_count - progression } else { progression };
 	let clamped_progression = progression.clamp(0., subpath_count);
 	let subpath_index = if clamped_progression >= subpath_count { subpath_count - 1. } else { clamped_progression } as usize;
 	let fractional_progression = if clamped_progression >= subpath_count { 1. } else { clamped_progression.fract() };
@@ -3023,7 +3026,7 @@ mod test {
 		second_rectangle.transform *= DAffine2::from_translation((-100., -100.).into());
 		rectangles.push(second_rectangle);
 
-		let morphed = super::morph(Footprint::default(), rectangles, 0.5, InterpolationDistribution::default(), Table::default()).await;
+		let morphed = super::morph(Footprint::default(), rectangles, 0.5, false, InterpolationDistribution::default(), Table::default()).await;
 		let row = morphed.iter().next().unwrap();
 		// Geometry stays in local space (original rectangle coordinates)
 		assert_eq!(