file_path
stringlengths 5
148
| content
stringlengths 150
498k
| size
int64 150
498k
|
|---|---|---|
OgnBundleConstructor.md | # Bundle Constructor
This node creates a bundle mirroring all of the dynamic input attributes that have been added to it. If no dynamic attributes exist then the bundle will be empty. See the ‘InsertAttribute’ node for something that can construct a bundle from existing connected attributes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Constructed Bundle (`outputs:bundle`) | `bundle` | The bundle consisting of copies of all of the dynamic input attributes. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.BundleConstructor |
| Version | 1 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.BundleConstructor.svg |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Bundle Constructor |
| Categories | bundle |
|------------|--------|
| Generated Class Name | OgnBundleConstructorDatabase |
| Python Module | omni.graph.nodes | | 1,097 |
OgnBundleInspector.md | # Bundle Inspector
This node creates independent outputs containing information about the contents of a bundle. It can be used for testing or debugging what is inside a bundle as it flows through the graph. The bundle is inspected recursively, so any bundles inside of the main bundle will have their contents added to the output as well. The bundle contents can be printed when the node executes, and it passes the input straight through unchanged, so you can insert this node between two nodes to inspect the data flowing through the graph.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|---------------|-------------------------------------------------|---------|
| Bundle To Analyze | bundle | The bundle to be inspected. | None |
| Exec In | execution | Signal to the graph that this node is ready to be executed. | None |
| Inspect Depth | int | The depth that the inspector is going to traverse and print. For example, 0 means just attributes on the input bundles. 1 means its immediate children. -1 means the entire recursive contents of the bundle. | 1 |
| Print Contents | bool | If true then the contents of ‘Bundle To Analyze’ will print when the node executes. | False |
## Outputs
| Name | Type | Descripton | Default |
|-----------------------|---------------|-------------------------------------------------|---------|
| Bundle To Analyze | bundle | The bundle to be inspected. | None |
| Exec In | execution | Signal to the graph that this node is ready to be executed. | None |
| Inspect Depth | int | The depth that the inspector is going to traverse and print. For example, 0 means just attributes on the input bundles. 1 means its immediate children. -1 means the entire recursive contents of the bundle. | 1 |
| Print Contents | bool | If true then the contents of ‘Bundle To Analyze’ will print when the node executes. | False |
## Metadata
### Name
- Unique ID
- Version
- Extension
- Icon
### Value
- omni.graph.nodes.BundleInspector
- 4
- omni.graph.nodes
- ogn/icons/omni.graph.nodes.BundleInspector.svg
| Has State? | False |
| --- | --- |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Bundle Inspector |
| Categories | bundle |
| Generated Class Name | OgnBundleInspectorDatabase |
| Python Module | omni.graph.nodes | | 2,754 |
OgnBundleToUSDA.md | # Bundle to USDA Text
Outputs a representation of the content of a bundle as usda text
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Bundle (inputs:bundle) | bundle | The bundle to convert to usda text. | None |
| Output Ancestors (inputs:outputAncestors) | bool | If usePath is true and this is also true, ancestor “primPath” entries will be output. | False |
| Output Values (inputs:outputValues) | bool | If true, the values of attributes will be output, else values will be omitted. | True |
| Use Prim Path (inputs:usePrimPath) | bool | Use the attribute named “primPath” for the usda prim path. | True |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Use Prim Type (inputs:usePrimType) | bool | Use the attribute named “primType” for the usda prim type name. | True |
| Use Primvar Metadata (inputs:usePrimvarMetadata) | bool | Identify attributes representing metadata like the interpolation type for primvars, and include them as usda metadata in the output text. | True |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Text (outputs:text) | token | Output usda text representing the bundle contents. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.BundleToUSDA |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Bundle to USDA Text |
| Categories | bundle |
| Generated Class Name | OgnBundleToUSDADatabase |
| Python Module | omni.graph.nodes | | 1,704 |
OgnButton.md | # Button (BETA)
Create a button widget on the Viewport
Here is an example of a button that was created using the text `Press Me`:
## Installation
To use this node enable `omni.graph.ui_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Create (`inputs:create`) | `execution` | Input execution to create and show the widget | None |
| Parent Widget Path (`inputs:parentWidgetPath`) | `token` | The absolute path to the parent widget. | |
| Size (`inputs:size`) | `double[2]` | The width and height of the created widget. Value of 0 means the created widget will be just large enough to fit everything. | [0.0, 0.0] |
| Start Hidden (`inputs:startHidden`) | `bool` | Determines whether the button will initially be visible (False) or not (True). | False |
| Style (`inputs:style`) | `string` | Style to be applied to the button. This can later be changed with the WriteWidgetStyle node. | None |
## Inputs
| Input Name | Type | Description | Default |
|------------|------|-------------|---------|
| Text (`inputs:text`) | string | The text that is displayed on the button | 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 |
## Outputs
| Output Name | Type | Description | Default |
|-------------|------|-------------|---------|
| Created (`outputs:created`) | execution | Executed when the widget is created | None |
| Widget Path (`outputs:widgetPath`) | token | The absolute path to the created widget | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.ui_nodes.Button |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| hidden | True |
| uiName | Button (BETA) |
| Categories | internal:test |
| Generated Class Name | OgnButtonDatabase |
| Python Module | omni.graph.ui_nodes |
Further information on the button operation can be found in the documentation of `omni.ui.Button`. | 2,166 |
OgnCapitalizeString.md | # Capitalize String
Formats a string based on a formatting operation (Upper Case, Lower Case, Capitalize, Title, etc.).
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Operation (`inputs:operation`) | `token` | The formatting operation. | UpperCase |
| Metadata | | `literalOnly` = 1 | |
| Metadata | | `allowedTokens` = UpperCase,LowerCase,Capitalize,Title | |
| String (`inputs:string`) | `['string', 'token', 'token[]']` | The base string. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| String (`outputs:string`) | `['string', 'token', 'token[]']` | | |
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.CapitalizeString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Capitalize String |
| Categories | function |
| Generated Class Name | OgnCapitalizeStringDatabase |
| Python Module | omni.graph.nodes | | 1,370 |
OgnCeil.md | # Ceiling
## Ceiling
Compute the ceiling value of a scalar, array of scalars, vector, or array of vectors; in the latter three cases the operator is applied to every single scalar element in the corresponding structures. The ceiling (sometimes shortenend to ceil) of a real number “A” is defined to be the smallest possible integer that is still greater than or equal to “A”.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (inputs:a) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalf[4]', 'normalf[4][]', 'normalf[]', 'quatd', 'quatd[]', 'quatf', 'quatf[]', 'quath', 'quath[]', 'uint', 'uint[2]', 'uint[2][]', 'uint[3]', 'uint[3][]', 'uint[4]', 'uint[4][]', 'uint[]', 'ulong', 'ulong[2]', 'ulong[2][]', 'ulong[3]', 'ulong[3][]', 'ulong[4]', 'ulong[4][]', 'ulong[]', 'ushort', 'ushort[2]', 'ushort[2][]', 'ushort[3]', 'ushort[3][]', 'ushort[4]', 'ushort[4][]', 'ushort[]'] | | |
# Inputs
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| A | `['int', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]']` | The scalar(s) or vector(s) to compute the ceil of. | None |
# Outputs
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | `['int', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]']` | The original input “A” with the ceil operator applied to each member. The structure of the result, arrays and tuples, will mirror that of the input. | None |
# Metadata
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.Ceil |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Ceiling |
| Categories | math:operator |
| Generated Class Name | OgnCeilDatabase |
| Python Module | omni.graph.nodes | | 2,486 |
OgnClamp.md | # Clamp — kit-omnigraph 1.143.1 documentation
## Clamp
Clamp a number or array of numbers to a specified range. If an array of numbers is provided as the input and lower/upper are scalars then each input numeric will be clamped to the range [lower, upper]. If all inputs are arrays, clamping will be done element-wise, where “Lower” and “Upper” are applied individually to each element in “Input”. An error will be reported if “Lower” > “Upper”.
### Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
### Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (inputs:input) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int'] | | |
'int64',
'int64[]',
'int[2]',
'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 input values to clamp. These can be scalar values, tuple values, matrix values, or arrays of any of them.
None
Lower (inputs:lower)
```
'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][]',
| Property | Description | Default |
|----------|-------------|---------|
| Input (inputs:input) | The input value to be clamped. | None |
| Lower (inputs:lower) | The lower bound of the clamp, which must be of the same base type as “Input” and <= “Upper”. | None |
| Upper (inputs:upper) | The upper bound of the clamp, which must be of the same base type as “Input” and >= “Lower”. | None |
**Input Types:**
- `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][]`
**Lower Types:**
- The lower bound of the clamp, which must be of the same base type as “Input” and <= “Upper”.
**Upper Types:**
- `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 upper bound of the clamp, which must be of the same base type as “Input” and >= “Lower”.
None
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Output (outputs:result) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64'] | | |
# Node Details
## Inputs
| Name | Type | Description |
| --- | --- | --- |
| `numerics` | ['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][]'] | A copy of the “numerics” after the clamping operation has been applied to it. |
| `min` | ['int64', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]'] | The minimum value to clamp to. |
| `max` | ['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 maximum value to clamp to. |
## Outputs
| Name | Type | Description |
| --- | --- | --- |
| `clampedNumerics` | ['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][]'] | A copy of the “numerics” after the clamping operation has been applied to it. |
# Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.Clamp |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Clamp |
| Categories | math:operator |
| Generated Class Name | OgnClampDatabase |
| Python Module | omni.graph.nodes | | 10,391 |
OgnClampDouble.md | # Clamp Double (Python)
Example node that clamps a number to a range
## Installation
To use this node, enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Max (`inputs:max`) | `double` | Maximum value | 0 |
| Min (`inputs:min`) | `double` | Minimum value | 0 |
| Num (`inputs:num`) | `double` | Input number | 0 |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Out (`outputs:out`) | `double` | The result of the number, having been clamped to the range min,max | None |
## Name Value Table
| Name | Value |
|---------------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.ClampDouble |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Clamp Double (Python) |
| Categories | examples |
| Generated Class Name | OgnClampDoubleDatabase |
| Python Module | omni.graph.examples.python | | 1,516 |
OgnClearVariantSelection.md | # Clear Variant Selection
This node will clear the variant selection of the prim on the active layer. Final variant selection will be determined by layer composition below your active layer. In a single layer stage, this will be the fallback variant defined in your variantSet.
## 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 Set Name (inputs:variantSetName) | token | The variantSet name | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Exec Out (outputs:execOut)
### Code Block
```
execution
```
### Description
Signal to the graph that execution can continue downstream.
### Return Value
None
## Metadata
### Table: Metadata Details
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.ClearVariantSelection |
| Version | 2 |
| Extension | omni.graph.nodes |
| Icon | ogn/icons/omni.graph.nodes.ClearVariantSelection.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Clear Variant Selection |
| Categories | graph:action,sceneGraph,variants |
| Generated Class Name | OgnClearVariantSelectionDatabase |
| Python Module | omni.graph.nodes | | 1,964 |
OgnCompare.md | # Compare
Outputs the truth value of a comparison operation. Tuples are compared in lexicographic order. If one input is an array and the other is a scalar, the scalar will be broadcast to the size of the array.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['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',
'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 first of the two inputs for which comparison will be invoked.
None
B (inputs:b)
['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',
'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][]'
```
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| A (inputs:A) | ['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][]'] | The first of the two inputs for which comparison will be invoked. | None |
| B (inputs:B) | ['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][]'] | The second of the two inputs for which comparison will be invoked. | None |
## Operation (inputs:operation)
- Type: token
- Description: The comparison operation to perform (>,<,>=,<=,==,!=)
- Default: >
## Metadata
- allowedTokens = >,<,>=,<=,==,!=
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | ['bool', 'bool[]'] | The truth-value result of the comparison operation between inputs “A” and “B”. | None |
| Unique ID | omni.graph.nodes.Compare |
|--------------------|--------------------------|
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type| cpu |
| Generated Code Exclusions | None |
| uiName | Compare |
| Categories | math:condition |
| Generated Class Name | OgnCompareDatabase |
| Python Module | omni.graph.nodes | | 6,382 |
OgnCompareTargets.md | # Compare Targets
Outputs the value of a comparison operation on target arrays.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `target` | Input A | None |
| B (`inputs:b`) | `target` | Input B | None |
| Compare Each (`inputs:compareEach`) | `bool` | If true, compare each array per-element. If false, compare the entire array and output a single value. | False |
| Operation (`inputs:operation`) | `token` | The comparison operation to perform (==,!=) | == |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | ['bool', 'bool[]'] | The result of the comparison operation | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.CompareTargets |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Compare Targets |
| Categories | math:condition |
| Generated Class Name | OgnCompareTargetsDatabase |
| Python Module | omni.graph.nodes | | 1,184 |
OgnComposeDouble3.md | # Compose Double3 (Python)
Example node that takes in the components of three doubles and outputs a double3
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| X (inputs:x) | double | The x component of the input double3 | 0 |
| Y (inputs:y) | double | The y component of the input double3 | 0 |
| Z (inputs:z) | double | The z component of the input double3 | 0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Double3 (outputs:double3) | double[3] | Output double3 | None |
## Metadata
| Name | Value |
|--------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.ComposeDouble3 |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Compose Double3 (Python) |
| Categories | examples |
| Generated Class Name | OgnComposeDouble3Database |
| Python Module | omni.graph.examples.python | | 1,439 |
OgnCompound.md | # Example Node: Compound
Encapsulation of one more other nodes into a single node entity. The compound node doesn’t have any functionality of its own, it is merely a wrapper for a set of nodes that perform a complex task. It presents a more limited set of input and output attributes than the union of the contained nodes to make it seem as though a single node is performing a higher level function. For example a compound node could present inputs a, b, and c, and outputs root1 and root2 at the compound boundary, wiring up simple math nodes square, squareRoot, add, subtract, times, and divided_by in a simple way that calculates quadratic roots. (root1 = divide(add(b, square_root(subtract(square(b), times(4, times(a, c))))))) (root2 = divide(subtract(b, square_root(subtract(square(b), times(4, times(a, c)))))))
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.examples.cpp.Compound |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Compound |
| Categories | examples |
| Generated Class Name | OgnCompoundDatabase |
| Python Module | omni.graph.examples.cpp | | 1,772 |
OgnConstantBool.md | # Constant Bool
Container for a boolean value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `bool` | The value, acting as both input and output. | False |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantBool |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
## 表格内容
| 列1 | 列2 |
| --- | --- |
| OgnConstantBoolDatabase | |
| Python Module | omni.graph.nodes | | 827 |
OgnConstantColor3d.md | # Constant Color3d
Container for a double-precision floating-point RGB color value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `colord[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantColor3d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantColor3dDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 912 |
OgnConstantColor3f.md | # Constant Color3f
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `colorf[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantColor3f |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantColor3fDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 776 |
OgnConstantColor3h.md | # Constant Color3h
Container for a half-precision floating-point RGB color value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `colorh[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantColor3h |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantColor3hDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 908 |
OgnConstantColor4d.md | # Constant Color4d
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `colord[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | | outputOnly = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantColor4d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantColor4dDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 777 |
OgnConstantColor4f.md | # Constant Color4f
[](#constant-color4f)
Container for a single-precision floating-point RGBA color value, mainly used to share a common value between several downstream nodes. The A (alpha) value is not premultiplied.
## Installation
[](#installation)
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
[](#inputs)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `colorf[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
[](#metadata)
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantColor4f |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantColor4fDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 1,316 |
OgnConstantColor4h.md | # Constant Color4h
Container for a half-precision floating-point RGBA color value, mainly used to share a common value between several downstream nodes. The A (alpha) value is not premultiplied.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `colorh[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantColor4h |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantColor4hDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 958 |
OgnConstantDouble.md | # Constant Double
[](https://example.com/permalink-link)
Container for a double-precision floating-point value, mainly used to share a common value between several downstream nodes.
## Installation
[](https://example.com/permalink-link)
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
[](https://example.com/permalink-link)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `double` | The value, acting as both input and output. | 0.0 |
| Metadata | | `outputOnly` = 1 | |
## Metadata
[](https://example.com/permalink-link)
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantDouble |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# Main Title
## Subtitle
### Generated Class Name
### OgnConstantDoubleDatabase
### Python Module
### omni.graph.nodes | 1,214 |
OgnConstantDouble2.md | # Constant Double2
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `double[2]` | The value, acting as both input and output. | [0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantDouble2 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantDouble2Database |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 772 |
OgnConstantDouble3.md | # Constant Double3
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | double[3] | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | outputOnly = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantDouble3 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantDouble3Database |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 772 |
OgnConstantDouble4.md | # Constant Double4
[](https://example.com/permalink-link)
Container for a 4-component double-precision floating-point value, mainly used to share a common value between several downstream nodes.
## Installation
[](https://example.com/permalink-link)
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
[](https://example.com/permalink-link)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `double[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
[](https://example.com/permalink-link)
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantDouble4 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantDouble4Database |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 1,287 |
OgnConstantE.md | # Constant E
Computes the mathematical constant “e” to the power of “Exponent”.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-----------------------|---------|-------------------------------------|---------|
| Exponent (inputs:exponent) | double | The power to which to raise the mathematical constant “e”. | 1.0 |
## Outputs
| Name | Type | Descripton | Default |
|-----------------|---------|-------------------------------------|---------|
| Value (outputs:value) | double | The mathematical constant “e” raised to the ‘Exponent’ power. | None |
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.ConstantE |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
|-------------|-------|
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantEDatabase |
| Python Module | omni.graph.nodes | | 1,258 |
OgnConstantFloat.md | # Constant Float
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `float` | The value, acting as both input and output. | 0.0 |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantFloat |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
## Table
| Column 1 | Column 2 |
|----------|----------|
| OgnConstantFloatDatabase | |
| Python Module | omni.graph.nodes | | 750 |
OgnConstantFloat2.md | # Constant Float2
[](#constant-float2)
Container for a 2-component single-precision floating-point value, mainly used to share a common value between several downstream nodes.
## Installation
[](#installation)
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
[](#inputs)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `float[2]` | The value, acting as both input and output. | [0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
[](#metadata)
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantFloat2 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# 表格数据
| Generated Class Name | OgnConstantFloat2Database |
|----------------------|---------------------------|
| Python Module | omni.graph.nodes | | 985 |
OgnConstantFloat3.md | # Constant Float3
Container for a 3-component single-precision floating-point value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `float[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantFloat3 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# Generated Class Name
OgnConstantFloat3Database
# Python Module
omni.graph.nodes | 837 |
OgnConstantFloat4.md | # Constant Float4
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `float[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantFloat4 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# 表格数据
| Generated Class Name | OgnConstantFloat4Database |
|----------------------|---------------------------|
| Python Module | omni.graph.nodes | | 785 |
OgnConstantFrame.md | # Constant Frame
Container for a 4x4 double-precision floating-point matrix value with the ‘frame’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `frame[4]` | The value, acting as both input and output. | [[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 | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantFrame |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# 转换后的Markdown格式数据
## 表格数据
| Generated Class Name | OgnConstantFrameDatabase |
|----------------------|---------------------------|
| Python Module | omni.graph.nodes | | 1,028 |
OgnConstantHalf.md | # Constant Half
Container for a half-precision floating-point value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `half` | The value, acting as both input and output. | 0.0 |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantHalf |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
## Table
| Column 1 | Column 2 |
|----------|----------|
| OgnConstantHalfDatabase | |
| Python Module | omni.graph.nodes | | 869 |
OgnConstantHalf2.md | # Constant Half2
[](#constant-half2)
Container for a 2-component half-precision floating-point value, mainly used to share a common value between several downstream nodes.
## Installation
[](#installation)
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
[](#inputs)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `half[2]` | The value, acting as both input and output. | [0.0, 0.0] |
| Metadata | | outputOnly = 1 | |
## Metadata
[](#metadata)
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantHalf2 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# Main Section
## Sub Section
### Table
| Column 1 | Column 2 |
|----------|----------|
| Generated Class Name | OgnConstantHalf2Database |
| Python Module | omni.graph.nodes | | 988 |
OgnConstantHalf3.md | # Constant Half3
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `half[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantHalf3 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# Main Title
## Sub Title
### Section Title
#### Subsection Title
- **Generated Class Name**
- **OgnConstantHalf3Database**
- **Python Module**
- **omni.graph.nodes** | 779 |
OgnConstantHalf4.md | # Constant Half4
Container for a 4-component half-precision floating-point value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `half[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | | outputOnly = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantHalf4 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# Main Content
## Table of Contents
### Classes
| Class Name | Generated Class Name |
|------------|----------------------|
| Database | OgnConstantHalf4Database |
### Python Module
| Module Name | omni.graph.nodes | | 974 |
OgnConstantInt.md | # Constant Int
Container for a 32-bit signed integer value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `int` | The value, acting as both input and output. | 0 |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantInt |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
<section>
<table>
<tbody>
<tr class="row-even">
<td>
<p>
OgnConstantIntDatabase
<td>
<p>
omni.graph.nodes
<tr class="row-odd">
<td>
<p>
Python Module
<td>
<p>
omni.graph.nodes
| 1,148 |
OgnConstantInt2.md | # Constant Int2
Container for a 2-component 32-bit signed integer value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|---------------|--------------------------------|---------|
| Value (inputs:value) | `int[2]` | The value, acting as both input and output. | [0, 0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
|--------------|--------------------------------|
| Unique ID | omni.graph.nodes.ConstantInt2 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
<section>
<section>
<div>
<div>
<div>
<table>
<thead>
<tr>
<th>
<p>
Category
<th>
<p>
Description
<tbody>
<tr class="row-even">
<td>
<p>
OgnConstantInt2Database
<td>
<p>
OgnConstantInt2Database
<tr class="row-odd">
<td>
<p>
Python Module
<td>
<p>
omni.graph.nodes
<footer>
<hr/>
| 2,062 |
OgnConstantInt3.md | # Constant Int3
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `int[3]` | The value, acting as both input and output. | [0, 0, 0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantInt3 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
## 表格数据
| 列1 | 列2 |
| --- | --- |
| OgnConstantInt3Database | |
| Python Module | omni.graph.nodes | | 729 |
OgnConstantInt4.md | # Constant Int4
Container for a 4-component 32-bit signed integer value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `int[4]` | The value, acting as both input and output. | [0, 0, 0, 0] |
| Metadata | `outputOnly` = 1 | | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantInt4 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
| | |
|------------|---------------------------|
| OgnConstantInt4Database | omni.graph.nodes | | 896 |
OgnConstantInt64.md | # Constant Int64
Container for a 64-bit signed integer value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `int64` | The value, acting as both input and output. | 0 |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantInt64 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
## OgnConstantInt64Database
## Python Module
## omni.graph.nodes | 804 |
OgnConstantMatrix2d.md | # Constant Matrix2d
Container for a 2x2 double-precision floating-point matrix value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `matrixd[2]` | The value, acting as both input and output. | [[1.0, 0.0], [0.0, 1.0]] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantMatrix2d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantMatrix2dDatabase |
|----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 927 |
OgnConstantMatrix3d.md | # Constant Matrix3d
Container for a 3x3 double-precision floating-point matrix value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `matrixd[3]` | The value, acting as both input and output. | [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] |
| Metadata | | outputOnly = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantMatrix3d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantMatrix3dDatabase |
|----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 964 |
OgnConstantMatrix4d.md | # Constant Matrix4d
Container for a 4x4 double-precision floating-point matrix value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `matrixd[4]` | The value, acting as both input and output. | [[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 | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantMatrix4d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
## Table
| Generated Class Name | OgnConstantMatrix4dDatabase |
|----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 1,001 |
OgnConstantNormal3d.md | # Constant Normal3d
Container for a 3-component double-precision floating-point value with the ‘normal’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `normald[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantNormal3d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantNormal3dDatabase |
|----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 948 |
OgnConstantNormal3f.md | # Constant Normal3f
Container for a 3-component single-precision floating-point value with the ‘normal’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `normalf[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantNormal3f |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantNormal3fDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 945 |
OgnConstantNormal3h.md | # Constant Normal3h
Container for a 3-component half-precision floating-point value with the ‘normal’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `normalh[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantNormal3h |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantNormal3hDatabase |
|-----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 943 |
OgnConstantPath.md | # Constant Path
Container for a string value with the ‘path’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `path` | The value, acting as both input and output. | |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantPath |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
# OgnConstantPathDatabase
## Python Module
- omni.graph.nodes
--- | 805 |
OgnConstantPi.md | # Constant Pi
Computes a double precision floating point constant value that is a multiple of the mathematical constant ‘pi’.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------|---------|--------------------------------------|---------|
| Factor (inputs:factor) | double | Multiply this by the mathematical constant ‘pi’ to compute the output. | 1 |
## Outputs
| Name | Type | Descripton | Default |
|------------|---------|--------------------------------------|---------|
| Value (outputs:value) | double | The mathematical constant ‘pi’ multiplied by ‘Factor’. | None |
## Metadata
| Name | Value |
|------------|------------------------------------|
| Unique ID | omni.graph.nodes.ConstantPi |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
|-------------|-------|
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantPiDatabase |
| Python Module | omni.graph.nodes | | 1,294 |
OgnConstantPoint3d.md | # Constant Point3d
[](#constant-point3d)
Container for a 3-component double-precision floating-point value with the ‘point’ role, mainly used to share a common value between several downstream nodes.
## Installation
[](#installation)
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
[](#inputs)
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `pointd[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
[](#metadata)
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantPoint3d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantPoint3dDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 1,292 |
OgnConstantPoint3f.md | # Constant Point3f
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `pointf[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantPoint3f |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantPoint3fDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 777 |
OgnConstantPoint3h.md | # Constant Point3h
Container for a 3-component half-precision floating-point value with the ‘point’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `pointh[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantPoint3h |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantPoint3hDatabase |
|----------------------|----------------------------|
| Python Module | omni.graph.nodes | | 934 |
OgnConstantPrims.md | # Constant Prims (Legacy)
DEPRECATED - use ConstantTarget
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | target | The input prim paths | None |
| Metadata | | outputOnly = 1 | |
| Metadata | | allowMultiInputs = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantPrims |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
hidden | true
---|---
uiName | Constant Prims (Legacy)
---|---
Categories | sceneGraph
---|---
Generated Class Name | OgnConstantPrimsDatabase
---|---
Python Module | omni.graph.nodes | 809 |
OgnConstantQuatd.md | # Constant Quatd
Container for a 4-component double-precision floating-point value with the ‘quaternion’ role, mainly used to share a common value between several downstream nodes. The first component is the real value, the remaining three are the imaginary values.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `quatd[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantQuatd |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantQuatdDatabase |
|----------------------|--------------------------|
| Python Module | omni.graph.nodes | | 1,023 |
OgnConstantQuatf.md | # Constant Quatf
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `quatf[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | outputOnly = 1 | | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantQuatf |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
## Table
| Generated Class Name | OgnConstantQuatfDatabase |
|----------------------|--------------------------|
| Python Module | omni.graph.nodes | | 778 |
OgnConstantQuath.md | # Constant Quath
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `quath[4]` | The value, acting as both input and output. | [0.0, 0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantQuath |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantQuathDatabase |
|----------------------|--------------------------|
| Python Module | omni.graph.nodes | | 771 |
OgnConstantString.md | # Constant String
Container for a string value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `string` | The value, acting as both input and output. | |
| Metadata | `outputOnly` = 1 | | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
OgnConstantStringDatabase
Python Module
omni.graph.nodes
--- | 787 |
OgnConstantTarget.md | # Constant Target
Container for a target value with paths to one or more Prims, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `target` | The value, acting as both input and output. | None |
| Metadata | | `outputOnly` = 1 | |
| Metadata | | `allowMultiInputs` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantTarget |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | |
| Categories | constants |
|------------|-----------|
| Generated Class Name | OgnConstantTargetDatabase |
| Python Module | omni.graph.nodes | | 889 |
OgnConstantTexCoord2d.md | # Constant Tex Coord2d
Container for a 2-component double-precision floating-point UV texture coordinate value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `texcoordd[2]` | The value, acting as both input and output. | [0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantTexCoord2d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantTexCoord2dDatabase |
|----------------------|-------------------------------|
| Python Module | omni.graph.nodes | | 954 |
OgnConstantTexCoord2f.md | # Constant Tex Coord2f
Container for a 2-component single-precision floating-point UV texture coordinate value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `texcoordf[2]` | The value, acting as both input and output. | [0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantTexCoord2f |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# Generated Class Name
## OgnConstantTexCoord2fDatabase
# Python Module
## omni.graph.nodes | 877 |
OgnConstantTexCoord2h.md | # Constant Tex Coord2h
Container for a 2-component half-precision floating-point UV texture coordinate value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `texcoordh[2]` | The value, acting as both input and output. | [0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantTexCoord2h |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
## Generated Class Name
OgnConstantTexCoord2hDatabase
## Python Module
omni.graph.nodes | 871 |
OgnConstantTexCoord3d.md | # Constant Tex Coord3d
Container for a 3-component double-precision floating-point UVW texture coordinate value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `texcoordd[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantTexCoord3d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
## Generated Class Name
- OgnConstantTexCoord3dDatabase
## Python Module
- omni.graph.nodes | 883 |
OgnConstantTexCoord3f.md | # Constant Tex Coord3f
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `texcoordf[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantTexCoord3f |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
## Generated Class Name
OgnConstantTexCoord3fDatabase
## Python Module
omni.graph.nodes | 713 |
OgnConstantTexCoord3h.md | # Constant Tex Coord3h
Container for a 3-component half-precision floating-point UVW texture coordinate value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `texcoordh[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantTexCoord3h |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
## Generated Class Name
OgnConstantTexCoord3hDatabase
## Python Module
omni.graph.nodes | 877 |
OgnConstantTimecode.md | # Constant Timecode
Container for a timecode value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `timecode` | The value, acting as both input and output. | 0.0 |
| Metadata | | outputOnly = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantTimecode |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
# Generated Class Name
## OgnConstantTimecodeDatabase
## Python Module
## omni.graph.nodes | 797 |
OgnConstantToken.md | # Constant Token
Container for a token value, which is a 64-bit constant representing a shared string, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `token` | The value, acting as both input and output. | |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantToken |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | |
## 表格内容
| 类名 | 描述 |
| --- | --- |
| OgnConstantTokenDatabase | OgnConstantTokenDatabase |
| Python Module | omni.graph.nodes | | 905 |
OgnConstantUChar.md | # Constant UChar
Container for an 8-bit unsigned integer, or character, value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `uchar` | The value, acting as both input and output. | 0 |
| Metadata | `outputOnly` = 1 | | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantUChar |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Constant UChar |
| Categories | |
| Generated Class Name | OgnConstantUCharDatabase |
|----------------------|---------------------------|
| Python Module | omni.graph.nodes | | 902 |
OgnConstantUInt.md | # Constant UInt
[](https://docs.omniverse.nvidia.com/kit/docs)
## Overview
Container for a 32-bit unsigned integer value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `uint` | The value, acting as both input and output. | 0 |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantUInt |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Constant UInt |
| Categories | |
| 常量 | 生成类名 | Python 模块 |
| --- | --- | --- |
| constants | OgnConstantUIntDatabase | omni.graph.nodes | | 932 |
OgnConstantUInt64.md | # Constant UInt64 — kit-omnigraph 1.143.1 documentation
## Constant UInt64
Container for a 64-bit unsigned integer value, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `uint64` | The value, acting as both input and output. | 0 |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantUInt64 |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Constant UInt64 |
| Categories | |
| Generated Class Name | OgnConstantUInt64Database |
|----------------------|---------------------------|
| Python Module | omni.graph.nodes | | 956 |
OgnConstantVector3d.md | # Constant Vector3d
Container for a 3-component double-precision floating-point value with the ‘vector’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | vectord[3] | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | outputOnly = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantVector3d |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantVector3dDatabase |
|----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 938 |
OgnConstantVector3f.md | # Constant Vector3f
Container for a 3-component single-precision floating-point value with the ‘vector’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (`inputs:value`) | `vectorf[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantVector3f |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantVector3fDatabase |
|----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 948 |
OgnConstantVector3h.md | # Constant Vector3h
Container for a 3-component half-precision floating-point value with the ‘vector’ role, mainly used to share a common value between several downstream nodes.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Value (inputs:value) | `vectorh[3]` | The value, acting as both input and output. | [0.0, 0.0, 0.0] |
| Metadata | | `outputOnly` = 1 | |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ConstantVector3h |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| Categories | constants |
| Generated Class Name | OgnConstantVector3hDatabase |
|----------------------|-----------------------------|
| Python Module | omni.graph.nodes | | 940 |
OgnConstructArray.md | # Make Array
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Array Size (`inputs:arraySize`) | `int` | The size of the array to construct. | 1 |
| Metadata | | `literalOnly` = 1 | |
| Array Type (`inputs:arrayType`) | `token` | The type of the array to construct. A value of ‘auto’ infers the type from the first connected and resolved input. | auto |
| Metadata | | `literalOnly` = 1 | |
| Metadata | | `allowedTokens` = auto,bool[],double[],float[],half[],int[],int64[],token[],uchar[],uint[],uint64[],double[2][],double[3][],double[4][],matrixd[2][],matrixd[3][],matrixd[4][],float[2][],float[3][],float[4][],half[2][],half[3][],half[4][],int[2][],int[3][],int[4][],timecode[],frame[4][],colord[3][],colorf[3][],colorh[3][],colord[4][],colorf[4][],colorh[4][],normald[3][],normalf[3][],normalh[3][],pointd[3][],pointf[3][],pointh[3][],quatd[4][],quatf[4][],quath[4][],texcoordd[2][],texcoordf[2][],texcoordh[2][],texcoordd[3][],texcoordf[3][],texcoordh[3][],vectord[3][],vectorf[3][],vectorh[3][] | |
| Input0 (`inputs:input0`) | `['bool', 'colord[3]', 'colord[4]', ...]` | | |
## Inputs
- **Input array element**
- Type: None
- Default: None
## Outputs
### Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Array (outputs:array) | ['bool[]', 'colord[3][]', 'colord[4][]', 'colorf[3][]', 'colorf[4][]', 'colorh[3][]', 'colorh[4][]', 'double[2][]', 'double[3][]', 'double[4][]', 'double[]', 'float[2][]', 'float[3][]', 'float[4][]', 'float[]', 'frame[4][]', 'half[2][]', 'half[3][]', 'half[4][]', 'half[]', 'int64[]', 'int[2][]', 'int[3][]', 'int[4][]', 'int[]', 'matrixd[2][]', 'matrixd[3][]', 'matrixd[4][]', 'normald[3][]', 'normalf[3][]', 'normalh[3][]', 'pointd[3][]', 'pointf[3][]', 'pointh[3][]', 'quatd[4][]', 'quatf[4][]', 'quath[4][]', 'texcoordd[2][]', 'texcoordd[3][]', 'texcoordf[2][]', 'texcoordf[3][]', 'texcoordh[2][]', 'texcoordh[3][]', 'timecode[]', 'token[]', 'transform[4][]', 'uchar[]', 'uint[]', 'uint64[]', 'vectord[3][]', 'vectorf[3][]', 'vectorh[3][]'] | | None |
# ConstructArray Node
## Inputs
| Input Name | Data Type | Description |
|------------|-----------|-------------|
| Array Size | int | The size of the array to be constructed. |
| Array Type | string | The type of the array elements. |
| Input Array | array | The array from which values are populated. |
## Outputs
| Output Name | Data Type | Description |
|-------------|-----------|-------------|
| Constructed Array | array | The constructed array of size ‘Array Size’ with the data type specified in ‘Array Type’ and values populated from the input array. |
| None | None | None |
# Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.ConstructArray |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Make Array |
| Categories | math:array |
| Generated Class Name | OgnConstructArrayDatabase |
| Python Module | omni.graph.nodes | | 3,149 |
OgnCopyAttr.md | # Copy Attributes From Bundles
Copies all attributes from one input bundle and specified attributes from a second input bundle to the output bundle.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-------------------------------|------------|----------------------------------------------------------------------------|---------|
| Full Bundle To Copy (inputs:fullData) | bundle | Collection of attributes to fully copy to the output | None |
| Extracted Names For Partial Copy (inputs:inputAttrNames) | token | Comma or space separated text, listing the names of attributes to copy from partialData | |
| New Names For Partial Copy (inputs:outputAttrNames) | token | Comma or space separated text, listing the new names of attributes copied from partialData | |
| Partial Bundle To Copy (inputs:partialData) | bundle | Collection of attributes from which to select named attributes | None |
## Outputs
| Name | Type | Descripton | Default |
|-------------------------------|------------|----------------------------------------------------------------------------|---------|
| Output Bundle (outputs:outputData) | bundle | Collection of attributes copied from both input bundles | None |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.CopyAttribute |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Copy Attributes From Bundles |
| Categories | bundle |
| Generated Class Name | OgnCopyAttrDatabase |
| Python Module | omni.graph.nodes | | 2,191 |
OgnCos.md | # Cosine
## Cosine
Compute the cosine value of a scalar, array of scalars, vector, or array of vectors; in the latter three cases the cosine 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][]'] | | |
## Inputs
- `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 cosine is to be computed. Each scalar element of the value is an angle, measured in degrees.
None
## Outputs
### Name
Result (outputs:value)
### Type
- `colord[3]`
- `colord[3][]`
- `colord[4]`
- `colord[4][]`
- `colorf[3]`
- `colorf[3][]`
- `colorf[4]`
- `colorf[4][]`
- `colorh[3]`
- `colorh[3][]`
- `colorh[4]`
- `colorh[4][]`
- `double`
- `double[2]`
- `double[2][]`
- `double[3]`
- `double[3][]`
- `double[4]`
- `double[4][]`
- `double[]`
- `float`
- `float[2]`
- `float[2][]`
- `float[3]`
- `float[3][]`
- `float[4]`
- `float[4][]`
- `float[]`
- `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][]`
# Metadata
## Metadata
| Name | Value |
|------------|--------------------------|
| Unique ID | omni.graph.nodes.Cos |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Cosine |
| Categories | math:operator |
| Generated Class Name | OgnCosDatabase |
| Python Module | omni.graph.nodes | | 3,147 |
OgnCountdown.md | # Countdown
## Countdown
This type of node will activate when ‘Exec In’ is first set and will remain active for a total of ‘Duration’ ticks, where a ‘tick’ is an execution of the node. Every ‘Period’ ticks the output ‘Tick’ will activate and after the final tick ‘Finished’ will activate.
For example if ‘Duration’ is set to 10 and ‘Period’ is set to 3 then after activation the ‘Tick’ signal will activate after 3, 6, and 9 executions, and ‘Finished’ will activate after the 10th.
If ‘Exec In’ is activated again before the current countdown has finished, the countdown will be reset to the start.
The first execution is considered number 0 and does not generate an activation signal.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Duration (`inputs:duration`) | `int` | The duration of the delay in ticks. | 5 |
| Exec In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Period (`inputs:period`) | `int` | The period of the pulse in ticks. | 1 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Alpha (`outputs:alpha`) | | | |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Progress | float | On first execution this is set to 0, indicating that there is no progress on the countdown. For every subsequent execution it is set to the normalized progress of the countdown as a value between 0 and 1 computed as ‘Tick Value’/’Duration’. After the countdown is complete it keeps a value of 1 until the next time the countdown is reset by activating ‘Exec In’. | None |
| Finished (outputs:finished) | execution | After ‘Duration’ ticks of this node have completed since ‘Exec In’ was activated signal the graph that execution can continue downstream. | None |
| Tick (outputs:tick) | execution | Every ‘Period’ ticks after ‘Exec In’ has been activated signal the graph that execution can continue downstream. | None |
| Tick Value (outputs:tickValue) | int | The current tick value, active in the range [1, ‘Duration’]. | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Count (state:count) | int | The number of ticks elapsed. The first tick is 0. A value of -1 means execution has not yet been activated. | -1 |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.action.Countdown |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | True |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Countdown |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnCountdownDatabase |
| Python Module | omni.graph.action_nodes | | 2,824 |
OgnCounter.md | # Counter
This node counts the number of times it has been executed since the ‘Reset’ signal was activated.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
| Reset (`inputs:reset`) | `execution` | Signal to the node to reset its internal counter. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Count (`outputs:count`) | `int` | The number of times this node has been executed since being reset. | None |
| Execute Out (`outputs:execOut`) | `execution` | Signal to the graph that execution can continue downstream. | None |
## State
### Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.action.Counter |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Counter |
| Categories | graph:action,function |
| Generated Class Name | OgnCounterDatabase |
| Python Module | omni.graph.action_nodes | | 1,445 |
OgnCountTo.md | # Count To
Example stateful node that counts to countTo by a certain increment
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Count To (`inputs:countTo`) | `double` | The ceiling to count to | 3 |
| Increment (`inputs:increment`) | `double` | Increment to count by | 0.1 |
| Reset (`inputs:reset`) | `bool` | Whether to reset the count | False |
| Trigger (`inputs:trigger`) | `double[3]` | Position to be used as a trigger for the counting | [0.0, 0.0, 0.0] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Count (`outputs:count`) | | | |
## Metadata
| Name | Value |
|--------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.CountTo |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Count To |
| Categories | examples |
| Generated Class Name | OgnCountToDatabase |
| Python Module | omni.graph.examples.python | | 1,507 |
OgnCreateTubeTopology.md | # Create Tube Topology
Creates the face vertex counts and indices describing a tube topology with the given number of rows and columns.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Column Array (`inputs:cols`) | `int[]` | Array of columns in the topology to be generated | [] |
| Row Array (`inputs:rows`) | `int[]` | Array of rows in the topology to be generated | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Face Vertex Counts (`outputs:faceVertexCounts`) | `int[]` | Array of vertex counts for each face in the tube topology | None |
| Face Vertex Indices (`outputs:faceVertexIndices`) | `int[]` | Array of vertex indices for each face in the tube topology | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.nodes.CreateTubeTopology |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Create Tube Topology |
| Categories | geometry:generator |
| Generated Class Name | OgnCreateTubeTopologyDatabase |
| Python Module | omni.graph.nodes | | 1,592 |
OgnCrossProduct.md | # Cross Product
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The first 3D vector (or array of 3D vectors) in the cross product. | None |
| B (`inputs:b`) | `['vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The second 3D vector (or array of 3D vectors) in the cross product. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.CrossProduct |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Cross Product |
| Categories | math:operator |
| Generated Class Name | OgnCrossProductDatabase |
| Python Module | omni.graph.nodes | | 1,060 |
OgnCurveFrame.md | # Create Curve From Frame
Create a frame object based on a curve description. The frame object is a combination of normal, up, and tangent vector. A frame object is generated for every subset of ‘Curve Points’ whose vertex ranges are based on the ‘Curve Vertex Starts’ and ‘Curve Vertex Counts’.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Curve Points (`inputs:curvePoints`) | `float[3][]` | Points on the curve to be framed. | [] |
| Curve Vertex Counts (`inputs:curveVertexCounts`) | `int[]` | Vertex counts for each curve frame. Must have the same number of elements as ‘Curve Vertex Starts’. | [] |
| Curve Vertex Starts (`inputs:curveVertexStarts`) | `int[]` | Vertex index starting points for each curve frame. Must have the same number of elements as ‘Curve Vertex Counts’. | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Out Vectors (`outputs:out`) | `float[3][]` | | |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Out vector directions on the curve frame. | None | None |
| Tangents (outputs:tangent) | float[3][] | Tangents on the curve frame. | None |
| Up Vectors (outputs:up) | float[3][] | Up vectors on the curve frame. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.CurveToFrame |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Create Curve From Frame |
| Categories | examples,geometry:generator |
| Generated Class Name | OgnCurveFrameDatabase |
| Python Module | omni.graph.nodes | | 1,775 |
OgnCurveTubePositions.md | # Curve Tube Positions
Take the points on a curve and a subset of vertex ranges and generate point geometry corresponding to a tube that follows the curve positions. Imagine a curve that is the center of a straw. The tube is constructed by inflating subsections of the curve.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Columns (`inputs:cols`) | `int[]` | Index along the curve where the tube is to be constructed. | [] |
| Curve Points (`inputs:curvePoints`) | `float[3][]` | Points on the curve from which the tubes are to be constructed. | [] |
| Curve Vertex Counts (`inputs:curveVertexCounts`) | `int[]` | Vertex counts for each curve frame. Must have the same number of elements as ‘Curve Vertex Starts’. | [] |
| Curve Vertex Starts (`inputs:curveVertexStarts`) | `int[]` | Vertex index starting points for each curve frame. Must have the same number of elements as ‘Curve Vertex Counts’. | [] |
| Out Vectors (`inputs:out`) | `float[3][]` | Out vector directions on the constructed tube. | [] |
## Inputs
| Input Name | Type | Description | Default Value |
|------------|------|-------------|---------------|
| Tube Point Starts (`inputs:tubePointStarts`) | `int[]` | Tube starting point index values. Must have the same number of elements as ‘Columns’. | [] |
| Up Vectors (`inputs:up`) | `float[3][]` | Up vectors on the constructed tube. | [] |
| Tube Widths (`inputs:width`) | `float[]` | Width of the constructed tube. | [] |
## Outputs
| Output Name | Type | Description | Default Value |
|-------------|------|-------------|---------------|
| Points (`outputs:points`) | `float[3][]` | Points on the tube that was constructed. | None |
## Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.CurveTubePositions |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Curve Tube Positions |
| Categories | geometry:generator |
| Generated Class Name | OgnCurveTubePositionsDatabase |
| Python Module | omni.graph.nodes | | 2,213 |
OgnCurveTubeST.md | # Curve Tube ST
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Columns (`inputs:cols`) | `int[]` | Columns of the tubes. | [] |
| Curve Vertex Counts (`inputs:curveVertexCounts`) | `int[]` | Vertex counts for each curve frame. Must have the same number of elements as ‘Curve Vertex Starts’. | [] |
| Curve Vertex Starts (`inputs:curveVertexStarts`) | `int[]` | Vertex index starting points for each curve frame. Must have the same number of elements as ‘Curve Vertex Counts’. | [] |
| Scale T Like S (`inputs:scaleTLikeS`) | `bool` | If true then scale T the same as S. | False |
| T Values (`inputs:t`) | `float[]` | T values of the tubes. | [] |
| Tube Quad Starts (`inputs:tubeQuadStarts`) | `int[]` | | [] |
# Inputs
| Description | Type | Default |
|-------------|------|---------|
| Vertex index values for the tube quad starting points. | int[] | [] |
| Vertex index values for the tube ST starting points. | int[] | [] |
| Width of tube positions, if scaling T like S. | float[] | [] |
# Outputs
| Name | Type | Descripton | Default |
|------|------|------------|---------|
| ST Values | float[2][] | Array of computed ST values. | None |
| ST Indices | int[] | Array of computed ST indices. | None |
# Metadata
| Name | Value |
|------|-------|
| Unique ID | omni.graph.nodes.CurveTubeST |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Curve Tube ST |
| Categories | geometry:generator |
| Generated Class Name | OgnCurveTubeSTDatabase |
| Python Module | omni.graph.nodes | | 1,745 |
OgnDecomposeDouble3.md | # Decompose Double3 (Python)
Example node that takes in a double3 and outputs scalars that are its components
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|------------|------------------|-----------|
| Double3 (inputs:double3) | double[3] | Input double3 | [0, 0, 0] |
## Outputs
| Name | Type | Descripton | Default |
|------|--------|---------------------------|---------|
| X (outputs:x) | double | The x component of the input double3 | None |
| Y (outputs:y) | double | The y component of the input double3 | None |
| Z (outputs:z) | double | The z component of the input double3 | None |
## Metadata
| Name | Value |
|------------|-----------------------------------------------------------------------|
| Unique ID | omni.graph.examples.python.DecomposeDouble3 |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Decompose Double3 (Python) |
| Categories | examples |
| Generated Class Name | OgnDecomposeDouble3Database |
| Python Module | omni.graph.examples.python | | 1,883 |
OgnDeformedPointsToHydra.md | # Deformed Points to Hydra
Deprecated: please refer to the example node RpResourceExampleHydra instead
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim Points (`inputs:points`) | `float[3][]` | Points attribute input. Points and a prim path may be supplied directly as an alternative to a bundle input. | [] |
| Prim path input (`inputs:primPath`) | `token` | Prim path input. Points and a prim path may be supplied directly as an alternative to a bundle input. | |
| Send to hydra (`inputs:sendToHydra`) | `bool` | send to hydra | False |
| stream (`inputs:stream`) | `uint64` | Pointer to the CUDA Stream | 0 |
| Verbose (`inputs:verbose`) | `bool` | verbose printing | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Configuration
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Reload (`outputs:reload`) | bool | Force RpResource reload | False |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.DeformedPointsToHydra |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| hidden | true |
| uiName | Deformed Points to Hydra |
| Categories | examples,graph:preRender,internal |
| Generated Class Name | OgnDeformedPointsToHydraDatabase |
| Python Module | omni.graph.nodes | | 1,512 |
OgnDeformer1_CPU.md | # Example Node: Sine Wave Deformer
Example deformer node that applies a sine wave to a mesh
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (`inputs:multiplier`) | `float` | Amplitude of sinusoidal deformer function | 0.7 |
| Points (`inputs:points`) | `pointf[3][]` | Set of points to be deformed | [] |
| Wavelength (`inputs:wavelength`) | `float` | Wavelength of sinusoidal deformer function | 50.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (`outputs:points`) | `pointf[3][]` | Set of deformed points | None |
## Metadata
| Name | Value |
|--------------|--------------------------------------------|
| Unique ID | omni.graph.examples.cpp.Deformer1 |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Sine Wave Deformer |
| Categories | examples |
| Generated Class Name | OgnDeformer1_CPUDatabase |
| Python Module | omni.graph.examples.cpp | | 1,496 |
OgnDeformer1_GPU.md | # Example Node: Sine Wave GPU Deformer
Example deformer node that applies a sine wave to a mesh using CUDA code
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (`inputs:multiplier`) | `float` | Amplitude of sinusoidal deformer function | 0.7 |
| Points (`inputs:points`) | `pointf[3][]` | Set of points to be deformed | [] |
| Wavelength (`inputs:wavelength`) | `float` | Wavelength of sinusoidal deformer function | 50.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (`outputs:points`) | `pointf[3][]` | Set of deformed points | None |
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.examples.cpp.Deformer1Gpu |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cuda |
| Generated Code Exclusions | tests |
| __memoryType | cuda |
| uiName | Example Node: Sine Wave GPU Deformer |
| Categories | examples |
| Generated Class Name | OgnDeformer1_GPUDatabase |
| Python Module | omni.graph.examples.cpp | | 1,579 |
OgnDeformer2_CPU.md | # Example Node: Z Threshold Deformer
Example deformer that limits the Z point positions to a threshold
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (`inputs:points`) | `pointf[3][]` | Set of points to be deformed | [] |
| Threshold (`inputs:threshold`) | `float` | Z value to limit points | 0.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (`outputs:points`) | `pointf[3][]` | Set of deformed points | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.Deformer2 |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Z Threshold Deformer |
| Categories | examples |
| Generated Class Name | OgnDeformer2_CPUDatabase |
| Python Module | omni.graph.examples.cpp | | 1,357 |
OgnDeformer2_GPU.md | # Example Node: Z Threshold GPU Deformer
Example deformer that limits the Z point positions to a threshold running on the GPU
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (inputs:points) | `pointf[3][]` | Set of points to be deformed | [] |
| Threshold (inputs:threshold) | `float` | Z value to limit points | 0.0 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (outputs:points) | `pointf[3][]` | Set of deformed points | None |
## Metadata
| Name | Descripton |
| --- | --- |
| Value |
|-------|
| Unique ID | omni.graph.examples.cpp.Deformer2Gpu |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cuda |
| Generated Code Exclusions | tests |
| __memoryType | cuda |
| uiName | Example Node: Z Threshold GPU Deformer |
| Categories | examples |
| Generated Class Name | OgnDeformer2_GPUDatabase |
| Python Module | omni.graph.examples.cpp | | 1,108 |
OgnDeformerCpu.md | # Sine Wave Deformer Z-axis (Python)
Example node applying a sine wave deformation to a set of points, written in Python
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (`inputs:multiplier`) | `float` | The multiplier for the amplitude of the sine wave | 1.0 |
| Points (`inputs:points`) | `pointf[3][]` | The input points to be deformed | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (`outputs:points`) | `pointf[3][]` | The deformed output points | None |
## Metadata
| Name | Descripton |
| --- | --- |
| Value |
|-------|
| Unique ID | omni.graph.examples.python.DeformerPy |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Sine Wave Deformer Z-axis (Python) |
| Categories | examples |
| Generated Class Name | OgnDeformerCpuDatabase |
| Python Module | omni.graph.examples.python | | 1,120 |
OgnDeformerGpu.md | # (Deprecated) Sine Wave Deformer Z-axis (Python GPU)
Deprecated: Requires Torch to run, which is not available. Use omni.warp instead.
Example node applying a sine wave deformation to a set of points, written in Python for the GPU
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (`inputs:multiplier`) | `float` | The multiplier for the amplitude of the sine wave | 1 |
| Points (`inputs:points`) | `pointf[3][]` | The input points to be deformed | [] |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (`outputs:points`) | `pointf[3][]` | The deformed output points | None |
## Metadata
| Name | Descripton |
| --- | --- |
```
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.DeformerPyGpu |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cuda |
| Generated Code Exclusions | None |
| __memoryType | cuda |
| uiName | (Deprecated) Sine Wave Deformer Z-axis (Python GPU) |
| Categories | examples,internal:test |
| Generated Class Name | OgnDeformerGpuDatabase |
| Python Module | omni.graph.examples.python | | 1,642 |
OgnDeformerTimeBased.md | # Example Node: Time-based Sine Wave Deformer
This is an example of a simple deformer with time based input to control a time dependent sine wave deformation.
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (`inputs:multiplier`) | `float` | The multiplier for the amplitude of the sine wave | 1 |
| Points (`inputs:points`) | `pointf[3][]` | The input points to be deformed | [] |
| Time (`inputs:time`) | `double` | Time value to modulate the offset in sine curve execution | 0.0 |
| Wavelength (`inputs:wavelength`) | `float` | The wavelength of the sine wave | 1 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
### Name
### Value
#### Unique ID
omni.graph.examples.cpp.DeformerTimeBased
#### Version
1
#### Extension
omni.graph.examples.cpp
#### Has State?
False
#### Implementation Language
C++
#### Default Memory Type
cpu
#### Generated Code Exclusions
None
#### uiName
Example Node: Time-based Sine Wave Deformer
#### Categories
examples
#### Generated Class Name
OgnDeformerTimeBasedDatabase
#### Python Module
omni.graph.examples.cpp | 1,236 |
OgnDeformerYAxis.md | # Sine Wave Deformer Y-axis (Python)
Example node applying a sine wave deformation to a set of points, written in Python. Deforms along Y-axis instead of Z
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Multiplier (`inputs:multiplier`) | `double` | The multiplier for the amplitude of the sine wave | 1 |
| Offset (`inputs:offset`) | `double` | The offset of the sine wave | 0 |
| Points (`inputs:points`) | `pointf[3][]` | The input points to be deformed | [] |
| Wavelength (`inputs:wavelength`) | `double` | The wavelength of the sine wave | 1 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.DeformerYAxis |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Sine Wave Deformer Y-axis (Python) |
| Categories | examples |
| Generated Class Name | OgnDeformerYAxisDatabase |
| Python Module | omni.graph.examples.python | | 1,547 |
OgnDelay.md | # Delay
This node will stop downstream execution for a period of time before continuing. The period of time is in ‘Duration’, measured in seconds, and begins when ‘Execute In’ is activated. Once the delay period has elapsed the node activates its ‘Finished’ signal, and execution continues downstream.
It is important to note that the execution can only resume when the application next updates. As the length of the application update varies based on the complexity, the ‘Duration’ is merely a minimum delay time. For example if the ‘Duration’ is 10 seconds and the application update time is 7 seconds then the node will trigger somewhere around the 14 second mark. After the first execution only 7 seconds will have elapsed, less than the 10 seconds requested, and at the second execution it will be a total of 14 seconds, which will be recognized as satisfying the ‘Duration’ requirement.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Duration (`inputs:duration`) | `double` | The duration of the delay in seconds. | 0.0 |
| Execute In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Finished (`outputs:finished`) | `execution` | After ‘Duration’ has elapsed signal to the graph that execution can continue downstream. | None |
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.action.Delay |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Delay |
| Categories | graph:action,time |
| Generated Class Name | OgnDelayDatabase |
| Python Module | omni.graph.action_nodes | | 2,102 |
OgnDistance3D.md | # Distance3D
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| A (`inputs:a`) | `['pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]']` | The first 3D vector (or array of 3D vectors) specifying the point position(s) with which the distance computation will be performed. | None |
| B (`inputs:b`) | `['pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]']` | The second 3D vector (or array of 3D vectors) specifying the point position(s) with which the distance computation will be performed. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Distance (`outputs:distance`) | | | |
<table>
<tr>
<td>
<p>
<code>
['double',
'double[]',
'float',
'float[]',
'half',
'half[]']
<td>
<p>
The distance between the points specified by vector(s) “A” and vector(s) “B”.
<td>
<p>
None
<section id="metadata">
<h2>
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.Distance3D
<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>
Distance3D
<tr>
<td>
<p>
Categories
<td>
<p>
math:operator
<tr>
<td>
<p>
Generated Class Name
<td>
<p>
OgnDistance3DDatabase
<tr>
<td>
<p>
Python Module
<td>
<p>
omni.graph.nodes
| 3,266 |
OgnDivide.md | # Divide
## 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', ...]` | | |
| A (inputs:a) | Description | Default |
|--------------|-------------|---------|
| ['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 dividend, or numerator, to use for the division. | None |
| B (inputs:b) | Description | Default |
|--------------|-------------|---------|
| ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'int', 'int64', 'int64[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]'] | The divisor, or denominator, to use for the division. | None |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| A | ['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 numerator, or dividend, to use for the division. | None |
| B | ['double', 'double[]'] | The divisor, or denominator, to use for the division. “B“‘s base type must match or be convertible to “A“‘s base type. “B” can only be an array if “A” is an array. “B” can only consist of scalars or an array of scalars (i.e. no vectors or matrices). Setting “B” to zero (or having it contain a zero element) will return an error during computation. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'frame[4]', 'frame[4][]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]'] | | None |
'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][]'
Result of the division between the numerator “A” and denominator “B”.
None
## Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.nodes.Divide |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Divide |
| Categories | math:operator |
| Generated Class Name | OgnDivideDatabase |
| Python Module | omni.graph.nodes |
# 这是一个标题
这是一个段落，包含一个链接：Example Link。
```
这是一段代码。
```
描述图片的文字 | 5,984 |
OgnDotProduct.md | # Dot Product
## Dot Product
Compute the dot product of two vectors, or two arrays of vectors. If arrays of vectors are provided, then the dot product will be taken on an element-by-element basis between the two arrays (e.g. if two arrays with three vectors each are provided, the result will be another array containing three scalars where the first output scalar is the result of taking the dot product between the first vectors in each input array, the second output vector is the result of taking the dot product between the second vectors in each input array, etc.). The inputs “A” and “B” must either both be vectors, or both be arrays of vectors with the same number of elements.
## 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[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]' | | |
The first vector (or array of vectors) for which the dot product is to be computed.
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[2]'
- 'double[2][]'
- 'double[3]'
- 'double[3][]'
- 'double[4]'
- 'double[4][]'
- 'double[]'
- 'float[2]'
- 'float[2][]'
- 'float[3]'
- 'float[3][]'
- 'float[4]'
- 'float[4][]'
- 'float[]'
- '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[]'
- 'vectord[3]'
- 'vectord[3][]'
- 'vectorf[3]'
- 'vectorf[3][]'
- 'vectorh[3]'
- 'vectorh[3][]'
# Inputs
## Inputs
### Vector A (inputs:vectorA)
- Type: `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'timecode']`
- Description: The first vector (or array of vectors) for which the dot product is to be computed.
- Default: None
### Vector B (inputs:vectorB)
- Type: `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'timecode']`
- Description: The second vector (or array of vectors) for which the dot product is to be computed.
- Default: None
# Outputs
## Outputs
### Product (outputs:product)
- Type: `['double', 'double[]', 'float', 'float[]', 'half', 'half[]', 'timecode']`
- Description: The resulting dot product between vector(s) “A” and vector(s) “B”.
- Default: None
# Metadata
## Metadata
### Unique ID
- Value: omni.graph.nodes.DotProduct
### Version
- Value: 1
### Extension
- Value: omni.graph.nodes
### Has State?
- Value: False
### Implementation Language
- Value: C++
### Default Memory Type
- Value: cpu
### Generated Code Exclusions
- Value: None
### uiName
- Value: Dot Product
### Categories
- Value: math:operator
### Generated Class Name
- Value: OgnDotProductDatabase
### Python Module
- Value: omni.graph.nodes | 3,724 |
OgnDrawDebugCurve.md | # Draw Debug Curve
Given a set of curve points, draw a curve in the viewport. This node is deprecated. Use the omni.ui_scene API from within a ScriptNode, or an omni.kit.data2ui.usd.Line prim instead.
## Installation
To use this node enable [omni.graph.ui_nodes](../Overview.html#ext-omni-graph-ui-nodes) in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Closed (`inputs:closed`) | `bool` | When true, connect the last point to the first | False |
| Color (`inputs:color`) | `colorf[3]` | The color of the curve | [0.0, 0.0, 0.0] |
| Curve Points (`inputs:curvepoints`) | `double[3][]` | The curve to be drawn | [] |
| In (`inputs:execIn`) | `execution` | Signal to the graph that this node is ready to be executed. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.ui_nodes.DrawDebugCurve |
| Version | 1 |
| Extension | omni.graph.ui_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| hidden | true |
| uiName | Draw Debug Curve |
| Categories | debug |
| Generated Class Name | OgnDrawDebugCurveDatabase |
| Python Module | omni.graph.ui_nodes | | 1,662 |
OgnDynamicSwitch.md | # Dynamic Switch
A switch node that will enable the left side or right side depending on the input. Requires dynamic scheduling to work.
## Installation
To use this node enable `omni.graph.examples.python` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|-------------------|--------|-----------------------|---------|
| Left Value (`inputs:left_value`) | int | Left value to output | -1 |
| Right Value (`inputs:right_value`) | int | Right value to output | 1 |
| Switch (`inputs:switch`) | int | Enables right value if greater than 0, else left value | 0 |
## Outputs
| Name | Type | Descripton | Default |
|---------------|--------|------------------|---------|
| Left Out (`outputs:left_out`) | int | Left side output | 0 |
| Right Out (`outputs:right_out`) | int | Right side output | 0 |
## Metadata
| Name | Value |
|-------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.DynamicSwitch |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | usd |
| uiName | Dynamic Switch |
| Categories | examples |
| Generated Class Name | OgnDynamicSwitchDatabase |
| Python Module | omni.graph.examples.python | | 1,726 |
OgnEase.md | # Easing Function
Easing function which interpolates between a start and end value. Vectors are eased component-wise. The easing functions can be applied to decimal types. Linear: Interpolates between start and finish at a fixed rate. EaseIn: Starts slowly and ends fast according to an exponential, the slope is determined by the “Blend Exponent” input. EaseOut: Same as EaseIn, but starts fast and ends slow EaseInOut: Combines EaseIn and EaseOut SinIn: Starts slowly and ends fast according to a sinusoidal curve SinOut: Same as SinIn, but starts fast and ends slow SinInOut: Combines SinIn and SinOut
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Alpha (`inputs:alpha`) | `['float', 'float[]']` | The normalized time [0 - 1.0] (inclusive). Values outside this range will be clamped. | None |
| Blend Exponent (`inputs:blendExponent`) | `int` | The blend exponent, which is the degree of the ease curve (1 = linear, 2 = quadratic, 3 = cubic, etc). This only applies to the Ease* functions. | 2 |
| Operation (`inputs:easeFunc`) | `token` | The easing function to apply (EaseIn, EaseOut, EaseInOut, Linear, SinIn, SinOut, SinInOut). | EaseInOut |
| Metadata | | `allowedTokens` = EaseIn,EaseOut,EaseInOut,Linear,SinIn,SinOut,SinInOut | |
| End (`inputs:end`) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]']` | | |
| Key | Description | Default |
| --- | ----------- | ------- |
| End (inputs:end) | The end value at which the interpolation will end. | None |
| Start (inputs:start) | The start value at which the interpolation will begin. | None |
## Inputs
- '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][]'
## Outputs
| Name | Type | Descripton | Default |
|------|------|------------|---------|
| Result (outputs:result) | ['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', '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][]'] | Description of the result | None |
# Ease
## Parameters
| Name | Type | Description |
| --- | --- | --- |
| `normalizedTime` | float | The normalized time value to use for the computation. |
## Returns
| Name | Type | Description |
| --- | --- | --- |
| `result` | float | The result of computing the configured easing function at the given normalized time value. |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.Ease |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Easing Function |
| Categories | math:operator |
| Generated Class Name | OgnEaseDatabase |
| Python Module | omni.graph.nodes | | 4,242 |
OgnEndsWith.md | # Ends With
Determines if a string ends with a given string value
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|------|--------|---------------------|---------|
| Suffix (inputs:suffix) | string | The suffix to test | |
| Value (inputs:value) | string | The string to check | |
## Outputs
| Name | Type | Descripton | Default |
|------------|------|-----------------------------|---------|
| Is Suffix (outputs:isSuffix) | bool | True if ‘value’ ends with ‘suffix’ | None |
## Metadata
| Name | Value |
|------------|----------------------------|
| Unique ID | omni.graph.nodes.EndsWith |
| 属性 | 值 |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Ends With |
| Categories | function |
| Generated Class Name | OgnEndsWithDatabase |
| Python Module | omni.graph.nodes | | 1,096 |
OgnEventUpdateTick.md | # Update Tick Event
Triggers on update ticks.
## Installation
To use this node enable [omni.graph.nodes](../Overview.html#ext-omni-graph-nodes) in the Extension Manager.
## Outputs
| Name | Type | Descripton | Default |
|------|-----------|----------------------------------------------------------------------------|---------|
| event| uint64 | Currently incomplete - always 0. Eventually should use a bundle for this. | None |
## Metadata
| Name | Value |
|--------------------------|----------------------------------------------------------------------------------------|
| Unique ID | omni.graph.nodes.UpdateTickEvent |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions| None |
| uiName | Update Tick Event |
| Generated Class Name | OgnEventUpdateTickDatabase |
| Python Module | omni.graph.nodes | | 1,949 |