4/2/02

The big difference: real time vs. off-line
Real time: sacrifice quality for performance
Hardware support necessary


Use polygons and scanline rendering
Use simple lighting models
 Phong+diffuse+ambient

New hardware might change this
Applications: interactive systems


Games
Walkthroughs

Primary goal: get the “right” appearance

Less concern about time
Done in software – great flexibility


Not only triangles
Not only Phong
Can use different rendering techniques

Raytracing


Radiosity
REYES

The idea: follow light propagation through the scene
Algorithm:


Shoot a ray through eye position and pixel center
Determine the first surface it intersects with



Compute surface color:
Shoot new rays to light sources (shadow rays)

If blocked, no contribution
Account for surface reflection, light and viewing direction

If surface is a mirror:


Shoot new ray in mirror direction
Repeat the process
If surface is diffuse:

Terminate


Alternative: shoot a ray in random direction
Called pathtracing – very slow
Always terminate once contribution is small

Rays carry light energy

Ray through the pixel center – aliasing artifacts
Increase number of rays per pixel, average results
 supersampling
Better if point is chosen randomly

Stochastic sampling
 Turn regular artifacts into noise

Mirror reflections / refractions are easy
Arbitrary surface reflectance properties

BRDFs
Diffuse interreflections are difficult
Can be very slow


Need extra acceleration datastructures
 Grids, octrees, etc.
With these, speed is ok on modern machines
Scanline performance: number of objects
Raytracing performance: image resolution

Assumption: all surfaces are Lambertian

Uniformly diffuse
Split all surfaces into patches

Chose a point on each patch
Light reflected from a patch at a point = linear combination of light from other points
Coefficients depends on mutual arrangement

Write equations of light transfer
Compute patch-to-patch transfer coefficients

Form factors
Solve this system

Get patch color at one point
Interpolate to get color everywhere on the patch

Lots of different algorithms to:



Split surfaces into patches
 Respecting shadow boundaries, etc.
Compute form factors
Solve radiosity system of equations
 Efficient methods for special “sparse” systems
 Take into account only significant energy exchanges
Some form is implemented in Blender

Very nice images of diffuse environments
A rather complex algorithm

Form factor computation is slow
Does not handle mirrors

Some form of raytracing is needed
Currently somewhat decreasing in popularity

Champion in longevity


Created in mid-80s by what now Pixar
Basis for RenderMan – standard rendering tool for movie industry
1993 Academy award (“Oscar”)
Major ideas:


Splitting and dicing of primitives
Surface shaders

Determine if a primitive is on the screen
Compute primitive size on the screen

Use bounding boxes
Split if the size is “too large”
Dicing – conversion to a “grid”


Tesselation into mycropolygons
 Size is about 1 pixel
Their vertices are shaded

Primitives have shaders attached to it
Shader – program which determines relevant parameters
Not only surface color (surface shaders)




Displacement shaders
Light shaders
Volume shaders
Imager shaders (BMRT only)

Determine which pixels are affected by micropol.
Each pixel has list of sample positions

Stochastic point samples
Test which are covered by a micropol.
Each sample has associated visible point list

Includes depth and transparency
Once done, determine pixel color

Memory usage problem

Visible point lists are huge
Use buckets – small pixel regions


Sort primitives into buckets
Process one bucket at a time
Occlusion culling


Sort primitives by depth in each bucket
Process close objects first

4/4/02

RenderMan also specifies a rendering interface
Independent of implementation


REYES system in Pixar’s RenderMan
Raytracing in BMRT

Mostly transparent for the user
Analog: OpenGL is an interface


Hardware support – driver hides the details
Software implementation (Mesa)

Scene description file

.rib (RenderMan interface bytestream)
Compiled shaders

.slc – used by RenderMan directly
Shading language


High level C-like language
.sl – run a compiler to convert into .slc

It is run from a command line
Run “setenv” first to set up paths rgl – fast OpenGL previewer


Good for geometry/lights/camera positioning
Usage: rgl ribname.rib
slc - shader language compiler :


 slc shadername.sl
Produces shadername.slc
Need to do this for all shaders used

rendrib is the renderer
 rendrib ribname.rib
Creates output according to rib specs

Use –d to get display output directly

-d 16 to get multiresolution approximation
Raytracing complex scenes can be slow

Debug shaders on simple geometry

Global options
Frame block
Image options
Camera options
World block
Attributes, lights, primitives
Changed options
Another world block
Next frame block

Can declare parameters with


Declare “name” “declaration” declaration is an analog of type
 class type actually
Type = float, color, vertex, vector, normal, point, string, matrix
This is global
In-line decraration – only in particular command

“ class type name ”

Everything between AttributeBegin and
AttributeEnd
Inherits attribute state of the parent
Manipulates it, assigns to geometric primitives
Attribute state:
 color/shaders attached

Transformation matrices
TransformBegin / TransformEnd push/pop transform matrices

Applies to local coord system
Rotate angle vx vy vz
Scale sx sy sz
Skew angle vx vy vz ax ay az
ConcatTransform matrix
Identity
Transform matrix

Camera space


Origin at the camera, Z+ in front, Y+ is up
Left-handed !!!

Created with
 Projection type parameterlist
Everything else is relative to it
Before WorldBegin – form world-to-camera matrix
Each object/shader created according to current transform matrix

Coord system is stored as “object” / “shader” space

Quadrics:

Sphere, cylinder, cone, paraboloid, hyperboloid, disk, torus
Polygons and meshes:

Polygon, GeneralPolygon, PointsPolygon,
PointsGeneralPolygon
Parametric patches and NURBS:

Basis, Patch, PatchMesh, NuPatch
Other: trim curves, subdivision meshes, CSG

Attached to geometric primitives
Can be referred to directly:

“P”, “Pw”, “N”, “Cs”, “Os”, “st”
These are:

Position in 3D (P), and in hc (Pw)



Normal (N)
Surface color (Cs) and opacity (Os)
Texture coords (st)

In .rib file, created by:

Surface “shadername” parameterlist

Displacement “shadername” parameterlist
Parameters are passed to the shader program

Written in special shading language
Has access to some global variables
Sets some global variables


Final surface color Ci and opacity Oi
Can also modify position P and normal N
 Displacement shader

Surface metal (float Ka = 1, Ks =
1; float roughness = .1;)
{ normal Nf = faceforward
(normalize(N),I); vector V = -normalize(I);
Ci = Cs * (Ka*ambient() +
Ks*specular(Nf,V,roughness));
Oi = Os; Ci *= Oi;
}

In .rib file the usage will be:
AttributeBegin
Translate 0 0 0
Color 1 .3 .05
Surface "metal" "roughness" [0.3]
"Ks" [1.5]
ReadArchive "vase.rib"
AttributeEnd

Global variables: N, I, Oi, Os, Ci, Cs


Sets final surface color Ci
Cs is from .rib file

Parameters Ka, Ks, roughness are from shader parameterlist in .rib
Shader language functions:


Uses default ambient() and specular(…) to do actual computation
 There is also diffuse(…)
Normalize(), faceforward()

Can access light information in illumination loops color diffuse (normal Nn){ extern point P; color C=0; illuminance(P,Nn,PI/2){
C+=Cl*(Nn . Normalize(L))
} return C; }
Loops over all visible lights from P which are within PI/2 from Nn

BMRT implements RenderMan interface
But it is a raytracer

Extra features available color trace(point from; vector dir) returns incoming light from dir
Also Fulltrace, rayhittest, visibility, etc.

RayTrace(…) – stochastic supersampling
Easy to do reflections

color MaterialShinyMetal (normal Nf; color basecolor; float Ka, Kd, Ks, roughness, Kr, blur; uniform float twosided;
DECLARE_ENVPARAMS;)
{ extern point P; extern vector I; extern normal N; float kr = Kr;

if (twosided == 0 && N.I > 0) kr = 0; vector IN = normalize(I), V = -IN; vector R = reflect (IN, Nf); return basecolor * (Ka*ambient() +
Kd*diffuse(Nf) +
Ks*specular(Nf,V,roughness) +
SampleEnvironment (P, R, kr, blur,
ENVPARAMS));
}

Mostly as before
SampleEnvironment calls RayTrace


Also includes environment mapping
See reflections.h
ENVPARAMS is a bunch of stuff controlling ray tracing / env. mapping

Number of samples, env.map name, etc.

Real power of RenderMan is in its flexibility
Want complex appearance – just write a shader function

Hundreds of parameters for complex shaders
Will see more on procedural techniques later in the course

Including possibilities for some interesting shaders
Assignment 5 asks you to play with shaders

And write a few of your own…