Navigating Node Graphs

Table of Contents

• Iterate over True Nodes
• Finding a Specific True Node
• Iterating over Ports
• Retrieving an Ancestor
• Retrieving Successors and Predecessors

Describes how to navigate a node graph. Contains topics on finding a specific node, iterating over ports or retrieving ancestors to find information.

Iterate over True Nodes

There are three functions to iterate over nodes:

• maxon::GraphNode::GetInnerNodes: Yields all inner nodes of this node matching a filtering mask. The recursive traversal will stop at nodes which do not match the filtering mask.
• maxon::GraphNode::GetChildren: Gets all children of this node. For a true node this will be its child nodes as well as a single input port list and a single output port list. Otherwise, the children are ports.
• maxon::nodes::Node::GetChildren: Returns an iterator for the child nodes of this node. This does include true nodes, but not the input and output port lists.

  Note

  GetChildren function from GraphNode allow you to use maxon::ValueReceiver which is a template for a generic delegate function. It can be a lambda function or a BaseArray for example.

    // Find a specific True Node
   
    // Define the id of the node we are looking for.
    maxon::Id searchingFor{ "Color2" };
    // And the variable that will receive the result.
    maxon::GraphNode searchNode;
   
    // Create the recursive Lambda
    maxon::ValueReceiver<const maxon::GraphNode&> FindNode;
    FindNode = [&FindNode, &searchingFor, &searchNode] 
    (const maxon::GraphNode& child)  -> maxon::Result<Bool>
    {
      const maxon::Id childId = child.GetId();
      // Compare the current node id with the one we are looking for.
      if (childId.Compare(searchingFor) == maxon::COMPARERESULT::EQUAL)
      {
        searchNode = child;
        return true;
      }
      // Recursively call the lambda for all the children
      return child.GetChildren(FindNode);
    };
    FindNode(root) iferr_return;
   
    if (searchNode.IsValid())
      ApplicationOutput("Node found @", searchNode);

Finding a Specific True Node

For nodes can be searched with their identifier, name or other types of data.

  // Find nodes that have some value in common with the passed DataDictionary
  
  maxon::DataDictionary dict;
  dict.Set(maxon::NODE::BASE::COMMENT, "This is my comment"_s) iferr_return;
  maxon::GraphModelHelper::ListAllNodes(nodeGraph, dict, [](const maxon::GraphNode& child)
    {
      ApplicationOutput("this graph have the same data @", child);
      return true;
    }) iferr_return;

Iterating over Ports

As Ports are also a GraphNode, they can be iterated just like the Nodes themselves.

  // Iterate the ports of a Node
  
  // Retrieve the NimbusRef for this material
  const maxon::NimbusBaseRef nimbusRefMaterial = nodeMaterial->GetNimbusRef(currentNodeSpaceID);
  if (nimbusRefMaterial == nullptr)
    return maxon::NullptrError(MAXON_SOURCE_LOCATION);
  
  // Retrieve the end node path
  const maxon::NodePath materialEndNodePath = nimbusRefMaterial.GetPath(
                                                              maxon::NIMBUS_PATH::MATERIALENDNODE);
  if (!materialEndNodePath.IsPopulated())
    return maxon::UnknownError(MAXON_SOURCE_LOCATION);
 
  // Retrieve the end node of the node material
  const maxon::GraphNode materialEndNode = nimbusRefMaterial.GetGraph().GetNode(materialEndNodePath);
  if (!materialEndNode.IsValid())
    return maxon::UnknownError(MAXON_SOURCE_LOCATION);
 
  // Iterate  all the port of the material end node
  maxon::ValueReceiver<const maxon::GraphNode&> printPort;
  printPort = [&printPort, &materialEndNode](const maxon::GraphNode& port) -> maxon::Result<Bool>
  {
    iferr_scope;
    String name = port.GetValue<decltype(maxon::NODE::BASE::NAME)>().GetValueOrNull() iferr_return;
    if (name.IsEmpty())
    {
      name = port.GetValue<decltype(maxon::EffectiveName)>().GetValueOrNull() iferr_return;
    }
    ApplicationOutput("@ is a port of @ and have the name @", port, materialEndNode, name);
    return port.GetChildren(printPort, maxon::NODE_KIND::NODE);
  };
  printPort(materialEndNode) iferr_return;

Retrieving an Ancestor

Retrieving an ancestor is useful to retrieve information related to a node.

  //  Retrieve the Ancestor of a port.
  
  // Retrieve the port's name.
  onePort.GetValue<decltype(maxon::EffectiveName)>().GetValueOrNull() iferr_return;
  ApplicationOutput("the name of the port is @");
  
  // Get the ancestor and print its information.
  const maxon::GraphNode ancestor = onePort.GetAncestor(maxon::NODE_KIND::NODE) iferr_return;
  ApplicationOutput("@ is a port and a child of @", onePort, ancestor);

Retrieving Successors and Predecessors

To retrieve the successors or predecessors of a node, one can utilize the following functions:

• maxon::GraphModelHelper::GetDirectPredecessors: Retrieves the first level of nodes connected to the input port of this node.
• maxon::GraphModelHelper::GetAllPredecessors: Retrieves all nodes connected to the input port of this node.
• maxon::GraphModelHelper::GetDirectSuccessors: Retrieves the first level of nodes connected to the output port of this node.
• maxon::GraphModelHelper::GetAllSuccessors: Retrieves all nodes connected to the output port of this node.

    // Retrieves all the nodes that are directly or indirectly connected to an input port of a True Node
   
    maxon::GraphModelHelper::GetAllPredecessors(materialEndNode, maxon::NODE_KIND::NODE, 
    [&materialEndNode](const maxon::GraphNode& pred) -> maxon::Result<Bool>
    {
      ApplicationOutput("this node @ is a predecessor of @", pred, materialEndNode);
      return true;
    }) iferr_return;