|On this page|
This node runs a block of SOP nodes that have been converted into a geometry graph. It runs them as if its inputs were wired into the geometry graph.
The usefulness of this node is very esoteric.
You can use it to compress node chains into geometry, reducing overhead of creating actual nodes, but at the complexity of working with geometry.
You can use it to have SOP networks that generate the SOP network they need prior to executing it. Because nodes cannot be created or destroyed during cooking; if an HDA needs to generate a bespoke node network to process some data it can’t do so other than outside the cook path. However, it can generate geometry while cooking and feed that new geometry to an Invoke Graph to apply the operation.
Geometry graphs cannot contain expressions or channels, so often it is not a simple conversion from a node network to a geometry graph. The Parameter Override can be used to gain the functionality of channels.
The first input is the geometry graph to process. This is of the form generated with Attribute from Parameters node. The Explicit Wires option can be used to build a graph that is independent of the path attributes.
You can specify a number of inputs on this node. Each input can “override” the input of the geometry graph.
In Compile Block mode, the inputs are matched to the Begin Compile nodes by the value of their Input name parameters.
For example, if you set the Input name parameter on a Block Begin Compile node in the block to
piece, and then create an input on this node and also set its Input name to
piece, it will override the input for that Begin Compile node when this node executes the block.
In Explicit Output / Inputs mode, the inputs are matched in order based on the specified input point group.
This controls how the graph is invoked. If the graph was generated from a compiled block, the Compiled Block approach provides parity with how the Invoke node works. Alternatively, the graph might be generated by connecting points in which case the explicit method will auto-wrap a compiled block.
Invoke Compiled Block
A root output is specifed by a path. The point with the corresponding
path attribute will be used as the root, and must be a Block End
Compile node. The inputs are found by
traversing the network and using the names stored in the input’s
Invoke Explicit Inputs / Outputs
The root output is specified by a point group. The first point in the group will be used. It does not have to be a compile block, however, instead an implicit compile block witll be wrapped around it and the points in the input group. The input point numbers will be wired to this nodes inputs.
The path of the output node. Must be a compile block. The
path point attribute is used to find the corresponding point.
Input # Name
The name of each of the inputs. The name stored in the
the block begin points that correspond to the ouitput are matched
How to determine the output type. Graph construction can be done with the rule that the first or last point is always the output node, making it straightforward to know which point to use. Otherwise, a group can be used, in which case the first point in the group is the output point.
The first point of this point group is the output point for the graph.
These points become the inputs for the graph. A block begin compile node is implicitly wired into their first inputs and hooked up to the additional inputs of this node.
Whether to unload the executed block’s intermediate data (or cache it on this node). Since compiled blocks are usually used for repeated sections that shouldn’t cache, this parameter defaults to always unload. This setting uses less memory.
Don’t unload (that is, cache the executed block’s intermediate data).
Use node’s flag
Check this node’s Unload flag for whether to unload the cache.
Always unload the intermediate data (this is, do not cache).