file_path
stringlengths 5
148
| content
stringlengths 150
498k
| size
int64 150
498k
|
|---|---|---|
OgnSdOnNewRenderProductFrame.md | # Sd On New Render Product Frame
Synthetic Data postprocess node to execute pipeline after the NewFrame event has been received on the given renderProduct
## Installation
To use this node enable [omni.syntheticdata](../Overview.html#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Received (inputs:exec) | execution | Executes for each newFrame event received | None |
| Render Product Data Ptrs (inputs:renderProductDataPtrs) | uint64[] | HydraRenderProduct data pointers. | [] |
| Render Product Path (inputs:renderProductPath) | token | Path of the renderProduct to wait for being rendered | |
| Render Product Paths (inputs:renderProductPaths) | token[] | Render product path tokens. | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
# Table 1
## Descripton
## Default
| Cuda Stream (outputs:cudaStream) | uint64 | Cuda stream | None |
| --- | --- | --- | --- |
| Received (outputs:exec) | execution | Executes for each newFrame event received | None |
| Render Product Path (outputs:renderProductPath) | token | Path of the renderProduct to wait for being rendered | None |
| Render Results (outputs:renderResults) | uint64 | Render results | None |
# Metadata
## Name
## Value
| Unique ID | omni.syntheticdata.SdOnNewRenderProductFrame |
| --- | --- |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnSdOnNewRenderProductFrameDatabase |
| Python Module | omni.syntheticdata | | 1,700 |
OgnSdPostCompRenderVarTextures.md | # Sd Post Comp Render Var Textures
Synthetic Data node to compose a front renderVar texture into a back renderVar texture
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Cuda Ptr (`inputs:cudaPtr`) | `uint64` | Front texture CUDA pointer | 0 |
| Format (`inputs:format`) | `uint64` | Front texture format | 0 |
| gpuFoundations (`inputs:gpu`) | `uint64` | Pointer to shared context containing gpu foundations | 0 |
| Height (`inputs:height`) | `uint` | Front texture height | 0 |
| Mode (`inputs:mode`) | `token` | Mode : grid, line | line |
| Parameters (`inputs:parameters`) | | | |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdPostCompRenderVarTextures |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["line", "grid"] |
| Categories | graph:postRender,rendering,internal |
| Generated Class Name | OgnSdPostCompRenderVarTexturesDatabase |
| Python Module | omni.syntheticdata | | 1,478 |
OgnSdPostInstanceMapping.md | # Sd Post Instance Mapping
Synthetic Data node to compute and store scene instances semantic hierarchy information
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| gpuFoundations (`inputs:gpu`) | `uint64` | Pointer to shared context containing gpu foundations | 0 |
| renderProduct (`inputs:rp`) | `uint64` | Pointer to render product for this view | 0 |
| Semantic Filter Name (`inputs:semanticFilterName`) | `token` | Name of the semantic filter to apply to the semanticLabelToken | default |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdPostInstanceMapping |
| Version | 2 |
|---------|---|
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["InstanceMappingInfoSDhost", "SemanticMapSD", "SemanticMapSDhost", "SemanticPrimTokenSD", "SemanticPrimTokenSDhost", "InstanceMapSD", "InstanceMapSDhost", "InstancePrimTokenSD", "InstancePrimTokenSDhost", "SemanticLabelTokenSD", "SemanticLabelTokenSDhost", "SemanticLocalTransformSD", "SemanticLocalTransformSDhost", "SemanticWorldTransformSD", "SemanticWorldTransformSDhost"] |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnSdPostInstanceMappingDatabase |
| Python Module | omni.syntheticdata | | 1,663 |
OgnSdPostRenderVarDisplayTexture.md | # Sd Post Render Var Display Texture
Synthetic Data node to copy the input aov texture into the corresponding visualization texture
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Camera Fisheye Params (`inputs:cameraFisheyeParams`) | `float[]` | Camera fisheye projection parameters | [] |
| Camera Model (`inputs:cameraModel`) | `int` | Camera model (pinhole or fisheye models) | 0 |
| Camera Near Far (`inputs:cameraNearFar`) | `float[2]` | Camera near/far clipping range | [0.0, 0.0] |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| gpuFoundations (`inputs:gpu`) | `uint64` | Pointer to shared context containing gpu foundations | 0 |
Instance Map SD Cuda Ptr (
**inputs:instanceMapSDCudaPtr**
)
```uint64```
cuda uint16_t buffer pointer of size numInstances containing the instance parent semantic index
0
Instance Mapping Info SD Ptr (
**inputs:instanceMappingInfoSDPtr**
)
```uint64```
uint buffer pointer containing the following information : [numInstances, minInstanceId, numSemantics, minSemanticId, numProtoSemantic]
0
Meters Per Scene Unit (
**inputs:metersPerSceneUnit**
)
```float```
Scene units to meters scale
0.0
Mode (
**inputs:mode**
)
```token```
Display mode
autoMode
Parameters (
**inputs:parameters**
)
```float[4]```
Display parameters
[0.0, 5.0, 0.33, 0.27]
Render Var (
**inputs:renderVar**
)
```token```
Name of the input RenderVar to display
Render Var Display (
**inputs:renderVarDisplay**
)
```token```
Name of the output display RenderVar
renderProduct (
**inputs:rp**
)
```uint64```
Pointer to render product for this view
0
Sd Display Height (
**inputs:sdDisplayHeight**
)
```uint```
Visualization texture Height
0
Sd Display Width (
**inputs:sdDisplayWidth**
)
```uint```
Visualization texture width
0
Sd Sem B Box3d Cam Corners Cuda Ptr (
**inputs:sdSemBBox3dCamCornersCudaPtr**
)
```uint64```
Cuda buffer containing the projection of the 3d bounding boxes on the camera plane represented as a float3=(u,v,z,a) for each bounding box corners
0
Sd Sem B Box3d Cam Extent Cuda Ptr (
**inputs:sdSemBBox3dCamExtentCudaPtr**
)
```uint64```
Cuda buffer containing the 2d extent of the 3d bounding boxes on the camera plane represented as a float6=(u_min,u_max,v_min,v_max,z_min,z_max)
0
Sd Sem B Box Extent Cuda Ptr (
**inputs:sdSemBBoxExtentCudaPtr**
)
```uint64```
Cuda buffer containing the extent of the bounding boxes as a float4=(u_min,v_min,u_max,v_max) for 2D or a float6=(xmin,ymin,zmin,xmax,ymax,zmax) in object space for 3D
0
Sd Sem B Box Infos Cuda Ptr (
**inputs:sdSemBBoxInfosCudaPtr**
)
```uint64```
Cuda buffer containing the extent of the bounding boxes as a float4=(u_min,v_min,u_max,v_max) for 2D or a float6=(xmin,ymin,zmin,xmax,ymax,zmax) in object space for 3D
0
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Bounding Box SD Cuda Ptr (inputs:boundingBoxSDCudaPtr) | uint64 | Cuda buffer containing valid bounding boxes infos | 0 |
| Semantic Label Token SD Cuda Ptr (inputs:semanticLabelTokenSDCudaPtr) | uint64 | cuda uint64_t buffer pointer of size numSemantics containing the semantic label token | 0 |
| Semantic Map SD Cuda Ptr (inputs:semanticMapSDCudaPtr) | uint64 | cuda uint16_t buffer pointer of size numSemantics containing the semantic parent semantic index | 0 |
| Semantic Prim Token SD Cuda Ptr (inputs:semanticPrimTokenSDCudaPtr) | uint64 | cuda uint64_t buffer pointer of size numSemantics containing the semantic path token | 0 |
| Semantic World Transform SD Cuda Ptr (inputs:semanticWorldTransformSDCudaPtr) | uint64 | cuda float44 buffer pointer of size numSemantics containing the world semantic transform | 0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Cuda Ptr (outputs:cudaPtr) | uint64 | Display texture CUDA pointer | None |
| Exec (outputs:exec) | execution | Trigger | None |
| Format (outputs:format) | uint64 | Display texture format | None |
| Height (outputs:height) | uint | Display texture height | None |
| Render Var Display (outputs:renderVarDisplay) | token | Name of the output display RenderVar | None |
| Width (outputs:width) | uint | Display texture width | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdPostRenderVarDisplayTexture |
| Version | 1 |
| Extension | omni.syntheticdata |
|-----------|---------------------|
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["LdrColorSD", "Camera3dPositionSD", "DistanceToImagePlaneSD", "DistanceToCameraSD", "InstanceSegmentationSD", "SemanticSegmentationSD", "NormalSD", "TargetMotionSD", "BoundingBox2DTightSD", "BoundingBox2DLooseSD", "BoundingBox3DSD", "OcclusionSD", "TruncationSD", "CrossCorrespondenceSD", "SemanticBoundingBox2DExtentTightSD", "SemanticBoundingBox2DInfosTightSD", "SemanticBoundingBox2DExtentLooseSD", "SemanticBoundingBox2DInfosLooseSD", "SemanticBoundingBox3DExtentSD", "SemanticBoundingBox3DInfosSD", "SemanticBoundingBox3DCamCornersSD", "SemanticBoundingBox3DDisplayAxesSD", "autoMode", "colorMode", "scaled3dVectorMode", "clippedValueMode", "normalized3dVectorMode", "segmentationMapMode", "instanceMapMode", "semanticPathMode", "semanticLabelMode", "semanticBoundingBox2dMode", "rawBoundingBox2dMode", "semanticProjBoundingBox3dMode", "semanticBoundingBox3dMode", "rawBoundingBox3dMode", "pinhole", "perspective", "orthographic", "fisheyePolynomial"] |
| Categories | graph:postRender,rendering,internal |
| Generated Class Name | OgnSdPostRenderVarDisplayTextureDatabase |
| Python Module | omni.syntheticdata | | 5,827 |
OgnSdPostRenderVarHostToDisk.md | # Sd Post Render Var Host To Disk
Dispatch the writing of a host renderVar to disk.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Detach Resource Before Dispatch (`inputs:detachResourceBeforeDispatch`) | bool | Duplicate the resource before dispatching the copy | False |
| Exec (`inputs:exec`) | execution | Trigger | None |
| Gpu (`inputs:gpu`) | uint64 | Pointer to shared context containing gpu foundations | 0 |
| Output Basename (`inputs:outputBasename`) | string | Basename to write renderVar file. (use {renderVar} if empty) | |
| Output Folder (`inputs:outputFolder`) | string | Folder to write renderVar file | /tmp/ovSdOut |
# Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Rational Render Time (inputs:outputRationalRenderTime) | bool | Add rational render time to the basename | True |
| Render Product Path (inputs:renderProductPath) | token | Path of the render product prim | |
| Render Var (inputs:renderVar) | token | Name of the renderVar to write to disk | |
| Rp (inputs:rp) | uint64 | Pointer to render product for this view | 0 |
# Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec (outputs:exec) | execution | Trigger | None |
| Output Path (outputs:outputPath) | string | Output path to be written | None |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdPostRenderVarHostToDisk |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnSdPostRenderVarHostToDiskDatabase |
| Python Module | omni.syntheticdata | | 1,844 |
OgnSdPostRenderVarTextureToBuffer.md | # Sd Post Render Var Texture To Buffer
Expose a device renderVar buffer a texture one.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Cuda Copy No Stride (`inputs:cudaCopyNoStride`) | bool | Use a cuda copy from a texture to a linear buffer without strides | True |
| Exec (`inputs:exec`) | execution | Trigger | None |
| Gpu (`inputs:gpu`) | uint64 | Pointer to shared context containing gpu foundations | 0 |
| Render Var (`inputs:renderVar`) | token | Name of the device renderVar to expose on the host | |
| Render Var Buffer Suffix (`inputs:renderVarBufferSuffix`) | string | Suffix appended to the renderVar name | buffer |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Render Product (outputs:renderProduct) | Pointer to render product for this view | 0 |
| Render Product Pointer | uint64 | Pointer to render product for this view | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (outputs:exec) | execution | Trigger | None |
| Render Var (outputs:renderVar) | token | Name of the resulting renderVar on the host | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdPostRenderVarTextureToBuffer |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnSdPostRenderVarTextureToBufferDatabase |
| Python Module | omni.syntheticdata | | 1,663 |
OgnSdPostRenderVarToHost.md | # Sd Post Render Var To Host
Expose a host renderVar from the input device renderVar.
## Installation
To use this node enable [omni.syntheticdata](../Overview.html#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (inputs:exec) | execution | Trigger | None |
| Gpu (inputs:gpu) | uint64 | Pointer to shared context containing gpu foundations | 0 |
| Render Var (inputs:renderVar) | token | Name of the device renderVar to expose on the host | |
| Render Var Host Suffix (inputs:renderVarHostSuffix) | string | Suffix appended to the renderVar name | host |
| Rp (inputs:rp) | uint64 | Pointer to render product for this view | 0 |
## Outputs
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdPostRenderVarToHost |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnSdPostRenderVarToHostDatabase |
| Python Module | omni.syntheticdata | | 1,423 |
OgnSdPostSemantic3dBoundingBoxCameraProjection.md | # Sd Post Semantic3d Bounding Box Camera Projection
Synthetic Data node to project 3d bounding boxes data in camera space.
## Installation
To use this node enable [omni.syntheticdata](../Overview.html#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Camera Fisheye Params (inputs:cameraFisheyeParams) | float[] | Camera fisheye projection parameters | [] |
| Camera Model (inputs:cameraModel) | int | Camera model (pinhole or fisheye models) | 0 |
| Camera Near Far (inputs:cameraNearFar) | float[2] | Camera near/far clipping range | [1.0, 10000000.0] |
| Exec (inputs:exec) | execution | Trigger | None |
| gpuFoundations (inputs:gpu) | uint64 | Pointer to shared context containing gpu foundations | 0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Instance Mapping Info SD Ptr (inputs:instanceMappingInfoSDPtr) | uint64 | uint buffer pointer containing the following information : [numInstances, minInstanceId, numSemantics, minSemanticId, numProtoSemantic] | 0 |
| Meters Per Scene Unit (inputs:metersPerSceneUnit) | float | Scene units to meters scale | 0.01 |
| Render Product Resolution (inputs:renderProductResolution) | int[2] | RenderProduct resolution | [65536, 65536] |
| renderProduct (inputs:rp) | uint64 | Pointer to render product for this view | 0 |
| Sd Sem B Box Extent Cuda Ptr (inputs:sdSemBBoxExtentCudaPtr) | uint64 | Cuda buffer containing the extent of the bounding boxes as a float4=(u_min,v_min,u_max,v_max) for 2D or a float6=(xmin,ymin,zmin,xmax,ymax,zmax) in object space for 3D | 0 |
| Sd Sem B Box Infos Cuda Ptr (inputs:sdSemBBoxInfosCudaPtr) | uint64 | Cuda buffer containing valid bounding boxes infos | 0 |
| Semantic World Transform SD Cuda Ptr (inputs:semanticWorldTransformSDCudaPtr) | uint64 | cuda float44 buffer pointer of size numSemantics containing the world semantic transform | 0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec (outputs:exec) | execution | Trigger | None |
| Sd Sem B Box3d Cam Corners Cuda Ptr (outputs:sdSemBBox3dCamCornersCudaPtr) | uint64 | Cuda buffer containing the projection of the 3d bounding boxes on the camera plane represented as a float4=(u,v,z,a) for each bounding box corners | None |
| Sd Sem B Box3d Cam Extent Cuda Ptr (outputs:sdSemBBox3dCamExtentCudaPtr) | uint64 | Cuda buffer containing the 2d extent of the 3d bounding boxes on the camera plane represented as a float6=(u_min,u_max,v_min,v_max,z_min,z_max) | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdPostSemantic3dBoundingBoxCameraProjection |
| 属性 | 值 |
| --- | --- |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["SemanticBoundingBox3DInfosSD", "SemanticBoundingBox3DCamCornersSD", "SemanticBoundingBox3DCamExtentSD"] |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnSdPostSemantic3dBoundingBoxCameraProjectionDatabase |
| Python Module | omni.syntheticdata | | 3,168 |
OgnSdPostSemantic3dBoundingBoxFilter.md | # Sd Post Semantic3d Bounding Box Filter
Synthetic Data node to cull the semantic 3d bounding boxes.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| gpuFoundations (`inputs:gpu`) | `uint64` | Pointer to shared context containing gpu foundations | 0 |
| Instance Mapping Info SD Ptr (`inputs:instanceMappingInfoSDPtr`) | `uint64` | uint buffer pointer containing the following information : [numInstances, minInstanceId, numSemantics, minSemanticId, numProtoSemantic] | 0 |
| Meters Per Scene Unit (`inputs:metersPerSceneUnit`) | `float` | Scene units to meters scale | 0.01 |
| renderProduct (`inputs:rp`) | `uint64` | Pointer to render product for this view | 0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Sd Sem B Box3d Cam Corners Cuda Ptr | uint64 | Cuda buffer containing the projection of the 3d bounding boxes on the camera plane represented as a float3=(u,v,z,a) for each bounding box corners | 0 |
| Sd Sem B Box Infos Cuda Ptr | uint64 | Cuda buffer containing valid bounding boxes infos | 0 |
| Viewport Near Far | float[2] | near and far plane (in scene units) used to clip the 3d bounding boxes. | [0.0, -1.0] |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Exec | execution | Trigger | None |
| Sd Sem B Box Infos Cuda Ptr | uint64 | Cuda buffer containing valid bounding boxes infos | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdPostSemantic3dBoundingBoxFilter |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["SemanticBoundingBox3DInfosSD", "SemanticBoundingBox3DFilterInfosSD"] |
| Categories | graph:postRender,rendering |
| Generated Class Name | OgnSdPostSemantic3dBoundingBoxFilterDatabase |
| Python Module | omni.syntheticdata | | 2,082 |
OgnSdPostSemanticBoundingBox.md | # Sd Post Semantic Bounding Box
Synthetic Data node to compute the bounding boxes of the scene semantic entities.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| gpuFoundations (`inputs:gpu`) | `uint64` | Pointer to shared context containing gpu foundations | 0 |
| Instance Map SD Cuda Ptr (`inputs:instanceMapSDCudaPtr`) | `uint64` | cuda uint16_t buffer pointer of size numInstances containing the instance parent semantic index | 0 |
| Instance Mapping Info SD Ptr (`inputs:instanceMappingInfoSDPtr`) | `uint64` | uint buffer pointer containing the following information : [numInstances, minInstanceId, numSemantics, minSemanticId, numProtoSemantic] | 0 |
| Render Product Resolution (`inputs:renderProductResolution`) | `int[2]` | RenderProduct resolution | |
[0, 0]
### Render Var (inputs:renderVar)
- **Type:** `token`
- **Description:** Name of the BoundingBox RenderVar to process
### renderProduct (inputs:rp)
- **Type:** `uint64`
- **Description:** Pointer to render product for this view
- **Default:** 0
### Semantic Local Transform SD Cuda Ptr (inputs:semanticLocalTransformSDCudaPtr)
- **Type:** `uint64`
- **Description:** cuda float44 buffer pointer of size numSemantics containing the local semantic transform
- **Default:** 0
### Semantic Map SD Cuda Ptr (inputs:semanticMapSDCudaPtr)
- **Type:** `uint64`
- **Description:** cuda uint16_t buffer pointer of size numSemantics containing the semantic parent semantic index
- **Default:** 0
## Outputs
### Exec (outputs:exec)
- **Type:** `execution`
- **Description:** Trigger
- **Default:** None
### Sd Sem B Box Extent Cuda Ptr (outputs:sdSemBBoxExtentCudaPtr)
- **Type:** `uint64`
- **Description:** Cuda buffer containing the extent of the bounding boxes as a float4=(u_min,v_min,u_max,v_max) for 2D or a float6=(xmin,ymin,zmin,xmax,ymax,zmax) in object space for 3D
- **Default:** None
### Sd Sem B Box Infos Cuda Ptr (outputs:sdSemBBoxInfosCudaPtr)
- **Type:** `uint64`
- **Description:** Cuda buffer containing valid bounding boxes infos
- **Default:** None
## Metadata
### Unique ID
- **Value:** omni.syntheticdata.SdPostSemanticBoundingBox
### Version
- **Value:** 1
### Extension
- **Value:** omni.syntheticdata
### Has State?
- **Value:** False
### Implementation Language
- **Value:** C++
### Default Memory Type
- **Value:** cpu
### Generated Code Exclusions
- **Value:** None
### __tokens
- **Value:** ["BoundingBox2DLooseSD", "BoundingBox2DTightSD", "SemanticBoundingBox2DExtentLooseSD", "SemanticBoundingBox2DInfosLooseSD", "SemanticBoundingBox2DExtentTightSD", "SemanticBoundingBox2DInfosTightSD", "BoundingBox3DSD", "SemanticBoundingBox3DExtentSD", "SemanticBoundingBox3DInfosSD"]
### Categories
- **Value:** graph:postRender,rendering
### Generated Class Name
- **Value:** OgnSdPostSemanticBoundingBoxDatabase
| Python Module | omni.syntheticdata | | 3,025 |
OgnSdPostSemanticFilterSegmentationMap.md | # Sd Post Semantic Filter Segmentation Map
Synthetic Data node to create an texture AOV: the semantic segmentation map corresponding to an input semantic filter
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| Gpu (`inputs:gpu`) | `uint64` | Pointer to shared context containing gpu foundations | 0 |
| Instance Mapping Info SD Ptr (`inputs:instanceMappingInfoSDPtr`) | `uint64` | uint buffer pointer containing the following information: [numInstances, minInstanceId, numSemantics, minSemanticId, numProtoSemantic] | 0 |
| Render Product Resolution (`inputs:renderProductResolution`) | `int[2]` | RenderProduct resolution | [0, 0] |
| Rp (`inputs:rp`) | `uint64` | Render results | 0 |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Semantic Filter Name (inputs:semanticFilterName) | token | Name of the semantic filter | |
| Semantic Label Token SD Cuda Ptr (inputs:semanticLabelTokenSDCudaPtr) | uint64 | uint64_t cuda buffer pointer of size numSemantics containing the semantic label token | 0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Received (outputs:exec) | execution | Executes for each newFrame event received | None |
| Semantic Filter Segmentation Map Cuda Ptr (outputs:semanticFilterSegmentationMapCudaPtr) | uint64 | uint64_t cuda array containing the segmentation map associated to the input semantic filter | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdPostSemanticFilterSegmentationMap |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["InstanceMapSD", "InstanceSegmentationSD"] |
| Categories | graph:postRender |
| Generated Class Name | OgnSdPostSemanticFilterSegmentationMapDatabase |
| Python Module | omni.syntheticdata | | 2,075 |
OgnSdRenderProductCamera.md | # Sd Render Product Camera
Synthetic Data node to expose the camera data
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| Gpu (`inputs:gpu`) | `uint64` | Pointer to shared context containing gpu foundations. | 0 |
| Render Product Path (`inputs:renderProductPath`) | `token` | RenderProduct prim path | |
| Render Results (`inputs:renderResults`) | `uint64` | Render results | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Camera Aperture Offset (outputs:cameraApertureOffset) | float[2] | Camera horizontal and vertical aperture offset | None |
|-----------------------------------------------------|----------|------------------------------------------------|------|
| Camera Aperture Size (outputs:cameraApertureSize) | float[2] | Camera horizontal and vertical aperture | None |
| Camera F Stop (outputs:cameraFStop) | float | Camera fStop | None |
| Camera Fisheye Params (outputs:cameraFisheyeParams) | float[] | Camera fisheye projection parameters | None |
| Camera Focal Length (outputs:cameraFocalLength) | float | Camera focal length | None |
| Camera Focus Distance (outputs:cameraFocusDistance) | float | Camera focus distance | None |
| Camera Model (outputs:cameraModel) | int | Camera model (pinhole or fisheye models) | None |
| Camera Near Far (outputs:cameraNearFar) | float[2] | Camera near/far clipping range | None |
| Camera Projection (outputs:cameraProjection) | matrixd[4] | Camera projection matrix | None |
| Camera View Transform (outputs:cameraViewTransform) | matrixd[4] | Camera view matrix | None |
| Received (outputs:exec) | execution | Executes for each newFrame event received | None |
| Meters Per Scene Unit (outputs:metersPerSceneUnit) | float | Scene units to meters scale | None |
| Render Product Resolution (outputs:renderProductResolution) | int[2] | RenderProduct resolution | None |
| Unique ID | omni.syntheticdata.SdRenderProductCamera |
| Version | 2 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | ["RenderProductCameraSD"] |
| Categories | graph:postRender,graph:action |
| Generated Class Name | OgnSdRenderProductCameraDatabase |
| Python Module | omni.syntheticdata | | 3,153 |
OgnSdRenderVarDisplayTexture.md | # Sd Render Var Display Texture
Synthetic Data node to expose texture resource of a visualization render variable
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (inputs:exec) | execution | Trigger | None |
| Render Results (inputs:renderResults) | uint64 | Render results pointer | 0 |
| Render Var Display (inputs:renderVarDisplay) | token | Name of the renderVar | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Cuda Ptr (outputs:cudaPtr) | uint64 | Display texture CUDA pointer | |
# Metadata
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdRenderVarDisplayTexture |
| Version | 2 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:action,rendering,internal |
| Generated Class Name | OgnSdRenderVarDisplayTextureDatabase |
| Python Module | omni.syntheticdata | | 1,088 |
OgnSdRenderVarPtr.md | # Sd Render Var Ptr
Synthetic Data node exposing the raw pointer data of a rendervar.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Trigger | None |
| Render Results (`inputs:renderResults`) | `uint64` | Render results pointer | 0 |
| Render Var (`inputs:renderVar`) | `token` | Name of the renderVar | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Buffer Size (`outputs:bufferSize`) | `uint64` | Size (in bytes) of the buffer (0 if the input is a texture) | None |
## Outputs
| Cuda Device Index (outputs:cudaDeviceIndex) | int | Index of the device where the data lives (-1 for host data) | -1 |
| --- | --- | --- | --- |
| Data Ptr (outputs:dataPtr) | uint64 | Pointer to the raw data (cuda device pointer or host pointer) | 0 |
| Received (outputs:exec) | execution | Executes when the event is received | None |
| Format (outputs:format) | uint64 | Format | None |
| Height (outputs:height) | uint | Height (0 if the input is a buffer) | None |
| Strides (outputs:strides) | int[2] | Strides (in bytes) ([0,0] if the input is a buffer) | None |
| Width (outputs:width) | uint | Width (0 if the input is a buffer) | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdRenderVarPtr |
| Version | 2 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| Categories | graph:action |
| Generated Class Name | OgnSdRenderVarPtrDatabase |
| Python Module | omni.syntheticdata | | 1,713 |
OgnSdRenderVarToRawArray.md | # Sd Render Var To Raw Array
Synthetic Data action node to copy the input rendervar into an output raw array
## Installation
To use this node enable [omni.syntheticdata](../Overview.html#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Cuda Stream (inputs:cudaStream) | uint64 | Pointer to the CUDA stream | 0 |
| Exec (inputs:exec) | execution | Trigger | None |
| Render Results (inputs:renderResults) | uint64 | Render results pointer | 0 |
| Render Var (inputs:renderVar) | token | Name of the renderVar | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Outputs
| Buffer Size (outputs:bufferSize) | uint64 | Size (in bytes) of the buffer (0 if the input is a texture) | None |
| --- | --- | --- | --- |
| Cuda Stream (outputs:cudaStream) | uint64 | Pointer to the CUDA stream | None |
| Data (outputs:data) | uchar[] | Buffer array data | [] |
| Received (outputs:exec) | execution | Executes when the event is received | None |
| Format (outputs:format) | uint64 | Format | None |
| Height (outputs:height) | uint | Height (0 if the input is a buffer) | None |
| Strides (outputs:strides) | int[2] | Strides (in bytes) ([0,0] if the input is a buffer) | None |
| Width (outputs:width) | uint | Width (0 if the input is a buffer) | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.syntheticdata.SdRenderVarToRawArray |
| Version | 2 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| Categories | graph:action |
| Generated Class Name | OgnSdRenderVarToRawArrayDatabase |
| Python Module | omni.syntheticdata | | 1,767 |
OgnSdSemanticFilter.md | # Sd Semantic Filter
Synthetic Data node to declare a semantic filter.
## Installation
To use this node enable `omni.syntheticdata` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (`inputs:exec`) | `execution` | Dependency | None |
| Hierarchical Labels (`inputs:hierarchicalLabels`) | `bool` | If true the filter consider all labels in the semantic hierarchy above the prims | False |
| Matching Labels (`inputs:matchingLabels`) | `bool` | If true output only the labels matching the filter (if false keep all labels of the matching prims) | True |
| Name (`inputs:name`) | `token` | Filter unique identifier [if empty, use the normalized predicate as an identifier] | |
| Predicate (`inputs:predicate`) | `token` | The semantic filter specification : a disjunctive normal form of semantic type and label | |
## Outputs
## Metadata
### Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.syntheticdata.SdSemanticFilter |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | graph:simulation |
| Generated Class Name | OgnSdSemanticFilterDatabase |
| Python Module | omni.syntheticdata | | 1,596 |
OgnSdSemanticLabelsMap.md | # Sd Semantic Labels Map
Synthetic Data node to expose the semantic labels map of a given semantic filter
## Installation
To use this node enable [omni.syntheticdata](#ext-omni-syntheticdata) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Exec (inputs:exec) | execution | Trigger | None |
| Gpu (inputs:gpu) | uint64 | Pointer to shared context containing gpu foundations. | 0 |
| Render Product Path (inputs:renderProductPath) | token | RenderProduct prim path | |
| Render Results (inputs:renderResults) | uint64 | Render results | 0 |
| Semantic Filter Name (inputs:semanticFilterName) | token | Name of the semantic filter to apply to the semanticLabelToken | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Name | Type | Descripton | Default |
|------|------|------------|---------|
| Cuda Device Index (outputs:cudaDeviceIndex) | int | Cuda index of the device the cuda buffer is residing in | -1 |
| Received (outputs:exec) | execution | Executes for each newFrame event received | None |
| Last Update Time Denominator (outputs:lastUpdateTimeDenominator) | uint64 | Time denominator of the last time the data has changed | None |
| Last Update Time Numerator (outputs:lastUpdateTimeNumerator) | int64 | Time numerator of the last time the data has changed | None |
| Min Semantic Index (outputs:minSemanticIndex) | uint | Lower semantic id. Semantics ids are in [minSemanticIndex, minSemanticIndex+numSemantic-1] | None |
| Num Semantics (outputs:numSemantics) | uint | Number of semantics in the scene | None |
| Semantic Filter Name (outputs:semanticFilterName) | token | Name of the semantic filter to apply to the semanticLabelToken | None |
| Semantic Label Token SD Cuda Ptr (outputs:semanticLabelTokenSDCudaPtr) | uint64 | uint64_t cuda buffer pointer of size numSemantics containing the semantic label token | None |
| Semantic Label Token SD Host Ptr (outputs:semanticLabelTokenSDHostPtr) | uint64 | uint64_t host buffer pointer of size numSemantics containing the semantic label token | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.syntheticdata.SdSemanticLabelsMap |
| Version | 1 |
| Extension | omni.syntheticdata |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| __tokens | [“InstanceMappingInfoSDhost”, “SemanticLabelTokenSD”, “SemanticLabelTokenSDhost”] |
|----------|----------------------------------------------------------------------------------------|
| Categories | graph:postRender,graph:action |
| Generated Class Name | OgnSdSemanticLabelsMapDatabase |
| Python Module | omni.syntheticdata | | 2,725 |
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 | | 1,496 |
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 | | 1,006 |
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 | | 3,621 |
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 | | 2,774 |
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 | | 1,815 |
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 | | 3,685 |
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 | | 2,070 |
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 | | 1,503 |
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 | | 2,145 |
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 | | 2,028 |
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 | 1,489 |
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 | | 993 |
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 | | 3,301 |
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 | | 1,702 |
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 | 1,603 |
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 | | 2,300 |
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 | | 1,298 |
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 | | 1,707 |
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 | 1,373 |
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 | | 1,725 |
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 | | 1,671 |
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 | 2,035 |
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 | | 1,651 |
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 | | 1,362 |
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 | | 1,767 |
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 | | 1,502 |
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 | | 1,519 |
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 | | 2,096 |
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 | 3,844 |
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 | | 1,869 |
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 | | 1,908 |
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 | | 1,323 |
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 class="pre">'normalh[3][]',
<span class="pre">'pointd[3]',
<span class="pre">'pointd[3][]',
<span class="pre">'pointf[3]',
<span class="pre">'pointf[3][]',
<span class="pre">'pointh[3]',
<span class="pre">'pointh[3][]',
<span class="pre">'quatd[4]',
<span class="pre">'quatd[4][]',
<span class="pre">'quatf[4]',
<span class="pre">'quatf[4][]',
<span class="pre">'quath[4]',
<span class="pre">'quath[4][]',
<span class="pre">'texcoordd[2]',
<span class="pre">'texcoordd[2][]',
<span class="pre">'texcoordd[3]',
<span class="pre">'texcoordd[3][]',
<span class="pre">'texcoordf[2]',
<span class="pre">'texcoordf[2][]',
<span class="pre">'texcoordf[3]',
<span class="pre">'texcoordf[3][]',
<span class="pre">'texcoordh[2]',
<span class="pre">'texcoordh[2][]',
<span class="pre">'texcoordh[3]',
<span class="pre">'texcoordh[3][]',
<span class="pre">'timecode',
<span class="pre">'timecode[]',
<span class="pre">'vectord[3]',
<span class="pre">'vectord[3][]',
<span class="pre">'vectorf[3]',
<span class="pre">'vectorf[3][]',
<span class="pre">'vectorh[3]',
<span class="pre">'vectorh[3][]']
<section id="outputs">
<h2>Outputs
<table>
<colgroup>
<col style="width: 20%"/>
<col style="width: 20%"/>
<col style="width: 50%"/>
<col style="width: 10%"/>
<thead>
<tr class="row-odd">
<th>Name
<th>Type
<th>Descripton
<th>Default
<tbody>
<tr class="row-even">
<td>Result (<em>outputs:value
<td>
<code class="docutils literal notranslate">
<span class="pre">'colord[3]',
<span class="pre">'colord[3][]',
<span class="pre">'colord[4]',
<span class="pre">'colord[4][]',
<span class="pre">'colorf[3]',
<span class="pre">'colorf[3][]',
<span class="pre">'colorf[4]',
<span class="pre">'colorf[4][]',
<span class="pre">'colorh[3]',
<span class="pre">'colorh[3][]',
<span class="pre">'colorh[4]',
<span class="pre">'colorh[4][]',
<span class="pre">'double',
<span class="pre">'double[2]',
<span class="pre">'double[2][]',
<span class="pre">'double[3]',
<span class="pre">'double[3][]',
<span class="pre">'double[4]',
<span class="pre">'double[4][]',
<span class="pre">'double[]',
<span class="pre">'float',
<span class="pre">'float[2]',
<span class="pre">'float[2][]',
<span class="pre">'float[3]',
<span class="pre">'float[3][]',
<span class="pre">'float[4]',
<span class="pre">'float[4][]',
<span class="pre">'float[]',
<span class="pre">'half',
<span class="pre">'half[2]',
<span class="pre">'half[2][]',
<span class="pre">'half[3]',
<span class="pre">'half[3][]',
<span class="pre">'half[4]',
<span class="pre">'half[4][]',
<span class="pre">'half[]',
<span class="pre">'normald[3]',
<span class="pre">'normald[3][]',
<span class="pre">'normalf[3]',
<span class="pre">'normalf[3][]',
<span class="pre">'normalh[3]',
<span class="pre">'normalh[3][]',
<span class="pre">'pointd[3]',
<span class="pre">'pointd[3][]',
<span class="pre">'pointf[3]',
<span class="pre">'pointf[3][]',
<span class="pre">'pointh[3]',
<span class="pre">'pointh[3][]',
<span class="pre">'quatd[4]',
<span class="pre">'quatd[4][]',
<span class="pre">'quatf[4]',
<span class="pre">'quatf[4][]',
<span class="pre">'quath[4]',
<span class="pre">'quath[4][]',
<span class="pre">'texcoordd[2]',
<span class="pre">'texcoordd[2][]',
<span class="pre">'texcoordd[3]',
<span class="pre">'texcoordd[3][]',
<td>None
<section id="sine-operator">
<h2>Sine Operator
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Input
<th class="head">
<p>Output
<th class="head">
<p>Description
<tbody>
<tr class="row-even">
<td>
<p>
<code>'texcoordf[2]'
<code>'texcoordf[2][]'
<code>'texcoordf[3]'
<code>'texcoordf[3][]'
<code>'texcoordh[2]'
<code>'texcoordh[2][]'
<code>'texcoordh[3]'
<code>'texcoordh[3][]'
<code>'timecode'
<code>'timecode[]'
<code>'vectord[3]'
<code>'vectord[3][]'
<code>'vectorf[3]'
<code>'vectorf[3][]'
<code>'vectorh[3]'
<code>'vectorh[3][]'
<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.
<td>
<p>None
<section id="metadata">
<h2>Metadata
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Name
<th class="head">
<p>Value
<tbody>
<tr class="row-even">
<td>
<p>Unique ID
<td>
<p>omni.graph.nodes.Sin
<tr class="row-odd">
<td>
<p>Version
<td>
<p>1
<tr class="row-even">
<td>
<p>Extension
<td>
<p>omni.graph.nodes
<tr class="row-odd">
<td>
<p>Has State?
<td>
<p>False
<tr class="row-even">
<td>
<p>Implementation Language
<td>
<p>C++
<tr class="row-odd">
<td>
<p>Default Memory Type
<td>
<p>cpu
<tr class="row-even">
<td>
<p>Generated Code Exclusions
<td>
<p>None
<tr class="row-odd">
<td>
<p>uiName
<td>
<p>Sine
<tr class="row-even">
<td>
<p>Categories
<td>
<p>math:operator
<tr class="row-odd">
<td>
<p>Generated Class Name
<td>
<p>OgnSinDatabase
<tr class="row-even">
<td>
<p>Python Module
<td>
<p>omni.graph.nodes
| 7,445 |
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 | 2,637 |
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 | | 1,244 |
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 | | 1,701 |
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 | | 1,830 |
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 | | 1,171 |
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 | | 1,153 |
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 | | 1,017 |
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 | | 1,272 |
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 | 6,009 |
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 | | 1,044 |
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 | | 2,026 |
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 | | 1,741 |
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
<td>
<p>
<code>
'texcoordd[2]',
<code>
'texcoordd[2][]',
<code>
'texcoordd[3]',
<code>
'texcoordd[3][]',
<code>
'texcoordf[2]',
<code>
'texcoordf[2][]',
<code>
'texcoordf[3]',
<code>
'texcoordf[3][]',
<code>
'texcoordh[2]',
<code>
'texcoordh[2][]',
<code>
'texcoordh[3]',
<code>
'texcoordh[3][]',
<code>
'timecode',
<code>
'timecode[]',
<code>
'vectord[3]',
<code>
'vectord[3][]',
<code>
'vectorf[3]',
<code>
'vectorf[3][]',
<code>
'vectorh[3]',
<code>
'vectorh[3][]'
<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.
<td>
<p>
None
## Metadata
<table>
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr>
<th>
<p>
Name
<th>
<p>
Value
<tbody>
<tr>
<td>
<p>
Unique ID
<td>
<p>
omni.graph.nodes.Tan
<tr>
<td>
<p>
Version
<td>
<p>
1
<tr>
<td>
<p>
Extension
<td>
<p>
omni.graph.nodes
<tr>
<td>
<p>
Has State?
<td>
<p>
False
<tr>
<td>
<p>
Implementation Language
<td>
<p>
C++
<tr>
<td>
<p>
Default Memory Type
<td>
<p>
cpu
<tr>
<td>
<p>
Generated Code Exclusions
<td>
<p>
None
<tr>
<td>
<p>
uiName
<td>
<p>
Tangent
<tr>
<td>
<p>
Categories
<td>
<p>
math:operator
<tr>
<td>
<p>
Generated Class Name
<td>
<p>
OgnTanDatabase
<tr>
<td>
<p>
Python Module
<td>
<p>
omni.graph.nodes
| 4,815 |
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 | 1,249 |
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 | | 1,005 |
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 | | 1,549 |
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 | | 883 |
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 | | 898 |
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 | | 1,239 |
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 | | 1,038 |
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 | 1,558 |
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 | | 961 |
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 | | 970 |
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 | | 2,258 |
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 | | 859 |
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 | | 1,543 |
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
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 20%"/>
<col style="width: 20%"/>
<col style="width: 60%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Input
<th class="head">
<p>Type
<th class="head">
<p>Description
<tbody>
<tr class="row-even">
<td>
<p>'texcoordf[3][]'
<td>
<p>float3
<td>
<p>None
<tr class="row-odd">
<td>
<p>'texcoordh[2]'
<td>
<p>half2
<td>
<p>None
<tr class="row-even">
<td>
<p>'texcoordh[2][]'
<td>
<p>half2
<td>
<p>None
<tr class="row-odd">
<td>
<p>'texcoordh[3]'
<td>
<p>half3
<td>
<p>None
<tr class="row-even">
<td>
<p>'texcoordh[3][]'
<td>
<p>half3
<td>
<p>None
<tr class="row-odd">
<td>
<p>'timecode'
<td>
<p>Timecode
<td>
<p>None
<tr class="row-even">
<td>
<p>'timecode[]'
<td>
<p>Timecode
<td>
<p>None
<tr class="row-odd">
<td>
<p>'vectord[3]'
<td>
<p>double3
<td>
<p>None
<tr class="row-even">
<td>
<p>'vectord[3][]'
<td>
<p>double3
<td>
<p>None
<tr class="row-odd">
<td>
<p>'vectorf[3]'
<td>
<p>float3
<td>
<p>None
<tr class="row-even">
<td>
<p>'vectorf[3][]'
<td>
<p>float3
<td>
<p>None
<tr class="row-odd">
<td>
<p>'vectorh[3]'
<td>
<p>half3
<td>
<p>None
<tr class="row-even">
<td>
<p>'vectorh[3][]'
<td>
<p>half3
<td>
<p>None
<section id="metadata">
<h2>Metadata
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Name
<th class="head">
<p>Value
<tbody>
<tr class="row-even">
<td>
<p>Unique ID
<td>
<p>omni.graph.nodes.ToDeg
<tr class="row-odd">
<td>
<p>Version
<td>
<p>1
<tr class="row-even">
<td>
<p>Extension
<td>
<p>omni.graph.nodes
<tr class="row-odd">
<td>
<p>Has State?
<td>
<p>False
<tr class="row-even">
<td>
<p>Implementation Language
<td>
<p>C++
<tr class="row-odd">
<td>
<p>Default Memory Type
<td>
<p>cpu
<tr class="row-even">
<td>
<p>Generated Code Exclusions
<td>
<p>None
<tr class="row-odd">
<td>
<p>uiName
<td>
<p>To Degrees
<tr class="row-even">
<td>
<p>Categories
<td>
<p>math:conversion
<tr class="row-odd">
<td>
<p>Generated Class Name
<td>
<p>OgnToDegDatabase
<tr class="row-even">
<td>
<p>Python Module
<td>
<p>omni.graph.nodes
| 5,904 |
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 | | 3,830 |
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 | | 1,942 |
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 | | 3,133 |
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 | | 2,463 |
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 | | 1,447 |
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
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Input
<th class="head">
<p>Description
<th class="head">
<p>Default Value
<tbody>
<tr class="row-even">
<td>
<p>angle
<td>
<p>Angle value in degrees
<td>
<p>None
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Output
<th class="head">
<p>Description
<th class="head">
<p>Default Value
<tbody>
<tr class="row-even">
<td>
<p>radians
<td>
<p>Angle value in radians
<td>
<p>None
<section id="metadata">
<h2>Metadata
<table class="colwidths-given docutils align-default">
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
<thead>
<tr class="row-odd">
<th class="head">
<p>Name
<th class="head">
<p>Value
<tbody>
<tr class="row-even">
<td>
<p>Unique ID
<td>
<p>omni.graph.nodes.ToRad
<tr class="row-odd">
<td>
<p>Version
<td>
<p>1
<tr class="row-even">
<td>
<p>Extension
<td>
<p>omni.graph.nodes
<tr class="row-odd">
<td>
<p>Has State?
<td>
<p>False
<tr class="row-even">
<td>
<p>Implementation Language
<td>
<p>C++
<tr class="row-odd">
<td>
<p>Default Memory Type
<td>
<p>cpu
<tr class="row-even">
<td>
<p>Generated Code Exclusions
<td>
<p>None
<tr class="row-odd">
<td>
<p>uiName
<td>
<p>To Radians
<tr class="row-even">
<td>
<p>Categories
<td>
<p>math:conversion
<tr class="row-odd">
<td>
<p>Generated Class Name
<td>
<p>OgnToRadDatabase
<tr class="row-even">
<td>
<p>Python Module
<td>
<p>omni.graph.nodes
| 5,971 |
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 | | 3,032 |
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 | | 2,005 |
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 | | 1,652 |
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 | | 1,473 |
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 | | 1,584 |
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 | | 1,429 |
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 | | 2,311 |
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 | | 2,017 |
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 | | 2,496 |
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 | | 1,832 |
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 | | 1,468 |
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 | 1,455 |
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](#). | 1,907 |
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) | 1,444 |
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). | 3,033 |
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 | 1,669 |
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 | 1,648 |