NVIDIA NCP-OUSD · Exam Weight: ~18%

NCP-OUSD: Content Aggregation, Instancing & Visualization

These two domains cover building large, efficient 3D scenes from modular assets and rendering them with geometry, materials, and lights — a combined 18% of the NCP-OUSD exam.

60–70 Questions 120 Minutes $200 Exam Fee 2-Year Credential

Core Concepts at a Glance

Modular Asset Design

Self-contained components with clear interfaces; built to be referenced, instanced, and overridden independently.

Instancing

Reuse one prim's definition across many scene locations with zero data duplication. Native instancing = prototype; point instancing = PointInstancer.

UsdGeom

USD's geometry domain: Mesh, Xform, Camera, Scope, Points, BasisCurves, Capsule, Cube, Sphere.

UsdShade / UsdLux

Material binding model (Material → Shader nodes); lighting prims (SphereLight, DomeLight, RectLight, DistantLight, CylinderLight).

Exam Domain Breakdown

Domain	Weight	Key Topics
Content Aggregation	~10%	Modular asset design, model hierarchies, asset interfaces, parallel layer organization, collaborative scene building, instancing
Visualization	~8%	UsdGeom (meshes, cameras, Xform), UsdShade (materials, shaders, NodeGraph), UsdLux (lights), rendering properties

Content Aggregation Concepts

Modular Asset Structure

Standard asset file layout: payload.usda (geometry, heavy data), look.usda (materials), asset.usda (root that references payload + look)
Model hierarchy: component (leaf asset) → assembly (group of components) → group
Model kinds: component, assembly, group, subcomponent — set via prim.SetKind("component")
Asset interface: the public "API surface" of an asset — which attributes and variants are designed to be overridden; use customData = {string[] ui:editorHints = ["..."]}
Parallel layer organization: separate files per department (anim.usda, fx.usda, look.usda) combined via subLayers or references

from pxr import Usd, Kind

stage = Usd.Stage.Open("asset.usda")
prim = stage.GetPrimAtPath("/World/Tree")

# Set model kind
modelAPI = Usd.ModelAPI(prim)
modelAPI.SetKind(Kind.Tokens.component)

# Check kind
kind = modelAPI.GetKind()
print(f"Kind: {kind}")  # component

Native Instancing

Mark a prim as instanceable: prim.SetInstanceable(True)
Instanceable prims with identical composition arcs share one in-memory prototype
prim.IsInstance() → True; prim.GetPrototype() → the shared prototype
Restrictions: cannot author opinions inside an instance (must edit the prototype); cannot nest instanceable prims
Best for: trees, rocks, props — anything repeated with identical appearance

from pxr import Usd, UsdGeom

stage = Usd.Stage.Open("scene.usda")

# Create multiple instances of the same asset
for i in range(10):
    prim = stage.DefinePrim(f"/World/Tree_{i}", "Xform")
    # Add reference to the asset
    prim.GetReferences().AddReference("./tree_asset.usda")
    # Mark as instanceable — shares a prototype with identical composition arcs
    prim.SetInstanceable(True)

# Check instance status
tree = stage.GetPrimAtPath("/World/Tree_0")
print(tree.IsInstance())       # True
print(tree.GetPrototype())     # Returns shared prototype prim

Point Instancing (PointInstancer)

UsdGeom.PointInstancer: scatter many instances at arbitrary positions/orientations/scales efficiently
Key attributes: positions (point3fArray), orientations (quatfArray), scales (float3Array), protoIndices (intArray), prototypes (relationship to prototype prims)
Much more efficient than placing individual prim copies for large crowds/vegetation
instancer.GetPositionsAttr().Set(positions, time) for animated instances

from pxr import Usd, UsdGeom, Gf, Vt
import numpy as np

stage = Usd.Stage.CreateNew("forest.usda")

# Define prototype
treePrim = stage.DefinePrim("/Prototypes/Tree", "Xform")
treePrim.GetReferences().AddReference("./tree.usda")

# Create PointInstancer
instancer = UsdGeom.PointInstancer.Define(stage, "/World/Forest")

# Set prototype relationship
instancer.CreatePrototypesRel().SetTargets(["/Prototypes/Tree"])

# Generate 10,000 random positions
n = 10000
positions = Vt.Vec3fArray(n, [Gf.Vec3f(np.random.uniform(-100, 100),
                                        0,
                                        np.random.uniform(-100, 100))
                               for _ in range(n)])
instancer.GetPositionsAttr().Set(positions)

# All instances use prototype index 0
protoIndices = Vt.IntArray(n, [0] * n)
instancer.GetProtoIndicesAttr().Set(protoIndices)

stage.Save()

Overriding Instanced Assets

Edit the prototype directly (authored in its own layer) to affect all instances
Use references + variant sets on the referencing prim for per-instance look variants
over specs layered on top of a referenced asset to override specific attributes
Cannot use local opinions inside an instance prim — must go through the prototype or a variant

# Override via variant set on the referencing prim (NOT inside the instance)
stage = Usd.Stage.Open("scene.usda")
treePrim = stage.GetPrimAtPath("/World/Tree_0")

# Add variant set for seasonal appearance
varSets = treePrim.GetVariantSets()
varSet = varSets.AddVariantSet("season")
varSet.AddVariant("summer")
varSet.AddVariant("autumn")

varSet.SetVariantSelection("autumn")
with varSet.GetVariantEditContext():
    # Override the material reference for autumn look
    matPrim = stage.OverridePrim("/World/Tree_0/Looks/LeafMat")
    matPrim.GetReferences().AddReference("./autumn_leaves.usda")

Visualization Concepts

UsdGeom — Geometry Domain

UsdGeom.Mesh: faceVertexCounts (int[]), faceVertexIndices (int[]), points (point3f[]), normals (normal3f[]), primvars:st (texCoord2f[], faceVarying)
UsdGeom.Xform: transform prim; xformOps: xformOp:translate, xformOp:rotateXYZ, xformOp:scale; xformOpOrder controls evaluation order
UsdGeom.Camera: projection (perspective/orthographic), focal length, aperture, clippingRange, fStop
UsdGeom.Scope: grouping prim with no transform; used for organizing (e.g., /World/Geometry, /World/Lights)
UsdGeom.BasisCurves: hair, fur, wires; UsdGeom.Points: particles

from pxr import Usd, UsdGeom, Gf, Vt, Sdf

stage = Usd.Stage.CreateNew("mesh_example.usda")

# Create a simple quad mesh
mesh = UsdGeom.Mesh.Define(stage, "/World/Quad")

# Required attributes
mesh.GetPointsAttr().Set(Vt.Vec3fArray([
    Gf.Vec3f(-1, 0, -1), Gf.Vec3f(1, 0, -1),
    Gf.Vec3f(1, 0,  1), Gf.Vec3f(-1, 0,  1)
]))
mesh.GetFaceVertexCountsAttr().Set(Vt.IntArray([4]))
mesh.GetFaceVertexIndicesAttr().Set(Vt.IntArray([0, 1, 2, 3]))

# UV texture coordinates (primvars:st, faceVarying interpolation)
st = UsdGeom.PrimvarsAPI(mesh).CreatePrimvar(
    "st", Sdf.ValueTypeNames.TexCoord2fArray,
    UsdGeom.Tokens.faceVarying
)
st.Set(Vt.Vec2fArray([
    Gf.Vec2f(0,0), Gf.Vec2f(1,0),
    Gf.Vec2f(1,1), Gf.Vec2f(0,1)
]))

# Xform transform
xform = UsdGeom.Xform.Define(stage, "/World/Root")
UsdGeom.XformCommonAPI(xform).SetTranslate(Gf.Vec3d(0, 5, 0))

stage.Save()

UsdShade — Materials & Shaders

UsdShade.Material: container for shading network; bound to geometry via material:binding relationship
UsdShade.MaterialBindingAPI(prim).Bind(material) — apply material to prim
UsdShade.Shader: individual shader node; info:id identifies the shader type (e.g., "UsdPreviewSurface")
UsdPreviewSurface inputs: diffuseColor (color3f), metallic (float), roughness (float), opacity (float), normal (normal3f)
NodeGraph: container for a subgraph of shaders; promotes reuse
UsdShade.ConnectableAPI for managing shader connections

from pxr import Usd, UsdShade, Sdf, Gf

stage = Usd.Stage.Open("scene.usda")

# Create Material
matPath = Sdf.Path("/World/Looks/MetalMat")
material = UsdShade.Material.Define(stage, matPath)

# Create UsdPreviewSurface shader
shaderPath = matPath.AppendChild("PBRShader")
shader = UsdShade.Shader.Define(stage, shaderPath)
shader.CreateIdAttr("UsdPreviewSurface")

# Set PBR inputs
shader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set(Gf.Vec3f(0.2, 0.4, 0.8))
shader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.9)
shader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.1)
shader.CreateInput("opacity", Sdf.ValueTypeNames.Float).Set(1.0)

# Connect shader surface output to material
shaderOutput = shader.CreateOutput("surface", Sdf.ValueTypeNames.Token)
material.CreateSurfaceOutput().ConnectToSource(shaderOutput)

# Bind material to geometry prim
meshPrim = stage.GetPrimAtPath("/World/Quad")
UsdShade.MaterialBindingAPI(meshPrim).Bind(material)

stage.Save()

UsdLux — Lighting

All lights inherit UsdLuxLightAPI: intensity (float), color (color3f), exposure (float), enableColorTemperature (bool), colorTemperature (float)
UsdLux.SphereLight: radius (float); soft area light
UsdLux.DomeLight: texture:file (asset); HDR environment map
UsdLux.RectLight: width, height; area light
UsdLux.DistantLight: angle (float); sun-like directional light
UsdLux.CylinderLight, DiskLight also available
Light linking: lightLink and shadowLink collections to control what geometry a light affects

from pxr import Usd, UsdLux, Sdf, Gf

stage = Usd.Stage.Open("scene.usda")

# DomeLight — HDR environment map (image-based lighting)
dome = UsdLux.DomeLight.Define(stage, "/World/Lights/EnvLight")
dome.CreateIntensityAttr(1.0)
dome.CreateTextureFileAttr().Set(Sdf.AssetPath("./hdri/studio.exr"))

# SphereLight — soft omnidirectional area light
sphere_light = UsdLux.SphereLight.Define(stage, "/World/Lights/KeyLight")
sphere_light.CreateIntensityAttr(5000.0)
sphere_light.CreateColorAttr().Set(Gf.Vec3f(1.0, 0.95, 0.9))
sphere_light.CreateRadiusAttr(0.3)

# DistantLight — directional sun light
sun = UsdLux.DistantLight.Define(stage, "/World/Lights/Sun")
sun.CreateIntensityAttr(10.0)
sun.CreateAngleAttr(0.53)  # angular diameter in degrees
sun.CreateColorTemperatureAttr(6500.0)
sun.CreateEnableColorTemperatureAttr(True)

# RectLight — rectangular area light
rect = UsdLux.RectLight.Define(stage, "/World/Lights/FillLight")
rect.CreateWidthAttr(2.0)
rect.CreateHeightAttr(1.0)
rect.CreateIntensityAttr(2000.0)

stage.Save()

Memory Hooks

Conceptual anchors to lock in key distinctions for exam day.

"Component → Assembly → Group"

Model kind hierarchy. A component is a leaf asset. An assembly groups components. A group organizes without a fixed structure. Set with prim.SetKind().

"Native Instance = Prototype sharing"

prim.SetInstanceable(True) makes it share a prototype with all identical peers. Can't author inside an instance — edit the prototype.

"PointInstancer = 10,000 trees at 60fps"

For large repeated instances (crowds, vegetation), PointInstancer is far more efficient than individual prim copies. Uses positions + protoIndices arrays.

"Bind Material via API"

UsdShade.MaterialBindingAPI(prim).Bind(material). The geometry prim needs the API applied; the material lives elsewhere in the hierarchy.

"UsdPreviewSurface = PBR shorthand"

diffuseColor + metallic + roughness + opacity = the 4 most tested attributes. info:id = "UsdPreviewSurface".

"DomeLight = HDRI environment"

DomeLight with texture:file pointing to an EXR/HDR provides image-based lighting. SphereLight = soft point source. DistantLight = sun.

Practice Quiz

Question 1 of 10

What attribute on UsdGeom.Mesh stores the number of vertices per face?

Question 2 of 10

Which Python call applies a UsdShade.Material to a geometry prim?

Question 3 of 10

What model kind describes a leaf asset that is self-contained (e.g., a single prop)?

Question 4 of 10

Which restriction applies to native instanceable prims?

Question 5 of 10

What is the primary advantage of UsdGeom.PointInstancer over placing individual prim copies?

Question 6 of 10

Which UsdLux light type is used for HDR image-based lighting via an environment map?

Question 7 of 10

What is the correct UsdGeom attribute for texture coordinates on a Mesh?

Question 8 of 10

Which USD schema provides a container prim with no transform for organizing scene hierarchy?

Question 9 of 10

What does the `info:id` attribute on a UsdShade.Shader specify?

Question 10 of 10

To create a scene with 50,000 trees using one mesh definition, which approach is most efficient?

Flashcards

Click any card to flip it.

Model kinds in USD

tap to flip

component (leaf asset, self-contained), assembly (group of components), group (organizational), subcomponent (part within a component). Set via prim.SetKind('component').

Native instancing vs PointInstancer

tap to flip

Native: prim.SetInstanceable(True) — identical prims share one prototype. PointInstancer: scatter instances at arbitrary positions with positions/protoIndices arrays — best for thousands of instances.

UsdGeom.Mesh required attributes

tap to flip

faceVertexCounts (int[] — verts per face), faceVertexIndices (int[] — vertex indices), points (point3f[] — vertex positions). Optional but common: normals, primvars:st.

Material binding in UsdShade

tap to flip

Apply UsdShade.MaterialBindingAPI to a geometry prim. Call .Bind(material). The material:binding relationship connects the prim to the Material prim in the shading hierarchy.

UsdPreviewSurface key inputs

tap to flip

diffuseColor (color3f), metallic (float 0–1), roughness (float 0–1), opacity (float 0–1), normal (normal3f), emissiveColor (color3f). info:id = 'UsdPreviewSurface'.

UsdLux light types

tap to flip

SphereLight (soft point, has radius), DomeLight (HDRI environment via texture:file), RectLight (area, width×height), DistantLight (sun-like directional, has angle), CylinderLight, DiskLight.

xformOps on UsdGeom.Xform

tap to flip

Operators: xformOp:translate, xformOp:rotateXYZ (or rotateX/Y/Z), xformOp:scale, xformOp:transform (full matrix). xformOpOrder attribute controls evaluation order.

Parallel layer organization

tap to flip

Different departments author to separate layers (anim.usda, look.usda, fx.usda) which are composed via subLayers or references. Nobody overwrites each other — all layers contribute opinions non-destructively.

Study Advisor

🎯 Exam Strategy

Visualization questions often test specific attribute names (faceVertexCounts, primvars:st, info:id). Content Aggregation questions test model kinds and instancing concepts. Know the difference between native instancing and PointInstancer.

📚 Core Resources

NVIDIA Learn OpenUSD Module 6 "Asset Structure Principles"; Module 8 "Asset Modularity and Instancing"; USD Schema docs at openusd.org; UsdPreviewSurface spec.

💻 Hands-On Practice

Create a simple UsdPreviewSurface material and bind it to a Mesh; scatter 100 instances with PointInstancer; experiment with model kinds using prim.SetKind().

⚠️ Common Mistakes

Forgetting that you cannot author inside an instance prim; confusing Scope (no transform) with Xform (has transform); mixing up primvars:st interpolation (usually faceVarying for UV maps).

🔗 Related Exam Topics

Instancing knowledge connects to Content Aggregation (10%) and Data Modeling (13%); UsdShade feeds into Pipeline Development (14%) where exporters must correctly export material networks.

Official Resources

NVIDIA NCP-OUSD Certification Page

Official exam overview, objectives, and registration information.

Learn OpenUSD Module 6 — Asset Structure Principles

NVIDIA's official module covering asset file layout, model kinds, and parallel layer organization.

Learn OpenUSD Module 8 — Asset Modularity & Instancing

Deep dive into native instancing, PointInstancer, and modular asset design patterns.

OpenUSD API Documentation

Complete API reference for UsdGeom, UsdShade, UsdLux, and all USD schemas.

UsdPreviewSurface Specification

Full specification for the UsdPreviewSurface shader including all input parameters.

Purchase your exam voucher and schedule your NCP-OUSD certification exam.

NCP-OUSD: Content Aggregation, Instancing & Visualization

Core Concepts at a Glance

Modular Asset Design

Instancing

UsdGeom

UsdShade / UsdLux

Exam Domain Breakdown

Content Aggregation Concepts

Modular Asset Structure

Native Instancing

Point Instancing (PointInstancer)

Overriding Instanced Assets

Visualization Concepts

UsdGeom — Geometry Domain

UsdShade — Materials & Shaders

UsdLux — Lighting

Memory Hooks

"Component → Assembly → Group"

"Native Instance = Prototype sharing"

"PointInstancer = 10,000 trees at 60fps"

"Bind Material via API"

"UsdPreviewSurface = PBR shorthand"

"DomeLight = HDRI environment"

Practice Quiz

What attribute on UsdGeom.Mesh stores the number of vertices per face?

Which Python call applies a UsdShade.Material to a geometry prim?

What model kind describes a leaf asset that is self-contained (e.g., a single prop)?

Which restriction applies to native instanceable prims?

What is the primary advantage of UsdGeom.PointInstancer over placing individual prim copies?

Which UsdLux light type is used for HDR image-based lighting via an environment map?

What is the correct UsdGeom attribute for texture coordinates on a Mesh?

Which USD schema provides a container prim with no transform for organizing scene hierarchy?

What does the info:id attribute on a UsdShade.Shader specify?

To create a scene with 50,000 trees using one mesh definition, which approach is most efficient?

Flashcards

Study Advisor

🎯 Exam Strategy

📚 Core Resources

💻 Hands-On Practice

⚠️ Common Mistakes

🔗 Related Exam Topics

Official Resources

What does the `info:id` attribute on a UsdShade.Shader specify?