Filter transform instances with 'Transform Selection' node

node-graph/gcore/src/lib.rs

@@ -21,6 +21,7 @@ pub mod raster;
 pub mod raster_types;
 pub mod registry;
 pub mod render_complexity;
+pub mod selection;
 pub mod structural;
 pub mod table;
 pub mod text;

node-graph/gcore/src/selection.rs

@@ -0,0 +1,61 @@
+use crate::{Ctx, ExtractIndex};
+
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize, Hash, dyn_any::DynAny, Default)]
+pub enum IndexOperationFilter {
+	Range(Vec<core::ops::RangeInclusive<usize>>),
+	#[default]
+	All,
+}
+
+impl IndexOperationFilter {
+	pub fn contains(&self, index: usize) -> bool {
+		match self {
+			Self::Range(range) => range.iter().any(|range| range.contains(&index)),
+			Self::All => true,
+		}
+	}
+}
+
+impl From<Vec<core::ops::RangeInclusive<usize>>> for IndexOperationFilter {
+	fn from(values: Vec<core::ops::RangeInclusive<usize>>) -> Self {
+		Self::Range(values)
+	}
+}
+
+impl From<core::ops::RangeInclusive<usize>> for IndexOperationFilter {
+	fn from(value: core::ops::RangeInclusive<usize>) -> Self {
+		Self::Range(vec![value])
+	}
+}
+
+impl core::fmt::Display for IndexOperationFilter {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::All => {
+				write!(f, "*")?;
+			}
+			Self::Range(range) => {
+				let mut started = false;
+				for value in range {
+					if started {
+						write!(f, ", ")?;
+					}
+					started = true;
+					if value.start() == value.end() {
+						write!(f, "{}", value.start())?;
+					} else {
+						write!(f, "{}..={}", value.start(), value.end())?;
+					}
+				}
+			}
+		}
+
+		Ok(())
+	}
+}
+
+#[node_macro::node(category("Filtering"), path(graphene_core::vector))]
+async fn evaluate_index_operation_filter(ctx: impl Ctx + ExtractIndex, filter: IndexOperationFilter) -> bool {
+	let index = ctx.try_index().and_then(|indexes| indexes.last().copied()).unwrap_or_default();
+	filter.contains(index)
+}

node-graph/gcore/src/transform_nodes.rs

@@ -1,11 +1,89 @@
 use crate::raster_types::{CPU, GPU, Raster};
 use crate::table::Table;
-use crate::transform::{ApplyTransform, Footprint, Transform};
+use crate::transform::{ApplyTransform, Footprint, Transform, TransformMut};
 use crate::vector::Vector;
 use crate::{CloneVarArgs, Context, Ctx, ExtractAll, Graphic, OwnedContextImpl};
 use core::f64;
 use glam::{DAffine2, DVec2};
 
+/// An updated version of the transform node supporting selecting which instances/rows are transformed
+#[node_macro::node(category(""))]
+async fn transform_two<T: ApplyTransform2>(
+	ctx: impl Ctx + CloneVarArgs + ExtractAll,
+	#[implementations(
+		Context -> DAffine2,
+		Context -> DVec2,
+		Context -> Table<Graphic>,
+		Context -> Table<Vector>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<Raster<GPU>>,
+	)]
+	value: impl Node<Context<'static>, Output = T>,
+	translate: DVec2,
+	rotate: f64,
+	scale: DVec2,
+	skew: DVec2,
+	selection: impl Node<Context<'static>, Output = bool>,
+) -> 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();
+
+	let mut transform_target = {
+		let mut new_ctx = OwnedContextImpl::from(ctx.clone());
+		if let Some(mut footprint) = footprint {
+			footprint.apply_transform(&matrix);
+			new_ctx = new_ctx.with_footprint(footprint);
+		}
+		value.eval(new_ctx.into_context()).await
+	};
+
+	transform_target.apply_transformation(matrix, &ctx, selection).await;
+
+	transform_target
+}
+
+/// A trait facilitating applying transforms with a particular selection field.
+trait ApplyTransform2 {
+	async fn apply_transformation<'n>(&mut self, matrix: DAffine2, ctx: &(impl Ctx + ExtractAll + CloneVarArgs), selection: &'n impl crate::Node<'n, Context<'n>, Output = impl Future<Output = bool>>);
+}
+
+/// Implementations of applying transforms for a table that implement the filtering based on the selection field.
+impl<T> ApplyTransform2 for Table<T> {
+	async fn apply_transformation<'n>(
+		&mut self,
+		matrix: DAffine2,
+		ctx: &(impl Ctx + ExtractAll + CloneVarArgs),
+		selection: &'n impl crate::Node<'n, Context<'n>, Output = impl Future<Output = bool>>,
+	) {
+		for (index, row) in self.iter_mut().enumerate() {
+			let new_ctx = OwnedContextImpl::from(ctx.clone()).with_index(index);
+
+			let should_eval = selection.eval(new_ctx.into_context()).await;
+			if should_eval {
+				info!("Applying to {index}");
+				*row.transform = matrix * *row.transform;
+			} else {
+				info!("Skipping index {index}");
+			}
+		}
+	}
+}
+
+/// An implementation for a non-table which ignores the selection
+impl<T: TransformMut> ApplyTransform2 for T {
+	async fn apply_transformation<'n>(&mut self, matrix: DAffine2, _: &(impl Ctx + ExtractAll + CloneVarArgs), _: &'n impl crate::Node<'n, Context<'n>, Output = impl Future<Output = bool>>) {
+		*self.transform_mut() = matrix * self.transform();
+	}
+}
+
+/// An implementation for a point which ignores the selection
+impl ApplyTransform2 for DVec2 {
+	async fn apply_transformation<'n>(&mut self, matrix: DAffine2, _: &(impl Ctx + ExtractAll + CloneVarArgs), _: &'n impl crate::Node<'n, Context<'n>, Output = impl Future<Output = bool>>) {
+		*self = matrix.transform_point2(*self);
+	}
+}
+
 #[node_macro::node(category(""))]
 async fn transform<T: ApplyTransform + 'n + 'static>(
 	ctx: impl Ctx + CloneVarArgs + ExtractAll,

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

@@ -9,6 +9,7 @@ use graphene_brush::brush_cache::BrushCache;
 use graphene_brush::brush_stroke::BrushStroke;
 use graphene_core::raster::Image;
 use graphene_core::raster_types::{CPU, Raster};
+use graphene_core::selection::IndexOperationFilter;
 use graphene_core::table::Table;
 use graphene_core::transform::ReferencePoint;
 use graphene_core::uuid::NodeId;
@@ -246,6 +247,7 @@ tagged_value! {
 	CentroidType(graphene_core::vector::misc::CentroidType),
 	BooleanOperation(graphene_path_bool::BooleanOperation),
 	TextAlign(graphene_core::text::TextAlign),
+	IndexOperationFilter(IndexOperationFilter),
 }
 
 impl TaggedValue {

node-graph/graphene-cli/src/main.rs

@@ -187,6 +187,8 @@ fn compile_graph(document_string: String, editor_api: Arc<WasmEditorApi>) -> Res
 	let substitutions = preprocessor::generate_node_substitutions();
 	preprocessor::expand_network(&mut network, &substitutions);
 
+	preprocessor::evaluate_index_operation_filter(&mut network);
+
 	let wrapped_network = wrap_network_in_scope(network.clone(), editor_api);
 
 	let compiler = Compiler {};

node-graph/preprocessor/src/lib.rs

@@ -24,6 +24,36 @@ pub fn expand_network(network: &mut NodeNetwork, substitutions: &HashMap<ProtoNo
 	}
 }
 
+/// Referencing the TaggedValue::IndexOperationFilter will expand to a node that contains the evaluate_index_operation_filter
+pub fn evaluate_index_operation_filter(network: &mut NodeNetwork) {
+	let mut new_nodes = Vec::new();
+	for node in network.nodes.values_mut() {
+		for input in &mut node.inputs {
+			if !matches!(input.as_value(), Some(TaggedValue::IndexOperationFilter(_)),) {
+				continue;
+			}
+			let node_id = NodeId::new();
+			let range_input = std::mem::replace(input, NodeInput::node(node_id, 0));
+			new_nodes.push((node_id, range_input));
+		}
+		match &mut node.implementation {
+			DocumentNodeImplementation::Network(node_network) => evaluate_index_operation_filter(node_network),
+			_ => {}
+		}
+	}
+	for (id, range_input) in new_nodes {
+		network.nodes.insert(
+			id,
+			DocumentNode {
+				inputs: vec![range_input],
+				manual_composition: Some(concrete!(Context)),
+				implementation: DocumentNodeImplementation::ProtoNode(graphene_core::selection::evaluate_index_operation_filter::IDENTIFIER),
+				..Default::default()
+			},
+		);
+	}
+}
+
 pub fn generate_node_substitutions() -> HashMap<ProtoNodeIdentifier, DocumentNode> {
 	let mut custom = HashMap::new();
 	let node_registry = graphene_core::registry::NODE_REGISTRY.lock().unwrap();