Add transform-related nodes to improve transformation abilities (#2893)

* Improve transformation abilities with transform-related nodes

* Fix Transform -> Merge and Transform -> Artboard connections

node-graph/gcore/src/graphic_element.rs

@@ -100,6 +100,11 @@ impl From<RasterDataTable<GPU>> for GraphicGroupTable {
 		Self::new(GraphicElement::RasterDataGPU(raster_data_table))
 	}
 }
+impl From<DAffine2> for GraphicGroupTable {
+	fn from(_: DAffine2) -> Self {
+		GraphicGroupTable::default()
+	}
+}
 
 /// The possible forms of graphical content held in a Vec by the `elements` field of [`GraphicElement`].
 #[derive(Clone, Debug, Hash, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
@@ -118,6 +123,12 @@ impl Default for GraphicElement {
 	}
 }
 
+impl From<DAffine2> for GraphicElement {
+	fn from(_: DAffine2) -> Self {
+		GraphicElement::default()
+	}
+}
+
 impl GraphicElement {
 	pub fn as_group(&self) -> Option<&GraphicGroupTable> {
 		match self {
@@ -351,6 +362,7 @@ async fn to_element<Data: Into<GraphicElement> + 'n>(
 	 	VectorDataTable,
 		RasterDataTable<CPU>,
 	 	RasterDataTable<GPU>,
+		DAffine2,
 	)]
 	data: Data,
 ) -> GraphicElement {
@@ -463,6 +475,7 @@ async fn to_artboard<Data: Into<GraphicGroupTable> + 'n>(
 		Context -> VectorDataTable,
 		Context -> RasterDataTable<CPU>,
 		Context -> RasterDataTable<GPU>,
+		Context -> DAffine2,
 	)]
 	contents: impl Node<Context<'static>, Output = Data>,
 	label: String,

node-graph/gcore/src/instances.rs

@@ -1,4 +1,5 @@
 use crate::AlphaBlending;
+use crate::transform::ApplyTransform;
 use crate::uuid::NodeId;
 use dyn_any::StaticType;
 use glam::DAffine2;
@@ -136,6 +137,20 @@ impl<T: Hash> Hash for Instances<T> {
 	}
 }
 
+impl<T> ApplyTransform for Instances<T> {
+	fn apply_transform(&mut self, modification: &DAffine2) {
+		for transform in &mut self.transform {
+			*transform *= *modification;
+		}
+	}
+
+	fn left_apply_transform(&mut self, modification: &DAffine2) {
+		for transform in &mut self.transform {
+			*transform = *modification * *transform;
+		}
+	}
+}
+
 impl<T: PartialEq> PartialEq for Instances<T> {
 	fn eq(&self, other: &Self) -> bool {
 		self.instance.len() == other.instance.len() && { self.instance.iter().zip(other.instance.iter()).all(|(a, b)| a == b) }

node-graph/gcore/src/transform.rs

@@ -6,14 +6,20 @@ use glam::{DAffine2, DMat2, DVec2};
 
 pub trait Transform {
 	fn transform(&self) -> DAffine2;
+
 	fn local_pivot(&self, pivot: DVec2) -> DVec2 {
 		pivot
 	}
+
 	fn decompose_scale(&self) -> DVec2 {
-		DVec2::new(
-			self.transform().transform_vector2((1., 0.).into()).length(),
-			self.transform().transform_vector2((0., 1.).into()).length(),
-		)
+		DVec2::new(self.transform().transform_vector2(DVec2::X).length(), self.transform().transform_vector2(DVec2::Y).length())
+	}
+
+	/// Requires that the transform does not contain any skew.
+	fn decompose_rotation(&self) -> f64 {
+		let rotation_matrix = (self.transform() * DAffine2::from_scale(self.decompose_scale().recip())).matrix2;
+		let rotation = -rotation_matrix.mul_vec2(DVec2::X).angle_to(DVec2::X);
+		if rotation == -0. { 0. } else { rotation }
 	}
 }
 
@@ -141,12 +147,21 @@ impl std::hash::Hash for Footprint {
 
 pub trait ApplyTransform {
 	fn apply_transform(&mut self, modification: &DAffine2);
+	fn left_apply_transform(&mut self, modification: &DAffine2);
 }
 impl<T: TransformMut> ApplyTransform for T {
 	fn apply_transform(&mut self, &modification: &DAffine2) {
 		*self.transform_mut() = self.transform() * modification
 	}
+	fn left_apply_transform(&mut self, &modification: &DAffine2) {
+		*self.transform_mut() = modification * self.transform()
+	}
 }
-impl ApplyTransform for () {
-	fn apply_transform(&mut self, &_modification: &DAffine2) {}
+impl ApplyTransform for DVec2 {
+	fn apply_transform(&mut self, modification: &DAffine2) {
+		*self = modification.transform_point2(*self);
+	}
+	fn left_apply_transform(&mut self, modification: &DAffine2) {
+		*self = modification.inverse().transform_point2(*self);
+	}
 }

node-graph/gcore/src/transform_nodes.rs

@@ -7,20 +7,22 @@ use core::f64;
 use glam::{DAffine2, DVec2};
 
 #[node_macro::node(category(""))]
-async fn transform<T: 'n + 'static>(
+async fn transform<T: ApplyTransform + 'n + 'static>(
 	ctx: impl Ctx + CloneVarArgs + ExtractAll,
 	#[implementations(
+		Context -> DAffine2,
+		Context -> DVec2,
 		Context -> VectorDataTable,
 		Context -> GraphicGroupTable,
 		Context -> RasterDataTable<CPU>,
 		Context -> RasterDataTable<GPU>,
 	)]
-	transform_target: impl Node<Context<'static>, Output = Instances<T>>,
+	value: impl Node<Context<'static>, Output = T>,
 	translate: DVec2,
 	rotate: f64,
 	scale: DVec2,
 	skew: DVec2,
-) -> Instances<T> {
+) -> T {
 	let matrix = DAffine2::from_scale_angle_translation(scale, rotate, translate) * DAffine2::from_cols_array(&[1., skew.y, skew.x, 1., 0., 0.]);
 
 	let footprint = ctx.try_footprint().copied();
@@ -31,11 +33,9 @@ async fn transform<T: 'n + 'static>(
 		ctx = ctx.with_footprint(footprint);
 	}
 
-	let mut transform_target = transform_target.eval(ctx.into_context()).await;
+	let mut transform_target = value.eval(ctx.into_context()).await;
 
-	for data_transform in transform_target.instance_mut_iter() {
-		*data_transform.transform = matrix * *data_transform.transform;
-	}
+	transform_target.left_apply_transform(&matrix);
 
 	transform_target
 }
@@ -52,6 +52,40 @@ fn replace_transform<Data, TransformInput: Transform>(
 	data
 }
 
+#[node_macro::node(category("Math: Transform"), path(graphene_core::vector))]
+async fn extract_transform<T>(
+	_: impl Ctx,
+	#[implementations(
+		GraphicGroupTable,
+		VectorDataTable,
+		RasterDataTable<CPU>,
+		RasterDataTable<GPU>,
+	)]
+	vector_data: Instances<T>,
+) -> DAffine2 {
+	vector_data.instance_ref_iter().next().map(|vector_data| *vector_data.transform).unwrap_or_default()
+}
+
+#[node_macro::node(category("Math: Transform"))]
+fn invert_transform(_: impl Ctx, transform: DAffine2) -> DAffine2 {
+	transform.inverse()
+}
+
+#[node_macro::node(category("Math: Transform"))]
+fn decompose_translation(_: impl Ctx, transform: DAffine2) -> DVec2 {
+	transform.translation
+}
+
+#[node_macro::node(category("Math: Transform"))]
+fn decompose_rotation(_: impl Ctx, transform: DAffine2) -> f64 {
+	transform.decompose_rotation()
+}
+
+#[node_macro::node(category("Math: Transform"))]
+fn decompose_scale(_: impl Ctx, transform: DAffine2) -> DVec2 {
+	transform.decompose_scale()
+}
+
 #[node_macro::node(category("Debug"))]
 async fn boundless_footprint<T: 'n + 'static>(
 	ctx: impl Ctx + CloneVarArgs + ExtractAll,

node-graph/gcore/src/vector/vector_data/modification.rs

@@ -418,7 +418,7 @@ impl Hash for VectorModification {
 	}
 }
 
-/// A node that applies a procedural modification to some [`VectorData`].
+/// Applies a diff modification to a vector path.
 #[node_macro::node(category(""))]
 async fn path_modify(_ctx: impl Ctx, mut vector_data: VectorDataTable, modification: Box<VectorModification>, node_path: Vec<NodeId>) -> VectorDataTable {
 	if vector_data.is_empty() {
@@ -437,6 +437,23 @@ async fn path_modify(_ctx: impl Ctx, mut vector_data: VectorDataTable, modificat
 	vector_data
 }
 
+/// Applies the vector path's local transformation to its geometry and resets it to the identity.
+#[node_macro::node(category("Vector"))]
+async fn apply_transform(_ctx: impl Ctx, mut vector_data: VectorDataTable) -> VectorDataTable {
+	for vector_data_instance in vector_data.instance_mut_iter() {
+		let vector_data = vector_data_instance.instance;
+		let transform = *vector_data_instance.transform;
+
+		for (_, point) in vector_data.point_domain.positions_mut() {
+			*point = transform.transform_point2(*point);
+		}
+
+		*vector_data_instance.transform = DAffine2::IDENTITY;
+	}
+
+	vector_data
+}
+
 // Do we want to enforce that all serialized/deserialized hashmaps are a vec of tuples?
 // TODO: Eventually remove this document upgrade code
 use serde::de::{SeqAccess, Visitor};

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

@@ -1874,7 +1874,7 @@ fn bevel_algorithm(mut vector_data: VectorData, vector_data_transform: DAffine2,
 		}
 
 		if segment_domain_length != sorted_segments.len() {
-			for i in 0..segment_domain_length as usize {
+			for i in 0..segment_domain_length {
 				if !sorted_segments.contains(&i) {
 					sorted_segments.push(i);
 				}

node-graph/gmath-nodes/src/lib.rs

@@ -1,6 +1,7 @@
-use glam::DVec2;
+use glam::{DAffine2, DVec2};
 use graphene_core::gradient::GradientStops;
-use graphene_core::registry::types::{Fraction, Percentage, TextArea};
+use graphene_core::registry::types::{Fraction, Percentage, PixelSize, TextArea};
+use graphene_core::transform::Footprint;
 use graphene_core::{Color, Ctx, num_traits};
 use log::warn;
 use math_parser::ast;
@@ -107,11 +108,11 @@ fn subtract<U: Sub<T>, T>(
 fn multiply<U: Mul<T>, T>(
 	_: impl Ctx,
 	/// The left-hand side of the multiplication operation.
-	#[implementations(f64, f32, u32, DVec2, f64, DVec2)]
+	#[implementations(f64, f32, u32, f64, DVec2, DVec2, DAffine2)]
 	multiplier: U,
 	/// The right-hand side of the multiplication operation.
 	#[default(1.)]
-	#[implementations(f64, f32, u32, DVec2, DVec2, f64)]
+	#[implementations(f64, f32, u32, DVec2, f64, DVec2, DAffine2)]
 	multiplicand: T,
 ) -> <U as Mul<T>>::Output {
 	multiplier * multiplicand
@@ -681,6 +682,16 @@ fn string_value(_: impl Ctx, _primary: (), string: TextArea) -> String {
 	string
 }
 
+/// Constructs a footprint value which may be set to any transformation of a unit square describing a render area, and a render resolution at least 1x1 integer pixels.
+#[node_macro::node(category("Value"))]
+fn footprint_value(_: impl Ctx, _primary: (), transform: DAffine2, #[default(100., 100.)] resolution: PixelSize) -> Footprint {
+	Footprint {
+		transform,
+		resolution: resolution.max(DVec2::ONE).as_uvec2(),
+		..Default::default()
+	}
+}
+
 #[node_macro::node(category("Math: Vector"))]
 fn dot_product(_: impl Ctx, vector_a: DVec2, vector_b: DVec2) -> f64 {
 	vector_a.dot(vector_b)

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

@@ -1,5 +1,5 @@
 use dyn_any::StaticType;
-use glam::{DVec2, IVec2, UVec2};
+use glam::{DAffine2, DVec2, IVec2, UVec2};
 use graph_craft::document::value::RenderOutput;
 use graph_craft::proto::{NodeConstructor, TypeErasedBox};
 use graphene_core::raster::color::Color;
@@ -52,6 +52,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => String]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => IVec2]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => DVec2]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => DAffine2]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => bool]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => f64]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => u32]),
@@ -166,7 +167,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 
 	for (id, entry) in graphene_core::registry::NODE_REGISTRY.lock().unwrap().iter() {
 		for (constructor, types) in entry.iter() {
-			map.entry(id.clone().into()).or_default().insert(types.clone(), *constructor);
+			map.entry(id.clone()).or_default().insert(types.clone(), *constructor);
 		}
 	}