Houdini 16.5 Rendering

Rendering with RenderMan

On this page

Rendering with RenderMan is done in Houdini thru a RenderMan render output driver node. It generates a RIB stream and pipes it to the prman executable specified in the Command parameter. It is also possible to save a .rib file to disk, by turning on the toggle next to the Disk File parameter.

Under the hood, the output driver node runs SOHO scripts, taking into consideration the RenderMan version specifiedc in the Render Target parameter. The scripts inspect the scene and write out a corresponding RIB, compiling any VOP shaders such as RSL Material, if necessary.

For more information, please refer to the RenderMan documentation.

Setting up RenderMan

In order for Houdini to be able to find all the necessary RenderMan tools, first you will need to set a few environment variables:

  • ensure the RMANTREE is set to the installed version of RenderMan, for example:

    export RMANTREE=/opt/pixar/RenderManProServer-20.0
    
  • ensure the search path includes the bin subdirectory of RenderMan, for example:

    export PATH=$PATH:$RMANTREE/bin
    
  • set the HOUDINI_DEFAULT_RIB_RENDERER to the desired version, for example:

    export HOUDINI_DEFAULT_RIB_RENDERER=prman20.0
    

After setting up these three environment variables, Houdini should be able to use RenderMan.

Choosing a renderer

Each RIB target renderer has its own executable, way of compiling shaders, attributes, options, and features. Much of this is handled by Houdini behind the scenes. However, as a big head start, you can give Houdini a hint as to which render you are using by setting the environment variable HOUDINI_DEFAULT_RIB_RENDERER to the render target you want to use. The list of renderers can be inferred by looking at the $HH/RIBtargets and also at $HH/soho directory and scanning the files. The current renderers include prman20.0, air6.0, 3Delight9.0, and rdc3.4.

Houdini uses this variable in several places. In the hrmanshader script (a wrapper around the shader compiler), the variable controls which compiler program to call. It also controls which properties appear on the RIB output driver.

To...Do this

Set the default RIB renderer

Set the HOUDINI_DEFAULT_RIB_RENDERER environment variable, for example:

# set up for prman20.0
export HOUDINI_DEFAULT_RIB_RENDERER=prman20.0

Setting up the display driver

RenderMan version 20.2 and up ships with a Houdini display driver, so there is no need for any additional setup, beyond specifying houdini in the ROP node’s Display Device parameter. Once this is done, the RIB renderer will render directly to MPlay.

It is also possible to reconfigure RenderMan to remap framebuffer device to Houdini display driver, so that all framebuffer rendering goes to MPlay as well. This can be done in rendermn.ini with this line:

/displaytype/framebuffer houdini

Customizing the View: RenderMan menu

The render menu in viewports has an entry View:RenderMan. This will render the scene without having to create an output driver. However, Houdini needs to know which application to invoke to render the scene. This is determined by setting the environment variable HOUDINI_VIEW_RMAN.

To...Do this

Modify the "View: Renderman" menu command

To change the renderer used when you choose View: RenderMan from the render icon in the viewer, set the environment variable HOUDINI_VIEW_RMAN. For example:

# Set up for 3delight
export HOUDINI_VIEW_RMAN=renderdl

Overriding the shader path

Houdini will set the path to the default path each renderer expects. You can override the shader path in two ways:

  1. Set the path by adding the rendering parameter to the output driver (preferred method).

  2. Set the environment variable HOUDINI_RI_SHADERPATH.

If you customize the path, you should include $HFS/ri_shaders in the path for light shaders. If you don’t customize the path, Houdini will look for directories named ri_shaders in the HOUDINI_PATH.

For RIS shader plugins there is a HOUDINI_RI_RIXPLUGINPATH environment variable. But you don’t need to include $HFS/ri_shaders in your customization, since Houdini does not look for directories named ri_shaders because Houdini does not ship with any custom RIS shader plugins. Thus the implicit default of $RMANTREE/lib/RIS usually suffices.

Customizing object parameters

If you are using RenderMan or AIR as a primary renderer, you may not want to see all of the mantra parameters in your geometry objects. You can customize the geometry object to create objects with RenderMan/AIR parameters instead.

To...Do this

Customize object parameters

  1. Create a Geometry object in Houdini.

  2. In the parameter editor, click the menu and choose Edit Rendering Parameters.

  3. Remove all of the mantra parameters.

  4. Add the appropriate RIB parameters.

    Different users may prefer different properties. The following list is not a complete list of all RenderMan parameters, but a list of useful ones.

    • Dicing

      • Binary Dicing

      • Raster Oriented Dicing

      • Motion Factor

    • Geometry

      • Automatically Compute N for Polygons

      • Render as points

      • Polys as subdivision

      • Backface Removal

    • Shading

      • Categories

      • Camera Hit Mode

      • Color (Cs)

      • Opacity (Os)

      • Matte

      • Cull Shading of Backface Surfaces

      • Shading Quality

  5. Choose Save As Permanent Defaults from the menu in the parameter editor. This will save the presets to the $HOME/houdiniX.X/presets directory and can be moved to per-shot, per-job or per-site directories. For more information see the Houdini Path help.

Once you save the parameters as permanent default parameters, they will be applied to all new objects. (You can do the same with the light and camera objects, though lights should work fairly well out-of-the-box in Houdini).

Tip

You can improve shading quality by adding the Shading Interpolation parameter.

Importing shaders

You can use VOPs to create RSL shaders, or you can import other shaders that you have written. Importing is done by creating Houdini Digital Assets that correspond to the written shaders.

To import shaders, run a Python script which parse the output of sloinfo (prman), shaderinfo (3Delight), aqsltell (Aqsis), sdrinfo (Pixie), etc. Houdini ships with 2 scripts: slo2otl.py to convert prman shaders and sdl2otl.py to convert 3Delight shaders.

The scripts are reliant on being able to parse information about shader parameters, but should be fairly easy to customize for an unsupported renderer. The script tries to implicitly guess the HDA table type and is geared for RIS shaders which are VOPs, so light and displacement .slo files implicitly yeld a VOP HDA. You can force the HDA SHOP with the -t command-line switch.

For example:

slo2otl.py -t Shop -l myshaders.hda *.slo

This will create an HDA which can be loaded into Houdini. All of the recognized shaders will exist as SHOP nodes.

Note

Windows requires you to run hython in order to run Python.

hython sdl2otl.py -l myrmanshaders.otl *.sdl

Hython will not find the sdl2otl.py script unless $HB is included in the Python path.

Building RSL shaders using VOPs

In addition to importing external .slo shaders described above, Houdini allows to build shaders using VOP networks such as RSL Material. You can assign RSL Material to objects by setting the Material parameter, or to individual primitives using the Material SOP, as described in the shading documentation.

RIS Rendering Mode

To use RenderMan’s RIS rendering mode, turn on the RIS Mode parameter in the RIS sub-tab of the Properties tab on the RenderMan node. You can then optionally specify an integrator shader in the Integrator parameter. Please see RIS shaders for more information.

See also

Rendering

Mantra user guide

Basics

Lighting

Next steps

Guru-level

Other renderers