New Features

• New PRMan SDK — RenderMan Pro Server 14.0 introduces a new Software Developers' Kit that simplifies linking, eliminates awkward workarounds and caveats, and provides a single, consistent method of usage. The notable changes in the new SDK are:

• The SDK is no longer a separate downloadable package.
• The static library — libprmanSDK.a — has been replaced by a dynamic library — libprman.so/dll/dylib.
• PRMan now loads libprman.so as a dynamic runtime.
• Other programs can load libprman.so as a dynamic runtime.
• A single library is all that is needed for third party stand-alone programs.
• Linkage on Windows platforms is simplified for other programs that might be plugins to Autodesk's Maya.
• Third party applications can, once again, direct link the renderer.

Perhaps most importantly, libprman.so supports new IPC (interprocess communication) features. This allows a client application to launch and control one or more more external prman processes and is the preferred means to connect to prman in re-rendering mode, but it can also be taken advantage of in regular rendering.

Developers should note that, with the introduction of the new SDK, Windows plugins will have to be recompiled against libprman.lib (instead of prman.lib) and all stand-alone programs will have to use OS-specific methods to locate the dynamic library.

• PRMan for Python — RenderMan Pro Server 14 introduces prman_for_python, a Python plugin module that allows you to build Pixar's RenderMan into your Python applications. The plugin module, prman_for_python.so, comes with a simple Python wrapper module, prman.py. Together they make accessing the power of prman as easy as py.

• In conjunction with the new Python binding, there is a new Python-based implicit surfaces compiler. Documentation and examples can be found in $RMANTREE/blobby.py.

• OpenEXR Textures — Pixar's RenderMan now supports OpenEXR-formatted textures. OpenEXR offers high dynamic range and good color resolution with the 16-bit "half" data format, as well as arbitrary image channels that can be accessed by name.
• Structs in RSL — The RenderMan Shading Language now supports user-defined structures: structs. Structs can contain uniform and varying data of any type, including arrays, nested structs, etc. Struct members are operated upon by reference, so introducing structs into existing code has minimal impact on performance.
• API for Reading Brick Maps — Brick map files can be read using the new brick map API. Reading brick maps has several applications, for example custom brick map lookup filters and visualization programs other than brickviewer.
• Organized Point Clouds — There is a new extension to the point cloud file format: organized point cloud. ptfilter now generates organized point clouds by default (unorganized point clouds can be generated using ptfilter -organize 0), and there are four new point cloud API functions to read and write organized point clouds.

An organized point cloud consists of data points organized into an octree, and a collection of octree nodes. When texture3d() reads from an organized point cloud, the points and octree nodes are read on demand and cached, thus using much less memory than unorganized point clouds (which are read in their entirety). Additionally, the occlusion(), indirectdiffuse(), and subsurface() functions can read both unorganized and organized point cloud files; for more information on this aspect, see the Using organized point clouds section of the Point-Based Approximate Ambient Occlusion and Color Bleeding application note.

Note that PRMan 14.0 can read older point cloud files, but previous versions cannot read point cloud files generated by PRMan 14.0.

• Re-Rendering Technology — Pixar's RenderMan now provides a re-rendering mode that accelerates re-shading and editing of production-quality scenes. The goal of this project is to produce quickly re-rendered results that are identical to full renders with all features of the RenderMan shading system available, including raytracing, DSO shadeops, and deep shadows. Re-rendering is fully multithreaded and utilizes progressive refinement and on-demand streaming of cached data to provide short start-up times and interactive feedback, even on complex scenes. Several caveats accompany the initial release that may prevent re-rendering from being plug-and-play compatible with your production pipeline; please see the Known Issues section of the Re-Rendering developer note for details. The developer note also includes a simple Python script that demonstrates the system in action.
• New Function: subsurface — Subsurface scattering can now be computed directly in RenderMan Shading Language using the new subsurface() function. The input is a point cloud file of illumination samples and (optionally) material scattering parameters. The algorithm is the same as ptfilter -filter ssdiffusion, but it is handy to be able to compute subsurface scattering directly in shaders.
• New Display Driver: multires — The new multires display driver provides high-performance rendering of the multi-resolution images produced by prman in re-rendering mode. While this is the preferred display for re-rendering, it supports a limited set of pixel types: 3 or 4 channels of byte or floating point images.

Performance Enhancements

• Unloading of Procedurals During Raytracing — In previous releases, the contents of ray-traced procedurals would stay in memory until the end of frame. The renderer can now unload this geometry plus any associated spatial acceleration data overhead on an as-needed basis. Control over this behavior is exposed via a new RiOption: Option "limits" "int proceduralmemory". If the renderer detects that the amount of geometric memory used by ray-traced procedurals exceeds this limit the renderer will unload procedurals on a least recently used basis, and, as needed, the renderer may subsequently re-run an unloaded procedural to restore its contents to the scene.
• More Efficient Handling of Large Polygon Sets and Long Curves — Dense polygon meshes now exhibit better memory characteristics, both with and without ray tracing enabled. In some circumstances, ray tracing speed may also be substantially improved. Additionally, very long Curves are now handled more efficiently by the renderer.
• Faster Arbitrary Output Variables (AOVs) — The performance of scenes with numerous AOVs and/or AOVs with empty buckets has been significantly improved.
• Better Threading Scalability — The performance of threading using eight or more CPU cores has been improved for many computationally intensive scenes.
• Ray tracing speedups — Raw ray tracing speed is up to 40% faster than before, depending on the scene. The speed-up is most apparent for computations where shading evaluation time is low, such as ray-traced ambient occlusion. (For ray-traced reflections and refractions, the time spent shading ray hit points can be considerably more than the time spent ray tracing, and the relative speedup will be smaller.)
• Depth Of Field acceleration — Depth of field is significantly faster, especially in scenes with large blurs.
• Brick Map Improvements — The number of brick reads for dense geometry with a shader that reads a brick map 3D texture that is small on screen but contains lots of detail (i.e. many levels) has been significantly reduced, and the open/close behavior of brick map geometric primitives has been improved.

Miscellaneous Changes and Bug Fixes

• RenderMan Shading Language 2.0

• Shaders can now be passed as shader parameters. That is, we now allow a string (i.e. a shader handle) to be provided as a value for a parameter of type "shader", enabling layer shaders, light shaders, et al., to access co-shaders as parameters, rather than parsing a co-shader list.
• There is a new pre-defined shader object, caller, which provides the shader pointer of the calling shader class. caller can be used to inspect the calling coshader or similar.
• Support for resizable arrays in RSL plugins has been improved, via a new RslResizer class. See What's New in RSL for more information.
• The shading system includes several new diagnostics, which are enabled by a shading debug level option. When enabled, a complete call stack is reported whenever a shading error is encountered. The shading system also detects the use of unitialized shader variables when debugging is enabled. See What's New in RSL f or more information.
• Uniform values are re-initialized to the default, if one is given prior to begin() running (i.e. once per grid). Previously strings could not persist between grids. Provided the shader is recompiled, this means:

• constant string foo = ""; will be initialized to the default value once prior to construct.
• constant string foo; will be initialized to "" prior to construct. User construct is assumed to set the value to something useful.
• uniform string foo = ""; will be reinitialized to "" prior to begin() running, i.e. at the start of shading on each grid.
• uniform string foo; retains the previous value. The default is "".

• Member variables of type shader may be computed in construct() and stored for the lifetime of the shader.
• Varying access in construct is now not legal. Any varying member cannot be accessed during construct().
• The renderer now provides better guarantees about construct frequency. Note that construct is called on shaders accessed during another shader's construct. See the User construct() method section of the Shader Objects and Co-Shaders application note for more information.
• Ordering for begin() has been improved. As with construct(), begin is called on shaders accessed during another shader's begin. See the User begin() method section of the Shader Objects and Co-Shaders application note for more information.
• Shaders passed via the parameter list do not need to be in scope when the shader binds to a gprim. Please see the Shaders as parameters section of the Shader Objects and Co-Shaders application note for more information on what is now supported.
• The caching of shader definitions has been improved, reducing the renderer's memory footprint. The size of the shader definition cache can be controlled using the defcache shading Option.
• String class members are now initialized to the empty string if they're not explicitly initialized, since uninitialized strings can crash the shading system.
• Multi-level break/continue statements now work even when the loop condition is uniform.
• An issue that prevented return statements inside uniform loops from operating correctly has been fixed.
• The RSL printf function now produces uniform output if the inputs are all uniform.
• The compiler now ensures that an array can no longer be assigned to a non-array variable.
• The predefined shaders "this", "surface", and "light" were inadvertently varying, which prevented them from being passed as parameters or copied.
• Fixed a multithreading bug in the built-in RSL getshader() and getlight() functions that could arise when looking up undefined shader handles.
• Fixed a bug that could cause a crash when calling a shader method with the wrong number of arguments.
• Fixed an array iterator bug involving varying resizable arrays.
• Fixed a spurious array length warning for long array parameter values in RIB.
• Fixed a bug involving grid combining and shader definition caching that could potentially cause an inconveniently abrupt cessation of functionality (i.e. a "crash").
• Fixed a bug involving combined shading for shaders with resizable array member variables.
• Fixed the RSL attribute() and option() functions to properly handle arrays of length one and resizable arrays.
• Several issues related to the allocation of space for method parameter defaults have been resolved.
• Output parameters are now initialized properly for optional method call outputs.
• Shaders in shader members now behave as expected.
• Fixed a bug that could cause shading local memory to grow larger than needed in certain cases where the shaders themselves are larger than the shader defcache allows.
• Several bugs relating to access of various types of variable sized arrays during construct have been resolved.
• A bug that prevented uniform integer primitive variables from being bound to equivalent shader float parameters has been fixed.
• Shaders passed via the parameter list can now have primitive variables bound to their parameters, e.g.:

Shader "first" "firstHandle" "varying float firstValuesHere" 0
Shader "second" "secondHandle" "uniform string otherShaderReference" "firstHandle"

Polygon "P" [...] "varying float firstValuesHere" [....]

• Resizing an array now initializes the new elements with the default values.
• The renderer's use of an opacity method (if provided) has been optimized, and will no longer be run unnecessarily early in cases without displacement.
• construct() is now fully lazy. That is to say: no coshader will be constructed until either a) such time as getshader(), getshaders(), getlight(), or getlights() is about to return it, or b) we require the construction of a shader, and another is referenced by that shader's parameter list. This should greatly reduce memory consumption in cases where there are many many coshaders available at any given time.
• arraylength() on a variable length array shader parameter now correctly returns 0, rather than -1, when it is not bound in RIB.
• The sloinfo and slo library support shaders with parameters of type shader.
• Method calls in construct() with no return value are no longer considered to be in violation of the no varying access in construct rule.
• Varying arrays may be resized in construct, but the elements of the array are not accessible.
• The surface variable is available and valid during the displacement portion of the shading pipeline.

• Ri

• The version number of the RiFilter interface has been incremented to 8 with the addition of new Ri interface routines that support re-rendering. As usual, most RiFilter plugins compiled against an older version of the interface will continue to work with the current release, but the converse is not true. There is an exception for any plugins that override callback functions to RiProcedurals; see Deprecated.
• There is a new Ri Control: RicProcessCallbacks.
• RiCamera definitions now behave properly as Options, i.e. they are pushed and popped by FrameBegin and FrameEnd.

• Displays

• Color AOVs can now composite using a separate opacity AOV by passing in the name of that opacity AOV as the "string opacity" argument to RiDisplayChannel. The shader is required to perform premultiplication in the shader of the color AOV by the opacity AOV, and is also required to output the opacity AOV. The renderer will then composite the color AOV correctly using the value of the opacity AOV, rather than Oi. As an additional benefit, after declaring the color AOV in this fashion, shaders that do not have either the color or the opacity AOV in their output parameter list will now have the natural interpretation of "black, transparent", as opposed to "black, opaque" in previous releases.
• Floating point alpha channels derived from arbitrary opacity AOVs can now be specified by passing the value "alpha" for the "string interpretation" parameter to RiDisplayChannel.
• AOVs that are computed by the sigma hider and use a non-compositing pixel filter (such as average, min, max, zmin, or zmax) are now filtered correctly.
• A bug on certain setups that could lead to a crash when gathering Arbitrary Output Variables (AOVs) through volume shaders has been fixed.

• Point Clouds and Brick Maps

• The functions occlusion(), indirectdiffuse(), and subsurface() can be passed an array of point cloud filenames.
• The function texture3d() can be passed an array of point cloud or brick map filenames.
• The automatically-computed filter size for texture3d() brick map lookups is now wider for brick maps with too few levels (i.e. fewer levels than required for optimal rendering quality — roughly one brick voxel per image pixel). The new automatic filter size gives smoother results for brick maps with few levels.
• Ptfilter has a new filter: crop. This filter crops a point cloud file to a given bounding box, i.e. it only writes the points that are within the bounding box.
• Brick map geometric primitives now "mix" properly with other gprims when using the LOD feature (DetailRange).
• There was a bug in the errorcode returned by texture3d() when a brick map lookup fails; this has been fixed.
• The point-cloud radius values computed automatically by bake3d() are no longer too large near the silhouette of implicit surfaces.
• The accuracy of point-based ambient occlusion near sharp edges has been improved. This eliminates thin white lines caused by missing ambient occlusion along, for example, intersecting planes.
• Fixed incorrect point-based color bleeding (and occlusion when computed along with color bleeding) for cone angles smaller than pi/2 when sortbleeding is off.
• The point-based subsurface(), occlusion(), and indirectdiffuse() functions have new parameters that allow users to specify the name of the point cloud channels that contain area and/or color data. Ptfilter has corresponding new command-line options.
• A bug that could lead to a crash when generating point clouds via multithreaded netrenders (or netrenders to multiple hosts) has been fixed.
• There is a new smoothing feature for subsurface scattering. This is useful if the source point cloud is too sparse relative to the diffuse mean free path length. Without the smoothing, the subsurface scattering results are very sensitive to the distance to the nearest point and can be noisy or aliased. Users can turn on this new feature by using the -smooth 1 option with the ptfilter utility or by passing "smooth" 1 to the new subsurface() function.

• Geometry

• The RiGeometricApproximation procedure can take a new parameter, focusfactor, that adjusts the dicing rate for blur due to RiDepthOfField. If focusfactor is not set, then the motionfactor value, if set, continues to affect the adjustment of dicing rate for both motion blur and depth blur. If focusfactor is set, then the motionfactor value only affects the motion blur adjustment, and focusfactor only affects the depth blur adjustment.
• RiCurves now support vertex storage class and bicubic interpolation for width and N.
• An issue with clipping of RiCurves with very small parametric range has been fixed.
• Using rational (hpoint) P with polygonal meshes no longer crashes the renderer.
• Inconsistencies in the calculation of P for certain ray-traced, motion-blurred geometry types have been fixed.
• A bug in the RIBBound.so Rif plugin that was preventing it from accurately bounding geometry with transformation blur has been fixed.
• area(P, "dicing") now returns a reasonable result on implicit surfaces. The area is computed from the size of a pixel at the (camera-space) z, modulated by the shadingrate.
• Normals attached to RiPoints are no longer ignored, and can now be used to orient the disks when they are hit tested. Previously, all disks were always oriented towards the camera; this behavior will be the fallback if no normals are provided.

• Shading

• The maxvariation parameter of occlusion() and indirectdiffuse() is now used for point-based occlusion and color bleeding. Previously, maxvariation was used for ray-traced calculations, but it was ignored for point-based calculations.
• time, dtime, and dPdtime are now computed for objects shaded using the vpvolumes shading strategy.
• dPdtime is now computed for all ray-traced geometry.
• The default value of maxvariation has been changed from -1 to 0.05. This change affects both ray-traced and point-based occlusion() and indirectdiffuse().
• The default matting behavior when a matte object is inside a vpvolumes shaded object has been fixed.
• A bug that could result in artifacts when using "doubleshaded=1" has been fixed.
• A bug that could cause different results when calling attribute("displacementbound:sphere", d) inside a surface or a displacement shader has been fixed.
• Fixed a bug related to invalid faces on subdivision surfaces (due to duplicate edges or non-manifold edges) that could cause problems with facevarying data.

• Statistics and Warnings

• Rendering statistics now include a breakdown of time spent in RSL plugins.
• A warning is reported if a shader calls lights in a varying conditional context (e.g. in a branch of a varying "if" statement). Doing so is risky because values provided by the surface shader might be incompletely initialized.
• Certain warnings (i.e. those that include shader call stacks) are now reported using a new multi-line error format. For example:

S01008 {WARNING} Variable X is uninitialized: file myplastic.sl, line 21, pc 17
S01008 {CONTINUED} in myfunction, called at line 28 of myplastic.sl
S01008 {CONTINUED} in mydiffuse, called at line 86 of myplastic.sl [Object:'<unnamed>']

• There is a new warning, S31003, to catch the case where undeclared variables fall back to rely on the .slo files for type information. Users who are certain that undeclared variables serve their interests can use woff to override this feature. This can also be done in the rendermn.ini, by adding /messages/disable S31003.
• PRMan now emits a warning (once) if bake3d() is asked to bake grids of points on geometry with raster-oriented dicing on. Point clouds generated from the aforementioned geometry are unsuitable for subsurface scattering, point-based occlusion and color bleeding, generating brick maps, etc.
• PRMan now emits a warning at the end of a render if an RslPlugin modifies the contents of an RtString that has been passed as an argument.
• The timing statistics for texture3d() and brick reads are more consistent.
• texture3d() calls that read point cloud files now return useful error codes.
• Various error messages and warnings have been updated for accuracy and efficacy.

• Other

• The built-in strings substituted for "$ARCH" or "%ARCH" in RIB searchpaths and procedural names have been updated; see Procedural Primitive Pathnames for details. Please consult the /architecture definitions in rendermn.ini for a way to revert to the previous names, or to supply site-specific names, and be sure to review your current site rendermn.ini for /architecture or /dirmap settings that may need to be updated to reflect the new built-in names.
• There is a new command line option to prman: -capture filename. When used, -capture writes all RIB rendered by prman to the given filename. Procedural primitives are written to a subdirectory as they are processed by the renderer, with paths written into the "captured" RIB file.
• There is a new attribute, "procedural" "int unloadable", that controls whether a procedural can be unloaded by proceduralmemory limiter or not. The default value is 1 (all procprims are subject to unloading).
• The libprman dynamic library for Linux distributions is now versioned. Users can link to libprman.so for an unversioned binary, or they can link to libprman_versioned.so for linkage to a specific release of the library.
• Illuminance loops can now fetch member variables from lights, using the same syntax that is used to fetch light parameters.
• Fixed a bug that could cause artifacts when spooling multithreaded netrenders to multiple hosts.
• The netrender -F client protocol now handles file names containing spaces or backslashes properly.
• The stability of the renderer with respect to multithreading and procedurals (particularly ray-traced) has been improved.
• A bug that could potentially cause a crash when using sloinfo with no command-line arguments has been fixed.
• A bug affecting multi-segment motion blur that could result in brighter-than-expected images has been fixed.
• Fixed a bug that could result in subdivision surfaces not correctly cloning string arguments for tags.
• A bug that could lead to erroneous resolution when the same declaration is used in multiple shadeop DSOs has been fixed.
• Fixed ASCII RIB formatting consistency by ensuring that a space precedes each token declaration in a parameter list.
• Fixed a bug with wnoise that could lead to a crash when N=0.
• The -catrib flag for prman now properly respects the -gzip and -binary flags.
• On Windows and OS X, the installer can now be run via the command line, bypassing the licensing application. As a consequence, installing via the command line will require handling licensing manually, via the rendermn.ini.
• Support for 64-bit builds on Windows Vista (64) and for 32- and 64-bit builds on OS X 10.5 (Leopard) has been added.
• A new version of the Pixar License Server, 6.0, is now available. Please consult the License 6.0 release notes for additional information.
• Passing the value [0 0] to the shutteropening parameter now gives the correct result, instead of wrongly mirroring the default behaviour of [0 1].

Deprecated

• The -p:n render mode, deprecated in version 13 with the introduction of multithreading, is no longer supported. As in the 13.x versions, by default -p:n is treated as an alias for -t:n; unlike the 13.x versions, this behavior cannot be changed via the rendermn.ini.
• Shader plugins should not retain pointers to string arguments. Doing so has always been risky, but in the past it has worked when the strings involved are constants. That is no longer true, because pointers to string constants in shaders might now become dangling when the shader is unloaded from the shader definition cache. Such problems can be diagnosed by setting the defcache shading Option to a large value to prevent shaders from being unloaded.
• Calling lights from a displacement shader (or from a displacement or opacity method) is now deprecated. Doing so is risky because the state of lights (i.e. their output parameters and member variables) is not preserved when lights are called prior to surface shading.
• The ProcDelayedReadArchive, ProcDynamicLoad, and ProcRunProgram entry points in the RiFilter interface have been removed, since these callbacks were ill-defined and not well supported. If your RiFilter plugins did not use these entry points, you do not need to recompile your plugin. Otherwise, you will need to remove any installed callbacks on these functions. It is anticipated that any intended usage of these entry points is better served by installing a callback on Procedural. To that end, performing a direct function pointer comparison between the RtProcSubdivFunc sdfunc parameter passed to a RiFilter Procedural callback, and the built-in Ri functions RiProcDelayedReadArchive, RiProcDynamicLoad, or RiProcRunProgram, should now work correctly and consistently in all RiFilter capable contexts (catrib, prman, and prman -catrib).
• The rif_passthru.so Ri Filter has been removed from the distribution.

Changes in 14.1

Changes in 14.2

Changes in 14.3

Changes in 14.4

Known Issues

• Previous versions of Alfserver will not be able to multiplex netrenders between 14.0 and other releases. If you require this capability, we recommend installing the 14.0 version of Alfserver, as it can multiplex with previous releases.
• txmake cannot yet create UINT format OpenEXR textures.
• netrender does not yet support certain optional arguments to RiMakeTexture, including compression, exrcompression, and type.
• The version of Python that is provided with OS X 10.5 (Leopard) is 32-bit only. As a result, it is not compatible with the Python bindings shipped with the 64-bit OS X build of RenderMan Pro Server.
• When using the multires display driver, prman will not exit until the display window is closed.
• Existing display drivers will no longer, by default, render all levels of the multi-resolution images generated by prman in re-rendering mode. When re-rendering, existing display drivers will show only the highest level of detail.
• During re-rendering there is a slight shift in the image on the transition to the highest level of detail.
• For a more complete list of known issues with the re-rendering mode of prman, please see the Re-Rendering API developer note.