USG Python API

AssetPath

class usg.AssetPath

Bases: pybind11_object

A path to an external asset.

__init__(text: str) → None: Create an asset path from the given string.

assetPath() → str: Return the asset path.

resolvedPath() → str: Return the resolved asset path.

Attribute

class usg.Attribute

Bases: pybind11_object

An attribute.

block() → None: Unsets any authored value on the attribute.

clear() → None: Unsets any authored value on the attribute.

clearAllTimeSamples() → None: Removes all time samples from the attribute, leaving the default value unaffected.

clearAtTime(arg0: float) → None: Removes a specific time sample, ignoring default value.

clearDefault() → None: Removes the default value, leaving time samples unaffected.

get(time: float = nan) → object: Return the value of this attribute as an int, float, vector, Token, AssetPath…

getAllowedTokens() → usg::Array<usg::Token>: Returns an array of the allowed Tokens for this Attribute.

getAuthoredMetadataFieldNames() → list: Returns the field names of the authored attribute metadata.

getBaseName() → str: Return the base name of this attribute.

getCustomData() → dict: Returns a dictionary containing the attribute’s custom data.

getDocumentation() → str: Return the documentation string for this attribute.

getField(arg0: usg::Token) → usg::Value: Return a field of the attribute.

getInterpolation() → usg::Token: Return the interpolation of the attribute.

getMetadataFieldNames() → list: Returns the field names of the attribute metadata.

getName() → str: Return the name of this attribute.

getNumDataElements() → int: Returns the number of data elements for each value. For example, 3 for a Vector3 or 16 for a Matrix4.

getPath() → usg::Path: Return the path of this attribute.

getTimeSamples() → std::vector<double, std::allocator<double> >: Return the list of authored time samples for this attribute.

getType() → usg::Value::Type: Return the type of this attribute.

getTypeName() → str: Return the type of this attribute as a string.

getUsgValue(time: float = nan) → usg::Value: Return the underlying usg::Value of this attribute.

hasAllowedTokens() → bool: Returns true if this Attribute has a set of allowed Tokens.

hasAuthoredValue() → bool: Returns true if the attribute has any authored values, either a default or time samples. Returns false if the attribute has been blocked.

hasFallbackValue() → bool: Returns true if the attribute has a fallback value provided by a schema.

hasValue() → bool: Returns true if the attribute has any authored values, either a default or time samples, or if there’s a fallback value provided by a schema. Returns false if the attribute has been blocked and there is no fallback value.

isAuthored() → bool: Return whether there are any authored opinions for this property in any layer that contributes to this stage.

isBlocked() → bool: Is the attribute currently blocked? Same as calling !hasAuthoredValue().

isValid() → bool: Return whether this attribute is valid or not.

set(value: object, time: float = nan) → None: Set the value of this attribute with an int, float, vector, Token, AssetPath…

setField(arg0: usg::Token, arg1: usg::Value) → bool: Set a field of the attribute.

setInterpolation(arg0: usg::Token) → None: Set the interpolation of the attribute.

Layer

class usg.Layer

Bases: pybind11_object

The wrapper class for a reference to a USD layer.

clearOwner() → None: Clears the layer’s owner.

property colorConfiguration: Property for the color configuration metadata.

property colorManagementSystem: Property for the color management system metadata.

property comment: Property for the comment metadata.

static create(identifier: str, file_args: usg._usg.KeyValueMapSorted = KeyValueMapSorted{}) → usg._usg.Layer: Creates a new layer with the given identifier.

static createAnonymous(identifier: str, file_args: usg._usg.KeyValueMapSorted = KeyValueMapSorted{}) → usg._usg.Layer: Creates a new layer with the given identifier.

property defaultPrim: Property for the default prim metadata.

definePrim(path: usg::Path, typeName: usg::Token) → usg::Prim

Define an abstract prim in this layer. The ‘typeName’ is the prim’s schema name like ‘Mesh’, ‘Scope’, ‘Xform’, etc.

If a prim already exists at ‘path’ it is returned unchanged.

property documentation: Property for the documentation metadata.

property endTimeCode: Property for the end time code metadata.

exportToFile(filepath: str, comment: str, fileFormatArgs: usg._usg.KeyValueMapSorted) → bool: Exports the flattened layer to a file.

exportToString() → object: Return the flattened layer as a string.

static findOrOpen(identifier: str, file_args: usg._usg.KeyValueMapSorted = KeyValueMapSorted{}) → usg._usg.Layer: Searches for a layer with the given identifier in the layer cache, opening it if it’s not already.

property framePrecision: Property for the frame precision metadata.

property framesPerSecond: Property for the frames per second metadata.

getIdentifier() → str

static getLoadedLayers() → usg._usg.LayerRefSet: Returns all loaded layers.

getPrimAtPath(arg0: usg::Path) → usg::Prim: Returns true if the layer is anonymous (in-memory).

getSubLayers() → std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >: Returns the sub layers of this layer.

getUsdLayer() → object: Returns the underlying USD py::object of the usg::Layer

isAnonymous() → bool: Returns true if the layer is anonymous (in-memory).

isValid() → bool: Return true if the layer is valid (has a valid object binding).

property metersPerUnit: Property for the meters per unit metadata.

overridePrim(*args, **kwargs)

Overloaded function.

overridePrim(self: usg._usg.Layer, path: usg::Path) -> usg::Prim

Same as definePrim() but the created prim will have an ‘over’ specifier with no Type.
overridePrim(self: usg._usg.Layer, path: usg::Path, typeName: usg::Token) -> usg::Prim

Same as definePrim() but the created prim will have an ‘over’ specifier.
overridePrim(self: usg._usg.Layer, src_prim: usg::Prim) -> usg::Prim

Similar to definePrim() but the created Prim will have an ‘over’ specifier and the schema class is taken from the provided source Prim.

property owner: Property for the owner metadata.

reload() → None: Reloads the layer.

save(force: bool = False) → bool: Saves the layer.

property sessionOwner: Property for the session owner metadata.

setOwner(owner: str) → None: Sets the layer’s owner.

property startTimeCode: Property for the start time code metadata.

property timeCodesPerSecond: Property for the time codes per second metadata.

transferContent(layer: usg._usg.Layer) → None: Transfers the content of the layer into this layer.

property upAxis: Property for the up axis metadata.

Path

class usg.Path

Bases: pybind11_object

A path value used to locate objects in layers or scenegraphs.

static IsValidPathString(arg0: str) → tuple: Static method to return whether the given string path would be valid and an error message if not.

__init__(text: str) → None

Create a path from the given string.

Create an empty path if the given string does not represent a valid path.

appendChild(*args, **kwargs)

Overloaded function.

appendChild(self: usg._usg.Path, suffix: usg::Token) -> usg._usg.Path

Create a path by appending an element to this path.

This path must be a prim path, the AbsoluteRootPath or the ReflexiveRelativePath. If it is not, or the child is not a valid prim name return an empty path.
appendChild(self: usg._usg.Path, suffix: str) -> usg._usg.Path

Create a path by appending an element to this path.

This path must be a prim path, the AbsoluteRootPath or the ReflexiveRelativePath. If it is not, or the child is not a valid prim name return an empty path.

appendPath(path: usg._usg.Path) → usg._usg.Path

Create a path by appending a given relative path to this path.

This path must be a prim path or the ReflexiveRelativePath. If it is not, return an empty path.

appendProperty(property: usg::Token) → usg._usg.Path

Create a path by appending a property to this path.

This path must be a prim path or the ReflexiveRelativePath. If it is not, return an empty path.

clear() → None: Clear the path so that it is empty.

empty() → bool: Return True if this is an empty path or False otherwise.

isValidPath() → tuple: Return whether this path is valid and an error message if not.

makeAbsolutePath(anchor: usg._usg.Path) → usg._usg.Path

Return the absolute form of this path using another path as the relative basis.

If this path is already an absolute path, return a copy.

makeRelativePath(anchor: usg._usg.Path) → usg._usg.Path: Return the relative form of this path using another path as the relative basis.

name() → str: Return the name of the prim, property or relational attribute identified by the path.

parent() → usg._usg.Path: Return the path that identifies this path’s namespace parent.

Prim

class usg.Prim

Bases: pybind11_object

The wrapper class for a reference to a USD prim.

addAppliedSchema(arg0: usg::Token, arg1: usg._usg.ListPosition) → bool: Adds an applied API schema.

createCustomAttr(name: usg::Token, type: usg::Value::Type, is_time_varying: usg::TimeVariability) → usg::Attribute

Create a attach a custom attribute to this prim. If the named GeomAttr object already exists return it at its current value.

If this Prim has just been defined on a GeomLayer then the new attribute will be defined on that GeomLayer.

If this Prim is being edited then the attribute will be created on the editable GeomStage and saved to the GeomStage’s current edit target GeomLayer.

defineInLayer(path: usg::Path, typeName: usg::Token) → usg._usg.Prim: Add this prim to a given layer.

getAttr(name: str) → object: Return named attribute if it exists on the prim. Otherwise return None.

getAttributeNames() → list: Returns the list of attribute names.

getAttributes() → list: Returns the list of attributes.

getAuthoredMetadataFieldNames() → list: Returns the field names of the authored prim metadata.

getChildren(activeOnly: bool = True, includeClasses: bool = False, includeOverrides: bool = True) → list: Returns a list of child prims.

getCustomData() → dict: Returns a dictionary containing the prim’s custom data.

getKind() → usg::Token: Return the kind of this prim.

getMetadata(arg0: str) → object: Return metadata value for prim for a given key.

getMetadataFieldNames() → list: Returns the field names of the prim metadata.

getName() → str: Return the name of this prim.

getPath() → usg::Path: Get geometry path (location) of this prim.

getRelationship(name: str) → object: Return named relationship if it exists on the prim. Otherwise return None.

getRelationshipNames() → list: Returns the list of relationship names.

getRelationships() → list: Returns the list of relationships.

getTypeName() → usg::Token: Get the type of this prim as a string.

getVariantSelection(arg0: str) → str: Return the variant selection for a given variant set name.

getVariantSets() → std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >: Get variant sets from prim as a StringArray.

getVariants(arg0: str) → std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >: Get variants for a given variant set name as a StringArray.

isActive() → bool: Return true if this prim is active.

isLoaded() → bool: Return true if this prim is active, and either it is loadable and it is loaded, or its nearest loadable ancestor is loaded, or it has no loadable ancestor; false otherwise.

isValid() → bool: Return whether this prim is valid or not.

removeAppliedSchema(arg0: usg::Token) → bool: Removes an applied API schema from any list ops it is present in.

removeProperty(arg0: usg::Token) → None: Removes a property if this prim is an SDF representation.

Relationship

class usg.Relationship

Bases: pybind11_object

The wrapper class for a reference to a Relationship.

getAuthoredMetadataFieldNames() → list: Returns the field names of the authored relationship metadata.

getBaseName() → str: Return the base name of this Relationship.

getCustomData() → dict: Returns a dictionary containing the relationship’s custom data.

getField(arg0: usg::Token) → usg::Value: Returns the metadata field given the field name.

getMetadataFieldNames() → list: Returns the field names of the relationship metadata.

getName() → str: Return the name of this Relationship.

getPath() → usg::Path: Full path including the Prim parent.

getTarget() → usg::Path: Retrieve the first target path.

getTargets() → usg::Array<usg::Path>: Retrieves the relationship’s target paths.

isAuthored() → bool: Return whether this Relationship is authored or not.

isValid() → bool: Return whether this Relationship is valid or not.

setField(arg0: usg::Token, arg1: usg::Value) → bool: Sets the metadata field given the field name and its new value.

setTarget(arg0: usg::Path) → None: Sets the relationship’s target path to a single path.

setTargets(arg0: usg::Array<usg::Path>) → None: Sets the relationship’s target paths.

Stage

class usg.Stage

Bases: pybind11_object

The wrapper class for a reference to a stage.

static create(sessionLayer: usg::Layer, loadAll: bool = True) → usg._usg.Stage: Creates a new Stage from the session layer.

static createMasked(sessionLayer: usg::Layer, maskPaths: usg::Array<usg::Path>) → usg._usg.Stage: Creates a new Stage from the session layer.

exportToString() → object: Return the flattened stage as a string.

flatten(addComment: bool = True) → usg::Layer: Return an anonymous layer containing the flattened stage.

flattenLayerStack() → usg::Layer: Returns the flattened stage as a single anonymous layer. Unlike ‘flatten’, this preserves variants and some composition arcs.

getLayerStack() → std::vector<std::shared_ptr<usg::Layer>, std::allocator<std::shared_ptr<usg::Layer> > >: Returns the layer stack.

getPrimAtPath(path: str) → object: Return prim at given path from that stage. Otherwise return None.

getPrimPathsByTypeName(typeName: usg::Token, traverseModelHierarchy: bool = True) → usg::Array<usg::Path>: Returns a list of prim paths which match the given type.

getRootLayer() → usg::Layer: Return this stage’s root layer.

getUsdStage() → object: Returns the underlying USD py::object of the usg::Stage

isValid() → bool: Return true if the stage is valid (has a valid binding to a USD stage).

StageNotifications

class usg.StageNotifications

Bases: pybind11_object

Stage notifications

__init__(arg0: usg._usg.Stage) → None

clearChanged() → None

isChanged() → bool

Token

class usg.Token

Bases: pybind11_object

The wrapper class for PXR_NS::TfToken.

__init__(text: str) → None: Create a token from the given text.

Value

class usg.Value

Bases: pybind11_object

An object which can hold many types of value.

ASSETPATH_DATA = <DataType.ASSETPATH_DATA: 2>

AssetPath = <Type.AssetPath: 6>

AssetPathArray = <Type.AssetPathArray: 7>

Bool = <Type.Bool: 9>

BoolArray = <Type.BoolArray: 10>

Channel = <Type.Channel: 65>

ChannelArray = <Type.ChannelArray: 66>

Color = <Type.Color: 67>

Color3d = <Type.Color3d: 73>

Color3dArray = <Type.Color3dArray: 74>

Color3f = <Type.Color3f: 71>

Color3fArray = <Type.Color3fArray: 72>

Color3h = <Type.Color3h: 69>

Color3hArray = <Type.Color3hArray: 70>

Color4d = <Type.Color4d: 79>

Color4dArray = <Type.Color4dArray: 80>

Color4f = <Type.Color4f: 77>

Color4fArray = <Type.Color4fArray: 78>

Color4h = <Type.Color4h: 75>

Color4hArray = <Type.Color4hArray: 76>

ColorArray = <Type.ColorArray: 68>

DOUBLE_DATA = <DataType.DOUBLE_DATA: 10>

class DataType

Bases: pybind11_object

Members:

STRING_DATA

TOKEN_DATA

ASSETPATH_DATA

PATHEXPRESSION_DATA

INT8_DATA

INT16_DATA

INT32_DATA

INT64_DATA

HALF_DATA

FLOAT_DATA

DOUBLE_DATA

ASSETPATH_DATA = <DataType.ASSETPATH_DATA: 2>

DOUBLE_DATA = <DataType.DOUBLE_DATA: 10>

FLOAT_DATA = <DataType.FLOAT_DATA: 9>

HALF_DATA = <DataType.HALF_DATA: 8>

INT16_DATA = <DataType.INT16_DATA: 5>

INT32_DATA = <DataType.INT32_DATA: 6>

INT64_DATA = <DataType.INT64_DATA: 7>

INT8_DATA = <DataType.INT8_DATA: 4>

PATHEXPRESSION_DATA = <DataType.PATHEXPRESSION_DATA: 3>

STRING_DATA = <DataType.STRING_DATA: 0>

TOKEN_DATA = <DataType.TOKEN_DATA: 1>

__init__(value: int) → None

property name

property value

Double = <Type.Double: 25>

Double2 = <Type.Double2: 35>

Double2Array = <Type.Double2Array: 36>

Double3 = <Type.Double3: 43>

Double3Array = <Type.Double3Array: 44>

Double4 = <Type.Double4: 51>

Double4Array = <Type.Double4Array: 52>

DoubleArray = <Type.DoubleArray: 26>

FLOAT_DATA = <DataType.FLOAT_DATA: 9>

Float = <Type.Float: 23>

Float2 = <Type.Float2: 33>

Float2Array = <Type.Float2Array: 34>

Float3 = <Type.Float3: 41>

Float3Array = <Type.Float3Array: 42>

Float4 = <Type.Float4: 49>

Float4Array = <Type.Float4Array: 50>

FloatArray = <Type.FloatArray: 24>

Frame4d = <Type.Frame4d: 119>

Frame4dArray = <Type.Frame4dArray: 120>

HALF_DATA = <DataType.HALF_DATA: 8>

Half = <Type.Half: 21>

Half2 = <Type.Half2: 31>

Half2Array = <Type.Half2Array: 32>

Half3 = <Type.Half3: 39>

Half3Array = <Type.Half3Array: 40>

Half4 = <Type.Half4: 47>

Half4Array = <Type.Half4Array: 48>

HalfArray = <Type.HalfArray: 22>

INT16_DATA = <DataType.INT16_DATA: 5>

INT32_DATA = <DataType.INT32_DATA: 6>

INT64_DATA = <DataType.INT64_DATA: 7>

INT8_DATA = <DataType.INT8_DATA: 4>

Int = <Type.Int: 11>

Int2 = <Type.Int2: 29>

Int2Array = <Type.Int2Array: 30>

Int3 = <Type.Int3: 37>

Int3Array = <Type.Int3Array: 38>

Int4 = <Type.Int4: 45>

Int4Array = <Type.Int4Array: 46>

Int64 = <Type.Int64: 13>

Int64Array = <Type.Int64Array: 14>

IntArray = <Type.IntArray: 12>

InvalidType = <Type.InvalidType: 127>

Matrix = <Type.Matrix: 117>

Matrix2d = <Type.Matrix2d: 53>

Matrix2dArray = <Type.Matrix2dArray: 54>

Matrix3d = <Type.Matrix3d: 55>

Matrix3dArray = <Type.Matrix3dArray: 56>

Matrix4d = <Type.Matrix4d: 57>

Matrix4dArray = <Type.Matrix4dArray: 58>

MatrixArray = <Type.MatrixArray: 118>

Normal = <Type.Normal: 81>

Normal3d = <Type.Normal3d: 87>

Normal3dArray = <Type.Normal3dArray: 88>

Normal3f = <Type.Normal3f: 85>

Normal3fArray = <Type.Normal3fArray: 86>

Normal3h = <Type.Normal3h: 83>

Normal3hArray = <Type.Normal3hArray: 84>

NormalArray = <Type.NormalArray: 82>

PATHEXPRESSION_DATA = <DataType.PATHEXPRESSION_DATA: 3>

PathExpr = <Type.PathExpr: 8>

Point = <Type.Point: 89>

Point3d = <Type.Point3d: 95>

Point3dArray = <Type.Point3dArray: 96>

Point3f = <Type.Point3f: 93>

Point3fArray = <Type.Point3fArray: 94>

Point3h = <Type.Point3h: 91>

Point3hArray = <Type.Point3hArray: 92>

PointArray = <Type.PointArray: 90>

Quatd = <Type.Quatd: 63>

QuatdArray = <Type.QuatdArray: 64>

Quatf = <Type.Quatf: 61>

QuatfArray = <Type.QuatfArray: 62>

Quath = <Type.Quath: 59>

QuathArray = <Type.QuathArray: 60>

STRING_DATA = <DataType.STRING_DATA: 0>

String = <Type.String: 0>

StringArray = <Type.StringArray: 1>

Struct = <Type.Struct: 121>

StructArray = <Type.StructArray: 122>

TOKEN_DATA = <DataType.TOKEN_DATA: 1>

Terminal = <Type.Terminal: 123>

TerminalArray = <Type.TerminalArray: 124>

TexCoord2d = <Type.TexCoord2d: 109>

TexCoord2dArray = <Type.TexCoord2dArray: 110>

TexCoord2f = <Type.TexCoord2f: 107>

TexCoord2fArray = <Type.TexCoord2fArray: 108>

TexCoord2h = <Type.TexCoord2h: 105>

TexCoord2hArray = <Type.TexCoord2hArray: 106>

TexCoord3d = <Type.TexCoord3d: 115>

TexCoord3dArray = <Type.TexCoord3dArray: 116>

TexCoord3f = <Type.TexCoord3f: 113>

TexCoord3fArray = <Type.TexCoord3fArray: 114>

TexCoord3h = <Type.TexCoord3h: 111>

TexCoord3hArray = <Type.TexCoord3hArray: 112>

TimeCode = <Type.TimeCode: 27>

TimeCodeArray = <Type.TimeCodeArray: 28>

Token = <Type.Token: 2>

TokenArray = <Type.TokenArray: 3>

class Type

Bases: pybind11_object

Members:

String

StringArray

Token

TokenArray

AssetPath

AssetPathArray

PathExpr

Bool

BoolArray

Int

IntArray

Int64

Int64Array

UChar

UCharArray

UInt

UIntArray

UInt64

UInt64Array

Half

HalfArray

Float

FloatArray

Double

DoubleArray

TimeCode

TimeCodeArray

Int2

Int2Array

Half2

Half2Array

Float2

Float2Array

Double2

Double2Array

Int3

Int3Array

Half3

Half3Array

Float3

Float3Array

Double3

Double3Array

Int4

Int4Array

Half4

Half4Array

Float4

Float4Array

Double4

Double4Array

Matrix2d

Matrix2dArray

Matrix3d

Matrix3dArray

Matrix4d

Matrix4dArray

Quath

QuathArray

Quatf

QuatfArray

Quatd

QuatdArray

Channel

ChannelArray

Color

ColorArray

Color3h

Color3hArray

Color3f

Color3fArray

Color3d

Color3dArray

Color4h

Color4hArray

Color4f

Color4fArray

Color4d

Color4dArray

Normal

NormalArray

Normal3h

Normal3hArray

Normal3f

Normal3fArray

Normal3d

Normal3dArray

Point

PointArray

Point3h

Point3hArray

Point3f

Point3fArray

Point3d

Point3dArray

Vector

VectorArray

Vector3h

Vector3hArray

Vector3f

Vector3fArray

Vector3d

Vector3dArray

TexCoord2h

TexCoord2hArray

TexCoord2f

TexCoord2fArray

TexCoord2d

TexCoord2dArray

TexCoord3h

TexCoord3hArray

TexCoord3f

TexCoord3fArray

TexCoord3d

TexCoord3dArray

Matrix

MatrixArray

Frame4d

Frame4dArray

Struct

StructArray

Terminal

TerminalArray

Vstruct

VstructArray

InvalidType

AssetPath = <Type.AssetPath: 6>

AssetPathArray = <Type.AssetPathArray: 7>

Bool = <Type.Bool: 9>

BoolArray = <Type.BoolArray: 10>

Channel = <Type.Channel: 65>

ChannelArray = <Type.ChannelArray: 66>

Color = <Type.Color: 67>

Color3d = <Type.Color3d: 73>

Color3dArray = <Type.Color3dArray: 74>

Color3f = <Type.Color3f: 71>

Color3fArray = <Type.Color3fArray: 72>

Color3h = <Type.Color3h: 69>

Color3hArray = <Type.Color3hArray: 70>

Color4d = <Type.Color4d: 79>

Color4dArray = <Type.Color4dArray: 80>

Color4f = <Type.Color4f: 77>

Color4fArray = <Type.Color4fArray: 78>

Color4h = <Type.Color4h: 75>

Color4hArray = <Type.Color4hArray: 76>

ColorArray = <Type.ColorArray: 68>

Double = <Type.Double: 25>

Double2 = <Type.Double2: 35>

Double2Array = <Type.Double2Array: 36>

Double3 = <Type.Double3: 43>

Double3Array = <Type.Double3Array: 44>

Double4 = <Type.Double4: 51>

Double4Array = <Type.Double4Array: 52>

DoubleArray = <Type.DoubleArray: 26>

Float = <Type.Float: 23>

Float2 = <Type.Float2: 33>

Float2Array = <Type.Float2Array: 34>

Float3 = <Type.Float3: 41>

Float3Array = <Type.Float3Array: 42>

Float4 = <Type.Float4: 49>

Float4Array = <Type.Float4Array: 50>

FloatArray = <Type.FloatArray: 24>

Frame4d = <Type.Frame4d: 119>

Frame4dArray = <Type.Frame4dArray: 120>

Half = <Type.Half: 21>

Half2 = <Type.Half2: 31>

Half2Array = <Type.Half2Array: 32>

Half3 = <Type.Half3: 39>

Half3Array = <Type.Half3Array: 40>

Half4 = <Type.Half4: 47>

Half4Array = <Type.Half4Array: 48>

HalfArray = <Type.HalfArray: 22>

Int = <Type.Int: 11>

Int2 = <Type.Int2: 29>

Int2Array = <Type.Int2Array: 30>

Int3 = <Type.Int3: 37>

Int3Array = <Type.Int3Array: 38>

Int4 = <Type.Int4: 45>

Int4Array = <Type.Int4Array: 46>

Int64 = <Type.Int64: 13>

Int64Array = <Type.Int64Array: 14>

IntArray = <Type.IntArray: 12>

InvalidType = <Type.InvalidType: 127>

Matrix = <Type.Matrix: 117>

Matrix2d = <Type.Matrix2d: 53>

Matrix2dArray = <Type.Matrix2dArray: 54>

Matrix3d = <Type.Matrix3d: 55>

Matrix3dArray = <Type.Matrix3dArray: 56>

Matrix4d = <Type.Matrix4d: 57>

Matrix4dArray = <Type.Matrix4dArray: 58>

MatrixArray = <Type.MatrixArray: 118>

Normal = <Type.Normal: 81>

Normal3d = <Type.Normal3d: 87>

Normal3dArray = <Type.Normal3dArray: 88>

Normal3f = <Type.Normal3f: 85>

Normal3fArray = <Type.Normal3fArray: 86>

Normal3h = <Type.Normal3h: 83>

Normal3hArray = <Type.Normal3hArray: 84>

NormalArray = <Type.NormalArray: 82>

PathExpr = <Type.PathExpr: 8>

Point = <Type.Point: 89>

Point3d = <Type.Point3d: 95>

Point3dArray = <Type.Point3dArray: 96>

Point3f = <Type.Point3f: 93>

Point3fArray = <Type.Point3fArray: 94>

Point3h = <Type.Point3h: 91>

Point3hArray = <Type.Point3hArray: 92>

PointArray = <Type.PointArray: 90>

Quatd = <Type.Quatd: 63>

QuatdArray = <Type.QuatdArray: 64>

Quatf = <Type.Quatf: 61>

QuatfArray = <Type.QuatfArray: 62>

Quath = <Type.Quath: 59>

QuathArray = <Type.QuathArray: 60>

String = <Type.String: 0>

StringArray = <Type.StringArray: 1>

Struct = <Type.Struct: 121>

StructArray = <Type.StructArray: 122>

Terminal = <Type.Terminal: 123>

TerminalArray = <Type.TerminalArray: 124>

TexCoord2d = <Type.TexCoord2d: 109>

TexCoord2dArray = <Type.TexCoord2dArray: 110>

TexCoord2f = <Type.TexCoord2f: 107>

TexCoord2fArray = <Type.TexCoord2fArray: 108>

TexCoord2h = <Type.TexCoord2h: 105>

TexCoord2hArray = <Type.TexCoord2hArray: 106>

TexCoord3d = <Type.TexCoord3d: 115>

TexCoord3dArray = <Type.TexCoord3dArray: 116>

TexCoord3f = <Type.TexCoord3f: 113>

TexCoord3fArray = <Type.TexCoord3fArray: 114>

TexCoord3h = <Type.TexCoord3h: 111>

TexCoord3hArray = <Type.TexCoord3hArray: 112>

TimeCode = <Type.TimeCode: 27>

TimeCodeArray = <Type.TimeCodeArray: 28>

Token = <Type.Token: 2>

TokenArray = <Type.TokenArray: 3>

UChar = <Type.UChar: 15>

UCharArray = <Type.UCharArray: 16>

UInt = <Type.UInt: 17>

UInt64 = <Type.UInt64: 19>

UInt64Array = <Type.UInt64Array: 20>

UIntArray = <Type.UIntArray: 18>

Vector = <Type.Vector: 97>

Vector3d = <Type.Vector3d: 103>

Vector3dArray = <Type.Vector3dArray: 104>

Vector3f = <Type.Vector3f: 101>

Vector3fArray = <Type.Vector3fArray: 102>

Vector3h = <Type.Vector3h: 99>

Vector3hArray = <Type.Vector3hArray: 100>

VectorArray = <Type.VectorArray: 98>

Vstruct = <Type.Vstruct: 125>

VstructArray = <Type.VstructArray: 126>

__init__(value: int) → None

baseDataType() → usg._usg.Value.DataType

baseType() → usg._usg.Value.Type

name()

__str__(*args, **kwargs) Overloaded function.

__str__(self: usg._usg.Value.Type) -> str
__str__(self: handle) -> str

property value

UChar = <Type.UChar: 15>

UCharArray = <Type.UCharArray: 16>

UInt = <Type.UInt: 17>

UInt64 = <Type.UInt64: 19>

UInt64Array = <Type.UInt64Array: 20>

UIntArray = <Type.UIntArray: 18>

Vector = <Type.Vector: 97>

Vector3d = <Type.Vector3d: 103>

Vector3dArray = <Type.Vector3dArray: 104>

Vector3f = <Type.Vector3f: 101>

Vector3fArray = <Type.Vector3fArray: 102>

Vector3h = <Type.Vector3h: 99>

Vector3hArray = <Type.Vector3hArray: 100>

VectorArray = <Type.VectorArray: 98>

Vstruct = <Type.Vstruct: 125>

VstructArray = <Type.VstructArray: 126>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Value, data: object, type: usg::Value::Type) -> None

Create a Value of the Value type specified by the type argument with given data. This method only supports the Types which are implicitly cast, all other types should use the default single argument constructor. The Types this method supports are: UChar, Bool, Int, Int64, UInt, UInt64, Float, Double. Will return an invalid value if the cast failed or the type is not supported.
__init__(self: usg._usg.Value, data: str) -> None

Create a Value of type String with given data.
__init__(self: usg._usg.Value, data: usg._usg.Token) -> None

Create a Value of type Token with given input data.
__init__(self: usg._usg.Value, arg0: usg._usg.AssetPath) -> None

Create a Value of type AssetPath with given input data.
__init__(self: usg._usg.Value, arg0: usg._usg.PathExpr) -> None

Create a Value of type PathExpr with given input data.
__init__(self: usg._usg.Value, arg0: usg._usg.Path) -> None

Create a Value of type Path with given input data.
__init__(self: usg._usg.Value, data: std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >) -> None

Create a Value of type StringArray with given input data.
__init__(self: usg._usg.Value, data: usg::Array<usg::Token>) -> None

Create a Value of type TokenArray with given input data.
__init__(self: usg._usg.Value, data: bool) -> None

Create a Value of type Bool with given input data.
__init__(self: usg._usg.Value, data: int) -> None

Create a Value of type Int with given input data.
__init__(self: usg._usg.Value, data: usg::Array<int>) -> None

Create a Value of type IntArray with given input data.
__init__(self: usg._usg.Value, data: usg::Array<long>) -> None

Create a Value of type Int64Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<unsigned int>) -> None

Create a Value of type UIntArray with given input data.
__init__(self: usg._usg.Value, data: usg::Array<unsigned long>) -> None

Create a Value of type UInt64Array with given input data.
__init__(self: usg._usg.Value, data: fdk::half) -> None

Create a Value of type half with given input data.
__init__(self: usg._usg.Value, data: float) -> None

Create a Value of type Double with given input data.
__init__(self: usg._usg.Value, data: usg::Array<float>) -> None

Create a Value of type FloatArray with given input data.
__init__(self: usg._usg.Value, data: usg::Array<double>) -> None

Create a Value of type DoubleArray with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec2<fdk::half>) -> None

Create a Value of type Half2 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec2<float>) -> None

Create a Value of type Float2 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec2<double>) -> None

Create a Value of type Double2 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec2<int>) -> None

Create a Value of type Int2 with given data.
__init__(self: usg._usg.Value, data: fdk::Vec3<fdk::half>) -> None

Create a Value of type Half3 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec3<float>) -> None

Create a Value of type Float3 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec3<double>) -> None

Create a Value of type Double3 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec3<int>) -> None

Create a Value of type Int3 with given data.
__init__(self: usg._usg.Value, data: fdk::Vec4<fdk::half>) -> None

Create a Value of type Half4 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec4<float>) -> None

Create a Value of type Float4 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec4<double>) -> None

Create a Value of type Double4 with given input data.
__init__(self: usg._usg.Value, data: fdk::Vec4<int>) -> None

Create a Value of type Int4 with given data.
__init__(self: usg._usg.Value, data: fdk::Quat<fdk::half>) -> None

Create a Value of type Quath with given data.
__init__(self: usg._usg.Value, data: fdk::Quat<float>) -> None

Create a Value of type Quatf with given input data.
__init__(self: usg._usg.Value, data: fdk::Quat<double>) -> None

Create a Value of type Quatd with given input data.
__init__(self: usg._usg.Value, data: fdk::Mat4<double>) -> None

Create a Value of type Matrix4d with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec2<fdk::half> >) -> None

Create a Value of type Half2Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec2<float> >) -> None

Create a Value of type Float2Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec2<double> >) -> None

Create a Value of type Double2Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec2<int> >) -> None

Create a Value of type Int2Array with given data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec3<fdk::half> >) -> None

Create a Value of type Half3Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec3<float> >) -> None

Create a Value of type Float3Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec3<double> >) -> None

Create a Value of type Double3Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec3<int> >) -> None

Create a Value of type Int3Array with given data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec4<fdk::half> >) -> None

Create a Value of type Half4Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec4<float> >) -> None

Create a Value of type Float4Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec4<double> >) -> None

Create a Value of type Double4Array with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Vec4<int> >) -> None

Create a Value of type Int4Array with given data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Quat<fdk::half> >) -> None

Create a Value of type QuathArray with given data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Quat<float> >) -> None

Create a Value of type QuatfArray with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Quat<double> >) -> None

Create a Value of type QuatdArray with given input data.
__init__(self: usg._usg.Value, data: usg::Array<fdk::Mat4<double> >) -> None

Create a Value of type Matrix4dArray with given input data.

get() → object: Return value of Value as a python type.

getBaseDataType() → usg::Value::DataType: Return the base data type for this Value.

getNumDataElements() → int: Return the number of data elements for the Type. For example, 3 for a Vector3 or 16 for a Matrix4. 0 is returned if Value is not valid.

getSize() → int: Return the number of values in the Value. 0 is returned if Value not valid. 1 is returned if Value is not an array type, otherwise array size is returned.

getType() → usg::Value::Type: Return a usg.Value.Type of the type name stored in the value.

isArray() → bool: Return true if Value is valid and an array.

isValid() → bool: Return true if Value is valid.

Utils

Utility functions

usg.utils.GetConcreteSchemaTypeNames() → usg._usg.StringArray: Returns a usg.StringArray of the all the registered Concrete Schema. Will load any associated plugin to discover the total set available in the current USD session.

usg.utils.GetAPISchemaTypeNames() → usg._usg.StringArray: Returns a usg.StringArray of the all the registered API Schema types. Will load any associated plugin to discover the total set available in the current USD session.

usg.utils.GetSchemaTfTypeNames() → usg._usg.StringArray: Returns a usg.StringArray of the all the registered Schema types. Will load any associated plugin to discover the total set available in the current USD session.

usg.utils.GetDefaultAttributesForType(arg0: usg._usg.Token) → usg._usg.AttributeArray: Returns a list of usg.Attributes defined for the a provided name of a Concrete Type

usg.utils.GetDefaultAttributesForAPISchema(arg0: usg._usg.Token) → usg._usg.AttributeArray: Returns a list of usg.Attributes defined for the a provided name of an APISchema

usg.utils.GetDefaultRelationshipsForType(arg0: usg._usg.Token) → usg._usg.RelationshipArray: Returns a list of usg.Relationships defined for the a provided name of a Concrete Type

usg.utils.GetDefaultRelationshipsForAPISchema(arg0: usg._usg.Token) → usg._usg.RelationshipArray: Returns a list of usg.Relationships defined for the a provided name of an APISchema

Other Prims

class usg.BasisCurvesPrim

Bases: CurvesPrim

__init__(arg0: usg._usg.Prim) → None

createBasisAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createTypeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createWrapAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.BasisCurvesPrim

getBasis(time: float = nan) → usg._usg.Token

getBasisAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.BasisCurvesPrim

getType(time: float = nan) → usg._usg.Token

getTypeAttr() → usg._usg.Attribute

getWrap(time: float = nan) → usg._usg.Token

getWrapAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.BasisCurvesPrim

setBasis(value: usg._usg.Token, time: float = nan) → None

setType(value: usg._usg.Token, time: float = nan) → None

setWrap(value: usg._usg.Token, time: float = nan) → None

class usg.BoundablePrim

Bases: XformablePrim

__init__(arg0: usg._usg.Prim) → None

createExtentAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getExtent(time: float = nan) → usg._usg.Vec3fArray

getExtentAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.BoundablePrim

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.BoundablePrim

setExtent(value: usg._usg.Vec3fArray, time: float = nan) → None

class usg.CameraPrim

Bases: XformablePrim

__init__(arg0: usg._usg.Prim) → None

createClippingPlanesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createClippingRangeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCloseAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createExposureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFStopAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFocalLengthAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFocusDistanceAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createHorizontalApertureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createHorizontalApertureOffsetAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createOpenAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createProjectionAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createStereoRoleAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVerticalApertureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVerticalApertureOffsetAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.CameraPrim

getClippingPlanes(time: float = nan) → usg._usg.Vec4fArray

getClippingPlanesAttr() → usg._usg.Attribute

getClippingRange(time: float = nan) → usg._usg.Vec2f

getClippingRangeAttr() → usg._usg.Attribute

getClose(time: float = nan) → float

getCloseAttr() → usg._usg.Attribute

getExposure(time: float = nan) → float

getExposureAttr() → usg._usg.Attribute

getFStop(time: float = nan) → float

getFStopAttr() → usg._usg.Attribute

getFocalLength(time: float = nan) → float

getFocalLengthAttr() → usg._usg.Attribute

getFocusDistance(time: float = nan) → float

getFocusDistanceAttr() → usg._usg.Attribute

getHorizontalAperture(time: float = nan) → float

getHorizontalApertureAttr() → usg._usg.Attribute

getHorizontalApertureOffset(time: float = nan) → float

getHorizontalApertureOffsetAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.CameraPrim

getOpen(time: float = nan) → float

getOpenAttr() → usg._usg.Attribute

getProjection(time: float = nan) → usg._usg.Token

getProjectionAttr() → usg._usg.Attribute

getStereoRole(time: float = nan) → usg._usg.Token

getStereoRoleAttr() → usg._usg.Attribute

getVerticalAperture(time: float = nan) → float

getVerticalApertureAttr() → usg._usg.Attribute

getVerticalApertureOffset(time: float = nan) → float

getVerticalApertureOffsetAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.CameraPrim

setClippingPlanes(value: usg._usg.Vec4fArray, time: float = nan) → None

setClippingRange(value: usg._usg.Vec2f, time: float = nan) → None

setClose(value: float, time: float = nan) → None

setExposure(value: float, time: float = nan) → None

setFStop(value: float, time: float = nan) → None

setFocalLength(value: float, time: float = nan) → None

setFocusDistance(value: float, time: float = nan) → None

setHorizontalAperture(value: float, time: float = nan) → None

setHorizontalApertureOffset(value: float, time: float = nan) → None

setOpen(value: float, time: float = nan) → None

setProjection(value: usg._usg.Token, time: float = nan) → None

setStereoRole(value: usg._usg.Token, time: float = nan) → None

setVerticalAperture(value: float, time: float = nan) → None

setVerticalApertureOffset(value: float, time: float = nan) → None

class usg.CapsulePrim

Bases: GprimPrim

__init__(arg0: usg._usg.Prim) → None

createAxisAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createHeightAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRadiusAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.CapsulePrim

getAxis(time: float = nan) → usg._usg.Token

getAxisAttr() → usg._usg.Attribute

getHeight(time: float = nan) → float

getHeightAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.CapsulePrim

getRadius(time: float = nan) → float

getRadiusAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.CapsulePrim

setAxis(value: usg._usg.Token, time: float = nan) → None

setHeight(value: float, time: float = nan) → None

setRadius(value: float, time: float = nan) → None

class usg.ConePrim

Bases: GprimPrim

__init__(arg0: usg._usg.Prim) → None

createAxisAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createHeightAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRadiusAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.ConePrim

getAxis(time: float = nan) → usg._usg.Token

getAxisAttr() → usg._usg.Attribute

getHeight(time: float = nan) → float

getHeightAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.ConePrim

getRadius(time: float = nan) → float

getRadiusAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.ConePrim

setAxis(value: usg._usg.Token, time: float = nan) → None

setHeight(value: float, time: float = nan) → None

setRadius(value: float, time: float = nan) → None

class usg.CubePrim

Bases: GprimPrim

__init__(arg0: usg._usg.Prim) → None

createSizeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.CubePrim

getInStage(arg0: usg._usg.Path) → usg._usg.CubePrim

getSize(time: float = nan) → float

getSizeAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.CubePrim

setSize(value: float, time: float = nan) → None

class usg.CurvesPrim

Bases: PointBasedPrim

__init__(arg0: usg._usg.Prim) → None

createCurveVertexCountsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createWidthsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getCurveVertexCounts(time: float = nan) → usg._usg.IntArray

getCurveVertexCountsAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.CurvesPrim

getWidths(time: float = nan) → usg._usg.FloatArray

getWidthsAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.CurvesPrim

setCurveVertexCounts(value: usg._usg.IntArray, time: float = nan) → None

setWidths(value: usg._usg.FloatArray, time: float = nan) → None

class usg.CylinderPrim

Bases: GprimPrim

__init__(arg0: usg._usg.Prim) → None

createAxisAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createHeightAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRadiusAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.CylinderPrim

getAxis(time: float = nan) → usg._usg.Token

getAxisAttr() → usg._usg.Attribute

getHeight(time: float = nan) → float

getHeightAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.CylinderPrim

getRadius(time: float = nan) → float

getRadiusAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.CylinderPrim

setAxis(value: usg._usg.Token, time: float = nan) → None

setHeight(value: float, time: float = nan) → None

setRadius(value: float, time: float = nan) → None

class usg.GeomSubsetPrim

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

createElementTypeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFamilyNameAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createIndicesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.GeomSubsetPrim

getElementType(time: float = nan) → usg._usg.Token

getElementTypeAttr() → usg._usg.Attribute

getFamilyName(time: float = nan) → usg._usg.Token

getFamilyNameAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.GeomSubsetPrim

getIndices(time: float = nan) → usg._usg.IntArray

getIndicesAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.GeomSubsetPrim

setElementType(value: usg._usg.Token, time: float = nan) → None

setFamilyName(value: usg._usg.Token, time: float = nan) → None

setIndices(value: usg._usg.IntArray, time: float = nan) → None

class usg.GprimPrim

Bases: BoundablePrim

__init__(arg0: usg._usg.Prim) → None

createDisplayColorAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDisplayOpacityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDoubleSidedAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createOrientationAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getDisplayColor(time: float = nan) → usg._usg.Vec3fArray

getDisplayColorAttr() → usg._usg.Attribute

getDisplayOpacity(time: float = nan) → usg._usg.FloatArray

getDisplayOpacityAttr() → usg._usg.Attribute

getDoubleSided(time: float = nan) → bool

getDoubleSidedAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.GprimPrim

getOrientation(time: float = nan) → usg._usg.Token

getOrientationAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.GprimPrim

setDisplayColor(value: usg._usg.Vec3fArray, time: float = nan) → None

setDisplayOpacity(value: usg._usg.FloatArray, time: float = nan) → None

setDoubleSided(value: bool, time: float = nan) → None

setOrientation(value: usg._usg.Token, time: float = nan) → None

class usg.HermiteCurvesPrim

Bases: CurvesPrim

__init__(arg0: usg._usg.Prim) → None

createTangentsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.HermiteCurvesPrim

getInStage(arg0: usg._usg.Path) → usg._usg.HermiteCurvesPrim

getTangents(time: float = nan) → usg._usg.Vec3fArray

getTangentsAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.HermiteCurvesPrim

setTangents(value: usg._usg.Vec3fArray, time: float = nan) → None

class usg.ImageablePrim

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

createProxyPrimRel() → usg._usg.Relationship

createPurposeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.ImageablePrim

getProxyPrimRel() → usg._usg.Relationship

getPurpose(time: float = nan) → usg._usg.Token

getPurposeAttr() → usg._usg.Attribute

getVisibility(time: float = nan) → usg._usg.Token

getVisibilityAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.ImageablePrim

setPurpose(value: usg._usg.Token, time: float = nan) → None

setVisibility(value: usg._usg.Token, time: float = nan) → None

class usg.MeshPrim

Bases: PointBasedPrim

__init__(arg0: usg._usg.Prim) → None

createCornerIndicesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCornerSharpnessesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCreaseIndicesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCreaseLengthsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCreaseSharpnessesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFaceVaryingLinearInterpolationAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFaceVertexCountsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFaceVertexIndicesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createHoleIndicesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createInterpolateBoundaryAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createSubdivisionSchemeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createTriangleSubdivisionRuleAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.MeshPrim

getCornerIndices(time: float = nan) → usg._usg.IntArray

getCornerIndicesAttr() → usg._usg.Attribute

getCornerSharpnesses(time: float = nan) → usg._usg.FloatArray

getCornerSharpnessesAttr() → usg._usg.Attribute

getCreaseIndices(time: float = nan) → usg._usg.IntArray

getCreaseIndicesAttr() → usg._usg.Attribute

getCreaseLengths(time: float = nan) → usg._usg.IntArray

getCreaseLengthsAttr() → usg._usg.Attribute

getCreaseSharpnesses(time: float = nan) → usg._usg.FloatArray

getCreaseSharpnessesAttr() → usg._usg.Attribute

getFaceVaryingLinearInterpolation(time: float = nan) → usg._usg.Token

getFaceVaryingLinearInterpolationAttr() → usg._usg.Attribute

getFaceVertexCounts(time: float = nan) → usg._usg.IntArray

getFaceVertexCountsAttr() → usg._usg.Attribute

getFaceVertexIndices(time: float = nan) → usg._usg.IntArray

getFaceVertexIndicesAttr() → usg._usg.Attribute

getHoleIndices(time: float = nan) → usg._usg.IntArray

getHoleIndicesAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.MeshPrim

getInterpolateBoundary(time: float = nan) → usg._usg.Token

getInterpolateBoundaryAttr() → usg._usg.Attribute

getSubdivisionScheme(time: float = nan) → usg._usg.Token

getSubdivisionSchemeAttr() → usg._usg.Attribute

getTriangleSubdivisionRule(time: float = nan) → usg._usg.Token

getTriangleSubdivisionRuleAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.MeshPrim

setCornerIndices(value: usg._usg.IntArray, time: float = nan) → None

setCornerSharpnesses(value: usg._usg.FloatArray, time: float = nan) → None

setCreaseIndices(value: usg._usg.IntArray, time: float = nan) → None

setCreaseLengths(value: usg._usg.IntArray, time: float = nan) → None

setCreaseSharpnesses(value: usg._usg.FloatArray, time: float = nan) → None

setFaceVaryingLinearInterpolation(value: usg._usg.Token, time: float = nan) → None

setFaceVertexCounts(value: usg._usg.IntArray, time: float = nan) → None

setFaceVertexIndices(value: usg._usg.IntArray, time: float = nan) → None

setHoleIndices(value: usg._usg.IntArray, time: float = nan) → None

setInterpolateBoundary(value: usg._usg.Token, time: float = nan) → None

setSubdivisionScheme(value: usg._usg.Token, time: float = nan) → None

setTriangleSubdivisionRule(value: usg._usg.Token, time: float = nan) → None

class usg.NurbsCurvesPrim

Bases: CurvesPrim

__init__(arg0: usg._usg.Prim) → None

createKnotsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRangesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.NurbsCurvesPrim

getInStage(arg0: usg._usg.Path) → usg._usg.NurbsCurvesPrim

getKnots(time: float = nan) → usg._usg.DoubleArray

getKnotsAttr() → usg._usg.Attribute

getOrder(time: float = nan) → usg._usg.IntArray

getOrderAttr() → usg._usg.Attribute

getRanges(time: float = nan) → usg._usg.Vec2dArray

getRangesAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.NurbsCurvesPrim

setKnots(value: usg._usg.DoubleArray, time: float = nan) → None

setOrder(value: usg._usg.IntArray, time: float = nan) → None

setRanges(value: usg._usg.Vec2dArray, time: float = nan) → None

class usg.NurbsPatchPrim

Bases: PointBasedPrim

__init__(arg0: usg._usg.Prim) → None

createCountsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createKnotsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createOrdersAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createPointWeightsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createPointsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRangesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createUFormAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createUKnotsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createUOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createURangeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createUVertexCountAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVFormAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVKnotsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVRangeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVVertexCountAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVertexCountsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.NurbsPatchPrim

getCounts(time: float = nan) → usg._usg.IntArray

getCountsAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.NurbsPatchPrim

getKnots(time: float = nan) → usg._usg.DoubleArray

getKnotsAttr() → usg._usg.Attribute

getOrders(time: float = nan) → usg._usg.IntArray

getOrdersAttr() → usg._usg.Attribute

getPointWeights(time: float = nan) → usg._usg.DoubleArray

getPointWeightsAttr() → usg._usg.Attribute

getPoints(time: float = nan) → usg._usg.Vec3dArray

getPointsAttr() → usg._usg.Attribute

getRanges(time: float = nan) → usg._usg.Vec2dArray

getRangesAttr() → usg._usg.Attribute

getUForm(time: float = nan) → usg._usg.Token

getUFormAttr() → usg._usg.Attribute

getUKnots(time: float = nan) → usg._usg.DoubleArray

getUKnotsAttr() → usg._usg.Attribute

getUOrder(time: float = nan) → int

getUOrderAttr() → usg._usg.Attribute

getURange(time: float = nan) → usg._usg.Vec2d

getURangeAttr() → usg._usg.Attribute

getUVertexCount(time: float = nan) → int

getUVertexCountAttr() → usg._usg.Attribute

getVForm(time: float = nan) → usg._usg.Token

getVFormAttr() → usg._usg.Attribute

getVKnots(time: float = nan) → usg._usg.DoubleArray

getVKnotsAttr() → usg._usg.Attribute

getVOrder(time: float = nan) → int

getVOrderAttr() → usg._usg.Attribute

getVRange(time: float = nan) → usg._usg.Vec2d

getVRangeAttr() → usg._usg.Attribute

getVVertexCount(time: float = nan) → int

getVVertexCountAttr() → usg._usg.Attribute

getVertexCounts(time: float = nan) → usg._usg.IntArray

getVertexCountsAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.NurbsPatchPrim

setCounts(value: usg._usg.IntArray, time: float = nan) → None

setKnots(value: usg._usg.DoubleArray, time: float = nan) → None

setOrders(value: usg._usg.IntArray, time: float = nan) → None

setPointWeights(value: usg._usg.DoubleArray, time: float = nan) → None

setPoints(value: usg._usg.Vec3dArray, time: float = nan) → None

setRanges(value: usg._usg.Vec2dArray, time: float = nan) → None

setUForm(value: usg._usg.Token, time: float = nan) → None

setUKnots(value: usg._usg.DoubleArray, time: float = nan) → None

setUOrder(value: int, time: float = nan) → None

setURange(value: usg._usg.Vec2d, time: float = nan) → None

setUVertexCount(value: int, time: float = nan) → None

setVForm(value: usg._usg.Token, time: float = nan) → None

setVKnots(value: usg._usg.DoubleArray, time: float = nan) → None

setVOrder(value: int, time: float = nan) → None

setVRange(value: usg._usg.Vec2d, time: float = nan) → None

setVVertexCount(value: int, time: float = nan) → None

setVertexCounts(value: usg._usg.IntArray, time: float = nan) → None

class usg.PointBasedPrim

Bases: GprimPrim

__init__(arg0: usg._usg.Prim) → None

createAccelerationsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createNormalsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createPointsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVelocitiesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getAccelerations(time: float = nan) → usg._usg.Vec3fArray

getAccelerationsAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.PointBasedPrim

getNormals(time: float = nan) → usg._usg.Vec3fArray

getNormalsAttr() → usg._usg.Attribute

getPoints(time: float = nan) → usg._usg.Vec3fArray

getPointsAttr() → usg._usg.Attribute

getVelocities(time: float = nan) → usg._usg.Vec3fArray

getVelocitiesAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.PointBasedPrim

setAccelerations(value: usg._usg.Vec3fArray, time: float = nan) → None

setNormals(value: usg._usg.Vec3fArray, time: float = nan) → None

setPoints(value: usg._usg.Vec3fArray, time: float = nan) → None

setVelocities(value: usg._usg.Vec3fArray, time: float = nan) → None

class usg.PointInstancerPrim

Bases: BoundablePrim

__init__(arg0: usg._usg.Prim) → None

createAccelerationsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createAngularVelocitiesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createIdsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createInvisibleIdsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createOrientationsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createPositionsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createProtoIndicesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createPrototypesRel() → usg._usg.Relationship

createScalesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVelocitiesAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.PointInstancerPrim

getAccelerations(time: float = nan) → usg._usg.Vec3fArray

getAccelerationsAttr() → usg._usg.Attribute

getAngularVelocities(time: float = nan) → usg._usg.Vec3fArray

getAngularVelocitiesAttr() → usg._usg.Attribute

getIds(time: float = nan) → usg._usg.Int64Array

getIdsAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.PointInstancerPrim

getInvisibleIds(time: float = nan) → usg._usg.Int64Array

getInvisibleIdsAttr() → usg._usg.Attribute

getOrientations(time: float = nan) → usg._usg.QuathArray

getOrientationsAttr() → usg._usg.Attribute

getPositions(time: float = nan) → usg._usg.Vec3fArray

getPositionsAttr() → usg._usg.Attribute

getProtoIndices(time: float = nan) → usg._usg.IntArray

getProtoIndicesAttr() → usg._usg.Attribute

getPrototypesRel() → usg._usg.Relationship

getScales(time: float = nan) → usg._usg.Vec3fArray

getScalesAttr() → usg._usg.Attribute

getVelocities(time: float = nan) → usg._usg.Vec3fArray

getVelocitiesAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.PointInstancerPrim

setAccelerations(value: usg._usg.Vec3fArray, time: float = nan) → None

setAngularVelocities(value: usg._usg.Vec3fArray, time: float = nan) → None

setIds(value: usg._usg.Int64Array, time: float = nan) → None

setInvisibleIds(value: usg._usg.Int64Array, time: float = nan) → None

setOrientations(value: usg._usg.QuathArray, time: float = nan) → None

setPositions(value: usg._usg.Vec3fArray, time: float = nan) → None

setProtoIndices(value: usg._usg.IntArray, time: float = nan) → None

setScales(value: usg._usg.Vec3fArray, time: float = nan) → None

setVelocities(value: usg._usg.Vec3fArray, time: float = nan) → None

class usg.PointsPrim

Bases: PointBasedPrim

__init__(arg0: usg._usg.Prim) → None

createIdsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createWidthsAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.PointsPrim

getIds(time: float = nan) → usg._usg.Int64Array

getIdsAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.PointsPrim

getWidths(time: float = nan) → usg._usg.FloatArray

getWidthsAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.PointsPrim

setIds(value: usg._usg.Int64Array, time: float = nan) → None

setWidths(value: usg._usg.FloatArray, time: float = nan) → None

class usg.ScopePrim

Bases: ImageablePrim

__init__(arg0: usg._usg.Prim) → None

defineInLayer(arg0: usg._usg.Path) → usg._usg.ScopePrim

getInStage(arg0: usg._usg.Path) → usg._usg.ScopePrim

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.ScopePrim

class usg.SpherePrim

Bases: GprimPrim

__init__(arg0: usg._usg.Prim) → None

createRadiusAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.SpherePrim

getInStage(arg0: usg._usg.Path) → usg._usg.SpherePrim

getRadius(time: float = nan) → float

getRadiusAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.SpherePrim

setRadius(value: float, time: float = nan) → None

class usg.XformablePrim

Bases: ImageablePrim

__init__(arg0: usg._usg.Prim) → None

createXformOpOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.XformablePrim

static getLocalMatrixAtPrim(prim: usg._usg.Prim, time: float = nan) → usg._usg.Mat4d

getXformOpOrder(time: float = nan) → usg._usg.TokenArray

getXformOpOrderAttr() → usg._usg.Attribute

isValid() → bool

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.XformablePrim

setXformOpOrder(value: usg._usg.TokenArray, time: float = nan) → None

class usg.XformPrim

Bases: XformablePrim

__init__(arg0: usg._usg.Prim) → None

defineInLayer(arg0: usg._usg.Path) → usg._usg.XformPrim

getInStage(arg0: usg._usg.Path) → usg._usg.XformPrim

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.XformPrim

Lux Prims

Classes dealing with lights

class usg.lux.BoundableLightBasePrim

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

getInStage(arg0: usg._usg.Path) → usg._usg.lux.BoundableLightBasePrim

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.lux.BoundableLightBasePrim

class usg.lux.CylinderLightPrim

Bases: BoundableLightBasePrim

__init__(arg0: usg._usg.Prim) → None

createColorAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDiffuseAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createEnableColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createExposureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFiltersRel() → usg._usg.Relationship

createIntensityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createLengthAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createNormalizeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createProxyPrimRel() → usg._usg.Relationship

createPurposeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRadiusAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createShaderIdAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createSpecularAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createTreatAsLineAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createXformOpOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.lux.CylinderLightPrim

getColor(time: float = nan) → usg._usg.Vec3f

getColorAttr() → usg._usg.Attribute

getColorTemperature(time: float = nan) → float

getColorTemperatureAttr() → usg._usg.Attribute

getDiffuse(time: float = nan) → float

getDiffuseAttr() → usg._usg.Attribute

getEnableColorTemperature(time: float = nan) → bool

getEnableColorTemperatureAttr() → usg._usg.Attribute

getExposure(time: float = nan) → float

getExposureAttr() → usg._usg.Attribute

getFiltersRel() → usg._usg.Relationship

getInStage(arg0: usg._usg.Path) → usg._usg.lux.CylinderLightPrim

getIntensity(time: float = nan) → float

getIntensityAttr() → usg._usg.Attribute

getLength(time: float = nan) → float

getLengthAttr() → usg._usg.Attribute

getNormalize(time: float = nan) → bool

getNormalizeAttr() → usg._usg.Attribute

getProxyPrimRel() → usg._usg.Relationship

getPurpose(time: float = nan) → usg._usg.Token

getPurposeAttr() → usg._usg.Attribute

getRadius(time: float = nan) → float

getRadiusAttr() → usg._usg.Attribute

getShaderId(time: float = nan) → usg._usg.Token

getShaderIdAttr() → usg._usg.Attribute

getSpecular(time: float = nan) → float

getSpecularAttr() → usg._usg.Attribute

getTreatAsLine(time: float = nan) → bool

getTreatAsLineAttr() → usg._usg.Attribute

getVisibility(time: float = nan) → usg._usg.Token

getVisibilityAttr() → usg._usg.Attribute

getXformOpOrder(time: float = nan) → usg._usg.TokenArray

getXformOpOrderAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.lux.CylinderLightPrim

setColor(value: usg._usg.Vec3f, time: float = nan) → None

setColorTemperature(value: float, time: float = nan) → None

setDiffuse(value: float, time: float = nan) → None

setEnableColorTemperature(value: bool, time: float = nan) → None

setExposure(value: float, time: float = nan) → None

setIntensity(value: float, time: float = nan) → None

setLength(value: float, time: float = nan) → None

setNormalize(value: bool, time: float = nan) → None

setPurpose(value: usg._usg.Token, time: float = nan) → None

setRadius(value: float, time: float = nan) → None

setShaderId(value: usg._usg.Token, time: float = nan) → None

setSpecular(value: float, time: float = nan) → None

setTreatAsLine(value: bool, time: float = nan) → None

setVisibility(value: usg._usg.Token, time: float = nan) → None

setXformOpOrder(value: usg._usg.TokenArray, time: float = nan) → None

class usg.lux.DiskLightPrim

Bases: BoundableLightBasePrim

__init__(arg0: usg._usg.Prim) → None

createColorAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDiffuseAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createEnableColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createExposureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFiltersRel() → usg._usg.Relationship

createIntensityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createNormalizeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createProxyPrimRel() → usg._usg.Relationship

createPurposeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRadiusAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createShaderIdAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createSpecularAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createXformOpOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.lux.DiskLightPrim

getColor(time: float = nan) → usg._usg.Vec3f

getColorAttr() → usg._usg.Attribute

getColorTemperature(time: float = nan) → float

getColorTemperatureAttr() → usg._usg.Attribute

getDiffuse(time: float = nan) → float

getDiffuseAttr() → usg._usg.Attribute

getEnableColorTemperature(time: float = nan) → bool

getEnableColorTemperatureAttr() → usg._usg.Attribute

getExposure(time: float = nan) → float

getExposureAttr() → usg._usg.Attribute

getFiltersRel() → usg._usg.Relationship

getInStage(arg0: usg._usg.Path) → usg._usg.lux.DiskLightPrim

getIntensity(time: float = nan) → float

getIntensityAttr() → usg._usg.Attribute

getNormalize(time: float = nan) → bool

getNormalizeAttr() → usg._usg.Attribute

getProxyPrimRel() → usg._usg.Relationship

getPurpose(time: float = nan) → usg._usg.Token

getPurposeAttr() → usg._usg.Attribute

getRadius(time: float = nan) → float

getRadiusAttr() → usg._usg.Attribute

getShaderId(time: float = nan) → usg._usg.Token

getShaderIdAttr() → usg._usg.Attribute

getSpecular(time: float = nan) → float

getSpecularAttr() → usg._usg.Attribute

getVisibility(time: float = nan) → usg._usg.Token

getVisibilityAttr() → usg._usg.Attribute

getXformOpOrder(time: float = nan) → usg._usg.TokenArray

getXformOpOrderAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.lux.DiskLightPrim

setColor(value: usg._usg.Vec3f, time: float = nan) → None

setColorTemperature(value: float, time: float = nan) → None

setDiffuse(value: float, time: float = nan) → None

setEnableColorTemperature(value: bool, time: float = nan) → None

setExposure(value: float, time: float = nan) → None

setIntensity(value: float, time: float = nan) → None

setNormalize(value: bool, time: float = nan) → None

setPurpose(value: usg._usg.Token, time: float = nan) → None

setRadius(value: float, time: float = nan) → None

setShaderId(value: usg._usg.Token, time: float = nan) → None

setSpecular(value: float, time: float = nan) → None

setVisibility(value: usg._usg.Token, time: float = nan) → None

setXformOpOrder(value: usg._usg.TokenArray, time: float = nan) → None

class usg.lux.DistantLightPrim

Bases: NonboundableLightBasePrim

__init__(arg0: usg._usg.Prim) → None

createAngleAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createColorAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDiffuseAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createEnableColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createExposureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFiltersRel() → usg._usg.Relationship

createIntensityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createNormalizeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createProxyPrimRel() → usg._usg.Relationship

createPurposeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createShaderIdAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createSpecularAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createXformOpOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.lux.DistantLightPrim

getAngle(time: float = nan) → float

getAngleAttr() → usg._usg.Attribute

getColor(time: float = nan) → usg._usg.Vec3f

getColorAttr() → usg._usg.Attribute

getColorTemperature(time: float = nan) → float

getColorTemperatureAttr() → usg._usg.Attribute

getDiffuse(time: float = nan) → float

getDiffuseAttr() → usg._usg.Attribute

getEnableColorTemperature(time: float = nan) → bool

getEnableColorTemperatureAttr() → usg._usg.Attribute

getExposure(time: float = nan) → float

getExposureAttr() → usg._usg.Attribute

getFiltersRel() → usg._usg.Relationship

getInStage(arg0: usg._usg.Path) → usg._usg.lux.DistantLightPrim

getIntensity(time: float = nan) → float

getIntensityAttr() → usg._usg.Attribute

getNormalize(time: float = nan) → bool

getNormalizeAttr() → usg._usg.Attribute

getProxyPrimRel() → usg._usg.Relationship

getPurpose(time: float = nan) → usg._usg.Token

getPurposeAttr() → usg._usg.Attribute

getShaderId(time: float = nan) → usg._usg.Token

getShaderIdAttr() → usg._usg.Attribute

getSpecular(time: float = nan) → float

getSpecularAttr() → usg._usg.Attribute

getVisibility(time: float = nan) → usg._usg.Token

getVisibilityAttr() → usg._usg.Attribute

getXformOpOrder(time: float = nan) → usg._usg.TokenArray

getXformOpOrderAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.lux.DistantLightPrim

setAngle(value: float, time: float = nan) → None

setColor(value: usg._usg.Vec3f, time: float = nan) → None

setColorTemperature(value: float, time: float = nan) → None

setDiffuse(value: float, time: float = nan) → None

setEnableColorTemperature(value: bool, time: float = nan) → None

setExposure(value: float, time: float = nan) → None

setIntensity(value: float, time: float = nan) → None

setNormalize(value: bool, time: float = nan) → None

setPurpose(value: usg._usg.Token, time: float = nan) → None

setShaderId(value: usg._usg.Token, time: float = nan) → None

setSpecular(value: float, time: float = nan) → None

setVisibility(value: usg._usg.Token, time: float = nan) → None

setXformOpOrder(value: usg._usg.TokenArray, time: float = nan) → None

class usg.lux.DomeLightPrim

Bases: NonboundableLightBasePrim

__init__(arg0: usg._usg.Prim) → None

createColorAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDiffuseAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createEnableColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createExposureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFiltersRel() → usg._usg.Relationship

createGuideRadiusAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createIntensityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createNormalizeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createPortalsRel() → usg._usg.Relationship

createProxyPrimRel() → usg._usg.Relationship

createPurposeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createShaderIdAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createSpecularAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createTextureFileAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createTextureFormatAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createXformOpOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.lux.DomeLightPrim

getColor(time: float = nan) → usg._usg.Vec3f

getColorAttr() → usg._usg.Attribute

getColorTemperature(time: float = nan) → float

getColorTemperatureAttr() → usg._usg.Attribute

getDiffuse(time: float = nan) → float

getDiffuseAttr() → usg._usg.Attribute

getEnableColorTemperature(time: float = nan) → bool

getEnableColorTemperatureAttr() → usg._usg.Attribute

getExposure(time: float = nan) → float

getExposureAttr() → usg._usg.Attribute

getFiltersRel() → usg._usg.Relationship

getGuideRadius(time: float = nan) → float

getGuideRadiusAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.lux.DomeLightPrim

getIntensity(time: float = nan) → float

getIntensityAttr() → usg._usg.Attribute

getNormalize(time: float = nan) → bool

getNormalizeAttr() → usg._usg.Attribute

getPortalsRel() → usg._usg.Relationship

getProxyPrimRel() → usg._usg.Relationship

getPurpose(time: float = nan) → usg._usg.Token

getPurposeAttr() → usg._usg.Attribute

getShaderId(time: float = nan) → usg._usg.Token

getShaderIdAttr() → usg._usg.Attribute

getSpecular(time: float = nan) → float

getSpecularAttr() → usg._usg.Attribute

getTextureFile(time: float = nan) → usg._usg.AssetPath

getTextureFileAttr() → usg._usg.Attribute

getTextureFormat(time: float = nan) → usg._usg.Token

getTextureFormatAttr() → usg._usg.Attribute

getVisibility(time: float = nan) → usg._usg.Token

getVisibilityAttr() → usg._usg.Attribute

getXformOpOrder(time: float = nan) → usg._usg.TokenArray

getXformOpOrderAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.lux.DomeLightPrim

setColor(value: usg._usg.Vec3f, time: float = nan) → None

setColorTemperature(value: float, time: float = nan) → None

setDiffuse(value: float, time: float = nan) → None

setEnableColorTemperature(value: bool, time: float = nan) → None

setExposure(value: float, time: float = nan) → None

setGuideRadius(value: float, time: float = nan) → None

setIntensity(value: float, time: float = nan) → None

setNormalize(value: bool, time: float = nan) → None

setPurpose(value: usg._usg.Token, time: float = nan) → None

setShaderId(value: usg._usg.Token, time: float = nan) → None

setSpecular(value: float, time: float = nan) → None

setTextureFile(value: usg._usg.AssetPath, time: float = nan) → None

setTextureFormat(value: usg._usg.Token, time: float = nan) → None

setVisibility(value: usg._usg.Token, time: float = nan) → None

setXformOpOrder(value: usg._usg.TokenArray, time: float = nan) → None

class usg.lux.NonboundableLightBasePrim

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

getInStage(arg0: usg._usg.Path) → usg._usg.lux.NonboundableLightBasePrim

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.lux.NonboundableLightBasePrim

class usg.lux.RectLightPrim

Bases: BoundableLightBasePrim

__init__(arg0: usg._usg.Prim) → None

createColorAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDiffuseAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createEnableColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createExposureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFiltersRel() → usg._usg.Relationship

createHeightAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createIntensityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createNormalizeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createProxyPrimRel() → usg._usg.Relationship

createPurposeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createShaderIdAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createSpecularAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createTextureFileAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createWidthAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createXformOpOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.lux.RectLightPrim

getColor(time: float = nan) → usg._usg.Vec3f

getColorAttr() → usg._usg.Attribute

getColorTemperature(time: float = nan) → float

getColorTemperatureAttr() → usg._usg.Attribute

getDiffuse(time: float = nan) → float

getDiffuseAttr() → usg._usg.Attribute

getEnableColorTemperature(time: float = nan) → bool

getEnableColorTemperatureAttr() → usg._usg.Attribute

getExposure(time: float = nan) → float

getExposureAttr() → usg._usg.Attribute

getFiltersRel() → usg._usg.Relationship

getHeight(time: float = nan) → float

getHeightAttr() → usg._usg.Attribute

getInStage(arg0: usg._usg.Path) → usg._usg.lux.RectLightPrim

getIntensity(time: float = nan) → float

getIntensityAttr() → usg._usg.Attribute

getNormalize(time: float = nan) → bool

getNormalizeAttr() → usg._usg.Attribute

getProxyPrimRel() → usg._usg.Relationship

getPurpose(time: float = nan) → usg._usg.Token

getPurposeAttr() → usg._usg.Attribute

getShaderId(time: float = nan) → usg._usg.Token

getShaderIdAttr() → usg._usg.Attribute

getSpecular(time: float = nan) → float

getSpecularAttr() → usg._usg.Attribute

getTextureFile(time: float = nan) → usg._usg.AssetPath

getTextureFileAttr() → usg._usg.Attribute

getVisibility(time: float = nan) → usg._usg.Token

getVisibilityAttr() → usg._usg.Attribute

getWidth(time: float = nan) → float

getWidthAttr() → usg._usg.Attribute

getXformOpOrder(time: float = nan) → usg._usg.TokenArray

getXformOpOrderAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.lux.RectLightPrim

setColor(value: usg._usg.Vec3f, time: float = nan) → None

setColorTemperature(value: float, time: float = nan) → None

setDiffuse(value: float, time: float = nan) → None

setEnableColorTemperature(value: bool, time: float = nan) → None

setExposure(value: float, time: float = nan) → None

setHeight(value: float, time: float = nan) → None

setIntensity(value: float, time: float = nan) → None

setNormalize(value: bool, time: float = nan) → None

setPurpose(value: usg._usg.Token, time: float = nan) → None

setShaderId(value: usg._usg.Token, time: float = nan) → None

setSpecular(value: float, time: float = nan) → None

setTextureFile(value: usg._usg.AssetPath, time: float = nan) → None

setVisibility(value: usg._usg.Token, time: float = nan) → None

setWidth(value: float, time: float = nan) → None

setXformOpOrder(value: usg._usg.TokenArray, time: float = nan) → None

class usg.lux.SphereLightPrim

Bases: BoundableLightBasePrim

__init__(arg0: usg._usg.Prim) → None

createColorAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDiffuseAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createEnableColorTemperatureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createExposureAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createFiltersRel() → usg._usg.Relationship

createIntensityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createNormalizeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createProxyPrimRel() → usg._usg.Relationship

createPurposeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRadiusAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createShaderIdAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createSpecularAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createTreatAsPointAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createXformOpOrderAttr(arg0: usg._usg.Value) → usg._usg.Attribute

defineInLayer(arg0: usg._usg.Path) → usg._usg.lux.SphereLightPrim

getColor(time: float = nan) → usg._usg.Vec3f

getColorAttr() → usg._usg.Attribute

getColorTemperature(time: float = nan) → float

getColorTemperatureAttr() → usg._usg.Attribute

getDiffuse(time: float = nan) → float

getDiffuseAttr() → usg._usg.Attribute

getEnableColorTemperature(time: float = nan) → bool

getEnableColorTemperatureAttr() → usg._usg.Attribute

getExposure(time: float = nan) → float

getExposureAttr() → usg._usg.Attribute

getFiltersRel() → usg._usg.Relationship

getInStage(arg0: usg._usg.Path) → usg._usg.lux.SphereLightPrim

getIntensity(time: float = nan) → float

getIntensityAttr() → usg._usg.Attribute

getNormalize(time: float = nan) → bool

getNormalizeAttr() → usg._usg.Attribute

getProxyPrimRel() → usg._usg.Relationship

getPurpose(time: float = nan) → usg._usg.Token

getPurposeAttr() → usg._usg.Attribute

getRadius(time: float = nan) → float

getRadiusAttr() → usg._usg.Attribute

getShaderId(time: float = nan) → usg._usg.Token

getShaderIdAttr() → usg._usg.Attribute

getSpecular(time: float = nan) → float

getSpecularAttr() → usg._usg.Attribute

getTreatAsPoint(time: float = nan) → bool

getTreatAsPointAttr() → usg._usg.Attribute

getVisibility(time: float = nan) → usg._usg.Token

getVisibilityAttr() → usg._usg.Attribute

getXformOpOrder(time: float = nan) → usg._usg.TokenArray

getXformOpOrderAttr() → usg._usg.Attribute

overrideInLayer(arg0: usg._usg.Prim) → usg._usg.lux.SphereLightPrim

setColor(value: usg._usg.Vec3f, time: float = nan) → None

setColorTemperature(value: float, time: float = nan) → None

setDiffuse(value: float, time: float = nan) → None

setEnableColorTemperature(value: bool, time: float = nan) → None

setExposure(value: float, time: float = nan) → None

setIntensity(value: float, time: float = nan) → None

setNormalize(value: bool, time: float = nan) → None

setPurpose(value: usg._usg.Token, time: float = nan) → None

setRadius(value: float, time: float = nan) → None

setShaderId(value: usg._usg.Token, time: float = nan) → None

setSpecular(value: float, time: float = nan) → None

setTreatAsPoint(value: bool, time: float = nan) → None

setVisibility(value: usg._usg.Token, time: float = nan) → None

setXformOpOrder(value: usg._usg.TokenArray, time: float = nan) → None

APIs

class usg.CollectionAPI

Bases: pybind11_object

__init__(arg0: usg._usg.Prim, arg1: usg._usg.Token) → None

apply() → None

createExcludesRel() → usg._usg.Relationship

createExpansionRuleAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createIncludeRootAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createIncludesRel() → usg._usg.Relationship

static getAll(prim: usg._usg.Prim) → list

static getAllNames(prim: usg._usg.Prim) → list

getExcludes() → usg._usg.PathArray

getExcludesRel() → usg._usg.Relationship

getExpansionRule(time: float = nan) → usg._usg.Token

getExpansionRuleAttr() → usg._usg.Attribute

getIncludeRoot(time: float = nan) → bool

getIncludeRootAttr() → usg._usg.Attribute

getIncludes() → usg._usg.PathArray

getIncludesRel() → usg._usg.Relationship

getName() → usg._usg.Token

setExpansionRule(value: usg._usg.Token, time: float = nan) → None

setIncludeRoot(value: bool, time: float = nan) → None

class usg.GeomModelAPI

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

apply() → None

createApplyDrawModeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCardGeometryAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCardTextureXNegAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCardTextureXPosAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCardTextureYNegAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCardTextureYPosAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCardTextureZNegAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createCardTextureZPosAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDrawModeAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createDrawModeColorAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getApplyDrawMode(time: float = nan) → bool

getApplyDrawModeAttr() → usg._usg.Attribute

getCardGeometry(time: float = nan) → usg._usg.Token

getCardGeometryAttr() → usg._usg.Attribute

getCardTextureXNeg(time: float = nan) → usg._usg.AssetPath

getCardTextureXNegAttr() → usg._usg.Attribute

getCardTextureXPos(time: float = nan) → usg._usg.AssetPath

getCardTextureXPosAttr() → usg._usg.Attribute

getCardTextureYNeg(time: float = nan) → usg._usg.AssetPath

getCardTextureYNegAttr() → usg._usg.Attribute

getCardTextureYPos(time: float = nan) → usg._usg.AssetPath

getCardTextureYPosAttr() → usg._usg.Attribute

getCardTextureZNeg(time: float = nan) → usg._usg.AssetPath

getCardTextureZNegAttr() → usg._usg.Attribute

getCardTextureZPos(time: float = nan) → usg._usg.AssetPath

getCardTextureZPosAttr() → usg._usg.Attribute

getDrawMode(time: float = nan) → usg._usg.Token

getDrawModeAttr() → usg._usg.Attribute

getDrawModeColor(time: float = nan) → usg._usg.Vec3f

getDrawModeColorAttr() → usg._usg.Attribute

setApplyDrawMode(value: bool, time: float = nan) → None

setCardGeometry(value: usg._usg.Token, time: float = nan) → None

setCardTextureXNeg(value: usg._usg.AssetPath, time: float = nan) → None

setCardTextureXPos(value: usg._usg.AssetPath, time: float = nan) → None

setCardTextureYNeg(value: usg._usg.AssetPath, time: float = nan) → None

setCardTextureYPos(value: usg._usg.AssetPath, time: float = nan) → None

setCardTextureZNeg(value: usg._usg.AssetPath, time: float = nan) → None

setCardTextureZPos(value: usg._usg.AssetPath, time: float = nan) → None

setDrawMode(value: usg._usg.Token, time: float = nan) → None

setDrawModeColor(value: usg._usg.Vec3f, time: float = nan) → None

class usg.MotionAPI

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

apply() → None

createBlurScaleAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createNonlinearSampleCountAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createVelocityScaleAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getBlurScale(time: float = nan) → float

getBlurScaleAttr() → usg._usg.Attribute

getNonlinearSampleCount(time: float = nan) → int

getNonlinearSampleCountAttr() → usg._usg.Attribute

getVelocityScale(time: float = nan) → float

getVelocityScaleAttr() → usg._usg.Attribute

setBlurScale(value: float, time: float = nan) → None

setNonlinearSampleCount(value: int, time: float = nan) → None

setVelocityScale(value: float, time: float = nan) → None

class usg.PrimvarsAPI

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

apply() → None

class usg.VisibilityAPI

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

apply() → None

createGuideVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createProxyVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

createRenderVisibilityAttr(arg0: usg._usg.Value) → usg._usg.Attribute

getGuideVisibility(time: float = nan) → usg._usg.Token

getGuideVisibilityAttr() → usg._usg.Attribute

getProxyVisibility(time: float = nan) → usg._usg.Token

getProxyVisibilityAttr() → usg._usg.Attribute

getRenderVisibility(time: float = nan) → usg._usg.Token

getRenderVisibilityAttr() → usg._usg.Attribute

setGuideVisibility(value: usg._usg.Token, time: float = nan) → None

setProxyVisibility(value: usg._usg.Token, time: float = nan) → None

setRenderVisibility(value: usg._usg.Token, time: float = nan) → None

class usg.XformCommonAPI

Bases: pybind11_object

__init__(arg0: usg._usg.Prim) → None

apply() → None

Math

class usg.Half

Bases: pybind11_object

__init__(arg0: float) → None: Initialize from floating point number.

class usg.Mat4d

Bases: pybind11_object

A 4x4 transformation matrix. You multiply a Vec4 by one of these to go from a transformed space to normal space.

The data is stored packed together in OpenGL order, which is transposed from the way used in most modern graphics literature. This affects how the element method works. You can directly access the entries with the aRC members, where R is the row and C is the column.

For instance matrix.a03 is the top-right corner of the matrix in most literature. It is multiplied by the W of a vector to produce part of the X of the output vector, and can be considered the X translation of the matrix.

However matrix.a03 is matrix.element(12)

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Mat4d, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float, arg9: float, arg10: float, arg11: float, arg12: float, arg13: float, arg14: float, arg15: float) -> None

Initialize with a00=a, a01=b, a02=c, etc. ie the arguments are given as rows.

__init__(self: usg._usg.Mat4d, arg0: float) -> None

Initialize to identity matrix with a constant in the diagonal.

__init__(self: usg._usg.Mat4d, other: usg._usg.Mat4d, transpose: bool = False) -> None

addDiagonal(arg0: float) → None: Add a constant to all the diagonal elements.

applyXform(xformOrder: usg._usg.XformOrder, rotateOrder: usg._usg.RotateOrder, translation: usg._usg.Vec3d, rotations: usg._usg.Vec3d, scaling: usg._usg.Vec3d, skewing: usg._usg.Vec3d, pivotOriginTranslate: usg._usg.Vec3d, pivotOriginRotate: usg._usg.Vec3d) → None

Apply a single-step SRT transform.

Rotations are assumed to be in degrees and are internally converted to radians. Skew always follows rotation.

clear() → None: Set all components to 0.

element(i: int) → float

Return the value of the ith matrix element.

The elements are arranged in OpenGL order, that is by column and then row: a00, a10, a20, a30, a01, a11, etc.

extractAndRemoveScalingAndShear() → object: Return a tuple of the scale and shear of this matrix and them from it.

extractSHRT(arg0: usg._usg.RotateOrder) → object: Return a tuple of the scale, shear, rotation and translation of the matrix or None if the extraction isn’t succesful.

extractScalingAndShear() → object: Return a tuple of the scale and shear of this matrix.

getDeterminant() → float

static getIdentity() → usg._usg.Mat4d: Return an identity matrix.

getRotations(rotateOrder: usg._usg.RotateOrder) → usg._usg.Vec3d

Return the rotation angles (in radians) from the matrix.

The matrix is assumed to have no shear, non-uniform scaling is handled.

getScale() → usg._usg.Vec3d: Return the scaling of the matrix.

getScaleAxis() → usg._usg.Vec3d: Return the scale of the matrix.

getTranslation() → usg._usg.Vec3d: Return the translations of the matrix.

interpolate(m0: usg._usg.Mat4d, m1: usg._usg.Mat4d, t: float) → None: Linear interpolate two matrices at offset ‘t’ which is between 0.0 and 1.0. This only interpolates position and rotation, and rotation is only valid within a certain range since it’s a linear interpolation of the xyz axes!

inverse() → tuple

Return a tuple containing the determinant and inverse of this matrix.

If the determinant is non-zero then the matrix is not invertible and the returned matrix will contain garbage.

invert() → usg._usg.Mat4d

Invert this matrix in place if it is invertible.

If the determinant is non-zero then the matrix is not invertible and the contents of this matrix will contain garbage.

isIdentity() → bool

isNotIdentity() → bool

normalTransform(n: usg._usg.Vec3d) → usg._usg.Vec3d: Transform a normal. This is the same as matrix.transpose().transform(n)

rotateAboutVector(angle: float, v: usg._usg.Vec3d) → None: Rotate the transformation by an angle (in radians) about the vector v.

rotateInOrder(*args, **kwargs)

Overloaded function.

rotateInOrder(self: usg._usg.Mat4d, order: usg._usg.RotateOrder, x: float, y: float, z: float) -> None

Apply rotations in about each axis (in radians) in a given order.

rotateInOrder(self: usg._usg.Mat4d, order: usg._usg.RotateOrder, v: usg._usg.Vec3d) -> None

Apply rotations in about each axis (in radians) in a given order.

rotateX(angle: float) → None: Rotate the transformation by an angle (in radians) about the X axis.

rotateY(angle: float) → None: Rotate the transformation by an angle (in radians) about the Y axis.

rotateZ(angle: float) → None: Rotate the transformation by an angle (in radians) about the Z axis.

scale(*args, **kwargs)

Overloaded function.

scale(self: usg._usg.Mat4d, d: float) -> None

Scale the transform by the uniform scale d.

scale(self: usg._usg.Mat4d, x: float, y: float, z: float) -> None

Scale columns 0,1,2 by x,y,z.

scale(self: usg._usg.Mat4d, v: usg._usg.Vec3d) -> None

Scale columns 0,1,2 by the components of v.

setToIdentity() → None: Set this matrix to the identity matrix.

setToProjection(lens: float, minz: float, maxz: float, persp: bool) → None

Replace the contents with a camera projection. The camera is sitting at 0,0,0 and pointing along the Z axis, and the ratio of its focal length to the width of the film is lens.

The area that will appear on the film is transformed to be in a square with X and Y ranging from -1 to 1. The plane Z=minz is transformed to be at Z=-1 and the plane Z=maxz is transformed to Z=1.

setToRotation(angle: float, v: usg._usg.Vec3d) → usg._usg.Mat4d: Set the contents to a rotation by the angle (in radians) about v.

setToRotationOnly() → None: Modify the transformation matrix to represent the rotation component only.

setToRotationX(arg0: float) → usg._usg.Mat4d: Set the contents to a rotation by the given angle (in radians) about the x-axis.

setToRotationY(arg0: float) → usg._usg.Mat4d: Set the contents to a rotation by the given angle (in radians) about the y-axis.

setToRotationZ(arg0: float) → usg._usg.Mat4d: Set the contents to a rotation by the given angle (in radians) about the z-axis.

setToRotations(*args, **kwargs)

Overloaded function.

setToRotations(self: usg._usg.Mat4d, order: usg._usg.RotateOrder, x: float, y: float, z: float) -> usg._usg.Mat4d

Set the contents to a rotationby angles x, y, z (in radians) in the given order.

setToRotations(self: usg._usg.Mat4d, order: usg._usg.RotateOrder, r: usg._usg.Vec3d) -> usg._usg.Mat4d

Set the contents to a rotation (in radians) by each component of the vector in the given order.

setToScale(*args, **kwargs)

Overloaded function.

setToScale(self: usg._usg.Mat4d, d: float) -> usg._usg.Mat4d

Set the contents to a uniform scale by d.

setToScale(self: usg._usg.Mat4d, x: float, y: float, z: float) -> usg._usg.Mat4d

Set the contents to a scale by specifying the scale in each direction.

setToScale(self: usg._usg.Mat4d, s: usg._usg.Vec3d) -> usg._usg.Mat4d

Set the contents to a scale by specifying the scale in each direction of a vector.

setToScaleAndRotationOnly() → None: Modify the transformation matrix to represent the scale and rotation component only.

setToScaleOnly() → None: Modify the transformation matrix to represent the scalecomponent only.

setToTranslation(*args, **kwargs)

Overloaded function.

setToTranslation(self: usg._usg.Mat4d, x: float, y: float, z: float) -> usg._usg.Mat4d

Set the contents to a translation by x, y, z.

setToTranslation(self: usg._usg.Mat4d, t: usg._usg.Vec3d) -> usg._usg.Mat4d

Set the contents to a translation by each component of the vector.

setToTranslationOnly() → None: Modify the transformation matrix to represent the translation component only.

setToXform(xformOrder: usg._usg.XformOrder, rotateOrder: usg._usg.RotateOrder, translation: usg._usg.Vec3d, rotations: usg._usg.Vec3d, scaling: usg._usg.Vec3d, skewing: usg._usg.Vec3d, pivotOriginTranslate: usg._usg.Vec3d, pivotOriginRotate: usg._usg.Vec3d) → None

Set this matrix to a single-step SRT transform.

Rotations are assumed to be in degrees and are internally converted to radians. Skew always follows rotation.

skew(*args, **kwargs)

Overloaded function.

skew(self: usg._usg.Mat4d, a: float) -> None

Skew the transformation by a (X positions have a*Y added to them).

skew(self: usg._usg.Mat4d, v: usg._usg.Vec3d) -> None

Skew the transformation in each direction by the components of v.

skewXY(x: float, y: float) → None: Skew in the X direction by x and then in the Y direction by y.

skewYX(x: float, y: float) → None: Skew in the Y direction by y and then in the X direction by x.

transform(*args, **kwargs)

Overloaded function.

transform(self: usg._usg.Mat4d, v: usg._usg.Vec4d) -> usg._usg.Vec4d

Return the 4-vector which is the result of transforming v by this matrix.

transform(self: usg._usg.Mat4d, v: usg._usg.Vec3d) -> usg._usg.Vec3d

Return the 3-vector which is the result of transforming v by this matrix.

translate(*args, **kwargs)

Overloaded function.

translate(self: usg._usg.Mat4d, x: float, y: float, z: float) -> None

Translate the transformation by an x,y,z offset.

translate(self: usg._usg.Mat4d, v: usg._usg.Vec3d) -> None

Translate the transformation by the vector v.

transpose() → None: Transpose this matrix.

vecTransform(v: usg._usg.Vec3d) → usg._usg.Vec3d: Return the 4-vector which is the result of transforming v by this matrix with no translation applied.

vectorToRotations(dir_vec: usg._usg.Vec3d, align_axis: usg._usg.AxisDirection, do_rx: bool, do_ry: bool, do_rz: bool) → tuple: Return a tuple where the first element is a vector containing angles (in radians) which align_axis should be rotated about each axis so that it aligns with dir_vec. The second element is the rotation order to apply them in to best avoid gimbal lock.

class usg.Quath

Bases: pybind11_object

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Quath, s: usg._usg.Half) -> None

Construct with a scalar part s and zero vector part.

__init__(self: usg._usg.Quath, s: usg._usg.Half, x: usg._usg.Half, y: usg._usg.Half, z: usg._usg.Half) -> None
__init__(self: usg._usg.Quath, s: usg._usg.Half, v: usg._usg.Vec3h) -> None

Construct with scalar part s and vector part v.

__init__(self: usg._usg.Quath, arg0: usg._usg.Mat4d) -> None

Construct to represent the rotation of the given transformation matrix.

__init__(self: usg._usg.Quath, arg0: usg._usg.Vec3h, arg1: usg._usg.Vec3h) -> None

Construct to represent the rotation from one vector to another.

static addIdentity() → usg._usg.Quath: Return the additive identity.

addInverse() → usg._usg.Quath: Return additive inverse of this quaternion.

conjugate() → usg._usg.Quath

static fromAngleAxis(angle: usg._usg.Half, v: usg._usg.Vec3h) → usg._usg.Quath: Return a quaternion representing a rotation by angle (in radians) about v.

length() → usg._usg.Half

lengthSquared() → usg._usg.Half

static multIdentity() → usg._usg.Quath: Return the multiplicative identity.

multInverse() → usg._usg.Quath: Return multiplicative inverse of this quaternion.

normalize() → None

normalized() → usg._usg.Quath

rotationMatrix() → usg._usg.Mat4d: Return the transformation matrix that will represent the the Euler angle rotations that this quaternion embodies. Note - this method only affects the rotation part of the matrix. NOTE: The quaternion must be normalized before using this function.

property s

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Quath, s: usg._usg.Half, x: usg._usg.Half, y: usg._usg.Half, z: usg._usg.Half) -> None
set(self: usg._usg.Quath, s: usg._usg.Half, v: usg._usg.Vec3h) -> None

setFromAngleAxis(angle: usg._usg.Half, v: usg._usg.Vec3h) → None: Set this to represent a rotation by an angle (in radians) about v.

slerp(end_quaternion: usg._usg.Quath, t: usg._usg.Half) → usg._usg.Quath

Spherical linear interpolation.

This method interpolates smoothly between two quaternions. The value t should be a number between 0.0 and 1.0. When t = 0.0, this is returned. When t = 1.0, end_quat is returned.

Because of the way quaternions work, you can’t just linearly interpolate between two of them. You must interpolate along the surface of a sphere. This method returns a quaternion that is between the current quaternion and the end_quat. The value of t (which should be between 0 and 1) determines the amount of interpolation.

property v

class usg.Quatf

Bases: pybind11_object

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Quatf, s: float) -> None

Construct with a scalar part s and zero vector part.

__init__(self: usg._usg.Quatf, s: float, x: float, y: float, z: float) -> None
__init__(self: usg._usg.Quatf, s: float, v: usg._usg.Vec3f) -> None

Construct with scalar part s and vector part v.

__init__(self: usg._usg.Quatf, arg0: usg._usg.Mat4d) -> None

Construct to represent the rotation of the given transformation matrix.

__init__(self: usg._usg.Quatf, arg0: usg._usg.Vec3f, arg1: usg._usg.Vec3f) -> None

Construct to represent the rotation from one vector to another.

static addIdentity() → usg._usg.Quatf: Return the additive identity.

addInverse() → usg._usg.Quatf: Return additive inverse of this quaternion.

conjugate() → usg._usg.Quatf

static fromAngleAxis(angle: float, v: usg._usg.Vec3f) → usg._usg.Quatf: Return a quaternion representing a rotation by angle (in radians) about v.

length() → float

lengthSquared() → float

static multIdentity() → usg._usg.Quatf: Return the multiplicative identity.

multInverse() → usg._usg.Quatf: Return multiplicative inverse of this quaternion.

normalize() → None

normalized() → usg._usg.Quatf

rotationMatrix() → usg._usg.Mat4d: Return the transformation matrix that will represent the the Euler angle rotations that this quaternion embodies. Note - this method only affects the rotation part of the matrix. NOTE: The quaternion must be normalized before using this function.

property s

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Quatf, s: float, x: float, y: float, z: float) -> None
set(self: usg._usg.Quatf, s: float, v: usg._usg.Vec3f) -> None

setFromAngleAxis(angle: float, v: usg._usg.Vec3f) → None: Set this to represent a rotation by an angle (in radians) about v.

slerp(end_quaternion: usg._usg.Quatf, t: float) → usg._usg.Quatf

Spherical linear interpolation.

This method interpolates smoothly between two quaternions. The value t should be a number between 0.0 and 1.0. When t = 0.0, this is returned. When t = 1.0, end_quat is returned.

Because of the way quaternions work, you can’t just linearly interpolate between two of them. You must interpolate along the surface of a sphere. This method returns a quaternion that is between the current quaternion and the end_quat. The value of t (which should be between 0 and 1) determines the amount of interpolation.

property v

class usg.Quatd

Bases: pybind11_object

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Quatd, s: float) -> None

Construct with a scalar part s and zero vector part.

__init__(self: usg._usg.Quatd, s: float, x: float, y: float, z: float) -> None
__init__(self: usg._usg.Quatd, s: float, v: usg._usg.Vec3d) -> None

Construct with scalar part s and vector part v.

__init__(self: usg._usg.Quatd, arg0: usg._usg.Mat4d) -> None

Construct to represent the rotation of the given transformation matrix.

__init__(self: usg._usg.Quatd, arg0: usg._usg.Vec3d, arg1: usg._usg.Vec3d) -> None

Construct to represent the rotation from one vector to another.

static addIdentity() → usg._usg.Quatd: Return the additive identity.

addInverse() → usg._usg.Quatd: Return additive inverse of this quaternion.

conjugate() → usg._usg.Quatd

static fromAngleAxis(angle: float, v: usg._usg.Vec3d) → usg._usg.Quatd: Return a quaternion representing a rotation by angle (in radians) about v.

length() → float

lengthSquared() → float

static multIdentity() → usg._usg.Quatd: Return the multiplicative identity.

multInverse() → usg._usg.Quatd: Return multiplicative inverse of this quaternion.

normalize() → None

normalized() → usg._usg.Quatd

rotationMatrix() → usg._usg.Mat4d: Return the transformation matrix that will represent the the Euler angle rotations that this quaternion embodies. Note - this method only affects the rotation part of the matrix. NOTE: The quaternion must be normalized before using this function.

property s

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Quatd, s: float, x: float, y: float, z: float) -> None
set(self: usg._usg.Quatd, s: float, v: usg._usg.Vec3d) -> None

setFromAngleAxis(angle: float, v: usg._usg.Vec3d) → None: Set this to represent a rotation by an angle (in radians) about v.

slerp(end_quaternion: usg._usg.Quatd, t: float) → usg._usg.Quatd

Spherical linear interpolation.

This method interpolates smoothly between two quaternions. The value t should be a number between 0.0 and 1.0. When t = 0.0, this is returned. When t = 1.0, end_quat is returned.

Because of the way quaternions work, you can’t just linearly interpolate between two of them. You must interpolate along the surface of a sphere. This method returns a quaternion that is between the current quaternion and the end_quat. The value of t (which should be between 0 and 1) determines the amount of interpolation.

property v

class usg.Vec2i

Bases: pybind11_object

A 2D vector.

XAxis = <Vec2i [1, 0]>

YAxis = <Vec2i [0, 1]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec2i, v: int) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec2i, x: int, y: int) -> None

Construct a vector with the given x and y components.

clear() → None: Set all values to 0.

cross(v: usg._usg.Vec2i) → int

Return the cross product of this and v.

For 2D vectors, this returns the z component of the cross product as if they were vectors in 3D space, in the x-y plane.

distanceBetween(v: usg._usg.Vec2i) → int

Return the distance between this and v.

This is the same as (this - v).length().

distanceSquared(v: usg._usg.Vec2i) → int: Return the square of the distance between this and v.

dot(v: usg._usg.Vec2i) → int: Return the dot product of this and v.

greaterThanZero() → bool: Return true if all components are greater than zero.

interpolateTo(v: usg._usg.Vec2i, t: float) → usg._usg.Vec2i: Return the linear-interpolation between this and v at time t, where t=0..1.

isZero() → bool: Return True if all components are zero.

largestAxis() → int: Return the absolute value of the largest element.

length() → int: Return the length (magnitude) of the vector.

lengthSquared() → int: Return the squared length of the vector.

maximum(arg0: usg._usg.Vec2i) → usg._usg.Vec2i: Return a new vector where each component is the largest of the two.

maximumComponent() → int: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec2i) → usg._usg.Vec2i: Return a new vector where each component is the smallest of the two.

minimumComponent() → int: Return the smallest component of this vector.

normalize() → int

Normalize this vector and return the original length.

This has the result that this vector’s length will be 1.

normalized() → usg._usg.Vec2i: Return the normalized unit vector from this vector.

notZero() → bool: Return True if any component is not zero.

roundIfNearlyOne(threshold: int = 0) → None: Round each element to one if it is within the threshold.

roundIfNearlyZero(threshold: int = 0) → None: Round each element to zero if it is within the threshold.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec2i, arg0: int, arg1: int) -> None

Set the x and y components.

set(self: usg._usg.Vec2i, n: int) -> None

Set all values to n.

property x: The x component of the vector.

property y: The y component of the vector.

class usg.Vec2h

Bases: pybind11_object

A 2D vector.

XAxis = <Vec2h [1, 0]>

YAxis = <Vec2h [0, 1]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec2h, v: usg._usg.Half) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec2h, x: usg._usg.Half, y: usg._usg.Half) -> None

Construct a vector with the given x and y components.

clear() → None: Set all values to 0.

cross(v: usg._usg.Vec2h) → usg._usg.Half

Return the cross product of this and v.

For 2D vectors, this returns the z component of the cross product as if they were vectors in 3D space, in the x-y plane.

distanceBetween(v: usg._usg.Vec2h) → usg._usg.Half

Return the distance between this and v.

This is the same as (this - v).length().

distanceSquared(v: usg._usg.Vec2h) → usg._usg.Half: Return the square of the distance between this and v.

dot(v: usg._usg.Vec2h) → usg._usg.Half: Return the dot product of this and v.

greaterThanZero() → bool: Return true if all components are greater than zero.

interpolateTo(v: usg._usg.Vec2h, t: float) → usg._usg.Vec2h: Return the linear-interpolation between this and v at time t, where t=0..1.

isZero() → bool: Return True if all components are zero.

largestAxis() → usg._usg.Half: Return the absolute value of the largest element.

length() → usg._usg.Half: Return the length (magnitude) of the vector.

lengthSquared() → usg._usg.Half: Return the squared length of the vector.

maximum(arg0: usg._usg.Vec2h) → usg._usg.Vec2h: Return a new vector where each component is the largest of the two.

maximumComponent() → usg._usg.Half: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec2h) → usg._usg.Vec2h: Return a new vector where each component is the smallest of the two.

minimumComponent() → usg._usg.Half: Return the smallest component of this vector.

normalize() → usg._usg.Half

Normalize this vector and return the original length.

This has the result that this vector’s length will be 1.

normalized() → usg._usg.Vec2h: Return the normalized unit vector from this vector.

notZero() → bool: Return True if any component is not zero.

roundIfNearlyOne(threshold: usg._usg.Half = 0.000977) → None: Round each element to one if it is within the threshold.

roundIfNearlyZero(threshold: usg._usg.Half = 0.000977) → None: Round each element to zero if it is within the threshold.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec2h, arg0: usg._usg.Half, arg1: usg._usg.Half) -> None

Set the x and y components.

set(self: usg._usg.Vec2h, n: usg._usg.Half) -> None

Set all values to n.

property x: The x component of the vector.

property y: The y component of the vector.

class usg.Vec2f

Bases: pybind11_object

A 2D vector.

XAxis = <Vec2f [1, 0]>

YAxis = <Vec2f [0, 1]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec2f, v: float) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec2f, x: float, y: float) -> None

Construct a vector with the given x and y components.

clear() → None: Set all values to 0.

cross(v: usg._usg.Vec2f) → float

Return the cross product of this and v.

For 2D vectors, this returns the z component of the cross product as if they were vectors in 3D space, in the x-y plane.

distanceBetween(v: usg._usg.Vec2f) → float

Return the distance between this and v.

This is the same as (this - v).length().

distanceSquared(v: usg._usg.Vec2f) → float: Return the square of the distance between this and v.

dot(v: usg._usg.Vec2f) → float: Return the dot product of this and v.

greaterThanZero() → bool: Return true if all components are greater than zero.

interpolateTo(v: usg._usg.Vec2f, t: float) → usg._usg.Vec2f: Return the linear-interpolation between this and v at time t, where t=0..1.

isZero() → bool: Return True if all components are zero.

largestAxis() → float: Return the absolute value of the largest element.

length() → float: Return the length (magnitude) of the vector.

lengthSquared() → float: Return the squared length of the vector.

maximum(arg0: usg._usg.Vec2f) → usg._usg.Vec2f: Return a new vector where each component is the largest of the two.

maximumComponent() → float: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec2f) → usg._usg.Vec2f: Return a new vector where each component is the smallest of the two.

minimumComponent() → float: Return the smallest component of this vector.

normalize() → float

Normalize this vector and return the original length.

This has the result that this vector’s length will be 1.

normalized() → usg._usg.Vec2f: Return the normalized unit vector from this vector.

notZero() → bool: Return True if any component is not zero.

roundIfNearlyOne(threshold: float = 1.1920928955078125e-07) → None: Round each element to one if it is within the threshold.

roundIfNearlyZero(threshold: float = 1.1920928955078125e-07) → None: Round each element to zero if it is within the threshold.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec2f, arg0: float, arg1: float) -> None

Set the x and y components.

set(self: usg._usg.Vec2f, n: float) -> None

Set all values to n.

property x: The x component of the vector.

property y: The y component of the vector.

class usg.Vec2d

Bases: pybind11_object

A 2D vector.

XAxis = <Vec2d [1, 0]>

YAxis = <Vec2d [0, 1]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec2d, v: float) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec2d, x: float, y: float) -> None

Construct a vector with the given x and y components.

clear() → None: Set all values to 0.

cross(v: usg._usg.Vec2d) → float

Return the cross product of this and v.

For 2D vectors, this returns the z component of the cross product as if they were vectors in 3D space, in the x-y plane.

distanceBetween(v: usg._usg.Vec2d) → float

Return the distance between this and v.

This is the same as (this - v).length().

distanceSquared(v: usg._usg.Vec2d) → float: Return the square of the distance between this and v.

dot(v: usg._usg.Vec2d) → float: Return the dot product of this and v.

greaterThanZero() → bool: Return true if all components are greater than zero.

interpolateTo(v: usg._usg.Vec2d, t: float) → usg._usg.Vec2d: Return the linear-interpolation between this and v at time t, where t=0..1.

isZero() → bool: Return True if all components are zero.

largestAxis() → float: Return the absolute value of the largest element.

length() → float: Return the length (magnitude) of the vector.

lengthSquared() → float: Return the squared length of the vector.

maximum(arg0: usg._usg.Vec2d) → usg._usg.Vec2d: Return a new vector where each component is the largest of the two.

maximumComponent() → float: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec2d) → usg._usg.Vec2d: Return a new vector where each component is the smallest of the two.

minimumComponent() → float: Return the smallest component of this vector.

normalize() → float

Normalize this vector and return the original length.

This has the result that this vector’s length will be 1.

normalized() → usg._usg.Vec2d: Return the normalized unit vector from this vector.

notZero() → bool: Return True if any component is not zero.

roundIfNearlyOne(threshold: float = 2.220446049250313e-16) → None: Round each element to one if it is within the threshold.

roundIfNearlyZero(threshold: float = 2.220446049250313e-16) → None: Round each element to zero if it is within the threshold.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec2d, arg0: float, arg1: float) -> None

Set the x and y components.

set(self: usg._usg.Vec2d, n: float) -> None

Set all values to n.

property x: The x component of the vector.

property y: The y component of the vector.

class usg.Vec3i

Bases: pybind11_object

A 3D vector.

XAxis = <Vec3i [1, 0, 0]>

YAxis = <Vec3i [0, 1, 0]>

ZAxis = <Vec3i [0, 0, 1]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec3i, v: int) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec3i, x: int, y: int, z: int = 0) -> None

Construct a vector with the given x, y and z components.

__init__(self: usg._usg.Vec3i, xy: usg._usg.Vec2i, z: int = 0) -> None

Construct a 3D vector from a 2D vector which specifies the x and y components.

asDegrees() → usg._usg.Vec3i: Return a vector with each component converted form radians to degrees.

asRadians() → usg._usg.Vec3i: Return a vector with each component converted form degrees to radians.

clear() → None: Set all values to 0.

cross(v: usg._usg.Vec3i) → usg._usg.Vec3i

Return the cross product of this and v.

For 2D vectors, this returns the z component of the cross product as if they were vectors in 3D space, in the x-y plane.

distanceBetween(v: usg._usg.Vec3i) → int

Return the distance between this and v.

This is the same as (this - v).length().

distanceFromPlane(a: int, b: int, c: int, d: int) → int: Return the scalar distance between this vector and the plane ABCD.

distanceSquared(v: usg._usg.Vec3i) → int: Return the square of the distance between this and v.

dot(v: usg._usg.Vec3i) → int: Return the dot product of this and v.

faceForward(normal: usg._usg.Vec3i) → None: Negate this vector if it points in the opposite direction of the normal.

greaterThanZero() → bool: Return true if all components are greater than zero.

interpolateTo(v: usg._usg.Vec3i, t: float) → usg._usg.Vec3i: Return the linear-interpolation between this and v at time t, where t=0..1.

isZero() → bool: Return True if all components are zero.

largestAxis() → int: Return the absolute value of the largest element.

length() → int: Return the length (magnitude) of the vector.

lengthSquared() → int: Return the squared length of the vector.

maximum(arg0: usg._usg.Vec3i) → usg._usg.Vec3i: Return a new vector where each component is the largest of the two.

maximumComponent() → int: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec3i) → usg._usg.Vec3i: Return a new vector where each component is the smallest of the two.

minimumComponent() → int: Return the smallest component of this vector.

normalize() → int

Normalize this vector and return the original length.

This has the result that this vector’s length will be 1.

normalized() → usg._usg.Vec3i: Return the normalized unit vector from this vector.

notZero() → bool: Return True if any component is not zero.

orientAroundNormal(normal: usg._usg.Vec3i, auto_flip: bool = True) → None

Orient vector relative to a normal’s frame.

The +z axis of this vector is rotated to line up with the normal. If normal.z is negative then the up orientation of the resulting vector is flipped to avoid the degenerate case where normal.z gets near -1.0 and there’s no rotation solution.

reflect(normal: usg._usg.Vec3i) → usg._usg.Vec3i: Return a vector of this one reflected around the normal vector.

rotateAroundAxis(angle: int, axis: usg._usg.Vec3i) → None: Rotate a vector by an angle around a center axis vector.

roundIfNearlyOne(threshold: int = 0) → None: Round each element to one if it is within the threshold.

roundIfNearlyZero(threshold: int = 0) → None: Round each element to zero if it is within the threshold.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec3i, arg0: int, arg1: int, arg2: int) -> None

Set the x, y and z components of the vector.

set(self: usg._usg.Vec3i, n: int) -> None

Set all values to n.

toDegrees() → None: Convert each component from radians to degrees.

toRadians() → None: Convert each component from degress to radians.

property x: The x component of the vector.

xy() → usg._usg.Vec2i: Return a 2D vector containing the x and y components.

property y: The y component of the vector.

property z: The z component of the vector.

class usg.Vec3h

Bases: pybind11_object

A 3D vector.

XAxis = <Vec3h [1, 0, 0]>

YAxis = <Vec3h [0, 1, 0]>

ZAxis = <Vec3h [0, 0, 1]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec3h, v: usg._usg.Half) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec3h, x: usg._usg.Half, y: usg._usg.Half, z: usg._usg.Half = 0.000000) -> None

Construct a vector with the given x, y and z components.

__init__(self: usg._usg.Vec3h, xy: usg._usg.Vec2h, z: usg._usg.Half = 0.000000) -> None

Construct a 3D vector from a 2D vector which specifies the x and y components.

asDegrees() → usg._usg.Vec3h: Return a vector with each component converted form radians to degrees.

asRadians() → usg._usg.Vec3h: Return a vector with each component converted form degrees to radians.

clear() → None: Set all values to 0.

cross(v: usg._usg.Vec3h) → usg._usg.Vec3h

Return the cross product of this and v.

For 2D vectors, this returns the z component of the cross product as if they were vectors in 3D space, in the x-y plane.

distanceBetween(v: usg._usg.Vec3h) → usg._usg.Half

Return the distance between this and v.

This is the same as (this - v).length().

distanceFromPlane(a: usg._usg.Half, b: usg._usg.Half, c: usg._usg.Half, d: usg._usg.Half) → usg._usg.Half: Return the scalar distance between this vector and the plane ABCD.

distanceSquared(v: usg._usg.Vec3h) → usg._usg.Half: Return the square of the distance between this and v.

dot(v: usg._usg.Vec3h) → usg._usg.Half: Return the dot product of this and v.

faceForward(normal: usg._usg.Vec3h) → None: Negate this vector if it points in the opposite direction of the normal.

greaterThanZero() → bool: Return true if all components are greater than zero.

interpolateTo(v: usg._usg.Vec3h, t: float) → usg._usg.Vec3h: Return the linear-interpolation between this and v at time t, where t=0..1.

isZero() → bool: Return True if all components are zero.

largestAxis() → usg._usg.Half: Return the absolute value of the largest element.

length() → usg._usg.Half: Return the length (magnitude) of the vector.

lengthSquared() → usg._usg.Half: Return the squared length of the vector.

maximum(arg0: usg._usg.Vec3h) → usg._usg.Vec3h: Return a new vector where each component is the largest of the two.

maximumComponent() → usg._usg.Half: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec3h) → usg._usg.Vec3h: Return a new vector where each component is the smallest of the two.

minimumComponent() → usg._usg.Half: Return the smallest component of this vector.

normalize() → usg._usg.Half

Normalize this vector and return the original length.

This has the result that this vector’s length will be 1.

normalized() → usg._usg.Vec3h: Return the normalized unit vector from this vector.

notZero() → bool: Return True if any component is not zero.

orientAroundNormal(normal: usg._usg.Vec3h, auto_flip: bool = True) → None

Orient vector relative to a normal’s frame.

The +z axis of this vector is rotated to line up with the normal. If normal.z is negative then the up orientation of the resulting vector is flipped to avoid the degenerate case where normal.z gets near -1.0 and there’s no rotation solution.

reflect(normal: usg._usg.Vec3h) → usg._usg.Vec3h: Return a vector of this one reflected around the normal vector.

rotateAroundAxis(angle: usg._usg.Half, axis: usg._usg.Vec3h) → None: Rotate a vector by an angle around a center axis vector.

roundIfNearlyOne(threshold: usg._usg.Half = 0.000977) → None: Round each element to one if it is within the threshold.

roundIfNearlyZero(threshold: usg._usg.Half = 0.000977) → None: Round each element to zero if it is within the threshold.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec3h, arg0: usg._usg.Half, arg1: usg._usg.Half, arg2: usg._usg.Half) -> None

Set the x, y and z components of the vector.

set(self: usg._usg.Vec3h, n: usg._usg.Half) -> None

Set all values to n.

toDegrees() → None: Convert each component from radians to degrees.

toRadians() → None: Convert each component from degress to radians.

property x: The x component of the vector.

xy() → usg._usg.Vec2h: Return a 2D vector containing the x and y components.

property y: The y component of the vector.

property z: The z component of the vector.

class usg.Vec3f

Bases: pybind11_object

A 3D vector.

XAxis = <Vec3f [1, 0, 0]>

YAxis = <Vec3f [0, 1, 0]>

ZAxis = <Vec3f [0, 0, 1]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec3f, v: float) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec3f, x: float, y: float, z: float = 0.0) -> None

Construct a vector with the given x, y and z components.

__init__(self: usg._usg.Vec3f, xy: usg._usg.Vec2f, z: float = 0.0) -> None

Construct a 3D vector from a 2D vector which specifies the x and y components.

asDegrees() → usg._usg.Vec3f: Return a vector with each component converted form radians to degrees.

asRadians() → usg._usg.Vec3f: Return a vector with each component converted form degrees to radians.

clear() → None: Set all values to 0.

cross(v: usg._usg.Vec3f) → usg._usg.Vec3f

Return the cross product of this and v.

For 2D vectors, this returns the z component of the cross product as if they were vectors in 3D space, in the x-y plane.

distanceBetween(v: usg._usg.Vec3f) → float

Return the distance between this and v.

This is the same as (this - v).length().

distanceFromPlane(a: float, b: float, c: float, d: float) → float: Return the scalar distance between this vector and the plane ABCD.

distanceSquared(v: usg._usg.Vec3f) → float: Return the square of the distance between this and v.

dot(v: usg._usg.Vec3f) → float: Return the dot product of this and v.

faceForward(normal: usg._usg.Vec3f) → None: Negate this vector if it points in the opposite direction of the normal.

greaterThanZero() → bool: Return true if all components are greater than zero.

interpolateTo(v: usg._usg.Vec3f, t: float) → usg._usg.Vec3f: Return the linear-interpolation between this and v at time t, where t=0..1.

isZero() → bool: Return True if all components are zero.

largestAxis() → float: Return the absolute value of the largest element.

length() → float: Return the length (magnitude) of the vector.

lengthSquared() → float: Return the squared length of the vector.

maximum(arg0: usg._usg.Vec3f) → usg._usg.Vec3f: Return a new vector where each component is the largest of the two.

maximumComponent() → float: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec3f) → usg._usg.Vec3f: Return a new vector where each component is the smallest of the two.

minimumComponent() → float: Return the smallest component of this vector.

normalize() → float

Normalize this vector and return the original length.

This has the result that this vector’s length will be 1.

normalized() → usg._usg.Vec3f: Return the normalized unit vector from this vector.

notZero() → bool: Return True if any component is not zero.

orientAroundNormal(normal: usg._usg.Vec3f, auto_flip: bool = True) → None

Orient vector relative to a normal’s frame.

The +z axis of this vector is rotated to line up with the normal. If normal.z is negative then the up orientation of the resulting vector is flipped to avoid the degenerate case where normal.z gets near -1.0 and there’s no rotation solution.

reflect(normal: usg._usg.Vec3f) → usg._usg.Vec3f: Return a vector of this one reflected around the normal vector.

rotateAroundAxis(angle: float, axis: usg._usg.Vec3f) → None: Rotate a vector by an angle around a center axis vector.

roundIfNearlyOne(threshold: float = 1.1920928955078125e-07) → None: Round each element to one if it is within the threshold.

roundIfNearlyZero(threshold: float = 1.1920928955078125e-07) → None: Round each element to zero if it is within the threshold.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec3f, arg0: float, arg1: float, arg2: float) -> None

Set the x, y and z components of the vector.

set(self: usg._usg.Vec3f, n: float) -> None

Set all values to n.

toDegrees() → None: Convert each component from radians to degrees.

toRadians() → None: Convert each component from degress to radians.

property x: The x component of the vector.

xy() → usg._usg.Vec2f: Return a 2D vector containing the x and y components.

property y: The y component of the vector.

property z: The z component of the vector.

class usg.Vec3d

Bases: pybind11_object

A 3D vector.

XAxis = <Vec3d [1, 0, 0]>

YAxis = <Vec3d [0, 1, 0]>

ZAxis = <Vec3d [0, 0, 1]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec3d, v: float) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec3d, x: float, y: float, z: float = 0.0) -> None

Construct a vector with the given x, y and z components.

__init__(self: usg._usg.Vec3d, xy: usg._usg.Vec2d, z: float = 0.0) -> None

Construct a 3D vector from a 2D vector which specifies the x and y components.

asDegrees() → usg._usg.Vec3d: Return a vector with each component converted form radians to degrees.

asRadians() → usg._usg.Vec3d: Return a vector with each component converted form degrees to radians.

clear() → None: Set all values to 0.

cross(v: usg._usg.Vec3d) → usg._usg.Vec3d

Return the cross product of this and v.

For 2D vectors, this returns the z component of the cross product as if they were vectors in 3D space, in the x-y plane.

distanceBetween(v: usg._usg.Vec3d) → float

Return the distance between this and v.

This is the same as (this - v).length().

distanceFromPlane(a: float, b: float, c: float, d: float) → float: Return the scalar distance between this vector and the plane ABCD.

distanceSquared(v: usg._usg.Vec3d) → float: Return the square of the distance between this and v.

dot(v: usg._usg.Vec3d) → float: Return the dot product of this and v.

faceForward(normal: usg._usg.Vec3d) → None: Negate this vector if it points in the opposite direction of the normal.

greaterThanZero() → bool: Return true if all components are greater than zero.

interpolateTo(v: usg._usg.Vec3d, t: float) → usg._usg.Vec3d: Return the linear-interpolation between this and v at time t, where t=0..1.

isZero() → bool: Return True if all components are zero.

largestAxis() → float: Return the absolute value of the largest element.

length() → float: Return the length (magnitude) of the vector.

lengthSquared() → float: Return the squared length of the vector.

maximum(arg0: usg._usg.Vec3d) → usg._usg.Vec3d: Return a new vector where each component is the largest of the two.

maximumComponent() → float: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec3d) → usg._usg.Vec3d: Return a new vector where each component is the smallest of the two.

minimumComponent() → float: Return the smallest component of this vector.

normalize() → float

Normalize this vector and return the original length.

This has the result that this vector’s length will be 1.

normalized() → usg._usg.Vec3d: Return the normalized unit vector from this vector.

notZero() → bool: Return True if any component is not zero.

orientAroundNormal(normal: usg._usg.Vec3d, auto_flip: bool = True) → None

Orient vector relative to a normal’s frame.

The +z axis of this vector is rotated to line up with the normal. If normal.z is negative then the up orientation of the resulting vector is flipped to avoid the degenerate case where normal.z gets near -1.0 and there’s no rotation solution.

reflect(normal: usg._usg.Vec3d) → usg._usg.Vec3d: Return a vector of this one reflected around the normal vector.

rotateAroundAxis(angle: float, axis: usg._usg.Vec3d) → None: Rotate a vector by an angle around a center axis vector.

roundIfNearlyOne(threshold: float = 2.220446049250313e-16) → None: Round each element to one if it is within the threshold.

roundIfNearlyZero(threshold: float = 2.220446049250313e-16) → None: Round each element to zero if it is within the threshold.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec3d, arg0: float, arg1: float, arg2: float) -> None

Set the x, y and z components of the vector.

set(self: usg._usg.Vec3d, n: float) -> None

Set all values to n.

toDegrees() → None: Convert each component from radians to degrees.

toRadians() → None: Convert each component from degress to radians.

property x: The x component of the vector.

xy() → usg._usg.Vec2d: Return a 2D vector containing the x and y components.

property y: The y component of the vector.

property z: The z component of the vector.

class usg.Vec4i

Bases: pybind11_object

A 4D vector.

WAxis = <Vec4i [0, 0, 0, 1]>

XAxis = <Vec4i [1, 0, 0, 0]>

YAxis = <Vec4i [0, 1, 0, 0]>

ZAxis = <Vec4i [0, 0, 1, 0]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec4i, v: int) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec4i, x: int, y: int, z: int = 0, w: int = 1) -> None

Construct a vector with the given x, y, z and w components.

__init__(self: usg._usg.Vec4i, xy: usg._usg.Vec2i, z: int = 0, w: int = 1) -> None

Construct a 4D vector from a 2D vector which specifies the x and y components.

__init__(self: usg._usg.Vec4i, xyz: usg._usg.Vec3i, w: int = 1) -> None

Construct a 4D vector from a 3D vector which specifies the x, y and z components.

clear() → None: Set all values to 0.

interpolateTo(v: usg._usg.Vec4i, t: float) → usg._usg.Vec4i: Return the linear-interpolation between this and v at time t, where t=0..1.

largestAxis() → int: Return the absolute value of the largest element.

maximum(arg0: usg._usg.Vec4i) → usg._usg.Vec4i: Return a new vector where each component is the largest of the two.

maximumComponent() → int: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec4i) → usg._usg.Vec4i: Return a new vector where each component is the smallest of the two.

minimumComponent() → int: Return the smallest component of this vector.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec4i, arg0: int, arg1: int, arg2: int, arg3: int) -> None

Set the x, y, z and w components.

set(self: usg._usg.Vec4i, v: usg._usg.Vec3i, w: int = 1) -> None

Set the x, y and z components to those in the vector v.

set(self: usg._usg.Vec4i, n: int) -> None

Set all values to n.

property w: The w component of the vector.

wNormalize() → usg._usg.Vec4i: Divide x, y and z by w.

wNormalized() → usg._usg.Vec3i: Return the result of dividing x, y and z by w.

property x: The x component of the vector.

xy() → usg._usg.Vec2i

xyz() → usg._usg.Vec3i

property y: The y component of the vector.

property z: The z component of the vector.

class usg.Vec4h

Bases: pybind11_object

A 4D vector.

WAxis = <Vec4h [0, 0, 0, 1]>

XAxis = <Vec4h [1, 0, 0, 0]>

YAxis = <Vec4h [0, 1, 0, 0]>

ZAxis = <Vec4h [0, 0, 1, 0]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec4h, v: usg._usg.Half) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec4h, x: usg._usg.Half, y: usg._usg.Half, z: usg._usg.Half = 0.000000, w: usg._usg.Half = 1.000000) -> None

Construct a vector with the given x, y, z and w components.

__init__(self: usg._usg.Vec4h, xy: usg._usg.Vec2h, z: usg._usg.Half = 0.000000, w: usg._usg.Half = 1.000000) -> None

Construct a 4D vector from a 2D vector which specifies the x and y components.

__init__(self: usg._usg.Vec4h, xyz: usg._usg.Vec3h, w: usg._usg.Half = 1.000000) -> None

Construct a 4D vector from a 3D vector which specifies the x, y and z components.

clear() → None: Set all values to 0.

interpolateTo(v: usg._usg.Vec4h, t: float) → usg._usg.Vec4h: Return the linear-interpolation between this and v at time t, where t=0..1.

largestAxis() → usg._usg.Half: Return the absolute value of the largest element.

maximum(arg0: usg._usg.Vec4h) → usg._usg.Vec4h: Return a new vector where each component is the largest of the two.

maximumComponent() → usg._usg.Half: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec4h) → usg._usg.Vec4h: Return a new vector where each component is the smallest of the two.

minimumComponent() → usg._usg.Half: Return the smallest component of this vector.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec4h, arg0: usg._usg.Half, arg1: usg._usg.Half, arg2: usg._usg.Half, arg3: usg._usg.Half) -> None

Set the x, y, z and w components.

set(self: usg._usg.Vec4h, v: usg._usg.Vec3h, w: usg._usg.Half = 1.000000) -> None

Set the x, y and z components to those in the vector v.

set(self: usg._usg.Vec4h, n: usg._usg.Half) -> None

Set all values to n.

property w: The w component of the vector.

wNormalize() → usg._usg.Vec4h: Divide x, y and z by w.

wNormalized() → usg._usg.Vec3h: Return the result of dividing x, y and z by w.

property x: The x component of the vector.

xy() → usg._usg.Vec2h

xyz() → usg._usg.Vec3h

property y: The y component of the vector.

property z: The z component of the vector.

class usg.Vec4f

Bases: pybind11_object

A 4D vector.

WAxis = <Vec4f [0, 0, 0, 1]>

XAxis = <Vec4f [1, 0, 0, 0]>

YAxis = <Vec4f [0, 1, 0, 0]>

ZAxis = <Vec4f [0, 0, 1, 0]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec4f, v: float) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec4f, x: float, y: float, z: float = 0.0, w: float = 1.0) -> None

Construct a vector with the given x, y, z and w components.

__init__(self: usg._usg.Vec4f, xy: usg._usg.Vec2f, z: float = 0.0, w: float = 1.0) -> None

Construct a 4D vector from a 2D vector which specifies the x and y components.

__init__(self: usg._usg.Vec4f, xyz: usg._usg.Vec3f, w: float = 1.0) -> None

Construct a 4D vector from a 3D vector which specifies the x, y and z components.

clear() → None: Set all values to 0.

interpolateTo(v: usg._usg.Vec4f, t: float) → usg._usg.Vec4f: Return the linear-interpolation between this and v at time t, where t=0..1.

largestAxis() → float: Return the absolute value of the largest element.

maximum(arg0: usg._usg.Vec4f) → usg._usg.Vec4f: Return a new vector where each component is the largest of the two.

maximumComponent() → float: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec4f) → usg._usg.Vec4f: Return a new vector where each component is the smallest of the two.

minimumComponent() → float: Return the smallest component of this vector.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec4f, arg0: float, arg1: float, arg2: float, arg3: float) -> None

Set the x, y, z and w components.

set(self: usg._usg.Vec4f, v: usg._usg.Vec3f, w: float = 1.0) -> None

Set the x, y and z components to those in the vector v.

set(self: usg._usg.Vec4f, n: float) -> None

Set all values to n.

property w: The w component of the vector.

wNormalize() → usg._usg.Vec4f: Divide x, y and z by w.

wNormalized() → usg._usg.Vec3f: Return the result of dividing x, y and z by w.

property x: The x component of the vector.

xy() → usg._usg.Vec2f

xyz() → usg._usg.Vec3f

property y: The y component of the vector.

property z: The z component of the vector.

class usg.Vec4d

Bases: pybind11_object

A 4D vector.

WAxis = <Vec4d [0, 0, 0, 1]>

XAxis = <Vec4d [1, 0, 0, 0]>

YAxis = <Vec4d [0, 1, 0, 0]>

ZAxis = <Vec4d [0, 0, 1, 0]>

__init__(*args, **kwargs)

Overloaded function.

__init__(self: usg._usg.Vec4d, v: float) -> None

Construct a vector with all components equal to v.

__init__(self: usg._usg.Vec4d, x: float, y: float, z: float = 0.0, w: float = 1.0) -> None

Construct a vector with the given x, y, z and w components.

__init__(self: usg._usg.Vec4d, xy: usg._usg.Vec2d, z: float = 0.0, w: float = 1.0) -> None

Construct a 4D vector from a 2D vector which specifies the x and y components.

__init__(self: usg._usg.Vec4d, xyz: usg._usg.Vec3d, w: float = 1.0) -> None

Construct a 4D vector from a 3D vector which specifies the x, y and z components.

clear() → None: Set all values to 0.

interpolateTo(v: usg._usg.Vec4d, t: float) → usg._usg.Vec4d: Return the linear-interpolation between this and v at time t, where t=0..1.

largestAxis() → float: Return the absolute value of the largest element.

maximum(arg0: usg._usg.Vec4d) → usg._usg.Vec4d: Return a new vector where each component is the largest of the two.

maximumComponent() → float: Return the largest component of this vector.

minimum(arg0: usg._usg.Vec4d) → usg._usg.Vec4d: Return a new vector where each component is the smallest of the two.

minimumComponent() → float: Return the smallest component of this vector.

set(*args, **kwargs)

Overloaded function.

set(self: usg._usg.Vec4d, arg0: float, arg1: float, arg2: float, arg3: float) -> None

Set the x, y, z and w components.

set(self: usg._usg.Vec4d, v: usg._usg.Vec3d, w: float = 1.0) -> None

Set the x, y and z components to those in the vector v.

set(self: usg._usg.Vec4d, n: float) -> None

Set all values to n.

property w: The w component of the vector.

wNormalize() → usg._usg.Vec4d: Divide x, y and z by w.

wNormalized() → usg._usg.Vec3d: Return the result of dividing x, y and z by w.

property x: The x component of the vector.

xy() → usg._usg.Vec2d

xyz() → usg._usg.Vec3d

property y: The y component of the vector.

property z: The z component of the vector.