| On this page | |
| Since | 17.0 |
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 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 save path metadata set to their own USD files.
-
You can use the
Configure Layer LOP to assign/change a save 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 save path where the geometry will be written when you write out USD. -
Save paths should be specified as absolute paths, often using global variables such as HIP (
$HIP/props/lamp.usd). During the save process, theUSD node by default will use an output processor that translates these absolute paths to relative references between the layer files, which makes it easy to move all the layer files from one location to another. -
The Flush Data After Each Frame parameter on the render node controls whether it writes out data to disk after calculating each frame. This option can be used to generate a sequence of USD files each containing a single time sample (for example,
lamp_0001.usd,lamp_0002.usd, and so on), or single files containing time sample data from all frames, depending on whether the output file name or save paths contain a time-varying component (such as$F).
Saving animation ¶
The Flush Data After Each Frame parameter on the USD render node controls whether it writes data out after each frame of data is generated. This feature can be used to create individual files containing the data for each frame, or arbitrarily large files containing time sample data across all frames.
When the USD render node writes out a frame range with Flush Data After Each Frame off:
-
For each frame the ROP will generate a set of layers ready to be saved to disk, but which still exist in-memory.
-
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 enable this option to limit Houdini to only have a single frame’s data in memory at any one time. The result may take longer to write to disk, and the final file size may be larger than with this option disabled. But the amount of data that can be written will not be limited by the computer’s available memory.
Another approach is to write out a sequence of USD files each containing a single time sample of data, then using the 
USD Stitch Clips ROP to generate a USD value clip. This approach only works if there is an isolated branch in the scene graph tree where the large data set exists, and the data for this branch can be written to a separate USD file.
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
.usdaextension, 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.
-
The
$SAVEDPATHSlocal variable gets set to a space separated list of all files written out by this ROP. This variable can be used in the Post-Frame or Post-Render script parameters to allow the creation of scripts that operates on all these saved files.
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 Flush Data After Each Frame parameter controls whether to write out data to disk after each frame, or to generate animated data in memory before writing out all the data at once.
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.
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.
Strip Layers Above Layer Breaks
Enable this option to prevent layers authored above Layer Break nodes from being written to disk by this ROP. This allows a Layer Break node to dictate which portions of the LOP Network are to be saved. Disabling this option allows this behavior to be overridden, forcing the full stage authored by the LOP network to be written to disk. This may be used for debugging purposes, or to write a complete scene to disk for rendering.
Strip Post-Layers
Enable this option to prevent layers added using the hou.LopNetwork.editablePostLayer method from being written to disk. With this option disabled, these post-layers are flattened into the layer Output file layer.
Flush Data After Each Frame
When this is on, the node writes out each frame’s data to disk before cooking the LOP Network to generate the next frame of data. When this is off (the default), the node cooks the data for all frames into memory and writes out the animated files all at once. Turning on this option ensures that only a single frame worth of data is in RAM at any one time, allowing arbitrarily large USD files to be created. But saving each frame can be slightly slower, and the generated files may be larger because of the way USD files append new data to an existing file. See saving animation above.
When this option is on, this ROP can also generate separate USD files for each frame. To do this, embed the local variable for the current frame number in the Output file path (and other layer save paths) so each frame will write out files with unique names. For example:
$HIP/usd/scene_$F4.usd
See expression in filenames for more information.
Track Primitive Existence to Set Visibility
LOP networks may generate vastly different scene graphs from one frame to the next. When combining these scene graphs over a frame range into a single animated scene graph, the set of primitives in the combined scene graph will be the union of the primitives in each frame’s hierarchy. But if a mesh appears at frame 50, this generally means that it is desired for this mesh to not be visible prior to frame 50. Enable this option to cause this node to track a list of all primitives at each frame, and automatically author animated visibility attributes for any primitives that are added to or removed from the scene graph over time. This gives the appearance of primitives being added and removed over time.
Only subclasses of UsdGeomImageable primitives will be tracked this way, since these are the only USD primitive types which respect the visibility attribute.
Use Network Drive Safe Save (Windows Only)
When running on Windows, the USD library often has issues saving layers to network mounted drives when those layers are currently loaded into a USD stage. This can make it impossible to overwrite a USD layer that is in use, even by the current Houdini session. This option works around this issue by having the USD ROP mute each layer right before ti is saved to disk (but only when running under Windows - on Linux and MacOS this parameter has no effect). Once the layer is saved, it is un-muted. This approach incurs a performance penalty as any stages using this layer will be recomposed twice instead of once. But in some settings this can make the save process much more robust.
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. This can be useful for generating more portable USD layers that rely on a minimal number of external layers. It can also be used to “harden” the sublayered files on disk in their current state if they may be changing, but you are generating a USD file for archiving purposes and do not want it to reflect any upcoming changes to the external files.
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. This can be useful for generating more portable USD layers that rely on a minimal number of external 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.
Copy All Assets to Referencing Layer Directory
This processor makes copies of all non-USD assets (such as UDIMs, texture maps, and volume files) in the same directory as the USD file that references them. The USD file is updated to refer to these local copies of the assets. These updated references will use absolute paths, so it is recommended that you use this in conjunction with a Use Relative Paths output processor. This localizing of assets makes it much easier to create USDZ archives of assets, since that format requires texture maps and similar assets to be in or contained under same directory holding the USD file.
This processor has an Output subdirectory parameter which causes the assets to be copied into a specific subdirectory inside the directory where the USD file is being written. This parameter should be a relative path, such as textures, not a full path to a directory.
USD assets are not localized because doing so would break relative path references within those USD files. If USD data must also be localized to a single directory, it is recommended that this be accomplished by setting the Save Style on the USD ROP to Flatten Stage, which will gather all USD data into a single layer.
If an asset file doesn’t exist, or the asset file is already located in the same directory or any subdirectory of the referencing layer file, the asset is not copied.
This output processor should be moved above the “Use Relative Paths” output processor to ensure that the asset paths written to the USD file produce the simplest possible paths to the localized file locations.
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
This options ensures that the upAxis and metersPerUnit metadata is set in every USD file written to disk. If a value has not been explicitly authored on a layer by the LOP Network, the default up axis and meters per unit values from the Lighting Preferences are used.
Context options ¶
Set ROP Cook Context Options
Controls whether this node sets the @ropcook, @ropstart, @ropend, and @ropinc context options when rendering. If enabled, these context options are automatically set to 1 for @ropcook, and the values of the Start, End, and Increment Frame values from this node for @ropstart, @ropend, and @ropinc. Using these standard context options it is easier to set up predictable behavior for Cache LOPs, LOPs that create ranges of time sampled values, and LOP nodes that are only used for generating viewport previews or final rendered output.
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).
Scripts ¶
A script command can be specified for execution at various execution points. The expression language selected for the script parameter determines whether the command is in hscript or python.
Prior to execution, this node is automatically set as the global current node.
To run statements from a file, specify the path to the file with
either a .cmd extension (when the language is set to Hscript) or a .py
extension (when the language is set to Python). Additional arguments to the
script can also be supplied. They will be parsed in a shell-like manner.
Pre-Render Script
Run this script before any rendering.
Pre-Frame Script
Run this script before each frame.
Post-Frame Script
Run this script after each frame.
Post-Render Script
Run this script after all rendering.
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.
