UsdGeomHermiteCurves#

Fully qualified name: usdrt::UsdGeomHermiteCurves

class UsdGeomHermiteCurves : public usdrt::UsdGeomCurves #

This schema specifies a cubic hermite interpolated curve batch as sometimes used for defining guides for animation. While hermite curves can be useful because they interpolate through their control points, they are not well supported by high-end renderers for imaging. Therefore, while we include this schema for interchange, we strongly recommend the use of UsdGeomBasisCurves as the representation of curves intended to be rendered (ie. hair or grass). Hermite curves can be converted to a Bezier representation (though not from Bezier back to Hermite in general).

Point Interpolation#

The initial cubic curve segment is defined by the first two points and first two tangents. Additional segments are defined by additional point / tangent pairs. The number of segments for each non-batched hermite curve would be len(curve.points) - 1. The total number of segments for the batched UsdGeomHermiteCurves representation is len(points) - len(curveVertexCounts).

Primvar, Width, and Normal Interpolation#

Primvar interpolation is not well specified for this type as it is not intended as a rendering representation. We suggest that per point primvars would be linearly interpolated across each segment and should be tagged as ‘varying’.

It is not immediately clear how to specify cubic or ‘vertex’ interpolation for this type, as we lack a specification for primvar tangents. This also means that width and normal interpolation should be restricted to varying (linear), uniform (per curve element), or constant (per prim).

Public Functions

inline explicit UsdGeomHermiteCurves(const UsdPrim &prim = UsdPrim())#: Construct a UsdGeomHermiteCurves on UsdPrim prim. Equivalent to UsdGeomHermiteCurves::Get(prim.GetStage(), prim.GetPath()) for a valid prim , but will not immediately throw an error for an invalid prim.

inline explicit UsdGeomHermiteCurves(const UsdSchemaBase &schemaObj)#: Construct a UsdGeomHermiteCurves on the prim held by schemaObj . Should be preferred over UsdGeomHermiteCurves(schemaObj.GetPrim()), as it preserves SchemaBase state.

inline virtual ~UsdGeomHermiteCurves()#: Destructor.

inline UsdAttribute GetTangentsAttr() const#

Defines the outgoing trajectory tangent for each point. Tangents should be the same size as the points attribute.


Declaration	`vector3f[] tangents = []`
C++ Type	VtArray<GfVec3f>
Usd Type	SdfValueTypeNames->Vector3fArray

inline UsdAttribute CreateTangentsAttr() const#: See GetTangentsAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetCurveVertexCountsAttr() const#

Curves-derived primitives can represent multiple distinct, potentially disconnected curves. The length of ‘curveVertexCounts’ gives the number of such curves, and each element describes the number of vertices in the corresponding curve.


Declaration	`int[] curveVertexCounts`
C++ Type	VtArray<int>
Usd Type	SdfValueTypeNames->IntArray

inline UsdAttribute CreateCurveVertexCountsAttr() const#: See GetCurveVertexCountsAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetWidthsAttr() const#

Provides width specification for the curves, whose application will depend on whether the curve is oriented (normals are defined for it), in which case widths are “ribbon width”, or unoriented, in which case widths are cylinder width. ‘widths’ is not a generic Primvar, but the number of elements in this attribute will be determined by its ‘interpolation’. See SetWidthsInterpolation() . If ‘widths’ and ‘primvars:widths’ are both specified, the latter has precedence.


Declaration	`float[] widths`
C++ Type	VtArray<float>
Usd Type	SdfValueTypeNames->FloatArray

inline UsdAttribute CreateWidthsAttr() const#: See GetWidthsAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetPointsAttr() const#

The primary geometry attribute for all PointBased primitives, describes points in (local) space.


Declaration	`point3f[] points`
C++ Type	VtArray<GfVec3f>
Usd Type	SdfValueTypeNames->Point3fArray

inline UsdAttribute CreatePointsAttr() const#: See GetPointsAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetVelocitiesAttr() const#

If provided, ‘velocities’ should be used by renderers to.

compute positions between samples for the ‘points’ attribute, rather than interpolating between neighboring ‘points’ samples. This is the only reasonable means of computing motion blur for topologically varying PointBased primitives. It follows that the length of each ‘velocities’ sample must match the length of the corresponding ‘points’ sample. Velocity is measured in position units per second, as per most simulation software. To convert to position units per UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().

See also UsdGeom_VelocityInterpolation .


Declaration	`vector3f[] velocities`
C++ Type	VtArray<GfVec3f>
Usd Type	SdfValueTypeNames->Vector3fArray

inline UsdAttribute CreateVelocitiesAttr() const#: See GetVelocitiesAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetAccelerationsAttr() const#

If provided, ‘accelerations’ should be used with velocities to compute positions between samples for the ‘points’ attribute rather than interpolating between neighboring ‘points’ samples. Acceleration is measured in position units per second-squared. To convert to position units per squared UsdTimeCode, divide by the square of UsdStage::GetTimeCodesPerSecond().


Declaration	`vector3f[] accelerations`
C++ Type	VtArray<GfVec3f>
Usd Type	SdfValueTypeNames->Vector3fArray

inline UsdAttribute CreateAccelerationsAttr() const#: See GetAccelerationsAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetNormalsAttr() const#

Provide an object-space orientation for individual points, which, depending on subclass, may define a surface, curve, or free points. Note that ‘normals’ should not be authored on any Mesh that is subdivided, since the subdivision algorithm will define its own normals. ‘normals’ is not a generic primvar, but the number of elements in this attribute will be determined by its ‘interpolation’. See SetNormalsInterpolation() . If ‘normals’ and ‘primvars:normals’ are both specified, the latter has precedence.


Declaration	`normal3f[] normals`
C++ Type	VtArray<GfVec3f>
Usd Type	SdfValueTypeNames->Normal3fArray

inline UsdAttribute CreateNormalsAttr() const#: See GetNormalsAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetDisplayColorAttr() const#

It is useful to have an “official” colorSet that can be used as a display or modeling color, even in the absence of any specified shader for a gprim. DisplayColor serves this role; because it is a UsdGeomPrimvar, it can also be used as a gprim override for any shader that consumes a displayColor parameter.


Declaration	`color3f[] primvars:displayColor`
C++ Type	VtArray<GfVec3f>
Usd Type	SdfValueTypeNames->Color3fArray

inline UsdAttribute CreateDisplayColorAttr() const#: See GetDisplayColorAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetDisplayOpacityAttr() const#

Companion to displayColor that specifies opacity, broken out as an independent attribute rather than an rgba color, both so that each can be independently overridden, and because shaders rarely consume rgba parameters.


Declaration	`float[] primvars:displayOpacity`
C++ Type	VtArray<float>
Usd Type	SdfValueTypeNames->FloatArray

inline UsdAttribute CreateDisplayOpacityAttr() const#: See GetDisplayOpacityAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetDoubleSidedAttr() const#

Although some renderers treat all parametric or polygonal surfaces as if they were effectively laminae with outward-facing normals on both sides, some renderers derive significant optimizations by considering these surfaces to have only a single outward side, typically determined by control-point winding order and/or orientation. By doing so they can perform “backface culling” to avoid drawing the many polygons of most closed surfaces that face away from the viewer.

However, it is often advantageous to model thin objects such as paper and cloth as single, open surfaces that must be viewable from both sides, always. Setting a gprim’s doubleSided attribute to true instructs all renderers to disable optimizations such as backface culling for the gprim, and attempt (not all renderers are able to do so, but the USD reference GL renderer always will) to provide forward-facing normals on each side of the surface for lighting calculations.


Declaration	`uniform bool doubleSided = 0`
C++ Type	bool
Usd Type	SdfValueTypeNames->Bool
Variability	SdfVariabilityUniform

inline UsdAttribute CreateDoubleSidedAttr() const#: See GetDoubleSidedAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetOrientationAttr() const#

Orientation specifies whether the gprim’s surface normal should be computed using the right hand rule, or the left hand rule. Please see UsdGeom_WindingOrder for a deeper explanation and generalization of orientation to composed scenes with transformation hierarchies.


Declaration	`uniform token orientation = "rightHanded"`
C++ Type	TfToken
Usd Type	SdfValueTypeNames->Token
Variability	SdfVariabilityUniform
Allowed Values	rightHanded, leftHanded

inline UsdAttribute CreateOrientationAttr() const#: See GetOrientationAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetExtentAttr() const#

Extent is a three dimensional range measuring the geometric extent of the authored gprim in its own local space (i.e. its own transform not applied), without accounting for any shader-induced displacement. If any extent value has been authored for a given Boundable, then it should be authored at every timeSample at which geometry-affecting properties are authored, to ensure correct evaluation via ComputeExtent(). If no extent value has been authored, then ComputeExtent() will call the Boundable’s registered ComputeExtentFunction(), which may be expensive, which is why we strongly encourage proper authoring of extent.

An authored extent on a prim which has children is expected to include the extent of all children, as they will be pruned from BBox computation during traversal.

See also

ComputeExtent()

See also

Why Extent and not Bounds ?.


Declaration	`float3[] extent`
C++ Type	VtArray<GfVec3f>
Usd Type	SdfValueTypeNames->Float3Array

inline UsdAttribute CreateExtentAttr() const#: See GetExtentAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetXformOpOrderAttr() const#

Encodes the sequence of transformation operations in the order in which they should be pushed onto a transform stack while visiting a UsdStage’s prims in a graph traversal that will effect the desired positioning for this prim and its descendant prims.

You should rarely, if ever, need to manipulate this attribute directly. It is managed by the AddXformOp(), SetResetXformStack(), and SetXformOpOrder(), and consulted by GetOrderedXformOps() and GetLocalTransformation().


Declaration	`uniform token[] xformOpOrder`
C++ Type	VtArray<TfToken>
Usd Type	SdfValueTypeNames->TokenArray
Variability	SdfVariabilityUniform

inline UsdAttribute CreateXformOpOrderAttr() const#: See GetXformOpOrderAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetVisibilityAttr() const#

Visibility is meant to be the simplest form of “pruning” visibility that is supported by most DCC apps. Visibility is animatable, allowing a sub-tree of geometry to be present for some segment of a shot, and absent from others; unlike the action of deactivating geometry prims, invisible geometry is still available for inspection, for positioning, for defining volumes, etc.


Declaration	`token visibility = "inherited"`
C++ Type	TfToken
Usd Type	SdfValueTypeNames->Token
Allowed Values	inherited, invisible

inline UsdAttribute CreateVisibilityAttr() const#: See GetVisibilityAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdAttribute GetPurposeAttr() const#

Purpose is a classification of geometry into categories that can each be independently included or excluded from traversals of prims on a stage, such as rendering or bounding-box computation traversals.

See UsdGeom_ImageablePurpose for more detail about how purpose is computed and used.


Declaration	`uniform token purpose = "default"`
C++ Type	TfToken
Usd Type	SdfValueTypeNames->Token
Variability	SdfVariabilityUniform
Allowed Values	default, render, proxy, guide

inline UsdAttribute CreatePurposeAttr() const#: See GetPurposeAttr(), and also Create vs Get Property Methods for when to use Get vs Create. If specified, author defaultValue as the attribute’s default, sparsely (when it makes sense to do so) if writeSparsely is true - the default for writeSparsely is false.

inline UsdRelationship GetProxyPrimRel() const#

The proxyPrim relationship allows us to link a prim whose purpose is “render” to its (single target) purpose=”proxy” prim. This is entirely optional, but can be useful in several scenarios:

In a pipeline that does pruning (for complexity management) by deactivating prims composed from asset references, when we deactivate a purpose=”render” prim, we will be able to discover and additionally deactivate its associated purpose=”proxy” prim, so that preview renders reflect the pruning accurately.

DCC importers may be able to make more aggressive optimizations for interactive processing and display if they can discover the proxy for a given render prim.

With a little more work, a Hydra-based application will be able to map a picked proxy prim back to its render geometry for selection.

Note

It is only valid to author the proxyPrim relationship on prims whose purpose is “render”.

inline UsdRelationship CreateProxyPrimRel() const#: See GetProxyPrimRel(), and also Create vs Get Property Methods for when to use Get vs Create.

UsdPrim GetPrim() const#: Return this schema object’s held prim.

SdfPath GetPath() const#: Return the SdfPath to this schema object’s held prim.

inline explicit operator bool() const#

Check if this schema object is compatible with it’s held prim and that the prim is valid.

A typed schema object is compatible if the held prim’s type is or is a subtype of the schema’s type. Based on prim.IsA().

An API schema object is compatible if the API is of type SingleApplyAPI or UsdSchemaType::MultipleApplyAPI, and the schema has been applied to the prim. Based on prim.HasAPI.

This method invokes polymorphic behaviour.

See also

UsdSchemaBase::_IsCompatible()

Returns:: True if the help prim is valid, and the schema object is compatible with its held prim.

Public Static Functions

static inline UsdGeomHermiteCurves Define( const UsdStageRefPtr &stage, const SdfPath &path, )#: Attempt to ensure a UsdPrim adhering to this schema at path is defined (according to UsdPrim::IsDefined()) on this stage.

Public Static Attributes

static const UsdSchemaType schemaType = UsdSchemaType::ConcreteTyped #

Compile time constant representing what kind of schema this class is.

See also

UsdSchemaType

Protected Functions

inline virtual bool _IsCompatible() const#

Helper for subclasses to do specific compatibility checking with the given prim. Subclassess may override _isCompatible to for example check type compatibility or value compatibility on the prim.

Overrides exist for UsdTyped and UsdAPISchemaBase.

This check is called when clients invoke the bool operator.

Returns:: True if the schema object is compatible with its held prim.

inline const TfToken _GetType() const#

Helper for subclasses to get this schema’s type token.

Note

This diverges from Usd and returns a TfToken, since we don’t implements TfType.

Returns:: The token representing the schema’s TfType.