from __future__ import annotations
import pxr.UsdGeom._usdGeom
import typing
import Boost.Python
import pxr.Usd
import pxr.UsdGeom

__all__ = [
    "BBoxCache",
    "BasisCurves",
    "Boundable",
    "Camera",
    "Capsule",
    "Cone",
    "ConstraintTarget",
    "Cube",
    "Curves",
    "Cylinder",
    "GetFallbackUpAxis",
    "GetStageMetersPerUnit",
    "GetStageUpAxis",
    "Gprim",
    "HermiteCurves",
    "Imageable",
    "LinearUnits",
    "LinearUnitsAre",
    "Mesh",
    "ModelAPI",
    "MotionAPI",
    "NurbsCurves",
    "NurbsPatch",
    "Plane",
    "PointBased",
    "PointInstancer",
    "Points",
    "Primvar",
    "PrimvarsAPI",
    "Scope",
    "SetStageMetersPerUnit",
    "SetStageUpAxis",
    "Sphere",
    "StageHasAuthoredMetersPerUnit",
    "Subset",
    "Tokens",
    "VisibilityAPI",
    "Xform",
    "XformCache",
    "XformCommonAPI",
    "XformOp",
    "XformOpTypes",
    "Xformable"
]


class BBoxCache(Boost.Python.instance):
    """
    Caches bounds by recursively computing and aggregating bounds of
    children in world space and aggregating the result back into local
    space.

    The cache is configured for a specific time and
    UsdGeomImageable::GetPurposeAttr() set of purposes. When querying a
    bound, transforms and extents are read either from the time specified
    or UsdTimeCode::Default() , following TimeSamples, Defaults, and Value
    Resolution standard time-sample value resolution. As noted in
    SetIncludedPurposes() , changing the included purposes does not
    invalidate the cache, because we cache purpose along with the
    geometric data.

    Child prims that are invisible at the requested time are excluded when
    computing a prim's bounds. However, if a bound is requested directly
    for an excluded prim, it will be computed. Additionally, only prims
    deriving from UsdGeomImageable are included in child bounds
    computations.

    Unlike standard UsdStage traversals, the traversal performed by the
    UsdGeomBBoxCache includesprims that are unloaded (see
    UsdPrim::IsLoaded() ). This makes it possible to fetch bounds for a
    UsdStage that has been opened without *forcePopulate*, provided the
    unloaded model prims have authored extent hints (see
    UsdGeomModelAPI::GetExtentsHint() ).

    This class is optimized for computing tight
    **untransformed"object"space** bounds for component-models. In the
    absence of component models, bounds are optimized for world-space,
    since there is no other easily identifiable space for which to
    optimize, and we cannot optimize for every prim's local space without
    performing quadratic work.

    The TfDebug flag, USDGEOM_BBOX, is provided for debugging.

    Warnings:

       - This class should only be used with valid UsdPrim objects.

       - This cache does not listen for change notifications; the user is
         responsible for clearing the cache when changes occur.

       - Thread safety: instances of this class may not be used
         concurrently.

       - Plugins may be loaded in order to compute extents for prim types
         provided by that plugin. See
         UsdGeomBoundable::ComputeExtentFromPlugins
    """
    @staticmethod
    def Clear() -> None: 
        """
        Clear() -> None


        Clears all pre-cached values.
        """
    @staticmethod
    def ClearBaseTime() -> None: 
        """
        ClearBaseTime() -> None


        Clear this cache's baseTime if one has been set.


        After calling this, the cache will use its time as the baseTime value.
        """
    @staticmethod
    def ComputeLocalBound(prim) -> BBox3d: 
        """
        ComputeLocalBound(prim) -> BBox3d


        Computes the oriented bounding box of the given prim, leveraging any
        pre-existing, cached bounds.


        The computed bound includes the transform authored on the prim itself,
        but does not include any ancestor transforms (it does not include the
        local-to-world transform).

        See ComputeWorldBound() for notes on performance and error handling.


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def ComputePointInstanceLocalBound(instancer, instanceId) -> BBox3d: 
        """
        ComputePointInstanceLocalBound(instancer, instanceId) -> BBox3d


        Compute the oriented bounding boxes of the given point instances.


        Parameters
        ----------
        instancer : PointInstancer

        instanceId : int
        """
    @staticmethod
    def ComputePointInstanceLocalBounds(instancer, instanceIdBegin, numIds, result) -> bool: 
        """
        ComputePointInstanceLocalBounds(instancer, instanceIdBegin, numIds, result) -> bool


        Compute the oriented bounding boxes of the given point instances.


        The computed bounds include the transform authored on the instancer
        itself, but does not include any ancestor transforms (it does not
        include the local-to-world transform).

        The ``result`` pointer must point to ``numIds`` GfBBox3d instances to
        be filled.


        Parameters
        ----------
        instancer : PointInstancer

        instanceIdBegin : int

        numIds : int

        result : BBox3d
        """
    @staticmethod
    def ComputePointInstanceRelativeBound(instancer, instanceId, relativeToAncestorPrim) -> BBox3d: 
        """
        ComputePointInstanceRelativeBound(instancer, instanceId, relativeToAncestorPrim) -> BBox3d


        Compute the bound of the given point instance in the space of an
        ancestor prim ``relativeToAncestorPrim`` .


        Parameters
        ----------
        instancer : PointInstancer

        instanceId : int

        relativeToAncestorPrim : Prim
        """
    @staticmethod
    def ComputePointInstanceRelativeBounds(instancer, instanceIdBegin, numIds, relativeToAncestorPrim, result) -> bool: 
        """
        ComputePointInstanceRelativeBounds(instancer, instanceIdBegin, numIds, relativeToAncestorPrim, result) -> bool


        Compute the bounds of the given point instances in the space of an
        ancestor prim ``relativeToAncestorPrim`` .


        Write the results to ``result`` .

        The computed bound excludes the local transform at
        ``relativeToAncestorPrim`` . The computed bound may be incorrect if
        ``relativeToAncestorPrim`` is not an ancestor of ``prim`` .

        The ``result`` pointer must point to ``numIds`` GfBBox3d instances to
        be filled.


        Parameters
        ----------
        instancer : PointInstancer

        instanceIdBegin : int

        numIds : int

        relativeToAncestorPrim : Prim

        result : BBox3d
        """
    @staticmethod
    def ComputePointInstanceUntransformedBound(instancer, instanceId) -> BBox3d: 
        """
        ComputePointInstanceUntransformedBound(instancer, instanceId) -> BBox3d


        Computes the bound of the given point instances, but does not include
        the instancer's transform.


        Parameters
        ----------
        instancer : PointInstancer

        instanceId : int
        """
    @staticmethod
    def ComputePointInstanceUntransformedBounds(instancer, instanceIdBegin, numIds, result) -> bool: 
        """
        ComputePointInstanceUntransformedBounds(instancer, instanceIdBegin, numIds, result) -> bool


        Computes the bound of the given point instances, but does not include
        the transform (if any) authored on the instancer itself.


        **IMPORTANT:** while the BBox does not contain the local
        transformation, in general it may still contain a non-identity
        transformation matrix to put the bounds in the correct space.
        Therefore, to obtain the correct axis-aligned bounding box, the client
        must call ComputeAlignedRange().

        The ``result`` pointer must point to ``numIds`` GfBBox3d instances to
        be filled.


        Parameters
        ----------
        instancer : PointInstancer

        instanceIdBegin : int

        numIds : int

        result : BBox3d
        """
    @staticmethod
    def ComputePointInstanceWorldBound(instancer, instanceId) -> BBox3d: 
        """
        ComputePointInstanceWorldBound(instancer, instanceId) -> BBox3d


        Compute the bound of the given point instance in world space.


        Parameters
        ----------
        instancer : PointInstancer

        instanceId : int
        """
    @staticmethod
    def ComputePointInstanceWorldBounds(instancer, instanceIdBegin, numIds, result) -> bool: 
        """
        ComputePointInstanceWorldBounds(instancer, instanceIdBegin, numIds, result) -> bool


        Compute the bound of the given point instances in world space.


        The bounds of each instance is computed and then transformed to world
        space. The ``result`` pointer must point to ``numIds`` GfBBox3d
        instances to be filled.


        Parameters
        ----------
        instancer : PointInstancer

        instanceIdBegin : int

        numIds : int

        result : BBox3d
        """
    @staticmethod
    def ComputeRelativeBound(prim, relativeToAncestorPrim) -> BBox3d: 
        """
        ComputeRelativeBound(prim, relativeToAncestorPrim) -> BBox3d


        Compute the bound of the given prim in the space of an ancestor prim,
        ``relativeToAncestorPrim`` , leveraging any pre-existing cached
        bounds.


        The computed bound excludes the local transform at
        ``relativeToAncestorPrim`` . The computed bound may be incorrect if
        ``relativeToAncestorPrim`` is not an ancestor of ``prim`` .


        Parameters
        ----------
        prim : Prim

        relativeToAncestorPrim : Prim
        """
    @staticmethod
    @typing.overload
    def ComputeUntransformedBound(prim) -> BBox3d: 
        """
        ComputeUntransformedBound(prim) -> BBox3d


        Computes the bound of the prim's children leveraging any pre-existing,
        cached bounds, but does not include the transform (if any) authored on
        the prim itself.


        **IMPORTANT:** while the BBox does not contain the local
        transformation, in general it may still contain a non-identity
        transformation matrix to put the bounds in the correct space.
        Therefore, to obtain the correct axis-aligned bounding box, the client
        must call ComputeAlignedRange().

        See ComputeWorldBound() for notes on performance and error handling.


        Parameters
        ----------
        prim : Prim



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the bound of the prim's descendents while excluding the
        subtrees rooted at the paths in ``pathsToSkip`` .


        Additionally, the parameter ``ctmOverrides`` is used to specify
        overrides to the CTM values of certain paths underneath the prim. The
        CTM values in the ``ctmOverrides`` map are in the space of the given
        prim, ``prim`` .

        This leverages any pre-existing, cached bounds, but does not include
        the transform (if any) authored on the prim itself.

        **IMPORTANT:** while the BBox does not contain the local
        transformation, in general it may still contain a non-identity
        transformation matrix to put the bounds in the correct space.
        Therefore, to obtain the correct axis-aligned bounding box, the client
        must call ComputeAlignedRange().

        See ComputeWorldBound() for notes on performance and error handling.


        Parameters
        ----------
        prim : Prim

        pathsToSkip : SdfPathSet

        ctmOverrides : TfHashMap[Path, Matrix4d, Path.Hash]
        """
    @staticmethod
    @typing.overload
    def ComputeUntransformedBound(prim, pathsToSkip, ctmOverrides) -> BBox3d: ...
    @staticmethod
    def ComputeWorldBound(prim) -> BBox3d: 
        """
        ComputeWorldBound(prim) -> BBox3d


        Compute the bound of the given prim in world space, leveraging any
        pre-existing, cached bounds.


        The bound of the prim is computed, including the transform (if any)
        authored on the node itself, and then transformed to world space.

        Error handling note: No checking of ``prim`` validity is performed. If
        ``prim`` is invalid, this method will abort the program; therefore it
        is the client's responsibility to ensure ``prim`` is valid.


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def ComputeWorldBoundWithOverrides(prim, pathsToSkip, primOverride, ctmOverrides) -> BBox3d: 
        """
        ComputeWorldBoundWithOverrides(prim, pathsToSkip, primOverride, ctmOverrides) -> BBox3d


        Computes the bound of the prim's descendents in world space while
        excluding the subtrees rooted at the paths in ``pathsToSkip`` .


        Additionally, the parameter ``primOverride`` overrides the local-to-
        world transform of the prim and ``ctmOverrides`` is used to specify
        overrides the local-to-world transforms of certain paths underneath
        the prim.

        This leverages any pre-existing, cached bounds, but does not include
        the transform (if any) authored on the prim itself.

        See ComputeWorldBound() for notes on performance and error handling.


        Parameters
        ----------
        prim : Prim

        pathsToSkip : SdfPathSet

        primOverride : Matrix4d

        ctmOverrides : TfHashMap[Path, Matrix4d, Path.Hash]
        """
    @staticmethod
    def GetBaseTime() -> TimeCode: 
        """
        GetBaseTime() -> TimeCode


        Return the base time if set, otherwise GetTime() .


        Use HasBaseTime() to observe if a base time has been set.
        """
    @staticmethod
    def GetIncludedPurposes() -> list[TfToken]: 
        """
        GetIncludedPurposes() -> list[TfToken]


        Get the current set of included purposes.
        """
    @staticmethod
    def GetTime() -> TimeCode: 
        """
        GetTime() -> TimeCode


        Get the current time from which this cache is reading values.
        """
    @staticmethod
    def GetUseExtentsHint() -> bool: 
        """
        GetUseExtentsHint() -> bool


        Returns whether authored extent hints are used to compute bounding
        boxes.
        """
    @staticmethod
    def HasBaseTime() -> bool: 
        """
        HasBaseTime() -> bool


        Return true if this cache has a baseTime that's been explicitly set,
        false otherwise.
        """
    @staticmethod
    def SetBaseTime(baseTime) -> None: 
        """
        SetBaseTime(baseTime) -> None


        Set the base time value for this bbox cache.


        This value is used only when computing bboxes for point instancer
        instances (see ComputePointInstanceWorldBounds() , for example). See
        UsdGeomPointInstancer::ComputeExtentAtTime() for more information. If
        unset, the bbox cache uses its time ( GetTime() / SetTime() ) for this
        value.

        Note that setting the base time does not invalidate any cache entries.


        Parameters
        ----------
        baseTime : TimeCode
        """
    @staticmethod
    def SetIncludedPurposes(includedPurposes) -> None: 
        """
        SetIncludedPurposes(includedPurposes) -> None


        Indicate the set of ``includedPurposes`` to use when resolving child
        bounds.


        Each child's purpose must match one of the elements of this set to be
        included in the computation; if it does not, child is excluded.

        Note the use of *child* in the docs above, purpose is ignored for the
        prim for whose bounds are directly queried.

        Changing this value **does not invalidate existing caches**.


        Parameters
        ----------
        includedPurposes : list[TfToken]
        """
    @staticmethod
    def SetTime(time) -> None: 
        """
        SetTime(time) -> None


        Use the new ``time`` when computing values and may clear any existing
        values cached for the previous time.


        Setting ``time`` to the current time is a no-op.


        Parameters
        ----------
        time : TimeCode
        """
    __instance_size__ = 544
    pass
class BasisCurves(Curves, PointBased, Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    BasisCurves are a batched curve representation analogous to the
    classic RIB definition via Basis and Curves statements. BasisCurves
    are often used to render dense aggregate geometry like hair or grass.

    A'matrix'and'vstep'associated with the *basis* are used to interpolate
    the vertices of a cubic BasisCurves. (The basis attribute is unused
    for linear BasisCurves.)

    A single prim may have many curves whose count is determined
    implicitly by the length of the *curveVertexCounts* vector. Each
    individual curve is composed of one or more segments. Each segment is
    defined by four vertices for cubic curves and two vertices for linear
    curves. See the next section for more information on how to map curve
    vertex counts to segment counts.

    Segment Indexing
    ================

    Interpolating a curve requires knowing how to decompose it into its
    individual segments.

    The segments of a cubic curve are determined by the vertex count, the
    *wrap* (periodicity), and the vstep of the basis. For linear curves,
    the basis token is ignored and only the vertex count and wrap are
    needed.

    cubic basis

    vstep

    bezier

    3

    catmullRom

    1

    bspline

    1

    The first segment of a cubic (nonperiodic) curve is always defined by
    its first four points. The vstep is the increment used to determine
    what vertex indices define the next segment. For a two segment
    (nonperiodic) bspline basis curve (vstep = 1), the first segment will
    be defined by interpolating vertices [0, 1, 2, 3] and the second
    segment will be defined by [1, 2, 3, 4]. For a two segment bezier
    basis curve (vstep = 3), the first segment will be defined by
    interpolating vertices [0, 1, 2, 3] and the second segment will be
    defined by [3, 4, 5, 6]. If the vstep is not one, then you must take
    special care to make sure that the number of cvs properly divides by
    your vstep. (The indices described are relative to the initial vertex
    index for a batched curve.)

    For periodic curves, at least one of the curve's initial vertices are
    repeated to close the curve. For cubic curves, the number of vertices
    repeated is'4 - vstep'. For linear curves, only one vertex is repeated
    to close the loop.

    Pinned curves are a special case of nonperiodic curves that only
    affects the behavior of cubic Bspline and Catmull-Rom curves. To
    evaluate or render pinned curves, a client must effectively
    add'phantom points'at the beginning and end of every curve in a batch.
    These phantom points are injected to ensure that the interpolated
    curve begins at P[0] and ends at P[n-1].

    For a curve with initial point P[0] and last point P[n-1], the phantom
    points are defined as. P[-1] = 2 \* P[0] - P[1] P[n] = 2 \* P[n-1] -
    P[n-2]

    Pinned cubic curves will (usually) have to be unpacked into the
    standard nonperiodic representation before rendering. This unpacking
    can add some additional overhead. However, using pinned curves reduces
    the amount of data recorded in a scene and (more importantly) better
    records the authors'intent for interchange.

    The additional phantom points mean that the minimum curve vertex count
    for cubic bspline and catmullRom curves is 2. Linear curve segments
    are defined by two vertices. A two segment linear curve's first
    segment would be defined by interpolating vertices [0, 1]. The second
    segment would be defined by vertices [1, 2]. (Again, for a batched
    curve, indices are relative to the initial vertex index.)

    When validating curve topology, each renderable entry in the
    curveVertexCounts vector must pass this check.

    type

    wrap

    validitity

    linear

    nonperiodic

    curveVertexCounts[i]>2

    linear

    periodic

    curveVertexCounts[i]>3

    cubic

    nonperiodic

    (curveVertexCounts[i] - 4) % vstep == 0

    cubic

    periodic

    (curveVertexCounts[i]) % vstep == 0

    cubic

    pinned (catmullRom/bspline)

    (curveVertexCounts[i] - 2)>= 0

    Cubic Vertex Interpolation
    ==========================

    Linear Vertex Interpolation
    ===========================

    Linear interpolation is always used on curves of type linear.'t'with
    domain [0, 1], the curve is defined by the equation P0 \* (1-t) + P1
    \* t. t at 0 describes the first point and t at 1 describes the end
    point.

    Primvar Interpolation
    =====================

    For cubic curves, primvar data can be either interpolated cubically
    between vertices or linearly across segments. The corresponding token
    for cubic interpolation is'vertex'and for linear interpolation
    is'varying'. Per vertex data should be the same size as the number of
    vertices in your curve. Segment varying data is dependent on the wrap
    (periodicity) and number of segments in your curve. For linear curves,
    varying and vertex data would be interpolated the same way. By
    convention varying is the preferred interpolation because of the
    association of varying with linear interpolation.

    To convert an entry in the curveVertexCounts vector into a segment
    count for an individual curve, apply these rules. Sum up all the
    results in order to compute how many total segments all curves have.

    The following tables describe the expected segment count for the'i'th
    curve in a curve batch as well as the entire batch. Python syntax
    like'[:]'(to describe all members of an array) and'len(\.\.\.)'(to
    describe the length of an array) are used.

    type

    wrap

    curve segment count

    batch segment count

    linear

    nonperiodic

    curveVertexCounts[i] - 1

    sum(curveVertexCounts[:]) - len(curveVertexCounts)

    linear

    periodic

    curveVertexCounts[i]

    sum(curveVertexCounts[:])

    cubic

    nonperiodic

    (curveVertexCounts[i] - 4) / vstep + 1

    sum(curveVertexCounts[:] - 4) / vstep + len(curveVertexCounts)

    cubic

    periodic

    curveVertexCounts[i] / vstep

    sum(curveVertexCounts[:]) / vstep

    cubic

    pinned (catmullRom/bspline)

    (curveVertexCounts[i] - 2) + 1

    sum(curveVertexCounts[:] - 2) + len(curveVertexCounts)

    The following table descrives the expected size of varying (linearly
    interpolated) data, derived from the segment counts computed above.

    wrap

    curve varying count

    batch varying count

    nonperiodic/pinned

    segmentCounts[i] + 1

    sum(segmentCounts[:]) + len(curveVertexCounts)

    periodic

    segmentCounts[i]

    sum(segmentCounts[:])

    Both curve types additionally define'constant'interpolation for the
    entire prim and'uniform'interpolation as per curve data.

    Take care when providing support for linearly interpolated data for
    cubic curves. Its shape doesn't provide a one to one mapping with
    either the number of curves (like'uniform') or the number of vertices
    (like'vertex') and so it is often overlooked. This is the only
    primitive in UsdGeom (as of this writing) where this is true. For
    meshes, while they use different interpolation
    methods,'varying'and'vertex'are both specified per point. It's common
    to assume that curves follow a similar pattern and build in structures
    and language for per primitive, per element, and per point data only
    to come upon these arrays that don't quite fit into either of those
    categories. It is also common to conflate'varying'with being per
    segment data and use the segmentCount rules table instead of its
    neighboring varying data table rules. We suspect that this is because
    for the common case of nonperiodic cubic curves, both the provided
    segment count and varying data size formula end with'+ 1'. While
    debugging, users may look at the double'+ 1'as a mistake and try to
    remove it. We take this time to enumerate these issues because we've
    fallen into them before and hope that we save others time in their own
    implementations. As an example of deriving per curve segment and
    varying primvar data counts from the wrap, type, basis, and
    curveVertexCount, the following table is provided.

    wrap

    type

    basis

    curveVertexCount

    curveSegmentCount

    varyingDataCount

    nonperiodic

    linear

    N/A

    [2 3 2 5]

    [1 2 1 4]

    [2 3 2 5]

    nonperiodic

    cubic

    bezier

    [4 7 10 4 7]

    [1 2 3 1 2]

    [2 3 4 2 3]

    nonperiodic

    cubic

    bspline

    [5 4 6 7]

    [2 1 3 4]

    [3 2 4 5]

    periodic

    cubic

    bezier

    [6 9 6]

    [2 3 2]

    [2 3 2]

    periodic

    linear

    N/A

    [3 7]

    [3 7]

    [3 7]

    Tubes and Ribbons
    =================

    The strictest definition of a curve as an infinitely thin wire is not
    particularly useful for describing production scenes. The additional
    *widths* and *normals* attributes can be used to describe cylindrical
    tubes and or flat oriented ribbons.

    Curves with only widths defined are imaged as tubes with radius'width
    / 2'. Curves with both widths and normals are imaged as ribbons
    oriented in the direction of the interpolated normal vectors.

    While not technically UsdGeomPrimvars, widths and normals also have
    interpolation metadata. It's common for authored widths to have
    constant, varying, or vertex interpolation (see
    UsdGeomCurves::GetWidthsInterpolation() ). It's common for authored
    normals to have varying interpolation (see
    UsdGeomPointBased::GetNormalsInterpolation() ).

    The file used to generate these curves can be found in
    pxr/extras/examples/usdGeomExamples/basisCurves.usda. It's provided as
    a reference on how to properly image both tubes and ribbons. The first
    row of curves are linear; the second are cubic bezier. (We aim in
    future releases of HdSt to fix the discontinuity seen with broken
    tangents to better match offline renderers like RenderMan.) The yellow
    and violet cubic curves represent cubic vertex width interpolation for
    which there is no equivalent for linear curves.

    How did this prim type get its name? This prim is a portmanteau of two
    different statements in the original RenderMan
    specification:'Basis'and'Curves'. For any described attribute
    *Fallback* *Value* or *Allowed* *Values* below that are text/tokens,
    the actual token is published and defined in UsdGeomTokens. So to set
    an attribute to the value"rightHanded", use UsdGeomTokens->rightHanded
    as the value.
    """
    @staticmethod
    def ComputeInterpolationForSize(n, timeCode, info) -> str: 
        """
        ComputeInterpolationForSize(n, timeCode, info) -> str


        Computes interpolation token for ``n`` .


        If this returns an empty token and ``info`` was non-None, it'll
        contain the expected value for each token.

        The topology is determined using ``timeCode`` .


        Parameters
        ----------
        n : int

        timeCode : TimeCode

        info : ComputeInterpolationInfo
        """
    @staticmethod
    def ComputeUniformDataSize(timeCode) -> int: 
        """
        ComputeUniformDataSize(timeCode) -> int


        Computes the expected size for data with"uniform"interpolation.


        If you're trying to determine what interpolation to use, it is more
        efficient to use ``ComputeInterpolationForSize``


        Parameters
        ----------
        timeCode : TimeCode
        """
    @staticmethod
    def ComputeVaryingDataSize(timeCode) -> int: 
        """
        ComputeVaryingDataSize(timeCode) -> int


        Computes the expected size for data with"varying"interpolation.


        If you're trying to determine what interpolation to use, it is more
        efficient to use ``ComputeInterpolationForSize``


        Parameters
        ----------
        timeCode : TimeCode
        """
    @staticmethod
    def ComputeVertexDataSize(timeCode) -> int: 
        """
        ComputeVertexDataSize(timeCode) -> int


        Computes the expected size for data with"vertex"interpolation.


        If you're trying to determine what interpolation to use, it is more
        efficient to use ``ComputeInterpolationForSize``


        Parameters
        ----------
        timeCode : TimeCode
        """
    @staticmethod
    def CreateBasisAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateBasisAttr(defaultValue, writeSparsely) -> Attribute


        See GetBasisAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTypeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTypeAttr(defaultValue, writeSparsely) -> Attribute


        See GetTypeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateWrapAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateWrapAttr(defaultValue, writeSparsely) -> Attribute


        See GetWrapAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> BasisCurves


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> BasisCurves


        Return a UsdGeomBasisCurves holding the prim adhering to this schema
        at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomBasisCurves(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetBasisAttr() -> Attribute: 
        """
        GetBasisAttr() -> Attribute


        The basis specifies the vstep and matrix used for cubic interpolation.



        The'hermite'and'power'tokens have been removed. We've provided
        UsdGeomHermiteCurves as an alternative for the'hermite'basis.

        Declaration

        ``uniform token basis ="bezier"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        bezier, bspline, catmullRom
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetTypeAttr() -> Attribute: 
        """
        GetTypeAttr() -> Attribute


        Linear curves interpolate linearly between two vertices.


        Cubic curves use a basis matrix with four vertices to interpolate a
        segment.

        Declaration

        ``uniform token type ="cubic"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        linear, cubic
        """
    @staticmethod
    def GetWrapAttr() -> Attribute: 
        """
        GetWrapAttr() -> Attribute


        If wrap is set to periodic, the curve when rendered will repeat the
        initial vertices (dependent on the vstep) to close the curve.


        If wrap is set to'pinned', phantom points may be created to ensure
        that the curve interpolation starts at P[0] and ends at P[n-1].

        Declaration

        ``uniform token wrap ="nonperiodic"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        nonperiodic, periodic, pinned
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Boundable(Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Boundable introduces the ability for a prim to persistently cache a
    rectilinear, local-space, extent.

    Why Extent and not Bounds ?
    ===========================

    Boundable introduces the notion of"extent", which is a cached
    computation of a prim's local-space 3D range for its resolved
    attributes **at the layer and time in which extent is authored**. We
    have found that with composed scene description, attempting to cache
    pre-computed bounds at interior prims in a scene graph is very
    fragile, given the ease with which one can author a single attribute
    in a stronger layer that can invalidate many authored caches - or with
    which a re-published, referenced asset can do the same.

    Therefore, we limit to precomputing (generally) leaf-prim extent,
    which avoids the need to read in large point arrays to compute bounds,
    and provides UsdGeomBBoxCache the means to efficiently compute and
    (session-only) cache intermediate bounds. You are free to compute and
    author intermediate bounds into your scenes, of course, which may work
    well if you have sufficient locks on your pipeline to guarantee that
    once authored, the geometry and transforms upon which they are based
    will remain unchanged, or if accuracy of the bounds is not an ironclad
    requisite.

    When intermediate bounds are authored on Boundable parents, the child
    prims will be pruned from BBox computation; the authored extent is
    expected to incorporate all child bounds.
    """
    @staticmethod
    def ComputeExtent(radius, transform, extent) -> bool: 
        """
        **classmethod** ComputeExtent(radius, extent) -> bool


        Compute the extent for the sphere defined by the radius.



        true upon success, false if unable to calculate extent. On success,
        extent will contain an approximate axis-aligned bounding box of the
        sphere defined by the radius.

        This function is to provide easy authoring of extent for usd authoring
        tools, hence it is static and acts outside a specific prim (as in
        attribute based methods).


        Parameters
        ----------
        radius : float

        extent : Vec3fArray



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the extent as if the matrix ``transform`` was first applied.


        Parameters
        ----------
        radius : float

        transform : Matrix4d

        extent : Vec3fArray
        """
    @staticmethod
    def ComputeExtentFromPlugins(boundable, time, transform, extent) -> bool: 
        """
        **classmethod** ComputeExtentFromPlugins(boundable, time, extent) -> bool


        Compute the extent for the Boundable prim ``boundable`` at time
        ``time`` .


        If successful, populates ``extent`` with the result and returns
        ``true`` , otherwise returns ``false`` .

        The extent computation is based on the concrete type of the prim
        represented by ``boundable`` . Plugins that provide a Boundable prim
        type may implement and register an extent computation for that type
        using UsdGeomRegisterComputeExtentFunction. ComputeExtentFromPlugins
        will use this function to compute extents for all prims of that type.
        If no function has been registered for a prim type, but a function has
        been registered for one of its base types, that function will be used
        instead.

        This function may load plugins in order to access the extent
        computation for a prim type.


        Parameters
        ----------
        boundable : Boundable

        time : TimeCode

        extent : Vec3fArray



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the extent as if the matrix ``transform`` was first applied.


        Parameters
        ----------
        boundable : Boundable

        time : TimeCode

        transform : Matrix4d

        extent : Vec3fArray
        """
    @staticmethod
    def CreateExtentAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExtentAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Boundable


        Return a UsdGeomBoundable holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomBoundable(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetExtentAttr() -> Attribute: 
        """
        GetExtentAttr() -> Attribute


        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.

        Why Extent and not Bounds? . 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.

        Declaration

        ``float3[] extent``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Float3Array
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Camera(Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Transformable camera.

    Describes optical properties of a camera via a common set of
    attributes that provide control over the camera's frustum as well as
    its depth of field. For stereo, the left and right camera are
    individual prims tagged through the stereoRole attribute.

    There is a corresponding class GfCamera, which can hold the state of a
    camera (at a particular time). UsdGeomCamera::GetCamera() and
    UsdGeomCamera::SetFromCamera() convert between a USD camera prim and a
    GfCamera.

    To obtain the camera's location in world space, call the following on
    a UsdGeomCamera 'camera':

    .. code-block:: text

      GfMatrix4d camXform = camera.ComputeLocalToWorldTransform(time);

    **Cameras in USD are always"Y up", regardless of the stage's
    orientation (i.e. UsdGeomGetStageUpAxis() ).** This means that the
    inverse of'camXform'(the VIEW half of the MODELVIEW transform in
    OpenGL parlance) will transform the world such that the camera is at
    the origin, looking down the -Z axis, with +Y as the up axis, and +X
    pointing to the right. This describes a **right handed coordinate
    system**.

    Units of Measure for Camera Properties
    ======================================

    Despite the familiarity of millimeters for specifying some physical
    camera properties, UsdGeomCamera opts for greater consistency with all
    other UsdGeom schemas, which measure geometric properties in scene
    units, as determined by UsdGeomGetStageMetersPerUnit() . We do make a
    concession, however, in that lens and filmback properties are measured
    in **tenths of a scene unit** rather than"raw"scene units. This means
    that with the fallback value of.01 for *metersPerUnit* - i.e. scene
    unit of centimeters - then these"tenth of scene unit"properties are
    effectively millimeters.

    If one adds a Camera prim to a UsdStage whose scene unit is not
    centimeters, the fallback values for filmback properties will be
    incorrect (or at the least, unexpected) in an absolute sense; however,
    proper imaging through a"default camera"with focusing disabled depends
    only on ratios of the other properties, so the camera is still usable.
    However, it follows that if even one property is authored in the
    correct scene units, then they all must be.

    Linear Algebra in UsdGeom For any described attribute *Fallback*
    *Value* or *Allowed* *Values* below that are text/tokens, the actual
    token is published and defined in UsdGeomTokens. So to set an
    attribute to the value"rightHanded", use UsdGeomTokens->rightHanded as
    the value.
    """
    @staticmethod
    def CreateClippingPlanesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateClippingPlanesAttr(defaultValue, writeSparsely) -> Attribute


        See GetClippingPlanesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateClippingRangeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateClippingRangeAttr(defaultValue, writeSparsely) -> Attribute


        See GetClippingRangeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateExposureAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExposureAttr(defaultValue, writeSparsely) -> Attribute


        See GetExposureAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateFStopAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateFStopAttr(defaultValue, writeSparsely) -> Attribute


        See GetFStopAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateFocalLengthAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateFocalLengthAttr(defaultValue, writeSparsely) -> Attribute


        See GetFocalLengthAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateFocusDistanceAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateFocusDistanceAttr(defaultValue, writeSparsely) -> Attribute


        See GetFocusDistanceAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateHorizontalApertureAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateHorizontalApertureAttr(defaultValue, writeSparsely) -> Attribute


        See GetHorizontalApertureAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateHorizontalApertureOffsetAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateHorizontalApertureOffsetAttr(defaultValue, writeSparsely) -> Attribute


        See GetHorizontalApertureOffsetAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateProjectionAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateProjectionAttr(defaultValue, writeSparsely) -> Attribute


        See GetProjectionAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateShutterCloseAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateShutterCloseAttr(defaultValue, writeSparsely) -> Attribute


        See GetShutterCloseAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateShutterOpenAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateShutterOpenAttr(defaultValue, writeSparsely) -> Attribute


        See GetShutterOpenAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateStereoRoleAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateStereoRoleAttr(defaultValue, writeSparsely) -> Attribute


        See GetStereoRoleAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVerticalApertureAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVerticalApertureAttr(defaultValue, writeSparsely) -> Attribute


        See GetVerticalApertureAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVerticalApertureOffsetAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVerticalApertureOffsetAttr(defaultValue, writeSparsely) -> Attribute


        See GetVerticalApertureOffsetAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Camera


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Camera


        Return a UsdGeomCamera holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomCamera(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetCamera(time) -> Camera: 
        """
        GetCamera(time) -> Camera


        Creates a GfCamera object from the attribute values at ``time`` .


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def GetClippingPlanesAttr() -> Attribute: 
        """
        GetClippingPlanesAttr() -> Attribute


        Additional, arbitrarily oriented clipping planes.


        A vector (a,b,c,d) encodes a clipping plane that cuts off (x,y,z) with
        a \* x + b \* y + c \* z + d \* 1<0 where (x,y,z) are the
        coordinates in the camera's space.

        Declaration

        ``float4[] clippingPlanes = []``

        C++ Type

        VtArray<GfVec4f>

        Usd Type

        SdfValueTypeNames->Float4Array
        """
    @staticmethod
    def GetClippingRangeAttr() -> Attribute: 
        """
        GetClippingRangeAttr() -> Attribute


        Near and far clipping distances in scene units; see Units of Measure
        for Camera Properties.



        Declaration

        ``float2 clippingRange = (1, 1000000)``

        C++ Type

        GfVec2f

        Usd Type

        SdfValueTypeNames->Float2
        """
    @staticmethod
    def GetExposureAttr() -> Attribute: 
        """
        GetExposureAttr() -> Attribute


        Exposure adjustment, as a log base-2 value.


        The default of 0.0 has no effect. A value of 1.0 will double the
        image-plane intensities in a rendered image; a value of -1.0 will
        halve them.

        Declaration

        ``float exposure = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetFStopAttr() -> Attribute: 
        """
        GetFStopAttr() -> Attribute


        Lens aperture.


        Defaults to 0.0, which turns off focusing.

        Declaration

        ``float fStop = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetFocalLengthAttr() -> Attribute: 
        """
        GetFocalLengthAttr() -> Attribute


        Perspective focal length in tenths of a scene unit; see Units of
        Measure for Camera Properties.



        Declaration

        ``float focalLength = 50``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetFocusDistanceAttr() -> Attribute: 
        """
        GetFocusDistanceAttr() -> Attribute


        Distance from the camera to the focus plane in scene units; see Units
        of Measure for Camera Properties.



        Declaration

        ``float focusDistance = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetHorizontalApertureAttr() -> Attribute: 
        """
        GetHorizontalApertureAttr() -> Attribute


        Horizontal aperture in tenths of a scene unit; see Units of Measure
        for Camera Properties.


        Default is the equivalent of the standard 35mm spherical projector
        aperture.

        Declaration

        ``float horizontalAperture = 20.955``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetHorizontalApertureOffsetAttr() -> Attribute: 
        """
        GetHorizontalApertureOffsetAttr() -> Attribute


        Horizontal aperture offset in the same units as horizontalAperture.


        Defaults to 0.

        Declaration

        ``float horizontalApertureOffset = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetProjectionAttr() -> Attribute: 
        """
        GetProjectionAttr() -> Attribute



        Declaration

        ``token projection ="perspective"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Allowed Values

        perspective, orthographic
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetShutterCloseAttr() -> Attribute: 
        """
        GetShutterCloseAttr() -> Attribute


        Frame relative shutter close time, analogous comments from
        shutter:open apply.


        A value greater or equal to shutter:open should be authored, otherwise
        there is no exposure and a renderer should produce a black image.

        Declaration

        ``double shutter:close = 0``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetShutterOpenAttr() -> Attribute: 
        """
        GetShutterOpenAttr() -> Attribute


        Frame relative shutter open time in UsdTimeCode units (negative value
        indicates that the shutter opens before the current frame time).


        Used for motion blur.

        Declaration

        ``double shutter:open = 0``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetStereoRoleAttr() -> Attribute: 
        """
        GetStereoRoleAttr() -> Attribute


        If different from mono, the camera is intended to be the left or right
        camera of a stereo setup.



        Declaration

        ``uniform token stereoRole ="mono"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        mono, left, right
        """
    @staticmethod
    def GetVerticalApertureAttr() -> Attribute: 
        """
        GetVerticalApertureAttr() -> Attribute


        Vertical aperture in tenths of a scene unit; see Units of Measure for
        Camera Properties.


        Default is the equivalent of the standard 35mm spherical projector
        aperture.

        Declaration

        ``float verticalAperture = 15.2908``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetVerticalApertureOffsetAttr() -> Attribute: 
        """
        GetVerticalApertureOffsetAttr() -> Attribute


        Vertical aperture offset in the same units as verticalAperture.


        Defaults to 0.

        Declaration

        ``float verticalApertureOffset = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def SetFromCamera(camera, time) -> None: 
        """
        SetFromCamera(camera, time) -> None


        Write attribute values from ``camera`` for ``time`` .


        These attributes will be updated:

           - projection

           - horizontalAperture

           - horizontalApertureOffset

           - verticalAperture

           - verticalApertureOffset

           - focalLength

           - clippingRange

           - clippingPlanes

           - fStop

           - focalDistance

           - xformOpOrder and xformOp:transform

        This will clear any existing xformOpOrder and replace it with a single
        xformOp:transform entry. The xformOp:transform property is created or
        updated here to match the transform on ``camera`` . This operation
        will fail if there are stronger xform op opinions in the composed
        layer stack that are stronger than that of the current edit target.


        Parameters
        ----------
        camera : Camera

        time : TimeCode
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Capsule(Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Defines a primitive capsule, i.e. a cylinder capped by two half
    spheres, centered at the origin, whose spine is along the specified
    *axis*.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateAxisAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAxisAttr(defaultValue, writeSparsely) -> Attribute


        See GetAxisAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateExtentAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExtentAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateHeightAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateHeightAttr(defaultValue, writeSparsely) -> Attribute


        See GetHeightAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateRadiusAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateRadiusAttr(defaultValue, writeSparsely) -> Attribute


        See GetRadiusAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Capsule


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Capsule


        Return a UsdGeomCapsule holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomCapsule(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAxisAttr() -> Attribute: 
        """
        GetAxisAttr() -> Attribute


        The axis along which the spine of the capsule is aligned.



        Declaration

        ``uniform token axis ="Z"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        X, Y, Z
        """
    @staticmethod
    def GetExtentAttr() -> Attribute: 
        """
        GetExtentAttr() -> Attribute


        Extent is re-defined on Capsule only to provide a fallback value.



        UsdGeomGprim::GetExtentAttr() .

        Declaration

        ``float3[] extent = [(-0.5, -0.5, -1), (0.5, 0.5, 1)]``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Float3Array
        """
    @staticmethod
    def GetHeightAttr() -> Attribute: 
        """
        GetHeightAttr() -> Attribute


        The size of the capsule's spine along the specified *axis* excluding
        the size of the two half spheres, i.e.


        the size of the cylinder portion of the capsule. If you author
        *height* you must also author *extent*.

        Declaration

        ``double height = 1``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetRadiusAttr() -> Attribute: 
        """
        GetRadiusAttr() -> Attribute


        The radius of the capsule.


        If you author *radius* you must also author *extent*.

        Declaration

        ``double radius = 0.5``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Cone(Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Defines a primitive cone, centered at the origin, whose spine is along
    the specified *axis*, with the apex of the cone pointing in the
    direction of the positive axis.

    The fallback values for Cube, Sphere, Cone, and Cylinder are set so
    that they all pack into the same volume/bounds.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateAxisAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAxisAttr(defaultValue, writeSparsely) -> Attribute


        See GetAxisAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateExtentAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExtentAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateHeightAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateHeightAttr(defaultValue, writeSparsely) -> Attribute


        See GetHeightAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateRadiusAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateRadiusAttr(defaultValue, writeSparsely) -> Attribute


        See GetRadiusAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Cone


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Cone


        Return a UsdGeomCone holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomCone(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAxisAttr() -> Attribute: 
        """
        GetAxisAttr() -> Attribute


        The axis along which the spine of the cone is aligned.



        Declaration

        ``uniform token axis ="Z"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        X, Y, Z
        """
    @staticmethod
    def GetExtentAttr() -> Attribute: 
        """
        GetExtentAttr() -> Attribute


        Extent is re-defined on Cone only to provide a fallback value.



        UsdGeomGprim::GetExtentAttr() .

        Declaration

        ``float3[] extent = [(-1, -1, -1), (1, 1, 1)]``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Float3Array
        """
    @staticmethod
    def GetHeightAttr() -> Attribute: 
        """
        GetHeightAttr() -> Attribute


        The size of the cone's spine along the specified *axis*.


        If you author *height* you must also author *extent*.

        Declaration

        ``double height = 2``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetRadiusAttr() -> Attribute: 
        """
        GetRadiusAttr() -> Attribute


        The radius of the cone.


        If you author *radius* you must also author *extent*.

        Declaration

        ``double radius = 1``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class ConstraintTarget(Boost.Python.instance):
    """
    Schema wrapper for UsdAttribute for authoring and introspecting
    attributes that are constraint targets.

    Constraint targets correspond roughly to what some DCC's call
    locators. They are coordinate frames, represented as (animated or
    static) GfMatrix4d values. We represent them as attributes in USD
    rather than transformable prims because generally we require no other
    coordinated information about a constraint target other than its name
    and its matrix value, and because attributes are more concise than
    prims.

    Because consumer clients often care only about the identity and value
    of constraint targets and may be able to usefully consume them without
    caring about the actual geometry with which they may logically
    correspond, UsdGeom aggregates all constraint targets onto a model's
    root prim, assuming that an exporter will use property namespacing
    within the constraint target attribute's name to indicate a path to a
    prim within the model with which the constraint target may correspond.

    To facilitate instancing, and also position-tweaking of baked assets,
    we stipulate that constraint target values always be recorded in
    **model-relative transformation space**. In other words, to get the
    world-space value of a constraint target, transform it by the local-
    to-world transformation of the prim on which it is recorded.
    ComputeInWorldSpace() will perform this calculation.
    """
    @staticmethod
    def ComputeInWorldSpace(time, xfCache) -> Matrix4d: 
        """
        ComputeInWorldSpace(time, xfCache) -> Matrix4d


        Computes the value of the constraint target in world space.


        If a valid UsdGeomXformCache is provided in the argument ``xfCache`` ,
        it is used to evaluate the CTM of the model to which the constraint
        target belongs.

        To get the constraint value in model-space (or local space), simply
        use UsdGeomConstraintTarget::Get() , since the authored values must
        already be in model-space.


        Parameters
        ----------
        time : TimeCode

        xfCache : XformCache
        """
    @staticmethod
    def Get(value, time) -> bool: 
        """
        Get(value, time) -> bool


        Get the attribute value of the ConstraintTarget at ``time`` .


        Parameters
        ----------
        value : Matrix4d

        time : TimeCode
        """
    @staticmethod
    def GetAttr() -> Attribute: 
        """
        GetAttr() -> Attribute


        Explicit UsdAttribute extractor.
        """
    @staticmethod
    def GetConstraintAttrName(*args, **kwargs) -> None: 
        """
        **classmethod** GetConstraintAttrName(constraintName) -> str


        Returns the fully namespaced constraint attribute name, given the
        constraint name.


        Parameters
        ----------
        constraintName : str
        """
    @staticmethod
    def GetIdentifier() -> str: 
        """
        GetIdentifier() -> str


        Get the stored identifier unique to the enclosing model's namespace
        for this constraint target.
        """
    @staticmethod
    def IsDefined() -> bool: 
        """
        IsDefined() -> bool


        Return true if the wrapped UsdAttribute::IsDefined() , and in addition
        the attribute is identified as a ConstraintTarget.
        """
    @staticmethod
    def IsValid(*args, **kwargs) -> None: 
        """
        **classmethod** IsValid(attr) -> bool


        Test whether a given UsdAttribute represents valid ConstraintTarget,
        which implies that creating a UsdGeomConstraintTarget from the
        attribute will succeed.


        Success implies that ``attr.IsDefined()`` is true.


        Parameters
        ----------
        attr : Attribute
        """
    @staticmethod
    def Set(value, time) -> bool: 
        """
        Set(value, time) -> bool


        Set the attribute value of the ConstraintTarget at ``time`` .


        Parameters
        ----------
        value : Matrix4d

        time : TimeCode
        """
    @staticmethod
    def SetIdentifier(identifier) -> None: 
        """
        SetIdentifier(identifier) -> None


        Explicitly sets the stored identifier to the given string.


        Clients are responsible for ensuring the uniqueness of this identifier
        within the enclosing model's namespace.


        Parameters
        ----------
        identifier : str
        """
    __instance_size__ = 48
    pass
class Cube(Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Defines a primitive rectilinear cube centered at the origin.

    The fallback values for Cube, Sphere, Cone, and Cylinder are set so
    that they all pack into the same volume/bounds.
    """
    @staticmethod
    def CreateExtentAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExtentAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateSizeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateSizeAttr(defaultValue, writeSparsely) -> Attribute


        See GetSizeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Cube


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Cube


        Return a UsdGeomCube holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomCube(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetExtentAttr() -> Attribute: 
        """
        GetExtentAttr() -> Attribute


        Extent is re-defined on Cube only to provide a fallback value.



        UsdGeomGprim::GetExtentAttr() .

        Declaration

        ``float3[] extent = [(-1, -1, -1), (1, 1, 1)]``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Float3Array
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetSizeAttr() -> Attribute: 
        """
        GetSizeAttr() -> Attribute


        Indicates the length of each edge of the cube.


        If you author *size* you must also author *extent*.

        Declaration

        ``double size = 2``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class HermiteCurves(Curves, PointBased, Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    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).
    """
    class PointAndTangentArrays(Boost.Python.instance):
        @staticmethod
        def GetPoints(*args, **kwargs) -> None: ...
        @staticmethod
        def GetTangents(*args, **kwargs) -> None: ...
        @staticmethod
        def Interleave(*args, **kwargs) -> None: ...
        @staticmethod
        def IsEmpty(*args, **kwargs) -> None: ...
        @staticmethod
        def Separate(*args, **kwargs) -> None: ...
        __instance_size__ = 96
        pass
    @staticmethod
    def CreateTangentsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTangentsAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> HermiteCurves


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> HermiteCurves


        Return a UsdGeomHermiteCurves holding the prim adhering to this schema
        at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomHermiteCurves(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetTangentsAttr() -> Attribute: 
        """
        GetTangentsAttr() -> Attribute


        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
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Curves(PointBased, Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Base class for UsdGeomBasisCurves, UsdGeomNurbsCurves, and
    UsdGeomHermiteCurves. The BasisCurves schema is designed to be
    analagous to offline renderers'notion of batched curves (such as the
    classical RIB definition via Basis and Curves statements), while the
    NurbsCurve schema is designed to be analgous to the NURBS curves found
    in packages like Maya and Houdini while retaining their consistency
    with the RenderMan specification for NURBS Patches. HermiteCurves are
    useful for the interchange of animation guides and paths.

    It is safe to use the length of the curve vertex count to derive the
    number of curves and the number and layout of curve vertices, but this
    schema should NOT be used to derive the number of curve points. While
    vertex indices are implicit in all shipped descendent types of this
    schema, one should not assume that all internal or future shipped
    schemas will follow this pattern. Be sure to key any indexing behavior
    off the concrete type, not this abstract type.
    """
    @staticmethod
    def ComputeExtent(points, widths, transform, extent) -> bool: 
        """
        **classmethod** ComputeExtent(points, widths, extent) -> bool


        Compute the extent for the curves defined by points and widths.



        true upon success, false if unable to calculate extent. On success,
        extent will contain an approximate axis-aligned bounding box of the
        curve defined by points with the given widths.

        This function is to provide easy authoring of extent for usd authoring
        tools, hence it is static and acts outside a specific prim (as in
        attribute based methods).


        Parameters
        ----------
        points : Vec3fArray

        widths : FloatArray

        extent : Vec3fArray



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the extent as if the matrix ``transform`` was first applied.


        Parameters
        ----------
        points : Vec3fArray

        widths : FloatArray

        transform : Matrix4d

        extent : Vec3fArray
        """
    @staticmethod
    def CreateCurveVertexCountsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCurveVertexCountsAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateWidthsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateWidthsAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Curves


        Return a UsdGeomCurves holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomCurves(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetCurveCount(timeCode) -> int: 
        """
        GetCurveCount(timeCode) -> int


        Returns the number of curves as defined by the size of the
        *curveVertexCounts* array at *timeCode*.



        For most code, this check will be performant. When using file formats
        where the cost of attribute reading is high and the time sampled array
        will be read into memory later, it may be better to explicitly read
        the value once and check the size of the array directly.


        Parameters
        ----------
        timeCode : TimeCode
        """
    @staticmethod
    def GetCurveVertexCountsAttr() -> Attribute: 
        """
        GetCurveVertexCountsAttr() -> Attribute


        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
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetWidthsAttr() -> Attribute: 
        """
        GetWidthsAttr() -> Attribute


        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
        """
    @staticmethod
    def GetWidthsInterpolation() -> str: 
        """
        GetWidthsInterpolation() -> str


        Get the interpolation for the *widths* attribute.


        Although'widths'is not classified as a generic UsdGeomPrimvar (and
        will not be included in the results of
        UsdGeomPrimvarsAPI::GetPrimvars() ) it does require an interpolation
        specification. The fallback interpolation, if left unspecified, is
        UsdGeomTokens->vertex, which means a width value is specified at the
        end of each curve segment.
        """
    @staticmethod
    def SetWidthsInterpolation(interpolation) -> bool: 
        """
        SetWidthsInterpolation(interpolation) -> bool


        Set the interpolation for the *widths* attribute.



        true upon success, false if ``interpolation`` is not a legal value as
        defined by UsdPrimvar::IsValidInterpolation(), or if there was a
        problem setting the value. No attempt is made to validate that the
        widths attr's value contains the right number of elements to match its
        interpolation to its prim's topology.


        Parameters
        ----------
        interpolation : str
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Cylinder(Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Defines a primitive cylinder with closed ends, centered at the origin,
    whose spine is along the specified *axis*.

    The fallback values for Cube, Sphere, Cone, and Cylinder are set so
    that they all pack into the same volume/bounds.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateAxisAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAxisAttr(defaultValue, writeSparsely) -> Attribute


        See GetAxisAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateExtentAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExtentAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateHeightAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateHeightAttr(defaultValue, writeSparsely) -> Attribute


        See GetHeightAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateRadiusAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateRadiusAttr(defaultValue, writeSparsely) -> Attribute


        See GetRadiusAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Cylinder


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Cylinder


        Return a UsdGeomCylinder holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomCylinder(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAxisAttr() -> Attribute: 
        """
        GetAxisAttr() -> Attribute


        The axis along which the spine of the cylinder is aligned.



        Declaration

        ``uniform token axis ="Z"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        X, Y, Z
        """
    @staticmethod
    def GetExtentAttr() -> Attribute: 
        """
        GetExtentAttr() -> Attribute


        Extent is re-defined on Cylinder only to provide a fallback value.



        UsdGeomGprim::GetExtentAttr() .

        Declaration

        ``float3[] extent = [(-1, -1, -1), (1, 1, 1)]``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Float3Array
        """
    @staticmethod
    def GetHeightAttr() -> Attribute: 
        """
        GetHeightAttr() -> Attribute


        The size of the cylinder's spine along the specified *axis*.


        If you author *height* you must also author *extent*.

        Declaration

        ``double height = 2``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetRadiusAttr() -> Attribute: 
        """
        GetRadiusAttr() -> Attribute


        The radius of the cylinder.


        If you author *radius* you must also author *extent*.

        Declaration

        ``double radius = 1``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Mesh(PointBased, Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Encodes a mesh with optional subdivision properties and features.

    As a point-based primitive, meshes are defined in terms of points that
    are connected into edges and faces. Many references to meshes use the
    term'vertex'in place of or interchangeably with'points', while some
    use'vertex'to refer to the'face-vertices'that define a face. To avoid
    confusion, the term'vertex'is intentionally avoided in favor
    of'points'or'face-vertices'.

    The connectivity between points, edges and faces is encoded using a
    common minimal topological description of the faces of the mesh. Each
    face is defined by a set of face-vertices using indices into the
    Mesh's *points* array (inherited from UsdGeomPointBased) and laid out
    in a single linear *faceVertexIndices* array for efficiency. A
    companion *faceVertexCounts* array provides, for each face, the number
    of consecutive face-vertices in *faceVertexIndices* that define the
    face. No additional connectivity information is required or
    constructed, so no adjacency or neighborhood queries are available.

    A key property of this mesh schema is that it encodes both subdivision
    surfaces and simpler polygonal meshes. This is achieved by varying the
    *subdivisionScheme* attribute, which is set to specify Catmull-Clark
    subdivision by default, so polygonal meshes must always be explicitly
    declared. The available subdivision schemes and additional subdivision
    features encoded in optional attributes conform to the feature set of
    OpenSubdiv (
    https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html).

    **A Note About Primvars**

    The following list clarifies the number of elements for and the
    interpolation behavior of the different primvar interpolation types
    for meshes:

       - **constant** : One element for the entire mesh; no interpolation.

       - **uniform** : One element for each face of the mesh; elements are
         typically not interpolated but are inherited by other faces derived
         from a given face (via subdivision, tessellation, etc.).

       - **varying** : One element for each point of the mesh;
         interpolation of point data is always linear.

       - **vertex** : One element for each point of the mesh;
         interpolation of point data is applied according to the
         *subdivisionScheme* attribute.

       - **faceVarying** : One element for each of the face-vertices that
         define the mesh topology; interpolation of face-vertex data may be
         smooth or linear, according to the *subdivisionScheme* and
         *faceVaryingLinearInterpolation* attributes.

    Primvar interpolation types and related utilities are described more
    generally in Interpolation of Geometric Primitive Variables.

    **A Note About Normals**

    Normals should not be authored on a subdivision mesh, since
    subdivision algorithms define their own normals. They should only be
    authored for polygonal meshes ( *subdivisionScheme* ="none").

    The *normals* attribute inherited from UsdGeomPointBased is not a
    generic primvar, but the number of elements in this attribute will be
    determined by its *interpolation*. See
    UsdGeomPointBased::GetNormalsInterpolation() . If *normals* and
    *primvars:normals* are both specified, the latter has precedence. If a
    polygonal mesh specifies **neither** *normals* nor *primvars:normals*,
    then it should be treated and rendered as faceted, with no attempt to
    compute smooth normals.

    The normals generated for smooth subdivision schemes, e.g. Catmull-
    Clark and Loop, will likewise be smooth, but others, e.g. Bilinear,
    may be discontinuous between faces and/or within non-planar irregular
    faces.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateCornerIndicesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCornerIndicesAttr(defaultValue, writeSparsely) -> Attribute


        See GetCornerIndicesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateCornerSharpnessesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCornerSharpnessesAttr(defaultValue, writeSparsely) -> Attribute


        See GetCornerSharpnessesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateCreaseIndicesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCreaseIndicesAttr(defaultValue, writeSparsely) -> Attribute


        See GetCreaseIndicesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateCreaseLengthsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCreaseLengthsAttr(defaultValue, writeSparsely) -> Attribute


        See GetCreaseLengthsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateCreaseSharpnessesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCreaseSharpnessesAttr(defaultValue, writeSparsely) -> Attribute


        See GetCreaseSharpnessesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateFaceVaryingLinearInterpolationAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateFaceVaryingLinearInterpolationAttr(defaultValue, writeSparsely) -> Attribute


        See GetFaceVaryingLinearInterpolationAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateFaceVertexCountsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateFaceVertexCountsAttr(defaultValue, writeSparsely) -> Attribute


        See GetFaceVertexCountsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateFaceVertexIndicesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateFaceVertexIndicesAttr(defaultValue, writeSparsely) -> Attribute


        See GetFaceVertexIndicesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateHoleIndicesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateHoleIndicesAttr(defaultValue, writeSparsely) -> Attribute


        See GetHoleIndicesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateInterpolateBoundaryAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateInterpolateBoundaryAttr(defaultValue, writeSparsely) -> Attribute


        See GetInterpolateBoundaryAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateSubdivisionSchemeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateSubdivisionSchemeAttr(defaultValue, writeSparsely) -> Attribute


        See GetSubdivisionSchemeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTriangleSubdivisionRuleAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTriangleSubdivisionRuleAttr(defaultValue, writeSparsely) -> Attribute


        See GetTriangleSubdivisionRuleAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Mesh


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Mesh


        Return a UsdGeomMesh holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomMesh(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetCornerIndicesAttr() -> Attribute: 
        """
        GetCornerIndicesAttr() -> Attribute


        The indices of points for which a corresponding sharpness value is
        specified in *cornerSharpnesses* (so the size of this array must match
        that of *cornerSharpnesses*).



        Declaration

        ``int[] cornerIndices = []``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetCornerSharpnessesAttr() -> Attribute: 
        """
        GetCornerSharpnessesAttr() -> Attribute


        The sharpness values associated with a corresponding set of points
        specified in *cornerIndices* (so the size of this array must match
        that of *cornerIndices*).


        Use the constant ``SHARPNESS_INFINITE`` for a perfectly sharp corner.

        Declaration

        ``float[] cornerSharpnesses = []``

        C++ Type

        VtArray<float>

        Usd Type

        SdfValueTypeNames->FloatArray
        """
    @staticmethod
    def GetCreaseIndicesAttr() -> Attribute: 
        """
        GetCreaseIndicesAttr() -> Attribute


        The indices of points grouped into sets of successive pairs that
        identify edges to be creased.


        The size of this array must be equal to the sum of all elements of the
        *creaseLengths* attribute.

        Declaration

        ``int[] creaseIndices = []``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetCreaseLengthsAttr() -> Attribute: 
        """
        GetCreaseLengthsAttr() -> Attribute


        The length of this array specifies the number of creases (sets of
        adjacent sharpened edges) on the mesh.


        Each element gives the number of points of each crease, whose indices
        are successively laid out in the *creaseIndices* attribute. Since each
        crease must be at least one edge long, each element of this array must
        be at least two.

        Declaration

        ``int[] creaseLengths = []``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetCreaseSharpnessesAttr() -> Attribute: 
        """
        GetCreaseSharpnessesAttr() -> Attribute


        The per-crease or per-edge sharpness values for all creases.


        Since *creaseLengths* encodes the number of points in each crease, the
        number of elements in this array will be either len(creaseLengths) or
        the sum over all X of (creaseLengths[X] - 1). Note that while the RI
        spec allows each crease to have either a single sharpness or a value
        per-edge, USD will encode either a single sharpness per crease on a
        mesh, or sharpnesses for all edges making up the creases on a mesh.
        Use the constant ``SHARPNESS_INFINITE`` for a perfectly sharp crease.

        Declaration

        ``float[] creaseSharpnesses = []``

        C++ Type

        VtArray<float>

        Usd Type

        SdfValueTypeNames->FloatArray
        """
    @staticmethod
    def GetFaceCount(timeCode) -> int: 
        """
        GetFaceCount(timeCode) -> int


        Returns the number of faces as defined by the size of the
        *faceVertexCounts* array at *timeCode*.



        For most code, this check will be performant. When using file formats
        where the cost of attribute reading is high and the time sampled array
        will be read into memory later, it may be better to explicitly read
        the value once and check the size of the array directly.


        Parameters
        ----------
        timeCode : TimeCode
        """
    @staticmethod
    def GetFaceVaryingLinearInterpolationAttr() -> Attribute: 
        """
        GetFaceVaryingLinearInterpolationAttr() -> Attribute


        Specifies how elements of a primvar of interpolation
        type"faceVarying"are interpolated for subdivision surfaces.


        Interpolation can be as smooth as a"vertex"primvar or constrained to
        be linear at features specified by several options. Valid values
        correspond to choices available in OpenSubdiv:

           - **none** : No linear constraints or sharpening, smooth everywhere

           - **cornersOnly** : Sharpen corners of discontinuous boundaries
             only, smooth everywhere else

           - **cornersPlus1** : The default, same as"cornersOnly"plus
             additional sharpening at points where three or more distinct face-
             varying values occur

           - **cornersPlus2** : Same as"cornersPlus1"plus additional
             sharpening at points with at least one discontinuous boundary corner
             or only one discontinuous boundary edge (a dart)

           - **boundaries** : Piecewise linear along discontinuous boundaries,
             smooth interior

           - **all** : Piecewise linear everywhere

        These are illustrated and described in more detail in the OpenSubdiv
        documentation:
        https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#face-
        varying-interpolation-rules

        Declaration

        ``token faceVaryingLinearInterpolation ="cornersPlus1"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Allowed Values

        none, cornersOnly, cornersPlus1, cornersPlus2, boundaries, all
        """
    @staticmethod
    def GetFaceVertexCountsAttr() -> Attribute: 
        """
        GetFaceVertexCountsAttr() -> Attribute


        Provides the number of vertices in each face of the mesh, which is
        also the number of consecutive indices in *faceVertexIndices* that
        define the face.


        The length of this attribute is the number of faces in the mesh. If
        this attribute has more than one timeSample, the mesh is considered to
        be topologically varying.

        Declaration

        ``int[] faceVertexCounts``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetFaceVertexIndicesAttr() -> Attribute: 
        """
        GetFaceVertexIndicesAttr() -> Attribute


        Flat list of the index (into the *points* attribute) of each vertex of
        each face in the mesh.


        If this attribute has more than one timeSample, the mesh is considered
        to be topologically varying.

        Declaration

        ``int[] faceVertexIndices``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetHoleIndicesAttr() -> Attribute: 
        """
        GetHoleIndicesAttr() -> Attribute


        The indices of all faces that should be treated as holes, i.e.


        made invisible. This is traditionally a feature of subdivision
        surfaces and not generally applied to polygonal meshes.

        Declaration

        ``int[] holeIndices = []``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetInterpolateBoundaryAttr() -> Attribute: 
        """
        GetInterpolateBoundaryAttr() -> Attribute


        Specifies how subdivision is applied for faces adjacent to boundary
        edges and boundary points.


        Valid values correspond to choices available in OpenSubdiv:

           - **none** : No boundary interpolation is applied and boundary
             faces are effectively treated as holes

           - **edgeOnly** : A sequence of boundary edges defines a smooth
             curve to which the edges of subdivided boundary faces converge

           - **edgeAndCorner** : The default, similar to"edgeOnly"but the
             smooth boundary curve is made sharp at corner points

        These are illustrated and described in more detail in the OpenSubdiv
        documentation:
        https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#boundary-
        interpolation-rules

        Declaration

        ``token interpolateBoundary ="edgeAndCorner"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Allowed Values

        none, edgeOnly, edgeAndCorner
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetSubdivisionSchemeAttr() -> Attribute: 
        """
        GetSubdivisionSchemeAttr() -> Attribute


        The subdivision scheme to be applied to the surface.


        Valid values are:

           - **catmullClark** : The default, Catmull-Clark subdivision;
             preferred for quad-dominant meshes (generalizes B-splines);
             interpolation of point data is smooth (non-linear)

           - **loop** : Loop subdivision; preferred for purely triangular
             meshes; interpolation of point data is smooth (non-linear)

           - **bilinear** : Subdivision reduces all faces to quads
             (topologically similar to"catmullClark"); interpolation of point data
             is bilinear

           - **none** : No subdivision, i.e. a simple polygonal mesh;
             interpolation of point data is linear

        Polygonal meshes are typically lighter weight and faster to render,
        depending on renderer and render mode. Use of"bilinear"will produce a
        similar shape to a polygonal mesh and may offer additional guarantees
        of watertightness and additional subdivision features (e.g. holes) but
        may also not respect authored normals.

        Declaration

        ``uniform token subdivisionScheme ="catmullClark"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        catmullClark, loop, bilinear, none
        """
    @staticmethod
    def GetTriangleSubdivisionRuleAttr() -> Attribute: 
        """
        GetTriangleSubdivisionRuleAttr() -> Attribute


        Specifies an option to the subdivision rules for the Catmull-Clark
        scheme to try and improve undesirable artifacts when subdividing
        triangles.


        Valid values are"catmullClark"for the standard rules (the default)
        and"smooth"for the improvement.

        See
        https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#triangle-
        subdivision-rule

        Declaration

        ``token triangleSubdivisionRule ="catmullClark"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Allowed Values

        catmullClark, smooth
        """
    @staticmethod
    def ValidateTopology(*args, **kwargs) -> None: 
        """
        **classmethod** ValidateTopology(faceVertexIndices, faceVertexCounts, numPoints, reason) -> bool


        Validate the topology of a mesh.


        This validates that the sum of ``faceVertexCounts`` is equal to the
        size of the ``faceVertexIndices`` array, and that all face vertex
        indices in the ``faceVertexIndices`` array are in the range [0,
        numPoints). Returns true if the topology is valid, or false otherwise.
        If the topology is invalid and ``reason`` is non-null, an error
        message describing the validation error will be set.


        Parameters
        ----------
        faceVertexIndices : IntArray

        faceVertexCounts : IntArray

        numPoints : int

        reason : str
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    SHARPNESS_INFINITE = 10.0
    __instance_size__ = 40
    pass
class NurbsCurves(Curves, PointBased, Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    This schema is analagous to NURBS Curves in packages like Maya and
    Houdini, often used for interchange of rigging and modeling curves.
    Unlike Maya, this curve spec supports batching of multiple curves into
    a single prim, widths, and normals in the schema. Additionally, we
    require'numSegments + 2 \* degree + 1'knots (2 more than maya does).
    This is to be more consistent with RenderMan's NURBS patch
    specification.

    To express a periodic curve:

       - knot[0] = knot[1] - (knots[-2] - knots[-3];

       - knot[-1] = knot[-2] + (knot[2] - knots[1]);

    To express a nonperiodic curve:

       - knot[0] = knot[1];

       - knot[-1] = knot[-2];

    In spite of these slight differences in the spec, curves generated in
    Maya should be preserved when roundtripping.

    *order* and *range*, when representing a batched NurbsCurve should be
    authored one value per curve. *knots* should be the concatentation of
    all batched curves.

    **NurbsCurve Form**

    **Form** is provided as an aid to interchange between modeling and
    animation applications so that they can robustly identify the intent
    with which the surface was modelled, and take measures (if they are
    able) to preserve the continuity/concidence constraints as the surface
    may be rigged or deformed.

       - An *open-form* NurbsCurve has no continuity constraints.

       - A *closed-form* NurbsCurve expects the first and last control
         points to overlap

       - A *periodic-form* NurbsCurve expects the first and last *order* -
         1 control points to overlap.
         For any described attribute *Fallback* *Value* or *Allowed* *Values*
         below that are text/tokens, the actual token is published and defined
         in UsdGeomTokens. So to set an attribute to the value"rightHanded",
         use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateFormAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateFormAttr(defaultValue, writeSparsely) -> Attribute


        See GetFormAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateKnotsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateKnotsAttr(defaultValue, writeSparsely) -> Attribute


        See GetKnotsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateOrderAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateOrderAttr(defaultValue, writeSparsely) -> Attribute


        See GetOrderAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreatePointWeightsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreatePointWeightsAttr(defaultValue, writeSparsely) -> Attribute


        See GetPointWeightsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateRangesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateRangesAttr(defaultValue, writeSparsely) -> Attribute


        See GetRangesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> NurbsCurves


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> NurbsCurves


        Return a UsdGeomNurbsCurves holding the prim adhering to this schema
        at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomNurbsCurves(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetFormAttr() -> Attribute: 
        """
        GetFormAttr() -> Attribute


        Interpret the control grid and knot vectors as representing an open,
        geometrically closed, or geometrically closed and C2 continuous curve.



        NurbsCurve Form

        Declaration

        ``uniform token form ="open"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        open, closed, periodic
        """
    @staticmethod
    def GetKnotsAttr() -> Attribute: 
        """
        GetKnotsAttr() -> Attribute


        Knot vector providing curve parameterization.


        The length of the slice of the array for the ith curve must be (
        curveVertexCount[i] + order[i] ), and its entries must take on
        monotonically increasing values.

        Declaration

        ``double[] knots``

        C++ Type

        VtArray<double>

        Usd Type

        SdfValueTypeNames->DoubleArray
        """
    @staticmethod
    def GetOrderAttr() -> Attribute: 
        """
        GetOrderAttr() -> Attribute


        Order of the curve.


        Order must be positive and is equal to the degree of the polynomial
        basis to be evaluated, plus 1. Its value for the'i'th curve must be
        less than or equal to curveVertexCount[i]

        Declaration

        ``int[] order = []``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetPointWeightsAttr() -> Attribute: 
        """
        GetPointWeightsAttr() -> Attribute


        Optionally provides"w"components for each control point, thus must be
        the same length as the points attribute.


        If authored, the patch will be rational. If unauthored, the patch will
        be polynomial, i.e. weight for all points is 1.0.

        Some DCC's pre-weight the *points*, but in this schema, *points* are
        not pre-weighted.

        Declaration

        ``double[] pointWeights``

        C++ Type

        VtArray<double>

        Usd Type

        SdfValueTypeNames->DoubleArray
        """
    @staticmethod
    def GetRangesAttr() -> Attribute: 
        """
        GetRangesAttr() -> Attribute


        Provides the minimum and maximum parametric values (as defined by
        knots) over which the curve is actually defined.


        The minimum must be less than the maximum, and greater than or equal
        to the value of the knots['i'th curve slice][order[i]-1]. The maxium
        must be less than or equal to the last element's value in knots['i'th
        curve slice]. Range maps to (vmin, vmax) in the RenderMan spec.

        Declaration

        ``double2[] ranges``

        C++ Type

        VtArray<GfVec2d>

        Usd Type

        SdfValueTypeNames->Double2Array
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class NurbsPatch(PointBased, Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Encodes a rational or polynomial non-uniform B-spline surface, with
    optional trim curves.

    The encoding mostly follows that of RiNuPatch and RiTrimCurve:
    https://renderman.pixar.com/resources/current/RenderMan/geometricPrimitives.html#rinupatch,
    with some minor renaming and coalescing for clarity.

    The layout of control vertices in the *points* attribute inherited
    from UsdGeomPointBased is row-major with U considered rows, and V
    columns.

    **NurbsPatch Form**

    The authored points, orders, knots, weights, and ranges are all that
    is required to render the nurbs patch. However, the only way to model
    closed surfaces with nurbs is to ensure that the first and last
    control points along the given axis are coincident. Similarly, to
    ensure the surface is not only closed but also C2 continuous, the last
    *order* - 1 control points must be (correspondingly) coincident with
    the first *order* - 1 control points, and also the spacing of the last
    corresponding knots must be the same as the first corresponding knots.

    **Form** is provided as an aid to interchange between modeling and
    animation applications so that they can robustly identify the intent
    with which the surface was modelled, and take measures (if they are
    able) to preserve the continuity/concidence constraints as the surface
    may be rigged or deformed.

       - An *open-form* NurbsPatch has no continuity constraints.

       - A *closed-form* NurbsPatch expects the first and last control
         points to overlap

       - A *periodic-form* NurbsPatch expects the first and last *order* -
         1 control points to overlap.
         **Nurbs vs Subdivision Surfaces**

    Nurbs are an important modeling primitive in CAD/CAM tools and early
    computer graphics DCC's. Because they have a natural UV
    parameterization they easily support"trim curves", which allow smooth
    shapes to be carved out of the surface.

    However, the topology of the patch is always rectangular, and joining
    two nurbs patches together (especially when they have differing
    numbers of spans) is difficult to do smoothly. Also, nurbs are not
    supported by the Ptex texturing technology ( http://ptex.us).

    Neither of these limitations are shared by subdivision surfaces;
    therefore, although they do not subscribe to trim-curve-based shaping,
    subdivs are often considered a more flexible modeling primitive.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreatePointWeightsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreatePointWeightsAttr(defaultValue, writeSparsely) -> Attribute


        See GetPointWeightsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTrimCurveCountsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTrimCurveCountsAttr(defaultValue, writeSparsely) -> Attribute


        See GetTrimCurveCountsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTrimCurveKnotsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTrimCurveKnotsAttr(defaultValue, writeSparsely) -> Attribute


        See GetTrimCurveKnotsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTrimCurveOrdersAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTrimCurveOrdersAttr(defaultValue, writeSparsely) -> Attribute


        See GetTrimCurveOrdersAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTrimCurvePointsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTrimCurvePointsAttr(defaultValue, writeSparsely) -> Attribute


        See GetTrimCurvePointsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTrimCurveRangesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTrimCurveRangesAttr(defaultValue, writeSparsely) -> Attribute


        See GetTrimCurveRangesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTrimCurveVertexCountsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTrimCurveVertexCountsAttr(defaultValue, writeSparsely) -> Attribute


        See GetTrimCurveVertexCountsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateUFormAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateUFormAttr(defaultValue, writeSparsely) -> Attribute


        See GetUFormAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateUKnotsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateUKnotsAttr(defaultValue, writeSparsely) -> Attribute


        See GetUKnotsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateUOrderAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateUOrderAttr(defaultValue, writeSparsely) -> Attribute


        See GetUOrderAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateURangeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateURangeAttr(defaultValue, writeSparsely) -> Attribute


        See GetURangeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateUVertexCountAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateUVertexCountAttr(defaultValue, writeSparsely) -> Attribute


        See GetUVertexCountAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVFormAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVFormAttr(defaultValue, writeSparsely) -> Attribute


        See GetVFormAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVKnotsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVKnotsAttr(defaultValue, writeSparsely) -> Attribute


        See GetVKnotsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVOrderAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVOrderAttr(defaultValue, writeSparsely) -> Attribute


        See GetVOrderAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVRangeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVRangeAttr(defaultValue, writeSparsely) -> Attribute


        See GetVRangeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVVertexCountAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVVertexCountAttr(defaultValue, writeSparsely) -> Attribute


        See GetVVertexCountAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> NurbsPatch


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> NurbsPatch


        Return a UsdGeomNurbsPatch holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomNurbsPatch(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetPointWeightsAttr() -> Attribute: 
        """
        GetPointWeightsAttr() -> Attribute


        Optionally provides"w"components for each control point, thus must be
        the same length as the points attribute.


        If authored, the patch will be rational. If unauthored, the patch will
        be polynomial, i.e. weight for all points is 1.0.

        Some DCC's pre-weight the *points*, but in this schema, *points* are
        not pre-weighted.

        Declaration

        ``double[] pointWeights``

        C++ Type

        VtArray<double>

        Usd Type

        SdfValueTypeNames->DoubleArray
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetTrimCurveCountsAttr() -> Attribute: 
        """
        GetTrimCurveCountsAttr() -> Attribute


        Each element specifies how many curves are present in each"loop"of the
        trimCurve, and the length of the array determines how many loops the
        trimCurve contains.


        The sum of all elements is the total nuber of curves in the trim, to
        which we will refer as *nCurves* in describing the other trim
        attributes.

        Declaration

        ``int[] trimCurve:counts``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetTrimCurveKnotsAttr() -> Attribute: 
        """
        GetTrimCurveKnotsAttr() -> Attribute


        Flat list of parametric values for each of the *nCurves* curves.


        There will be as many knots as the sum over all elements of
        *vertexCounts* plus the sum over all elements of *orders*.

        Declaration

        ``double[] trimCurve:knots``

        C++ Type

        VtArray<double>

        Usd Type

        SdfValueTypeNames->DoubleArray
        """
    @staticmethod
    def GetTrimCurveOrdersAttr() -> Attribute: 
        """
        GetTrimCurveOrdersAttr() -> Attribute


        Flat list of orders for each of the *nCurves* curves.



        Declaration

        ``int[] trimCurve:orders``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetTrimCurvePointsAttr() -> Attribute: 
        """
        GetTrimCurvePointsAttr() -> Attribute


        Flat list of homogeneous 2D points (u, v, w) that comprise the
        *nCurves* curves.


        The number of points should be equal to the um over all elements of
        *vertexCounts*.

        Declaration

        ``double3[] trimCurve:points``

        C++ Type

        VtArray<GfVec3d>

        Usd Type

        SdfValueTypeNames->Double3Array
        """
    @staticmethod
    def GetTrimCurveRangesAttr() -> Attribute: 
        """
        GetTrimCurveRangesAttr() -> Attribute


        Flat list of minimum and maximum parametric values (as defined by
        *knots*) for each of the *nCurves* curves.



        Declaration

        ``double2[] trimCurve:ranges``

        C++ Type

        VtArray<GfVec2d>

        Usd Type

        SdfValueTypeNames->Double2Array
        """
    @staticmethod
    def GetTrimCurveVertexCountsAttr() -> Attribute: 
        """
        GetTrimCurveVertexCountsAttr() -> Attribute


        Flat list of number of vertices for each of the *nCurves* curves.



        Declaration

        ``int[] trimCurve:vertexCounts``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetUFormAttr() -> Attribute: 
        """
        GetUFormAttr() -> Attribute


        Interpret the control grid and knot vectors as representing an open,
        geometrically closed, or geometrically closed and C2 continuous
        surface along the U dimension.



        NurbsPatch Form

        Declaration

        ``uniform token uForm ="open"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        open, closed, periodic
        """
    @staticmethod
    def GetUKnotsAttr() -> Attribute: 
        """
        GetUKnotsAttr() -> Attribute


        Knot vector for U direction providing U parameterization.


        The length of this array must be ( uVertexCount + uOrder), and its
        entries must take on monotonically increasing values.

        Declaration

        ``double[] uKnots``

        C++ Type

        VtArray<double>

        Usd Type

        SdfValueTypeNames->DoubleArray
        """
    @staticmethod
    def GetUOrderAttr() -> Attribute: 
        """
        GetUOrderAttr() -> Attribute


        Order in the U direction.


        Order must be positive and is equal to the degree of the polynomial
        basis to be evaluated, plus 1.

        Declaration

        ``int uOrder``

        C++ Type

        int

        Usd Type

        SdfValueTypeNames->Int
        """
    @staticmethod
    def GetURangeAttr() -> Attribute: 
        """
        GetURangeAttr() -> Attribute


        Provides the minimum and maximum parametric values (as defined by
        uKnots) over which the surface is actually defined.


        The minimum must be less than the maximum, and greater than or equal
        to the value of uKnots[uOrder-1]. The maxium must be less than or
        equal to the last element's value in uKnots.

        Declaration

        ``double2 uRange``

        C++ Type

        GfVec2d

        Usd Type

        SdfValueTypeNames->Double2
        """
    @staticmethod
    def GetUVertexCountAttr() -> Attribute: 
        """
        GetUVertexCountAttr() -> Attribute


        Number of vertices in the U direction.


        Should be at least as large as uOrder.

        Declaration

        ``int uVertexCount``

        C++ Type

        int

        Usd Type

        SdfValueTypeNames->Int
        """
    @staticmethod
    def GetVFormAttr() -> Attribute: 
        """
        GetVFormAttr() -> Attribute


        Interpret the control grid and knot vectors as representing an open,
        geometrically closed, or geometrically closed and C2 continuous
        surface along the V dimension.



        NurbsPatch Form

        Declaration

        ``uniform token vForm ="open"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        open, closed, periodic
        """
    @staticmethod
    def GetVKnotsAttr() -> Attribute: 
        """
        GetVKnotsAttr() -> Attribute


        Knot vector for V direction providing U parameterization.


        The length of this array must be ( vVertexCount + vOrder), and its
        entries must take on monotonically increasing values.

        Declaration

        ``double[] vKnots``

        C++ Type

        VtArray<double>

        Usd Type

        SdfValueTypeNames->DoubleArray
        """
    @staticmethod
    def GetVOrderAttr() -> Attribute: 
        """
        GetVOrderAttr() -> Attribute


        Order in the V direction.


        Order must be positive and is equal to the degree of the polynomial
        basis to be evaluated, plus 1.

        Declaration

        ``int vOrder``

        C++ Type

        int

        Usd Type

        SdfValueTypeNames->Int
        """
    @staticmethod
    def GetVRangeAttr() -> Attribute: 
        """
        GetVRangeAttr() -> Attribute


        Provides the minimum and maximum parametric values (as defined by
        vKnots) over which the surface is actually defined.


        The minimum must be less than the maximum, and greater than or equal
        to the value of vKnots[vOrder-1]. The maxium must be less than or
        equal to the last element's value in vKnots.

        Declaration

        ``double2 vRange``

        C++ Type

        GfVec2d

        Usd Type

        SdfValueTypeNames->Double2
        """
    @staticmethod
    def GetVVertexCountAttr() -> Attribute: 
        """
        GetVVertexCountAttr() -> Attribute


        Number of vertices in the V direction.


        Should be at least as large as vOrder.

        Declaration

        ``int vVertexCount``

        C++ Type

        int

        Usd Type

        SdfValueTypeNames->Int
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Plane(Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Defines a primitive plane, centered at the origin, and is defined by a
    cardinal axis, width, and length. The plane is double-sided by
    default.

    The axis of width and length are perpendicular to the plane's *axis*:

    axis

    width

    length

    X

    z-axis

    y-axis

    Y

    x-axis

    z-axis

    Z

    x-axis

    y-axis

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateAxisAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAxisAttr(defaultValue, writeSparsely) -> Attribute


        See GetAxisAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateDoubleSidedAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDoubleSidedAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateExtentAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExtentAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateLengthAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateLengthAttr(defaultValue, writeSparsely) -> Attribute


        See GetLengthAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateWidthAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateWidthAttr(defaultValue, writeSparsely) -> Attribute


        See GetWidthAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Plane


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Plane


        Return a UsdGeomPlane holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomPlane(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAxisAttr() -> Attribute: 
        """
        GetAxisAttr() -> Attribute


        The axis along which the surface of the plane is aligned.


        When set to'Z'the plane is in the xy-plane; when *axis* is'X'the plane
        is in the yz-plane, and when *axis* is'Y'the plane is in the xz-plane.

        UsdGeomGprim::GetAxisAttr().

        Declaration

        ``uniform token axis ="Z"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        X, Y, Z
        """
    @staticmethod
    def GetDoubleSidedAttr() -> Attribute: 
        """
        GetDoubleSidedAttr() -> Attribute


        Planes are double-sided by default.


        Clients may also support single-sided planes.

        UsdGeomGprim::GetDoubleSidedAttr()

        Declaration

        ``uniform bool doubleSided = 1``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool

        Variability

        SdfVariabilityUniform
        """
    @staticmethod
    def GetExtentAttr() -> Attribute: 
        """
        GetExtentAttr() -> Attribute


        Extent is re-defined on Plane only to provide a fallback value.



        UsdGeomGprim::GetExtentAttr() .

        Declaration

        ``float3[] extent = [(-1, -1, 0), (1, 1, 0)]``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Float3Array
        """
    @staticmethod
    def GetLengthAttr() -> Attribute: 
        """
        GetLengthAttr() -> Attribute


        The length of the plane, which aligns to the y-axis when *axis*
        is'Z'or'X', or to the z-axis when *axis* is'Y'.


        If you author *length* you must also author *extent*.

        UsdGeomGprim::GetExtentAttr()

        Declaration

        ``double length = 2``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetWidthAttr() -> Attribute: 
        """
        GetWidthAttr() -> Attribute


        The width of the plane, which aligns to the x-axis when *axis*
        is'Z'or'Y', or to the z-axis when *axis* is'X'.


        If you author *width* you must also author *extent*.

        UsdGeomGprim::GetExtentAttr()

        Declaration

        ``double width = 2``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Points(PointBased, Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Points are analogous to the RiPoints spec.

    Points can be an efficient means of storing and rendering particle
    effects comprised of thousands or millions of small particles. Points
    generally receive a single shading sample each, which should take
    *normals* into account, if present.

    While not technically UsdGeomPrimvars, the widths and normals also
    have interpolation metadata. It's common for authored widths and
    normals to have constant or varying interpolation.
    """
    @staticmethod
    def ComputeExtent(points, widths, transform, extent) -> bool: 
        """
        **classmethod** ComputeExtent(points, widths, extent) -> bool


        Compute the extent for the point cloud defined by points and widths.



        true upon success, false if widths and points are different sized
        arrays. On success, extent will contain the axis-aligned bounding box
        of the point cloud defined by points with the given widths.

        This function is to provide easy authoring of extent for usd authoring
        tools, hence it is static and acts outside a specific prim (as in
        attribute based methods).


        Parameters
        ----------
        points : Vec3fArray

        widths : FloatArray

        extent : Vec3fArray



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the extent as if the matrix ``transform`` was first applied.


        Parameters
        ----------
        points : Vec3fArray

        widths : FloatArray

        transform : Matrix4d

        extent : Vec3fArray
        """
    @staticmethod
    def CreateIdsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateIdsAttr(defaultValue, writeSparsely) -> Attribute


        See GetIdsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateWidthsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateWidthsAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Points


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Points


        Return a UsdGeomPoints holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomPoints(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetIdsAttr() -> Attribute: 
        """
        GetIdsAttr() -> Attribute


        Ids are optional; if authored, the ids array should be the same length
        as the points array, specifying (at each timesample if point
        identities are changing) the id of each point.


        The type is signed intentionally, so that clients can encode some
        binary state on Id'd points without adding a separate primvar.

        Declaration

        ``int64[] ids``

        C++ Type

        VtArray<int64_t>

        Usd Type

        SdfValueTypeNames->Int64Array
        """
    @staticmethod
    def GetPointCount(timeCode) -> int: 
        """
        GetPointCount(timeCode) -> int


        Returns the number of points as defined by the size of the *points*
        array at *timeCode*.



        For most code, this check will be performant. When using file formats
        where the cost of attribute reading is high and the time sampled array
        will be read into memory later, it may be better to explicitly read
        the value once and check the size of the array directly.


        Parameters
        ----------
        timeCode : TimeCode
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetWidthsAttr() -> Attribute: 
        """
        GetWidthsAttr() -> Attribute


        Widths are defined as the *diameter* of the points, in object space.


        '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
        """
    @staticmethod
    def GetWidthsInterpolation() -> str: 
        """
        GetWidthsInterpolation() -> str


        Get the interpolation for the *widths* attribute.


        Although'widths'is not classified as a generic UsdGeomPrimvar (and
        will not be included in the results of
        UsdGeomPrimvarsAPI::GetPrimvars() ) it does require an interpolation
        specification. The fallback interpolation, if left unspecified, is
        UsdGeomTokens->vertex, which means a width value is specified for each
        point.
        """
    @staticmethod
    def SetWidthsInterpolation(interpolation) -> bool: 
        """
        SetWidthsInterpolation(interpolation) -> bool


        Set the interpolation for the *widths* attribute.



        true upon success, false if ``interpolation`` is not a legal value as
        defined by UsdPrimvar::IsValidInterpolation(), or if there was a
        problem setting the value. No attempt is made to validate that the
        widths attr's value contains the right number of elements to match its
        interpolation to its prim's topology.


        Parameters
        ----------
        interpolation : str
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class PointBased(Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Base class for all UsdGeomGprims that possess points, providing common
    attributes such as normals and velocities.
    """
    @staticmethod
    def ComputeExtent(points, transform, extent) -> bool: 
        """
        **classmethod** ComputeExtent(points, extent) -> bool


        Compute the extent for the point cloud defined by points.



        true on success, false if extents was unable to be calculated. On
        success, extent will contain the axis-aligned bounding box of the
        point cloud defined by points.

        This function is to provide easy authoring of extent for usd authoring
        tools, hence it is static and acts outside a specific prim (as in
        attribute based methods).


        Parameters
        ----------
        points : Vec3fArray

        extent : Vec3fArray



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the extent as if the matrix ``transform`` was first applied.


        Parameters
        ----------
        points : Vec3fArray

        transform : Matrix4d

        extent : Vec3fArray
        """
    @staticmethod
    def ComputePointsAtTime(points, stage, time, positions, velocities, velocitiesSampleTime, accelerations, velocityScale) -> bool: 
        """
        **classmethod** ComputePointsAtTime(points, time, baseTime) -> bool


        Compute points given the positions, velocities and accelerations at
        ``time`` .


        This will return ``false`` and leave ``points`` untouched if:

           - ``points`` is None

           - one of ``time`` and ``baseTime`` is numeric and the other is
             UsdTimeCode::Default() (they must either both be numeric or both be
             default)

           - there is no authored points attribute

        If there is no error, we will return ``true`` and ``points`` will
        contain the computed points.

        points

        \- the out parameter for the new points. Its size will depend on the
        authored data. time

        \- UsdTimeCode at which we want to evaluate the transforms baseTime

        \- required for correct interpolation between samples when *velocities*
        or *accelerations* are present. If there are samples for *positions*
        and *velocities* at t1 and t2, normal value resolution would attempt
        to interpolate between the two samples, and if they could not be
        interpolated because they differ in size (common in cases where
        velocity is authored), will choose the sample at t1. When sampling for
        the purposes of motion-blur, for example, it is common, when rendering
        the frame at t2, to sample at [ t2-shutter/2, t2+shutter/2 ] for a
        shutter interval of *shutter*. The first sample falls between t1 and
        t2, but we must sample at t2 and apply velocity-based interpolation
        based on those samples to get a correct result. In such scenarios, one
        should provide a ``baseTime`` of t2 when querying *both* samples. If
        your application does not care about off-sample interpolation, it can
        supply the same value for ``baseTime`` that it does for ``time`` .
        When ``baseTime`` is less than or equal to ``time`` , we will choose
        the lower bracketing timeSample.


        Parameters
        ----------
        points : VtArray[Vec3f]

        time : TimeCode

        baseTime : TimeCode



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Perform the point computation.


        This does the same computation as the non-static ComputePointsAtTime
        method, but takes all data as parameters rather than accessing
        authored data.

        points

        \- the out parameter for the computed points. Its size will depend on
        the given data. stage

        \- the UsdStage time

        \- time at which we want to evaluate the transforms positions

        \- array containing all current points. velocities

        \- array containing all velocities. This array must be either the same
        size as ``positions`` or empty. If it is empty, points are computed as
        if all velocities were zero in all dimensions. velocitiesSampleTime

        \- time at which the samples from ``velocities`` were taken.
        accelerations

        \- array containing all accelerations. This array must be either the
        same size as ``positions`` or empty. If it is empty, points are
        computed as if all accelerations were zero in all dimensions.
        velocityScale

        \- Deprecated


        Parameters
        ----------
        points : VtArray[Vec3f]

        stage : UsdStageWeak

        time : TimeCode

        positions : Vec3fArray

        velocities : Vec3fArray

        velocitiesSampleTime : TimeCode

        accelerations : Vec3fArray

        velocityScale : float
        """
    @staticmethod
    def ComputePointsAtTimes(pointsArray, times, baseTime) -> bool: 
        """
        ComputePointsAtTimes(pointsArray, times, baseTime) -> bool


        Compute points as in ComputePointsAtTime, but using multiple sample
        times.


        An array of vector arrays is returned where each vector array contains
        the points for the corresponding time in ``times`` .

        times

        \- A vector containing the UsdTimeCodes at which we want to sample.


        Parameters
        ----------
        pointsArray : list[VtArray[Vec3f]]

        times : list[TimeCode]

        baseTime : TimeCode
        """
    @staticmethod
    def CreateAccelerationsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAccelerationsAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateNormalsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateNormalsAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreatePointsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreatePointsAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVelocitiesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVelocitiesAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> PointBased


        Return a UsdGeomPointBased holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomPointBased(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAccelerationsAttr() -> Attribute: 
        """
        GetAccelerationsAttr() -> Attribute


        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
        """
    @staticmethod
    def GetNormalsAttr() -> Attribute: 
        """
        GetNormalsAttr() -> Attribute


        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
        """
    @staticmethod
    def GetNormalsInterpolation() -> str: 
        """
        GetNormalsInterpolation() -> str


        Get the interpolation for the *normals* attribute.


        Although'normals'is not classified as a generic UsdGeomPrimvar (and
        will not be included in the results of
        UsdGeomPrimvarsAPI::GetPrimvars() ) it does require an interpolation
        specification. The fallback interpolation, if left unspecified, is
        UsdGeomTokens->vertex, which will generally produce smooth shading on
        a polygonal mesh. To achieve partial or fully faceted shading of a
        polygonal mesh with normals, one should use UsdGeomTokens->faceVarying
        or UsdGeomTokens->uniform interpolation.
        """
    @staticmethod
    def GetPointsAttr() -> Attribute: 
        """
        GetPointsAttr() -> Attribute


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



        Declaration

        ``point3f[] points``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Point3fArray
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetVelocitiesAttr() -> Attribute: 
        """
        GetVelocitiesAttr() -> Attribute


        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 Applying Timesampled Velocities to Geometry.

        Declaration

        ``vector3f[] velocities``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Vector3fArray
        """
    @staticmethod
    def SetNormalsInterpolation(interpolation) -> bool: 
        """
        SetNormalsInterpolation(interpolation) -> bool


        Set the interpolation for the *normals* attribute.



        true upon success, false if ``interpolation`` is not a legal value as
        defined by UsdGeomPrimvar::IsValidInterpolation() , or if there was a
        problem setting the value. No attempt is made to validate that the
        normals attr's value contains the right number of elements to match
        its interpolation to its prim's topology.


        Parameters
        ----------
        interpolation : str
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Gprim(Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Base class for all geometric primitives.

    Gprim encodes basic graphical properties such as *doubleSided* and
    *orientation*, and provides primvars for"display
    color"and"displayopacity"that travel with geometry to be used as
    shader overrides.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateDisplayColorAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDisplayColorAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateDisplayColorPrimvar(interpolation, elementSize) -> Primvar: 
        """
        CreateDisplayColorPrimvar(interpolation, elementSize) -> Primvar


        Convenience function to create the displayColor primvar, optionally
        specifying interpolation and elementSize.




        Parameters
        ----------
        interpolation : str

        elementSize : int
        """
    @staticmethod
    def CreateDisplayOpacityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDisplayOpacityAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateDisplayOpacityPrimvar(interpolation, elementSize) -> Primvar: 
        """
        CreateDisplayOpacityPrimvar(interpolation, elementSize) -> Primvar


        Convenience function to create the displayOpacity primvar, optionally
        specifying interpolation and elementSize.




        Parameters
        ----------
        interpolation : str

        elementSize : int
        """
    @staticmethod
    def CreateDoubleSidedAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDoubleSidedAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateOrientationAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateOrientationAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Gprim


        Return a UsdGeomGprim holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomGprim(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetDisplayColorAttr() -> Attribute: 
        """
        GetDisplayColorAttr() -> Attribute


        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
        """
    @staticmethod
    def GetDisplayColorPrimvar() -> Primvar: 
        """
        GetDisplayColorPrimvar() -> Primvar


        Convenience function to get the displayColor Attribute as a Primvar.
        """
    @staticmethod
    def GetDisplayOpacityAttr() -> Attribute: 
        """
        GetDisplayOpacityAttr() -> Attribute


        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
        """
    @staticmethod
    def GetDisplayOpacityPrimvar() -> Primvar: 
        """
        GetDisplayOpacityPrimvar() -> Primvar


        Convenience function to get the displayOpacity Attribute as a Primvar.
        """
    @staticmethod
    def GetDoubleSidedAttr() -> Attribute: 
        """
        GetDoubleSidedAttr() -> Attribute


        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
        """
    @staticmethod
    def GetOrientationAttr() -> Attribute: 
        """
        GetOrientationAttr() -> Attribute


        Orientation specifies whether the gprim's surface normal should be
        computed using the right hand rule, or the left hand rule.


        Please see Coordinate System, Winding Order, Orientation, and Surface
        Normals 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
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Imageable(pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Base class for all prims that may require rendering or visualization
    of some sort. The primary attributes of Imageable are *visibility* and
    *purpose*, which each provide instructions for what geometry should be
    included for processing by rendering and other computations.

    Deprecated

    Imageable also provides API for accessing primvars, which has been
    moved to the UsdGeomPrimvarsAPI schema, because primvars can now be
    applied on non-Imageable prim types. This API is planned to be
    removed, UsdGeomPrimvarsAPI should be used directly instead.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    class PurposeInfo(Boost.Python.instance):
        @staticmethod
        def GetInheritablePurpose(*args, **kwargs) -> None: ...
        @property
        def isInheritable(self) -> None:
            """
            :type: None
            """
        @property
        def purpose(self) -> None:
            """
            :type: None
            """
        __instance_size__ = 32
        pass
    @staticmethod
    def ComputeEffectiveVisibility(purpose, time) -> str: 
        """
        ComputeEffectiveVisibility(purpose, time) -> str


        Calculate the effective purpose visibility of this prim for the given
        ``purpose`` , taking into account opinions for the corresponding
        purpose attribute, along with overall visibility opinions.


        If ComputeVisibility() returns"invisible", then
        ComputeEffectiveVisibility() is"invisible"for all purpose values.
        Otherwise, ComputeEffectiveVisibility() returns the value of the
        nearest ancestral authored opinion for the corresponding purpose
        visibility attribute, as retured by GetPurposeVisibilityAttr(purpose).

        Note that the value returned here can be"invisible"(indicating the
        prim is invisible for the given purpose),"visible"(indicating that
        it's visible), or"inherited"(indicating that the purpose visibility is
        context-dependent and the fallback behavior must be determined by the
        caller.

        This function should be considered a reference implementation for
        correctness. **If called on each prim in the context of a traversal we
        will perform massive overcomputation, because sibling prims share sub-
        problems in the query that can be efficiently cached, but are not
        (cannot be) by this simple implementation.** If you have control of
        your traversal, it will be far more efficient to manage visibility on
        a stack as you traverse.

        UsdGeomVisibilityAPI


        Parameters
        ----------
        purpose : str

        time : TimeCode
        """
    @staticmethod
    def ComputeLocalBound(time, purpose1, purpose2, purpose3, purpose4) -> BBox3d: 
        """
        ComputeLocalBound(time, purpose1, purpose2, purpose3, purpose4) -> BBox3d


        Compute the bound of this prim in local space, at the specified
        ``time`` , and for the specified purposes.


        The bound of the prim is computed, including the transform (if any)
        authored on the node itself.

        It is an error to not specify any purposes, which will result in the
        return of an empty box.

        **If you need to compute bounds for multiple prims on a stage, it will
        be much, much more efficient to instantiate a UsdGeomBBoxCache and
        query it directly; doing so will reuse sub-computations shared by the
        prims.**


        Parameters
        ----------
        time : TimeCode

        purpose1 : str

        purpose2 : str

        purpose3 : str

        purpose4 : str
        """
    @staticmethod
    def ComputeLocalToWorldTransform(time) -> Matrix4d: 
        """
        ComputeLocalToWorldTransform(time) -> Matrix4d


        Compute the transformation matrix for this prim at the given time,
        including the transform authored on the Prim itself, if present.


        **If you need to compute the transform for multiple prims on a stage,
        it will be much, much more efficient to instantiate a
        UsdGeomXformCache and query it directly; doing so will reuse sub-
        computations shared by the prims.**


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def ComputeParentToWorldTransform(time) -> Matrix4d: 
        """
        ComputeParentToWorldTransform(time) -> Matrix4d


        Compute the transformation matrix for this prim at the given time,
        *NOT* including the transform authored on the prim itself.


        **If you need to compute the transform for multiple prims on a stage,
        it will be much, much more efficient to instantiate a
        UsdGeomXformCache and query it directly; doing so will reuse sub-
        computations shared by the prims.**


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def ComputeProxyPrim(*args, **kwargs) -> None: 
        """
        Returns None if neither this prim nor any of its ancestors has a valid renderProxy prim.  Otherwise, returns a tuple of (proxyPrim, renderPrimWithAuthoredProxyPrimRel)
        """
    @staticmethod
    def ComputePurpose() -> str: 
        """
        ComputePurpose() -> str


        Calculate the effective purpose information about this prim.


        This is equivalent to extracting the purpose from the value returned
        by ComputePurposeInfo() .

        This function should be considered a reference implementation for
        correctness. **If called on each prim in the context of a traversal we
        will perform massive overcomputation, because sibling prims share sub-
        problems in the query that can be efficiently cached, but are not
        (cannot be) by this simple implementation.** If you have control of
        your traversal, it will be far more efficient to manage purpose, along
        with visibility, on a stack as you traverse.
        """
    @staticmethod
    @typing.overload
    def ComputePurposeInfo() -> PurposeInfo: 
        """
        ComputePurposeInfo() -> PurposeInfo


        Calculate the effective purpose information about this prim which
        includes final computed purpose value of the prim as well as whether
        the purpose value should be inherited by namespace children without
        their own purpose opinions.


        This function should be considered a reference implementation for
        correctness. **If called on each prim in the context of a traversal we
        will perform massive overcomputation, because sibling prims share sub-
        problems in the query that can be efficiently cached, but are not
        (cannot be) by this simple implementation.** If you have control of
        your traversal, it will be far more efficient to manage purpose, along
        with visibility, on a stack as you traverse.




        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Calculates the effective purpose information about this prim, given
        the computed purpose information of its parent prim.


        This can be much more efficient than using CommputePurposeInfo() when
        PurposeInfo values are properly computed and cached for a hierarchy of
        prims using this function.


        Parameters
        ----------
        parentPurposeInfo : PurposeInfo
        """
    @staticmethod
    @typing.overload
    def ComputePurposeInfo(parentPurposeInfo) -> PurposeInfo: ...
    @staticmethod
    def ComputeUntransformedBound(time, purpose1, purpose2, purpose3, purpose4) -> BBox3d: 
        """
        ComputeUntransformedBound(time, purpose1, purpose2, purpose3, purpose4) -> BBox3d


        Compute the untransformed bound of this prim, at the specified
        ``time`` , and for the specified purposes.


        The bound of the prim is computed in its object space, ignoring any
        transforms authored on or above the prim.

        It is an error to not specify any purposes, which will result in the
        return of an empty box.

        **If you need to compute bounds for multiple prims on a stage, it will
        be much, much more efficient to instantiate a UsdGeomBBoxCache and
        query it directly; doing so will reuse sub-computations shared by the
        prims.**


        Parameters
        ----------
        time : TimeCode

        purpose1 : str

        purpose2 : str

        purpose3 : str

        purpose4 : str
        """
    @staticmethod
    def ComputeVisibility(time) -> str: 
        """
        ComputeVisibility(time) -> str


        Calculate the effective visibility of this prim, as defined by its
        most ancestral authored"invisible"opinion, if any.


        A prim is considered visible at the current ``time`` if none of its
        Imageable ancestors express an authored"invisible"opinion, which is
        what leads to the"simple pruning"behavior described in
        GetVisibilityAttr() .

        This function should be considered a reference implementation for
        correctness. **If called on each prim in the context of a traversal we
        will perform massive overcomputation, because sibling prims share sub-
        problems in the query that can be efficiently cached, but are not
        (cannot be) by this simple implementation.** If you have control of
        your traversal, it will be far more efficient to manage visibility on
        a stack as you traverse.


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def ComputeWorldBound(time, purpose1, purpose2, purpose3, purpose4) -> BBox3d: 
        """
        ComputeWorldBound(time, purpose1, purpose2, purpose3, purpose4) -> BBox3d


        Compute the bound of this prim in world space, at the specified
        ``time`` , and for the specified purposes.


        The bound of the prim is computed, including the transform (if any)
        authored on the node itself, and then transformed to world space.

        It is an error to not specify any purposes, which will result in the
        return of an empty box.

        **If you need to compute bounds for multiple prims on a stage, it will
        be much, much more efficient to instantiate a UsdGeomBBoxCache and
        query it directly; doing so will reuse sub-computations shared by the
        prims.**


        Parameters
        ----------
        time : TimeCode

        purpose1 : str

        purpose2 : str

        purpose3 : str

        purpose4 : str
        """
    @staticmethod
    def CreateProxyPrimRel() -> Relationship: 
        """
        CreateProxyPrimRel() -> Relationship


        See GetProxyPrimRel() , and also Create vs Get Property Methods for
        when to use Get vs Create.
        """
    @staticmethod
    def CreatePurposeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreatePurposeAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVisibilityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVisibilityAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Imageable


        Return a UsdGeomImageable holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomImageable(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetOrderedPurposeTokens(*args, **kwargs) -> None: 
        """
        **classmethod** GetOrderedPurposeTokens() -> list[TfToken]


        Returns an ordered list of allowed values of the purpose attribute.


        The ordering is important because it defines the protocol between
        UsdGeomModelAPI and UsdGeomBBoxCache for caching and retrieving
        extents hints by purpose.

        The order is: [default, render, proxy, guide]

        See

        UsdGeomModelAPI::GetExtentsHint() .
        """
    @staticmethod
    def GetProxyPrimRel() -> Relationship: 
        """
        GetProxyPrimRel() -> Relationship


        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.

        It is only valid to author the proxyPrim relationship on prims whose
        purpose is"render".
        """
    @staticmethod
    def GetPurposeAttr() -> Attribute: 
        """
        GetPurposeAttr() -> Attribute


        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 Imageable Purpose 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
        """
    @staticmethod
    def GetPurposeVisibilityAttr(purpose) -> Attribute: 
        """
        GetPurposeVisibilityAttr(purpose) -> Attribute


        Return the attribute that is used for expressing visibility opinions
        for the given ``purpose`` .


        For"default"purpose, return the overall *visibility* attribute.
        For"guide","proxy", or"render"purpose, return *guideVisibility*,
        *proxyVisibility*, or *renderVisibility* if UsdGeomVisibilityAPI is
        applied to the prim. If UsdGeomvVisibiltyAPI is not applied, an empty
        attribute is returned for purposes other than default.

        UsdGeomVisibilityAPI::Apply

        UsdGeomVisibilityAPI::GetPurposeVisibilityAttr


        Parameters
        ----------
        purpose : str
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetVisibilityAttr() -> Attribute: 
        """
        GetVisibilityAttr() -> Attribute


        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
        """
    @staticmethod
    def MakeInvisible(time) -> None: 
        """
        MakeInvisible(time) -> None


        Makes the imageable invisible if it is visible at the given time.



        When visibility is animated, this only works when it is invoked
        sequentially at increasing time samples. If visibility is already
        authored and animated in the scene, calling MakeVisible() at an
        arbitrary (in-between) frame isn't guaranteed to work.

        Be sure to set the edit target to the layer containing the strongest
        visibility opinion or to a stronger layer.


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def MakeVisible(time) -> None: 
        """
        MakeVisible(time) -> None


        Make the imageable visible if it is invisible at the given time.


        Since visibility is pruning, this may need to override some ancestor's
        visibility and all-but-one of the ancestor's children's visibility,
        for all the ancestors of this prim up to the highest ancestor that is
        explicitly invisible, to preserve the visibility state.

        If MakeVisible() (or MakeInvisible() ) is going to be applied to all
        the prims on a stage, ancestors must be processed prior to descendants
        to get the correct behavior.

        When visibility is animated, this only works when it is invoked
        sequentially at increasing time samples. If visibility is already
        authored and animated in the scene, calling MakeVisible() at an
        arbitrary (in-between) frame isn't guaranteed to work.

        This will only work properly if all ancestor prims of the imageable
        are **defined**, as the imageable schema is only valid on defined
        prims.

        Be sure to set the edit target to the layer containing the strongest
        visibility opinion or to a stronger layer.


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def SetProxyPrim(proxy) -> bool: 
        """
        SetProxyPrim(proxy) -> bool


        Convenience function for authoring the *renderProxy* rel on this prim
        to target the given ``proxy`` prim.


        To facilitate authoring on sparse or unloaded stages, we do not
        perform any validation of this prim's purpose or the type or purpose
        of the specified prim.


        Parameters
        ----------
        proxy : Prim



        ----------------------------------------------------------------------


        Parameters
        ----------
        proxy : SchemaBase
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class LinearUnits(Boost.Python.instance):
    centimeters = 0.01
    feet = 0.3048
    inches = 0.0254
    kilometers = 1000.0
    lightYears = 9460730472580800.0
    meters = 1.0
    micrometers = 1e-06
    miles = 1609.344
    millimeters = 0.001
    nanometers = 1e-09
    yards = 0.9144
    pass
class ModelAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    UsdGeomModelAPI extends the generic UsdModelAPI schema with geometry
    specific concepts such as cached extents for the entire model,
    constraint targets, and geometry-inspired extensions to the payload
    lofting process.

    As described in GetExtentsHint() below, it is useful to cache extents
    at the model level. UsdGeomModelAPI provides schema for computing and
    storing these cached extents, which can be consumed by
    UsdGeomBBoxCache to provide fast access to precomputed extents that
    will be used as the model's bounds ( see
    UsdGeomBBoxCache::UsdGeomBBoxCache() ).

    Draw Modes
    ==========

    Draw modes provide optional alternate imaging behavior for USD
    subtrees with kind model. *model:drawMode* (which is inheritable) and
    *model:applyDrawMode* (which is not) are resolved into a decision to
    stop traversing the scene graph at a certain point, and replace a USD
    subtree with proxy geometry.

    The value of *model:drawMode* determines the type of proxy geometry:

       - *origin* - Draw the model-space basis vectors of the replaced
         prim.

       - *bounds* - Draw the model-space bounding box of the replaced
         prim.

       - *cards* - Draw textured quads as a placeholder for the replaced
         prim.

       - *default* - An explicit opinion to draw the USD subtree as
         normal.

       - *inherited* - Defer to the parent opinion.

    *model:drawMode* falls back to *inherited* so that a whole scene, a
    large group, or all prototypes of a model hierarchy PointInstancer can
    be assigned a draw mode with a single attribute edit. If no draw mode
    is explicitly set in a hierarchy, the resolved value is *default*.

    *model:applyDrawMode* is meant to be written when an asset is
    authored, and provides flexibility for different asset types. For
    example, a character assembly (composed of character, clothes, etc)
    might have *model:applyDrawMode* set at the top of the subtree so the
    whole group can be drawn as a single card object. An effects subtree
    might have *model:applyDrawMode* set at a lower level so each particle
    group draws individually.

    Models of kind component are treated as if *model:applyDrawMode* were
    true. This means a prim is drawn with proxy geometry when: the prim
    has kind component, and/or *model:applyDrawMode* is set; and the
    prim's resolved value for *model:drawMode* is not *default*.

    Cards Geometry
    ==============

    The specific geometry used in cards mode is controlled by the
    *model:cardGeometry* attribute:

       - *cross* - Generate a quad normal to each basis direction and
         negative. Locate each quad so that it bisects the model extents.

       - *box* - Generate a quad normal to each basis direction and
         negative. Locate each quad on a face of the model extents, facing out.

       - *fromTexture* - Generate a quad for each supplied texture from
         attributes stored in that texture's metadata.

    For *cross* and *box* mode, the extents are calculated for purposes
    *default*, *proxy*, and *render*, at their earliest authored time. If
    the model has no textures, all six card faces are rendered using
    *model:drawModeColor*. If one or more textures are present, only axes
    with one or more textures assigned are drawn. For each axis, if both
    textures (positive and negative) are specified, they'll be used on the
    corresponding card faces; if only one texture is specified, it will be
    mapped to the opposite card face after being flipped on the texture's
    s-axis. Any card faces with invalid asset paths will be drawn with
    *model:drawModeColor*.

    Both *model:cardGeometry* and *model:drawModeColor* should be authored
    on the prim where the draw mode takes effect, since these attributes
    are not inherited.

    For *fromTexture* mode, only card faces with valid textures assigned
    are drawn. The geometry is generated by pulling the *worldtoscreen*
    attribute out of texture metadata. This is expected to be a 4x4 matrix
    mapping the model-space position of the card quad to the clip-space
    quad with corners (-1,-1,0) and (1,1,0). The card vertices are
    generated by transforming the clip-space corners by the inverse of
    *worldtoscreen*. Textures are mapped so that (s) and (t) map to (+x)
    and (+y) in clip space. If the metadata cannot be read in the right
    format, or the matrix can't be inverted, the card face is not drawn.

    All card faces are drawn and textured as single-sided.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> ModelAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"GeomModelAPI"to the token-valued,
        listOp metadata *apiSchemas* on the prim.

        A valid UsdGeomModelAPI object is returned upon success. An invalid
        (or empty) UsdGeomModelAPI object is returned upon failure. See
        UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def ComputeExtentsHint(bboxCache) -> Vec3fArray: 
        """
        ComputeExtentsHint(bboxCache) -> Vec3fArray


        For the given model, compute the value for the extents hint with the
        given ``bboxCache`` .


        ``bboxCache`` should be setup with the appropriate time. After calling
        this function, the ``bboxCache`` may have it's included purposes
        changed.

        ``bboxCache`` should not be in use by any other thread while this
        method is using it in a thread.


        Parameters
        ----------
        bboxCache : BBoxCache
        """
    @staticmethod
    def ComputeModelDrawMode(parentDrawMode) -> str: 
        """
        ComputeModelDrawMode(parentDrawMode) -> str


        Calculate the effective model:drawMode of this prim.


        If the draw mode is authored on this prim, it's used. Otherwise, the
        fallback value is"inherited", which defers to the parent opinion. The
        first non-inherited opinion found walking from this prim towards the
        root is used. If the attribute isn't set on any ancestors, we
        return"default"(meaning, disable"drawMode"geometry).

        If this function is being called in a traversal context to compute the
        draw mode of an entire hierarchy of prims, it would be beneficial to
        cache and pass in the computed parent draw-mode via the
        ``parentDrawMode`` parameter. This avoids repeated upward traversal to
        look for ancestor opinions.

        When ``parentDrawMode`` is empty (or unspecified), this function does
        an upward traversal to find the closest ancestor with an authored
        model:drawMode.


        Parameters
        ----------
        parentDrawMode : str
        """
    @staticmethod
    def CreateConstraintTarget(constraintName) -> ConstraintTarget: 
        """
        CreateConstraintTarget(constraintName) -> ConstraintTarget


        Creates a new constraint target with the given name,
        ``constraintName`` .


        If the constraint target already exists, then the existing target is
        returned. If it does not exist, a new one is created and returned.


        Parameters
        ----------
        constraintName : str
        """
    @staticmethod
    def CreateModelApplyDrawModeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelApplyDrawModeAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelApplyDrawModeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelCardGeometryAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelCardGeometryAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelCardGeometryAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelCardTextureXNegAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelCardTextureXNegAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelCardTextureXNegAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelCardTextureXPosAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelCardTextureXPosAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelCardTextureXPosAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelCardTextureYNegAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelCardTextureYNegAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelCardTextureYNegAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelCardTextureYPosAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelCardTextureYPosAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelCardTextureYPosAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelCardTextureZNegAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelCardTextureZNegAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelCardTextureZNegAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelCardTextureZPosAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelCardTextureZPosAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelCardTextureZPosAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelDrawModeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelDrawModeAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelDrawModeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateModelDrawModeColorAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateModelDrawModeColorAttr(defaultValue, writeSparsely) -> Attribute


        See GetModelDrawModeColorAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> ModelAPI


        Return a UsdGeomModelAPI holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomModelAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetConstraintTarget(constraintName) -> ConstraintTarget: 
        """
        GetConstraintTarget(constraintName) -> ConstraintTarget


        Get the constraint target with the given name, ``constraintName`` .


        If the requested constraint target does not exist, then an invalid
        UsdConstraintTarget object is returned.


        Parameters
        ----------
        constraintName : str
        """
    @staticmethod
    def GetConstraintTargets() -> list[ConstraintTarget]: 
        """
        GetConstraintTargets() -> list[ConstraintTarget]


        Returns all the constraint targets belonging to the model.


        Only valid constraint targets in the"constraintTargets"namespace are
        returned by this method.
        """
    @staticmethod
    def GetExtentsHint(extents, time) -> bool: 
        """
        GetExtentsHint(extents, time) -> bool


        Retrieve the authored value (if any) of this model's"extentsHint".


        Persistent caching of bounds in USD is a potentially perilous
        endeavor, given that:

           - It is very easy to add overrides in new super-layers that
             invalidate the cached bounds, and no practical way to automatically
             detect when this happens

           - It is possible for references to be allowed to"float", so that
             asset updates can flow directly into cached scenes. Such changes in
             referenced scene description can also invalidate cached bounds in
             referencing layers.
             For these reasons, as a general rule, we only persistently cache leaf
             gprim extents in object space. However, even with cached gprim
             extents, computing bounds can be expensive. Since model-level bounds
             are so useful to many graphics applications, we make an exception,
             with some caveats. The"extentsHint"should be considered entirely
             optional (whereas gprim extent is not); if authored, it should
             contains the extents for various values of gprim purposes. The extents
             for different values of purpose are stored in a linear Vec3f array as
             pairs of GfVec3f values in the order specified by
             UsdGeomImageable::GetOrderedPurposeTokens() . This list is trimmed to
             only include non-empty extents. i.e., if a model has only default and
             render geoms, then it will only have 4 GfVec3f values in its
             extentsHint array. We do not skip over zero extents, so if a model has
             only default and proxy geom, we will author six GfVec3f 's, the middle
             two representing an zero extent for render geometry.

        A UsdGeomBBoxCache can be configured to first consult the cached
        extents when evaluating model roots, rather than descending into the
        models for the full computation. This is not the default behavior, and
        gives us a convenient way to validate that the cached extentsHint is
        still valid.

        ``true`` if a value was fetched; ``false`` if no value was authored,
        or on error. It is an error to make this query of a prim that is not a
        model root.

        UsdGeomImageable::GetPurposeAttr() ,
        UsdGeomImageable::GetOrderedPurposeTokens()


        Parameters
        ----------
        extents : Vec3fArray

        time : TimeCode
        """
    @staticmethod
    def GetExtentsHintAttr() -> Attribute: 
        """
        GetExtentsHintAttr() -> Attribute


        Returns the custom'extentsHint'attribute if it exits.
        """
    @staticmethod
    def GetModelApplyDrawModeAttr() -> Attribute: 
        """
        GetModelApplyDrawModeAttr() -> Attribute


        If true, and the resolved value of *model:drawMode* is non-default,
        apply an alternate imaging mode to this prim.


        See Draw Modes.

        Declaration

        ``uniform bool model:applyDrawMode = 0``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool

        Variability

        SdfVariabilityUniform
        """
    @staticmethod
    def GetModelCardGeometryAttr() -> Attribute: 
        """
        GetModelCardGeometryAttr() -> Attribute


        The geometry to generate for imaging prims inserted for *cards*
        imaging mode.


        See Cards Geometry for geometry descriptions.

        Declaration

        ``uniform token model:cardGeometry ="cross"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        cross, box, fromTexture
        """
    @staticmethod
    def GetModelCardTextureXNegAttr() -> Attribute: 
        """
        GetModelCardTextureXNegAttr() -> Attribute


        In *cards* imaging mode, the texture applied to the X- quad.


        The texture axes (s,t) are mapped to model-space axes (y, -z).

        Declaration

        ``asset model:cardTextureXNeg``

        C++ Type

        SdfAssetPath

        Usd Type

        SdfValueTypeNames->Asset
        """
    @staticmethod
    def GetModelCardTextureXPosAttr() -> Attribute: 
        """
        GetModelCardTextureXPosAttr() -> Attribute


        In *cards* imaging mode, the texture applied to the X+ quad.


        The texture axes (s,t) are mapped to model-space axes (-y, -z).

        Declaration

        ``asset model:cardTextureXPos``

        C++ Type

        SdfAssetPath

        Usd Type

        SdfValueTypeNames->Asset
        """
    @staticmethod
    def GetModelCardTextureYNegAttr() -> Attribute: 
        """
        GetModelCardTextureYNegAttr() -> Attribute


        In *cards* imaging mode, the texture applied to the Y- quad.


        The texture axes (s,t) are mapped to model-space axes (-x, -z).

        Declaration

        ``asset model:cardTextureYNeg``

        C++ Type

        SdfAssetPath

        Usd Type

        SdfValueTypeNames->Asset
        """
    @staticmethod
    def GetModelCardTextureYPosAttr() -> Attribute: 
        """
        GetModelCardTextureYPosAttr() -> Attribute


        In *cards* imaging mode, the texture applied to the Y+ quad.


        The texture axes (s,t) are mapped to model-space axes (x, -z).

        Declaration

        ``asset model:cardTextureYPos``

        C++ Type

        SdfAssetPath

        Usd Type

        SdfValueTypeNames->Asset
        """
    @staticmethod
    def GetModelCardTextureZNegAttr() -> Attribute: 
        """
        GetModelCardTextureZNegAttr() -> Attribute


        In *cards* imaging mode, the texture applied to the Z- quad.


        The texture axes (s,t) are mapped to model-space axes (-x, -y).

        Declaration

        ``asset model:cardTextureZNeg``

        C++ Type

        SdfAssetPath

        Usd Type

        SdfValueTypeNames->Asset
        """
    @staticmethod
    def GetModelCardTextureZPosAttr() -> Attribute: 
        """
        GetModelCardTextureZPosAttr() -> Attribute


        In *cards* imaging mode, the texture applied to the Z+ quad.


        The texture axes (s,t) are mapped to model-space axes (x, -y).

        Declaration

        ``asset model:cardTextureZPos``

        C++ Type

        SdfAssetPath

        Usd Type

        SdfValueTypeNames->Asset
        """
    @staticmethod
    def GetModelDrawModeAttr() -> Attribute: 
        """
        GetModelDrawModeAttr() -> Attribute


        Alternate imaging mode; applied to this prim or child prims where
        *model:applyDrawMode* is true, or where the prim has kind *component*.


        See Draw Modes for mode descriptions.

        Declaration

        ``uniform token model:drawMode ="inherited"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        origin, bounds, cards, default, inherited
        """
    @staticmethod
    def GetModelDrawModeColorAttr() -> Attribute: 
        """
        GetModelDrawModeColorAttr() -> Attribute


        The base color of imaging prims inserted for alternate imaging modes.


        For *origin* and *bounds* modes, this controls line color; for *cards*
        mode, this controls the fallback quad color.

        Declaration

        ``uniform float3 model:drawModeColor = (0.18, 0.18, 0.18)``

        C++ Type

        GfVec3f

        Usd Type

        SdfValueTypeNames->Float3

        Variability

        SdfVariabilityUniform
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def SetExtentsHint(extents, time) -> bool: 
        """
        SetExtentsHint(extents, time) -> bool


        Authors the extentsHint array for this model at the given time.




        Parameters
        ----------
        extents : Vec3fArray

        time : TimeCode
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class MotionAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    UsdGeomMotionAPI encodes data that can live on any prim that may
    affect computations involving:

       - computed motion for motion blur

       - sampling for motion blur

    The motion:blurScale attribute allows artists to scale the **amount**
    of motion blur to be rendered for parts of the scene without changing
    the recorded animation. See Effectively Applying motion:blurScale for
    use and implementation details.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> MotionAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"MotionAPI"to the token-valued,
        listOp metadata *apiSchemas* on the prim.

        A valid UsdGeomMotionAPI object is returned upon success. An invalid
        (or empty) UsdGeomMotionAPI object is returned upon failure. See
        UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def ComputeMotionBlurScale(time) -> float: 
        """
        ComputeMotionBlurScale(time) -> float


        Compute the inherited value of *motion:blurScale* at ``time`` , i.e.


        the authored value on the prim closest to this prim in namespace,
        resolved upwards through its ancestors in namespace.

        the inherited value, or 1.0 if neither the prim nor any of its
        ancestors possesses an authored value.

        this is a reference implementation that is not particularly efficient
        if evaluating over many prims, because it does not share inherited
        results.


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def ComputeNonlinearSampleCount(time) -> int: 
        """
        ComputeNonlinearSampleCount(time) -> int


        Compute the inherited value of *nonlinearSampleCount* at ``time`` ,
        i.e.


        the authored value on the prim closest to this prim in namespace,
        resolved upwards through its ancestors in namespace.

        the inherited value, or 3 if neither the prim nor any of its ancestors
        possesses an authored value.

        this is a reference implementation that is not particularly efficient
        if evaluating over many prims, because it does not share inherited
        results.


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def ComputeVelocityScale(time) -> float: 
        """
        ComputeVelocityScale(time) -> float


        Deprecated

        Compute the inherited value of *velocityScale* at ``time`` , i.e. the
        authored value on the prim closest to this prim in namespace, resolved
        upwards through its ancestors in namespace.

        the inherited value, or 1.0 if neither the prim nor any of its
        ancestors possesses an authored value.

        this is a reference implementation that is not particularly efficient
        if evaluating over many prims, because it does not share inherited
        results.


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def CreateMotionBlurScaleAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateMotionBlurScaleAttr(defaultValue, writeSparsely) -> Attribute


        See GetMotionBlurScaleAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateNonlinearSampleCountAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateNonlinearSampleCountAttr(defaultValue, writeSparsely) -> Attribute


        See GetNonlinearSampleCountAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVelocityScaleAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVelocityScaleAttr(defaultValue, writeSparsely) -> Attribute


        See GetVelocityScaleAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> MotionAPI


        Return a UsdGeomMotionAPI holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomMotionAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetMotionBlurScaleAttr() -> Attribute: 
        """
        GetMotionBlurScaleAttr() -> Attribute


        BlurScale is an **inherited** float attribute that stipulates the
        rendered motion blur (as typically specified via UsdGeomCamera 's
        *shutter:open* and *shutter:close* properties) should be scaled for
        **all objects** at and beneath the prim in namespace on which the
        *motion:blurScale* value is specified.


        Without changing any other data in the scene, *blurScale* allows
        artists to"dial in"the amount of blur on a per-object basis. A
        *blurScale* value of zero removes all blur, a value of 0.5 reduces
        blur by half, and a value of 2.0 doubles the blur. The legal range for
        *blurScale* is [0, inf), although very high values may result in
        extremely expensive renders, and may exceed the capabilities of some
        renderers.

        Although renderers are free to implement this feature however they see
        fit, see Effectively Applying motion:blurScale for our guidance on
        implementing the feature universally and efficiently.

        Declaration

        ``float motion:blurScale = 1``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetNonlinearSampleCountAttr() -> Attribute: 
        """
        GetNonlinearSampleCountAttr() -> Attribute


        Determines the number of position or transformation samples created
        when motion is described by attributes contributing non-linear terms.


        To give an example, imagine an application (such as a renderer)
        consuming'points'and the USD document also contains'accelerations'for
        the same prim. Unless the application can consume
        these'accelerations'itself, an intermediate layer has to compute
        samples within the sampling interval for the point positions based on
        the value of'points','velocities'and'accelerations'. The number of
        these samples is given by'nonlinearSampleCount'. The samples are
        equally spaced within the sampling interval.

        Another example involves the PointInstancer
        where'nonlinearSampleCount'is relevant
        when'angularVelocities'or'accelerations'are authored.

        'nonlinearSampleCount'is an **inherited** attribute, also see
        ComputeNonlinearSampleCount()

        Declaration

        ``int motion:nonlinearSampleCount = 3``

        C++ Type

        int

        Usd Type

        SdfValueTypeNames->Int
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetVelocityScaleAttr() -> Attribute: 
        """
        GetVelocityScaleAttr() -> Attribute


        Deprecated

        VelocityScale is an **inherited** float attribute that velocity-based
        schemas (e.g. PointBased, PointInstancer) can consume to compute
        interpolated positions and orientations by applying velocity and
        angularVelocity, which is required for interpolating between samples
        when topology is varying over time. Although these quantities are
        generally physically computed by a simulator, sometimes we require
        more or less motion-blur to achieve the desired look.  VelocityScale
        allows artists to dial-in, as a post-sim correction, a scale factor to
        be applied to the velocity prior to computing interpolated positions
        from it.

        Declaration

        ``float motion:velocityScale = 1``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class PointInstancer(Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Encodes vectorized instancing of multiple, potentially animated,
    prototypes (object/instance masters), which can be arbitrary
    prims/subtrees on a UsdStage.

    PointInstancer is a"multi instancer", as it allows multiple prototypes
    to be scattered among its"points". We use a UsdRelationship
    *prototypes* to identify and order all of the possible prototypes, by
    targeting the root prim of each prototype. The ordering imparted by
    relationships associates a zero-based integer with each prototype, and
    it is these integers we use to identify the prototype of each
    instance, compactly, and allowing prototypes to be swapped out without
    needing to reauthor all of the per-instance data.

    The PointInstancer schema is designed to scale to billions of
    instances, which motivates the choice to split the per-instance
    transformation into position, (quaternion) orientation, and scales,
    rather than a 4x4 matrix per-instance. In addition to requiring fewer
    bytes even if all elements are authored (32 bytes vs 64 for a single-
    precision 4x4 matrix), we can also be selective about which attributes
    need to animate over time, for substantial data reduction in many
    cases.

    Note that PointInstancer is *not* a Gprim, since it is not a graphical
    primitive by any stretch of the imagination. It *is*, however,
    Boundable, since we will sometimes want to treat the entire
    PointInstancer similarly to a procedural, from the perspective of
    inclusion or framing.

    Varying Instance Identity over Time
    ===================================

    PointInstancers originating from simulations often have the
    characteristic that points/instances are"born", move around for some
    time period, and then die (or leave the area of interest). In such
    cases, billions of instances may be birthed over time, while at any
    *specific* time, only a much smaller number are actually alive. To
    encode this situation efficiently, the simulator may re-use indices in
    the instance arrays, when a particle dies, its index will be taken
    over by a new particle that may be birthed in a much different
    location. This presents challenges both for identity-tracking, and for
    motion-blur.

    We facilitate identity tracking by providing an optional, animatable
    *ids* attribute, that specifies the 64 bit integer ID of the particle
    at each index, at each point in time. If the simulator keeps
    monotonically increasing a particle-count each time a new particle is
    birthed, it will serve perfectly as particle *ids*.

    We facilitate motion blur for varying-topology particle streams by
    optionally allowing per-instance *velocities* and *angularVelocities*
    to be authored. If instance transforms are requested at a time between
    samples and either of the velocity attributes is authored, then we
    will not attempt to interpolate samples of *positions* or
    *orientations*. If not authored, and the bracketing samples have the
    same length, then we will interpolate.

    Computing an Instance Transform
    ===============================

    Each instance's transformation is a combination of the SRT affine
    transform described by its scale, orientation, and position, applied
    *after* (i.e. less locally) than the transformation computed at the
    root of the prototype it is instancing. In other words, to put an
    instance of a PointInstancer into the space of the PointInstancer's
    parent prim:

       - Apply (most locally) the authored transformation for
         *prototypes[protoIndices[i]]*

       - If *scales* is authored, next apply the scaling matrix from
         *scales[i]*

       - If *orientations* is authored: **if *angularVelocities* is
         authored**, first multiply *orientations[i]* by the unit quaternion
         derived by scaling *angularVelocities[i]* by the time differential
         from the left-bracketing timeSample for *orientation* to the requested
         evaluation time *t*, storing the result in *R*, **else** assign *R*
         directly from *orientations[i]*. Apply the rotation matrix derived
         from *R*.

       - Apply the translation derived from *positions[i]*. If
         *velocities* is authored, apply the translation deriving from
         *velocities[i]* scaled by the time differential from the left-
         bracketing timeSample for *positions* to the requested evaluation time
         *t*.

       - Least locally, apply the transformation authored on the
         PointInstancer prim itself (or the
         UsdGeomImageable::ComputeLocalToWorldTransform() of the PointInstancer
         to put the instance directly into world space)

    If neither *velocities* nor *angularVelocities* are authored, we
    fallback to standard position and orientation computation logic (using
    linear interpolation between timeSamples) as described by Applying
    Timesampled Velocities to Geometry.

    **Scaling Velocities for Interpolation**

    When computing time-differentials by which to apply velocity or
    angularVelocity to positions or orientations, we must scale by ( 1.0 /
    UsdStage::GetTimeCodesPerSecond() ), because velocities are recorded
    in units/second, while we are interpolating in UsdTimeCode ordinates.

    We provide both high and low-level API's for dealing with the
    transformation as a matrix, both will compute the instance matrices
    using multiple threads; the low-level API allows the client to cache
    unvarying inputs so that they need not be read duplicately when
    computing over time.

    See also Applying Timesampled Velocities to Geometry.

    Primvars on PointInstancer
    ==========================

    Primvars authored on a PointInstancer prim should always be applied to
    each instance with *constant* interpolation at the root of the
    instance. When you are authoring primvars on a PointInstancer, think
    about it as if you were authoring them on a point-cloud (e.g. a
    UsdGeomPoints gprim). The same interpolation rules for points apply
    here, substituting"instance"for"point".

    In other words, the (constant) value extracted for each instance from
    the authored primvar value depends on the authored *interpolation* and
    *elementSize* of the primvar, as follows:

       - **constant** or **uniform** : the entire authored value of the
         primvar should be applied exactly to each instance.

       - **varying**, **vertex**, or **faceVarying** : the first
         *elementSize* elements of the authored primvar array should be
         assigned to instance zero, the second *elementSize* elements should be
         assigned to instance one, and so forth.

    Masking Instances:"Deactivating"and Invising
    ============================================

    Often a PointInstancer is created"upstream"in a graphics pipeline, and
    the needs of"downstream"clients necessitate eliminating some of the
    instances from further consideration. Accomplishing this pruning by
    re-authoring all of the per-instance attributes is not very
    attractive, since it may mean destructively editing a large quantity
    of data. We therefore provide means of"masking"instances by ID, such
    that the instance data is unmolested, but per-instance transform and
    primvar data can be retrieved with the no-longer-desired instances
    eliminated from the (smaller) arrays. PointInstancer allows two
    independent means of masking instances by ID, each with different
    features that meet the needs of various clients in a pipeline. Both
    pruning features'lists of ID's are combined to produce the mask
    returned by ComputeMaskAtTime() .

    If a PointInstancer has no authored *ids* attribute, the masking
    features will still be available, with the integers specifying element
    position in the *protoIndices* array rather than ID.

    The first masking feature encodes a list of IDs in a list-editable
    metadatum called *inactiveIds*, which, although it does not have any
    similar impact to stage population as prim activation, it shares with
    that feature that its application is uniform over all time. Because it
    is list-editable, we can *sparsely* add and remove instances from it
    in many layers.

    This sparse application pattern makes *inactiveIds* a good choice when
    further downstream clients may need to reverse masking decisions made
    upstream, in a manner that is robust to many kinds of future changes
    to the upstream data.

    See ActivateId() , ActivateIds() , DeactivateId() , DeactivateIds() ,
    ActivateAllIds()

    The second masking feature encodes a list of IDs in a time-varying
    Int64Array-valued UsdAttribute called *invisibleIds*, since it shares
    with Imageable visibility the ability to animate object visibility.

    Unlike *inactiveIds*, overriding a set of opinions for *invisibleIds*
    is not at all straightforward, because one will, in general need to
    reauthor (in the overriding layer) **all** timeSamples for the
    attribute just to change one Id's visibility state, so it cannot be
    authored sparsely. But it can be a very useful tool for situations
    like encoding pre-computed camera-frustum culling of geometry when
    either or both of the instances or the camera is animated.

    See VisId() , VisIds() , InvisId() , InvisIds() , VisAllIds()

    Processing and Not Processing Prototypes
    ========================================

    Any prim in the scenegraph can be targeted as a prototype by the
    *prototypes* relationship. We do not, however, provide a specific
    mechanism for identifying prototypes as geometry that should not be
    drawn (or processed) in their own, local spaces in the scenegraph. We
    encourage organizing all prototypes as children of the PointInstancer
    prim that consumes them, and pruning"raw"processing and drawing
    traversals when they encounter a PointInstancer prim; this is what the
    UsdGeomBBoxCache and UsdImaging engines do.

    There *is* a pattern one can deploy for organizing the prototypes such
    that they will automatically be skipped by basic
    UsdPrim::GetChildren() or UsdPrimRange traversals. Usd prims each have
    a specifier of"def","over", or"class". The default traversals skip
    over prims that are"pure overs"or classes. So to protect prototypes
    from all generic traversals and processing, place them under a prim
    that is just an"over". For example,

    .. code-block:: text

      01 def PointInstancer "Crowd_Mid"
      02 {
      03     rel prototypes = [ </Crowd_Mid/Prototypes/MaleThin_Business>, </Crowd_Mid/Prototypes/MaleThin_Casual> ]
      04     
      05     over "Prototypes" 
      06     {
      07          def "MaleThin_Business" (
      08              references = [@MaleGroupA/usd/MaleGroupA.usd@</MaleGroupA>]
      09              variants = {
      10                  string modelingVariant = "Thin"
      11                  string costumeVariant = "BusinessAttire"
      12              }
      13          )
      14          { \.\.\. }
      15          
      16          def "MaleThin_Casual"
      17          \.\.\.
      18     }
      19 }
    """
    class MaskApplication(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Encodes whether to evaluate and apply the PointInstancer's mask to
        computed results.

        ComputeMaskAtTime()
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'PointInstancer'
        allValues: tuple # value = (UsdGeom.PointInstancer.ApplyMask, UsdGeom.PointInstancer.IgnoreMask)
        pass
    class ProtoXformInclusion(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Encodes whether to include each prototype's root prim's transformation
        as the most-local component of computed instance transforms.
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'PointInstancer'
        allValues: tuple # value = (UsdGeom.PointInstancer.IncludeProtoXform, UsdGeom.PointInstancer.ExcludeProtoXform)
        pass
    @staticmethod
    def ActivateAllIds() -> bool: 
        """
        ActivateAllIds() -> bool


        Ensure that all instances are active over all time.


        This does not guarantee that the instances will be rendered, because
        each may still be"invisible"due to its presence in the *invisibleIds*
        attribute (see VisId() , InvisId() )
        """
    @staticmethod
    def ActivateId(id) -> bool: 
        """
        ActivateId(id) -> bool


        Ensure that the instance identified by ``id`` is active over all time.


        This activation is encoded sparsely, affecting no other instances.

        This does not guarantee that the instance will be rendered, because it
        may still be"invisible"due to ``id`` being present in the
        *invisibleIds* attribute (see VisId() , InvisId() )


        Parameters
        ----------
        id : int
        """
    @staticmethod
    def ActivateIds(ids) -> bool: 
        """
        ActivateIds(ids) -> bool


        Ensure that the instances identified by ``ids`` are active over all
        time.


        This activation is encoded sparsely, affecting no other instances.

        This does not guarantee that the instances will be rendered, because
        each may still be"invisible"due to its presence in the *invisibleIds*
        attribute (see VisId() , InvisId() )


        Parameters
        ----------
        ids : Int64Array
        """
    @staticmethod
    @typing.overload
    def ComputeExtentAtTime(extent, time, baseTime) -> bool: 
        """
        ComputeExtentAtTime(extent, time, baseTime) -> bool


        Compute the extent of the point instancer based on the per-
        instance,"PointInstancer relative"transforms at ``time`` , as
        described in Computing an Instance Transform.


        If there is no error, we return ``true`` and ``extent`` will be the
        tightest bounds we can compute efficiently. If an error occurs,
        ``false`` will be returned and ``extent`` will be left untouched.

        For now, this uses a UsdGeomBBoxCache with the"default","proxy",
        and"render"purposes.

        extent

        \- the out parameter for the extent. On success, it will contain two
        elements representing the min and max. time

        \- UsdTimeCode at which we want to evaluate the extent baseTime

        \- required for correct interpolation between samples when *velocities*
        or *angularVelocities* are present. If there are samples for
        *positions* and *velocities* at t1 and t2, normal value resolution
        would attempt to interpolate between the two samples, and if they
        could not be interpolated because they differ in size (common in cases
        where velocity is authored), will choose the sample at t1. When
        sampling for the purposes of motion-blur, for example, it is common,
        when rendering the frame at t2, to sample at [ t2-shutter/2,
        t2+shutter/2 ] for a shutter interval of *shutter*. The first sample
        falls between t1 and t2, but we must sample at t2 and apply velocity-
        based interpolation based on those samples to get a correct result. In
        such scenarios, one should provide a ``baseTime`` of t2 when querying
        *both* samples. If your application does not care about off-sample
        interpolation, it can supply the same value for ``baseTime`` that it
        does for ``time`` . When ``baseTime`` is less than or equal to
        ``time`` , we will choose the lower bracketing timeSample.


        Parameters
        ----------
        extent : Vec3fArray

        time : TimeCode

        baseTime : TimeCode



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the extent as if the matrix ``transform`` was first applied.


        Parameters
        ----------
        extent : Vec3fArray

        time : TimeCode

        baseTime : TimeCode

        transform : Matrix4d
        """
    @staticmethod
    @typing.overload
    def ComputeExtentAtTime(extent, time, baseTime, transform) -> bool: ...
    @staticmethod
    @typing.overload
    def ComputeExtentAtTimes(extents, times, baseTime) -> bool: 
        """
        ComputeExtentAtTimes(extents, times, baseTime) -> bool


        Compute the extent of the point instancer as in ComputeExtentAtTime,
        but across multiple ``times`` .


        This is equivalent to, but more efficient than, calling
        ComputeExtentAtTime several times. Each element in ``extents`` is the
        computed extent at the corresponding time in ``times`` .

        As in ComputeExtentAtTime, if there is no error, we return ``true``
        and ``extents`` will be the tightest bounds we can compute
        efficiently. If an error occurs computing the extent at any time,
        ``false`` will be returned and ``extents`` will be left untouched.

        times

        \- A vector containing the UsdTimeCodes at which we want to sample.


        Parameters
        ----------
        extents : list[Vec3fArray]

        times : list[TimeCode]

        baseTime : TimeCode



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the extent as if the matrix ``transform`` was first applied
        at each time.


        Parameters
        ----------
        extents : list[Vec3fArray]

        times : list[TimeCode]

        baseTime : TimeCode

        transform : Matrix4d
        """
    @staticmethod
    @typing.overload
    def ComputeExtentAtTimes(extents, times, baseTime, transform) -> bool: ...
    @staticmethod
    def ComputeInstanceTransformsAtTime(xforms, stage, time, protoIndices, positions, velocities, velocitiesSampleTime, accelerations, scales, orientations, angularVelocities, angularVelocitiesSampleTime, protoPaths, mask, velocityScale) -> bool: 
        """
        **classmethod** ComputeInstanceTransformsAtTime(xforms, time, baseTime, doProtoXforms, applyMask) -> bool


        Compute the per-instance,"PointInstancer relative"transforms given the
        positions, scales, orientations, velocities and angularVelocities at
        ``time`` , as described in Computing an Instance Transform.


        This will return ``false`` and leave ``xforms`` untouched if:

           - ``xforms`` is None

           - one of ``time`` and ``baseTime`` is numeric and the other is
             UsdTimeCode::Default() (they must either both be numeric or both be
             default)

           - there is no authored *protoIndices* attribute or *positions*
             attribute

           - the size of any of the per-instance attributes does not match the
             size of *protoIndices*

           - ``doProtoXforms`` is ``IncludeProtoXform`` but an index value in
             *protoIndices* is outside the range [0, prototypes.size())

           - ``applyMask`` is ``ApplyMask`` and a mask is set but the size of
             the mask does not match the size of *protoIndices*.

        If there is no error, we will return ``true`` and ``xforms`` will
        contain the computed transformations.

        xforms

        \- the out parameter for the transformations. Its size will depend on
        the authored data and ``applyMask`` time

        \- UsdTimeCode at which we want to evaluate the transforms baseTime

        \- required for correct interpolation between samples when *velocities*
        or *angularVelocities* are present. If there are samples for
        *positions* and *velocities* at t1 and t2, normal value resolution
        would attempt to interpolate between the two samples, and if they
        could not be interpolated because they differ in size (common in cases
        where velocity is authored), will choose the sample at t1. When
        sampling for the purposes of motion-blur, for example, it is common,
        when rendering the frame at t2, to sample at [ t2-shutter/2,
        t2+shutter/2 ] for a shutter interval of *shutter*. The first sample
        falls between t1 and t2, but we must sample at t2 and apply velocity-
        based interpolation based on those samples to get a correct result. In
        such scenarios, one should provide a ``baseTime`` of t2 when querying
        *both* samples. If your application does not care about off-sample
        interpolation, it can supply the same value for ``baseTime`` that it
        does for ``time`` . When ``baseTime`` is less than or equal to
        ``time`` , we will choose the lower bracketing timeSample. Selecting
        sample times with respect to baseTime will be performed independently
        for positions and orientations. doProtoXforms

        \- specifies whether to include the root transformation of each
        instance's prototype in the instance's transform. Default is to
        include it, but some clients may want to apply the proto transform as
        part of the prototype itself, so they can specify
        ``ExcludeProtoXform`` instead. applyMask

        \- specifies whether to apply ApplyMaskToArray() to the computed
        result. The default is ``ApplyMask`` .


        Parameters
        ----------
        xforms : VtArray[Matrix4d]

        time : TimeCode

        baseTime : TimeCode

        doProtoXforms : ProtoXformInclusion

        applyMask : MaskApplication



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Perform the per-instance transform computation as described in
        Computing an Instance Transform.


        This does the same computation as the non-static
        ComputeInstanceTransformsAtTime method, but takes all data as
        parameters rather than accessing authored data.

        xforms

        \- the out parameter for the transformations. Its size will depend on
        the given data and ``applyMask`` stage

        \- the UsdStage time

        \- time at which we want to evaluate the transforms protoIndices

        \- array containing all instance prototype indices. positions

        \- array containing all instance positions. This array must be the same
        size as ``protoIndices`` . velocities

        \- array containing all instance velocities. This array must be either
        the same size as ``protoIndices`` or empty. If it is empty, transforms
        are computed as if all velocities were zero in all dimensions.
        velocitiesSampleTime

        \- time at which the samples from ``velocities`` were taken.
        accelerations

        \- array containing all instance accelerations. This array must be
        either the same size as ``protoIndicesor`` empty. If it is empty,
        transforms are computed as if all accelerations were zero in all
        dimensions. scales

        \- array containing all instance scales. This array must be either the
        same size as ``protoIndices`` or empty. If it is empty, transforms are
        computed with no change in scale. orientations

        \- array containing all instance orientations. This array must be
        either the same size as ``protoIndices`` or empty. If it is empty,
        transforms are computed with no change in orientation
        angularVelocities

        \- array containing all instance angular velocities. This array must be
        either the same size as ``protoIndices`` or empty. If it is empty,
        transforms are computed as if all angular velocities were zero in all
        dimensions. angularVelocitiesSampleTime

        \- time at which the samples from ``angularVelocities`` were taken.
        protoPaths

        \- array containing the paths for all instance prototypes. If this
        array is not empty, prototype transforms are applied to the instance
        transforms. mask

        \- vector containing a mask to apply to the computed result. This
        vector must be either the same size as ``protoIndices`` or empty. If
        it is empty, no mask is applied. velocityScale

        \- Deprecated


        Parameters
        ----------
        xforms : VtArray[Matrix4d]

        stage : UsdStageWeak

        time : TimeCode

        protoIndices : IntArray

        positions : Vec3fArray

        velocities : Vec3fArray

        velocitiesSampleTime : TimeCode

        accelerations : Vec3fArray

        scales : Vec3fArray

        orientations : QuathArray

        angularVelocities : Vec3fArray

        angularVelocitiesSampleTime : TimeCode

        protoPaths : list[SdfPath]

        mask : list[bool]

        velocityScale : float
        """
    @staticmethod
    def ComputeInstanceTransformsAtTimes(xformsArray, times, baseTime, doProtoXforms, applyMask) -> bool: 
        """
        ComputeInstanceTransformsAtTimes(xformsArray, times, baseTime, doProtoXforms, applyMask) -> bool


        Compute the per-instance transforms as in
        ComputeInstanceTransformsAtTime, but using multiple sample times.


        An array of matrix arrays is returned where each matrix array contains
        the instance transforms for the corresponding time in ``times`` .

        times

        \- A vector containing the UsdTimeCodes at which we want to sample.


        Parameters
        ----------
        xformsArray : list[VtArray[Matrix4d]]

        times : list[TimeCode]

        baseTime : TimeCode

        doProtoXforms : ProtoXformInclusion

        applyMask : MaskApplication
        """
    @staticmethod
    def ComputeMaskAtTime(time, ids) -> list[bool]: 
        """
        ComputeMaskAtTime(time, ids) -> list[bool]


        Computes a presence mask to be applied to per-instance data arrays
        based on authored *inactiveIds*, *invisibleIds*, and *ids*.


        If no *ids* attribute has been authored, then the values in
        *inactiveIds* and *invisibleIds* will be interpreted directly as
        indices of *protoIndices*.

        If ``ids`` is non-None, it is assumed to be the id-mapping to apply,
        and must match the length of *protoIndices* at ``time`` . If None, we
        will call GetIdsAttr() .Get(time)

        If all"live"instances at UsdTimeCode ``time`` pass the mask, we will
        return an **empty** mask so that clients can trivially recognize the
        common"no masking"case. The returned mask can be used with
        ApplyMaskToArray() , and will contain a ``true`` value for every
        element that should survive.


        Parameters
        ----------
        time : TimeCode

        ids : Int64Array
        """
    @staticmethod
    def CreateAccelerationsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAccelerationsAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateAngularVelocitiesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAngularVelocitiesAttr(defaultValue, writeSparsely) -> Attribute


        See GetAngularVelocitiesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateIdsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateIdsAttr(defaultValue, writeSparsely) -> Attribute


        See GetIdsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateInvisibleIdsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateInvisibleIdsAttr(defaultValue, writeSparsely) -> Attribute


        See GetInvisibleIdsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateOrientationsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateOrientationsAttr(defaultValue, writeSparsely) -> Attribute


        See GetOrientationsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreatePositionsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreatePositionsAttr(defaultValue, writeSparsely) -> Attribute


        See GetPositionsAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateProtoIndicesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateProtoIndicesAttr(defaultValue, writeSparsely) -> Attribute


        See GetProtoIndicesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreatePrototypesRel() -> Relationship: 
        """
        CreatePrototypesRel() -> Relationship


        See GetPrototypesRel() , and also Create vs Get Property Methods for
        when to use Get vs Create.
        """
    @staticmethod
    def CreateScalesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateScalesAttr(defaultValue, writeSparsely) -> Attribute


        See GetScalesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVelocitiesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVelocitiesAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def DeactivateId(id) -> bool: 
        """
        DeactivateId(id) -> bool


        Ensure that the instance identified by ``id`` is inactive over all
        time.


        This deactivation is encoded sparsely, affecting no other instances.

        A deactivated instance is guaranteed not to render if the renderer
        honors masking.


        Parameters
        ----------
        id : int
        """
    @staticmethod
    def DeactivateIds(ids) -> bool: 
        """
        DeactivateIds(ids) -> bool


        Ensure that the instances identified by ``ids`` are inactive over all
        time.


        This deactivation is encoded sparsely, affecting no other instances.

        A deactivated instance is guaranteed not to render if the renderer
        honors masking.


        Parameters
        ----------
        ids : Int64Array
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> PointInstancer


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> PointInstancer


        Return a UsdGeomPointInstancer holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomPointInstancer(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAccelerationsAttr() -> Attribute: 
        """
        GetAccelerationsAttr() -> Attribute


        If authored, per-instance'accelerations'will be used with velocities
        to compute positions between samples for the'positions'attribute
        rather than interpolating between neighboring'positions'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
        """
    @staticmethod
    def GetAngularVelocitiesAttr() -> Attribute: 
        """
        GetAngularVelocitiesAttr() -> Attribute


        If authored, per-instance angular velocity vector to be used for
        interoplating orientations.


        Angular velocities should be considered mandatory if both
        *protoIndices* and *orientations* are animated. Angular velocity is
        measured in **degrees** per second. To convert to degrees per
        UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond() .

        See also Computing an Instance Transform.

        Declaration

        ``vector3f[] angularVelocities``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Vector3fArray
        """
    @staticmethod
    def GetIdsAttr() -> Attribute: 
        """
        GetIdsAttr() -> Attribute


        Ids are optional; if authored, the ids array should be the same length
        as the *protoIndices* array, specifying (at each timeSample if
        instance identities are changing) the id of each instance.


        The type is signed intentionally, so that clients can encode some
        binary state on Id'd instances without adding a separate primvar. See
        also Varying Instance Identity over Time

        Declaration

        ``int64[] ids``

        C++ Type

        VtArray<int64_t>

        Usd Type

        SdfValueTypeNames->Int64Array
        """
    @staticmethod
    def GetInstanceCount(timeCode) -> int: 
        """
        GetInstanceCount(timeCode) -> int


        Returns the number of instances as defined by the size of the
        *protoIndices* array at *timeCode*.



        For most code, this check will be performant. When using file formats
        where the cost of attribute reading is high and the time sampled array
        will be read into memory later, it may be better to explicitly read
        the value once and check the size of the array directly.


        Parameters
        ----------
        timeCode : TimeCode
        """
    @staticmethod
    def GetInvisibleIdsAttr() -> Attribute: 
        """
        GetInvisibleIdsAttr() -> Attribute


        A list of id's to make invisible at the evaluation time.


        See invisibleIds: Animatable Masking.

        Declaration

        ``int64[] invisibleIds = []``

        C++ Type

        VtArray<int64_t>

        Usd Type

        SdfValueTypeNames->Int64Array
        """
    @staticmethod
    def GetOrientationsAttr() -> Attribute: 
        """
        GetOrientationsAttr() -> Attribute


        If authored, per-instance orientation of each instance about its
        prototype's origin, represented as a unit length quaternion, which
        allows us to encode it with sufficient precision in a compact GfQuath.


        It is client's responsibility to ensure that authored quaternions are
        unit length; the convenience API below for authoring orientations from
        rotation matrices will ensure that quaternions are unit length, though
        it will not make any attempt to select the"better (for
        interpolationwith respect to neighboring samples)"of the two possible
        quaternions that encode the rotation.

        See also Computing an Instance Transform.

        Declaration

        ``quath[] orientations``

        C++ Type

        VtArray<GfQuath>

        Usd Type

        SdfValueTypeNames->QuathArray
        """
    @staticmethod
    def GetPositionsAttr() -> Attribute: 
        """
        GetPositionsAttr() -> Attribute


        **Required property**.


        Per-instance position. See also Computing an Instance Transform.

        Declaration

        ``point3f[] positions``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Point3fArray
        """
    @staticmethod
    def GetProtoIndicesAttr() -> Attribute: 
        """
        GetProtoIndicesAttr() -> Attribute


        **Required property**.


        Per-instance index into *prototypes* relationship that identifies what
        geometry should be drawn for each instance. **Topology attribute** -
        can be animated, but at a potential performance impact for streaming.

        Declaration

        ``int[] protoIndices``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetPrototypesRel() -> Relationship: 
        """
        GetPrototypesRel() -> Relationship


        **Required property**.


        Orders and targets the prototype root prims, which can be located
        anywhere in the scenegraph that is convenient, although we promote
        organizing prototypes as children of the PointInstancer. The position
        of a prototype in this relationship defines the value an instance
        would specify in the *protoIndices* attribute to instance that
        prototype. Since relationships are uniform, this property cannot be
        animated.
        """
    @staticmethod
    def GetScalesAttr() -> Attribute: 
        """
        GetScalesAttr() -> Attribute


        If authored, per-instance scale to be applied to each instance, before
        any rotation is applied.


        See also Computing an Instance Transform.

        Declaration

        ``float3[] scales``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Float3Array
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetVelocitiesAttr() -> Attribute: 
        """
        GetVelocitiesAttr() -> Attribute


        If provided, per-instance'velocities'will be used to compute positions
        between samples for the'positions'attribute, rather than interpolating
        between neighboring'positions'samples.


        Velocities should be considered mandatory if both *protoIndices* and
        *positions* are animated. 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 Computing an Instance Transform, Applying Timesampled
        Velocities to Geometry.

        Declaration

        ``vector3f[] velocities``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Vector3fArray
        """
    @staticmethod
    def InvisId(id, time) -> bool: 
        """
        InvisId(id, time) -> bool


        Ensure that the instance identified by ``id`` is invisible at ``time``
        .


        This will cause *invisibleIds* to first be broken down (keyed) at
        ``time`` , causing all animation in weaker layers that the current
        UsdEditTarget to be overridden. Has no effect on any timeSamples other
        than the one at ``time`` .

        An invised instance is guaranteed not to render if the renderer honors
        masking.


        Parameters
        ----------
        id : int

        time : TimeCode
        """
    @staticmethod
    def InvisIds(ids, time) -> bool: 
        """
        InvisIds(ids, time) -> bool


        Ensure that the instances identified by ``ids`` are invisible at
        ``time`` .


        This will cause *invisibleIds* to first be broken down (keyed) at
        ``time`` , causing all animation in weaker layers that the current
        UsdEditTarget to be overridden. Has no effect on any timeSamples other
        than the one at ``time`` .

        An invised instance is guaranteed not to render if the renderer honors
        masking.


        Parameters
        ----------
        ids : Int64Array

        time : TimeCode
        """
    @staticmethod
    def VisAllIds(time) -> bool: 
        """
        VisAllIds(time) -> bool


        Ensure that all instances are visible at ``time`` .


        Operates by authoring an empty array at ``time`` .

        This does not guarantee that the instances will be rendered, because
        each may still be"inactive"due to its id being present in the
        *inactivevIds* metadata (see ActivateId() , DeactivateId() )


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def VisId(id, time) -> bool: 
        """
        VisId(id, time) -> bool


        Ensure that the instance identified by ``id`` is visible at ``time`` .


        This will cause *invisibleIds* to first be broken down (keyed) at
        ``time`` , causing all animation in weaker layers that the current
        UsdEditTarget to be overridden. Has no effect on any timeSamples other
        than the one at ``time`` . If the *invisibleIds* attribute is not
        authored or is blocked, this operation is a no-op.

        This does not guarantee that the instance will be rendered, because it
        may still be"inactive"due to ``id`` being present in the
        *inactivevIds* metadata (see ActivateId() , DeactivateId() )


        Parameters
        ----------
        id : int

        time : TimeCode
        """
    @staticmethod
    def VisIds(ids, time) -> bool: 
        """
        VisIds(ids, time) -> bool


        Ensure that the instances identified by ``ids`` are visible at
        ``time`` .


        This will cause *invisibleIds* to first be broken down (keyed) at
        ``time`` , causing all animation in weaker layers that the current
        UsdEditTarget to be overridden. Has no effect on any timeSamples other
        than the one at ``time`` . If the *invisibleIds* attribute is not
        authored or is blocked, this operation is a no-op.

        This does not guarantee that the instances will be rendered, because
        each may still be"inactive"due to ``id`` being present in the
        *inactivevIds* metadata (see ActivateId() , DeactivateId() )


        Parameters
        ----------
        ids : Int64Array

        time : TimeCode
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    ApplyMask: pxr.UsdGeom.MaskApplication # value = UsdGeom.PointInstancer.ApplyMask
    ExcludeProtoXform: pxr.UsdGeom.ProtoXformInclusion # value = UsdGeom.PointInstancer.ExcludeProtoXform
    IgnoreMask: pxr.UsdGeom.MaskApplication # value = UsdGeom.PointInstancer.IgnoreMask
    IncludeProtoXform: pxr.UsdGeom.ProtoXformInclusion # value = UsdGeom.PointInstancer.IncludeProtoXform
    __instance_size__ = 40
    pass
class Primvar(Boost.Python.instance):
    """
    Schema wrapper for UsdAttribute for authoring and introspecting
    attributes that are primvars.

    UsdGeomPrimvar provides API for authoring and retrieving the
    additional data required to encode an attribute as a"Primvar", which
    is a convenient contraction of RenderMan's"Primitive Variable"concept,
    which is represented in Alembic as"arbitrary geometry
    parameters"(arbGeomParams).

    This includes the attribute's interpolation across the primitive
    (which RenderMan refers to as its class specifier and Alembic as its
    "geometry scope" ); it also includes the attribute's elementSize,
    which states how many values in the value array must be aggregated for
    each element on the primitive. An attribute's TypeName also factors
    into the encoding of Primvar.

    What is the Purpose of a Primvar?
    =================================

    There are three key aspects of Primvar identity:

       - Primvars define a value that can vary across the primitive on
         which they are defined, via prescribed interpolation rules

       - Taken collectively on a prim, its Primvars describe the"per-
         primitiveoverrides"to the material to which the prim is bound.
         Different renderers may communicate the variables to the shaders using
         different mechanisms over which Usd has no control; Primvars simply
         provide the classification that any renderer should use to locate
         potential overrides. Do please note that primvars override parameters
         on UsdShadeShader objects, *not* Interface Attributes on
         UsdShadeMaterial prims.

       - *Primvars inherit down scene namespace.* Regular USD attributes
         only apply to the prim on which they are specified, but primvars
         implicitly also apply to any child prims, unless those child prims
         have their own opinions about those primvars. This capability
         necessarily entails added cost to check for inherited values, but the
         benefit is that it allows concise encoding of certain opinions that
         broadly affect large amounts of geometry. See
         UsdGeomImageable::FindInheritedPrimvars().

    Creating and Accessing Primvars
    ===============================

    The UsdGeomPrimvarsAPI schema provides a complete interface for
    creating and querying prims for primvars.

    The **only** way to create a new Primvar in scene description is by
    calling UsdGeomPrimvarsAPI::CreatePrimvar() . One
    cannot"enhance"or"promote"an already existing attribute into a
    Primvar, because doing so may require a namespace edit to rename the
    attribute, which cannot, in general, be done within a single
    UsdEditContext. Instead, create a new UsdGeomPrimvar of the desired
    name using UsdGeomPrimvarsAPI::CreatePrimvar() , and then copy the
    existing attribute onto the new UsdGeomPrimvar.

    Primvar names can contain arbitrary sub-namespaces. The behavior of
    UsdGeomImageable::GetPrimvar(TfToken const & name) is to
    prepend"primvars:"onto'name'if it is not already a prefix, and return
    the result, which means we do not have any ambiguity between the
    primvars"primvars:nsA:foo"and"primvars:nsB:foo". **There are reserved
    keywords that may not be used as the base names of primvars,** and
    attempting to create Primvars of these names will result in a coding
    error. The reserved keywords are tokens the Primvar uses internally to
    encode various features, such as the"indices"keyword used by Indexed
    Primvars.

    If a client wishes to access an already-extant attribute as a Primvar,
    (which may or may not actually be valid Primvar), they can use the
    speculative constructor; typically, a primvar is only"interesting"if
    it additionally provides a value. This might look like:

    .. code-block:: text

      UsdGeomPrimvar primvar = UsdGeomPrimvar(usdAttr);
      if (primvar.HasValue()) {
          VtValue values;
          primvar.Get(&values, timeCode);
          TfToken interpolation = primvar.GetInterpolation();
          int     elementSize = primvar.GetElementSize();
          \.\.\.
      }

    or, because Get() returns ``true`` if and only if it found a value:

    .. code-block:: text

      UsdGeomPrimvar primvar = UsdGeomPrimvar(usdAttr);
      VtValue values;
      if (primvar.Get(&values, timeCode)) {
          TfToken interpolation = primvar.GetInterpolation();
          int     elementSize = primvar.GetElementSize();
          \.\.\.
      }

    As discussed in greater detail in Indexed Primvars, primvars can
    optionally contain a (possibly time-varying) indexing attribute that
    establishes a sharing topology for elements of the primvar. Consumers
    can always chose to ignore the possibility of indexed data by
    exclusively using the ComputeFlattened() API. If a client wishes to
    preserve indexing in their processing of a primvar, we suggest a
    pattern like the following, which accounts for the fact that a
    stronger layer can block a primvar's indexing from a weaker layer, via
    UsdGeomPrimvar::BlockIndices() :

    .. code-block:: text

      VtValue values;
      VtIntArray indices;
      
      if (primvar.Get(&values, timeCode)){
          if (primvar.GetIndices(&indices, timeCode)){
              // primvar is indexed: validate/process values and indices together
          }
          else {
              // primvar is not indexed: validate/process values as flat array
          }
      }

    UsdGeomPrimvar presents a small slice of the UsdAttribute API - enough
    to extract the data that comprises the"Declaration info", and get/set
    of the attribute value. A UsdGeomPrimvar also auto-converts to
    UsdAttribute, so you can pass a UsdGeomPrimvar to any function that
    accepts a UsdAttribute or const-ref thereto.

    Primvar Allowed Scene Description Types and Plurality
    =====================================================

    There are no limitations imposed on the allowable scene description
    types for Primvars; it is the responsibility of each consuming client
    to perform renderer-specific conversions, if need be (the USD
    distribution will include reference RenderMan conversion utilities).

    A note about type plurality of Primvars: It is legitimate for a
    Primvar to be of scalar or array type, and again, consuming clients
    must be prepared to accommodate both. However, while it is not
    possible, in all cases, for USD to *prevent* one from *changing* the
    type of an attribute in different layers or variants of an asset, it
    is never a good idea to do so. This is relevant because, except in a
    few special cases, it is not possible to encode an *interpolation* of
    any value greater than *constant* without providing multiple (i.e.
    array) data values. Therefore, if there is any possibility that
    downstream clients might need to change a Primvar's interpolation, the
    Primvar-creator should encode it as an array rather than a scalar.

    Why allow scalar values at all, then? First, sometimes it brings
    clarity to (use of) a shader's API to acknowledge that some parameters
    are meant to be single-valued over a shaded primitive. Second, many
    DCC's provide far richer affordances for editing scalars than they do
    array values, and we feel it is safer to let the content creator make
    the decision/tradeoff of which kind of flexibility is more relevant,
    rather than leaving it to an importer/exporter pair to interpret.

    Also, like all attributes, Primvars can be time-sampled, and values
    can be authored and consumed just as any other attribute. There is
    currently no validation that the length of value arrays matches to the
    size required by a gprim's topology, interpolation, and elementSize.

    For consumer convenience, we provide GetDeclarationInfo() , which
    returns all the type information (other than topology) needed to
    compute the required array size, which is also all the information
    required to prepare the Primvar's value for consumption by a renderer.

    Lifetime Management and Primvar Validity
    ========================================

    UsdGeomPrimvar has an explicit bool operator that validates that the
    attribute IsDefined() and thus valid for querying and authoring values
    and metadata. This is a fairly expensive query that we do **not**
    cache, so if client code retains UsdGeomPrimvar objects, it should
    manage its object validity closely, for performance. An ideal pattern
    is to listen for UsdNotice::StageContentsChanged notifications, and
    revalidate/refetch its retained UsdGeomPrimvar s only then, and
    otherwise use them without validity checking.

    Interpolation of Geometric Primitive Variables
    ==============================================

    In the following explanation of the meaning of the various
    kinds/levels of Primvar interpolation, each bolded bullet gives the
    name of the token in UsdGeomTokens that provides the value. So to set
    a Primvar's interpolation to"varying", one would:

    .. code-block:: text

      primvar.SetInterpolation(UsdGeomTokens->varying);

    Reprinted and adapted from the RPS documentation, which contains
    further details, *interpolation* describes how the Primvar will be
    interpolated over the uv parameter space of a surface primitive (or
    curve or pointcloud). The possible values are:

       - **constant** One value remains constant over the entire surface
         primitive.

       - **uniform** One value remains constant for each uv patch segment
         of the surface primitive (which is a *face* for meshes).

       - **varying** Four values are interpolated over each uv patch
         segment of the surface. Bilinear interpolation is used for
         interpolation between the four values.

       - **vertex** Values are interpolated between each vertex in the
         surface primitive. The basis function of the surface is used for
         interpolation between vertices.

       - **faceVarying** For polygons and subdivision surfaces, four
         values are interpolated over each face of the mesh. Bilinear
         interpolation is used for interpolation between the four values.

    UsdGeomPrimvar As Example of Attribute Schema
    =============================================

    Just as UsdSchemaBase and its subclasses provide the pattern for how
    to layer schema onto the generic UsdPrim object, UsdGeomPrimvar
    provides an example of how to layer schema onto a generic UsdAttribute
    object. In both cases, the schema object wraps and contains the
    UsdObject.

    Primvar Namespace Inheritance
    =============================

    Constant interpolation primvar values can be inherited down namespace.
    That is, a primvar value set on a prim will also apply to any child
    prims, unless those children have their own opinions about those named
    primvars. For complete details on how primvars inherit, see
    usdGeom_PrimvarInheritance.

    UsdGeomImageable::FindInheritablePrimvars().
    """
    @staticmethod
    def BlockIndices() -> None: 
        """
        BlockIndices() -> None


        Block the indices that were previously set.


        This effectively makes an indexed primvar no longer indexed. This is
        useful when overriding an existing primvar.
        """
    @staticmethod
    @typing.overload
    def ComputeFlattened(value, time) -> bool: 
        """
        **classmethod** ComputeFlattened(value, time) -> bool


        Computes the flattened value of the primvar at ``time`` .


        If the primvar is not indexed or if the value type of this primvar is
        a scalar, this returns the authored value, which is the same as Get()
        . Hence, it's safe to call ComputeFlattened() on non-indexed primvars.


        Parameters
        ----------
        value : VtArray[ScalarType]

        time : TimeCode



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Computes the flattened value of the primvar at ``time`` as a VtValue.


        If the primvar is not indexed or if the value type of this primvar is
        a scalar, this returns the authored value, which is the same as Get()
        . Hence, it's safe to call ComputeFlattened() on non-indexed primvars.


        Parameters
        ----------
        value : VtValue

        time : TimeCode



        ----------------------------------------------------------------------


        Computes the flattened value of ``attrValue`` given ``indices`` .


        This method is a static convenience function that performs the main
        work of ComputeFlattened above without needing an instance of a
        UsdGeomPrimvar.

        Returns ``false`` if the value contained in ``attrVal`` is not a
        supported type for flattening. Otherwise returns ``true`` . The output
        ``errString`` variable may be populated with an error string if an
        error is encountered during flattening.


        Parameters
        ----------
        value : VtValue

        attrVal : VtValue

        indices : IntArray

        errString : str
        """
    @staticmethod
    @typing.overload
    def ComputeFlattened(value, attrVal, indices, errString) -> bool: ...
    @staticmethod
    def CreateIndicesAttr() -> Attribute: 
        """
        CreateIndicesAttr() -> Attribute


        Returns the existing indices attribute if the primvar is indexed or
        creates a new one.
        """
    @staticmethod
    def Get(value, time) -> bool: 
        """
        Get(value, time) -> bool


        Get the attribute value of the Primvar at ``time`` .



        Usd_Handling_Indexed_Primvars for proper handling of indexed primvars


        Parameters
        ----------
        value : T

        time : TimeCode



        ----------------------------------------------------------------------


        Parameters
        ----------
        value : str

        time : TimeCode



        ----------------------------------------------------------------------


        Parameters
        ----------
        value : StringArray

        time : TimeCode



        ----------------------------------------------------------------------


        Parameters
        ----------
        value : VtValue

        time : TimeCode
        """
    @staticmethod
    def GetAttr() -> Attribute: 
        """
        GetAttr() -> Attribute


        Explicit UsdAttribute extractor.
        """
    @staticmethod
    def GetBaseName() -> str: 
        """
        GetBaseName() -> str



        UsdAttribute::GetBaseName()
        """
    @staticmethod
    def GetDeclarationInfo(name, typeName, interpolation, elementSize) -> None: 
        """
        GetDeclarationInfo(name, typeName, interpolation, elementSize) -> None


        Convenience function for fetching all information required to properly
        declare this Primvar.


        The ``name`` returned is the"client name", stripped of
        the"primvars"namespace, i.e. equivalent to GetPrimvarName()

        May also be more efficient than querying key individually.


        Parameters
        ----------
        name : str

        typeName : ValueTypeName

        interpolation : str

        elementSize : int
        """
    @staticmethod
    def GetElementSize() -> int: 
        """
        GetElementSize() -> int


        Return the"element size"for this Primvar, which is 1 if unauthored.


        If this Primvar's type is *not* an array type, (e.g."Vec3f[]"), then
        elementSize is irrelevant.

        ElementSize does *not* generally encode the length of an array-type
        primvar, and rarely needs to be authored. ElementSize can be thought
        of as a way to create an"aggregate interpolatable type", by dictating
        how many consecutive elements in the value array should be taken as an
        atomic element to be interpolated over a gprim.

        For example, spherical harmonics are often represented as a collection
        of nine floating-point coefficients, and the coefficients need to be
        sampled across a gprim's surface: a perfect case for primvars.
        However, USD has no ``float9`` datatype. But we can communicate the
        aggregation of nine floats successfully to renderers by declaring a
        simple float-array valued primvar, and setting its *elementSize* to 9.
        To author a *uniform* spherical harmonic primvar on a Mesh of 42
        faces, the primvar's array value would contain 9\*42 = 378 float
        elements.
        """
    @staticmethod
    def GetIndices(indices, time) -> bool: 
        """
        GetIndices(indices, time) -> bool


        Returns the value of the indices array associated with the indexed
        primvar at ``time`` .




        Parameters
        ----------
        indices : IntArray

        time : TimeCode
        """
    @staticmethod
    def GetIndicesAttr() -> Attribute: 
        """
        GetIndicesAttr() -> Attribute


        Returns a valid indices attribute if the primvar is indexed.


        Returns an invalid attribute otherwise.
        """
    @staticmethod
    def GetInterpolation() -> str: 
        """
        GetInterpolation() -> str


        Return the Primvar's interpolation, which is UsdGeomTokens->constant
        if unauthored.


        Interpolation determines how the Primvar interpolates over a geometric
        primitive. See Interpolation of Geometric Primitive Variables
        """
    @staticmethod
    def GetName() -> str: 
        """
        GetName() -> str



        UsdAttribute::GetName()
        """
    @staticmethod
    def GetNamespace() -> str: 
        """
        GetNamespace() -> str



        UsdAttribute::GetNamespace()
        """
    @staticmethod
    def GetPrimvarName() -> str: 
        """
        GetPrimvarName() -> str


        Returns the primvar's name, devoid of the"primvars:"namespace.


        This is the name by which clients should refer to the primvar, if not
        by its full attribute name - i.e. they should **not**, in general, use
        GetBaseName() . In the error condition in which this Primvar object is
        not backed by a properly namespaced UsdAttribute, return an empty
        TfToken.
        """
    @staticmethod
    def GetTimeSamples(times) -> bool: 
        """
        GetTimeSamples(times) -> bool


        Populates a vector with authored sample times for this primvar.


        Returns false on error.

        This considers any timeSamples authored on the
        associated"indices"attribute if the primvar is indexed.

        UsdAttribute::GetTimeSamples


        Parameters
        ----------
        times : list[float]
        """
    @staticmethod
    def GetTimeSamplesInInterval(interval, times) -> bool: 
        """
        GetTimeSamplesInInterval(interval, times) -> bool


        Populates a vector with authored sample times in ``interval`` .


        This considers any timeSamples authored on the
        associated"indices"attribute if the primvar is indexed.

        UsdAttribute::GetTimeSamplesInInterval


        Parameters
        ----------
        interval : Interval

        times : list[float]
        """
    @staticmethod
    def GetTypeName() -> ValueTypeName: 
        """
        GetTypeName() -> ValueTypeName



        UsdAttribute::GetTypeName()
        """
    @staticmethod
    def GetUnauthoredValuesIndex() -> int: 
        """
        GetUnauthoredValuesIndex() -> int


        Returns the index that represents unauthored values in the indices
        array.
        """
    @staticmethod
    def HasAuthoredElementSize() -> bool: 
        """
        HasAuthoredElementSize() -> bool


        Has elementSize been explicitly authored on this Primvar?
        """
    @staticmethod
    def HasAuthoredInterpolation() -> bool: 
        """
        HasAuthoredInterpolation() -> bool


        Has interpolation been explicitly authored on this Primvar?
        """
    @staticmethod
    def HasAuthoredValue() -> bool: 
        """
        HasAuthoredValue() -> bool


        Return true if the underlying attribute has an unblocked, authored
        value.
        """
    @staticmethod
    def HasValue() -> bool: 
        """
        HasValue() -> bool


        Return true if the underlying attribute has a value, either from
        authored scene description or a fallback.
        """
    @staticmethod
    def IsDefined() -> bool: 
        """
        IsDefined() -> bool


        Return true if the underlying UsdAttribute::IsDefined() , and in
        addition the attribute is identified as a Primvar.


        Does not imply that the primvar provides a value
        """
    @staticmethod
    def IsIdTarget() -> bool: 
        """
        IsIdTarget() -> bool


        Returns true if the primvar is an Id primvar.



        UsdGeomPrimvar_Id_primvars
        """
    @staticmethod
    def IsIndexed() -> bool: 
        """
        IsIndexed() -> bool


        Returns true if the primvar is indexed, i.e., if it has an
        associated"indices"attribute.


        If you are going to query the indices anyways, prefer to simply
        consult the return-value of GetIndices() , which will be more
        efficient.
        """
    @staticmethod
    def IsPrimvar(*args, **kwargs) -> None: 
        """
        **classmethod** IsPrimvar(attr) -> bool


        Test whether a given UsdAttribute represents valid Primvar, which
        implies that creating a UsdGeomPrimvar from the attribute will
        succeed.


        Success implies that ``attr.IsDefined()`` is true.


        Parameters
        ----------
        attr : Attribute
        """
    @staticmethod
    def IsValidInterpolation(*args, **kwargs) -> None: 
        """
        **classmethod** IsValidInterpolation(interpolation) -> bool


        Validate that the provided ``interpolation`` is a valid setting for
        interpolation as defined by Interpolation of Geometric Primitive
        Variables.




        Parameters
        ----------
        interpolation : str
        """
    @staticmethod
    def IsValidPrimvarName(*args, **kwargs) -> None: 
        """
        **classmethod** IsValidPrimvarName(name) -> bool


        Test whether a given ``name`` represents a valid name of a primvar,
        which implies that creating a UsdGeomPrimvar with the given name will
        succeed.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def NameContainsNamespaces() -> bool: 
        """
        NameContainsNamespaces() -> bool


        Does this primvar contain any namespaces other than
        the"primvars:"namespace?


        Some clients may only wish to consume primvars that have no extra
        namespaces in their names, for ease of translating to other systems
        that do not allow namespaces.
        """
    @staticmethod
    def Set(value, time) -> bool: 
        """
        Set(value, time) -> bool


        Set the attribute value of the Primvar at ``time`` .


        Parameters
        ----------
        value : T

        time : TimeCode
        """
    @staticmethod
    def SetElementSize(eltSize) -> bool: 
        """
        SetElementSize(eltSize) -> bool


        Set the elementSize for this Primvar.


        Errors and returns false if ``eltSize`` less than 1.


        Parameters
        ----------
        eltSize : int
        """
    @staticmethod
    def SetIdTarget(path) -> bool: 
        """
        SetIdTarget(path) -> bool


        This primvar must be of String or StringArray type for this method to
        succeed.


        If not, a coding error is raised.

        UsdGeomPrimvar_Id_primvars


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def SetIndices(indices, time) -> bool: 
        """
        SetIndices(indices, time) -> bool


        Sets the indices value of the indexed primvar at ``time`` .


        The values in the indices array must be valid indices into the
        authored array returned by Get() . The element numerality of the
        primvar's'interpolation'metadata applies to the"indices"array, not the
        attribute value array (returned by Get() ).


        Parameters
        ----------
        indices : IntArray

        time : TimeCode
        """
    @staticmethod
    def SetInterpolation(interpolation) -> bool: 
        """
        SetInterpolation(interpolation) -> bool


        Set the Primvar's interpolation.


        Errors and returns false if ``interpolation`` is out of range as
        defined by IsValidInterpolation() . No attempt is made to validate
        that the Primvar's value contains the right number of elements to
        match its interpolation to its topology.


        Parameters
        ----------
        interpolation : str
        """
    @staticmethod
    def SetUnauthoredValuesIndex(unauthoredValuesIndex) -> bool: 
        """
        SetUnauthoredValuesIndex(unauthoredValuesIndex) -> bool


        Set the index that represents unauthored values in the indices array.


        Some apps (like Maya) allow you to author primvars sparsely over a
        surface. Since most apps can't handle sparse primvars, Maya needs to
        provide a value even for the elements it didn't author. This metadatum
        provides a way to recover the information in apps that do support
        sparse authoring / representation of primvars.

        The fallback value of unauthoredValuesIndex is -1, which indicates
        that there are no unauthored values.


        Parameters
        ----------
        unauthoredValuesIndex : int
        """
    @staticmethod
    def SplitName() -> list[str]: 
        """
        SplitName() -> list[str]



        UsdAttribute::SplitName()
        """
    @staticmethod
    def StripPrimvarsName(*args, **kwargs) -> None: 
        """
        **classmethod** StripPrimvarsName(name) -> str


        Returns the ``name`` , devoid of the"primvars:"token if present,
        otherwise returns the ``name`` unchanged.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def ValueMightBeTimeVarying() -> bool: 
        """
        ValueMightBeTimeVarying() -> bool


        Return true if it is possible, but not certain, that this primvar's
        value changes over time, false otherwise.


        This considers time-varyingness of the associated"indices"attribute if
        the primvar is indexed.

        UsdAttribute::ValueMightBeTimeVarying
        """
    __instance_size__ = 64
    pass
class PrimvarsAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    UsdGeomPrimvarsAPI encodes geometric"primitive variables", as
    UsdGeomPrimvar, which interpolate across a primitive's topology, can
    override shader inputs, and inherit down namespace.

    Which Method to Use to Retrieve Primvars
    ========================================

    While creating primvars is unambiguous ( CreatePrimvar() ), there are
    quite a few methods available for retrieving primvars, making it
    potentially confusing knowing which one to use. Here are some
    guidelines:

       - If you are populating a GUI with the primvars already available
         for authoring values on a prim, use GetPrimvars() .

       - If you want all of the"useful"(e.g. to a renderer) primvars
         available at a prim, including those inherited from ancestor prims,
         use FindPrimvarsWithInheritance() . Note that doing so individually
         for many prims will be inefficient.

       - To find a particular primvar defined directly on a prim, which
         may or may not provide a value, use GetPrimvar() .

       - To find a particular primvar defined on a prim or inherited from
         ancestors, which may or may not provide a value, use
         FindPrimvarWithInheritance() .

       - To *efficiently* query for primvars using the overloads of
         FindPrimvarWithInheritance() and FindPrimvarsWithInheritance() , one
         must first cache the results of FindIncrementallyInheritablePrimvars()
         for each non-leaf prim on the stage.
    """
    @staticmethod
    def BlockPrimvar(name) -> None: 
        """
        BlockPrimvar(name) -> None


        Remove all time samples on the primvar and its associated indices
        attr, and author a *block* ``default`` value.


        This will cause authored opinions in weaker layers to be ignored.

        UsdAttribute::Block() , UsdGeomPrimvar::BlockIndices


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def CanContainPropertyName(*args, **kwargs) -> None: 
        """
        **classmethod** CanContainPropertyName(name) -> bool


        Test whether a given ``name`` contains the"primvars:"prefix.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def CreateIndexedPrimvar(name, typeName, value, indices, interpolation, elementSize, time) -> Primvar: 
        """
        CreateIndexedPrimvar(name, typeName, value, indices, interpolation, elementSize, time) -> Primvar


        Author scene description to create an attribute and authoring a
        ``value`` on this prim that will be recognized as an indexed Primvar
        with ``indices`` appropriately set (i.e.


        will present as a valid UsdGeomPrimvar).

        an invalid UsdGeomPrimvar on error, a valid UsdGeomPrimvar otherwise.
        It is fine to call this method multiple times, and in different
        UsdEditTargets, even if there is an existing primvar of the same name,
        indexed or not.


        Parameters
        ----------
        name : str

        typeName : ValueTypeName

        value : T

        indices : IntArray

        interpolation : str

        elementSize : int

        time : TimeCode
        """
    @staticmethod
    def CreateNonIndexedPrimvar(name, typeName, value, interpolation, elementSize, time) -> Primvar: 
        """
        CreateNonIndexedPrimvar(name, typeName, value, interpolation, elementSize, time) -> Primvar


        Author scene description to create an attribute and authoring a
        ``value`` on this prim that will be recognized as a Primvar (i.e.


        will present as a valid UsdGeomPrimvar). Note that unlike
        CreatePrimvar using this API explicitly authors a block for the
        indices attr associated with the primvar, thereby blocking any indices
        set in any weaker layers.

        an invalid UsdGeomPrimvar on error, a valid UsdGeomPrimvar otherwise.
        It is fine to call this method multiple times, and in different
        UsdEditTargets, even if there is an existing primvar of the same name,
        indexed or not.


        Parameters
        ----------
        name : str

        typeName : ValueTypeName

        value : T

        interpolation : str

        elementSize : int

        time : TimeCode
        """
    @staticmethod
    def CreatePrimvar(name, typeName, interpolation, elementSize) -> Primvar: 
        """
        CreatePrimvar(name, typeName, interpolation, elementSize) -> Primvar


        Author scene description to create an attribute on this prim that will
        be recognized as Primvar (i.e.


        will present as a valid UsdGeomPrimvar).

        The name of the created attribute may or may not be the specified
        ``name`` , due to the possible need to apply property namespacing for
        primvars. See Creating and Accessing Primvars for more information.
        Creation may fail and return an invalid Primvar if ``name`` contains a
        reserved keyword, such as the"indices"suffix we use for indexed
        primvars.

        The behavior with respect to the provided ``typeName`` is the same as
        for UsdAttributes::Create(), and ``interpolation`` and ``elementSize``
        are as described in UsdGeomPrimvar::GetInterpolation() and
        UsdGeomPrimvar::GetElementSize() .

        If ``interpolation`` and/or ``elementSize`` are left unspecified, we
        will author no opinions for them, which means any (strongest) opinion
        already authored in any contributing layer for these fields will
        become the Primvar's values, or the fallbacks if no opinions have been
        authored.

        an invalid UsdGeomPrimvar if we failed to create a valid attribute, a
        valid UsdGeomPrimvar otherwise. It is not an error to create over an
        existing, compatible attribute.

        UsdPrim::CreateAttribute() , UsdGeomPrimvar::IsPrimvar()


        Parameters
        ----------
        name : str

        typeName : ValueTypeName

        interpolation : str

        elementSize : int
        """
    @staticmethod
    def FindIncrementallyInheritablePrimvars(inheritedFromAncestors) -> list[Primvar]: 
        """
        FindIncrementallyInheritablePrimvars(inheritedFromAncestors) -> list[Primvar]


        Compute the primvars that can be inherited from this prim by its child
        prims, starting from the set of primvars inherited from this prim's
        ancestors.


        If this method returns an empty vector, then this prim's children
        should inherit the same set of primvars available to this prim, i.e.
        the input ``inheritedFromAncestors`` .

        As opposed to FindInheritablePrimvars() , which always recurses up
        through all of the prim's ancestors, this method allows more efficient
        computation of inheritable primvars by starting with the list of
        primvars inherited from this prim's ancestors, and returning a newly
        allocated vector only when this prim makes a change to the set of
        inherited primvars. This enables O(n) inherited primvar computation
        for all prims on a Stage, with potential to share computed results
        that are identical (i.e. when this method returns an empty vector, its
        parent's result can (and must!) be reused for all of the prim's
        children.

        Which Method to Use to Retrieve Primvars


        Parameters
        ----------
        inheritedFromAncestors : list[Primvar]
        """
    @staticmethod
    def FindInheritablePrimvars() -> list[Primvar]: 
        """
        FindInheritablePrimvars() -> list[Primvar]


        Compute the primvars that can be inherited from this prim by its child
        prims, including the primvars that **this** prim inherits from
        ancestor prims.


        Inherited primvars will be bound to attributes on the corresponding
        ancestor prims.

        Only primvars with **authored**, **non-blocked**, **constant
        interpolation** values are inheritable; fallback values are not
        inherited. The order of the returned primvars is undefined.

        It is not generally useful to call this method on UsdGeomGprim leaf
        prims, and furthermore likely to be expensive since *most* primvars
        are defined on Gprims.

        Which Method to Use to Retrieve Primvars
        """
    @staticmethod
    @typing.overload
    def FindPrimvarWithInheritance(name) -> Primvar: 
        """
        FindPrimvarWithInheritance(name) -> Primvar


        Like GetPrimvar() , but if the named primvar does not exist or has no
        authored value on this prim, search for the named, value-producing
        primvar on ancestor prims.


        The returned primvar will be bound to the attribute on the
        corresponding ancestor prim on which it was found (if any). If neither
        this prim nor any ancestor contains a value-producing primvar, then
        the returned primvar will be the same as that returned by GetPrimvar()
        .

        This is probably the method you want to call when needing to consume a
        primvar of a particular name.

        Which Method to Use to Retrieve Primvars


        Parameters
        ----------
        name : str



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.

        This version of FindPrimvarWithInheritance() takes the pre-computed
        set of primvars inherited from this prim's ancestors, as computed by
        FindInheritablePrimvars() or FindIncrementallyInheritablePrimvars() on
        the prim's parent.



        Which Method to Use to Retrieve Primvars


        Parameters
        ----------
        name : str

        inheritedFromAncestors : list[Primvar]
        """
    @staticmethod
    @typing.overload
    def FindPrimvarWithInheritance(name, inheritedFromAncestors) -> Primvar: ...
    @staticmethod
    @typing.overload
    def FindPrimvarsWithInheritance() -> list[Primvar]: 
        """
        FindPrimvarsWithInheritance() -> list[Primvar]


        Find all of the value-producing primvars either defined on this prim,
        or inherited from ancestor prims.



        Which Method to Use to Retrieve Primvars




        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.

        This version of FindPrimvarsWithInheritance() takes the pre-computed
        set of primvars inherited from this prim's ancestors, as computed by
        FindInheritablePrimvars() or FindIncrementallyInheritablePrimvars() on
        the prim's parent.



        Which Method to Use to Retrieve Primvars


        Parameters
        ----------
        inheritedFromAncestors : list[Primvar]
        """
    @staticmethod
    @typing.overload
    def FindPrimvarsWithInheritance(inheritedFromAncestors) -> list[Primvar]: ...
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> PrimvarsAPI


        Return a UsdGeomPrimvarsAPI holding the prim adhering to this schema
        at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomPrimvarsAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAuthoredPrimvars() -> list[Primvar]: 
        """
        GetAuthoredPrimvars() -> list[Primvar]


        Like GetPrimvars() , but include only primvars that have some authored
        scene description (though not necessarily a value).



        Which Method to Use to Retrieve Primvars
        """
    @staticmethod
    def GetPrimvar(name) -> Primvar: 
        """
        GetPrimvar(name) -> Primvar


        Return the Primvar object named by ``name`` , which will be valid if a
        Primvar attribute definition already exists.


        Name lookup will account for Primvar namespacing, which means that
        this method will succeed in some cases where

        .. code-block:: text

          UsdGeomPrimvar(prim->GetAttribute(name))

         will not, unless ``name`` is properly namespace prefixed.

        Just because a Primvar is valid and defined, and *even if* its
        underlying UsdAttribute (GetAttr()) answers HasValue() affirmatively,
        one must still check the return value of Get() , due to the potential
        of time-varying value blocks (see Attribute Value Blocking).


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def GetPrimvars() -> list[Primvar]: 
        """
        GetPrimvars() -> list[Primvar]


        Return valid UsdGeomPrimvar objects for all defined Primvars on this
        prim, similarly to UsdPrim::GetAttributes() .


        The returned primvars may not possess any values, and therefore not be
        useful to some clients. For the primvars useful for inheritance
        computations, see GetPrimvarsWithAuthoredValues() , and for primvars
        useful for direct consumption, see GetPrimvarsWithValues() .

        Which Method to Use to Retrieve Primvars
        """
    @staticmethod
    def GetPrimvarsWithAuthoredValues() -> list[Primvar]: 
        """
        GetPrimvarsWithAuthoredValues() -> list[Primvar]


        Like GetPrimvars() , but include only primvars that have an
        **authored** value.


        This is the query used when computing inheritable primvars, and is
        generally more useful than GetAuthoredPrimvars() .

        Which Method to Use to Retrieve Primvars
        """
    @staticmethod
    def GetPrimvarsWithValues() -> list[Primvar]: 
        """
        GetPrimvarsWithValues() -> list[Primvar]


        Like GetPrimvars() , but include only primvars that have some value,
        whether it comes from authored scene description or a schema fallback.


        For most purposes, this method is more useful than GetPrimvars() .

        Which Method to Use to Retrieve Primvars
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def HasPossiblyInheritedPrimvar(name) -> bool: 
        """
        HasPossiblyInheritedPrimvar(name) -> bool


        Is there a Primvar named ``name`` with an authored value on this prim
        or any of its ancestors?


        This is probably the method you want to call when wanting to know
        whether or not the prim"has"a primvar of a particular name.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def HasPrimvar(name) -> bool: 
        """
        HasPrimvar(name) -> bool


        Is there a defined Primvar ``name`` on this prim?


        Name lookup will account for Primvar namespacing.

        Like GetPrimvar() , a return value of ``true`` for HasPrimvar() does
        not guarantee the primvar will produce a value.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def RemovePrimvar(name) -> bool: 
        """
        RemovePrimvar(name) -> bool


        Author scene description to delete an attribute on this prim that was
        recognized as Primvar (i.e.


        will present as a valid UsdGeomPrimvar), *in the current
        UsdEditTarget*.

        Because this method can only remove opinions about the primvar from
        the current EditTarget, you may generally find it more useful to use
        BlockPrimvar() which will ensure that all values from the EditTarget
        and weaker layers for the primvar and its indices will be ignored.

        Removal may fail and return false if ``name`` contains a reserved
        keyword, such as the"indices"suffix we use for indexed primvars.

        Note this will also remove the indices attribute associated with an
        indiced primvar.

        true if UsdGeomPrimvar and indices attribute was successfully removed,
        false otherwise.

        UsdPrim::RemoveProperty() )


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class Scope(Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Scope is the simplest grouping primitive, and does not carry the
    baggage of transformability. Note that transforms should inherit down
    through a Scope successfully - it is just a guaranteed no-op from a
    transformability perspective.
    """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Scope


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Scope


        Return a UsdGeomScope holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomScope(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Sphere(Gprim, Boundable, Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Defines a primitive sphere centered at the origin.

    The fallback values for Cube, Sphere, Cone, and Cylinder are set so
    that they all pack into the same volume/bounds.
    """
    @staticmethod
    def CreateExtentAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExtentAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateRadiusAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateRadiusAttr(defaultValue, writeSparsely) -> Attribute


        See GetRadiusAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Sphere


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Sphere


        Return a UsdGeomSphere holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomSphere(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetExtentAttr() -> Attribute: 
        """
        GetExtentAttr() -> Attribute


        Extent is re-defined on Sphere only to provide a fallback value.



        UsdGeomGprim::GetExtentAttr() .

        Declaration

        ``float3[] extent = [(-1, -1, -1), (1, 1, 1)]``

        C++ Type

        VtArray<GfVec3f>

        Usd Type

        SdfValueTypeNames->Float3Array
        """
    @staticmethod
    def GetRadiusAttr() -> Attribute: 
        """
        GetRadiusAttr() -> Attribute


        Indicates the sphere's radius.


        If you author *radius* you must also author *extent*.

        Declaration

        ``double radius = 1``

        C++ Type

        double

        Usd Type

        SdfValueTypeNames->Double
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Subset(pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Encodes a subset of a piece of geometry (i.e. a UsdGeomImageable) as a
    set of indices. Currently only supports encoding of face-subsets, but
    could be extended in the future to support subsets representing edges,
    segments, points etc.

    To apply to a geometric prim, a GeomSubset prim must be the prim's
    direct child in namespace, and possess a concrete defining specifier
    (i.e. def). This restriction makes it easy and efficient to discover
    subsets of a prim. We might want to relax this restriction if it's
    common to have multiple **families** of subsets on a gprim and if it's
    useful to be able to organize subsets belonging to a family under a
    common scope. See'familyName'attribute for more info on defining a
    family of subsets.

    Note that a GeomSubset isn't an imageable (i.e. doesn't derive from
    UsdGeomImageable). So, you can't author **visibility** for it or
    override its **purpose**.

    Materials are bound to GeomSubsets just as they are for regular
    geometry using API available in UsdShade (UsdShadeMaterial::Bind).

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateElementTypeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateElementTypeAttr(defaultValue, writeSparsely) -> Attribute


        See GetElementTypeAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateFamilyNameAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateFamilyNameAttr(defaultValue, writeSparsely) -> Attribute


        See GetFamilyNameAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateGeomSubset(*args, **kwargs) -> None: 
        """
        **classmethod** CreateGeomSubset(geom, subsetName, elementType, indices, familyName, familyType) -> Subset


        Creates a new GeomSubset below the given ``geom`` with the given name,
        ``subsetName`` , element type, ``elementType`` and ``indices`` .


        If a subset named ``subsetName`` already exists below ``geom`` , then
        this updates its attributes with the values of the provided arguments
        (indices value at time'default'will be updated) and returns it.

        The family type is set / updated on ``geom`` only if a non-empty value
        is passed in for ``familyType`` and ``familyName`` .


        Parameters
        ----------
        geom : Imageable

        subsetName : str

        elementType : str

        indices : IntArray

        familyName : str

        familyType : str
        """
    @staticmethod
    def CreateIndicesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateIndicesAttr(defaultValue, writeSparsely) -> Attribute


        See GetIndicesAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateUniqueGeomSubset(*args, **kwargs) -> None: 
        """
        **classmethod** CreateUniqueGeomSubset(geom, subsetName, elementType, indices, familyName, familyType) -> Subset


        Creates a new GeomSubset below the given imageable, ``geom`` with the
        given name, ``subsetName`` , element type, ``elementType`` and
        ``indices`` .


        If a subset named ``subsetName`` already exists below ``geom`` , then
        this creates a new subset by appending a suitable index as suffix to
        ``subsetName`` (eg, subsetName_1) to avoid name collisions.

        The family type is set / updated on ``geom`` only if a non-empty value
        is passed in for ``familyType`` and ``familyName`` .


        Parameters
        ----------
        geom : Imageable

        subsetName : str

        elementType : str

        indices : IntArray

        familyName : str

        familyType : str
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Subset


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Subset


        Return a UsdGeomSubset holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomSubset(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAllGeomSubsetFamilyNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetAllGeomSubsetFamilyNames(geom) -> str.Set


        Returns the names of all the families of GeomSubsets defined on the
        given imageable, ``geom`` .


        Parameters
        ----------
        geom : Imageable
        """
    @staticmethod
    def GetAllGeomSubsets(*args, **kwargs) -> None: 
        """
        **classmethod** GetAllGeomSubsets(geom) -> list[Subset]


        Returns all the GeomSubsets defined on the given imageable, ``geom`` .


        Parameters
        ----------
        geom : Imageable
        """
    @staticmethod
    def GetElementTypeAttr() -> Attribute: 
        """
        GetElementTypeAttr() -> Attribute


        The type of element that the indices target.


        Currently only allows"face"and defaults to it.

        Declaration

        ``uniform token elementType ="face"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        face
        """
    @staticmethod
    def GetFamilyNameAttr() -> Attribute: 
        """
        GetFamilyNameAttr() -> Attribute


        The name of the family of subsets that this subset belongs to.


        This is optional and is primarily useful when there are multiple
        families of subsets under a geometric prim. In some cases, this could
        also be used for achieving proper roundtripping of subset data between
        DCC apps. When multiple subsets belonging to a prim have the same
        familyName, they are said to belong to the family. A *familyType*
        value can be encoded on the owner of a family of subsets as a token
        using the static method UsdGeomSubset::SetFamilyType()
        ."familyType"can have one of the following values:

           - **UsdGeomTokens->partition** : implies that every element of the
             whole geometry appears exactly once in only one of the subsets
             belonging to the family.

           - **UsdGeomTokens->nonOverlapping** : an element that appears in
             one subset may not appear in any other subset belonging to the family.

           - **UsdGeomTokens->unrestricted** : implies that there are no
             restrictions w.r.t. the membership of elements in the subsets. They
             could be overlapping and the union of all subsets in the family may
             not represent the whole.

        The validity of subset data is not enforced by the authoring APIs,
        however they can be checked using UsdGeomSubset::ValidateFamily() .

        Declaration

        ``uniform token familyName =""``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform
        """
    @staticmethod
    def GetFamilyType(*args, **kwargs) -> None: 
        """
        **classmethod** GetFamilyType(geom, familyName) -> str


        Returns the type of family that the GeomSubsets on the given geometric
        prim ``geom`` , with the given family name, ``familyName`` belong to.


        This only returns the token that's encoded on ``geom`` and does not
        perform any actual validation on the family of GeomSubsets. Please use
        ValidateFamily() for such validation.

        When familyType is not set on ``geom`` , the fallback value
        UsdTokens->unrestricted is returned.


        Parameters
        ----------
        geom : Imageable

        familyName : str
        """
    @staticmethod
    def GetGeomSubsets(*args, **kwargs) -> None: 
        """
        **classmethod** GetGeomSubsets(geom, elementType, familyName) -> list[Subset]


        Returns all the GeomSubsets of the given ``elementType`` belonging to
        the specified family, ``familyName`` on the given imageable, ``geom``
        .


        If ``elementType`` is empty, then subsets containing all element types
        are returned. If ``familyName`` is left empty, then all subsets of the
        specified ``elementType`` will be returned.


        Parameters
        ----------
        geom : Imageable

        elementType : str

        familyName : str
        """
    @staticmethod
    def GetIndicesAttr() -> Attribute: 
        """
        GetIndicesAttr() -> Attribute


        The set of indices included in this subset.


        The indices need not be sorted, but the same index should not appear
        more than once.

        Declaration

        ``int[] indices = []``

        C++ Type

        VtArray<int>

        Usd Type

        SdfValueTypeNames->IntArray
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetUnassignedIndices(*args, **kwargs) -> None: 
        """
        **classmethod** GetUnassignedIndices(subsets, elementCount, time) -> IntArray


        Utility for getting the list of indices that are not assigned to any
        of the GeomSubsets in ``subsets`` at the timeCode, ``time`` , given
        the element count (total number of indices in the array being
        subdivided), ``elementCount`` .


        Parameters
        ----------
        subsets : list[Subset]

        elementCount : int

        time : TimeCode
        """
    @staticmethod
    def SetFamilyType(*args, **kwargs) -> None: 
        """
        **classmethod** SetFamilyType(geom, familyName, familyType) -> bool


        This method is used to encode the type of family that the GeomSubsets
        on the given geometric prim ``geom`` , with the given family name,
        ``familyName`` belong to.


        See UsdGeomSubset::GetFamilyNameAttr for the possible values for
        ``familyType`` .

        When a family of GeomSubsets is tagged as a UsdGeomTokens->partition
        or UsdGeomTokens->nonOverlapping, the validity of the data (i.e.
        mutual exclusivity and/or wholeness) is not enforced by the authoring
        APIs. Use ValidateFamily() to validate the data in a family of
        GeomSubsets.

        Returns false upon failure to create or set the appropriate attribute
        on ``geom`` .


        Parameters
        ----------
        geom : Imageable

        familyName : str

        familyType : str
        """
    @staticmethod
    def ValidateFamily(*args, **kwargs) -> None: 
        """
        **classmethod** ValidateFamily(geom, elementType, familyName, reason) -> bool


        Validates whether the family of subsets identified by the given
        ``familyName`` and ``elementType`` on the given imageable, ``geom``
        contain valid data.


        If the family is designated as a partition or as non-overlapping using
        SetFamilyType() , then the validity of the data is checked. If the
        familyType is"unrestricted", then this performs only bounds checking
        of the values in the"indices"arrays.

        If ``reason`` is not None, then it is populated with a string
        explaining why the family is invalid, if it is invalid.

        The python version of this method returns a tuple containing a (bool,
        string), where the bool has the validity of the family and the string
        contains the reason (if it's invalid).


        Parameters
        ----------
        geom : Imageable

        elementType : str

        familyName : str

        reason : str
        """
    @staticmethod
    def ValidateSubsets(*args, **kwargs) -> None: 
        """
        **classmethod** ValidateSubsets(subsets, elementCount, familyType, reason) -> bool


        Validates the data in the given set of GeomSubsets, ``subsets`` ,
        given the total number of elements in the array being subdivided,
        ``elementCount`` and the ``familyType`` that the subsets belong to.



        For proper validation of indices in ``subsets`` , all of the
        GeomSubsets must have the same'elementType'.

        If one or more subsets contain invalid data, then false is returned
        and ``reason`` is populated with a string explaining the reason why it
        is invalid.

        The python version of this method returns a tuple containing a (bool,
        string), where the bool has the validity of the subsets and the string
        contains the reason (if they're invalid).


        Parameters
        ----------
        subsets : list[Subset]

        elementCount : int

        familyType : str

        reason : str
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Tokens(Boost.Python.instance):
    accelerations = 'accelerations'
    all = 'all'
    angularVelocities = 'angularVelocities'
    axis = 'axis'
    basis = 'basis'
    bezier = 'bezier'
    bilinear = 'bilinear'
    boundaries = 'boundaries'
    bounds = 'bounds'
    box = 'box'
    bspline = 'bspline'
    cards = 'cards'
    catmullClark = 'catmullClark'
    catmullRom = 'catmullRom'
    clippingPlanes = 'clippingPlanes'
    clippingRange = 'clippingRange'
    closed = 'closed'
    constant = 'constant'
    cornerIndices = 'cornerIndices'
    cornerSharpnesses = 'cornerSharpnesses'
    cornersOnly = 'cornersOnly'
    cornersPlus1 = 'cornersPlus1'
    cornersPlus2 = 'cornersPlus2'
    creaseIndices = 'creaseIndices'
    creaseLengths = 'creaseLengths'
    creaseSharpnesses = 'creaseSharpnesses'
    cross = 'cross'
    cubic = 'cubic'
    curveVertexCounts = 'curveVertexCounts'
    default_ = 'default'
    doubleSided = 'doubleSided'
    edgeAndCorner = 'edgeAndCorner'
    edgeOnly = 'edgeOnly'
    elementSize = 'elementSize'
    elementType = 'elementType'
    exposure = 'exposure'
    extent = 'extent'
    extentsHint = 'extentsHint'
    fStop = 'fStop'
    face = 'face'
    faceVarying = 'faceVarying'
    faceVaryingLinearInterpolation = 'faceVaryingLinearInterpolation'
    faceVertexCounts = 'faceVertexCounts'
    faceVertexIndices = 'faceVertexIndices'
    familyName = 'familyName'
    focalLength = 'focalLength'
    focusDistance = 'focusDistance'
    form = 'form'
    fromTexture = 'fromTexture'
    guide = 'guide'
    guideVisibility = 'guideVisibility'
    height = 'height'
    hermite = 'hermite'
    holeIndices = 'holeIndices'
    horizontalAperture = 'horizontalAperture'
    horizontalApertureOffset = 'horizontalApertureOffset'
    ids = 'ids'
    inactiveIds = 'inactiveIds'
    indices = 'indices'
    inherited = 'inherited'
    interpolateBoundary = 'interpolateBoundary'
    interpolation = 'interpolation'
    invisible = 'invisible'
    invisibleIds = 'invisibleIds'
    knots = 'knots'
    left = 'left'
    leftHanded = 'leftHanded'
    length = 'length'
    linear = 'linear'
    loop = 'loop'
    metersPerUnit = 'metersPerUnit'
    modelApplyDrawMode = 'model:applyDrawMode'
    modelCardGeometry = 'model:cardGeometry'
    modelCardTextureXNeg = 'model:cardTextureXNeg'
    modelCardTextureXPos = 'model:cardTextureXPos'
    modelCardTextureYNeg = 'model:cardTextureYNeg'
    modelCardTextureYPos = 'model:cardTextureYPos'
    modelCardTextureZNeg = 'model:cardTextureZNeg'
    modelCardTextureZPos = 'model:cardTextureZPos'
    modelDrawMode = 'model:drawMode'
    modelDrawModeColor = 'model:drawModeColor'
    mono = 'mono'
    motionBlurScale = 'motion:blurScale'
    motionNonlinearSampleCount = 'motion:nonlinearSampleCount'
    motionVelocityScale = 'motion:velocityScale'
    nonOverlapping = 'nonOverlapping'
    none = 'none'
    nonperiodic = 'nonperiodic'
    normals = 'normals'
    open = 'open'
    order = 'order'
    orientation = 'orientation'
    orientations = 'orientations'
    origin = 'origin'
    orthographic = 'orthographic'
    partition = 'partition'
    periodic = 'periodic'
    perspective = 'perspective'
    pinned = 'pinned'
    pivot = 'pivot'
    pointWeights = 'pointWeights'
    points = 'points'
    positions = 'positions'
    power = 'power'
    primvarsDisplayColor = 'primvars:displayColor'
    primvarsDisplayOpacity = 'primvars:displayOpacity'
    projection = 'projection'
    protoIndices = 'protoIndices'
    prototypes = 'prototypes'
    proxy = 'proxy'
    proxyPrim = 'proxyPrim'
    proxyVisibility = 'proxyVisibility'
    purpose = 'purpose'
    radius = 'radius'
    ranges = 'ranges'
    render = 'render'
    renderVisibility = 'renderVisibility'
    right = 'right'
    rightHanded = 'rightHanded'
    scales = 'scales'
    shutterClose = 'shutter:close'
    shutterOpen = 'shutter:open'
    size = 'size'
    smooth = 'smooth'
    stereoRole = 'stereoRole'
    subdivisionScheme = 'subdivisionScheme'
    tangents = 'tangents'
    triangleSubdivisionRule = 'triangleSubdivisionRule'
    trimCurveCounts = 'trimCurve:counts'
    trimCurveKnots = 'trimCurve:knots'
    trimCurveOrders = 'trimCurve:orders'
    trimCurvePoints = 'trimCurve:points'
    trimCurveRanges = 'trimCurve:ranges'
    trimCurveVertexCounts = 'trimCurve:vertexCounts'
    type = 'type'
    uForm = 'uForm'
    uKnots = 'uKnots'
    uOrder = 'uOrder'
    uRange = 'uRange'
    uVertexCount = 'uVertexCount'
    unauthoredValuesIndex = 'unauthoredValuesIndex'
    uniform = 'uniform'
    unrestricted = 'unrestricted'
    upAxis = 'upAxis'
    vForm = 'vForm'
    vKnots = 'vKnots'
    vOrder = 'vOrder'
    vRange = 'vRange'
    vVertexCount = 'vVertexCount'
    varying = 'varying'
    velocities = 'velocities'
    vertex = 'vertex'
    verticalAperture = 'verticalAperture'
    verticalApertureOffset = 'verticalApertureOffset'
    visibility = 'visibility'
    visible = 'visible'
    width = 'width'
    widths = 'widths'
    wrap = 'wrap'
    x = 'X'
    xformOpOrder = 'xformOpOrder'
    y = 'Y'
    z = 'Z'
    pass
class VisibilityAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    UsdGeomVisibilityAPI introduces properties that can be used to author
    visibility opinions.

    Currently, this schema only introduces the attributes that are used to
    control purpose visibility. Later, this schema will define *all*
    visibility-related properties and UsdGeomImageable will no longer
    define those properties. The purpose visibility attributes added by
    this schema, *guideVisibility*, *proxyVisibility*, and
    *renderVisibility* can each be used to control visibility for geometry
    of the corresponding purpose values, with the overall *visibility*
    attribute acting as an override. I.e., if *visibility* evaluates
    to"invisible", purpose visibility is invisible; otherwise, purpose
    visibility is determined by the corresponding purpose visibility
    attribute.

    Note that the behavior of *guideVisibility* is subtly different from
    the *proxyVisibility* and *renderVisibility* attributes, in
    that"guide"purpose visibility always evaluates to
    either"invisible"or"visible", whereas the other attributes may yield
    computed values of"inherited"if there is no authored opinion on the
    attribute or inherited from an ancestor. This is motivated by the fact
    that, in Pixar"s user workflows, we have never found a need to have
    all guides visible in a scene by default, whereas we do find that
    flexibility useful for"proxy"and"render"geometry.

    This schema can only be applied to UsdGeomImageable prims. The
    UseGeomImageable schema provides API for computing the purpose
    visibility values that result from the attributes introduced by this
    schema.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdGeomTokens. So to set an attribute to the value"rightHanded",
    use UsdGeomTokens->rightHanded as the value.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> VisibilityAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"VisibilityAPI"to the token-
        valued, listOp metadata *apiSchemas* on the prim.

        A valid UsdGeomVisibilityAPI object is returned upon success. An
        invalid (or empty) UsdGeomVisibilityAPI object is returned upon
        failure. See UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def CreateGuideVisibilityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateGuideVisibilityAttr(defaultValue, writeSparsely) -> Attribute


        See GetGuideVisibilityAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateProxyVisibilityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateProxyVisibilityAttr(defaultValue, writeSparsely) -> Attribute


        See GetProxyVisibilityAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateRenderVisibilityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateRenderVisibilityAttr(defaultValue, writeSparsely) -> Attribute


        See GetRenderVisibilityAttr() , 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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> VisibilityAPI


        Return a UsdGeomVisibilityAPI holding the prim adhering to this schema
        at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomVisibilityAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetGuideVisibilityAttr() -> Attribute: 
        """
        GetGuideVisibilityAttr() -> Attribute


        This attribute controls visibility for geometry with purpose"guide".


        Unlike overall *visibility*, *guideVisibility* is uniform, and
        therefore cannot be animated.

        Also unlike overall *visibility*, *guideVisibility* is tri-state, in
        that a descendant with an opinion of"visible"overrides an ancestor
        opinion of"invisible".

        The *guideVisibility* attribute works in concert with the overall
        *visibility* attribute: The visibility of a prim with purpose"guide"is
        determined by the inherited values it receives for the *visibility*
        and *guideVisibility* attributes. If *visibility* evaluates
        to"invisible", the prim is invisible. If *visibility* evaluates
        to"inherited"and *guideVisibility* evaluates to"visible", then the
        prim is visible. **Otherwise, it is invisible.**

        Declaration

        ``uniform token guideVisibility ="invisible"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        inherited, invisible, visible
        """
    @staticmethod
    def GetProxyVisibilityAttr() -> Attribute: 
        """
        GetProxyVisibilityAttr() -> Attribute


        This attribute controls visibility for geometry with purpose"proxy".


        Unlike overall *visibility*, *proxyVisibility* is uniform, and
        therefore cannot be animated.

        Also unlike overall *visibility*, *proxyVisibility* is tri-state, in
        that a descendant with an opinion of"visible"overrides an ancestor
        opinion of"invisible".

        The *proxyVisibility* attribute works in concert with the overall
        *visibility* attribute: The visibility of a prim with purpose"proxy"is
        determined by the inherited values it receives for the *visibility*
        and *proxyVisibility* attributes. If *visibility* evaluates
        to"invisible", the prim is invisible. If *visibility* evaluates
        to"inherited"then: If *proxyVisibility* evaluates to"visible", then
        the prim is visible; if *proxyVisibility* evaluates to"invisible",
        then the prim is invisible; if *proxyVisibility* evaluates
        to"inherited", then the prim may either be visible or invisible,
        depending on a fallback value determined by the calling context.

        Declaration

        ``uniform token proxyVisibility ="inherited"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        inherited, invisible, visible
        """
    @staticmethod
    def GetPurposeVisibilityAttr(purpose) -> Attribute: 
        """
        GetPurposeVisibilityAttr(purpose) -> Attribute


        Return the attribute that is used for expressing visibility opinions
        for the given ``purpose`` .


        The valid purpose tokens are"guide","proxy", and"render"which return
        the attributes *guideVisibility*, *proxyVisibility*, and
        *renderVisibility* respectively.

        Note that while"default"is a valid purpose token for
        UsdGeomImageable::GetPurposeVisibilityAttr, it is not a valid purpose
        for this function, as UsdGeomVisibilityAPI itself does not have a
        default visibility attribute. Calling this function with "default will
        result in a coding error.


        Parameters
        ----------
        purpose : str
        """
    @staticmethod
    def GetRenderVisibilityAttr() -> Attribute: 
        """
        GetRenderVisibilityAttr() -> Attribute


        This attribute controls visibility for geometry with purpose"render".


        Unlike overall *visibility*, *renderVisibility* is uniform, and
        therefore cannot be animated.

        Also unlike overall *visibility*, *renderVisibility* is tri-state, in
        that a descendant with an opinion of"visible"overrides an ancestor
        opinion of"invisible".

        The *renderVisibility* attribute works in concert with the overall
        *visibility* attribute: The visibility of a prim with
        purpose"render"is determined by the inherited values it receives for
        the *visibility* and *renderVisibility* attributes. If *visibility*
        evaluates to"invisible", the prim is invisible. If *visibility*
        evaluates to"inherited"then: If *renderVisibility* evaluates
        to"visible", then the prim is visible; if *renderVisibility* evaluates
        to"invisible", then the prim is invisible; if *renderVisibility*
        evaluates to"inherited", then the prim may either be visible or
        invisible, depending on a fallback value determined by the calling
        context.

        Declaration

        ``uniform token renderVisibility ="inherited"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        inherited, invisible, visible
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class Xform(Xformable, Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Concrete prim schema for a transform, which implements Xformable
    """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Xform


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Xform


        Return a UsdGeomXform holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomXform(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class XformCache(Boost.Python.instance):
    """
    A caching mechanism for transform matrices. For best performance, this
    object should be reused for multiple CTM queries.

    Instances of this type can be copied, though using Swap() may result
    in better performance.

    It is valid to cache prims from multiple stages in a single
    XformCache.

    WARNING: this class does not automatically invalidate cached values
    based on changes to the stage from which values were cached.
    Additionally, a separate instance of this class should be used per-
    thread, calling the Get\* methods from multiple threads is not safe,
    as they mutate internal state.
    """
    @staticmethod
    def Clear() -> None: 
        """
        Clear() -> None


        Clears all pre-cached values.
        """
    @staticmethod
    def ComputeRelativeTransform(prim, ancestor, resetXformStack) -> Matrix4d: 
        """
        ComputeRelativeTransform(prim, ancestor, resetXformStack) -> Matrix4d


        Returns the result of concatenating all transforms beneath
        ``ancestor`` that affect ``prim`` .


        This includes the local transform of ``prim`` itself, but not the
        local transform of ``ancestor`` . If ``ancestor`` is not an ancestor
        of ``prim`` , the resulting transform is the local-to-world
        transformation of ``prim`` .  The ``resetXformTsack`` pointer must be
        valid. If any intermediate prims reset the transform stack,
        ``resetXformStack`` will be set to true. Intermediate transforms are
        cached, but the result of this call itself is not cached.


        Parameters
        ----------
        prim : Prim

        ancestor : Prim

        resetXformStack : bool
        """
    @staticmethod
    def GetLocalToWorldTransform(prim) -> Matrix4d: 
        """
        GetLocalToWorldTransform(prim) -> Matrix4d


        Compute the transformation matrix for the given ``prim`` , including
        the transform authored on the Prim itself, if present.



        This method may mutate internal cache state and is not thread safe.


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def GetLocalTransformation(prim, resetsXformStack) -> Matrix4d: 
        """
        GetLocalTransformation(prim, resetsXformStack) -> Matrix4d


        Returns the local transformation of the prim.


        Uses the cached XformQuery to compute the result quickly. The
        ``resetsXformStack`` pointer must be valid. It will be set to true if
        ``prim`` resets the transform stack. The result of this call is
        cached.


        Parameters
        ----------
        prim : Prim

        resetsXformStack : bool
        """
    @staticmethod
    def GetParentToWorldTransform(prim) -> Matrix4d: 
        """
        GetParentToWorldTransform(prim) -> Matrix4d


        Compute the transformation matrix for the given ``prim`` , but do NOT
        include the transform authored on the prim itself.



        This method may mutate internal cache state and is not thread safe.


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def GetTime() -> TimeCode: 
        """
        GetTime() -> TimeCode


        Get the current time from which this cache is reading values.
        """
    @staticmethod
    def SetTime(time) -> None: 
        """
        SetTime(time) -> None


        Use the new ``time`` when computing values and may clear any existing
        values cached for the previous time.


        Setting ``time`` to the current time is a no-op.


        Parameters
        ----------
        time : TimeCode
        """
    @staticmethod
    def Swap(other) -> None: 
        """
        Swap(other) -> None


        Swap the contents of this XformCache with ``other`` .


        Parameters
        ----------
        other : XformCache
        """
    __instance_size__ = 88
    pass
class XformCommonAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    This class provides API for authoring and retrieving a standard set of
    component transformations which include a scale, a rotation, a scale-
    rotate pivot and a translation. The goal of the API is to enhance
    component-wise interchange. It achieves this by limiting the set of
    allowed basic ops and by specifying the order in which they are
    applied. In addition to the basic set of ops, the'resetXformStack'bit
    can also be set to indicate whether the underlying xformable resets
    the parent transformation (i.e. does not inherit it's parent's
    transformation).

    UsdGeomXformCommonAPI::GetResetXformStack()

    UsdGeomXformCommonAPI::SetResetXformStack() The operator-bool for the
    class will inform you whether an existing xformable is compatible with
    this API.

    The scale-rotate pivot is represented by a pair of (translate,
    inverse-translate) xformOps around the scale and rotate operations.
    The rotation operation can be any of the six allowed Euler angle sets.

    UsdGeomXformOp::Type. The xformOpOrder of an xformable that has all of
    the supported basic ops is as follows:
    ["xformOp:translate","xformOp:translate:pivot","xformOp:rotateXYZ","xformOp:scale","!invert!xformOp:translate:pivot"].

    It is worth noting that all of the ops are optional. For example, an
    xformable may have only a translate or a rotate. It would still be
    considered as compatible with this API. Individual SetTranslate() ,
    SetRotate() , SetScale() and SetPivot() methods are provided by this
    API to allow such sparse authoring.
    """
    class OpFlags(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Enumerates the categories of ops that can be handled by
        XformCommonAPI.


        For use with CreateXformOps() .
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'XformCommonAPI'
        allValues: tuple # value = (UsdGeom.XformCommonAPI.OpTranslate, UsdGeom.XformCommonAPI.OpRotate, UsdGeom.XformCommonAPI.OpScale, UsdGeom.XformCommonAPI.OpPivot)
        pass
    class RotationOrder(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Enumerates the rotation order of the 3-angle Euler rotation.
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'XformCommonAPI'
        allValues: tuple # value = (UsdGeom.XformCommonAPI.RotationOrderXYZ, UsdGeom.XformCommonAPI.RotationOrderXZY, UsdGeom.XformCommonAPI.RotationOrderYXZ, UsdGeom.XformCommonAPI.RotationOrderYZX, UsdGeom.XformCommonAPI.RotationOrderZXY, UsdGeom.XformCommonAPI.RotationOrderZYX)
        pass
    @staticmethod
    def CanConvertOpTypeToRotationOrder(*args, **kwargs) -> None: 
        """
        **classmethod** CanConvertOpTypeToRotationOrder(opType) -> bool


        Whether the given ``opType`` has a corresponding value in the
        UsdGeomXformCommonAPI::RotationOrder enum (i.e., whether it is a
        three-axis rotation).


        Parameters
        ----------
        opType : XformOp.Type
        """
    @staticmethod
    def ConvertOpTypeToRotationOrder(*args, **kwargs) -> None: 
        """
        **classmethod** ConvertOpTypeToRotationOrder(opType) -> RotationOrder


        Converts the given ``opType`` to the corresponding value in the
        UsdGeomXformCommonAPI::RotationOrder enum.


        For example, TypeRotateYZX corresponds to RotationOrderYZX. Raises a
        coding error if ``opType`` is not convertible to RotationOrder (i.e.,
        if it isn't a three-axis rotation) and returns the default
        RotationOrderXYZ instead.


        Parameters
        ----------
        opType : XformOp.Type
        """
    @staticmethod
    def ConvertRotationOrderToOpType(*args, **kwargs) -> None: 
        """
        **classmethod** ConvertRotationOrderToOpType(rotOrder) -> XformOp.Type


        Converts the given ``rotOrder`` to the corresponding value in the
        UsdGeomXformOp::Type enum.


        For example, RotationOrderYZX corresponds to TypeRotateYZX. Raises a
        coding error if ``rotOrder`` is not one of the named enumerators of
        RotationOrder.


        Parameters
        ----------
        rotOrder : RotationOrder
        """
    @staticmethod
    @typing.overload
    def CreateXformOps(rotOrder, op1, op2, op3, op4) -> Ops: 
        """
        CreateXformOps(rotOrder, op1, op2, op3, op4) -> Ops


        Creates the specified XformCommonAPI-compatible xform ops, or returns
        the existing ops if they already exist.


        If successful, returns an Ops object with all the ops on this prim,
        identified by type. If the requested xform ops couldn't be created or
        the prim is not XformCommonAPI-compatible, returns an Ops object with
        all invalid ops.

        The ``rotOrder`` is only used if OpRotate is specified. Otherwise, it
        is ignored. (If you don't need to create a rotate op, you might find
        it helpful to use the other overload that takes no rotation order.)


        Parameters
        ----------
        rotOrder : RotationOrder

        op1 : OpFlags

        op2 : OpFlags

        op3 : OpFlags

        op4 : OpFlags



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        This overload does not take a rotation order.


        If you specify OpRotate, then this overload assumes RotationOrderXYZ
        or the previously-authored rotation order. (If you do need to create a
        rotate op, you might find it helpful to use the other overload that
        explicitly takes a rotation order.)


        Parameters
        ----------
        op1 : OpFlags

        op2 : OpFlags

        op3 : OpFlags

        op4 : OpFlags
        """
    @staticmethod
    @typing.overload
    def CreateXformOps(op1, op2, op3, op4) -> Ops: ...
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> XformCommonAPI


        Return a UsdGeomXformCommonAPI holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomXformCommonAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetResetXformStack() -> bool: 
        """
        GetResetXformStack() -> bool


        Returns whether the xformable resets the transform stack.


        i.e., does not inherit the parent transformation.
        """
    @staticmethod
    def GetRotationTransform(*args, **kwargs) -> None: 
        """
        **classmethod** GetRotationTransform(rotation, rotationOrder) -> Matrix4d


        Return the 4x4 matrix that applies the rotation encoded by rotation
        vector ``rotation`` using the rotation order ``rotationOrder`` .


        Deprecated

        Please use the result of ConvertRotationOrderToOpType() along with
        UsdGeomXformOp::GetOpTransform() instead.


        Parameters
        ----------
        rotation : Vec3f

        rotationOrder : XformCommonAPI.RotationOrder
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetXformVectors(translation, rotation, scale, pivot, rotOrder, time) -> bool: 
        """
        GetXformVectors(translation, rotation, scale, pivot, rotOrder, time) -> bool


        Retrieve values of the various component xformOps at a given ``time``
        .


        Identity values are filled in for the component xformOps that don't
        exist or don't have an authored value.

        This method works even on prims with an incompatible xform schema,
        i.e. when the bool operator returns false. When the underlying
        xformable has an incompatible xform schema, it performs a full-on
        matrix decomposition to XYZ rotation order.


        Parameters
        ----------
        translation : Vec3d

        rotation : Vec3f

        scale : Vec3f

        pivot : Vec3f

        rotOrder : RotationOrder

        time : TimeCode
        """
    @staticmethod
    def GetXformVectorsByAccumulation(translation, rotation, scale, pivot, rotOrder, time) -> bool: 
        """
        GetXformVectorsByAccumulation(translation, rotation, scale, pivot, rotOrder, time) -> bool


        Retrieve values of the various component xformOps at a given ``time``
        .


        Identity values are filled in for the component xformOps that don't
        exist or don't have an authored value.

        This method allows some additional flexibility for xform schemas that
        do not strictly adhere to the xformCommonAPI. For incompatible
        schemas, this method will attempt to reduce the schema into one from
        which component vectors can be extracted by accumulating xformOp
        transforms of the common types.

        When the underlying xformable has a compatible xform schema, the usual
        component value extraction method is used instead. When the xform
        schema is incompatible and it cannot be reduced by accumulating
        transforms, it performs a full-on matrix decomposition to XYZ rotation
        order.


        Parameters
        ----------
        translation : Vec3d

        rotation : Vec3f

        scale : Vec3f

        pivot : Vec3f

        rotOrder : XformCommonAPI.RotationOrder

        time : TimeCode
        """
    @staticmethod
    def SetPivot(pivot, time) -> bool: 
        """
        SetPivot(pivot, time) -> bool


        Set pivot position at ``time`` to ``pivot`` .


        Parameters
        ----------
        pivot : Vec3f

        time : TimeCode
        """
    @staticmethod
    def SetResetXformStack(resetXformStack) -> bool: 
        """
        SetResetXformStack(resetXformStack) -> bool


        Set whether the xformable resets the transform stack.


        i.e., does not inherit the parent transformation.


        Parameters
        ----------
        resetXformStack : bool
        """
    @staticmethod
    def SetRotate(rotation, rotOrder, time) -> bool: 
        """
        SetRotate(rotation, rotOrder, time) -> bool


        Set rotation at ``time`` to ``rotation`` .


        Parameters
        ----------
        rotation : Vec3f

        rotOrder : XformCommonAPI.RotationOrder

        time : TimeCode
        """
    @staticmethod
    def SetScale(scale, time) -> bool: 
        """
        SetScale(scale, time) -> bool


        Set scale at ``time`` to ``scale`` .


        Parameters
        ----------
        scale : Vec3f

        time : TimeCode
        """
    @staticmethod
    def SetTranslate(translation, time) -> bool: 
        """
        SetTranslate(translation, time) -> bool


        Set translation at ``time`` to ``translation`` .


        Parameters
        ----------
        translation : Vec3d

        time : TimeCode
        """
    @staticmethod
    def SetXformVectors(translation, rotation, scale, pivot, rotOrder, time) -> bool: 
        """
        SetXformVectors(translation, rotation, scale, pivot, rotOrder, time) -> bool


        Set values for the various component xformOps at a given ``time`` .


        Calling this method will call all of the supported ops to be created,
        even if they only contain default (identity) values.

        To author individual operations selectively, use the Set[OpType]()
        API.

        Once the rotation order has been established for a given xformable
        (either because of an already defined (and compatible) rotate op or
        from calling SetXformVectors() or SetRotate() ), it cannot be changed.


        Parameters
        ----------
        translation : Vec3d

        rotation : Vec3f

        scale : Vec3f

        pivot : Vec3f

        rotOrder : RotationOrder

        time : TimeCode
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    OpPivot: pxr.UsdGeom.OpFlags # value = UsdGeom.XformCommonAPI.OpPivot
    OpRotate: pxr.UsdGeom.OpFlags # value = UsdGeom.XformCommonAPI.OpRotate
    OpScale: pxr.UsdGeom.OpFlags # value = UsdGeom.XformCommonAPI.OpScale
    OpTranslate: pxr.UsdGeom.OpFlags # value = UsdGeom.XformCommonAPI.OpTranslate
    RotationOrderXYZ: pxr.UsdGeom.RotationOrder # value = UsdGeom.XformCommonAPI.RotationOrderXYZ
    RotationOrderXZY: pxr.UsdGeom.RotationOrder # value = UsdGeom.XformCommonAPI.RotationOrderXZY
    RotationOrderYXZ: pxr.UsdGeom.RotationOrder # value = UsdGeom.XformCommonAPI.RotationOrderYXZ
    RotationOrderYZX: pxr.UsdGeom.RotationOrder # value = UsdGeom.XformCommonAPI.RotationOrderYZX
    RotationOrderZXY: pxr.UsdGeom.RotationOrder # value = UsdGeom.XformCommonAPI.RotationOrderZXY
    RotationOrderZYX: pxr.UsdGeom.RotationOrder # value = UsdGeom.XformCommonAPI.RotationOrderZYX
    __instance_size__ = 48
    pass
class XformOp(Boost.Python.instance):
    """
    Schema wrapper for UsdAttribute for authoring and computing
    transformation operations, as consumed by UsdGeomXformable schema.

    The semantics of an op are determined primarily by its name, which
    allows us to decode an op very efficiently. All ops are independent
    attributes, which must live in the"xformOp"property namespace. The
    op's primary name within the namespace must be one of
    UsdGeomXformOpTypes, which determines the type of transformation
    operation, and its secondary name (or suffix) within the namespace
    (which is not required to exist), can be any name that distinguishes
    it from other ops of the same type. Suffixes are generally imposed by
    higer level xform API schemas.

    **On packing order of rotateABC triples**  The order in which the axis
    rotations are recorded in a Vec3\* for the six *rotateABC* Euler
    triples **is always the same:** vec[0] = X, vec[1] = Y, vec[2] = Z.
    The *A*, *B*, *C* in the op name dictate the order in which their
    corresponding elements are consumed by the rotation, not how they are
    laid out.
    """
    class Precision(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Precision with which the value of the tranformation operation is
        encoded.
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'XformOp'
        allValues: tuple # value = (UsdGeom.XformOp.PrecisionDouble, UsdGeom.XformOp.PrecisionFloat, UsdGeom.XformOp.PrecisionHalf)
        pass
    class Type(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Enumerates the set of all transformation operation types.
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'XformOp'
        allValues: tuple # value = (UsdGeom.XformOp.TypeInvalid, UsdGeom.XformOp.TypeTranslate, UsdGeom.XformOp.TypeScale, UsdGeom.XformOp.TypeRotateX, UsdGeom.XformOp.TypeRotateY, UsdGeom.XformOp.TypeRotateZ, UsdGeom.XformOp.TypeRotateXYZ, UsdGeom.XformOp.TypeRotateXZY, UsdGeom.XformOp.TypeRotateYXZ, UsdGeom.XformOp.TypeRotateYZX, UsdGeom.XformOp.TypeRotateZXY, UsdGeom.XformOp.TypeRotateZYX, UsdGeom.XformOp.TypeOrient, UsdGeom.XformOp.TypeTransform)
        pass
    @staticmethod
    def Get(value, time) -> bool: 
        """
        Get(value, time) -> bool


        Get the attribute value of the XformOp at ``time`` .



        For inverted ops, this returns the raw, uninverted value.


        Parameters
        ----------
        value : T

        time : TimeCode
        """
    @staticmethod
    def GetAttr() -> Attribute: 
        """
        GetAttr() -> Attribute


        Explicit UsdAttribute extractor.
        """
    @staticmethod
    def GetBaseName() -> str: 
        """
        GetBaseName() -> str



        UsdAttribute::GetBaseName()
        """
    @staticmethod
    def GetName() -> str: 
        """
        GetName() -> str



        UsdAttribute::GetName()
        """
    @staticmethod
    def GetNamespace() -> str: 
        """
        GetNamespace() -> str



        UsdAttribute::GetNamespace()
        """
    @staticmethod
    def GetNumTimeSamples() -> int: 
        """
        GetNumTimeSamples() -> int


        Returns the number of time samples authored for this xformOp.
        """
    @staticmethod
    def GetOpName() -> str: 
        """
        **classmethod** GetOpName(opType, opSuffix, inverse) -> str


        Returns the xformOp's name as it appears in xformOpOrder, given the
        opType, the (optional) suffix and whether it is an inverse operation.


        Parameters
        ----------
        opType : Type

        opSuffix : str

        inverse : bool



        ----------------------------------------------------------------------


        Returns the opName as it appears in the xformOpOrder attribute.


        This will begin with"!invert!:xformOp:"if it is an inverse xform
        operation. If it is not an inverse xformOp, it will begin
        with'xformOp:'.

        This will be empty for an invalid xformOp.
        """
    @staticmethod
    def GetOpTransform(opType, opVal, isInverseOp) -> Matrix4d: 
        """
        **classmethod** GetOpTransform(time) -> Matrix4d


        Return the 4x4 matrix that applies the transformation encoded in this
        op at ``time`` .


        Returns the identity matrix and issues a coding error if the op is
        invalid.

        If the op is valid, but has no authored value, the identity matrix is
        returned and no error is issued.


        Parameters
        ----------
        time : TimeCode



        ----------------------------------------------------------------------


        Return the 4x4 matrix that applies the transformation encoded by op
        ``opType`` and data value ``opVal`` .


        If ``isInverseOp`` is true, then the inverse of the tranformation
        represented by the op/value pair is returned.

        An error will be issued if ``opType`` is not one of the values in the
        enum UsdGeomXformOp::Type or if ``opVal`` cannot be converted to a
        suitable input to ``opType``


        Parameters
        ----------
        opType : Type

        opVal : VtValue

        isInverseOp : bool
        """
    @staticmethod
    def GetOpType() -> Type: 
        """
        GetOpType() -> Type


        Return the operation type of this op, one of UsdGeomXformOp::Type.
        """
    @staticmethod
    def GetOpTypeEnum(*args, **kwargs) -> None: 
        """
        **classmethod** GetOpTypeEnum(opTypeToken) -> Type


        Returns the Type enum associated with the given ``opTypeToken`` .


        Parameters
        ----------
        opTypeToken : str
        """
    @staticmethod
    def GetOpTypeToken(*args, **kwargs) -> None: 
        """
        **classmethod** GetOpTypeToken(opType) -> str


        Returns the TfToken used to encode the given ``opType`` .


        Note that an empty TfToken is used to represent TypeInvalid


        Parameters
        ----------
        opType : Type
        """
    @staticmethod
    def GetPrecision() -> Precision: 
        """
        GetPrecision() -> Precision


        Returns the precision level of the xform op.
        """
    @staticmethod
    def GetTimeSamples(times) -> bool: 
        """
        GetTimeSamples(times) -> bool


        Populates the list of time samples at which the associated attribute
        is authored.


        Parameters
        ----------
        times : list[float]
        """
    @staticmethod
    def GetTimeSamplesInInterval(interval, times) -> bool: 
        """
        GetTimeSamplesInInterval(interval, times) -> bool


        Populates the list of time samples within the given ``interval`` , at
        which the associated attribute is authored.


        Parameters
        ----------
        interval : Interval

        times : list[float]
        """
    @staticmethod
    def GetTypeName() -> ValueTypeName: 
        """
        GetTypeName() -> ValueTypeName



        UsdAttribute::GetTypeName()
        """
    @staticmethod
    def IsDefined() -> bool: 
        """
        IsDefined() -> bool


        Return true if the wrapped UsdAttribute::IsDefined() , and in addition
        the attribute is identified as a XformOp.
        """
    @staticmethod
    def IsInverseOp() -> bool: 
        """
        IsInverseOp() -> bool


        Returns whether the xformOp represents an inverse operation.
        """
    @staticmethod
    def MightBeTimeVarying() -> bool: 
        """
        MightBeTimeVarying() -> bool


        Determine whether there is any possibility that this op's value may
        vary over time.


        The determination is based on a snapshot of the authored state of the
        op, and may become invalid in the face of further authoring.
        """
    @staticmethod
    def Set(value, time) -> bool: 
        """
        Set(value, time) -> bool


        Set the attribute value of the XformOp at ``time`` .



        This only works on non-inverse operations. If invoked on an inverse
        xform operation, a coding error is issued and no value is authored.


        Parameters
        ----------
        value : T

        time : TimeCode
        """
    @staticmethod
    def SplitName() -> list[str]: 
        """
        SplitName() -> list[str]



        UsdAttribute::SplitName()
        """
    PrecisionDouble: pxr.UsdGeom.Precision # value = UsdGeom.XformOp.PrecisionDouble
    PrecisionFloat: pxr.UsdGeom.Precision # value = UsdGeom.XformOp.PrecisionFloat
    PrecisionHalf: pxr.UsdGeom.Precision # value = UsdGeom.XformOp.PrecisionHalf
    TypeInvalid: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeInvalid
    TypeOrient: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeOrient
    TypeRotateX: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateX
    TypeRotateXYZ: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateXYZ
    TypeRotateXZY: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateXZY
    TypeRotateY: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateY
    TypeRotateYXZ: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateYXZ
    TypeRotateYZX: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateYZX
    TypeRotateZ: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateZ
    TypeRotateZXY: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateZXY
    TypeRotateZYX: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeRotateZYX
    TypeScale: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeScale
    TypeTransform: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeTransform
    TypeTranslate: pxr.UsdGeom.Type # value = UsdGeom.XformOp.TypeTranslate
    __instance_size__ = 152
    pass
class XformOpTypes(Boost.Python.instance):
    orient = 'orient'
    resetXformStack = '!resetXformStack!'
    rotateX = 'rotateX'
    rotateXYZ = 'rotateXYZ'
    rotateXZY = 'rotateXZY'
    rotateY = 'rotateY'
    rotateYXZ = 'rotateYXZ'
    rotateYZX = 'rotateYZX'
    rotateZ = 'rotateZ'
    rotateZXY = 'rotateZXY'
    rotateZYX = 'rotateZYX'
    scale = 'scale'
    transform = 'transform'
    translate = 'translate'
    pass
class Xformable(Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Base class for all transformable prims, which allows arbitrary
    sequences of component affine transformations to be encoded.

    You may find it useful to review Linear Algebra in UsdGeom while
    reading this class description. **Supported Component Transformation
    Operations**

    UsdGeomXformable currently supports arbitrary sequences of the
    following operations, each of which can be encoded in an attribute of
    the proper shape in any supported precision:

       - translate - 3D

       - scale - 3D

       - rotateX - 1D angle in degrees

       - rotateY - 1D angle in degrees

       - rotateZ - 1D angle in degrees

       - rotateABC - 3D where ABC can be any combination of the six
         principle Euler Angle sets: XYZ, XZY, YXZ, YZX, ZXY, ZYX. See note on
         rotation packing order

       - orient - 4D (quaternion)

       - transform - 4x4D
         **Creating a Component Transformation**

    To add components to a UsdGeomXformable prim, simply call AddXformOp()
    with the desired op type, as enumerated in UsdGeomXformOp::Type, and
    the desired precision, which is one of UsdGeomXformOp::Precision.
    Optionally, you can also provide an"op suffix"for the operator that
    disambiguates it from other components of the same type on the same
    prim.  Application-specific transform schemas can use the suffixes to
    fill a role similar to that played by AbcGeom::XformOp's"Hint"enums
    for their own round-tripping logic.

    We also provide specific"Add"API for each type, for clarity and
    conciseness, e.g. AddTranslateOp() , AddRotateXYZOp() etc.

    AddXformOp() will return a UsdGeomXformOp object, which is a schema on
    a newly created UsdAttribute that provides convenience API for
    authoring and computing the component transformations. The
    UsdGeomXformOp can then be used to author any number of timesamples
    and default for the op.

    Each successive call to AddXformOp() adds an operator that will be
    applied"more locally"than the preceding operator, just as if we were
    pushing transforms onto a transformation stack - which is precisely
    what should happen when the operators are consumed by a reader.

    If you can, please try to use the UsdGeomXformCommonAPI, which wraps
    the UsdGeomXformable with an interface in which Op creation is taken
    care of for you, and there is a much higher chance that the data you
    author will be importable without flattening into other DCC's, as it
    conforms to a fixed set of Scale-Rotate-Translate Ops.

    Using the Authoring API **Data Encoding and Op Ordering**

    Because there is no"fixed schema"of operations, all of the attributes
    that encode transform operations are dynamic, and are scoped in the
    namespace"xformOp". The second component of an attribute's name
    provides the *type* of operation, as listed above.
    An"xformOp"attribute can have additional namespace components derived
    from the *opSuffix* argument to the AddXformOp() suite of methods,
    which provides a preferred way of naming the ops such that we can have
    multiple"translate"ops with unique attribute names. For example, in
    the attribute named"xformOp:translate:maya:pivot","translate"is the
    type of operation and"maya:pivot"is the suffix.

    The following ordered list of attribute declarations in usda define a
    basic Scale-Rotate-Translate with XYZ Euler angles, wherein the
    translation is double-precision, and the remainder of the ops are
    single, in which we will:

       - Scale by 2.0 in each dimension

       - Rotate about the X, Y, and Z axes by 30, 60, and 90 degrees,
         respectively

       - Translate by 100 units in the Y direction

    .. code-block:: text

      float3 xformOp:rotateXYZ = (30, 60, 90)
      float3 xformOp:scale = (2, 2, 2)
      double3 xformOp:translate = (0, 100, 0)
      uniform token[] xformOpOrder = [ "xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale" ]

    The attributes appear in the dictionary order in which USD, by
    default, sorts them. To ensure the ops are recovered and evaluated in
    the correct order, the schema introduces the **xformOpOrder**
    attribute, which contains the names of the op attributes, in the
    precise sequence in which they should be pushed onto a transform
    stack. **Note** that the order is opposite to what you might expect,
    given the matrix algebra described in Linear Algebra in UsdGeom. This
    also dictates order of op creation, since each call to AddXformOp()
    adds a new op to the end of the **xformOpOrder** array, as a new"most-
    local"operation. See Example 2 below for C++ code that could have
    produced this USD.

    If it were important for the prim's rotations to be independently
    overridable, we could equivalently (at some performance cost) encode
    the transformation also like so:

    .. code-block:: text

      float xformOp:rotateX = 30
      float xformOp:rotateY = 60
      float xformOp:rotateZ = 90
      float3 xformOp:scale = (2, 2, 2)
      double3 xformOp:translate = (0, 100, 0)
      uniform token[] xformOpOrder = [ "xformOp:translate", "xformOp:rotateZ", "xformOp:rotateY", "xformOp:rotateX", "xformOp:scale" ]

    Again, note that although we are encoding an XYZ rotation, the three
    rotations appear in the **xformOpOrder** in the opposite order, with
    Z, followed, by Y, followed by X.

    Were we to add a Maya-style scalePivot to the above example, it might
    look like the following:

    .. code-block:: text

      float3 xformOp:rotateXYZ = (30, 60, 90)
      float3 xformOp:scale = (2, 2, 2)
      double3 xformOp:translate = (0, 100, 0)
      double3 xformOp:translate:scalePivot
      uniform token[] xformOpOrder = [ "xformOp:translate", "xformOp:rotateXYZ", "xformOp:translate:scalePivot", "xformOp:scale" ]

    **Paired"Inverted"Ops**

    We have been claiming that the ordered list of ops serves as a set of
    instructions to a transform stack, but you may have noticed in the
    last example that there is a missing operation - the pivot for the
    scale op needs to be applied in its inverse-form as a final (most
    local) op! In the AbcGeom::Xform schema, we would have encoded an
    actual"final"translation op whose value was authored by the exporter
    as the negation of the pivot's value. However, doing so would be
    brittle in USD, given that each op can be independently overridden,
    and the constraint that one attribute must be maintained as the
    negation of the other in order for successful re-importation of the
    schema cannot be expressed in USD.

    Our solution leverages the **xformOpOrder** member of the schema,
    which, in addition to ordering the ops, may also contain one of two
    special tokens that address the paired op and"stack
    resetting"behavior.

    The"paired op"behavior is encoded as an"!invert!"prefix in
    **xformOpOrder**, as the result of an AddXformOp(isInverseOp=True)
    call.  The **xformOpOrder** for the last example would look like:

    .. code-block:: text

      uniform token[] xformOpOrder = [ "xformOp:translate", "xformOp:rotateXYZ", "xformOp:translate:scalePivot", "xformOp:scale", "!invert!xformOp:translate:scalePivot" ]

    When asked for its value via UsdGeomXformOp::GetOpTransform() ,
    an"inverted"Op (i.e. the"inverted"half of a set of paired Ops) will
    fetch the value of its paired attribute and return its negation. This
    works for all op types - an error will be issued if a"transform"type
    op is singular and cannot be inverted. When getting the authored value
    of an inverted op via UsdGeomXformOp::Get() , the raw, uninverted
    value of the associated attribute is returned.

    For the sake of robustness, **setting a value on an inverted op is
    disallowed.** Attempting to set a value on an inverted op will result
    in a coding error and no value being set.

    **Resetting the Transform Stack**

    The other special op/token that can appear in *xformOpOrder* is
    *"!resetXformStack!"*, which, appearing as the first element of
    *xformOpOrder*, indicates this prim should not inherit the
    transformation of its namespace parent. See SetResetXformStack()

    **Expected Behavior for"Missing"Ops**

    If an importer expects Scale-Rotate-Translate operations, but a prim
    has only translate and rotate ops authored, the importer should assume
    an identity scale. This allows us to optimize the data a bit, if only
    a few components of a very rich schema (like Maya's) are authored in
    the app.

    **Using the C++ API**

    #1. Creating a simple transform matrix encoding

    .. code-block:: text

     #2. Creating the simple SRT from the example above

    .. code-block:: text

     #3. Creating a parameterized SRT with pivot using
    UsdGeomXformCommonAPI

    .. code-block:: text

     #4. Creating a rotate-only pivot transform with animated rotation and
    translation

    .. code-block:: text
    """
    @staticmethod
    def AddOrientOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddOrientOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a orient op (arbitrary axis/angle rotation) to the local stack
        represented by this xformable.




        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateXOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateXOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation about the X-axis to the local stack represented by this
        xformable.


        Set the angle value of the resulting UsdGeomXformOp **in degrees**


        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateXYZOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateXYZOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation op with XYZ rotation order to the local stack
        represented by this xformable.


        Set the angle value of the resulting UsdGeomXformOp **in degrees**


        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateXZYOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateXZYOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation op with XZY rotation order to the local stack
        represented by this xformable.


        Set the angle values of the resulting UsdGeomXformOp **in degrees**


        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateYOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateYOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation about the YX-axis to the local stack represented by
        this xformable.


        Set the angle value of the resulting UsdGeomXformOp **in degrees**


        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateYXZOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateYXZOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation op with YXZ rotation order to the local stack
        represented by this xformable.


        Set the angle values of the resulting UsdGeomXformOp **in degrees**


        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateYZXOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateYZXOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation op with YZX rotation order to the local stack
        represented by this xformable.


        Set the angle values of the resulting UsdGeomXformOp **in degrees**


        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateZOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateZOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation about the Z-axis to the local stack represented by this
        xformable.




        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateZXYOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateZXYOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation op with ZXY rotation order to the local stack
        represented by this xformable.


        Set the angle values of the resulting UsdGeomXformOp **in degrees**


        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddRotateZYXOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddRotateZYXOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a rotation op with ZYX rotation order to the local stack
        represented by this xformable.


        Set the angle values of the resulting UsdGeomXformOp **in degrees**


        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddScaleOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddScaleOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a scale operation to the local stack represented by this
        xformable.




        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddTransformOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddTransformOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a tranform op (4x4 matrix transformation) to the local stack
        represented by this xformable.




        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddTranslateOp(precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddTranslateOp(precision, opSuffix, isInverseOp) -> XformOp


        Add a translate operation to the local stack represented by this
        xformable.




        Parameters
        ----------
        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def AddXformOp(opType, precision, opSuffix, isInverseOp) -> XformOp: 
        """
        AddXformOp(opType, precision, opSuffix, isInverseOp) -> XformOp


        Add an affine transformation to the local stack represented by this
        Xformable.


        This will fail if there is already a transform operation of the same
        name in the ordered ops on this prim (i.e. as returned by
        GetOrderedXformOps() ), or if an op of the same name exists at all on
        the prim with a different precision than that specified.

        The newly created operation will become the most-locally applied
        transformation on the prim, and will appear last in the list returned
        by GetOrderedXformOps() . It is OK to begin authoring values to the
        returned UsdGeomXformOp immediately, interspersed with subsequent
        calls to AddXformOp() - just note the order of application, which
        *can* be changed at any time (and in stronger layers) via
        SetXformOpOrder() .

        opType

        is the type of transform operation, one of UsdGeomXformOp::Type.
        precision

        allows you to specify the precision with which you desire to encode
        the data. This should be one of the values in the enum
        UsdGeomXformOp::Precision. opSuffix

        allows you to specify the purpose/meaning of the op in the stack. When
        opSuffix is specified, the associated attribute's name is set
        to"xformOp:<opType>:<opSuffix>". isInverseOp

        is used to indicate an inverse transformation operation.

        a UsdGeomXformOp that can be used to author to the operation. An error
        is issued and the returned object will be invalid (evaluate to false)
        if the op being added already exists in xformOpOrder or if the
        arguments supplied are invalid.

        If the attribute associated with the op already exists, but isn't of
        the requested precision, a coding error is issued, but a valid xformOp
        is returned with the existing attribute.


        Parameters
        ----------
        opType : XformOp.Type

        precision : XformOp.Precision

        opSuffix : str

        isInverseOp : bool
        """
    @staticmethod
    def ClearXformOpOrder() -> bool: 
        """
        ClearXformOpOrder() -> bool


        Clears the local transform stack.
        """
    @staticmethod
    def CreateXformOpOrderAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateXformOpOrderAttr(defaultValue, writeSparsely) -> Attribute


        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`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Xformable


        Return a UsdGeomXformable holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdGeomXformable(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetLocalTransformation(*args, **kwargs) -> None: 
        """
        Compute the fully-combined, local-to-parent transformation for this prim.
        If a client does not need to manipulate the individual ops themselves, and requires only the combined transform on this prim, this method will take care of all the data marshalling and linear algebra needed to combine the ops into a 4x4 affine transformation matrix, in double-precision, regardless of the precision of the op inputs.
        The python version of this function only returns the computed  local-to-parent transformation. Clients must independently call  GetResetXformStack() to be able to construct the local-to-world transformation.

        Compute the fully-combined, local-to-parent transformation for this prim as efficiently as possible, using pre-fetched list of ordered xform ops supplied by the client.
        The python version of this function only returns the computed  local-to-parent transformation. Clients must independently call  GetResetXformStack() to be able to construct the local-to-world transformation.
        """
    @staticmethod
    def GetOrderedXformOps(*args, **kwargs) -> None: 
        """
        Return the ordered list of transform operations to be applied to this prim, in least-to-most-local order.  This is determined by the intersection of authored op-attributes and the explicit ordering of those attributes encoded in the "xformOpOrder" attribute on this prim.

        Any entries in "xformOpOrder" that do not correspond to valid attributes on the xformable prim are skipped and a warning is issued.

        A UsdGeomTransformable that has not had any ops added via AddXformOp() will return an empty vector.



        The python version of this function only returns the ordered list of xformOps. Clients must independently call GetResetXformStack() if they need the info.
        """
    @staticmethod
    def GetResetXformStack() -> bool: 
        """
        GetResetXformStack() -> bool


        Does this prim reset its parent's inherited transformation?


        Returns true if"!resetXformStack!"appears *anywhere* in xformOpOrder.
        When this returns true, all ops upto the last"!resetXformStack!"in
        xformOpOrder are ignored when computing the local transformation.
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetTimeSamples(orderedXformOps, times) -> bool: 
        """
        **classmethod** GetTimeSamples(times) -> bool


        Sets ``times`` to the union of all the timesamples at which xformOps
        that are included in the xformOpOrder attribute are authored.


        This clears the ``times`` vector before accumulating sample times from
        all the xformOps.

        UsdAttribute::GetTimeSamples


        Parameters
        ----------
        times : list[float]



        ----------------------------------------------------------------------


        Returns the union of all the timesamples at which the attributes
        belonging to the given ``orderedXformOps`` are authored.


        This clears the ``times`` vector before accumulating sample times from
        ``orderedXformOps`` .

        UsdGeomXformable::GetTimeSamples


        Parameters
        ----------
        orderedXformOps : list[XformOp]

        times : list[float]
        """
    @staticmethod
    def GetTimeSamplesInInterval(orderedXformOps, interval, times) -> bool: 
        """
        **classmethod** GetTimeSamplesInInterval(interval, times) -> bool


        Sets ``times`` to the union of all the timesamples in the interval,
        ``interval`` , at which xformOps that are included in the xformOpOrder
        attribute are authored.


        This clears the ``times`` vector before accumulating sample times from
        all the xformOps.

        UsdAttribute::GetTimeSamples


        Parameters
        ----------
        interval : Interval

        times : list[float]



        ----------------------------------------------------------------------


        Returns the union of all the timesamples in the ``interval`` at which
        the attributes belonging to the given ``orderedXformOps`` are
        authored.


        This clears the ``times`` vector before accumulating sample times from
        ``orderedXformOps`` .

        UsdGeomXformable::GetTimeSamplesInInterval


        Parameters
        ----------
        orderedXformOps : list[XformOp]

        interval : Interval

        times : list[float]
        """
    @staticmethod
    def GetXformOpOrderAttr() -> Attribute: 
        """
        GetXformOpOrderAttr() -> Attribute


        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
        """
    @staticmethod
    def IsTransformationAffectedByAttrNamed(*args, **kwargs) -> None: 
        """
        **classmethod** IsTransformationAffectedByAttrNamed(attrName) -> bool


        Returns true if the attribute named ``attrName`` could affect the
        local transformation of an xformable prim.


        Parameters
        ----------
        attrName : str
        """
    @staticmethod
    def MakeMatrixXform() -> XformOp: 
        """
        MakeMatrixXform() -> XformOp


        Clears the existing local transform stack and creates a new xform op
        of type'transform'.


        This API is provided for convenience since this is the most common
        xform authoring operation.
        """
    @staticmethod
    def SetResetXformStack(resetXform) -> bool: 
        """
        SetResetXformStack(resetXform) -> bool


        Specify whether this prim's transform should reset the transformation
        stack inherited from its parent prim.



        By default, parent transforms are inherited. SetResetXformStack() can
        be called at any time during authoring, but will always add
        a'!resetXformStack!'op as the *first* op in the ordered list, if one
        does not exist already. If one already exists, and ``resetXform`` is
        false, it will remove all ops upto and including the
        last"!resetXformStack!"op.


        Parameters
        ----------
        resetXform : bool
        """
    @staticmethod
    def SetXformOpOrder(orderedXformOps, resetXformStack) -> bool: 
        """
        SetXformOpOrder(orderedXformOps, resetXformStack) -> bool


        Reorder the already-existing transform ops on this prim.


        All elements in ``orderedXformOps`` must be valid and represent
        attributes on this prim. Note that it is *not* required that all the
        existing operations be present in ``orderedXformOps`` , so this method
        can be used to completely change the transformation structure applied
        to the prim.

        If ``resetXformStack`` is set to true, then "!resetXformOp! will be
        set as the first op in xformOpOrder, to indicate that the prim does
        not inherit its parent's transformation.

        If you wish to re-specify a prim's transformation completely in a
        stronger layer, you should first call this method with an *empty*
        ``orderedXformOps`` vector. From there you can call AddXformOp() just
        as if you were authoring to the prim from scratch.

        false if any of the elements of ``orderedXformOps`` are not extant on
        this prim, or if an error occurred while authoring the ordering
        metadata. Under either condition, no scene description is authored.


        Parameters
        ----------
        orderedXformOps : list[XformOp]

        resetXformStack : bool
        """
    @staticmethod
    @typing.overload
    def TransformMightBeTimeVarying() -> bool: 
        """
        TransformMightBeTimeVarying() -> bool


        Determine whether there is any possibility that this prim's *local*
        transformation may vary over time.


        The determination is based on a snapshot of the authored state of the
        op attributes on the prim, and may become invalid in the face of
        further authoring.




        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.
        Determine whether there is any possibility that this prim's *local*
        transformation may vary over time, using a pre-fetched (cached) list
        of ordered xform ops supplied by the client.


        The determination is based on a snapshot of the authored state of the
        op attributes on the prim, and may become invalid in the face of
        further authoring.


        Parameters
        ----------
        ops : list[XformOp]
        """
    @staticmethod
    @typing.overload
    def TransformMightBeTimeVarying(ops) -> bool: ...
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class _CanApplyResult(Boost.Python.instance):
    @property
    def whyNot(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 56
    pass
def GetFallbackUpAxis() -> str:
    """
    GetFallbackUpAxis() -> str


    Return the site-level fallback up axis as a TfToken.


    In a generic installation of USD, the fallback will be"Y". This can be
    changed to"Z"by adding, in a plugInfo.json file discoverable by USD's
    PlugPlugin mechanism:

    .. code-block:: text

      "UsdGeomMetrics": {
          "upAxis": "Z"
      }

    If more than one such entry is discovered and the values for upAxis
    differ, we will issue a warning during the first call to this
    function, and ignore all of them, so that we devolve to deterministic
    behavior of Y up axis until the problem is rectified.
    """
def GetStageMetersPerUnit(stage) -> float:
    """
    GetStageMetersPerUnit(stage) -> float


    Return *stage* 's authored *metersPerUnit*, or 0.01 if unauthored.



    Encoding Stage Linear Units


    Parameters
    ----------
    stage : UsdStageWeak
    """
def GetStageUpAxis(stage) -> str:
    """
    GetStageUpAxis(stage) -> str


    Fetch and return ``stage`` 's upAxis.


    If unauthored, will return the value provided by
    UsdGeomGetFallbackUpAxis() . Exporters, however, are strongly
    encouraged to always set the upAxis for every USD file they create.

    one of: UsdGeomTokens->y or UsdGeomTokens->z, unless there was an
    error, in which case returns an empty TfToken

    Encoding Stage UpAxis


    Parameters
    ----------
    stage : UsdStageWeak
    """
def LinearUnitsAre(authoredUnits, standardUnits, epsilon) -> bool:
    """
    LinearUnitsAre(authoredUnits, standardUnits, epsilon) -> bool


    Return *true* if the two given metrics are within the provided
    relative *epsilon* of each other, when you need to know an absolute
    metric rather than a scaling factor.



    Use like so:

    .. code-block:: text

      double stageUnits = UsdGeomGetStageMetersPerUnit(stage);
      
      if (UsdGeomLinearUnitsAre(stageUnits, UsdGeomLinearUnits::meters))
          // do something for meters
      else if (UsdGeomLinearUnitsAre(stageUnits, UsdGeomLinearUnits::feet))
          // do something for feet

    *false* if either input is zero or negative, otherwise relative
    floating-point comparison between the two inputs.

    Encoding Stage Linear Units


    Parameters
    ----------
    authoredUnits : float

    standardUnits : float

    epsilon : float
    """
def SetStageMetersPerUnit(stage, metersPerUnit) -> bool:
    """
    SetStageMetersPerUnit(stage, metersPerUnit) -> bool


    Author *stage* 's *metersPerUnit*.



    true if metersPerUnit was successfully set. The stage's UsdEditTarget
    must be either its root layer or session layer.

    Encoding Stage Linear Units


    Parameters
    ----------
    stage : UsdStageWeak

    metersPerUnit : float
    """
def SetStageUpAxis(stage, axis) -> bool:
    """
    SetStageUpAxis(stage, axis) -> bool


    Set ``stage`` 's upAxis to ``axis`` , which must be one of
    UsdGeomTokens->y or UsdGeomTokens->z.


    UpAxis is stage-level metadata, therefore see UsdStage::SetMetadata()
    .

    true if upAxis was successfully set. The stage's UsdEditTarget must be
    either its root layer or session layer.

    Encoding Stage UpAxis


    Parameters
    ----------
    stage : UsdStageWeak

    axis : str
    """
def StageHasAuthoredMetersPerUnit(stage) -> bool:
    """
    StageHasAuthoredMetersPerUnit(stage) -> bool


    Return whether *stage* has an authored *metersPerUnit*.



    Encoding Stage Linear Units


    Parameters
    ----------
    stage : UsdStageWeak
    """
__MFB_FULL_PACKAGE_NAME = 'usdGeom'
