The RenderMan Interface - Paul Bourke

A more efficient method for accessing subdivision routines is to write them as dynamic
shared objects (DSOs) 1 , and dynamically load them into the renderer executable
at run-time. In this case, you write your subdivision and free routines in C, exactly
as you would if you were writing them to be linked into the renderer using the C
RiProcedural interface. DSOs are compiled with special compiler options to make
them run-time loadable and are specified in the RIB file by the name of the shared
object file. The renderer will load the DSO the first time that the subdivision routine
must be called, and from then on, it is called as if (and executes as fast as if) it were
statically linked. DSOs are more efficient than external programs because they avoid
the overhead of interprocess communication.
When writing a procedural primitive DSO, you must create three specific public subroutine
entry points, named Subdivide, Free, and ConvertParameters. Subdivide is a
standard RiProcedural() primitive subdivision routine, taking a blind data pointer to
be subdivided and a floating-point detail to estimate screen size. Free is a standard
RiProcedural primitive free routine, taking a blind data pointer to be released. ConvertParameters
is a special routine that takes a string and returns a blind data pointer.
It will be called exactly once for each DynamicLoad procedural primitive in the RIB
file, and its job is to convert a printable string version of the progenitor’s blind data
(which must be in ASCII in the RIB file), into something that the Subdivide routine
will accept.
The C prototypes for these functions are as follows:
RtPointer ConvertParameters(char * initialdata );
void Subdivide(RtPointer blinddata, RtFloat detailsize );
void Free( RtPointer blinddata );
Note that if the DSO Subdivide routine wants to recursively create child procedural
primitives of the same type as itself, it should specify a direct recursive call to
itself, with RiProcedural(newdata,newbound,Subdivide,Free), not call itself as a DynamicLoad
procedural. The latter would eventually just call the former after wasting
time checking for and reloading the DSO.
The conventions for how dynamic objects are compiled are implementation-dependent
(and also very likely OS-dependent).
RIB BINDING
Procedural ”DynamicLoad” [dsoname paramdata] [boundingbox]
The argument list is an array of two strings. The first element is the name of the
shared object file that contains the three required entry points and has been compiled
and prelinked as described earlier. The second element is the ASCII printable
string that represents the initial data to be sent to the ConvertParameters routine. The
boundingbox is an array of six floating-point numbers, which is xmin, xmax, ymin,
ymax, zmin, zmax in the current object space.
EXAMPLE
RtString args[] = { ”mydso.so”, ”” };
RtBound mybound = { -1, 1, -1, 1, 0, 6 };
RiProcedural ((RtPointer)args, mybound, RiProcDynamicLoad, RiProcFree);
1 on some systems called dynamically linked libraries, or DLLs
91