OpenUSD Library Tour

Platform specific code, and a few very low level utilities for things like malloc hooks.

The main math library. Provides types for linear algebra and for specific graphics needs like cameras and frustums.

JSON file reader/writer, built on rapidjson. This is only used in C++, python should use the python json library.

The plugin system. Loads plugins and handles reading the pluginfo.json files USD uses.

A large set of reusable C++ classes and code.

Tf provides the basic features for providing python bindings and for hosting python interpreters.

It has a logging system, a runtime type system, string formatting, the token type for registering strings, a reference counted pointer type, a notification callback system, and utilities for mutexes, RAII objects, environment variables, file i/o... I'm sure I missed a few things.

A system for tracking performance using instrumented functions. USD has a lot of this instrumentation built-in, so enabling this can give good performance feedback. Trace can output traces in chrome tracing format.

This is extremely new as of the time of writing and is still in flux. Ts provides support for a spline value object, which USD hasn't supported until now. Previously you would need to roll your own solution, or use timesampled animation instead of splines.

I honestly have no idea what the T stands for.

Provides dynamically sized containers for plain old data types and Gf math types. Vt arrays and other sized types are copy-on-write, saving a lot of time passing buffers around, and can even support copy free passing of buffers to and from python.

Vt also provides a type-erased value type VtValue that is used often in USD apis, especially for communicating with Python. VtDictionary and VtValue together can marshal Python dictionaries to and from C++

Wraps TBB to offer some easily called multithreading utilities. Also manages dispatch and the thread pool

Implements the asset resolver base classes users can derive from, and provides a default resolver. Resolvers take paths from usd composition arcs and remap them to the layers you actually open.

Has some python apps and some that require C++. usdcat, usdedit and other applications that don't use imaging are all here.

Kind is a sort of type system for telling which prims are models, groups of models, etc. The available kinds are extensible.

Most terms for type systems are already taken. If you've already got class, model, type, what can you call this? This is called "kind" in the sense of "what kind of thing is it?" "Oh, it's that kind."

An extremely generic library for storing node types, of the sort you might use in a shading graph, or composition, etc. Underpins several other libraries that need to have nodes with properties and connections.

This is a cache for what USD calls "composition." When you load a USD Stage and it reads in a network of layers for your scene, pcp caches the traversal information and data so that lookups are fast.

Contains some of the file type plugins USD ships with. Has support for Alembic, Osl and Draco files at the time of writing.

Usd is the library that deals with whole stages and scenes, which are collections of files. Sdf is the library that deals with individual files only. If you use Sdf to open a Usd file that has references the references are not read in. You open only that file, not a stage.

Sdf also provides the SdfPath type, defines what value types are valid in Usd files, and defines the text usda format.

Builds on ndr to create nodes that are suitable for shader networks. Sdr is shading language agnostic, it just stores node networks without understanding the shaders that underpin them. It's up to the imaging code to turn these into real shaders.

Usd has the Stage type, and defines the basic Usd Prim type, Usd Property and Attribute types, utilities for stage traversal and editing, and much more. The Usd library is the core feature-set of OpenUsd as a whole.

I'm not going to break these out individually, because there are lots and this is already too long. Each of these provides concrete schemas for USD prim types. Some highlights

• usdGeom 🔸 Mesh, Xform, Sphere, ...
• usdShade 🔸 Material, Shader, ...
• usdLux 🔸 DistantLight, DomeLight, ...
• usdSkel 🔸 Skeleton, BlendShape

GfCamera provides low level math for cameras, this library provides utilities for modeling more real world cameras. There's math related to filmback, output windows, and other practical things.

Platform wrappers for OpenGL. This is used in the Storm Hydra render delegate, which renders using OpenGL.

Utilities for generating things like cones, cuboids, cylinders. Note that this does not generate USD prims, only geometry for rendering.

Code for managing glContexts, draw targets, materials, etc. The main OpenGL driving classes for Storm.

This is the core hydra library. Hydra is a framework that takes one or more scene graphs as input and converts them into data fed to one or more renderer. It's used as a plugin in many digital content creation tools to display USD viewport renders.

A Hydra 2.0 feature. Generate procedural information at render time.

Utilities for working with MaterialX shader networks.

The core OpenGL renderer used by the Hydra Storm render delegate. Note that the delegate plugin itself is in the imaging/plugin/hdStorm folder.

A Hydra 2.0 utility to assist with Usd asset resolution.

A Hydra 2.0 library that provides a variety of scene index types.

Useful utilities for applications that embed Hydra. Code for fullscreen shaders, selection in a viewport, colorizing, etc.

Provides a plugin system for Hydra, using the base/plug library underneath.

I honestly don't know what this one stands for, and perusing the source didn't help.

Base classes for wrapping a GPU library like OpenGL, Vulkan, Metal, etc. Provides a common api for Hydra to use.

Hgi implementations for these graphics APIs.

Code for reading glslfx files, OpenVDB files, images (using openimageio or stb)

Render delegates for Storm, Embree and Prman are in here

Support for working with OpenSubdiv for subdivision surfaces

usdview, usdrecord, and other helpful applications.

Contains high level shader plugins. The reference implementation for UsdPreviewShader is here, along with some other interesting code.

These are helpers used in usdview and usdrecord

This is the Hydra 1.0 Scene Delegate that ships with USD. It's what feeds USD stages into Hydra for rendering, and it's used in usdview and many other real time USD renderers. It still works with Hydra 2.0, but in the future may be replaced by a higher performance alternative built on Hydra 2.0 natively.

This is the rendering engine usdview uses. It manages a Hydra instance and does things like highlight selection, implement picking and switch out the render delegates when requested.

I find the naming of this library a little strange. It isn't a version of the usdImaging scene delegate, but has a very similar name. It also isn't limited to OpenGL rendering. I suspect its just a legacy name. In any case, it's pretty cool.

This is a Hydra plugin that implements a "display adapter" for procedurals. Display adapters are plugins to Hydra that tell it how to render a type of Prim.

Hydra display adapters and filters for rendering with Renderman.

Hydra display adapters for showing skeleton guides

Hydra display adapters for rendering Volumes. Field3d and OpenVDB volumes are supported.

The Qt part of usdview. The UI and interactive parts of usdview are implemented here. The actual script that launches usdview is in usdImaging/bin