file_path
stringlengths 5
148
| content
stringlengths 150
498k
| size
int64 150
498k
|
|---|---|---|
OgnExampleAdjacency.md | # Example Node: Adjacency
Computes chosen adjacency information from specified input mesh topology data.
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Compute Distances (`inputs:computeDistances`) | `bool` | When enabled, the distances from each point to its neighbors is computed and stored in a ‘float[]’ attribute in ‘output’ as specified by ‘nameOfDistancesOutputAttribute’. | False |
| Compute Neighbor Counts (`inputs:computeNeighborCounts`) | `bool` | When enabled, the number of neighbors of each point is computed and all are stored in an ‘int[]’ attribute in ‘output’ as specified by ‘nameOfNeighborCountsOutputAttribute’. | False |
| Compute Neighbor Starts (`inputs:computeNeighborStarts`) | `bool` | When enabled, the beginning index of neighbors of each point within the arrays computed by either ‘computeNeighbors’ or ‘computeDistances’ is computed and all, plus an additional integer to indicate the end of the array, are stored in an ‘int[]’ attribute in ‘output’ as specified by ‘nameOfNeighborStartsOutputAttribute’. The extra integer at the end allows for easy computing of the number of neighbors of any single point, by subtracting the value in the array corresponding with the point, from the following value in the array. | True |
| Compute Neighbors (`inputs:computeNeighbors`) | `bool` | When enabled, the neighbors of each point are computed and stored contiguously in an ‘int[]’ attribute in ‘output’ as specified by ‘nameOfNeighborsOutputAttribute’. | True |
| Name Of Bundle Input Attribute (inputs:nameOfBundleInputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Bundle containing topology data to be analysed | None | | |
| Name Of Distances Output Attribute (inputs:nameOfDistancesOutputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘float[]’ attribute to be created in ‘output’ to contain the computed distances to each neighbor. This is only used if ‘computeDistances’ is true. | distances | | |
| Name Of Neighbor Counts Output Attribute (inputs:nameOfNeighborCountsOutputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute to be created in ‘output’ to contain the number of neighbors of each point. This is only used if ‘computeNeighborCounts’ is true. A running sum of this array can be computed using ‘computeNeighborStarts’. The neighbors themselves can be computed using ‘computeNeighbors’. | neighborCounts | | |
| Name Of Neighbor Starts Output Attribute (inputs:nameOfNeighborStartsOutputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute to be created in ‘output’ to contain the beginning index of neighbors of each point in the arrays computed by either ‘computeNeighbors’ or ‘computeDistances’. This is only used if ‘computeNeighborStarts’ is true. | neighborStarts | | |
| Name Of Neighbors Output Attribute (inputs:nameOfNeighborsOutputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute to be created in ‘output’ to contain the neighbors of all points. This is only used if ‘computeNeighbors’ is true. The beginnings of each point’s neighbors within this array can be computed using ‘computeNeighborStarts’. The number of neighbors of each point can be computed using ‘computeNeighborCounts’. | neighbors | | |
| Name Of Positions Input Attribute (inputs:nameOfPositionsInputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘point3f[]’ attribute in ‘mesh’ containing the positions of each point. This is only used if ‘computeDistances’ is true. The element count of this array overrides ‘pointCount’, when used. | points | | |
| Name Of Vertex Counts Input Attribute (inputs:nameOfVertexCountsInputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute in ‘mesh’ containing the vertex counts of each face | faceVertexCounts | | |
| Name Of Vertex Indices Input Attribute (inputs:nameOfVertexIndicesInputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute in ‘mesh’ containing the vertex indices of each face | faceVertexIndices | | |
| Point Count (inputs:pointCount) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Number of points being referred to in the vertex indices attribute. This is only used if ‘computeDistances’ is false, otherwise this is overridden by the element count of the attribute specified by ‘nameOfPositionsInputAttribute’. | 0 | | |
| Remove Duplicates (inputs:removeDuplicates) | Type | Description | Default Value |
| --- | --- | --- | --- |
| When enabled, each neighbor of a point will be counted only once, instead of once per edge that connects the point to the neighbor. | True | | |
| Treat Edges As One Way (inputs:treatEdgesAsOneWay) | Type | Description | Default Value |
| --- | --- | --- | --- |
| When enabled, if a face has an edge from A to B, B will be considered a neighbor of A, but A will not be considered a neighbor of B. This can be useful as part of identifying unshared edges or inconsistent face winding order. | False | | |
| Treat Faces As Curves (inputs:treatFacesAsCurves) | Type | Description | Default Value |
| --- | --- | --- | --- |
| | | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| TreatFacesAsCurves | bool | When enabled, the input faces will be treated as curves, instead of closed polygons, i.e. no edge from the last vertex of each face to the first vertex of that face will be counted. | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Mesh (outputs:mesh) | bundle | A copy of the input ‘mesh’ with the computed attributes added, as specified above. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.Adjacency |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Adjacency |
| Generated Class Name | OgnExampleAdjacencyDatabase |
| Python Module | omni.graph.examples.cpp | | 6,441 |
OgnExampleExtractFloat3Array.md | # Example Node: Extract Float3 Array
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (inputs:input) | bundle | Bundle containing a float[3][] attribute to be extracted to ‘output’ | None |
| Name Of Attribute (inputs:nameOfAttribute) | token | Name of the attribute in ‘input’ that is to be extracted to ‘output’ | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Output (outputs:output) | float[3][] | The float[3][] attribute extracted from ‘input’ | None |
## Metadata
| Name | Descripton |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.ExtractFloat3Array |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Extract Float3 Array |
| Categories | examples |
| Generated Class Name | OgnExampleExtractFloat3ArrayDatabase |
| Python Module | omni.graph.examples.cpp | | 1,115 |
OgnExampleSimpleDeformer.md | # Example Node: Simple Sine Wave Deformer
This is an example of a simple deformer. It calculates a sine wave and deforms the input geometry with it.
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (`inputs:multiplier`) | `float` | The multiplier for the amplitude of the sine wave | 1 |
| Points (`inputs:points`) | `pointf[3][]` | The input points to be deformed | [] |
| Wavelength (`inputs:wavelength`) | `float` | The wavelength of the sine wave | 1 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (`outputs:points`) | `pointf[3][]` | The deformed output points | |
# Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.examples.cpp.SimpleDeformer |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Simple Sine Wave Deformer |
| Categories | examples |
| Generated Class Name | OgnExampleSimpleDeformerDatabase |
| Python Module | omni.graph.examples.cpp | | 1,493 |
OgnExampleSmooth.md | # Example Node: Smooth Points
Smooths data in a very simple way by averaging values with neighbors.
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Iterations (`inputs:iterations`) | `int` | Number of times to average neighboring values | 5 |
| Mesh (`inputs:mesh`) | `bundle` | Bundle containing data to be smoothed and neighbor arrays. | None |
| Name Of Attribute To Smooth (`inputs:nameOfAttributeToSmooth`) | `token` | Name of the attribute in ‘mesh’ containing the data to be smoothed | points |
| Name Of Neighbor Starts Input Attribute (`inputs:nameOfNeighborStartsInputAttribute`) | `token` | Name of the ‘int[]’ attribute in ‘mesh’ containing the beginning index of neighbors of each point in the array attribute specified by ‘nameOfNeighborsInputAttribute’ | neighborStarts |
| Name Of Neighbors Input Attribute (`inputs:nameOfNeighborsInputAttribute`) | `token` | Name of the ‘int[]’ attribute in ‘mesh’ containing the neighbors of all points. The beginnings of each point’s neighbors within this array are provided in the attribute specified by ‘nameOfNeighborStartsInputAttribute’. | |
## Inputs
### neighbors
## Use GPU (inputs:useGPU)
- **Type**: bool
- **Description**: When this option is on, the node will use the GPU to perform the smoothing computation.
- **Default**: True
## Outputs
### Mesh (outputs:mesh)
- **Type**: bundle
- **Description**: A copy of ‘mesh’ with the specified attribute smoothed.
- **Default**: None
## Metadata
### Name
- **Value**: Unique ID
- **Value**: omni.graph.examples.cpp.Smooth
### Version
- **Value**: 1
### Extension
- **Value**: omni.graph.examples.cpp
### Has State?
- **Value**: False
### Implementation Language
- **Value**: C++
### Default Memory Type
- **Value**: cpu
### Generated Code Exclusions
- **Value**: None
### uiName
- **Value**: Example Node: Smooth Points
### Generated Class Name
- **Value**: OgnExampleSmoothDatabase
### Python Module
- **Value**: omni.graph.examples.cpp | 2,102 |
OgnExecSwitch.md | # Exec Switch
A switch node that will enable the left side or right side depending on the input
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|----------------|------------|-------------------------------------------------|---------|
| Exec In (inputs:execIn) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Switch (inputs:switch) | `bool` | Enables right value if greater than 0, else left value | False |
## Outputs
| Name | Type | Descripton | Default |
|-------------------|------------|-------------------------------------------------|---------|
| Exec Left Out (outputs:execLeftOut) | `execution` | If ‘Switch’ is less than or equal to 0, signal to the graph that execution can continue downstream on this path. | None |
| Exec Right Out (outputs:execRightOut) | `execution` | If ‘Switch’ is greater than 0, signal to the graph that execution can continue downstream on this path. | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.ExecSwitch |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | usd |
| uiName | Exec Switch |
| Categories | examples |
| Generated Class Name | OgnExecSwitchDatabase |
| Python Module | omni.graph.examples.python | | 1,925 |
OgnExitApplication.md | # Exit Application
Immediately exits the application. Uses a fast shutdown to avoid any cleanup that would otherwise be triggered.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|---------------|-------------------------------------------------|---------|
| Exec In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed, exiting the application. | None |
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.action.ExitApplication |
| Version | 1 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Exit Application |
| Categories | graph:action,flowControl |
| Generated Class Name |
OgnExitApplicationDatabase
Python Module
omni.graph.action_nodes | 1,406 |
OgnExponent.md | # Exponent
## Exponent
Computes the base input raised to the power of the exponent. The result is the same type as the base input for floating point types. The result is double for integral values to allow for negative exponents. If the input is a vector or matrix, then the node calculates the exponent for each element and computes a vector or matrix of the same size.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Base (inputs:base) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int'] | | |
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Base (inputs:base) | `['int', 'int[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | Base value that will be raised to the power of exponent. | None |
| Exponent (inputs:exponent) | `int` | Power to raise the base value “Base” to. If “Base” consists of an array, vector, or matrix, then the exponent will be applied to each member of the aforementioned data structures. | 2 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]']` | | |
## Metadata
### Name
- Unique ID
- Version
- Extension
- Has State?
- Implementation Language
- Default Memory Type
- Generated Code Exclusions
- uiName
### Value
- omni.graph.nodes.Exponent
- 1
- omni.graph.nodes
- False
- C++
- cpu
- None
- Exponent
| Categories | math:operator |
|------------|---------------|
| Generated Class Name | OgnExponentDatabase |
| Python Module | omni.graph.nodes | | 3,244 |
OgnExportUSDPrim.md | # export USD prim data
Exports data from an input bundle into a USD prim This node is deprecated, Use WritePrim nodes instead
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Apply Transform (`inputs:applyTransform`) | bool | If true, apply the transform necessary to transform any transforming attributes from the space of the node into the space of the specified prim. | False |
| Metadata | | `displayGroup` = parameters | |
| Attributes To Export (`inputs:attrNamesToExport`) | token | Comma or space separated text, listing the names of attributes in the input data to be exported or empty to import all attributes. | |
| Metadata | | `displayGroup` = parameters | |
| Bundle (`inputs:bundle`) | bundle | The bundle from which data should be exported. | None |
| Attributes To Exclude (`inputs:excludedAttrNames`) | token | Attributes to be excluded from being exported | |
| Export to Root Layer (`inputs:exportToRootLayer`) | | | |
<section id="outputs">
<h2>
Outputs
```
由于您提供的HTML代码中包含大量的表格数据，我将逐个处理表格行（tr）并将其转换为Markdown格式。请注意，Markdown中的表格需要特定的格式，而HTML中的表格结构通常更为复杂。以下是转换后的Markdown格式数据：
```markdown
<section id="outputs">
<h2>
Outputs
<section id="parameters">
<h2>
Parameters
<table>
<tbody>
<tr>
<td>
<p>
Export to Root Layer (inputs:exportToRootLayer)
<td>
<p>
<code>bool
<td>
<p>
If true, prims are exported in the root layer, otherwise the layer specified by “layerName” is used.
<td>
<p>
True
<tr>
<td>
<p>
Attributes To Rename (inputs:inputAttrNames)
<td>
<p>
<code>token
<td>
<p>
Comma or space separated text, listing the names of attributes in the input data to be renamed
<td>
<tr>
<td>
<p>
Layer Name (inputs:layerName)
<td>
<p>
<code>token
<td>
<p>
Identifier of the layer to export to if “exportToRootLayer” is false, or leave this blank to export to the session layer
<td>
<tr>
<td>
<p>
Only Export To Existing (inputs:onlyExportToExisting)
<td>
<p>
<code>bool
<td>
<p>
If true, only attributes that already exist in the specified output prim will have data transferred to them from the input bundle.
<td>
<p>
False
<tr>
<td>
<p>
New Attribute Names (inputs:outputAttrNames)
<td>
<p>
<code>token
<td>
<p>
Comma or space separated text, listing the new names for the attributes listed in inputAttrNames
<td>
<tr>
<td>
<p>
Prim Path From Bundle (inputs:primPathFromBundle)
<td>
<p>
<code>bool
<td>
<p>
When true, if there is a “primPath” token attribute inside the bundle, that will be the path of the USD prim to write to, else the “outputs:prim” attribute below will be used for the USD prim path.
<td>
<p>
False
<tr>
<td>
<p>
Export to Root Layer (inputs:removeMissingAttrs)
<td>
<p>
<code>bool
<td>
<p>
If true, any attributes on the USD prim(s) being written to, that aren’t in the input data, will be removed from the USD prim(s).
<td>
<p>
False
<tr>
<td>
<p>
Rename Attributes (inputs:renameAttributes)
<td>
<p>
<code>bool
<td>
<p>
If true, attributes listed in “inputAttrNames” will be exported to attributes with the names specified in “outputAttrNames”. Note: to avoid potential issues with redundant attributes being created while typing, keep this off until after specifying all input and output attribute names.
<td>
<p>
False
<tr>
<td>
<p>
Time Varying Attributes (inputs:timeVaryingAttributes)
<td>
<p>
<code>bool
<td>
<p>
Check whether the USD attributes should be time-varying and if so, export their data to a time sample at the time “usdTimecode”.
<td>
<p>
False
<tr>
<td>
<p>
Usd Timecode (inputs:usdTimecode)
<td>
<p>
<code>double
<td>
<p>
The time at which to evaluate the transform of the USD prim for applyTransform.
<td>
<p>
0
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prev Apply Transform (state:prevApplyTransform) | bool | Value of “applyTransform” input from previous run | None |
| Prev Attr Names To Export (state:prevAttrNamesToExport) | token | Value of “attrNamesToExport” input from previous run | None |
| Prev Bundle Dirty ID (state:prevBundleDirtyID) | uint64 | Dirty ID of input bundle from previous run | None |
| Prev Excluded Attr Names (state:prevExcludedAttrNames) | token | Value of “excludedAttrNames” input from previous run | None |
| Prev Export To Root Layer (state:prevExportToRootLayer) | bool | Value of “exportToRootLayer” input from previous run | None |
| Prev Input Attr Names (state:prevInputAttrNames) | token | Value of “inputAttrNames” input from previous run | None |
| Prev Layer Name (state:prevLayerName) | token | Value of “layerName” input from previous run | None |
| Prev Only Export To Existing (state:prevOnlyExportToExisting) | bool | Value of “onlyExportToExisting” input from previous run | None |
| Prev Output Attr Names (state:prevOutputAttrNames) | token | Value of “outputAttrNames” input from previous run | None |
| Prev Prim Dirty IDs (state:prevPrimDirtyIDs) | | | |
# Metadata
## Metadata
### Name
* Unique ID
* Version
* Extension
* Icon
* Has State?
* Implementation Language
* Default Memory Type
* Generated Code Exclusions
* uiName
* hidden
* __tokens
* Generated Class Name
* Python Module
### Value
* omni.graph.ExportUSDPrim
* 1
* omni.graph.nodes
* ogn/icons/omni.graph.ExportUSDPrim.svg
* True
* C++
* cpu
* None
* export USD prim data
* true
* {“primPath”: “primPath”, “primType”: “primType”, “primTime”: “primTime”, “primCount”: “primCount”, “transform”: “transform”}
* OgnExportUSDPrimDatabase
* omni.graph.nodes | 5,590 |
OgnExtractAttr.md | # Extract Attribute
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|--------------------------|-----------|-------------------------------------|---------|
| Attribute To Extract (`inputs:attrName`) | token | Name of the attribute to look for in the bundle | points |
| Bundle For Extraction (`inputs:data`) | bundle | Collection of attributes from which the named attribute is to be extracted | None |
## Outputs
| Name | Type | Descripton | Default |
|--------------------------|-----------|-------------------------------------|---------|
| Extracted Attribute (`outputs:output`) | any | The single attribute extracted from the input bundle | None |
## Metadata
| Name | Descripton |
|--------------------------|-------------------------------------|
| Metadata Name | Metadata Description |
| Unique ID | omni.graph.nodes.ExtractAttribute |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Extract Attribute |
| Categories | bundle |
| Generated Class Name | OgnExtractAttrDatabase |
| Python Module | omni.graph.nodes | | 1,449 |
OgnExtractBundle.md | # Extract Bundle
Exposes readable attributes for a bundle as outputs on this node. When this node computes it will read the latest attribute values from the target bundle into these node attributes
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle (inputs:bundle) | `bundle` | The bundle to be read from. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Pass Through (outputs:passThrough) | `bundle` | The input bundle passed as-is | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ExtractBundle |
| Version | 3 |
| Extension | omni.graph.nodes |
| Has State? | False |
| --- | --- |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Extract Bundle |
| Categories | bundle |
| Generated Class Name | OgnExtractBundleDatabase |
| Python Module | omni.graph.nodes | | 1,019 |
OgnExtractPrim.md | # Extract Prim
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (`inputs:prim`) | `target` | The prim to be extracted from Multiple Primitives in Bundle. | None |
| Prim Path (`inputs:primPath`) | `path` | The path of the prim to be extracted from Multiple Primitives in Bundle. | |
| Prims Bundle (`inputs:prims`) | `bundle` | The Multiple Primitives in Bundle to extract from. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim Bundle (`outputs:primBundle`) | `bundle` | The extracted Single Primitive in Bundle | |
## Metadata
| Name | Value |
|------------|---------------------------------|
| Unique ID | omni.graph.nodes.ExtractPrim |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Extract Prim |
| Categories | bundle |
| Generated Class Name | OgnExtractPrimDatabase |
| Python Module | omni.graph.nodes | | 1,271 |
OgnFindPrims.md | # Find Prims
Finds Prims on the stage which match the given criteria
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Ignore System Prims (`inputs:ignoreSystemPrims`) | bool | Ignore system prims such as omni graph nodes that shouldn’t be considered during the import. | False |
| Prim Name Prefix (`inputs:namePrefix`) | token | Only prims with a name starting with the given prefix will be returned. | |
| Prim Path Pattern (`inputs:pathPattern`) | token | A list of wildcard patterns used to match the prim paths Supported syntax of wildcard pattern: ‘*’ - match an arbitrary number of any characters ‘?’ - match any single character ‘^’ - (caret) is used to define a pattern that is to be excluded Example of wildcard patterns, input: [‘/Cube0’, ‘/Cube1’, ‘/Box’] ‘*’ - match any ‘* ^/Box’ - match any, but exclude ‘/Box’ ‘* ^/Cube*’ - match any, but exclude ‘/Cube0’ and ‘/Cube1’ | |
| Recursive (`inputs:recursive`) | bool | False means only consider children of the root prim, True means all prims in the hierarchy | False |
| Attribute Names (`inputs:requiredAttributes`) | string | A space-separated list of attribute names that are required to be present on matched prims | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Relationship Name (`inputs:requiredRelationship`) | | The name of a relationship which must have a target specified by requiredRelationshipTarget or requiredTarget | |
| Relationship Prim Path (`inputs:requiredRelationshipTarget`) | | The path that must be a target of the requiredRelationship | |
| Relationship Prim (`inputs:requiredTarget`) | | The target of the requiredRelationship | None |
| Root Prim (`inputs:rootPrim`) | | Only children of the given prim will be considered. If rootPrim is specified, rootPrimPath will be ignored. | None |
| Root Prim Path (`inputs:rootPrimPath`) | | Only children of the given prim will be considered. Empty will search the whole stage. | |
| Prim Type Pattern (`inputs:type`) | | A list of wildcard patterns used to match the prim types that are to be imported Supported syntax of wildcard pattern: ‘*’ - match an arbitrary number of any characters ‘?’ - match any single character ‘^’ - (caret) is used to define a pattern that is to be excluded Example of wildcard patterns, input: [‘Mesh’, ‘Cone’, ‘Cube’] ‘*’ - match any ‘* ^Mesh’ - match any, but exclude ‘Mesh’ ‘* ^Cone ^Cube’ - match any, but exclude ‘Cone’ and ‘Cube’ | |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Prim Paths (`outputs:primPaths`) | token[] | A list of Prim paths as tokens which match the given type | None |
| Prims (`outputs:prims`) | target | A list of Prim paths which match the given type | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Ignore System Prims (`state:ignoreSystemPrims`) | bool | last corresponding input seen | None |
| Input Type (`state:inputType`) | token | last corresponding input seen | None |
| Name Prefix (`state:namePrefix`) | token | | |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.FindPrims |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Find Prims |
| Categories | sceneGraph |
| Generated Class Name | OgnFindPrimsDatabase |
| Python Module | omni.graph.nodes | | 3,587 |
OgnFindString.md | # Find String
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Pos (`inputs:pos`) | `int` | The starting position to search for the string. | 0 |
| String (`inputs:string`) | `['string', 'token']` | The base string. | None |
| Value (`inputs:value`) | `['string', 'token']` | The string to search for. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Index (`outputs:index`) | `int` | The index of the first occurrence of string, or -1 if not found. | None |
## Metadata
| Name | Value |
|------------|---------------------------|
| Unique ID | omni.graph.nodes.FindString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Find String |
| Categories | function |
| Generated Class Name | OgnFindStringDatabase |
| Python Module | omni.graph.nodes | | 1,158 |
OgnFindTarget.md | # Find Target
Returns the index of the first occurrence of a target, or -1 if not found.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Search Target (`inputs:searchTarget`) | `target` | The target to search for. | None |
| Targets (`inputs:targets`) | `target` | The input target array. | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Index (`outputs:index`) | `int` | The index of the first occurrence of “searchTarget”, or -1 if not found | None |
## Metadata
| Name | Descripton |
| --- | --- |
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.FindTarget |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Find Target |
| Categories | sceneGraph |
| Generated Class Name | OgnFindTargetDatabase |
| Python Module | omni.graph.nodes | | 1,087 |
OgnFlipFlop.md | # Flip Flop
This node activates its outputs in an alternating sequence, starting with ‘On Odd’ on the first execution after ‘Signal Execution’ has been activated.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute In (inputs:execIn) | `execution` | Signal to the graph that this node is ready to be executed. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute A (outputs:a) | `execution` | After every odd-numbered execution signal to the graph that execution can continue downstream. | None |
| Execute B (outputs:b) | `execution` | After every even-numbered execution signal to the graph that execution can continue downstream. | None |
| Is A (outputs:isA) | `bool` | Set to true when the ‘Execute A’ signal is active, otherwise set to false. | None |
# Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.action.FlipFlop |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Icon | ogn/icons/omni.graph.action.FlipFlop.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Flip Flop |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnFlipFlopDatabase |
| Python Module | omni.graph.action_nodes | | 1,589 |
OgnFloor.md | # Floor
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]']` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| A | ['int', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]'] | The scalar(s) or vector(s) to compute the floor of. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | ['int', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]'] | The original input “A” with the floor operator applied to each scalar value. The structure of the result, arrays and tuples, will mirror that of the input. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.Floor |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Floor |
| Categories | math:operator |
| Generated Class Name | OgnFloorDatabase |
| Python Module | omni.graph.nodes | | 1,695 |
OgnFMod.md | # Float Remainder
Computes the floating point remainder of “A” / “B”. If “B” is zero, then the result is zero. The returned value has the same sign and shape as “A”.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]']` | | |
| A (inputs:a) | B (inputs:b) |
|--------------|-------------|
| ['normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]'] | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]'] |
The numerator “A” from which the floating point remainder will be computed.
None
The numerator “B” from which the floating point remainder will be computed.
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| A (inputs:a) | `['vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The numerator “A” from which the floating point remainder will be computed. | None |
| B | `['vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The numerator “B” from which the floating point remainder will be computed. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The floating point remainder of “A” / “B”, which should have the same sign and shape as “A”. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.FMod |
| Version | 1 |
| --- | --- |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Float Remainder |
| Categories | math:operator |
| Generated Class Name | OgnFModDatabase |
| Python Module | omni.graph.nodes | | 4,840 |
OgnForEach.md | # For Each Loop
## For Each Loop
Activates the ‘Loop Body’ signal once for each element in the ‘Input Array’, making the current array member available in ‘Element’ with its index in ‘Array Index’. After every element of the ‘Input Array’ has been processed the ‘Finished’ signal is activated. All of this will happen in a single execution of the node, giving you the ability to evaluate a downstream graph multiple times with different inputs coming from the changing ‘Element’ output.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input Array (`inputs:arrayIn`) | `['bool[]', 'colord[3][]', 'colord[4][]', 'colorf[3][]', 'colorf[4][]', 'colorh[3][]', 'colorh[4][]', 'double[2][]', 'double[3][]', 'double[4][]', 'double[]', 'float[2][]', 'float[3][]', 'float[4][]', 'float[]', 'frame[4][]', 'half[2][]', 'half[3][]', 'half[4][]', 'half[]', 'int64[]', 'int[2][]', 'int[3][]', 'int[4][]', 'int[]', 'matrixd[2][]', 'matrixd[3][]', 'matrixd[4][]', 'normald[3][]', 'normalf[3][]', 'normalh[3][]', 'pointd[3][]', 'pointf[3][]', 'pointh[3][]', 'quatd[4][]', 'quatf[4][]', 'quath[4][]']` | | |
```code
'texcoordd[2][]',
'texcoordd[3][]',
'texcoordf[2][]',
'texcoordf[3][]',
'texcoordh[2][]',
'texcoordh[3][]',
'timecode[]',
'token[]',
'transform[4][]',
'uchar[]',
'uint64[]',
'uint[]',
'vectord[3][]',
'vectorf[3][]',
'vectorh[3][]'
```
```markdown
The array to loop over
```
```markdown
None
```
```markdown
Exec In (
inputs:execIn
)
```
```markdown
execution
```
```markdown
Signal to the graph that this node is ready to be executed.
```
```markdown
None
```
```markdown
Outputs
```
```markdown
Name
```
```markdown
Type
```
```markdown
Descripton
```
```markdown
Default
```
```markdown
Array Index (
outputs:arrayIndex
)
```
```markdown
int
```
```markdown
The value of the current index being visited by the loop. Keeps the value of the last index after the loop has completed. The index starts at zero and increments by one as it walks through the members of ‘Input Array’.
```
```markdown
None
```
```markdown
Element (
outputs:element
)
```
```code
['bool',
'colord[3]',
'colord[4]',
'colorf[3]',
'colorf[4]',
'colorh[3]',
'colorh[4]',
'double',
'double[2]',
'double[3]',
'double[4]',
'float',
'float[2]',
'float[3]',
'float[4]',
'frame[4]',
'half',
'half[2]',
'half[3]',
'half[4]',
'int',
'int64',
'int[2]',
'int[3]',
'int[4]',
'matrixd[2]',
'matrixd[3]',
'matrixd[4]',
'normald[3]',
'normalf[3]',
'normalh[3]',
'pointd[3]',
'pointf[3]',
'pointh[3]',
'quatd[4]',
'quatf[4]',
'quath[4]',
'texcoordd[2]',
'texcoordd[3]',
'texcoordf[2]',
'texcoordf[3]',
'texcoordh[2]',
'texcoordh[3]',
'timecode',
'token',
'transform[4]',
'uchar',
'uint',
'uint64',
'vectord[3]',
'vectorf[3]',
'vectorh[3]']
```
```markdown
The current member of ‘Input Array’ being visited by the loop. Keeps the value of the last array element after the loop has completed.
```
```markdown
None
```
```markdown
Finished (
outputs:finished
)
```
```markdown
execution
```
## Execution
### Loop Initialization
- **Description**: Initialize the loop by signaling the graph that execution can continue downstream.
- **Result**: None
### Loop Body
- **Description**: For each member of 'Input Array', signal the graph that execution can continue downstream.
- **Result**: None
## Metadata
| Name | Value |
|------------|---------------------------------|
| Unique ID | omni.graph.action.ForEach |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Icon | ogn/icons/omni.graph.action.ForEach.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | For Each Loop |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnForEachDatabase |
| Python Module | omni.graph.action_nodes | | 4,107 |
OgnForEachTarget.md | # For Each Target Loop
Activates the ‘Loop Body’ signal once for each target in ‘Targets’, making the current array member available in the output ‘Target’ with its index in ‘Array Index’. After every element of ‘Targets’ has been processed the ‘Finished’ signal is activated. All of this will happen in a single execution of the node, giving you the ability to evaluate a downstream graph multiple times with different inputs coming from the changing ‘Target’ output.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Targets (`inputs:targets`) | `target` | The targets array to loop over | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Array Index (`outputs:arrayIndex`) | `int` | The value of the current index being visited by the loop. Keeps the value of the last index after the loop has completed. The index starts at zero and increments by one as it walks through the members of ‘Targets’. | |
## Metadata
### Name
- Unique ID
- Version
- Extension
- Icon
- Has State?
- Implementation Language
- Default Memory Type
- Generated Code Exclusions
- uiName
- Categories
- Generated Class Name
- Python Module
### Value
- omni.graph.action.ForEachTarget
- 1
- omni.graph.action_nodes
- ogn/icons/omni.graph.action.ForEachTarget.svg
- False
- C++
- cpu
- None
- For Each Target Loop
- graph:action,flowControl
- OgnForEachTargetDatabase
- omni.graph.action_nodes | 1,685 |
OgnForLoop.md | # For Loop
Executes the a loop body once for each value within a range. When step is positive, the values in the range are determined by the formula:
r[i] = start + step*i, i >= 0 & r[i] < stop.
When step is negative the constraint is instead r[i] > stop. A step of zero is an error.
The break input can be used to break out of the loop before the last index. The finished output is executed after all iterations are complete, or when the loop was broken. All of this will happen in a single execution of the node, giving you the ability to evaluate a downstream graph multiple times with different inputs coming from the changing ‘Value’ and ‘Index’ outputs.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Break (inputs:breakLoop) | execution | Signal to the graph that execution of the loop body is to be aborted. It behaves exactly as the ‘break’ statements in Python or C++ behave. After the loop is broken the current ‘Value’ and ‘Index’ retain their current values and the ‘Finished’ signal is activated. | None |
| In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed. | None |
| Start (inputs:start) | int | The first value in the range to loop over. | 0 |
| Step (inputs:step) | int | The step size of the range. This number is added to the ‘Value’ after each execution. The value can be negative to step backwards, however it is an error if the value is zero. | 1 |
| Stop (inputs:stop) | int | The end value of the range. | None |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Start | int | The initial value of the range to loop over. | 0 |
| Step | int | The increment value for each iteration of the loop. | 1 |
| Stop | int | The limiting value of the range to loop over. It may or may not be equal to the final value of the loop, depending on the ‘Step’ value. For example if ‘Start’ is 1, ‘Step’ is 2, and ‘Stop’ is 4 then the loop will run with output ‘Value’s equal to 1 and 3, but not 5. | 0 |
## Outputs
### Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Finished (outputs:finished) | execution | When either the ‘Value’ has reached or exceeded ‘Stop’, or ‘Signal Break’ has activated signal the graph that execution can continue downstream. | None |
| Index (outputs:index) | int | The current value of the index when the loop is active, or the value the index had when the ‘Stop’ threshold was met or exceeded after the loop has completed. The ‘Index’ value starts at zero after the first execution and increments by one each time the loop body runs. | None |
| Loop Body (outputs:loopBody) | execution | For each execution where the ‘Value’ is still in range signal the graph that execution can continue downstream. | None |
| Value (outputs:value) | int | The current value of the range when the loop is active, or the value that met or exceeded the ‘Stop’ threshold after the loop has completed. | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| I (state:i) | int | The next index in the range, or -1 when loop is not active. | -1 |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.ForLoop |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Icon | ogn/icons/omni.graph.action.ForLoop.svg |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| tags | range |
| uiName | For Loop |
| Categories | graph:action,flowControl |
|------------|--------------------------|
| Generated Class Name | OgnForLoopDatabase |
| Python Module | omni.graph.action_nodes | | 3,758 |
OgnGate.md | # Gate
This node controls a flow of execution based on the state of its gate. The gate can be opened or closed by activation of the ‘Toggle’ gate controls. Each time ‘Enter’ is activated, the node will activate the ‘Exit’ signal if the gate is open, and silently succeed if the gate is closed. The current state of the gate is not directly accessible.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Enter (`inputs:enter`) | `execution` | Signal to the graph that this node is ready to be executed. Before this signal is activated the gate will be in the state specified by the ‘Start Closed’ value. | None |
| Start Closed (`inputs:startClosed`) | `bool` | If true the gate will start in a closed state. | False |
| Toggle (`inputs:toggle`) | `execution` | Signal to the node that the state of the gate should switch from open to closed, or vice versa. This signal will not activate the ‘Exit’, it will only determine whether or not the next ‘Enter’ will activate it. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exit (`outputs:exit`) | `execution` | Signal indicating that the node has completed its execution. | None |
# Gate Action Node
## Execution
| Property | Value |
|----------|-------|
| Execution | When ‘Enter’ is activated and the gate is open signal to the graph that execution should continue downstream. |
| None | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.action.Gate |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Icon | ogn/icons/omni.graph.action.Gate.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Gate |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnGateDatabase |
| Python Module | omni.graph.action_nodes | | 1,971 |
OgnGetActiveViewportCamera.md | # Get Active Camera
Gets the path of the camera bound to a viewport
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Viewport (`inputs:viewport`) | `token` | Name of the viewport, or empty for the default viewport | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Camera (`outputs:camera`) | `token` | Path of the active camera | None |
| Camera Prim (`outputs:cameraPrim`) | `target` | The prim of the active camera | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| 属性 | 值 |
| --- | --- |
| omni.graph.ui_nodes.GetActiveViewportCamera | |
| Version | 2 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Get Active Camera |
| Categories | sceneGraph:camera |
| Generated Class Name | OgnGetActiveViewportCameraDatabase |
| Python Module | omni.graph.ui_nodes | | 1,067 |
OgnGetAttrNames.md | # Get Attribute Names From Bundle
Retrieves the names of all of the attributes contained in the input bundle, optionally sorted.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|----------|----------------------------------------------------------------------------|---------|
| Bundle To Examine | bundle | Collection of attributes from which to extract names | None |
| Sort Output | bool | If true, the names will be output in sorted order. If false, the order is not be guaranteed to be consistent between systems or over time, so do not rely on the order downstream in this case. | True |
## Outputs
| Name | Type | Descripton | Default |
|---------------------|-----------|----------------------------------------------------------------------------|---------|
| Attribute Names | token\[\] | Names of all of the attributes contained in the input bundle | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.GetAttributeNames |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Attribute Names From Bundle |
| Categories | bundle |
| Generated Class Name | OgnGetAttrNamesDatabase |
| Python Module | omni.graph.nodes | | 1,639 |
OgnGetCameraPosition.md | # Get Camera Position
Gets a viewport camera position
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (`inputs:prim`) | `target` | The camera prim, when ‘usePath’ is false | None |
| Camera Path (`inputs:primPath`) | `token` | Path of the camera, used when ‘usePath’ is true | |
| Use Path (`inputs:usePath`) | `bool` | When true, the ‘primPath’ attribute is used as the path to the prim being read, otherwise it will read the connection at the ‘prim’ attribute | True |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Position (`outputs:position`) | `pointd[3]` | The position of the camera in world space | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.ui_nodes.GetCameraPosition |
| Version | 2 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Get Camera Position |
| Categories | sceneGraph:camera |
| Generated Class Name | OgnGetCameraPositionDatabase |
| Python Module | omni.graph.ui_nodes | | 1,527 |
OgnGetCameraTarget.md | # Get Camera Target
Gets a viewport camera’s target point.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (inputs:prim) | target | The camera prim, when ‘usePath’ is false | None |
| Camera Path (inputs:primPath) | token | Path of the camera, used when ‘usePath’ is true | |
| Use Path (inputs:usePath) | bool | When true, the ‘primPath’ attribute is used as the path to the prim being read, otherwise it will read the connection at the ‘prim’ attribute | True |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Target (outputs:target) | pointd[3] | The target point | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.ui_nodes.GetCameraTarget |
| Version | 2 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Get Camera Target |
| Categories | sceneGraph:camera |
| Generated Class Name | OgnGetCameraTargetDatabase |
| Python Module | omni.graph.ui_nodes | | 1,484 |
OgnGetGraphTargetId.md | # Get Graph Target Id
Access a unique id for the target prim the graph is being executed on.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Target Id (`outputs:targetId`) | `uint64` | The target prim id | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetGraphTargetId |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | sceneGraph |
| Generated Class Name | OgnGetGraphTargetIdDatabase |
| Python Module | |
# omni.graph.nodes | 719 |
OgnGetGraphTargetPrim.md | # Get Graph Target Prim
Access the target prim the graph is being executed on. If the graph is executing itself, this will output the prim of the graph. Otherwise the graph is being executed via instancing, then this will output the prim of the target instance.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (`outputs:prim`) | `target` | The graph target as a prim | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetGraphTargetPrim |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Graph Target Prim |
| Categories | sceneGraph |
| Generated Class Name | OgnGetGraphTargetPrimDatabase |
|----------------------|--------------------------------|
| Python Module | omni.graph.nodes | | 1,001 |
OgnGetLocationAtDistanceOnCurve.md | # Get Locations At Distances On Curve
DEPRECATED: Use GetLocationAtDistanceOnCurve2
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Curve (`inputs:curve`) | `pointd[3][]` | The curve to be examined | [] |
| Distances (`inputs:distance`) | `double[]` | The distances along the curve, wrapped to the range 0-1.0 | [] |
| Forward (`inputs:forwardAxis`) | `token` | The direction vector from which the returned rotation is relative, one of X, Y, Z | X |
| Up (`inputs:upAxis`) | `token` | The world Up vector, the curve should be in a plane perpendicular with this - one of X, Y, Z | Y |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Metadata
## Name
- Unique ID
- Version
- Extension
- Has State?
- Implementation Language
- Default Memory Type
- Generated Code Exclusions
- hidden
- uiName
- __tokens
- Categories
- Generated Class Name
- Python Module
## Value
- omni.graph.nodes.GetLocationAtDistanceOnCurve
- 1
- omni.graph.nodes
- False
- C++
- cpu
- None
- true
- Get Locations At Distances On Curve
- ["x", "y", "z", "X", "Y", "Z"]
- internal
- OgnGetLocationAtDistanceOnCurveDatabase
- omni.graph.nodes | 1,258 |
OgnGetLocationAtDistanceOnCurve2.md | # Get Locations At Distances On Curve
Given a set of curve points and a normalized distance between 0-1.0, return the location on a closed curve. 0 is the first point on the curve, 1.0 is also the first point because the is an implicit segment connecting the first and last points. Values outside the range 0-1.0 will be wrapped to that range, for example -0.4 is equivalent to 0.6 and 1.3 is equivalent to 0.3. This is a simplistic curve-following node, intended for curves in a plane, for prototyping purposes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Curve (`inputs:curve`) | `pointd[3][]` | The vertex values of the curve to be examined. | [] |
| Distance (`inputs:distance`) | `double` | The distance along the curve, normalized to the range 0-1.0. | 0.0 |
| Forward (`inputs:forwardAxis`) | `token` | The direction vector from which the returned rotation is relative. The legal values are ‘X’, ‘Y’, or ‘Z’. | X |
| Up (`inputs:upAxis`) | `token` | The world Up vector, the curve should be in a plane perpendicular with this. The legal values are ‘X’, ‘Y’, or ‘Z’. | Y |
## Outputs
| Name | Type | Descripton |
| --- | --- | --- |
## Metadata
### Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.GetLocationAtDistanceOnCurve2 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Get Locations At Distances On Curve |
| __tokens | ["x", "y", "z", "X", "Y", "Z"] |
| Categories | internal |
| Generated Class Name | OgnGetLocationAtDistanceOnCurve2Database |
| Python Module | omni.graph.nodes | | 2,165 |
OgnGetLookAtRotation.md | # Get Look At Rotation
Computes the rotation angles to align the ‘Forward’ direction vector to the vector formed by starting at ‘From’ and pointing at ‘Target’. The ‘Forward’ vector is the current orientation of the Prim being rotated which usually starts at +X or +Z. The ‘Up’ vector defines the desired orientation of the rotation.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Forward (`inputs:forward`) | `double[3]` | The direction vector which is to be aligned | [0.0, 0.0, 1.0] |
| From (`inputs:start`) | `pointd[3]` | The position to look from | [0.0, 0.0, 0.0] |
| Target (`inputs:target`) | `pointd[3]` | The position to look at | [0.0, 0.0, 0.0] |
| Up (`inputs:up`) | `double[3]` | The direction of the up vector, if not specified USD scene-up will be used. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Outputs
| Description | Default |
|-------------|---------|
| Orientation (outputs:orientation) | `quatd[4]` |
| The calculated orientation quaternion, which is equivalent to ‘Rotation (XYZ)’ | None |
| Rotation (XYZ) (outputs:rotateXYZ) | `double[3]` |
| The calculated rotation vector, as XYZ | None |
# Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.GetLookAtRotation |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Look At Rotation |
| Categories | math:operator |
| Generated Class Name | OgnGetLookAtRotationDatabase |
| Python Module | omni.graph.nodes | | 1,714 |
OgnGetMatrix4Quaternion.md | # Get Rotation Quaternion
Gets the rotation of the given matrix or rotation angles value which represents a linear transformation. Returns the quaternion orientation component.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (inputs:matrix) | ['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]'] | The matrix or rotation angles to extract the quaternion from. | None |
| Rotation Order (inputs:rotationOrder) | token | The order the rotation should be applied when using rotation angles. | XYZ |
| Metadata | allowedTokens = XYZ,XZY,YXZ,YZX,ZXY,ZYX | | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Orientation ( | | | |
<em>
outputs:quaternion
)
<code class="docutils literal notranslate">
<span class="pre">
['quatd[4]',
<span class="pre">
'quatd[4][]',
<span class="pre">
'quatf[4]',
<span class="pre">
'quatf[4][]',
<span class="pre">
'quath[4]',
<span class="pre">
'quath[4][]']
The quaternion representing the orientation of the transformation.
None
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.GetMatrix4Quaternion |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Rotation Quaternion |
| Categories | math:operator |
| Generated Class Name | OgnGetMatrix4QuaternionDatabase |
| Python Module | omni.graph.nodes | | 2,013 |
OgnGetMatrix4Rotation.md | # Get Rotation
Gets the rotation of the given matrix3d, matrix4d or quaternion value which represents a linear transformation. Returns the vector3 rotation in the given rotation order
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------|----------------------------------------------------------------------|-------------------------------------|---------|
| Input (inputs:matrix) | `['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]']` | The matrix or quaternion to extract the rotation from. | None |
| Rotation Order (inputs:rotationOrder) | `token` | The order of the output rotation angles. | XYZ |
| Metadata | | `allowedTokens = XYZ,XZY,YXZ,YZX,ZXY,ZYX` | |
## Outputs
| Name | Type | Descripton | Default |
|---------------|----------------------------------------------------------------------|-------------------------------------|---------|
| Rotation (outputs:rotation) | `vector3` | The extracted rotation. | |
# Table of Inputs
| Input Name | Type | Description | Default Value |
|------------|------|-------------|---------------|
| matrixd[3] | float[3][3] | The matrix representing the transformation. | None |
| matrixd[3][] | float[3][3] | The matrix representing the transformation. | None |
| matrixf[3] | float[3][3] | The matrix representing the transformation. | None |
| matrixf[3][] | float[3][3] | The matrix representing the transformation. | None |
| matrixh[3] | float[3][3] | The matrix representing the transformation. | None |
| matrixh[3][] | float[3][3] | The matrix representing the transformation. | None |
# Table of Outputs
| Output Name | Type | Description | Default Value |
|-------------|------|-------------|---------------|
| vectord[3] | float[3] | The vector representing the rotation of the transformation. | None |
| vectord[3][] | float[3] | The vector representing the rotation of the transformation. | None |
| vectorf[3] | float[3] | The vector representing the rotation of the transformation. | None |
| vectorf[3][] | float[3] | The vector representing the rotation of the transformation. | None |
| vectorh[3] | float[3] | The vector representing the rotation of the transformation. | None |
| vectorh[3][] | float[3] | The vector representing the rotation of the transformation. | None |
# Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.GetMatrix4Rotation |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Rotation |
| Categories | math:operator |
| Generated Class Name | OgnGetMatrix4RotationDatabase |
| Python Module | omni.graph.nodes | | 3,281 |
OgnGetMatrix4RotationMatrix.md | # Get Rotation Matrix
Gets the rotation matrix of the given matrix4d, rotation angles or quaternion value which represents a linear transformation. Returns the matrix3d rotation matrix.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (inputs:matrix) | ['matrixd[4]', 'matrixd[4][]', 'quatd[4]', 'quatd[4][]', 'vectord[3]', 'vectord[3][]'] | The matrix, rotation angles or quaternion to extract the rotation from. | None |
| Rotation Order (inputs:rotationOrder) | token | The order the rotation should be applied when using rotation angles. | XYZ |
| | Metadata | allowedTokens = XYZ,XZY,YXZ,YZX,ZXY,ZYX | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Rotation (outputs:rotation) | ['matrixd[3]', | The rotation matrix extracted from the input. | None |
# Parameters
## matrixd[3][]
- **Type**: float[3][4]
- **Description**: The matrix representing the rotation of the transformation.
- **Default**: None
# Metadata
| Name | Value |
|------------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.GetMatrix4RotationMatrix |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Rotation Matrix |
| Categories | math:operator |
| Generated Class Name | OgnGetMatrix4RotationMatrixDatabase |
| Python Module | omni.graph.nodes | | 1,928 |
OgnGetMatrix4Scale.md | # Get Scale
Gets the scale of the given matrix3d or matrix4d value which represents a linear transformation. Returns the vector3 scale component.
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Transform (inputs:matrix) | ['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]'] | The matrix to extract the scale from. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Scale (outputs:scale) | ['vectord[3]', 'vectord[3][]'] | The vector that represents the scale of the transformation. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetMatrix4Scale |
| Version | 1 |
|---------|---|
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Scale |
| Categories | math:operator |
| Generated Class Name | OgnGetMatrix4ScaleDatabase |
| Python Module | omni.graph.nodes | | 1,123 |
OgnGetMatrix4Translation.md | # Get Translation
Gets the translation of the given matrix4d value which represents a linear transformation. Returns the vector3 translation component
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|-------------------------------------------|-------------------------------------|---------|
| Transform (inputs:matrix) | ['matrixd[4]', 'matrixd[4][]'] | The matrix to extract the translate from. | None |
## Outputs
| Name | Type | Descripton | Default |
|---------------------|-------------------------------------------|-------------------------------------|---------|
| Translation (outputs:translation) | ['vectord[3]', 'vectord[3][]'] | The vector that represents the translation of the transformation. | None |
## Metadata
| Name | Value |
|-------------|---------------------------------------|
| Unique ID | omni.graph.nodes.GetMatrix4Translation |
| Version | |
1
| Extension | omni.graph.nodes |
|-----------|------------------|
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Translation |
| Categories | math:operator |
| Generated Class Name | OgnGetMatrix4TranslationDatabase |
| Python Module | omni.graph.nodes | | 1,582 |
OgnGetParentPath.md | # Get Parent Path
Generates a parent path token from another path token. (ex. /World/Cube -> /World)
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Path (`inputs:path`) | `['token', 'token[]']` | One or more path tokens to compute a parent path from. (ex. /World/Cube) | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Parent Path (`outputs:parentPath`) | `['token', 'token[]']` | Parent path token (ex. /World) | None |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Path (`state:path`) | | | |
# Metadata
| Name | Value |
|-------------|--------------------------------|
| Unique ID | omni.graph.nodes.GetParentPath |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Parent Path |
| Categories | sceneGraph |
| Generated Class Name | OgnGetParentPathDatabase |
| Python Module | omni.graph.nodes | | 1,334 |
OgnGetParentPrims.md | # Get Target Parents
Generates parent paths from one or more targeted paths (ex. /World/Cube -> /World)
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Targets (inputs:prims) | `target` | Input paths (ex. /World/Cube) | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Target Parents (outputs:parentPrims) | `target` | Computed parent paths (ex. /World) | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetParentPrims |
| Key | Value |
|--------------------|----------------------|
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type| cpu |
| Generated Code Exclusions | None |
| uiName | Get Target Parents |
| Categories | sceneGraph |
| Generated Class Name | OgnGetParentPrimsDatabase |
| Python Module | omni.graph.nodes | | 1,217 |
OgnGetPrimDirectionVector.md | # Get Prim Direction Vector
Given a prim, find its direction vectors (up vector, forward vector, right vector, etc.)
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (inputs:prim) | target | The connection to the input prim - this attribute is used when ‘usePath’ is false | None |
| Prim Path (inputs:primPath) | token | The path of the input prim - this attribute is used when ‘usePath’ is true | |
| Use Path (inputs:usePath) | bool | When true, it will use the ‘primPath’ attribute as the path to the prim, otherwise it will read the connection at the ‘prim’ attribute | True |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Backward Vector (outputs:backwardVector) | double[3] | The backward vector of the prim | |
## Prim Direction Vector
### Down Vector (outputs:downVector)
double[3]
```
The down vector of the prim
### Forward Vector (outputs:forwardVector)
double[3]
```
The forward vector of the prim
### Left Vector (outputs:leftVector)
double[3]
```
The left vector of the prim
### Right Vector (outputs:rightVector)
double[3]
```
The right vector of the prim
### Up Vector (outputs:upVector)
double[3]
```
The up vector of the prim
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.GetPrimDirectionVector |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Prim Direction Vector |
| Categories | sceneGraph |
| Generated Class Name | OgnGetPrimDirectionVectorDatabase |
| Python Module | omni.graph.nodes |
``` | 2,080 |
OgnGetPrimLocalToWorldTransform.md | # Get Prim Local to World Transform
Given a path to a prim on the current USD stage, returns the transformation matrix that transforms a vector from the local frame to the global frame.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (`inputs:prim`) | `target` | The prim used as the local coordinate system when ‘Use Path’ is false | None |
| Prim Path (`inputs:primPath`) | `token` | The path of the prim used as the local coordinate system when ‘Use Path’ is true | |
| Use Path (`inputs:usePath`) | `bool` | When true, the ‘Prim Path’ attribute is used as the path to the prim being read otherwise it will read the connection at the ‘Prim’ attribute | True |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Local Transform (`outputs:localToWorldTransform`) | `matrixd[4]` | | |
## Metadata
| Name | Value |
|-------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.nodes.GetPrimLocalToWorldTransform |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Prim Local to World Transform |
| Categories | sceneGraph |
| Generated Class Name | OgnGetPrimLocalToWorldTransformDatabase |
| Python Module | omni.graph.nodes | | 2,072 |
OgnGetPrimPath.md | # Get Prim Path
Generates a path from the specified relationship. This is useful when an absolute prim path may change.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (inputs:prim) | `target` | The prim to determine the path of | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Path (outputs:path) | `path` | The absolute path of the given prim as a string | None |
| Prim Path (outputs:primPath) | `token` | The absolute path of the given prim as a token | None |
## Metadata
| Name | Value |
| --- | --- |
```
| Unique ID | omni.graph.nodes.GetPrimPath |
|------------------------|------------------------------|
| Version | 3 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language| C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Prim Path |
| Categories | sceneGraph |
| Generated Class Name | OgnGetPrimPathDatabase |
| Python Module | omni.graph.nodes | | 1,362 |
OgnGetPrimPaths.md | # Get Prim Paths
Generates a path array from the specified relationship. This is useful when absolute prim paths may change.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prims (`inputs:prims`) | `target` | Relationship to prims on the stage | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim Paths (`outputs:primPaths`) | `token[]` | The absolute paths of the given prims as a token array | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetPrimPaths |
| 属性 | 值 |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Prim Paths |
| Categories | sceneGraph |
| Generated Class Name | OgnGetPrimPathsDatabase |
| Python Module | omni.graph.nodes | | 1,034 |
OgnGetPrimRelationship.md | # Get Prim Relationship
DEPRECATED - Use ReadPrimRelationship!
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Relationship Name (`inputs:name`) | `token` | Name of the relationship property | |
| Prim Path (`inputs:path`) | `token` | Path of the prim with the relationship property | None |
| Prim (`inputs:prim`) | `target` | The prim with the relationship | None |
| Use Path (`inputs:usePath`) | `bool` | When true, the ‘path’ attribute is used, otherwise it will read the connection at the ‘prim’ attribute. | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Paths (`outputs:paths`) | | | |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.GetPrimRelationship |
| Version | 3 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Get Prim Relationship |
| Categories | sceneGraph |
| Generated Class Name | OgnGetPrimRelationshipDatabase |
| Python Module | omni.graph.nodes | | 1,615 |
OgnGetPrims.md | # Get Prims
Filters primitives in the input bundle by path and type.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle (`inputs:bundle`) | `bundle` | The bundle to be read from | None |
| Inverse (`inputs:inverse`) | `bool` | By default all primitives matching the path patterns and types are added to the output bundle; when this option is on, all mismatching primitives will be added instead. | False |
| Path Pattern (`inputs:pathPattern`) | `string` | A list of wildcard patterns used to match primitive path. Supported syntax of wildcard pattern: `*` - match an arbitrary number of any characters `?` - match any single character `^` - (caret) is used to define a pattern that is to be excluded Example of wildcard patterns, input: [`/Cube0`, `/Cube1`, `/Box`] `*` - match any `* ^/Box` - match any, but exclude `/Box` `* ^/Cube*` - match any, but exclude `/Cube0` and `/Cube1` | |
| Prims (`inputs:prims`) | `target` | The prim to be extracted from Multiple Primitives in Bundle. | None |
| Metadata | | `allowMultiInputs` = 1 | |
# Type Pattern
- **inputs:typePattern**
- **Type:** `string`
- **Description:** A list of wildcard patterns used to match primitive type. Supported syntax of wildcard pattern:
- `*` - match an arbitrary number of any characters
- `?` - match any single character
- `^` - (caret) is used to define a pattern that is to be excluded
- Example of wildcard patterns, input: [‘Mesh’, ‘Cone’, ‘Cube’]
- `*` - match any
- `* ^Mesh` - match any, but exclude ‘Mesh’
- `* ^Cone ^Cube` - match any, but exclude ‘Cone’ and ‘Cube’
# Outputs
- **outputs:bundle**
- **Type:** `bundle`
- **Description:** The output bundle that contains filtered primitives
- **Default:** None
# Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.GetPrims |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Prims |
| Categories | bundle |
| Generated Class Name | OgnGetPrimsDatabase |
| Python Module | omni.graph.nodes | | 2,476 |
OgnGetPrimsAtPath.md | # Get Prims At Path (Legacy)
DEPRECATED - Use ToTarget
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Path (`inputs:path`) | `['token', 'token[]']` | A token or token array to compute representing a path. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prims (`outputs:prims`) | `target` | The output prim paths | None |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Path (`state:path`) | `token` | | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.GetPrimsAtPath |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Get Prims At Path (Legacy) |
| Categories | sceneGraph |
| Generated Class Name | OgnGetPrimsAtPathDatabase |
| Python Module | omni.graph.nodes | | 1,429 |
OgnGetRelativePath.md | # Get Relative Path
Generates a path token relative to anchor from path.(ex. (/World, /World/Cube) -> /Cube)
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Anchor (inputs:anchor) | `token` | Path token to compute relative to (ex. /World) | |
| Path (inputs:path) | `['token', 'token[]']` | Path token to convert to a relative path (ex. /World/Cube) | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Relative Path (outputs:relativePath) | `['token', 'token[]']` | Relative path token (ex. /Cube) | None |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| State Name (state:stateName) | `stateType` | Description of the state | Default State |
# Metadata
## Metadata
### Name
### Value
#### Name
#### Value
- Unique ID
- omni.graph.nodes.GetRelativePath
- Version
- 1
- Extension
- omni.graph.nodes
- Has State?
- True
- Implementation Language
- C++
- Default Memory Type
- cpu
- Generated Code Exclusions
- None
- uiName
- Get Relative Path
- Categories
- sceneGraph
- Generated Class Name
- OgnGetRelativePathDatabase
- Python Module
- omni.graph.nodes | 1,252 |
OgnGetString.md | # Get String
Return a string in a base string at index with count.
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-------------|---------|----------------------------------------------------------------------------|---------|
| Count | int | The number of characters to return. When set to -1, the length of “string” will be used. | -1 |
| Index | int | The index of the string in the range [-stringLength, stringLength). Negative values index from the end of the string, and values out of range will result in an error. | 0 |
| String | ['string', 'token'] | The base string. | None |
## Outputs
| Name | Type | Descripton | Default |
|-------------|---------|----------------------------------------------------------------------------|---------|
| String | ['string', 'token'] | The extracted string. | |
# Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.GetString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get String |
| Categories | function |
| Generated Class Name | OgnGetStringDatabase |
| Python Module | omni.graph.nodes | | 1,876 |
OgnGetStringLength.md | # Get String Length
Return the length of the provided string.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| String (`inputs:string`) | `['string', 'token', 'token[]']` | The input string. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Length (`outputs:length`) | `['int', 'int[]']` | The length of the string. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetStringLength |
| Version | 1 |
| Extension | omni.graph.nodes |
|-----------|------------------|
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get String Length |
| Categories | function |
| Generated Class Name | OgnGetStringLengthDatabase |
| Python Module | omni.graph.nodes | | 929 |
OgnGetTargets.md | # Get Targets
Returns targets from an array at an index in range [-arrayLength, arrayLength). If the given index is negative it will be an offset from the end of the array.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Count (inputs:count) | int | The number of paths to return. Only returns as many paths as possible until the end of the array. A value of -1 will return values until the end of the array | 1 |
| Index (inputs:index) | int | The index into the array in range [-arrayLength, arrayLength). A negative value indexes from the end of the array. | 0 |
| Targets (inputs:targets) | target | The input target array. | None |
| Metadata | | allowMultiInputs = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Targets (outputs:targets) | | | |
# Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.GetTargets |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Targets |
| Categories | sceneGraph |
| Generated Class Name | OgnGetTargetsDatabase |
| Python Module | omni.graph.nodes | | 1,548 |
OgnGetTargetsSize.md | # Get Targets Size
Returns the size of the target array.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Targets (`inputs:targets`) | `target` | The input target array. | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Size (`outputs:size`) | `int` | The size of the target array. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetTargetsSize |
| Version | |
1
| Extension | omni.graph.nodes |
|-----------|------------------|
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Targets Size |
| Categories | sceneGraph |
| Generated Class Name | OgnGetTargetsSizeDatabase |
| Python Module | omni.graph.nodes | | 935 |
OgnGetVariantNames.md | # Get Variant Names
Get variant names from a variantSet on a prim
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (inputs:prim) | target | The prim with the variantSet | None |
| Variant Set Name (inputs:variantSetName) | token | The variantSet name | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Variant Names (outputs:variantNames) | token[] | List of variant names | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| 属性 | 值 |
| --- | --- |
| omni.graph.nodes.GetVariantNames | |
| Version | 2 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.GetVariantNames.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Variant Names |
| Categories | graph:action,sceneGraph,variants |
| Generated Class Name | OgnGetVariantNamesDatabase |
| Python Module | omni.graph.nodes | | 1,068 |
OgnGetVariantSelection.md | # Get Variant Selection
Get the variant selection on a prim
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (inputs:prim) | target | The prim with the variantSet | None |
| Variant Set Name (inputs:variantSetName) | token | The variantSet name | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Variant Name (outputs:variantName) | token | The variant name | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| omni.graph.nodes.GetVariantSelection | 2 |
| --- | --- |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.GetVariantSelection.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Variant Selection |
| Categories | graph:action,sceneGraph,variants |
| Generated Class Name | OgnGetVariantSelectionDatabase |
| Python Module | omni.graph.nodes | | 1,077 |
OgnGetVariantSetNames.md | # Get Variant Set Names
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (`inputs:prim`) | `target` | The prim with the variantSet | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Variant Set Names (`outputs:variantSetNames`) | `token[]` | List of variantSet names | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetVariantSetNames |
| Version | 2 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.GetVariantSetNames.svg |
| --- | --- |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Variant Set Names |
| Categories | graph:action,sceneGraph,variants |
| Generated Class Name | OgnGetVariantSetNamesDatabase |
| Python Module | omni.graph.nodes | | 955 |
OgnGetViewportRenderer.md | # Get Viewport Renderer
Gets the renderer being used by the target viewport.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Viewport (`inputs:viewport`) | `token` | Name of the viewport, or empty for the default viewport | Viewport |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Renderer (`outputs:renderer`) | `token` | The renderer being used by the target viewport | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.GetViewportRenderer |
| Version | 1 |
| Extension |
| 属性 | 值 |
|------------------------|------------------|
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Get Viewport Renderer |
| Categories | viewport |
| Generated Class Name | OgnGetViewportRendererDatabase |
| Python Module | omni.graph.ui_nodes | | 1,150 |
OgnGetViewportResolution.md | # Get Viewport Resolution
Gets the resolution of the target viewport.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Viewport (`inputs:viewport`) | `token` | Name of the viewport, or empty for the default viewport | Viewport |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Resolution (`outputs:resolution`) | `int[2]` | The resolution of the target viewport | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.GetViewportResolution |
| Version | 1 |
| Extension | |
omni.graph.ui_nodes
Has State?
False
Implementation Language
Python
Default Memory Type
cpu
Generated Code Exclusions
tests
uiName
Get Viewport Resolution
Categories
viewport
Generated Class Name
OgnGetViewportResolutionDatabase
Python Module
omni.graph.ui_nodes | 930 |
OgnGpuInteropAdjustExposure.md | # GPU Interop Example: Adjust Render Exposure
RTX Renderer Postprocess Example: adjust the exposure of the rendered image. The node can be used in a post-render graph to change the brightness of the rendered image. As a CUDA interop node, the node is scheduled for execution as a CUDA command. If the input RenderVar is not a valid texture, the node does not produce a result.
## Installation
To use this node enable `omni.graph.image.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| RenderVar Data (inputs:cudaMipmappedArray) | `uint64` | The RenderVar data, defined as a CUDA Mipmapped Array. | 0 |
| Exposure (inputs:exposure) | `float` | Exposure value (in stops). Positive values increase the brightness of the image, while negative values result in darker images. The default exposure value of 0 results in an unmodified image. Increasing the value by one unit, results in a doubling of the exposure and a brighter image; decreasing the value by one unit results in a halving of the exposure, thus a darker image. | 0 |
| Texture Format (inputs:format) | `uint64` | The texture format of the input image, matching the values of the enum carb::graphics::Format. | 0 |
| Height (inputs:height) | `uint` | The height of the input image. | 0 |
| Renderer Time (inputs:hydraTime) | `float` | The time at which the renderer is executing. | 0 |
# Metadata
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.GpuInteropAdjustExposure |
| Version | 2 |
| Extension | omni.graph.image.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | GPU Interop Example: Adjust Render Exposure |
| Categories | examples,graph:postRender,rendering |
| Generated Class Name | OgnGpuInteropAdjustExposureDatabase |
| Python Module | omni.graph.image.nodes | | 1,939 |
OgnGpuInteropCpuToDisk.md | # GPU Interop: Cpu To Disk
Saves the specified CPU buffer to disk. The node assumes that the RenderVar (AOV) has already been copied to the host (CPU) memory.
## Installation
To use this node enable `omni.graph.image.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Active Reset (`inputs:active`) | `bool` | If true, the node computes once, then resets to false. It is useful to use in runtime scripts or tests, where a single frame should be captured at a time. | False |
| AOV CPU (`inputs:aovCpu`) | `string` | Name of AOV representing the CPU buffer of GPU resource. It is assumed that the CPU RenderVar is a copy of the GPU data. If the CPU AOV is invalid, the node does not output anything. | |
| AOV GPU (`inputs:aovGpu`) | `string` | Name of AOV representing the GPU resource, used for querying format and properties. | |
| Auto File Number (`inputs:autoFileNumber`) | `int` | If non zero, this number will be the starting number for export. Each invocation of this node increases the number by 1. | -1 |
| File Name (`inputs:fileName`) | `string` | Optional, name given to the output file. If specified the output filename will be ‘File Name_{aovGpu}.{fileType}’. | |
## Inputs
| Name | Type | Description | Default |
|-------------------------------|--------|-----------------------------------------------------------------------------|---------|
| File Number (inputs:fileNumber) | int | Number that will be appended to the exported filename. If -1 then the render product’s frame number will be used. | -1 |
| File Type (inputs:fileType) | string | The file type of the saved images. The valid types are bmp, png and exr. | png |
| Frame Count (inputs:frameCount) | int64 | Number of frames to capture. If set to -1, the node execution never stops. | -1 |
| GPU Foundations (inputs:gpu) | uint64 | The shared context containing GPU foundation interfaces. | 0 |
| Max Concurrent Writes (inputs:maxInflightWrites) | int | Specifies the maximum allowed concurrent asynchronous file write operations dispatched by the node, preventing potential blocking on file I/O for the Render thread. This attribute controls the number of writes before waiting to dispatch a new I/O command. If the number of concurrent writes is reached, the Render Thread waits for the existing write commands to complete before dispatching new commands. | 2 |
| Render Product (inputs:rp) | uint64 | The render product for this view. | 0 |
| Save Flags (inputs:saveFlags) | uint64 | Flags that will be passed to carb::imaging::IImaging for file saving. | 0 |
| Save Location (inputs:saveLocation) | string | The path to save AOVs as AOV_FrameNumber.{exr,png} | |
| Start Frame (inputs:startFrame) | uint64 | Frame number to begin saving to disk. | 0 |
## Outputs
| Name | Type | Description | Default |
|-------------------------------|--------|-----------------------------------------------------------------------------|---------|
| GPU Foundations (outputs:gpu) | uint64 | The shared context containing GPU foundation interfaces. | None |
| Render Product (outputs:rp) | uint64 | The render product for this view. | None |
| Header | Value |
|--------|-------|
| Unique ID | omni.graph.examples.cpp.GpuInteropCpuToDisk |
| Version | 2 |
| Extension | omni.graph.image.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | GPU Interop: Cpu To Disk |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnGpuInteropCpuToDiskDatabase |
| Python Module | omni.graph.image.nodes | | 4,081 |
OgnGpuInteropCudaEntry.md | # GPU Interop: Cuda Entry
Entry node for post-processing hydra render results for a single view. It outputs the properties of a RenderVar as attributes accessible to downstream nodes. All downstream nodes are scheduled as CUDA commands.
## Installation
To use this node enable `omni.graph.image.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Source Name (`inputs:sourceName`) | `string` | The name of the source RenderVar (AOV). The properties of this AOV are the output of this node. | ldrColor |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Buffer Size (`outputs:bufferSize`) | `uint` | Size of the buffer, if the selected RenderVar is a buffer, otherwise it represents the texture depth. | None |
| RenderVar Data (`outputs:cudaMipmappedArray`) | `uint64` | The RenderVar data, which is represented as a CUDA Mipmapped Array. | None |
| External Time Of Simulation Frame (`outputs:externalTimeOfSimFrame`) | `uint64` | The external time of the simulation frame. | None |
| Name | Description |
| --- | --- |
| External Time | The external time on the master node, matching the simulation frame used to render this frame. It is only valid if the simulation and rendering are performed at the same, or different but constant rates. |
| Texture Format | The texture format of the input image, matching the values of the enum carb::graphics::Format. If the RenderVar is a buffer, the value is unknown. |
| Frame ID | The frame number. It is only valid if the simulation and rendering are performed at the same, or different but constant rates. |
| Height | The width of the selected texture RenderVar. If the RenderVar is an arbitrary buffer, it is 0. |
| Renderer Time | The time difference since the last rendered frame. |
| Is Buffer | True if the entry exposes an arbitrary buffer RenderVar as opposed to a texture RenderVar. |
| Mip Count | The number of levels of detail encoded in ‘RenderVar Data’. If the RenderVar is not a texture, the value is 0. |
| Rational Time Of Sim Denominator | The denominator of the simulation time expressed as rational time. It is always valid and may be used to fetch data from Fabric during the node compute. |
| Rational Time Of Sim Numerator | The numerator of the simulation time expressed as rational time. It is always valid and may be used to fetch data from Fabric during the node compute. |
| Simulation Time | The time difference since the last simulation frame. May suffer from loss of precision and cannot be used as a deterministic identifier, for example for fetching data from Fabric during the node compute - use the Rational Time instead in that case. |
| Stream | The CUDA Stream used to order the CUDA commands scheduled by this graph execution. |
| Width | The width of the selected texture RenderVar. If the RenderVar is an arbitrary buffer, it is 0. |
| Unique ID | omni.graph.nodes.GpuInteropCudaEntry |
| Version | 3 |
| Extension | omni.graph.image.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | GPU Interop: Cuda Entry |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnGpuInteropCudaEntryDatabase |
| Python Module | omni.graph.image.nodes | | 3,660 |
OgnGpuInteropGpuToCpuCopy.md | # GPU Interop: Gpu To Cpu Copy
Generates a new AOV representing a CPU copy of a GPU buffer
## Installation
To use this node enable `omni.graph.image.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|------------|----------------------------------------------------------------------------|---------|
| AOV GPU (`inputs:aovGpu`) | `string` | Name of the RenderVar to copy from GPU to CPU. The RenderVar must be a valid texture on the RenderProduct, otherwise this node will not do anything. | |
| GPU Foundations (`inputs:gpu`) | `uint64` | The shared context containing GPU foundation interfaces. | 0 |
| Render Product (`inputs:rp`) | `uint64` | The render product for this view. | 0 |
## Outputs
| Name | Type | Descripton | Default |
|------|------------|----------------------------------------------------------------------------|---------|
| AOV CPU (`outputs:aovCpu`) | `string` | | |
# Metadata
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.GpuInteropGpuToCpuCopy |
| Version | 2 |
| Extension | omni.graph.image.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | GPU Interop: Gpu To Cpu Copy |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnGpuInteropGpuToCpuCopyDatabase |
| Python Module | omni.graph.image.nodes | | 1,734 |
OgnGpuInteropRenderProductEntry.md | # GPU Interop: Render Product Entry
Entry node for post-processing hydra render results for a single view. Gives direct access to the RenderProduct and GPU interfaces.
## Installation
To use this node enable `omni.graph.image.nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`outputs:exec`) | `execution` | Trigger for scheduling dependencies. | None |
| GPU Foundations (`outputs:gpu`) | `uint64` | The shared context containing GPU foundation interfaces. | None |
| Renderer Time (`outputs:hydraTime`) | `double` | The time difference since the last rendered frame. | None |
| Render Product (`outputs:rp`) | `uint64` | The to render product for this view. | None |
| Simulation Time (`outputs:simTime`) | `double` | The time difference since the last simulation frame. May suffer from loss of precision and cannot be used as a deterministic identifier, for example for fetching data from Fabric during the node compute. | None |
## Metadata
| Name | Value |
|--------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.nodes.GpuInteropRenderProductEntry |
| Version | 2 |
| Extension | omni.graph.image.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | GPU Interop: Render Product Entry |
| Categories | internal,graph:postRender,rendering |
| Generated Class Name | OgnGpuInteropRenderProductEntryDatabase |
| Python Module | omni.graph.image.nodes | | 2,270 |
OgnGraphTarget.md | # Get Graph Target
Access the target prim the graph is being executed on. If the graph is executing itself, this will output the prim path of the graph. Otherwise the graph is being executed via instancing, then this will output the prim path of the target instance.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Target Path (`inputs:targetPath`) | `token` | Deprecated. Do not use. | |
| Metadata | | `hidden` = true | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim Path (`outputs:primPath`) | `token` | The target prim path | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GraphTarget |
| Version | 1 |
|---------|---|
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get Graph Target |
| Categories | sceneGraph |
| Generated Class Name | OgnGraphTargetDatabase |
| Python Module | omni.graph.nodes | | 1,117 |
OgnHasAttr.md | # Has Attribute
Inspect an input bundle for a named attribute, setting output to true if it exists
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|------------|--------------------------------------|---------|
| Attribute To Find | token | Name of the attribute to look for in the bundle | points |
| Bundle To Check | bundle | Collection of attributes that may contain the named attribute | None |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|------------|--------------------------------------|---------|
| Is Attribute In Bundle| bool | True if the named attribute was found in the bundle | None |
## Metadata
| Name | Value |
|-----------------------|------------|
| Unique ID | omni.graph.nodes.HasAttribute |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Has Attribute |
| Categories | bundle |
| Generated Class Name | OgnHasAttrDatabase |
| Python Module | omni.graph.nodes | | 1,325 |
OgnHasVariantSet.md | # Has Variant Set
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (`inputs:prim`) | `target` | The prim with the variantSet | None |
| Variant Set Name (`inputs:variantSetName`) | `token` | The variantSet name | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exists (`outputs:exists`) | `bool` | Variant exists | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.HasVariantSet |
| Version | 2 |
| --- | --- |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.HasVariantSet.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Has Variant Set |
| Categories | graph:action,sceneGraph,variants |
| Generated Class Name | OgnHasVariantSetDatabase |
| Python Module | omni.graph.nodes | | 976 |
OgnHTTPPost.md | # HTTP Post
A node that will send a synchronous HTTP POST request
## Installation
To use this node enable [omni.graph.http](../Overview.html#ext-omni-graph-http) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Data (inputs:data) | string | Data of the request (optionally) specified in JSON format | |
| Exec In (inputs:execIn) | execution | Trigger the output | None |
| URL (inputs:url) | string | URL for HTTP request | |
| Use JSON (inputs:use_json) | bool | Use JSON encoding for data | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (outputs:execOut) | execution | | |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.http.HTTPPost |
| Version | 1 |
| Extension | omni.graph.http |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | usd |
| uiName | HTTP Post |
| Categories | internal |
| Generated Class Name | OgnHTTPPostDatabase |
| Python Module | omni.graph.http.python | | 1,323 |
OgnIK.md | # Example Node: Simple IK
Example node that employs a simple IK algorithm to match a three-joint limb to a goal
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Goal Transform (`inputs:goal`) | `matrixd[4]` | Transform of the IK goal | [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]] |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Ankle Transform (`state:ankle`) | `matrixd[4]` | Computed transform of the ankle joint | None |
| Hip Transform (`state:hip`) | `matrixd[4]` | Computed transform of the hip joint | None |
| Knee Transform (`state:knee`) | `matrixd[4]` | Computed transform of the knee joint | None |
## Metadata
| Name | Value |
|-------------|--------------------------------------------|
| Unique ID | omni.graph.examples.cpp.SimpleIk |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Simple IK |
| Categories | examples |
| Generated Class Name | OgnIKDatabase |
| Python Module | omni.graph.examples.cpp | | 1,603 |
OgnImage2Volume.md | # Image2Volume Node
Image to hair volume inference node
## Installation
To use this node enable [omni.sim.haircomposer](../Overview.html#ext-omni-sim-haircomposer) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|------------|-------------------------------------|---------|
| inputs:debug_output_dir | string | Writes debug output to this dir | |
| inputs:image_filename | string | Input image filename | |
## Outputs
| Name | Type | Descripton | Default |
|---------------------|------------|-------------------------------------|---------|
| outputs:occ_grid | uchar[] | Hair volume occupancy | None |
| outputs:ori_grid | uchar[] | Hair volume orientation | None |
## Metadata
| Name | Descripton |
|---------------------|-------------------------------------|
| | |
| Unique ID | omni.sim.haircomposer.Image2Volume |
| --- | --- |
| Version | 1 |
| Extension | omni.sim.haircomposer |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Image2Volume Node |
| Categories | geometry |
| Generated Class Name | OgnImage2VolumeDatabase |
| Python Module | omni.sim.haircomposer | | 1,498 |
OgnImportUSDPrim.md | # import USD prim data
Imports data from a USD prim into attributes in an output bundle This node is deprecated, Use ReadPrim nodes instead
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Apply Skel Binding (`inputs:applySkelBinding`) | `bool` | If the input USD prim is a Mesh, and has SkelBindingAPI schema applied, compute skinned points and normals. | True |
| Metadata | | `displayGroup` = parameters | |
| Apply Transform (`inputs:applyTransform`) | `bool` | If importAttributes is true, apply the transform necessary to transform any transforming attributes into the space of this node. | False |
| Metadata | | `displayGroup` = parameters | |
| Attributes To Import (`inputs:attrNamesToImport`) | `token` | Comma or space separated text, listing the names of attributes in the input data to be imported or empty to import all attributes. | |
| Metadata | | `displayGroup` = parameters | |
| Compute Bounding Box (`inputs:computeBoundingBox`) | `bool` | | |
| | | | |
|---|---|---|---|
| | Compute and store local bounding box of a prim and its children. | False | |
| | Metadata | *displayGroup* = parameters | |
| Import Attributes (*inputs:importAttributes*) | `bool` | Import attribute data from the USD prim. | True |
| | Metadata | *displayGroup* = parameters | |
| Import Path (*inputs:importPath*) | `bool` | Record the input USD prim’s path into the output bundle in an attribute named “primPath”. | True |
| | Metadata | *displayGroup* = parameters | |
| Import Primvar Metadata (*inputs:importPrimvarMetadata*) | `bool` | Import metadata like the interpolation type for primvars, and store it as attributes in the output bundle. | True |
| | Metadata | *displayGroup* = parameters | |
| Import Time (*inputs:importTime*) | `bool` | Record the usdTimecode above into the output bundle in an attribute named “primTime”. | True |
| | Metadata | *displayGroup* = parameters | |
| Import Transform (*inputs:importTransform*) | `bool` | Record the transform required to take any attributes of the input USD prim into the space of this node, i.e. the world transform of the input prim times the inverse world transform of this node, into the output bundle in an attribute named “transform”. | True |
| | Metadata | *displayGroup* = parameters | |
| Import Type (*inputs:importType*) | `bool` | Deprecated, prim type is always imported | True |
| | Metadata | *hidden* = true | |
| | Metadata | *displayGroup* = parameters | |
| Attributes To Rename (*inputs:inputAttrNames*) | `token` | Comma or space separated text, listing the names of attributes in the input data to be renamed | |
| Keep Prims Separate (*inputs:keepPrimsSeparate*) | `bool` | Prefix output attribute names with “prim” followed by a unique number and a colon, to keep the attributes for separate input prims separate. The prim paths will be in the “primPaths” token array attribute. | True |
| | Metadata | *displayGroup* = parameters | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| New Attribute Names (inputs:outputAttrNames) | | Comma or space separated text, listing the new names for the attributes listed in inputAttrNames | |
| Prim (inputs:prim) | | The USD prim from which to import data. | None |
| Rename Attributes (inputs:renameAttributes) | | If true, attributes listed in “inputAttrNames” will be imported to attributes with the names specified in “outputAttrNames”. | False |
| Time Varying Attributes (inputs:timeVaryingAttributes) | | Check whether the USD attributes are time-varying and if so, import their data at the time “usdTimecode”. | True |
| Usd Timecode (inputs:usdTimecode) | | The time at which to evaluate the transform of the USD prim. | 0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Output (outputs:output) | | Output bundle containing all of the imported data. | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Prev Apply Skel Binding (state:prevApplySkelBinding) | | Value of “applySkelBinding” input from previous run | None |
| Prev Apply Transform (state:prevApplyTransform) | | Value of “applyTransform” input from previous run | None |
| Prev Attr Names To Import (state:prevAttrNamesToImport) | | Value of “attrNamesToImport” input from previous run | None |
- **Prev Compute Bounding Box** (state:prevComputeBoundingBox)
- Type: `bool`
- Description: Value of “computeBoundingBox” input from previous run
- Default: None
- **Prev Import Attributes** (state:prevImportAttributes)
- Type: `bool`
- Description: Value of “importAttributes” input from previous run
- Default: None
- **Prev Import Path** (state:prevImportPath)
- Type: `bool`
- Description: Value of “importPath” input from previous run
- Default: None
- **Prev Import Primvar Metadata** (state:prevImportPrimvarMetadata)
- Type: `bool`
- Description: Value of “importPrimvarMetadata” input from previous run
- Default: None
- **Prev Import Time** (state:prevImportTime)
- Type: `bool`
- Description: Value of “importTime” input from previous run
- Default: None
- **Prev Import Transform** (state:prevImportTransform)
- Type: `bool`
- Description: Value of “importTransform” input from previous run
- Default: None
- **Prev Import Type** (state:prevImportType)
- Type: `bool`
- Description: Value of “importType” input from previous run
- Default: None
- **Prev Input Attr Names** (state:prevInputAttrNames)
- Type: `token`
- Description: Value of “inputAttrNames” input from previous run
- Default: None
- **Prev Inv Node Transform** (state:prevInvNodeTransform)
- Type: `matrixd[4]`
- Description: Inverse transform of the node prim from the previous run.
- Default: None
- **Prev Keep Prims Separate** (state:prevKeepPrimsSeparate)
- Type: `bool`
- Description: Value of “keepPrimsSeparate” input from previous run
- Default: None
- **Prev Only Import Specified** (state:prevOnlyImportSpecified)
- Type: `bool`
- Description: Value of “onlyImportSpecified” input from previous run
- Default: None
- **Prev Output Attr Names** (state:prevOutputAttrNames)
- Type: `token`
- Description: Value of “outputAttrNames” input from previous run
- Default: None
- **Prev Paths** (state:prevPaths)
- Type: `token[]`
- Description: Array of paths from the previous run.
- Default: None
- **Prev Rename Attributes** (state:prevRenameAttributes)
- Type: `bool`
- Description: Value of “renameAttributes” input from previous run
- Default: None
## State
| Column 1 | Column 2 | Column 3 | Column 4 |
|----------|----------|----------|----------|
| Value of “renameAttributes” input from previous run | `bool` | None | |
| Prev Time Varying Attributes (state:prevTimeVaryingAttributes) | `bool` | Value of “timeVaryingAttributes” input from previous run | None |
| Prev Transforms (state:prevTransforms) | `matrixd[4][]` | Array of transforms from the previous run. | None |
| Prev Usd Timecode (state:prevUsdTimecode) | `double` | Value of “usdTimecode” input from previous run | None |
## Metadata
### Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.ImportUSDPrim |
| Version | 1 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.ImportUSDPrim.svg |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | import USD prim data |
| Generated Class Name | OgnImportUSDPrimDatabase |
| Python Module | omni.graph.nodes | | 7,725 |
OgnIncrement.md | # Increment
Add a double argument to any type (element-wise). This includes simple values, tuples, arrays, and arrays of tuples. The output type/shape is always the same as the input “Value“‘s type/shape. For example, a “Value” input of type tuple with an “Increment amount” type double will compute a tuple. Fractional values are used for approximation. For example: (int)4 + 3.2 will return 7. The default increment value is 1.0.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Increment amount (`inputs:increment`) | `double` | The number added to the first operand “Value” (in an element-wise fashion where appropriate). | 1.0 |
| Value (`inputs:value`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]']` | | |
| Name | Type | Descripton | Default |
|------|------|------------|---------|
| Result (outputs:result) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]'] | The operand that is to be increased by the “Increment amount”. | None |
| Input Type | Description | Default Value |
|------------|-------------|---------------|
| Value | The value to increment. | None |
| Increment | The amount to increment by. | None |
| Output Type | Description |
|-------------|-------------|
| Result | Result of the increment; should have the same type and shape as the input “Value”. | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.Increment |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | |
| Increment | Categories | Generated Class Name | Python Module |
|-----------|------------|----------------------|---------------|
| | math:operator | OgnIncrementDatabase | omni.graph.nodes | | 3,504 |
OgnIndexDistributedComputeTechnique.md | # NVIDIA IndeX distributed compute technique
Integration with NVIDIA IndeX distributed compute technique
## Installation
To use this node enable `omni.index.compute` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Active (`inputs:active`) | `bool` | If false then disable the node operation | True |
| Compute buffers (`inputs:buffers`) | `uint64[]` | Input compute buffers | [] |
| Multithreading (`inputs:threading`) | `bool` | Use multithreading | True |
| Timestep (`inputs:timestep`) | `int` | Active timestep | -1 |
| Verbose (`inputs:verbose`) | `int` | Log verbose output | 0 |
## Metadata
| Name | Value |
|--------------------|--------------------------------------------|
| Unique ID | omni.index.compute.indexDistributedComputeTechnique |
| Version | 1 |
| Extension | omni.index.compute |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type| cpu |
| Generated Code Exclusions | None |
| uiName | NVIDIA IndeX distributed compute technique |
| Generated Class Name | OgnIndexDistributedComputeTechniqueDatabase |
| Python Module | omni.index.compute | | 1,493 |
OgnInsertAttr.md | # Insert Attribute
Copies all attributes from an input bundle to the output bundle, as well as copying an additional ‘attrToInsert’ attribute from the node itself with a specified name.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-------------------------------|---------|-------------------------------------------------|---------|
| Attribute To Insert (inputs:attrToInsert) | any | The the attribute to be copied from the node to the output bundle | None |
| Original Bundle (inputs:data) | bundle | Initial bundle of attributes | None |
| Attribute Name (inputs:outputAttrName) | token | The name of the new output attribute in the bundle | attr0 |
## Outputs
| Name | Type | Descripton | Default |
|-------------------------------|---------|-------------------------------------------------|---------|
| Bundle With Inserted Attribute (outputs:data) | bundle | Bundle of input attributes with the new one inserted with the specified name | None |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.InsertAttribute |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Insert Attribute |
| Categories | bundle |
| Generated Class Name | OgnInsertAttrDatabase |
| Python Module | omni.graph.nodes | | 1,841 |
OgnInsertString.md | # Insert String
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Index (`inputs:index`) | `int` | The index of the string in the range [0, stringLength]. Index will be clamped to the valid range. | 0 |
| String (`inputs:string`) | `['string', 'token']` | The base string. | None |
| Value (`inputs:value`) | `['string', 'token']` | The string to insert. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| String (`outputs:string`) | `['string', 'token']` | The modified string. | None |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.InsertString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Insert String |
| Categories | function |
| Generated Class Name | OgnInsertStringDatabase |
| Python Module | omni.graph.nodes | | 1,276 |
OgnInsertTargets.md | # Insert Targets
Inserts a target or target array to a target array at an index. Index is clamped in the range [0:arrayLength].
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Index (`inputs:index`) | `int` | The array index clamped in the range [0:arrayLength] to insert the targets. | 0 |
| Insert Targets (`inputs:insertTargets`) | `target` | The targets to insert. | None |
| Metadata | | `allowMultiInputs` = 1 | |
| Targets (`inputs:targets`) | `target` | The input target array. | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Targets
Targets (**outputs:targets**)
```
target
```
The modified target array.
None
## Metadata
### Name
### Value
#### Unique ID
omni.graph.nodes.InsertTargets
#### Version
1
#### Extension
omni.graph.nodes
#### Has State?
False
#### Implementation Language
C++
#### Default Memory Type
cpu
#### Generated Code Exclusions
None
#### uiName
Insert Targets
#### Categories
sceneGraph
#### Generated Class Name
OgnInsertTargetsDatabase
#### Python Module
omni.graph.nodes
```
--- | 1,248 |
OgnIntCounter.md | # Int Counter
Example stateful node that increments every time it’s executed.
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Increment (`inputs:increment`) | `int` | Increment to count by | 1 |
| Reset (`inputs:reset`) | `bool` | Whether to reset the count | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Count (`outputs:count`) | `int` | The current count | 0 |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| 属性 | 值 |
|------------------------|-------------|
| omni.graph.examples.python.IntCounter | |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Int Counter |
| Categories | examples |
| Generated Class Name | OgnIntCounterDatabase |
| Python Module | omni.graph.examples.python | | 1,181 |
OgnInterpolateTo.md | # Interpolate To
## Interpolate To
Computes the value “Result” after moving “Delta Seconds” forward in time at a given “Speed” from the “Current” value in the direction of a “Target” value. The interpolation provides an eased approach to the “Target”, with options to adjust the “Speed” and “Exponent” to tweak the curve. The formula is: result = current + (target - current) * (1 - clamp(0, speed * deltaSeconds, 1))^exp. For quaternions, the node performs a spherical linear interpolation (SLERP) with alpha = (1 - clamp(0, speed * deltaSeconds, 1))^exp Vectors and arrays are interpolated component-wise, and interpolation can be applied to decimal types.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Current (`inputs:current`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]']` | | |
| Initial Value (inputs:initialValue) | Type | Description | Default Value |
|-------------------------------------|------|-------------|--------------|
| | | The initial value at which the dependent variable (i.e. the variable that’s being interpolated over) begins its current interpolation step. | None |
| Delta Seconds (inputs:deltaSeconds) | Type | Description | Default Value |
|-------------------------------------|------|-------------|--------------|
| | | The time step for the interpolation (in seconds). | 0.0 |
| Exponent (inputs:exponent) | Type | Description | Default Value |
|-----------------------------|------|-------------|--------------|
| | | The blend exponent, which is the degree of the ease curve (1 = linear, 2 = quadratic, 3 = cubic, etc). | 2.0 |
| Speed (inputs:speed) | Type | Description | Default Value |
|----------------------|------|-------------|--------------|
| | | The peak speed of approach (in units per second). | 1.0 |
| Target (inputs:target) | Type | Description | Default Value |
|------------------------|------|-------------|--------------|
| | | List of types for the target value. | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Target | string | The target value that the dependent variable will eventually reach (given enough time) | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]'] | | None |
<section id="interpolate-to">
<h2>Interpolate To
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Input
<th class="head">
<p>Description
<th class="head">
<p>Default Value
<tbody>
<tr class="row-even">
<td>
<p>startValue
<td>
<p>The starting value of the dependent variable.
<td>
<p>None
<tr class="row-odd">
<td>
<p>endValue
<td>
<p>The final value of the dependent variable.
<td>
<p>None
<tr class="row-even">
<td>
<p>timeStep
<td>
<p>The time-step duration.
<td>
<p>None
<tr class="row-odd">
<td>
<p>interpolationType
<td>
<p>The type of interpolation.
<td>
<p>None
<tr class="row-even">
<td>
<p>outputType
<td>
<p>The type of the output value.
<td>
<p>None
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Output
<th class="head">
<p>Description
<th class="head">
<p>Default Value
<tbody>
<tr class="row-even">
<td>
<p>result
<td>
<p>The value of the dependent variable being interpolated after a single time-step.
<td>
<p>None
<section id="metadata">
<h2>Metadata
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Name
<th class="head">
<p>Value
<tbody>
<tr class="row-even">
<td>
<p>Unique ID
<td>
<p>omni.graph.nodes.InterpolateTo
<tr class="row-odd">
<td>
<p>Version
<td>
<p>2
<tr class="row-even">
<td>
<p>Extension
<td>
<p>omni.graph.nodes
<tr class="row-odd">
<td>
<p>Has State?
<td>
<p>False
<tr class="row-even">
<td>
<p>Implementation Language
<td>
<p>C++
<tr class="row-odd">
<td>
<p>Default Memory Type
<td>
<p>cpu
<tr class="row-even">
<td>
<p>Generated Code Exclusions
<td>
<p>None
<tr class="row-odd">
<td>
<p>uiName
<td>
<p>Interpolate To
<tr class="row-even">
<td>
<p>Categories
<td>
<p>math:operator
<tr class="row-odd">
<td>
<p>Generated Class Name
<td>
<p>OgnInterpolateToDatabase
<tr class="row-even">
<td>
<p>Python Module
<td>
<p>omni.graph.nodes
| 7,559 |
OgnInterpolator.md | # Interpolator
Time sample interpolator
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Knot Array (`inputs:knots`) | `float[]` | Array of knots on the time sample curve | [] |
| Interpolation Point (`inputs:param`) | `float` | Time sample interpolation point | 0.0 |
| Value Array (`inputs:values`) | `float[]` | Array of time sample values | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Interpolated Value (`outputs:value`) | `float` | Value in the time samples, interpolated at the given parameter location | None |
## Metadata
## Name
Value
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.Interpolator |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Interpolator |
| Categories | math:operator |
| Generated Class Name | OgnInterpolatorDatabase |
| Python Module | omni.graph.nodes | | 1,323 |
OgnInvert.md | # Invert
## Invert
Inverts the given value (1/value). If the input is zero, the result is zero. The result is the same type as the input value if it is a decimal type, otherwise the result is a double. If the input is a vector, then result will be calculated per element and output a vector of the same size.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]']` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Input Value | `['int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The input value. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]']` | | None |
```pre
'int[4][]',
```pre
'int[]',
```pre
'normald[3]',
```pre
'normald[3][]',
```pre
'normalf[3]',
```pre
'normalf[3][]',
```pre
'normalh[3]',
```pre
'normalh[3][]',
```pre
'pointd[3]',
```pre
'pointd[3][]',
```pre
'pointf[3]',
```pre
'pointf[3][]',
```pre
'pointh[3]',
```pre
'pointh[3][]',
```pre
'quatd[4]',
```pre
'quatd[4][]',
```pre
'quatf[4]',
```pre
'quatf[4][]',
```pre
'quath[4]',
```pre
'quath[4][]',
```pre
'texcoordd[2]',
```pre
'texcoordd[2][]',
```pre
'texcoordd[3]',
```pre
'texcoordd[3][]',
```pre
'texcoordf[2]',
```pre
'texcoordf[2][]',
```pre
'texcoordf[3]',
```pre
'texcoordf[3][]',
```pre
'texcoordh[2]',
```pre
'texcoordh[2][]',
```pre
'texcoordh[3]',
```pre
'texcoordh[3][]',
```pre
'timecode',
```pre
'timecode[]',
```pre
'uchar',
```pre
'uchar[]',
```pre
'uint',
```pre
'uint64',
```pre
'uint64[]',
```pre
'uint[]',
```pre
'vectord[3]',
```pre
'vectord[3][]',
```pre
'vectorf[3]',
```pre
'vectorf[3][]',
```pre
'vectorh[3]',
```pre
'vectorh[3][]'
```pre
<td>
<p>
The resulting inverted value.
<td>
<p>
None
<section id="metadata">
<h2>
Metadata
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>
Name
<th class="head">
<p>
Value
<tbody>
<tr class="row-even">
<td>
<p>
Unique ID
<td>
<p>
omni.graph.nodes.Invert
<tr class="row-odd">
<td>
<p>
Version
<td>
<p>
1
<tr class="row-even">
<td>
<p>
Extension
<td>
<p>
omni.graph.nodes
<tr class="row-odd">
<td>
<p>
Has State?
<td>
<p>
False
<tr class="row-even">
<td>
<p>
Implementation Language
<td>
<p>
C++
<tr class="row-odd">
<td>
<p>
Default Memory Type
<td>
<p>
cpu
<tr class="row-even">
<td>
<p>
Generated Code Exclusions
<td>
<p>
None
<tr class="row-odd">
<td>
<p>
uiName
<td>
<p>
Invert
<tr class="row-even">
<td>
<p>
Categories
<td>
<p>
math:operator
<tr class="row-odd">
<td>
<p>
Generated Class Name
<td>
<p>
OgnInvertDatabase
<tr class="row-even">
<td>
<p>
Python Module
<td>
<p>
omni.graph.nodes
<footer>
<hr/>
| 4,669 |
OgnInvertMatrix.md | # Invert Matrix
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (inputs:matrix) | ['matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]'] | The input matrix or matrices to invert | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Inverse (outputs:invertedMatrix) | ['matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]'] | The resulting inverted matrix or matrices | None |
## Metadata
| Name | Descripton |
| --- | --- |
| Value |
|-------|
| Unique ID | omni.graph.nodes.OgnInvertMatrix |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Invert Matrix |
| Categories | math:operator |
| Generated Class Name | OgnInvertMatrixDatabase |
| Python Module | omni.graph.nodes | | 1,039 |
OgnIsEmpty.md | # Is Empty
Checks if the given input is empty. An input is considered empty if there is no data. A string or array of size 0 is considered empty whereas a blank string ‘ ‘ is not empty. A float with value 0.0 and int[2] with value [0, 0] are not empty.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (inputs:input) | ['bool', 'bool[]', 'colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int'] | | |
## Inputs
- **Type**:
```
'int64',
'int64[]',
'int[2]',
'int[2][]',
'int[3]',
'int[3][]',
'int[4]',
'int[4][]',
'int[]',
'matrixd[2]',
'matrixd[2][]',
'matrixd[3]',
'matrixd[3][]',
'matrixd[4]',
'matrixd[4][]',
'normald[3]',
'normald[3][]',
'normalf[3]',
'normalf[3][]',
'normalh[3]',
'normalh[3][]',
'path',
'pointd[3]',
'pointd[3][]',
'pointf[3]',
'pointf[3][]',
'pointh[3]',
'pointh[3][]',
'quatd[4]',
'quatd[4][]',
'quatf[4]',
'quatf[4][]',
'quath[4]',
'quath[4][]',
'string',
'texcoordd[2]',
'texcoordd[2][]',
'texcoordd[3]',
'texcoordd[3][]',
'texcoordf[2]',
'texcoordf[2][]',
'texcoordf[3]',
'texcoordf[3][]',
'texcoordh[2]',
'texcoordh[2][]',
'texcoordh[3]',
'texcoordh[3][]',
'timecode',
'timecode[]',
'token',
'token[]',
'transform[4]',
'transform[4][]',
'uchar',
'uchar[]',
'uint',
'uint64',
'uint64[]',
'uint[]',
'vectord[3]',
'vectord[3][]',
'vectorf[3]',
'vectorf[3][]',
'vectorh[3]',
'vectorh[3][]'
```
- **The input to check if empty**:
- None
## Outputs
- **Name**: Is Empty (outputs:isEmpty)
- **Type**: `bool`
- **Description**: True if the input is empty, false otherwise
- **Default**: None
## Metadata
- **Name**: Unique ID
- **Value**: omni.graph.nodes.IsEmpty
- **Name**: Version
- **Value**: 1
- **Name**: Extension
- **Value**: omni.graph.nodes
- **Name**: Has State?
- **Value**: False
- **Name**: Implementation Language
- **Value**: C++
| Default Memory Type | cpu |
| --- | --- |
| Generated Code Exclusions | None |
| uiName | Is Empty |
| Categories | function |
| Generated Class Name | OgnIsEmptyDatabase |
| Python Module | omni.graph.nodes | | 2,690 |
OgnIsPrimActive.md | # Is Prim Active
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim Path (`inputs:prim`) | `path` | The prim path to be queried | |
| Prim (`inputs:primTarget`) | `target` | The prim to be queried | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Active (`outputs:active`) | `bool` | Whether the prim is active or not | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.IsPrimActive |
| Version | 1 |
| --- | --- |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Is Prim Active |
| Categories | sceneGraph |
| Generated Class Name | OgnIsPrimActiveDatabase |
| Python Module | omni.graph.nodes | | 903 |
OgnIsPrimSelected.md | # Is Prim Selected
Checks if the prim at the given path is currently selected
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (`inputs:prim`) | `target` | The prim to check | None |
| Prim Path (`inputs:primPath`) | `token` | The prim path to check | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Selected (`outputs:isSelected`) | `bool` | True if the given path is in the current stage selection | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| Key | Value |
|-------------------------|------------------|
| IsPrimSelected | omni.graph.nodes.IsPrimSelected |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Is Prim Selected |
| Categories | sceneGraph |
| Generated Class Name | OgnIsPrimSelectedDatabase |
| Python Module | omni.graph.nodes | | 1,262 |
OgnIsZero.md | # Is Zero
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Tolerance (`inputs:tolerance`) | `double` | How close the value must be to 0 to be considered “zero”. | 0.0 |
| Value (`inputs:value`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]']` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Value | Various | Value(s) to check for zero. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | bool | If ‘value’ is a scalar then ‘result’ will be true if ‘value’ is zero. If ‘value’ is non-scalar (array, tuple, matrix, etc) then ‘result’ will be true if all of its elements/components are zero. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.IsZero |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | |
| 属性 | 值 |
| --- | --- |
| 语言 | C++ |
| 默认内存类型 | cpu |
| 生成的代码排除 | None |
| uiName | Is Zero |
| 类别 | math:condition |
| 生成的类名 | OgnIsZeroDatabase |
| Python 模块 | omni.graph.nodes | | 1,631 |
OgnJoinString.md | # Join String
Creates a string from an input array and a delimiter.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Delimiter (`inputs:delimiter`) | `string` | The delimiter string used to join the elements. | |
| Elements (`inputs:elements`) | `token[]` | The string elements to join. | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| String (`outputs:string`) | `string` | The output string. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.JoinString |
| Version | 1 |
| --- | --- |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Join String |
| Categories | function |
| Generated Class Name | OgnJoinStringDatabase |
| Python Module | omni.graph.nodes | | 967 |
OgnLengthAlongCurve.md | # Length Along Curve
Find the length along the curve of a subset of points on the curve.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|-----------------------|----------------------------------------------------------------------------|---------|
| Curve Points (inputs:curvePoints) | float[3][] | Points on the curve for which the lengths are to be computed. | [] |
| Curve Vertex Counts (inputs:curveVertexCounts) | int[] | Vertex counts for each curve subsection whose length is to be computed. Must have the same number of elements as ‘Curve Vertex Starts’. | [] |
| Curve Vertex Starts (inputs:curveVertexStarts) | int[] | Vertex index starting points for each curve subsection whose length is to be computed. Must have the same number of elements as ‘Curve Vertex Counts’. | [] |
| Normalize (inputs:normalize) | bool | If true then normalize the curve length to a 0, 1 range. | False |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|-----------------------|----------------------------------------------------------------------------|---------|
| Curve Lengths | float[] | Lengths of the curve subsections. | [] |
# Default
## Metadata
### Name
### Value
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.LengthAlongCurve |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Length Along Curve |
| Categories | geometry:analysis |
| Generated Class Name | OgnLengthAlongCurveDatabase |
| Python Module | omni.graph.nodes | | 2,441 |
OgnLockViewportRender.md | # Lock Viewport Render
Locks and unlocks viewport render. Viewport render is frozen at the frame when it is locked, while computation and UI update are still executed as normal. It fades out back to the current frame when it is unlocked, two output execution attributes - fadeStarted and fadeComplete - will be triggered separately during the fading progress. The node manages the lock state for its target viewport and takes action according to the lock state when an input execution attribute is triggered. A node is able to unlock the target viewort only if it has locked the target viewport.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Fade Time (`inputs:fadeTime`) | double | The duration of fading in time (seconds) when being unlocked | 1.0 |
| Lock (`inputs:lock`) | execution | Signal to the graph that this node is ready to be executed for locking the viewport render. | None |
| Unlock (`inputs:unlock`) | execution | Signal to the graph that this node is ready to be executed for unlocking the viewport render. | None |
| Viewport (`inputs:viewport`) | token | Name of the viewport, or empty for the default viewport | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table 1
## Headers
| Name | Type | Descripton | Default |
|------|------|------------|---------|
## Body
| Fade Complete (outputs:fadeComplete) | execution | When fading is complete, signal to the graph that execution can continue downstream on this path. | None |
| Fade Started (outputs:fadeStarted) | execution | When fading is started, signal to the graph that execution can continue downstream on this path. | None |
| Locked (outputs:locked) | execution | When viewport render is locked, signal to the graph that execution can continue downstream on this path. | None |
# Table 2
## Headers
| Name | Value |
|------|-------|
## Body
| Unique ID | omni.graph.ui_nodes.LockViewportRender |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Lock Viewport Render |
| Categories | graph:action,viewport |
| Generated Class Name | OgnLockViewportRenderDatabase |
| Python Module | omni.graph.ui_nodes | | 2,386 |
OgnLogarithm.md | # Logarithm
Computes the base-“Base” logarithm of the input “Value”. The result is the same type as the input “Value” if it is a decimal type, otherwise the result is a double. If the input is an array, vector, or matrix, then the node will calculate the logarithm of each element and output an array, vector, or matrix of the same size. The logarithm’s “Base” must be greater than zero and not equal to one while “Value” must be greater than zero, otherwise the compute will fail.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Base (`inputs:base`) | `double` | The logarithm base. Must be greater than zero and not equal to one or the compute will fail. | 10 |
| Value (`inputs:value`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', ...]` | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Input Value | `float` | The input value. Must be greater than zero or the compute will fail. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]'` | | None |
'float[2][]',
'float[3]',
'float[3][]',
'float[4]',
'float[4][]',
'float[]',
'frame[4]',
'frame[4][]',
'half',
'half[2]',
'half[2][]',
'half[3]',
'half[3][]',
'half[4]',
'half[4][]',
'half[]',
'int',
'int64',
'int64[]',
'int[2]',
'int[2][]',
'int[3]',
'int[3][]',
'int[4]',
'int[4][]',
'int[]',
'matrixd[2]',
'matrixd[2][]',
'matrixd[3]',
'matrixd[3][]',
'matrixd[4]',
'matrixd[4][]',
'normald[3]',
'normald[3][]',
'normalf[3]',
'normalf[3][]',
'normalh[3]',
'normalh[3][]',
'pointd[3]',
'pointd[3][]',
'pointf[3]',
'pointf[3][]',
'pointh[3]',
'pointh[3][]',
'quatd[4]',
'quatd[4][]',
'quatf[4]',
'quatf[4][]',
'quath[4]',
'quath[4][]',
'texcoordd[2]',
'texcoordd[2][]',
'texcoordd[3]',
'texcoordd[3][]',
'texcoordf[2]',
'texcoordf[2][]',
'texcoordf[3]',
'texcoordf[3][]',
'texcoordh[2]',
'texcoordh[2][]',
'texcoordh[3]',
'texcoordh[3][]',
'timecode',
'timecode[]',
'transform[4]',
'transform[4][]',
'uchar',
'uchar[]',
'uint',
'uint64',
'uint64[]',
'uint[]',
'vectord[3]',
'vectord[3][]',
'vectorf[3]',
'vectorf[3][]',
'vectorh[3]',
'vectorh[3][]'
```
The logarithm value. The shape and type of this output should match “Value“‘s unless the input “Value” is not a decimal type, in which case the result should be of type double.
None
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.Logarithm |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Logarithm |
| --- | --- |
| Categories | math:operator |
| Generated Class Name | OgnLogarithmDatabase |
| Python Module | omni.graph.nodes | | 3,696 |
OgnMagnitude.md | # Magnitude
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (`inputs:input`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]']` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Vector or Scalar | ['int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]'] | The vector(s) or scalar(s) to take the magnitude of. | None |
## Outputs
### Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Magnitude (outputs:magnitude) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]'] | | |
# Magnitude Node
## Inputs
| Type | Description | Default |
| --- | --- | --- |
| `int[4][]` | | |
| `int[]` | | |
| `normald[3]` | | |
| `normald[3][]` | | |
| `normalf[3]` | | |
| `normalf[3][]` | | |
| `normalh[3]` | | |
| `normalh[3][]` | | |
| `pointd[3]` | | |
| `pointd[3][]` | | |
| `pointf[3]` | | |
| `pointf[3][]` | | |
| `pointh[3]` | | |
| `pointh[3][]` | | |
| `quatd[4]` | | |
| `quatd[4][]` | | |
| `quatf[4]` | | |
| `quatf[4][]` | | |
| `quath[4]` | | |
| `quath[4][]` | | |
| `texcoordd[2]` | | |
| `texcoordd[2][]` | | |
| `texcoordd[3]` | | |
| `texcoordd[3][]` | | |
| `texcoordf[2]` | | |
| `texcoordf[2][]` | | |
| `texcoordf[3]` | | |
| `texcoordf[3][]` | | |
| `texcoordh[2]` | | |
| `texcoordh[2][]` | | |
| `texcoordh[3]` | | |
| `texcoordh[3][]` | | |
| `timecode` | | |
| `timecode[]` | | |
| `uchar` | | |
| `uchar[]` | | |
| `uint` | | |
| `uint64` | | |
| `uint64[]` | | |
| `uint[]` | | |
| `vectord[3]` | | |
| `vectord[3][]` | | |
| `vectorf[3]` | | |
| `vectorf[3][]` | | |
| `vectorh[3]` | | |
| `vectorh[3][]` | | |
## Outputs
| Type | Description | Default |
| --- | --- | --- |
| | The resulting magnitude(s) of the inputted vector(s) or scalar(s). | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.Magnitude |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | absolute |
| uiName | Magnitude |
| Categories | math:operator |
| Generated Class Name | OgnMagnitudeDatabase |
| Python Module | omni.graph.nodes | | 3,962 |
OgnMakeArray.md | # Make Array
Makes an output array attribute from input values, in the order of the inputs. If “Array Size” is less than five, the top “Array Size” elements will be taken (e.g., if “Array Size” is equal to two, the output array will be constructed using elements “A” and “B”). If “Array Size” is greater than five, element “E” will be repeated to fill the remaining space.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[2]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'vector2d', 'vector2f', 'vector2h', 'vector3d', 'vector3f', 'vector3h', 'vector4d', 'vector4f', 'vector4h']` | | |
| A (inputs:a) | Description | Default |
| --- | --- | --- |
| `['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'timecode', 'token', 'transform[4]', 'uchar', 'uint', 'uint64', 'vectord[3]', 'vectorf[3]', 'vectorh[3]']` | The first element that can be used for the array construction (if “Array Size” >= 1). | None |
| Array Size (inputs:arraySize) | Description | Default |
| --- | --- | --- |
| `int` | The size of the array to create using the provided array elements. | 0 |
| B (inputs:b) | Description | Default |
| --- | --- | --- |
| `['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'timecode', 'token', 'transform[4]', 'uchar', 'uint', 'uint64', 'vectord[3]', 'vectorf[3]', 'vectorh[3]']` | The second element that can be used for the array construction (if “Array Size” >= 2). | None |
| C (inputs:c) | Description | Default |
| --- | --- | --- |
| `['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'timecode', 'token', 'transform[4]', 'uchar', 'uint', 'uint64', 'vectord[3]', 'vectorf[3]', 'vectorh[3]']` | The third element that can be used for the array construction (if “Array Size” >= 3). | None |
| | | |
|---|---|---|
| A (inputs:a) | ['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[2]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'timecode', 'token', 'transform[4]', 'uchar', 'uint', 'uint64', 'vectord[3]', 'vectorf[3]', 'vectorh[3]'] | The first element that can be used for the array construction (if “Array Size” >= 1). | None |
| B (inputs:b) | ['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[2]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'timecode', 'token', 'transform[4]', 'uchar', 'uint', 'uint64', 'vectord[3]', 'vectorf[3]', 'vectorh[3]'] | The second element that can be used for the array construction (if “Array Size” >= 2). | None |
| C (inputs:c) | ['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[2]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'timecode', 'token', 'transform[4]', 'uchar', 'uint', 'uint64', 'vectord[3]', 'vectorf[3]', 'vectorh[3]'] | The third element that can be used for the array construction (if “Array Size” >= 3). | None |
| D (inputs:d) | ['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[2]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'timecode', 'token', 'transform[4]', 'uchar', 'uint', 'uint64', 'vectord[3]', 'vectorf[3]', 'vectorh[3]'] | The fourth element that can be used for the array construction (if “Array Size” >= 4). | None |
| E (inputs:e) | ['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[3]', 'double[4]', 'float', 'float[2]', 'float[3]', 'float[4]', 'frame[4]', 'half', 'half[2]', 'half[3]', 'half[4]', 'int', 'int64', 'int[2]', 'int[3]', 'int[4]', 'matrixd[2]', 'matrixd[3]', 'matrixd[4]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]', 'quath[4]', 'texcoordd[2]', 'texcoordd[3]', 'texcoordf[2]', 'texcoordf[3]', 'texcoordh[2]', 'texcoordh[3]', 'timecode', 'token', 'transform[4]', 'uchar', 'uint', 'uint64', 'vectord[3]', 'vectorf[3]', 'vectorh[3]'] | The fifth element that can be used for the array construction (if “Array Size” >= 5). | None |
## Inputs
| Index | Description | Default |
|-------|-------------|---------|
| 1 | The first element that can be used for the array construction (if “Array Size” >= 1). | None |
| 2 | The second element that can be used for the array construction (if “Array Size” >= 2). | None |
| 3 | The third element that can be used for the array construction (if “Array Size” >= 3). | None |
| 4 | The fourth element that can be used for the array construction (if “Array Size” >= 4). | None |
| 5 | The fifth element that can be used for the array construction (if “Array Size” >= 5). Note that if “Array Size” > 5, all subsequent elements past the fifth index will have their values set to element “E“‘s value. | None |
## Outputs
### Outputs
| Name | Type | Description | Default |
|------|------|-------------|---------|
| Array (`outputs:array`) | `['colord[3][]', 'colord[4][]', 'colorf[3][]', 'colorf[4][]', 'colorh[3][]', 'colorh[4][]', 'double[2][]', 'double[3][]', 'double[4][]', 'double[]', 'float[2][]', 'float[3][]', 'float[4][]', 'float[]', 'frame[4][]', 'half[2][]', 'half[3][]', 'half[4][]', 'half[]', 'int64[]', 'int[2][]', 'int[3][]', 'int[4][]', 'int[]', 'matrixd[2][]', 'matrixd[3][]', 'matrixd[4][]', 'normald[3][]', 'normalf[3][]', 'normalh[3][]', 'pointd[3][]', 'pointf[3][]', 'pointh[3][]', 'quatd[4][]', 'quatf[4][]', 'quath[4][]', 'texcoordd[2][]', 'texcoordd[3][]', 'texcoordf[2][]', 'texcoordf[3][]', 'texcoordh[2][]', 'texcoordh[3][]', 'timecode[]', 'token[]', 'transform[4][]', 'uchar[]', 'uint64[]', 'uint[]', 'vectord[3][]', 'vectorf[3][]', 'vectorh[3][]']` | The array of copied values of inputs in the given order. | None |
## Metadata
### Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.MakeArray |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Make Array |
| Categories | math:array |
| Generated Class Name | OgnMakeArrayDatabase |
| Python Module | omni.graph.nodes | | 9,608 |
OgnMakeMatrix2.md | # Make Matrix2
Merge 2 row vectors into a matrix. If the inputs are arrays, the output will be an array of matrices.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| First Row (`inputs:x`) | `['double[2]', 'double[2][]']` | The first row of the matrix | None |
| Second Row (`inputs:y`) | `['double[2]', 'double[2][]']` | The second row of the matrix | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`outputs:matrix`) | `['matrixd[2]', 'matrixd[2][]']` | Matrix formed by ‘First Row’ and ‘Second Row’ | None |
## Metadata
| Name | Descripton |
| --- | --- |
```
| Column 1 | Column 2 |
|----------------|-------------------|
| Unique ID | omni.graph.nodes.MakeMatrix2 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | compose,combine,join |
| uiName | Make Matrix2 |
| Categories | math:conversion |
| Generated Class Name | OgnMakeMatrix2Database |
| Python Module | omni.graph.nodes | | 1,316 |
OgnMakeMatrix3.md | # Make Matrix3
Merge 3 row vectors into a matrix. If the inputs are arrays, the output will be an array of matrices.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|-------------------------------------------|-------------------------------------|---------|
| First Row (inputs:x) | `['double[3]', 'double[3][]']` | The first row of the matrix | None |
| Second Row (inputs:y) | `['double[3]', 'double[3][]']` | The second row of the matrix | None |
| Third Row (inputs:z) | `['double[3]', 'double[3][]']` | The third row of the matrix | None |
## Outputs
| Name | Type | Descripton | Default |
|---------------------|-------------------------------------------|-------------------------------------|---------|
| Matrix (outputs:matrix) | `['matrixd[3]', 'matrixd[3][]']` | The resulting matrix | None |
# Matrix formed from the input row vectors
## Metadata
### Name
### Value
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.MakeMatrix3 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | compose,combine,join |
| uiName | Make Matrix3 |
| Categories | math:conversion |
| Generated Class Name | OgnMakeMatrix3Database |
| Python Module | omni.graph.nodes | | 2,031 |
OgnMakeMatrix4.md | # Make Matrix4
Merge 4 row vectors into a matrix. If the inputs are arrays, the output will be an array of matrices.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Fourth Row (inputs:w) | ['double[3]', 'double[3][]', 'double[4]', 'double[4][]'] | The fourth row of the matrix | None |
| First Row (inputs:x) | ['double[3]', 'double[3][]', 'double[4]', 'double[4][]'] | The first row of the matrix | None |
| Second Row (inputs:y) | ['double[3]', 'double[3][]', 'double[4]', 'double[4][]'] | The second row of the matrix | None |
| Third Row (inputs:z) | ['double[3]', 'double[3][]', 'double[4]', 'double[4][]'] | The third row of the matrix | None |
## Outputs
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (outputs:matrix) | ['matrixd[4]', 'matrixd[4][]'] | The matrix formed by the input row vectors | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.MakeMatrix4 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | compose,combine,join |
| uiName | Make Matrix4 |
| Categories | math:conversion |
| Generated Class Name | OgnMakeMatrix4Database |
| Python Module | omni.graph.nodes | | 1,409 |
OgnMakeTransform.md | # Make Transformation Matrix from TRS
Make a transformation matrix that performs a translation, rotation (in euler angles), and scale in that order
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|--------------|-------------------------------------|---------|
| Rotation Order (inputs:rotationOrder) | token | The order the rotation should be applied | XYZ |
| Metadata | | allowedTokens = XYZ,XZY,YXZ,YZX,ZXY,ZYX | |
| Rotation (inputs:rotationXYZ) | vectord[3] | The desired orientation in euler angles XYZ | [0, 0, 0] |
| Scale (inputs:scale) | vectord[3] | The desired scaling factor about the X, Y, and Z axis respectively | [1, 1, 1] |
| Translation (inputs:translation) | vectord[3] | The desired translation as a vector | [0, 0, 0] |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|--------------|-------------------------------------|---------|
| Name | Type | Descripton | Default |
|------|------|------------|---------|
| Transform (outputs:transform) | matrixd[4] | The computed transformation matrix | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.MakeTransform |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Make Transformation Matrix from TRS |
| Categories | math:operator |
| Generated Class Name | OgnMakeTransformDatabase |
| Python Module | omni.graph.nodes | | 1,776 |
OgnMakeTransformLookAt.md | # Make Transformation Matrix Look At
Make a transformation matrix from eye and center world-space positions and an up vector. Forward vector is negative Z direction computed from (eye - center) and normalized. Up is positive Y direction. Right is the positive X direction.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Center (`inputs:center`) | `vectord[3]` | The position of the center or target-position in world-space | [0, 0, 0] |
| Eye (`inputs:eye`) | `vectord[3]` | The position of the eye, or from-position in world-space | [1, 0, 0] |
| Up (`inputs:up`) | `vectord[3]` | The direction of the up vector | [0, 1, 0] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Transform (`outputs:transform`) | `matrixd[4]` | | |
# Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.MakeTransformLookAt |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Make Transformation Matrix Look At |
| Categories | math:operator |
| Generated Class Name | OgnMakeTransformLookAtDatabase |
| Python Module | omni.graph.nodes | | 1,661 |
OgnMakeVector2.md | # Make 2-Vector
Merge 2 input values into a single output vector. If the inputs are arrays, the output will be an array of vectors.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| X (`inputs:x`) | `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]']` | The first component of the vector | None |
| Y (`inputs:y`) | `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]']` | The second component of the vector | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Vector (`outputs:tuple`) | | | |
<section id="make-vector-2">
<h2>Make Vector 2
<table>
<thead>
<tr>
<th>Input Type
<th>Output Type
<th>Description
<tbody>
<tr>
<td>
<p>
['double[2]',
'double[2][]',
'float[2]',
'float[2][]',
'half[2]',
'half[2][]',
'int[2]',
'int[2][]']
<td>
<p>Output vector(s)
<td>
<p>None
<section id="metadata">
<h2>Metadata
<table>
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr>
<th>Name
<th>Value
<tbody>
<tr>
<td>Unique ID
<td>omni.graph.nodes.MakeVector2
<tr>
<td>Version
<td>1
<tr>
<td>Extension
<td>omni.graph.nodes
<tr>
<td>Has State?
<td>False
<tr>
<td>Implementation Language
<td>C++
<tr>
<td>Default Memory Type
<td>cpu
<tr>
<td>Generated Code Exclusions
<td>None
<tr>
<td>tags
<td>compose,combine,join
<tr>
<td>uiName
<td>Make 2-Vector
<tr>
<td>Categories
<td>math:conversion
<tr>
<td>Generated Class Name
<td>OgnMakeVector2Database
<tr>
<td>Python Module
<td>omni.graph.nodes
| 2,288 |
OgnMakeVector3.md | # Make 3-Vector
Merge 3 input values into a single output vector. If the inputs are arrays, the output will be an array of vectors.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| X (inputs:x) | ['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]'] | The first component of the vector | None |
| Y (inputs:y) | ['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]'] | The second component of the vector | None |
| Z (inputs:z) | ['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]'] | The third component of the vector | None |
## Outputs
## Outputs
| Name | Type | Descripton | Default |
|------|------|------------|---------|
| Vector (outputs:tuple) | `['double[3]', 'double[3][]', 'float[3]', 'float[3][]', 'half[3]', 'half[3][]', 'int[3]', 'int[3][]']` | Output 3-vector(s) | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.MakeVector3 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | compose,combine,join |
| uiName | Make 3-Vector |
| Categories | math:conversion |
| Generated Class Name | OgnMakeVector3Database |
| Python Module | omni.graph.nodes | | 1,418 |
OgnMakeVector4.md | # Make 4-Vector
Merge 4 input values into a single output vector. If the inputs are arrays, the output will be an array of vectors.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| W (`inputs:w`) | `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]']` | The fourth component of the vector | None |
| X (`inputs:x`) | `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]']` | The first component of the vector | None |
| Y (`inputs:y`) | `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]']` | The second component of the vector | None |
| Z (`inputs:z`) | `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]']` | The third component of the vector | None |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Vector (outputs:tuple) | `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int[]']` | The third component of the vector | None |
## Outputs
### Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Vector (outputs:tuple) | `['double[4]', 'double[4][]', 'float[4]', 'float[4][]', 'half[4]', 'half[4][]', 'int[4]', 'int[4][]']` | Output 4-vector | None |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.MakeVector4 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | compose,combine,join |
| uiName | Make 4-Vector |
| Categories | math:conversion |
| Generated Class Name | OgnMakeVector4Database |
| Python Module | omni.graph.nodes | | 1,801 |
OgnMatrixMultiply.md | # Matrix Multiply
## Matrix Multiply
- Computes the matrix product of the inputs. Inputs must be compatible. Also accepts tuples (treated as vectors) as inputs. Tuples in input ‘A’ will be treated as row vectors. Tuples in input ‘B’ will be treated as column vectors. Arrays of inputs will be computed element-wise with broadcasting if necessary.
## Installation
- To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'frame[4]', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normalf[3]', 'normalh[3]', 'pointd[3]', 'pointf[3]', 'pointh[3]', 'quatd[4]', 'quatf[4]']` | | |
```
'quath[4]',
'texcoordd[2]',
'texcoordd[3]',
'texcoordf[2]',
'texcoordf[3]',
'texcoordh[2]',
'texcoordh[3]',
'transform[4]',
'vectord[3]',
'vectorf[3]',
'vectorh[3]']
```
First matrix or row vector to multiply as A*B
None
B (inputs:b)
```
['colord[3]',
'colord[4]',
'colorf[3]',
'colorf[4]',
'colorh[3]',
'colorh[4]',
'double[2]',
'double[2][]',
'double[3]',
'double[3][]',
'double[4]',
'double[4][]',
'float[2]',
'float[2][]',
'float[3]',
'float[3][]',
'float[4]',
'float[4][]',
'frame[4]',
'half[2]',
'half[2][]',
'half[3]',
'half[3][]',
'half[4]',
'half[4][]',
'matrixd[2]',
'matrixd[2][]',
'matrixd[3]',
'matrixd[3][]',
'matrixd[4]',
'matrixd[4][]',
'normald[3]',
'normalf[3]',
'normalh[3]',
'pointd[3]',
'pointf[3]',
'pointh[3]',
'quatd[4]',
'quatf[4]',
'quath[4]',
'texcoordd[2]',
'texcoordd[3]',
'texcoordf[2]',
'texcoordf[3]',
'texcoordh[2]',
'texcoordh[3]',
'transform[4]',
'vectord[3]',
'vectorf[3]',
'vectorh[3]']
```
Second matrix or column vector to multiply as A*B
None
Outputs
======
Name | Type | Descripton | Default
---- | ---- | ---------- | -------
Product (outputs:output) | ['colord[3]', 'colord[4]', 'colorf[3]', 'colorf[4]', 'colorh[3]', 'colorh[4]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'half', 'half[2]'] | | None
# Metadata
## Metadata
| Name | Value |
|------------|---------------------------|
| Unique ID | omni.graph.nodes.MatrixMultiply |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Matrix Multiply |
| Categories | math:operator |
| Generated Class Name | OgnMatrixMultiplyDatabase |
| Python Module | omni.graph.nodes | | 3,073 |
OgnMaximum.md | # Maximum — kit-omnigraph 1.143.1 documentation
## Maximum
Computes the maximum of two or more inputs. If one input has a higher dimension than the others, then the input with lower dimension will be repeated to match the dimension of the higher dimension input (broadcasting). Examples: scalar * tuple -> tuple, tuple * array of tuples -> array of tuples, scalar * array of tuples -> array of tuples. To add/remove extra inputs on this node, select the node and press the small “+”/”-” buttons in the bottom-right corner of the “Inputs” widget in the “Property” window.
## Installation
To use this node enable omni.graph.nodes in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (inputs:a) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]'] | | |
| A (inputs:a) | Description | Default |
|--------------|-------------|---------|
| ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]'] | First value in the set of all inputs from which the maximum will be computed. | None |
| B (inputs:b) | Description | Default |
|--------------|-------------|---------|
| ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]'] | Description for B | None |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| First value in the set of all inputs from which the maximum will be computed. | `['int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | None |
| Second value in the set of all inputs from which the maximum will be computed. | None | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Maximum (`outputs:maximum`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]']` | None |
<section id="attributes">
<h2>Attributes
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 20%"/>
<col style="width: 40%"/>
<col style="width: 40%"/>
<thead>
<tr class="row-odd">
<th class="head">Name
<th class="head">Type
<th class="head">Description
<tbody>
<tr class="row-even">
<td>A, B, ...
<td>
```
'half[4]',
'half[4][]',
'half[]',
'int',
'int64',
'int64[]',
'int[2]',
'int[2][]',
'int[3]',
'int[3][]',
'int[4]',
'int[4][]',
'int[]',
'matrixd[2]',
'matrixd[2][]',
'matrixd[3]',
'matrixd[3][]',
'matrixd[4]',
'matrixd[4][]',
'normald[3]',
'normald[3][]',
'normalf[3]',
'normalf[3][]',
'normalh[3]',
'normalh[3][]',
'pointd[3]',
'pointd[3][]',
'pointf[3]',
'pointf[3][]',
'pointh[3]',
'pointh[3][]',
'quatd[4]',
'quatd[4][]',
'quatf[4]',
'quatf[4][]',
'quath[4]',
'quath[4][]',
'texcoordd[2]',
'texcoordd[2][]',
'texcoordd[3]',
'texcoordd[3][]',
'texcoordf[2]',
'texcoordf[2][]',
'texcoordf[3]',
'texcoordf[3][]',
'texcoordh[2]',
'texcoordh[2][]',
'texcoordh[3]',
'texcoordh[3][]',
'timecode',
'timecode[]',
'transform[4]',
'transform[4][]',
'uchar',
'uchar[]',
'uint',
'uint64',
'uint64[]',
'uint[]',
'vectord[3]',
'vectord[3][]',
'vectorf[3]',
'vectorf[3][]',
'vectorh[3]',
'vectorh[3][]'
```
<td>Maximum of all input values “A”, “B”, etc. This attribute’s dimension will match the highest- dimensioned input (e.g. if “A” is an array of tuples while “B” is a double, then the output will also be an array of tuples).
<tr class="row-odd">
<td>Output
<td>Same as input with highest dimension
<td>None
<section id="metadata">
<h2>Metadata
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th>Name
<th>Value
<tbody>
<tr class="row-even">
<td>Unique ID
<td>omni.graph.nodes.Maximum
<tr class="row-odd">
<td>Version
<td>1
<tr class="row-even">
<td>Extension
<td>omni.graph.nodes
<tr class="row-odd">
<td>Has State?
<td>False
<tr class="row-even">
<td>Implementation Language
<td>C++
<tr class="row-odd">
<td>Default Memory Type
<td>cpu
<tr class="row-even">
<td>Generated Code Exclusions
<td>None
<tr class="row-odd">
<td>uiName
<td>Maximum
<tr class="row-even">
<td>Categories
<td>math:operator
<tr class="row-odd">
<td>Generated Class Name
<td>OgnMaximumDatabase
<tr class="row-even">
<td>Python Module
<td>omni.graph.nodes
---
title: "文章标题"
author: "作者"
date: "2023-04-01"
---
# 第一章
这里是第一章的内容。
## 第一节
这里是第一节的内容。
### 代码块
```python
print("Hello, world!")
```
## 第二节
这里是第二节的内容。
### 列表
- 列表项1
- 列表项2
## 第三节
这里是第三节的内容。
### 引用
> 这是一个引用。
## 第四节
这里是第四节的内容。
### 表格
| 列1 | 列2 |
| --- | --- |
| 数据1 | 数据2 |
| 数据3 | 数据4 |
## 第五节
这里是第五节的内容。
### 链接
这是一个链接文本。
## 第六节
这里是第六节的内容。
### 图片
## 第七节
这里是第七节的内容。
### 段落
这是一个段落。
---
### 页脚
--- | 9,937 |
OgnMinimum.md | # Minimum
Computes the minimum of two or more inputs. If one input has a higher dimension than the others, then the input with lower dimension will be repeated to match the dimension of the higher dimension input (broadcasting). Examples: scalar * tuple -> tuple, tuple * array of tuples -> array of tuples, scalar * array of tuples -> array of tuples. To add/remove extra inputs on this node, select the node and press the small “+”/”-” buttons in the bottom-right corner of the “Inputs” widget in the “Property” window.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (inputs:a) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]'] | | |
| A (inputs:a) | Description | Default |
|--------------|-------------|---------|
| ['int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]'] | First value in the set of all inputs from which the minimum will be computed. | None |
| B (inputs:b) | Description | Default |
|--------------|-------------|---------|
| ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]'] | Description for B | None |
## Inputs
- `int[3]`
- `int[3][]`
- `int[4]`
- `int[4][]`
- `int[]`
- `matrixd[2]`
- `matrixd[2][]`
- `matrixd[3]`
- `matrixd[3][]`
- `matrixd[4]`
- `matrixd[4][]`
- `normald[3]`
- `normald[3][]`
- `normalf[3]`
- `normalf[3][]`
- `normalh[3]`
- `normalh[3][]`
- `pointd[3]`
- `pointd[3][]`
- `pointf[3]`
- `pointf[3][]`
- `pointh[3]`
- `pointh[3][]`
- `quatd[4]`
- `quatd[4][]`
- `quatf[4]`
- `quatf[4][]`
- `quath[4]`
- `quath[4][]`
- `texcoordd[2]`
- `texcoordd[2][]`
- `texcoordd[3]`
- `texcoordd[3][]`
- `texcoordf[2]`
- `texcoordf[2][]`
- `texcoordf[3]`
- `texcoordf[3][]`
- `texcoordh[2]`
- `texcoordh[2][]`
- `texcoordh[3]`
- `texcoordh[3][]`
- `timecode`
- `timecode[]`
- `transform[4]`
- `transform[4][]`
- `uchar`
- `uchar[]`
- `uint`
- `uint64`
- `uint64[]`
- `uint[]`
- `vectord[3]`
- `vectord[3][]`
- `vectorf[3]`
- `vectorf[3][]`
- `vectorh[3]`
- `vectorh[3][]`
## Outputs
- `Minimum (outputs:minimum)`
- `['colord[3]'`
- `'colord[3][]'`
- `'colord[4]'`
- `'colord[4][]'`
- `'colorf[3]'`
- `'colorf[3][]'`
- `'colorf[4]'`
- `'colorf[4][]'`
- `'colorh[3]'`
- `'colorh[3][]'`
- `'colorh[4]'`
- `'colorh[4][]'`
- `'double'`
- `'double[2]'`
- `'double[2][]'`
- `'double[3]'`
- `'double[3][]'`
- `'double[4]'`
- `'double[4][]'`
- `'double[]'`
- `'float'`
- `'float[2]'`
- `'float[2][]'`
- `'float[3]'`
- `'float[3][]'`
- `'float[4]'`
- `'float[4][]'`
- `'float[]'`
- `'frame[4]'`
- `'frame[4][]'`
- `'half'`
- `'half[2]'`
- `'half[2][]'`
- `'half[3]'`
- `'half[3][]'`
- `'half[3][]'`
'half[4]',
'half[4][]',
'half[]',
'int',
'int64',
'int64[]',
'int[2]',
'int[2][]',
'int[3]',
'int[3][]',
'int[4]',
'int[4][]',
'int[]',
'matrixd[2]',
'matrixd[2][]',
'matrixd[3]',
'matrixd[3][]',
'matrixd[4]',
'matrixd[4][]',
'normald[3]',
'normald[3][]',
'normalf[3]',
'normalf[3][]',
'normalh[3]',
'normalh[3][]',
'pointd[3]',
'pointd[3][]',
'pointf[3]',
'pointf[3][]',
'pointh[3]',
'pointh[3][]',
'quatd[4]',
'quatd[4][]',
'quatf[4]',
'quatf[4][]',
'quath[4]',
'quath[4][]',
'texcoordd[2]',
'texcoordd[2][]',
'texcoordd[3]',
'texcoordd[3][]',
'texcoordf[2]',
'texcoordf[2][]',
'texcoordf[3]',
'texcoordf[3][]',
'texcoordh[2]',
'texcoordh[2][]',
'texcoordh[3]',
'texcoordh[3][]',
'timecode',
'timecode[]',
'transform[4]',
'transform[4][]',
'uchar',
'uchar[]',
'uint',
'uint64',
'uint64[]',
'uint[]',
'vectord[3]',
'vectord[3][]',
'vectorf[3]',
'vectorf[3][]',
'vectorh[3]',
'vectorh[3][]'
Minimum of all input values “A”, “B”, etc. This attribute’s dimension will match the highest- dimensioned input (e.g. if “A” is an array of tuples while “B” is a double, then the output will also be an array of tuples).
None
## Metadata
| Name | Value |
|------------|---------------------------------|
| Unique ID | omni.graph.nodes.Minimum |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Minimum |
| Categories | math:operator |
| Generated Class Name | OgnMinimumDatabase |
| Python Module | omni.graph.nodes | | 6,196 |
OgnModulo.md | # Modulo
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['int', 'int64', 'uchar', 'uint', 'uint64']` | The dividend of the (“A” % “B”) operation, i.e. “A”. | None |
| B (`inputs:b`) | `['int', 'int64', 'uchar', 'uint', 'uint64']` | The divisor of the (“A” % “B”) operation, i.e. “B”. If “B” is zero, then the final result will be zero. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (`outputs:result`) | `['int', 'int64', 'uchar', 'uint', 'uint64']` | The result of the modulo operation. | None |
# Modulo Node
## Inputs
| Name | Type | Description | Default Value |
| --- | --- | --- | --- |
| "A" | ['int', 'int64', 'uchar', 'uint', 'uint64'] | Input value A | None |
| "B" | ['int', 'int64', 'uchar', 'uint', 'uint64'] | Input value B | None |
## Description
Modulo (“A” % “B”), i.e. the remainder of the division operation “A” / “B”.
## Outputs
| Name | Type | Description | Default Value |
| --- | --- | --- | --- |
| "Result" | ['int', 'int64', 'uchar', 'uint', 'uint64'] | Result of the modulo operation | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.Modulo |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Modulo |
| Categories | math:operator |
| Generated Class Name | OgnModuloDatabase |
| Python Module | omni.graph.nodes | | 1,598 |
OgnMoveToTarget.md | # Move To Target
This node smoothly translates, rotates, and scales a prim object to a target prim object given a speed and easing factor. At the end of the maneuver, the source prim will have the translation, rotation, and scale of the target prim.
Note: The Prim must have xform:orient in transform stack in order to interpolate rotations
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Execute In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed. | None |
| Exponent (inputs:exponent) | float | The blend exponent, which is the degree of the ease curve (1 = linear, 2 = quadratic, 3 = cubic, etc). | 2.0 |
| Source Prim (inputs:sourcePrim) | target | The source prim to be transformed | None |
| Source Prim Path (inputs:sourcePrimPath) | path | The source prim to be transformed, used when ‘useSourcePath’ is true | None |
| Speed (inputs:speed) | double | The peak speed of approach (Units / Second) | 1.0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Execution (inputs:execution) | `execution` | Signal to the graph that this node is ready to stop the maneuver | None |
| Target Prim (inputs:targetPrim) | `target` | The destination prim. The target’s translation, rotation, and scale will be matched by the sourcePrim | None |
| Target Prim Path (inputs:targetPrimPath) | `path` | The destination prim. The target’s translation, rotation, and scale will be matched by the sourcePrim, used when ‘useTargetPath’ is true | None |
| Use Source Path (inputs:useSourcePath) | `bool` | When true, the ‘sourcePrimPath’ attribute is used, otherwise it will read the connection at the ‘sourcePrim’ attribute | False |
| Use Target Path (inputs:useTargetPath) | `bool` | When true, the ‘targetPrimPath’ attribute is used, otherwise it will read the connection at the ‘targetPrim’ attribute | False |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Finished (outputs:finished) | `execution` | When the maneuver is completed, signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.MoveToTarget |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Move To Target |
| Categories | sceneGraph |
| Generated Class Name | OgnMoveToTargetDatabase |
| Python Module | omni.graph.nodes | | 2,624 |
OgnMoveToTransform.md | # Move to Transform
Perform a transformation maneuver, moving a prim to a target transformation given a speed and easing factor. Transformation, Rotation, and Scale from a 4x4 transformation matrix will be applied Note: The Prim must have xform:orient in transform stack in order to interpolate rotations
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed. | None |
| Ease Exponent (inputs:exponent) | float | The blend exponent, which is the degree of the ease curve (1 = linear, 2 = quadratic, 3 = cubic, etc). | 2.0 |
| Prim (inputs:prim) | target | The prim to be transformed. | None |
| Prim Path (inputs:primPath) | path | The source prim to be transformed, used when ‘Use Path’ is true | None |
| Speed (inputs:speed) | double | The peak speed of approach (Units / Second) | 1.0 |
| Stop (inputs:stop) | | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Execution Stop Signal | execution | Signal to the graph that this node is ready to stop the maneuver | None |
| Target Transform | matrixd[4] | The desired local transform | [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]] |
| Use Path | bool | When true, the ‘Prim Path’ attribute is used, otherwise it will read the connection at the ‘Prim’ attribute | False |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Finished | execution | When the maneuver is completed, signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.MoveToTransform |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Move to Transform |
| Categories | sceneGraph |
| Generated Class Name | OgnMoveToTransformDatabase |
| Python Module | omni.graph.nodes | | 2,137 |