Filter transform instances

Author: 0HyperCube

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

@@ -1485,6 +1485,112 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			description: Cow::Borrowed("TODO"),
 			properties: None,
 		},
+		DocumentNodeDefinition {
+			identifier: "Transform2",
+			category: "Math: Transform",
+			node_template: NodeTemplate {
+				document_node: DocumentNode {
+					inputs: vec![
+						NodeInput::value(TaggedValue::DAffine2(DAffine2::default()), true),
+						NodeInput::value(TaggedValue::DVec2(DVec2::ZERO), false),
+						NodeInput::value(TaggedValue::F64(0.), false),
+						NodeInput::value(TaggedValue::DVec2(DVec2::ONE), false),
+						NodeInput::value(TaggedValue::DVec2(DVec2::ZERO), false),
+						NodeInput::value(TaggedValue::IndexOperationFilter((0..=1).into()), false),
+					],
+					implementation: DocumentNodeImplementation::Network(NodeNetwork {
+						exports: vec![NodeInput::node(NodeId(1), 0)],
+						nodes: [
+							DocumentNode {
+								inputs: vec![NodeInput::network(generic!(T), 0)],
+								implementation: DocumentNodeImplementation::ProtoNode(memo::monitor::IDENTIFIER),
+								manual_composition: Some(generic!(T)),
+								skip_deduplication: true,
+								..Default::default()
+							},
+							DocumentNode {
+								inputs: vec![
+									NodeInput::node(NodeId(0), 0),
+									NodeInput::network(concrete!(DVec2), 1),
+									NodeInput::network(concrete!(f64), 2),
+									NodeInput::network(concrete!(DVec2), 3),
+									NodeInput::network(concrete!(DVec2), 4),
+									NodeInput::network(fn_type!(Context, bool), 5),
+								],
+								manual_composition: Some(concrete!(Context)),
+								implementation: DocumentNodeImplementation::ProtoNode(transform_nodes::transform_two::IDENTIFIER),
+								..Default::default()
+							},
+						]
+						.into_iter()
+						.enumerate()
+						.map(|(id, node)| (NodeId(id as u64), node))
+						.collect(),
+						..Default::default()
+					}),
+					..Default::default()
+				},
+				persistent_node_metadata: DocumentNodePersistentMetadata {
+					network_metadata: Some(NodeNetworkMetadata {
+						persistent_metadata: NodeNetworkPersistentMetadata {
+							node_metadata: [
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Monitor".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(0, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Transform".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(7, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+							]
+							.into_iter()
+							.enumerate()
+							.map(|(id, node)| (NodeId(id as u64), node))
+							.collect(),
+							..Default::default()
+						},
+						..Default::default()
+					}),
+					input_metadata: vec![
+						("Value", "TODO").into(),
+						InputMetadata::with_name_description_override(
+							"Translation",
+							"TODO",
+							WidgetOverride::Vec2(Vec2InputSettings {
+								x: "X".to_string(),
+								y: "Y".to_string(),
+								unit: " px".to_string(),
+								..Default::default()
+							}),
+						),
+						InputMetadata::with_name_description_override("Rotation", "TODO", WidgetOverride::Custom("transform_rotation".to_string())),
+						InputMetadata::with_name_description_override(
+							"Scale",
+							"TODO",
+							WidgetOverride::Vec2(Vec2InputSettings {
+								x: "W".to_string(),
+								y: "H".to_string(),
+								unit: "x".to_string(),
+								..Default::default()
+							}),
+						),
+						InputMetadata::with_name_description_override("Skew", "TODO", WidgetOverride::Custom("transform_skew".to_string())),
+					],
+					output_names: vec!["Data".to_string()],
+					..Default::default()
+				},
+			},
+			description: Cow::Borrowed("TODO"),
+			properties: None,
+		},
 		DocumentNodeDefinition {
 			identifier: "Boolean Operation",
 			category: "Vector",

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

@@ -20,6 +20,7 @@ use graphene_std::raster::{
 	SelectiveColorChoice,
 };
 use graphene_std::raster_types::{CPU, GPU, RasterDataTable};
+use graphene_std::selection::IndexOperationFilter;
 use graphene_std::text::Font;
 use graphene_std::transform::{Footprint, ReferencePoint, Transform};
 use graphene_std::vector::VectorDataTable;
@@ -182,6 +183,7 @@ pub(crate) fn property_from_type(
 						// ==========================
 						Some(x) if x == TypeId::of::<Vec<f64>>() => array_of_number_widget(default_info, TextInput::default()).into(),
 						Some(x) if x == TypeId::of::<Vec<DVec2>>() => array_of_coordinates_widget(default_info, TextInput::default()).into(),
+						Some(x) if x == TypeId::of::<IndexOperationFilter>() => array_of_ranges(default_info, TextInput::default()).into(),
 						// ====================
 						// GRAPHICAL DATA TYPES
 						// ====================
@@ -754,6 +756,72 @@ pub fn array_of_coordinates_widget(parameter_widgets_info: ParameterWidgetsInfo,
 	widgets
 }
 
+pub fn array_of_ranges(parameter_widgets_info: ParameterWidgetsInfo, text_props: TextInput) -> Vec<WidgetHolder> {
+	let ParameterWidgetsInfo { document_node, node_id, index, .. } = parameter_widgets_info;
+
+	let mut widgets = start_widgets(parameter_widgets_info);
+
+	let from_string = |string: &str| {
+		let mut result = Vec::new();
+		let mut start: Option<usize> = None;
+		let mut number: Option<usize> = None;
+		let mut seen_continue = false;
+		for c in string.chars() {
+			if let Some(digit) = c.to_digit(10) {
+				if !seen_continue {
+					if let Some(start) = start.take() {
+						result.push(start..=start);
+					}
+				}
+				let mut value = number.unwrap_or_default();
+				value *= 10;
+				value += digit as usize;
+				number = Some(value);
+			} else {
+				if let Some(number) = number.take() {
+					if let Some(start) = start.take() {
+						result.push(start.min(number)..=start.max(number));
+					} else {
+						start = Some(number);
+					}
+					seen_continue = false;
+				}
+				if c == '=' || c == '-' || c == '.' {
+					seen_continue = true;
+				}
+			}
+		}
+		if let Some(number) = number.take() {
+			if let Some(start) = start.take() {
+				result.push(start.min(number)..=start.max(number));
+			} else {
+				result.push(number..=number);
+			}
+		}
+		if let Some(start) = start.take() {
+			result.push(start..=start);
+		}
+
+		Some(TaggedValue::IndexOperationFilter(result.into()))
+	};
+
+	let Some(document_node) = document_node else { return Vec::new() };
+	let Some(input) = document_node.inputs.get(index) else {
+		log::warn!("A widget failed to be built because its node's input index is invalid.");
+		return vec![];
+	};
+	if let Some(TaggedValue::IndexOperationFilter(x)) = &input.as_non_exposed_value() {
+		widgets.extend_from_slice(&[
+			Separator::new(SeparatorType::Unrelated).widget_holder(),
+			text_props
+				.value(x.to_string())
+				.on_update(optionally_update_value(move |x: &TextInput| from_string(&x.value), node_id, index))
+				.widget_holder(),
+		])
+	}
+	widgets
+}
+
 pub fn font_inputs(parameter_widgets_info: ParameterWidgetsInfo) -> (Vec<WidgetHolder>, Option<Vec<WidgetHolder>>) {
 	let ParameterWidgetsInfo { document_node, node_id, index, .. } = parameter_widgets_info;
 

editor/src/node_graph_executor/runtime.rs

@@ -228,6 +228,7 @@ impl NodeRuntime {
 
 	async fn update_network(&mut self, mut graph: NodeNetwork) -> Result<ResolvedDocumentNodeTypesDelta, String> {
 		preprocessor::expand_network(&mut graph, &self.substitutions);
+		preprocessor::evaluate_index_operation_filter(&mut graph);
 
 		let scoped_network = wrap_network_in_scope(graph, self.editor_api.clone());
 

node-graph/gcore/src/lib.rs

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

node-graph/gcore/src/selection.rs

@@ -0,0 +1,48 @@
+use crate::{Ctx, ExtractIndex};
+
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize, Hash, dyn_any::DynAny, Default)]
+pub struct IndexOperationFilter {
+	values: Vec<core::ops::RangeInclusive<usize>>,
+}
+
+impl IndexOperationFilter {
+	pub fn contains(&self, index: usize) -> bool {
+		self.values.iter().any(|range| range.contains(&index))
+	}
+}
+
+impl From<Vec<core::ops::RangeInclusive<usize>>> for IndexOperationFilter {
+	fn from(values: Vec<core::ops::RangeInclusive<usize>>) -> Self {
+		Self { values }
+	}
+}
+
+impl From<core::ops::RangeInclusive<usize>> for IndexOperationFilter {
+	fn from(value: core::ops::RangeInclusive<usize>) -> Self {
+		Self { values: vec![value] }
+	}
+}
+
+impl core::fmt::Display for IndexOperationFilter {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		let mut started = false;
+		for value in &self.values {
+			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

@@ -6,6 +6,44 @@ use crate::{CloneVarArgs, Context, Ctx, ExtractAll, GraphicGroupTable, OwnedCont
 use core::f64;
 use glam::{DAffine2, DVec2};
 
+#[node_macro::node(category(""))]
+async fn transform_two(
+	ctx: impl Ctx + CloneVarArgs + ExtractAll,
+	value: impl Node<Context<'static>, Output = VectorDataTable>,
+	translate: DVec2,
+	rotate: f64,
+	scale: DVec2,
+	skew: DVec2,
+	selection: impl Node<Context<'static>, Output = bool>,
+) -> VectorDataTable {
+	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
+	};
+
+	for (index, instance) in transform_target.instance_mut_iter().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}");
+			*instance.transform = matrix * *instance.transform;
+		} else {
+			info!("Skipping index {index}");
+		}
+	}
+
+	transform_target
+}
+
 #[node_macro::node(category(""))]
 async fn transform<T: ApplyTransform + 'n + 'static>(
 	ctx: impl Ctx + CloneVarArgs + ExtractAll,

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

@@ -8,6 +8,7 @@ use graphene_application_io::SurfaceFrame;
 use graphene_brush::brush_cache::BrushCache;
 use graphene_brush::brush_stroke::BrushStroke;
 use graphene_core::raster_types::CPU;
+use graphene_core::selection::IndexOperationFilter;
 use graphene_core::transform::ReferencePoint;
 use graphene_core::uuid::NodeId;
 use graphene_core::vector::style::Fill;
@@ -247,6 +248,8 @@ tagged_value! {
 	ReferencePoint(graphene_core::transform::ReferencePoint),
 	CentroidType(graphene_core::vector::misc::CentroidType),
 	BooleanOperation(graphene_path_bool::BooleanOperation),
+
+	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();