OpenUSD

https://openusd.org/release/
Admin
OpenUSD is a high-performance extensible software platform for collaboratively constructing animated...
Tokens:4,490,983
Snippets:39,936
Trust Score:9.1
Update:1 month 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>]
```

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

### Windows directory layout for USD DLLs and plugins

Source: https://openusd.org/release/usdfaq.html

Example directory layout when installing USD DLLs and plugins in the same directory as your executable to resolve DLL/plugin loading issues on Windows.

```text
C:\MyPrograms\MyCustomUSDTool\MyCustomTool.exe
C:\MyPrograms\MyCustomUSDTool\tbb.dll
C:\MyPrograms\MyCustomUSDTool\usd_ar.dll
C:\MyPrograms\MyCustomUSDTool\(...remaining USD DLLs...)
C:\MyPrograms\MyCustomUSDTool\usd\plugInfo.json
C:\MyPrograms\MyCustomUSDTool\usd\ar\resources\plugInfo.json
C:\MyPrograms\MyCustomUSDTool\usd\(...remaining core USD plugin directories and files...)
C:\MyPrograms\MyCustomUSDTool\usd\(...other non-core plugin directories as needed...)
```

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

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

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

### URI Resolver Examples

Source: https://openusd.org/release/wp_ar2.html

Code examples demonstrating URI resolver implementation, context usage, and binding behavior.

```cpp
httpResolver.h/.cpp:

/// \class HTTPResolver
/// ArResolver implementation handling http and https asset paths.
class HTTPResolver : public ArResolver
{
    // ... implementation!
};

plugInfo.json:
{
    "Plugins": [
        "Info": {
            "Types": {
                "HTTPResolver" : {
                    "bases": ["ArResolver"],
                    "uriSchemes": ["http", "https"]
                }
            }
        },
        ...
     ],
     ...
}

```

```cpp
ArGetResolver().Resolve("https://...") => HTTPResolver
ArGetResolver().Resolve("/foo/bar/...") => ArDefaultResolver

```

```cpp
httpResolverContext.h/.cpp:

/// \class HTTPResolverContext
/// Context object for use with ArResolverContext that provides extra
/// information when resolving http and https asset paths.
class HTTPResolverContext
{
    HTTPResolverContext(const std::string& username, const std::string& password);
    // ...
};

```

```cpp
ArResolverContext ctx({
    HTTPResolverContext("user", "12345"),
    ArDefaultResolverContext({"/search/dir/1", "/search/dir/2"})
});

UsdStage newStage = UsdStage::Open(..., ctx);

```

```cpp
ArResolverContext ctx_1({
    ArDefaultResolverContext({"/search/dir/3", "/search/dir/4"})
});

ArResolverContext ctx_2({
    HTTPResolverContext("user", "12345"),
    ArDefaultResolverContext({"/search/dir/1", "/search/dir/2"})
});

ArResolverContextBinder binder_2(ctx_2);

// Create a new UsdStage that will bind ctx_1 when resolving asset paths.
// In particular, this means that the HTTPResolverContext specified in
// ctx_2 should not be used when resolving asset paths on this stage,
// even though no HTTPResolverContext object was specified in ctx_1.
UsdStage newStage = UsdStage::Open(..., ctx_1);

```

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

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

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

### 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();
}
```

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

### 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"
}
}
}
...
}
]
}
```

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

### StartRender()

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

Starts the rendering process.

```APIDOC
## StartRender()

### Description
Starts the rendering process.

### Method
Control

### Signature
void StartRender()

### Parameters
None

### Returns
None
```

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

### SpatialAudio example with Speech and Ambient prims

Source: https://openusd.org/release/user_guides/schemas/usdMedia/SpatialAudio.html

Shows a typical SpatialAudio setup with a spatial Speech prim nested under a Cube and a non-spatial Ambient prim. The Speech plays once from start to end for 10 seconds, while Ambient loops for the entire stage duration.

```usda
#usda 1.0
(
    defaultPrim = "World"
    endTimeCode = 2400
    startTimeCode = 0
    timeCodesPerSecond = 24
)

def Xform "World"
{
    def Cube "Cube"
    {
        double3 xformOp:translate = (1, 5, -2)
        uniform token[] xformOpOrder = ["xformOp:translate"]

        def SpatialAudio "Speech"
        {
            uniform token auralMode = "spatial"
            uniform timecode endTime = 480
            uniform asset filePath = @mySpeech.mp3@
            uniform token playbackMode = "onceFromStartToEnd"
            uniform timecode startTime = 240
        }
    }

    def SpatialAudio "Ambient"
    {
        uniform token auralMode = "nonSpatial"
        uniform asset filePath = @myAmbientTrack.mp3@
        uniform token playbackMode = "loopFromStage"
    }
}

```

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

### Example solarSystem.usda with references, inheritance, and variants

Source: https://openusd.org/release/usdfaq.html

Illustrative .usda file showing composition operators: class inheritance, references to planet.usda, and variant selection. This example is not a model for asset structure.

```usda
#usda 1.0

class "_class_Planet"
{
    bool has_life = False
}

def Xform "SolarSystem"
{
    def "Earth" (
        references = @./planet.usda@</Planet>
    )
    {
        bool has_life = True
        string color = "blue"
    }

    def "Mars" (
        references = @./planet.usda@</Planet>
    )
    {
        string color = "red"
    }

    def "Saturn" (
        references = @./planet.usda@</Planet>
        variants = {
            string rings = "with_rings"
        }
    )
    {
        string color = "beige"
    }
}

```

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

### Get value at earliest TimeCode with Usd.TimeCode.EarliestTime()

Source: https://openusd.org/release/user_guides/time_and_animated_values.html

Get the attribute value at the earliest TimeCode in the set. For the example values, this returns 5 at TimeCode 3.

```python
earliestValue = translate_attr.Get(Usd.TimeCode.EarliestTime())
```

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

### Launch Katana with the tutorial scene

Source: https://openusd.org/release/tut_end_to_end.html

Run this command from the root of the endToEnd tutorial directory to open the shot in Katana. The USD file is read via the provided PxrusdIn node, an optional camera is merged to work around a known rendering issue, and a simple light is created in the gaffer node.

```bash
katana assets/simple.katana

```

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

### 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
)
{
}
```

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

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

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

### 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 []
```

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

### Get value before a TimeCode with Usd.TimeCode.PreTime()

Source: https://openusd.org/release/user_guides/time_and_animated_values.html

Get the attribute value just prior to a given TimeCode, evaluating the limit from the left. Useful for attributes with held interpolation or dual-valued knots. For the example values, this returns 10.0 at TimeCode 25.

```python
preValue = translate_attr.Get(Usd.TimeCode.PreTime(25))
```

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

### Open the stage in usdview

Source: https://openusd.org/release/tut_helloworld.html

Launches usdview to visualize and inspect the HelloWorld.usda stage.

```bash
$ usdview HelloWorld.usda

```

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

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

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

### Iterate over a TimeCodeRange with UsdUtils.TimeCodeRange

Source: https://openusd.org/release/user_guides/time_and_animated_values.html

Creates a closed TimeCodeRange using the stage's start and end time codes with a stride of 2, then iterates to get an attribute value at each time code. Negative stride values are allowed only if the start time code is greater than or equal to the end time code.

```python
timeCodeRange = UsdUtils.TimeCodeRange(stage.GetStartTimeCode(),
                                       stage.GetEndTimeCode(), 2)
for timeCode in timeCodeRange:
    print(f"At TimeCode {timeCode}, attribute value is: "
          f"{example_attribute.Get(timeCode)}")

```

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

### 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})
```

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

### Distance Joint Implementation in USDA

Source: https://openusd.org/release/wp_rigid_body_physics.html

A complete USDA example showing a dynamic box connected to a fixed box using a PhysicsDistanceJoint. The setup includes a PhysicsScene and applies PhysicsCollisionAPI and PhysicsRigidBodyAPI to the relevant primitives.

```usda
#usda 1.0

# Shows a dynamic box connected
# to a fixed box with a distance joint.
(
    defaultPrim = "World"
    endTimeCode = 100
    metersPerUnit = 0.01
    startTimeCode = 0
    timeCodesPerSecond = 24
    upAxis = "Z"
    kilogramsPerUnit = 1.0
)

def Xform "World"
{
    def PhysicsScene "physicsScene"
    {
    }

    def Cube "StaticBox" (
        prepend apiSchemas = ["PhysicsCollisionAPI"]
    )
    {
        color3f[] primvars:displayColor = [(0.64705884, 0.08235294, 0.08235294)]
        double size = 100
        quatf xformOp:orient = (1, 0, 0, 0)
        float3 xformOp:scale = (0.1, 1, 0.1)
        double3 xformOp:translate = (0, 0, 1000)
        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
    }

    def Cube "DynamicBox" (
        prepend apiSchemas = ["PhysicsCollisionAPI", "PhysicsRigidBodyAPI"]
    )
    {
        color3f[] primvars:displayColor = [(0.2784314, 0.64705884, 1)]
        double size = 100
        float3 velocity = (0, 0, 0)
        quatf xformOp:orient = (1, 0, 0, 0)
        float3 xformOp:scale = (0.1, 1, 0.1)
        double3 xformOp:translate = (0, 120, 1000)
        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
    }

    def PhysicsDistanceJoint "DistanceJoint"
    {
        rel physics:body0 = </World/StaticBox>
        rel physics:body1 = </World/DynamicBox>
        float3 physics:localPos0 = (0, 60, 0)
        float3 physics:localPos1 = (0, -60, 0)
        quatf physics:localRot0 = (1, 0, 0, 0)
        quatf physics:localRot1 = (1, 0, 0, 0)
        float physics:maxDistance = 50
        float physics:minDistance = 10
    }

    def SphereLight "SphereLight"
    {
        float intensity = 30000
        float radius = 150
        double3 xformOp:translate = (650, 0, 1150)
        uniform token[] xformOpOrder = ["xformOp:translate"]
    }
}
```

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

### Python: Blocking primvar attribute with Block()

Source: https://openusd.org/release/user_guides/primvars.html

Shows how calling Block() on the primvar attribute only blocks the elements, not the indices. The example opens a USD stage, gets the primvar, and blocks the attribute, then prints the flattened stage.

```python
stage = Usd.Stage.Open("faceVarying-example.usda")

prim = stage.GetPrimAtPath("/faceVarying")

primvar_api = UsdGeom.PrimvarsAPI(prim)

# If you call Block() on the primvar attribute, this will only block the
# elements, not the indices

primvar = primvar_api.GetPrimvar("primvars:displayColor")
primvar.GetAttr().Block()

print(stage.ExportToString())

```

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

### Full ExecUsd evaluation example with TF_AXIOM checks

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

Complete example that opens a UsdStage, creates an ExecUsdSystem, builds a request for local-to-world transforms of two prims, prepares and computes the request, then extracts and verifies the resulting matrices. Uses TF_AXIOM to assert the expected translations.

```cpp
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/tf/diagnosticLite.h"
#include "pxr/base/vt/value.h"
#include "pxr/exec/execGeom/tokens.h"
#include "pxr/exec/execUsd/cacheView.h"
#include "pxr/exec/execUsd/request.h"
#include "pxr/exec/execUsd/system.h"
#include "pxr/exec/execUsd/valueKey.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/usd/usd/stage.h"
#include <utility>
#include <vector>

PXR_NAMESPACE_USING_DIRECTIVE;

void Example()
{
    // Open the layer that contains our scene on a UsdStage.
    const UsdStageRefPtr stage = UsdStage::Open("xformPrims.usda");

    // Create an ExecUsdSystem, which we will use to evaluate computations on
    // the stage.
    ExecUsdSystem execSystem(stage);

    // Create a vector of value keys that indicate which computed values we are
    // requesting for evaluation.
    std::vector<ExecUsdValueKey> valueKeys {
        {stage->GetPrimAtPath(SdfPath("/Root/A1")),
         ExecGeomXformableTokens->computeLocalToWorldTransform},
        {stage->GetPrimAtPath(SdfPath("/Root/A2")),
         ExecGeomXformableTokens->computeLocalToWorldTransform},
    };

    // Build the request.
    const ExecUsdRequest request =
        execSystem.BuildRequest(std::move(valueKeys));

    // Prepare the request, ensuring the data flow graph is compiled and the
    // schedule is created.
    execSystem.PrepareRequest(request);

    // Evaluate the data flow graph according to the schedule, to yield the
    // requested computed values.
    ExecUsdCacheView cache = execSystem.Compute(request);

    // Extract the values.
    VtValue value;
    value = cache.Get(0);
    const GfMatrix4d a1LocalToWorld = value.Get<GfMatrix4d>();
    value = cache.Get(1);
    const GfMatrix4d a2LocalToWorld = value.Get<GfMatrix4d>();

    // The resulting matrices are the concatenation of the transforms
    // authored on A1 and Root and A2 and Root, respectively. Here, we
    // extract the translations from the resulting matrices, demonstrating
    // that we end up with the expected net translations necessary to
    // translate points in each local space into world space.
    TF_AXIOM(GfIsClose(
        a1LocalToWorld.ExtractTranslation(), GfVec3d(1, 2, 0), 1e-6));
    TF_AXIOM(GfIsClose(
        a2LocalToWorld.ExtractTranslation(), GfVec3d(1, 0, 3), 1e-6));
}
```

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

### 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;

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

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

### len() function examples

Source: https://openusd.org/release/user_guides/variable_expressions.html

Shows how to use len() to get the number of elements in a list or string, and to sanity check that a list is not empty before accessing it with at(). The first example returns the length of assetList or errors if undefined or not a list/string. The second returns 5 for the string "hello". The third uses len() in an if() to return the first element of assetList if non-empty, otherwise a default path.

```usda
# returns number of elements in assetList, or error if assetList undefined or not a list or string
len(${assetList})

# returns 5
len("hello")

# sanity check assetList has at least one element, and if so, return the 0th index element
# otherwise return a default path string
if( gt(len(${assetList}), 0), at(${assetList},0), "defaultAssetPath")
```

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

### 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();
```

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

### USD SpatialAudio Example with Ambient and Spatial Sounds

Source: https://openusd.org/release/wp_usdaudio.html

A complete USD file defining two SpatialAudio prims: 'AmbientSound' (non-spatial, looping) and 'WoodysVoice' (spatial, once from start). It shows usage of filePath, auralMode, playbackMode, startTime, mediaOffset, and xformOp translate.

```usda
#usda 1.0
(
   upAxis = "Z"
   endTimeCode = 200
   startTimeCode = 1
   timeCodesPerSecond = 24
)

def Xform "Sounds"
{
    def SpatialAudio "AmbientSound"
    {
        # We need not encode startTime, mediaOffset, or level as the fallback
        # values suffice for ambient sound.  Playback will begin at timeCode 1
        uniform asset filePath       = @AmbientSound.mp3@
        uniform token auralMode      = "nonSpatial"
        uniform token playbackMode   = "loopFromStage"
    }

    def SpatialAudio "WoodysVoice"
    {
        # SpatialAudio xform.  This prim might typically be located
        # as a child of the "Woody" model so that it's location need
        # only be specified relative to Woody, rather than replicating
        # Woody's animation
        double3 xformOp:translate     = (3.0, -3.0, 2)
        uniform token[] xformOpOrder  = ["xformOp:translate"]


        # SpatialAudio Properties.  We have left the playbackMode at its
        # fallback of "onceFromStart", so we do not require an endTime:
        # the sound will play to completion
        uniform asset  filePath       = @WoodysVoice.mp3@
        uniform token  auralMode      = "spatial"
        uniform timeCode startTime =  65.0
        # Skip the first third of a second in WoodysVoice.mp3
        uniform double mediaOffset    =  0.33333333333
    }
}

```

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

### Python: Access UI hints via ObjectHints API vs metadata

Source: https://openusd.org/release/user_guides/schemas/usdUI/overview.html

Shows how to use UsdUI.ObjectHints.GetDisplayName() to get a display name, which returns an empty string when not authored, while direct metadata access returns None. The example uses a prim with an empty uiHints dictionary.

```python
# "PrimWithNoHints" is a prim with an empty "uiHints" dictionary, e.g.
#    def "PrimWithNoHints" (
#        uiHints = {}
#    )
#    {
#    }
noHintsPrim = stage.GetPrimAtPath('/PrimWithNoHints')
hints = UsdUI.ObjectHints(noHintsPrim)
# APIs will return an empty string 
print("NoHints: DisplayName from objHints: " + hints.GetDisplayName())
metadata = noHintsPrim.GetMetadata("uiHints")
# Metadata.get returns None if metadata doesn't exist
if metadata.get("displayName") is not None:
    print("NoHints: DisplayName from prim metadata: " + metadata.get("displayName"))

```

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

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

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

### Purpose inheritance example in USD

Source: https://openusd.org/release/user_guides/render_user_guide.html

Shows how purpose is inherited at render time. The prims Root, Prim, and InheritXform have no authored purpose or are not imageable, so they inherit from the closest imageable ancestor with an authored purpose. RenderXform has purpose render, GuideXform has purpose guide, and Xform has no authored purpose and no imageable ancestor, so it uses the fallback default.

```usda
def "Root" {
    token purpose = "proxy"
    def Xform "RenderXform" {
        token purpose = "render"
        def "Prim" {
            token purpose = "default"
            def Xform "InheritXform" {
            }
            def Xform "GuideXform" {
                token purpose = "guide"
            }
        }
    }
    def Xform "Xform" {
    }
}

```

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

### usdInitSchema command-line help

Source: https://openusd.org/release/toolset.html

Command-line help output for usdInitSchema, showing its usage, positional arguments (codeGenPath, libraryPath, pxrPrefix), and optional flags. Use this to understand required arguments and defaults, such as the template path search order and the --genModuleDeps flag for non-OpenUSD build systems.

```text
usage: usdInitSchema [-h] [-v] [-q] [--genModuleDeps] [-t TEMPLATEPATH]
                     codeGenPath libraryPath [pxrPrefix]

Set up build necessities for schema classes. This will generate templates for
the CMakeLists.txt, __init__.py, schema.usda, module.cpp, and a user doc if
they do not already exist.

positional arguments:
  codeGenPath           The target directory where the code should be
                        generated. Can be '.' for the current directory.
  libraryPath           The partial path with which to prefix '#include'
                        statements of generated files for this module. For
                        external (non-Pixar) plugins, we recommend setting
                        libraryPath to ".", so that the headers inside src
directory are included in the generated files.
  pxrPrefix             Prefix to the path from pxr to this library. For
                        pxr/usd/usd, the prefix would be pxr/usd. Omit this
                        argument for non-OpenUSD build systems.

optional arguments:
  -h, --help            show this help message and exit
  -v, --validate        Verify that the source files are unchanged.
  -q, --quiet           Do not output text during execution.
  --genModuleDeps       Generates a template for the moduleDeps.cpp. This
                        template will need to be filled in and kept up to date
                        with library dependencies if you are not using the
                        OpenUSD build system.
  -t TEMPLATEPATH, --templates TEMPLATEPATH
                        Directory containing schema class templates. [Default:
                        first directory that exists from this list:
                        <usd install dir>/bin/codegenTemplates:<usd install dir>
                        /lib/usd/usd/resources/codegenTemplates]
```

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

### faceVarying interpolation for Mesh primvars:displayColor

Source: https://openusd.org/release/user_guides/primvars.html

Two USD Mesh examples that use faceVarying interpolation for primvars:displayColor. The first shows the basic setup with eight colors matching the faceVertexIndices order. The second adds the faceVaryingLinearInterpolation attribute set to "all" to control linear interpolation for boundaries and interior of each face on subdivision surfaces.

```usda
#usda 1.0
(
)

def Mesh "faceVarying"
{
    float3[] extent = [(-1, 0, 0), (1, 1, 0)]
    point3f[] points = [(-1, 0, 0), (-1, 1, 0), (0, 1, 0), (0, 0, 0), (1, 1, 0), (1, 0, 0)]
    int[] faceVertexCounts = [4, 4]
    int[] faceVertexIndices = [3, 2, 1, 0, 5, 4, 2, 3]

    color3f[] primvars:displayColor = [(0,0,1), (0,0,0.75), (0.75,0,0), (1,0,0),
                                       (0,0,1), (0,0,0.75), (0.75,0,0), (1,0,0)] (
        interpolation = "faceVarying"
    )

    double3 xformOp:translate = (0, 0, -10)
    uniform token[] xformOpOrder = ["xformOp:translate"]
}

```

```usda
#usda 1.0
(
)

def Mesh "faceVarying"
{
    float3[] extent = [(-1, 0, 0), (1, 1, 0)]
    point3f[] points = [(-1, 0, 0), (-1, 1, 0), (0, 1, 0), (0, 0, 0), (1, 1, 0), (1, 0, 0)]
    int[] faceVertexCounts = [4, 4]
    int[] faceVertexIndices = [3, 2, 1, 0, 5, 4, 2, 3]

    color3f[] primvars:displayColor = [(0,0,1), (0,0,0.75), (0.75,0,0), (1,0,0),
                                       (0,0,1), (0,0,0.75), (0.75,0,0), (1,0,0)] (
        interpolation = "faceVarying"
    )

    # Configure the face-varying interpolation rule for this surface
    token faceVaryingLinearInterpolation = "all"

    double3 xformOp:translate = (0, 0, -10)
    uniform token[] xformOpOrder = ["xformOp:translate"]
}

```

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

### 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)
```

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

### 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);
```

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

### 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)
```

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

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

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

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

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

### Get (static)

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

Gets the UsdLuxPluginLight at the given path on the stage.

```APIDOC
## Get (static)

### Description
Gets the UsdLuxPluginLight at the given path on the stage.

### Method
Get

### Parameters
- **stage** (const UsdStagePtr &) - Required - The stage.
- **path** (const SdfPath &) - Required - The path.

### Returns
UsdLuxPluginLight
```

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

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

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

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

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

### usdGenSchema usage help

Source: https://openusd.org/release/toolset.html

Displays the command-line interface options and arguments for the usdGenSchema tool.

```text
usage: usdGenSchema [-h] [-v] [-q] [-n NAMESPACE [NAMESPACE ...]]
                    [-t TEMPLATEPATH] [-hts HEADERTERMINATORSTRING]
                    [schemaPath] [codeGenPath]

Generate C++ schema class code from a USD file.

positional arguments:
  schemaPath            The source USD file where schema classes are defined.
                        [Default: ./schema.usda]
  codeGenPath           The target directory where the code should be
                        generated. [Default: .]

optional arguments:
  -h, --help            show this help message and exit
  -v, --validate        Verify that the source files are unchanged.
  -q, --quiet           Do not output text during execution.
  -n NAMESPACE [NAMESPACE ...], --namespace NAMESPACE [NAMESPACE ...]
                        Wrap code in this specified namespace. Multiple
                        arguments will be interpreted as a nested namespace.
                        The leftmost argument will be treated as the outermost
                        namespace, with the rightmost argument as the
                        innermost.
  -t TEMPLATEPATH, --templates TEMPLATEPATH
                        Directory containing schema class templates. [Default:
                        first directory that exists from this list:
                        <usd install dir>/bin/codegenTemplates:<usd install dir>
                        /lib/usd/usd/resources/codegenTemplates]
  -hts HEADERTERMINATORSTRING, --headerTerminatorString HEADERTERMINATORSTRING
                        The string used to terminate generated C++ header
                        files, after the custom code section. [Default:
                        #endif]
```

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

### 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 (static)

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

Gets the UsdLuxCylinderLight prim at the given path on the stage.

```APIDOC
## Get (static)

### Description
Gets the UsdLuxCylinderLight prim at the given path on the stage.

### Method
Get

### Signature
`Get(const UsdStagePtr &stage, const SdfPath &path)`

### Parameters
- **stage** (UsdStagePtr) - Required - The stage.
- **path** (SdfPath) - Required - The path of the prim.

### Returns
UsdLuxCylinderLight

### Inherited From
UsdLuxCylinderLight
```

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

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

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

### 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 program instance.

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

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

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

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

### Get (static)

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

Gets the capsule prim at the given path on the stage.

```APIDOC
## Get (static)

### Description
Gets the capsule prim at the given path on the stage.

### Method
Get (static)

### Signature
`static UsdGeomCapsule_1 Get(const UsdStagePtr &stage, const SdfPath &path)`

### Parameters
- **stage** (UsdStagePtr) - Required - The stage on which to get the prim.
- **path** (SdfPath) - Required - The path of the prim.

### Returns
- **UsdGeomCapsule_1** - The capsule prim.
```

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

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

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

### int64 expression variable examples

Source: https://openusd.org/release/user_guides/variable_expressions.html

Examples of 64-bit integer expression variables.

```usda
int64 exampleInt = 43
int64 exampleIntNeg = -500

```

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

### 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)
```

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

### Flattened primvar example

Source: https://openusd.org/release/user_guides/primvars.html

Shows the result of flattening the indexed primvar from the previous example.

```text
[element1-partA, element1-partB, element2-partA, element2-partB, element1-partA, element1-partB]

```
Tokens:
Raw