file_path
stringlengths 5
148
| content
stringlengths 0
526k
|
|---|---|
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 | |
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 | |
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 | |
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 |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 |
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 | |
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 | |
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 | |
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 | |
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** |
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 | |
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
</p>
</td>
<td>
<p>
omni.graph.nodes
</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>
Python Module
</p>
</td>
<td>
<p>
omni.graph.nodes
</p>
</td>
</tr>
</tbody>
</table>
</section> |
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
</p>
</th>
<th>
<p>
Description
</p>
</th>
</tr>
</thead>
<tbody>
<tr class="row-even">
<td>
<p>
OgnConstantInt2Database
</p>
</td>
<td>
<p>
OgnConstantInt2Database
</p>
</td>
</tr>
<tr class="row-odd">
<td>
<p>
Python Module
</p>
</td>
<td>
<p>
omni.graph.nodes
</p>
</td>
</tr>
</tbody>
</table>
</section>
</section>
</div>
</div>
<footer>
<hr/>
</footer>
</div> |
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 | |
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 | |
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 |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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
--- |
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 | |
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 | |
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 | |
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 | |
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 |
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 | |
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 | |
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 | |
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
--- |
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 | |
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 | |
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 |
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 |
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 |
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 |
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 |
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 |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 |
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 | |
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 | |
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[]']
</code>
</p>
</td>
<td>
<p>
The distance between the points specified by vector(s) “A” and vector(s) “B”.
</p>
</td>
<td>
<p>
None
</p>
</td>
</tr>
</table>
<section id="metadata">
<h2>
Metadata
</h2>
<table>
<colgroup>
<col style="width: 30%"/>
<col style="width: 70%"/>
</colgroup>
<thead>
<tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Value
</p>
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<p>
Unique ID
</p>
</td>
<td>
<p>
omni.graph.nodes.Distance3D
</p>
</td>
</tr>
<tr>
<td>
<p>
Version
</p>
</td>
<td>
<p>
1
</p>
</td>
</tr>
<tr>
<td>
<p>
Extension
</p>
</td>
<td>
<p>
omni.graph.nodes
</p>
</td>
</tr>
<tr>
<td>
<p>
Has State?
</p>
</td>
<td>
<p>
False
</p>
</td>
</tr>
<tr>
<td>
<p>
Implementation Language
</p>
</td>
<td>
<p>
C++
</p>
</td>
</tr>
<tr>
<td>
<p>
Default Memory Type
</p>
</td>
<td>
<p>
cpu
</p>
</td>
</tr>
<tr>
<td>
<p>
Generated Code Exclusions
</p>
</td>
<td>
<p>
None
</p>
</td>
</tr>
<tr>
<td>
<p>
uiName
</p>
</td>
<td>
<p>
Distance3D
</p>
</td>
</tr>
<tr>
<td>
<p>
Categories
</p>
</td>
<td>
<p>
math:operator
</p>
</td>
</tr>
<tr>
<td>
<p>
Generated Class Name
</p>
</td>
<td>
<p>
OgnDistance3DDatabase
</p>
</td>
</tr>
<tr>
<td>
<p>
Python Module
</p>
</td>
<td>
<p>
omni.graph.nodes
</p>
</td>
</tr>
</tbody>
</table>
</section> |
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。
```
这是一段代码。
```
描述图片的文字 |
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 |
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 | |
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 | |
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 | |
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 | |
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 | |
OgnExampleAdjacency.md | # Example Node: Adjacency
Computes chosen adjacency information from specified input mesh topology data.
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Compute Distances (`inputs:computeDistances`) | `bool` | When enabled, the distances from each point to its neighbors is computed and stored in a ‘float[]’ attribute in ‘output’ as specified by ‘nameOfDistancesOutputAttribute’. | False |
| Compute Neighbor Counts (`inputs:computeNeighborCounts`) | `bool` | When enabled, the number of neighbors of each point is computed and all are stored in an ‘int[]’ attribute in ‘output’ as specified by ‘nameOfNeighborCountsOutputAttribute’. | False |
| Compute Neighbor Starts (`inputs:computeNeighborStarts`) | `bool` | When enabled, the beginning index of neighbors of each point within the arrays computed by either ‘computeNeighbors’ or ‘computeDistances’ is computed and all, plus an additional integer to indicate the end of the array, are stored in an ‘int[]’ attribute in ‘output’ as specified by ‘nameOfNeighborStartsOutputAttribute’. The extra integer at the end allows for easy computing of the number of neighbors of any single point, by subtracting the value in the array corresponding with the point, from the following value in the array. | True |
| Compute Neighbors (`inputs:computeNeighbors`) | `bool` | When enabled, the neighbors of each point are computed and stored contiguously in an ‘int[]’ attribute in ‘output’ as specified by ‘nameOfNeighborsOutputAttribute’. | True |
| Name Of Bundle Input Attribute (inputs:nameOfBundleInputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Bundle containing topology data to be analysed | None | | |
| Name Of Distances Output Attribute (inputs:nameOfDistancesOutputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘float[]’ attribute to be created in ‘output’ to contain the computed distances to each neighbor. This is only used if ‘computeDistances’ is true. | distances | | |
| Name Of Neighbor Counts Output Attribute (inputs:nameOfNeighborCountsOutputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute to be created in ‘output’ to contain the number of neighbors of each point. This is only used if ‘computeNeighborCounts’ is true. A running sum of this array can be computed using ‘computeNeighborStarts’. The neighbors themselves can be computed using ‘computeNeighbors’. | neighborCounts | | |
| Name Of Neighbor Starts Output Attribute (inputs:nameOfNeighborStartsOutputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute to be created in ‘output’ to contain the beginning index of neighbors of each point in the arrays computed by either ‘computeNeighbors’ or ‘computeDistances’. This is only used if ‘computeNeighborStarts’ is true. | neighborStarts | | |
| Name Of Neighbors Output Attribute (inputs:nameOfNeighborsOutputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute to be created in ‘output’ to contain the neighbors of all points. This is only used if ‘computeNeighbors’ is true. The beginnings of each point’s neighbors within this array can be computed using ‘computeNeighborStarts’. The number of neighbors of each point can be computed using ‘computeNeighborCounts’. | neighbors | | |
| Name Of Positions Input Attribute (inputs:nameOfPositionsInputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘point3f[]’ attribute in ‘mesh’ containing the positions of each point. This is only used if ‘computeDistances’ is true. The element count of this array overrides ‘pointCount’, when used. | points | | |
| Name Of Vertex Counts Input Attribute (inputs:nameOfVertexCountsInputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute in ‘mesh’ containing the vertex counts of each face | faceVertexCounts | | |
| Name Of Vertex Indices Input Attribute (inputs:nameOfVertexIndicesInputAttribute) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Name of the ‘int[]’ attribute in ‘mesh’ containing the vertex indices of each face | faceVertexIndices | | |
| Point Count (inputs:pointCount) | Type | Description | Default Value |
| --- | --- | --- | --- |
| Number of points being referred to in the vertex indices attribute. This is only used if ‘computeDistances’ is false, otherwise this is overridden by the element count of the attribute specified by ‘nameOfPositionsInputAttribute’. | 0 | | |
| Remove Duplicates (inputs:removeDuplicates) | Type | Description | Default Value |
| --- | --- | --- | --- |
| When enabled, each neighbor of a point will be counted only once, instead of once per edge that connects the point to the neighbor. | True | | |
| Treat Edges As One Way (inputs:treatEdgesAsOneWay) | Type | Description | Default Value |
| --- | --- | --- | --- |
| When enabled, if a face has an edge from A to B, B will be considered a neighbor of A, but A will not be considered a neighbor of B. This can be useful as part of identifying unshared edges or inconsistent face winding order. | False | | |
| Treat Faces As Curves (inputs:treatFacesAsCurves) | Type | Description | Default Value |
| --- | --- | --- | --- |
| | | | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| TreatFacesAsCurves | bool | When enabled, the input faces will be treated as curves, instead of closed polygons, i.e. no edge from the last vertex of each face to the first vertex of that face will be counted. | False |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Mesh (outputs:mesh) | bundle | A copy of the input ‘mesh’ with the computed attributes added, as specified above. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.Adjacency |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Adjacency |
| Generated Class Name | OgnExampleAdjacencyDatabase |
| Python Module | omni.graph.examples.cpp | |
OgnExampleExtractFloat3Array.md | # Example Node: Extract Float3 Array
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Input (inputs:input) | bundle | Bundle containing a float[3][] attribute to be extracted to ‘output’ | None |
| Name Of Attribute (inputs:nameOfAttribute) | token | Name of the attribute in ‘input’ that is to be extracted to ‘output’ | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Output (outputs:output) | float[3][] | The float[3][] attribute extracted from ‘input’ | None |
## Metadata
| Name | Descripton |
| --- | --- |
| Unique ID | omni.graph.examples.cpp.ExtractFloat3Array |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Extract Float3 Array |
| Categories | examples |
| Generated Class Name | OgnExampleExtractFloat3ArrayDatabase |
| Python Module | omni.graph.examples.cpp | |
OgnExampleSimpleDeformer.md | # Example Node: Simple Sine Wave Deformer
This is an example of a simple deformer. It calculates a sine wave and deforms the input geometry with it.
## 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 | [] |
| Wavelength (`inputs:wavelength`) | `float` | The wavelength of the sine wave | 1 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Points (`outputs:points`) | `pointf[3][]` | The deformed output points | |
# Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.examples.cpp.SimpleDeformer |
| Version | 1 |
| Extension | omni.graph.examples.cpp |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Example Node: Simple Sine Wave Deformer |
| Categories | examples |
| Generated Class Name | OgnExampleSimpleDeformerDatabase |
| Python Module | omni.graph.examples.cpp | |
OgnExampleSmooth.md | # Example Node: Smooth Points
Smooths data in a very simple way by averaging values with neighbors.
## Installation
To use this node enable `omni.graph.examples.cpp` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Iterations (`inputs:iterations`) | `int` | Number of times to average neighboring values | 5 |
| Mesh (`inputs:mesh`) | `bundle` | Bundle containing data to be smoothed and neighbor arrays. | None |
| Name Of Attribute To Smooth (`inputs:nameOfAttributeToSmooth`) | `token` | Name of the attribute in ‘mesh’ containing the data to be smoothed | points |
| Name Of Neighbor Starts Input Attribute (`inputs:nameOfNeighborStartsInputAttribute`) | `token` | Name of the ‘int[]’ attribute in ‘mesh’ containing the beginning index of neighbors of each point in the array attribute specified by ‘nameOfNeighborsInputAttribute’ | neighborStarts |
| Name Of Neighbors Input Attribute (`inputs:nameOfNeighborsInputAttribute`) | `token` | Name of the ‘int[]’ attribute in ‘mesh’ containing the neighbors of all points. The beginnings of each point’s neighbors within this array are provided in the attribute specified by ‘nameOfNeighborStartsInputAttribute’. | |
## Inputs
### neighbors
## Use GPU (inputs:useGPU)
- **Type**: bool
- **Description**: When this option is on, the node will use the GPU to perform the smoothing computation.
- **Default**: True
## Outputs
### Mesh (outputs:mesh)
- **Type**: bundle
- **Description**: A copy of ‘mesh’ with the specified attribute smoothed.
- **Default**: None
## Metadata
### Name
- **Value**: Unique ID
- **Value**: omni.graph.examples.cpp.Smooth
### Version
- **Value**: 1
### Extension
- **Value**: omni.graph.examples.cpp
### Has State?
- **Value**: False
### Implementation Language
- **Value**: C++
### Default Memory Type
- **Value**: cpu
### Generated Code Exclusions
- **Value**: None
### uiName
- **Value**: Example Node: Smooth Points
### Generated Class Name
- **Value**: OgnExampleSmoothDatabase
### Python Module
- **Value**: omni.graph.examples.cpp |
OgnExecSwitch.md | # Exec Switch
A switch node that will enable the left side or right side depending on the input
## Installation
To use this node enable `omni.graph.examples.python` 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 |
| Switch (inputs:switch) | `bool` | Enables right value if greater than 0, else left value | False |
## Outputs
| Name | Type | Descripton | Default |
|-------------------|------------|-------------------------------------------------|---------|
| Exec Left Out (outputs:execLeftOut) | `execution` | If ‘Switch’ is less than or equal to 0, signal to the graph that execution can continue downstream on this path. | None |
| Exec Right Out (outputs:execRightOut) | `execution` | If ‘Switch’ is greater than 0, signal to the graph that execution can continue downstream on this path. | None |
## Metadata
| Name | Value |
|------------|--------------------------------------------|
| Unique ID | omni.graph.examples.python.ExecSwitch |
| Version | 1 |
| Extension | omni.graph.examples.python |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | usd |
| uiName | Exec Switch |
| Categories | examples |
| Generated Class Name | OgnExecSwitchDatabase |
| Python Module | omni.graph.examples.python | |
OgnExitApplication.md | # Exit Application
Immediately exits the application. Uses a fast shutdown to avoid any cleanup that would otherwise be triggered.
## Installation
To use this node enable `omni.graph.action_nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|---------------------|---------------|-------------------------------------------------|---------|
| Exec In (inputs:execIn) | execution | Signal to the graph that this node is ready to be executed, exiting the application. | None |
## Metadata
| Name | Value |
|---------------|--------------------------------------------|
| Unique ID | omni.graph.action.ExitApplication |
| Version | 1 |
| Extension | omni.graph.action_nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Exit Application |
| Categories | graph:action,flowControl |
| Generated Class Name |
OgnExitApplicationDatabase
Python Module
omni.graph.action_nodes |
OgnExponent.md | # Exponent
## Exponent
Computes the base input raised to the power of the exponent. The result is the same type as the base input for floating point types. The result is double for integral values to allow for negative exponents. If the input is a vector or matrix, then the node calculates the exponent for each element and computes a vector or matrix of the same size.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Base (inputs:base) | ['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'] | | |
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Base (inputs:base) | `['int', 'int[]', 'int[2]', 'int[2][]', 'int[3]', 'int[3][]', 'int[4]', 'int[4][]', 'int[]', 'matrixd[2]', 'matrixd[2][]', 'matrixd[3]', 'matrixd[3][]', 'matrixd[4]', 'matrixd[4][]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'transform[4]', 'transform[4][]', 'uchar', 'uchar[]', 'uint', 'uint64', 'uint64[]', 'uint[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | Base value that will be raised to the power of exponent. | None |
| Exponent (inputs:exponent) | `int` | Power to raise the base value “Base” to. If “Base” consists of an array, vector, or matrix, then the exponent will be applied to each member of the aforementioned data structures. | 2 |
## 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][]']` | | |
## Metadata
### Name
- Unique ID
- Version
- Extension
- Has State?
- Implementation Language
- Default Memory Type
- Generated Code Exclusions
- uiName
### Value
- omni.graph.nodes.Exponent
- 1
- omni.graph.nodes
- False
- C++
- cpu
- None
- Exponent
| Categories | math:operator |
|------------|---------------|
| Generated Class Name | OgnExponentDatabase |
| Python Module | omni.graph.nodes | |
OgnExportUSDPrim.md | # export USD prim data
Exports data from an input bundle into a USD prim This node is deprecated, Use WritePrim nodes instead
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Apply Transform (`inputs:applyTransform`) | bool | If true, apply the transform necessary to transform any transforming attributes from the space of the node into the space of the specified prim. | False |
| Metadata | | `displayGroup` = parameters | |
| Attributes To Export (`inputs:attrNamesToExport`) | token | Comma or space separated text, listing the names of attributes in the input data to be exported or empty to import all attributes. | |
| Metadata | | `displayGroup` = parameters | |
| Bundle (`inputs:bundle`) | bundle | The bundle from which data should be exported. | None |
| Attributes To Exclude (`inputs:excludedAttrNames`) | token | Attributes to be excluded from being exported | |
| Export to Root Layer (`inputs:exportToRootLayer`) | | | |
<section id="outputs">
<h2>
Outputs
</h2>
</section>
```
由于您提供的HTML代码中包含大量的表格数据，我将逐个处理表格行（tr）并将其转换为Markdown格式。请注意，Markdown中的表格需要特定的格式，而HTML中的表格结构通常更为复杂。以下是转换后的Markdown格式数据：
```markdown
<section id="outputs">
<h2>
Outputs
</h2>
</section>
<section id="parameters">
<h2>
Parameters
</h2>
<table>
<tbody>
<tr>
<td>
<p>
Export to Root Layer (inputs:exportToRootLayer)
</p>
</td>
<td>
<p>
<code>bool</code>
</p>
</td>
<td>
<p>
If true, prims are exported in the root layer, otherwise the layer specified by “layerName” is used.
</p>
</td>
<td>
<p>
True
</p>
</td>
</tr>
<tr>
<td>
<p>
Attributes To Rename (inputs:inputAttrNames)
</p>
</td>
<td>
<p>
<code>token</code>
</p>
</td>
<td>
<p>
Comma or space separated text, listing the names of attributes in the input data to be renamed
</p>
</td>
<td>
</td>
</tr>
<tr>
<td>
<p>
Layer Name (inputs:layerName)
</p>
</td>
<td>
<p>
<code>token</code>
</p>
</td>
<td>
<p>
Identifier of the layer to export to if “exportToRootLayer” is false, or leave this blank to export to the session layer
</p>
</td>
<td>
</td>
</tr>
<tr>
<td>
<p>
Only Export To Existing (inputs:onlyExportToExisting)
</p>
</td>
<td>
<p>
<code>bool</code>
</p>
</td>
<td>
<p>
If true, only attributes that already exist in the specified output prim will have data transferred to them from the input bundle.
</p>
</td>
<td>
<p>
False
</p>
</td>
</tr>
<tr>
<td>
<p>
New Attribute Names (inputs:outputAttrNames)
</p>
</td>
<td>
<p>
<code>token</code>
</p>
</td>
<td>
<p>
Comma or space separated text, listing the new names for the attributes listed in inputAttrNames
</p>
</td>
<td>
</td>
</tr>
<tr>
<td>
<p>
Prim Path From Bundle (inputs:primPathFromBundle)
</p>
</td>
<td>
<p>
<code>bool</code>
</p>
</td>
<td>
<p>
When true, if there is a “primPath” token attribute inside the bundle, that will be the path of the USD prim to write to, else the “outputs:prim” attribute below will be used for the USD prim path.
</p>
</td>
<td>
<p>
False
</p>
</td>
</tr>
<tr>
<td>
<p>
Export to Root Layer (inputs:removeMissingAttrs)
</p>
</td>
<td>
<p>
<code>bool</code>
</p>
</td>
<td>
<p>
If true, any attributes on the USD prim(s) being written to, that aren’t in the input data, will be removed from the USD prim(s).
</p>
</td>
<td>
<p>
False
</p>
</td>
</tr>
<tr>
<td>
<p>
Rename Attributes (inputs:renameAttributes)
</p>
</td>
<td>
<p>
<code>bool</code>
</p>
</td>
<td>
<p>
If true, attributes listed in “inputAttrNames” will be exported to attributes with the names specified in “outputAttrNames”. Note: to avoid potential issues with redundant attributes being created while typing, keep this off until after specifying all input and output attribute names.
</p>
</td>
<td>
<p>
False
</p>
</td>
</tr>
<tr>
<td>
<p>
Time Varying Attributes (inputs:timeVaryingAttributes)
</p>
</td>
<td>
<p>
<code>bool</code>
</p>
</td>
<td>
<p>
Check whether the USD attributes should be time-varying and if so, export their data to a time sample at the time “usdTimecode”.
</p>
</td>
<td>
<p>
False
</p>
</td>
</tr>
<tr>
<td>
<p>
Usd Timecode (inputs:usdTimecode)
</p>
</td>
<td>
<p>
<code>double</code>
</p>
</td>
<td>
<p>
The time at which to evaluate the transform of the USD prim for applyTransform.
</p>
</td>
<td>
<p>
0
</p>
</td>
</tr>
</tbody>
</table>
</section>
## State
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prev Apply Transform (state:prevApplyTransform) | bool | Value of “applyTransform” input from previous run | None |
| Prev Attr Names To Export (state:prevAttrNamesToExport) | token | Value of “attrNamesToExport” input from previous run | None |
| Prev Bundle Dirty ID (state:prevBundleDirtyID) | uint64 | Dirty ID of input bundle from previous run | None |
| Prev Excluded Attr Names (state:prevExcludedAttrNames) | token | Value of “excludedAttrNames” input from previous run | None |
| Prev Export To Root Layer (state:prevExportToRootLayer) | bool | Value of “exportToRootLayer” input from previous run | None |
| Prev Input Attr Names (state:prevInputAttrNames) | token | Value of “inputAttrNames” input from previous run | None |
| Prev Layer Name (state:prevLayerName) | token | Value of “layerName” input from previous run | None |
| Prev Only Export To Existing (state:prevOnlyExportToExisting) | bool | Value of “onlyExportToExisting” input from previous run | None |
| Prev Output Attr Names (state:prevOutputAttrNames) | token | Value of “outputAttrNames” input from previous run | None |
| Prev Prim Dirty IDs (state:prevPrimDirtyIDs) | | | |
# Metadata
## Metadata
### Name
* Unique ID
* Version
* Extension
* Icon
* Has State?
* Implementation Language
* Default Memory Type
* Generated Code Exclusions
* uiName
* hidden
* __tokens
* Generated Class Name
* Python Module
### Value
* omni.graph.ExportUSDPrim
* 1
* omni.graph.nodes
* ogn/icons/omni.graph.ExportUSDPrim.svg
* True
* C++
* cpu
* None
* export USD prim data
* true
* {“primPath”: “primPath”, “primType”: “primType”, “primTime”: “primTime”, “primCount”: “primCount”, “transform”: “transform”}
* OgnExportUSDPrimDatabase
* omni.graph.nodes |
OgnExtractAttr.md | # Extract Attribute
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
|--------------------------|-----------|-------------------------------------|---------|
| Attribute To Extract (`inputs:attrName`) | token | Name of the attribute to look for in the bundle | points |
| Bundle For Extraction (`inputs:data`) | bundle | Collection of attributes from which the named attribute is to be extracted | None |
## Outputs
| Name | Type | Descripton | Default |
|--------------------------|-----------|-------------------------------------|---------|
| Extracted Attribute (`outputs:output`) | any | The single attribute extracted from the input bundle | None |
## Metadata
| Name | Descripton |
|--------------------------|-------------------------------------|
| Metadata Name | Metadata Description |
| Unique ID | omni.graph.nodes.ExtractAttribute |
| --- | --- |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Extract Attribute |
| Categories | bundle |
| Generated Class Name | OgnExtractAttrDatabase |
| Python Module | omni.graph.nodes | |
OgnExtractBundle.md | # Extract Bundle
Exposes readable attributes for a bundle as outputs on this node. When this node computes it will read the latest attribute values from the target bundle into these node attributes
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Bundle (inputs:bundle) | `bundle` | The bundle to be read from. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Pass Through (outputs:passThrough) | `bundle` | The input bundle passed as-is | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.ExtractBundle |
| Version | 3 |
| Extension | omni.graph.nodes |
| Has State? | False |
| --- | --- |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Extract Bundle |
| Categories | bundle |
| Generated Class Name | OgnExtractBundleDatabase |
| Python Module | omni.graph.nodes | |
OgnExtractPrim.md | # Extract Prim
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim (`inputs:prim`) | `target` | The prim to be extracted from Multiple Primitives in Bundle. | None |
| Prim Path (`inputs:primPath`) | `path` | The path of the prim to be extracted from Multiple Primitives in Bundle. | |
| Prims Bundle (`inputs:prims`) | `bundle` | The Multiple Primitives in Bundle to extract from. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Prim Bundle (`outputs:primBundle`) | `bundle` | The extracted Single Primitive in Bundle | |
## Metadata
| Name | Value |
|------------|---------------------------------|
| Unique ID | omni.graph.nodes.ExtractPrim |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Extract Prim |
| Categories | bundle |
| Generated Class Name | OgnExtractPrimDatabase |
| Python Module | omni.graph.nodes | |
OgnFindPrims.md | # Find Prims
Finds Prims on the stage which match the given criteria
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Ignore System Prims (`inputs:ignoreSystemPrims`) | bool | Ignore system prims such as omni graph nodes that shouldn’t be considered during the import. | False |
| Prim Name Prefix (`inputs:namePrefix`) | token | Only prims with a name starting with the given prefix will be returned. | |
| Prim Path Pattern (`inputs:pathPattern`) | token | A list of wildcard patterns used to match the prim paths Supported syntax of wildcard pattern: ‘*’ - match an arbitrary number of any characters ‘?’ - match any single character ‘^’ - (caret) is used to define a pattern that is to be excluded Example of wildcard patterns, input: [‘/Cube0’, ‘/Cube1’, ‘/Box’] ‘*’ - match any ‘* ^/Box’ - match any, but exclude ‘/Box’ ‘* ^/Cube*’ - match any, but exclude ‘/Cube0’ and ‘/Cube1’ | |
| Recursive (`inputs:recursive`) | bool | False means only consider children of the root prim, True means all prims in the hierarchy | False |
| Attribute Names (`inputs:requiredAttributes`) | string | A space-separated list of attribute names that are required to be present on matched prims | |
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Relationship Name (`inputs:requiredRelationship`) | | The name of a relationship which must have a target specified by requiredRelationshipTarget or requiredTarget | |
| Relationship Prim Path (`inputs:requiredRelationshipTarget`) | | The path that must be a target of the requiredRelationship | |
| Relationship Prim (`inputs:requiredTarget`) | | The target of the requiredRelationship | None |
| Root Prim (`inputs:rootPrim`) | | Only children of the given prim will be considered. If rootPrim is specified, rootPrimPath will be ignored. | None |
| Root Prim Path (`inputs:rootPrimPath`) | | Only children of the given prim will be considered. Empty will search the whole stage. | |
| Prim Type Pattern (`inputs:type`) | | A list of wildcard patterns used to match the prim types that are to be imported Supported syntax of wildcard pattern: ‘*’ - match an arbitrary number of any characters ‘?’ - match any single character ‘^’ - (caret) is used to define a pattern that is to be excluded Example of wildcard patterns, input: [‘Mesh’, ‘Cone’, ‘Cube’] ‘*’ - match any ‘* ^Mesh’ - match any, but exclude ‘Mesh’ ‘* ^Cone ^Cube’ - match any, but exclude ‘Cone’ and ‘Cube’ | |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Prim Paths (`outputs:primPaths`) | token[] | A list of Prim paths as tokens which match the given type | None |
| Prims (`outputs:prims`) | target | A list of Prim paths which match the given type | None |
## State
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Ignore System Prims (`state:ignoreSystemPrims`) | bool | last corresponding input seen | None |
| Input Type (`state:inputType`) | token | last corresponding input seen | None |
| Name Prefix (`state:namePrefix`) | token | | |
## Metadata
### Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.FindPrims |
| Version | 2 |
| Extension | omni.graph.nodes |
| Has State? | True |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Find Prims |
| Categories | sceneGraph |
| Generated Class Name | OgnFindPrimsDatabase |
| Python Module | omni.graph.nodes | |
OgnFindString.md | # Find String
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Pos (`inputs:pos`) | `int` | The starting position to search for the string. | 0 |
| String (`inputs:string`) | `['string', 'token']` | The base string. | None |
| Value (`inputs:value`) | `['string', 'token']` | The string to search for. | None |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Index (`outputs:index`) | `int` | The index of the first occurrence of string, or -1 if not found. | None |
## Metadata
| Name | Value |
|------------|---------------------------|
| Unique ID | omni.graph.nodes.FindString |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Find String |
| Categories | function |
| Generated Class Name | OgnFindStringDatabase |
| Python Module | omni.graph.nodes | |
OgnFindTarget.md | # Find Target
Returns the index of the first occurrence of a target, or -1 if not found.
## Installation
To use this node enable `omni.graph.nodes` in the Extension Manager.
## Inputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Search Target (`inputs:searchTarget`) | `target` | The target to search for. | None |
| Targets (`inputs:targets`) | `target` | The input target array. | None |
| Metadata | | `allowMultiInputs` = 1 | |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Index (`outputs:index`) | `int` | The index of the first occurrence of “searchTarget”, or -1 if not found | None |
## Metadata
| Name | Descripton |
| --- | --- |
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.FindTarget |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Find Target |
| Categories | sceneGraph |
| Generated Class Name | OgnFindTargetDatabase |
| Python Module | omni.graph.nodes | |
OgnFlipFlop.md | # Flip Flop
This node activates its outputs in an alternating sequence, starting with ‘On Odd’ on the first execution after ‘Signal Execution’ has been 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 |
## Outputs
| Name | Type | Descripton | Default |
| --- | --- | --- | --- |
| Execute A (outputs:a) | `execution` | After every odd-numbered execution signal to the graph that execution can continue downstream. | None |
| Execute B (outputs:b) | `execution` | After every even-numbered execution signal to the graph that execution can continue downstream. | None |
| Is A (outputs:isA) | `bool` | Set to true when the ‘Execute A’ signal is active, otherwise set to false. | None |
# Metadata
| Name | Value |
|------------|--------------------------------|
| Unique ID | omni.graph.action.FlipFlop |
| Version | 2 |
| Extension | omni.graph.action_nodes |
| Icon | ogn/icons/omni.graph.action.FlipFlop.svg |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | tests |
| uiName | Flip Flop |
| Categories | graph:action,flowControl |
| Generated Class Name | OgnFlipFlopDatabase |
| Python Module | omni.graph.action_nodes | |
OgnFloor.md | # Floor
## 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][]']` | | |
## 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 floor of. | None |
## 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 floor operator applied to each scalar value. The structure of the result, arrays and tuples, will mirror that of the input. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.Floor |
| Version | 1 |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | C++ |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Floor |
| Categories | math:operator |
| Generated Class Name | OgnFloorDatabase |
| Python Module | omni.graph.nodes | |
OgnFMod.md | # Float Remainder
Computes the floating point remainder of “A” / “B”. If “B” is zero, then the result is zero. The returned value has the same sign and shape as “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][]', 'normalh[3]', 'normalh[3][]']` | | |
| A (inputs:a) | B (inputs:b) |
|--------------|-------------|
| ['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][]'] | ['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][]'] |
The numerator “A” from which the floating point remainder will be computed.
None
The numerator “B” from which the floating point remainder will be computed.
## Inputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| A (inputs:a) | `['vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The numerator “A” from which the floating point remainder will be computed. | None |
| B | `['vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The numerator “B” from which the floating point remainder will be computed. | None |
## Outputs
| Name | Type | Description | Default |
| --- | --- | --- | --- |
| Result (outputs:result) | `['colord[3]', 'colord[3][]', 'colord[4]', 'colord[4][]', 'colorf[3]', 'colorf[3][]', 'colorf[4]', 'colorf[4][]', 'colorh[3]', 'colorh[3][]', 'colorh[4]', 'colorh[4][]', 'double', 'double[2]', 'double[2][]', 'double[3]', 'double[3][]', 'double[4]', 'double[4][]', 'double[]', 'float', 'float[2]', 'float[2][]', 'float[3]', 'float[3][]', 'float[4]', 'float[4][]', 'float[]', 'half', 'half[2]', 'half[2][]', 'half[3]', 'half[3][]', 'half[4]', 'half[4][]', 'half[]', 'normald[3]', 'normald[3][]', 'normalf[3]', 'normalf[3][]', 'normalh[3]', 'normalh[3][]', 'pointd[3]', 'pointd[3][]', 'pointf[3]', 'pointf[3][]', 'pointh[3]', 'pointh[3][]', 'quatd[4]', 'quatd[4][]', 'quatf[4]', 'quatf[4][]', 'quath[4]', 'quath[4][]', 'texcoordd[2]', 'texcoordd[2][]', 'texcoordd[3]', 'texcoordd[3][]', 'texcoordf[2]', 'texcoordf[2][]', 'texcoordf[3]', 'texcoordf[3][]', 'texcoordh[2]', 'texcoordh[2][]', 'texcoordh[3]', 'texcoordh[3][]', 'timecode', 'timecode[]', 'vectord[3]', 'vectord[3][]', 'vectorf[3]', 'vectorf[3][]', 'vectorh[3]', 'vectorh[3][]']` | The floating point remainder of “A” / “B”, which should have the same sign and shape as “A”. | None |
## Metadata
| Name | Value |
| --- | --- |
| Unique ID | omni.graph.nodes.FMod |
| Version | 1 |
| --- | --- |
| Extension | omni.graph.nodes |
| Has State? | False |
| Implementation Language | Python |
| Default Memory Type | cpu |
| Generated Code Exclusions | None |
| uiName | Float Remainder |
| Categories | math:operator |
| Generated Class Name | OgnFModDatabase |
| Python Module | omni.graph.nodes | |