file_path
stringlengths 5
148
| content
stringlengths 0
526k
|
|---|---|
OgnSdSimInstanceMapping.md | # Sd Sim Instance Mapping
Synthetic Data node to update and cache the instance mapping data
## Installation
To use this node enable [omni.syntheticdata](../Overview.html#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Need Transform (inputs:needTransform) | bool | If true compute the semantic entities world and object transforms | True |
| Semantic Filter Predicate (inputs:semanticFilterPredicate) | token | The semantic filter predicate : a disjunctive normal form of semantic type and label | : |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (outputs:exec) | execution | Trigger | None |
| Semantic Filter Predicate (outputs:semanticFilterPredicate) | token | | |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdSimInstanceMapping |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:simulation,internal |
| Generated Class Name | OgnSdSimInstanceMappingDatabase |
| Python Module | omni.syntheticdata | |
OgnSdSimRenderProductCamera.md | # Sd Sim Render Product Camera
Synthetic Data node to expose the renderProduct camera in the fabric
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Render Product Path (`inputs:renderProductPath`) | `token` | renderProduct prim path | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`outputs:exec`) | `execution` | Trigger | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdSimRenderProductCamera |
| Version | 1 |
| Extension | omni.syntheticdata |
|-----------|---------------------|
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:simulation,internal |
| Generated Class Name | OgnSdSimRenderProductCameraDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTestInstanceMapping.md | # Sd Test Instance Mapping
Synthetic Data node to test the instance mapping pipeline
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| Instance Map Ptr (`inputs:instanceMapPtr`) | `uint64` | Array pointer of numInstances uint16_t containing the semantic index of the instance prim first semantic prim parent | 0 |
| Instance Prim Path Ptr (`inputs:instancePrimPathPtr`) | `uint64` | Array pointer of numInstances uint64_t containing the prim path tokens for every instance prims | 0 |
| Min Instance Index (`inputs:minInstanceIndex`) | `uint` | Instance index of the first instance prim in the instance arrays | 0 |
| Min Semantic Index (`inputs:minSemanticIndex`) | `uint` | Semantic index of the first semantic prim in the semantic arrays | 0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Num Instances (`inputs:numInstances`) | `uint` | Number of instances prim in the instance arrays | 0 |
| Num Semantics (`inputs:numSemantics`) | `uint` | Number of semantic prim in the semantic arrays | 0 |
| Semantic Label Token Ptrs (`inputs:semanticLabelTokenPtrs`) | `uint64[]` | Array containing for every input semantic filters the corresponding array pointer of numSemantics uint64_t representing the semantic label of the semantic prim | [] |
| Semantic Local Transform Ptr (`inputs:semanticLocalTransformPtr`) | `uint64` | Array pointer of numSemantics 4x4 float matrices containing the transform from world to object space for every semantic prims | 0 |
| Semantic Map Ptr (`inputs:semanticMapPtr`) | `uint64` | Array pointer of numSemantics uint16_t containing the semantic index of the semantic prim first semantic prim parent | 0 |
| Semantic Prim Path Ptr (`inputs:semanticPrimPathPtr`) | `uint64` | Array pointer of numSemantics uint32_t containing the prim part of the prim path tokens for every semantic prims | 0 |
| Semantic World Transform Ptr (`inputs:semanticWorldTransformPtr`) | `uint64` | Array pointer of numSemantics 4x4 float matrices containing the transform from local to world space for every semantic entity | 0 |
| Stage (`inputs:stage`) | `token` | Stage in {simulation, postrender, ondemand} | |
| Swh Frame Number (`inputs:swhFrameNumber`) | `uint64` | Fabric frame number | 0 |
| Test Case Index (`inputs:testCaseIndex`) | `int` | Test case index | -1 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Received (`outputs:exec`) | `execution` | Executes when the event is received | None |
| Semantic Filter Predicate (`outputs:semanticFilterPredicate`) | `token` | The semantic filter predicate : a disjunctive normal form of semantic type and label | |
# Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdTestInstanceMapping |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["simulation", "postRender", "onDemand"] |
| Categories | graph:simulation,graph:postRender,graph:action,internal:test |
| Generated Class Name | OgnSdTestInstanceMappingDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTestPrintRawArray.md | # Sd Test Print Raw Array
Synthetic Data test node printing the input linear array
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Buffer Size (`inputs:bufferSize`) | `uint` | Size (in bytes) of the buffer (0 if the input is a texture) | 0 |
| Data (`inputs:data`) | `uchar[]` | Buffer array data | [] |
| Data File Base Name (`inputs:dataFileBaseName`) | `token` | Basename of the output npy file | /tmp/sdTestRawArray |
| Element Count (`inputs:elementCount`) | `int` | Number of array element | 1 |
| Element Type (`inputs:elementType`) | `token` | Type of the array element | uint8 |
| Exec (`inputs:exec`) | | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Execution | execution | | None |
| Height (inputs:height) | uint | Height (0 if the input is a buffer) | 0 |
| Mode (inputs:mode) | token | Mode in [printFormatted, printReferences, testReferences] | printFormatted |
| Random Seed (inputs:randomSeed) | int | Random seed | 0 |
| Reference Num Unique Random Values (inputs:referenceNumUniqueRandomValues) | int | Number of reference unique random values to compare | 7 |
| Reference SWH Frame Numbers (inputs:referenceSWHFrameNumbers) | uint[] | Reference swhFrameNumbers relative to the first one | [11, 17, 29] |
| Reference Tolerance (inputs:referenceTolerance) | float | Reference tolerance | 0.1 |
| Reference Values (inputs:referenceValues) | float[] | Reference data point values | [] |
| Swh Frame Number (inputs:swhFrameNumber) | uint64 | Frame number | 0 |
| Width (inputs:width) | uint | Width (0 if the input is a buffer) | 0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Received (outputs:exec) | execution | Executes when the event is received | None |
| Swh Frame Number (outputs:swhFrameNumber) | uint64 | FrameNumber just rendered | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
# Table 1
## Parameters
| Type | Descripton | Default |
|------|------------|---------|
| Initial SWH Frame Number (state:initialSWHFrameNumber) | int64 | Initial swhFrameNumber | -1 |
# Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.syntheticdata.SdTestPrintRawArray |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | True |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| __tokens | ["uint16", "int16", "uint32", "int32", "float32", "token", "printFormatted", "printReferences", "writeToDisk"] |
| Categories | graph:action,internal:test |
| Generated Class Name | OgnSdTestPrintRawArrayDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTestRationalTimeSyncGate.md | # Sd Test Rational Time Sync Gate
This node triggers when all its input executions have triggered successively at the same rational time.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|---------------|-------------------------------------|---------|
| Execute In (inputs:execIn) | execution | The input execution | None |
| Sync Denominator (inputs:rationalTimeDenominator) | uint64 | Denominator of the synchronization time. | 0 |
| Sync Numerator (inputs:rationalTimeNumerator) | int64 | Numerator of the synchronization time. | 0 |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|---------------|-------------------------------------|---------|
| Execute Out (outputs:execOut) | execution | The output execution | None |
## Outputs
| Name | Type | Description | Default Value |
| --- | --- | --- | --- |
| Output Execution | | | None |
| Sync Denominator (outputs:rationalTimeDenominator) | uint64 | Denominator of the synchronization time. | None |
| Sync Numerator (outputs:rationalTimeNumerator) | int64 | Numerator of the synchronization time. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdTestRationalTimeSyncGate |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| Categories | graph:action,internal:test |
| Generated Class Name | OgnSdTestRationalTimeSyncGateDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTestRenderProductCamera.md | # Sd Test Render Product Camera
Synthetic Data node to test the renderProduct camera pipeline
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Camera Aperture Offset (`inputs:cameraApertureOffset`) | `float[2]` | Camera horizontal and vertical aperture offset | [0.0, 0.0] |
| Camera Aperture Size (`inputs:cameraApertureSize`) | `float[2]` | Camera horizontal and vertical aperture | [0.0, 0.0] |
| Camera F Stop (`inputs:cameraFStop`) | `float` | Camera fStop | 0.0 |
| Camera Fisheye Params (`inputs:cameraFisheyeParams`) | `float[]` | Camera fisheye projection parameters | [] |
| Camera Focal Length (`inputs:cameraFocalLength`) | `float` | Camera focal length | 0.0 |
- Camera Focus Distance (`inputs:cameraFocusDistance`)
- Type: `float`
- Description: Camera focus distance
- Default Value: 0.0
- Camera Model (`inputs:cameraModel`)
- Type: `int`
- Description: Camera model (pinhole or fisheye models)
- Default Value: 0
- Camera Near Far (`inputs:cameraNearFar`)
- Type: `float[2]`
- Description: Camera near/far clipping range
- Default Value: [0.0, 0.0]
- Camera Projection (`inputs:cameraProjection`)
- Type: `matrixd[4]`
- Description: Camera projection matrix
- Default Value: [[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]]
- Camera View Transform (`inputs:cameraViewTransform`)
- Type: `matrixd[4]`
- Description: Camera view matrix
- Default Value: [[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]]
- Exec (`inputs:exec`)
- Type: `execution`
- Description: Trigger
- Default Value: None
- Height (`inputs:height`)
- Type: `uint`
- Description: Height of the frame
- Default Value: 0
- Meters Per Scene Unit (`inputs:metersPerSceneUnit`)
- Type: `float`
- Description: Scene units to meters scale
- Default Value: 0.0
- Render Product Camera Path (`inputs:renderProductCameraPath`)
- Type: `token`
- Description: RenderProduct camera prim path
- Default Value:
- Render Product Resolution (`inputs:renderProductResolution`)
- Type: `int[2]`
- Description: RenderProduct resolution
- Default Value: [0, 0]
- Render Results (`inputs:renderResults`)
- Type: `uint64`
- Description: OnDemand connection : pointer to render product results
- Default Value: 0
- renderProduct (`inputs:rp`)
- Type: `uint64`
- Description: PostRender connection : pointer to render product for this view
- Default Value: 0
- Stage (`inputs:stage`)
- Type: `token`
- Description: Stage in {simulation, postrender, ondemand}
- Default Value:
- Trace Error (`inputs:traceError`)
- Type: `bool`
- Description: If true print an error message when the frame numbers are out-of-sync
- Default Value: False
# Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Width (inputs:width) | uint | Width of the frame | 0 |
# Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Test (outputs:test) | bool | Test value : false if failed | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdTestRenderProductCamera |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| __tokens | [“simulation”, “postRender”, “onDemand”] |
| Categories | graph:simulation,graph:postRender,graph:action,internal:test |
| Generated Class Name | OgnSdTestRenderProductCameraDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTestSimFabricTimeRange.md | # Sd Test Sim Fabric Time Range
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Number Of Frames (`inputs:numberOfFrames`) | `uint64` | Number of frames to write. | 0 |
| Time Range Begin Denominator Token (`inputs:timeRangeBeginDenominatorToken`) | `token` | Attribute name of the range begin time denominator | timeRangeStartDenominator |
| Time Range Begin Numerator Token (`inputs:timeRangeBeginNumeratorToken`) | `token` | Attribute name of the range begin time numerator | timeRangeStartNumerator |
| Time Range End Denominator Token (`inputs:timeRangeEndDenominatorToken`) | `token` | Attribute name of the range end time denominator | timeRangeEndDenominator |
| Time Range End Numerator Token (`inputs:timeRangeEndNumeratorToken`) | `token` | Attribute name of the range end time numerator | timeRangeEndNumerator |
# Inputs
## Attribute Definitions
| Attribute Name of the Range End Time Numerator | timeRangeEndNumerator |
|-----------------------------------------------|------------------------|
| Time Range Name (inputs:timeRangeName) | token |
| Time range name used to write to the Fabric | Time range name used to write to the Fabric. |
| TestSimFabricTimeRangeSD | TestSimFabricTimeRangeSD |
# Outputs
## Output Definitions
| Name (outputs:exec) | Type | Description | Default |
|----------------------|------|-------------|---------|
| Exec | execution | Trigger | None |
# Metadata
## Metadata Definitions
| Name | Value |
|------|-------|
| Unique ID | omni.syntheticdata.SdTestSimFabricTimeRange |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["fc_exportToRingbuffer"] |
| Categories | graph:simulation,internal,event |
| Generated Class Name | OgnSdTestSimFabricTimeRangeDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTestStageManipulationScenarii.md | # Sd Test Stage Manipulation Scenarii
Synthetic Data test node applying randomly some predefined stage manipulation scenarii
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Random Seed (`inputs:randomSeed`) | `int` | Random seed | 0 |
| World Prim Path (`inputs:worldPrimPath`) | `token` | Path of the world prim : contains every modifiable prim, cannot be modified | |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Frame Number (`state:frameNumber`) | `uint64` | Current frameNumber (number of invocations) | 0 |
## Metadata
| Name | Descripton |
| --- | --- |
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdTestStageManipulationScenarii |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | True |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| Categories | graph:simulation,internal:test |
| Generated Class Name | OgnSdTestStageManipulationScenariiDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTestStageSynchronization.md | # Sd Test Stage Synchronization
Synthetic Data node to test the pipeline stage synchronization
## Installation
To use this node enable [omni.syntheticdata](../Overview.html#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (inputs:exec) | execution | OnDemand connection : trigger | None |
| gpuFoundations (inputs:gpu) | uint64 | PostRender connection : pointer to shared context containing gpu foundations | 0 |
| Random Max Processing Time Us (inputs:randomMaxProcessingTimeUs) | uint | Maximum number of micro-seconds to randomly (uniformely) wait for in order to simulate varying workload | 0 |
| Random Seed (inputs:randomSeed) | uint | Random seed for the randomization | 0 |
| Render Results (inputs:renderResults) | uint64 | OnDemand connection : pointer to render product results | 0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| renderProduct (inputs:rp) | uint64 | PostRender connection : pointer to render product for this view | 0 |
| Swh Frame Number (inputs:swhFrameNumber) | uint64 | Fabric frame number | 0 |
| Tag (inputs:tag) | token | A tag to identify the node | |
| Trace Error (inputs:traceError) | bool | If true print an error message when the frame numbers are out-of-sync | False |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec (outputs:exec) | execution | OnDemand connection : trigger | None |
| Fabric SWH Frame Number (outputs:fabricSWHFrameNumber) | uint64 | Fabric frame number from the fabric | None |
| Swh Frame Number (outputs:swhFrameNumber) | uint64 | Fabric frame number | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdTestStageSynchronization |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| Categories | graph:simulation,graph:postRender,graph:action,internal:test |
| Generated Class Name | OgnSdTestStageSynchronizationDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTextureToLinearArray.md | # Sd Texture To Linear Array
SyntheticData node to copy the input texture into a linear array buffer
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Cuda Mipmapped Array (`inputs:cudaMipmappedArray`) | `uint64` | Pointer to the CUDA Mipmapped Array | 0 |
| Format (`inputs:format`) | `uint64` | Format | 0 |
| Height (`inputs:height`) | `uint` | Height | 0 |
| Hydra Time (`inputs:hydraTime`) | `double` | Hydra time in stage | 0.0 |
| Mip Count (`inputs:mipCount`) | `uint` | Mip Count | 0 |
| Output Height (`inputs:outputHeight`) | `uint` | Output Height | 0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Output Height (inputs:outputHeight) | uint | Requested output height | 0 |
| Output Width (inputs:outputWidth) | uint | Requested output width | 0 |
| Sim Time (inputs:simTime) | double | Simulation time | 0.0 |
| Stream (inputs:stream) | uint64 | Pointer to the CUDA Stream | 0 |
| Width (inputs:width) | uint | Width | 0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Data (outputs:data) | float[4][] | Buffer array data | [] |
| Height (outputs:height) | uint | Buffer array height | None |
| Hydra Time (outputs:hydraTime) | double | Hydra time in stage | None |
| Sim Time (outputs:simTime) | double | Simulation time | None |
| Stream (outputs:stream) | uint64 | Pointer to the CUDA Stream | None |
| Width (outputs:width) | uint | Buffer array width | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdTextureToLinearArray |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
|-------------------------|-----|
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| Categories | internal |
| Generated Class Name | OgnSdTextureToLinearArrayDatabase |
| Python Module | omni.syntheticdata | |
OgnSdTimeChangeExecution.md | # Sd Time Change Execution
Set its execution output if the input rational time is more recent that the last registered time.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Error On Future Change (`inputs:errorOnFutureChange`) | bool | Print error if the last update is in the future. | False |
| Exec (`inputs:exec`) | execution | Trigger | None |
| Last Update Time Denominator (`inputs:lastUpdateTimeDenominator`) | uint64 | Time denominator of the last time change | 0 |
| Last Update Time Numerator (`inputs:lastUpdateTimeNumerator`) | int64 | Time numerator of the last time change | 0 |
| Render Results (`inputs:renderResults`) | uint64 | Render results | 0 |
## Outputs
## Exec (outputs:exec)
- **Type**: execution
- **Descripton**: Trigger
- **Default**: None
## Metadata
- **Name**: Unique ID
- **Value**: omni.syntheticdata.SdTimeChangeExecution
- **Name**: Version
- **Value**: 1
- **Name**: Extension
- **Value**: omni.syntheticdata
- **Name**: Has State?
- **Value**: False
- **Name**: Implementation Language
- **Value**: C++
- **Name**: Default Memory Type
- **Value**: cpu
- **Name**: Generated Code Exclusions
- **Value**: None
- **Name**: Categories
- **Value**: graph:postRender,graph:action
- **Name**: Generated Class Name
- **Value**: OgnSdTimeChangeExecutionDatabase
- **Name**: Python Module
- **Value**: omni.syntheticdata |
OgnSdUpdateSwhFrameNumber.md | # Sd Update Sw Frame Number
Synthetic Data node to return the current update swhFrameNumber
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Received (`outputs:exec`) | `execution` | Executes when the event is received | None |
| Swh Frame Number (`outputs:swhFrameNumber`) | `uint64` | Fabric frame number | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdUpdateSwFrameNumber |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
# Table
| Column 1 | Column 2 |
|----------------|---------------------------|
| Generated Code Exclusions | None |
| Categories | graph:simulation |
| Generated Class Name | OgnSdUpdateSwhFrameNumberDatabase |
| Python Module | omni.syntheticdata | |
OgnSelectIf.md | # Select If
Selects an output from the given inputs based on a boolean condition. If the condition is an array, and the inputs are arrays of equal length, and values will be selected from ifTrue, ifFalse depending on the bool at the same index. If one input is an array and the other is a scaler of the same base type, the scaler will be extended to the length of the other input.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Condition (`inputs:condition`) | `['bool', 'bool[]']` | The selection variable | None |
| If False (`inputs:ifFalse`) | `['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[]']` | | None |
'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][]',
'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][]'
```
Value if condition is False
None
If True (inputs:ifTrue)
```markdown
['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[]'
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | ['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][]'] | | |
## Metadata
### Name
- Unique ID: omni.graph.nodes.SelectIf
- Version: 1
- Extension: omni.graph.nodes
- Icon: ogn/icons/omni.graph.nodes.SelectIf.svg
| Has State? | False |
| --- | --- |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Select If |
| Categories | flowControl |
| Generated Class Name | OgnSelectIfDatabase |
| Python Module | omni.graph.nodes | |
OgnSelectTargetIf.md | # Select Target If
Selects a target from the given inputs based on a boolean condition. If condition is a scalar, result will either be “ifTrue” or “ifFalse”. If it is an array, select between each input element-wise (if arrays are the same length).
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Condition (`inputs:condition`) | `['bool', 'bool[]']` | The boolean condition used to select between “ifTrue” and “ifFalse”. If a scalar, result will either be “ifTrue” or “ifFalse”. If an array, select between each input element-wise (if arrays are the same length). | None |
| If False (`inputs:ifFalse`) | `target` | The targets if condition is “False”. | None |
| Metadata | | `allowMultiInputs` = 1 | |
| If True (`inputs:ifTrue`) | `target` | The targets if condition is “True”. | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table 1
## Headers
| Type | Descripton | Default |
## Body
| Result (outputs:result) | target | The selected targets from ifTrue and ifFalse | None |
# Metadata
## Headers
| Name | Value |
## Body
| Unique ID | omni.graph.nodes.SelectTargetIf |
| Version | 1 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.SelectTargetIf.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Select Target If |
| Categories | flowControl |
| Generated Class Name | OgnSelectTargetIfDatabase |
| Python Module | omni.graph.nodes | |
OgnSendCustomEvent.md | # Send Custom Event
Sends a custom event, which will asynchronously trigger any ‘On Custom Event’ nodes which are listening for the same ‘Event Name’.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle (`inputs:bundle`) | `bundle` | Bundle of data with information that is to be sent with the event. The payload for the event consists of a dictionary whose keys are the names of the attributes in this bundle and whose values are the values of the named attribute in Python pickled format. Optionally the value of the ‘Path’ attribute is also added to the payload. | None |
| Event Name (`inputs:eventName`) | `token` | The name of the custom event to be sent out. | |
| Exec In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Path (`inputs:path`) | `token` | The path associated with the event. If specified, the path is added to the payload for the event under the dictionary key ‘!path’. | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Metadata
## Metadata
### Name
### Value
#### Unique ID
omni.graph.action.SendCustomEvent
#### Version
2
#### Extension
omni.graph.action_nodes
#### Has State?
True
#### Implementation Language
Python
#### Default Memory Type
cpu
#### Generated Code Exclusions
None
#### uiName
Send Custom Event
#### Categories
graph:action,event
#### Generated Class Name
OgnSendCustomEventDatabase
#### Python Module
omni.graph.action_nodes |
OgnSendMessageBusEvent.md | # Send MessageBus Event
Pushes a named event to the Application Message Bus. The payload of the event is constructed from any dynamic input attributes that have been added to this node and consists of a dictionary whose key is the name of the attribute, with the ‘inputs:’ prefix stripped from it, with a value equal to the raw pointer to the attribute’s data in Fabric. If the attribute has a type that is not able to be converted to this form then a warning is posted for the node but the execution continues.
The event can be handled by any message bus listener, or with a corresponding OnMessageBusEvent node.
Data from dynamic input attributes will be copied into the event payload, with keys that match the attribute name. Here’s an example of handling the event in Python. In this example the sending node has an input “inputs:arg1”:
```python
import carb.events
import omni.kit.app
def on_event(event: carb.events.IEvent):
data = event.payload["arg1"]
print(f"got data = {data}")
msg = carb.events.type_from_string("my_event_name")
message_bus = omni.kit.app.get_app().get_message_bus_event_stream()
sub = message_bus.create_subscription_to_pop_by_type(msg, on_event)
```
## 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 to be sent. | |
| Metadata | | | |
# Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec In (outputs:execIn) | execution | Signal to the graph that this node is ready to be executed. | None |
# Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec Out (outputs:execOut) | execution | Signal to the graph that execution can continue downstream. | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.SendMessageBusEvent |
| Version | 1 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Send MessageBus Event |
| Categories | graph:action,event |
| Generated Class Name | OgnSendMessageBusEventDatabase |
| Python Module | omni.graph.action_nodes | |
OgnSequence.md | # Sequence
Activates one of two downstream graphs, alternating between the two. No consideration is made whether there is actually a graph downstream of either 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 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`outputs:a`) | `execution` | On odd-numbered executions, signal to the graph that execution can continue downstream. | None |
| B (`outputs:b`) | `execution` | On even-numbered executions, signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
```
| Unique ID | omni.graph.action.Sequence |
| --- | --- |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Icon | ogn/icons/omni.graph.action.Sequence.svg |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Sequence |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnSequenceDatabase |
| Python Module | omni.graph.action_nodes | |
OgnSetActiveViewportCamera.md | # Set Active Camera
Sets Viewport’s actively bound camera to given camera at give path
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|--------------|------------|--------------------------------------|---------|
| In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed. | None |
| Camera Path (inputs:primPath) | token | Path of the camera to bind | |
| Viewport (inputs:viewport) | token | Name of the viewport, or empty for the default viewport | |
## Outputs
| Name | Type | Descripton | Default |
|--------------|------------|--------------------------------------|---------|
| Out (outputs:execOut) | execution | Signal to the graph that execution can continue downstream. | None |
# Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.ui_nodes.SetActiveViewportCamera|
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Set Active Camera |
| Categories | sceneGraph:camera |
| Generated Class Name | OgnSetActiveViewportCameraDatabase |
| Python Module | omni.graph.ui_nodes | |
OgnSetCameraPosition.md | # Set Camera Position
Sets the camera’s position
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| In (inputs:execIn) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Position (inputs:position) | `pointd[3]` | The new position | [0.0, 0.0, 0.0] |
| 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 | |
| Rotate (inputs:rotate) | `bool` | True to keep position but change orientation and radius (camera moves to new position while still looking at the same target). False to keep orientation and radius but change position (camera moves to look at new target). | True |
| Use Path (inputs:usePath) | `bool` | | |
# Inputs
## Inputs
### Inputs
#### Inputs
##### Inputs
###### Inputs
####### Inputs
###### Inputs
##### Inputs
#### Inputs
### Inputs
## Inputs
# Inputs
## Outputs
### Outputs
#### Outputs
##### Outputs
###### Outputs
####### Outputs
###### Outputs
##### Outputs
#### Outputs
### Outputs
## Outputs
# Outputs
## Metadata
### Metadata
#### Metadata
##### Metadata
###### Metadata
####### Metadata
###### Metadata
##### Metadata
#### Metadata
### Metadata
## Metadata
# Metadata |
OgnSetCameraTarget.md | # Set Camera Target
Sets the camera’s target
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| In (inputs:execIn) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| 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 | |
| Rotate (inputs:rotate) | `bool` | True to keep position but change orientation and radius (camera rotates to look at new target). False to keep orientation and radius but change position (camera moves to look at new target). | True |
| Target (inputs:target) | `pointd[3]` | The target point | [0.0, 0.0, 0.0] |
| Use Path (inputs:usePath) | `bool` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| primPath | 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 |
| --- | --- | --- | --- |
| Out (outputs:execOut) | execution | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.SetCameraTarget |
| Version | 2 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Set Camera Target |
| Categories | sceneGraph:camera |
| Generated Class Name | OgnSetCameraTargetDatabase |
| Python Module | omni.graph.ui_nodes | |
OgnSetMatrix4Quaternion.md | # Set Rotation Quaternion (Legacy)
DEPRECATED - PLEASE USE SetMatrix4Rotation Sets the rotation of the given matrix4d value which represents a linear transformation. Does not modify the translation (row 3) of the matrix.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`inputs:matrix`) | `['matrixd[4]', 'matrixd[4][]']` | The matrix to be modified | None |
| Quaternion (`inputs:quaternion`) | `['quatd[4]', 'quatd[4][]']` | The quaternion the matrix will apply about the given rotationAxis. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`outputs:matrix`) | `['matrixd[4]', 'matrixd[4][]']` | The updated matrix | None |
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.SetMatrix4Quaternion |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Set Rotation Quaternion (Legacy) |
| Categories | math:operator |
| Generated Class Name | OgnSetMatrix4QuaternionDatabase |
| Python Module | omni.graph.nodes | |
OgnSetMatrix4Rotation.md | # Set Rotation
Sets the rotation of the given matrix4d value which represents a linear transformation. Does not modify the translation (row 3) of the matrix. Accepts an angle/axis combination, Euler angles, quaternions or rotation matrices
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Rotation Axis (`inputs:fixedRotationAxis`) | token | The axis of the given rotation | Y |
| Metadata | | `allowedTokens` = X,Y,Z,Custom | |
| Matrix (`inputs:matrix`) | ['matrixd[4]', 'matrixd[4][]'] | The matrix to be modified | None |
| Rotation (`inputs:rotationAngle`) | ['double', 'double[]', 'matrixd[3]', 'matrixd[3][]', 'quatd[4]', 'quatd[4][]', 'vectord[3]', 'vectord[3][]'] | The rotation to be applied to the matrix. This can be a angle about an axis, euler angles, quaternion or a rotation matrix. | None |
| Custom Rotation Axis (`inputs:rotationAxis`) | vectord[3] | | |
# Inputs
## Rotation Axis
### Fixed Rotation Axis
- **Type**: Boolean
- **Default**: False
### Custom Rotation Axis
- **Type**: Vector3
- **Default**: [0, 1, 0]
### Rotation Order
- **Type**: token
- **Default**: XYZ
- **Metadata**: allowedTokens = XYZ,XZY,YXZ,YZX,ZXY,ZYX
# Outputs
## Matrix
- **Name**: Matrix (outputs:matrix)
- **Type**: ['matrixd[4]', 'matrixd[4][]']
- **Descripton**: The updated matrix
- **Default**: None
# Metadata
## General
- **Name**: Unique ID
- **Value**: omni.graph.nodes.SetMatrix4Rotation
- **Name**: Version
- **Value**: 2
- **Name**: Extension
- **Value**: omni.graph.nodes
- **Name**: Has State?
- **Value**: False
- **Name**: Implementation Language
- **Value**: C++
- **Name**: Default Memory Type
- **Value**: cpu
- **Name**: Generated Code Exclusions
- **Value**: None
- **Name**: uiName
- **Value**: Set Rotation
- **Name**: Categories
- **Value**: math:operator
- **Name**: Generated Class Name
- **Value**: OgnSetMatrix4RotationDatabase
- **Name**: Python Module
- **Value**: omni.graph.nodes |
OgnSetMatrix4Scale.md | # Set Scale
[](#set-scale)
Sets the scale of the given matrix value which represents a linear transformation. Does not modify the orientation (row 0-2) of the matrix.
## Installation
[](#installation)
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
[](#inputs)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`inputs:matrix`) | `['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]']` | The matrix to be modified | None |
| Scale (`inputs:scale`) | `['vectord[3]', 'vectord[3][]']` | The scale that the matrix will apply | None |
## Outputs
[](#outputs)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`outputs:matrix`) | `['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]']` | The updated matrix | None |
## Metadata
[](#metadata)
## Name Value Table
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.SetMatrix4Scale |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Set Scale |
| Categories | math:operator |
| Generated Class Name | OgnSetMatrix4ScaleDatabase |
| Python Module | omni.graph.nodes | |
OgnSetMatrix4Translation.md | # Set Translation
Sets the translation of the given matrix value which represents a linear transformation. Does not modify the orientation (row 0-2) of the matrix.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`inputs:matrix`) | `['matrixd[4]', 'matrixd[4][]']` | The matrix to be modified | None |
| Translation (`inputs:translation`) | `['vectord[3]', 'vectord[3][]']` | The translation that the matrix will apply | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`outputs:matrix`) | `['matrixd[4]', 'matrixd[4][]']` | The updated matrix | None |
## Metadata
| Name | Descripton |
| --- | --- |
```
| Name | Value |
|---------|---------------------------|
| Unique ID | omni.graph.nodes.SetMatrix4Translation |
| Version | 1 |
| Extension| omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Set Translation |
| Categories | math:operator |
| Generated Class Name | OgnSetMatrix4TranslationDatabase |
| Python Module | omni.graph.nodes | |
OgnSetPrimActive.md | # Set Prim Active
Set whether a prim on the Stage is active (selected) or not. Only one prim can be connected to the ‘Prim’ input for execution. If multiple targets are present then a warning will be logged. The ‘Active’ input value will be the prim’s new active state. If the prim cannot be found then an error will be logged. Avoiding use of the deprecated ‘Prim Path’ input will ensure that error cannot be encountered.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Active (`inputs:active`) | `bool` | Whether to set the prim active or not | False |
| Exec In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Prim Path (`inputs:prim`) | `path` | The prim to be (de)activated | |
| Prim (`inputs:primTarget`) | `target` | The prim to be (de)activated | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.action.SetPrimActive |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Set Prim Active |
| Categories | graph:action,sceneGraph |
| Generated Class Name | OgnSetPrimActiveDatabase |
| Python Module | omni.graph.action_nodes | |
OgnSetTarget.md | # Set Target
Sets a target in a target 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 |
| --- | --- | --- | --- |
| Index (inputs:index) | int | The index into the array in range [-arrayLength, arrayLength). A negative value indexes from the end of the array. | 0 |
| Set Target (inputs:setTarget) | target | The target to set at the given index. | None |
| Targets (inputs:targets) | target | The input target array. | None |
| Metadata | | allowMultiInputs = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Targets (outputs:targets) | target | | None |
# Set Target
## Parameters
| Parameter | Description | Default Value |
|-----------|-------------|---------------|
| `target` | The target array. | `None` |
## Outputs
| Output | Description |
|--------|-------------|
| `target` | The modified target array. |
| `None` | None |
# Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.SetTarget |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Set Target |
| Categories | sceneGraph |
| Generated Class Name | OgnSetTargetDatabase |
| Python Module | omni.graph.nodes | |
OgnSetVariantSelection.md | # Set Variant Selection
Set the variant selection on a prim
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed. | None |
| Prim (inputs:prim) | target | The prim with the variantSet | None |
| Set Variant (inputs:setVariant) | bool | Sets the variant selection when finished rather than writing to the attribute values | False |
| Variant Name (inputs:variantName) | token | The variant name | |
| Variant Set Name (inputs:variantSetName) | token | The variantSet name | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table 1
## Headers
| Name | Type | Description | Default |
|------|------|-------------|---------|
## Body
| Exec Out (outputs:execOut) | `execution` | Signal to the graph that execution can continue downstream. | None |
# Metadata
## Headers
| Name | Value |
|------|-------|
## Body
| Unique ID | omni.graph.nodes.SetVariantSelection |
| Version | 2 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.SetVariantSelection.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Set Variant Selection |
| Categories | graph:action,sceneGraph,variants |
| Generated Class Name | OgnSetVariantSelectionDatabase |
| Python Module | omni.graph.nodes | |
OgnSetViewportFullscreen.md | # Set Viewport Fullscreen
Toggles fullscreen on/off for viewport(s) and visibility on/off for all other panes.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (inputs:exec) | execution | Signal to the graph that this node is ready to be executed. | None |
| Mode (inputs:mode) | token | The mode to toggle fullscreen on/off for viewport(s) and visibility on/off for all other panes: “Default” - Windowed viewport(s) with all other panes shown. “Fullscreen” - Fullscreen viewport(s) with all other panes hidden. “Hide UI” - Windowed viewport(s) with all other panes hidden. | Default |
| Metadata | | allowedTokens = Default,Fullscreen,Hide UI | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (outputs:exec) | execution | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
|------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.ui_nodes.SetViewportFullscreen |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Set Viewport Fullscreen |
| Categories | graph:action,viewport |
| Generated Class Name | OgnSetViewportFullscreenDatabase |
| Python Module | omni.graph.ui_nodes | |
OgnSetViewportMode.md | # Set Viewport Mode (BETA)
Sets the mode of a specified viewport window to ‘Scripted’ mode or ‘Default’ mode when executed.
‘Scripted’ mode disables default viewport interaction and enables placing UI elements over the viewport. ‘Default’ mode is the default state of the viewport, and entering it will destroy any UI elements on the viewport.
Executing with ‘Enable Viewport Mouse Events’ set to true in ‘Scripted’ mode is required to allow the specified viewport to be targeted by viewport mouse event nodes, including ‘On Viewport Dragged’ and ‘Read Viewport Drag State’.
Executing with ‘Enable Picking’ set to true in ‘Scripted’ mode is required to allow the specified viewport to be targeted by the ‘On Picked’ and ‘Read Pick State’ nodes.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Enable Picking (`inputs:enablePicking`) | `bool` | Enable/Disable picking prims in the specified viewport when in ‘Scripted’ mode | False |
| Enable Viewport Mouse Events (`inputs:enableViewportMouseEvents`) | `bool` | Enable/Disable viewport mouse events on the specified viewport when in ‘Scripted’ mode | False |
| Exec In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Mode (`inputs:mode`) | `int` | The mode to set the specified viewport to when this node is executed (0: ‘Default’, 1: ‘Scripted’) | 0 |
| Pass Clicks Thru (`inputs:passClicksThru`) | | | |
# Inputs
## AllowMouseClicksInScriptedMode
- **Type**: bool
- **Description**: Allow mouse clicks to affect the viewport while in ‘Scripted’ mode. In ‘Scripted’ mode mouse clicks are prevented from reaching the viewport to avoid accidentally selecting prims or interacting with the viewport’s own UI. Setting this attribute true will allow clicks to reach the viewport. This is in addition to interacting with the widgets created by UI nodes so if a button widget appears on top of some geometry in the viewport, clicking on the button will not only trigger the button but could also select the geometry. To avoid this, put the button inside a Stack widget and use a WriteWidgetProperty node to set the Stack’s ‘content_clipping’ property to 1.
- **Default**: False
## Viewport
- **Type**: token
- **Description**: Name of the viewport window to set the mode of
- **Default**: Viewport
# Outputs
## Default Mode
- **Type**: execution
- **Description**: When this node is successfully executed with ‘Mode’ set to ‘Default’, signal to the graph that execution can continue downstream on this path.
- **Default**: None
## Scripted Mode
- **Type**: execution
- **Description**: When this node is successfully executed with ‘Mode’ set to ‘Scripted’, signal to the graph that execution can continue downstream on this path.
- **Default**: None
## Widget Path
- **Type**: token
- **Description**: When the viewport enters ‘Scripted’ mode, a container widget is created under which other UI may be parented. This attribute provides the absolute path to that widget, which can be used as the ‘parentWidgetPath’ input to various UI nodes, such as Button. When the viewport exits ‘Scripted’ mode, the container widget and all the UI within it will be destroyed.
- **Default**: None
# Metadata
## Unique ID
- **Value**: omni.graph.ui_nodes.SetViewportMode
## Version
- **Value**: 1
## Extension
- **Value**: omni.graph.ui_nodes
## Has State?
- **Value**: False
## Implementation Language
- **Value**: Python
## Default Memory Type
- **Value**: cpu
## Generated Code Exclusions
- **Value**: tests
## uiName
- **Value**: Set Viewport Mode (BETA)
## Categories
- **Value**: graph:action,ui
## Generated Class Name
- **Value**: OgnSetViewportModeDatabase
## Python Module
- **Value**: omni.graph.ui_nodes |
OgnSetViewportRenderer.md | # Set Viewport Renderer
Sets renderer for the target viewport.
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (inputs:exec) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Renderer (inputs:renderer) | `token` | Renderer to be assigned to the target viewport | |
| Viewport (inputs:viewport) | `token` | Name of the viewport, or empty for the default viewport | Viewport |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (outputs:exec) | `execution` | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
|------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.ui_nodes.SetViewportRenderer |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Set Viewport Renderer |
| Categories | graph:action,viewport |
| Generated Class Name | OgnSetViewportRendererDatabase |
| Python Module | omni.graph.ui_nodes | |
OgnSetViewportResolution.md | # Set Viewport Resolution
Sets 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 |
| --- | --- | --- | --- |
| Exec (inputs:exec) | execution | Signal to the graph that this node is ready to be executed. | None |
| Resolution (inputs:resolution) | int[2] | The new resolution of the target viewport | [512, 512] |
| Viewport (inputs:viewport) | token | Name of the viewport, or empty for the default viewport | Viewport |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (outputs:exec) | execution | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
|-------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.ui_nodes.SetViewportResolution |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Set Viewport Resolution |
| Categories | graph:action,viewport |
| Generated Class Name | OgnSetViewportResolutionDatabase |
| Python Module | omni.graph.ui_nodes | |
OgnSimple.md | # Example Node: Simple Multiply
Minimal compute node example that reads two floats and outputs their product
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (inputs:multiplier) | float | Multiplier of value | 0.0 |
| Value (inputs:value) | float | Value to be multiplied | 0.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (outputs:value) | double | Result of the multiplication | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.Simple |
|------------------------|--------------------------------|
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Simple Multiply |
| Categories | examples |
| Generated Class Name | OgnSimpleDatabase |
| Python Module | omni.graph.examples.cpp | |
OgnSin.md | # Sine
## Sine
Compute the sine value of a scalar, array of scalars, vector, or array of vectors; in the latter three cases the sine function is applied to every single scalar element in the corresponding structures. All input scalar elements are assumed to be angles that are measured in degrees.
## 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[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]'] | | |
<span class="pre">'normalh[3]',</span>
<span class="pre">'normalh[3][]',</span>
<span class="pre">'pointd[3]',</span>
<span class="pre">'pointd[3][]',</span>
<span class="pre">'pointf[3]',</span>
<span class="pre">'pointf[3][]',</span>
<span class="pre">'pointh[3]',</span>
<span class="pre">'pointh[3][]',</span>
<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>
<span class="pre">'texcoordd[2]',</span>
<span class="pre">'texcoordd[2][]',</span>
<span class="pre">'texcoordd[3]',</span>
<span class="pre">'texcoordd[3][]',</span>
<span class="pre">'texcoordf[2]',</span>
<span class="pre">'texcoordf[2][]',</span>
<span class="pre">'texcoordf[3]',</span>
<span class="pre">'texcoordf[3][]',</span>
<span class="pre">'texcoordh[2]',</span>
<span class="pre">'texcoordh[2][]',</span>
<span class="pre">'texcoordh[3]',</span>
<span class="pre">'texcoordh[3][]',</span>
<span class="pre">'timecode',</span>
<span class="pre">'timecode[]',</span>
<span class="pre">'vectord[3]',</span>
<span class="pre">'vectord[3][]',</span>
<span class="pre">'vectorf[3]',</span>
<span class="pre">'vectorf[3][]',</span>
<span class="pre">'vectorh[3]',</span>
<span class="pre">'vectorh[3][]']</span>
</code>
</p>
</td>
</tr>
</tbody>
</table>
</section>
<section id="outputs">
<h2>Outputs</h2>
<table>
<colgroup>
<col style="width: 20%"/>
<col style="width: 20%"/>
<col style="width: 50%"/>
<col style="width: 10%"/>
</colgroup>
<thead>
<tr class="row-odd">
<th>Name</th>
<th>Type</th>
<th>Descripton</th>
<th>Default</th>
</tr>
</thead>
<tbody>
<tr class="row-even">
<td>Result (<em>outputs:value</em>)</td>
<td>
<code class="docutils literal notranslate">
<span class="pre">'colord[3]',</span>
<span class="pre">'colord[3][]',</span>
<span class="pre">'colord[4]',</span>
<span class="pre">'colord[4][]',</span>
<span class="pre">'colorf[3]',</span>
<span class="pre">'colorf[3][]',</span>
<span class="pre">'colorf[4]',</span>
<span class="pre">'colorf[4][]',</span>
<span class="pre">'colorh[3]',</span>
<span class="pre">'colorh[3][]',</span>
<span class="pre">'colorh[4]',</span>
<span class="pre">'colorh[4][]',</span>
<span class="pre">'double',</span>
<span class="pre">'double[2]',</span>
<span class="pre">'double[2][]',</span>
<span class="pre">'double[3]',</span>
<span class="pre">'double[3][]',</span>
<span class="pre">'double[4]',</span>
<span class="pre">'double[4][]',</span>
<span class="pre">'double[]',</span>
<span class="pre">'float',</span>
<span class="pre">'float[2]',</span>
<span class="pre">'float[2][]',</span>
<span class="pre">'float[3]',</span>
<span class="pre">'float[3][]',</span>
<span class="pre">'float[4]',</span>
<span class="pre">'float[4][]',</span>
<span class="pre">'float[]',</span>
<span class="pre">'half',</span>
<span class="pre">'half[2]',</span>
<span class="pre">'half[2][]',</span>
<span class="pre">'half[3]',</span>
<span class="pre">'half[3][]',</span>
<span class="pre">'half[4]',</span>
<span class="pre">'half[4][]',</span>
<span class="pre">'half[]',</span>
<span class="pre">'normald[3]',</span>
<span class="pre">'normald[3][]',</span>
<span class="pre">'normalf[3]',</span>
<span class="pre">'normalf[3][]',</span>
<span class="pre">'normalh[3]',</span>
<span class="pre">'normalh[3][]',</span>
<span class="pre">'pointd[3]',</span>
<span class="pre">'pointd[3][]',</span>
<span class="pre">'pointf[3]',</span>
<span class="pre">'pointf[3][]',</span>
<span class="pre">'pointh[3]',</span>
<span class="pre">'pointh[3][]',</span>
<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>
<span class="pre">'texcoordd[2]',</span>
<span class="pre">'texcoordd[2][]',</span>
<span class="pre">'texcoordd[3]',</span>
<span class="pre">'texcoordd[3][]',
</code>
</td>
<td>None</td>
</tr>
</tbody>
</table>
</section>
<section id="sine-operator">
<h2>Sine Operator</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>Output</p>
</th>
<th class="head">
<p>Description</p>
</th>
</tr>
</thead>
<tbody>
<tr class="row-even">
<td>
<p>
<code>'texcoordf[2]'</code>
<code>'texcoordf[2][]'</code>
<code>'texcoordf[3]'</code>
<code>'texcoordf[3][]'</code>
<code>'texcoordh[2]'</code>
<code>'texcoordh[2][]'</code>
<code>'texcoordh[3]'</code>
<code>'texcoordh[3][]'</code>
<code>'timecode'</code>
<code>'timecode[]'</code>
<code>'vectord[3]'</code>
<code>'vectord[3][]'</code>
<code>'vectorf[3]'</code>
<code>'vectorf[3][]'</code>
<code>'vectorh[3]'</code>
<code>'vectorh[3][]'</code>
</p>
</td>
<td>
<p>The original input “Value” with the sine operator applied to each scalar value, all of which will have values lying in the range [-1, 1]. The structure of the result, arrays and tuples, will mirror that of the input.</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.Sin</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>Sine</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>OgnSinDatabase</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>Python Module</p>
</td>
<td>
<p>omni.graph.nodes</p>
</td>
</tr>
</tbody>
</table>
</section> |
OgnSlider.md | # Slider (BETA)
Create a slider widget on the Viewport
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Create (`inputs:create`) | `execution` | Signal to the graph that this node is ready to create and show the widget. | None |
| Disable (`inputs:disable`) | `execution` | Signal to the graph that this node is ready to disable this button so that it cannot be pressed. | None |
| Enable (`inputs:enable`) | `execution` | Signal to the graph that this node is ready enable this button after it has been disabled. | None |
| Hide (`inputs:hide`) | `execution` | Signal to the graph that this node is ready to hide the widget and all its child widgets. | None |
| Max (`inputs:max`) | `float` | The maximum value of the slider | 0.0 |
| Min (`inputs:min`) | `float` | The minimum value of the slider | 0.0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Minimum Value of the Slider | | The minimum value of the slider | 0.0 |
| Parent Widget Path (inputs:parentWidgetPath) | token | The absolute path to the parent widget. If empty, this widget will be created as a direct child of Viewport. | None |
| Show (inputs:show) | execution | Signal to the graph that this node is ready to show the widget and all its child widgets after they become hidden. | None |
| Step (inputs:step) | float | The step size of the slider | 0.01 |
| Tear Down (inputs:tearDown) | execution | Signal to the graph that this node is ready to tear down the widget and all its child widgets. | None |
| Widget Identifier (inputs:widgetIdentifier) | token | An optional unique identifier for the widget. Can be used to refer to this widget in other places such as the OnWidgetClicked node. | None |
| Width (inputs:width) | double | The width of the created slider | 100.0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Created (outputs:created) | execution | When the widget is created, signal to the graph that execution can continue downstream. | None |
| Widget Path (outputs:widgetPath) | token | The absolute path to the created widget | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.ui_nodes.Slider |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| hidden | |
True
uiName | Slider (BETA)
---|---
Categories | internal:test
Generated Class Name | OgnSliderDatabase
Python Module | omni.graph.ui_nodes |
OgnSourceIndices.md | # Extract Source Index Array
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Source Starts In Target (`inputs:sourceStartsInTarget`) | `int[]` | List of index values encoding the increments for the output array values. | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Source Indices (`outputs:sourceIndices`) | `int[]` | Decoded list of index values as described by the node algorithm. | [] |
| Name | Value |
|---------------|--------------------------------|
| Unique ID | omni.graph.nodes.SourceIndices |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Extract Source Index Array |
| Categories | math:operator |
| Generated Class Name | OgnSourceIndicesDatabase |
| Python Module | omni.graph.nodes | |
OgnSpecializedBundleConsumer.md | # Example Node: Specialized Bundle Consumer
Minimal compute node example that consumes specialized bundle
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle (`inputs:bundle`) | `bundle` | Specialized bundle | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Diameter (`outputs:diameter`) | `float` | Diameter of specialized bundle | None |
| Type (`outputs:type`) | `token` | Type of specialized bundle | None |
## Metadata
| Name | Descripton |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.SpecializedBundleConsumer |
|------------------------------------|--------------------------------------------------|
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Specialized Bundle Consumer |
| Categories | examples |
| Generated Class Name | OgnSpecializedBundleConsumerDatabase |
| Python Module | omni.graph.examples.cpp | |
OgnSpecializedBundleProducer.md | # Example Node: Specialized Bundle Producer
Minimal compute node example that produces specialized bundle
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Diameter (inputs:diameter) | float | Diameter of produced specialized bundle | 0.0 |
| Product Type (inputs:productType) | token | Product type produced by this node | Circle |
| Metadata | | allowedTokens = Circle,Sphere | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle (outputs:bundle) | bundle | Produced output | None |
## Metadata
## Table
| Name | Value |
|--------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.examples.cpp.SpecializedBundleProducer |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Specialized Bundle Producer |
| Categories | examples |
| Generated Class Name | OgnSpecializedBundleProducerDatabase |
| Python Module | omni.graph.examples.cpp | |
OgnSplitString.md | # Split String
Returns a list of elements from a string based on 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 string to use as a delimiter to split the string. | None |
| String (`inputs:string`) | string | The input string. | None |
## Outputs
| Name | Type | Descripton | Default |
|------------|----------|---------------------|---------|
| Elements (`outputs:elements`) | token[] | The string elements. | None |
## Metadata
| Name | Value |
|-------------|-------------------------------|
| Unique ID | omni.graph.nodes.SplitString |
| Version | 1 |
| --- | --- |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Split String |
| Categories | function |
| Generated Class Name | OgnSplitStringDatabase |
| Python Module | omni.graph.nodes | |
OgnStartsWith.md | # Starts With
Determines if a string starts with a given string value
## Installation
To use this node enable [omni.graph.nodes](#ext-omni-graph-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------|---------|------------------|---------|
| Prefix (inputs:prefix) | string | The prefix to test | |
| Value (inputs:value) | string | The string to check | |
## Outputs
| Name | Type | Descripton | Default |
|---------------|-------|-------------------------------------|---------|
| Is Prefix (outputs:isPrefix) | bool | True if ‘value’ starts with ‘prefix’ | None |
## Metadata
| Name | Value |
|------------|----------------------|
| Unique ID | omni.graph.nodes.StartsWith |
| Version | 1 |
|----------|---|
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Starts With |
| Categories | function |
| Generated Class Name | OgnStartsWithDatabase |
| Python Module | omni.graph.nodes | |
OgnStopAllSound.md | # Stop All Sound
Stop playing all sounds
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.StopAllSound |
| Version | 1 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.StopAllSound.svg |
|------|------------------------------------------|
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Stop All Sound |
| Categories | sound |
| Generated Class Name | OgnStopAllSoundDatabase |
| Python Module | omni.graph.nodes | |
OgnStopSound.md | # Stop Sound
Stop playing a sound primitive
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Sound Id (`inputs:soundId`) | `uint64` | The sound identifier | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | |
| 属性 | 值 |
|------------------------|------------|
| Node Type | omni.graph.nodes.StopSound |
| Version | 1 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.StopSound.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Stop Sound |
| Categories | sound |
| Generated Class Name | OgnStopSoundDatabase |
| Python Module | omni.graph.nodes | |
OgnSubtract.md | # Subtract
Subtract two or more values of any numeric type (element-wise). 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:
- tuple - scalar = resultTuple (where resultTuple is formed by subtracting scalar from each element in tuple).
- arrayOfTuples - tuple = resultArrayOfTuples (where resultArrayOfTuples is formed by subtracting each element in tuple from each corresponding element of each tuple in arrayOfTuples).
- arrayOfTuples - scalar = resultArrayOfTuples (where resultArrayOfTuples is formed by subtracting scalar from each element of every tuple in arrayOfTuples).
To add/remove subtrahends 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[]',
'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 initial value from which “B” is subtracted from.
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[]']
```python
'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 value which is subtracted from the input “A”.
None
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Difference (outputs:difference) | ['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'] | | | None |
### Input Types
```python
'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 difference of the input numerical values (with preserved typing).
### Return Value
None
## Metadata
### Name
Value
---
Unique ID | omni.graph.nodes.Subtract
Version | 2
Extension | omni.graph.nodes
Has State? | False
Implementation Language | C++
Default Memory Type | cpu
Generated Code Exclusions | None
uiName | Subtract
Categories | math:operator
Generated Class Name | OgnSubtractDatabase
Python Module |
```
请注意，由于HTML中的链接和图片已被删除，因此Markdown中的相应部分也已被删除。此外，Markdown中的代码块使用三个反引号
omni.graph.nodes |
OgnSubtractDouble.md | # Subtract Double (Python)
Example node that subtracts 2 doubles from each other
## 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 | |
| 属性 | 值 |
| --- | --- |
| omni.graph.examples.python.SubtractDouble | |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Subtract Double (Python) |
| Categories | examples |
| Generated Class Name | OgnSubtractDoubleDatabase |
| Python Module | omni.graph.examples.python | |
OgnSwitchToken.md | # Switch On Token
Selectively activates a downstream graph based on the ‘Value’ name and dynamic attributes. There will be both input and output dynamic attributes for proper functioning of this node. The input attributes will be named ‘inputs:branchX’, where ‘X’ is any string, typically just a number.
These input attributes must be a ‘token’ type, where the value of the token will be compared against the ‘Value’ input. When the strings match, a corresponding output attribute named ‘outputs:outputX’ will be checked. If it exists and is of type ‘execution’ then it will be activated to signal that its downstream graph is ready to be executed. If no matches are found then the node will complete execution without activating any outputs.
For example if ‘Value’ is set to ‘A’, and the dynamic attribute ‘inputs:branch0’ is set to the value ‘A’ then when this node executes it will active the graph downstream of the dynamic attribute ‘outputs:output0’. If multiple branch input attributes contain the same matching value only one of their corresponding outputs will be activated. There is no guarantee as to which of those outputs will be chosen so this situation should be avoided.
## 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 |
| Value (`inputs:value`) | `token` | The value to check for in the dynamic input branch attributes. | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.SwitchToken |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| --- | --- |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Switch On Token |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnSwitchTokenDatabase |
| Python Module | omni.graph.action_nodes | |
OgnSyncGate.md | # Sync Gate
Activate the downstream graphs after all of the input signals have been triggered with the same synchronization value. An internal count is maintained that resets whenever a new synchronization value is encountered. If the count reaches a number equal to the number of ‘Execute In’ inputs then the ‘Execute Out’ activation signals to the downstream graph that it is ready to be executed.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Sync (`inputs:syncValue`) | `uint64` | Value against which each of the input signals are checked for synchronization. | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
| Sync (`outputs:syncValue`) | `uint64` | Value against which each of the input signals are checked for synchronization. | 0 |
# Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.action.SyncGate |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Sync Gate |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnSyncGateDatabase |
| Python Module | omni.graph.action_nodes | |
OgnTan.md | # Tangent
## 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[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]']` | | |
'normalh[3]',
'normalh[3][]',
'pointd[3]',
'pointd[3][]',
'pointf[3]',
'pointf[3][]',
'pointh[3]',
'pointh[3][]',
'quatd[4]',
'quatd[4][]',
'quatf[4]',
'quatf[4][]',
'quath[4]',
'quath[4][]',
'texcoordd[2]',
'texcoordd[2][]',
'texcoordd[3]',
'texcoordd[3][]',
'texcoordf[2]',
'texcoordf[2][]',
'texcoordf[3]',
'texcoordf[3][]',
'texcoordh[2]',
'texcoordh[2][]',
'texcoordh[3]',
'texcoordh[3][]',
'timecode',
'timecode[]',
'vectord[3]',
'vectord[3][]',
'vectorf[3]',
'vectorf[3][]',
'vectorh[3]',
'vectorh[3][]'
```
The value(s) for which the trigonometric tangent is to be computed. Each scalar element of the value is an angle, measured in degrees.
None
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (outputs: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[]', '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][]'] | | |
# Table of Contents
- [Tan Operator](#tan-operator)
- [Metadata](#metadata)
## Tan Operator
<table>
<tbody>
<tr>
<td>
<p>
Output Types
</p>
</td>
<td>
<p>
<code>
'texcoordd[2]',
</code>
<code>
'texcoordd[2][]',
</code>
<code>
'texcoordd[3]',
</code>
<code>
'texcoordd[3][]',
</code>
<code>
'texcoordf[2]',
</code>
<code>
'texcoordf[2][]',
</code>
<code>
'texcoordf[3]',
</code>
<code>
'texcoordf[3][]',
</code>
<code>
'texcoordh[2]',
</code>
<code>
'texcoordh[2][]',
</code>
<code>
'texcoordh[3]',
</code>
<code>
'texcoordh[3][]',
</code>
<code>
'timecode',
</code>
<code>
'timecode[]',
</code>
<code>
'vectord[3]',
</code>
<code>
'vectord[3][]',
</code>
<code>
'vectorf[3]',
</code>
<code>
'vectorf[3][]',
</code>
<code>
'vectorh[3]',
</code>
<code>
'vectorh[3][]'
</code>
</p>
</td>
<td>
<p>
The original input “Value” with the trigonometric tangent operator applied to each scalar value, all of which will have values lying in the range [-1, 1]. The structure of the result, arrays and tuples, will mirror that of the input.
</p>
</td>
<td>
<p>
None
</p>
</td>
</tr>
</tbody>
</table>
## Metadata
<table>
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
</colgroup>
<thead>
<tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Value
</p>
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<p>
Unique ID
</p>
</td>
<td>
<p>
omni.graph.nodes.Tan
</p>
</td>
</tr>
<tr>
<td>
<p>
Version
</p>
</td>
<td>
<p>
1
</p>
</td>
</tr>
<tr>
<td>
<p>
Extension
</p>
</td>
<td>
<p>
omni.graph.nodes
</p>
</td>
</tr>
<tr>
<td>
<p>
Has State?
</p>
</td>
<td>
<p>
False
</p>
</td>
</tr>
<tr>
<td>
<p>
Implementation Language
</p>
</td>
<td>
<p>
C++
</p>
</td>
</tr>
<tr>
<td>
<p>
Default Memory Type
</p>
</td>
<td>
<p>
cpu
</p>
</td>
</tr>
<tr>
<td>
<p>
Generated Code Exclusions
</p>
</td>
<td>
<p>
None
</p>
</td>
</tr>
<tr>
<td>
<p>
uiName
</p>
</td>
<td>
<p>
Tangent
</p>
</td>
</tr>
<tr>
<td>
<p>
Categories
</p>
</td>
<td>
<p>
math:operator
</p>
</td>
</tr>
<tr>
<td>
<p>
Generated Class Name
</p>
</td>
<td>
<p>
OgnTanDatabase
</p>
</td>
</tr>
<tr>
<td>
<p>
Python Module
</p>
</td>
<td>
<p>
omni.graph.nodes
</p>
</td>
</tr>
</tbody>
</table> |
OgnTemplateNodeCpp.md | # C++ Template Node
Template Node to use that shows the basic requirements of an OmniGraph C++ node. For the sake of illustration it multiplies a float value by the number returned from the IOmniGraphTemplateMixed::getMultiplier() function, which is 2.0 for testing purposes
## Installation
To use this node enable `omni.graph.template.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|--------|------------|---------|
| Value (inputs:value) | float | Value | 0.0 |
## Outputs
| Name | Type | Descripton | Default |
|------|--------|------------|---------|
| Value (outputs:value) | float | Value | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.template.cpp.TemplateNodeCpp |
| Version | 1 |
| Extension | |
omni.graph.template.cpp
Has State?
False
Implementation Language
C++
Default Memory Type
cpu
Generated Code Exclusions
python
uiName
C++ Template Node
Categories
examples
Generated Class Name
OgnTemplateNodeCppDatabase
Python Module
omni.graph.template.cpp |
OgnTemplateNodeMixedCpp.md | # C++ Template Node
Template Node to use that shows the basic requirements of an OmniGraph C++ node. For the sake of illustration it multiplies a float value by 2.0.
## Installation
To use this node enable `omni.graph.template.mixed` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `float` | Value | 0.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`outputs:value`) | `float` | Value | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.template.mixed.TemplateNodeCpp |
| Version | 1 |
| Extension | omni.graph.template.mixed |
|-----------|---------------------------|
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | C++ Template Node |
| Categories | examples |
| Generated Class Name | OgnTemplateNodeMixedCppDatabase |
| Python Module | omni.graph.template.mixed | |
OgnTemplateNodePy.md | # Python Template Node
[](https://example.com/permalink-icon.png)
Template Node to use that shows the basic requirements of an OmniGraph Python node. For the sake of illustration it multiplies a float value by two.
## Installation
[](https://example.com/permalink-icon.png)
To use this node enable `omni.graph.template.python` in the Extension Manager.
## Inputs
[](https://example.com/permalink-icon.png)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `float` | Value | 0.0 |
## Outputs
[](https://example.com/permalink-icon.png)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`outputs:value`) | `float` | Value | None |
## Metadata
[](https://example.com/permalink-icon.png)
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.template.python.TemplateNode |
| Version | 1 |
| Extension | omni.graph.template.python |
| Has State? | False |
| --- | --- |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Python Template Node |
| Categories | examples |
| Generated Class Name | OgnTemplateNodePyDatabase |
| Python Module | omni.graph.template.python | |
OgnTestInitNode.md | # TestInitNode
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Shared (`inputs:shared`) | `bool` | Whether to read the shared state or the per instance state | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`outputs:value`) | `float` | Value | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.python.TestInitNode |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
|-------------|-------|
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | TestInitNode |
| Categories | examples |
| Generated Class Name | OgnTestInitNodeDatabase |
| Python Module | omni.graph.examples.python | |
OgnTestSingleton.md | # Test Singleton
Example node that showcases the use of singleton nodes (nodes that can have only 1 instance)
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Out (outputs:out) | `double` | The unique output of the only instance of this node | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.python.TestSingleton |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| singleton | 1 |
| uiName | Test Singleton |
| Categories | examples |
| Generated Class Name | OgnTestSingletonDatabase |
|----------------------|---------------------------|
| Python Module | omni.graph.examples.python | |
OgnTimelineGet.md | # Get main timeline
Get the main timeline properties
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| End Frame (`outputs:endFrame`) | `double` | The end frame of the main timeline’s play range. | None |
| End Time (`outputs:endTime`) | `double` | The end time (in seconds) of the main timeline’s play range. | None |
| Current Frame (`outputs:frame`) | `double` | The current frame number of the main timeline’s playhead. | None |
| Frames Per Second (`outputs:framesPerSecond`) | `double` | The number of frames per second of the main timeline. | None |
| Is Looping (`outputs:isLooping`) | `bool` | Is the main timeline currently looping? | None |
| Is Playing (`outputs:isPlaying`) | `bool` | | None |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.GetTimeline |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Get main timeline |
| Categories | time |
| Generated Class Name | OgnTimelineGetDatabase |
| Python Module | omni.graph.nodes | |
OgnTimelineLoop.md | # Set playback looping
Controls looping playback of the main timeline
## 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 |
| Loop (inputs:loop) | `bool` | Enable or disable playback looping? | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute Out (outputs:execOut) | `execution` | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.LoopTimeline |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Set playback looping |
| Categories | time |
| Generated Class Name | OgnTimelineLoopDatabase |
| Python Module | omni.graph.nodes | |
OgnTimelineSet.md | # Set main timeline
Set properties of the main timeline
## 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 |
| Property Name (inputs:propName) | token | The name of the property to set. | Frame |
| Metadata | | displayGroup = parameters | |
| Metadata | | literalOnly = 1 | |
| Metadata | | allowedTokens = Frame,Time,StartFrame,StartTime,EndFrame,EndTime,FramesPerSecond | |
| Property Value (inputs:propValue) | double | The value of the property to set. | 0.0 |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|---------------|-------------------------------------|---------|
# Metadata
## Metadata
### Name
### Value
#### Unique ID
omni.graph.nodes.SetTimeline
#### Version
1
#### Extension
omni.graph.nodes
#### Has State?
False
#### Implementation Language
C++
#### Default Memory Type
cpu
#### Generated Code Exclusions
None
#### uiName
Set main timeline
#### Categories
time
#### Generated Class Name
OgnTimelineSetDatabase
#### Python Module
omni.graph.nodes |
OgnTimelineStart.md | # Start playback
Starts playback of the main timeline at the current frame
## 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 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute Out (outputs:execOut) | `execution` | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.StartTimeline |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| --- | --- |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Start playback |
| Categories | time |
| Generated Class Name | OgnTimelineStartDatabase |
| Python Module | omni.graph.nodes | |
OgnTimelineStop.md | # Stop playback
Stops playback of the main timeline at the current frame
## 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 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.StopTimeline |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
|-------------|-------|
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Stop playback |
| Categories | time |
| Generated Class Name | OgnTimelineStopDatabase |
| Python Module | omni.graph.nodes | |
OgnTimer.md | # Timer
Timer Node is a node that lets you create animation curve(s), plays back and samples the value(s) along its time to output values.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Duration (`inputs:duration`) | `double` | Number of seconds to play interpolation. | 1.0 |
| End Value (`inputs:endValue`) | `double` | Value of the end of the duration. | 1.0 |
| Play (`inputs:play`) | `execution` | Signal to the graph that this node is ready for execution. When the node executes with this signal active it plays the clip from the current frame. | None |
| Start Value (`inputs:startValue`) | `double` | Value of the start of the duration. | 0.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Finished (`outputs:finished`) | `execution` | Signal that the timer has finished its duration. | None |
# Timer Node
## Outputs
### Finished
- **Code**: `execution`
- **Description**: When the node has finished the playback, signal to the graph that execution can continue downstream on this path.
- **Value**: None
### Updated
- **Code**: `execution`
- **Description**: When the node is executed, and output value(s) resampled and updated, signal to the graph that execution can continue downstream on this path.
- **Value**: None
### Value
- **Code**: `double`
- **Description**: Progress of the Timer node, between 0.0 and 1.0.
- **Value**: 0.0
## Metadata
| Name | Value |
|---------------|---------------------------------|
| Unique ID | omni.graph.nodes.Timer |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Timer |
| Categories | animation |
| __categoryDescriptions | animation,Nodes dealing with Animation |
| Generated Class Name | OgnTimerDatabase |
| Python Module | omni.graph.nodes | |
OgnTimestepSelector.md | # Timestep selector
Selects a timestep from time input
## Installation
To use this node enable `omni.index.compute` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| FPS (`inputs:fps`) | `double` | FPS | 1.0 |
| Time (`inputs:time`) | `double` | Time | -1.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Timestep (`outputs:timestep`) | `int` | Timestep | -1 |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.index.compute.timestepSelector |
| --- | --- |
| Version | 1 |
| Extension | omni.index.compute |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Timestep selector |
| Generated Class Name | OgnTimestepSelectorDatabase |
| Python Module | omni.index.compute | |
OgnToBool.md | # To Bool
## To Bool
Convert the numeric input to a boolean value. Scalar inputs will output a single boolean value, and array inputs will output an equivalently-sized array of booleans. Non-zero values convert to a boolean value of true, and zero values convert to a boolean value of false.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `['bool', 'bool[]', 'double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int64', 'int64[]', 'int[]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]']` | The input value to convert to boolean. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bool (`outputs:converted`) | `['bool', 'bool[]']` | The converted boolean value or array of boolean values. | None |
## Metadata
| Name | Value |
|------------|------------------------------|
| Unique ID | omni.graph.nodes.ToBool |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To Bool |
| Categories | math:conversion |
| Generated Class Name | OgnToBoolDatabase |
| Python Module | omni.graph.nodes | |
OgnToDeg.md | # To Degrees
Convert radian input into degrees
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------|----------------------------------------------------------------------|----------------------------------------------------------------------------|---------|
| Radians | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]',` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Radians (**inputs:radians**) | `float` | Angle value in radians to be converted | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Degrees (**outputs:degrees**) | `float` | Angle value in degrees | None |
<section id="to-degrees">
<h2>To Degrees</h2>
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 20%"/>
<col style="width: 20%"/>
<col style="width: 60%"/>
</colgroup>
<thead>
<tr class="row-odd">
<th class="head">
<p>Input</p>
</th>
<th class="head">
<p>Type</p>
</th>
<th class="head">
<p>Description</p>
</th>
</tr>
</thead>
<tbody>
<tr class="row-even">
<td>
<p>'texcoordf[3][]'</p>
</td>
<td>
<p>float3</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>'texcoordh[2]'</p>
</td>
<td>
<p>half2</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>'texcoordh[2][]'</p>
</td>
<td>
<p>half2</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>'texcoordh[3]'</p>
</td>
<td>
<p>half3</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>'texcoordh[3][]'</p>
</td>
<td>
<p>half3</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>'timecode'</p>
</td>
<td>
<p>Timecode</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>'timecode[]'</p>
</td>
<td>
<p>Timecode</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>'vectord[3]'</p>
</td>
<td>
<p>double3</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>'vectord[3][]'</p>
</td>
<td>
<p>double3</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>'vectorf[3]'</p>
</td>
<td>
<p>float3</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>'vectorf[3][]'</p>
</td>
<td>
<p>float3</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>'vectorh[3]'</p>
</td>
<td>
<p>half3</p>
</td>
<td>
<p>None</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>'vectorh[3][]'</p>
</td>
<td>
<p>half3</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.ToDeg</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>To Degrees</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>Categories</p>
</td>
<td>
<p>math:conversion</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>Generated Class Name</p>
</td>
<td>
<p>OgnToDegDatabase</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>Python Module</p>
</td>
<td>
<p>omni.graph.nodes</p>
</td>
</tr>
</tbody>
</table>
</section> |
OgnToDouble.md | # To Double
## To Double
Convert the given input to 64-bit floating-point. Array and tuple inputs are converted element-wise to arrays and tuples of the same shape.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| role (inputs:role) | token | The attribute role to apply to the output type. If the role is not supported by the output shape, a role of None is used. | None |
| Metadata | | literalOnly = 1 | |
| Metadata | | allowedTokens = None,Color,Frame,Matrix,Normal,Point,Quaternion,TexCoord,Timecode,Vector | |
| Value (inputs:value) | ['bool', 'bool[]', 'colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'int', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrix4d', 'matrix4d[]', 'matrix4f', 'matrix4f[]', 'quaterniond', 'quaterniond[]', 'quaternionf', 'quaternionf[]', 'string', 'string[]', 'timecode', 'timecode[]', 'vector2d', 'vector2d[]', 'vector2f', 'vector2f[]', 'vector3d', 'vector3d[]', 'vector3f', 'vector3f[]', 'vector4d', 'vector4d[]', 'vector4f', 'vector4f[]'] | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Value | `['float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The numeric or boolean value to convert. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Double (outputs:converted) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'frame[4]', 'frame[4][]']` | | None |
# ToDouble Node
## Inputs
| Name | Type | Description |
| --- | --- | --- |
| Value | `[{'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'pointd[3]', 'pointd[3][]', 'quatd[4]', 'quatd[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'timecode', 'timecode[]', 'vectord[3]', 'vectord[3][]']}` | The value converted to double form with the role applied. |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ToDouble |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To Double |
| Categories | math:conversion |
| Generated Class Name | OgnToDoubleDatabase |
| Python Module | omni.graph.nodes | |
OgnToFloat.md | # To Float
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Description | Default |
|------------|------------|-----------------------------------------------------------------------------|---------|
| role | token | The attribute role to apply to the output type. If the role is not supported by the output shape, a role of None is used. | None |
| Value | ['bool', 'bool[]', 'colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]'] | |
## Inputs
- **Value** (various types): The numeric or boolean value to convert.
- **None**
## Outputs
### Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Float (outputs:converted) | ['colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'normalf[3]', 'normalf[3][]', 'pointf[3]', 'pointf[3][]', 'quatf[4]', 'quatf[4][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'vectorf[3]', 'vectorf[3][]'] | | None |
# Metadata
| Name | Value |
|------------|---------------------------|
| Unique ID | omni.graph.nodes.ToFloat |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To Float |
| Categories | math:conversion |
| Generated Class Name | OgnToFloatDatabase |
| Python Module | omni.graph.nodes | |
OgnToHalf.md | # To Half
Convert the given input to 16-bit floating-point. Array and tuple inputs are converted element-wise to arrays and tuples of the same shape.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| role (inputs:role) | token | The attribute role to apply to the output type. If the role is not supported by the output shape, a role of None is used. | None |
| Metadata | | literalOnly = 1 | |
| Metadata | | allowedTokens = None,Color,Frame,Normal,Point,Quaternion,TexCoord,Timecode,Vector | |
| Value (inputs:value) | ['bool', 'bool[]', 'colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', ...] | | |
## Inputs
- `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[]`
- `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
- **Name**: Half (outputs:converted)
- **Type**:
- `colorh[3]`
- `colorh[3][]`
- `colorh[4]`
- `colorh[4][]`
- `half`
- `half[2]`
- `half[2][]`
- `half[3]`
- `half[3][]`
- `half[4]`
- `half[4][]`
- `half[]`
- `normalh[3]`
- `normalh[3][]`
- `pointh[3]`
- `pointh[3][]`
- `quath[4]`
- `quath[4][]`
- `texcoordh[2]`
- `texcoordh[2][]`
- `texcoordh[3]`
- `texcoordh[3][]`
- `vectorh[3]`
- `vectorh[3][]`
- **Descripton**: None
- **Default**: None
# Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.ToHalf |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To Half |
| Categories | math:conversion |
| Generated Class Name | OgnToHalfDatabase |
| Python Module | omni.graph.nodes | |
OgnToInt.md | # To Int
## To Int
Convert the given input to signed 32-bit integer. Array and tuple inputs are converted element-wise to arrays and tuples of the same shape. Conversion of floating-point values is performed by truncation towards zero.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | ['bool', 'bool[]', 'colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', '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[]'] | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Value | ['int', 'int[2]', '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 numeric or boolean value to convert. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Int (outputs:converted) | ['int', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]'] | The value converted to 32-bit integer form. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ToInt |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To Int |
| Categories | math:conversion |
|------------|-----------------|
| Generated Class Name | OgnToIntDatabase |
| Python Module | omni.graph.nodes | |
OgnToInt64.md | # To Int64
Convert the given input to signed 64-bit integer. Array and tuple inputs are converted element-wise to arrays and tuples of the same shape. Conversion of floating-point values is performed by truncation towards zero.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `['bool', 'bool[]', 'double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int64', 'int64[]', 'int[]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]']` | The numeric or boolean value to convert. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Int64 (`outputs:converted`) | `['int64', 'int64[]']` | The value converted to 64-bit integer form. | None |
# Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.ToInt64 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To Int64 |
| Categories | math:conversion |
| Generated Class Name | OgnToInt64Database |
| Python Module | omni.graph.nodes | |
OgnToRad.md | # To Radians
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Degrees (`inputs:degrees`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]',` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Angle value in degrees (inputs:angle) | `['double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | Angle value in degrees to be converted | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Radians (outputs:radians) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | Angle value in degrees to be converted | None |
<section id="to-rad">
<h2>To Rad</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>angle</p>
</td>
<td>
<p>Angle value in degrees</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>radians</p>
</td>
<td>
<p>Angle value in radians</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.ToRad</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>To Radians</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>Categories</p>
</td>
<td>
<p>math:conversion</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>Generated Class Name</p>
</td>
<td>
<p>OgnToRadDatabase</p>
</td>
</tr>
<tr class="row-even">
<td>
<p>Python Module</p>
</td>
<td>
<p>omni.graph.nodes</p>
</td>
</tr>
</tbody>
</table>
</section> |
OgnToString.md | # To String
Converts the input to a string representation. Array inputs are converted to a single output string.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `['bool', 'bool[]', 'colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', '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']` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Value | `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 value to be converted to a string. Very large or very small numeric values may be converted to use an exponential representation of the value (e.g. 1.234e+06). Arrays of numeric values are converted using a list syntax (e.g. “[1.5, -0.03]”). A uchar value converts to a string of a single unquoted character. An array of uchar values converts to an unquoted string. Zero values (i.e. null characters) in the array may result in undefined behavior and should be avoided. A token is converted to its unquoted string representation. An array of tokens are converted to Python list syntax with each token enclosed in double quotes (e.g. [“first”, “second”]). | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| String (outputs:converted) | `string` | The input value represented as a string. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ToString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | No |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To String |
| Categories | function |
| Generated Class Name | OgnToStringDatabase |
| Python Module | omni.graph.nodes | |
OgnToTarget.md | # To Target
## To Target
Creates a target object using the input value as references in the scenegraph. Target objects in OmniGraph are represented by USD Relationships. See [USD Glossary - Relationship](https://openusd.org/release/glossary.html#usdglossary-relationship) for more information.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `['path', 'string', 'token', 'token[]']` | The value or values to add as scenegraph references in the output target object. If the input is an empty string, no references are added to the target object. If the input is not a valid scenegraph path, an empty path is added to the target object. If the input is a token[], each element is added to the target object as an scenegraph reference. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Target (`outputs:converted`) | `target` | A target output containing the input value as scenegraph references. | None |
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
```
# Table 1
## Headers
| Type | Descripton | Default |
|------|------------|---------|
## Body
| Value (state:value) | Code Block | Description | Default |
|----------------------|------------|-------------|---------|
| Value (state:value) | `['path', 'string', 'token', 'token[]']` | A cached value of the input used to determine if the output target needs to be updated. | None |
# Metadata
## Headers
| Name | Value |
|------|-------|
## Body
| Unique ID | omni.graph.nodes.ToTarget |
|-----------|---------------------------|
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To Target |
| Categories | sceneGraph |
| Generated Class Name | OgnToTargetDatabase |
| Python Module | omni.graph.nodes | |
OgnToToken.md | # To Token
Converts the input to a string representation stored as a token. Array inputs are converted to a single output string.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `['bool', 'bool[]', 'colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', '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']` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Value | `string` | The value to be converted to a string. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Token (outputs:converted) | `token` | The input value represented as a string token. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ToToken |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
|--------------------------|-----|
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To Token |
| Categories | function |
| Generated Class Name | OgnToTokenDatabase |
| Python Module | omni.graph.nodes | |
OgnToUchar.md | # To UChar
Converts the input to 8-bit unsigned integer. Array inputs are converted element-wise to arrays of the same shape. Conversion of floating-point values is performed by truncation towards zero. Conversion of negative values is performed by subtracting the converted positive value from 256.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `['bool', 'bool[]', 'double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int64', 'int64[]', 'int[]', 'string', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]']` | The numeric or boolean value to convert. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| UChar (`outputs:converted`) | `['uchar', 'uchar[]']` | | |
# Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.ToUchar |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To UChar |
| Categories | math:conversion |
| Generated Class Name | OgnToUcharDatabase |
| Python Module | omni.graph.nodes | |
OgnToUint.md | # To UInt
Converts the input to 32-bit unsigned integer. Array inputs are converted element-wise to arrays of the same shape. Conversion of floating-point values is performed by truncation towards zero. Conversion of negative values is performed by subtracting the converted positive value from the value 2e32.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `['bool', 'bool[]', 'double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'int', 'int64', 'int64[]', 'int[]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]']` | The numeric or boolean value to convert. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| UInt (`outputs:converted`) | `['uint', 'uint[]']` | The value converted to 32-bit unsigned integer form. |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.ToUint |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | To UInt |
| Categories | math:conversion |
| Generated Class Name | OgnToUintDatabase |
| Python Module | omni.graph.nodes | |
OgnTransformBundle.md | # Transform Bundle
Applies a transform to an input bundle, storing the result in an output bundle
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (`inputs:input`) | `bundle` | Input bundle containing the attributes to be transformed. | None |
| Transform (`inputs:transform`) | `matrixd[4]` | The transform to apply to the bundle | [[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]] |
| Metadata | | `displayGroup` = parameters | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Output (`outputs:output`) | `bundle` | Output bundle containing all of the transformed attributes | None |
## Metadata
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Name | Value |
|------------|---------------------------|
| Unique ID | omni.graph.TransformBundle|
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Transform Bundle |
| Categories | bundle |
| Generated Class Name | OgnTransformBundleDatabase |
| Python Module | omni.graph.nodes | |
OgnTransformVector.md | # Transform Vector
Applies a transformation matrix to a row vector, returning the result. returns ‘Vector’ * ‘Matrix’. If the vector is one dimension smaller than the matrix (eg a 4x4 matrix and a 3d vector), the last component of the vector will be treated as a 1. The result is then projected back to a 3-vector. Supports mixed array inputs, eg a single matrix and an array of vectors.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------|----------------------------------------------------------------------|--------------------------------------|---------|
| Matrix (`inputs:matrix`) | `['matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]']` | The transformation matrix to be applied | None |
| Vector (`inputs:vector`) | `['vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The row vector(s) to be translated | None |
## Outputs
| Name | Type | Descripton | Default |
|---------------|----------------------------------------------------------------------|--------------------------------------|---------|
| Vector (`outputs:result`) | `['vectord[3]', 'vectord[3][]',` | The transformed vector(s) | None |
## Inputs
### Input Type(s)
- `vectorf[3]`
- `vectorf[3][]`
- `vectorh[3]`
- `vectorh[3][]`
### Transformed row vector(s)
None
## Metadata
### Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.TransformVector |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Transform Vector |
| Categories | math:operator |
| Generated Class Name | OgnTransformVectorDatabase |
| Python Module | omni.graph.nodes | |
OgnTranslateToLocation.md | # Translate To Location
Perform a smooth translation maneuver, translating a prim to a desired point given a speed and easing factor
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute In (inputs:execIn) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Ease Exponent (inputs:exponent) | `float` | The blend exponent, which is the degree of the ease curve (1 = linear, 2 = quadratic, 3 = cubic, etc). | 2.0 |
| Prim (inputs:prim) | `target` | The prim to be translated | None |
| Prim Path (inputs:primPath) | `path` | The source prim to be transformed, used when ‘usePath’ is true | None |
| Speed (inputs:speed) | `double` | The peak speed of approach (Units / Second) | 1.0 |
| Stop (inputs:stop) | `bool` | Signal to stop the translation | False |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Stop Maneuver (inputs:stopManeuver) | execution | Signal to the graph that this node is ready to stop the maneuver. | None |
| Target Location (inputs:target) | vectord[3] | The desired local position | [0.0, 0.0, 0.0] |
| Use Path (inputs:usePath) | bool | When true, the ‘Prim Path’ attribute is used, otherwise it will read the connection at the ‘Prim’ attribute | False |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Finished (outputs:finished) | execution | When the maneuver is completed, Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.TranslateToLocation |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Translate To Location |
| Categories | sceneGraph |
| Generated Class Name | OgnTranslateToLocationDatabase |
| Python Module | omni.graph.nodes | |
OgnTranslateToTarget.md | # Translate To Target
This node smoothly translates 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 same translation as the target prim.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute In (inputs:execIn) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Exponent (inputs:exponent) | `float` | The blend exponent, which is the degree of the ease curve (1 = linear, 2 = quadratic, 3 = cubic, etc). | 2.0 |
| 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 |
| Stop (inputs:stop) | | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| 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 will be matched by the sourcePrim | None |
| Target Prim Path (inputs:targetPrimPath) | `path` | The destination prim. The target’s translation 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 | Descripton | Default |
| --- | --- | --- | --- |
| Finished (outputs:finished) | `execution` | When the maneuver is completed, Signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.TranslateToTarget |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Translate To Target |
| Categories | sceneGraph |
| Generated Class Name | OgnTranslateToTargetDatabase |
| Python Module | omni.graph.nodes | |
OgnTranspose.md | # Transpose
Computes the transposed matrix from an input matrix (or array of matrices) and outputs the result in an entirely-new matrix (or array of matrices) - the original inputs are not mutated in-place. The transpose of a matrix is an operation that “flips” a matrix over its diagonal, i.e. it switches the rows the columns of the matrix. For example, the transpose of the 2x3 matrix [[0, 1], [2, 3], [4, 5]] is the 3x2 matrix [[0, 2, 4], [1, 3, 5]].
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Matrix (`inputs:matrix`) | `['matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]']` | Input matrix or matrices. For arrays of matrices, the transpose will be computed for each member matrix. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (`outputs:result`) | `['matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]']` | The transposed matrix or matrices, with the same typing and size as the input(s). | None |
## Metadata
## Name
### Value
| Name | Value |
|---------------|--------------------------------|
| Unique ID | omni.graph.nodes.Transpose |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Transpose |
| Categories | math:operator |
| Generated Class Name | OgnTransposeDatabase |
| Python Module | omni.graph.nodes | |
OgnTrig.md | # Trigonometric Operation
Trigonometric operation of one input in degrees. Supported operations are: SIN, COS, TAN, ARCSIN, ARCCOS, ARCTAN, DEGREES, RADIANS
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['double', 'float', 'half', 'timecode']` | Input value on which the specified “Operation” will be invoked upon. | None |
| Operation (`inputs:operation`) | `token` | The trigonometric operation to perform, specified from a predefined list of allowed tokens. | SIN |
| Metadata | | `allowedTokens` = SIN,COS,TAN,ARCSIN,ARCCOS,ARCTAN,DEGREES,RADIANS | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (`outputs:result`) | `['double', 'float', 'half', 'timecode']` | | |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.Trig |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Trigonometric Operation |
| Categories | math:operator,math:conversion |
| Generated Class Name | OgnTrigDatabase |
| Python Module | omni.graph.nodes | |
OgnTutorialABI.md | # Tutorial Node: ABI Overrides
This tutorial node shows how to override ABI methods on your node.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|-------|--------------------------|---------|
| Namespace A Bool (inputs:namespace:a_bool) | bool | The input is any boolean value | True |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|-------|--------------------------|---------|
| Namespace A Bool (outputs:namespace:a_bool) | bool | The output is computed as the negation of the input | True |
## Metadata
| Name | Value |
|------------|----------------------|
| Unique ID | omni.graph.tutorials.Abi |
| Version | 1 |
| Icon | ogn/icons/omni.graph.tutorials.Abi.svg |
| ---- | ------------------------------------- |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | python |
| uiName | Tutorial Node: ABI Overrides |
| Categories | tutorials,internal:abi |
| __categoryDescriptions | internal:abi,Internal nodes that override the ABI functions |
| Generated Class Name | OgnTutorialABIDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at Tutorial 3 - ABI Override Node |
OgnTutorialABIPy.md | # Tutorial Python Node: ABI Overrides
This tutorial node shows how to override ABI methods on your Python node. The algorithm of the node converts an RGB color into HSV components.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Color To Convert (`inputs:color`) | `colord[3]` | The color to be converted | [0.0, 0.0, 0.0] |
| Metadata | | `multipleValues` = value1,value2,value3 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| H (`outputs:h`) | `double` | The hue component of the input color | None |
| S (`outputs:s`) | `double` | The saturation component of the input color | None |
| V (`outputs:v`) | `double` | The value component of the input color | None |
# Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.tutorials.AbiPy |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.AbiPy.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Python Node: ABI Overrides |
| Categories | tutorials,internal:abiPy |
| __categoryDescriptions | internal:abiPy,Internal nodes that override the Python ABI functions |
| Generated Class Name | OgnTutorialABIPyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 12 - Python ABI Override Node](#). |
OgnTutorialArrayData.md | # Tutorial Node: Array Attributes
This is a tutorial node. It will compute the array ‘result’ as the input array ‘original’ with every element multiplied by the constant ‘multiplier’.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Gates (inputs:gates) | bool[] | Boolean mask telling which elements of the array should be multiplied | [] |
| Info (inputs:info) | token[] | List of strings providing commentary | ['There', 'is', 'no', 'data'] |
| Multiplier (inputs:multiplier) | float | Multiplier of the array elements | 1.0 |
| Original (inputs:original) | float[] | Array to be multiplied | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Default
### Metadata
#### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.tutorials.ArrayData |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.ArrayData.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: Array Attributes |
| Categories | tutorials |
| Generated Class Name | OgnTutorialArrayDataDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 5 - Array Data Node](../tutorial5.html#ogn-tutorial-arraydata) |
OgnTutorialBundleAddAttributes.md | # Tutorial Node: Bundle Add Attributes
This is a tutorial node. It exercises functionality for adding and removing attributes on output bundles.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Added Attribute Names (`inputs:addedAttributeNames`) | `token[]` | Names for the attribute types to be added. The size of this array must match the size of the ‘typesToAdd’ array to be legal. | [] |
| Removed Attribute Names (`inputs:removedAttributeNames`) | `token[]` | Names for the attribute types to be removed. Non-existent attributes will be ignored. | [] |
| Attribute Types To Add (`inputs:typesToAdd`) | `token[]` | List of type descriptions to add to the bundle. The strings in this list correspond to the strings that represent the attribute types in the .ogn file (e.g. float[3][], colord[3], bool | [] |
| Use Batched API (`inputs:useBatchedAPI`) | `bool` | Controls whether or not to used batched APIS for adding/removing attributes | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table of Contents
## Constructed Bundle
| Name | Type | Description | Default |
|--------------------------------|--------|-----------------------------------------------------------------------------|---------|
| Constructed Bundle (outputs:bundle) | bundle | This is the bundle with all attributes added by compute. | None |
## Metadata
| Name | Value |
|--------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.tutorials.BundleAddAttributes |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.BundleAddAttributes.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: Bundle Add Attributes |
| Categories | tutorials |
| Generated Class Name | OgnTutorialBundleAddAttributesDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 21 - Adding Bundled Attributes](../tutorial21.html#ogn-tutorial-bundle-add-attributes). |
OgnTutorialBundleData.md | # Tutorial Node: Bundle Data
This is a tutorial node. It exercises functionality for access of data within bundle attributes.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|---------|-------------------------------------------------|---------|
| Input Bundle (inputs:bundle) | bundle | Bundle whose contents are modified for passing to the output | None |
## Outputs
| Name | Type | Descripton | Default |
|---------------------|---------|-------------------------------------------------|---------|
| Bundle (outputs:bundle) | bundle | This is the bundle with values of known types doubled. | None |
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.tutorials.BundleData |
| Version | 1 |
| Extension | Icon | Has State? | Implementation Language | Default Memory Type | Generated Code Exclusions | uiName | Categories | Generated Class Name | Python Module |
|-----------|------|------------|-------------------------|---------------------|---------------------------|--------|------------|----------------------|---------------|
| omni.graph.tutorials | ogn/icons/omni.graph.tutorials.BundleData.svg | False | C++ | cpu | None | Tutorial Node: Bundle Data | tutorials | OgnTutorialBundleDataDatabase | omni.graph.tutorials |
See the accompanying tutorial and annotated code at Tutorial 16 - Bundle Data |
OgnTutorialBundleDataPy.md | # Tutorial Python Node: Bundle Data
This is a tutorial node. It exercises functionality for access of data within bundle attributes. The configuration is the same as omni.graph.tutorials.BundleData except that the implementation language is Python
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|---------|-------------------------------------|---------|
| Input Bundle (`inputs:bundle`) | `bundle` | Bundle whose contents are modified for passing to the output | None |
## Outputs
| Name | Type | Descripton | Default |
|---------------------|---------|-------------------------------------|---------|
| Output Bundle (`outputs:bundle`) | `bundle` | This is the bundle with values of known types doubled. | None |
## Metadata
| Name | Value |
|-----------------|---------------------------------|
| Unique ID | omni.graph.tutorials.BundleDataPy |
| Version | |
| 1 |
| --- |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.BundleDataPy.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Python Node: Bundle Data |
| Categories | tutorials |
| Generated Class Name | OgnTutorialBundleDataPyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at Tutorial 16 - Bundle Data |
OgnTutorialBundles.md | # Tutorial Node: Bundle Manipulation
This is a tutorial node. It exercises functionality for the manipulation of bundle attribute contents.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|--------------|----------------------------------------------------------------------------|---------|
| Filtered Bundle (inputs:filteredBundle) | `bundle` | Bundle whose contents are filtered before being added to the output | None |
| Filters (inputs:filters) | `token[]` | List of filter names to be applied to the filteredBundle. Any filter name appearing in this list will be applied to members of that bundle and only those passing all filters will be added to the output bundle. Legal filter values are ‘big’ (arrays of size > 10), ‘x’ (attributes whose name contains the letter x), and ‘int’ (attributes whose base type is integer). | [] |
| Full Bundle (inputs:fullBundle) | `bundle` | Bundle whose contents are passed to the output in their entirety | None |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|--------------|----------------------------------------------------------------------------|---------|
| Combined Bundle (outputs:combinedBundle) | `bundle` | Bundle resulting from the combination of filtered and full bundles | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.tutorials.BundleManipulation |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.BundleManipulation.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: Bundle Manipulation |
| Categories | tutorials |
| Generated Class Name | OgnTutorialBundlesDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 15 - Bundle Manipulation](../tutorial15.html#ogn-tutorial-bundle-manipulation) |
OgnTutorialBundlesPy.md | # Tutorial Python Node: Bundle Manipulation
This is a tutorial node. It exercises functionality for the manipulation of bundle attribute contents. The configuration is the same as omni.graph.tutorials.BundleManipulation except that the implementation language is Python
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Filtered Bundle (`inputs:filteredBundle`) | `bundle` | Bundle whose contents are filtered before being added to the output | None |
| Filters (`inputs:filters`) | `token[]` | List of filter names to be applied to the filteredBundle. Any filter name appearing in this list will be applied to members of that bundle and only those passing all filters will be added to the output bundle. Legal filter values are ‘big’ (arrays of size > 10), ‘x’ (attributes whose name contains the letter x), and ‘int’ (attributes whose base type is integer). | [] |
| Full Bundle (`inputs:fullBundle`) | `bundle` | Bundle whose contents are passed to the output in their entirety | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.tutorials.BundleManipulationPy |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.BundleManipulationPy.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Python Node: Bundle Manipulation |
| Categories | tutorials |
| Generated Class Name | OgnTutorialBundlesPyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 15 - Bundle Manipulation](../tutorial15.html#ogn-tutorial-bundle-manipulation) |
OgnTutorialComplexDataPy.md | # Tutorial Python Node: Attributes With Arrays of Tuples
This is a tutorial node written in Python. It will compute the point3f array by multiplying each element of the float array by the three element vector in the multiplier.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|--------------|------------------|---------|
| A Input Array (inputs:a_inputArray) | float[] | Input array | [] |
| A Vector Multiplier (inputs:a_vectorMultiplier) | float[3] | Vector multiplier | [1.0, 2.0, 3.0] |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|--------------|------------------|---------|
| A Product Array (outputs:a_productArray) | pointf[3][] | Output array | [] |
| A Token Array (outputs:a_tokenArray) | token[] | | [] |
## Metadata
| Name | Value |
|------------|--------------------------------------------------------------------------------------------|
| Unique ID | omni.graph.tutorials.ComplexDataPy |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.ComplexDataPy.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Python Node: Attributes With Arrays of Tuples |
| Categories | tutorials |
| Generated Class Name | OgnTutorialComplexDataPyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 11 - Complex Data Node in Python](../tutorial11.html#ogn-tutorial-complexdata-py) |
OgnTutorialCpuGpuBundles.md | # Tutorial Node: CPU/GPU Bundles
This is a tutorial node. It exercises functionality for accessing data in bundles that are on the GPU as well as bundles whose CPU/GPU location is decided at runtime. The compute looks for bundled attributes named ‘points’ and, if they are found, computes their dot products. If the bundle on the output contains an integer array type named ‘dotProducts’ then the results are placed there, otherwise a new attribute of that name and type is created on the output bundle to hold the results. This node is identical to OgnTutorialCpuGpuBundlesPy.ogn, except it is implemented in C++.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|--------------|----------------------------------------------------|---------|
| CPU Input Bundle (inputs:cpuBundle) | `bundle` | Input bundle whose data always lives on the CPU | None |
| Results To GPU (inputs:gpu) | `bool` | If true then copy gpuBundle onto the output, otherwise copy cpuBundle | False |
| GPU Input Bundle (inputs:gpuBundle) | `bundle` | Input bundle whose data always lives on the GPU | None |
## Outputs
| Name | Type | Descripton | Default |
|---------------------|--------------|----------------------------------------------------|---------|
| Constructed Bundle | `bundle` | Output bundle containing the computed results | None |
<em>
outputs:cpuGpuBundle
</em>
<code class="docutils literal notranslate">
<span class="pre">
bundle
</span>
</code>
This is the bundle with the merged data. If the ‘gpu’ attribute is set to true then this bundle’s contents will be entirely on the GPU, otherwise they will be on the CPU.
None
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.tutorials.CpuGpuBundles |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.CpuGpuBundles.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | tutorial,bundle,gpu |
| uiName | Tutorial Node: CPU/GPU Bundles |
| __tokens | ["points", "dotProducts"] |
| Categories | tutorials |
| Generated Class Name | OgnTutorialCpuGpuBundlesDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at
Tutorial 22 - Bundles On The GPU |
OgnTutorialCpuGpuBundlesPy.md | # Tutorial Python Node: CPU/GPU Bundles
This is a tutorial node. It exercises functionality for accessing data in bundles that are on the GPU as well as bundles whose CPU/GPU location is decided at runtime. The compute looks for bundled attributes named ‘points’ and, if they are found, computes the dot products. If the bundle on the output contains an integer array type named ‘dotProducts’ then the results are placed there, otherwise a new attribute of that name and type is created on the output bundle to hold the results. This node is identical to OgnTutorialCpuGpuBundles.ogn, except is is implemented in Python.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| CPU Input Bundle (`inputs:cpuBundle`) | `bundle` | Input bundle whose data always lives on the CPU | None |
| Results To GPU (`inputs:gpu`) | `bool` | If true then copy gpuBundle onto the output, otherwise copy cpuBundle | False |
| GPU Input Bundle (`inputs:gpuBundle`) | `bundle` | Input bundle whose data always lives on the GPU | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Constructed Bundle (
**outputs:cpuGpuBundle**
)
## Code Block
```
bundle
```
This is the bundle with the merged data. If the ‘gpu’ attribute is set to true then this bundle’s contents will be entirely on the GPU, otherwise it will be on the CPU.
# Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.tutorials.CpuGpuBundlesPy |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.CpuGpuBundlesPy.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | tutorial,bundle,gpu |
| uiName | Tutorial Python Node: CPU/GPU Bundles |
| __tokens | ["points", "dotProducts"] |
| Categories | tutorials |
| Generated Class Name | OgnTutorialCpuGpuBundlesPyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 22 - Bundles On The GPU](../tutorial22.html#ogn-tutorial-cpu-gpu-bundles) |
OgnTutorialCpuGpuData.md | # Tutorial Node: Attributes With CPU/GPU Data
This is a tutorial node. It illustrates how to access data whose memory location, CPU or GPU, is determined at runtime in the compute method. The data types are the same as for the purely CPU and purely GPU tutorials, it is only the access method that changes. The input ‘is_gpu’ determines where the data of the other attributes can be accessed.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `float` | First value to be added in algorithm 1 | 0.0 |
| B (`inputs:b`) | `float` | Second value to be added in algorithm 1 | 0.0 |
| Is Gpu (`inputs:is_gpu`) | `bool` | Runtime switch determining where the data for the other attributes lives. | False |
| Multiplier (`inputs:multiplier`) | `float[3]` | Amplitude of the expansion for the input points in algorithm 2 | [1.0, 1.0, 1.0] |
| Points (`inputs:points`) | `float[3][]` | Points to be moved by algorithm 2 | [] |
## Outputs
### Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (outputs:points) | float[3][] | Final positions of points from algorithm 2 | None |
| Sum (outputs:sum) | float | Sum of the two inputs from algorithm 1 | None |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.tutorials.CpuGpuData |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.CpuGpuData.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | any |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: Attributes With CPU/GPU Data |
| __memoryType | any |
| Categories | tutorials |
| Generated Class Name | OgnTutorialCpuGpuDataDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at Tutorial 9 - Runtime CPU/GPU Decision |
OgnTutorialCpuGpuExtended.md | # Tutorial Node: CPU/GPU Extended Attributes
This is a tutorial node. It exercises functionality for accessing data in extended attributes that are on the GPU as well as those whose CPU/GPU location is decided at runtime. The compute adds the two inputs ‘gpuData’ and ‘cpuData’ together, placing the result in `cpuGpuSum`, whose memory location is determined by the ‘gpu’ flag. This node is identical to OgnTutorialCpuGpuExtendedPy.ogn, except is is implemented in C++.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| CPU Input Attribute (`inputs:cpuData`) | `any` | Input attribute whose data always lives on the CPU | None |
| Results To GPU (`inputs:gpu`) | `bool` | If true then put the sum on the GPU, otherwise put it on the CPU | False |
| GPU Input Attribute (`inputs:gpuData`) | `any` | Input attribute whose data always lives on the GPU | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Sum (`outputs:cpuGpuSum`) | `any` | The sum of the CPU and GPU data | None |
## Attributes
### outputs:cpuGpuSum
```
any
```
This is the attribute with the selected data. If the ‘gpu’ attribute is set to true then this attribute’s contents will be entirely on the GPU, otherwise it will be on the CPU.
None
## Metadata
### Name
* Unique ID: omni.graph.tutorials.CpuGpuExtended
* Version: 1
* Extension: omni.graph.tutorials
* Icon: ogn/icons/omni.graph.tutorials.CpuGpuExtended.svg
* Has State?: False
* Implementation Language: C++
* Default Memory Type: cpu
* Generated Code Exclusions: None
* tags: tutorial,extended,gpu
* uiName: Tutorial Node: CPU/GPU Extended Attributes
* Categories: tutorials
* Generated Class Name: OgnTutorialCpuGpuExtendedDatabase
* Python Module: omni.graph.tutorials
See the accompanying tutorial and annotated code at [Tutorial 23 - Extended Attributes On The GPU](../tutorial23.html#ogn-tutorial-cpu-gpu-extended). |
OgnTutorialCpuGpuExtendedPy.md | # Tutorial Python Node: CPU/GPU Extended Attributes
This is a tutorial node. It exercises functionality for accessing data in extended attributes that are on the GPU as well as those whose CPU/GPU location is decided at runtime. The compute adds the two inputs ‘gpuData’ and ‘cpuData’ together, placing the result in `cpuGpuSum`, whose memory location is determined by the ‘gpu’ flag. This node is identical to OgnTutorialCpuGpuExtended.ogn, except is is implemented in Python.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| CPU Input Attribute (`inputs:cpuData`) | `any` | Input attribute whose data always lives on the CPU | None |
| Results To GPU (`inputs:gpu`) | `bool` | If true then put the sum on the GPU, otherwise put it on the CPU | False |
| GPU Input Attribute (`inputs:gpuData`) | `any` | Input attribute whose data always lives on the GPU | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Sum (`outputs:cpuGpuSum`) | `any` | The sum of `cpuData` and `gpuData` | None |
<em>
outputs:cpuGpuSum
</em>
)
<code class="docutils literal notranslate">
<span class="pre">
any
</span>
</code>
This is the attribute with the selected data. If the ‘gpu’ attribute is set to true then this attribute’s contents will be entirely on the GPU, otherwise it will be on the CPU.
None
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.tutorials.CpuGpuExtendedPy |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.CpuGpuExtendedPy.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| tags | tutorial,extended,gpu |
| uiName | Tutorial Python Node: CPU/GPU Extended Attributes |
| Categories | tutorials |
| Generated Class Name | OgnTutorialCpuGpuExtendedPyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 23 - Extended Attributes On The GPU](#). |
OgnTutorialCudaData.md | # Tutorial Node: Attributes With CUDA Data
This is a tutorial node. It performs different functions on the GPU to illustrate different types of data access. The first adds inputs ‘a’ and ‘b’ to yield output ‘sum’, all of which are on the GPU. The second is a sample expansion deformation that multiplies every point on a set of input points, stored on the GPU, by a constant value, stored on the CPU, to yield a set of output points, also on the GPU. The third is an assortment of different data types illustrating how different data is passed to the GPU. This particular node uses CUDA for its GPU computations, as indicated in the memory type value. Normal use case for GPU compute is large amounts of data. For testing purposes this node only handles a very small amount but the principle is the same.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (inputs:a) | `float` | First value to be added in algorithm 1 | 0.0 |
| B (inputs:b) | `float` | Second value to be added in algorithm 1 | 0.0 |
| Color (inputs:color) | `colord[3]` | Input with three doubles as a color for algorithm 3 | [1.0, 0.5, 1.0] |
| Half (inputs:half) | `half` | Input of type half for algorithm 3 | 1.0 |
| Matrix (inputs:matrix) | `matrix` | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Matrix | double[4] | Input with 16 doubles interpreted as a double-precision 4d matrix | [[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]] |
| Multiplier | float[3] | Amplitude of the expansion for the input points in algorithm 2 | [1.0, 1.0, 1.0] |
| Points | float[3][] | Points to be moved by algorithm 2 | [] |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Color | colord[3] | Output with three doubles as a color for algorithm 3 | None |
| Half | half | Output of type half for algorithm 3 | None |
| Matrix | matrixd[4] | Output with 16 doubles interpreted as a double-precision 4d matrix | None |
| Points | float[3][] | Final positions of points from algorithm 2 | None |
| Sum | float | Sum of the two inputs from algorithm 1 | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.tutorials.CudaData |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.CudaData.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cuda |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: Attributes With CUDA Data |
| __memoryType | cuda |
| Categories | |
| | |
|---------------|-----------------------------------------------------------------|
| tutorials | |
| Generated Class Name | OgnTutorialCudaDataDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at Tutorial 8 - GPU Data Node. |
OgnTutorialCudaDataCpu.md | # Tutorial Node: Attributes With CUDA Array Pointers In Cpu Memory
This is a tutorial node. It illustrates the alternative method of extracting pointers to GPU array data in which the pointer returned is a CPU pointer and can be dereferenced on the CPU side. Without the cudaPointers value set that pointer would be a GPU pointer to an array of GPU pointers and could only be dereferenced on the device.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|---------------|-------------------------------------|---------------|
| Multiplier (inputs:multiplier) | `float[3]` | Amplitude of the expansion for the input points | [1.0, 1.0, 1.0] |
| Points (inputs:points) | `float[3][]` | Array of points to be moved | [] |
## Outputs
| Name | Type | Descripton | Default |
|------|---------------|-------------------------------------|---------------|
| Points (outputs:points) | `float[3][]` | Final positions of points | None |
## Table of Contents
| Name | Value |
|--------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.tutorials.CudaCpuArrays |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.CudaCpuArrays.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cuda |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: Attributes With CUDA Array Pointers In Cpu Memory |
| __memoryType | cuda |
| Categories | tutorials |
| Generated Class Name | OgnTutorialCudaDataCpuDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 27 - GPU Data Node with CPU Array Pointers](#). |
OgnTutorialCudaDataCpuPy.md | # Tutorial Python Node: Attributes With CUDA Array Pointers In Cpu Memory
This is a tutorial node. It illustrates the alternative method of extracting pointers to GPU array data in which the pointer returned is a CPU pointer and can be dereferenced on the CPU side. Without the cudaPointers value set that pointer would be a GPU pointer to an array of GPU pointers and could only be dereferenced on the device. Both plain attribute and bundle attribute extraction are shown.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|---------------|-------------------------------------|---------------|
| Multiplier (inputs:multiplier) | float[3] | Amplitude of the expansion for the input points | [1.0, 1.0, 1.0] |
| Points (inputs:points) | float[3][] | Array of points to be moved | [] |
## Outputs
| Name | Type | Descripton | Default |
|------------|---------|-------------------------------------|---------|
| Out Bundle (outputs:outBundle) | bundle | Bundle containing a copy of the output points | None |
# Metadata
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.tutorials.CudaCpuArraysPy |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.CudaCpuArraysPy.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cuda |
| Generated Code Exclusions | None |
| __memoryType | cuda |
| uiName | Tutorial Python Node: Attributes With CUDA Array Pointers In Cpu Memory |
| Categories | tutorials |
| Generated Class Name | OgnTutorialCudaDataCpuPyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 27 - GPU Data Node with CPU Array Pointers](../tutorial27.html#ogn-tutorial-cudadataoncpu) |
OgnTutorialDefaults.md | # Tutorial Node: Defaults
This is a tutorial node. It will move the values of inputs to corresponding outputs. Inputs all have unspecified, and therefore empty, default values.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A Array (inputs:a_array) | `float[]` | This is an attribute of type array of floats | [] |
| A Bool (inputs:a_bool) | `bool` | This is an attribute of type boolean | False |
| A Double (inputs:a_double) | `double` | This is an attribute of type 64 bit floating point | 0.0 |
| A Float (inputs:a_float) | `float` | This is an attribute of type 32 bit floating point | 0.0 |
| A Half (inputs:a_half) | `half` | This is an attribute of type 16 bit floating point | 0.0 |
| A Int (inputs:a_int) | `int` | This is an attribute of type integer | 0 |
## Inputs
| Name | Type | Description | Default |
|---------------------|--------------|--------------------------------------------------|---------|
| A Int | int | This is an attribute of type 32 bit integer | 0 |
| A Int2 (inputs:a_int2) | int[2] | This is an attribute of type 2-tuple of integers | [0, 0] |
| A Int64 (inputs:a_int64) | int64 | This is an attribute of type 64 bit integer | 0 |
| A Matrix (inputs:a_matrix) | matrixd[2] | This is an attribute of type 2x2 matrix | [[1.0, 0.0], [0.0, 1.0]] |
| A String (inputs:a_string) | string | This is an attribute of type string | |
| A Token (inputs:a_token) | token | This is an attribute of type interned string with fast comparison and hashing | |
| A Uchar (inputs:a_uchar) | uchar | This is an attribute of type unsigned 8 bit integer | 0 |
| A Uint (inputs:a_uint) | uint | This is an attribute of type unsigned 32 bit integer | 0 |
| A Uint64 (inputs:a_uint64) | uint64 | This is an attribute of type unsigned 64 bit integer | 0 |
## Outputs
| Name | Type | Description | Default |
|---------------------|--------------|--------------------------------------------------|---------|
| A Array (outputs:a_array) | float[] | This is a computed attribute of type array of floats | None |
| A Bool (outputs:a_bool) | bool | This is a computed attribute of type boolean | None |
| A Double (outputs:a_double) | double | This is a computed attribute of type 64 bit floating point | None |
| A Float (outputs:a_float) | float | This is a computed attribute of type 32 bit floating point | None |
A Half (
**outputs:a_half**
)
```half```
This is a computed attribute of type 16 bit floating point
None
---
A Int (
**outputs:a_int**
)
```int```
This is a computed attribute of type 32 bit integer
None
---
A Int2 (
**outputs:a_int2**
)
```int[2]```
This is a computed attribute of type 2-tuple of integers
None
---
A Int64 (
**outputs:a_int64**
)
```int64```
This is a computed attribute of type 64 bit integer
None
---
A Matrix (
**outputs:a_matrix**
)
```matrixd[2]```
This is a computed attribute of type 2x2 matrix
None
---
A String (
**outputs:a_string**
)
```string```
This is a computed attribute of type string
None
---
A Token (
**outputs:a_token**
)
```token```
This is a computed attribute of type interned string with fast comparison and hashing
None
---
A Uchar (
**outputs:a_uchar**
)
```uchar```
This is a computed attribute of type unsigned 8 bit integer
None
---
A Uint (
**outputs:a_uint**
)
```uint```
This is a computed attribute of type unsigned 32 bit integer
None
---
A Uint64 (
**outputs:a_uint64**
)
```uint64```
This is a computed attribute of type unsigned 64 bit integer
None
---
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.tutorials.Defaults |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.Defaults.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
```
请注意，我已将HTML中的强调（`<em>`）转换为Markdown的加粗（`**`），将代码块（`<code>`）转换为Markdown的代码块
| uiName | Tutorial Node: Defaults |
| --- | --- |
| Categories | tutorials |
| Generated Class Name | OgnTutorialDefaultsDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at Tutorial 14 - Defaults |
OgnTutorialDynamicAttributes.md | # Tutorial Node: Dynamic Attributes
This is a C++ node that exercises the ability to add and remove database attribute accessors for dynamic attributes. When the dynamic attribute is added the property will exist and be able to get/set the attribute values. When it does not the property will not exist. The dynamic attribute names are found in the tokens below. If neither exist then the input value is copied to the output directly. If ‘firstBit’ exists then the ‘firstBit’th bit of the input is x-ored for the copy. If ‘secondBit’ exists then the ‘secondBit’th bit of the input is x-ored for the copy. (Recall bitwise match xor(0,0)=0, xor(0,1)=1, xor(1,0)=1, and xor(1,1)=0.) For example, if ‘firstBit’ is present and set to 1 then the bitmask will be b0010, where bit 1 is set. If the input is 7, or b0111, then the xor operation will flip bit 1, yielding b0101, or 5 as the result. If on the next run ‘secondBit’ is also present and set to 2 then its bitmask will be b0100, where bit 2 is set. The input of 7 (b0111) flips bit 1 because firstBit=1 and flips bit 2 because secondBit=2, yielding a final result of 1 (b0001).
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `uint` | Original value to be modified. | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (`outputs:result`) | `uint` | Modified value | None |
## Metadata
| Name | Value |
|------------------|--------------------------------------------|
| Unique ID | omni.graph.tutorials.DynamicAttributes |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.DynamicAttributes.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: Dynamic Attributes |
| __tokens | {"firstBit": "inputs:firstBit", "secondBit": "inputs:secondBit", "invert": "inputs:invert"} |
| Categories | tutorials |
| Generated Class Name | OgnTutorialDynamicAttributesDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at Tutorial 25 - Dynamic Attributes |
OgnTutorialEmpty.md | # Tutorial Node: No Attributes
This is a tutorial node. It does absolutely nothing and is only meant to serve as an example to use for setting up your build.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.tutorials.Empty |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.Empty.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: No Attributes |
| Categories | tutorials |
| Generated Class Name | OgnTutorialEmptyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 1 - Trivial Node](#). |
OgnTutorialExtendedTypes.md | # Tutorial Node: Extended Attribute Types
This is a tutorial node. It exercises functionality for the manipulation of the extended attribute types.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Flexible Values (`inputs:flexible`) | `['float[3][]', 'token']` | Flexible data type input | None |
| Float Or Token (`inputs:floatOrToken`) | `['float', 'token']` | Attribute that can either be a float value or a token value | None |
| To Negate (`inputs:toNegate`) | `['bool[]', 'float[]']` | Attribute that can either be an array of booleans or an array of floats | None |
| Tuple Values (`inputs:tuple`) | `any` | Variable size/type tuple values | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table of Contents
## Attributes
| Type | Descripton | Default |
|--------|------------------|---------|
| Doubled Input Value (outputs:doubledResult) | any | If the input ‘simpleInput’ is a float this is 2x the value. If it is a token this contains the input token repeated twice. | None |
| Inverted Flexible Values (outputs:flexible) | ['float[3][]', 'token'] | Flexible data type output | None |
| Negated Array Values (outputs:negatedResult) | ['bool[]', 'float[]'] | Result of negating the data from the ‘toNegate’ input | None |
| Negative Tuple Values (outputs:tuple) | any | Negated values of the tuple input | None |
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.tutorials.ExtendedTypes |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.ExtendedTypes.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Node: Extended Attribute Types |
| Categories | tutorials |
| Generated Class Name | OgnTutorialExtendedTypesDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at Tutorial 19 - Extended Attribute Types. |
OgnTutorialExtendedTypesPy.md | # Tutorial Python Node: Extended Attribute Types
This is a tutorial node. It exercises functionality for the manipulation of the extended attribute types. It is identical to OgnTutorialExtendedTypes.ogn, except the language of implementation is selected to be python.
## Installation
To use this node enable `omni.graph.tutorials` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|-------------------------------------------|--------------------------------------|---------|
| Flexible Values | `['float[3][]', 'token']` | Flexible data type input | None |
| Float Or Token | `['float', 'token']` | Attribute that can either be a float value or a token value | None |
| To Negate | `['bool[]', 'float[]']` | Attribute that can either be an array of booleans or an array of floats | None |
| Tuple Values | `any` | Variable size/type tuple values | None |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|-------------------------------------------|--------------------------------------|---------|
| Flexible Values | `['float[3][]', 'token']` | Flexible data type output | None |
| Float Or Token | `['float', 'token']` | Attribute that can either be a float value or a token value | None |
| To Negate | `['bool[]', 'float[]']` | Attribute that can either be an array of booleans or an array of floats | None |
| Tuple Values | `any` | Variable size/type tuple values | None |
# Table 1: Node Attributes
| Name | Type | Description | Default |
|-------------------------------|------------|-----------------------------------------------------------------------------|---------|
| Doubled Input Value (outputs:doubledResult) | any | If the input ‘floatOrToken’ is a float this is 2x the value. If it is a token this contains the input token repeated twice. | None |
| Inverted Flexible Values (outputs:flexible) | ['float[3][]', 'token'] | Flexible data type output | None |
| Negated Array Values (outputs:negatedResult) | ['bool[]', 'float[]'] | Result of negating the data from the ‘toNegate’ input | None |
| Negative Tuple Values (outputs:tuple) | any | Negated values of the tuple input | None |
# Metadata
| Name | Value |
|-----------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.tutorials.ExtendedTypesPy |
| Version | 1 |
| Extension | omni.graph.tutorials |
| Icon | ogn/icons/omni.graph.tutorials.ExtendedTypesPy.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Tutorial Python Node: Extended Attribute Types |
| Categories | tutorials |
| Generated Class Name | OgnTutorialExtendedTypesPyDatabase |
| Python Module | omni.graph.tutorials |
See the accompanying tutorial and annotated code at [Tutorial 19 - Extended Attribute Types](../tutorial19.html#ogn-tutorial-extended-types). |
OgnTutorialGenericMathNode.md | # Tutorial Python Node: Generic Math Node
This is a tutorial node. It is functionally equivalent to the built-in Multiply node, but written in python as a practical demonstration of using extended attributes to write math nodes that work with any numeric types, including arrays and tuples.
## Installation
To use this node enable `omni.graph.tutorials` 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[]'] | | |
'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 number 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[]',
'int',
'int64',
'int64[]',
'int[2]',
'int[2][]',
| 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', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]'] | | None |
### Metadata
#### Name
- Unique ID: omni.graph.tutorials.GenericMathNode
- Version: 1
- Extension: omni.graph.tutorials
- Icon: ogn/icons/omni.graph.tutorials.GenericMathNode.svg
- Has State?: False
- Implementation Language: Python
- Default Memory Type: cpu
- Generated Code Exclusions: None
- uiName: Tutorial Python Node: Generic Math Node
- Categories: tutorials
- Generated Class Name: OgnTutorialGenericMathNodeDatabase
- Python Module: omni.graph.tutorials
See the accompanying tutorial and annotated code at
Tutorial 26 - Generic Math Node |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.