USDRT Python API Reference¶

Note that modules show up here in their private namespace, but they are usable from the public namespace, reflecting USD’s API. For example, the documentation here reports the class:

usdrt.Gf._Gf.Vec3d

But it can be used in Python code like:

from usdrt import Gf

vec_up = Gf.Vec3d(0, 1, 0)

Someday I’ll figure out how to fix this with Sphinx or in the build, but today is not that day.

usdrt.Gf module¶

usdrt.Gf._Gf.CompDiv(*args, **kwargs)¶

Overloaded function.

CompDiv(arg0: usdrt.Gf._Gf.Vec2f, arg1: usdrt.Gf._Gf.Vec2f) -> usdrt.Gf._Gf.Vec2f
CompDiv(arg0: usdrt.Gf._Gf.Vec2d, arg1: usdrt.Gf._Gf.Vec2d) -> usdrt.Gf._Gf.Vec2d
CompDiv(arg0: usdrt.Gf._Gf.Vec2i, arg1: usdrt.Gf._Gf.Vec2i) -> usdrt.Gf._Gf.Vec2i
CompDiv(arg0: usdrt.Gf._Gf.Vec2h, arg1: usdrt.Gf._Gf.Vec2h) -> usdrt.Gf._Gf.Vec2h
CompDiv(arg0: usdrt.Gf._Gf.Vec3f, arg1: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
CompDiv(arg0: usdrt.Gf._Gf.Vec3d, arg1: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d
CompDiv(arg0: usdrt.Gf._Gf.Vec3i, arg1: usdrt.Gf._Gf.Vec3i) -> usdrt.Gf._Gf.Vec3i
CompDiv(arg0: usdrt.Gf._Gf.Vec3h, arg1: usdrt.Gf._Gf.Vec3h) -> usdrt.Gf._Gf.Vec3h
CompDiv(arg0: usdrt.Gf._Gf.Vec4f, arg1: usdrt.Gf._Gf.Vec4f) -> usdrt.Gf._Gf.Vec4f
CompDiv(arg0: usdrt.Gf._Gf.Vec4d, arg1: usdrt.Gf._Gf.Vec4d) -> usdrt.Gf._Gf.Vec4d
CompDiv(arg0: usdrt.Gf._Gf.Vec4i, arg1: usdrt.Gf._Gf.Vec4i) -> usdrt.Gf._Gf.Vec4i
CompDiv(arg0: usdrt.Gf._Gf.Vec4h, arg1: usdrt.Gf._Gf.Vec4h) -> usdrt.Gf._Gf.Vec4h

usdrt.Gf._Gf.CompMult(*args, **kwargs)¶

Overloaded function.

CompMult(arg0: usdrt.Gf._Gf.Vec2f, arg1: usdrt.Gf._Gf.Vec2f) -> usdrt.Gf._Gf.Vec2f
CompMult(arg0: usdrt.Gf._Gf.Vec2d, arg1: usdrt.Gf._Gf.Vec2d) -> usdrt.Gf._Gf.Vec2d
CompMult(arg0: usdrt.Gf._Gf.Vec2i, arg1: usdrt.Gf._Gf.Vec2i) -> usdrt.Gf._Gf.Vec2i
CompMult(arg0: usdrt.Gf._Gf.Vec2h, arg1: usdrt.Gf._Gf.Vec2h) -> usdrt.Gf._Gf.Vec2h
CompMult(arg0: usdrt.Gf._Gf.Vec3f, arg1: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
CompMult(arg0: usdrt.Gf._Gf.Vec3d, arg1: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d
CompMult(arg0: usdrt.Gf._Gf.Vec3i, arg1: usdrt.Gf._Gf.Vec3i) -> usdrt.Gf._Gf.Vec3i
CompMult(arg0: usdrt.Gf._Gf.Vec3h, arg1: usdrt.Gf._Gf.Vec3h) -> usdrt.Gf._Gf.Vec3h
CompMult(arg0: usdrt.Gf._Gf.Vec4f, arg1: usdrt.Gf._Gf.Vec4f) -> usdrt.Gf._Gf.Vec4f
CompMult(arg0: usdrt.Gf._Gf.Vec4d, arg1: usdrt.Gf._Gf.Vec4d) -> usdrt.Gf._Gf.Vec4d
CompMult(arg0: usdrt.Gf._Gf.Vec4i, arg1: usdrt.Gf._Gf.Vec4i) -> usdrt.Gf._Gf.Vec4i
CompMult(arg0: usdrt.Gf._Gf.Vec4h, arg1: usdrt.Gf._Gf.Vec4h) -> usdrt.Gf._Gf.Vec4h

usdrt.Gf._Gf.Cross(*args, **kwargs)¶

Overloaded function.

Cross(arg0: usdrt.Gf._Gf.Vec3f, arg1: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
Cross(arg0: usdrt.Gf._Gf.Vec3d, arg1: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d
Cross(arg0: usdrt.Gf._Gf.Vec3i, arg1: usdrt.Gf._Gf.Vec3i) -> usdrt.Gf._Gf.Vec3i
Cross(arg0: usdrt.Gf._Gf.Vec3h, arg1: usdrt.Gf._Gf.Vec3h) -> usdrt.Gf._Gf.Vec3h

usdrt.Gf._Gf.DegreesToRadians(arg0: float) → float¶

usdrt.Gf._Gf.Dot(*args, **kwargs)¶

Overloaded function.

Dot(arg0: usdrt.Gf._Gf.Vec2f, arg1: usdrt.Gf._Gf.Vec2f) -> float
Dot(arg0: usdrt.Gf._Gf.Vec2d, arg1: usdrt.Gf._Gf.Vec2d) -> float
Dot(arg0: usdrt.Gf._Gf.Vec2i, arg1: usdrt.Gf._Gf.Vec2i) -> int
Dot(arg0: usdrt.Gf._Gf.Vec2h, arg1: usdrt.Gf._Gf.Vec2h) -> GfHalf
Dot(arg0: usdrt.Gf._Gf.Vec3f, arg1: usdrt.Gf._Gf.Vec3f) -> float
Dot(arg0: usdrt.Gf._Gf.Vec3d, arg1: usdrt.Gf._Gf.Vec3d) -> float
Dot(arg0: usdrt.Gf._Gf.Vec3i, arg1: usdrt.Gf._Gf.Vec3i) -> int
Dot(arg0: usdrt.Gf._Gf.Vec3h, arg1: usdrt.Gf._Gf.Vec3h) -> GfHalf
Dot(arg0: usdrt.Gf._Gf.Vec4f, arg1: usdrt.Gf._Gf.Vec4f) -> float
Dot(arg0: usdrt.Gf._Gf.Vec4d, arg1: usdrt.Gf._Gf.Vec4d) -> float
Dot(arg0: usdrt.Gf._Gf.Vec4i, arg1: usdrt.Gf._Gf.Vec4i) -> int
Dot(arg0: usdrt.Gf._Gf.Vec4h, arg1: usdrt.Gf._Gf.Vec4h) -> GfHalf
Dot(arg0: usdrt.Gf._Gf.Quatd, arg1: usdrt.Gf._Gf.Quatd) -> float
Dot(arg0: usdrt.Gf._Gf.Quatf, arg1: usdrt.Gf._Gf.Quatf) -> float
Dot(arg0: usdrt.Gf._Gf.Quath, arg1: usdrt.Gf._Gf.Quath) -> GfHalf

usdrt.Gf._Gf.GetComplement(*args, **kwargs)¶

Overloaded function.

GetComplement(arg0: usdrt.Gf._Gf.Vec2f, arg1: usdrt.Gf._Gf.Vec2f) -> usdrt.Gf._Gf.Vec2f
GetComplement(arg0: usdrt.Gf._Gf.Vec2d, arg1: usdrt.Gf._Gf.Vec2d) -> usdrt.Gf._Gf.Vec2d
GetComplement(arg0: usdrt.Gf._Gf.Vec2i, arg1: usdrt.Gf._Gf.Vec2i) -> usdrt.Gf._Gf.Vec2i
GetComplement(arg0: usdrt.Gf._Gf.Vec2h, arg1: usdrt.Gf._Gf.Vec2h) -> usdrt.Gf._Gf.Vec2h
GetComplement(arg0: usdrt.Gf._Gf.Vec3f, arg1: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
GetComplement(arg0: usdrt.Gf._Gf.Vec3d, arg1: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d
GetComplement(arg0: usdrt.Gf._Gf.Vec3i, arg1: usdrt.Gf._Gf.Vec3i) -> usdrt.Gf._Gf.Vec3i
GetComplement(arg0: usdrt.Gf._Gf.Vec3h, arg1: usdrt.Gf._Gf.Vec3h) -> usdrt.Gf._Gf.Vec3h
GetComplement(arg0: usdrt.Gf._Gf.Vec4f, arg1: usdrt.Gf._Gf.Vec4f) -> usdrt.Gf._Gf.Vec4f
GetComplement(arg0: usdrt.Gf._Gf.Vec4d, arg1: usdrt.Gf._Gf.Vec4d) -> usdrt.Gf._Gf.Vec4d
GetComplement(arg0: usdrt.Gf._Gf.Vec4i, arg1: usdrt.Gf._Gf.Vec4i) -> usdrt.Gf._Gf.Vec4i
GetComplement(arg0: usdrt.Gf._Gf.Vec4h, arg1: usdrt.Gf._Gf.Vec4h) -> usdrt.Gf._Gf.Vec4h

usdrt.Gf._Gf.GetLength(*args, **kwargs)¶

Overloaded function.

GetLength(arg0: usdrt.Gf._Gf.Vec2f) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec2d) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec2i) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec2h) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec3f) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec3d) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec3i) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec3h) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec4f) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec4d) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec4i) -> float
GetLength(arg0: usdrt.Gf._Gf.Vec4h) -> float

usdrt.Gf._Gf.GetNormalized(*args, **kwargs)¶

Overloaded function.

GetNormalized(arg0: usdrt.Gf._Gf.Vec2f) -> usdrt.Gf._Gf.Vec2f
GetNormalized(arg0: usdrt.Gf._Gf.Vec2d) -> usdrt.Gf._Gf.Vec2d
GetNormalized(arg0: usdrt.Gf._Gf.Vec2i) -> usdrt.Gf._Gf.Vec2i
GetNormalized(arg0: usdrt.Gf._Gf.Vec2h) -> usdrt.Gf._Gf.Vec2h
GetNormalized(arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
GetNormalized(arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d
GetNormalized(arg0: usdrt.Gf._Gf.Vec3i) -> usdrt.Gf._Gf.Vec3i
GetNormalized(arg0: usdrt.Gf._Gf.Vec3h) -> usdrt.Gf._Gf.Vec3h
GetNormalized(arg0: usdrt.Gf._Gf.Vec4f) -> usdrt.Gf._Gf.Vec4f
GetNormalized(arg0: usdrt.Gf._Gf.Vec4d) -> usdrt.Gf._Gf.Vec4d
GetNormalized(arg0: usdrt.Gf._Gf.Vec4i) -> usdrt.Gf._Gf.Vec4i
GetNormalized(arg0: usdrt.Gf._Gf.Vec4h) -> usdrt.Gf._Gf.Vec4h

usdrt.Gf._Gf.GetProjection(*args, **kwargs)¶

Overloaded function.

GetProjection(arg0: usdrt.Gf._Gf.Vec2f, arg1: usdrt.Gf._Gf.Vec2f) -> usdrt.Gf._Gf.Vec2f
GetProjection(arg0: usdrt.Gf._Gf.Vec2d, arg1: usdrt.Gf._Gf.Vec2d) -> usdrt.Gf._Gf.Vec2d
GetProjection(arg0: usdrt.Gf._Gf.Vec2i, arg1: usdrt.Gf._Gf.Vec2i) -> usdrt.Gf._Gf.Vec2i
GetProjection(arg0: usdrt.Gf._Gf.Vec2h, arg1: usdrt.Gf._Gf.Vec2h) -> usdrt.Gf._Gf.Vec2h
GetProjection(arg0: usdrt.Gf._Gf.Vec3f, arg1: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
GetProjection(arg0: usdrt.Gf._Gf.Vec3d, arg1: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d
GetProjection(arg0: usdrt.Gf._Gf.Vec3i, arg1: usdrt.Gf._Gf.Vec3i) -> usdrt.Gf._Gf.Vec3i
GetProjection(arg0: usdrt.Gf._Gf.Vec3h, arg1: usdrt.Gf._Gf.Vec3h) -> usdrt.Gf._Gf.Vec3h
GetProjection(arg0: usdrt.Gf._Gf.Vec4f, arg1: usdrt.Gf._Gf.Vec4f) -> usdrt.Gf._Gf.Vec4f
GetProjection(arg0: usdrt.Gf._Gf.Vec4d, arg1: usdrt.Gf._Gf.Vec4d) -> usdrt.Gf._Gf.Vec4d
GetProjection(arg0: usdrt.Gf._Gf.Vec4i, arg1: usdrt.Gf._Gf.Vec4i) -> usdrt.Gf._Gf.Vec4i
GetProjection(arg0: usdrt.Gf._Gf.Vec4h, arg1: usdrt.Gf._Gf.Vec4h) -> usdrt.Gf._Gf.Vec4h

usdrt.Gf._Gf.IsClose(*args, **kwargs)¶

Overloaded function.

IsClose(arg0: float, arg1: float, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec2f, arg1: usdrt.Gf._Gf.Vec2f, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec2d, arg1: usdrt.Gf._Gf.Vec2d, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec2i, arg1: usdrt.Gf._Gf.Vec2i, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec2h, arg1: usdrt.Gf._Gf.Vec2h, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec3f, arg1: usdrt.Gf._Gf.Vec3f, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec3d, arg1: usdrt.Gf._Gf.Vec3d, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec3i, arg1: usdrt.Gf._Gf.Vec3i, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec3h, arg1: usdrt.Gf._Gf.Vec3h, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec4f, arg1: usdrt.Gf._Gf.Vec4f, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec4d, arg1: usdrt.Gf._Gf.Vec4d, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec4i, arg1: usdrt.Gf._Gf.Vec4i, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Vec4h, arg1: usdrt.Gf._Gf.Vec4h, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Matrix4d, arg1: usdrt.Gf._Gf.Matrix4d, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Matrix4f, arg1: usdrt.Gf._Gf.Matrix4f, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Quatd, arg1: usdrt.Gf._Gf.Quatd, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Quatf, arg1: usdrt.Gf._Gf.Quatf, arg2: float) -> bool
IsClose(arg0: usdrt.Gf._Gf.Quath, arg1: usdrt.Gf._Gf.Quath, arg2: float) -> bool

usdrt.Gf._Gf.Lerp(*args, **kwargs)¶

Overloaded function.

Lerp(alpha: float, a: float, b: float) -> float
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec2f, b: usdrt.Gf._Gf.Vec2f) -> usdrt.Gf._Gf.Vec2f
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec2d, b: usdrt.Gf._Gf.Vec2d) -> usdrt.Gf._Gf.Vec2d
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec2i, b: usdrt.Gf._Gf.Vec2i) -> usdrt.Gf._Gf.Vec2i
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec2h, b: usdrt.Gf._Gf.Vec2h) -> usdrt.Gf._Gf.Vec2h
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec3f, b: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec3d, b: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec3i, b: usdrt.Gf._Gf.Vec3i) -> usdrt.Gf._Gf.Vec3i
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec3h, b: usdrt.Gf._Gf.Vec3h) -> usdrt.Gf._Gf.Vec3h
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec4f, b: usdrt.Gf._Gf.Vec4f) -> usdrt.Gf._Gf.Vec4f
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec4d, b: usdrt.Gf._Gf.Vec4d) -> usdrt.Gf._Gf.Vec4d
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec4i, b: usdrt.Gf._Gf.Vec4i) -> usdrt.Gf._Gf.Vec4i
Lerp(alpha: float, a: usdrt.Gf._Gf.Vec4h, b: usdrt.Gf._Gf.Vec4h) -> usdrt.Gf._Gf.Vec4h

usdrt.Gf._Gf.Lerpf(alpha: float, a: float, b: float) → float¶

class usdrt.Gf._Gf.Matrix3d¶

GetArrayItem(self: usdrt.Gf._Gf.Matrix3d, arg0: int) → float¶

GetColumn(self: usdrt.Gf._Gf.Matrix3d, arg0: int) → usdrt.Gf._Gf.Vec3d ¶

GetDeterminant(self: usdrt.Gf._Gf.Matrix3d) → float¶

GetHandedness(self: usdrt.Gf._Gf.Matrix3d) → int¶

GetInverse(self: usdrt.Gf._Gf.Matrix3d) → usdrt.Gf._Gf.Matrix3d ¶

GetOrthonormalized(self: usdrt.Gf._Gf.Matrix3d) → usdrt.Gf._Gf.Matrix3d ¶

GetRow(self: usdrt.Gf._Gf.Matrix3d, arg0: int) → usdrt.Gf._Gf.Vec3d ¶

GetTranspose(self: usdrt.Gf._Gf.Matrix3d) → usdrt.Gf._Gf.Matrix3d ¶

IsLeftHanded(self: usdrt.Gf._Gf.Matrix3d) → bool¶

IsRightHanded(self: usdrt.Gf._Gf.Matrix3d) → bool¶

Orthonormalize(self: usdrt.Gf._Gf.Matrix3d) → bool¶

Set(self: usdrt.Gf._Gf.Matrix3d, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float) → usdrt.Gf._Gf.Matrix3d ¶

SetArrayItem(self: usdrt.Gf._Gf.Matrix3d, arg0: int, arg1: float) → None¶

SetColumn(self: usdrt.Gf._Gf.Matrix3d, arg0: int, arg1: usdrt.Gf._Gf.Vec3d) → None¶

SetDiagonal(*args, **kwargs)¶

Overloaded function.

SetDiagonal(self: usdrt.Gf._Gf.Matrix3d, arg0: float) -> usdrt.Gf._Gf.Matrix3d
SetDiagonal(self: usdrt.Gf._Gf.Matrix3d, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Matrix3d

SetIdentity(self: usdrt.Gf._Gf.Matrix3d) → usdrt.Gf._Gf.Matrix3d ¶

SetRow(self: usdrt.Gf._Gf.Matrix3d, arg0: int, arg1: usdrt.Gf._Gf.Vec3d) → None¶

SetZero(self: usdrt.Gf._Gf.Matrix3d) → usdrt.Gf._Gf.Matrix3d ¶

dimension = (3, 3)¶

class usdrt.Gf._Gf.Matrix3f¶

GetArrayItem(self: usdrt.Gf._Gf.Matrix3f, arg0: int) → float¶

GetColumn(self: usdrt.Gf._Gf.Matrix3f, arg0: int) → usdrt.Gf._Gf.Vec3f ¶

GetDeterminant(self: usdrt.Gf._Gf.Matrix3f) → float¶

GetHandedness(self: usdrt.Gf._Gf.Matrix3f) → int¶

GetInverse(self: usdrt.Gf._Gf.Matrix3f) → usdrt.Gf._Gf.Matrix3f ¶

GetOrthonormalized(self: usdrt.Gf._Gf.Matrix3f) → usdrt.Gf._Gf.Matrix3f ¶

GetRow(self: usdrt.Gf._Gf.Matrix3f, arg0: int) → usdrt.Gf._Gf.Vec3f ¶

GetTranspose(self: usdrt.Gf._Gf.Matrix3f) → usdrt.Gf._Gf.Matrix3f ¶

IsLeftHanded(self: usdrt.Gf._Gf.Matrix3f) → bool¶

IsRightHanded(self: usdrt.Gf._Gf.Matrix3f) → bool¶

Orthonormalize(self: usdrt.Gf._Gf.Matrix3f) → bool¶

Set(self: usdrt.Gf._Gf.Matrix3f, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float) → usdrt.Gf._Gf.Matrix3f ¶

SetArrayItem(self: usdrt.Gf._Gf.Matrix3f, arg0: int, arg1: float) → None¶

SetColumn(self: usdrt.Gf._Gf.Matrix3f, arg0: int, arg1: usdrt.Gf._Gf.Vec3f) → None¶

SetDiagonal(*args, **kwargs)¶

Overloaded function.

SetDiagonal(self: usdrt.Gf._Gf.Matrix3f, arg0: float) -> usdrt.Gf._Gf.Matrix3f
SetDiagonal(self: usdrt.Gf._Gf.Matrix3f, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Matrix3f

SetIdentity(self: usdrt.Gf._Gf.Matrix3f) → usdrt.Gf._Gf.Matrix3f ¶

SetRow(self: usdrt.Gf._Gf.Matrix3f, arg0: int, arg1: usdrt.Gf._Gf.Vec3f) → None¶

SetZero(self: usdrt.Gf._Gf.Matrix3f) → usdrt.Gf._Gf.Matrix3f ¶

dimension = (3, 3)¶

class usdrt.Gf._Gf.Matrix4d¶

ExtractRotation(self: usdrt.Gf._Gf.Matrix4d) → omni::math::linalg::quat<double>¶

ExtractRotationMatrix(self: usdrt.Gf._Gf.Matrix4d) → omni::math::linalg::matrix3<double>¶

ExtractTranslation(self: usdrt.Gf._Gf.Matrix4d) → usdrt.Gf._Gf.Vec3d ¶

GetArrayItem(self: usdrt.Gf._Gf.Matrix4d, arg0: int) → float¶

GetColumn(self: usdrt.Gf._Gf.Matrix4d, arg0: int) → usdrt.Gf._Gf.Vec4d ¶

GetDeterminant(self: usdrt.Gf._Gf.Matrix4d) → float¶

GetDeterminant3(self: usdrt.Gf._Gf.Matrix4d) → float¶

GetHandedness(self: usdrt.Gf._Gf.Matrix4d) → int¶

GetInverse(self: usdrt.Gf._Gf.Matrix4d) → usdrt.Gf._Gf.Matrix4d ¶

GetOrthonormalized(self: usdrt.Gf._Gf.Matrix4d) → usdrt.Gf._Gf.Matrix4d ¶

GetRow(self: usdrt.Gf._Gf.Matrix4d, arg0: int) → usdrt.Gf._Gf.Vec4d ¶

GetRow3(self: usdrt.Gf._Gf.Matrix4d, arg0: int) → usdrt.Gf._Gf.Vec3d ¶

GetTranspose(self: usdrt.Gf._Gf.Matrix4d) → usdrt.Gf._Gf.Matrix4d ¶

IsLeftHanded(self: usdrt.Gf._Gf.Matrix4d) → bool¶

IsRightHanded(self: usdrt.Gf._Gf.Matrix4d) → bool¶

Orthonormalize(self: usdrt.Gf._Gf.Matrix4d) → bool¶

RemoveScaleShear(self: usdrt.Gf._Gf.Matrix4d) → usdrt.Gf._Gf.Matrix4d ¶

Set(self: usdrt.Gf._Gf.Matrix4d, 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) → usdrt.Gf._Gf.Matrix4d ¶

SetArrayItem(self: usdrt.Gf._Gf.Matrix4d, arg0: int, arg1: float) → None¶

SetColumn(self: usdrt.Gf._Gf.Matrix4d, arg0: int, arg1: usdrt.Gf._Gf.Vec4d) → None¶

SetDiagonal(*args, **kwargs)¶

Overloaded function.

SetDiagonal(self: usdrt.Gf._Gf.Matrix4d, arg0: float) -> usdrt.Gf._Gf.Matrix4d
SetDiagonal(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec4d) -> usdrt.Gf._Gf.Matrix4d

SetIdentity(self: usdrt.Gf._Gf.Matrix4d) → usdrt.Gf._Gf.Matrix4d ¶

SetLookAt(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3d, arg1: usdrt.Gf._Gf.Vec3d, arg2: usdrt.Gf._Gf.Vec3d) → usdrt.Gf._Gf.Matrix4d ¶

SetRotate(*args, **kwargs)¶

Overloaded function.

SetRotate(self: usdrt.Gf._Gf.Matrix4d, arg0: omni::math::linalg::quat<double>) -> usdrt.Gf._Gf.Matrix4d
SetRotate(self: usdrt.Gf._Gf.Matrix4d, arg0: omni::math::linalg::matrix3<double>) -> usdrt.Gf._Gf.Matrix4d

SetRotateOnly(*args, **kwargs)¶

Overloaded function.

SetRotateOnly(self: usdrt.Gf._Gf.Matrix4d, arg0: omni::math::linalg::quat<double>) -> usdrt.Gf._Gf.Matrix4d
SetRotateOnly(self: usdrt.Gf._Gf.Matrix4d, arg0: omni::math::linalg::matrix3<double>) -> usdrt.Gf._Gf.Matrix4d

SetRow(self: usdrt.Gf._Gf.Matrix4d, arg0: int, arg1: usdrt.Gf._Gf.Vec4d) → None¶

SetRow3(self: usdrt.Gf._Gf.Matrix4d, arg0: int, arg1: usdrt.Gf._Gf.Vec3d) → None¶

SetScale(*args, **kwargs)¶

Overloaded function.

SetScale(self: usdrt.Gf._Gf.Matrix4d, arg0: float) -> usdrt.Gf._Gf.Matrix4d
SetScale(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Matrix4d

SetTranslate(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3d) → usdrt.Gf._Gf.Matrix4d ¶

SetTranslateOnly(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3d) → usdrt.Gf._Gf.Matrix4d ¶

SetZero(self: usdrt.Gf._Gf.Matrix4d) → usdrt.Gf._Gf.Matrix4d ¶

Transform(*args, **kwargs)¶

Overloaded function.

Transform(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
Transform(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d

TransformAffine(*args, **kwargs)¶

Overloaded function.

TransformAffine(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
TransformAffine(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d

TransformDir(*args, **kwargs)¶

Overloaded function.

TransformDir(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
TransformDir(self: usdrt.Gf._Gf.Matrix4d, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d

dimension = (4, 4)¶

class usdrt.Gf._Gf.Matrix4f¶

ExtractRotation(self: usdrt.Gf._Gf.Matrix4f) → omni::math::linalg::quat<double>¶

ExtractRotationMatrix(self: usdrt.Gf._Gf.Matrix4f) → omni::math::linalg::matrix3<float>¶

ExtractTranslation(self: usdrt.Gf._Gf.Matrix4f) → usdrt.Gf._Gf.Vec3f ¶

GetArrayItem(self: usdrt.Gf._Gf.Matrix4f, arg0: int) → float¶

GetColumn(self: usdrt.Gf._Gf.Matrix4f, arg0: int) → usdrt.Gf._Gf.Vec4f ¶

GetDeterminant(self: usdrt.Gf._Gf.Matrix4f) → float¶

GetDeterminant3(self: usdrt.Gf._Gf.Matrix4f) → float¶

GetHandedness(self: usdrt.Gf._Gf.Matrix4f) → int¶

GetInverse(self: usdrt.Gf._Gf.Matrix4f) → usdrt.Gf._Gf.Matrix4f ¶

GetOrthonormalized(self: usdrt.Gf._Gf.Matrix4f) → usdrt.Gf._Gf.Matrix4f ¶

GetRow(self: usdrt.Gf._Gf.Matrix4f, arg0: int) → usdrt.Gf._Gf.Vec4f ¶

GetRow3(self: usdrt.Gf._Gf.Matrix4f, arg0: int) → usdrt.Gf._Gf.Vec3f ¶

GetTranspose(self: usdrt.Gf._Gf.Matrix4f) → usdrt.Gf._Gf.Matrix4f ¶

IsLeftHanded(self: usdrt.Gf._Gf.Matrix4f) → bool¶

IsRightHanded(self: usdrt.Gf._Gf.Matrix4f) → bool¶

Orthonormalize(self: usdrt.Gf._Gf.Matrix4f) → bool¶

RemoveScaleShear(self: usdrt.Gf._Gf.Matrix4f) → usdrt.Gf._Gf.Matrix4f ¶

Set(self: usdrt.Gf._Gf.Matrix4f, 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) → usdrt.Gf._Gf.Matrix4f ¶

SetArrayItem(self: usdrt.Gf._Gf.Matrix4f, arg0: int, arg1: float) → None¶

SetColumn(self: usdrt.Gf._Gf.Matrix4f, arg0: int, arg1: usdrt.Gf._Gf.Vec4f) → None¶

SetDiagonal(*args, **kwargs)¶

Overloaded function.

SetDiagonal(self: usdrt.Gf._Gf.Matrix4f, arg0: float) -> usdrt.Gf._Gf.Matrix4f
SetDiagonal(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec4f) -> usdrt.Gf._Gf.Matrix4f

SetIdentity(self: usdrt.Gf._Gf.Matrix4f) → usdrt.Gf._Gf.Matrix4f ¶

SetLookAt(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3f, arg1: usdrt.Gf._Gf.Vec3f, arg2: usdrt.Gf._Gf.Vec3f) → usdrt.Gf._Gf.Matrix4f ¶

SetRotate(*args, **kwargs)¶

Overloaded function.

SetRotate(self: usdrt.Gf._Gf.Matrix4f, arg0: omni::math::linalg::quat<double>) -> usdrt.Gf._Gf.Matrix4f
SetRotate(self: usdrt.Gf._Gf.Matrix4f, arg0: omni::math::linalg::matrix3<float>) -> usdrt.Gf._Gf.Matrix4f

SetRotateOnly(*args, **kwargs)¶

Overloaded function.

SetRotateOnly(self: usdrt.Gf._Gf.Matrix4f, arg0: omni::math::linalg::quat<double>) -> usdrt.Gf._Gf.Matrix4f
SetRotateOnly(self: usdrt.Gf._Gf.Matrix4f, arg0: omni::math::linalg::matrix3<float>) -> usdrt.Gf._Gf.Matrix4f

SetRow(self: usdrt.Gf._Gf.Matrix4f, arg0: int, arg1: usdrt.Gf._Gf.Vec4f) → None¶

SetRow3(self: usdrt.Gf._Gf.Matrix4f, arg0: int, arg1: usdrt.Gf._Gf.Vec3f) → None¶

SetScale(*args, **kwargs)¶

Overloaded function.

SetScale(self: usdrt.Gf._Gf.Matrix4f, arg0: float) -> usdrt.Gf._Gf.Matrix4f
SetScale(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Matrix4f

SetTranslate(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3f) → usdrt.Gf._Gf.Matrix4f ¶

SetTranslateOnly(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3f) → usdrt.Gf._Gf.Matrix4f ¶

SetZero(self: usdrt.Gf._Gf.Matrix4f) → usdrt.Gf._Gf.Matrix4f ¶

Transform(*args, **kwargs)¶

Overloaded function.

Transform(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
Transform(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d

TransformAffine(*args, **kwargs)¶

Overloaded function.

TransformAffine(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
TransformAffine(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d

TransformDir(*args, **kwargs)¶

Overloaded function.

TransformDir(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
TransformDir(self: usdrt.Gf._Gf.Matrix4f, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d

dimension = (4, 4)¶

usdrt.Gf._Gf.Max(*args, **kwargs)¶

Overloaded function.

Max(arg0: float, arg1: float) -> float
Max(arg0: float, arg1: float, arg2: float) -> float
Max(arg0: float, arg1: float, arg2: float, arg3: float) -> float
Max(arg0: float, arg1: float, arg2: float, arg3: float, arg4: float) -> float
Max(arg0: int, arg1: int) -> int
Max(arg0: int, arg1: int, arg2: int) -> int
Max(arg0: int, arg1: int, arg2: int, arg3: int) -> int
Max(arg0: int, arg1: int, arg2: int, arg3: int, arg4: int) -> int

usdrt.Gf._Gf.Min(*args, **kwargs)¶

Overloaded function.

Min(arg0: float, arg1: float) -> float
Min(arg0: float, arg1: float, arg2: float) -> float
Min(arg0: float, arg1: float, arg2: float, arg3: float) -> float
Min(arg0: float, arg1: float, arg2: float, arg3: float, arg4: float) -> float
Min(arg0: int, arg1: int) -> int
Min(arg0: int, arg1: int, arg2: int) -> int
Min(arg0: int, arg1: int, arg2: int, arg3: int) -> int
Min(arg0: int, arg1: int, arg2: int, arg3: int, arg4: int) -> int

usdrt.Gf._Gf.Normalize(*args, **kwargs)¶

Overloaded function.

Normalize(arg0: usdrt.Gf._Gf.Vec2f) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec2d) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec2i) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec2h) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec3f) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec3d) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec3i) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec3h) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec4f) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec4d) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec4i) -> float
Normalize(arg0: usdrt.Gf._Gf.Vec4h) -> float

class usdrt.Gf._Gf.Quatd¶

Dot(self: usdrt.Gf._Gf.Quatd, arg0: usdrt.Gf._Gf.Quatd) → float¶

GetConjugate(self: usdrt.Gf._Gf.Quatd) → usdrt.Gf._Gf.Quatd ¶

GetIdentity() → usdrt.Gf._Gf.Quatd ¶

GetImaginary(self: usdrt.Gf._Gf.Quatd) → usdrt.Gf._Gf.Vec3d ¶

GetInverse(self: usdrt.Gf._Gf.Quatd) → usdrt.Gf._Gf.Quatd ¶

GetLength(self: usdrt.Gf._Gf.Quatd) → float¶

GetLengthSq(self: usdrt.Gf._Gf.Quatd) → float¶

GetNormalized(self: usdrt.Gf._Gf.Quatd) → usdrt.Gf._Gf.Quatd ¶

GetReal(self: usdrt.Gf._Gf.Quatd) → float¶

Normalize(self: usdrt.Gf._Gf.Quatd) → float¶

SetImaginary(*args, **kwargs)¶

Overloaded function.

SetImaginary(self: usdrt.Gf._Gf.Quatd, imaginary: usdrt.Gf._Gf.Vec3d) -> None
SetImaginary(self: usdrt.Gf._Gf.Quatd, i: float, j: float, k: float) -> None

SetReal(self: usdrt.Gf._Gf.Quatd, real: float) → None¶

Transform(self: usdrt.Gf._Gf.Quatd, point: usdrt.Gf._Gf.Vec3d) → usdrt.Gf._Gf.Vec3d ¶

property imaginary¶

property real¶

class usdrt.Gf._Gf.Quatf¶

Dot(self: usdrt.Gf._Gf.Quatf, arg0: usdrt.Gf._Gf.Quatf) → float¶

GetConjugate(self: usdrt.Gf._Gf.Quatf) → usdrt.Gf._Gf.Quatf ¶

GetIdentity() → usdrt.Gf._Gf.Quatf ¶

GetImaginary(self: usdrt.Gf._Gf.Quatf) → usdrt.Gf._Gf.Vec3f ¶

GetInverse(self: usdrt.Gf._Gf.Quatf) → usdrt.Gf._Gf.Quatf ¶

GetLength(self: usdrt.Gf._Gf.Quatf) → float¶

GetLengthSq(self: usdrt.Gf._Gf.Quatf) → float¶

GetNormalized(self: usdrt.Gf._Gf.Quatf) → usdrt.Gf._Gf.Quatf ¶

GetReal(self: usdrt.Gf._Gf.Quatf) → float¶

Normalize(self: usdrt.Gf._Gf.Quatf) → float¶

SetImaginary(*args, **kwargs)¶

Overloaded function.

SetImaginary(self: usdrt.Gf._Gf.Quatf, imaginary: usdrt.Gf._Gf.Vec3f) -> None
SetImaginary(self: usdrt.Gf._Gf.Quatf, i: float, j: float, k: float) -> None

SetReal(self: usdrt.Gf._Gf.Quatf, real: float) → None¶

Transform(self: usdrt.Gf._Gf.Quatf, point: usdrt.Gf._Gf.Vec3f) → usdrt.Gf._Gf.Vec3f ¶

property imaginary¶

property real¶

class usdrt.Gf._Gf.Quath¶

Dot(self: usdrt.Gf._Gf.Quath, arg0: usdrt.Gf._Gf.Quath) → GfHalf¶

GetConjugate(self: usdrt.Gf._Gf.Quath) → usdrt.Gf._Gf.Quath ¶

GetIdentity() → usdrt.Gf._Gf.Quath ¶

GetImaginary(self: usdrt.Gf._Gf.Quath) → usdrt.Gf._Gf.Vec3h ¶

GetInverse(self: usdrt.Gf._Gf.Quath) → usdrt.Gf._Gf.Quath ¶

GetLength(self: usdrt.Gf._Gf.Quath) → float¶

GetLengthSq(self: usdrt.Gf._Gf.Quath) → GfHalf¶

GetNormalized(self: usdrt.Gf._Gf.Quath) → usdrt.Gf._Gf.Quath ¶

GetReal(self: usdrt.Gf._Gf.Quath) → GfHalf¶

Normalize(self: usdrt.Gf._Gf.Quath) → float¶

SetImaginary(*args, **kwargs)¶

Overloaded function.

SetImaginary(self: usdrt.Gf._Gf.Quath, imaginary: usdrt.Gf._Gf.Vec3h) -> None
SetImaginary(self: usdrt.Gf._Gf.Quath, i: GfHalf, j: GfHalf, k: GfHalf) -> None

SetReal(self: usdrt.Gf._Gf.Quath, real: GfHalf) → None¶

Transform(self: usdrt.Gf._Gf.Quath, point: usdrt.Gf._Gf.Vec3h) → usdrt.Gf._Gf.Vec3h ¶

property imaginary¶

property real¶

usdrt.Gf._Gf.RadiansToDegrees(arg0: float) → float¶

class usdrt.Gf._Gf.Range1d¶

Contains(*args, **kwargs)¶

Overloaded function.

Contains(self: usdrt.Gf._Gf.Range1d, arg0: float) -> bool
Contains(self: usdrt.Gf._Gf.Range1d, arg0: usdrt.Gf._Gf.Range1d) -> bool

GetDistanceSquared(self: usdrt.Gf._Gf.Range1d, arg0: float) → float¶

static GetIntersection(arg0: usdrt.Gf._Gf.Range1d, arg1: usdrt.Gf._Gf.Range1d) → usdrt.Gf._Gf.Range1d ¶

GetMax(self: usdrt.Gf._Gf.Range1d) → float¶

GetMidpoint(self: usdrt.Gf._Gf.Range1d) → float¶

GetMin(self: usdrt.Gf._Gf.Range1d) → float¶

GetSize(self: usdrt.Gf._Gf.Range1d) → float¶

static GetUnion(arg0: usdrt.Gf._Gf.Range1d, arg1: usdrt.Gf._Gf.Range1d) → usdrt.Gf._Gf.Range1d ¶

IntersectWith(self: usdrt.Gf._Gf.Range1d, arg0: usdrt.Gf._Gf.Range1d) → usdrt.Gf._Gf.Range1d ¶

IsEmpty(self: usdrt.Gf._Gf.Range1d) → bool¶

SetEmpty(self: usdrt.Gf._Gf.Range1d) → None¶

SetMax(self: usdrt.Gf._Gf.Range1d, arg0: float) → None¶

SetMin(self: usdrt.Gf._Gf.Range1d, arg0: float) → None¶

UnionWith(*args, **kwargs)¶

Overloaded function.

UnionWith(self: usdrt.Gf._Gf.Range1d, arg0: float) -> usdrt.Gf._Gf.Range1d
UnionWith(self: usdrt.Gf._Gf.Range1d, arg0: usdrt.Gf._Gf.Range1d) -> usdrt.Gf._Gf.Range1d

property max¶

property min¶

class usdrt.Gf._Gf.Range1f¶

Contains(*args, **kwargs)¶

Overloaded function.

Contains(self: usdrt.Gf._Gf.Range1f, arg0: float) -> bool
Contains(self: usdrt.Gf._Gf.Range1f, arg0: usdrt.Gf._Gf.Range1f) -> bool

GetDistanceSquared(self: usdrt.Gf._Gf.Range1f, arg0: float) → float¶

static GetIntersection(arg0: usdrt.Gf._Gf.Range1f, arg1: usdrt.Gf._Gf.Range1f) → usdrt.Gf._Gf.Range1f ¶

GetMax(self: usdrt.Gf._Gf.Range1f) → float¶

GetMidpoint(self: usdrt.Gf._Gf.Range1f) → float¶

GetMin(self: usdrt.Gf._Gf.Range1f) → float¶

GetSize(self: usdrt.Gf._Gf.Range1f) → float¶

static GetUnion(arg0: usdrt.Gf._Gf.Range1f, arg1: usdrt.Gf._Gf.Range1f) → usdrt.Gf._Gf.Range1f ¶

IntersectWith(self: usdrt.Gf._Gf.Range1f, arg0: usdrt.Gf._Gf.Range1f) → usdrt.Gf._Gf.Range1f ¶

IsEmpty(self: usdrt.Gf._Gf.Range1f) → bool¶

SetEmpty(self: usdrt.Gf._Gf.Range1f) → None¶

SetMax(self: usdrt.Gf._Gf.Range1f, arg0: float) → None¶

SetMin(self: usdrt.Gf._Gf.Range1f, arg0: float) → None¶

UnionWith(*args, **kwargs)¶

Overloaded function.

UnionWith(self: usdrt.Gf._Gf.Range1f, arg0: float) -> usdrt.Gf._Gf.Range1f
UnionWith(self: usdrt.Gf._Gf.Range1f, arg0: usdrt.Gf._Gf.Range1f) -> usdrt.Gf._Gf.Range1f

property max¶

property min¶

class usdrt.Gf._Gf.Range2d¶

Contains(*args, **kwargs)¶

Overloaded function.

Contains(self: usdrt.Gf._Gf.Range2d, arg0: usdrt.Gf._Gf.Vec2d) -> bool
Contains(self: usdrt.Gf._Gf.Range2d, arg0: usdrt.Gf._Gf.Range2d) -> bool

GetCorner(self: usdrt.Gf._Gf.Range2d, arg0: int) → usdrt.Gf._Gf.Vec2d ¶

GetDistanceSquared(self: usdrt.Gf._Gf.Range2d, arg0: usdrt.Gf._Gf.Vec2d) → float¶

static GetIntersection(arg0: usdrt.Gf._Gf.Range2d, arg1: usdrt.Gf._Gf.Range2d) → usdrt.Gf._Gf.Range2d ¶

GetMax(self: usdrt.Gf._Gf.Range2d) → usdrt.Gf._Gf.Vec2d ¶

GetMidpoint(self: usdrt.Gf._Gf.Range2d) → usdrt.Gf._Gf.Vec2d ¶

GetMin(self: usdrt.Gf._Gf.Range2d) → usdrt.Gf._Gf.Vec2d ¶

GetQuadrant(self: usdrt.Gf._Gf.Range2d, arg0: int) → usdrt.Gf._Gf.Range2d ¶

GetSize(self: usdrt.Gf._Gf.Range2d) → usdrt.Gf._Gf.Vec2d ¶

static GetUnion(arg0: usdrt.Gf._Gf.Range2d, arg1: usdrt.Gf._Gf.Range2d) → usdrt.Gf._Gf.Range2d ¶

IntersectWith(self: usdrt.Gf._Gf.Range2d, arg0: usdrt.Gf._Gf.Range2d) → usdrt.Gf._Gf.Range2d ¶

IsEmpty(self: usdrt.Gf._Gf.Range2d) → bool¶

SetEmpty(self: usdrt.Gf._Gf.Range2d) → None¶

SetMax(self: usdrt.Gf._Gf.Range2d, arg0: usdrt.Gf._Gf.Vec2d) → None¶

SetMin(self: usdrt.Gf._Gf.Range2d, arg0: usdrt.Gf._Gf.Vec2d) → None¶

UnionWith(*args, **kwargs)¶

Overloaded function.

UnionWith(self: usdrt.Gf._Gf.Range2d, arg0: usdrt.Gf._Gf.Vec2d) -> usdrt.Gf._Gf.Range2d
UnionWith(self: usdrt.Gf._Gf.Range2d, arg0: usdrt.Gf._Gf.Range2d) -> usdrt.Gf._Gf.Range2d

property max¶

property min¶

static unitSquare() → usdrt.Gf._Gf.Range2d ¶

class usdrt.Gf._Gf.Range2f¶

Contains(*args, **kwargs)¶

Overloaded function.

Contains(self: usdrt.Gf._Gf.Range2f, arg0: usdrt.Gf._Gf.Vec2f) -> bool
Contains(self: usdrt.Gf._Gf.Range2f, arg0: usdrt.Gf._Gf.Range2f) -> bool

GetCorner(self: usdrt.Gf._Gf.Range2f, arg0: int) → usdrt.Gf._Gf.Vec2f ¶

GetDistanceSquared(self: usdrt.Gf._Gf.Range2f, arg0: usdrt.Gf._Gf.Vec2f) → float¶

static GetIntersection(arg0: usdrt.Gf._Gf.Range2f, arg1: usdrt.Gf._Gf.Range2f) → usdrt.Gf._Gf.Range2f ¶

GetMax(self: usdrt.Gf._Gf.Range2f) → usdrt.Gf._Gf.Vec2f ¶

GetMidpoint(self: usdrt.Gf._Gf.Range2f) → usdrt.Gf._Gf.Vec2f ¶

GetMin(self: usdrt.Gf._Gf.Range2f) → usdrt.Gf._Gf.Vec2f ¶

GetQuadrant(self: usdrt.Gf._Gf.Range2f, arg0: int) → usdrt.Gf._Gf.Range2f ¶

GetSize(self: usdrt.Gf._Gf.Range2f) → usdrt.Gf._Gf.Vec2f ¶

static GetUnion(arg0: usdrt.Gf._Gf.Range2f, arg1: usdrt.Gf._Gf.Range2f) → usdrt.Gf._Gf.Range2f ¶

IntersectWith(self: usdrt.Gf._Gf.Range2f, arg0: usdrt.Gf._Gf.Range2f) → usdrt.Gf._Gf.Range2f ¶

IsEmpty(self: usdrt.Gf._Gf.Range2f) → bool¶

SetEmpty(self: usdrt.Gf._Gf.Range2f) → None¶

SetMax(self: usdrt.Gf._Gf.Range2f, arg0: usdrt.Gf._Gf.Vec2f) → None¶

SetMin(self: usdrt.Gf._Gf.Range2f, arg0: usdrt.Gf._Gf.Vec2f) → None¶

UnionWith(*args, **kwargs)¶

Overloaded function.

UnionWith(self: usdrt.Gf._Gf.Range2f, arg0: usdrt.Gf._Gf.Vec2f) -> usdrt.Gf._Gf.Range2f
UnionWith(self: usdrt.Gf._Gf.Range2f, arg0: usdrt.Gf._Gf.Range2f) -> usdrt.Gf._Gf.Range2f

property max¶

property min¶

static unitSquare() → usdrt.Gf._Gf.Range2f ¶

class usdrt.Gf._Gf.Range3d¶

Contains(*args, **kwargs)¶

Overloaded function.

Contains(self: usdrt.Gf._Gf.Range3d, arg0: usdrt.Gf._Gf.Vec3d) -> bool
Contains(self: usdrt.Gf._Gf.Range3d, arg0: usdrt.Gf._Gf.Range3d) -> bool

GetCorner(self: usdrt.Gf._Gf.Range3d, arg0: int) → usdrt.Gf._Gf.Vec3d ¶

GetDistanceSquared(self: usdrt.Gf._Gf.Range3d, arg0: usdrt.Gf._Gf.Vec3d) → float¶

static GetIntersection(arg0: usdrt.Gf._Gf.Range3d, arg1: usdrt.Gf._Gf.Range3d) → usdrt.Gf._Gf.Range3d ¶

GetMax(self: usdrt.Gf._Gf.Range3d) → usdrt.Gf._Gf.Vec3d ¶

GetMidpoint(self: usdrt.Gf._Gf.Range3d) → usdrt.Gf._Gf.Vec3d ¶

GetMin(self: usdrt.Gf._Gf.Range3d) → usdrt.Gf._Gf.Vec3d ¶

GetOctant(self: usdrt.Gf._Gf.Range3d, arg0: int) → usdrt.Gf._Gf.Range3d ¶

GetSize(self: usdrt.Gf._Gf.Range3d) → usdrt.Gf._Gf.Vec3d ¶

static GetUnion(arg0: usdrt.Gf._Gf.Range3d, arg1: usdrt.Gf._Gf.Range3d) → usdrt.Gf._Gf.Range3d ¶

IntersectWith(self: usdrt.Gf._Gf.Range3d, arg0: usdrt.Gf._Gf.Range3d) → usdrt.Gf._Gf.Range3d ¶

IsEmpty(self: usdrt.Gf._Gf.Range3d) → bool¶

SetEmpty(self: usdrt.Gf._Gf.Range3d) → None¶

SetMax(self: usdrt.Gf._Gf.Range3d, arg0: usdrt.Gf._Gf.Vec3d) → None¶

SetMin(self: usdrt.Gf._Gf.Range3d, arg0: usdrt.Gf._Gf.Vec3d) → None¶

UnionWith(*args, **kwargs)¶

Overloaded function.

UnionWith(self: usdrt.Gf._Gf.Range3d, arg0: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Range3d
UnionWith(self: usdrt.Gf._Gf.Range3d, arg0: usdrt.Gf._Gf.Range3d) -> usdrt.Gf._Gf.Range3d

property max¶

property min¶

static unitCube() → usdrt.Gf._Gf.Range3d ¶

class usdrt.Gf._Gf.Range3f¶

Contains(*args, **kwargs)¶

Overloaded function.

Contains(self: usdrt.Gf._Gf.Range3f, arg0: usdrt.Gf._Gf.Vec3f) -> bool
Contains(self: usdrt.Gf._Gf.Range3f, arg0: usdrt.Gf._Gf.Range3f) -> bool

GetCorner(self: usdrt.Gf._Gf.Range3f, arg0: int) → usdrt.Gf._Gf.Vec3f ¶

GetDistanceSquared(self: usdrt.Gf._Gf.Range3f, arg0: usdrt.Gf._Gf.Vec3f) → float¶

static GetIntersection(arg0: usdrt.Gf._Gf.Range3f, arg1: usdrt.Gf._Gf.Range3f) → usdrt.Gf._Gf.Range3f ¶

GetMax(self: usdrt.Gf._Gf.Range3f) → usdrt.Gf._Gf.Vec3f ¶

GetMidpoint(self: usdrt.Gf._Gf.Range3f) → usdrt.Gf._Gf.Vec3f ¶

GetMin(self: usdrt.Gf._Gf.Range3f) → usdrt.Gf._Gf.Vec3f ¶

GetOctant(self: usdrt.Gf._Gf.Range3f, arg0: int) → usdrt.Gf._Gf.Range3f ¶

GetSize(self: usdrt.Gf._Gf.Range3f) → usdrt.Gf._Gf.Vec3f ¶

static GetUnion(arg0: usdrt.Gf._Gf.Range3f, arg1: usdrt.Gf._Gf.Range3f) → usdrt.Gf._Gf.Range3f ¶

IntersectWith(self: usdrt.Gf._Gf.Range3f, arg0: usdrt.Gf._Gf.Range3f) → usdrt.Gf._Gf.Range3f ¶

IsEmpty(self: usdrt.Gf._Gf.Range3f) → bool¶

SetEmpty(self: usdrt.Gf._Gf.Range3f) → None¶

SetMax(self: usdrt.Gf._Gf.Range3f, arg0: usdrt.Gf._Gf.Vec3f) → None¶

SetMin(self: usdrt.Gf._Gf.Range3f, arg0: usdrt.Gf._Gf.Vec3f) → None¶

UnionWith(*args, **kwargs)¶

Overloaded function.

UnionWith(self: usdrt.Gf._Gf.Range3f, arg0: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Range3f
UnionWith(self: usdrt.Gf._Gf.Range3f, arg0: usdrt.Gf._Gf.Range3f) -> usdrt.Gf._Gf.Range3f

property max¶

property min¶

static unitCube() → usdrt.Gf._Gf.Range3f ¶

class usdrt.Gf._Gf.Rect2i¶

Contains(self: usdrt.Gf._Gf.Rect2i, arg0: usdrt.Gf._Gf.Vec2i) → bool¶

GetArea(self: usdrt.Gf._Gf.Rect2i) → int¶

GetCenter(self: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Vec2i ¶

GetHeight(self: usdrt.Gf._Gf.Rect2i) → int¶

GetIntersection(self: usdrt.Gf._Gf.Rect2i, arg0: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Rect2i ¶

GetMax(self: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Vec2i ¶

GetMaxX(self: usdrt.Gf._Gf.Rect2i) → int¶

GetMaxY(self: usdrt.Gf._Gf.Rect2i) → int¶

GetMin(self: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Vec2i ¶

GetMinX(self: usdrt.Gf._Gf.Rect2i) → int¶

GetMinY(self: usdrt.Gf._Gf.Rect2i) → int¶

GetNormalized(self: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Rect2i ¶

GetSize(self: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Vec2i ¶

GetUnion(self: usdrt.Gf._Gf.Rect2i, arg0: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Rect2i ¶

GetWidth(self: usdrt.Gf._Gf.Rect2i) → int¶

Intersect(self: usdrt.Gf._Gf.Rect2i, arg0: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Rect2i ¶

IsEmpty(self: usdrt.Gf._Gf.Rect2i) → bool¶

IsNull(self: usdrt.Gf._Gf.Rect2i) → bool¶

IsValid(self: usdrt.Gf._Gf.Rect2i) → bool¶

SetMax(self: usdrt.Gf._Gf.Rect2i, arg0: usdrt.Gf._Gf.Vec2i) → None¶

SetMaxX(self: usdrt.Gf._Gf.Rect2i, arg0: int) → None¶

SetMaxY(self: usdrt.Gf._Gf.Rect2i, arg0: int) → None¶

SetMin(self: usdrt.Gf._Gf.Rect2i, arg0: usdrt.Gf._Gf.Vec2i) → None¶

SetMinX(self: usdrt.Gf._Gf.Rect2i, arg0: int) → None¶

SetMinY(self: usdrt.Gf._Gf.Rect2i, arg0: int) → None¶

Translate(self: usdrt.Gf._Gf.Rect2i, arg0: usdrt.Gf._Gf.Vec2i) → None¶

Union(self: usdrt.Gf._Gf.Rect2i, arg0: usdrt.Gf._Gf.Rect2i) → usdrt.Gf._Gf.Rect2i ¶

property area¶

property center¶

property height¶

property max¶

property maxX¶

property maxY¶

property min¶

property minX¶

property minY¶

property size¶

property width¶

usdrt.Gf._Gf.Slerp(*args, **kwargs)¶

Overloaded function.

Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec2f, v2: usdrt.Gf._Gf.Vec2f) -> usdrt.Gf._Gf.Vec2f
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec2d, v2: usdrt.Gf._Gf.Vec2d) -> usdrt.Gf._Gf.Vec2d
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec2i, v2: usdrt.Gf._Gf.Vec2i) -> usdrt.Gf._Gf.Vec2i
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec2h, v2: usdrt.Gf._Gf.Vec2h) -> usdrt.Gf._Gf.Vec2h
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec3f, v2: usdrt.Gf._Gf.Vec3f) -> usdrt.Gf._Gf.Vec3f
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec3d, v2: usdrt.Gf._Gf.Vec3d) -> usdrt.Gf._Gf.Vec3d
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec3i, v2: usdrt.Gf._Gf.Vec3i) -> usdrt.Gf._Gf.Vec3i
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec3h, v2: usdrt.Gf._Gf.Vec3h) -> usdrt.Gf._Gf.Vec3h
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec4f, v2: usdrt.Gf._Gf.Vec4f) -> usdrt.Gf._Gf.Vec4f
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec4d, v2: usdrt.Gf._Gf.Vec4d) -> usdrt.Gf._Gf.Vec4d
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec4i, v2: usdrt.Gf._Gf.Vec4i) -> usdrt.Gf._Gf.Vec4i
Slerp(alpha: float, v1: usdrt.Gf._Gf.Vec4h, v2: usdrt.Gf._Gf.Vec4h) -> usdrt.Gf._Gf.Vec4h
Slerp(arg0: float, arg1: usdrt.Gf._Gf.Quatd, arg2: usdrt.Gf._Gf.Quatd) -> usdrt.Gf._Gf.Quatd
Slerp(arg0: float, arg1: usdrt.Gf._Gf.Quatf, arg2: usdrt.Gf._Gf.Quatf) -> usdrt.Gf._Gf.Quatf
Slerp(arg0: float, arg1: usdrt.Gf._Gf.Quath, arg2: usdrt.Gf._Gf.Quath) -> usdrt.Gf._Gf.Quath

class usdrt.Gf._Gf.Vec2d¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec2d ¶

GetComplement(self: usdrt.Gf._Gf.Vec2d, arg0: usdrt.Gf._Gf.Vec2d) → usdrt.Gf._Gf.Vec2d ¶

GetDot(self: usdrt.Gf._Gf.Vec2d, arg0: usdrt.Gf._Gf.Vec2d) → float¶

GetLength(self: usdrt.Gf._Gf.Vec2d) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec2d) → usdrt.Gf._Gf.Vec2d ¶

GetProjection(self: usdrt.Gf._Gf.Vec2d, arg0: usdrt.Gf._Gf.Vec2d) → usdrt.Gf._Gf.Vec2d ¶

Normalize(self: usdrt.Gf._Gf.Vec2d) → float¶

static XAxis() → usdrt.Gf._Gf.Vec2d ¶

static YAxis() → usdrt.Gf._Gf.Vec2d ¶

dimension = 2¶

class usdrt.Gf._Gf.Vec2f¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec2f ¶

GetComplement(self: usdrt.Gf._Gf.Vec2f, arg0: usdrt.Gf._Gf.Vec2f) → usdrt.Gf._Gf.Vec2f ¶

GetDot(self: usdrt.Gf._Gf.Vec2f, arg0: usdrt.Gf._Gf.Vec2f) → float¶

GetLength(self: usdrt.Gf._Gf.Vec2f) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec2f) → usdrt.Gf._Gf.Vec2f ¶

GetProjection(self: usdrt.Gf._Gf.Vec2f, arg0: usdrt.Gf._Gf.Vec2f) → usdrt.Gf._Gf.Vec2f ¶

Normalize(self: usdrt.Gf._Gf.Vec2f) → float¶

static XAxis() → usdrt.Gf._Gf.Vec2f ¶

static YAxis() → usdrt.Gf._Gf.Vec2f ¶

dimension = 2¶

class usdrt.Gf._Gf.Vec2h¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec2h ¶

GetComplement(self: usdrt.Gf._Gf.Vec2h, arg0: usdrt.Gf._Gf.Vec2h) → usdrt.Gf._Gf.Vec2h ¶

GetDot(self: usdrt.Gf._Gf.Vec2h, arg0: usdrt.Gf._Gf.Vec2h) → GfHalf¶

GetLength(self: usdrt.Gf._Gf.Vec2h) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec2h) → usdrt.Gf._Gf.Vec2h ¶

GetProjection(self: usdrt.Gf._Gf.Vec2h, arg0: usdrt.Gf._Gf.Vec2h) → usdrt.Gf._Gf.Vec2h ¶

Normalize(self: usdrt.Gf._Gf.Vec2h) → float¶

static XAxis() → usdrt.Gf._Gf.Vec2h ¶

static YAxis() → usdrt.Gf._Gf.Vec2h ¶

dimension = 2¶

class usdrt.Gf._Gf.Vec2i¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec2i ¶

GetComplement(self: usdrt.Gf._Gf.Vec2i, arg0: usdrt.Gf._Gf.Vec2i) → usdrt.Gf._Gf.Vec2i ¶

GetDot(self: usdrt.Gf._Gf.Vec2i, arg0: usdrt.Gf._Gf.Vec2i) → int¶

GetLength(self: usdrt.Gf._Gf.Vec2i) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec2i) → usdrt.Gf._Gf.Vec2i ¶

GetProjection(self: usdrt.Gf._Gf.Vec2i, arg0: usdrt.Gf._Gf.Vec2i) → usdrt.Gf._Gf.Vec2i ¶

Normalize(self: usdrt.Gf._Gf.Vec2i) → float¶

static XAxis() → usdrt.Gf._Gf.Vec2i ¶

static YAxis() → usdrt.Gf._Gf.Vec2i ¶

dimension = 2¶

class usdrt.Gf._Gf.Vec3d¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec3d ¶

BuildOrthonormalFrame(self: usdrt.Gf._Gf.Vec3d, eps: float = 1e-10) → tuple¶

GetComplement(self: usdrt.Gf._Gf.Vec3d, arg0: usdrt.Gf._Gf.Vec3d) → usdrt.Gf._Gf.Vec3d ¶

GetCross(self: usdrt.Gf._Gf.Vec3d, arg0: usdrt.Gf._Gf.Vec3d) → usdrt.Gf._Gf.Vec3d ¶

GetDot(self: usdrt.Gf._Gf.Vec3d, arg0: usdrt.Gf._Gf.Vec3d) → float¶

GetLength(self: usdrt.Gf._Gf.Vec3d) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec3d) → usdrt.Gf._Gf.Vec3d ¶

GetProjection(self: usdrt.Gf._Gf.Vec3d, arg0: usdrt.Gf._Gf.Vec3d) → usdrt.Gf._Gf.Vec3d ¶

Normalize(self: usdrt.Gf._Gf.Vec3d) → float¶

static OrthogonalizeBasis(v1: usdrt.Gf._Gf.Vec3d, v2: usdrt.Gf._Gf.Vec3d, v3: usdrt.Gf._Gf.Vec3d, normalize: bool = True) → bool¶

static XAxis() → usdrt.Gf._Gf.Vec3d ¶

static YAxis() → usdrt.Gf._Gf.Vec3d ¶

static ZAxis() → usdrt.Gf._Gf.Vec3d ¶

dimension = 3¶

class usdrt.Gf._Gf.Vec3f¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec3f ¶

BuildOrthonormalFrame(self: usdrt.Gf._Gf.Vec3f, eps: float = 1e-10) → tuple¶

GetComplement(self: usdrt.Gf._Gf.Vec3f, arg0: usdrt.Gf._Gf.Vec3f) → usdrt.Gf._Gf.Vec3f ¶

GetCross(self: usdrt.Gf._Gf.Vec3f, arg0: usdrt.Gf._Gf.Vec3f) → usdrt.Gf._Gf.Vec3f ¶

GetDot(self: usdrt.Gf._Gf.Vec3f, arg0: usdrt.Gf._Gf.Vec3f) → float¶

GetLength(self: usdrt.Gf._Gf.Vec3f) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec3f) → usdrt.Gf._Gf.Vec3f ¶

GetProjection(self: usdrt.Gf._Gf.Vec3f, arg0: usdrt.Gf._Gf.Vec3f) → usdrt.Gf._Gf.Vec3f ¶

Normalize(self: usdrt.Gf._Gf.Vec3f) → float¶

static OrthogonalizeBasis(v1: usdrt.Gf._Gf.Vec3f, v2: usdrt.Gf._Gf.Vec3f, v3: usdrt.Gf._Gf.Vec3f, normalize: bool = True) → bool¶

static XAxis() → usdrt.Gf._Gf.Vec3f ¶

static YAxis() → usdrt.Gf._Gf.Vec3f ¶

static ZAxis() → usdrt.Gf._Gf.Vec3f ¶

dimension = 3¶

class usdrt.Gf._Gf.Vec3h¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec3h ¶

BuildOrthonormalFrame(self: usdrt.Gf._Gf.Vec3h, eps: float = 1e-10) → tuple¶

GetComplement(self: usdrt.Gf._Gf.Vec3h, arg0: usdrt.Gf._Gf.Vec3h) → usdrt.Gf._Gf.Vec3h ¶

GetCross(self: usdrt.Gf._Gf.Vec3h, arg0: usdrt.Gf._Gf.Vec3h) → usdrt.Gf._Gf.Vec3h ¶

GetDot(self: usdrt.Gf._Gf.Vec3h, arg0: usdrt.Gf._Gf.Vec3h) → GfHalf¶

GetLength(self: usdrt.Gf._Gf.Vec3h) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec3h) → usdrt.Gf._Gf.Vec3h ¶

GetProjection(self: usdrt.Gf._Gf.Vec3h, arg0: usdrt.Gf._Gf.Vec3h) → usdrt.Gf._Gf.Vec3h ¶

Normalize(self: usdrt.Gf._Gf.Vec3h) → float¶

static OrthogonalizeBasis(v1: usdrt.Gf._Gf.Vec3h, v2: usdrt.Gf._Gf.Vec3h, v3: usdrt.Gf._Gf.Vec3h, normalize: bool = True) → bool¶

static XAxis() → usdrt.Gf._Gf.Vec3h ¶

static YAxis() → usdrt.Gf._Gf.Vec3h ¶

static ZAxis() → usdrt.Gf._Gf.Vec3h ¶

dimension = 3¶

class usdrt.Gf._Gf.Vec3i¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec3i ¶

BuildOrthonormalFrame(self: usdrt.Gf._Gf.Vec3i, eps: float = 1e-10) → tuple¶

GetComplement(self: usdrt.Gf._Gf.Vec3i, arg0: usdrt.Gf._Gf.Vec3i) → usdrt.Gf._Gf.Vec3i ¶

GetCross(self: usdrt.Gf._Gf.Vec3i, arg0: usdrt.Gf._Gf.Vec3i) → usdrt.Gf._Gf.Vec3i ¶

GetDot(self: usdrt.Gf._Gf.Vec3i, arg0: usdrt.Gf._Gf.Vec3i) → int¶

GetLength(self: usdrt.Gf._Gf.Vec3i) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec3i) → usdrt.Gf._Gf.Vec3i ¶

GetProjection(self: usdrt.Gf._Gf.Vec3i, arg0: usdrt.Gf._Gf.Vec3i) → usdrt.Gf._Gf.Vec3i ¶

Normalize(self: usdrt.Gf._Gf.Vec3i) → float¶

static OrthogonalizeBasis(v1: usdrt.Gf._Gf.Vec3i, v2: usdrt.Gf._Gf.Vec3i, v3: usdrt.Gf._Gf.Vec3i, normalize: bool = True) → bool¶

static XAxis() → usdrt.Gf._Gf.Vec3i ¶

static YAxis() → usdrt.Gf._Gf.Vec3i ¶

static ZAxis() → usdrt.Gf._Gf.Vec3i ¶

dimension = 3¶

class usdrt.Gf._Gf.Vec4d¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec4d ¶

GetComplement(self: usdrt.Gf._Gf.Vec4d, arg0: usdrt.Gf._Gf.Vec4d) → usdrt.Gf._Gf.Vec4d ¶

GetDot(self: usdrt.Gf._Gf.Vec4d, arg0: usdrt.Gf._Gf.Vec4d) → float¶

GetLength(self: usdrt.Gf._Gf.Vec4d) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec4d) → usdrt.Gf._Gf.Vec4d ¶

GetProjection(self: usdrt.Gf._Gf.Vec4d, arg0: usdrt.Gf._Gf.Vec4d) → usdrt.Gf._Gf.Vec4d ¶

Normalize(self: usdrt.Gf._Gf.Vec4d) → float¶

static WAxis() → usdrt.Gf._Gf.Vec4d ¶

static XAxis() → usdrt.Gf._Gf.Vec4d ¶

static YAxis() → usdrt.Gf._Gf.Vec4d ¶

static ZAxis() → usdrt.Gf._Gf.Vec4d ¶

dimension = 4¶

class usdrt.Gf._Gf.Vec4f¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec4f ¶

GetComplement(self: usdrt.Gf._Gf.Vec4f, arg0: usdrt.Gf._Gf.Vec4f) → usdrt.Gf._Gf.Vec4f ¶

GetDot(self: usdrt.Gf._Gf.Vec4f, arg0: usdrt.Gf._Gf.Vec4f) → float¶

GetLength(self: usdrt.Gf._Gf.Vec4f) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec4f) → usdrt.Gf._Gf.Vec4f ¶

GetProjection(self: usdrt.Gf._Gf.Vec4f, arg0: usdrt.Gf._Gf.Vec4f) → usdrt.Gf._Gf.Vec4f ¶

Normalize(self: usdrt.Gf._Gf.Vec4f) → float¶

static WAxis() → usdrt.Gf._Gf.Vec4f ¶

static XAxis() → usdrt.Gf._Gf.Vec4f ¶

static YAxis() → usdrt.Gf._Gf.Vec4f ¶

static ZAxis() → usdrt.Gf._Gf.Vec4f ¶

dimension = 4¶

class usdrt.Gf._Gf.Vec4h¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec4h ¶

GetComplement(self: usdrt.Gf._Gf.Vec4h, arg0: usdrt.Gf._Gf.Vec4h) → usdrt.Gf._Gf.Vec4h ¶

GetDot(self: usdrt.Gf._Gf.Vec4h, arg0: usdrt.Gf._Gf.Vec4h) → GfHalf¶

GetLength(self: usdrt.Gf._Gf.Vec4h) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec4h) → usdrt.Gf._Gf.Vec4h ¶

GetProjection(self: usdrt.Gf._Gf.Vec4h, arg0: usdrt.Gf._Gf.Vec4h) → usdrt.Gf._Gf.Vec4h ¶

Normalize(self: usdrt.Gf._Gf.Vec4h) → float¶

static WAxis() → usdrt.Gf._Gf.Vec4h ¶

static XAxis() → usdrt.Gf._Gf.Vec4h ¶

static YAxis() → usdrt.Gf._Gf.Vec4h ¶

static ZAxis() → usdrt.Gf._Gf.Vec4h ¶

dimension = 4¶

class usdrt.Gf._Gf.Vec4i¶

static Axis(arg0: int) → usdrt.Gf._Gf.Vec4i ¶

GetComplement(self: usdrt.Gf._Gf.Vec4i, arg0: usdrt.Gf._Gf.Vec4i) → usdrt.Gf._Gf.Vec4i ¶

GetDot(self: usdrt.Gf._Gf.Vec4i, arg0: usdrt.Gf._Gf.Vec4i) → int¶

GetLength(self: usdrt.Gf._Gf.Vec4i) → float¶

GetNormalized(self: usdrt.Gf._Gf.Vec4i) → usdrt.Gf._Gf.Vec4i ¶

GetProjection(self: usdrt.Gf._Gf.Vec4i, arg0: usdrt.Gf._Gf.Vec4i) → usdrt.Gf._Gf.Vec4i ¶

Normalize(self: usdrt.Gf._Gf.Vec4i) → float¶

static WAxis() → usdrt.Gf._Gf.Vec4i ¶

static XAxis() → usdrt.Gf._Gf.Vec4i ¶

static YAxis() → usdrt.Gf._Gf.Vec4i ¶

static ZAxis() → usdrt.Gf._Gf.Vec4i ¶

dimension = 4¶

usdrt.Vt module¶

class usdrt.Vt._Vt.BoolArray¶

DetachFromSource(self: usdrt.Vt._Vt.BoolArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.BoolArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.BoolArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.BoolArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.BoolArray) → bool¶

class usdrt.Vt._Vt.CharArray¶

DetachFromSource(self: usdrt.Vt._Vt.CharArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.CharArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.CharArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.CharArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.CharArray) → bool¶

class usdrt.Vt._Vt.DoubleArray¶

DetachFromSource(self: usdrt.Vt._Vt.DoubleArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.DoubleArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.DoubleArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.DoubleArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.DoubleArray) → bool¶

class usdrt.Vt._Vt.FloatArray¶

DetachFromSource(self: usdrt.Vt._Vt.FloatArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.FloatArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.FloatArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.FloatArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.FloatArray) → bool¶

class usdrt.Vt._Vt.HalfArray¶

DetachFromSource(self: usdrt.Vt._Vt.HalfArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.HalfArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.HalfArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.HalfArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.HalfArray) → bool¶

class usdrt.Vt._Vt.Int64Array¶

DetachFromSource(self: usdrt.Vt._Vt.Int64Array) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Int64Array) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Int64Array) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Int64Array) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Int64Array) → bool¶

class usdrt.Vt._Vt.IntArray¶

DetachFromSource(self: usdrt.Vt._Vt.IntArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.IntArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.IntArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.IntArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.IntArray) → bool¶

class usdrt.Vt._Vt.Matrix3dArray¶

DetachFromSource(self: usdrt.Vt._Vt.Matrix3dArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Matrix3dArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Matrix3dArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Matrix3dArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Matrix3dArray) → bool¶

class usdrt.Vt._Vt.Matrix3fArray¶

DetachFromSource(self: usdrt.Vt._Vt.Matrix3fArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Matrix3fArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Matrix3fArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Matrix3fArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Matrix3fArray) → bool¶

class usdrt.Vt._Vt.Matrix4dArray¶

DetachFromSource(self: usdrt.Vt._Vt.Matrix4dArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Matrix4dArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Matrix4dArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Matrix4dArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Matrix4dArray) → bool¶

class usdrt.Vt._Vt.Matrix4fArray¶

DetachFromSource(self: usdrt.Vt._Vt.Matrix4fArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Matrix4fArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Matrix4fArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Matrix4fArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Matrix4fArray) → bool¶

class usdrt.Vt._Vt.QuatdArray¶

DetachFromSource(self: usdrt.Vt._Vt.QuatdArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.QuatdArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.QuatdArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.QuatdArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.QuatdArray) → bool¶

class usdrt.Vt._Vt.QuatfArray¶

DetachFromSource(self: usdrt.Vt._Vt.QuatfArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.QuatfArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.QuatfArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.QuatfArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.QuatfArray) → bool¶

class usdrt.Vt._Vt.QuathArray¶

DetachFromSource(self: usdrt.Vt._Vt.QuathArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.QuathArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.QuathArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.QuathArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.QuathArray) → bool¶

class usdrt.Vt._Vt.ShortArray¶

DetachFromSource(self: usdrt.Vt._Vt.ShortArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.ShortArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.ShortArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.ShortArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.ShortArray) → bool¶

class usdrt.Vt._Vt.StringArray¶

DetachFromSource(self: usdrt.Vt._Vt.StringArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.StringArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.StringArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.StringArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.StringArray) → bool¶

class usdrt.Vt._Vt.TokenArray¶

DetachFromSource(self: usdrt.Vt._Vt.TokenArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.TokenArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.TokenArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.TokenArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.TokenArray) → bool¶

class usdrt.Vt._Vt.UCharArray¶

DetachFromSource(self: usdrt.Vt._Vt.UCharArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.UCharArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.UCharArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.UCharArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.UCharArray) → bool¶

class usdrt.Vt._Vt.UInt64Array¶

DetachFromSource(self: usdrt.Vt._Vt.UInt64Array) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.UInt64Array) → bool¶

IsFabricData(self: usdrt.Vt._Vt.UInt64Array) → bool¶

IsOwnData(self: usdrt.Vt._Vt.UInt64Array) → bool¶

IsPythonData(self: usdrt.Vt._Vt.UInt64Array) → bool¶

class usdrt.Vt._Vt.UIntArray¶

DetachFromSource(self: usdrt.Vt._Vt.UIntArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.UIntArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.UIntArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.UIntArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.UIntArray) → bool¶

class usdrt.Vt._Vt.UShortArray¶

DetachFromSource(self: usdrt.Vt._Vt.UShortArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.UShortArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.UShortArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.UShortArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.UShortArray) → bool¶

class usdrt.Vt._Vt.Vec2dArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec2dArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec2dArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec2dArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec2dArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec2dArray) → bool¶

class usdrt.Vt._Vt.Vec2fArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec2fArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec2fArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec2fArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec2fArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec2fArray) → bool¶

class usdrt.Vt._Vt.Vec2hArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec2hArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec2hArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec2hArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec2hArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec2hArray) → bool¶

class usdrt.Vt._Vt.Vec2iArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec2iArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec2iArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec2iArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec2iArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec2iArray) → bool¶

class usdrt.Vt._Vt.Vec3dArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec3dArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec3dArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec3dArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec3dArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec3dArray) → bool¶

class usdrt.Vt._Vt.Vec3fArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec3fArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec3fArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec3fArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec3fArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec3fArray) → bool¶

class usdrt.Vt._Vt.Vec3hArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec3hArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec3hArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec3hArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec3hArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec3hArray) → bool¶

class usdrt.Vt._Vt.Vec3iArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec3iArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec3iArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec3iArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec3iArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec3iArray) → bool¶

class usdrt.Vt._Vt.Vec4dArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec4dArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec4dArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec4dArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec4dArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec4dArray) → bool¶

class usdrt.Vt._Vt.Vec4fArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec4fArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec4fArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec4fArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec4fArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec4fArray) → bool¶

class usdrt.Vt._Vt.Vec4hArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec4hArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec4hArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec4hArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec4hArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec4hArray) → bool¶

class usdrt.Vt._Vt.Vec4iArray¶

DetachFromSource(self: usdrt.Vt._Vt.Vec4iArray) → None¶

HasFabricGpuData(self: usdrt.Vt._Vt.Vec4iArray) → bool¶

IsFabricData(self: usdrt.Vt._Vt.Vec4iArray) → bool¶

IsOwnData(self: usdrt.Vt._Vt.Vec4iArray) → bool¶

IsPythonData(self: usdrt.Vt._Vt.Vec4iArray) → bool¶

usdrt.Sdf module¶

class usdrt.Sdf._Sdf.AncestorsRange¶

GetPath(self: usdrt.Sdf._Sdf.AncestorsRange) → usdrt.Sdf._Sdf.Path ¶

class usdrt.Sdf._Sdf.Path¶

GetAncestorsRange(self: usdrt.Sdf._Sdf.Path) → usdrt::SdfPathAncestorsRange¶

GetPrefixes(self: usdrt.Sdf._Sdf.Path) → List[usdrt.Sdf._Sdf.Path]¶

GetString(self: usdrt.Sdf._Sdf.Path) → str¶

GetText(self: usdrt.Sdf._Sdf.Path) → str¶

GetToken(self: usdrt.Sdf._Sdf.Path) → TfToken¶

IsEmpty(self: usdrt.Sdf._Sdf.Path) → bool¶

class usdrt.Sdf._Sdf.ValueTypeName¶

GetAsString(self: usdrt.Sdf._Sdf.ValueTypeName) → str¶

GetAsToken(self: usdrt.Sdf._Sdf.ValueTypeName) → TfToken¶

GetAsTypeC(self: usdrt.Sdf._Sdf.ValueTypeName) → carb::flatcache::TypeC¶

property arrayType¶

property isArray¶

property isScalar¶

property scalarType¶

class usdrt.Sdf._Sdf.ValueTypeNames¶

Asset = Sdf.ValueTypeName('asset')¶

AssetArray = Sdf.ValueTypeName('asset[]')¶

Bool = Sdf.ValueTypeName('bool')¶

BoolArray = Sdf.ValueTypeName('bool[]')¶

Color3d = Sdf.ValueTypeName('double3 (color)')¶

Color3dArray = Sdf.ValueTypeName('double3[] (color)')¶

Color3f = Sdf.ValueTypeName('float3 (color)')¶

Color3fArray = Sdf.ValueTypeName('float3[] (color)')¶

Color3h = Sdf.ValueTypeName('half3 (color)')¶

Color3hArray = Sdf.ValueTypeName('half3[] (color)')¶

Color4d = Sdf.ValueTypeName('double4 (color)')¶

Color4dArray = Sdf.ValueTypeName('double4[] (color)')¶

Color4f = Sdf.ValueTypeName('float4 (color)')¶

Color4fArray = Sdf.ValueTypeName('float4[] (color)')¶

Color4h = Sdf.ValueTypeName('half4 (color)')¶

Color4hArray = Sdf.ValueTypeName('half4[] (color)')¶

Double = Sdf.ValueTypeName('double')¶

Double2 = Sdf.ValueTypeName('double2')¶

Double2Array = Sdf.ValueTypeName('double2[]')¶

Double3 = Sdf.ValueTypeName('double3')¶

Double3Array = Sdf.ValueTypeName('double3[]')¶

Double4 = Sdf.ValueTypeName('double4')¶

Double4Array = Sdf.ValueTypeName('double4[]')¶

DoubleArray = Sdf.ValueTypeName('double[]')¶

Float = Sdf.ValueTypeName('float')¶

Float2 = Sdf.ValueTypeName('float2')¶

Float2Array = Sdf.ValueTypeName('float2[]')¶

Float3 = Sdf.ValueTypeName('float3')¶

Float3Array = Sdf.ValueTypeName('float3[]')¶

Float4 = Sdf.ValueTypeName('float4')¶

Float4Array = Sdf.ValueTypeName('float4[]')¶

FloatArray = Sdf.ValueTypeName('float[]')¶

Frame4d = Sdf.ValueTypeName('double16 (frame)')¶

Frame4dArray = Sdf.ValueTypeName('double16[] (frame)')¶

Half = Sdf.ValueTypeName('half')¶

Half2 = Sdf.ValueTypeName('half2')¶

Half2Array = Sdf.ValueTypeName('half2[]')¶

Half3 = Sdf.ValueTypeName('half3')¶

Half3Array = Sdf.ValueTypeName('half3[]')¶

Half4 = Sdf.ValueTypeName('half4')¶

Half4Array = Sdf.ValueTypeName('half4[]')¶

HalfArray = Sdf.ValueTypeName('half[]')¶

Int = Sdf.ValueTypeName('int')¶

Int2 = Sdf.ValueTypeName('int2')¶

Int2Array = Sdf.ValueTypeName('int2[]')¶

Int3 = Sdf.ValueTypeName('int3')¶

Int3Array = Sdf.ValueTypeName('int3[]')¶

Int4 = Sdf.ValueTypeName('int4')¶

Int4Array = Sdf.ValueTypeName('int4[]')¶

Int64 = Sdf.ValueTypeName('int64')¶

Int64Array = Sdf.ValueTypeName('int64[]')¶

IntArray = Sdf.ValueTypeName('int[]')¶

Matrix2d = Sdf.ValueTypeName('double4 (matrix)')¶

Matrix2dArray = Sdf.ValueTypeName('double4[] (matrix)')¶

Matrix3d = Sdf.ValueTypeName('double9 (matrix)')¶

Matrix3dArray = Sdf.ValueTypeName('double9[] (matrix)')¶

Matrix4d = Sdf.ValueTypeName('double16 (matrix)')¶

Matrix4dArray = Sdf.ValueTypeName('double16[] (matrix)')¶

Normal3d = Sdf.ValueTypeName('double3 (normal)')¶

Normal3dArray = Sdf.ValueTypeName('double3[] (normal)')¶

Normal3f = Sdf.ValueTypeName('float3 (normal)')¶

Normal3fArray = Sdf.ValueTypeName('float3[] (normal)')¶

Normal3h = Sdf.ValueTypeName('half3 (normal)')¶

Normal3hArray = Sdf.ValueTypeName('half3[] (normal)')¶

Point3d = Sdf.ValueTypeName('double3 (position)')¶

Point3dArray = Sdf.ValueTypeName('double3[] (position)')¶

Point3f = Sdf.ValueTypeName('float3 (position)')¶

Point3fArray = Sdf.ValueTypeName('float3[] (position)')¶

Point3h = Sdf.ValueTypeName('half3 (position)')¶

Point3hArray = Sdf.ValueTypeName('half3[] (position)')¶

PrimTypeTag = Sdf.ValueTypeName('tag (primTypeName)')¶

Quatd = Sdf.ValueTypeName('double4 (quaternion)')¶

QuatdArray = Sdf.ValueTypeName('double4[] (quaternion)')¶

Quatf = Sdf.ValueTypeName('float4 (quaternion)')¶

QuatfArray = Sdf.ValueTypeName('float4[] (quaternion)')¶

Quath = Sdf.ValueTypeName('half4 (quaternion)')¶

QuathArray = Sdf.ValueTypeName('half4[] (quaternion)')¶

Range3d = Sdf.ValueTypeName('double6')¶

String = Sdf.ValueTypeName('uchar[] (text)')¶

StringArray = Sdf.ValueTypeName('uchar[][] (text)')¶

Tag = Sdf.ValueTypeName('tag')¶

TexCoord2d = Sdf.ValueTypeName('double2 (texCoord)')¶

TexCoord2dArray = Sdf.ValueTypeName('double2[] (texCoord)')¶

TexCoord2f = Sdf.ValueTypeName('float2 (texCoord)')¶

TexCoord2fArray = Sdf.ValueTypeName('float2[] (texCoord)')¶

TexCoord2h = Sdf.ValueTypeName('half2 (texCoord)')¶

TexCoord2hArray = Sdf.ValueTypeName('half2[] (texCoord)')¶

TexCoord3d = Sdf.ValueTypeName('double3 (texCoord)')¶

TexCoord3dArray = Sdf.ValueTypeName('double3[] (texCoord)')¶

TexCoord3f = Sdf.ValueTypeName('float3 (texCoord)')¶

TexCoord3fArray = Sdf.ValueTypeName('float3[] (texCoord)')¶

TexCoord3h = Sdf.ValueTypeName('half3 (texCoord)')¶

TexCoord3hArray = Sdf.ValueTypeName('half3[] (texCoord)')¶

TimeCode = Sdf.ValueTypeName('double (timecode)')¶

TimeCodeArray = Sdf.ValueTypeName('double[] (timecode)')¶

Token = Sdf.ValueTypeName('token')¶

TokenArray = Sdf.ValueTypeName('token[]')¶

UChar = Sdf.ValueTypeName('uchar')¶

UCharArray = Sdf.ValueTypeName('uchar[]')¶

UInt = Sdf.ValueTypeName('uint')¶

UInt64 = Sdf.ValueTypeName('uint64')¶

UInt64Array = Sdf.ValueTypeName('uint64[]')¶

UIntArray = Sdf.ValueTypeName('uint[]')¶

Vector3d = Sdf.ValueTypeName('double3 (vector)')¶

Vector3dArray = Sdf.ValueTypeName('double3[] (vector)')¶

Vector3f = Sdf.ValueTypeName('float3 (vector)')¶

Vector3fArray = Sdf.ValueTypeName('float3[] (vector)')¶

Vector3h = Sdf.ValueTypeName('half3 (vector)')¶

Vector3hArray = Sdf.ValueTypeName('half3[] (vector)')¶

usdrt.Usd module¶

class usdrt.Usd._Usd.Attribute¶

Get(self: usdrt.Usd._Usd.Attribute, time: float = 0) → object¶

GetBaseName(self: usdrt.Usd._Usd.Attribute) → TfToken¶

GetName(self: usdrt.Usd._Usd.Attribute) → TfToken¶

GetNamespace(self: usdrt.Usd._Usd.Attribute) → TfToken¶

GetPath(self: usdrt.Usd._Usd.Attribute) → usdrt.Sdf._Sdf.Path ¶

GetPrim(self: usdrt.Usd._Usd.Attribute) → usdrt.Usd._Usd.Prim ¶

GetPrimPath(self: usdrt.Usd._Usd.Attribute) → usdrt.Sdf._Sdf.Path ¶

GetStage(self: usdrt.Usd._Usd.Attribute) → usdrt.Usd._Usd.Stage ¶

GetTypeName(self: usdrt.Usd._Usd.Attribute) → usdrt.Sdf._Sdf.ValueTypeName ¶

HasAuthoredValue(self: usdrt.Usd._Usd.Attribute) → bool¶

HasValue(self: usdrt.Usd._Usd.Attribute) → bool¶

IsValid(self: usdrt.Usd._Usd.Attribute) → bool¶

Set(self: usdrt.Usd._Usd.Attribute, value: object, time: float = 0) → bool¶

SplitName(self: usdrt.Usd._Usd.Attribute) → List[str]¶

class usdrt.Usd._Usd.ListPosition¶

Members:

ListPositionFrontOfPrependList

ListPositionBackOfPrependList

ListPositionFrontOfAppendList

ListPositionBackOfAppendList

ListPositionBackOfAppendList = ListPosition.ListPositionBackOfAppendList¶

ListPositionBackOfPrependList = ListPosition.ListPositionBackOfPrependList¶

ListPositionFrontOfAppendList = ListPosition.ListPositionFrontOfAppendList¶

ListPositionFrontOfPrependList = ListPosition.ListPositionFrontOfPrependList¶

property name¶

handle) -> str

Type: (self

class usdrt.Usd._Usd.Prim¶

ClearTypeName(self: usdrt.Usd._Usd.Prim) → bool¶

CreateAttribute(self: usdrt.Usd._Usd.Prim, name: TfToken, typeName: usdrt.Sdf._Sdf.ValueTypeName, custom: bool) → usdrt::UsdAttribute¶

CreateRelationship(self: usdrt.Usd._Usd.Prim, relName: TfToken, custom: bool = True) → usdrt::UsdRelationship¶

GetAttribute(self: usdrt.Usd._Usd.Prim, name: TfToken) → usdrt::UsdAttribute¶

GetAttributes(self: usdrt.Usd._Usd.Prim) → List[usdrt::UsdAttribute]¶

GetAuthoredAttributes(self: usdrt.Usd._Usd.Prim) → List[usdrt::UsdAttribute]¶

GetAuthoredRelationships(self: usdrt.Usd._Usd.Prim) → List[usdrt::UsdRelationship]¶

GetChild(self: usdrt.Usd._Usd.Prim, name: TfToken) → usdrt.Usd._Usd.Prim ¶

GetChildren(self: usdrt.Usd._Usd.Prim) → List[usdrt.Usd._Usd.Prim]¶

GetName(self: usdrt.Usd._Usd.Prim) → TfToken¶

GetNextSibling(self: usdrt.Usd._Usd.Prim) → usdrt.Usd._Usd.Prim ¶

GetParent(self: usdrt.Usd._Usd.Prim) → usdrt.Usd._Usd.Prim ¶

GetPath(self: usdrt.Usd._Usd.Prim) → usdrt.Sdf._Sdf.Path ¶

GetPrim(self: usdrt.Usd._Usd.Prim) → usdrt.Usd._Usd.Prim ¶

GetPrimPath(self: usdrt.Usd._Usd.Prim) → usdrt.Sdf._Sdf.Path ¶

GetRelationship(self: usdrt.Usd._Usd.Prim, relName: TfToken) → usdrt::UsdRelationship¶

GetRelationships(self: usdrt.Usd._Usd.Prim) → List[usdrt::UsdRelationship]¶

GetStage(self: usdrt.Usd._Usd.Prim) → usdrt.Usd._Usd.Stage ¶

GetTypeName(self: usdrt.Usd._Usd.Prim) → TfToken¶

HasAttribute(self: usdrt.Usd._Usd.Prim, name: TfToken) → bool¶

HasAuthoredTypeName(self: usdrt.Usd._Usd.Prim) → bool¶

HasRelationship(self: usdrt.Usd._Usd.Prim, relName: TfToken) → bool¶

IsValid(self: usdrt.Usd._Usd.Prim) → bool¶

RemoveProperty(self: usdrt.Usd._Usd.Prim, propName: TfToken) → bool¶

SetTypeName(self: usdrt.Usd._Usd.Prim, typeName: TfToken) → bool¶

class usdrt.Usd._Usd.PrimRange¶

class usdrt.Usd._Usd.Relationship¶

AddTarget(self: usdrt.Usd._Usd.Relationship, target: usdrt.Sdf._Sdf.Path, position: usdrt.Usd._Usd.ListPosition = ListPosition.ListPositionBackOfPrependList) → bool¶

ClearTargets(self: usdrt.Usd._Usd.Relationship, removeSpec: bool) → bool¶

GetBaseName(self: usdrt.Usd._Usd.Relationship) → TfToken¶

GetForwardedTargets(self: usdrt.Usd._Usd.Relationship) → List[usdrt.Sdf._Sdf.Path]¶

GetName(self: usdrt.Usd._Usd.Relationship) → TfToken¶

GetNamespace(self: usdrt.Usd._Usd.Relationship) → TfToken¶

GetPath(self: usdrt.Usd._Usd.Relationship) → usdrt.Sdf._Sdf.Path ¶

GetPrim(self: usdrt.Usd._Usd.Relationship) → usdrt.Usd._Usd.Prim ¶

GetPrimPath(self: usdrt.Usd._Usd.Relationship) → usdrt.Sdf._Sdf.Path ¶

GetStage(self: usdrt.Usd._Usd.Relationship) → usdrt.Usd._Usd.Stage ¶

GetTargets(self: usdrt.Usd._Usd.Relationship) → List[usdrt.Sdf._Sdf.Path]¶

HasAuthoredTargets(self: usdrt.Usd._Usd.Relationship) → bool¶

IsValid(self: usdrt.Usd._Usd.Relationship) → bool¶

RemoveTarget(self: usdrt.Usd._Usd.Relationship, target: usdrt.Sdf._Sdf.Path) → bool¶

SetTargets(self: usdrt.Usd._Usd.Relationship, targets: List[usdrt.Sdf._Sdf.Path]) → bool¶

SplitName(self: usdrt.Usd._Usd.Relationship) → List[str]¶

class usdrt.Usd._Usd.SchemaBase¶

GetPrim(self: usdrt.Usd._Usd.SchemaBase) → usdrt.Usd._Usd.Prim ¶

GetPrimPath(self: usdrt.Usd._Usd.SchemaBase) → usdrt.Usd._Usd.Prim ¶

class usdrt.Usd._Usd.Stage¶

static Attach(stageId: int) → usdrt.Usd._Usd.Stage ¶

static CreateInMemory(identifier: str, load: usdrt.Usd._Usd.Stage.InitialLoadSet = InitialLoadSet.LoadAll) → usdrt.Usd._Usd.Stage ¶

static CreateNew(identifier: str, load: usdrt.Usd._Usd.Stage.InitialLoadSet = InitialLoadSet.LoadAll) → usdrt.Usd._Usd.Stage ¶

DefinePrim(self: usdrt.Usd._Usd.Stage, path: usdrt.Sdf._Sdf.Path, typeName: TfToken = '') → usdrt::UsdPrim¶

GetAttributeAtPath(self: usdrt.Usd._Usd.Stage, path: usdrt.Sdf._Sdf.Path) → usdrt::UsdAttribute¶

GetDefaultPrim(self: usdrt.Usd._Usd.Stage) → usdrt::UsdPrim¶

GetPrimAtPath(self: usdrt.Usd._Usd.Stage, path: usdrt.Sdf._Sdf.Path) → usdrt::UsdPrim¶

GetPseudoRoot(self: usdrt.Usd._Usd.Stage) → usdrt::UsdPrim¶

GetRelationshipAtPath(self: usdrt.Usd._Usd.Stage, path: usdrt.Sdf._Sdf.Path) → usdrt::UsdRelationship¶

GetStageId(self: usdrt.Usd._Usd.Stage) → int¶

GetStageInProgressId(self: usdrt.Usd._Usd.Stage) → usdrt.Usd._Usd.StageInProgressId ¶

HasPrimAtPath(self: usdrt.Usd._Usd.Stage, path: usdrt.Sdf._Sdf.Path) → bool¶

class InitialLoadSet¶

Members:

LoadAll

LoadNone

LoadAll = InitialLoadSet.LoadAll¶

LoadNone = InitialLoadSet.LoadNone¶

property name¶

handle) -> str

Type: (self

static Open(filePath: str, load: usdrt.Usd._Usd.Stage.InitialLoadSet = InitialLoadSet.LoadAll) → usdrt.Usd._Usd.Stage ¶

OwnsStageWithHistory(self: usdrt.Usd._Usd.Stage) → bool¶

RemovePrim(self: usdrt.Usd._Usd.Stage, path: usdrt.Sdf._Sdf.Path) → bool¶

SetAttributeValue(self: usdrt.Usd._Usd.Stage, path: usdrt.Sdf._Sdf.Path, value: object, time: float = 0) → bool¶

SetStageWithHistoryOwnership(self: usdrt.Usd._Usd.Stage, isOwner: bool) → None¶

static StageWithHistoryExists(stageId: int) → bool¶

Traverse(self: usdrt.Usd._Usd.Stage) → usdrt::UsdPrimRange¶

WriteToLayer(self: usdrt.Usd._Usd.Stage, filePath: str) → None¶

WriteToStage(self: usdrt.Usd._Usd.Stage) → None¶

class usdrt.Usd._Usd.StageInProgressId¶

property id¶

class usdrt.Usd._Usd.Typed¶

usdrt.Rt module¶

class usdrt.Rt._Rt.Xformable¶

ClearLocalXform(self: usdrt.Rt._Rt.Xformable) → bool¶

ClearWorldXform(self: usdrt.Rt._Rt.Xformable) → bool¶

CreateLocalMatrixAttr(self: usdrt.Rt._Rt.Xformable, defaultValue: usdrt.Gf._Gf.Matrix4d = Gf.Matrix4d(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0)) → usdrt.Usd._Usd.Attribute ¶

CreateWorldOrientationAttr(self: usdrt.Rt._Rt.Xformable, defaultValue: usdrt.Gf._Gf.Quatf = Gf.Quatf(0.0, Gf.Vec3f(0.0, 0.0, 0.0))) → usdrt.Usd._Usd.Attribute ¶

CreateWorldPositionAttr(self: usdrt.Rt._Rt.Xformable, defaultValue: usdrt.Gf._Gf.Vec3d = Gf.Vec3d(0.0, 0.0, 0.0)) → usdrt.Usd._Usd.Attribute ¶

CreateWorldScaleAttr(self: usdrt.Rt._Rt.Xformable, defaultValue: usdrt.Gf._Gf.Vec3f = Gf.Vec3f(0.0, 0.0, 0.0)) → usdrt.Usd._Usd.Attribute ¶

GetLocalMatrixAttr(self: usdrt.Rt._Rt.Xformable) → usdrt.Usd._Usd.Attribute ¶

GetPath(self: usdrt.Rt._Rt.Xformable) → usdrt.Sdf._Sdf.Path ¶

GetPrim(self: usdrt.Rt._Rt.Xformable) → usdrt.Usd._Usd.Prim ¶

GetWorldOrientationAttr(self: usdrt.Rt._Rt.Xformable) → usdrt.Usd._Usd.Attribute ¶

GetWorldPositionAttr(self: usdrt.Rt._Rt.Xformable) → usdrt.Usd._Usd.Attribute ¶

GetWorldScaleAttr(self: usdrt.Rt._Rt.Xformable) → usdrt.Usd._Usd.Attribute ¶

HasLocalXform(self: usdrt.Rt._Rt.Xformable) → bool¶

HasWorldXform(self: usdrt.Rt._Rt.Xformable) → bool¶

SetLocalXformFromUsd(self: usdrt.Rt._Rt.Xformable) → bool¶

SetWorldXformFromUsd(self: usdrt.Rt._Rt.Xformable) → bool¶