Potentially solve outstanding issues

Author: Keavon

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

@@ -1196,55 +1196,29 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 			description: Cow::Borrowed("Generates customizable procedural noise patterns."),
 			properties: None,
 		},
-		DocumentNodeDefinition {
-			identifier: "Split Channels",
-			category: "Raster: Channels",
-			node_template: NodeTemplate {
-				document_node: DocumentNode {
-					implementation: DocumentNodeImplementation::ProtoNode(raster_nodes::adjustments::split_channels::IDENTIFIER),
-					inputs: vec![NodeInput::value(TaggedValue::Raster(Default::default()), true)],
-					call_argument: generic!(T),
-					..Default::default()
-				},
-				persistent_node_metadata: DocumentNodePersistentMetadata {
-					input_metadata: vec![("Image", "TODO").into()],
-					network_metadata: None,
-					..Default::default()
-				},
-			},
-			description: Cow::Borrowed("TODO"),
-			properties: None,
-		},
-		DocumentNodeDefinition {
-			identifier: "Split Vec2",
-			category: "Math: Vector",
-			node_template: NodeTemplate {
-				document_node: DocumentNode {
-					implementation: DocumentNodeImplementation::ProtoNode(extract_xy::split_vec_2::IDENTIFIER),
-					inputs: vec![NodeInput::value(TaggedValue::DVec2(DVec2::ZERO), true)],
-					call_argument: generic!(T),
-					..Default::default()
-				},
-				persistent_node_metadata: DocumentNodePersistentMetadata {
-					input_metadata: vec![("Vec2", "TODO").into()],
-					network_metadata: None,
-					..Default::default()
-				},
-			},
-			description: Cow::Borrowed(
-				"Decomposes the X and Y components of a vec2.\n\
-				\n\
-				The inverse of this node is \"Vec2 Value\", which can have either or both its X and Y parameters exposed as graph inputs.",
-			),
-			properties: None,
-		},
-		//TODO: Remove this and just use the proto node definition directly
+		// TODO: Remove this and just use the proto node definition directly
 		DocumentNodeDefinition {
 			identifier: "Brush",
 			category: "Raster",
 			node_template: NodeTemplate {
 				document_node: DocumentNode {
-					implementation: DocumentNodeImplementation::ProtoNode(brush::brush::brush::IDENTIFIER),
+					implementation: DocumentNodeImplementation::Network(NodeNetwork {
+						exports: vec![NodeInput::node(NodeId(0), 0)],
+						nodes: vec![DocumentNode {
+							inputs: vec![
+								NodeInput::import(concrete!(Table<Raster<CPU>>), 0),
+								NodeInput::import(concrete!(Vec<brush::brush_stroke::BrushStroke>), 1),
+								NodeInput::import(concrete!(BrushCache), 2),
+							],
+							implementation: DocumentNodeImplementation::ProtoNode(brush::brush::brush::IDENTIFIER),
+							..Default::default()
+						}]
+						.into_iter()
+						.enumerate()
+						.map(|(id, node)| (NodeId(id as u64), node))
+						.collect(),
+						..Default::default()
+					}),
 					inputs: vec![
 						NodeInput::value(TaggedValue::Raster(Default::default()), true),
 						NodeInput::value(TaggedValue::BrushStrokes(Vec::new()), false),

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

@@ -1,6 +1,10 @@
 use super::DocumentNodeDefinition;
 use crate::messages::portfolio::document::node_graph::document_node_definitions::DefinitionIdentifier;
-use crate::messages::portfolio::document::utility_types::network_interface::{DocumentNodePersistentMetadata, InputMetadata, NodeTemplate, WidgetOverride};
+use crate::messages::portfolio::document::utility_types::network_interface::{
+	DocumentNodeMetadata, DocumentNodePersistentMetadata, InputMetadata, NodeNetworkMetadata, NodeNetworkPersistentMetadata, NodeTemplate, NodeTypePersistentMetadata, WidgetOverride,
+};
+use graph_craft::ProtoNodeIdentifier;
+use graph_craft::document::value::TaggedValue;
 use graph_craft::document::*;
 use graphene_std::registry::*;
 use graphene_std::*;
@@ -36,7 +40,7 @@ pub(super) fn post_process_nodes(custom: Vec<DocumentNodeDefinition>) -> HashMap
 			description,
 			properties,
 			context_features,
-			output_fields: _,
+			output_fields,
 		} = metadata;
 
 		let Some(implementations) = &node_registry.get(id) else { continue };
@@ -72,6 +76,12 @@ pub(super) fn post_process_nodes(custom: Vec<DocumentNodeDefinition>) -> HashMap
 								RegistryWidgetOverride::Custom(str) => InputMetadata::with_name_description_override(f.name, f.description, WidgetOverride::Custom(str.to_string())),
 							})
 							.collect(),
+						output_names: if output_fields.is_empty() {
+							Vec::new()
+						} else {
+							// A leading field with empty node_path is a hidden primary output placeholder, included as ""
+							output_fields.iter().map(|field| field.name.to_string()).collect()
+						},
 						locked: false,
 						..Default::default()
 					},
@@ -82,6 +92,120 @@ pub(super) fn post_process_nodes(custom: Vec<DocumentNodeDefinition>) -> HashMap
 			},
 		);
 	}
+	drop(node_registry);
+
+	// For nodes with destructured outputs, build a Network implementation so the UI knows about
+	// the multiple output connectors. The network contains the source proto node plus one extractor
+	// proto node per output field, wired directly (no identity pass-through or memo nodes).
+	let destructured_info = {
+		let node_metadata_registry = NODE_METADATA.lock().unwrap();
+		let node_registry = NODE_REGISTRY.lock().unwrap();
+		definitions_map
+			.iter()
+			.filter_map(|(_, def)| {
+				let DocumentNodeImplementation::ProtoNode(id) = &def.node_template.document_node.implementation else {
+					return None;
+				};
+				let meta = node_metadata_registry.get(id)?;
+				if meta.output_fields.is_empty() {
+					return None;
+				}
+
+				let has_hidden_primary = meta.output_fields.first().is_some_and(|f| f.node_path.is_empty());
+				let real_fields = if has_hidden_primary { &meta.output_fields[1..] } else { meta.output_fields };
+
+				let extractors: Vec<_> = real_fields
+					.iter()
+					.filter_map(|field| {
+						let extractor_id = ProtoNodeIdentifier::with_owned_string(field.node_path.to_string());
+						let call_arg = node_registry.get(&extractor_id).and_then(|impls| impls.first().map(|(_, node_io)| node_io.call_argument.clone()))?;
+						Some((extractor_id, call_arg))
+					})
+					.collect();
+
+				if extractors.is_empty() {
+					return None;
+				}
+
+				Some((id.clone(), has_hidden_primary, extractors))
+			})
+			.collect::<Vec<_>>()
+	};
+
+	// Build the definition-time network for each destructured node
+	for (id, has_hidden_primary, extractors) in &destructured_info {
+		let identifier = DefinitionIdentifier::ProtoNode(id.clone());
+		let Some(definition) = definitions_map.get_mut(&identifier) else { continue };
+
+		// The source node runs the original proto node (e.g. split_vec2)
+		let source_node_id = NodeId(0);
+		let source_node = DocumentNode {
+			inputs: definition
+				.node_template
+				.document_node
+				.inputs
+				.iter()
+				.enumerate()
+				.map(|(i, input)| NodeInput::import(input.ty(), i))
+				.collect(),
+			implementation: DocumentNodeImplementation::ProtoNode(id.clone()),
+			call_argument: definition.node_template.document_node.call_argument.clone(),
+			..Default::default()
+		};
+
+		// One extractor node per output field, each taking input from the source node
+		let mut inner_nodes: Vec<(NodeId, DocumentNode)> = vec![(source_node_id, source_node)];
+
+		let mut exports = if *has_hidden_primary { vec![NodeInput::value(TaggedValue::None, false)] } else { Vec::new() };
+
+		for (i, (extractor_id, call_arg)) in extractors.iter().enumerate() {
+			let extractor_node_id = NodeId((i + 1) as u64);
+			inner_nodes.push((
+				extractor_node_id,
+				DocumentNode {
+					inputs: vec![NodeInput::node(source_node_id, 0)],
+					implementation: DocumentNodeImplementation::ProtoNode(extractor_id.clone()),
+					call_argument: call_arg.clone(),
+					..Default::default()
+				},
+			));
+			exports.push(NodeInput::node(extractor_node_id, 0));
+		}
+
+		// Generate network metadata for each inner node
+		let node_metadata: HashMap<_, _> = inner_nodes
+			.iter()
+			.map(|(nid, _)| {
+				(
+					*nid,
+					DocumentNodeMetadata {
+						persistent_metadata: DocumentNodePersistentMetadata {
+							node_type_metadata: NodeTypePersistentMetadata::node(glam::IVec2::ZERO),
+							..Default::default()
+						},
+						..Default::default()
+					},
+				)
+			})
+			.collect();
+
+		definition.node_template.persistent_node_metadata.network_metadata = Some(NodeNetworkMetadata {
+			persistent_metadata: NodeNetworkPersistentMetadata {
+				reference: Some(definition.identifier.to_string()),
+				node_metadata,
+				..Default::default()
+			},
+			..Default::default()
+		});
+		definition.node_template.persistent_node_metadata.display_name = definition.identifier.to_string();
+
+		definition.node_template.document_node.implementation = DocumentNodeImplementation::Network(NodeNetwork {
+			exports,
+			nodes: inner_nodes.into_iter().collect(),
+			scope_injections: Default::default(),
+			generated: false,
+		});
+	}
 
 	// If any protonode does not have metadata then set its display name to its identifier string
 	for definition in definitions_map.values_mut() {
@@ -93,6 +217,17 @@ pub(super) fn post_process_nodes(custom: Vec<DocumentNodeDefinition>) -> HashMap
 		}
 	}
 
+	// Fill in inner proto node metadata for the destructured output network definitions
+	for (id, _, _) in destructured_info {
+		let identifier = DefinitionIdentifier::ProtoNode(id);
+		// We need to split the borrow: extract the node and metadata, traverse, then put metadata back
+		let Some(definition) = definitions_map.get(&identifier) else { continue };
+		let document_node = definition.node_template.document_node.clone();
+		let mut persistent_metadata = definition.node_template.persistent_node_metadata.clone();
+		traverse_node(&document_node, &mut persistent_metadata, &definitions_map);
+		definitions_map.get_mut(&identifier).unwrap().node_template.persistent_node_metadata = persistent_metadata;
+	}
+
 	// Add the rest of the network nodes to the map and add the metadata for their internal protonodes
 	for mut network_node in network_nodes {
 		traverse_node(&network_node.node_template.document_node, &mut network_node.node_template.persistent_node_metadata, &definitions_map);

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

@@ -405,7 +405,9 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 				{
 					return;
 				};
-				if let Some(DocumentNodeImplementation::Network(_)) = network_interface.implementation(&node_id, selection_network_path) {
+				if let Some(DocumentNodeImplementation::Network(network)) = network_interface.implementation(&node_id, selection_network_path)
+					&& !network.generated
+				{
 					responses.add(DocumentMessage::EnterNestedNetwork { node_id });
 				}
 			}

editor/src/node_graph_executor/runtime.rs

@@ -140,7 +140,14 @@ impl NodeRuntime {
 			node_graph_errors: Vec::new(),
 			monitor_nodes: Vec::new(),
 
-			substitutions: preprocessor::generate_node_substitutions(),
+			substitutions: {
+				// Exclude nodes with destructured outputs since their definition networks already contain the complete structure
+				let mut substitutions = preprocessor::generate_node_substitutions();
+				let node_metadata = graphene_std::registry::NODE_METADATA.lock().unwrap();
+				substitutions.retain(|id, _| node_metadata.get(id).is_none_or(|meta| meta.output_fields.is_empty()));
+				drop(node_metadata);
+				substitutions
+			},
 
 			thumbnail_renders: Default::default(),
 			vector_modify: Default::default(),

node-graph/node-macro/src/destruct.rs

@@ -31,6 +31,19 @@ pub fn derive(input: DeriveInput) -> syn::Result<TokenStream2> {
 		};
 
 		let ty = field.ty;
+
+		// A `()` field serves as a hidden primary output placeholder (analogous to `_: ()` for inputs)
+		if is_unit_type(&ty) {
+			output_fields.push(quote! {
+				#core_types::registry::StructField {
+					name: "",
+					node_path: "",
+					ty: #core_types::concrete!(()),
+				}
+			});
+			continue;
+		}
+
 		let output_name = parse_output_name(&field.attrs)?.unwrap_or_else(|| field_name.to_string().to_case(Case::Title));
 		let output_name_lit = LitStr::new(&output_name, field_name.span());
 
@@ -70,6 +83,10 @@ fn generate_extractor_node(core_types: &TokenStream2, fn_name: &syn::Ident, stru
 	}
 }
 
+fn is_unit_type(ty: &Type) -> bool {
+	matches!(ty, Type::Tuple(tuple) if tuple.elems.is_empty())
+}
+
 fn parse_output_name(attrs: &[syn::Attribute]) -> syn::Result<Option<String>> {
 	let mut output_name = None;
 

node-graph/nodes/gcore/src/extract_xy.rs

@@ -2,12 +2,7 @@ use core_types::Ctx;
 use dyn_any::DynAny;
 use glam::{DVec2, IVec2, UVec2};
 
-#[derive(Debug, Clone, DynAny, node_macro::Destruct)]
-pub struct SplitVec2Output {
-	pub x: f64,
-	pub y: f64,
-}
-
+// TODO: Remove `extract_xy` and `XY` once a migration converts old documents' Split Vec2 network nodes (which used Extract XY internally) to the new proto node form
 /// Obtains the X or Y component of a vec2.
 ///
 /// The inverse of this node is "Vec2 Value", which can have either or both its X and Y parameters exposed as graph inputs.
@@ -19,10 +14,24 @@ fn extract_xy<T: Into<DVec2>>(_: impl Ctx, #[implementations(DVec2, IVec2, UVec2
 	}
 }
 
+#[derive(Debug, Clone, DynAny, node_macro::Destruct)]
+pub struct SplitVec2Output {
+	pub primary: (),
+	pub x: f64,
+	pub y: f64,
+}
+
+/// Decomposes the X and Y components of a vec2.
+///
+/// The inverse of this node is "Vec2 Value", which can have either or both its X and Y parameters exposed as graph inputs.
 #[node_macro::node(name("Split Vec2"), category("Math: Vector"), deconstruct_output)]
 fn split_vec2<T: Into<DVec2>>(_: impl Ctx, #[implementations(DVec2, IVec2, UVec2)] vector: T) -> SplitVec2Output {
 	let vector = vector.into();
-	SplitVec2Output { x: vector.x, y: vector.y }
+	SplitVec2Output {
+		primary: (),
+		x: vector.x,
+		y: vector.y,
+	}
 }
 
 /// The X or Y component of a vec2.

node-graph/nodes/raster/src/adjustments.rs

@@ -21,6 +21,7 @@ use vector_types::GradientStops;
 #[cfg(feature = "std")]
 #[derive(Debug, Clone, dyn_any::DynAny, node_macro::Destruct)]
 pub struct SplitChannelsOutput {
+	pub primary: (),
 	pub red: Table<Raster<CPU>>,
 	pub green: Table<Raster<CPU>>,
 	pub blue: Table<Raster<CPU>>,
@@ -103,6 +104,7 @@ fn gamma_correction<T: Adjust<Color>>(
 	input
 }
 
+// TODO: Remove `extract_channel` and `RedGreenBlueAlpha` once a migration converts old documents' Split Channels network nodes (which used Extract Channel internally) to the new proto node form
 #[node_macro::node(category("Raster: Channels"), shader_node(PerPixelAdjust))]
 fn extract_channel<T: Adjust<Color>>(
 	_: impl Ctx,
@@ -131,6 +133,7 @@ fn extract_channel<T: Adjust<Color>>(
 #[node_macro::node(name("Split Channels"), category("Raster: Channels"), deconstruct_output)]
 fn split_channels(_: impl Ctx, input: Table<Raster<CPU>>) -> SplitChannelsOutput {
 	SplitChannelsOutput {
+		primary: (),
 		red: extract_channel((), input.clone(), RedGreenBlueAlpha::Red),
 		green: extract_channel((), input.clone(), RedGreenBlueAlpha::Green),
 		blue: extract_channel((), input.clone(), RedGreenBlueAlpha::Blue),