Universal Scene Description (USD)

https://openusd.org/release/api/
Admin
USD is a system for authoring, composing, and reading hierarchically organized scene description,...
Tokens:3,682,157
Snippets:33,869
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Build OpenUSD with Examples

Source: https://openusd.org/release/api/md_examples_2_r_e_a_d_m_e.html

Use the build script with the --examples flag to include example plugins and assets in the installation.

```bash
python /path/to/OpenUSD/build_scripts/build_usd.py --examples [other options ...] /path/to/my_usd_install_dir
```

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

### Launch usdview

Source: https://openusd.org/release/api/md_examples_2_r_e_a_d_m_e.html

Start the usdview application pointing to the example asset file.

```bash
usdview /path/to/OpenUSD/extras/exec/examples/irExample/assets/shot.usda
```

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

### Instancer Configuration Example

Source: https://openusd.org/release/api/class_hd_instancer.html

Example showing how an instancer defines prototypes and instance translations.

```text
"/InstancerA": prototypes = ["/sphere", "/cube", "/sphere"]; 
               hydra:instanceTranslations  = [<0,0,0>, <1,0,0>, <0,1,0>]
```

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

### Nested Instancing Example

Source: https://openusd.org/release/api/class_hd_instancer.html

Example showing how instancers can be nested to create multiple instances based on index tuples.

```text
"/cube": instancerId = "/InstancerA"
"/InstancerA": instancerId = "/InstancerB"
               indices("/cube") = [0, 1]
               hydra:instanceTranslations = [<0,0,0>, <1,0,0>]
"/InstancerB": indices("/InstancerA") = [0, 1]
               hydra:instanceTranslations = [<0,0,0>, <0,1,0>]
```

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

### Complete Bind State Instancing Example

Source: https://openusd.org/release/api/_usd_skel__instancing.html

A full example demonstrating the definition of an instanceable model and multiple model instances with unique animations.

```usd
def Xform "Model" (
instanceable = true
prepend apiSchemas = ["SkelBindingAPI"]
)
{
rel skel:skeleton = <Skel>
def Mesh "Mesh" {}
def Skeleton "Skel" {}
}
def SkelAnimation "ModelAnim_1" {}
...
def SkelAnimation "ModelAnim_N" {}
over Model_1 (
add references = </Model>
)
{
rel skel:animationSource = </ModelAnim_1>
}
...
over Model_N (
add references = </Model>
)
{
rel skel:animationSource = </ModelAnim_N>
}
```

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

### TF_VERIFY Practical Examples

Source: https://openusd.org/release/api/group__group__tf___diagnostic.html

Examples demonstrating how to use TF_VERIFY for state validation and error recovery.

```cpp
// List should be empty. If not, issue an error, clear it out and continue.
if (not TF_VERIFY(list.empty()) {
// The list was unexpectedly not empty. TF_VERIFY will have
// issued a coding error with details. We clear the list and continue.
list.clear();
}
```

```cpp
// Only add to string if ptr is valid.
string result = ...; 
if (TF_VERIFY(ptr != NULL)) {
result += ptr->Method();
}
```

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

### TfPyInitialize

Source: https://openusd.org/release/api/base_2tf_2py_utils_8h_source.html

Starts up the python runtime.

```APIDOC
## void TfPyInitialize()

### Description
Starts up the python runtime.
```

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

### Example plugInfo.json Metadata Configuration

Source: https://openusd.org/release/api/sdf_page_front.html

A concrete example showing the structure of custom metadata definitions within a plugInfo.json file.

```json
{
"Plugins": [
{
...
"Info": {
"SdfMetadata": {
"custom_double": {
"type": "double",
"appliesTo": "prims"
},
"custom_string": {
"type": "string",
"default": "default metadata value"
}
}
}
...
}
]
}
```

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

### begin()

Source: https://openusd.org/release/api/group___s_t_l___a_p_i.html

Returns an iterator to the start of the array.

```APIDOC
## iterator begin()

### Description
Return a non-const iterator to the start of the array. The underlying data is copied if it is not uniquely owned.
```

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

### StartThread()

Source: https://openusd.org/release/api/class_hd_render_thread.html

Starts the background rendering thread.

```APIDOC
## void StartThread()

### Description
Start the rendering background thread. It is an error to call this if the thread is already running.
```

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

### StartThread

Source: https://openusd.org/release/api/class_hd_render_thread.html

Starts the background rendering thread.

```APIDOC
## void StartThread()

### Description
Starts the rendering background thread. This method is not thread-safe.
```

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

### ArchGetStartTickTime

Source: https://openusd.org/release/api/group__group__arch___system_functions.html

Gets a start tick time for measuring intervals with high precision.

```APIDOC
## uint64_t ArchGetStartTickTime()

### Description
Get a "start" tick time for measuring an interval of time, followed by a later call to ArchGetStopTickTime(). This function includes compiler & CPU fencing & reordering constraints to ensure accurate measurement.
```

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

### begin

Source: https://openusd.org/release/api/class_ef___page_cache.html

Returns an iterator to the start of the cache.

```APIDOC
## iterator begin()

### Description
Returns an iterator to the output-to-value cache in the first page.
```

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

### App Constructor

Source: https://openusd.org/release/api/_c_l_i11_8h_source.html

Initializes a new App instance with optional description and name.

```cpp
explicit App(std::string app_description = "", std::string app_name = "")
: App(app_description, app_name, nullptr) {
set_help_flag("-h,--help", "Print this help message and exit");
}
```

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

### Interpolate Missing Values in Clip Set

Source: https://openusd.org/release/api/_usd__page__value_clips.html

Example setup for enabling interpolateMissingClipValues to interpolate across gaps in a clip set.

```usda
#usda 1.0 def "Model" { double a.timeSamples = { 1: 1 } }
```

```usda
#usda 1.0 def "Model" { }
```

```usda
#usda 1.0 def "Model" { double a.timeSamples = { 4: 4 } }
```

```usda
#usda 1.0 def "Model" { double a.timeSamples = { 2: None, 3: None } }
```

```usda
#usda 1.0 def "TestModel" ( clips = { dictionary default = { double2[] active = [(1, 0), (2, 1), (3, 2), (4, 3)] asset[] assetPaths = [@./clip1.usd@, @./clip2.usd@, @./clip3.usd@, @./clip4.usd@] asset manifestAssetPath = @./manifest.usd@ string primPath = "/Model" bool interpolateMissingClipValues = true } } ) { double a }
```

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

### Define Missing Values in Clip Set

Source: https://openusd.org/release/api/_usd__page__value_clips.html

Example setup for a clip set where missing time samples fall back to manifest defaults or value blocks.

```usda
#usda 1.0 def "Model" { double a.timeSamples = { 1: 1 } double b.timeSamples = { 1: 1 } }
```

```usda
#usda 1.0 def "Model" { }
```

```usda
#usda 1.0 def "Model" { double a.timeSamples = { 3: 3 } double b.timeSamples = { 3: 3 } }
```

```usda
#usda 1.0 def "Model" { double a = 10.0 double b }
```

```usda
#usda 1.0 def "TestModel" ( clips = { dictionary default = { double2[] active = [(1, 0), (2, 1), (3, 2)] asset[] assetPaths = [@./clip1.usd@, @./clip2.usd@, @./clip3.usd@] asset manifestAssetPath = @./manifest.usd@ string primPath = "/Model" } } ) { double a double b }
```

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

### Example root.usd file structure

Source: https://openusd.org/release/api/_usd__page__dynamic_file_format.html

Demonstrates how prims reference parameters and define payloads for dynamic file formats.

```usd
#usda 1.0
def "Root" (
references = </Params>
payload = @./dynamic.mydynamicfile@
)
{
}
def "Params" (
dynamicName = "Foo"
dynamicNumber = 8
)
{
}
```

```usd
#usda 1.0
def "Root" (
dynamicName = "Bar"
references = </Params>
payload = @./dynamic.mydynamicfile@
)
{
}
def "Params" (
dynamicName = "Foo"
dynamicNumber = 8
)
{
}
```

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

### Python Plugin __init__.py

Source: https://openusd.org/release/api/md_pxr_2usd_validation_2usd_validation_2_r_e_a_d_m_e.html

Example __init__.py file containing the registration logic for a Python plugin.

```python
from pxr import Sdf, UsdGeom, UsdValidation
_PLUGIN_NAME = "myPlugin"
def _CheckUpAxis(stage, timeRange):
if not stage.HasAuthoredMetadata(UsdGeom.Tokens.upAxis):
return [
UsdValidation.ValidationError(
"MissingUpAxis",
UsdValidation.ValidationErrorType.Error,
[UsdValidation.ValidationErrorSite(
stage, Sdf.Path.absoluteRootPath)],
"Stage is missing upAxis metadata.",
)
]
return []
```

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

### Skeleton Guide Computation Functions

Source: https://openusd.org/release/api/skel_guide_data_8h_source.html

Utility functions for computing guide mesh data and applying skinning transforms to skeleton guide points.

```cpp
USDSKELIMAGING_API
UsdSkelImagingSkelGuideData
UsdSkelImagingComputeSkelGuideData(
 const UsdSkelImagingSkelData &skelData);

USDSKELIMAGING_API
VtIntArray
UsdSkelImagingComputeSkelGuideFaceVertexCounts(
 const UsdSkelImagingSkelGuideData &skelGuideData);

USDSKELIMAGING_API
VtIntArray
UsdSkelImagingComputeSkelGuideFaceVertexIndices(
 const UsdSkelImagingSkelGuideData &skelGuideData);

USDSKELIMAGING_API
VtVec3fArray
UsdSkelImagingComputeSkelGuidePoints(
 const UsdSkelImagingSkelGuideData &skelGuideData,
 const VtArray<GfMatrix4f> &skinningTransforms);
```

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

### begin()

Source: https://openusd.org/release/api/class_sdf_list_proxy.html

Returns a const iterator to the start of the sequence.

```APIDOC
## const_iterator begin() const

### Description
Returns a const iterator to the start of the sequence.
```

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

### GetStartLayer()

Source: https://openusd.org/release/api/class_usd_resolve_target.html

Retrieves the starting layer for value resolution.

```APIDOC
## SdfLayerHandle GetStartLayer()

### Description
Returns the layer in the layer stack of the start node that value resolution with this resolve target will start at.

### Returns
- **SdfLayerHandle** - The starting layer handle.
```

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

### GetStartPoint()

Source: https://openusd.org/release/api/class_gf_ray.html

Returns the starting point of the ray.

```APIDOC
## GfVec3d GetStartPoint()

### Description
Returns the starting point of the ray.
```

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

### Get

Source: https://openusd.org/release/api/class_esf_attribute_query_interface.html

Gets the resolved value of the attribute at a given time.

```APIDOC
## bool Get(VtValue *value, UsdTimeCode time)

### Description
Gets the resolved value of the attribute at a given time.
```

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

### Create a Render Index for Backend Emulation

Source: https://openusd.org/release/api/class_hd_render_index.html

Example showing how to initialize a render index with a terminal scene index for backend emulation.

```cpp
hgi = Hgi::CreatePlatformDefaultHgi()
hgiDriver = new HdDriver<Hgi*>(HgiTokens→renderDriver, hgi)
HdRenderIndex::New(_renderDelegate, {_hgiDriver})
```

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

### Get Name for Unit

Source: https://openusd.org/release/api/usd_2sdf_2types_8h_source.html

Gets the name for a given unit.

```cpp
SDF_API const std::string & SdfGetNameForUnit(const TfEnum &unit)
```

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

### App::_configure

Source: https://openusd.org/release/api/_c_l_i11_8h_source.html

Configures the application and its subcommands, setting startup modes and parent-child relationships.

```cpp
7793CLI11_INLINE void App::_configure() {
7794 if(default_startup == startup_mode::enabled) {
7795 disabled_ = false;
7796 } else if(default_startup == startup_mode::disabled) {
7797 disabled_ = true;
7798 }
7799 for(const App_p &app : subcommands_) {
7800 if(app->has_automatic_name_) {
7801 app->name_.clear();
7802 }
7803 if(app->name_.empty()) {
7804 app->fallthrough_ = false; // make sure fallthrough_ is false to prevent infinite loop
7805 app->prefix_command_ = false;
7806 }
7807 // make sure the parent is set to be this object in preparation for parse
7808 app->parent_ = this;
7809 app->_configure();
7810 }
7811}
```

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

### Get Unit Category

Source: https://openusd.org/release/api/usd_2sdf_2types_8h_source.html

Gets the unit category for a given unit.

```cpp
SDF_API const std::string & SdfUnitCategory(const TfEnum &unit)
```

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

### Get Default Unit

Source: https://openusd.org/release/api/usd_2sdf_2types_8h_source.html

Gets the show default unit for the given typeName.

```cpp
SDF_API TfEnum SdfDefaultUnit(TfToken const &typeName)
```

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

### Include and Namespace Setup for UsdLuxRectLight

Source: https://openusd.org/release/api/rect_light_8h_source.html

This snippet shows the initial header guards, necessary includes for USD and Gf types, and the opening of the PXR namespace.

```cpp
//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef USDLUX_GENERATED_RECTLIGHT_H
#define USDLUX_GENERATED_RECTLIGHT_H


#include "pxr/pxr.h"
#include "pxr/usd/usdLux/api.h"
#include "pxr/usd/usdLux/boundableLightBase.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/stage.h"
#include "pxr/usd/usdLux/tokens.h"

#include "pxr/base/vt/value.h"

#include "pxr/base/gf/vec3d.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/matrix4d.h"

#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"

PXR_NAMESPACE_OPEN_SCOPE

class SdfAssetPath;

// -------------------------------------------------------------------------- //
```

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

### Access Guide Length Attribute

Source: https://openusd.org/release/api/joint_scope_8h_source.html

Methods for retrieving or creating the guide length attribute.

```cpp
156 EXECIR_API
157 UsdAttribute GetGuideLengthAttr() const;
164 EXECIR_API
165 UsdAttribute CreateGuideLengthAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
```

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

### Initialize Python Runtime

Source: https://openusd.org/release/api/py_interpreter_8h_source.html

Starts up the Python runtime environment.

```cpp
TF_API
extern void TfPyInitialize();
```

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

### Python Function Definition Example

Source: https://openusd.org/release/api/struct_tf_py_kw_arg.html

Example of a Python function signature that accepts keyword arguments.

```python
def MyFunction(arg1, arg2, arg3 = None, arg4 = None, arg5 = None):
# ...
```

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

### Preamble and Initialization

Source: https://openusd.org/release/api/add_ext_visit_value_type_8h_source.html

Sets up the initial environment for type registration, including necessary headers and default type list definitions.

```cpp
#ifndef PXR_BASE_VT_ADD_EXT_VISIT_VALUE_PREAMBLE
#define PXR_BASE_VT_ADD_EXT_VISIT_VALUE_PREAMBLE
#include "pxr/pxr.h"
#include "pxr/base/tf/meta.h"
#ifndef VT_VISIT_VALUE_EXT_TYPES
# define VT_VISIT_VALUE_EXT_TYPES PXR_NS_GLOBAL::TfMetaList<>
#endif
#endif // PXR_BASE_VT_ADD_EXT_VISIT_VALUE_PREAMBLE

#ifndef VT_ADD_EXT_VISIT_VALUE_TYPE
# error "Define VT_ADD_EXT_VISIT_VALUE_TYPE before including addExtVisitValueType.h"
#endif

#ifndef _VT_VISIT_VALUE_EXT_N
# define _VT_VISIT_VALUE_EXT_N 0
#endif
```

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

### Get(VtValue *value, UsdTimeCode time)

Source: https://openusd.org/release/api/class_esf_attribute_query_interface.html

Gets the resolved value of the attribute at a given time.

```APIDOC
## bool Get(VtValue *value, UsdTimeCode time) const

### Description
Gets the resolved value of the attribute at a given time.

### Parameters
- **value** (VtValue*) - Pointer to store the resolved value.
- **time** (UsdTimeCode) - The time at which to resolve the attribute value.

### Returns
- **bool** - Returns true if the value was successfully retrieved.
```

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

### Registering a Plugin Implementation

Source: https://openusd.org/release/api/class_plug_static_interface.html

Example of implementing the interface and registering it with the plugin system.

```cpp
#include "path/to/SomePlugin.h"
#include "pxr/base/plug/interfaceFactory.h"
#include <iostream>
class SomePluginImplementation : public SomePluginInterface {
public:
virtual bool MakePluginDoSomething() const {
return std::cout << "Plugin did something" << std::endl;
}
};
PLUG_REGISTER_INTERFACE_SINGLETON_TYPE(SomePluginInterface,
SomePluginImplementation)
```

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

### begin()

Source: https://openusd.org/release/api/class_sdf_zip_file.html

Returns an iterator pointing to the first file in the zip archive.

```APIDOC
## begin()

### Description
Returns an iterator pointing to the first file in the zip archive.

### Signature
`SDF_API Iterator begin() const`
```

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

### Access Guide Display Opacity Attribute

Source: https://openusd.org/release/api/joint_scope_8h_source.html

Methods for retrieving or creating the guide display opacity attribute.

```cpp
200 EXECIR_API
201 UsdAttribute GetGuideDisplayOpacityAttr() const;
208 EXECIR_API
209 UsdAttribute CreateGuideDisplayOpacityAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
```

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

### Access Guide Display Color Attribute

Source: https://openusd.org/release/api/joint_scope_8h_source.html

Methods for retrieving or creating the guide display color attribute.

```cpp
178 EXECIR_API
179 UsdAttribute GetGuideDisplayColorAttr() const;
186 EXECIR_API
187 UsdAttribute CreateGuideDisplayColorAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
```

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

### App(std::string app_description, std::string app_name)

Source: https://openusd.org/release/api/classpxr___c_l_i_1_1_app.html

Constructor to create a new command-line application instance.

```APIDOC
## App(std::string app_description, std::string app_name)

### Description
Creates a new program instance. Pass in the application description and name.

### Parameters
- **app_description** (std::string) - Optional - A description of the application.
- **app_name** (std::string) - Optional - The name of the application.
```

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

### API Initialization and Feature Checking

Source: https://openusd.org/release/api/gl_api_8h_source.html

Example usage for initializing the API and checking for feature availability at runtime.

```cpp
// #include "pxr/imaging/garch/glApi.h"
// ...
// GarchGLApiLoad();
// ...

// #if defined(GL_VERSION_4_0)
// if (GARCH_GLAPI_HAS(VERSION_4_0)) {
// // ... GL_VERSION_4_0 specific code
// }
// #endif

// #if defined(GL_ARB_tessellation_shader)
// if (GARCH_GLAPI_HAS(ARB_tessellation_shader)) {
// // ... ARB_tessellation_shader specific code
// }
// #endif
```

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

### Get(VtValue *value, UsdTimeCode time)

Source: https://openusd.org/release/api/class_usd_attribute_query.html

Type-erased version of the Get method for fetching attribute values.

```APIDOC
## Get(VtValue *value, UsdTimeCode time)

### Description
Type-erased access to fetch the value of the attribute. This is an overloaded member function provided for convenience.

### Parameters
- **value** (VtValue*) - Required - Pointer to store the retrieved value.
- **time** (UsdTimeCode) - Optional - The time code at which to fetch the value (defaults to UsdTimeCode::Default()).

### Returns
- **bool** - Returns true if the value was successfully retrieved.
```

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

### Define Dictionary Get and Set Accessor Macro

Source: https://openusd.org/release/api/accessor_helpers_8h.html

Combines the definition of both dictionary get and set accessors.

```cpp
#define SDF_DEFINE_DICTIONARY_GET_SET(getName_, setName_, key_) \
SDF_DEFINE_DICTIONARY_GET(getName_, key_) \
SDF_DEFINE_DICTIONARY_SET(setName_, key_)
```

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

### ConnectableAPI Header Includes and Setup

Source: https://openusd.org/release/api/connectable_a_p_i_8h_source.html

Initializes the ConnectableAPI header with necessary USD and base library dependencies.

```cpp
//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef USDSHADE_GENERATED_CONNECTABLEAPI_H
#define USDSHADE_GENERATED_CONNECTABLEAPI_H

#include "pxr/pxr.h"
#include "pxr/usd/usdShade/api.h"
#include "pxr/usd/usd/apiSchemaBase.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/stage.h"

#include "pxr/usd/usd/typed.h"
#include "pxr/usd/usdShade/input.h"
#include "pxr/usd/usdShade/output.h"
#include "pxr/usd/usdShade/tokens.h"
#include "pxr/usd/usdShade/types.h"

#include "pxr/base/vt/value.h"

#include "pxr/base/gf/vec3d.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/matrix4d.h"

#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"

PXR_NAMESPACE_OPEN_SCOPE

class SdfAssetPath;

// -------------------------------------------------------------------------- //
// CONNECTABLEAPI //
```

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

### make_help(const App *app, std::string name, AppFormatMode mode)

Source: https://openusd.org/release/api/classpxr___c_l_i_1_1_formatter_base.html

Generates the help string for the application.

```APIDOC
## std::string make_help(const App *app, std::string name, AppFormatMode mode)

### Description
This is the key method that puts together the help output for the application.

### Parameters
- **app** (const App*) - Required - Pointer to the application instance.
- **name** (std::string) - Required - The name associated with the help.
- **mode** (AppFormatMode) - Required - The formatting mode to use.
```

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

### Include and Namespace Setup for HdCamera

Source: https://openusd.org/release/api/imaging_2hd_2camera_8h_source.html

Initializes the header guard, includes essential Hydra and Gf dependencies, and opens the PXR namespace.

```cpp
//
// Copyright 2017 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HD_CAMERA_H
#define PXR_IMAGING_HD_CAMERA_H

#include "pxr/pxr.h"
#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/version.h"
#include "pxr/imaging/hd/sprim.h"

#include "pxr/imaging/cameraUtil/conformWindow.h"

#include "pxr/base/tf/staticTokens.h"
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/gf/range1f.h"
#include "pxr/base/gf/vec2f.h"

#include <vector>

PXR_NAMESPACE_OPEN_SCOPE
```

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

### USD API Functions starting with J

Source: https://openusd.org/release/api/functions_func_j.html

List of functions starting with the letter J available in the USD API.

```APIDOC
## Function Reference: J

- **join()** : Member of `OptionBase< CRTP >`
- **JoinIdentifier()** : Member of `SdfPath`
- **JointTransformsMightBeTimeVarying()** : Member of `UsdSkelAnimQuery`
- **JsValue()** : Constructor/Member of `JsValue`
- **JsWriter()** : Constructor/Member of `JsWriter`
```

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

### Scope(key, start, stop)

Source: https://openusd.org/release/api/class_trace_collector.html

Records a scope event with a specified key, start time, and stop time.

```APIDOC
## Scope(key, start, stop)

### Description
Records a scope event described by _key_ that started at _start_ and ended at _stop_. This method is used by the TRACE_FUNCTION, TRACE_SCOPE and TRACE_FUNCTION_SCOPE macros.

### Parameters
- **key** (TraceKey) - The identifier for the scope.
- **start** (TimeStamp) - The start time of the scope.
- **stop** (TimeStamp) - The stop time of the scope.
```

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

### Define Render Settings and Products in USDA

Source: https://openusd.org/release/api/usd_render_page_front.html

Example demonstrating the structure of RenderSettings, RenderProduct, RenderVar, and RenderPass prims within a USD file.

```usda
#usda1.0
(
renderSettingsPrimPath = "/Render/PrimarySettings"
)
def Scope "Render"
{
def RenderSettings "PrimarySettings" {
rel products = </Render/PrimaryProduct>
int2 resolution = (512, 512)
}
def RenderProduct "PrimaryProduct" {
rel camera = </World/main_cam>
token productName = "/scratch/tmp/render000009.exr"
rel orderedVars = [
</Render/Vars/color>,
</Render/Vars/alpha>,
</Render/Vars/directDiffuse>,
</Render/Vars/id>
]
}
}
def Scope "Vars"
{
def RenderVar "color" {
string sourceName = "Ci"
}
def RenderVar "alpha" {
token dataType = "float"
string sourceName = "a"
}
def RenderVar "directDiffuse" {
string sourceName = "C<RD>[<L.>O]"
token sourceType = "lpe"
}
def RenderVar "id" {
token dataType = "int"
string sourceName = "id"
}
}
def Scope "Passes"
{
def RenderPass "beauty"{
token passType = "prman"
rel renderSource = <Render/PrimarySettings>
string[] command = ["prman"]
}
def RenderPass "composite"{
token passType = "nuke"
asset fileName = @composite.nk@
# this Nuke-namespaced property might come from a hypothetical 
# Nuke-supplied API schema applied to this prim
string nuke:writeNode = "WriteFinalComposite"
rel renderSource = </Render/Passes/composite.nuke:writeNode>
string[] command = ["nuke", "-x", "-c", "32G"]
rel inputPasses = </Render/Passes/beauty>
} 
}
}
```

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

### Apply and Configure UsdCollectionAPI in C++

Source: https://openusd.org/release/api/class_usd_collection_a_p_i.html

Demonstrates applying collection APIs to a prim, defining inclusion/exclusion paths, setting explicit expansion rules, and querying membership.

```cpp
bool ApplyCollections(UsdPrim const &prim)
{ 
/* Assuming the folling prim hierarchy:
|- Vehicles 
| |- FourWheelers
| | |- CarA
| | |- CarB
| | |- CarC
| | |- CarD
| | |- TruckA
| | |- TruckB
| |- TwoWheelers
| | |- BikeA
| | |- BikeB
| | |- BicycleA
| | |- FrontWheel
| | |- BackWheel
| |- Other
| | |- TricycleA
| | |- FrontWheel
| | |- BackWheels
*/
// Create a collection that includes only the cars, by adding all 
// of "FourWheelers" and excluding the trucks.
UsdCollectionAPI cars = UsdCollectionAPI::Apply(prim, "cars");
cars.CreateIncludesRel().AddTarget(SdfPath("/Vehicles/FourWheelers"));
cars.CreateExcludesRel().AddTarget(SdfPath("/Vehicles/FourWheelers/TruckA"));
cars.CreateExcludesRel().AddTarget(SdfPath("/Vehicles/FourWheelers/TruckB"));
// Create a collection that includes only the bikes by explicitly inluding 
// just the two bikes in the collection.
UsdCollectionAPI bikes = UsdCollectionAPI::Apply(prim, "bikes");
bikes.CreateExpansionRuleAttr(VtValue(UsdTokens->explicitOnly));
bikes.CreateIncludesRel().AddTarget(SdfPath("/Vehicles/TwoWheelers/BikeA"));
bikes.CreateIncludesRel().AddTarget(SdfPath("/Vehicles/TwoWheelers/BikeB"));
// Create an explicit collection of slow-moving vehicles. 
// An explicit collection implies that descendants (i.e. the front and back 
// wheels) are not considered to be included in the collection.
UsdCollectionAPI slowVehicles = UsdCollectionAPI::Apply(prim, "slowVehicles");
slowVehicles.CreateExpansionRuleAttr(VtValue(UsdTokens->explicitOnly));
slowVehicles.CreateIncludesRel().AddTarget(SdfPath("/Vehicles/TwoWheelers/BicycleA"));
slowVehicles.CreateIncludesRel().AddTarget(SdfPath("/Vehicles/Other/TricycleA"));
UsdCollectionAPI vehicles = UsdCollectionAPI::Apply(prim, "vehicles");
vehicles.CreateIncludesRel().AddTarget(cars.GetCollectionPath());
vehicles.CreateIncludesRel().AddTarget(bikes.GetCollectionPath());
vehicles.CreateIncludesRel().AddTarget(slowVehicles.GetCollectionPath());
vehicles.CreateIncludesRel().AddTarget(SdfPath("/Vehicles/FourWheelers/TruckA"));
vehicles.CreateIncludesRel().AddTarget(SdfPath("/Vehicles/FourWheelers/TruckB"));
UsdCollectionAPI::MembershipQuery query = vehicles.ComputeMembershipQuery();
// CarA is included in the 'vehicles' collection through the 'cars' collection.
TF_AXIOM(query.IsPathIncluded("/Vehicles/FourWheelers/CarA"))
// BikeB is included in the 'vehicles' collection through the 'cars' collection.
TF_AXIOM(query.IsPathIncluded("/Vehicles/TwoWheelers/BikeB"))
// BikeB is included directly in the 'vehicles' collection 
TF_AXIOM(query.IsPathIncluded("/Vehicles/FourWheelers/TruckA"))
// BicycleA is included, but it's descendants are not, since it is part of 
// an "explicitOnly" collection.
TF_AXIOM(query.IsPathIncluded("/Vehicles/TwoWheelers/BicycleA"))
TF_AXIOM(!query.IsPathIncluded("/Vehicles/TwoWheelers/BicycleA/FrontWheel"))
// TricycleA is included, but it's descendants are not, since it is part of 
// an "explicitOnly" collection.
TF_AXIOM(query.IsPathIncluded("/Vehicles/Other/TricycleA"))
TF_AXIOM(!query.IsPathIncluded("/Vehicles/Other/TricycleA/BackWheels"))
SdfPathSet includedPaths;
UsdCollectionAPI::ComputeIncludedPaths(query, prim.GetStage(), 
&includedPaths);
std::set<UsdObject> includedObjects;
UsdCollectionAPI::ComputeIncludedObjects(query, prim.GetStage(), 
&includedObjects);
}
```

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

### Parallel Reduction Example

Source: https://openusd.org/release/api/reduce_8h.html

Example demonstrating how to reduce an array of mesh points into a single bounding box using WorkParallelReduceN.

```cpp
// Get the mesh points from which we are going to generate the bounding box.
const std::vector<Vector3> &points = GetMeshPoints();
// Generate the bounding box by parallel reducing the points.
BoundingBox bbox = WorkParallelReduceN(
BoundingBox(),
points.size(),
[&points](size_t b, size_t e, const BoundingBox &identity){
BoundingBox bbox(identity);
// Insert each point in this subrange into the local bounding box.
for (size_t i = b; i != e; ++i) {
bbox.InsertPoint(points[i]);
}
// Return the local bounding box, which now encapsulates all the
// points in this subrange.
return bbox;
},
[](const BoundingBox &lhs, const BoundingBox &rhs){
// Join two bounding boxes into a single bounding box. The
// algorithm will apply this reduction step recursively until there
// is only a single bounding box left.
BoundingBox bbox(lhs);
bbox.UnionWith(rhs);
return bbox;
}
);
```

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

### Include and Namespace Setup for UsdLuxNonboundableLightBase

Source: https://openusd.org/release/api/nonboundable_light_base_8h_source.html

This snippet includes the required headers for the UsdLuxNonboundableLightBase class and opens the PXR namespace.

```cpp
//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef USDLUX_GENERATED_NONBOUNDABLELIGHTBASE_H
#define USDLUX_GENERATED_NONBOUNDABLELIGHTBASE_H


#include "pxr/pxr.h"
#include "pxr/usd/usdLux/api.h"
#include "pxr/usd/usdGeom/xformable.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/stage.h"
#include "pxr/usd/usdLux/lightAPI.h"

#include "pxr/base/vt/value.h"

#include "pxr/base/gf/vec3d.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/matrix4d.h"

#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"

PXR_NAMESPACE_OPEN_SCOPE

class SdfAssetPath;
```

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

### USD Skel Arm Example

Source: https://openusd.org/release/api/_usd_skel__schema_overview.html

A complete USDA example of a 3-joint skinned arm with animation data and binding information.

```usda
#usda 1.0
(
defaultPrim = "Model"
endTimeCode = 10
startTimeCode = 1
metersPerUnit = .01
upAxis = 'Y'
)
def SkelRoot "Model" (
kind = "component"
prepend apiSchemas = ["SkelBindingAPI"]
)
{
def Skeleton "Skel" (
prepend apiSchemas = ["SkelBindingAPI"]
)
{
uniform token[] joints = ["Shoulder", "Shoulder/Elbow", "Shoulder/Elbow/Hand"]
uniform matrix4d[] bindTransforms = [
((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1)),
((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,2,1)),
((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,4,1)) 
]
uniform matrix4d[] restTransforms = [
((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1)),
((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,2,1)),
((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,2,1))
]
def SkelAnimation "Anim" {
uniform token[] joints = ["Shoulder/Elbow"]
float3[] translations = [(0,0,2)]
quatf[] rotations.timeSamples = {
1: [(1,0,0,0)],
10: [(0.7071, 0.7071, 0, 0)]
}
half3[] scales = [(1,1,1)]
}
rel skel:animationSource = </Model/Skel/Anim>
}
# Both the binding of the Skeleton, and the specificatin of the
# weighting primvars necessitates the application of the 
# SkelBindingAPI schema
def Mesh "Arm" (
prepend apiSchemas = ["SkelBindingAPI"]
)
{
int[] faceVertexCounts = [4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
int[] faceVertexIndices = [
2, 3, 1, 0,
6, 7, 5, 4,
8, 9, 7, 6,
3, 2, 9, 8,
10, 11, 4, 5,
0, 1, 11, 10,
7, 9, 10, 5,
9, 2, 0, 10,
3, 8, 11, 1,
8, 6, 4, 11
]
point3f[] points = [
(0.5, -0.5, 4), (-0.5, -0.5, 4), (0.5, 0.5, 4), (-0.5, 0.5, 4),
(-0.5, -0.5, 0), (0.5, -0.5, 0), (-0.5, 0.5, 0), (0.5, 0.5, 0),
(-0.5, 0.5, 2), (0.5, 0.5, 2), (0.5, -0.5, 2), (-0.5, -0.5, 2)
]
rel skel:skeleton = </Model/Skel>
int[] primvars:skel:jointIndices = [
2,2,2,2, 0,0,0,0, 1,1,1,1
] (
interpolation = "vertex"
elementSize = 1
)
float[] primvars:skel:jointWeights = [
1,1,1,1, 1,1,1,1, 1,1,1,1
] (
interpolation = "vertex"
elementSize = 1
)
matrix4d primvars:skel:geomBindTransform = ((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1))
}
}
```

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

### Internal Get Implementation Logic

Source: https://openusd.org/release/api/class_usd_color_space_definition_a_p_i.html

Shows the underlying logic used by the path-based Get method to resolve the schema object.

```cpp
TfToken name = SdfPath::StripNamespace(path.GetToken());
UsdColorSpaceDefinitionAPI(
stage->GetPrimAtPath(path.GetPrimPath()), name);
```

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

### Initialize()

Source: https://openusd.org/release/api/class_arch_malloc_hook.html

Installs custom callback functions to replace standard system memory allocation routines. Returns true on success, or false if initialization fails or has already been performed.

```APIDOC
### Initialize()

#### Description
Installs the supplied functions as callbacks in place of the standard system memory allocation routines. The callbacks accept an extra `const void*` parameter which should be ignored on supported systems.

#### Signature
`bool Initialize(void *(*mallocWrapper)(size_t, const void *), void *(*reallocWrapper)(void *, size_t, const void *), void *(*memalignWrapper)(size_t, size_t, const void *), void(*freeWrapper)(void *, const void *), std::string *errMsg)`

#### Parameters
- **mallocWrapper** (function pointer) - Callback for malloc
- **reallocWrapper** (function pointer) - Callback for realloc
- **memalignWrapper** (function pointer) - Callback for memalign
- **freeWrapper** (function pointer) - Callback for free
- **errMsg** (std::string*) - Pointer to string to store error message if initialization fails

#### Returns
- **bool** - True if initialization succeeded, false otherwise.
```

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

### VdfSparseVectorizedOutputTraverser::Traverse

Source: https://openusd.org/release/api/sparse_vectorized_output_traverser_8h_source.html

Starts a traversal of the network starting from the provided outputs, invoking the specified callback for all terminal nodes encountered.

```APIDOC
## void Traverse(const VdfMaskedOutputVector &outputs, const NodeCallback &callback)

### Description
Starts a traversal with the given outputs request and node callback.

### Parameters
- **outputs** (const VdfMaskedOutputVector &) - Required - The vector of masked outputs to begin the traversal from.
- **callback** (const NodeCallback &) - Required - The function to be invoked for all terminal nodes.
```

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

### Include Guard and Header Setup

Source: https://openusd.org/release/api/shadow_task_8h_source.html

Standard header guard and include for the shadow task definition.

```cpp
//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HDX_SHADOW_TASK_H
#define PXR_IMAGING_HDX_SHADOW_TASK_H

#include "pxr/pxr.h"
```

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

### Traverse

Source: https://openusd.org/release/api/class_vdf_sparse_input_path_finder.html

Traverses the network in the input direction sparsely, starting from a start node and attempting to find all possible paths into a target node.

```APIDOC
## static void Traverse(const VdfMaskedOutput &start, const VdfMaskedOutput &target, InputCallback inputCallback, std::vector< VdfConnectionConstVector > *paths)

### Description
Traverses the network in the input direction sparsely, starting from `start` trying to find all possible paths into `target`.

### Parameters
- **start** (const VdfMaskedOutput &) - The starting output node.
- **target** (const VdfMaskedOutput &) - The target node to reach.
- **inputCallback** (InputCallback) - Callback function to determine if an input is a relevant path.
- **paths** (std::vector< VdfConnectionConstVector > *) - Pointer to a vector to store the found paths.
```

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

### Navigating Instance Hierarchies

Source: https://openusd.org/release/api/_usd__page__scenegraph_instancing.html

Demonstrates how to identify instance prims and retrieve their children using instance proxies.

```python
>>> car_1 = stage.GetPrimAtPath('/ParkingLot/Car_1')
>>> car_1.IsInstance()
True
>>> car_1.GetChildren()
[]
>>> car_1.GetFilteredChildren(Usd.TraverseInstanceProxies())
[Usd.Prim(</ParkingLot/Car_1/Body>), Usd.Prim(</ParkingLot/Car_1/Door>)]
```

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

### UsdLuxPortalLight Header Includes

Source: https://openusd.org/release/api/portal_light_8h_source.html

Initial includes and namespace setup for the portal light schema definition.

```cpp
//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef USDLUX_GENERATED_PORTALLIGHT_H
#define USDLUX_GENERATED_PORTALLIGHT_H


#include "pxr/pxr.h"
#include "pxr/usd/usdLux/api.h"
#include "pxr/usd/usdLux/boundableLightBase.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/stage.h"
#include "pxr/usd/usdLux/tokens.h"

#include "pxr/base/vt/value.h"

#include "pxr/base/gf/vec3d.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/matrix4d.h"

#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"

PXR_NAMESPACE_OPEN_SCOPE

class SdfAssetPath;

// -------------------------------------------------------------------------- //
```

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

### Constant Value Deduction Guides

Source: https://openusd.org/release/api/computation_builders_8h_source.html

Deduction guides to ensure character string literals are stored as std::string within the Constant template.

```cpp
Constant(const char *) -> Constant<std::string>;
Constant(char *) -> Constant<std::string>;
```

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

### Discovering Lights via Manual Traversal

Source: https://openusd.org/release/api/class_usd_lux_light_list_a_p_i.html

Demonstrates how to manually traverse a stage to identify all prims with the UsdLuxLightAPI schema applied.

```cpp
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 }
```

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

### GetDomain()

Source: https://openusd.org/release/api/class_sdr_shader_node.html

Gets the domain of the node.

```APIDOC
## const TfToken & GetDomain()

### Description
Gets the domain of the node.
```

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

### UsdSkelImagingComputeSkelGuideData

Source: https://openusd.org/release/api/skel_guide_data_8h_source.html

Computes the skeleton guide data structure from the provided skeleton data.

```APIDOC
## UsdSkelImagingComputeSkelGuideData

### Description
Computes the `UsdSkelImagingSkelGuideData` required for skeleton guide mesh generation based on the provided `UsdSkelImagingSkelData`.

### Signature
`UsdSkelImagingSkelGuideData UsdSkelImagingComputeSkelGuideData(const UsdSkelImagingSkelData &skelData);`
```

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

### UsdAppUtilsFrameRecorder Constructor

Source: https://openusd.org/release/api/class_usd_app_utils_frame_recorder-members.html

Initializes a new instance of the UsdAppUtilsFrameRecorder.

```APIDOC
## UsdAppUtilsFrameRecorder(const TfToken &rendererPluginId, bool gpuEnabled, bool enableUsdDrawModes)

### Description
Constructs a frame recorder instance with specified renderer plugin and hardware settings.

### Parameters
- **rendererPluginId** (TfToken) - Optional - The ID of the renderer plugin to use.
- **gpuEnabled** (bool) - Optional - Whether to enable GPU acceleration.
- **enableUsdDrawModes** (bool) - Optional - Whether to enable USD draw modes.
```

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

### GetDisplayGuides

Source: https://openusd.org/release/api/class_usd_imaging_delegate.html

Checks if display guides are enabled.

```APIDOC
## GetDisplayGuides()

### Description
Returns a boolean indicating if display guides are enabled.

### Signature
`bool GetDisplayGuides()`
```

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

### help(std::string prev, AppFormatMode mode)

Source: https://openusd.org/release/api/classpxr___c_l_i_1_1_app.html

Generates a help message using the currently configured formatter.

```APIDOC
## App::help(std::string prev="", AppFormatMode mode=AppFormatMode::Normal)

### Description
Makes a help message, using the currently configured formatter. Will only do one subcommand at a time.

### Parameters
- **prev** (std::string) - Optional - Previous context string.
- **mode** (AppFormatMode) - Optional - The formatting mode to use.
```

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

### make_help()

Source: https://openusd.org/release/api/classpxr___c_l_i_1_1_formatter.html

Assembles the complete help documentation string.

```APIDOC
## make_help(const App *app, std::string name, AppFormatMode mode)

### Description
Assembles the full help output for the application.

### Parameters
- **app** (const App *) - The application instance.
- **name** (std::string) - The name of the application or command.
- **mode** (AppFormatMode) - The formatting mode to apply.
```

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

### Get Inverse

Source: https://openusd.org/release/api/quatd_8h_source.html

Returns the inverse of the quaternion.

```cpp
GfQuatd GetInverse() const {
	return GetConjugate() / _GetLengthSquared();
}
```

```cpp
GetInverse() const  {…}
```

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

### Include and Namespace Setup for plugin_light_filter.h

Source: https://openusd.org/release/api/plugin_light_filter_8h_source.html

Standard header guard and dependency includes for the plugin light filter schema.

```cpp
//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef USDLUX_GENERATED_PLUGINLIGHTFILTER_H
#define USDLUX_GENERATED_PLUGINLIGHTFILTER_H

#include "pxr/pxr.h"
#include "pxr/usd/usdLux/api.h"
#include "pxr/usd/usdLux/lightFilter.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/stage.h"

#include "pxr/usd/usdShade/nodeDefAPI.h"

#include "pxr/base/vt/value.h"

#include "pxr/base/gf/vec3d.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/matrix4d.h"

#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"

PXR_NAMESPACE_OPEN_SCOPE

class SdfAssetPath;
```

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

### Get Conjugate

Source: https://openusd.org/release/api/quatd_8h_source.html

Returns the conjugate of the quaternion.

```cpp
GfQuatd GetConjugate() const {
	return GfQuatd(GetReal(), -GetImaginary());
}
```

```cpp
GetConjugate() const  {…}
```
Tokens:
Raw