file_path
stringlengths 5
148
| content
stringlengths 150
498k
| size
int64 150
498k
|
|---|---|---|
OgnMultDouble.md | # Multiply Double (Python)
Example node that multiplies 2 doubles together
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|--------|------------|---------|
| A (inputs:a) | double | Input a | 0 |
| B (inputs:b) | double | Input b | 0 |
## Outputs
| Name | Type | Descripton | Default |
|------|--------|------------|---------|
| Out (outputs:out) | double | The result of a * b | None |
## Metadata
| Name | Value |
|------------|------------|
| Unique ID | |
<p>
omni.graph.examples.python.MultDouble
<p>
Version
<p>
1
<p>
Extension
<p>
omni.graph.examples.python
<p>
Has State?
<p>
False
<p>
Implementation Language
<p>
Python
<p>
Default Memory Type
<p>
cpu
<p>
Generated Code Exclusions
<p>
None
<p>
uiName
<p>
Multiply Double (Python)
<p>
Categories
<p>
examples
<p>
Generated Class Name
<p>
OgnMultDoubleDatabase
<p>
Python Module
<p>
omni.graph.examples.python
| 1,053 |
OgnMultigate.md | # Multigate
This node cycles through each of its N outputs. On each input, one output will be activated. Outputs will be activated in sequence, eg: 0->1->2->3->4->0->1…. ‘Output 0’ is provided as the first output to be activated. To add more to the sequence add new output attributes with indexed unique names, such as ‘outputs:output1’, ‘outputs:output2’, etc.
## Installation
To use this node enable `omni.graph.action_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 |
| Reset (inputs:reset) | execution | Signal to the node to reset its internal counter. The next time ‘Execute In’ is activated it will go back to activating ‘Output 0’. This will skip any other outputs present. | None |
## Outputs
| Name | Type | Description | Default |
|-----------------|---------------|-----------------------------------------------------------------------------|---------|
| Output0 (outputs:output0) | execution | On the first execution signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.action.Multigate |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Icon | ogn/icons/omni.graph.action.Multigate.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Multigate |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnMultigateDatabase |
| Python Module | omni.graph.action_nodes | | 2,222 |
OgnMultiply.md | # Multiply
## Multiply
Computes the element-wise product of two or more inputs (multiplication). This includes simple values, tuples, arrays, and arrays of tuples. If one input has a higher dimension than the other, then the input with lower dimension will be added to each element of the higher-dimension input.
Examples:
- scalar * tuple = resultTuple (where resultTuple is formed by multiplying scalar to each element in tuple).
- tuple * arrayOfTuples = resultArrayOfTuples (where resultArrayOfTuples is formed by multiplying each element in tuple with each corresponding element of each tuple in arrayOfTuples).
- scalar * arrayOfTuples = resultArrayOfTuples (where resultArrayOfTuples is formed by multiplying scalar to each element of every tuple in arrayOfTuples).
To add/remove factors 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][]', ...] | | |
First value to multiply.
None
B (inputs:b)
- '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[]'
| First value to multiply | Second value to multiply | None |
|-------------------------|--------------------------|------|
| int<br>'int64'<br>'int64[]'<br>'int[2]'<br>'int[2][]'<br>'int[3]'<br>'int[3][]'<br>'int[4]'<br>'int[4][]'<br>'int[]'<br>'matrixd[2]'<br>'matrixd[2][]'<br>'matrixd[3]'<br>'matrixd[3][]'<br>'matrixd[4]'<br>'matrixd[4][]'<br>'normald[3]'<br>'normald[3][]'<br>'normalf[3]'<br>'normalf[3][]'<br>'normalh[3]'<br>'normalh[3][]'<br>'pointd[3]'<br>'pointd[3][]'<br>'pointf[3]'<br>'pointf[3][]'<br>'pointh[3]'<br>'pointh[3][]'<br>'quatd[4]'<br>'quatd[4][]'<br>'quatf[4]'<br>'quatf[4][]'<br>'quath[4]'<br>'quath[4][]'<br>'texcoordd[2]'<br>'texcoordd[2][]'<br>'texcoordd[3]'<br>'texcoordd[3][]'<br>'texcoordf[2]'<br>'texcoordf[2][]'<br>'texcoordf[3]'<br>'texcoordf[3][]'<br>'texcoordh[2]'<br>'texcoordh[2][]'<br>'texcoordh[3]'<br>'texcoordh[3][]'<br>'timecode'<br>'timecode[]'<br>'transform[4]'<br>'transform[4][]'<br>'uchar'<br>'uchar[]'<br>'uint'<br>'uint64'<br>'uint64[]'<br>'uint[]'<br>'vectord[3]'<br>'vectord[3][]'<br>'vectorf[3]'<br>'vectorf[3][]'<br>'vectorh[3]'<br>'vectorh[3][]' | |
## Outputs
| Name | Type | Descripton | Default |
|------|------|------------|---------|
| Product (outputs:product) | ['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'] | | |
### Inputs
- **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
The element-wise product of the input numerical values (with preserved typing).
### Returns
None
## Metadata
### Name
- **Unique ID**: omni.graph.nodes.Multiply
- **Version**: 2
- **Extension**: omni.graph.nodes
- **Has State?**: False
- **Implementation Language**: C++
- **Default Memory Type**: cpu
- **Generated Code Exclusions**: None
- **uiName**: Multiply
- **Categories**: math:operator
- **Generated Class Name**: OgnMultiplyDatabase
- **Python Module**: omni.graph.nodes | 5,407 |
OgnMultisequence.md | # Sequence
Outputs an execution pulse along each of its N outputs in sequence. For every single input execution pulse, each and every output will be exclusively enabled in order. ‘Output 0’ is provided by default. To add more to the sequence add new output attributes with indexed unique names, such as ‘outputs:output1’, ‘outputs:output2’, etc.
## 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 |
| --- | --- | --- | --- |
| Output0 (outputs:output0) | `execution` | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.Multisequence |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| --- | --- |
| Icon | ogn/icons/omni.graph.action.Multisequence.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Sequence |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnMultisequenceDatabase |
| Python Module | omni.graph.action_nodes | | 1,321 |
OgnNand.md | # Boolean NAND
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['bool', 'bool[]']` | Input A: bool or bool array. | None |
| B (`inputs:b`) | `['bool', 'bool[]']` | Input B: bool or bool array. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (`outputs:result`) | `['bool', 'bool[]']` | The result of the boolean NAND - an array of booleans if either input is an array, otherwise a boolean. | None |
| Name | Value |
|------------|----------------------------|
| Unique ID | omni.graph.nodes.BooleanNand |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Boolean NAND |
| Categories | math:condition |
| Generated Class Name | OgnNandDatabase |
| Python Module | omni.graph.nodes | | 1,183 |
OgnNegate.md | # Negate
Computes the result of multiplying a vector, scalar, or array of vectors or scalars by -1. The input must not be unsigned.
## 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[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]']` | | |
| Name | Type | Descripton | Default |
|------|------|------------|---------|
| Output (outputs:output) | ['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', '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 vector(s) or scalar(s) to negate | None |
# Negate Node
## Overview
The Negate node performs a negation operation on the input value(s).
### Inputs
| Name | Type | Description |
| --- | --- | --- |
| Value(s) | various | The input value(s) to be negated. |
### Outputs
| Name | Type | Description |
| --- | --- | --- |
| Result(s) | various | The resulting negated value(s). |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.Negate |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Negate |
| Categories | math:operator |
| Generated Class Name | OgnNegateDatabase |
| Python Module | omni.graph.nodes | | 3,081 |
OgnNoise.md | # Noise
Sample values from a Perlin noise field. The noise field for any given seed is static: the same input position will always give the same result. This is useful in many areas, such as texturing and animation, where repeatability is essential. If you want a result that varies then you will need to vary either the position or the seed. For example, connecting the “Frame” output of an OnTick node to position will provide a noise result which varies from frame to frame. Perlin noise is locally smooth, meaning that small changes in the sample position will produce small changes in the resulting noise. Varying the seed value will produce a more chaotic result.
Another characteristic of Perlin noise is that it is zero at the corners of each cell in the field. In practical terms this means that integral positions, such as 5.0 in a one-dimensional field or (3.0, -1.0) in a two-dimensional field, will return a result of 0.0. Thus, if the source of your sample positions provides only integral values then all of your results will be zero. To avoid this try offsetting your position values by a fractional amount, such as 0.5.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Position (`inputs:position`) | `['float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]']` | Position(s) within the noise field to be sampled. For a given seed, the same position will always return the same noise value. | None |
| Seed (`inputs:seed`) | `uint` | Positive seeding value for generating the Perlin noise field. | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Metadata
## Metadata
### Name
### Value
#### Unique ID
omni.graph.nodes.Noise
#### Version
1
#### Extension
omni.graph.nodes
#### Has State?
False
#### Implementation Language
C++
#### Default Memory Type
cpu
#### Generated Code Exclusions
None
#### uiName
Noise
#### Categories
math:operator
#### Generated Class Name
OgnNoiseDatabase
#### Python Module
omni.graph.nodes | 2,142 |
OgnNoOp.md | # No-Op
Empty node, used only as a placeholder in the graph. It has no inputs or outputs.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Metadata
| Name | Value |
|---------------|---------------------------|
| Unique ID | omni.graph.nodes.Noop |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | No-Op |
| Categories | debug |
| Generated Class Name | OgnNoOpDatabase |
| Python Module | omni.graph.nodes | | 760 |
OgnNormalize.md | # Normalize
Normalize the input vector (or array of input vectors). If the input vector has a magnitude of zero, the null vector is returned. The inputs will be copied into the output attribute before the normalization is performed on said output (i.e. the input vector(s) are not mutated in-place).
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Vector (`inputs:vector`) | `['double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]']` | Input vector (or an array of input vectors) to normalize. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (`outputs:result`) | `['double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]']` | The normalized vector (or array of normalized vectors). | None |
## Normalize Node
### Inputs
| Input Type | Description | Default Value |
|------------|-------------|---------------|
| double[3][] | - | - |
| double[4] | - | - |
| double[4][] | - | - |
| float[2] | - | - |
| float[2][] | - | - |
| float[3] | - | - |
| float[3][] | - | - |
| float[4] | - | - |
| float[4][] | - | - |
| half[2] | - | - |
| half[2][] | - | - |
| half[3] | - | - |
| half[3][] | - | - |
| half[4] | - | - |
| half[4][] | - | - |
### Outputs
| Output Type | Description | Default Value |
|-------------|-------------|---------------|
| Copy of the input vector (or array of vectors) after applying the corresponding normalization operations. | - | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.Normalize |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Normalize |
| Categories | math:operator |
| Generated Class Name | OgnNormalizeDatabase |
| Python Module | omni.graph.nodes | | 2,290 |
OgnNot.md | # Boolean Not
Inverts a bool or bool array
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------|-------------------------------|-----------------------------|---------|
| Value In (`inputs:valueIn`) | `['bool', 'bool[]']` | bool or bool array to invert | None |
## Outputs
| Name | Type | Descripton | Default |
|-----------------|-------------------------------|-----------------------------|---------|
| Value Out (`outputs:valueOut`) | `['bool', 'bool[]']` | inverted bool or bool array | None |
## Metadata
| Name | Value |
|------------|------------------------------|
| Unique ID | omni.graph.nodes.BooleanNot |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| --- | --- |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Boolean Not |
| Categories | math:condition |
| Generated Class Name | OgnNotDatabase |
| Python Module | omni.graph.nodes | | 1,234 |
OgnNthRoot.md | # Nth Root
## Nth Root
Computes the nth root of value. The result is the same type as the input value if the numerator is a decimal type. Otherwise the result is a double. If the input is a vector or matrix, then the node will calculate the square root of each element, and output a vector or matrix of the same size. Note that there are combinations of inputs that can result in a loss of precision due to different value ranges. Taking roots of a negative number will give a result of NaN if “Nth Root” is even. Setting “Nth Root” to zero will give a result of inf.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Nth Root (inputs:nthRoot) | int | The degree of the root for the mathematical operation. Equivalent to raising “Value” to the 1/”Nth Root” power. Note that the result will be NaN if “Nth Root” is even and “Value” is negative. Also note that the result will be inf if “Nth Root” is set to zero. | 2 |
| 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][]'] | | |
## 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[]'] | | None |
## Metadata
### Name
- Unique ID: omni.graph.nodes.NthRoot
- Version: 1
- Extension: omni.graph.nodes
- Has State?: False
- Implementation Language: C++
- Default Memory Type: cpu
- Generated Code Exclusions: None
| uiName | Nth Root |
| ------------ | ---------------- |
| Categories | math:operator |
| Generated Class Name | OgnNthRootDatabase |
| Python Module | omni.graph.nodes | | 2,228 |
OgnOnce.md | # Once
Controls flow of execution by activating the ‘Once’ signal on the first execution and the ‘After’ signal for each successive execution.
## 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 |
| Reset (`inputs:reset`) | `execution` | Signal to the node to reset the state so that ‘Once’ will be activated on the next ‘Exec In’. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| After (`outputs:after`) | `execution` | On every execution after the first one, or the first execution after ‘Reset’ is activated signal to the graph that execution can continue downstream. | None |
| Once (`outputs:once`) | `execution` | On the very first execution, or the first execution after ‘Reset’ is activated signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.action.Once |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Once |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnOnceDatabase |
| Python Module | omni.graph.action_nodes | | 1,640 |
OgnOnClosing.md | # On Closing
Activates an output signal when the USD stage is about to be closed.
Note that only simple necessary actions should be taken during closing since the application is in the process of cleaning up the existing state and some systems may be in a transitional state.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Closing (outputs:execOut) | `execution` | After the file close event was received signal to the graph that execution should continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.OnClosing |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | On Closing |
| Categories | graph:action,event |
| Generated Class Name | OgnOnClosingDatabase |
|----------------------|----------------------|
| Python Module | omni.graph.action_nodes | | 1,076 |
OgnOnCustomEvent.md | # On Custom Event
Event node which fires when the specified custom event is sent. This node is used in combination with ‘omni.graph.action.SendCustomEvent’.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Event Name (`inputs:eventName`) | `token` | The name of the custom event. | |
| Metadata | `literalOnly` = 1 | | |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
| Metadata | `literalOnly` = 1 | | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle (`outputs:bundle`) | `bundle` | Bundle received with the event. The contents of the bundle are determined by the input bundle given to the corresponding ‘SendCustomEvent’ node. | |
## Metadata
### Name
- Value
### Unique ID
- omni.graph.action.OnCustomEvent
### Version
- 3
### Extension
- omni.graph.action_nodes
### Has State?
- True
### Implementation Language
- Python
### Default Memory Type
- cpu
### Generated Code Exclusions
- None
### uiName
- On Custom Event
### Categories
- graph:action,event
### Generated Class Name
- OgnOnCustomEventDatabase
### Python Module
- omni.graph.action_nodes | 1,322 |
OgnOnGamepadInput.md | # On Gamepad Input
Event node which fires when a gamepad event occurs. This node only capture events on buttons, excluding triggers and sticks.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gamepad Element In (`inputs:gamepadElementIn`) | `token` | The gamepad button that will trigger the downstream execution. | Face Button Bottom |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `literalOnly` = 1 | |
| Metadata | | `allowedTokens` = Face Button Bottom,Face Button Right,Face Button Left,Face Button Top,Left Shoulder,Right Shoulder,Special Left,Special Right,Left Stick Button,Right Stick Button,D-Pad Up,D-Pad Right,D-Pad Down,D-Pad Left | |
| Gamepad ID (`inputs:gamepadId`) | `uint` | Gamepad id number starting from 0. Each gamepad will be registered automatically with a unique ID monotonically increasing in the order they are connected. If a gamepad is disconnected, the ID assigned to the remaining gamepad will be adjusted accordingly so the IDs are always continuous and start from 0. Changing this value to a non-existing ID will result in an error prompt in the console and the node will not listen to any gamepad input. | 0 |
| Metadata | | `literalOnly` = 1 | |
| Only Simulate On Play (`inputs:onlyPlayback`) | | | |
# Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Play On | Type | When true, the node is only executed while the Stage is being played. | True |
| Metadata | Metadata | `literalOnly = 1` | |
# Outputs
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Pressed (`outputs:isPressed`) | Type | True if the gamepad button was pressed, False if it was released. | None |
| Pressed (`outputs:pressed`) | Type | When the gamepad element was pressed signal to the graph that execution can continue downstream. | None |
| Released (`outputs:released`) | Type | When the gamepad element was released signal to the graph that execution can continue downstream. | None |
# Metadata
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.OnGamepadInput |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | On Gamepad Input |
| Categories | graph:action,input:gamepad |
| Generated Class Name | OgnOnGamepadInputDatabase |
| Python Module | omni.graph.action_nodes | | 2,566 |
OgnOnImpulseEvent.md | # On Impulse Event
Triggers the output execution once when the state attribute ‘Enable Impulse’ is set.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
| Metadata | | `literalOnly` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Trigger (`outputs:execOut`) | `execution` | After the impulse, signal to the graph that execution can continue downstream. | None |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Name | Type | Descripton | Default |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.action.OnImpulseEvent |
| Version | 3 |
| Extension | omni.graph.action_nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | On Impulse Event |
| Categories | graph:action,event |
| Generated Class Name | OgnOnImpulseEventDatabase |
| Python Module | omni.graph.action_nodes | | 1,524 |
OgnOnKeyboardInput.md | # On Keyboard Input
Event node which fires when a keyboard event occurs. The event can be any of the keys accepted by ‘Key In’, plus any combination of modifiers as specified by inputs ‘Shift’, ‘Alt’, and ‘Ctrl’.
For key combinations, the press event requires all modifiers to be held, with the ‘Key In’ pressed last. The release event is only triggered once when one of the chosen keys released after the pressed event happens.
For example: if the combination is Ctrl-Shift-D, the pressed event happens once right after D is pressed while both Ctrl and Shift are held. The release event happens only once, when the user releases any one of Ctrl, Shift and D while holding them.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Alt (`inputs:altIn`) | `bool` | When true, the Alt key modifier must be pressed along with the ‘Key In’ to activate the output. | False |
| Ctrl (`inputs:ctrlIn`) | `bool` | When true, the Ctrl key modifier must be pressed along with the ‘Key In’ to activate the output. | False |
| Key In (`inputs:keyIn`) | `token` | The key that triggers the downstream execution, not including modifiers. | A |
| Metadata | literalOnly = 1 |
| --- | --- |
| Metadata | allowedTokens = A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,Apostrophe,Backslash,Backspace,CapsLock,Comma,Del,Down,End,Enter,Equal,Escape,F1,F10,F11,F12,F2,F3,F4,F5,F6,F7,F8,F9,GraveAccent,Home,Insert,Key0,Key1,Key2,Key3,Key4,Key5,Key6,Key7,Key8,Key9,Left,LeftAlt,LeftBracket,LeftControl,LeftShift,LeftSuper,Menu,Minus,NumLock,Numpad0,Numpad1,Numpad2,Numpad3,Numpad4,Numpad5,Numpad6,Numpad7,Numpad8,Numpad9,NumpadAdd,NumpadDel,NumpadDivide,NumpadEnter,NumpadEqual,NumpadMultiply,NumpadSubtract,PageDown,PageUp,Pause,Period,PrintScreen,Right,RightAlt,RightBracket,RightControl,RightShift,RightSuper,ScrollLock,Semicolon,Slash,Space,Tab,Up |
| Only Simulate On Play (inputs:onlyPlayback) | bool | When true, the node is only executed while the Stage is being played. | True |
| Metadata | literalOnly = 1 |
| Shift (inputs:shiftIn) | bool | When true, the Shift key modifier must be pressed along with the ‘Key In’ to activate the output. | False |
| Metadata | literalOnly = 1 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Pressed (outputs:isPressed) | bool | True if the most recent activation was the key being pressed, False if it was released. | None |
| Key Out (outputs:keyOut) | token | The key that was pressed or released to trigger the execution of this node. | None |
| Pressed (outputs:pressed) | execution | After the key was pressed, along with any required modifiers, signal to the graph that the execution can continue downstream. | None |
| Released (outputs:released) | execution | After the key or any of the required modifiers were released, signal to the graph that the execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.OnKeyboardInput |
| Version | 4 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | |
| 属性 | 值 |
|------------|-------------------|
| cpu | |
| Generated Code Exclusions | None |
| uiName | On Keyboard Input |
| Categories | graph:action,input:keyboard |
| Generated Class Name | OgnOnKeyboardInputDatabase |
| Python Module | omni.graph.action_nodes | | 3,549 |
OgnOnLoaded.md | # On Loaded
Activates the output on the first update of the graph after it is created or loaded. This will run before any other event node, and will only run once after this node is created.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (`outputs:execOut`) | `execution` | On first create or load of the graph signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.OnLoaded |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | On Loaded |
| Categories | graph:action,event |
# Main Content
## Section 1
### Subsection 1
#### Table
| Column 1 | Column 2 |
|-------------------|-------------------|
| Generated Class Name | OgnOnLoadedDatabase |
| Python Module | omni.graph.action_nodes | | 1,078 |
OgnOnMessageBusEvent.md | # On MessageBus Event
Event node which fires when the specified event appears on the Application Message Bus. The node uses a callback to monitor messages on the message bus and sets an internal state value when an event named ‘Event Name’ was received.
Here’s an example of sending a kit application message bus event:
```python
import carb.events
import omni.kit.app
msg = carb.events.type_from_string("my_event_name")
omni.kit.app.get_app().get_message_bus_event_stream().push(msg, payload={"arg1": 42})
```
The event payload data will be copied in to matching dynamic output attributes if they exist.
In the previous example, 42 would be copied to outputs:arg1 if possible.
[SendMessageBusEvent](OgnSendMessageBusEvent.html#omni-graph-action-sendmessagebusevent) is related.
## Installation
To use this node enable [omni.graph.action_nodes](../Overview.html#ext-omni-graph-action-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Event Name (inputs:eventName) | token | The name of the custom event. | |
| Metadata | literalOnly | = 1 | |
| Only Simulate On Play (inputs:onlyPlayback) | bool | When true, the node is only executed while the Stage is being played. | True |
| Metadata | literalOnly | | |
# Outputs
## Outputs
### Name
- Name
### Type
- Type
### Descripton
- Descripton
### Default
- Default
# Metadata
## Metadata
### Name
- Name
### Value
- Value | 1,441 |
OgnOnMouseInput.md | # On Mouse Input
Event node which fires when a mouse event occurs. You can choose which ‘Mouse Element’ this node reacts to. When ‘Mouse Element’ is chosen to be a button, the only meaningful outputs are: ‘Pressed’, ‘Released’ and ‘Is Pressed’. When scroll or move events are chosen, the only meaningful outputs are: ‘Value Changed’ and ‘Value’. You can choose to output normalized or pixel coordinates of the mouse.
Pixel coordinates are the absolute position of the mouse cursor in pixel units. The original point is the upper left corner. The minimum value is 0, and the maximum value depends on the size of the window.
Normalized coordinates are the relative position of the mouse cursor to the window. The value is always between 0 and 1.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Mouse Element (`inputs:mouseElement`) | `token` | The name of the mouse event that will trigger the downstream execution. | Left Button |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
## Outputs
## On Mouse Input
### Parameters
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Pressed (outputs:isPressed) | bool | True if the mouse button was pressed, False if it was released or ‘Mouse Element’ is not related to a button, as in a move or scroll. | None |
| Pressed (outputs:pressed) | execution | When any mouse button was pressed signal to the graph that the execution can continue downstream. Will not execute on move or scroll events. | None |
| Released (outputs:released) | execution | When any mouse button was released signal to the graph that the execution can continue downstream. Will not execute on move or scroll events. | None |
| Delta Value (outputs:value) | float[2] | The meaning of this output depends on ‘Mouse Element’. Normalized Move: will output the normalized coordinates of mouse, each element of the vector is in the range of [0, 1]. Pixel Move: will output the absolute coordinates of mouse, each vector is in the range of [0, pixel width/height of the window]. Scroll: will output the change of scroll value. Otherwise: will output [0,0]. | None |
| Moved (outputs:valueChanged) | execution | When the mouse was moved or scrolled signal to the graph that the execution can continue downstream. Will not execute on press or release events. | None |
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.OnMouseInput |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | On Mouse Input |
| Categories | graph:action,input:mouse |
| Generated Class Name | OgnOnMouseInputDatabase |
| Python Module | omni.graph.action_nodes | | 2,952 |
OgnOnNewFrame.md | # On New Frame
Triggers when there is a new frame available for the given viewport. Note that the graph will run asynchronously to the new frame event
## 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 | |
| Metadata | | `displayGroup` = parameters | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
| Frame Number (`outputs:frameNumber`) | `int` | The number of the frame which is available | None |
## Metadata
| Name | Value |
|--------------|----------------------------------------|
| Unique ID | omni.graph.ui_nodes.OnNewFrame |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | True |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | On New Frame |
| Categories | graph:action,event |
| Generated Class Name | OgnOnNewFrameDatabase |
| Python Module | omni.graph.ui_nodes | | 1,528 |
OgnOnObjectChange.md | # On USD Object Change
Monitors a specific ‘Property Name’ on a connected ‘Prim’ target. When a change in the underlying USD is detected, activates execution of the downstream graph.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Property Name (`inputs:name`) | `token` | The name of the property of interest on the USD prim being monitored. | None |
| Metadata | | `literalOnly` = 1 | |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
| Metadata | | `literalOnly` = 1 | |
| Path (`inputs:path`) | `path` | The path of object of interest (property or prim). If the prim input has a target, this is ignored | None |
| Metadata | | `literalOnly` = 1 | |
| Prim (`inputs:prim`) | `target` | | |
# Metadata
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Changed (outputs:changed) | `execution` | When the watched property changes signal to the graph that execution can continue downstream. | None |
| Property Name (outputs:propertyName) | `token` | The name of the property on which the change was detected. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.OnObjectChange |
| Version | 5 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | On USD Object Change |
| Categories | graph:action,event |
| Generated Class Name | OgnOnObjectChangeDatabase |
| Python Module | omni.graph.action_nodes | | 1,709 |
OgnOnPicked.md | # On Picked (BETA)
Event node which fires when a picking event occurs in the specified viewport. Note that picking events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gesture (`inputs:gesture`) | `token` | The input gesture to trigger a picking event | Left Mouse Click |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `literalOnly` = 1 | |
| Metadata | | `allowedTokens` = Left Mouse Click,Right Mouse Click,Middle Mouse Click,Left Mouse Press,Right Mouse Press,Middle Mouse Press | |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while Stage is being played. | True |
| Metadata | | `literalOnly` = 1 | |
| Tracked Prims (`inputs:trackedPrims`) | `target` | Optionally specify a set of tracked prims that will cause ‘Picked’ to fire when picked | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.OnPicked |
| Version | 3 |
| Extension | omni.graph.ui_nodes |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Tracked Prim Picked | bool | True if a tracked prim got picked, or if any prim got picked if no tracked prims are specified (will always be true when ‘Picked’ fires, and false when ‘Missed’ fires) | None |
| Missed | execution | When an attempted picking did not pick a tracked prim, or when nothing gets picked if no tracked prims are specified, signal to the graph that execution can continue downstream on this path. | None |
| Picked | execution | When a tracked prim is picked, or when any prim is picked if no tracked prims are specified, signal to the graph that execution can continue downstream on this path. | None |
| Picked Prim | target | The picked prim, or an empty target if nothing got picked | None |
| Picked Prim Path | token | The path of the picked prim, or an empty string if nothing got picked | None |
| Picked World Position | pointd[3] | The XYZ-coordinates of the point in world space at which the prim got picked, or (0,0,0) if nothing got picked | None |
| Tracked Prim Paths | token[] | A list of the paths of the prims specified in ‘Tracked Prims’ | None |
| Has State? | False |
|-------------|-------|
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | On Picked (BETA) |
| Categories | graph:action,ui |
| Generated Class Name | OgnOnPickedDatabase |
| Python Module | omni.graph.ui_nodes | | 2,634 |
OgnOnPlaybackTick.md | # On Playback Tick
For each frame tick during playback, activate the downstream graph execution. In addition to the activation signal, the outputs also contain the playback time values, taken directly from the execution context.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|------------|--------------------------------------------------|---------|
| Delta Seconds (`outputs:deltaSeconds`) | double | The number of seconds that have elapsed since the last update. | None |
| Frame (`outputs:frame`) | double | The global playback time in frames, equivalent to (Time * PlaybackFramesPerSecond). | None |
| Tick (`outputs:tick`) | execution | Signal to the graph that execution can continue downstream. | None |
| Time (`outputs:time`) | double | The global playback time in seconds. | None |
## Metadata
| Name | Value |
|--------------|----------|
| Unique ID | |
| 属性 | 值 |
| --- | --- |
| Action | omni.graph.action.OnPlaybackTick |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | On Playback Tick |
| Categories | graph:action,event |
| Generated Class Name | OgnOnPlaybackTickDatabase |
| Python Module | omni.graph.action_nodes | | 1,559 |
OgnOnStageEvent.md | # On Stage Event
Activates the downstream graph execution when the specified ‘Event Name’ from the Stage occurs. Stage Events are emitted when certain USD stage-related actions are performed by the system:
- Saved: USD file saved.
- Selection Changed: USD Prim selection has changed.
- Hierarchy Changed: USD stage hierarchy has changed, e.g. a prim is added, deleted or moved.
- OmniGraph Start Play: OmniGraph started.
- OmniGraph Stop Play: OmniGraph stopped.
- Simulation Start Play: Simulation started.
- Simulation Stop Play: Simulation stopped.
- Animation Start Play: Animation playback has started.
- Animation Stop Play: Animation playback has stopped.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Event Name (`inputs:eventName`) | `token` | The event of interest | |
| Metadata | | `allowedTokens` = Saved,Selection Changed,Hierarchy Changed,OmniGraph Start Play,OmniGraph Stop Play,Simulation Start Play,Simulation Stop Play,Animation Start Play,Animation Stop Play | |
| Metadata | | `default` = Animation Start Play | |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `literalOnly` = 1 | |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
| Metadata | | `literalOnly` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (outputs:execOut) | `execution` | After the stage event is received, signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.OnStageEvent |
| Version | 4 |
| Extension | omni.graph.action_nodes |
| Has State? | True |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | On Stage Event |
| Categories | graph:action,event |
| Generated Class Name | OgnOnStageEventDatabase |
| Python Module | omni.graph.action_nodes | | 2,091 |
OgnOnTick.md | # On Tick
Activates execution of the downstream graph at a regular multiple of the application’s refresh rate. As the application runs the this node will skip every ‘Update Period’ executions. Typically you might set this to a larger value if the downstream graph is doing something you do not want to happen too frequently, such as printing out debugging messages or polling some input that does not get triggered very often. The actual refresh rate timing will depend on external factors such as rendering time and scene complexity. In addition to the activation signal, the outputs also contain global time information for convenience.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Update Period (Ticks) (`inputs:framePeriod`) | `uint` | The number of application refreshes to skip between executions of this node. For example, the default 0 means no skipping so this node executes on every application update, 1 means every other update. This can be used to rate-limit updates. | 0 |
| Metadata | | `literalOnly` = 1 | |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
| Metadata | | `literalOnly` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Absolute Simulation Time (Seconds) (outputs:absoluteSimTime) | double | The accumulated total of elapsed times between rendered frames. This is independent of any executions skipped as a result of a non-zero ‘Update Period’. | None |
| Delta (Seconds) (outputs:deltaSeconds) | double | The accumulated graph evaluation time since the last time the graph downstream of ‘Tick’ was activated. | None |
| Animation Time (Frames) (outputs:frame) | double | The global animation time in frames, equivalent to (Animation Time * FramesPerSecond), during playback. | None |
| Is Playing (outputs:isPlaying) | bool | True during global animation timeline playback. | None |
| Tick (outputs:tick) | execution | At each specified update tick, signal to the graph that execution can continue downstream. | None |
| Animation Time (Seconds) (outputs:time) | double | The global animation time in seconds during playback. | None |
| Time Since Start (Seconds) (outputs:timeSinceStart) | double | Elapsed time since the application started. | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Accumulated Seconds (state:accumulatedSeconds) | double | Accumulated time since the last activation of the downstream graph. | 0 |
| Frame Count (state:frameCount) | uint | Accumulated frames since the last activation of the downstream graph. | 0 |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.OnTick |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | True |
| Implementation Language | C++ |
| 属性 | 值 |
| --- | --- |
| cpu | |
| Generated Code Exclusions | None |
| uiName | On Tick |
| Categories | graph:action,event |
| Generated Class Name | OgnOnTickDatabase |
| Python Module | omni.graph.action_nodes | | 3,269 |
OgnOnVariableChange.md | # On Variable Change
Activates execution of the downstream graph when a graph variable’s value changes. The name of the variable comes from the input ‘Variable Name’. Only variables in the current graph are considered.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
| Metadata | | `literalOnly` = 1 | |
| Variable Name (`inputs:variableName`) | `token` | The name of the graph variable to monitor for changes. | |
| Metadata | | `literalOnly` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Changed (`outputs:changed`) | `execution` | When the variable value changes, signal to the graph that execution can continue downstream. | |
## Metadata
| Name | Value |
|-------------|--------------------------------------------|
| Unique ID | omni.graph.action.OnVariableChange |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | On Variable Change |
| Categories | graph:action,event |
| Generated Class Name | OgnOnVariableChangeDatabase |
| Python Module | omni.graph.action_nodes | | 1,712 |
OgnOnViewportClicked.md | # On Viewport Clicked (BETA)
Event node which fires when a click event occurs in the specified viewport. A press event differs from a click event only in timing. Press events are held down while click events are pressed and then immediately (within a small amount of time) released. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gesture (`inputs:gesture`) | `token` | The input gesture to trigger viewport click events. | Left Mouse Click |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `literalOnly` = 1 | |
| Metadata | | `allowedTokens` = Left Mouse Click,Right Mouse Click,Middle Mouse Click | |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
| Metadata | | `literalOnly` = 1 | |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | `bool` | | |
| Metadata | | `literalOnly` = 1 | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Scale Position | Boolean | When true, the components of the 2D position output are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. | False |
| Metadata | | | literalOnly = 1 |
| Viewport (`inputs:viewport`) | token | Name of the viewport window to watch for click events. | Viewport |
| Metadata | | | literalOnly = 1 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Clicked (`outputs:clicked`) | execution | When the specified input gesture triggers a click event in the specified viewport, signal to the graph that execution can continue downstream. | None |
| Position (`outputs:position`) | double[2] | The position at which the click event occurred. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.OnViewportClicked |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | On Viewport Clicked (BETA) |
| Categories | graph:action,ui |
| Generated Class Name | OgnOnViewportClickedDatabase |
| Python Module | omni.graph.ui_nodes | | 2,446 |
OgnOnViewportDragged.md | # On Viewport Dragged (BETA)
Event node which fires when a drag event occurs in the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gesture (`inputs:gesture`) | `token` | The input gesture to trigger viewport drag events. | Left Mouse Drag |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `literalOnly` = 1 | |
| Metadata | | `allowedTokens` = Left Mouse Drag,Right Mouse Drag,Middle Mouse Drag | |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while Stage is being played | True |
| Metadata | | `literalOnly` = 1 | |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | `bool` | When true, the components of 2D position outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. | |
## Inputs
| Name | Type | Default | Description |
| --- | --- | --- | --- |
| Viewport (inputs:viewport) | token | | Name of the viewport window to watch for drag events. | Viewport |
| Metadata | | | |
| literalOnly = 1 | | | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Began (outputs:began) | execution | When the drag begins, signal to the graph that execution can continue downstream on this path. ‘Initial Position’ will also be populated when this signal is set. | None |
| Ended (outputs:ended) | execution | When the drag ends, signal to the graph that execution can continue downstream on this path. ‘Final Position’ will also be populated when this signal is set. | None |
| Final Position (outputs:finalPosition) | double[2] | The mouse position at which the drag ended (valid when ‘Ended’ is enabled). | None |
| Initial Position (outputs:initialPosition) | double[2] | The mouse position at which the drag began (valid when either ‘Began’ or ‘Ended’ is enabled). | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.OnViewportDragged |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | On Viewport Dragged (BETA) |
| Categories | graph:action,ui |
| Generated Class Name | OgnOnViewportDraggedDatabase |
| Python Module | omni.graph.ui_nodes | | 2,569 |
OgnOnViewportHovered.md | # On Viewport Hovered (BETA)
Event node which fires when the specified viewport is hovered over. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while the Stage is being played. | True |
| Metadata | | `literalOnly` = 1 | |
| Viewport (`inputs:viewport`) | `token` | Name of the viewport window to watch for hover events. | Viewport |
| Metadata | | `literalOnly` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Began (`outputs:began`) | `execution` | | |
## Metadata
| Name | Value |
|------------|--------------------------------------------------------------------------------------------|
| Unique ID | omni.graph.ui_nodes.OnViewportHovered |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | On Viewport Hovered (BETA) |
| Categories | graph:action,ui |
| Generated Class Name | OgnOnViewportHoveredDatabase |
| Python Module | omni.graph.ui_nodes | | 2,278 |
OgnOnViewportPressed.md | # On Viewport Pressed (BETA)
Event node which fires when a press event is initiated in a viewport, and when that press is released. A press event differs from a click event only in timing. Press events are held down while click events are pressed and then immediately (within a small amount of time) released. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gesture (`inputs:gesture`) | `token` | The input gesture that will trigger press events | Left Mouse Press |
| Only Simulate On Play (`inputs:onlyPlayback`) | `bool` | When true, the node is only executed while Stage is being played | True |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | `bool` | | |
### Inputs
| Property | Value | Description |
|----------|-------|-------------|
| 2D Position Output Scaling | False | When true, the components of 2D position outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. |
| Metadata | literalOnly = 1 | - |
| Viewport | token | Name of the viewport window to watch for press events |
| Metadata | literalOnly = 1 | - |
### Outputs
| Name | Type | Description | Default |
|------|------|-------------|---------|
| Is Release Position Valid | bool | True if the press was released inside of the viewport, and false otherwise | None |
| Press Position | double[2] | The position at which the press occurred (valid when either ‘Pressed’ or ‘Released’ is enabled) | None |
| Pressed | execution | When a press event is initiated in the viewport, signal to the graph that execution can continue downstream on this path. ‘Press Position’ will also be populated when this signal is set. | None |
| Release Position | double[2] | The position at which the press was released, or (0,0) if the press was released outside of the viewport or the viewport is currently pressed (valid when ‘Ended’ is enabled and ‘Is Release Position Valid’ is true) | None |
| Released | execution | When a press in the viewport is released, signal to the graph that execution can continue downstream on this path. ‘Release Position’ and ‘Is Release Position Valid’ will also be populated when this signal is set. | None |
### Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.ui_nodes.OnViewportPressed |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | On Viewport Pressed (BETA) |
| Categories | Generated Class Name | Python Module |
|------------|----------------------|---------------|
| graph:action,ui | OgnOnViewportPressedDatabase | omni.graph.ui_nodes | | 2,931 |
OgnOnViewportScrolled.md | # On Viewport Scrolled (BETA)
Event node which fires when a scroll event occurs in the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Only Simulate On Play (`inputs:onlyPlayback`) | bool | When true, the node is only executed while the Stage is being played. | True |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | bool | When true, the components of the 2D position output are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. | False |
| Viewport (`inputs:viewport`) | token | Name of the viewport window to watch for scroll events. | Viewport |
## Outputs
# Metadata
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.OnViewportScrolled |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | On Viewport Scrolled (BETA) |
| Categories | graph:action,ui |
| Generated Class Name | OgnOnViewportScrolledDatabase |
| Python Module | omni.graph.ui_nodes | | 1,356 |
OgnOnWidgetClicked.md | # On Widget Clicked (BETA)
Event node which fires when a UI widget with the specified identifier is clicked. This node should be used in combination with UI creation nodes such as OgnButton.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Widget Identifier (`inputs:widgetIdentifier`) | `token` | A unique identifier identifying the widget. This should be specified in the UI creation node such as OgnButton. | |
| Metadata | | `literalOnly` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Clicked (`outputs:clicked`) | `execution` | When the widget is clicked, signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| 属性 | 值 |
| --- | --- |
| omni.graph.ui_nodes.OnWidgetClicked | |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | True |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| hidden | True |
| uiName | On Widget Clicked (BETA) |
| Categories | internal:test |
| Generated Class Name | OgnOnWidgetClickedDatabase |
| Python Module | omni.graph.ui_nodes | | 1,280 |
OgnOnWidgetValueChanged.md | # On Widget Value Changed (BETA)
Event node which fires when a UI widget with the specified identifier has its value changed. This node should be used in combination with UI creation nodes such as OgnSlider.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Widget Identifier (`inputs:widgetIdentifier`) | `token` | A unique identifier identifying the widget. This should be specified in the UI creation node such as OgnSlider. | |
| Metadata | | `literalOnly` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| New Value (`outputs:newValue`) | `['bool', 'float', 'int', 'string']` | The new value of the widget | None |
| Value Changed (`outputs:valueChanged`) | `execution` | When the value of the widget is changed, signal to the graph that execution can continue downstream. | |
## Metadata
| Name | Value |
|------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.ui_nodes.OnWidgetValueChanged |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | True |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| hidden | True |
| uiName | On Widget Value Changed (BETA) |
| Categories | internal:test |
| Generated Class Name | OgnOnWidgetValueChangedDatabase |
| Python Module | omni.graph.ui_nodes | | 2,175 |
OgnOrthonormalize.md | # Orthonormalize
## Orthonormalize
Computes the orthonormalized matrix from an input matrix or array of matrices. In practice, this involves treating the columns (or rows, depending on whether column-major or row-major semantics are being utilized for matrix descriptions - in mathematics the former is often used, while in computer graphics the latter tends to be preferred) of each input matrix as independent vectors that span some N-dimensional space (N being the number of column or row vectors in the matrix) and finding another set of mutually-perpendicular vectors that span the same space before normalizing each one (hence the term “orthonormal”; also see the so-called “Gram-Schmidt Process” that details exactly how one can go about performing this computation); these new sets of vectors can then be combined to form the “orthonormal” versions of each input matrix.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`inputs:matrix`) | `['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]']` | Input matrix or array of matrices to orthonormalize. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (`outputs:result`) | `['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]']` | The orthonormalized matrix or array of matrices (with preserved typing). | None |
## Metadata
## Name Value Table
| Name | Value |
|-----------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.Orthonormalize |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Orthonormalize |
| Categories | math:operator |
| Generated Class Name | OgnOrthonormalizeDatabase |
| Python Module | omni.graph.nodes | | 2,336 |
OgnPartialSum.md | # Compute Integer Array Partial Sums
Compute the partial sums of the input integer array named “Array” and put the result in an output integer array named “PartialSum”. A partial sum is the sum of all of the elements up to but not including a certain point in an array, so output element 0 is always 0, element 1 is array[0], element 2 is array[0] + array[1], etc.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|---------|-----------------------------------|---------|
| Array| `int[]` | List of integers whose partial sum is to be computed. | [] |
## Outputs
| Name | Type | Descripton | Default |
|--------------|---------|-----------------------------------|---------|
| Partial Sum | `int[]` | Array whose nth value equals the nth partial sum of the input “Array”. | [] |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.PartialSum |
| Version | |
1
Extension
omni.graph.nodes
Has State?
False
Implementation Language
C++
Default Memory Type
cpu
Generated Code Exclusions
None
uiName
Compute Integer Array Partial Sums
Categories
math:operator
Generated Class Name
OgnPartialSumDatabase
Python Module
omni.graph.nodes | 1,432 |
OgnPauseSound.md | # Pause Sound
## Installation
To use this node enable `omni.graph.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 |
| Sound Id (`inputs:soundId`) | `uint64` | The sound identifier | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| 属性 | 值 |
|------------------------|-------------|
| omni.graph.nodes.PauseSound | |
| Version | 1 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.PauseSound.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Pause Sound |
| Categories | sound |
| Generated Class Name | OgnPauseSoundDatabase |
| Python Module | omni.graph.nodes | | 1,243 |
OgnPlaySound.md | # Play Sound
## Installation
To use this node enable `omni.graph.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 |
| Prim (`inputs:prim`) | `target` | The sound Prim to play | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
| Sound Id (`outputs:soundId`) | `uint64` | The sound identifier | None |
## Metadata
| Name | Value |
|-------------|------------------------------|
| Unique ID | omni.graph.nodes.PlaySound |
| Version | 2 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.PlaySound.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Play Sound |
| Categories | sound |
| Generated Class Name | OgnPlaySoundDatabase |
| Python Module | omni.graph.nodes | | 1,338 |
OgnPositionToColor.md | # PositionToColor
[](#positiontocolor)
This node takes positional data (double3) and converts to a color, and outputs as color3f[] (which seems to be the default color connection in USD)
## Installation
[](#installation)
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
[](#inputs)
| Name | Type | Descripton | Default |
|---------------------|---------------|-------------------------------------|---------------|
| Color Offset (inputs:color_offset) | colorf[3] | Offset added to the scaled color to get the final result | [0.0, 0.0, 0.0] |
| Position (inputs:position) | double[3] | Position to be converted to a color | [0.0, 0.0, 0.0] |
| Scale (inputs:scale) | float | Constant by which to multiply the position to get the color | 1.0 |
## Outputs
[](#outputs)
| Name | Type | Descripton | Default |
|---------------------|---------------|-------------------------------------|---------------|
| Color (outputs:color) | colorf[3][] | Color value extracted from the position | |
# Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.PositionToColor |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | PositionToColor |
| Categories | examples |
| Generated Class Name | OgnPositionToColorDatabase |
| Python Module | omni.graph.examples.python | | 1,981 |
OgnPrimDeformer1.md | # Example Node: Sine Wave Prim Deformer
Example deformer node that applies a sine wave to a mesh, input via a Prim
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Metadata
| Name | Value |
|--------------|--------------------------------------------|
| Unique ID | omni.graph.examples.cpp.PrimDeformer1 |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Example Node: Sine Wave Prim Deformer |
| Categories | examples |
| Generated Class Name | OgnPrimDeformer1Database |
| Python Module | omni.graph.examples.cpp | | 981 |
OgnPrimDeformer2.md | # Example Node: Z Threshold Prim Deformer
Example deformer node that limits the Z point positions to a threshold, input via a Prim
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.PrimDeformer2 |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Example Node: Z Threshold Prim Deformer |
| Categories | examples |
| Generated Class Name | OgnPrimDeformer2Database |
| Python Module | omni.graph.examples.cpp | | 677 |
OgnPrintText.md | # Print Text
Prints some text to the system log or to the screen
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed. | None |
| Log Level (inputs:logLevel) | token | The logging level for the message [Info, Warning, Error] | Info |
| Metadata | | allowedTokens = Info,Warning,Error | |
| Text (inputs:text) | string | The text to print | |
| To Screen (inputs:toScreen) | bool | When true, displays the text on the viewport for a few seconds, as well as the log | False |
| Viewport (inputs:viewport) | token | Name of the viewport if printing to screen, or empty for the default viewport | |
## Outputs
## Metadata
### Table 1: Metadata Information
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.ui_nodes.PrintText |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| tags | logging,toast,debug |
| uiName | Print Text |
| Categories | debug |
| Generated Class Name | OgnPrintTextDatabase |
| Python Module | omni.graph.ui_nodes | | 1,673 |
OgnPyUniversalAdd.md | # Universal Add For All Types (Python)
Python-based universal add node for all types. This file is generated using UniversalAddGenerator.py
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bool 0 (`inputs:bool_0`) | `bool` | Input of type bool | False |
| Bool 1 (`inputs:bool_1`) | `bool` | Input of type bool | False |
| Bool Arr 0 (`inputs:bool_arr_0`) | `bool[]` | Input of type bool[] | [] |
| Bool Arr 1 (`inputs:bool_arr_1`) | `bool[]` | Input of type bool[] | [] |
| Colord3 0 (`inputs:colord3_0`) | `colord[3]` | Input of type colord[3] | [0.0, 0.0, 0.0] |
| Colord3 1 (`inputs:colord3_1`) | `colord[3]` | Input of type colord[3] | [0.0, 0.0, 0.0] |
| Colord3 Arr 0 (inputs:colord3_arr_0) | colord[3][] | Input of type colord[3][] | [] |
| --- | --- | --- | --- |
| Colord3 Arr 1 (inputs:colord3_arr_1) | colord[3][] | Input of type colord[3][] | [] |
| Colord4 0 (inputs:colord4_0) | colord[4] | Input of type colord[4] | [0.0, 0.0, 0.0, 0.0] |
| Colord4 1 (inputs:colord4_1) | colord[4] | Input of type colord[4] | [0.0, 0.0, 0.0, 0.0] |
| Colord4 Arr 0 (inputs:colord4_arr_0) | colord[4][] | Input of type colord[4][] | [] |
| Colord4 Arr 1 (inputs:colord4_arr_1) | colord[4][] | Input of type colord[4][] | [] |
| Colorf3 0 (inputs:colorf3_0) | colorf[3] | Input of type colorf[3] | [0.0, 0.0, 0.0] |
| Colorf3 1 (inputs:colorf3_1) | colorf[3] | Input of type colorf[3] | [0.0, 0.0, 0.0] |
| Colorf3 Arr 0 (inputs:colorf3_arr_0) | colorf[3][] | Input of type colorf[3][] | [] |
| Colorf3 Arr 1 (inputs:colorf3_arr_1) | colorf[3][] | Input of type colorf[3][] | [] |
| Colorf4 0 (inputs:colorf4_0) | colorf[4] | Input of type colorf[4] | [0.0, 0.0, 0.0, 0.0] |
| Colorf4 1 (inputs:colorf4_1) | colorf[4] | Input of type colorf[4] | [0.0, 0.0, 0.0, 0.0] |
| Colorf4 Arr 0 (inputs:colorf4_arr_0) | colorf[4][] | Input of type colorf[4][] | [] |
| Colorf4 Arr 1 (inputs:colorf4_arr_1) | colorf[4][] | Input of type colorf[4][] | [] |
| Colorh3 0 (inputs:colorh3_0) | `colorh[3]` | Input of type colorh[3] | [0.0, 0.0, 0.0] |
|------------------------------|-------------|-------------------------|------------------|
| Colorh3 1 (inputs:colorh3_1) | `colorh[3]` | Input of type colorh[3] | [0.0, 0.0, 0.0] |
| Colorh3 Arr 0 (inputs:colorh3_arr_0) | `colorh[3][]` | Input of type colorh[3][] | [] |
| Colorh3 Arr 1 (inputs:colorh3_arr_1) | `colorh[3][]` | Input of type colorh[3][] | [] |
| Colorh4 0 (inputs:colorh4_0) | `colorh[4]` | Input of type colorh[4] | [0.0, 0.0, 0.0, 0.0] |
| Colorh4 1 (inputs:colorh4_1) | `colorh[4]` | Input of type colorh[4] | [0.0, 0.0, 0.0, 0.0] |
| Colorh4 Arr 0 (inputs:colorh4_arr_0) | `colorh[4][]` | Input of type colorh[4][] | [] |
| Colorh4 Arr 1 (inputs:colorh4_arr_1) | `colorh[4][]` | Input of type colorh[4][] | [] |
| Double2 0 (inputs:double2_0) | `double[2]` | Input of type double[2] | [0.0, 0.0] |
| Double2 1 (inputs:double2_1) | `double[2]` | Input of type double[2] | [0.0, 0.0] |
| Double2 Arr 0 (inputs:double2_arr_0) | `double[2][]` | Input of type double[2][] | [] |
| Double2 Arr 1 (inputs:double2_arr_1) | `double[2][]` | Input of type double[2][] | [] |
| Double3 0 (inputs:double3_0) | `double[3]` | Input of type double[3] | [0.0, 0.0, 0.0] |
| Double3 1 (inputs:double3_1) | `double[3]` | Input of type double[3] | [0.0, 0.0, 0.0] |
| Double3 Arr 0 (inputs:double3_arr_0) | double[3][] | Input of type double[3][] | [] |
|-------------------------------------|-------------|---------------------------|----|
| Double3 Arr 1 (inputs:double3_arr_1) | double[3][] | Input of type double[3][] | [] |
| Double4 0 (inputs:double4_0) | double[4] | Input of type double[4] | [0.0, 0.0, 0.0, 0.0] |
| Double4 1 (inputs:double4_1) | double[4] | Input of type double[4] | [0.0, 0.0, 0.0, 0.0] |
| Double4 Arr 0 (inputs:double4_arr_0)| double[4][] | Input of type double[4][] | [] |
| Double4 Arr 1 (inputs:double4_arr_1)| double[4][] | Input of type double[4][] | [] |
| Double 0 (inputs:double_0) | double | Input of type double | 0.0 |
| Double 1 (inputs:double_1) | double | Input of type double | 0.0 |
| Double Arr 0 (inputs:double_arr_0) | double[] | Input of type double[] | [] |
| Double Arr 1 (inputs:double_arr_1) | double[] | Input of type double[] | [] |
| Float2 0 (inputs:float2_0) | float[2] | Input of type float[2] | [0.0, 0.0] |
| Float2 1 (inputs:float2_1) | float[2] | Input of type float[2] | [0.0, 0.0] |
| Float2 Arr 0 (inputs:float2_arr_0) | float[2][] | Input of type float[2][] | [] |
| Float2 Arr 1 (inputs:float2_arr_1) | float[2][] | Input of type float[2][] | [] |
| Float3 0 (inputs:float3_0) | float[3][] | Input of type float[3][] | [] |
| 描述 | 类型 | 说明 | 默认值 |
| --- | --- | --- | --- |
| Float3 0 (inputs:float3_0) | float[3] | Input of type float[3] | [0.0, 0.0, 0.0] |
| Float3 1 (inputs:float3_1) | float[3] | Input of type float[3] | [0.0, 0.0, 0.0] |
| Float3 Arr 0 (inputs:float3_arr_0) | float[3][] | Input of type float[3][] | [] |
| Float3 Arr 1 (inputs:float3_arr_1) | float[3][] | Input of type float[3][] | [] |
| Float4 0 (inputs:float4_0) | float[4] | Input of type float[4] | [0.0, 0.0, 0.0, 0.0] |
| Float4 1 (inputs:float4_1) | float[4] | Input of type float[4] | [0.0, 0.0, 0.0, 0.0] |
| Float4 Arr 0 (inputs:float4_arr_0) | float[4][] | Input of type float[4][] | [] |
| Float4 Arr 1 (inputs:float4_arr_1) | float[4][] | Input of type float[4][] | [] |
| Float 0 (inputs:float_0) | float | Input of type float | 0.0 |
| Float 1 (inputs:float_1) | float | Input of type float | 0.0 |
| Float Arr 0 (inputs:float_arr_0) | float[] | Input of type float[] | [] |
| Float Arr 1 (inputs:float_arr_1) | float[] | Input of type float[] | [] |
| Frame4 0 (inputs:frame4_0) | frame[4] | Input of type frame[4] | [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]] |
| Frame4 1 (inputs:frame4_1) | frame[4] | Input of type frame[4] | [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]] |
| Frame4 Arr 0 (inputs:frame4_arr_0) | frame[4][] | Input of type frame[4][] | [] |
| Frame4 Arr 1 (inputs:frame4_arr_1) | `frame[4][]` | Input of type frame[4][] | [] |
| --- | --- | --- | --- |
| Frame4 Arr 1 (inputs:frame4_arr_1) | `frame[4][]` | Input of type frame[4][] | [] |
| Half2 0 (inputs:half2_0) | `half[2]` | Input of type half[2] | [0.0, 0.0] |
| Half2 1 (inputs:half2_1) | `half[2]` | Input of type half[2] | [0.0, 0.0] |
| Half2 Arr 0 (inputs:half2_arr_0) | `half[2][]` | Input of type half[2][] | [] |
| Half2 Arr 1 (inputs:half2_arr_1) | `half[2][]` | Input of type half[2][] | [] |
| Half3 0 (inputs:half3_0) | `half[3]` | Input of type half[3] | [0.0, 0.0, 0.0] |
| Half3 1 (inputs:half3_1) | `half[3]` | Input of type half[3] | [0.0, 0.0, 0.0] |
| Half3 Arr 0 (inputs:half3_arr_0) | `half[3][]` | Input of type half[3][] | [] |
| Half3 Arr 1 (inputs:half3_arr_1) | `half[3][]` | Input of type half[3][] | [] |
| Half4 0 (inputs:half4_0) | `half[4]` | Input of type half[4] | [0.0, 0.0, 0.0, 0.0] |
| Half4 1 (inputs:half4_1) | `half[4]` | Input of type half[4] | [0.0, 0.0, 0.0, 0.0] |
| Half4 Arr 0 (inputs:half4_arr_0) | `half[4][]` | Input of type half[4][] | [] |
| Half4 Arr 1 (inputs:half4_arr_1) | `half[4][]` | Input of type half[4][] | [] |
| Half 0 (inputs:half_0) | `half` | Input of type half | 0.0 |
| | | | |
|---|---|---|---|
| Half 1 (inputs:half_1) | `half` | Input of type half | 0.0 |
| Half Arr 0 (inputs:half_arr_0) | `half[]` | Input of type half[] | [] |
| Half Arr 1 (inputs:half_arr_1) | `half[]` | Input of type half[] | [] |
| Int2 0 (inputs:int2_0) | `int[2]` | Input of type int[2] | [0, 0] |
| Int2 1 (inputs:int2_1) | `int[2]` | Input of type int[2] | [0, 0] |
| Int2 Arr 0 (inputs:int2_arr_0) | `int[2][]` | Input of type int[2][] | [] |
| Int2 Arr 1 (inputs:int2_arr_1) | `int[2][]` | Input of type int[2][] | [] |
| Int3 0 (inputs:int3_0) | `int[3]` | Input of type int[3] | [0, 0, 0] |
| Int3 1 (inputs:int3_1) | `int[3]` | Input of type int[3] | [0, 0, 0] |
| Int3 Arr 0 (inputs:int3_arr_0) | `int[3][]` | Input of type int[3][] | [] |
| Int3 Arr 1 (inputs:int3_arr_1) | `int[3][]` | Input of type int[3][] | [] |
| Int4 0 (inputs:int4_0) | `int[4]` | Input of type int[4] | [0, 0, 0, 0] |
| Int4 1 (inputs:int4_1) | `int[4]` | Input of type int[4] | [0, 0, 0, 0] |
| Int4 Arr 0 (inputs:int4_arr_0) | `int[4][]` | Input of type int[4][] | [] |
| Int4 Arr 1 (inputs:int4_arr_1) | `int[4][]` | Input of type int[4][] | [] |
| Int64 0 (inputs:int64_0) | `int64` | Input of type int64 | 0 |
| --- | --- | --- | --- |
| Int64 1 (inputs:int64_1) | `int64` | Input of type int64 | 0 |
| Int64 Arr 0 (inputs:int64_arr_0) | `int64[]` | Input of type int64[] | [] |
| Int64 Arr 1 (inputs:int64_arr_1) | `int64[]` | Input of type int64[] | [] |
| Int 0 (inputs:int_0) | `int` | Input of type int | 0 |
| Int 1 (inputs:int_1) | `int` | Input of type int | 0 |
| Int Arr 0 (inputs:int_arr_0) | `int[]` | Input of type int[] | [] |
| Int Arr 1 (inputs:int_arr_1) | `int[]` | Input of type int[] | [] |
| Matrixd2 0 (inputs:matrixd2_0) | `matrixd[2]` | Input of type matrixd[2] | [[0.0, 0.0], [0.0, 0.0]] |
| Matrixd2 1 (inputs:matrixd2_1) | `matrixd[2]` | Input of type matrixd[2] | [[0.0, 0.0], [0.0, 0.0]] |
| Matrixd2 Arr 0 (inputs:matrixd2_arr_0) | `matrixd[2][]` | Input of type matrixd[2][] | [] |
| Matrixd2 Arr 1 (inputs:matrixd2_arr_1) | `matrixd[2][]` | Input of type matrixd[2][] | [] |
| Matrixd3 0 (inputs:matrixd3_0) | `matrixd[3]` | Input of type matrixd[3] | [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] |
| Matrixd3 1 (inputs:matrixd3_1) | `matrixd[3]` | Input of type matrixd[3] | [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] |
| Matrixd3 Arr 0 (inputs:matrixd3_arr_0) | matrixd[3][] | Input of type matrixd[3][] | [] |
|--------------------------------------|--------------|----------------------------|----|
| Matrixd3 Arr 1 (inputs:matrixd3_arr_1) | matrixd[3][] | Input of type matrixd[3][] | [] |
| Matrixd4 0 (inputs:matrixd4_0) | matrixd[4] | Input of type matrixd[4] | [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]] |
| Matrixd4 1 (inputs:matrixd4_1) | matrixd[4] | Input of type matrixd[4] | [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]] |
| Matrixd4 Arr 0 (inputs:matrixd4_arr_0) | matrixd[4][] | Input of type matrixd[4][] | [] |
| Matrixd4 Arr 1 (inputs:matrixd4_arr_1) | matrixd[4][] | Input of type matrixd[4][] | [] |
| Normald3 0 (inputs:normald3_0) | normald[3] | Input of type normald[3] | [0.0, 0.0, 0.0] |
| Normald3 1 (inputs:normald3_1) | normald[3] | Input of type normald[3] | [0.0, 0.0, 0.0] |
| Normald3 Arr 0 (inputs:normald3_arr_0) | normald[3][] | Input of type normald[3][] | [] |
| Normald3 Arr 1 (inputs:normald3_arr_1) | normald[3][] | Input of type normald[3][] | [] |
| Normalf3 0 (inputs:normalf3_0) | normalf[3] | Input of type normalf[3] | [0.0, 0.0, 0.0] |
| Normalf3 1 (inputs:normalf3_1) | normalf[3] | Input of type normalf[3] | [0.0, 0.0, 0.0] |
| Normalf3 Arr 0 (inputs:normalf3_arr_0) | normalf[3][] | Input of type normalf[3][] | [] |
| Normalf3 Arr 1 (inputs:normalf3_arr_1) | normalf[3][] | Input of type normalf[3][] | [] |
| Normalh3 0 (inputs:normalh3_0) | `normalh[3]` | Input of type normalh[3] | [0.0, 0.0, 0.0] |
|--------------------------------|--------------|--------------------------|------------------|
| Normalh3 1 (inputs:normalh3_1) | `normalh[3]` | Input of type normalh[3] | [0.0, 0.0, 0.0] |
| Normalh3 Arr 0 (inputs:normalh3_arr_0) | `normalh[3][]` | Input of type normalh[3][] | [] |
| Normalh3 Arr 1 (inputs:normalh3_arr_1) | `normalh[3][]` | Input of type normalh[3][] | [] |
| Pointd3 0 (inputs:pointd3_0) | `pointd[3]` | Input of type pointd[3] | [0.0, 0.0, 0.0] |
| Pointd3 1 (inputs:pointd3_1) | `pointd[3]` | Input of type pointd[3] | [0.0, 0.0, 0.0] |
| Pointd3 Arr 0 (inputs:pointd3_arr_0) | `pointd[3][]` | Input of type pointd[3][] | [] |
| Pointd3 Arr 1 (inputs:pointd3_arr_1) | `pointd[3][]` | Input of type pointd[3][] | [] |
| Pointf3 0 (inputs:pointf3_0) | `pointf[3]` | Input of type pointf[3] | [0.0, 0.0, 0.0] |
| Pointf3 1 (inputs:pointf3_1) | `pointf[3]` | Input of type pointf[3] | [0.0, 0.0, 0.0] |
| Pointf3 Arr 0 (inputs:pointf3_arr_0) | `pointf[3][]` | Input of type pointf[3][] | [] |
| Pointf3 Arr 1 (inputs:pointf3_arr_1) | `pointf[3][]` | Input of type pointf[3][] | [] |
| Pointh3 0 (inputs:pointh3_0) | `pointh[3]` | Input of type pointh[3] | [0.0, 0.0, 0.0] |
| Pointh3 1 (inputs:pointh3_1) | `pointh[3]` | Input of type pointh[3] | [0.0, 0.0, 0.0] |
| Pointh3 Arr 0 (inputs:pointh3_arr_0) | `pointh[3][]` | Input of type pointh[3][] | [] |
<em>
inputs:pointh3_arr_0
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
pointh[3][]
<td>
<p>
Input of type pointh[3][]
<td>
<p>
[]
<tr class="row-odd">
<td>
<p>
Pointh3 Arr 1 (
<em>
inputs:pointh3_arr_1
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
pointh[3][]
<td>
<p>
Input of type pointh[3][]
<td>
<p>
[]
<tr class="row-even">
<td>
<p>
Quatd4 0 (
<em>
inputs:quatd4_0
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quatd[4]
<td>
<p>
Input of type quatd[4]
<td>
<p>
[0.0, 0.0, 0.0, 0.0]
<tr class="row-odd">
<td>
<p>
Quatd4 1 (
<em>
inputs:quatd4_1
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quatd[4]
<td>
<p>
Input of type quatd[4]
<td>
<p>
[0.0, 0.0, 0.0, 0.0]
<tr class="row-even">
<td>
<p>
Quatd4 Arr 0 (
<em>
inputs:quatd4_arr_0
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quatd[4][]
<td>
<p>
Input of type quatd[4][]
<td>
<p>
[]
<tr class="row-odd">
<td>
<p>
Quatd4 Arr 1 (
<em>
inputs:quatd4_arr_1
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quatd[4][]
<td>
<p>
Input of type quatd[4][]
<td>
<p>
[]
<tr class="row-even">
<td>
<p>
Quatf4 0 (
<em>
inputs:quatf4_0
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quatf[4]
<td>
<p>
Input of type quatf[4]
<td>
<p>
[0.0, 0.0, 0.0, 0.0]
<tr class="row-odd">
<td>
<p>
Quatf4 1 (
<em>
inputs:quatf4_1
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quatf[4]
<td>
<p>
Input of type quatf[4]
<td>
<p>
[0.0, 0.0, 0.0, 0.0]
<tr class="row-even">
<td>
<p>
Quatf4 Arr 0 (
<em>
inputs:quatf4_arr_0
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quatf[4][]
<td>
<p>
Input of type quatf[4][]
<td>
<p>
[]
<tr class="row-odd">
<td>
<p>
Quatf4 Arr 1 (
<em>
inputs:quatf4_arr_1
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quatf[4][]
<td>
<p>
Input of type quatf[4][]
<td>
<p>
[]
<tr class="row-even">
<td>
<p>
Quath4 0 (
<em>
inputs:quath4_0
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quath[4]
<td>
<p>
Input of type quath[4]
<td>
<p>
[0.0, 0.0, 0.0, 0.0]
<tr class="row-odd">
<td>
<p>
Quath4 1 (
<em>
inputs:quath4_1
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quath[4]
<td>
<p>
Input of type quath[4]
<td>
<p>
[0.0, 0.0, 0.0, 0.0]
<tr class="row-even">
<td>
<p>
Quath4 Arr 0 (
<em>
inputs:quath4_arr_0
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quath[4][]
<td>
<p>
Input of type quath[4][]
<td>
<p>
[]
<tr class="row-odd">
<td>
<p>
Quath4 Arr 1 (
<em>
inputs:quath4_arr_1
)
<td>
<p>
<code class="docutils literal notranslate">
<span class="pre">
quath[4][]
<td>
<p>
Input of type quath[4][]
<td>
<p>
[]
<tr class="row-even">
<td>
<p>
Texcoordd2 0 (
<em>
inputs:texcoordd2_0
)
<td>
<p>
<code class="docutils literal notranslate">
Texcoordd2 0 (inputs:texcoordd2_0)
```
```
texcoordd[2]
```
Input of type texcoordd[2]
[0.0, 0.0]
---
Texcoordd2 1 (inputs:texcoordd2_1)
```
texcoordd[2]
```
Input of type texcoordd[2]
[0.0, 0.0]
---
Texcoordd2 Arr 0 (inputs:texcoordd2_arr_0)
```
texcoordd[2][]
```
Input of type texcoordd[2][]
[]
---
Texcoordd2 Arr 1 (inputs:texcoordd2_arr_1)
```
texcoordd[2][]
```
Input of type texcoordd[2][]
[]
---
Texcoordd3 0 (inputs:texcoordd3_0)
```
texcoordd[3]
```
Input of type texcoordd[3]
[0.0, 0.0, 0.0]
---
Texcoordd3 1 (inputs:texcoordd3_1)
```
texcoordd[3]
```
Input of type texcoordd[3]
[0.0, 0.0, 0.0]
---
Texcoordd3 Arr 0 (inputs:texcoordd3_arr_0)
```
texcoordd[3][]
```
Input of type texcoordd[3][]
[]
---
Texcoordd3 Arr 1 (inputs:texcoordd3_arr_1)
```
texcoordd[3][]
```
Input of type texcoordd[3][]
[]
---
Texcoordf2 0 (inputs:texcoordf2_0)
```
texcoordf[2]
```
Input of type texcoordf[2]
[0.0, 0.0]
---
Texcoordf2 1 (inputs:texcoordf2_1)
```
texcoordf[2]
```
Input of type texcoordf[2]
[0.0, 0.0]
---
Texcoordf2 Arr 0 (inputs:texcoordf2_arr_0)
```
texcoordf[2][]
```
Input of type texcoordf[2][]
[]
---
Texcoordf2 Arr 1 (inputs:texcoordf2_arr_1)
```
texcoordf[2][]
```
Input of type texcoordf[2][]
[]
---
Texcoordf3 0 (inputs:texcoordf3_0)
```
texcoordf[3]
```
Input of type texcoordf[3]
[0.0, 0.0, 0.0]
---
Texcoordf3 1 (inputs:texcoordf3_1)
```
texcoordf[3]
```
Input of type texcoordf[3]
[0.0, 0.0, 0.0]
---
Texcoordf3 Arr 0 (inputs:texcoordf3_arr_0)
```
texcoordf[3][]
```
Input of type texcoordf[3][]
[]
| Texcoordf3 Arr 1 (inputs:texcoordf3_arr_1) | texcoordf[3][] | Input of type texcoordf[3][] | [] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordf3 Arr 1 (inputs:texcoordf3_arr_1) | texcoordf[3][] | Input of type texcoordf[3][] | [] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordh2 0 (inputs:texcoordh2_0) | texcoordh[2] | Input of type texcoordh[2] | [0.0, 0.0] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordh2 1 (inputs:texcoordh2_1) | texcoordh[2] | Input of type texcoordh[2] | [0.0, 0.0] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordh2 Arr 0 (inputs:texcoordh2_arr_0) | texcoordh[2][] | Input of type texcoordh[2][] | [] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordh2 Arr 1 (inputs:texcoordh2_arr_1) | texcoordh[2][] | Input of type texcoordh[2][] | [] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordh3 0 (inputs:texcoordh3_0) | texcoordh[3] | Input of type texcoordh[3] | [0.0, 0.0, 0.0] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordh3 1 (inputs:texcoordh3_1) | texcoordh[3] | Input of type texcoordh[3] | [0.0, 0.0, 0.0] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordh3 Arr 0 (inputs:texcoordh3_arr_0) | texcoordh[3][] | Input of type texcoordh[3][] | [] |
|------------------------------------------|----------------|-------------------------------|----|
| Texcoordh3 Arr 1 (inputs:texcoordh3_arr_1) | texcoordh[3][] | Input of type texcoordh[3][] | [] |
|------------------------------------------|----------------|-------------------------------|----|
| Timecode 0 (inputs:timecode_0) | timecode | Input of type timecode | 0.0 |
|------------------------------------------|----------------|-------------------------------|----|
| Timecode 1 (inputs:timecode_1) | timecode | Input of type timecode | 0.0 |
|------------------------------------------|----------------|-------------------------------|----|
| Timecode Arr 0 (inputs:timecode_arr_0) | timecode[] | Input of type timecode[] | [] |
|------------------------------------------|----------------|-------------------------------|----|
| Timecode Arr 1 (inputs:timecode_arr_1) | timecode[] | Input of type timecode[] | [] |
|------------------------------------------|----------------|-------------------------------|----|
| Token 0 (inputs:token_0) | token | Input of type token | |
|------------------------------------------|----------------|-------------------------------|----|
| Input of type token | default_token |
|---------------------|---------------|
| Token 1 (inputs:token_1) | `token` |
| Input of type token | default_token |
| Token Arr 0 (inputs:token_arr_0) | `token[]` |
| Input of type token[] | [] |
| Token Arr 1 (inputs:token_arr_1) | `token[]` |
| Input of type token[] | [] |
| Uchar 0 (inputs:uchar_0) | `uchar` |
| Input of type uchar | 0 |
| Uchar 1 (inputs:uchar_1) | `uchar` |
| Input of type uchar | 0 |
| Uchar Arr 0 (inputs:uchar_arr_0) | `uchar[]` |
| Input of type uchar[] | [] |
| Uchar Arr 1 (inputs:uchar_arr_1) | `uchar[]` |
| Input of type uchar[] | [] |
| Uint64 0 (inputs:uint64_0) | `uint64` |
| Input of type uint64 | 0 |
| Uint64 1 (inputs:uint64_1) | `uint64` |
| Input of type uint64 | 0 |
| Uint64 Arr 0 (inputs:uint64_arr_0) | `uint64[]` |
| Input of type uint64[] | [] |
| Uint64 Arr 1 (inputs:uint64_arr_1) | `uint64[]` |
| Input of type uint64[] | [] |
| Uint 0 (inputs:uint_0) | `uint` |
| Input of type uint | 0 |
| Uint 1 (inputs:uint_1) | `uint` |
| Input of type uint | 0 |
| Uint Arr 0 (inputs:uint_arr_0) | `uint[]` |
| Input of type uint[] | [] |
| Uint Arr 1 (inputs:uint_arr_1) | `uint[]` |
| Input of type uint[] | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Vectord3 0 (inputs:vectord3_0) | vectord[3] | Input of type vectord[3] | [0.0, 0.0, 0.0] |
| Vectord3 1 (inputs:vectord3_1) | vectord[3] | Input of type vectord[3] | [0.0, 0.0, 0.0] |
| Vectord3 Arr 0 (inputs:vectord3_arr_0) | vectord[3][] | Input of type vectord[3][] | [] |
| Vectord3 Arr 1 (inputs:vectord3_arr_1) | vectord[3][] | Input of type vectord[3][] | [] |
| Vectorf3 0 (inputs:vectorf3_0) | vectorf[3] | Input of type vectorf[3] | [0.0, 0.0, 0.0] |
| Vectorf3 1 (inputs:vectorf3_1) | vectorf[3] | Input of type vectorf[3] | [0.0, 0.0, 0.0] |
| Vectorf3 Arr 0 (inputs:vectorf3_arr_0) | vectorf[3][] | Input of type vectorf[3][] | [] |
| Vectorf3 Arr 1 (inputs:vectorf3_arr_1) | vectorf[3][] | Input of type vectorf[3][] | [] |
| Vectorh3 0 (inputs:vectorh3_0) | vectorh[3] | Input of type vectorh[3] | [0.0, 0.0, 0.0] |
| Vectorh3 1 (inputs:vectorh3_1) | vectorh[3] | Input of type vectorh[3] | [0.0, 0.0, 0.0] |
| Vectorh3 Arr 0 (inputs:vectorh3_arr_0) | vectorh[3][] | Input of type vectorh[3][] | [] |
| Vectorh3 Arr 1 (inputs:vectorh3_arr_1) | vectorh[3][] | Input of type vectorh[3][] | [] |
| Bool 0 (outputs:bool_0) | bool | Output of type bool | False |
|-------------------------|------|---------------------|-------|
| Bool Arr 0 (outputs:bool_arr_0) | bool[] | Output of type bool[] | [] |
| Colord3 0 (outputs:colord3_0) | colord[3] | Output of type colord[3] | [0.0, 0.0, 0.0] |
| Colord3 Arr 0 (outputs:colord3_arr_0) | colord[3][] | Output of type colord[3][] | [] |
| Colord4 0 (outputs:colord4_0) | colord[4] | Output of type colord[4] | [0.0, 0.0, 0.0, 0.0] |
| Colord4 Arr 0 (outputs:colord4_arr_0) | colord[4][] | Output of type colord[4][] | [] |
| Colorf3 0 (outputs:colorf3_0) | colorf[3] | Output of type colorf[3] | [0.0, 0.0, 0.0] |
| Colorf3 Arr 0 (outputs:colorf3_arr_0) | colorf[3][] | Output of type colorf[3][] | [] |
| Colorf4 0 (outputs:colorf4_0) | colorf[4] | Output of type colorf[4] | [0.0, 0.0, 0.0, 0.0] |
| Colorf4 Arr 0 (outputs:colorf4_arr_0) | colorf[4][] | Output of type colorf[4][] | [] |
| Colorh3 0 (outputs:colorh3_0) | colorh[3] | Output of type colorh[3] | [0.0, 0.0, 0.0] |
| Colorh3 Arr 0 (outputs:colorh3_arr_0) | colorh[3][] | Output of type colorh[3][] | [] |
| Colorh4 0 (outputs:colorh4_0) | colorh[4] | Output of type colorh[4] | [0.0, 0.0, 0.0, 0.0] |
| Colorh4 Arr 0 (outputs:colorh4_arr_0) | colorh[4][] | Output of type colorh[4][] | [] |
| Double2 0 (outputs:double2_0) | double[2] | Output of type double[2] | [0.0, 0.0] |
| | | | |
| --- | --- | --- | --- |
| Double2 0 (outputs:double2_0) | `double[2]` | Output of type double[2] | [0.0, 0.0] |
| Double2 Arr 0 (outputs:double2_arr_0) | `double[2][]` | Output of type double[2][] | [] |
| Double3 0 (outputs:double3_0) | `double[3]` | Output of type double[3] | [0.0, 0.0, 0.0] |
| Double3 Arr 0 (outputs:double3_arr_0) | `double[3][]` | Output of type double[3][] | [] |
| Double4 0 (outputs:double4_0) | `double[4]` | Output of type double[4] | [0.0, 0.0, 0.0, 0.0] |
| Double4 Arr 0 (outputs:double4_arr_0) | `double[4][]` | Output of type double[4][] | [] |
| Double 0 (outputs:double_0) | `double` | Output of type double | 0.0 |
| Double Arr 0 (outputs:double_arr_0) | `double[]` | Output of type double[] | [] |
| Float2 0 (outputs:float2_0) | `float[2]` | Output of type float[2] | [0.0, 0.0] |
| Float2 Arr 0 (outputs:float2_arr_0) | `float[2][]` | Output of type float[2][] | [] |
| Float3 0 (outputs:float3_0) | `float[3]` | Output of type float[3] | [0.0, 0.0, 0.0] |
| Float3 Arr 0 (outputs:float3_arr_0) | `float[3][]` | Output of type float[3][] | [] |
| Float4 0 (outputs:float4_0) | `float[4]` | Output of type float[4] | [0.0, 0.0, 0.0, 0.0] |
| Float4 Arr 0 (outputs:float4_arr_0) | `float[4][]` | Output of type float[4][] | [] |
| Float 0 (outputs:float_0) | `float` | Output of type float | 0.0 |
| | | | |
|-------|-------|-------|-------|
| Float 0 (outputs:float_0) | `float` | Output of type float | 0.0 |
| Float Arr 0 (outputs:float_arr_0) | `float[]` | Output of type float[] | [] |
| Frame4 0 (outputs:frame4_0) | `frame[4]` | Output of type frame[4] | [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]] |
| Frame4 Arr 0 (outputs:frame4_arr_0) | `frame[4][]` | Output of type frame[4][] | [] |
| Half2 0 (outputs:half2_0) | `half[2]` | Output of type half[2] | [0.0, 0.0] |
| Half2 Arr 0 (outputs:half2_arr_0) | `half[2][]` | Output of type half[2][] | [] |
| Half3 0 (outputs:half3_0) | `half[3]` | Output of type half[3] | [0.0, 0.0, 0.0] |
| Half3 Arr 0 (outputs:half3_arr_0) | `half[3][]` | Output of type half[3][] | [] |
| Half4 0 (outputs:half4_0) | `half[4]` | Output of type half[4] | [0.0, 0.0, 0.0, 0.0] |
| Half4 Arr 0 (outputs:half4_arr_0) | `half[4][]` | Output of type half[4][] | [] |
| Half 0 (outputs:half_0) | `half` | Output of type half | 0.0 |
| Half Arr 0 (outputs:half_arr_0) | `half[]` | Output of type half[] | [] |
| Int2 0 (outputs:int2_0) | `int[2]` | Output of type int[2] | [0, 0] |
| Int2 Arr 0 (outputs:int2_arr_0) | `int[2][]` | Output of type int[2][] | [] |
| Int3 0 (outputs:int3_0) | `int[3]` | Output of type int[3] | [0, 0, 0] |
[0, 0, 0]
Int3 Arr 0 (
**outputs:int3_arr_0**
)
```int[3][]```
Output of type int[3][]
[]
Int4 0 (
**outputs:int4_0**
)
```int[4]```
Output of type int[4]
[0, 0, 0, 0]
Int4 Arr 0 (
**outputs:int4_arr_0**
)
```int[4][]```
Output of type int[4][]
[]
Int64 0 (
**outputs:int64_0**
)
```int64```
Output of type int64
0
Int64 Arr 0 (
**outputs:int64_arr_0**
)
```int64[]```
Output of type int64[]
[]
Int 0 (
**outputs:int_0**
)
```int```
Output of type int
0
Int Arr 0 (
**outputs:int_arr_0**
)
```int[]```
Output of type int[]
[]
Matrixd2 0 (
**outputs:matrixd2_0**
)
```matrixd[2]```
Output of type matrixd[2]
[[0.0, 0.0], [0.0, 0.0]]
Matrixd2 Arr 0 (
**outputs:matrixd2_arr_0**
)
```matrixd[2][]```
Output of type matrixd[2][]
[]
Matrixd3 0 (
**outputs:matrixd3_0**
)
```matrixd[3]```
Output of type matrixd[3]
[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
Matrixd3 Arr 0 (
**outputs:matrixd3_arr_0**
)
```matrixd[3][]```
Output of type matrixd[3][]
[]
Matrixd4 0 (
**outputs:matrixd4_0**
)
```matrixd[4]```
Output of type matrixd[4]
[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
Matrixd4 Arr 0 (
**outputs:matrixd4_arr_0**
)
```matrixd[4][]```
Output of type matrixd[4][]
[]
Normald3 0 (
**outputs:normald3_0**
)
```normald[3]```
Output of type normald[3]
[0.0, 0.0, 0.0]
| Normald3 Arr 0 (outputs:normald3_arr_0) | `normald[3][]` | Output of type normald[3][] | [] |
| --- | --- | --- | --- |
| Normalf3 0 (outputs:normalf3_0) | `normalf[3]` | Output of type normalf[3] | [0.0, 0.0, 0.0] |
| Normalf3 Arr 0 (outputs:normalf3_arr_0) | `normalf[3][]` | Output of type normalf[3][] | [] |
| Normalh3 0 (outputs:normalh3_0) | `normalh[3]` | Output of type normalh[3] | [0.0, 0.0, 0.0] |
| Normalh3 Arr 0 (outputs:normalh3_arr_0) | `normalh[3][]` | Output of type normalh[3][] | [] |
| Pointd3 0 (outputs:pointd3_0) | `pointd[3]` | Output of type pointd[3] | [0.0, 0.0, 0.0] |
| Pointd3 Arr 0 (outputs:pointd3_arr_0) | `pointd[3][]` | Output of type pointd[3][] | [] |
| Pointf3 0 (outputs:pointf3_0) | `pointf[3]` | Output of type pointf[3] | [0.0, 0.0, 0.0] |
| Pointf3 Arr 0 (outputs:pointf3_arr_0) | `pointf[3][]` | Output of type pointf[3][] | [] |
| Pointh3 0 (outputs:pointh3_0) | `pointh[3]` | Output of type pointh[3] | [0.0, 0.0, 0.0] |
| Pointh3 Arr 0 (outputs:pointh3_arr_0) | `pointh[3][]` | Output of type pointh[3][] | [] |
| Quatd4 0 (outputs:quatd4_0) | `quatd[4]` | Output of type quatd[4] | [0.0, 0.0, 0.0, 0.0] |
| Quatd4 Arr 0 (outputs:quatd4_arr_0) | `quatd[4][]` | Output of type quatd[4][] | [] |
| Quatf4 0 (outputs:quatf4_0) | `quatf[4]` | Output of type quatf[4] | [0.0, 0.0, 0.0, 0.0] |
| Quatf4 Arr 0 (outputs:quatf4_arr_0) | `quatf[4][]` | Output of type quatf[4][] | [] |
| Quatf4 0 (outputs:quatf4_0) | quatf[4] | Output of type quatf[4] | [0.0, 0.0, 0.0, 0.0] |
| --- | --- | --- | --- |
| Quatf4 Arr 0 (outputs:quatf4_arr_0) | quatf[4][] | Output of type quatf[4][] | [] |
| Quath4 0 (outputs:quath4_0) | quath[4] | Output of type quath[4] | [0.0, 0.0, 0.0, 0.0] |
| Quath4 Arr 0 (outputs:quath4_arr_0) | quath[4][] | Output of type quath[4][] | [] |
| Texcoordd2 0 (outputs:texcoordd2_0) | texcoordd[2] | Output of type texcoordd[2] | [0.0, 0.0] |
| Texcoordd2 Arr 0 (outputs:texcoordd2_arr_0) | texcoordd[2][] | Output of type texcoordd[2][] | [] |
| Texcoordd3 0 (outputs:texcoordd3_0) | texcoordd[3] | Output of type texcoordd[3] | [0.0, 0.0, 0.0] |
| Texcoordd3 Arr 0 (outputs:texcoordd3_arr_0) | texcoordd[3][] | Output of type texcoordd[3][] | [] |
| Texcoordf2 0 (outputs:texcoordf2_0) | texcoordf[2] | Output of type texcoordf[2] | [0.0, 0.0] |
| Texcoordf2 Arr 0 (outputs:texcoordf2_arr_0) | texcoordf[2][] | Output of type texcoordf[2][] | [] |
| Texcoordf3 0 (outputs:texcoordf3_0) | texcoordf[3] | Output of type texcoordf[3] | [0.0, 0.0, 0.0] |
| Texcoordf3 Arr 0 (outputs:texcoordf3_arr_0) | texcoordf[3][] | Output of type texcoordf[3][] | [] |
| Texcoordh2 0 (outputs:texcoordh2_0) | texcoordh[2] | Output of type texcoordh[2] | [0.0, 0.0] |
| Texcoordh2 Arr 0 (outputs:texcoordh2_arr_0) | texcoordh[2][] | Output of type texcoordh[2][] | [] |
| Texcoordh3 0 (outputs:texcoordh3_0) | texcoordh[3] | Output of type texcoordh[3] | [0.0, 0.0, 0.0] |
| Texcoordh3 Arr 0 (outputs:texcoordh3_arr_0) | texcoordh[3][] | Output of type texcoordh[3][] | [] |
| Column 1 | Column 2 | Column 3 | Column 4 |
|----------|----------|----------|----------|
| Output of type texcoordh[3][] | texcoordh[3][] | Output of type texcoordh[3][] | [] |
| Timecode 0 (outputs:timecode_0) | timecode | Output of type timecode | 0.0 |
| Timecode Arr 0 (outputs:timecode_arr_0) | timecode[] | Output of type timecode[] | [] |
| Token 0 (outputs:token_0) | token | Output of type token | default_token |
| Token Arr 0 (outputs:token_arr_0) | token[] | Output of type token[] | [] |
| Uchar 0 (outputs:uchar_0) | uchar | Output of type uchar | 0 |
| Uchar Arr 0 (outputs:uchar_arr_0) | uchar[] | Output of type uchar[] | [] |
| Uint64 0 (outputs:uint64_0) | uint64 | Output of type uint64 | 0 |
| Uint64 Arr 0 (outputs:uint64_arr_0) | uint64[] | Output of type uint64[] | [] |
| Uint 0 (outputs:uint_0) | uint | Output of type uint | 0 |
| Uint Arr 0 (outputs:uint_arr_0) | uint[] | Output of type uint[] | [] |
| Vectord3 0 (outputs:vectord3_0) | vectord[3] | Output of type vectord[3] | [0.0, 0.0, 0.0] |
| Vectord3 Arr 0 (outputs:vectord3_arr_0) | vectord[3][] | Output of type vectord[3][] | [] |
| Vectorf3 0 (outputs:vectorf3_0) | vectorf[3] | Output of type vectorf[3] | [0.0, 0.0, 0.0] |
| Vectorf3 Arr 0 (outputs:vectorf3_arr_0) | vectorf[3][] | Output of type vectorf[3][] | [] |
## Metadata
### Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.UniversalAdd |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | usd |
| uiName | Universal Add For All Types (Python) |
| Categories | examples |
| Generated Class Name | OgnPyUniversalAddDatabase |
| Python Module | omni.graph.examples.python | | 33,540 |
OgnRandomBoolean.md | # Random Boolean
Generates a random boolean value.
## Installation
To use this node enable `omni.graph.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 |
| Is noise function (inputs:isNoise) | bool | Turn this node into a noise generator function For a given seed, it will then always output the same number(s) | False |
| Seed (inputs:seed) | uint64 | The seed of the random generator. | None |
| Use seed (inputs:useSeed) | bool | Use the custom seed instead of a random one | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gen (state:gen) | matrixd[3] | Random number generator internal state (abusing matrix3d because it is large enough) | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.RandomBoolean |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Random Boolean |
| Categories | math:operator |
| Generated Class Name | OgnRandomBooleanDatabase |
| Python Module | omni.graph.nodes | | 1,345 |
OgnRandomGaussian.md | # Random Gaussian
Generates a random numeric value using a Gaussian (i.e. normal) distribution. The shape can be controlled with two inputs: “Mean” and “Standard Deviation.” These inputs can be numbers, vectors, tuples or arrays of these. If one input has a higher dimension than the other, then the input with the lower dimension will be repeated to match the dimension of the other input (broadcasting).
## Installation
To use this node enable `omni.graph.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 |
| Is noise function (`inputs:isNoise`) | `bool` | Turn this node into a noise generator function. For a given seed, it will always output the same number(s). | False |
| Mean (`inputs:mean`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]']` | | |
| Parameter | Type | Description | Default Value |
|-----------|------|-------------|---------------|
| Mean (inputs:mean) | `['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 mean of the normal distribution. Can be a number, vector, tuple, or array of these. | double 0 |
| Seed (inputs:seed) | `uint64` | The input seed value for the random number generator. | None |
| Standard Deviation (inputs:stdev) | `['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[]']` | The standard deviation of the normal distribution. | None |
## Inputs
### Standard Deviation (inputs:stdDev)
- **Type:** `['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][]']`
- **Description:** The standard deviation of the normal distribution. Can be a number, vector, tuple, or array of these. The default value is double 1.
- **Default:** None
### Use log-normal (inputs:useLog)
- **Type:** `bool`
- **Description:** Use a log-normal distribution instead of the standard normal distribution.
- **Default:** False
### Use seed (inputs:useSeed)
- **Type:** `bool`
- **Description:** Use the custom seed instead of a random one.
- **Default:** False
## Outputs
### Exec Out (outputs:execOut)
- **Type:** `execution`
- **Description:** Signal to the graph that execution can continue downstream.
- **Default:** None
### Random Gaussian (outputs:random)
- **Type:** `['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[]']`
- **Description:** Random Gaussian output.
- **Default:** None
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Mean | `float` | The mean of the Gaussian distribution. | None |
| Standard Deviation | `float` | The standard deviation of the Gaussian distribution. | None |
| Output Type | `enum` | The type of the output value. Options include: `float`, `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][]` | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result | The random Gaussian value that was generated. | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Gen (state:gen) | `matrixd[3]` | Random number generator internal state. Not an actual matrix, the structure was chosen because it was large enough to hold the internal data required for the computation. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.RandomGaussian |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Random Gaussian |
| Categories | math:operator |
| Generated Class Name | OgnRandomGaussianDatabase |
| Python Module | omni.graph.nodes |
# 标题1
这是一个段落，包含[链接文本](#)和图片。
```
```
这里是代码块 | 6,506 |
OgnRandomNumeric.md | # Random Numeric
Generates a random numeric value in a range, using a uniform distribution. The range is specified with two inputs: “Minimum” and “Maximum”. These inputs can be numbers, vectors, tuples or arrays of these. If one input has a higher dimension than the other, then the input with the lower dimension will be repeated to match the dimension of the other input (broadcasting).
## Installation
To use this node enable `omni.graph.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 |
| Is Noise Function (`inputs:isNoise`) | `bool` | Turn this node into a noise generator function For a given seed, it will always output the same number(s). | False |
| Maximum (`inputs:max`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]']` | | |
| | Description | Type | Default Value |
|----|-----------------------------------------------------------------------------|----------------------------------------------------------------------|---------------|
| | The maximum of the random range, inclusive of integral numbers and exclusive for real numbers. Can be a number, vector, tuple, or array of these. The default value is double 1. | ['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][]'] | None |
| | The minimum of the random range, inclusive of integral numbers and exclusive for real numbers. Can be a number, vector, tuple, or array of these. | ['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]'] | None |
'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][]'
```
The minimum of the random range (inclusive). Can be a number, vector, tuple, or array of these. The default value is double 0.
Seed (inputs:seed)
uint64
The input seed value for the random number generator.
None
Use seed (inputs:useSeed)
bool
Use the custom seed instead of a random one.
False
```
Outputs
======
Name | Type | Description | Default
---- | ---- | ----------- | -------
Seed (inputs:seed) | uint64 | The input seed value for the random number generator. | None
Use seed (inputs:useSeed) | bool | Use the custom seed instead of a random one. | False
| Type | Descripton | Default |
|------|------------|---------|
| Exec Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
| Random Numeric (`outputs:random`) | `['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][]']` | None |
# RandomNumeric
## Parameters
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Seed | `int` | The seed value for the random number generator. | None |
| Output | `float` | The output format of the random number. | None |
| Range | `tuple` | The range of the random number. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Value | `float` | The random numeric value that was generated. | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Gen (state:gen) | `matrixd[3]` | Random number generator internal state. Not an actual matrix, the structure was chosen because it was large enough to hold the internal data required for the computation. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.RandomNumeric |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Random Numeric |
| Categories | math:operator |
| Generated Class Name | OgnRandomNumericDatabase |
| Python Module | omni.graph.nodes | | 7,466 |
OgnRandomUnitQuaternion.md | # Random Unit Quaternion
Generates a random unit quaternion with uniform distribution.
## Installation
To use this node enable `omni.graph.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 |
| Is noise function (inputs:isNoise) | bool | Turn this node into a noise generator function. For a given seed, it will always output the same number(s). | False |
| Metadata | | hidden = true | |
| Metadata | | literalOnly = 1 | |
| Seed (inputs:seed) | uint64 | The input seed value for the random unit quaternion generator. | None |
| Use seed (inputs:useSeed) | bool | Use the custom seed instead of a random one. | False |
## Outputs
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gen (state:gen) | matrixd[3] | Random number generator internal state. Not an actual matrix, the structure was chosen because it was large enough to hold the internal data required for the computation. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.RandomUnitQuaternion |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Random Unit Quaternion |
| Categories | math:operator |
| Generated Class Name | OgnRandomUnitQuaternionDatabase |
| Python Module | omni.graph.nodes | | 1,523 |
OgnRandomUnitVector.md | # Random Unit Vector
Generates a random vector with uniform distribution on the unit sphere.
## Installation
To use this node enable `omni.graph.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 |
| Is noise function (inputs:isNoise) | bool | Turn this node into a noise generator function. For a given seed, it will always output the same number(s). | False |
| Seed (inputs:seed) | uint64 | The input seed value for the random unit vector generator. | None |
| Use seed (inputs:useSeed) | bool | Use the custom seed instead of a random one. | False |
## Outputs
| Name | Type | Descripton | Default |
|---------------------|-------------|-------------------------------------------------|---------|
| Exec Out (outputs:execOut) | execution | Signal to the graph that this node has been executed. | None |
# Table 1
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (outputs:execOut) | `execution` | Signal to the graph that execution can continue downstream. | None |
| Random Unit Vector (outputs:random) | `vectorf[3]` | The random unit vector that was generated. | None |
# State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gen (state:gen) | `matrixd[3]` | Random number generator internal state. Not an actual matrix, the structure was chosen because it was large enough to hold the internal data required for the computation. | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.RandomUnitVector |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Random Unit Vector |
| Categories | math:operator |
| Generated Class Name | OgnRandomUnitVectorDatabase |
| Python Module | omni.graph.nodes | | 2,209 |
OgnRationalTimeSyncGate.md | # Rational Sync Gate
Activate the downstream graphs after all of the input signals have been triggered with the same synchronization value. An internal count is maintained that resets whenever a new synchronization value is encountered. If the count reaches a number equal to the number of ‘Execute In’ inputs then the ‘Execute Out’ activation signals to the downstream graph that it is ready to be executed.
The synchronization value is expressed as a rational number, conceptually equal to ‘Sync Numerator’ / ‘Sync Denominator’, although a zero denominator is accepted because the division is not actually performed. The comparison is made between two rational values by first reducing them by their greatest common denominators and then comparing numerator and denominator individually.
This means, for example, that 1/2 and 3/6 will be considered the same, but 1/0 and 2/0 will not since they cannot be reduced.
## 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 |
| Sync Denominator (`inputs:rationalTimeDenominator`) | `uint64` | Denominator of the synchronization time. | 0 |
| Sync Numerator (`inputs:rationalTimeNumerator`) | `int64` | Numerator of the synchronization time. | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
```
## Metadata
### Name
- Value: omni.graph.action.RationalTimeSyncGate
### Version
- Value: 2
### Extension
- Value: omni.graph.action_nodes
### Has State?
- Value: False
### Implementation Language
- Value: C++
### Default Memory Type
- Value: cpu
### Generated Code Exclusions
- Value: None
### uiName
- Value: Rational Sync Gate
### Categories
- Value: graph:action,flowControl
### Generated Class Name
- Value: OgnRationalTimeSyncGateDatabase
### Python Module
- Value: omni.graph.action_nodes | 2,013 |
OgnReadGamepadState.md | # Read Gamepad State
Reads the current state of the ID-specified gamepad device (i.e. which buttons are being pressed, the orientation of the joystick(s), etc.).
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Deadzone (`inputs:deadzone`) | `float` | Threshold from [0, 1] that the value must pass for it to be registered as input. | 0.1 |
| Element (`inputs:gamepadElement`) | `token` | The gamepad element whose state is to be checked. | Left Stick X Axis |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `allowedTokens` = Left Stick X Axis,Left Stick Y Axis,Right Stick X Axis,Right Stick Y Axis,Left Trigger,Right Trigger,Face Button Bottom,Face Button Right,Face Button Left,Face Button Top,Left Shoulder,Right Shoulder,Special Left,Special Right,Left Stick Button,Right Stick Button,D-Pad Up,D-Pad Right,D-Pad Down,D-Pad Left | |
| Gamepad ID (`inputs:gamepadId`) | `uint` | Gamepad ID number starting from 0. Used to identify a given gamepad device. | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.ReadGamepadState |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Read Gamepad State |
| Categories | input:gamepad |
| Generated Class Name | OgnReadGamepadStateDatabase |
| Python Module | omni.graph.nodes | | 1,786 |
OgnReadKeyboardState.md | # Read Keyboard State
Reads the current state of the keyboard (i.e. which keys or combination of keys on the associated keyboard are pressed).
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Key (`inputs:key`) | `token` | The key on the keyboard whose state is to be checked. | A |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `allowedTokens` = A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,Apostrophe,Backslash,Backspace,CapsLock,Comma,Del,Down,End,Enter,Equal,Escape,F1,F10,F11,F12,F2,F3,F4,F5,F6,F7,F8,F9,GraveAccent,Home,Insert,Key0,Key1,Key2,Key3,Key4,Key5,Key6,Key7,Key8,Key9,Left,LeftAlt,LeftBracket,LeftControl,LeftShift,LeftSuper,Menu,Minus,NumLock,Numpad0,Numpad1,Numpad2,Numpad3,Numpad4,Numpad5,Numpad6,Numpad7,Numpad8,Numpad9,NumpadAdd,NumpadDel,NumpadDivide,NumpadEnter,NumpadEqual,NumpadMultiply,NumpadSubtract,PageDown,PageUp,Pause,Period,PrintScreen,Right,RightAlt,RightBracket,RightControl,RightShift,RightSuper,ScrollLock,Semicolon,Slash,Space,Tab,Up | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Alt (`outputs:altOut`) | `bool` | True if any Alt key on the keyboard is held. | None |
## Metadata
### Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.ReadKeyboardState |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Read Keyboard State |
| Categories | input:keyboard |
| Generated Class Name | OgnReadKeyboardStateDatabase |
| Python Module | omni.graph.nodes | | 1,908 |
OgnReadMouseState.md | # Read Mouse State
Reads the current state of the mouse. You can choose which mouse element this node is associated with. When mouse element is chosen to be a button, only outputs:isPressed is meaningful. When coordinates are chosen, only outputs:coords and outputs:window are meaningful.
Pixel coordinates are the position of the mouse cursor in screen pixel units with (0,0) top left. Normalized coordinates are values between 0-1 where 0 is top/left and 1 is bottom/right. By default, coordinates are relative to the application window, but if ‘Use Relative Coords’ is set to true, then coordinates are relative to the workspace window containing the mouse pointer.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Mouse Element (`inputs:mouseElement`) | `token` | The mouse input to check the state of | Left Button |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `allowedTokens` = Left Button,Right Button,Middle Button,Forward Button,Back Button,Normalized Mouse Coordinates,Pixel Mouse Coordinates | |
| Use Relative Coords (`inputs:useRelativeCoords`) | `bool` | When true, the output ‘coords’ is made relative to the workspace window containing the mouse pointer instead of the entire application window | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Outputs
| Coords (outputs:coords) | float[2] | The coordinates of the mouse. If the mouse element selected is a button, this will output a zero vector. | None |
| --- | --- | --- | --- |
| Is Pressed (outputs:isPressed) | bool | True if the button is currently pressed, false otherwise. If the mouse element selected is a coordinate, this will output false. | None |
| Window (outputs:window) | token | The name of the workspace window containing the mouse pointer if ‘Use Relative Coords’ is true and the mouse element selected is a coordinate | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.ReadMouseState |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Read Mouse State |
| Categories | input:mouse |
| Generated Class Name | OgnReadMouseStateDatabase |
| Python Module | omni.graph.ui_nodes | | 2,422 |
OgnReadOmniGraphValue.md | # Read OmniGraph Value
Imports a data value from the Fabric cache that is located at the given path and attribute name. This is for data that is not already present in OmniGraph as that data can be accessed through a direct connection to the underlying OmniGraph node.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Name (inputs:name) | token | The name of the attribute to be queried | |
| Path (inputs:path) | path | The path to the Fabric data bucket in which the attribute being queried lives. | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (outputs:value) | any | The attribute value | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ReadOmniGraphValue |
|-----------------------|-------------------------------------|
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Read OmniGraph Value |
| Categories | sceneGraph |
| Generated Class Name | OgnReadOmniGraphValueDatabase |
| Python Module | omni.graph.nodes | | 1,574 |
OgnReadPickState.md | # Read Pick State (BETA)
Read the state of the last picking event from the specified viewport. Note that picking events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gesture (`inputs:gesture`) | `token` | The input gesture to trigger a picking event | Left Mouse Click |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `allowedTokens` = Left Mouse Click,Right Mouse Click,Middle Mouse Click,Left Mouse Press,Right Mouse Press,Middle Mouse Press | |
| Tracked Prim Paths (`inputs:trackedPrimPaths`) | `token[]` | Optionally specify a set of prims (by paths) to track whether or not they got picked (only affects the value of ‘Is Tracked Prim Picked’) | None |
| Tracked Prims (`inputs:trackedPrims`) | `target` | Optionally specify a set of prims to track whether or not they got picked (only affects the value of ‘Is Tracked Prim Picked’) | None |
| Metadata | | `allowMultiInputs` = 1 | |
| Use Paths (`inputs:usePaths`) | | | |
## Inputs
| Input | Type | Description | Default |
|-------|------|-------------|---------|
| Tracked Prim Paths | bool | When true, ‘Tracked Prim Paths’ is used, otherwise ‘Tracked Prims’ is used | False |
| Viewport | token | Name of the viewport window to watch for picking events | Viewport |
## Outputs
| Output | Type | Description | Default |
|--------|------|-------------|---------|
| Is Tracked Prim Picked | bool | True if a tracked prim got picked in the last picking event, or if any prim got picked if no tracked prims are specified | None |
| Is Valid | bool | True if a valid event state was detected and the outputs of this node are valid, and false otherwise | None |
| Picked Prim | target | The picked prim, or an empty target if nothing got picked | None |
| Picked Prim Path | token | The path of the prim picked in the last picking event, or an empty string if nothing got picked | None |
| Picked World Position | pointd[3] | The XYZ-coordinates of the point in world space at which the prim got picked, or (0,0,0) if nothing got picked | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.ui_nodes.ReadPickState |
| Version | 2 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Read Pick State (BETA) |
| Categories | ui |
| Generated Class Name | OgnReadPickStateDatabase |
| Python Module | omni.graph.ui_nodes |
```javascript
SphinxRtdTheme.Navigation.enable(true);
});
``` | 2,703 |
OgnReadPrim.md | # Read Prim
**DEPRECATED - use ReadPrimAttributes!**
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-------------------------------|--------------|----------------------------------------------------------------------------|---------|
| Attributes To Import (inputs:attrNamesToImport) | token | A list of wildcard patterns used to match the attribute names 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: [‘points’, ‘faceVertexCount’, ‘faceVertexIndices’, ‘size’]. ‘*’ - match any, ‘* ^points’ - match any, but exclude ‘points’, ‘* ^face*’ - match any, but exclude ‘faceVertexCount’ and ‘faceVertexIndices’. | |
| Compute Bounding Box (inputs:computeBoundingBox) | bool | For each primitive compute local bounding box and store them as ‘bboxMinCorner’, ‘bboxMaxCorner’ and ‘bboxTransform’ attributes. | False |
| Prim (inputs:prim) | bundle | The prims to be read from when ‘usePathPattern’ is false. | None |
| Time (inputs:usdTimecode) | timecode | The time at which to evaluate the transform of the USD prim. A value of “NaN” indicates that the default USD time stamp should be used. | NaN |
## Outputs
| Name | Type | Descripton | Default |
|-------------------------------|--------------|----------------------------------------------------------------------------|---------|
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Attr Names To Import (state:attrNamesToImport) | uint64 | State from previous execution | None |
| Compute Bounding Box (state:computeBoundingBox) | bool | State from previous execution | False |
| Prim Path (state:primPath) | uint64 | State from previous execution | None |
| Prim Types (state:primTypes) | uint64 | State from previous execution | None |
| Usd Timecode (state:usdTimecode) | timecode | State from previous execution | NaN |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ReadPrim |
| Version | 9 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Read Prim |
| Categories | sceneGraph,bundle |
| Generated Class Name | OgnReadPrimDatabase |
| Python Module | omni.graph.nodes | | 2,777 |
OgnReadPrimAttribute.md | # Read Prim Attribute
Given a path to a prim on the current USD stage and the name of an attribute on that prim, gets the value of that attribute, at the global timeline value.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Attribute Name (`inputs:name`) | `token` | The name of the attribute to get on the specified prim. | |
| Prim (`inputs:prim`) | `target` | The prim to be read from when “Use Path” is false. | None |
| Prim Path (`inputs:primPath`) | `token` | The path of the prim to be modified when “Use Path” is true. | None |
| Time (`inputs:usdTimecode`) | `timecode` | The time at which to evaluate the transform of the USD prim attribute. A value of “nan” indicates that the default USD time stamp should be used. | NaN |
| 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. | False |
## Outputs
## Value
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (outputs:value) | any | The attribute value | None |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Correctly Setup (state:correctlySetup) | bool | Whether or not the instance is properly setup | False |
| Import Path (state:importPath) | uint64 | Path at which data has been imported | None |
| Reimport At Time (state:reimportAtTime) | bool | Internal flag that’s used to help decide if the source attribute at the specified time needs to be reimported. | None |
| Src Attrib (state:srcAttrib) | uint64 | A TokenC to the source attribute | None |
| Src Path (state:srcPath) | uint64 | A PathC to the source prim | None |
| Src Path As Token (state:srcPathAsToken) | uint64 | A TokenC to the source prim | None |
| Time (state:time) | double | The timecode at which we have imported the value | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ReadPrimAttribute |
| Version | 3 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.ReadPrimAttribute.svg |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | |
| 属性 | 值 |
| --- | --- |
| cpu | cpu |
| Generated Code Exclusions | usd |
| uiName | Read Prim Attribute |
| Categories | sceneGraph |
| Generated Class Name | OgnReadPrimAttributeDatabase |
| Python Module | omni.graph.nodes | | 2,494 |
OgnReadPrimAttributes.md | # Read Prim Attributes
Read Prim attributes and exposes them as dynamic attributes. Produces an output bundle.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Attribute Name Pattern (`inputs:attrNamesToImport`) | `string` | A list of wildcard patterns used to match the attribute names 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: [‘points’, ‘faceVertexCount’, ‘faceVertexIndices’, ‘size’] ‘*’ - match any ‘* ^points’ - match any, but exclude ‘points’ ‘* ^face*’ - match any, but exclude ‘faceVertexCount’ and ‘faceVertexIndices’ | |
| Prim (`inputs:prim`) | `target` | The prim to be read from when ‘usePath’ is false | None |
| Prim Path (`inputs:primPath`) | `path` | The path of the prim to be read from when ‘usePath’ is true | |
| Time (`inputs:usdTimecode`) | `timecode` | The time at which to evaluate the transform of the USD prim. A value of “NaN” indicates that the default USD time stamp should be used | NaN |
| Use Path (`inputs:usePath`) | `bool` | | |
# Inputs
## Attributes
| Input | Type | Description | Default |
|-------|------|-------------|---------|
| Prim Path | 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 | False |
# Outputs
## Outputs
| Name | Type | Description | Default |
|------|------|-------------|---------|
| Prim Bundle (outputs:primBundle) | bundle | A bundle of the target Prim attributes. In addition to the data attributes, there are token attributes named sourcePrimPath and sourcePrimType which contains the path of the Prim being read | None |
| Metadata | | hidden = true | |
| Metadata | | literalOnly = 1 | |
# State
## State
| Name | Type | Description | Default |
|------|------|-------------|---------|
| Attr Names To Import (state:attrNamesToImport) | string | State from previous execution | None |
| Prim Path (state:primPath) | uint64 | State from previous execution | None |
| Usd Timecode (state:usdTimecode) | timecode | State from previous execution | NaN |
# Metadata
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.ReadPrimAttributes |
| Version | 3 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Read Prim Attributes |
| Categories | sceneGraph,bundle |
| Generated Class Name | OgnReadPrimAttributesDatabase |
| Python Module | omni.graph.nodes |
```javascript
SphinxRtdTheme.Navigation.enable(true);
});
``` | 2,881 |
OgnReadPrimBundle.md | # Read Prim into Bundle
**DEPRECATED - use ReadPrims!**
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Attributes To Import (`inputs:attrNamesToImport`) | `token` | A list of wildcard patterns used to match the attribute names 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: [‘points’, ‘faceVertexCount’, ‘faceVertexIndices’, ‘size’] ‘*’ - match any ‘* ^points’ - match any, but exclude ‘points’ ‘* ^face*’ - match any, but exclude ‘faceVertexCount’ and ‘faceVertexIndices’ | |
| Compute Bounding Box (`inputs:computeBoundingBox`) | `bool` | For each primitive compute local bounding box and store them as ‘bboxMinCorner’, ‘bboxMaxCorner’ and ‘bboxTransform’ attributes. | False |
| Prim (`inputs:prim`) | `target` | The prims to be read from when ‘usePath’ is false | None |
| Prim Path (`inputs:primPath`) | `token` | The paths of the prims to be read from when ‘usePath’ is true | |
| Time (`inputs:usdTimecode`) | `timecode` | The time at which to evaluate the transform of the USD prim. A value of “NaN” indicates that the default USD time stamp should be used | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Prim Bundle (outputs:primBundle) | bundle | A bundle containing multiple prims as children. Each child contains data attributes and two additional token attributes named sourcePrimPath and sourcePrimType which contain the path and the type of the Prim being read | None |
## Outputs
### Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Prim Bundle (outputs:primBundle) | bundle | A bundle containing multiple prims as children. Each child contains data attributes and two additional token attributes named sourcePrimPath and sourcePrimType which contain the path and the type of the Prim being read | None |
## State
### State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Attr Names To Import (state:attrNamesToImport) | uint64 | State from previous execution | None |
| Compute Bounding Box (state:computeBoundingBox) | bool | State from previous execution | False |
| Prim Path (state:primPath) | uint64 | State from previous execution | None |
| Usd Timecode (state:usdTimecode) | timecode | State from previous execution | NaN |
| Use Path (state:usePath) | bool | State from previous execution | False |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ReadPrimBundle |
| Version | 7 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.ReadPrimBundle.svg |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| --- | --- |
| hidden | true |
| uiName | Read Prim into Bundle |
| Categories | sceneGraph,bundle |
| Generated Class Name | OgnReadPrimBundleDatabase |
| Python Module | omni.graph.nodes | | 3,160 |
OgnReadPrimMaterial.md | # Read Prim Material
Given a path to a prim on the current USD stage, outputs the material of the prim. Gives an error if the given prim can not be found.
## 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 material to be read. If both this and primPath inputs are set, this input takes priority. | None |
| Prim Path (inputs:primPath) | path | Path of the prim with the material to be read. | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Material Path (outputs:material) | path | The material of the input prim | None |
| Material (outputs:materialPrim) | target | The prim containing the material of the input prim | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.ReadPrimMaterial |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Read Prim Material |
| Categories | sceneGraph |
| Generated Class Name | OgnReadPrimMaterialDatabase |
| Python Module | omni.graph.nodes | | 1,602 |
OgnReadPrimRelationship.md | # Read Prim Relationship
Reads the target(s) of a relationship on a given prim
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Relationship Name (`inputs:name`) | `token` | The name of the relationship to read | |
| Prim (`inputs:prim`) | `target` | The prim with the named relationship to read | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`outputs:value`) | `target` | The relationship target(s) | None |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
### Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.ReadPrimRelationship |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | usd |
| uiName | Read Prim Relationship |
| Categories | sceneGraph |
| Generated Class Name | OgnReadPrimRelationshipDatabase |
| Python Module | omni.graph.nodes | | 1,347 |
OgnReadPrims.md | # Read Prims (Legacy)
DEPRECATED - use ReadPrimsV2!
## 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 an input USD prim is skinnable and has the SkelBindingAPI schema applied, read skeletal data and apply SkelBinding to deform the prim. The output bundle will have additional child bundles created to hold data for the skeleton and skel animation prims if present. After execution, deformed points and normals will be written to the `points` and `normals` attributes, while non-deformed points and normals will be copied to the `points:default` and `normals:default` attributes. | False |
| Attribute Name Pattern (`inputs:attrNamesToImport`) | string | A list of wildcard patterns used to match the attribute names 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: [‘points’, ‘faceVertexCount’, ‘faceVertexIndices’, ‘size’] ‘*’ - match any ‘* ^points’ - match any, but exclude ‘points’ ‘* ^face*’ - match any, but exclude ‘faceVertexCount’ and ‘faceVertexIndices’ | |
| Compute Bounding Box (`inputs:computeBoundingBox`) | bool | For each primitive compute local bounding box and store them as ‘bboxMinCorner’, ‘bboxMaxCorner’ and ‘bboxTransform’ attributes. | False |
| Prim Path Pattern (`inputs:pathPattern`) | string | | |
# Inputs
## Path Pattern
A list of wildcard patterns used to match the prim paths 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: [‘/Cube0’, ‘/Cube1’, ‘/Box’]
- ‘*’ - match any
- ‘* ^/Box’ - match any, but exclude ‘/Box’
- ‘* ^/Cube*’ - match any, but exclude ‘/Cube0’ and ‘/Cube1’
## Prims
The prims to be read from when ‘useFindPrims’ is false
## Metadata
allowMultiInputs = 1
## Prim Type Pattern
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’
## Time
The time at which to evaluate the transform of the USD prim. A value of “NaN” indicates that the default USD time stamp should be used
## Use Find Prims
When true, the ‘pathPattern’ and ‘typePattern’ attribute is used as the pattern to search for the prims to read otherwise it will read the connection at the ‘prim’ attribute.
# Outputs
## Prims Bundle
An output bundle containing multiple prims as children. Each child contains data attributes and two additional token attributes named sourcePrimPath and sourcePrimType which contains the path of the Prim being read
# State
## Apply Skel Binding
State from previous execution
## Attr Names To Import
State from previous execution
## Compute Bounding Box
State from previous execution
## Path Pattern
State from previous execution
## Node Properties
| Property Name | Type | State from Previous Execution | Default Value |
|---------------|------|-------------------------------|---------------|
| Prim Paths (state:primPaths) | uint64[] | State from previous execution | None |
| Type Pattern (state:typePattern) | string | State from previous execution | None |
| Usd Timecode (state:usdTimecode) | timecode | State from previous execution | -1 |
| Use Find Prims (state:useFindPrims) | bool | State from previous execution | False |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.ReadPrims |
| Version | 3 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Read Prims (Legacy) |
| Categories | sceneGraph,bundle |
| Generated Class Name | OgnReadPrimsDatabase |
| Python Module | omni.graph.nodes | | 4,411 |
OgnReadPrimsBundle.md | # Read Prims into Bundle
Reads primitives and outputs multiple primitive in a bundle.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Attributes To Import (`inputs:attrNamesToImport`) | `string` | A list of wildcard patterns used to match the attribute names 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: [‘points’, ‘faceVertexCount’, ‘faceVertexIndices’, ‘size’] ‘*’ - match any ‘* ^points’ - match any, but exclude ‘points’ ‘* ^face*’ - match any, but exclude ‘faceVertexCount’ and ‘faceVertexIndices’ | |
| Prim Paths (`inputs:primPaths`) | `['path', 'token', 'token[]']` | The paths of the prims to be read from when ‘usePaths’ is true | None |
| Prims (`inputs:prims`) | `target` | The prims to be read from when ‘usePaths’ is false | None |
| Metadata | | `allowMultiInputs` = 1 | |
| Time (`inputs:usdTimecode`) | `timecode` | The time at which to evaluate the transform of the USD prim. A value of “NaN” indicates that the default USD time stamp should be used | |
# Outputs
| Name | Type | Descripton | Default |
|-----------------------|---------|----------------------------------------------------------------------------|---------|
| Prims Bundle (outputs:primsBundle) | bundle | An output bundle containing multiple prims as children. Each child contains data attributes and two additional token attributes named sourcePrimPath and sourcePrimType which contain the path and the type of the Prim being read | None |
# State
| Name | Type | Descripton | Default |
|-------------------------------|-----------|----------------------------------------------------------------------------|---------|
| Attr Names To Import (state:attrNamesToImport) | string | State from previous execution | None |
| Prim Paths (state:primPaths) | uint64[] | State from previous execution | None |
| Usd Timecode (state:usdTimecode) | timecode | State from previous execution | NaN |
| Use Paths (state:usePaths) | bool | State from previous execution | False |
# Metadata
| Name | Value |
|-----------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.nodes.ReadPrimsBundle |
| Version | 3 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Read Prims into Bundle |
| Categories | sceneGraph,bundle |
| Generated Class Name | OgnReadPrimsBundleDatabase |
|----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 3,970 |
OgnReadPrimsV2.md | # Read Prims
Reads primitives and outputs multiple primitive in a bundle.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Debug Stamp (`inputs:_debugStamp`) | `int` | For internal testing only, and subject to change. Please do not depend on this attribute! When not zero, this _debugStamp attribute will be copied to root and child bundles that change When a full update is performed, the negative _debugStamp is written. When only derived attributes (like bounding boxes and world matrices) are updated, _debugStamp + 1000000 is written | 0 |
| Metadata | | `literalOnly` = 1 | |
| Metadata | | `hidden` = true | |
| Apply Skel Binding (`inputs:applySkelBinding`) | `bool` | If an input USD prim is skinnable and has the SkelBindingAPI schema applied, read skeletal data and apply SkelBinding to deform the prim. The output bundle will have additional child bundles created to hold data for the skeleton and skel animation prims if present. After execution, deformed points and normals will be written to the `points` and `normals` attributes, while non-deformed points and normals will be copied to the `points:default` and `normals:default` attributes. | False |
| Attribute Name Pattern (`inputs:attrNamesToImport`) | `string` | A list of wildcard patterns used to match the attribute names 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: [‘points’, ‘faceVertexCount’, ‘faceVertexIndices’, ‘size’] ‘*’ - match any ‘* ^points’ - match any, but exclude ‘points’ ‘* ^face*’ - match any, but exclude ‘faceVertexCount’ and ‘faceVertexIndices’ | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Compute Bounding Box (`inputs:computeBoundingBox`) | bool | For each primitive compute local bounding box and store them as ‘bboxMinCorner’, ‘bboxMaxCorner’ and ‘bboxTransform’ attributes. | False |
| Bundle change tracking (`inputs:enableBundleChangeTracking`) | bool | Enable change tracking for output bundle, its children and attributes. The change tracking system for bundles has some overhead, but enables users to inspect the changes that occurred in a bundle. Through inspecting the type of changes user can mitigate excessive computations. | False |
| USD change tracking (`inputs:enableChangeTracking`) | bool | Should the output bundles only be updated when the associated USD prims change? This uses a USD notice handler, and has a small overhead, so if you know that the imported USD prims will change frequently, you might want to disable this. | True |
| Prim Path Pattern (`inputs:pathPattern`) | string | A list of wildcard patterns used to match the prim paths 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: [‘/Cube0’, ‘/Cube1’, ‘/Box’]. | |
| Prims (`inputs:prims`) | target | The root prim(s) that pattern matching uses to search from. If ‘pathPattern’ input is empty, the directly connected prims will be read. Otherwise, all the subtree (including root) will be tested against pattern matcher inputs, and the matched prims will be read into the output bundle. If no prims are connected, and ‘pathPattern’ is none empty, absolute root “/” will be searched as root prim. | None |
| Metadata | | `allowMultiInputs` = 1 | |
| Prim Type Pattern (`inputs:typePattern`) | string | 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’]. | |
| Time (`inputs:usdTimecode`) | timecode | The time at which to evaluate the transform of the USD prim. A value of “NaN” indicates that the default USD time stamp should be used. | NaN |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Prims Bundle (`outputs:primsBundle`) | bundle | An output bundle containing multiple prims as children. Each child contains data attributes and two additional token attributes named sourcePrimPath and sourcePrimType which contains the path of the Prim being read. | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
## Parameters
| Name | Type | Descripton | Default |
| ---- | ---- | ---------- | ------- |
| Apply Skel Binding (state:applySkelBinding) | bool | State from previous execution | False |
| Attr Names To Import (state:attrNamesToImport) | string | State from previous execution | None |
| Compute Bounding Box (state:computeBoundingBox) | bool | State from previous execution | False |
| Enable Bundle Change Tracking (state:enableBundleChangeTracking) | bool | State from previous execution | False |
| Enable Change Tracking (state:enableChangeTracking) | bool | State from previous execution | False |
| Path Pattern (state:pathPattern) | string | State from previous execution | None |
| Type Pattern (state:typePattern) | string | State from previous execution | None |
| Usd Timecode (state:usdTimecode) | timecode | State from previous execution | -1 |
## Metadata
### Metadata
| Name | Value |
| ---- | ----- |
| Unique ID | omni.graph.nodes.ReadPrimsV2 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Read Prims |
| Categories | sceneGraph,bundle |
| Generated Class Name | OgnReadPrimsV2Database |
| Python Module | omni.graph.nodes | | 5,989 |
OgnReadSetting.md | # Read Setting
Node that reads a value from a kit application setting
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Setting Path (`inputs:settingPath`) | `string` | The path of the setting | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`outputs:value`) | `['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']` | | |
## Metadata
### Name
- Value
### Unique ID
- omni.graph.nodes.ReadSetting
### Version
- 1
### Extension
- omni.graph.nodes
### Has State?
- False
### Implementation Language
- C++
### Default Memory Type
- cpu
### Generated Code Exclusions
| None |
| --- |
| uiName | Read Setting |
| Categories | sceneGraph |
| Generated Class Name | OgnReadSettingDatabase |
| Python Module | omni.graph.nodes | | 1,133 |
OgnReadStageSelection.md | # Read Stage Selection
Outputs the current stage selection as a list of paths
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
|-------------------------------|------------|---------------------|---------|
| Selected Prims (outputs:selectedPrims) | token[] | The currently selected path(s) | None |
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.ReadStageSelection |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Read Stage Selection |
| Categories | sceneGraph |
| Generated Class Name | OgnReadStageSelectionDatabase |
## Python Module
omni.graph.nodes | 1,239 |
OgnReadTime.md | # Read Time
Holds the values related to the current global time and the timeline.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Absolute Simulation Time (Seconds) (`outputs:absoluteSimTime`) | `double` | The accumulated total of elapsed times between rendered frames. | None |
| Delta (Seconds) (`outputs:deltaSeconds`) | `double` | The number of seconds elapsed since the last OmniGraph update. | None |
| Animation Time (Frames) (`outputs:frame`) | `double` | The global animation time in frames, equivalent to (time * fps), during playback. | None |
| Is Playing (`outputs:isPlaying`) | `bool` | True during global animation timeline playback. | None |
| Animation Time (Seconds) (`outputs:time`) | `double` | The global animation time in seconds during playback. | None |
| Time Since Start (Seconds) (`outputs:timeSinceStart`) | `double` | The time since the start of the simulation. | None |
# Node Details
## Inputs
### Name
```
double
```
### Description
Elapsed time since the App started.
### Default Value
None
# Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.ReadTime |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Read Time |
| Categories | time |
| Generated Class Name | OgnReadTimeDatabase |
| Python Module | omni.graph.nodes | | 1,828 |
OgnReadVariable.md | # Read Variable
Node that reads a value from a variable
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Graph (`inputs:graph`) | `target` | Ignored. Do not use | None |
| Metadata | | `hidden` = true | |
| Target Path (`inputs:targetPath`) | `token` | Ignored. Do not use. | None |
| Metadata | | `hidden` = true | |
| Variable Name (`inputs:variableName`) | `token` | The name of the graph variable to use. | |
| Metadata | | `hidden` = true | |
| Metadata | | `literalOnly` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
| Name | Value |
|------------|---------------------------|
| Unique ID | omni.graph.core.ReadVariable |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Read Variable |
| Categories | internal |
| Generated Class Name | OgnReadVariableDatabase |
| Python Module | omni.graph.nodes | | 1,293 |
OgnReadViewportClickState.md | # Read Viewport Click State (BETA)
Read the state of the last viewport click event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gesture (`inputs:gesture`) | `token` | The input gesture to trigger viewport click events | Left Mouse Click |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `allowedTokens` = Left Mouse Click,Right Mouse Click,Middle Mouse Click | |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | `bool` | When true, the components of the 2D position output are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. | False |
| Viewport (`inputs:viewport`) | `token` | Name of the viewport window to watch for click events | Viewport |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table 1
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Valid (outputs:isValid) | `bool` | True if a valid event state was detected and the outputs of this node are valid, and false otherwise | None |
| Position (outputs:position) | `double[2]` | The position at which the specified input gesture last triggered a viewport click event in the specified viewport | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.ReadViewportClickState |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Read Viewport Click State (BETA) |
| Categories | ui |
| Generated Class Name | OgnReadViewportClickStateDatabase |
| Python Module | omni.graph.ui_nodes | | 1,931 |
OgnReadViewportDragState.md | # Read Viewport Drag State (BETA)
Read the state of the last viewport drag event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gesture (`inputs:gesture`) | `token` | The input gesture to trigger viewport drag events | Left Mouse Drag |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | `bool` | When true, the components of 2D position and velocity outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. | False |
| Viewport (`inputs:viewport`) | `token` | Name of the viewport window to watch for drag events | Viewport |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table 1: Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Current Position (outputs:currentPosition) | double[2] | The current mouse position if a drag is in progress, or the final mouse position of the most recent drag if a drag is not in progress | None |
| Initial Position (outputs:initialPosition) | double[2] | The mouse position at which the most recent drag began | None |
| Is Drag In Progress (outputs:isDragInProgress) | bool | True if a viewport drag event is currently in progress in the specified viewport | None |
| Is Valid (outputs:isValid) | bool | True if a valid event state was detected and the outputs of this node are valid, and false otherwise | None |
| Velocity (outputs:velocity) | double[2] | A vector representing the change in position of the mouse since the previous frame if a drag is in progress, otherwise (0,0) | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.ReadViewportDragState |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Read Viewport Drag State (BETA) |
| Categories | ui |
| Generated Class Name | OgnReadViewportDragStateDatabase |
| Python Module | omni.graph.ui_nodes | | 2,284 |
OgnReadViewportHoverState.md | # Read Viewport Hover State (BETA)
Read the state of the last viewport hover event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | `bool` | When true, the components of 2D position and velocity outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. | False |
| Viewport (`inputs:viewport`) | `token` | Name of the viewport window to watch for hover events | Viewport |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Hovered (`outputs:isHovered`) | `bool` | True if the specified viewport is currently hovered | None |
| Is Valid (`outputs:isValid`) | `bool` | | |
## Outputs
| Column | Description |
| --- | --- |
| **Valid State (outputs:validState)** |
```
bool
```
| True if a valid event state was detected and the outputs of this node are valid, and false otherwise | None |
| **Position (outputs:position)** |
```
double[2]
```
| The current mouse position if the specified viewport is currently hovered, otherwise (0,0) | None |
| **Velocity (outputs:velocity)** |
```
double[2]
```
| A vector representing the change in position of the mouse since the previous frame if the specified viewport is currently hovered, otherwise (0,0) | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.ReadViewportHoverState |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Read Viewport Hover State (BETA) |
| Categories | ui |
| Generated Class Name | OgnReadViewportHoverStateDatabase |
| Python Module | omni.graph.ui_nodes | | 2,035 |
OgnReadViewportPressState.md | # Read Viewport Press State (BETA)
[](#read-viewport-press-state-beta)
Read the state of the last viewport press event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
[](#installation)
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
[](#inputs)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gesture (`inputs:gesture`) | `token` | The input gesture to trigger viewport press events | Left Mouse Press |
| Metadata | | `displayGroup` = parameters | |
| Metadata | | `allowedTokens` = Left Mouse Press,Right Mouse Press,Middle Mouse Press | |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | `bool` | When true, the components of 2D position outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. | False |
| Viewport (`inputs:viewport`) | `token` | Name of the viewport window to watch for press events | Viewport |
## Outputs
[](#outputs)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table 1: Node Properties
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Pressed (outputs:isPressed) | bool | True if the specified viewport is currently pressed | None |
| Is Release Position Valid (outputs:isReleasePositionValid) | bool | True if the press was released inside of the viewport, and false otherwise | None |
| Is Valid (outputs:isValid) | bool | True if a valid event state was detected and the outputs of this node are valid, and false otherwise | None |
| Press Position (outputs:pressPosition) | double[2] | The position at which the specified viewport was last pressed | None |
| Release Position (outputs:releasePosition) | double[2] | The position at which the last press on the specified viewport was released, or (0,0) if the press was released outside of the viewport or the viewport is currently pressed | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.ReadViewportPressState |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Read Viewport Press State (BETA) |
| Categories | ui |
| Generated Class Name | OgnReadViewportPressStateDatabase |
| Python Module | omni.graph.ui_nodes | | 2,664 |
OgnReadViewportScrollState.md | # Read Viewport Scroll State (BETA)
Read the state of the last viewport scroll event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Use Normalized Coords (`inputs:useNormalizedCoords`) | bool | When true, the components of the 2D position output are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels. | False |
| Viewport (`inputs:viewport`) | token | Name of the viewport window to watch for scroll events | Viewport |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Is Valid (`outputs:isValid`) | bool | True if a valid event state was detected and the outputs of this node are valid, and false otherwise | None |
| Position (`outputs:position`) | Vector2 | The 2D position of the scroll event in the viewport | None |
## Viewport Scroll State
### Outputs
| Name | Type | Description | Default Value |
| --- | --- | --- | --- |
| Last Scroll Position | double[2] | The last position at which a viewport scroll event occurred in the specified viewport | None |
| Scroll Value | float | The number of mouse wheel clicks scrolled up if positive, or scrolled down if negative | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.ReadViewportScrollState |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Read Viewport Scroll State (BETA) |
| Categories | ui |
| Generated Class Name | OgnReadViewportScrollStateDatabase |
| Python Module | omni.graph.ui_nodes | | 1,903 |
OgnRemoveAttr.md | # Remove Attributes From Bundles
Copies all attributes from an input bundle to the output bundle, except for any specified to be removed.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Allow Remove Prim Internal (`inputs:allowRemovePrimInternal`) | bool | When on, then primitive internal attributes can be removed(‘sourcePrimPath’ etc…) | False |
| Attributes To Remove (`inputs:attrNamesToRemove`) | token | A list of wildcard patterns used to match the attribute names that are to be removed from the output bundle 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: [‘points’, ‘faceVertexCount’, ‘faceVertexIndices’, ‘size’] ‘*’ - match any ‘* ^points’ - match any, but exclude ‘points’ ‘* ^face*’ - match any, but exclude ‘faceVertexCount’ and ‘faceVertexIndices’ | |
| Original Bundle (`inputs:data`) | bundle | Collection of attributes to be partially copied to the output | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle After Removal (`outputs:data`) | | | |
<em>
)
```
```
bundle
```
Final bundle of attributes, with the attributes specified by attrNamesToRemove omitted
None
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.RemoveAttribute |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Remove Attributes From Bundles |
| Categories | bundle |
| Generated Class Name | OgnRemoveAttrDatabase |
| Python Module | omni.graph.nodes | | 2,072 |
OgnRemoveString.md | # Remove String
## Remove String
Remove a string starting at the indicated index with length.
## 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 characters to delete. When set to -1, the length of “string” will be used. | -1 |
| Index (`inputs: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 (`inputs:string`) | `['string', 'token']` | The base string. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| String (`outputs:string`) | `['string', 'token']` | The output string. | |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.RemoveString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Remove String |
| Categories | function |
| Generated Class Name | OgnRemoveStringDatabase |
| Python Module | omni.graph.nodes | | 1,449 |
OgnRemoveTarget.md | # Remove Target
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| 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) | target | The modified target array. | None |
## Metadata
| Name | Value |
|--------------|---------------------------------|
| Unique ID | omni.graph.nodes.RemoveTarget |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Remove Target |
| Categories | sceneGraph |
| Generated Class Name | OgnRemoveTargetDatabase |
| Python Module | omni.graph.nodes | | 1,301 |
OgnRenameAttr.md | # Rename Attributes In Bundles
Changes the names of attributes from an input bundle for the corresponding output bundle. Attributes whose names are not in the ‘inputAttrNames’ list will be copied from the input bundle to the output bundle without changing the name.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Original Attribute Bundle (`inputs:data`) | `bundle` | Collection of attributes to be renamed | None |
| Attributes To Rename (`inputs:inputAttrNames`) | `token` | Comma or space separated text, listing the names of attributes in the input data to be renamed | |
| New Attribute Names (`inputs:outputAttrNames`) | `token` | Comma or space separated text, listing the new names for the attributes listed in inputAttrNames | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle Of Renamed Attributes (`outputs:data`) | `bundle` | Final bundle of attributes, with attributes renamed based on inputAttrNames and outputAttrNames | |
## Metadata
| Name | Value |
|------------|---------------------------------|
| Unique ID | omni.graph.nodes.RenameAttribute|
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Rename Attributes In Bundles |
| Categories | bundle |
| Generated Class Name | OgnRenameAttrDatabase |
| Python Module | omni.graph.nodes | | 1,705 |
OgnRenderPostprocessEntry.md | # Render Postprocess Entry
**Deprecated:** use OgnGpuInteropCudaEntry instead.
## Installation
To use this node enable `omni.graph.image.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Source Name (`inputs:sourceName`) | `string` | Source name of the AOV | ldrColor |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| cudaMipmappedArray (`outputs:cudaMipmappedArray`) | `uint64` | Pointer to the CUDA Mipmapped Array | None |
| format (`outputs:format`) | `uint64` | Format | None |
| height (`outputs:height`) | `uint` | Height | None |
## Properties
| Name | Type | Description | Default |
|---------------------|---------|---------------------------------|---------|
| hydraTime | double | Hydra time in stage | None |
| mipCount | uint | Mip Count | None |
| Rational Time Of Sim Denominator | uint64 | Rational time of simulation used to fetch data from Fabric | None |
| Rational Time Of Sim Numerator | int64 | Rational time of simulation used to fetch data from Fabric | None |
| simTime | double | Simulation time | None |
| stream | uint64 | Pointer to the CUDA Stream | None |
| width | uint | Width | None |
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.RenderPostProcessEntry |
| Version | 3 |
| Extension | omni.graph.image.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Render Postprocess Entry |
| hidden | true |
| Categories | internal,graph:postRender |
| Generated Class Name | OgnRenderPostprocessEntryDatabase |
| Python Module | omni.graph.image.nodes | | 2,327 |
OgnRenderPreprocessEntry.md | # Render Preprocess Entry
Entry node for pre-processing hydra render results for a single view. All downstream nodes are scheduled as CUDA commands.
## Installation
To use this node enable `omni.graph.image.nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Renderer Time (`outputs:hydraTime`) | `double` | The time difference since the last rendered frame. | None |
| Rational Time Of Sim Denominator (`outputs:rationalTimeOfSimDenominator`) | `uint64` | 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. | None |
| Rational Time Of Sim Numerator (`outputs:rationalTimeOfSimNumerator`) | `int64` | 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. | 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 - use the Rational Time instead in that case. | None |
## Graph Execution
### CUDA Stream
- **Description**: The CUDA Stream used to order the CUDA commands scheduled by this graph execution.
- **Value**: None
## Metadata
### Metadata
| Name | Value |
|--------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.RenderPreProcessEntry |
| Version | 3 |
| Extension | omni.graph.image.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Render Preprocess Entry |
| Categories | graph:preRender,rendering |
| Generated Class Name | OgnRenderPreprocessEntryDatabase |
| Python Module | omni.graph.image.nodes | | 2,177 |
OgnReplaceString.md | # Replace String
Replaces the first occurrence of the given value from an array with a new value. If “replaceAll” is true, replace all occurrences.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Replace (`inputs:replace`) | `['string', 'token']` | The string to replace within the base string. | None |
| Replace All (`inputs:replaceAll`) | `bool` | If true, replace all occurrences of the value. | False |
| String (`inputs:string`) | `['string', 'token']` | The base string. | None |
| Value (`inputs:value`) | `['string', 'token']` | The sub string to set within the base string. Can be an empty string to remove. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Descripton
## Default
| String (outputs:string) | ['string', 'token'] | The output string. | None |
| --- | --- | --- | --- |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ReplaceString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Replace String |
| Categories | function |
| Generated Class Name | OgnReplaceStringDatabase |
| Python Module | omni.graph.nodes | | 1,360 |
OgnReplaceTargetName.md | # Replace Target Name
Replaces the target name (the last element) with the specified name. Array inputs will be appended element-wise.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| New Name (`inputs:newName`) | `['string', 'token', 'token[]']` | The new name to replace the current name. Array inputs will be appended element-wise. | None |
| Targets (`inputs:targets`) | `target` | The target array to be modified | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Targets (`outputs:targets`) | `target` | The modified target array. | None |
## Name Value Table
| Name | Value |
|--------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.ReplaceTargetName |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Replace Target Name |
| Categories | sceneGraph |
| Generated Class Name | OgnReplaceTargetNameDatabase |
| Python Module | omni.graph.nodes | | 1,521 |
OgnReplaceTargetParent.md | # Replace Target Parent
Replaces the old parent with a new parent in every target in an array. If the old parent is not found, the target is unmodified.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| New Parent (`inputs:newParent`) | `target` | The new target parent. If empty, use the stage. | None |
| Old Parent (`inputs:oldParent`) | `target` | The target parent to replace. If the old parent is not found, the target is unmodified. | None |
| Targets (`inputs:targets`) | `target` | The target array to be modified | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Targets (`outputs:targets`) | `target` | | |
## Metadata
| Name | Value |
|-------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.ReplaceTargetParent |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Replace Target Parent |
| Categories | sceneGraph |
| Generated Class Name | OgnReplaceTargetParentDatabase |
| Python Module | omni.graph.nodes | | 1,583 |
OgnReplaceTargets.md | # Replace Targets
Replaces all occurrences of the given targets with new targets in the input array. Targets are replaced element-wise.
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Replace Targets (`inputs:replaceTargets`) | `target` | The targets to replace. | None |
| Metadata | | `allowMultiInputs` = 1 | |
| Set Targets (`inputs:setTargets`) | `target` | The new targets to set. If empty, targets will be removed. | None |
| Metadata | | `allowMultiInputs` = 1 | |
| Targets (`inputs:targets`) | `target` | The input target array. | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table of Contents
## ReplaceTargets
### Parameters
| Type | Descripton | Default |
| ---- | ---------- | ------- |
| Targets (outputs:targets) | `target` | The modified target array. | None |
## Metadata
### Metadata
| Name | Value |
| ---- | ----- |
| Unique ID | omni.graph.nodes.ReplaceTargets |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Replace Targets |
| Categories | sceneGraph |
| Generated Class Name | OgnReplaceTargetsDatabase |
| Python Module | omni.graph.nodes | | 1,458 |
OgnRotateToOrientation.md | # Rotate To Orientation
Perform a smooth rotation maneuver, rotating a prim to a desired orientation given a speed and easing factor
## 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 |
| 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 rotated | None |
| Prim Path (inputs:primPath) | `path` | The source prim to be transformed, used when ‘usePath’ is true | None |
| Speed (inputs:speed) | `double` | The peak speed of approach (Units / Second) | 1.0 |
| Stop (inputs:stop) | `bool` | A boolean flag to stop the rotation | False |
## Inputs
| Name | Type | Description | Default |
|--------------------------|--------------|-----------------------------------------------------------------------------|---------|
| Stop Maneuver (inputs:stopManeuver) | execution | Signal to the graph that this node is ready to stop the maneuver. | None |
| Target Orientation (inputs:target) | vectord[3] | The desired orientation as euler angles (XYZ) in local space | [0.0, 0.0, 0.0] |
| Use Path (inputs:usePath) | bool | When true, the ‘primPath’ attribute is used, otherwise it will read the connection at the ‘prim’ attribute | False |
## Outputs
| Name | Type | Descripton | 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.RotateToOrientation |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type| cpu |
| Generated Code Exclusions | None |
| uiName | Rotate To Orientation |
| Categories | sceneGraph |
| Generated Class Name | OgnRotateToOrientationDatabase |
| Python Module | omni.graph.nodes | | 3,296 |
OgnRotateToTarget.md | # Rotate To Target
This node smoothly rotates a prim object to match a target prim object given a speed and easing factor. At the end of the maneuver, the source prim will have the rotation as 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](../Overview.html#ext-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 |
| 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 rotation will be matched by the sourcePrim | None |
| Target Prim Path (inputs:targetPrimPath) | `path` | The destination prim. The target’s rotation 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.RotateToTarget |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Rotate To Target |
| Categories | sceneGraph |
| Generated Class Name | OgnRotateToTargetDatabase |
| Python Module | omni.graph.nodes | | 2,581 |
OgnRotateVector.md | # Rotate Vector
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Rotation (`inputs:rotation`) | `['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The rotation to be applied, either in the form of matrices, euler angles, or quaternions. If this input is an array, then the size of that array should match the size of the “Vector” array (or only contain a single element), otherwise the node will be unable to perform the computation. For 4x4 matrices, the transformation information in the matrix will be ignored. | None |
| Rotation Order (`inputs:rotationOrder`) | `token` | The order the rotation should be applied when using euler angles. | XYZ |
| | Metadata | `allowedTokens = XYZ,XZY,YXZ,YZX,ZXY,ZYX` | |
# Inputs
## Inputs
The three-dimensional row vector (or array of row vectors) to be rotated.
```
['vectord[3]',
'vectord[3][]',
'vectorf[3]',
'vectorf[3][]',
'vectorh[3]',
'vectorh[3][]']
```
None
# Outputs
## Outputs
The transformed three-dimensional row vector (or array of row vectors). This output will have the same shape as the input “Vector” attribute.
```
['vectord[3]',
'vectord[3][]',
'vectorf[3]',
'vectorf[3][]',
'vectorh[3]',
'vectorh[3][]']
```
None
# Metadata
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.RotateVector |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Rotate Vector |
| Categories | math:operator |
| Generated Class Name | OgnRotateVectorDatabase |
| Python Module | omni.graph.nodes |
``` | 2,157 |
OgnRound.md | # Round
## Round
Round a decimal input to the given number of decimals. Accepts float, double, half, or arrays / tuples of the aforementioned types.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Decimals (`inputs:decimals`) | `int` | The number of decimal places to round to. Negative numbers specify the number of positions left of the decimal. | 0 |
| 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][]']` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| 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[]', '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 input data to round. Can be of type float, double, half, or arrays / tuples of the aforementioned types. | None |
## Outputs
### Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Output (outputs:output) | ['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][]'] | | |
## Attributes
| Input | Output | Description |
|-------|--------|-------------|
| `'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 resultant rounded numbers, with the same type and size as the “Input” attribute.
None
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.Round |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Round |
| Categories | math:operator |
| Generated Class Name | OgnRoundDatabase |
| Python Module | omni.graph.nodes | | 4,150 |
OgnRpResourceExampleAllocator.md | # GPU Interop Example: RpResource Allocator
Example node showing how to allocate a CUDA-interoperable RpResource in a pre-render graph. The node allocates two new RpResources for the supplied prim which match the size of the array of points of the prim. One RpResource can be used to deform and render the prim, without actually mutating the input prim, while the other holds the original point values.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim Points (`inputs:points`) | `float[3][]` | The array of points of the input prim meshes. | [] |
| Prim Path (`inputs:primPath`) | `token` | The path of the prim for which we allocate a new RpResources. | |
| Reload (`inputs:reload`) | `bool` | Setting this to true will force the reallocation of the RpResource. This should be used when changing the input prims. | False |
| Stream (`inputs:stream`) | `uint64` | The CUDA Stream used to order the CUDA commands scheduled by this graph execution. | 0 |
| Verbose (`inputs:verbose`) | `bool` | If true, the node will log detailed messages during the execution. Can negatively impact performance. | |
## Outputs
| Name | Type | Descripton | Default |
|-------------------------------|---------------|----------------------------------------------------------------------------|---------|
| Point Counts (outputs:pointCountCollection) | uint64[] | Point count for each prim being deformed. The size of the array is equal to the number of allocator nodes of this type found in the graph. | None |
| Prim Paths (outputs:primPathCollection) | token[] | Path for each prim for which a new RpResource was allocated. The size of the array is equal to the number of allocator nodes of this type found in the graph. | None |
| Reload (outputs:reload) | bool | If true, the RpResources will be reallocated during the node compute. | False |
| Resource Pointer Collection (outputs:resourcePointerCollection) | uint64[] | Pointers to the allocated RpResources. Two resources are allocated per prim: one for the rest positions and one for deformed positions. | None |
| Stream (outputs:stream) | uint64 | The CUDA Stream used to order the CUDA commands scheduled by this graph execution. | None |
## Metadata
| Name | Value |
|---------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.nodes.RpResourceExampleAllocator |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | GPU Interop Example: RpResource Allocator |
| Categories | examples,graph:preRender |
| Generated Class Name | OgnRpResourceExampleAllocatorDatabase |
| Python Module | omni.graph.nodes | | 3,685 |
OgnRpResourceExampleDeformer.md | # GPU Interop Example: RpResource Deformer
Example node showcasing the deformation of a set of prims in a pre-render graph. The node is meant to be used together with RpResourceExampleAllocator and RpResourceExampleHydra. The deformation function translates the input points on a sinusoidal path against the z axis.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Deform Scale (`inputs:deformScale`) | `float` | Multiplier used to control the scale of the deformation. Increasing the value beyond 1 will increase the offset between the position at rest and the deformed position, for a given deformation. Negative values will flip the point position against the displacement axis. | 1.0 |
| Point Counts (`inputs:pointCountCollection`) | `uint64[]` | Point count for each prim being deformed. The size of the array is equal to the number prims being deformed. | [] |
| Position Scale (`inputs:positionScale`) | `float` | Determines the offset applied on the deformed points in each iteration of the node compute. Larger values will result in a more pronounced deformation over multiple frames. | 1.0 |
| Prim Paths (`inputs:primPathCollection`) | `token[]` | The paths of the prims being deformed. | [] |
| Resource Pointer Collection (`inputs:resourcePointerCollection`) | `token[]` | The collection of resource pointers for the deformation. | [] |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Run Deformer (inputs:runDeformerKernel) | bool | If true, performs the deformation of the prims. Can be toggled off to stop the deformation at an arbitrary point in time. | True |
| Simulation Frame Time (inputs: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. | 0.0 |
| Stream (inputs:stream) | uint64 | The CUDA Stream used to order the CUDA commands scheduled by this graph execution. | 0 |
| Time Scale (inputs:timeScale) | float | Determines the offset applied on the deformed points in each iteration of the node compute. Larger values will result in a more pronounced deformation over multiple frames. | 0.01 |
| Verbose (inputs:verbose) | bool | If true, the node will log detailed messages during the execution. Can negatively impact performance. | False |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Point Counts (outputs:pointCountCollection) | uint64[] | Point count for each prim being deformed. The size of the array is equal to the number prims being deformed. | None |
| Prim Paths (outputs:primPathCollection) | token[] | The paths of the prims being deformed. | None |
| Resource Pointer Collection (outputs:resourcePointerCollection) | uint64[] | Pointers to the allocated RpResources. Two resources are expected per prim: one for the rest positions and one for deformed positions. | None |
| Stream (outputs:stream) | uint64 | The CUDA Stream used to order the CUDA commands scheduled by this graph execution. | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Sequence Counter (state:sequenceCounter) | | | |
## Metadata
| Name | Value |
|------------|--------------------------------------------------------------------------------------------|
| Unique ID | omni.graph.nodes.RpResourceExampleDeformer |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | GPU Interop Example: RpResource Deformer |
| __tokens | {“points”: “points”, “transform”: “transform”, “rpResource”: “rpResource”, “pointCount”: “pointCount”, “primPath”: “primPath”, “testToken”: “testToken”, “uintData”: “uintData”} |
| Categories | examples,graph:preRender |
| Generated Class Name | OgnRpResourceExampleDeformerDatabase |
| Python Module | omni.graph.nodes | | 4,986 |
OgnRpResourceExampleHydra.md | # GPU Interop Example: RpResource to Hydra
Example Node: Send RpResource to Hydra for rendering. The node is meant to be used together with OgnRpResourceAllocator and OgnRpResourceDeformer. For each deformed prim, it is assumed that we have two sets of points to send to hydra for rendering: one set contains the original positions points of the deformed prims, the second contains the points after the deformation operation is applied.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Point Counts (`inputs:pointCountCollection`) | `uint64[]` | Point count for each prim being deformed. Should match the size of the arrays in the ‘Resource Pointer Collection’. | [] |
| Prim Paths (`inputs:primPathCollection`) | `token[]` | Path for each prim being deformed. Used for input validation during the node computation. | [] |
| Resource Pointer Collection (`inputs:resourcePointerCollection`) | `uint64[]` | Pointers to RpResources (two resources per prim are assumed – one for rest positions and one for deformed positions) | [] |
| Send to Hydra (`inputs:sendToHydra`) | `bool` | Send the RpResource to hydra using the specified prim path. If set to false, the node can be used simply as a debug node for the RpResource, if verbose is set to true. | False |
| Verbose (`inputs:verbose`) | `bool` | | |
# Configuration
## Log Level
- **Type**: `bool`
- **Description**: If true, the node will log detailed information about the data sent to hydra during the execution. Can negatively impact performance.
- **Default**: False
# Metadata
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.RpResourceExampleHydra |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | GPU Interop Example: RpResource to Hydra |
| __tokens | {"points": "points", "transform": "transform", "rpResource": "rpResource", "pointCount": "pointCount", "uintData": "uintData"} |
| Categories | examples,graph:preRender |
| Generated Class Name | OgnRpResourceExampleHydraDatabase |
| Python Module | omni.graph.nodes | | 2,626 |
OgnScaleCube.md | # Example Node: Multiply Float
Example node that performs a simple multiplication
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (`inputs:multiplier`) | `float` | 2nd multiplicand | 0.0 |
| Value (`inputs:value`) | `float` | 1st multiplicand | 0.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`outputs:value`) | `double` | Product of value and multiplier | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.ScaleCube |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Multiply Float |
| Categories | examples |
| Generated Class Name | OgnScaleCubeDatabase |
| Python Module | omni.graph.examples.cpp | | 989 |
OgnScaleCubeWithPrim.md | # Example Node: Multiply From Prim
Example node that performs a simple multiplication on a float value extracted from a Prim
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.examples.cpp.ScaleCubeWithOutputPrim |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Example Node: Multiply From Prim |
| Categories | examples |
| Generated Class Name | OgnScaleCubeWithPrimDatabase |
| Python Module | omni.graph.examples.cpp | | 1,062 |
OgnScaleToSize.md | # Scale To Size
Perform a smooth scaling maneuver, scaling a prim to a desired size tuple given a speed and easing factor
## 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 scaled | 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) | execution | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Stop Maneuver (inputs:stopManeuver) | None | Signal to the graph that this node is ready to stop the maneuver. | None |
| Target Scale (inputs:target) | vectord[3] | The desired local scale | [0.0, 0.0, 0.0] |
| Use Path (inputs:usePath) | 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 (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.ScaleToSize |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Scale To Size |
| Categories | sceneGraph |
| Generated Class Name | OgnScaleToSizeDatabase |
| Python Module | omni.graph.nodes | | 1,929 |
OgnScriptNode.md | # Script Node
This script node allows you to execute arbitrary Python code inside an OmniGraph. The compute function is defined by you at runtime and can be unique in every instance of a script node that you create. Inside that function you can access the database for the node, which is used for getting and setting all attribute values that you define.
## Exploring The Script Node
- **What Is A Script Node?**
- **Using The Script Node**
- **Tradeoffs: Script Node vs. Python Node**
- **Code Snippets: Pre-Packaged Code Samples**
- **Installation**
- **Inputs**
- **Outputs**
- **State**
- **Metadata**
- **Related Extensions**
### What Is A Script Node?
A script node is an implementation of a single node type for OmniGraph that can be used to create many different behaviors at runtime. Unlike most node types, whose behavior is hardcoded, each instantiation of a script node type can have its own custom behavior, implemented as a Python script on the node.
Some of the best uses of a script node are, to make quick prototypes of functionality to validate concepts you are trying out, and to write one-off nodes that are so simple that it is easier to write them yourself rather than to try to find an equivalent node (e.g. write a node that computes the hexadecimal string equivalent of an integer).
### Using The Script Node
These are the three steps you need to add a customized script node to your OmniGraph:
1. Create a script node.
2. Add the Python code required to implement the runtime behavior of the node.
3. Add necessary attributes for its operation.
In practice steps 2 and 3 can be done in either order, though we think you will find it easier to first define your function and then from that decide the list of attributes to be added.
**Important**
The script node will not be operational until you have added the extra attributes required. In the graph editor this execution failure shows up as a red coloring on the node. Once you have added the attributes normal execution will resume.
The script node can be used either directly from the UI via the graph editor and property panel, or indirectly through Python scripting, either in the script editor or in external files. The instructions below show both approaches - choose the one that you feel most comfortable with.
#### Creation
To start using the script node you must first create an OmniGraph in which it can live, and then create an instance
# Graph Editor
> Open the **Action Graph Editor** using the *Visual Scripting* menu
> Create a new **Action Graph** to hold the script node
> Drag the script node icon from the navigation bar on the left onto the newly created graph
> Once you have created a script node it will look something like this in your graph editor. The script node is suitable for use in any type of graph. In an **Action Graph**, the node will have an *execIn* pin to trigger its execution and an *execOut* pin to trigger other nodes when its compute completes.
# Python Code
The **Controller** is the main class through which you can manipulate an OmniGraph using a script file or the script editor. This script will create an **Action Graph** and add a script node to it.
```python
from textwrap import dedent # Just to make the documentation look better
import omni.graph.core as og
# Note the extra parameter to the graph to ensure it is an action graph.
(__, (script_node,), __, ___) = og.Controller.edit(
{"graph_path": "/TestGraph", "evaluator_name": "execution"},
{og.Controller.Keys.CREATE_NODES: ("ScriptNode", "omni.graph.scriptnode.ScriptNode")},
)
# After this call "script_node" contains the og.Node that was created in a brand new OmniGraph.
```
# Writing A Compute Function
The actual input from the script node can come from one of two sources - a string set directly on the node, or an external file containing the script. These are defined using shared attributes, present in all script nodes. The extra attributes you will use as part of your computation will be added later.
## Contents Of The Script
The script node creates a limited override of the API accessible from **omni.graph.core.NodeType**. The following callback functions can be defined in the script, and will be used as the runtime implementations of the equivalent functions on the node type API.
- **compute(db)**: called every time the node computes (should always be defined).
- **setup(db)**: called before compute the first time, or after the reset attribute value is set.
- **cleanup(db)**: called when the node is deleted or the reset attribute value is set.
*db:* **omni.graph.core.Database** is the node interface where attributes are exposed like `db.inputs.foo`. This includes the predefined attributes used by the script node as described below, as well as any dynamic attributes added to a script node instance by the user. The predefined functions `db.log_error` or `db.log_warning` should be used to report problems in the node’s computation.
In addition, for convenience the
```python
omni.graph.core
```
module is imported under the variable named
```python
og
```
.
```
import statements, function/class definitions, and global variables may be placed,
outside of the callbacks, as you would in any other Python module definition.
Variables may be added to the
```python
db.per_instance_state
```
state object for persistence across nodes that are instanced
in more than one graph. See how the
sample snippet for the Fibonacci function
makes use of this feature to
walk through the values in the Fibonacci sequence on each successive evaluation.
Overriding the
```python
db.setup(db)
```
and
```python
db.cleanup(db)
```
functions can be used to let your script node define values
that will be used through multiple evaluations, but which you do not wish to persist when the script node itself is
deleted. See how the
sample snippet for the Controller function
makes use of this feature to
initialize and clean up the USD stage for a script node that is responsible for creating cubes.
```admonition
Note
```
The
```python
setup
```
function corresponds to the
```python
omni.graph.core.NodeType.initialize()
```
function on the node type
and the
```python
cleanup
```
function corresponds to the
```python
omni.graph.core.NodeType.release()
```
function. The reason they
are different is that they will also be called when the script node is reset whereas the API functions only get
called when the node is created and destroyed.
All of the attribute values you get back from calling the
```python
db.inputs
```
or
```python
db.outputs
```
properties have a specific
data type based on their attribute type.
You can find a description of all of the data types returned from the database for the supported attribute types
by looking through the
data type descriptions.
```markdown
## Setting The Script With Text
```
The attribute
```python
inputs:script
```
is a simple text string which will be later translated into Python.
After creation of the script node it should be selected and its properties should be visible in the
property panel. If you don’t have the property panel visible you can turn it on with this menu
This is what the property panel for your script node will look like on creation. Notice how the script
field has been pre-populated with some placeholders for the functions you are allowed to write as well as some
instructions on what the script can contain.
Here is the full text of the instructions:
```python
# This script is executed the first time the script node computes, or the next time
# it computes after this script is modified or the 'Reset' button is pressed.
#
# The following callback functions may be defined in this script:
# setup(db): Called immediately after this script is executed
# compute(db): Called every time the node computes (should always be defined)
# cleanup(db): Called when the node is deleted or the reset button is pressed
# Available variables:
# db: og.Database The node interface - attributes are exposed in a namespace like db.inputs.foo and db.outputs.bar.
# Use db.log_error, db.log_warning to report problems in the compute function.
# og: The omni.graph.core module
def setup(db: og.Database):
pass
def cleanup(db: og.Database):
pass
def compute(db: og.Database):
return True
```
Ignoring the
```python
setup(db)
```
and
```python
cleanup(db)
```
functions for now copy-paste this simple node type definition string
and replace the **Script** text field with it.
```python
"""Set the output to True if the first input is larger than the second input"""
def compute(db: og.Database):
db.outputs.greater = db.inputs.first_input > db.inputs.second_input
# You always return True to indicate that the compute succeeded
return True
```
"""
Tip
As script nodes do not have unique node type definitions it is always a good idea to add Python docstrings as documentation as a reminder of exactly what the node does.
Now that you have a script defined you can skip ahead to Adding Attributes.
## Setting The Script With A File
If you want to use an external file then you set the *Use Path* attribute to **True** and set the *Script Path* attribute to be a string containing the path to the script file on disk. It can be an absolute path name, which will be highly reliant on your file system configuration, or it can be relative to the USD edit layer so that the script can be passed along with your USD file as a “sidecar” file.
### Graph Editor
After creation of the script node it should be selected and its properties should be visible in the property panel. If you don’t have the property panel visible you can turn it on with this menu.
This is what the property panel for your script node will look like on creation. Notice how the script field has been pre-populated with some placeholders for the functions you are allowed to write as well as some instructions on what the script can contain.
Now check the *Use Path* checkbox to tell the script node that it is getting its input from a file rather than the *Script* value above. Next set the *Script File Path* value to point to a file in which you have put your script. (See the Setting The Script With Text script section above for an example of what you might put into your file.) When you are done your property panel should look something like this.
### Python Code
The attribute values required to point the script node at a file can be set through the Controller.
This example creates a temporary file with the same script as the example above and accesses it.
```
```python
script_text = '''
"""Set the output to True if the first input is larger than the second input"""
def compute(db: og.Database):
db.outputs.greater = db.inputs.first_input > db.inputs.second_input
# You always return True to indicate that the compute succeeded
return True
'''
with TemporaryDirectory() as test_directory:
tmp_file_path = Path(test_directory) / "sample_scriptnode_script.py"
with open(tmp_file_path, "w", encoding="utf-8") as script_fd:
script_fd.write(dedent(script_text))
use_path_attr = script_node.get_attribute("inputs:usePath")
script_path_attr = script_node.get_attribute("inputs:scriptPath")
og.Controller.set(use_path_attr, True)
og.Controller.set(script_path_attr, str(tmp_file_path))
## Adding Attributes
Since there is no .ogn description of the node your script node will rely on Dynamic Attributes to define the inputs and outputs of the node. A dynamic attribute is just one that is not predefined by the node type. In the script you have written above these appear as anything in your `compute()` functions accessed as **db.inputs.X** for input attributes and **db.outputs.Y** for output attributes.
As the intent of your code is unknown (e.g. did you mean to add two integers or two arrays of points when you typed `db.inputs.a + db.inputs.b`) you must manually add each of the attributes with the types you intend to use.
### Graph Editor
In the script node property panel you will see a button labeled **Add Attribute…**. You will click on it once for each attribute that your `compute()` function requires; in this case it will be two inputs and one output.
This brings up a dialog where you can define your attributes. Here is what you will enter in order to define the first attribute as an integer value.
Repeat this for the other input `second_input` and then once again for the output attribute.
Notice here that you must also click the **output** button to specify that the new attribute will be an output. As a rule of thumb, inputs are values that you read and outputs are values that you write.
Once you have created a script node it will look something like this in your graph editor. The script node is suitable for use in any type of graph. In an Action Graph the node will have an `execIn` pin to trigger its execution and an `execOut` pin to trigger other nodes when its compute completes.
### Python Code
The Controller can also be used to add attributes to a node. This example makes our two inputs `integer` types and the output a `boolean` type. Note that this is a continuation of the previous script as it must appear inside the `TemporaryDirectory` context to work properly.
```python
# In the script you have accessed the database variables "db.inputs.first_input", "db.inputs.second_input",
# and "db.outputs.greater". These all correspond to attributes of the named port type (input or output)
# that must now be added to the node in order for it to function correctly.
first_input = og.Controller.create_attribute(script_node, "first_input", "int", og.AttributePortType.INPUT)
second_input = og.Controller.create_attribute(
script_node, "second_input", "int", og.AttributePortType.INPUT
)
output = og.Controller.create_attribute(script_node, "greater", "bool", og.AttributePortType.OUTPUT)
```
### Note
You may have seen references to another type of attribute port beyond input and output. The `state` attribute port is just like an `output` port except that it is guaranteed to retain its value between executions of the `compute()` function. Use state attributes for temporarily caching information.
The downside is that, since the script node you write is not on disk, it is more difficult to share the implementation with other users.
### Note
This is an important distinction. In simple terms, a **node type** is like a blueprint for making nodes. The blueprint can be used by scripts or by the graph editor to create as many nodes of the same type as you wish. A **node** is the actual thing created based on that blueprint. Think of it like a cookie cutter (node type) used to make cookies (nodes).
The **script node type** then is a general template for creating nodes that run scripts. A **script node** is a specific cookie made using that template, having its unique attributes and a Python script to run. While everyone can use the same cookie cutter (script node type) to make cookies (nodes) using standard tools, to create a new, specific cookie (script node), you’d have to duplicate an existing one.
### Code Snippets: Pre-Packaged Code Samples
If you have been using the property panel for editing you may have noticed a button labeled **Code Snippets**. This button accesses a drop-down menu that will populate your `compute()` function with working examples. You may have to enable extra extensions to make them work (e.g. **omni.warp**), and you will definitely have to inspect the snippets to see what types of attributes they are expecting as those must still be added manually by you.
#### Compute Count
```python
# In this example, we retrieve the number of times this script node has been computed
# and assign it to Output Data so that downstream nodes can use this information.
# Add these attributes first:
# outputs:my_output_attribute(int) Number of times the compute function was executed.
def compute(db):
compute_count = db.node.get_compute_count()
db.outputs.my_output_attribute = compute_count
```
#### Fibonacci
```python
# In this example, we produce the Fibonacci sequence 0, 1, 1, 2, 3, 5, 8, 13, 21...
# Each time this node is evaluated, the next Fibonacci number will be set as the output value.
# This illustrates how variables declared in the setup script can be used to keep persistent information.
# Add these attributes first:
# outputs:my_output_attribute(int) The current number in the Fibonacci sequence.
# state:last(int) The most recent Fibonacci number.
# state:previous(int) The second-most recent Fibonacci number.
def compute(db):
# Bootstrap the first call
if db.state.previous == 0:
db.state.last = 0
db.state.previous = 1
total = db.state.last + db.state.previous
db.state.last = db.state.previous
db.state.previous = total
db.outputs.my_output_attribute = db.state.last
```
#### Controller
```python
# In this example, we use omni.graph.core.Controller to create cube prims.
# Each time this node is evaluated, it will create a new cube prim on the scene.
# When the 'Reset' button is pressed or the node is deleted, the created cube prims will be deleted.
import omni.kit.commands
def setup(db):
state = db.per_instance_state
state.cube_count = 0
def compute(db):
state = db.per_instance_state
state.cube_count += 1
og.Controller.edit(
db.node.get_graph(), {og.Controller.Keys.CREATE_PRIMS: [f"/World/Cube{state.cube_count}", "Cube"]}
)
def cleanup(db):
import omni.usd
from pxr import Usd
```
```python
for prim in Usd.PrimRange(omni.usd.get_context().get_stage().GetPrimAtPath("/World")):
print(f"Deleting prim {prim.GetPrimPath()}", flush=True)
state = db.per_instance_state
omni.kit.commands.execute("DeletePrims", paths=[f"/World/Cube{i}" for i in range(1, state.cube_count + 1)])
```
```markdown
```python
# In this example, we deform input points using a Warp kernel, varying the deformation based on a time sequence
# Add these attributes first:
# inputs:points(pointf[3][]) Points to be deformed
# inputs:time(float) Point in time at which the deformation is to be computed
# outputs:points(pointf[3][]) Deformed positions of the points at the given time
import omni.warp
import warp as wp
@wp.kernel
def deform(points_in: wp.array(dtype=wp.vec3), points_out: wp.array(dtype=wp.vec3), time: float):
tid = wp.tid()
points_out[tid] = points_in[tid] + wp.vec3(0.0, wp.sin(time + points_in[tid][0] * 0.1) * 10.0, 0.0)
def compute(db):
# Indicate that inputs:points and outputs:points should be stored in cuda memory.
# outputs:points can be connected to a similarly configured input to avoid
# that attribute being copied from the device
db.set_dynamic_attribute_memory_location(
on_gpu=True,
gpu_ptr_kind=og.PtrToPtrKind.CPU,
)
with wp.ScopedDevice(f"cuda:{og.get_compute_cuda_device()}"):
points_in = omni.warp.from_omni_graph(db.inputs.points, dtype=wp.vec3)
n = db.inputs.points.shape[0]
if not n:
return
out_points = wp.zeros_like(points_in)
# launch kernel
wp.launch(kernel=deform, dim=n, inputs=[points_in, out_points, db.inputs.time])
# allocate output array
db.outputs.points_size = n
# copy points
points_out = omni.warp.from_omni_graph(db.outputs.points, dtype=wp.vec3)
wp.copy(points_out, out_points)
```
# The callback is called when the value of inputs:my_input_attribute is changed from the property panel.
# Add these attributes first:
# inputs:my_input_attribute(int) The attribute triggering the callback.
```python
def on_my_input_attribute_changed(attr):
print(f"inputs:my_input_attribute = {attr.get_attribute_data().get()}", flush=True)
def setup(db):
print("Setting up the value changed callback", flush=True)
attr = db.node.get_attribute("inputs:my_input_attribute")
attr.register_value_changed_callback(on_my_input_attribute_changed)
def cleanup(db):
print("Removing the value changed callback", flush=True)
attr = db.node.get_attribute("inputs:my_input_attribute")
attr.register_value_changed_callback(None)
def compute(db):
pass
```
# The setup() and cleanup() functions can be used to manage resources required by the node that correspond to the
# lifetime of the node. The management of state attributes is something that would commonly be done at these times
# since such attributes persist for the life of the node and remember their values throughout.
#
# Here is an example of how you might add state information and use the `setup()` and `cleanup()` functions to create an
# accumulated execution time for a node.
#
# For this example you will not create an Action Graph. Instead, create a `Generic Graph` and add a script node to it.
# Copy and paste the snippet below into your script node's script field. No attributes are required for this example.
#
# Since the node is in a push graph it will evaluate continuously. You can periodically hit the ``Reset`` button and it
# will report the total amount of time it spent in the `compute()` function since the last time you reset it.
#
# You can see how this simple mechanism could generalize to include per-compute averages, min and max times, etc.
# If you wish to accumulate all of the data you could even add a file descriptor to your internal state information,
# opening the file in the `setup()` function, printing to it in the `compute()` function, and closing it in the
# `cleanup()` function to create a journal of every computation time. -->
```python
import time
def setup(db: og.Database):
"""Initialize the timing information to start at 0.0"""
db.per_instance_state.elapsed = 0.0
print("Initialize the elapsed time", flush=True)
def cleanup(db: og.Database):
"""Report the final timing information"""
print(f"Total time spent in the script compute = {db.per_instance_state.elapsed}", flush=True)
def compute(db: og.Database):
"""Accumulate the timing information for each compute.
For the `compute()` a simple delay will serve to illustrate how the time accumulates as the node executes. As with any
other node, the database has a member called `per_instance_state` in which you can store any data that belongs to the node
which will persist for the lifetime of that node.
"""
start_time = time.perf_counter()
time.sleep(0.1) # Normally this would be your actual computation
end_time = time.perf_counter()
db.per_instance_state.elapsed = db.per_instance_state.elapsed + (end_time - start_time)
return True
```
## Installation
To use this node enable `omni.graph.scriptnode` in the Extension Manager.
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| inputs:my_input_attribute | int | The attribute triggering the callback. | |
# Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed. | None |
| Inline Script (inputs:script) | string | A string containing a Python script that may define code to be executed when the script node computes. See the default and example scripts for more information. | None |
| Script File Path (inputs:scriptPath) | token | The path of a file containing a Python script that may define code to be executed when the script node computes. See the default and example scripts for more info. | None |
| Metadata | uiType = filePath | | |
| Metadata | fileExts = Python Scripts (\*.py) | | |
| Use Script File (inputs:usePath) | bool | When true, the python script is read from the file specified in ‘Script File Path’ (inputs:scriptPath), instead of the string in ‘Inline Script’ (inputs:script). | False |
# Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec Out (outputs:execOut) | execution | Signal to the graph that execution can continue downstream. | None |
# State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Omni Initialized (state:omni_initialized) | bool | State attribute used to control when the script should be reloaded. This should be set to false to trigger a reload of the script. | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.scriptnode.ScriptNode |
| Version | 2 |
| Extension | omni.graph.scriptnode |
## Script Node Details
| Icon | Has State? | Implementation Language | Default Memory Type | Generated Code Exclusions | uiName | Categories | Generated Class Name | Python Module |
|------|------------|-------------------------|---------------------|---------------------------|--------|------------|----------------------|---------------|
| Icon | True | Python | cpu | None | Script Node | script | OgnScriptNodeDatabase | omni.graph.scriptnode |
## Related Extensions
The Python database implementation comes from the `omni.graph` extension.
The database definition is generated using the `omni.graph.tools` extension.
The graph editors described above for visual addition of dynamic attributes to the script node can be found in `omni.graph.window.action`. | 25,318 |
OgnSdFabricTimeRangeExecution.md | # Sd Fabric Time Range Execution
Read a rational time range from Fabric or RenderVars and signal its execution if the current time falls within this range. The range is [begin,end[, that is the end time does not belong to the range.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| Gpu (`inputs:gpu`) | `uint64` | Pointer to shared context containing gpu foundations. | 0 |
| Render Results (`inputs:renderResults`) | `uint64` | Render results | 0 |
| Time Range Begin Denominator Token (`inputs:timeRangeBeginDenominatorToken`) | `token` | Attribute name of the range begin time denominator | timeRangeStartDenominator |
| Time Range Begin Numerator Token (`inputs:timeRangeBeginNumeratorToken`) | `token` | Attribute name of the range begin time numerator | timeRangeStartNumerator |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Time Range End Denominator Token | token | Attribute name of the range end time denominator | timeRangeEndDenominator |
| Time Range End Numerator Token | token | Attribute name of the range end time numerator | timeRangeEndNumerator |
| Time Range Name | token | Time range name used to read from the Fabric or RenderVars. | |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec | execution | Trigger | None |
| Time Range Begin Denominator | uint64 | Time denominator of the last time range change (begin) | None |
| Time Range Begin Numerator | int64 | Time numerator of the last time range change (begin) | None |
| Time Range End Denominator | uint64 | Time denominator of the last time range change (end) | None |
| Time Range End Numerator | int64 | Time numerator of the last time range change (end) | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdFabricTimeRangeExecution |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:postRender,graph:action |
| Generated Class Name | |
# OgnSdFabricTimeRangeExecutionDatabase
## Python Module
- omni.syntheticdata | 2,325 |
OgnSdFrameIdentifier.md | # Sd Frame Identifier
Synthetic Data node to expose pipeline frame identifier.
## Installation
To use this node enable [omni.syntheticdata](../Overview.html#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (inputs:exec) | execution | Trigger | None |
| Render Results (inputs:renderResults) | uint64 | Render results | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Duration Denominator (outputs:durationDenominator) | uint64 | Duration denominator. Only valid if eConstantFramerateFrameNumber | 0 |
| Duration Numerator (outputs:durationNumerator) | int64 | Duration numerator. Only valid if eConstantFramerateFrameNumber. | 0 |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdFrameIdentifier |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:postRender,graph:action |
| Generated Class Name | OgnSdFrameIdentifierDatabase |
| Python Module | omni.syntheticdata | | 1,180 |
OgnSdInstanceMapping.md | # Sd Instance Mapping
Synthetic Data node to expose the scene instances semantic hierarchy information
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| Lazy (`inputs:lazy`) | `bool` | Compute outputs only when connected to a downstream node | True |
| Render Results (`inputs:renderResults`) | `uint64` | Render results pointer | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Received (`outputs:exec`) | `execution` | Executes when the event is received | None |
Sd IM Instance Semantic Map (
**outputs:sdIMInstanceSemanticMap**
)
```uchar[]```
Raw array of uint16_t of size sdIMNumInstances*sdIMMaxSemanticHierarchyDepth containing the mapping from the instances index to their inherited semantic entities
None
---
Sd IM Instance Tokens (
**outputs:sdIMInstanceTokens**
)
```token[]```
Instance array containing the token for every instances
None
---
Sd IM Last Update Time Denominator (
**outputs:sdIMLastUpdateTimeDenominator**
)
```uint64```
Time denominator of the last time the data has changed
None
---
Sd IM Last Update Time Numerator (
**outputs:sdIMLastUpdateTimeNumerator**
)
```int64```
Time numerator of the last time the data has changed
None
---
Sd IM Max Semantic Hierarchy Depth (
**outputs:sdIMMaxSemanticHierarchyDepth**
)
```uint```
Maximal number of semantic entities inherited by an instance
None
---
Sd IM Min Instance Index (
**outputs:sdIMMinInstanceIndex**
)
```uint```
Instance id of the first instance in the instance arrays
None
---
Sd IM Min Semantic Index (
**outputs:sdIMMinSemanticIndex**
)
```uint```
Semantic id of the first semantic entity in the semantic arrays
None
---
Sd IM Num Instances (
**outputs:sdIMNumInstances**
)
```uint```
Number of instances in the instance arrays
None
---
Sd IM Num Semantic Tokens (
**outputs:sdIMNumSemanticTokens**
)
```uint```
Number of semantics token including the semantic entity path, the semantic entity types and if the number of semantic types is greater than one a
None
---
Sd IM Num Semantics (
**outputs:sdIMNumSemantics**
)
```uint```
Number of semantic entities in the semantic arrays
None
---
Sd IM Semantic Local Transform (
**outputs:sdIMSemanticLocalTransform**
)
```float[]```
Semantic array of 4x4 float matrices containing the transform from world to local space for every semantic entity
None
---
Sd IM Semantic Token Map (
**outputs:sdIMSemanticTokenMap**
)
```token[]```
Semantic array of token of size numSemantics * numSemanticTypes containing the mapping from the semantic entities to the semantic entity path and semantic types
None
---
Sd IM Semantic World Transform (
**outputs:sdIMSemanticWorldTransform**
)
```float[]```
Semantic array of 4x4 float matrices containing the transform from local to world space for every semantic entity
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdInstanceMapping |
| Version | 2 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["InstanceMappingInfoSDhost", "InstanceMapSDhost", "SemanticLabelTokenSDhost", "InstancePrimTokenSDhost", "SemanticLocalTransformSDhost", "SemanticWorldTransformSDhost"] |
| Categories | graph:action |
| Generated Class Name | OgnSdInstanceMappingDatabase |
| Python Module | omni.syntheticdata | | 3,908 |
OgnSdInstanceMappingPtr.md | # Sd Instance Mapping Ptr
Synthetic Data node to expose the scene instances semantic hierarchy information
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Cuda Ptr (`inputs:cudaPtr`) | `bool` | If true, return cuda device pointer instead of host pointer | False |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| Render Results (`inputs:renderResults`) | `uint64` | Render results pointer | 0 |
| Semantic Filer Tokens (`inputs:semanticFilerTokens`) | `token[]` | Tokens identifying the semantic filters applied to the output semantic labels. Each token should correspond to an activated SdSemanticFilter node | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Descripton | Default |
|------------|---------|
| Cuda Device Index (`outputs:cudaDeviceIndex`) | int |
| If the data is on the device it is the cuda index of this device otherwise it is set to -1 | -1 |
| Received (`outputs:exec`) | execution |
| Executes when the event is received | None |
| Instance Map Ptr (`outputs:instanceMapPtr`) | uint64 |
| Array pointer of numInstances uint16_t containing the semantic index of the instance prim first semantic prim parent | None |
| Instance Prim Path Ptr (`outputs:instancePrimPathPtr`) | uint64 |
| Array pointer of numInstances uint64_t containing the prim path tokens for every instance prims | None |
| Last Update Time Denominator (`outputs:lastUpdateTimeDenominator`) | uint64 |
| Time denominator of the last time the data has changed | None |
| Last Update Time Numerator (`outputs:lastUpdateTimeNumerator`) | int64 |
| Time numerator of the last time the data has changed | None |
| Min Instance Index (`outputs:minInstanceIndex`) | uint |
| Instance index of the first instance prim in the instance arrays | None |
| Min Semantic Index (`outputs:minSemanticIndex`) | uint |
| Semantic index of the first semantic prim in the semantic arrays | None |
| Num Instances (`outputs:numInstances`) | uint |
| Number of instances prim in the instance arrays | None |
| Num Semantics (`outputs:numSemantics`) | uint |
| Number of semantic prim in the semantic arrays | None |
| Semantic Label Token Ptrs (`outputs:semanticLabelTokenPtrs`) | uint64[] |
| Array containing for every input semantic filters the corresponding array pointer of numSemantics uint64_t representing the semantic label of the semantic prim | None |
| Semantic Local Transform Ptr (`outputs:semanticLocalTransformPtr`) | uint64 |
| Array pointer of numSemantics 4x4 float matrices containing the transform from world to object space for every semantic prims | None |
| Semantic Map Ptr (`outputs:semanticMapPtr`) | uint64 |
| Array pointer of numSemantics uint16_t containing the semantic index of the semantic prim first semantic prim parent | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdInstanceMappingPtr |
| Version | 2 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["InstanceMappingInfoSDhost", "InstancePrimTokenSDhost", "InstancePrimTokenSD", "SemanticPrimTokenSDhost", "SemanticPrimTokenSD", "InstanceMapSDhost", "InstanceMapSD", "SemanticMapSDhost", "SemanticMapSD", "SemanticWorldTransformSDhost", "SemanticWorldTransformSD", "SemanticLocalTransformSDhost", "SemanticLocalTransformSD", "SemanticLabelTokenSDhost", "SemanticLabelTokenSD"] |
| Categories | graph:action |
| Generated Class Name | OgnSdInstanceMappingPtrDatabase |
| Python Module | omni.syntheticdata | | 4,000 |
OgnSdLinearArrayToTexture.md | # Sd Linear Array To Texture
Synthetic Data node to copy the input buffer array into a texture for visualization
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Data (`inputs:data`) | `float[4][]` | Buffer array data | [] |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| Height (`inputs:height`) | `uint` | Buffer array height | 0 |
| Sd Display Cuda Mipmapped Array (`inputs:sdDisplayCudaMipmappedArray`) | `uint64` | Visualization texture CUDA mipmapped array pointer | 0 |
| Sd Display Format (`inputs:sdDisplayFormat`) | `uint64` | Visualization texture format | 0 |
| Sd Display Height (`inputs:sdDisplayHeight`) | `uint64` | Visualization texture height | 0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Visualization texture Height | | | 0 |
| Sd Display Stream (inputs:sdDisplayStream) | uint64 | Visualization texture CUDA stream pointer | 0 |
| Sd Display Width (inputs:sdDisplayWidth) | uint | Visualization texture width | 0 |
| Stream (inputs:stream) | uint64 | Pointer to the CUDA Stream | 0 |
| Width (inputs:width) | uint | Buffer array width | 0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Cuda Ptr (outputs:cudaPtr) | uint64 | Display texture CUDA pointer | None |
| Received (outputs:exec) | execution | Executes when the event is received | None |
| Format (outputs:format) | uint64 | Display texture format | None |
| Handle Ptr (outputs:handlePtr) | uint64 | Display texture handle reference | None |
| Height (outputs:height) | uint | Display texture height | None |
| Stream (outputs:stream) | uint64 | Output texture CUDA stream pointer | None |
| Width (outputs:width) | uint | Display texture width | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| Key | Value |
|------------------------------|----------------------|
| omni.syntheticdata.SdLinearArrayToTexture | - |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| Categories | graph:action |
| Generated Class Name | OgnSdLinearArrayToTextureDatabase |
| Python Module | omni.syntheticdata | | 2,599 |
OgnSdNoOp.md | # Sd No Op
Synthetic Data pass through node
## Installation
To use this node enable [omni.syntheticdata](../Overview.html#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|---------------|------------|---------|
| Exec (inputs:exec) | `execution` | Trigger | None |
## Outputs
| Name | Type | Descripton | Default |
|------|---------------|------------|---------|
| Exec (outputs:exec) | `execution` | Trigger | None |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.syntheticdata.SdNoOp |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
|-------------|-------|
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | internal |
| Generated Class Name | OgnSdNoOpDatabase |
| Python Module | omni.syntheticdata | | 1,021 |
OgnSdOnNewFrame.md | # Sd On New Frame
Synthetic Data postprocess node to execute pipeline after the NewFrame event has been received
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Cuda Stream (`outputs:cudaStream`) | `uint64` | Cuda stream | None |
| Exec (`outputs:exec`) | `execution` | Executes for each newFrame event received | None |
| Reference Time Denominator (`outputs:referenceTimeDenominator`) | `uint64` | Reference time represented as a rational number : denominator | None |
| Reference Time Numerator (`outputs:referenceTimeNumerator`) | `int64` | Reference time represented as a rational number : numerator | None |
| Render Product Data Ptrs (`outputs:renderProductDataPtrs`) | `uint64[]` | HydraRenderProduct data pointer. | None |
| Render Product Paths (`outputs:renderProductPaths`) | | | None |
# Metadata
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdOnNewFrame |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnSdOnNewFrameDatabase |
| Python Module | omni.syntheticdata | | 1,635 |