Upload
mariah
View
92
Download
0
Tags:
Embed Size (px)
DESCRIPTION
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 - PowerPoint PPT Presentation
Citation preview
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…