diff --git a/document/format/src/layers.rs b/document/format/src/layers.rs new file mode 100644 index 00000000000..152383b5d2a --- /dev/null +++ b/document/format/src/layers.rs @@ -0,0 +1,113 @@ +//! Finds the path of every layer in a runtime network, once for each instance of the networks holding it. + +use std::collections::HashSet; + +use document_graph_storage::NodeMetadataEntry; +use graph_craft::document::{DocumentNodeImplementation, NetworkLocation, NodeId, NodeNetwork}; + +/// The path of every node its metadata marks as a layer. +pub fn layer_paths(network: &NodeNetwork, node_metadata: &[NodeMetadataEntry]) -> Vec> { + let layers: HashSet<(NetworkLocation, NodeId)> = node_metadata.iter().filter(|node| node.is_layer).map(|node| (node.network, node.local_id)).collect(); + + let mut layer_paths = Vec::new(); + for_each_network_instance(network, |network_path, nested| { + let Some(location) = network.locate(network_path) else { return }; + let nested_layers = nested.nodes.keys().filter(|node_id| layers.contains(&(location, **node_id))); + layer_paths.extend(nested_layers.map(|node_id| [network_path, &[*node_id]].concat())); + }); + layer_paths +} + +/// Visits every network with its path, once for each instance of it. +/// A definition is not entered again from inside itself. +pub fn for_each_network_instance(network: &NodeNetwork, mut visit: impl FnMut(&[NodeId], &NodeNetwork)) { + let mut stack = vec![(Vec::new(), Vec::new())]; + while let Some((network_path, enclosing_definitions)) = stack.pop() { + let Some(nested) = network.nested_network(&network_path) else { continue }; + visit(&network_path, nested); + + for (node_id, node) in &nested.nodes { + let mut enclosing_definitions = enclosing_definitions.clone(); + match node.implementation { + DocumentNodeImplementation::Definition(id) if enclosing_definitions.contains(&id) => continue, + DocumentNodeImplementation::Definition(id) => enclosing_definitions.push(id), + DocumentNodeImplementation::Network(_) => {} + _ => continue, + } + stack.push(([network_path.as_slice(), &[*node_id]].concat(), enclosing_definitions)); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use graph_craft::document::{DocumentNode, NetworkId}; + + const DEFINITION: NetworkId = NetworkId(9); + + fn node_metadata(network: NetworkLocation, local_id: u64, is_layer: bool) -> NodeMetadataEntry { + NodeMetadataEntry { + network, + local_id: NodeId(local_id), + position: None, + is_layer, + display_name: None, + locked: false, + pinned: false, + input_metadata: Vec::new(), + output_names: Vec::new(), + output_descriptions: Vec::new(), + } + } + + #[test] + fn a_layer_inside_a_definition_is_found_through_each_instance() { + let instance = DocumentNode { + implementation: DocumentNodeImplementation::Definition(DEFINITION), + ..Default::default() + }; + let definition = NodeNetwork { + nodes: [3, 4].map(|id| (NodeId(id), DocumentNode::default())).into_iter().collect(), + ..Default::default() + }; + let network = NodeNetwork { + nodes: [1, 2].map(|id| (NodeId(id), instance.clone())).into_iter().collect(), + definitions: [(DEFINITION, definition)].into_iter().collect(), + ..Default::default() + }; + let metadata = [(None, 1, true), (None, 2, false), (Some(DEFINITION), 3, true), (Some(DEFINITION), 4, false)]; + let metadata: Vec<_> = metadata.into_iter().map(|(location, local_id, is_layer)| node_metadata(location, local_id, is_layer)).collect(); + + let mut layer_paths = layer_paths(&network, &metadata); + layer_paths.sort(); + + assert_eq!(layer_paths, vec![vec![NodeId(1)], vec![NodeId(1), NodeId(3)], vec![NodeId(2), NodeId(3)]]); + } + + #[test] + fn a_definition_holding_itself_is_entered_once() { + let recursive = DocumentNode { + implementation: DocumentNodeImplementation::Definition(DEFINITION), + ..Default::default() + }; + let network = NodeNetwork { + nodes: [(NodeId(1), recursive.clone())].into_iter().collect(), + definitions: [( + DEFINITION, + NodeNetwork { + nodes: [(NodeId(2), recursive)].into_iter().collect(), + ..Default::default() + }, + )] + .into_iter() + .collect(), + ..Default::default() + }; + + let mut network_paths = Vec::new(); + for_each_network_instance(&network, |network_path, _| network_paths.push(network_path.to_vec())); + + assert_eq!(network_paths, vec![vec![], vec![NodeId(1)]]); + } +} diff --git a/document/format/src/lib.rs b/document/format/src/lib.rs index 0c758eb7218..b2a0be18af6 100644 --- a/document/format/src/lib.rs +++ b/document/format/src/lib.rs @@ -29,6 +29,8 @@ pub mod codec; pub mod error; pub mod export; pub mod io; +#[cfg(feature = "conversion")] +pub mod layers; pub mod layout; mod load; pub mod manifest; diff --git a/document/live/src/lib.rs b/document/live/src/lib.rs index 33c289b17af..6879d3949b9 100644 --- a/document/live/src/lib.rs +++ b/document/live/src/lib.rs @@ -3,9 +3,9 @@ use document_container::AnyContainer; use document_container::backends::memory::MemoryBackend; use document_format::{GddV1, GddV1Layout}; -use document_graph_storage::{NodeMetadataEntry, PeerId, UserId}; +use document_graph_storage::{PeerId, UserId}; use graph_craft::application_io::resource::ResourceHash; -use graph_craft::document::NodeNetwork; +use graph_craft::document::{NodeId, NodeNetwork}; use peer_transport::{Room, SyncTarget}; pub use document_format::Error as FormatError; @@ -97,10 +97,12 @@ impl LiveDocument { &mut self.gdd } - /// The document's runtime network, with the metadata of each of its nodes. - pub async fn network_with_metadata(&self) -> Result<(NodeNetwork, Vec), LiveError> { + /// The document's runtime network, with the path of every layer in it. + pub async fn network_with_layers(&self) -> Result<(NodeNetwork, Vec>), LiveError> { let declarations = self.gdd.declarations(&self.gdd).await; - Ok(self.gdd.registry().to_runtime_with_metadata(&declarations, self.gdd.blobs())?) + let (network, node_metadata) = self.gdd.registry().to_runtime_with_metadata(&declarations, self.gdd.blobs())?; + let layers = document_format::layers::layer_paths(&network, &node_metadata); + Ok((network, layers)) } pub fn leave(&mut self) { diff --git a/document/loader/src/lib.rs b/document/loader/src/lib.rs index 066c5698bb3..0c578081268 100644 --- a/document/loader/src/lib.rs +++ b/document/loader/src/lib.rs @@ -5,7 +5,8 @@ use document_container::archive::ArchiveFormat; use document_container::backends::memory::MemoryBackend; use document_format::{GddV1, GddV1Layout}; use document_graph_storage::{NetworkMetadataEntry, NodeMetadataEntry}; -use graph_craft::document::NodeNetwork; +use graph_craft::document::{DocumentNodeImplementation, NodeId, NodeNetwork}; +use std::collections::HashMap; use std::error::Error; use std::path::Path; @@ -17,6 +18,8 @@ use migration_nodes as _; /// A document's runtime network, with the file it was opened from. pub struct LoadedDocument { pub network: NodeNetwork, + /// The path of every layer in `network`, once for each instance of the networks holding it. + pub layers: Vec>, pub origin: DocumentOrigin, } @@ -58,9 +61,13 @@ pub async fn open_document(path: &Path) -> Result let named_gdd = path.extension().is_some_and(|extension| extension.eq_ignore_ascii_case("gdd")); if !named_gdd && ArchiveFormat::detect(&bytes).is_none() { let document_string = String::from_utf8(bytes).map_err(|error| format!("Document {} is neither a .gdd archive nor text: {error}", path.display()))?; - let network = legacy_network(&document_string).map_err(|error| format!("Failed to parse legacy document {}: {error}", path.display()))?; + let parse_error = |error| format!("Failed to parse legacy document {}: {error}", path.display()); + let document: serde_json::Value = serde_json::from_str(&document_string).map_err(parse_error)?; + let network = legacy_network(&document).map_err(parse_error)?; + let layers = legacy_layer_paths(&network, &document); return Ok(LoadedDocument { network, + layers, origin: DocumentOrigin::Legacy(document_string), }); } @@ -68,14 +75,118 @@ pub async fn open_document(path: &Path) -> Result let gdd = open_gdd(&bytes).await?; let declarations = gdd.declarations(&gdd).await; let (network, nodes, networks) = gdd.registry().to_runtime_with_full_metadata(&declarations, gdd.blobs())?; + let layers = document_format::layers::layer_paths(&network, &nodes); Ok(LoadedDocument { network, + layers, origin: DocumentOrigin::Gdd { gdd: Box::new(gdd), nodes, networks }, }) } -fn legacy_network(document_string: &str) -> Result { - let document: serde_json::Value = serde_json::from_str(document_string)?; +fn legacy_network(document: &serde_json::Value) -> Result { let network = document["network_interface"]["network"].to_string(); serde_json::from_str(&network) } + +/// The path of every node a legacy document's metadata marks as a layer. +fn legacy_layer_paths(network: &NodeNetwork, document: &serde_json::Value) -> Vec> { + let mut layer_paths = Vec::new(); + document_format::layers::for_each_network_instance(network, |network_path, _| { + let Some(network_metadata) = legacy_network_metadata(network, document, network_path) else { + return; + }; + let is_layer = |node_metadata: &serde_json::Value| node_metadata["node_type_metadata"]["Layer"].is_object(); + let layers = legacy_node_metadata(network_metadata).into_iter().filter(|(_, node_metadata)| is_layer(node_metadata)); + layer_paths.extend(layers.map(|(node_id, _)| [network_path, &[node_id]].concat())); + }); + layer_paths +} + +/// The metadata of the network at this path in a legacy document. +/// Older documents keep a held network's metadata inside its node's metadata, newer ones keep a definition's in a table. +fn legacy_network_metadata<'a>(network: &NodeNetwork, document: &'a serde_json::Value, network_path: &[NodeId]) -> Option<&'a serde_json::Value> { + let document_network_metadata = &document["network_interface"]["network_metadata"]; + let definitions = &document_network_metadata["persistent_metadata"]["definitions"]; + + let mut current = network; + let mut network_metadata = document_network_metadata; + for node_id in network_path { + let node = current.nodes.get(node_id)?; + network_metadata = match node.implementation { + DocumentNodeImplementation::Definition(id) => &definitions[id.0.to_string()], + DocumentNodeImplementation::Network(_) => &legacy_node_metadata(network_metadata).remove(node_id)?["network_metadata"], + _ => return None, + }; + current = network.implementation_network(&node.implementation)?; + } + + Some(network_metadata) +} + +/// The metadata of each node in a legacy network, by ID. +fn legacy_node_metadata(network_metadata: &serde_json::Value) -> HashMap { + let entries = network_metadata["persistent_metadata"]["node_metadata"].as_array().into_iter().flatten(); + entries.filter_map(|entry| Some((NodeId(entry[0].as_u64()?), &entry[1]["persistent_metadata"]))).collect() +} + +#[cfg(test)] +mod tests { + use super::*; + use graph_craft::document::{DocumentNode, NetworkId}; + + fn node(implementation: DocumentNodeImplementation) -> DocumentNode { + DocumentNode { implementation, ..Default::default() } + } + + /// A network holding the nodes 3 and 4. + fn inner_network() -> NodeNetwork { + NodeNetwork { + nodes: [3, 4].map(|id| (NodeId(id), DocumentNode::default())).into_iter().collect(), + ..Default::default() + } + } + + fn sorted_legacy_layer_paths(network: &NodeNetwork, document: &str) -> Vec> { + let document = serde_json::from_str(document).expect("The test document should be valid JSON"); + let mut layer_paths = legacy_layer_paths(network, &document); + layer_paths.sort(); + layer_paths + } + + #[test] + fn a_layer_inside_a_definition_is_found_through_each_instance() { + let definition = NetworkId(9); + let network = NodeNetwork { + nodes: [1, 2].map(|id| (NodeId(id), node(DocumentNodeImplementation::Definition(definition)))).into_iter().collect(), + definitions: [(definition, inner_network())].into_iter().collect(), + ..Default::default() + }; + let document = r#"{ "network_interface": { "network_metadata": { "persistent_metadata": { + "node_metadata": [[1, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [2, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]], + "definitions": { "9": { "persistent_metadata": { + "node_metadata": [[3, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [4, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]] + } } } + } } } }"#; + + let expected = vec![vec![NodeId(1)], vec![NodeId(1), NodeId(3)], vec![NodeId(2), NodeId(3)]]; + assert_eq!(sorted_legacy_layer_paths(&network, document), expected); + } + + #[test] + fn a_layer_inside_a_held_network_is_found() { + let network = NodeNetwork { + nodes: [(NodeId(1), node(DocumentNodeImplementation::Network(inner_network())))].into_iter().collect(), + ..Default::default() + }; + let document = r#"{ "network_interface": { "network_metadata": { "persistent_metadata": { + "node_metadata": [[1, { "persistent_metadata": { + "node_type_metadata": { "Layer": {} }, + "network_metadata": { "persistent_metadata": { + "node_metadata": [[3, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [4, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]] + } } + } }]] + } } } }"#; + + assert_eq!(sorted_legacy_layer_paths(&network, document), vec![vec![NodeId(1)], vec![NodeId(1), NodeId(3)]]); + } +} diff --git a/editor/src/node_graph_executor/runtime/layer_path_tests.rs b/editor/src/node_graph_executor/runtime/layer_path_tests.rs index 080dc0a1bfc..a156e9231eb 100644 --- a/editor/src/node_graph_executor/runtime/layer_path_tests.rs +++ b/editor/src/node_graph_executor/runtime/layer_path_tests.rs @@ -4,13 +4,16 @@ use crate::messages::portfolio::document::utility_types::network_interface::{Inp use crate::test_utils::test_prelude::*; use graphene_std::graphic::extend; -// A layer that ends in no Extend node has its path written onto its whole output, which gives the editor its click targets +fn rectangle() -> DefinitionIdentifier { + DefinitionIdentifier::ProtoNode(graphene_std::vector::generator_nodes::rectangle::IDENTIFIER) +} + +// A layer without an Extend node gets its path written onto its whole output #[tokio::test] -async fn a_node_shown_as_a_layer_is_traced_back_to() { +async fn a_layer_gets_click_targets() { let mut editor = EditorTestUtils::create(); editor.new_document().await; - let rectangle = DefinitionIdentifier::ProtoNode(graphene_std::vector::generator_nodes::rectangle::IDENTIFIER); - let rectangle = editor.create_node_by_name_at(rectangle, 0, 0).await; + let rectangle = editor.create_node_by_name_at(rectangle(), 0, 0).await; editor .handle_message(NodeGraphMessage::CreateWire { output_connector: OutputConnector::node(rectangle, 0), @@ -30,14 +33,13 @@ async fn a_node_shown_as_a_layer_is_traced_back_to() { ); } -// A layer that is itself an Extend node has its path written, from beside it, onto what it's given to add +// A layer that is an Extend node gets its path written onto what it adds #[tokio::test] -async fn an_extend_node_shown_as_a_layer_is_traced_back_to() { +async fn an_extend_node_layer_gets_click_targets() { let mut editor = EditorTestUtils::create(); editor.new_document().await; let extend = editor.create_node_by_name_at(DefinitionIdentifier::ProtoNode(extend::IDENTIFIER), 0, 0).await; - let rectangle = DefinitionIdentifier::ProtoNode(graphene_std::vector::generator_nodes::rectangle::IDENTIFIER); - let (below, added) = (editor.create_node_by_name_at(rectangle.clone(), -10, 0).await, editor.create_node_by_name_at(rectangle, -10, 4).await); + let (below, added) = (editor.create_node_by_name_at(rectangle(), -10, 0).await, editor.create_node_by_name_at(rectangle(), -10, 4).await); for (rectangle, input) in [(below, InputConnector::node(extend, extend::BaseInput)), (added, InputConnector::node(extend, extend::NewInput))] { editor .handle_message(NodeGraphMessage::CreateWire { diff --git a/node-graph/graphene-cli/src/lib.rs b/node-graph/graphene-cli/src/lib.rs index fcff551b3b1..b630c493bf8 100644 --- a/node-graph/graphene-cli/src/lib.rs +++ b/node-graph/graphene-cli/src/lib.rs @@ -5,10 +5,9 @@ pub mod dump; pub mod export; use document_format::GddV1; -use document_graph_storage::NodeMetadataEntry; use document_loader::{DocumentOrigin, LoadedDocument}; use graph_craft::application_io::{PlatformApplicationIo, PlatformEditorApi}; -use graph_craft::document::{DocumentNode, DocumentNodeImplementation, NetworkLocation, NodeId, NodeNetwork}; +use graph_craft::document::{NetworkLocation, NodeId, NodeNetwork}; use graph_craft::graphene_compiler::Compiler; use graph_craft::proto::ProtoNetwork; use graphene_std::application_io::ApplicationIo; @@ -16,7 +15,7 @@ use graphene_std::runtime::{AsyncRuntime, RuntimeHandle, Spawn, Task}; use interpreted_executor::dynamic_executor::DynamicExecutor; use interpreted_executor::layer_paths::write_layer_paths; use interpreted_executor::util::wrap_network_in_scope; -use std::collections::{HashMap, HashSet}; +use std::collections::HashMap; use std::error::Error; use std::path::Path; use std::sync::atomic::{AtomicBool, Ordering}; @@ -26,7 +25,7 @@ use std::sync::{Arc, Mutex}; pub struct OpenedDocument { pub gdd: Option, pub network: NodeNetwork, - /// The path of every layer, which compiling writes onto what the layer renders so the artwork can be measured. + /// The path of every layer in `network`. pub layers: Vec>, /// What `dump` shows for each node and network, when asked for. pub names: Option, String>>, @@ -34,102 +33,22 @@ pub struct OpenedDocument { /// Open `path` with [`document_loader::open_document`]. `with_names` also collects its display names. pub async fn open_document(path: &Path, with_names: bool) -> Result> { - let LoadedDocument { network, origin } = document_loader::open_document(path).await?; + let LoadedDocument { network, layers, origin } = document_loader::open_document(path).await?; - let (gdd, layers, names) = match origin { - DocumentOrigin::Legacy(document_string) => { - let layers = legacy_layer_paths(&network, &document_string); - (None, layers, with_names.then(|| dump::legacy_names(&document_string))) - } + let (gdd, names) = match origin { + DocumentOrigin::Legacy(document_string) => (None, with_names.then(|| dump::legacy_names(&document_string))), DocumentOrigin::Gdd { gdd, nodes, networks } => { - let layers = layer_paths(&network, &nodes); let names = with_names.then(|| { let references: HashMap<_, _> = networks.into_iter().filter_map(|network| Some((network.network, network.reference?))).collect(); let display_names: HashMap<_, _> = nodes.into_iter().filter_map(|node| Some(((node.network, node.local_id), node.display_name?))).collect(); instance_names(&network, &references, &display_names) }); - (Some(*gdd), layers, names) + (Some(*gdd), names) } }; Ok(OpenedDocument { gdd, network, layers, names }) } -/// The path of every node its metadata marks as a layer, once for each instance of the networks holding it. -pub fn layer_paths(network: &NodeNetwork, node_metadata: &[NodeMetadataEntry]) -> Vec> { - let layers: HashSet<(NetworkLocation, NodeId)> = node_metadata.iter().filter(|node| node.is_layer).map(|node| (node.network, node.local_id)).collect(); - - instance_layer_paths( - network, - None, - |_, _, node| match node.implementation { - DocumentNodeImplementation::Definition(id) => Some(Some(id)), - _ => None, - }, - |location, node_id| layers.contains(&(*location, node_id)), - ) -} - -/// The path of every layer in a legacy document, read from its JSON text. -/// That describes the networks nodes hold inside their own metadata, and the ones they name in a table beside the document network's. -fn legacy_layer_paths(network: &NodeNetwork, document: &str) -> Vec> { - let Ok(document) = serde_json::from_str::(document) else { return Vec::new() }; - let document_network = &document["network_interface"]["network_metadata"]; - let definitions = &document_network["persistent_metadata"]["definitions"]; - - instance_layer_paths( - network, - legacy_node_metadata(document_network), - |node_metadata, node_id, node| match node.implementation { - DocumentNodeImplementation::Network(_) => Some(legacy_node_metadata(&node_metadata.get(&node_id).copied()?["network_metadata"])), - DocumentNodeImplementation::Definition(id) => Some(legacy_node_metadata(&definitions[id.0.to_string()])), - _ => None, - }, - |node_metadata, node_id| node_metadata.get(&node_id).is_some_and(|metadata| metadata["node_type_metadata"]["Layer"].is_object()), - ) -} - -/// The metadata of each node in a legacy document's network, by ID. -fn legacy_node_metadata(network_metadata: &serde_json::Value) -> HashMap { - let entries = network_metadata["persistent_metadata"]["node_metadata"].as_array().into_iter().flatten(); - entries.filter_map(|entry| Some((NodeId(entry[0].as_u64()?), &entry[1]["persistent_metadata"]))).collect() -} - -/// The path of every layer, once for each instance of the networks holding it, with a network's layers before those of the networks inside it as the editor orders them. -/// The walk carries the metadata of each network it enters, which `nested` finds for the network a node holds or names. -fn instance_layer_paths( - network: &NodeNetwork, - document_network_metadata: Metadata, - nested: impl Fn(&Metadata, NodeId, &DocumentNode) -> Option, - is_layer: impl Fn(&Metadata, NodeId) -> bool, -) -> Vec> { - let mut layer_paths = Vec::new(); - - // Each network is walked with the definitions enclosing it, so one that holds itself isn't entered again - let mut stack = vec![(Vec::new(), document_network_metadata, Vec::new())]; - while let Some((network_path, metadata, enclosing_definitions)) = stack.pop() { - let Some(walked) = network.nested_network(&network_path) else { continue }; - - for (node_id, node) in &walked.nodes { - let node_path = [network_path.as_slice(), &[*node_id]].concat(); - if is_layer(&metadata, *node_id) { - layer_paths.push(node_path.clone()); - } - - let definition = match node.implementation { - DocumentNodeImplementation::Definition(id) if enclosing_definitions.contains(&id) => continue, - DocumentNodeImplementation::Definition(id) => Some(id), - _ => None, - }; - if let Some(nested_metadata) = nested(&metadata, *node_id, node) { - let enclosing_definitions = enclosing_definitions.iter().copied().chain(definition).collect(); - stack.push((node_path, nested_metadata, enclosing_definitions)); - } - } - } - - layer_paths -} - /// The name of each node, keyed by the path the dump visits it at. /// This is its display name, or else the reference of the network it implements. fn instance_names(network: &NodeNetwork, references: &HashMap, display_names: &HashMap<(NetworkLocation, NodeId), String>) -> HashMap, String> { @@ -292,110 +211,3 @@ impl TokioSpawner { pending } } - -#[cfg(test)] -mod tests { - use super::*; - use graph_craft::document::NetworkId; - - const DEFINITION: NetworkId = NetworkId(9); - - fn node(implementation: DocumentNodeImplementation) -> DocumentNode { - DocumentNode { implementation, ..Default::default() } - } - - /// A network holding the nodes 3 and 4. - fn inner_network() -> NodeNetwork { - let nodes = [3, 4].map(|id| (NodeId(id), DocumentNode::default())); - NodeNetwork { - nodes: nodes.into_iter().collect(), - ..Default::default() - } - } - - fn node_metadata(network: NetworkLocation, local_id: u64, is_layer: bool) -> NodeMetadataEntry { - NodeMetadataEntry { - network, - local_id: NodeId(local_id), - position: None, - is_layer, - display_name: None, - locked: false, - pinned: false, - input_metadata: Vec::new(), - output_names: Vec::new(), - output_descriptions: Vec::new(), - } - } - - /// The paths found, checking each layer comes after the one holding it. - fn checked_and_sorted(mut layer_paths: Vec>) -> Vec> { - for (index, layer_path) in layer_paths.iter().enumerate() { - let holder = &layer_path[..layer_path.len() - 1]; - let holder_index = layer_paths.iter().position(|other| other == holder); - assert!( - holder_index.is_none_or(|holder_index| holder_index < index), - "Layer {layer_path:?} should come after the layer holding it" - ); - } - - layer_paths.sort(); - layer_paths - } - - /// The nodes 1 and 2, which both name the definition holding the nodes 3 and 4. - fn two_instances_of_a_definition() -> NodeNetwork { - NodeNetwork { - nodes: [1, 2].map(|id| (NodeId(id), node(DocumentNodeImplementation::Definition(DEFINITION)))).into_iter().collect(), - definitions: [(DEFINITION, inner_network())].into_iter().collect(), - ..Default::default() - } - } - - /// The layer paths when 1 and 3 are layers. - fn expected_instance_paths() -> Vec> { - vec![vec![NodeId(1)], vec![NodeId(1), NodeId(3)], vec![NodeId(2), NodeId(3)]] - } - - #[test] - fn a_layer_inside_a_definition_is_found_through_each_instance() { - let network = two_instances_of_a_definition(); - let metadata = [(None, 1, true), (None, 2, false), (Some(DEFINITION), 3, true), (Some(DEFINITION), 4, false)]; - let metadata: Vec<_> = metadata.into_iter().map(|(location, local_id, is_layer)| node_metadata(location, local_id, is_layer)).collect(); - - assert_eq!(checked_and_sorted(layer_paths(&network, &metadata)), expected_instance_paths()); - } - - // Current legacy JSON describes a definition's nodes in a table beside the document network's - #[test] - fn a_legacy_layer_inside_a_definition_is_found_through_each_instance() { - let network = two_instances_of_a_definition(); - let document = r#"{ "network_interface": { "network_metadata": { "persistent_metadata": { - "node_metadata": [[1, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [2, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]], - "definitions": { "9": { "persistent_metadata": { - "node_metadata": [[3, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [4, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]] - } } } - } } } }"#; - - assert_eq!(checked_and_sorted(legacy_layer_paths(&network, document)), expected_instance_paths()); - } - - // Older legacy JSON describes a network a node holds inside that node's own metadata - #[test] - fn a_legacy_layer_inside_a_held_network_is_found() { - let network = NodeNetwork { - nodes: [(NodeId(1), node(DocumentNodeImplementation::Network(inner_network())))].into_iter().collect(), - ..Default::default() - }; - let document = r#"{ "network_interface": { "network_metadata": { "persistent_metadata": { - "node_metadata": [[1, { "persistent_metadata": { - "node_type_metadata": { "Layer": {} }, - "network_metadata": { "persistent_metadata": { - "node_metadata": [[3, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [4, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]] - } } - } }]] - } } } }"#; - - assert_eq!(checked_and_sorted(legacy_layer_paths(&network, document)), vec![vec![NodeId(1)], vec![NodeId(1), NodeId(3)]]); - } -} diff --git a/node-graph/graphene-cli/src/watch.rs b/node-graph/graphene-cli/src/watch.rs index aa3eb80b391..1dfe1059300 100644 --- a/node-graph/graphene-cli/src/watch.rs +++ b/node-graph/graphene-cli/src/watch.rs @@ -2,7 +2,7 @@ use document_live::{Event, LiveDocument}; use graph_craft::application_io::resource::ResourceHash; use graph_craft::application_io::{PlatformApplicationIo, PlatformEditorApi}; use graph_craft::document::value::{RenderOutput, RenderOutputType, TaggedValue, UVec2}; -use graphene_cli::{TokioSpawner, compile_graph, create_executor, editor_api, export, layer_paths}; +use graphene_cli::{TokioSpawner, compile_graph, create_executor, editor_api, export}; use graphene_std::application_io::{ApplicationIo, ExportFormat, RenderConfig}; use graphene_std::runtime::AsyncRuntime; use interpreted_executor::dynamic_executor::DynamicExecutor; @@ -124,11 +124,10 @@ impl Viewer { } fn recompile(&mut self) { - let (network, nodes) = match self.runtime.block_on(self.live.network_with_metadata()) { - Ok(network_with_metadata) => network_with_metadata, + let (network, layers) = match self.runtime.block_on(self.live.network_with_layers()) { + Ok(network_with_layers) => network_with_layers, Err(error) => return log::error!("Failed to build the runtime network: {error}"), }; - let layers = layer_paths(&network, &nodes); let proto = match compile_graph(network, &layers, self.editor_api.clone(), Some(self.live.document()), self.graph_runtime.handle()) { Ok(proto) => proto, Err(error) => return log::error!("Compile failed: {error}"), diff --git a/node-graph/interpreted-executor/src/layer_paths.rs b/node-graph/interpreted-executor/src/layer_paths.rs index 4eaefd7dc13..931719a1d4b 100644 --- a/node-graph/interpreted-executor/src/layer_paths.rs +++ b/node-graph/interpreted-executor/src/layer_paths.rs @@ -60,7 +60,8 @@ pub fn write_layer_paths(network: &mut NodeNetwork, layer_paths: &[Vec]) let Some((layer, parent_path)) = layer_path.split_last() else { continue }; let Some(content) = layer_content(layer_path, network) else { continue }; - // An Extend node deeper inside the layer may be in a network other layers share, so the writer goes on the layer's whole output instead + // An Extend node nested deeper than the layer may be in a network that other layers share. + // So the writer goes after the layer's output, and the Extend node only decides if the content can carry the path. let content = match content { LayerContent::Added { network_path, extend } if network_path.len() > layer_path.len() => LayerContent::Output([network_path.as_slice(), &[extend]].concat()), content => content, @@ -201,7 +202,7 @@ fn layer_path_writer(content: NodeInput, layer_beside: Vec) -> DocumentN DocumentNode { inputs: vec![ content, - // The writer is in the layer's own network or beside the layer, so dropping just its own ID reaches it + // The writer is directly inside the layer or beside it, so removing only its own ID gives the path NodeInput::value(TaggedValue::Integer(1), false), NodeInput::value(TaggedValue::NodeIdPath(NodeIdPath::from(layer_beside)), false), NodeInput::Reflection(DocumentNodeMetadata::DocumentNodePath), @@ -291,9 +292,9 @@ mod tests { // The writer writes the path of the layer holding its network, whichever layer that is let writer = &written[0].definitions[&merge].nodes[&layer_path_writer_id(NodeId(1))]; - let (levels_up, layer_beside) = (&writer.inputs[1], &writer.inputs[2]); - assert_eq!(*levels_up, NodeInput::value(TaggedValue::Integer(1), false)); - assert_eq!(*layer_beside, NodeInput::value(TaggedValue::NodeIdPath(NodeIdPath::from(Vec::new())), false)); + let (levels_up, layer_beside) = (writer.input(write_layer_path::LevelsUpInput), writer.input(write_layer_path::LayerBesideInput)); + assert_eq!(levels_up, Some(&NodeInput::value(TaggedValue::Integer(1), false))); + assert_eq!(layer_beside, Some(&NodeInput::value(TaggedValue::NodeIdPath(NodeIdPath::from(Vec::new())), false))); } // Content that already writes its own layer path, like the 'Merge' networks of older documents, gets no second writer