Advanced rendering techniques

1. Advanced rendering techniques 4/2/02

2. Rendering for animation • 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

3. 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

4. Ray tracing • 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

5. 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

6. Stochastic supersampling • 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

7. Advantages / disadvantages • 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

8. 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 points • Coefficients depends on mutual arrangement

9. Radiosity • 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

10. 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

11. Advantages / disadvantages • 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

12. 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

13. Splitting and dicing • 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

14. Shader concept • 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)

15. 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

16. 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

17. RenderMan / BMRT 4/4/02

18. RenderMan rendering interface • 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)

19. 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

20. Using RenderMan • 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

21. 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

22. .rib file anatomy Global options Frame block Image options Camera options World block Attributes, lights, primitives Changed options Another world block Next frame block

23. 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, matrix • This is global • In-line decraration – only in particular command • “class type name”

24. Attribute blocks • 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

25. Transformations • 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

26. Special coord systems • 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

27. 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

28. Primitive variables • 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)

29. 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 variables • Sets some global variables • Final surface color Ci and opacity Oi • Can also modify position P and normal N • Displacement shader

30. A simple shader Surfacemetal (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; }

31. 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

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

33. Lights and illumination • 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

34. BMRT • 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

35. 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;

36. …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)); }

37. Notes on raytracing shader • 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.

38. Concluding notes • 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…