Advanced rendering techniques

4/2/02

Rendering for animation

The big difference: real time vs. off-lineReal time: sacrifice quality for performanceHardware support necessary Use polygons and scanline rendering Use simple lighting models

Phong+diffuse+ambient New hardware might change this

Applications: interactive systems Games Walkthroughs

Off-line rendering

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

Ray tracing

The idea: follow light propagation through the sceneAlgorithm: 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

Recursive ray tracing

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

Stochastic supersampling

Ray through the pixel center – aliasing artifactsIncrease number of rays per pixel, average results supersampling

Better if point is chosen randomly Stochastic sampling

Turn regular artifacts into noise

Advantages / disadvantages

Mirror reflections / refractions are easyArbitrary surface reflectance properties BRDFs

Diffuse interreflections are difficultCan be very slow Need extra acceleration datastructures

Grids, octrees, etc. With these, speed is ok on modern machines

Scanline performance: number of objectsRaytracing performance: image resolution

Radiosity

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 pointsCoefficients depends on mutual arrangement

Radiosity

Write equations of light transferCompute patch-to-patch transfer coefficients Form factors

Solve this system Get patch color at one point

Interpolate to get color everywhere on the patch

Radiosity

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

Advantages / disadvantages

Very nice images of diffuse environmentsA rather complex algorithm Form factor computation is slow

Does not handle mirrors Some form of raytracing is needed

Currently somewhat decreasing in popularity

REYES system

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

Splitting and dicing

Determine if a primitive is on the screenCompute 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

Shader concept

Primitives have shaders attached to itShader – program which determines relevant parametersNot only surface color (surface shaders) Displacement shaders Light shaders Volume shaders Imager shaders (BMRT only)

Visible surface determination

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

Enhanced REYES

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

RenderMan / BMRT

4/4/02

RenderMan rendering interface

RenderMan also specifies a rendering interfaceIndependent 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)

RenderMan interface

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

Using RenderMan

It is run from a command lineRun “setenv” first to set up pathsrgl – 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

Using RenderMan

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

.rib file anatomy

Global options

Frame block

Next frame block

Another world block

World block Attributes, lights, primitives

Changed options

Image optionsCamera options

Parameter declarations

Can declare parameters with Declare “name” “declaration” declaration is an analog of type

class type actually

Type = float, color, vertex, vector, normal, point, string, matrixThis is globalIn-line decraration – only in particular command “class type name”

Attribute blocks

Everything between AttributeBegin and AttributeEndInherits attribute state of the parentManipulates it, assigns to geometric primitivesAttribute state: color/shaders attached Transformation matrices

TransformBegin / TransformEnd push/pop transform matrices

Transformations

Applies to local coord systemRotate angle vx vy vz

Scale sx sy sz

Skew angle vx vy vz ax ay az

ConcatTransform matrix

Identity

Transform matrix

Special coord systemsCamera space Origin at the camera, Z+ in front, Y+ is up Left-handed !!! Created with

Projection type parameterlist

Everything else is relative to itBefore WorldBegin – form world-to-camera matrixEach object/shader created according to current transform matrix Coord system is stored as “object” / “shader” space

Geometry

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

Primitive variables

Attached to geometric primitivesCan 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)

Shaders

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 variablesSets some global variables Final surface color Ci and opacity Oi Can also modify position P and normal N

Displacement shader

A simple 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;}

Simple shader usage

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

Simple shader notes

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()

Lights and illuminationCan 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

BMRT implements RenderMan interfaceBut it is a raytracer Extra features available

color trace(point from; vector dir) returns incoming light from dirAlso Fulltrace, rayhittest, visibility, etc. RayTrace(…) – stochastic supersampling

Easy to do reflections

Simple shader using raytracing

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;

…continued

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));

}

Notes on raytracing shader

Mostly as beforeSampleEnvironment 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.

Concluding notes

Real power of RenderMan is in its flexibilityWant 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…