NVIDIA OpenUSD Development

Composition is how USD builds one scene from many files. You stack layers, bring in other assets with references and payloads, and learn how opinions combine into the value you finally see.

• The layer stack and sublayer order
• References and what they bring in
• Payloads and deferred loading
• Opinions and how values resolve
• Path translation and namespace editing
• Authoring with edit targets

You build A scene assembled from sublayers, references and a payload, with the opinion order documented.

Strength ordering decides which opinion wins. You learn LIVERPS, use inherits and specializes, work through cases where arcs interact in surprising ways, and predict a result before you run the code.

• LIVERPS and the strength ordering
• Inherits and class prims
• Specializes and how it differs
• Arcs inside references and payloads
• Hard cases: arcs through several levels
• Predicting and checking resolved values

You build A set of composition puzzles, each with a prediction checked against the stage.

Variants and overrides let many artists change one scene without touching its source. You author variant sets and selections, set fallbacks, and layer overrides so that any change can be traced and removed.

• Variant sets and variant selections
• Nested variants and variant fallbacks
• Authoring overrides in a separate layer
• Active state, visibility and purpose
• Layer-based workflows for departments
• Removing and reverting edits cleanly

You build An asset with variants and a department override layer that changes it without editing the source.

When a scene looks wrong, the cause is usually one opinion in one layer. You use stage inspection tools and composition queries to trace values to their source, and find badly authored data before it spreads.

• usdview and its inspectors
• usdcat, usdtree and usddiff
• Prim composition queries in Python
• Tracing an attribute to the layer that set it
• Validating with usdchecker
• Common authoring mistakes and their symptoms

You build A debugging guide with five broken scenes and the trace that explains each.

Reusable assets need structure. You build components and assemblies with proper model kinds, organize asset layers, and keep packaging consistent so that teams can swap parts and trust what they get.

• Model kinds: component, assembly and group
• Building a component asset
• Assembling larger scenes from components
• Asset interfaces and naming conventions
• Payloads and model hierarchy for performance
• Validating an asset against a contract

You build A modular component library and an assembly built from it.

Large scenes depend on sharing. You use native instancing and point instancers to reduce memory, decide where each applies, and override properties on instanced models without losing the sharing.

• Native instancing and prototypes
• Point instancers and their data
• Choosing between the two
• Overriding instanced models
• Instance proxies and editing rules
• Measuring memory savings

You build An instanced scene with overrides and a memory comparison against the uninstanced version.

Most scenes are meshes, cameras, materials and lights. You author them through their schemas, assign materials by binding, set primvars and units, and check the results in a viewer.

• Xforms, meshes and curves in UsdGeom
• Cameras and units
• Primvars and interpolation
• Materials and bindings in UsdShade
• Preview surface shading networks
• Lights in UsdLux
• Purposes and visibility

You build A small lit scene with a bound material network and a camera, authored in code.

Sometimes the built-in schemas are not enough. You define custom schemas and generate their code, write file format plugins, and set model kinds and variant fallbacks that match how your studio works.

• When to extend and when not to
• Writing a schema definition
• Generating schema code with usdGenSchema
• Registering plugins with plugInfo files
• Writing a file format plugin
• Setting global variant fallbacks
• Versioning custom schemas

You build A custom API schema, built and registered, used in a working scene.

Data exchange decides how well USD fits a pipeline. You plan mapping documents for another tool’s data, write importers and exporters, preserve units, axes and naming, and check what survives a round trip.

• Mapping documents: planning the translation
• Writing an exporter to USD
• Writing an importer from USD
• Units, up-axis and coordinate systems
• Preserving names, hierarchy and metadata
• Testing round trips
• Handling data that does not map

You build A mapping document and a working exporter for a simple scene format.

A pipeline is more than scripts. You design asset structure and versioning, add exporter hooks, build and package tools reliably, and flatten assets for delivery to systems that cannot compose layers.

• Asset structure and naming
• Asset resolvers and versioned paths
• Exporter hooks and publishing steps
• Build and packaging for USD tools
• Flattening layers and exporting stages
• Packaging assets as USDZ
• Migrating existing assets safely

You build A publishing pipeline that versions an asset, runs checks and flattens it for delivery.

Slow stages cost every artist time. You measure stage open time and render cost, find the layers, prims and settings that cause them, and apply payloads, instancing and cleanup to bring both down.

• Measuring stage open and population time
• Profiling with trace tools
• Payloads and load rules for large scenes
• Heavy prims and badly authored data
• Render time and scene complexity
• Verifying that a fix helped

You build A performance report that cuts the load time of a heavy scene, with before and after numbers.

Build a miniature production pipeline. You author modular assets, assemble a scene with variants and instancing, extend it with a custom schema, move data in from another tool, and debug and optimize the result.

• Designing the asset and scene structure
• Authoring assets and variants
• Assembling and instancing a scene
• Importing data and extending the schema
• Debugging, optimizing and delivering

You build A working mini pipeline: modular assets, an assembled scene, a custom schema and a delivery step.