Maya/Houdini USD Layout Creation

---

This toolset provides a solution for authoring USD layout layers directly within Maya or Houdini, which can then be used downstream for animation, rendering, etc.

Using Maya’s USD Proxy Shape node, it automates stage creation in Maya by generating a structured USD hierarchy that is consistent thourghout the pipe. I also updated an existing Houdini HDA, that sets up the same USD structure, allowing for layout creation or tweaking in either software.

The tool includes a set of custom Qt interfaces that query ShotGrid for the list of environments to build upon, and a list of assets to reference in. Artists can assign or replace layout contents using dropdowns and selection UIs, ensuring consistency with production-tracked assets. These selections drive the creation of reference prims, grouped by logical layout groupings, and organized under a user-defined hierarchy inside the USD stage.

I also developed tools in Maya and Houdini that allow for instant recreation of layouts published in the other software.

This allows layouts to be built and changed in Maya or Houdini regardless of the DCC used in previous work on this set. This works regardless of the step in produciton, or even whether or not assets are finished becuase of USD references. This lets anyone in the production pipline make layout edits that are instantly updated everywhere else.

Layout Artist: Isabella Francis

Altogether, this tool bridges the gap between DCCs, allowing layout to begin in Maya where artists are most comfortable, while ensuring compatibility and fidelity with downstream USD workflows in Solaris or any Hydra-compliant renderer.

Look Dev Pipeline

---

This tool streamlines the surfacing workflow across Substance Painter and Houdini by allowing artists to export textures that then get automatically built as RenderMan Material Layers.

In Substance Painter, users can link each texture set to a specific production asset regardless of how many texture sets are involved. This enables entire asset groups to be textured simultaneously, with all files automatically published to their correct destinations.

Upon export, the tool allows the user to specify metadata for each asset, including render pass type (e.g., hero, midground), material variant (e.g., dusty, wet), and geometry variant (e.g., damaged, clean).

It then automatically generates the correct folder structure, converts texture maps to .tex files optimized for RenderMan, and updates the ShotGrid database with any new variants. This ensures surfacing work is both technically correct and pipeline-aware, reducing the risk of asset mismatches in downstream departments.

The publishing tool builds on dungeons-pipeline export system, with significant enhancements including support for new variant types, batch publishing of textures across multiple assets, and extended export functionality for Renderman material layers.

Once textures are in place, a Houdini-side tool reads the variant data and automatically builds RenderMan layered materials using a Houdini HDA. Based on the assigned material and geometry variants, it creates networks that blend maps correctly, load the appropriate .tex files, and apply the correct shading models per object type. Artists don’t need to manually set up material networks, just select the asset, and the tool builds everything procedurally.

This tool significantly accelerates lookdev for building asset libraries and hero props by allowing for batched surfacing workflows while preserving full control over variant creation and material attributes. It also ensures that shading setups in Houdini match exactly what was exported from Substance, with no manual relinking.

Shotgrid API Bi-Directional Integration

---

I built upon the internal ShotGrid API used in our pipeline to support full bi-directional communication. Previously, the API was limited to read-only access, artists could only query data like tasks, users, or version history. I extended this functionality to allow write-access as well, enabling DCC tools to publish new data directly to ShotGrid without leaving the application.

I created a set of lightweight, extensible data structures to represent ShotGrid entities including User, Task, and Version. These structs are now used throughout the pipeline tools to query existing production data and to construct and submit new entities when artists publish. All entity creation logic follows our own schema and validation rules, so new records integrate seamlessly with scheduling and review systems.

With this update, publishing tasks and versions can now be triggered directly from Maya, Houdini, or Nuke using custom UI tools that wrap this new API. Artists can publish lookdev variants, shot versions, or rigging WIPs without needing to manually enter data in the ShotGrid web interface. This reduces context switching, increases data accuracy, and allows publishing tools to intelligently infer metadata based on the artist’s current scene or file.

This upgrade unlocked an entire layer of automation in our DCC tools, from asset publishing and task tracking to auto-linking dependencies across departments. The new API structure is also modular and ready to support future features like automated thumbnail generation, cross-app asset history, and pipeline event hooks.

Example: Publishing a New Version

            from pipe.db import DB
            from env_sg import DB_Config

            # Establish connection with ShotGrid
            conn = DB(DB_Config)

            # Get list of shots
            shots = conn.get_shot_code_list()

            # Get different entities in custom structs
            shot = conn.get_shot_by_code(shots[0])
            user = conn.get_user_by_name("Katie Willard")
            task = conn.get_tasks(shot, user)

            # Publish the version with custom attributes
            conn.create_version_for_shot(shot=shot,code="newer_version",
                                         user=user,task=task[0], "/path/to/mp4", 
                                         "shot_description")
            

---

© 2025 Dallin Clark · Built with HTML/CSS · Contact Me