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 Next frame block Another world block World block Attributes, lights, primitives Changed options Image options Camera options

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

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…