def Execute(result):
   result["BoundableLightBase"].__doc__ = """
Base class for intrinsic lights that are boundable.

The primary purpose of this class is to provide a direct API to the
functions provided by LightAPI for concrete derived light types.

"""
   result["BoundableLightBase"].LightAPI.func_doc = """LightAPI() -> LightAPI


Contructs and returns a UsdLuxLightAPI object for this light.



"""
   result["BoundableLightBase"].GetIntensityAttr.func_doc = """GetIntensityAttr() -> Attribute


See UsdLuxLightAPI::GetIntensityAttr() .



"""
   result["BoundableLightBase"].CreateIntensityAttr.func_doc = """CreateIntensityAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateIntensityAttr() .


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

writeSparsely : bool


"""
   result["BoundableLightBase"].GetExposureAttr.func_doc = """GetExposureAttr() -> Attribute


See UsdLuxLightAPI::GetExposureAttr() .



"""
   result["BoundableLightBase"].CreateExposureAttr.func_doc = """CreateExposureAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateExposureAttr() .


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

writeSparsely : bool


"""
   result["BoundableLightBase"].GetDiffuseAttr.func_doc = """GetDiffuseAttr() -> Attribute


See UsdLuxLightAPI::GetDiffuseAttr() .



"""
   result["BoundableLightBase"].CreateDiffuseAttr.func_doc = """CreateDiffuseAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateDiffuseAttr() .


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

writeSparsely : bool


"""
   result["BoundableLightBase"].GetSpecularAttr.func_doc = """GetSpecularAttr() -> Attribute


See UsdLuxLightAPI::GetSpecularAttr() .



"""
   result["BoundableLightBase"].CreateSpecularAttr.func_doc = """CreateSpecularAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateSpecularAttr() .


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

writeSparsely : bool


"""
   result["BoundableLightBase"].GetNormalizeAttr.func_doc = """GetNormalizeAttr() -> Attribute


See UsdLuxLightAPI::GetNormalizeAttr() .



"""
   result["BoundableLightBase"].CreateNormalizeAttr.func_doc = """CreateNormalizeAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateNormalizeAttr() .


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

writeSparsely : bool


"""
   result["BoundableLightBase"].GetColorAttr.func_doc = """GetColorAttr() -> Attribute


See UsdLuxLightAPI::GetColorAttr() .



"""
   result["BoundableLightBase"].CreateColorAttr.func_doc = """CreateColorAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateColorAttr() .


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

writeSparsely : bool


"""
   result["BoundableLightBase"].GetEnableColorTemperatureAttr.func_doc = """GetEnableColorTemperatureAttr() -> Attribute


See UsdLuxLightAPI::GetEnableColorTemperatureAttr() .



"""
   result["BoundableLightBase"].CreateEnableColorTemperatureAttr.func_doc = """CreateEnableColorTemperatureAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateEnableColorTemperatureAttr() .


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

writeSparsely : bool


"""
   result["BoundableLightBase"].GetColorTemperatureAttr.func_doc = """GetColorTemperatureAttr() -> Attribute


See UsdLuxLightAPI::GetColorTemperatureAttr() .



"""
   result["BoundableLightBase"].CreateColorTemperatureAttr.func_doc = """CreateColorTemperatureAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateColorTemperatureAttr() .


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

writeSparsely : bool


"""
   result["BoundableLightBase"].GetFiltersRel.func_doc = """GetFiltersRel() -> Relationship


See UsdLuxLightAPI::GetFiltersRel() .



"""
   result["BoundableLightBase"].CreateFiltersRel.func_doc = """CreateFiltersRel() -> Relationship


See UsdLuxLightAPI::CreateFiltersRel() .



"""
   result["BoundableLightBase"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxBoundableLightBase on UsdPrim ``prim`` .


Equivalent to UsdLuxBoundableLightBase::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxBoundableLightBase on the prim held by ``schemaObj``
.


Should be preferred over UsdLuxBoundableLightBase
(schemaObj.GetPrim()), as it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["BoundableLightBase"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["BoundableLightBase"].Get.func_doc = """**classmethod** Get(stage, path) -> BoundableLightBase


Return a UsdLuxBoundableLightBase 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

  UsdLuxBoundableLightBase(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["BoundableLightBase"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["CylinderLight"].__doc__ = """
Light emitted outward from a cylinder. The cylinder is centered at the
origin and has its major axis on the X axis. The cylinder does not
emit light from the flat end-caps.

"""
   result["CylinderLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxCylinderLight on UsdPrim ``prim`` .


Equivalent to UsdLuxCylinderLight::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxCylinderLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxCylinderLight (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["CylinderLight"].GetLengthAttr.func_doc = """GetLengthAttr() -> Attribute


Width of the rectangle, in the local X axis.



Declaration

``float inputs:length = 1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["CylinderLight"].CreateLengthAttr.func_doc = """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


"""
   result["CylinderLight"].GetRadiusAttr.func_doc = """GetRadiusAttr() -> Attribute


Radius of the cylinder.



Declaration

``float inputs:radius = 0.5``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["CylinderLight"].CreateRadiusAttr.func_doc = """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


"""
   result["CylinderLight"].GetTreatAsLineAttr.func_doc = """GetTreatAsLineAttr() -> Attribute


A hint that this light can be treated as a'line'light (effectively, a
zero-radius cylinder) by renderers that benefit from non-area
lighting.


Renderers that only support area lights can disregard this.

Declaration

``bool treatAsLine = 0``

C++ Type

bool

Usd Type

SdfValueTypeNames->Bool



"""
   result["CylinderLight"].CreateTreatAsLineAttr.func_doc = """CreateTreatAsLineAttr(defaultValue, writeSparsely) -> Attribute


See GetTreatAsLineAttr() , 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


"""
   result["CylinderLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["CylinderLight"].Get.func_doc = """**classmethod** Get(stage, path) -> CylinderLight


Return a UsdLuxCylinderLight 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

  UsdLuxCylinderLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["CylinderLight"].Define.func_doc = """**classmethod** Define(stage, path) -> CylinderLight


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


"""
   result["CylinderLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["DiskLight"].__doc__ = """
Light emitted from one side of a circular disk. The disk is centered
in the XY plane and emits light along the -Z axis.

"""
   result["DiskLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxDiskLight on UsdPrim ``prim`` .


Equivalent to UsdLuxDiskLight::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxDiskLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxDiskLight (schemaObj.GetPrim()), as it
preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["DiskLight"].GetRadiusAttr.func_doc = """GetRadiusAttr() -> Attribute


Radius of the disk.



Declaration

``float inputs:radius = 0.5``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["DiskLight"].CreateRadiusAttr.func_doc = """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


"""
   result["DiskLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["DiskLight"].Get.func_doc = """**classmethod** Get(stage, path) -> DiskLight


Return a UsdLuxDiskLight 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

  UsdLuxDiskLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["DiskLight"].Define.func_doc = """**classmethod** Define(stage, path) -> DiskLight


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


"""
   result["DiskLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["DistantLight"].__doc__ = """
Light emitted from a distant source along the -Z axis. Also known as a
directional light.

"""
   result["DistantLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxDistantLight on UsdPrim ``prim`` .


Equivalent to UsdLuxDistantLight::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxDistantLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxDistantLight (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["DistantLight"].GetAngleAttr.func_doc = """GetAngleAttr() -> Attribute


Angular size of the light in degrees.


As an example, the Sun is approximately 0.53 degrees as seen from
Earth. Higher values broaden the light and therefore soften shadow
edges.

Declaration

``float inputs:angle = 0.53``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["DistantLight"].CreateAngleAttr.func_doc = """CreateAngleAttr(defaultValue, writeSparsely) -> Attribute


See GetAngleAttr() , 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


"""
   result["DistantLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["DistantLight"].Get.func_doc = """**classmethod** Get(stage, path) -> DistantLight


Return a UsdLuxDistantLight 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

  UsdLuxDistantLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["DistantLight"].Define.func_doc = """**classmethod** Define(stage, path) -> DistantLight


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


"""
   result["DistantLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["DomeLight"].__doc__ = """
Light emitted inward from a distant external environment, such as a
sky or IBL light probe. The orientation of a dome light with a latlong
texture is expected to match the OpenEXR specification for latlong
environment maps. From the OpenEXR documentation:

Latitude-Longitude Map:

The environment is projected onto the image using polar coordinates
(latitude and longitude). A pixel's x coordinate corresponds to its
longitude, and the y coordinate corresponds to its latitude. Pixel
(dataWindow.min.x, dataWindow.min.y) has latitude +pi/2 and longitude
+pi; pixel (dataWindow.max.x, dataWindow.max.y) has latitude -pi/2 and
longitude -pi.

In 3D space, latitudes -pi/2 and +pi/2 correspond to the negative and
positive y direction. Latitude 0, longitude 0 points into positive z
direction; and latitude 0, longitude pi/2 points into positive x
direction.

The size of the data window should be 2\\*N by N pixels (width by
height),

For any described attribute *Fallback* *Value* or *Allowed* *Values*
below that are text/tokens, the actual token is published and defined
in UsdLuxTokens. So to set an attribute to the value"rightHanded", use
UsdLuxTokens->rightHanded as the value.

"""
   result["DomeLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxDomeLight on UsdPrim ``prim`` .


Equivalent to UsdLuxDomeLight::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxDomeLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxDomeLight (schemaObj.GetPrim()), as it
preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["DomeLight"].GetTextureFileAttr.func_doc = """GetTextureFileAttr() -> Attribute


A color texture to use on the dome, such as an HDR (high dynamic
range) texture intended for IBL (image based lighting).



Declaration

``asset inputs:texture:file``

C++ Type

SdfAssetPath

Usd Type

SdfValueTypeNames->Asset



"""
   result["DomeLight"].CreateTextureFileAttr.func_doc = """CreateTextureFileAttr(defaultValue, writeSparsely) -> Attribute


See GetTextureFileAttr() , 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


"""
   result["DomeLight"].GetTextureFormatAttr.func_doc = """GetTextureFormatAttr() -> Attribute


Specifies the parameterization of the color map file.


Valid values are:

   - automatic: Tries to determine the layout from the file itself.
     For example, Renderman texture files embed an explicit
     parameterization.

   - latlong: Latitude as X, longitude as Y.

   - mirroredBall: An image of the environment reflected in a sphere,
     using an implicitly orthogonal projection.

   - angular: Similar to mirroredBall but the radial dimension is
     mapped linearly to the angle, providing better sampling at the edges.

   - cubeMapVerticalCross: A cube map with faces laid out as a
     vertical cross.

Declaration

``token inputs:texture:format ="automatic"``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token

Allowed Values

automatic, latlong, mirroredBall, angular, cubeMapVerticalCross



"""
   result["DomeLight"].CreateTextureFormatAttr.func_doc = """CreateTextureFormatAttr(defaultValue, writeSparsely) -> Attribute


See GetTextureFormatAttr() , 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


"""
   result["DomeLight"].GetGuideRadiusAttr.func_doc = """GetGuideRadiusAttr() -> Attribute


The radius of guide geometry to use to visualize the dome light.


The default is 1 km for scenes whose metersPerUnit is the USD default
of 0.01 (i.e., 1 world unit is 1 cm).

Declaration

``float guideRadius = 100000``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["DomeLight"].CreateGuideRadiusAttr.func_doc = """CreateGuideRadiusAttr(defaultValue, writeSparsely) -> Attribute


See GetGuideRadiusAttr() , 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


"""
   result["DomeLight"].GetPortalsRel.func_doc = """GetPortalsRel() -> Relationship


Optional portals to guide light sampling.



"""
   result["DomeLight"].CreatePortalsRel.func_doc = """CreatePortalsRel() -> Relationship


See GetPortalsRel() , and also Create vs Get Property Methods for when
to use Get vs Create.



"""
   result["DomeLight"].OrientToStageUpAxis.func_doc = """OrientToStageUpAxis() -> None


Adds a transformation op, if neeeded, to orient the dome to align with
the stage's up axis.


Uses UsdLuxTokens->orientToStageUpAxis as the op suffix. If an op with
this suffix already exists, this method assumes it is already applying
the proper correction and does nothing further. If no op is required
to match the stage's up axis, no op will be created.

UsdGeomXformOp

UsdGeomGetStageUpAxis



"""
   result["DomeLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["DomeLight"].Get.func_doc = """**classmethod** Get(stage, path) -> DomeLight


Return a UsdLuxDomeLight 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

  UsdLuxDomeLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["DomeLight"].Define.func_doc = """**classmethod** Define(stage, path) -> DomeLight


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


"""
   result["DomeLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["GeometryLight"].__doc__ = """
Deprecated

Light emitted outward from a geometric prim (UsdGeomGprim), which is
typically a mesh.

"""
   result["GeometryLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxGeometryLight on UsdPrim ``prim`` .


Equivalent to UsdLuxGeometryLight::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxGeometryLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxGeometryLight (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["GeometryLight"].GetGeometryRel.func_doc = """GetGeometryRel() -> Relationship


Relationship to the geometry to use as the light source.



"""
   result["GeometryLight"].CreateGeometryRel.func_doc = """CreateGeometryRel() -> Relationship


See GetGeometryRel() , and also Create vs Get Property Methods for
when to use Get vs Create.



"""
   result["GeometryLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["GeometryLight"].Get.func_doc = """**classmethod** Get(stage, path) -> GeometryLight


Return a UsdLuxGeometryLight 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

  UsdLuxGeometryLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["GeometryLight"].Define.func_doc = """**classmethod** Define(stage, path) -> GeometryLight


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


"""
   result["GeometryLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["LightAPI"].__doc__ = """
API schema that imparts the quality of being a light onto a prim.

A light is any prim that has this schema applied to it. This is true
regardless of whether LightAPI is included as a built-in API of the
prim type (e.g. RectLight or DistantLight) or is applied directly to a
Gprim that should be treated as a light.

**Linking**

Lights can be linked to geometry. Linking controls which geometry a
light illuminates, and which geometry casts shadows from the light.

Linking is specified as collections (UsdCollectionAPI) which can be
accessed via GetLightLinkCollection() and GetShadowLinkCollection().
Note that these collections have their includeRoot set to true, so
that lights will illuminate and cast shadows from all objects by
default. To illuminate only a specific set of objects, there are two
options. One option is to modify the collection paths to explicitly
exclude everything else, assuming it is known; the other option is to
set includeRoot to false and explicitly include the desired objects.
These are complementary approaches that may each be preferable
depending on the scenario and how to best express the intent of the
light setup.

For any described attribute *Fallback* *Value* or *Allowed* *Values*
below that are text/tokens, the actual token is published and defined
in UsdLuxTokens. So to set an attribute to the value"rightHanded", use
UsdLuxTokens->rightHanded as the value.

"""
   result["LightAPI"].__init__.func_doc = """__init__(connectable)


Constructor that takes a ConnectableAPI object.


Allow implicit conversion of a UsdShadeConnectableAPI to
UsdLuxLightAPI


Parameters
----------
connectable : ConnectableAPI



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

__init__(prim)


Construct a UsdLuxLightAPI on UsdPrim ``prim`` .


Equivalent to UsdLuxLightAPI::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxLightAPI on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxLightAPI (schemaObj.GetPrim()), as it
preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["LightAPI"].ConnectableAPI.func_doc = """ConnectableAPI() -> ConnectableAPI


Contructs and returns a UsdShadeConnectableAPI object with this light.


Note that most tasks can be accomplished without explicitly
constructing a UsdShadeConnectable API, since connection-related API
such as UsdShadeConnectableAPI::ConnectToSource() are static methods,
and UsdLuxLightAPI will auto-convert to a UsdShadeConnectableAPI when
passed to functions that want to act generically on a connectable
UsdShadeConnectableAPI object.



"""
   result["LightAPI"].CreateOutput.func_doc = """CreateOutput(name, typeName) -> Output


Create an output which can either have a value or can be connected.


The attribute representing the output is created in
the"outputs:"namespace. Outputs on a light cannot be connected, as
their value is assumed to be computed externally.


Parameters
----------
name : str

typeName : ValueTypeName


"""
   result["LightAPI"].GetOutput.func_doc = """GetOutput(name) -> Output


Return the requested output if it exists.


Parameters
----------
name : str


"""
   result["LightAPI"].GetOutputs.func_doc = """GetOutputs(onlyAuthored) -> list[Output]


Outputs are represented by attributes in the"outputs:"namespace.


If ``onlyAuthored`` is true (the default), then only return authored
attributes; otherwise, this also returns un-authored builtins.


Parameters
----------
onlyAuthored : bool


"""
   result["LightAPI"].CreateInput.func_doc = """CreateInput(name, typeName) -> Input


Create an input which can either have a value or can be connected.


The attribute representing the input is created in
the"inputs:"namespace. Inputs on lights are connectable.


Parameters
----------
name : str

typeName : ValueTypeName


"""
   result["LightAPI"].GetInput.func_doc = """GetInput(name) -> Input


Return the requested input if it exists.


Parameters
----------
name : str


"""
   result["LightAPI"].GetInputs.func_doc = """GetInputs(onlyAuthored) -> list[Input]


Inputs are represented by attributes in the"inputs:"namespace.


If ``onlyAuthored`` is true (the default), then only return authored
attributes; otherwise, this also returns un-authored builtins.


Parameters
----------
onlyAuthored : bool


"""
   result["LightAPI"].GetShaderIdAttr.func_doc = """GetShaderIdAttr() -> Attribute


Default ID for the light's shader.


This defines the shader ID for this light when a render context
specific shader ID is not available.

The default shaderId for the intrinsic UsdLux lights (RectLight,
DistantLight, etc.) are set to default to the light's type name. For
each intrinsic UsdLux light, we will always register an SdrShaderNode
in the SdrRegistry, with the identifier matching the type name and the
source type"USD", that corresponds to the light's inputs.

GetShaderId

GetShaderIdAttrForRenderContext

SdrRegistry::GetShaderNodeByIdentifier

SdrRegistry::GetShaderNodeByIdentifierAndType

Declaration

``uniform token light:shaderId =""``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token

Variability

SdfVariabilityUniform



"""
   result["LightAPI"].CreateShaderIdAttr.func_doc = """CreateShaderIdAttr(defaultValue, writeSparsely) -> Attribute


See GetShaderIdAttr() , 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


"""
   result["LightAPI"].GetMaterialSyncModeAttr.func_doc = """GetMaterialSyncModeAttr() -> Attribute


For a LightAPI applied to geometry that has a bound Material, which is
entirely or partly emissive, this specifies the relationship of the
Material response to the lighting response.


Valid values are:

   - materialGlowTintsLight: All primary and secondary rays see the
     emissive/glow response as dictated by the bound Material while the
     base color seen by light rays (which is then modulated by all of the
     other LightAPI controls) is the multiplication of the color feeding
     the emission/glow input of the Material (i.e. its surface or volume
     shader) with the scalar or pattern input to *inputs:color*. This
     allows the light's color to tint the geometry's glow color while
     preserving access to intensity and other light controls as ways to
     further modulate the illumination.

   - independent: All primary and secondary rays see the emissive/glow
     response as dictated by the bound Material, while the base color seen
     by light rays is determined solely by *inputs:color*. Note that for
     partially emissive geometry (in which some parts are reflective rather
     than emissive), a suitable pattern must be connected to the light's
     color input, or else the light will radiate uniformly from the
     geometry.

   - noMaterialResponse: The geometry behaves as if there is no
     Material bound at all, i.e. there is no diffuse, specular, or
     transmissive response. The base color of light rays is entirely
     controlled by the *inputs:color*. This is the standard mode
     for"canonical"lights in UsdLux and indicates to renderers that a
     Material will either never be bound or can always be ignored.

Declaration

``uniform token light:materialSyncMode ="noMaterialResponse"``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token

Variability

SdfVariabilityUniform

Allowed Values

materialGlowTintsLight, independent, noMaterialResponse



"""
   result["LightAPI"].CreateMaterialSyncModeAttr.func_doc = """CreateMaterialSyncModeAttr(defaultValue, writeSparsely) -> Attribute


See GetMaterialSyncModeAttr() , 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


"""
   result["LightAPI"].GetIntensityAttr.func_doc = """GetIntensityAttr() -> Attribute


Scales the power of the light linearly.



Declaration

``float inputs:intensity = 1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["LightAPI"].CreateIntensityAttr.func_doc = """CreateIntensityAttr(defaultValue, writeSparsely) -> Attribute


See GetIntensityAttr() , 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


"""
   result["LightAPI"].GetExposureAttr.func_doc = """GetExposureAttr() -> Attribute


Scales the power of the light exponentially as a power of 2 (similar
to an F-stop control over exposure).


The result is multiplied against the intensity.

Declaration

``float inputs:exposure = 0``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["LightAPI"].CreateExposureAttr.func_doc = """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


"""
   result["LightAPI"].GetDiffuseAttr.func_doc = """GetDiffuseAttr() -> Attribute


A multiplier for the effect of this light on the diffuse response of
materials.


This is a non-physical control.

Declaration

``float inputs:diffuse = 1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["LightAPI"].CreateDiffuseAttr.func_doc = """CreateDiffuseAttr(defaultValue, writeSparsely) -> Attribute


See GetDiffuseAttr() , 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


"""
   result["LightAPI"].GetSpecularAttr.func_doc = """GetSpecularAttr() -> Attribute


A multiplier for the effect of this light on the specular response of
materials.


This is a non-physical control.

Declaration

``float inputs:specular = 1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["LightAPI"].CreateSpecularAttr.func_doc = """CreateSpecularAttr(defaultValue, writeSparsely) -> Attribute


See GetSpecularAttr() , 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


"""
   result["LightAPI"].GetNormalizeAttr.func_doc = """GetNormalizeAttr() -> Attribute


Normalizes power by the surface area of the light.


This makes it easier to independently adjust the power and shape of
the light, by causing the power to not vary with the area or angular
size of the light.

Declaration

``bool inputs:normalize = 0``

C++ Type

bool

Usd Type

SdfValueTypeNames->Bool



"""
   result["LightAPI"].CreateNormalizeAttr.func_doc = """CreateNormalizeAttr(defaultValue, writeSparsely) -> Attribute


See GetNormalizeAttr() , 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


"""
   result["LightAPI"].GetColorAttr.func_doc = """GetColorAttr() -> Attribute


The color of emitted light, in energy-linear terms.



Declaration

``color3f inputs:color = (1, 1, 1)``

C++ Type

GfVec3f

Usd Type

SdfValueTypeNames->Color3f



"""
   result["LightAPI"].CreateColorAttr.func_doc = """CreateColorAttr(defaultValue, writeSparsely) -> Attribute


See GetColorAttr() , 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


"""
   result["LightAPI"].GetEnableColorTemperatureAttr.func_doc = """GetEnableColorTemperatureAttr() -> Attribute


Enables using colorTemperature.



Declaration

``bool inputs:enableColorTemperature = 0``

C++ Type

bool

Usd Type

SdfValueTypeNames->Bool



"""
   result["LightAPI"].CreateEnableColorTemperatureAttr.func_doc = """CreateEnableColorTemperatureAttr(defaultValue, writeSparsely) -> Attribute


See GetEnableColorTemperatureAttr() , 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


"""
   result["LightAPI"].GetColorTemperatureAttr.func_doc = """GetColorTemperatureAttr() -> Attribute


Color temperature, in degrees Kelvin, representing the white point.


The default is a common white point, D65. Lower values are warmer and
higher values are cooler. The valid range is from 1000 to 10000. Only
takes effect when enableColorTemperature is set to true. When active,
the computed result multiplies against the color attribute. See
UsdLuxBlackbodyTemperatureAsRgb() .

Declaration

``float inputs:colorTemperature = 6500``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["LightAPI"].CreateColorTemperatureAttr.func_doc = """CreateColorTemperatureAttr(defaultValue, writeSparsely) -> Attribute


See GetColorTemperatureAttr() , 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


"""
   result["LightAPI"].GetFiltersRel.func_doc = """GetFiltersRel() -> Relationship


Relationship to the light filters that apply to this light.



"""
   result["LightAPI"].CreateFiltersRel.func_doc = """CreateFiltersRel() -> Relationship


See GetFiltersRel() , and also Create vs Get Property Methods for when
to use Get vs Create.



"""
   result["LightAPI"].GetLightLinkCollectionAPI.func_doc = """GetLightLinkCollectionAPI() -> CollectionAPI


Return the UsdCollectionAPI interface used for examining and modifying
the light-linking of this light.


Light-linking controls which geometry this light illuminates.



"""
   result["LightAPI"].GetShadowLinkCollectionAPI.func_doc = """GetShadowLinkCollectionAPI() -> CollectionAPI


Return the UsdCollectionAPI interface used for examining and modifying
the shadow-linking of this light.


Shadow-linking controls which geometry casts shadows from this light.



"""
   result["LightAPI"].GetShaderIdAttrForRenderContext.func_doc = """GetShaderIdAttrForRenderContext(renderContext) -> Attribute


Returns the shader ID attribute for the given ``renderContext`` .


If ``renderContext`` is non-empty, this will try to return an
attribute named *light:shaderId* with the namespace prefix
``renderContext`` . For example, if the passed in render context
is"ri"then the attribute returned by this function would have the
following signature:

Declaration

``token ri:light:shaderId``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token

If the render context is empty, this will return the default shader ID
attribute as returned by GetShaderIdAttr() .


Parameters
----------
renderContext : str


"""
   result["LightAPI"].CreateShaderIdAttrForRenderContext.func_doc = """CreateShaderIdAttrForRenderContext(renderContext, defaultValue, writeSparsely) -> Attribute


Creates the shader ID attribute for the given ``renderContext`` .


See GetShaderIdAttrForRenderContext() , 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
----------
renderContext : str

defaultValue : VtValue

writeSparsely : bool


"""
   result["LightAPI"].GetShaderId.func_doc = """GetShaderId(renderContexts) -> str


Return the light's shader ID for the given list of available
``renderContexts`` .


The shader ID returned by this function is the identifier to use when
looking up the shader definition for this light in the shader
registry.

The render contexts are expected to be listed in priority order, so
for each render context provided, this will try to find the shader ID
attribute specific to that render context (see
GetShaderIdAttrForRenderContext() ) and will return the value of the
first one found that has a non-empty value. If no shader ID value can
be found for any of the given render contexts or ``renderContexts`` is
empty, then this will return the value of the default shader ID
attribute (see GetShaderIdAttr() ).


Parameters
----------
renderContexts : list[TfToken]


"""
   result["LightAPI"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["LightAPI"].Get.func_doc = """**classmethod** Get(stage, path) -> LightAPI


Return a UsdLuxLightAPI 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

  UsdLuxLightAPI(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["LightAPI"].CanApply.func_doc = """**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


"""
   result["LightAPI"].Apply.func_doc = """**classmethod** Apply(prim) -> LightAPI


Applies this **single-apply** API schema to the given ``prim`` .


This information is stored by adding"LightAPI"to the token-valued,
listOp metadata *apiSchemas* on the prim.

A valid UsdLuxLightAPI object is returned upon success. An invalid (or
empty) UsdLuxLightAPI 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


"""
   result["LightAPI"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["LightFilter"].__doc__ = """
A light filter modifies the effect of a light. Lights refer to filters
via relationships so that filters may be shared.

**Linking**

Filters can be linked to geometry. Linking controls which geometry a
light-filter affects, when considering the light filters attached to a
light illuminating the geometry.

Linking is specified as a collection (UsdCollectionAPI) which can be
accessed via GetFilterLinkCollection().

For any described attribute *Fallback* *Value* or *Allowed* *Values*
below that are text/tokens, the actual token is published and defined
in UsdLuxTokens. So to set an attribute to the value"rightHanded", use
UsdLuxTokens->rightHanded as the value.

"""
   result["LightFilter"].__init__.func_doc = """__init__(connectable)


Constructor that takes a ConnectableAPI object.


Allow implicit conversion of UsdShadeConnectableAPI to
UsdLuxLightFilter.


Parameters
----------
connectable : ConnectableAPI



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

__init__(prim)


Construct a UsdLuxLightFilter on UsdPrim ``prim`` .


Equivalent to UsdLuxLightFilter::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxLightFilter on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxLightFilter (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["LightFilter"].ConnectableAPI.func_doc = """ConnectableAPI() -> ConnectableAPI


Contructs and returns a UsdShadeConnectableAPI object with this light
filter.


Note that most tasks can be accomplished without explicitly
constructing a UsdShadeConnectable API, since connection-related API
such as UsdShadeConnectableAPI::ConnectToSource() are static methods,
and UsdLuxLightFilter will auto-convert to a UsdShadeConnectableAPI
when passed to functions that want to act generically on a connectable
UsdShadeConnectableAPI object.



"""
   result["LightFilter"].CreateOutput.func_doc = """CreateOutput(name, typeName) -> Output


Create an output which can either have a value or can be connected.


The attribute representing the output is created in
the"outputs:"namespace. Outputs on a light filter cannot be connected,
as their value is assumed to be computed externally.


Parameters
----------
name : str

typeName : ValueTypeName


"""
   result["LightFilter"].GetOutput.func_doc = """GetOutput(name) -> Output


Return the requested output if it exists.


Parameters
----------
name : str


"""
   result["LightFilter"].GetOutputs.func_doc = """GetOutputs(onlyAuthored) -> list[Output]


Outputs are represented by attributes in the"outputs:"namespace.


If ``onlyAuthored`` is true (the default), then only return authored
attributes; otherwise, this also returns un-authored builtins.


Parameters
----------
onlyAuthored : bool


"""
   result["LightFilter"].CreateInput.func_doc = """CreateInput(name, typeName) -> Input


Create an input which can either have a value or can be connected.


The attribute representing the input is created in
the"inputs:"namespace. Inputs on light filters are connectable.


Parameters
----------
name : str

typeName : ValueTypeName


"""
   result["LightFilter"].GetInput.func_doc = """GetInput(name) -> Input


Return the requested input if it exists.


Parameters
----------
name : str


"""
   result["LightFilter"].GetInputs.func_doc = """GetInputs(onlyAuthored) -> list[Input]


Inputs are represented by attributes in the"inputs:"namespace.


If ``onlyAuthored`` is true (the default), then only return authored
attributes; otherwise, this also returns un-authored builtins.


Parameters
----------
onlyAuthored : bool


"""
   result["LightFilter"].GetShaderIdAttr.func_doc = """GetShaderIdAttr() -> Attribute


Default ID for the light filter's shader.


This defines the shader ID for this light filter when a render context
specific shader ID is not available.

GetShaderId

GetShaderIdAttrForRenderContext

SdrRegistry::GetShaderNodeByIdentifier

SdrRegistry::GetShaderNodeByIdentifierAndType

Declaration

``uniform token lightFilter:shaderId =""``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token

Variability

SdfVariabilityUniform



"""
   result["LightFilter"].CreateShaderIdAttr.func_doc = """CreateShaderIdAttr(defaultValue, writeSparsely) -> Attribute


See GetShaderIdAttr() , 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


"""
   result["LightFilter"].GetFilterLinkCollectionAPI.func_doc = """GetFilterLinkCollectionAPI() -> CollectionAPI


Return the UsdCollectionAPI interface used for examining and modifying
the filter-linking of this light filter.


Linking controls which geometry this light filter affects.



"""
   result["LightFilter"].GetShaderIdAttrForRenderContext.func_doc = """GetShaderIdAttrForRenderContext(renderContext) -> Attribute


Returns the shader ID attribute for the given ``renderContext`` .


If ``renderContext`` is non-empty, this will try to return an
attribute named *lightFilter:shaderId* with the namespace prefix
``renderContext`` . For example, if the passed in render context
is"ri"then the attribute returned by this function would have the
following signature:

Declaration

``token ri:lightFilter:shaderId``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token

If the render context is empty, this will return the default shader ID
attribute as returned by GetShaderIdAttr() .


Parameters
----------
renderContext : str


"""
   result["LightFilter"].CreateShaderIdAttrForRenderContext.func_doc = """CreateShaderIdAttrForRenderContext(renderContext, defaultValue, writeSparsely) -> Attribute


Creates the shader ID attribute for the given ``renderContext`` .


See GetShaderIdAttrForRenderContext() , 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
----------
renderContext : str

defaultValue : VtValue

writeSparsely : bool


"""
   result["LightFilter"].GetShaderId.func_doc = """GetShaderId(renderContexts) -> str


Return the light filter's shader ID for the given list of available
``renderContexts`` .


The shader ID returned by this function is the identifier to use when
looking up the shader definition for this light filter in the shader
registry.

The render contexts are expected to be listed in priority order, so
for each render context provided, this will try to find the shader ID
attribute specific to that render context (see
GetShaderIdAttrForRenderContext() ) and will return the value of the
first one found that has a non-empty value. If no shader ID value can
be found for any of the given render contexts or ``renderContexts`` is
empty, then this will return the value of the default shader ID
attribute (see GetShaderIdAttr() ).


Parameters
----------
renderContexts : list[TfToken]


"""
   result["LightFilter"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["LightFilter"].Get.func_doc = """**classmethod** Get(stage, path) -> LightFilter


Return a UsdLuxLightFilter 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

  UsdLuxLightFilter(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["LightFilter"].Define.func_doc = """**classmethod** Define(stage, path) -> LightFilter


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


"""
   result["LightFilter"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["LightListAPI"].__doc__ = """
API schema to support discovery and publishing of lights in a scene.

Discovering Lights via Traversal
================================

To motivate this API, consider what is required to discover all lights
in a scene. We must load all payloads and traverse all prims:

.. code-block:: text

  01  // Load everything on the stage so we can find all lights,
  02  // including those inside payloads
  03  stage->Load();
  04  
  05  // Traverse all prims, checking if they have an applied UsdLuxLightAPI
  06  // (Note: ignoring instancing and a few other things for simplicity)
  07  SdfPathVector lights;
  08  for (UsdPrim prim: stage->Traverse()) {
  09      if (prim.HasAPI<UsdLuxLightAPI>()) {
  10          lights.push_back(i->GetPath());
  11      }
  12  }

This traversal  suitably elaborated to handle certain details  is the
first and simplest thing UsdLuxLightListAPI provides.
UsdLuxLightListAPI::ComputeLightList() performs this traversal and
returns all lights in the scene:

.. code-block:: text

  01  UsdLuxLightListAPI listAPI(stage->GetPseudoRoot());
  02  SdfPathVector lights = listAPI.ComputeLightList();

Publishing a Cached Light List
==============================

Consider a USD client that needs to quickly discover lights but wants
to defer loading payloads and traversing the entire scene where
possible, and is willing to do up-front computation and caching to
achieve that.

UsdLuxLightListAPI provides a way to cache the computed light list, by
publishing the list of lights onto prims in the model hierarchy.
Consider a big set that contains lights:

.. code-block:: text

  01  def Xform "BigSetWithLights" (
  02      kind = "assembly"
  03      payload = @BigSetWithLights.usd@   // Heavy payload
  04  ) {
  05      // Pre-computed, cached list of lights inside payload
  06      rel lightList = [
  07          <./Lights/light_1>,
  08          <./Lights/light_2>,
  09          \\.\\.\\.
  10      ]
  11      token lightList:cacheBehavior = "consumeAndContinue";
  12  }

The lightList relationship encodes a set of lights, and the
lightList:cacheBehavior property provides fine-grained control over
how to use that cache. (See details below.)

The cache can be created by first invoking
ComputeLightList(ComputeModeIgnoreCache) to pre-compute the list and
then storing the result with UsdLuxLightListAPI::StoreLightList() .

To enable efficient retrieval of the cache, it should be stored on a
model hierarchy prim. Furthermore, note that while you can use a
UsdLuxLightListAPI bound to the pseudo-root prim to query the lights
(as in the example above) because it will perform a traversal over
descendants, you cannot store the cache back to the pseduo-root prim.

To consult the cached list, we invoke
ComputeLightList(ComputeModeConsultModelHierarchyCache):

.. code-block:: text

  01  // Find and load all lights, using lightList cache where available
  02  UsdLuxLightListAPI list(stage->GetPseudoRoot());
  03  SdfPathSet lights = list.ComputeLightList(
  04      UsdLuxLightListAPI::ComputeModeConsultModelHierarchyCache);
  05  stage.LoadAndUnload(lights, SdfPathSet());

In this mode, ComputeLightList() will traverse the model hierarchy,
accumulating cached light lists.

Controlling Cache Behavior
==========================

The lightList:cacheBehavior property gives additional fine-grained
control over cache behavior:

   - The fallback value,"ignore", indicates that the lightList should
     be disregarded. This provides a way to invalidate cache entries. Note
     that unless"ignore"is specified, a lightList with an empty list of
     targets is considered a cache indicating that no lights are present.

   - The value"consumeAndContinue"indicates that the cache should be
     consulted to contribute lights to the scene, and that recursion should
     continue down the model hierarchy in case additional lights are added
     as descedants. This is the default value established when
     StoreLightList() is invoked. This behavior allows the lights within a
     large model, such as the BigSetWithLights example above, to be
     published outside the payload, while also allowing referencing and
     layering to add additional lights over that set.

   - The value"consumeAndHalt"provides a way to terminate recursive
     traversal of the scene for light discovery. The cache will be
     consulted but no descendant prims will be examined.

Instancing
==========

Where instances are present, UsdLuxLightListAPI::ComputeLightList()
will return the instance-unique paths to any lights discovered within
those instances. Lights within a UsdGeomPointInstancer will not be
returned, however, since they cannot be referred to solely via paths.

For any described attribute *Fallback* *Value* or *Allowed* *Values*
below that are text/tokens, the actual token is published and defined
in UsdLuxTokens. So to set an attribute to the value"rightHanded", use
UsdLuxTokens->rightHanded as the value.

"""
   result["LightListAPI"].ComputeMode.__doc__ = """
Runtime control over whether to consult stored lightList caches.

"""
   result["LightListAPI"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxLightListAPI on UsdPrim ``prim`` .


Equivalent to UsdLuxLightListAPI::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxLightListAPI on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxLightListAPI (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["LightListAPI"].GetLightListCacheBehaviorAttr.func_doc = """GetLightListCacheBehaviorAttr() -> Attribute


Controls how the lightList should be interpreted.


Valid values are:

   - consumeAndHalt: The lightList should be consulted, and if it
     exists, treated as a final authoritative statement of any lights that
     exist at or below this prim, halting recursive discovery of lights.

   - consumeAndContinue: The lightList should be consulted, but
     recursive traversal over nameChildren should continue in case
     additional lights are added by descendants.

   - ignore: The lightList should be entirely ignored. This provides a
     simple way to temporarily invalidate an existing cache. This is the
     fallback behavior.

Declaration

``token lightList:cacheBehavior``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token

Allowed Values

consumeAndHalt, consumeAndContinue, ignore



"""
   result["LightListAPI"].CreateLightListCacheBehaviorAttr.func_doc = """CreateLightListCacheBehaviorAttr(defaultValue, writeSparsely) -> Attribute


See GetLightListCacheBehaviorAttr() , 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


"""
   result["LightListAPI"].GetLightListRel.func_doc = """GetLightListRel() -> Relationship


Relationship to lights in the scene.



"""
   result["LightListAPI"].CreateLightListRel.func_doc = """CreateLightListRel() -> Relationship


See GetLightListRel() , and also Create vs Get Property Methods for
when to use Get vs Create.



"""
   result["LightListAPI"].ComputeLightList.func_doc = """ComputeLightList(mode) -> SdfPathSet


Computes and returns the list of lights and light filters in the
stage, optionally consulting a cached result.


In ComputeModeIgnoreCache mode, caching is ignored, and this does a
prim traversal looking for prims that have a UsdLuxLightAPI or are of
type UsdLuxLightFilter.

In ComputeModeConsultModelHierarchyCache, this does a traversal only
of the model hierarchy. In this traversal, any lights that live as
model hierarchy prims are accumulated, as well as any paths stored in
lightList caches. The lightList:cacheBehavior attribute gives further
control over the cache behavior; see the class overview for details.

When instances are present, ComputeLightList(ComputeModeIgnoreCache)
will return the instance-uniqiue paths to any lights discovered within
those instances. Lights within a UsdGeomPointInstancer will not be
returned, however, since they cannot be referred to solely via paths.


Parameters
----------
mode : ComputeMode


"""
   result["LightListAPI"].StoreLightList.func_doc = """StoreLightList(arg1) -> None


Store the given paths as the lightlist for this prim.


Paths that do not have this prim's path as a prefix will be silently
ignored. This will set the listList:cacheBehavior
to"consumeAndContinue".


Parameters
----------
arg1 : SdfPathSet


"""
   result["LightListAPI"].InvalidateLightList.func_doc = """InvalidateLightList() -> None


Mark any stored lightlist as invalid, by setting the
lightList:cacheBehavior attribute to ignore.



"""
   result["LightListAPI"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["LightListAPI"].Get.func_doc = """**classmethod** Get(stage, path) -> LightListAPI


Return a UsdLuxLightListAPI 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

  UsdLuxLightListAPI(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["LightListAPI"].CanApply.func_doc = """**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


"""
   result["LightListAPI"].Apply.func_doc = """**classmethod** Apply(prim) -> LightListAPI


Applies this **single-apply** API schema to the given ``prim`` .


This information is stored by adding"LightListAPI"to the token-valued,
listOp metadata *apiSchemas* on the prim.

A valid UsdLuxLightListAPI object is returned upon success. An invalid
(or empty) UsdLuxLightListAPI 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


"""
   result["LightListAPI"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["ListAPI"].__doc__ = """
Deprecated

Use LightListAPI instead

For any described attribute *Fallback* *Value* or *Allowed* *Values*
below that are text/tokens, the actual token is published and defined
in UsdLuxTokens. So to set an attribute to the value"rightHanded", use
UsdLuxTokens->rightHanded as the value.

"""
   result["ListAPI"].ComputeMode.__doc__ = """
Runtime control over whether to consult stored lightList caches.

"""
   result["ListAPI"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxListAPI on UsdPrim ``prim`` .


Equivalent to UsdLuxListAPI::Get (prim.GetStage(), prim.GetPath()) for
a *valid* ``prim`` , but will not immediately throw an error for an
invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxListAPI on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxListAPI (schemaObj.GetPrim()), as it
preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["ListAPI"].GetLightListCacheBehaviorAttr.func_doc = """GetLightListCacheBehaviorAttr() -> Attribute


Controls how the lightList should be interpreted.


Valid values are:

   - consumeAndHalt: The lightList should be consulted, and if it
     exists, treated as a final authoritative statement of any lights that
     exist at or below this prim, halting recursive discovery of lights.

   - consumeAndContinue: The lightList should be consulted, but
     recursive traversal over nameChildren should continue in case
     additional lights are added by descendants.

   - ignore: The lightList should be entirely ignored. This provides a
     simple way to temporarily invalidate an existing cache. This is the
     fallback behavior.

Declaration

``token lightList:cacheBehavior``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token

Allowed Values

consumeAndHalt, consumeAndContinue, ignore



"""
   result["ListAPI"].CreateLightListCacheBehaviorAttr.func_doc = """CreateLightListCacheBehaviorAttr(defaultValue, writeSparsely) -> Attribute


See GetLightListCacheBehaviorAttr() , 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


"""
   result["ListAPI"].GetLightListRel.func_doc = """GetLightListRel() -> Relationship


Relationship to lights in the scene.



"""
   result["ListAPI"].CreateLightListRel.func_doc = """CreateLightListRel() -> Relationship


See GetLightListRel() , and also Create vs Get Property Methods for
when to use Get vs Create.



"""
   result["ListAPI"].ComputeLightList.func_doc = """ComputeLightList(mode) -> SdfPathSet


Computes and returns the list of lights and light filters in the
stage, optionally consulting a cached result.


In ComputeModeIgnoreCache mode, caching is ignored, and this does a
prim traversal looking for prims that have a UsdLuxLightAPI or are of
type UsdLuxLightFilter.

In ComputeModeConsultModelHierarchyCache, this does a traversal only
of the model hierarchy. In this traversal, any lights that live as
model hierarchy prims are accumulated, as well as any paths stored in
lightList caches. The lightList:cacheBehavior attribute gives further
control over the cache behavior; see the class overview for details.

When instances are present, ComputeLightList(ComputeModeIgnoreCache)
will return the instance-uniqiue paths to any lights discovered within
those instances. Lights within a UsdGeomPointInstancer will not be
returned, however, since they cannot be referred to solely via paths.


Parameters
----------
mode : ComputeMode


"""
   result["ListAPI"].StoreLightList.func_doc = """StoreLightList(arg1) -> None


Store the given paths as the lightlist for this prim.


Paths that do not have this prim's path as a prefix will be silently
ignored. This will set the listList:cacheBehavior
to"consumeAndContinue".


Parameters
----------
arg1 : SdfPathSet


"""
   result["ListAPI"].InvalidateLightList.func_doc = """InvalidateLightList() -> None


Mark any stored lightlist as invalid, by setting the
lightList:cacheBehavior attribute to ignore.



"""
   result["ListAPI"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["ListAPI"].Get.func_doc = """**classmethod** Get(stage, path) -> ListAPI


Return a UsdLuxListAPI 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

  UsdLuxListAPI(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["ListAPI"].CanApply.func_doc = """**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


"""
   result["ListAPI"].Apply.func_doc = """**classmethod** Apply(prim) -> ListAPI


Applies this **single-apply** API schema to the given ``prim`` .


This information is stored by adding"ListAPI"to the token-valued,
listOp metadata *apiSchemas* on the prim.

A valid UsdLuxListAPI object is returned upon success. An invalid (or
empty) UsdLuxListAPI 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


"""
   result["ListAPI"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["MeshLightAPI"].__doc__ = """
This is the preferred API schema to apply to Mesh type prims when
adding light behaviors to a mesh. At its base, this API schema has the
built-in behavior of applying LightAPI to the mesh and overriding the
default materialSyncMode to allow the emission/glow of the bound
material to affect the color of the light. But, it additionally serves
as a hook for plugins to attach additional properties to"mesh
lights"through the creation of API schemas which are authored to auto-
apply to MeshLightAPI.

Auto applied API schemas

"""
   result["MeshLightAPI"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxMeshLightAPI on UsdPrim ``prim`` .


Equivalent to UsdLuxMeshLightAPI::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxMeshLightAPI on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxMeshLightAPI (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["MeshLightAPI"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["MeshLightAPI"].Get.func_doc = """**classmethod** Get(stage, path) -> MeshLightAPI


Return a UsdLuxMeshLightAPI 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

  UsdLuxMeshLightAPI(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["MeshLightAPI"].CanApply.func_doc = """**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


"""
   result["MeshLightAPI"].Apply.func_doc = """**classmethod** Apply(prim) -> MeshLightAPI


Applies this **single-apply** API schema to the given ``prim`` .


This information is stored by adding"MeshLightAPI"to the token-valued,
listOp metadata *apiSchemas* on the prim.

A valid UsdLuxMeshLightAPI object is returned upon success. An invalid
(or empty) UsdLuxMeshLightAPI 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


"""
   result["MeshLightAPI"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["NonboundableLightBase"].__doc__ = """
Base class for intrinsic lights that are not boundable.

The primary purpose of this class is to provide a direct API to the
functions provided by LightAPI for concrete derived light types.

"""
   result["NonboundableLightBase"].LightAPI.func_doc = """LightAPI() -> LightAPI


Contructs and returns a UsdLuxLightAPI object for this light.



"""
   result["NonboundableLightBase"].GetIntensityAttr.func_doc = """GetIntensityAttr() -> Attribute


See UsdLuxLightAPI::GetIntensityAttr() .



"""
   result["NonboundableLightBase"].CreateIntensityAttr.func_doc = """CreateIntensityAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateIntensityAttr() .


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

writeSparsely : bool


"""
   result["NonboundableLightBase"].GetExposureAttr.func_doc = """GetExposureAttr() -> Attribute


See UsdLuxLightAPI::GetExposureAttr() .



"""
   result["NonboundableLightBase"].CreateExposureAttr.func_doc = """CreateExposureAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateExposureAttr() .


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

writeSparsely : bool


"""
   result["NonboundableLightBase"].GetDiffuseAttr.func_doc = """GetDiffuseAttr() -> Attribute


See UsdLuxLightAPI::GetDiffuseAttr() .



"""
   result["NonboundableLightBase"].CreateDiffuseAttr.func_doc = """CreateDiffuseAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateDiffuseAttr() .


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

writeSparsely : bool


"""
   result["NonboundableLightBase"].GetSpecularAttr.func_doc = """GetSpecularAttr() -> Attribute


See UsdLuxLightAPI::GetSpecularAttr() .



"""
   result["NonboundableLightBase"].CreateSpecularAttr.func_doc = """CreateSpecularAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateSpecularAttr() .


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

writeSparsely : bool


"""
   result["NonboundableLightBase"].GetNormalizeAttr.func_doc = """GetNormalizeAttr() -> Attribute


See UsdLuxLightAPI::GetNormalizeAttr() .



"""
   result["NonboundableLightBase"].CreateNormalizeAttr.func_doc = """CreateNormalizeAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateNormalizeAttr() .


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

writeSparsely : bool


"""
   result["NonboundableLightBase"].GetColorAttr.func_doc = """GetColorAttr() -> Attribute


See UsdLuxLightAPI::GetColorAttr() .



"""
   result["NonboundableLightBase"].CreateColorAttr.func_doc = """CreateColorAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateColorAttr() .


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

writeSparsely : bool


"""
   result["NonboundableLightBase"].GetEnableColorTemperatureAttr.func_doc = """GetEnableColorTemperatureAttr() -> Attribute


See UsdLuxLightAPI::GetEnableColorTemperatureAttr() .



"""
   result["NonboundableLightBase"].CreateEnableColorTemperatureAttr.func_doc = """CreateEnableColorTemperatureAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateEnableColorTemperatureAttr() .


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

writeSparsely : bool


"""
   result["NonboundableLightBase"].GetColorTemperatureAttr.func_doc = """GetColorTemperatureAttr() -> Attribute


See UsdLuxLightAPI::GetColorTemperatureAttr() .



"""
   result["NonboundableLightBase"].CreateColorTemperatureAttr.func_doc = """CreateColorTemperatureAttr(defaultValue, writeSparsely) -> Attribute


See UsdLuxLightAPI::CreateColorTemperatureAttr() .


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

writeSparsely : bool


"""
   result["NonboundableLightBase"].GetFiltersRel.func_doc = """GetFiltersRel() -> Relationship


See UsdLuxLightAPI::GetFiltersRel() .



"""
   result["NonboundableLightBase"].CreateFiltersRel.func_doc = """CreateFiltersRel() -> Relationship


See UsdLuxLightAPI::CreateFiltersRel() .



"""
   result["NonboundableLightBase"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxNonboundableLightBase on UsdPrim ``prim`` .


Equivalent to UsdLuxNonboundableLightBase::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxNonboundableLightBase on the prim held by
``schemaObj`` .


Should be preferred over UsdLuxNonboundableLightBase
(schemaObj.GetPrim()), as it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["NonboundableLightBase"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["NonboundableLightBase"].Get.func_doc = """**classmethod** Get(stage, path) -> NonboundableLightBase


Return a UsdLuxNonboundableLightBase 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

  UsdLuxNonboundableLightBase(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["NonboundableLightBase"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["PluginLight"].__doc__ = """
Light that provides properties that allow it to identify an external
SdrShadingNode definition, through UsdShadeNodeDefAPI, that can be
provided to render delegates without the need to provide a schema
definition for the light's type.

Plugin Lights and Light Filters

"""
   result["PluginLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxPluginLight on UsdPrim ``prim`` .


Equivalent to UsdLuxPluginLight::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxPluginLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxPluginLight (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["PluginLight"].GetNodeDefAPI.func_doc = """GetNodeDefAPI() -> NodeDefAPI


Convenience method for accessing the UsdShadeNodeDefAPI functionality
for this prim.


One can also construct a UsdShadeNodeDefAPI directly from a UsdPrim.



"""
   result["PluginLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["PluginLight"].Get.func_doc = """**classmethod** Get(stage, path) -> PluginLight


Return a UsdLuxPluginLight 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

  UsdLuxPluginLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["PluginLight"].Define.func_doc = """**classmethod** Define(stage, path) -> PluginLight


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


"""
   result["PluginLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["PluginLightFilter"].__doc__ = """
Light filter that provides properties that allow it to identify an
external SdrShadingNode definition, through UsdShadeNodeDefAPI, that
can be provided to render delegates without the need to provide a
schema definition for the light filter's type.

Plugin Lights and Light Filters

"""
   result["PluginLightFilter"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxPluginLightFilter on UsdPrim ``prim`` .


Equivalent to UsdLuxPluginLightFilter::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxPluginLightFilter on the prim held by ``schemaObj``
.


Should be preferred over UsdLuxPluginLightFilter
(schemaObj.GetPrim()), as it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["PluginLightFilter"].GetNodeDefAPI.func_doc = """GetNodeDefAPI() -> NodeDefAPI


Convenience method for accessing the UsdShadeNodeDefAPI functionality
for this prim.


One can also construct a UsdShadeNodeDefAPI directly from a UsdPrim.



"""
   result["PluginLightFilter"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["PluginLightFilter"].Get.func_doc = """**classmethod** Get(stage, path) -> PluginLightFilter


Return a UsdLuxPluginLightFilter 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

  UsdLuxPluginLightFilter(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["PluginLightFilter"].Define.func_doc = """**classmethod** Define(stage, path) -> PluginLightFilter


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


"""
   result["PluginLightFilter"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["PortalLight"].__doc__ = """
A rectangular portal in the local XY plane that guides sampling of a
dome light. Transmits light in the -Z direction. The rectangle is 1
unit in length.

"""
   result["PortalLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxPortalLight on UsdPrim ``prim`` .


Equivalent to UsdLuxPortalLight::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxPortalLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxPortalLight (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["PortalLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["PortalLight"].Get.func_doc = """**classmethod** Get(stage, path) -> PortalLight


Return a UsdLuxPortalLight 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

  UsdLuxPortalLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["PortalLight"].Define.func_doc = """**classmethod** Define(stage, path) -> PortalLight


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


"""
   result["PortalLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["RectLight"].__doc__ = """
Light emitted from one side of a rectangle. The rectangle is centered
in the XY plane and emits light along the -Z axis. The rectangle is 1
unit in length in the X and Y axis. In the default position, a texture
file's min coordinates should be at (+X, +Y) and max coordinates at
(-X, -Y).

"""
   result["RectLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxRectLight on UsdPrim ``prim`` .


Equivalent to UsdLuxRectLight::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxRectLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxRectLight (schemaObj.GetPrim()), as it
preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["RectLight"].GetWidthAttr.func_doc = """GetWidthAttr() -> Attribute


Width of the rectangle, in the local X axis.



Declaration

``float inputs:width = 1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["RectLight"].CreateWidthAttr.func_doc = """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


"""
   result["RectLight"].GetHeightAttr.func_doc = """GetHeightAttr() -> Attribute


Height of the rectangle, in the local Y axis.



Declaration

``float inputs:height = 1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["RectLight"].CreateHeightAttr.func_doc = """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


"""
   result["RectLight"].GetTextureFileAttr.func_doc = """GetTextureFileAttr() -> Attribute


A color texture to use on the rectangle.



Declaration

``asset inputs:texture:file``

C++ Type

SdfAssetPath

Usd Type

SdfValueTypeNames->Asset



"""
   result["RectLight"].CreateTextureFileAttr.func_doc = """CreateTextureFileAttr(defaultValue, writeSparsely) -> Attribute


See GetTextureFileAttr() , 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


"""
   result["RectLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["RectLight"].Get.func_doc = """**classmethod** Get(stage, path) -> RectLight


Return a UsdLuxRectLight 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

  UsdLuxRectLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["RectLight"].Define.func_doc = """**classmethod** Define(stage, path) -> RectLight


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


"""
   result["RectLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["ShadowAPI"].__doc__ = """
Controls to refine a light's shadow behavior. These are non-physical
controls that are valuable for visual lighting work.

"""
   result["ShadowAPI"].__init__.func_doc = """__init__(connectable)


Constructor that takes a ConnectableAPI object.


Allow implicit conversion of UsdShadeConnectableAPI to
UsdLuxShadowAPI.


Parameters
----------
connectable : ConnectableAPI



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

__init__(prim)


Construct a UsdLuxShadowAPI on UsdPrim ``prim`` .


Equivalent to UsdLuxShadowAPI::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxShadowAPI on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxShadowAPI (schemaObj.GetPrim()), as it
preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["ShadowAPI"].ConnectableAPI.func_doc = """ConnectableAPI() -> ConnectableAPI


Contructs and returns a UsdShadeConnectableAPI object with this shadow
API prim.


Note that a valid UsdLuxShadowAPI will only return a valid
UsdShadeConnectableAPI if the its prim's Typed schema type is actually
connectable.



"""
   result["ShadowAPI"].CreateOutput.func_doc = """CreateOutput(name, typeName) -> Output


Create an output which can either have a value or can be connected.


The attribute representing the output is created in
the"outputs:"namespace. Outputs on a shadow API cannot be connected,
as their value is assumed to be computed externally.


Parameters
----------
name : str

typeName : ValueTypeName


"""
   result["ShadowAPI"].GetOutput.func_doc = """GetOutput(name) -> Output


Return the requested output if it exists.


Parameters
----------
name : str


"""
   result["ShadowAPI"].GetOutputs.func_doc = """GetOutputs(onlyAuthored) -> list[Output]


Outputs are represented by attributes in the"outputs:"namespace.


If ``onlyAuthored`` is true (the default), then only return authored
attributes; otherwise, this also returns un-authored builtins.


Parameters
----------
onlyAuthored : bool


"""
   result["ShadowAPI"].CreateInput.func_doc = """CreateInput(name, typeName) -> Input


Create an input which can either have a value or can be connected.


The attribute representing the input is created in
the"inputs:"namespace. Inputs on shadow API are connectable.


Parameters
----------
name : str

typeName : ValueTypeName


"""
   result["ShadowAPI"].GetInput.func_doc = """GetInput(name) -> Input


Return the requested input if it exists.


Parameters
----------
name : str


"""
   result["ShadowAPI"].GetInputs.func_doc = """GetInputs(onlyAuthored) -> list[Input]


Inputs are represented by attributes in the"inputs:"namespace.


If ``onlyAuthored`` is true (the default), then only return authored
attributes; otherwise, this also returns un-authored builtins.


Parameters
----------
onlyAuthored : bool


"""
   result["ShadowAPI"].GetShadowEnableAttr.func_doc = """GetShadowEnableAttr() -> Attribute


Enables shadows to be cast by this light.



Declaration

``bool inputs:shadow:enable = 1``

C++ Type

bool

Usd Type

SdfValueTypeNames->Bool



"""
   result["ShadowAPI"].CreateShadowEnableAttr.func_doc = """CreateShadowEnableAttr(defaultValue, writeSparsely) -> Attribute


See GetShadowEnableAttr() , 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


"""
   result["ShadowAPI"].GetShadowColorAttr.func_doc = """GetShadowColorAttr() -> Attribute


The color of shadows cast by the light.


This is a non-physical control. The default is to cast black shadows.

Declaration

``color3f inputs:shadow:color = (0, 0, 0)``

C++ Type

GfVec3f

Usd Type

SdfValueTypeNames->Color3f



"""
   result["ShadowAPI"].CreateShadowColorAttr.func_doc = """CreateShadowColorAttr(defaultValue, writeSparsely) -> Attribute


See GetShadowColorAttr() , 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


"""
   result["ShadowAPI"].GetShadowDistanceAttr.func_doc = """GetShadowDistanceAttr() -> Attribute


The maximum distance shadows are cast.


The default value (-1) indicates no limit.

Declaration

``float inputs:shadow:distance = -1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["ShadowAPI"].CreateShadowDistanceAttr.func_doc = """CreateShadowDistanceAttr(defaultValue, writeSparsely) -> Attribute


See GetShadowDistanceAttr() , 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


"""
   result["ShadowAPI"].GetShadowFalloffAttr.func_doc = """GetShadowFalloffAttr() -> Attribute


The near distance at which shadow falloff begins.


The default value (-1) indicates no falloff.

Declaration

``float inputs:shadow:falloff = -1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["ShadowAPI"].CreateShadowFalloffAttr.func_doc = """CreateShadowFalloffAttr(defaultValue, writeSparsely) -> Attribute


See GetShadowFalloffAttr() , 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


"""
   result["ShadowAPI"].GetShadowFalloffGammaAttr.func_doc = """GetShadowFalloffGammaAttr() -> Attribute


A gamma (i.e., exponential) control over shadow strength with linear
distance within the falloff zone.


This requires the use of shadowDistance and shadowFalloff.

Declaration

``float inputs:shadow:falloffGamma = 1``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["ShadowAPI"].CreateShadowFalloffGammaAttr.func_doc = """CreateShadowFalloffGammaAttr(defaultValue, writeSparsely) -> Attribute


See GetShadowFalloffGammaAttr() , 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


"""
   result["ShadowAPI"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["ShadowAPI"].Get.func_doc = """**classmethod** Get(stage, path) -> ShadowAPI


Return a UsdLuxShadowAPI 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

  UsdLuxShadowAPI(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["ShadowAPI"].CanApply.func_doc = """**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


"""
   result["ShadowAPI"].Apply.func_doc = """**classmethod** Apply(prim) -> ShadowAPI


Applies this **single-apply** API schema to the given ``prim`` .


This information is stored by adding"ShadowAPI"to the token-valued,
listOp metadata *apiSchemas* on the prim.

A valid UsdLuxShadowAPI object is returned upon success. An invalid
(or empty) UsdLuxShadowAPI 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


"""
   result["ShadowAPI"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["ShapingAPI"].__doc__ = """
Controls for shaping a light's emission.

"""
   result["ShapingAPI"].__init__.func_doc = """__init__(connectable)


Constructor that takes a ConnectableAPI object.


Allow implicit conversion of UsdShadeConnectableAPI to
UsdLuxShapingAPI.


Parameters
----------
connectable : ConnectableAPI



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

__init__(prim)


Construct a UsdLuxShapingAPI on UsdPrim ``prim`` .


Equivalent to UsdLuxShapingAPI::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxShapingAPI on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxShapingAPI (schemaObj.GetPrim()), as it
preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["ShapingAPI"].ConnectableAPI.func_doc = """ConnectableAPI() -> ConnectableAPI


Contructs and returns a UsdShadeConnectableAPI object with this
shaping API prim.


Note that a valid UsdLuxShapingAPI will only return a valid
UsdShadeConnectableAPI if the its prim's Typed schema type is actually
connectable.



"""
   result["ShapingAPI"].CreateOutput.func_doc = """CreateOutput(name, typeName) -> Output


Create an output which can either have a value or can be connected.


The attribute representing the output is created in
the"outputs:"namespace. Outputs on a shaping API cannot be connected,
as their value is assumed to be computed externally.


Parameters
----------
name : str

typeName : ValueTypeName


"""
   result["ShapingAPI"].GetOutput.func_doc = """GetOutput(name) -> Output


Return the requested output if it exists.


Parameters
----------
name : str


"""
   result["ShapingAPI"].GetOutputs.func_doc = """GetOutputs(onlyAuthored) -> list[Output]


Outputs are represented by attributes in the"outputs:"namespace.


If ``onlyAuthored`` is true (the default), then only return authored
attributes; otherwise, this also returns un-authored builtins.


Parameters
----------
onlyAuthored : bool


"""
   result["ShapingAPI"].CreateInput.func_doc = """CreateInput(name, typeName) -> Input


Create an input which can either have a value or can be connected.


The attribute representing the input is created in
the"inputs:"namespace. Inputs on shaping API are connectable.


Parameters
----------
name : str

typeName : ValueTypeName


"""
   result["ShapingAPI"].GetInput.func_doc = """GetInput(name) -> Input


Return the requested input if it exists.


Parameters
----------
name : str


"""
   result["ShapingAPI"].GetInputs.func_doc = """GetInputs(onlyAuthored) -> list[Input]


Inputs are represented by attributes in the"inputs:"namespace.


If ``onlyAuthored`` is true (the default), then only return authored
attributes; otherwise, this also returns un-authored builtins.


Parameters
----------
onlyAuthored : bool


"""
   result["ShapingAPI"].GetShapingFocusAttr.func_doc = """GetShapingFocusAttr() -> Attribute


A control to shape the spread of light.


Higher focus values pull light towards the center and narrow the
spread. Implemented as an off-axis cosine power exponent. TODO:
clarify semantics

Declaration

``float inputs:shaping:focus = 0``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["ShapingAPI"].CreateShapingFocusAttr.func_doc = """CreateShapingFocusAttr(defaultValue, writeSparsely) -> Attribute


See GetShapingFocusAttr() , 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


"""
   result["ShapingAPI"].GetShapingFocusTintAttr.func_doc = """GetShapingFocusTintAttr() -> Attribute


Off-axis color tint.


This tints the emission in the falloff region. The default tint is
black. TODO: clarify semantics

Declaration

``color3f inputs:shaping:focusTint = (0, 0, 0)``

C++ Type

GfVec3f

Usd Type

SdfValueTypeNames->Color3f



"""
   result["ShapingAPI"].CreateShapingFocusTintAttr.func_doc = """CreateShapingFocusTintAttr(defaultValue, writeSparsely) -> Attribute


See GetShapingFocusTintAttr() , 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


"""
   result["ShapingAPI"].GetShapingConeAngleAttr.func_doc = """GetShapingConeAngleAttr() -> Attribute


Angular limit off the primary axis to restrict the light spread.



Declaration

``float inputs:shaping:cone:angle = 90``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["ShapingAPI"].CreateShapingConeAngleAttr.func_doc = """CreateShapingConeAngleAttr(defaultValue, writeSparsely) -> Attribute


See GetShapingConeAngleAttr() , 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


"""
   result["ShapingAPI"].GetShapingConeSoftnessAttr.func_doc = """GetShapingConeSoftnessAttr() -> Attribute


Controls the cutoff softness for cone angle.


TODO: clarify semantics

Declaration

``float inputs:shaping:cone:softness = 0``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["ShapingAPI"].CreateShapingConeSoftnessAttr.func_doc = """CreateShapingConeSoftnessAttr(defaultValue, writeSparsely) -> Attribute


See GetShapingConeSoftnessAttr() , 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


"""
   result["ShapingAPI"].GetShapingIesFileAttr.func_doc = """GetShapingIesFileAttr() -> Attribute


An IES (Illumination Engineering Society) light profile describing the
angular distribution of light.



Declaration

``asset inputs:shaping:ies:file``

C++ Type

SdfAssetPath

Usd Type

SdfValueTypeNames->Asset



"""
   result["ShapingAPI"].CreateShapingIesFileAttr.func_doc = """CreateShapingIesFileAttr(defaultValue, writeSparsely) -> Attribute


See GetShapingIesFileAttr() , 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


"""
   result["ShapingAPI"].GetShapingIesAngleScaleAttr.func_doc = """GetShapingIesAngleScaleAttr() -> Attribute


Rescales the angular distribution of the IES profile.


TODO: clarify semantics

Declaration

``float inputs:shaping:ies:angleScale = 0``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["ShapingAPI"].CreateShapingIesAngleScaleAttr.func_doc = """CreateShapingIesAngleScaleAttr(defaultValue, writeSparsely) -> Attribute


See GetShapingIesAngleScaleAttr() , 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


"""
   result["ShapingAPI"].GetShapingIesNormalizeAttr.func_doc = """GetShapingIesNormalizeAttr() -> Attribute


Normalizes the IES profile so that it affects the shaping of the light
while preserving the overall energy output.



Declaration

``bool inputs:shaping:ies:normalize = 0``

C++ Type

bool

Usd Type

SdfValueTypeNames->Bool



"""
   result["ShapingAPI"].CreateShapingIesNormalizeAttr.func_doc = """CreateShapingIesNormalizeAttr(defaultValue, writeSparsely) -> Attribute


See GetShapingIesNormalizeAttr() , 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


"""
   result["ShapingAPI"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["ShapingAPI"].Get.func_doc = """**classmethod** Get(stage, path) -> ShapingAPI


Return a UsdLuxShapingAPI 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

  UsdLuxShapingAPI(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["ShapingAPI"].CanApply.func_doc = """**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


"""
   result["ShapingAPI"].Apply.func_doc = """**classmethod** Apply(prim) -> ShapingAPI


Applies this **single-apply** API schema to the given ``prim`` .


This information is stored by adding"ShapingAPI"to the token-valued,
listOp metadata *apiSchemas* on the prim.

A valid UsdLuxShapingAPI object is returned upon success. An invalid
(or empty) UsdLuxShapingAPI 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


"""
   result["ShapingAPI"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["SphereLight"].__doc__ = """
Light emitted outward from a sphere.

"""
   result["SphereLight"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxSphereLight on UsdPrim ``prim`` .


Equivalent to UsdLuxSphereLight::Get (prim.GetStage(), prim.GetPath())
for a *valid* ``prim`` , but will not immediately throw an error for
an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxSphereLight on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxSphereLight (schemaObj.GetPrim()), as
it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["SphereLight"].GetRadiusAttr.func_doc = """GetRadiusAttr() -> Attribute


Radius of the sphere.



Declaration

``float inputs:radius = 0.5``

C++ Type

float

Usd Type

SdfValueTypeNames->Float



"""
   result["SphereLight"].CreateRadiusAttr.func_doc = """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


"""
   result["SphereLight"].GetTreatAsPointAttr.func_doc = """GetTreatAsPointAttr() -> Attribute


A hint that this light can be treated as a'point'light (effectively, a
zero-radius sphere) by renderers that benefit from non-area lighting.


Renderers that only support area lights can disregard this.

Declaration

``bool treatAsPoint = 0``

C++ Type

bool

Usd Type

SdfValueTypeNames->Bool



"""
   result["SphereLight"].CreateTreatAsPointAttr.func_doc = """CreateTreatAsPointAttr(defaultValue, writeSparsely) -> Attribute


See GetTreatAsPointAttr() , 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


"""
   result["SphereLight"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["SphereLight"].Get.func_doc = """**classmethod** Get(stage, path) -> SphereLight


Return a UsdLuxSphereLight 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

  UsdLuxSphereLight(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["SphereLight"].Define.func_doc = """**classmethod** Define(stage, path) -> SphereLight


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


"""
   result["SphereLight"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""
   result["VolumeLightAPI"].__doc__ = """
This is the preferred API schema to apply to Volume type prims when
adding light behaviors to a volume. At its base, this API schema has
the built-in behavior of applying LightAPI to the volume and
overriding the default materialSyncMode to allow the emission/glow of
the bound material to affect the color of the light. But, it
additionally serves as a hook for plugins to attach additional
properties to"volume lights"through the creation of API schemas which
are authored to auto-apply to VolumeLightAPI.

Auto applied API schemas

"""
   result["VolumeLightAPI"].__init__.func_doc = """__init__(prim)


Construct a UsdLuxVolumeLightAPI on UsdPrim ``prim`` .


Equivalent to UsdLuxVolumeLightAPI::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


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



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

__init__(schemaObj)


Construct a UsdLuxVolumeLightAPI on the prim held by ``schemaObj`` .


Should be preferred over UsdLuxVolumeLightAPI (schemaObj.GetPrim()),
as it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["VolumeLightAPI"].GetSchemaAttributeNames.func_doc = """**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


"""
   result["VolumeLightAPI"].Get.func_doc = """**classmethod** Get(stage, path) -> VolumeLightAPI


Return a UsdLuxVolumeLightAPI 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

  UsdLuxVolumeLightAPI(stage->GetPrimAtPath(path));



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

path : Path


"""
   result["VolumeLightAPI"].CanApply.func_doc = """**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


"""
   result["VolumeLightAPI"].Apply.func_doc = """**classmethod** Apply(prim) -> VolumeLightAPI


Applies this **single-apply** API schema to the given ``prim`` .


This information is stored by adding"VolumeLightAPI"to the token-
valued, listOp metadata *apiSchemas* on the prim.

A valid UsdLuxVolumeLightAPI object is returned upon success. An
invalid (or empty) UsdLuxVolumeLightAPI 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


"""
   result["VolumeLightAPI"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""