PhotoRealistic RenderMan 10.0

Release Notes

December, 2001


Introduction

These release notes describe significant changes and enhancements to the RenderMan® Toolkit for the 10.0 release over the 3.9 release.

Class Specifier facevarying

PRMan now supports a new class specifier for PointsPolygons, PointsGeneralPolygons, and SubdivisionMesh primitives: facevarying. The purpose of this new class specifier is to easily allow a vertex shared by two faces to have different values for variables such as N, s, or t. More information on this class specifier is detailed in the RI Spec.

Arbitrary Output Variables

Several important limitations have been removed from the arbitrary output variable functionality:

As well, bugs which prevented the use of multiple frames, each with arbitrary output variables, in a single RIB file have been fixed.

Finally, inline declarations now work in arbitrary output displays, so you may now use:

Display "+image.tif" "tiff" "varying float myvar"

More information on the new AOV functionality may be found in User Manual.

TIFF Textures

In addition to the proprietary Pixar texture file format, PRMan now accepts TIFF images as a source of texture data for texture, shadow and environment calls. These are tiled, mip-mapped TIFFs with special tags; thus, they are usually prepared by txmake or the RiMakeTexture call.

The choice of default texture format created in this way is controlled by the /prman/textureformat setting in rendermn.ini, which defaults to "tiff" (the now deprecated Pixar format can still be chosen by setting this to "pixar"). The output format used can be overridden on a per texture basis using the -format flag to txmake, or the "format" parameter passed to RiMakeTexture or the shadow display driver.

String Handles

Light and object handle representations in RIB have been changed from integers to strings. This allows applications to guarantee that light and object handles do not conflict between multiple RIB files which reference each other (i.e. via ReadArchive). For backwards compatibility with older RIB files, integers are still supported and will be converted to their string representation. Therefore, the following RIB statements are equivalent:

LightSource 57 "spotlight"
LightSource "57" "spotlight"

If your application uses the RIB client library, instead of incrementing an integer counter for each light, the RIB library will now use an algorithm that generates a unique ID, which is guaranteed to be unique across all RIB files and all machines. Applications which wish to override this automatic assignment of handles may pass the __handleid parameter to the LightSource call:

RtString id = "mylight";
RiLightSource("spotlight", "__handleid", &id);

It is recommended that application writers who override the automatic assignment use a facility which also generates unique identifiers.

catrib now no longer discards light or object handle IDs which it does not recognize. Thus, you may now catrib a RIB file which contains an Illuminate statement which refers to a light which has not already been defined.

User Defined Options and Attributes

In prior releases, the renderer ignored token-value pairs for options and attributes which it did not know about. In PRMan 10.0, you may now define arbitrary token-value pairs for the user attribute and option. All token-value pairs associated with this attribute and option will be pushed and popped on the graphics stack, like all other attributes that PRMan recognizes.

Example:

RtFloat myattribute = 3.0f;
RtString myoption = "foo";
RiOption("user", "uniform string myoption", (RtPointer)&myoption, RI_NULL);
RiAttribute("user", "uniform float myattribute", (RtPointer)&myattribute, RI_NULL);

In RIB form:

Option "user" "uniform string myoption" [ "foo" ]
Attribute "user" "uniform float myattribute" [ 3.0 ]

In the shading language, the attribute and option shadeops have been extended to allow these arbitrary token-value pairs to be queried. To query the user defined attribute defined above, you may use:

float myattribute;
string myoption;
option("user:myoption", myoption);
attribute("user:myattribute", myattribute);

Conditional RI Evaluation

The renderer now has four new Interface calls to support conditional evaluation of RIB: RiIfBegin, RiElseIf, RiElse and RiIfEnd. This functionality allows for a single RIB archive to be written once, and then reused but with certain aspects changed based on the current context in which it has been instantiated.

The RI calls themselves, as well as the syntax of the conditions recognized by the RiIfBegin and RiElseIf statements, are described in the RI Spec.

Scoped Coordinate Systems

The new RiScopedCoordinateSystem interface call allows the bindings of named coordinate systems to be pushed and popped along with the attribute stack. This is different behaviour from RiCoordinateSystem, which maintained the coordinate systems in an unscoped global list.

Blobby Thresholds

The RiBlobby primitive now recognizes a new special parameter: __threshold, which is a constant float (one value for the entire RiBlobby call). The value specified for __threshold will be added to the threshold value used by the field function.

Inline Archives

In addition to disk based RIB archives, the renderer now supports the use of inline archives of RI calls. An inline archive is created via the RiArchiveBegin call, which returns a RtArchiveHandle:

RtArchiveHandle handle = RiArchiveBegin(RI_NULL, RI_NULL);
  ...
RiArchiveEnd();

In RIB form:

ArchiveBegin id
  ...
ArchiveEnd

An inline archive can be referenced using ReadArchive, which has been extended to support both inline and disk based RIB archives:

ArchiveBegin "uid"
  ...
ArchiveEnd
ReadArchive "uid"

In RIB form, inline archives use unique handles as described above.

Renderer Checkpointing

A new command line parameter allows the renderer to pick up where it left off when a render fails:

prman -recover 1 ...

In conjunction with a display driver which supports the checkpointing facility, this parameter causes the renderer to check for a partially completed image and attempt to render only the remainder of that image.

The display driver interface has been extended to allow the use of custom drivers which support this new checkpointing functionality. Note that of the drivers currently shipped with PRMan, only the TIFF driver supports checkpointing.

Rendering Contexts

PRMan now supports the new RiContext call, as described in the RenderMan Interface Specification 3.2. Implementation specific notes about the Context call may be found in the RI Spec.

Non-Raster Oriented Dicing

PRMan 10.0 supports a new mode of dicing on NURBs, which computes micropolygon sizes using an unoriented raster space metric rather than the standard screen aligned raster metric. This is useful in situations where it is important that the dicing rate on an object doesn't change due to camera orientation. For example, it can help in situations where objects which are viewed edge on result in large micropolygons (but small in screen space), which are then displaced leading to micropolygons which are large in screen space.

The default dicing criteria is the screen-oriented raster space. This can be turned off to use the new unoriented metric as follows:

Attribute "dice" "rasterorient" [0]

The ability to turn off the oriented dicing metric is only implemented on NURB primitives.

Arbitrary Clipping Planes

This new feature, added to the 3.2 Specification, makes it easy to cull portions of a scene by specifying a series of arbitrarily oriented clipping planes:

RtVoid 
RiClippingPlane(RtFloat Nx, RtFloat Ny, RtFloat Nz, 
                RtFloat Px, RtFloat Py, RtFloat Pz); 

ClippingPlane Nx Ny Nz Px Py Pz

The provided normal and position describe a plane cutting the scene in half, and the half opposite the normal is culled entirely. If you specify multiple clipping planes, they are applied one after the other.

Like RiClipping, RiClippingPlane must appear before RiWorldBegin. Clipping planes interact properly with camera motion blur, but RiClippingPlane itself may not appear within a motion block.

Soft Shadow Improvements

Soft shadows have been sped up by 2 to 3 times.

In prior releases, the minmax shadow files required for soft shadows could only be created by rendering with the zfile driver, and then converting the result to a shadow texture. In 10.0, the shadow display driver now supports the direct creation of minmax maps. This is enabled by passing the minmax argument to the RiDisplay call with the value 1.0:

RiInt minmax = 1;
RiDisplay("shadow.tex", "shadow", RI_Z, "minmax", &minmax, RI_NULL);

The netrender client will now handle TxMakeShadow in the minmax case correctly.

Extended Rx DSO Library

The Rx library, introduced in 3.9, allows your shader and primitive procedural DSOs access to renderer internals. It has now been extended with new functions, declared in rx.h:

More information on the Rx library may be found in Section 8 of the User Manual.

Shutter Offset Option

A new Option has been added which specifies an offset to be added to motion blur times:

Option "shutter" "offset" [float frameoffset]

The specified offset is added to all time values specified in subsequent RiShutter and RiMotionBegin calls. This is a useful Option to use when using a sequence of RIB files which change the shutter times, while repeatedly referring to the same RIB archive containing motion blurred geometry. Without the new Option this would be difficult because the MotionBegin times in the archive would need to match the Shutter times: either the archive would have to be regenerated with each frame, or the Shutter and MotionBegin would always need to be locked at the same range for all frames (which would mean that the time shading variable is identical for each frame as well).

With the new Option, you may now keep a single RIB archive with the MotionBegin times starting at zero, and then from each referring RIB define an offset, prior to ReadArchive:

#
# produces RIB with time = 0 -> 0.5
#
Shutter 0 0.5
Option "shutter" "offset" [0]
FrameBegin 0
ReadArchive "geometry.rib"
FrameEnd

#
# produces RIB with time = 1 -> 1.5
#
Shutter 0 0.5
Option "shutter" "offset" [1]
FrameBegin 2
ReadArchive "geometry.rib"
FrameEnd

Netrender Improvements

Previous versions of netrender used a default bucketstride of "2 2", meaning that each processor would render a 2-bucket by 2-bucket portion of the screen. Because bucket sizes tend to be small, there was typically a great deal of redundant shading being done by each netrender process, and an undue amount of per-stride overhead. PRMan now attempts to use a larger bucket stride in general, and to adjust the stride to match the number of processors being used. This results in much better netrender efficiency.

In addition, the reliability of netrender has been generally improved.

Pixel Filters

New built-in pixel filters have been added to PRMan:

Shading Language Changes

Displacement Bound Checking

The renderer is now able to check whether displacement shaders displace an object by more than the displacement bound, and will warn accordingly (with R56004 or R56005) on a per primitive basis as needed.

As well, if a primitive displaces by less than half the displacement bound it declares, a warning will be generated into the statistics output.

Miscellaneous Changes

Bug Fixes


 

Pixar Animation Studios
(510) 752-3000 (voice)   (510) 752-3151 (fax)
Copyright © 1996- Pixar. All rights reserved.
RenderMan® is a registered trademark of Pixar.