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