Houdini 18.0 Nodes Render nodes

USD render node

Renders a LOP network out to one or more USD files. This node is available as render node or as a LOP.

On this page

Tip

This node renders out USD files. To render images from a LOP network, use the Karma render node or USD Render render node.

Where the files go

  • In the USD render node, you specify a file path (in the Output file parameter) for the "top-level" USD file, containing data from the root layer.

    In addition to this file, the node writes any layers that have their file path metadata set to their own USD files.

  • Layers that were imported from disk remember their file paths and are written out to those paths, relative to the top-level file.

  • You can use the Configure Layer LOP to assign/change a file path for any layer in the network. When you render to USD the layer will be written out to disk.

  • The SOP Import LOP and SOP Create LOP also let you specify a file path where the geometry will be written when you write out USD.

  • File paths in Houdini are usually specified relative to the HIP file ($HIP/props/lamp.usd), while paths in USD are recommeded to be relative to the top-level file (./props/lamp.usd). The USD render node has a default output processor that translates paths to be relative to the top-level file as the node writes the USD.

  • The Separate file per frame parameter on the render node controls whether it writes out individual files for each frame (for example, lamp_0001.usd, lamp_0002.usd, and so on) or files containing time sample data from all frames.

Saving animation

The Separate file per frame parameter on the USD render node controls whether it writes out individual files containing the data for each frame, or files containing time sample data across all frames.

When the USD render node writes out a frame range with Separate file per frame off:

  1. For each frame the ROP will generate a set of layers ready to be saved to disk, but which still exist in-memory.

  2. It uses USD Stitch to combine the generated frames with previously cooked frames in-memory.

If the LOP Network is generating a lot of data, this can quickly use a lot of memory (even though the stitch operation does not duplicate data which is the same from frame to frame).

If you find writing out animated USD runs out of memory in Houdini, you can instead save out separate layer files per-frame, and use USD Stitch or USD Stitch Clips to batch-combine them from disk, either into layers containing time samples, or into a set of value clips.

Tips

  • This node writes output files when you click Save to disk, or when you click the Render flag on the node (in a render network), or when the node is triggered by an input dependency (in a render network).

  • You can add this node to a render node network, or put it at the end of a lop node network.

  • If you set an output path to have a .usda extension, the node will write them using the text format. This may occasionally be useful for debugging. Note that writing out textual files is slow compared to the regular binary format.

  • If the node doesn’t seem to be generating a file it should, double check if you have patterns in the Files to save parameter.

Parameters

Save to Disk

Click to write out the layers generated by a LOP network to USD files.

Save to Disk in Background

Starts another copy of Houdini in the background and instructs that copy to cook and save the USD files generated by the LOP network. This allows one to continue working in the current Houdini session.

Controls

Click to open a dialog that lets you launch a "one-off" render with different frame range and dependency settings.

Valid Frame Range

See saving animation above for more information.

Render Current Frame

Render the current frame number (in the playbar).

Render Frame Range

Render each frame in the range set by the Start/End/Inc parameters below. The Separate file per frame parameter controls whether to write out separate files for each frame, or write out files containing time samples for all frames.

Render Frame Range (Strict)

The "Render Frame Range" option may generate frames outside the given range if they're requested by a render dependency. If you choose this option, this node will never render frames outside the given range.

Render Frame Range From Stage

Examines the USD stage of the source LOP node for a start and end timecode value. These are used as the start and end of the frame range to save to disk. If the stage does not have this metadata set, executing a save operation will result in an error.

Start/End/Inc

When Valid frame range is "Render frame range" or "Render frame range (strict)", the start and end frames (inclusive) and interval.

Preroll/Postroll/Inc

When Valid frame range is "Render stage’s frame range", the number of frames before and after the stage’s official start and end frame to save, and the interval between time samples.

Render with Take

Render with the parameter values stored in this take.

LOP Path

Node path to the LOP node whose output this node will render. If this node is in a LOP network and you connect its input, the node disables and ignores this parameter, and renders the data from the input instead.

Output File

The "top-level" USD file to write the root layer to. Other layers that have file path metadata set will be written to their own USD files. A default output processor (see below) translates external file references in nodes to be relative to this file’s directory, as is recommended.

Separate File Per Frame

When this is on, the node writes out individual files containing the data for each frame. When this is off (the default), the node writes out files containing time samples across all frames. See saving animation above.

When this is on, you should embed the local variable for the current frame number in the Output file path so it writes out frame files with unique names. For example:

$HIP/usd/scene_$F04.usd

See expression in filenames for more information.

Save Style

This node can apply some transformations to the layer stack before writing out files. These transformations do not affect the final composed stage, only the number of layer files generated.

Flatten Implicit Layers (Collapse Implicit Sublayers, Preserve References)

The default. Composes anonymous in-memory layers down onto the nearest layer with a file path (so the node will write out any layers that have file path metadata to separate USD files). This preserves references, variants, and other composition arcs.

Flatten All Layers (Combine All Sublayers, Preserve References)

This composes all layers (both anonymous layers and layers with file paths) into a single layer. This preserves references, variants, and other composition arcs, so the node may still write out more than one file if external files were referenced in.

Separate Layers (Preserve All Sublayers and References)

Don’t compose any layers in any way. Even anonymous in-memory layers will be saved out to their own files (you should turn off Error saving layers with implicit paths so the node doesn’t error trying to save anonymous layers).

This may be useful for debugging, especially in combination with debug flags on nodes, to see what each LOP node is doing.

When the node has to write out a layer without file path metadata, it will automatically generate a relative file path based on information such as the node path of the node that generated the layer.

Flatten Stage (Collapse All Sublayers and References)

This flattens all layers into a single stage, and "bakes in" all composition arcs, even variant selections. This discards information such as which opinions came from which layer, and unused variants. This writes out a single USD file.

This may be useful if you want to "delete history" and make it seem like it a file wasn’t composed from layers, references, variants, and so on.

Tip

If you want to "preserve history" but want the convenience and portability of a single file, use the USD Zip render node to generate a .usdz file.

Extra files

Files to Save

A list of patterns matching which files the node is allowed to save. If this is blank (the default), the node saves all files. You can use this, for example, to avoid rewriting layer files that you know will never change.

Error Saving Layers With Implicit Paths

When this is on (the default), the node errors if it would otherwise write an anonymous in-memory layer (that is, a layer with no file path metadata) to disk.

You will usually only turn this off if you are using the Save style "Separate layers" to write out every layer separate for debugging purposes.

Save Updates to Modified Files From Disk

If you use the Load Layer LOP to bring a layer onto the stage, this "editable" version of the layer on disk has metadata marking it as originally coming from disk, rather than being created from scratch by LOPs. When this is on, layers created this way are saved to disk just like any other layer with file path metadata.

Turning this off prevents saving these layers to disk. This can be useful if you never want these "edited from disk" layers to overwrite the original files, or at least prevent overwriting them until you are certain the output of the LOP network is correct, when you can allow the edited layers to be written to disk.

Flatten File Layers

When Save Style is "Flatten Implicit Layers", files loaded from disk with a Sublayer LOP are not considered anonymous layers, and so are not composed down. Turn this on to flatten layers from disk as if they were anonymous layers.

Flatten SOP Layers

When Save Style is "Flatten Implicit Layers", layers generated by importing data from SOPs with SOP Import are not considered anonymous layers, and so are not composed down. Turn this on to flatten layers imported from SOPs as if they were anonymous layers.

Output processing

Output Processors

Add an output processor to this node. Output processors are Python plugins that can alter the file locations and file path strings used for external files. The USD render node starts with one default output processor (called Use Relative Paths, see below).

(See output processors for information on how to write an output processor plugin.)

The following built-in processors are available:

Use Relative Paths

This is automatically added by default. This processor changes absolute file paths to relative paths in layer files. This allows you to use paths such as $HIP/usd/foo.usd for loading, but have them written out as paths relative to the source file. This is recommended practice so you probably do not want to remove this processor.

Make Output Layer Extension

Normally, if you change the extension of the output file, it only affects that "top-level" output file. All other external files are written to their embedded save paths, with their embedded extension. This processor changes the extension on all paths to match the extension of the output file. This means if you change the output file to use .usda (the textual format), when this processor is active, all external USD files will also switch to .usda.

Save Paths Relative to Output Path

Causes any Save Path parameters that are relative paths to be treated as if they are relative to the Output File parameter value. This makes it easy to ensure all files generated by a LOP network are saved into a common root directory. Changing the save location of the output file will implicitly change the save location of all other files.

This processor has a Root Directory parameter which, if set, specifies a location other than the Output File to which Save Paths will be considered relative.

Use Search Paths

This processor includes a Search Path parameter. Each asset path is compared against the directories listed in this path. If the asset is inside one of the search paths, the asset will be referenced with a search path rather than a full path or relative path.

Layer metadata

Default Primitive

Set this to the name of a root primitive on the current stage to set it as the default primitive for the top-level file.

Error Saving Layer With No Default Primitive

When this is on, the render node will error and stop cooking if you haven’t specified a default primitive for all layers being written out.

This is a way to force yourself to make sure layers have default prims, so you know you can reference in files without having to manually specify a top-level prim.

Save ROP’s Time Information to Output

Write the start and end frames, as well as the current frames per second setting, to the top-level output file.

Clear Houdini-Specific Custom Data

LOP networks often attach Houdini-specific custom data to layers, prims, and properties. Houdini does not need this data to be stored on disk (usually it is related to how to write files), so by default Houdini strips out this data before saving. Normally there’s no reason to turn this parameter off (it’s possible it might help SideFX diagnosing a problem).

Ensure Basic Metrics are Set on All Layers

???

Context options

Number of Options

Lets you specify context options that only apply while writing out files from this node. Set the number of context options to define/override, or use the plus and minus buttons to add or remove options.

You could have two separate USD render nodes with different context options, so they would write out different USD from the same LOP network depending on uses of @contextoption references in expressions. This could be useful for wedging, or to cause the LOP network to configure the stage in ways that are not good for interactively, but should be written to disk.

Option Name

For each option, the name of the option. You can reference this option in an expression using @name.

Option Type

For each option, the type of data stored in the option, either a floating point number of a string.

Option Value

For each option, the value of the option (while this node writes out USD).

Pre-Render Script

This command is run once, before any files are generated.

Pre-Frame Script

This command is run before each frame is generated.

Post-Frame Script

This command is run after each frame is generated.

Post-Render Script

This command is run once, after all files have been generated.

Initialize Simulation OPs

Initialize DOP simulations before rendering.

Alfred Style Progress

Print percentage complete value as files are written. This is in the style expected by Pixar’s Alfred render queue.

Report Network Use

Print the number of bytes sent or received by the distributed simulation nodes during cooks triggered by this node.

This does not track network usage from, for example, saving a file to an NFS mount. It only tracks the network communication of distributed Houdini nodes.

Render nodes

  • Agent

    This output operator is used to write agent definition files.

  • Alembic

  • Archive Generator

    Generates disk-based archives which can be used by either mantra or RIB renderers.

  • Bake Animation

    Bakes animation from object transforms and CHOP overrides.

  • Bake Texture

    Generates a texture map from one or more objects' rendered appearance.

  • Batch

    Renders the input ROP in a single batch job.

  • Brick Map Generator

    Allows you to convert Houdini volume primitives into Pixar brickmap files.

  • Channel

    The Channel output operator generates clip files from a particular CHOP.

  • Composite

    The Composite output operator renders the image(s) produced in the Compositing Editor.

  • DSM Merge

    Merges two or more deep shadow/camera map files.

  • Dynamics

    Saves the state of a DOP network simulation into files.

  • Fetch

    Makes a dependency link to a ROP in a different network.

  • Filmbox FBX

    Exports entire scenes to FBX files.

  • Frame Container

    Prevents frame dependency changes in the contained nodes from affecting its inputs.

  • Frame Depedency

    Allows an output frame to depend on one or more input frames.

  • Geometry

    Generates geometry files from a SOP or DOP network.

  • HQueue Render

    HQueue, or Houdini Queue, is a distributed job scheduling system.

  • HQueue Simulation

    HQueue, or Houdini Queue, is a distributed job scheduling system.

  • Hair Card Texture

    Renders hair textures for use on hair cards.

  • Karma

    Renders the USD scene using Houdini’s Karma renderer (Beta).

  • MDD Point Cache

    This output operator is used to write an MDD animation file.

  • Mantra

    Renders the scene using Houdini’s standard mantra renderer and generates IFD files.

  • Mantra Archive

    Generates disk-based archives which can be used by mantra.

  • Merge

    Merges several render dependencies into one.

  • Net Barrier

    Blocks the ROP network until synchronization occurs.

  • Null

    Does nothing.

  • OpenGL

    Render an image using the hardware-accelerated 3D viewport renderer.

  • Pre Post

    Renders ROPs before and after a main job.

  • Render nodes

    Render nodes either render the scene or set up render dependency networks.

  • RenderMan

    Renders the scene using Pixar’s RenderMan renderer.

  • RenderMan

    Renders the scene using Pixar’s RenderMan RIS renderer.

  • RenderMan Archive

    Generates disk-based archives which can be used by RenderMan .

  • Shell

    Runs an external command.

  • Subnetwork

    The SubNetwork output operator provides an easy way to manage large number of output operators.

  • Switch

    Renders one of several inputs.

  • Tractor

    Tractor is a program shipped out with Pixar’s distribution of RenderMan.

  • USD

    Renders a LOP network out to one or more USD files. This node is available as render node or as a LOP.

  • USD Render

    Renders an output image from the stage generated by a LOP network.

  • USD Stitch

    Merges USD files representing individual frames by composing them.

  • USD Stitch Clips

    Merges multiple value clips representing individual frames.

  • USD Zip

    Assembles USDZ archive files from existing USD files.

  • Wedge

    Re-renders the same ROP multiple times with different settings

  • Wren

    This output operator is used to drive the Wren rendering program.

  • glTF

  • glTF