Disable motion blur by setting the camera to have an instantaneous shutter time.

Comma or Space separated list of primitives that have to included in the render. If this is enabled, all other primitives will be omitted.

Enabling this will append all cameras found in the stage, as well as the render settings (assuming they're in /Render) to the population mask.

Comma separated list of purposes to render (from geometry, guide, proxy, and render). The default is geometry,render.

This setting is defined by USD and Hydra to control for the number of iterations to use to render “refine-able” (subdivision) surfaces. Karma mostly ignores this setting, since it measures the surface in screen space to decide how many iterations it needs to render the surface smoothly. Instead Karma uses this setting more like a subdivision on/off switch. If this is set to Low or Medium, Karma renders the (chunky) hull. If it is High or Very High, Karma renders the (smooth) limit surface.

Other renderers (such as RenderMan or Storm) will treat this setting differently, using it to determine subdivision quality. If you need to render the same scene in Karma and another renderer, remember to use High or Very High to make sure Karma renders subdivision surfaces smoothly.

When saving OpenEXR images with multiple AOVs, husk will normally save the images using multi-part EXR files. This extension (introduced in 2013) lets programs read a single AOV without having to read the entire image. This allows most software to work much more efficiently.

Some applications have not transitioned to support multi-part images. If your pipeline uses software that doesn’t support OpenEXR v2.0, this option will force husk to write out images in an inefficient, but more compatible format.

Enable render delegate products. These allow render delegates to save non-raster products like deep images or photon maps. These render products are render delegate specific.

Normally, when rendering sequences, husk uses UDS delta operations to make rendering more efficient. The delegate is only told about scene data that changes frame-to-frame so it can share work between frames.

This option will force the render delegate to be restarted when rendering sequences.

Since restarting the delegate will cause the scene to be rebuilt, using this option can have significant performance impact and should only be used if required.

When this is on, the renderer writes out a snapshot file and partial image at every interval of this many seconds.

When this is on, the renderer will terminate if the render time limit is exceeded. Time Limit is measured in seconds. Note that husk will save the partial result before terminating.

When rendering multiple frames in a single process (Render All Frames With a Single Process), the time limit specified is applied per image rather than the entire sequence of images.

When rendering to disk, open an MPlay window to interactively monitor progress.

This is the list of AOVs to display in the MPlay monitor. Specifying - will monitor all AOVs.

This is a zoom factor applied to the monitor. The monitor will display images at a fraction of the full resolution while the image written to disk will be full resolution.

When rendering to MPlay, all Houdini sessions will send the output to the same MPlay flipbook. This can be problematic when running multiple Houdini sessions. The MPlay Label lets you specify a label for the MPlay associated with the output driver. Only renders which match the given label will be sent to that MPlay.

The Python script husk runs before any rendering begins.

The Python script husk runs before rendering each frame.

The Python script husk runs after rendering each frame. This is run after all render products are saved.

The Python script husk runs after all rendering.

husk can break up a single large image into multiple tiles and render each tile independently. It does this by overriding the dataWindowNDC setting defined on the render settings.

The number of tiles in the X and Y resolutions.

This is the tile that husk should render. The value should be between 0 and the total number of tiles (Count.x*Count.y).

Each output image will be suffixed with this string. The string supports the same variable expansion husk does on output images, but replacing the %02d with the tile index instead of the frame number.

This option can be used to debug exactly what command the ROP is executing.

How much information to print out while rendering. Normally you should avoid “Full with VEX profiling” (slow) or “Full with VEX Profiling and NaN checks” (very slow), though they may be useful for debugging.

This enables USD tracing. This information can be used to profile Usd performance in husk.

When using Chrome tracing, this is the file where the trace log should be stored.

Capture the output from husk and store the log in a file on disk.

Normally husk will overwrite the log file on each run. This option will cause output to be appended to the text in existing files.

This is the file where normal messages should be saved.

This is the file to which error messages should be saved. If this is the same file specified for the Output Log, the output and error messages will be interleaved (in the same way they are written to the console).

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.

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.

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.

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.

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.

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:

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.

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.

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

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).

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.

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 ro @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.

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.

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

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

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