# Role-Based Data Type Examples

This file contains example usage for all of the AutoNode role-based data types. For access to the other types of examples see AutoNode Examples.

*colord[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color3d(first_value: ot.color3d, second_value: ot.color3d) -> ot.color3d:
"""Takes in two colord[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float64). When put into
Fabric the values are stored as 3 double-precision values. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colord[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color3darray(first_value: ot.color3darray, second_value: ot.color3darray) -> ot.color3darray:
"""Takes in two arrays of color3d attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colorf[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color3f(first_value: ot.color3f, second_value: ot.color3f) -> ot.color3f:
"""Takes in two colorf[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float32). When put into
Fabric the values are stored as 3 single-precision values. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colorf[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color3farray(first_value: ot.color3farray, second_value: ot.color3farray) -> ot.color3farray:
"""Takes in two arrays of color3f attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float32) where "N" is
the size of the array determined at runtime. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colorh[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color3h(first_value: ot.color3h, second_value: ot.color3h) -> ot.color3h:
"""Takes in two colorh[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float16). When put into
Fabric the values are stored as 3 half-precision values. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colorh[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color3harray(first_value: ot.color3harray, second_value: ot.color3harray) -> ot.color3harray:
"""Takes in two arrays of color3h attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float16) where "N" is
the size of the array determined at runtime. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colord[4]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color4d(first_value: ot.color4d, second_value: ot.color4d) -> ot.color4d:
"""Takes in two color4d values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(4,), dtype=numpy.float64). When put into
Fabric the values are stored as 4 double-precision values. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colord[4][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color4darray(first_value: ot.color4darray, second_value: ot.color4darray) -> ot.color4darray:
"""Takes in two arrays of color4d attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(4,N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colorf[4]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color4f(first_value: ot.color4f, second_value: ot.color4f) -> ot.color4f:
"""Takes in two color4f values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(4,), dtype=numpy.float32). When put into
Fabric the values are stored as 4 single-precision values. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colorf[4][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color4farray(first_value: ot.color4farray, second_value: ot.color4farray) -> ot.color4farray:
"""Takes in two arrays of color4f attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(4,N,), dtype=numpy.float32) where "N" is
the size of the array determined at runtime. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*colorh[4]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color4h(first_value: ot.color4h, second_value: ot.color4h) -> ot.color4h:
"""Takes in two color4h values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(4,), dtype=numpy.float16). When put into
Fabric the values are stored as 4 half-precision values. The color role is applied to USD and OmniGraph types as
an aid to interpreting the values.
"""
return first_value + second_value
```

*colorh[4][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_color4harray(first_value: ot.color4harray, second_value: ot.color4harray) -> ot.color4harray:
"""Takes in two arrays of color4h attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(4,N,), dtype=numpy.float16) where "N" is
the size of the array determined at runtime. The color role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*frame[4]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_frame4d(first_value: ot.frame4d, second_value: ot.frame4d) -> ot.frame4d:
"""Takes in two frame4d values and outputs the sum of them.
The types of both inputs and the return value are numpy.ndarray(shape=(4,4), dtype=numpy.float64). When put
into Fabric the values are stored as a set of 16 double-precision values. USD uses the special frame4d type.
"""
return first_value + second_value
```

*frame[4][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_frame4darray(first_value: ot.frame4darray, second_value: ot.frame4darray) -> ot.frame4darray:
"""Takes in two frame4darray values and outputs the sum of them.
The types of both inputs and the return value are numpy.ndarray(shape=(4,4,N), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. When put into Fabric the values are stored as an array of sets
of 16 double-precision values. USD stores it as the native frame4d[] type.
"""
return first_value + second_value
```

*matrixd[2]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_matrix2d(first_value: ot.matrix2d, second_value: ot.matrix2d) -> ot.matrix2d:
"""Takes in two matrix2d values and outputs the sum of them.
The types of both inputs and the return value are numpy.ndarray(shape=(2,2), dtype=numpy.float64). When put
into Fabric and USD the values are stored as a list of 4 double-precision values.
"""
return first_value + second_value
```

*matrixd[2][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_matrix2darray(first_value: ot.matrix2darray, second_value: ot.matrix2darray) -> ot.matrix2darray:
"""Takes in two matrix2darray values and outputs the sum of them.
The types of both inputs and the return value are numpy.ndarray(shape=(N,2,2), dtype=numpy.float64) where "N" is
the size of the array determined at runtime.. When put into Fabric the values are stored as an array of sets
of 9 double-precision values. USD stores it as the native matrix2d[] type.
"""
return first_value + second_value
```

*matrixd[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_matrix3d(first_value: ot.matrix3d, second_value: ot.matrix3d) -> ot.matrix3d:
"""Takes in two matrix3d values and outputs the sum of them.
The types of both inputs and the return value are numpy.ndarray(shape=(3,3), dtype=numpy.float64). When put
into Fabric and USD the values are stored as a list of 9 double-precision values.
"""
return first_value + second_value
```

*matrixd[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_matrix3darray(first_value: ot.matrix3darray, second_value: ot.matrix3darray) -> ot.matrix3darray:
"""Takes in two matrix3darray values and outputs the sum of them.
The types of both inputs and the return value are numpy.ndarray(shape=(3,3,N), dtype=numpy.float64) where "N" is
the size of the array determined at runtime.. When put into Fabric the values are stored as an array of sets
of 9 double-precision values. USD stores it as the native matrix3d[] type.
"""
return first_value + second_value
```

*matrixd[4]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_matrix4d(first_value: ot.matrix4d, second_value: ot.matrix4d) -> ot.matrix4d:
"""Takes in two matrix4d values and outputs the sum of them.
The types of both inputs and the return value are numpy.ndarray(shape=(4,4), dtype=numpy.float64). When put
into Fabric and USD the values are stored as a list of 9 double-precision values.
"""
return first_value + second_value
```

*matrixd[4][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_matrix4darray(first_value: ot.matrix4darray, second_value: ot.matrix4darray) -> ot.matrix4darray:
"""Takes in two matrix4darray values and outputs the sum of them.
The types of both inputs and the return value are numpy.ndarray(shape=(4,4,N), dtype=numpy.float64) where "N" is
the size of the array determined at runtime.. When put into Fabric the values are stored as an array of sets
of 16 double-precision values. USD stores it as the native matrix4d[] type.
"""
return first_value + second_value
```

*normald[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_normal3d(first_value: ot.normal3d, second_value: ot.normal3d) -> ot.normal3d:
"""Takes in two normald[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float64). When put into
Fabric the values are stored as 3 double-precision values. The normal role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*normald[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_normal3darray(first_value: ot.normal3darray, second_value: ot.normal3darray) -> ot.normal3darray:
"""Takes in two arrays of normal3d attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. The normal role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*normalf[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_normal3f(first_value: ot.normal3f, second_value: ot.normal3f) -> ot.normal3f:
"""Takes in two normalf[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float32). When put into
Fabric the values are stored as 3 single-precision values. The normal role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*normalf[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_normal3farray(first_value: ot.normal3farray, second_value: ot.normal3farray) -> ot.normal3farray:
"""Takes in two arrays of normal3f attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float32) where "N" is
the size of the array determined at runtime. The normal role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*normalh[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_normal3h(first_value: ot.normal3h, second_value: ot.normal3h) -> ot.normal3h:
"""Takes in two normalh[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float16). When put into
Fabric the values are stored as 3 half-precision values. The normal role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*normalh[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_normal3harray(first_value: ot.normal3harray, second_value: ot.normal3harray) -> ot.normal3harray:
"""Takes in two arrays of normal3h attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float16) where "N" is
the size of the array determined at runtime. The normal role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*pointd[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_point3d(first_value: ot.point3d, second_value: ot.point3d) -> ot.point3d:
"""Takes in two pointd[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float64). When put into
Fabric the values are stored as 3 double-precision values. The point role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*pointd[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_point3darray(first_value: ot.point3darray, second_value: ot.point3darray) -> ot.point3darray:
"""Takes in two arrays of point3d attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. The point role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*pointf[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_point3f(first_value: ot.point3f, second_value: ot.point3f) -> ot.point3f:
"""Takes in two pointf[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float32). When put into
Fabric the values are stored as 3 single-precision values. The point role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*pointf[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_point3farray(first_value: ot.point3farray, second_value: ot.point3farray) -> ot.point3farray:
"""Takes in two arrays of point3f attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float32) where "N" is
the size of the array determined at runtime. The point role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*pointh[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_point3h(first_value: ot.point3h, second_value: ot.point3h) -> ot.point3h:
"""Takes in two pointh[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float16). When put into
Fabric the values are stored as 3 half-precision values. The point role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*pointh[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_point3harray(first_value: ot.point3harray, second_value: ot.point3harray) -> ot.point3harray:
"""Takes in two arrays of point3h attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float16) where "N" is
the size of the array determined at runtime. The point role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*quatd[4]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_quatd(first_value: ot.quatd, second_value: ot.quatd) -> ot.quatd:
"""Takes in two quatd[4] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(4,), dtype=numpy.float64). When put into
Fabric the values are stored as 4 double-precision values. The quaternion role is applied to USD and OmniGraph
types as an aid to interpreting the values.
"""
return first_value + second_value
```

*quatd[4][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_quatdarray(first_value: ot.quatdarray, second_value: ot.quatdarray) -> ot.quatdarray:
"""Takes in two arrays of quatd attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(4,N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. The quaternion role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*quatf[4]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_quatf(first_value: ot.quatf, second_value: ot.quatf) -> ot.quatf:
"""Takes in two quatf[4] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(4,), dtype=numpy.float32). When put into
Fabric the values are stored as 4 single-precision values. The quaternion role is applied to USD and OmniGraph
types as an aid to interpreting the values.
"""
return first_value + second_value
```

*quatf[4][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_quatfarray(first_value: ot.quatfarray, second_value: ot.quatfarray) -> ot.quatfarray:
"""Takes in two arrays of quatf attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(4,N,), dtype=numpy.float32) where "N" is
the size of the array determined at runtime. The quaternion role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*quath[4]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_quath(first_value: ot.quath, second_value: ot.quath) -> ot.quath:
"""Takes in two quath[4] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(4,), dtype=numpy.float16). When put into
Fabric the values are stored as 4 half-precision values. The quaternion role is applied to USD and OmniGraph
types as an aid to interpreting the values.
"""
return first_value + second_value
```

*quath[4][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_quatharray(first_value: ot.quatharray, second_value: ot.quatharray) -> ot.quatharray:
"""Takes in two arrays of quath attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(4,N,), dtype=numpy.float16) where "N" is
the size of the array determined at runtime. The quaternion role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordd[2]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord2d(first_value: ot.texcoord2d, second_value: ot.texcoord2d) -> ot.texcoord2d:
"""Takes in two texcoordd[2] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(2,), dtype=numpy.float64). When put into
Fabric the values are stored as 2 double-precision values. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordd[2][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord2darray(
first_value: ot.texcoord2darray, second_value: ot.texcoord2darray
) -> ot.texcoord2darray:
"""Takes in two arrays of texcoord2d attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordf[2]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord2f(first_value: ot.texcoord2f, second_value: ot.texcoord2f) -> ot.texcoord2f:
"""Takes in two texcoordf[2] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(2,), dtype=numpy.float32). When put into
Fabric the values are stored as 2 single-precision values. The texcoord role is applied to USD and OmniGraph
types as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordf[2][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord2farray(
first_value: ot.texcoord2farray, second_value: ot.texcoord2farray
) -> ot.texcoord2farray:
"""Takes in two arrays of texcoord2f attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float32) where "N" is
the size of the array determined at runtime. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordh[2]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord2h(first_value: ot.texcoord2h, second_value: ot.texcoord2h) -> ot.texcoord2h:
"""Takes in two texcoordh[2] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(2,), dtype=numpy.float16). When put into
Fabric the values are stored as 2 half-precision values. The texcoord role is applied to USD and OmniGraph
types as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordh[2][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord2harray(
first_value: ot.texcoord2harray, second_value: ot.texcoord2harray
) -> ot.texcoord2harray:
"""Takes in two arrays of texcoord2h attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float16) where "N" is
the size of the array determined at runtime. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordd[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord3d(first_value: ot.texcoord3d, second_value: ot.texcoord3d) -> ot.texcoord3d:
"""Takes in two texcoordd[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float64). When put into
Fabric the values are stored as 3 double-precision values. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordd[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord3darray(
first_value: ot.texcoord3darray, second_value: ot.texcoord3darray
) -> ot.texcoord3darray:
"""Takes in two arrays of texcoord3d attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordf[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord3f(first_value: ot.texcoord3f, second_value: ot.texcoord3f) -> ot.texcoord3f:
"""Takes in two texcoordf[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float32). When put into
Fabric the values are stored as 3 single-precision values. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordf[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord3farray(
first_value: ot.texcoord3farray, second_value: ot.texcoord3farray
) -> ot.texcoord3farray:
"""Takes in two arrays of texcoord3f attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float32) where "N" is
the size of the array determined at runtime. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordh[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord3h(first_value: ot.texcoord3h, second_value: ot.texcoord3h) -> ot.texcoord3h:
"""Takes in two texcoordh[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float16). When put into
Fabric the values are stored as 3 half-precision values. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*texcoordh[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_texcoord3harray(
first_value: ot.texcoord3harray, second_value: ot.texcoord3harray
) -> ot.texcoord3harray:
"""Takes in two arrays of texcoord3h attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float16) where "N" is
the size of the array determined at runtime. The texcoord role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*timecode*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_timecode(first_value: ot.timecode, second_value: ot.timecode) -> ot.timecode:
"""Takes in two timecodes outputs the sum of them.
The types of both inputs and the return value are Python floats with the full precision required in order
to represent the range of legal timecodes. When put into Fabric and USD the values are stored as a
double-precision floating point value.
"""
return first_value + second_value
```

*timecode[]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_timecodearray(first_value: ot.timecodearray, second_value: ot.timecodearray) -> ot.timecodearray:
"""Takes in two arrays of timecodes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime.
"""
return first_value + second_value
```

*vectord[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_vector3d(first_value: ot.vector3d, second_value: ot.vector3d) -> ot.vector3d:
"""Takes in two vectord[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float64). When put into
Fabric the values are stored as 3 double-precision values. The vector role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*vectord[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_vector3darray(first_value: ot.vector3darray, second_value: ot.vector3darray) -> ot.vector3darray:
"""Takes in two arrays of vector3d attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float64) where "N" is
the size of the array determined at runtime. The vector role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*vectorf[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_vector3f(first_value: ot.vector3f, second_value: ot.vector3f) -> ot.vector3f:
"""Takes in two vectorf[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float32). When put into
Fabric the values are stored as 3 single-precision values. The vector role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*vectorf[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_vector3farray(first_value: ot.vector3farray, second_value: ot.vector3farray) -> ot.vector3farray:
"""Takes in two arrays of vector3f attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float32) where "N" is
the size of the array determined at runtime. The vector role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*vectorh[3]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_vector3h(first_value: ot.vector3h, second_value: ot.vector3h) -> ot.vector3h:
"""Takes in two vectorh[3] values and outputs the sum of them.
The types of both inputs and the return value are numpy.array(shape=(3,), dtype=numpy.float16). When put into
Fabric the values are stored as 3 half-precision values. The vector role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```

*vectorh[3][]*

```
import omni.graph.core as og
import omni.graph.core.types as ot
@og.create_node_type
def autonode_vector3harray(first_value: ot.vector3harray, second_value: ot.vector3harray) -> ot.vector3harray:
"""Takes in two arrays of vector3h attributes and returns an array containing the sum of each element.
The types of both inputs and the return value are numpy.ndarray(shape=(3,N,), dtype=numpy.float16) where "N" is
the size of the array determined at runtime. The vector role is applied to USD and OmniGraph types
as an aid to interpreting the values.
"""
return first_value + second_value
```