Tool for Loading
Shot Loader
Context-aware department loading. Knows where you are in the hierarchy and presents appropriate options with inheritance visualization.
Unreal Engine Viewport
Final Pixels
Cascading USD Pipeline
Production Architecture for Film & Games
Architected a studio pipeline that bridges Houdini and Unreal Engine through USD—enabling artists to work at any scale while changes cascade automatically through the production.
Inversion Studio · Sole Technical Architect & Developer
USDHoudiniUnreal EnginePython
USD's Potential is Mostly Unrealized
The Problem
Most studios adopting USD treat it like a traditional pipeline with a different file format. They get some benefits—better interchange, composition arcs—but miss the deeper possibilities. USD is significantly more granular than traditional approaches, but the industry hasn't really figured out how to work with those building blocks effectively. Not in public, anyway.
The other challenge: making assets work across both film rendering and real-time engines. If a client decides they want a game built from film assets, you shouldn't need to rebuild everything. The pipeline should handle that from the start.
Treating USD Like Traditional Pipelines
If you just swap file formats without rethinking structure, you don't get USD's real benefits. The composition system enables patterns that traditional pipelines can't match.
Underused Granularity
USD lets you work at incredibly fine levels—per-attribute overrides, sparse layers, targeted opinions. Most pipelines don't take advantage of this flexibility.
Film-to-Game Friction
Assets built for film rendering often need significant rework for real-time engines. Different LOD requirements, different material systems, different optimization needs.
Coordination Overhead
More granular structures require different coordination patterns. The old ways of organizing work don't map cleanly onto USD's compositional model.
Level → Sequence → Shot Composition
Hierarchy as Specificity
We borrowed a concept from game engines: levels as organizational containers. But instead of just loading screens, our hierarchy is about specificity. Each tier adds precision to the one above it, letting you work at whatever granularity makes sense.
Levels handle large-scale placement—hero assets, environmental anchors, where sequences exist relative to each other. Sequences get more specific about what's needed throughout that portion of the story. Shots might store just transform data and shot-specific overrides.
This makes the shot pipeline significantly lighter and faster to iterate. But it requires different coordination than traditional pipelines—you're thinking about where information should live rather than duplicating it everywhere.
Level
General placement and large-scale assets. Useful for scouting, establishing spatial relationships between sequences, and placing environmental foundations.
Sequence
Sequence-specific assets and refinements. What does this portion of the story need? Assets and overrides here cascade to all shots in the sequence.
Shot
Often just cameras, transforms and targeted overrides. Because so much is inherited, shots become lightweight—focused only on what's unique to that moment.
Push-Style Control Without C++
Structural Versioning
USD has a built-in mechanism for version control called the Asset Resolver. It intercepts file path lookups and can redirect them to specific versions. The catch: it requires C++ implementation and needs to be compiled against each DCC's specific USD build.
We achieved similar push-style versioning through file structure alone. Every published file exists in two forms: a versioned file containing the actual work, and an unversioned 'pointer' file that references the current version. Downstream files reference the pointer, so they automatically receive updates.
This approach works across any DCC that reads USD—no custom resolver compilation required. When a shot is approved for delivery, a freeze operation replaces all pointers with their specific versioned references, locking that shot to exactly the versions used for approval.
Automatic Updates
Reference the pointer, get the latest version. Artists working downstream always see current work without hunting for version numbers.
Intentional Freezing
Lock a shot to specific versions for delivery. The freeze operation captures the exact state used for approval.
Audit Trail
Versioned files preserve history. Roll back to any previous state by changing which version the pointer references.
Department Independence
Each department publishes independently. Lighting doesn't wait for animation to version up—they reference the animation pointer and always get current work.
Translating between Houdini & Unreal
Cross-Engine Bridge
Houdini and Unreal Engine are both powerful, but they weren't designed to talk to each other. Different coordinate systems, different material models, different assumptions about how scenes are structured.
We built a translation layer. Assets publish from Houdini in both USD and traditional formats. A custom Unreal importer reads the published metadata, corrects transforms automatically, and recreates assets exactly as they appeared in Houdini—no manual rebuild or material assignments required.
A key design decision: if the client decided they wanted a game built from the film assets, we'd be ready. The asset publishing pipeline automatically generates LODs for meshes and textures that Unreal understands natively. Film assets become game-ready assets without a separate conversion pass.
Dual-Format Export
Assets publish in both USD and engine-native formats. Use USD for the full pipeline, traditional formats for direct engine import.
Transform Correction
Coordinate system differences handled automatically. What's oriented correctly in Houdini arrives correctly in Unreal.
Material Recreation
Materials authored in USD translate to Unreal materials with matching appearance. No manual shader rebuilding.
Automatic LOD Generation
Publishing generates mesh and texture LODs that Unreal understands natively. Film assets are game-ready from day one.
Specialization Hierarchy
Material Architecture
We borrowed another concept from game engines: material inheritance. Instead of creating unique materials for every asset, we built a hierarchy where materials specialize from shared parents.
A master 'weathered metal' material defines the core behavior—how rust spreads, how scratches reveal base metal, how dirt accumulates. Specialized children inherit this behavior but swap in asset-specific textures. The memory efficiency is dramatic: dozens of assets sharing base textures, each with only their unique maps loaded.
Time-based variations add another dimension. An asset might have pristine, weathered, and damaged states. Rather than separate materials, we use blend parameters that transition between states—with unique values per variation that can be overridden at any hierarchy level.
Inherited Behavior
Child materials inherit shading logic from parents. Update the parent, and all children reflect the change.
Asset-Specific Overrides
Each asset variant can override specific textures or parameters without duplicating the entire material.
Time Variations
Pristine to damaged states controlled by parameters. Each asset variant carries its own blend values.
Memory Efficiency
Shared base textures loaded once. Only unique maps per asset add to memory footprint.
Structure Without Friction
Artist-Friendly Tooling
Tool for Loading
Asset Loader
Discovers all variants and published departments for any asset. Works in both SOP and USD/LOP workflows.
Tool for Publishing
Section Publishing
Departmental work publishes through guided interfaces that validate structure before export. Artists focus on their work; the system ensures consistency.
Tool for Publishing
Validation Pipeline
Pre-publish checks verify structural integrity, completeness, and cross-references. Errors surface before they propagate downstream.
Raw Footage
Integrated with UE Render
What This Enabled
Production Impact
The pipeline transformed how the studio approached production. Artists spent less time on technical overhead and more time on creative work. Updates that previously required manual propagation through dozens of files happened automatically.
The three-tier hierarchy proved especially valuable for environment-heavy sequences. Layout artists could establish an entire level once, with downstream shots inheriting that work automatically. When client feedback required environment changes, updates propagated without the usual shot-by-shot rebuild.
Cross-engine flexibility meant Houdini's procedural power could feed directly into Unreal's real-time environment. The translation layer we built removed what had been a significant friction point in the studio's hybrid workflow.
Reduced Manual Overhead
Version tracking, reference updating, and format translation—previously manual tasks—became automatic.
Faster Iteration
Changes at any hierarchy level propagate immediately. Client revisions no longer meant days of file updates.
Flexible Granularity
Work at the scope that makes sense—level-wide changes, sequence-specific overrides, or shot-level precision.
Cross-Engine Workflow
Houdini and Unreal became partners rather than endpoints. Work flows between them with context preserved.
