1 / 38

Advanced rendering techniques

Advanced rendering techniques. 4/2/02. 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

mariah
Download Presentation

Advanced rendering techniques

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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…

More Related