Welcome!

Thank you for visiting my RenderMan portfolio. This body of work encompasses what I am learning in Programming Models and Shaders I at the Savannah College of Art and Design.

 

 

Matrix Composition

This page demonstrates the basics of scripting shapes directly into a RenderMan RIB file. Coding shapes in this way focuses attention on the use of color, opacity and the fundamental concepts related to xyz coordinate system.

         
     
         
     
         
     
         
     
         

These shapes were created using partial spheres and a network of cubes built with individual planes. The objects were then arranged in an aesthetically pleasing manner.

Above are a series of images showing the renderer in action. The images in the left column are shaded with the "plastic" shader and nothing else. The images on the right incorporate displacement from a simple grid texture, depth of field, and simple flat colors on the geometry. Simple shadows also come into play from one of the light sources.

.

RIB File excerpts:

The partial sphere shapes were created with this RIB archive.

The twisting series of cubes were created with this RIB archive.

The final RIB file referenced archives that contained the previous archives that were duplicated and rotated.

 

Pre-Baked Animation

The static images, movies and technical breakdown on this page demonstrate how an animation can be baked (exported) as a sequence of rib archive files. An explanation is also given of how other Maya scenes can reference the archived assets in such a way that complex scenes can be rendered without the need for Maya to directly display multiple copies of the original geometry.

Reference images:

     
 
     
 
     

Using the above reference images and careful direct observation of the saw palmetto, I modeled the plant in Maya using polygons. To accomplish this, I first modeled a single palmetto leaf, then instanced it along a NURBS curve that was to be the stem. Once I was happy with the proportions and locations of all the leaves, I duplicated the leaf and created the entire plant.

However, I ran into a problem when trying to animate the movement of the palmetto. I used two bend deformers, one for the mid-section of the leaf and one for the tip, and keyframed the curvature parameter until I got a satisfactory result. But when duplicating the leafs again for the animated version of the palmetto, my scene file size quickly skyrocketed to over 100mb. To correct this problem, I combined the instanced leaves into one mesh and reanimated the bend deformers. Here is the result:

The animation was then baked out into 70 frames worth of RIB archives using the RIB archive export plug-in. Because each frame was contained within individual RIB files, I could now reference the geometry externally without having to rely on Maya to display a preview. To accomplish this, RenderMan's delayedReadArchive command was applied to a polygon cube about the size of the palmetto plant. By doing this, the scene file remains extremely clean and the geometry is not imported until render time. By using this technique, the artist is allowed maximum flexibility when working with scenes that deal with an obscene amount of geometry. Here is a sample render using the delayedReadArchive script on a polygon cube:

Because the geometry is being referenced directly from a RIB archive, no shader has been applied thus giving it a self-illuminating look.

The next step was to create a fake sub-surface scattering material that simulated translucency by making shadows cast on the opposite side of the geometry (relative to the camera) also apparent on the front side.

Using the translucency shader along with the added functionality of the 'blackhole' affect, this animation was created:

I have yet to figure out how to get our custom MEL readArchive script to understand RIB sequences so that the palmetto can be animated while it is being 'vaporized'.

st Coloration

These images show the results of using the RenderMan Shading Language (RSL) to write a variety of special effects surface shaders. The notes and RSL code accompanying each image explain how each effect was achieved.

 

 

 

 

 

 

 

 

 

 

 

   
// Wedge shape on bottom
if(pow(s,2) <= t && 1-pow(t,1.8) <= s)
    surfopacity = 0;
  
// Outer eye
if(bigCircleSize >= pow((t-.3), 2) + pow((s-.3), 2))
    surfopacity = 0;
  
// Inner eye
if(littleCircleSize >= pow((t-.3), 2) + pow((s-.25), 2))
    surfopacity = 1;
    
// Diagonal exponent curve
if(pow((s-.2), 2) > t)
    surfopacity = 0;
    
// Mouth
if(t >= 0.55 && t <= 0.85 && s >= 0 && s <= 0.2)
    surfopacity = 0;
    
// Top teeth
if(t >= 0.56 && t <= 0.6 && s >= 0 && s <= 0.05)
    surfopacity = 1;
if(t >= 0.56 && t <= 0.6 && s >= .06 && s <= 0.11)
    surfopacity = 1;
if(t >= 0.56 && t <= 0.6 && s >= 0.12 && s <= 0.17)
    surfopacity = 1;
  
// Bottom teeth
if(t >= 0.82 && t <= 0.84 && s >= 0 && s <= 0.05)
    surfopacity = 1;
if(t >= 0.82 && t <= 0.84 && s >= 0.06 && s <= 0.11)
    surfopacity = 1;
if(t >= 0.82 && t <= 0.84 && s >= 0.12 && s <= 0.17)
    surfopacity = 1;
     
  
if(s >= smin && s <= smax && t >= tmin && t <= tmax) 
    surfopacity = 0;
     
  
if(s > t) 
    surfopacity = 0;
     
  
if(1 >= pow(t, 2) + pow(s, 2))
    surfopacity = 0;
     
  
if(circleSize >= pow((t-.5), 2) + pow((s-.5), 2))
    surfopacity = 0;
     
  
if(.1 >= pow((t-.5), 2) + pow((s-.5), 2))
    surfopacity = 0;
if(.09 >= pow((t-.5), 2) + pow((s-.45), 2))
    surfopacity = 1
     

 

 

 

 

 

 

 

 

 

 

   
if(s >= smin && s <= smax) 
    surfopacity = 0;
if(t >= tmin && t <= tmax)
    surfopacity = 0;
     

 

 

Maya Pattern Animation

The animation and notes on this page explain how custom shaders written in the RenderMan Shading Language can be animated using SLIM parameter expressions.

The personal pattern found on the st Coloration page was modified and animated using several techniques.

More color and functionality was given to the basic 'face' shader in order to animate the parameters in Maya. Common occurrences of values were replaced with variables and compiled out of Cutter as sliders that can be manipulated in Maya's attribute editor. The various variables can be seen here:

Two instances of the 'face' shader were used in the final animation. One instance was used to animate the angry chasing crowd and the other for the helpless bystander. To create the crowd, three particle systems were emitted from three curves. Each particle cloud had a NURBS plane with an offset version of the animated 'face' shader.

The bystander version of the 'face' shader was animated on a separate NURBS plane which was keyframed to look like he was running away. The only thing left was to add deep shadows from a directional light and render the scene.

Here is the final animation:

Full-Resolution stills: Frame 79, Frame 138

 

Flame Animation

This page shows the results of applying a custom surface shader, written in the RenderMan Shading Language, to a Maya scene in order to create the illusion of fire.

Reference videos:

Cigarette lighter:

 

Notebook paper burning:

 

RenderMan surface shader with Hypershade displacement:

Surface Shader Only
Displacement Shader Only
Combined Surface and Displacement Shaders

 

 

Workflow

Here is a first attempt at a simple displacement shader that was constructed in SLIM using simple noise and fractal generators:

Here is an early image of the surface shader applied to a poly plane. This effect was achieved by following the tutorial here:

 

This shader was given extra functionality including facing ratio controlled opacity and surface color. I also noticed from the reference images that the opacity of the flames seem to be more opaque at the edges as the flame moves up. To simulate this, I have a ramp controlling direction of the facing ratio as the flames continue upwards. This shader was then applied to a NURBS cylinder in Maya.

A locator was created so that I could use its location, rotation, and scale values directly within my shader in order to animate the noise. To do this, a post-transform MEL script (RiCoordinateSystem "flameCoord";) was placed on the transform node of the locator. The rest of the shader attributes were tweaked in order to achieve the best result.

In order to make the flame move realistically, the shape of the cylinder needed to be deformed using an animated displacement shader. I decided to create this shader in Hypershade.

By combining the displacement and surface shaders, these tests were created using variations in both the displacement and surface shader settings:

And the final result: