Repetition of TDA361. Ulf Assarsson

Transcription

1 Repetition of TDA361 Ulf Assarsson

2 Misc Eng translation: All your answers on exam must be written in English Till alla lärare på masternivån, Undervisningen på Chalmers masterprogram sker på engelska. Vicerektor Sven Engström klarlägger att all examination också sker på engelska dvs tentamenssvaren skall vara på engelska. Syftet är att studenten skall träna i att kommunicera på engelska såväl muntligt som skriftligt i olika situationer. För skriftliga tentamina gäller t ex att annat språk än engelska inte skall beaktas vid rättningen. Som tidigare är ordböcker tillåtna hjälpmedel vid tentamina förutom vid tentamen i språk. Var vänlig meddela detta till studenterna på Dina kurser inför tentamensperioden i oktober. Tomas Akenine-Mőller 2002

3 Lecture 1: Real-time Rendering The Graphics Rendering Pipeline Chapter 2 in the book The pipeline is the engine that creates images from 3D scenes Three conceptual stages of the pipeline: Application (executed on the CPU) Geometry Rasterizer Application Geometry Rasterizer Image input 3D scene + how to locate the bottleneck, RTR: ch 10.1 Ulf Assarsson 2004 output

4 GEOMETRY Summary Application Geometry Rasterizer model space world space world space camera space compute lighting projection image space clip map to screen ModelViewMtx = Model to View Matrix Ulf Assarsson 2004

5 Lecture 2: Transforms Homogeneous notation Quaternions Know what they are good for. Not knowing all mathematical rules. Projections Ulf Assarsson 2004

6 Tomas Akenine-Mőller 2002 Homogeneous notation A point: Translation becomes: A vector (direction): Translation of vector: Also allows for projections (later) 1 1 ) ( z z y y x x z y x z y x t p t p t p p p p t t t t T T z y x p p p 1 p T z y x d d d 0 d Td d Translationsdelen rotationsdelen 03. Vectors and Transforms

7 Change of Frames M model-to-world : M world model-toz z z z y y y y x x x x o c b a o c b a o c b a (0,5,0) E.g.: p world = M mw p model = M mw (0,5,0) T = 5 b (+ o) b x y z a c o world space model space 03. Vectors and Transforms

8 03. Vectors and Transforms Projections Orthogonal (parallel) and Perspective Tomas Akenine-Mőller 2002

9 Tomas Akenine-Mőller 2002 Orthogonal projection Simple, just skip one coordinate Say, we re looking along the z-axis Then drop z, and render y x z y x ortho ortho p p p p p M M z z 03. Vectors and Transforms

10 06. Rasterization, Depth Sorting and Culling: DDA Algorithm Digital Differential Analyzer DDA was a mechanical device for numerical solution of differential equations Line y=kx+ m satisfies differential equation dy/dx = k = Dy/Dx = y 2 -y 1 /x 2 -x 1 Along scan line Dx = 1 y=y1; For(x=x1; x<=x2,ix++) { write_pixel(x, round(y), line_color) y+=k; }

11 06. Rasterization, Depth Sorting and Culling: Using Symmetry Use for 1 k 0 For k > 1, swap role of x and y For each y, plot closest x

12 06. Rasterization, Depth Sorting and Culling: Very Important! The problem with DDA is that it uses floats which was slow in the old days Bresenhams algorithm only uses integers You do not need to know Bresenham s algorithm by heart. It is enough to understand the following 2 slides.

13 Bresenham s line drawing algorithm The line is drawn between two points (x 0, y 0 ) and (x 1, y 1 ) k ( y ( x Slope 1 0 (y = kx + m) 1 y x 0 ) ) This is the reason that DDA needs floats. So Bresenham s solution is to multiply all corresponding numbers with (x 1 -x 0 ) to get integers. Each time we step 1 in x-direction, we should increment y with k. Otherwise the error in y increases with k. If the error surpasses 0.5, the line has become closer to the next y- value, so we add 1 to y simultaneously decreasing the error by 1 function line(x0, x1, y0, y1) int deltax := abs(x1 - x0) int deltay := abs(y1 - y0) real error := 0 real deltaerr := deltay / deltax int y := y0 for x from x0 to x1 plot(x,y) error := error + deltaerr if error 0.5 y := y + 1 error := error See also Ulf Assarsson 2006

14 Bresenham s line drawing algorithm Now, convert algorithm to only using integer computations The trick we use is to multiply all the fractional numbers above by (x 1, x 0 ), which enables us to express them as integers. The only problem remaining is the constant 0.5 to deal with this, we multiply both sides of the inequality by 2 Old float version: function line(x0, x1, y0, y1) int deltax := abs(x1 - x0) int deltay := abs(y1 - y0) real error := 0 real deltaerr := deltay / deltax int y := y0 for x from x0 to x1 plot(x,y) error := error + deltaerr if error 0.5 y := y + 1 error := error New integer version: function line(x0, x1, y0, y1) int deltax := abs(x1 - x0) int deltay := abs(y1 - y0) real error := 0 real deltaerr := deltay int y := y0 for x from x0 to x1 plot(x,y) error := error + deltaerr if 2*error deltax y := y + 1 error := error - deltax Bresenhams alg. Ulf Assarsson 2006

15 06. Rasterization, Depth Sorting and Culling: Painter s Algorithm Render polygons a back to front order so that polygons behind others are simply painted over B behind A as seen by viewer Requires ordering of polygons first O(n log n) calculation for ordering Not every polygon is either in front or behind all other polygons Fill B then A I.e., : Sort all triangles and render them back-to-front.

16 06. Rasterization, Depth Sorting and Culling: z-buffer Algorithm Use a buffer called the z or depth buffer to store the depth of the closest object at each pixel found so far As we render each polygon, compare the depth of each pixel to depth in z buffer If less, place shade of pixel in color buffer and update z buffer

17 Lektion 3: OpenGL Uses OpenGL (or DirectX) Will not ask about syntax. Know how to use. E.g. how to achieve Transparency Fog(start, stop, linear/exp/exp-squared) Specify a material, a triangle Ulf Assarsson 2004

18 03. OpenGL: Specifying vertices and polygons OpenGL is a state machine. Commands typically change the current state Multiple calling formats for the commands: void glvertex{234}{sifd}( T coords ); glbegin()/glend(). (Slow) glbegin(gl_triangle) glvertex3f(0,0,0) glvertex3f(0,1,0); glvertex3f(1,1,0); glend(); Optional: Can specify for instance glcolor3f(r,g,b), gltexcoord2f(s,t), glnormal3f(x,y,z) - typically per vertex or per primitive. Display lists are created with surrounding glnewlist() and glendlist(). (Fast) int dlist=glgenlists(1); glnewlist(dlist,gl_compile); glutsolidsphere(radius, 20, 20); glendlist(); Display lists are then drawn with: glcalllist(dlist); Vertex Arrays (Fast): // generate one display list number // indicates start of display list // or any object specification // indicates end of display list Idea: Objects are stored internally in the most efficient format void gltexcoordpointer( int size, enum type, sizei stride, void *pointer ); //Defines an array of texture coordinates void glcolorpointer( int size, enum type, sizei stride,void *pointer ); //Defines an array of colors (void glindexpointer( enum type, sizei stride, void *pointer ); //Defines an array of color indices) void glnormalpointer( enum type, sizei stride,void *pointer ); //Defines an array of normals void glvertexpointer( int size, enum type, sizei stride,void *pointer ); //Defines an array of vertices void glenableclientstate( enum array ); void gldisableclientstate( enum array ); with array set to TEXTURE_COORD_ARRAY, COLOR_ARRAY, INDEX_ARRAY, NORMAL_ARRAY, or VERTEX_ARRAY, void glarrayelement(int i ); // Transfers the ith element of every enabled array to OpenGL void gldrawarrays(mode; first; count); // Renders multiple primitives from the enabled arrays void gldrawelements(mode, count, type,*indices ); // Same as gldrawarrays, but takes array elements pointed to by indices. void glinterleavedarrays(format; stride; pointer); // One array with vertices, normals, textures and/colors interleaved Ulf Assarsson 2003

19 03. OpenGL: Matrix and Stack Operations Matrix Operations: glrotate(),gltranslate(), glscale(), GLU Helper functions: gluperspective(), glulookat, Ulf Assarsson 2003

20 03. OpenGL: Lighting and Colors glcolor4f(r,g,b,a), glcolor3f(r,g,b) Used when lighting is disabled: Disable with gldisable( GL_LIGHTING ); Could be changed for instance per vertex or per object. Can also be specified with glcolorpointer() as described previously glmaterialfv() Used when lighting is enabled. Enable with glenable( GL_LIGHTING ); Must also enable lights: glenable( GL_LIGHTn ); Example: glmaterialfv(gl_front_and_back, GL_AMBIENT, float rgba[4]) glmaterialfv(gl_front_and_back, GL_DIFFUSE, float rgba[4]) glmaterialfv(gl_front_and_back, GL_SPECULAR, float rgba[4]) glmaterialfv(gl_front_and_back, GL_EMISSION, float rgba[4]) glmaterialf(gl_front_and_back, GL_SHININESS, 30) Ulf Assarsson 2003

21 03. OpenGL: Buffers Frame buffer Back/front/left/right gldrawbuffers() Alpha channel: glalphafunc() Depth buffer (z-buffer) For correct depth sorting Instead of BSP-algorithm, painters algorithm Stencil buffer E.g. Shadow volumes and masking rendering to non-rectangular regions, Accumulation buffer Ulf Assarsson 2003

22 Lecture 4.1: Shading Lighting i=iamb+idiff+ispec+iemission + + = Know how to compute components. Also, Blinns and Phongs highlight model Ulf Assarsson 2004

23 05. Shading: Lighting Light: Ambient (r,g,b,a) Diffuse (r,g,b,a) Specular (r,g,b,a) Material: Ambient (r,g,b,a) Diffuse (r,g,b,a) Specular (r,g,b,a) Emission (r,g,b,a) = självlysande färg Tomas Added Akenine-Mőller by Ulf Assarsson,

24 04. Shading: Lighting i=iamb+idiff+ispec+iemission I.e.: i=iamb+idiff+ispec+iemission i amb m amb s amb i diff ( nl) m Phong s reflection model: diff i s spec diff mshi max(0,( r v) ) m spec s spec Blinn s reflection model: i spec mshi max(0,( hn) ) m spec s spec iemission m emission Tomas Akenine-Mőller 2002

25 04. Shading: Ambient component: iamb Ad-hoc tries to account for light coming from other surfaces Just add a constant color: i amb m amb s amb i.e., (i r, i g, i b, i a ) = (m r, m g, m b, m a ) (l r, l g, l b, l a ) gllightmodelfv(gl_light_model_ambient, global_ambient) Modified Tomas Akenine-Mőller by Ulf Assarsson,

26 04. Shading: Diffuse component : idiff i=iamb+idiff+ispec+iemission Diffuse is Lambert s law: i diff nl Photons are scattered equally in all directions i diff ( nl) m diff s diff cos Tomas Akenine-Mőller 2002

27 04. Shading: Lighting Specular component : ispec Diffuse is dull (left) Specular: simulates a highlight Tomas Akenine-Mőller 2002

28 04. Shading: Specular component: Phong Phong specular highlight model Reflect l around n: r r l 2(n l)n i ( r v) (cos ) spec m shi m shi ( n l) n -l n l nl i spec mshi max(0,( r v) ) m spec s spec Next: Blinns highlight formula: (n. h) m Tomas Akenine-Mőller 2002

29 04. Shading: Halfway Vector Blinn proposed replacing v r by n h where h = (l+v)/ l + v (l+v)/2 is halfway between l and v If n, l, and v are coplanar: y /2 Must then adjust exponent so that (n h) e (r v) e i spec (e 4e) mshi max(0,( hn) ) m spec s spec

30 04. Shading: Shading Three common types of shading: Flat, Goraud, and Phong In standard Gouraud shading the lighting is computed per triangle vertex and for each pixel, the color is interpolated from the colors at the vertices. In Phong Shading the lighting is not per vertex. Instead the normal is interpolated per pixel from the normals defined at the vertices and full lighting is computed per pixel using this normal. This is of course more expensive but looks better. Flat Gouraud Phong Tomas Akenine-Mőller 2002

31 04. Shading: Transparency and alpha Transparency Very simple in real-time contexts The tool: alpha blending (mix two colors) Alpha (a) is another component in the frame buffer, or on triangle Represents the opacity 1.0 is totally opaque 0.0 is totally transparent The over operator: c ac ( 1a) c o s d Rendered object Tomas Akenine-Mőller 2002

32 04. Shading: Transparency Need to sort the transparent objects First, render all non-transparent triangles as usual. Then, sort all transparent triangles and render back-to-front with blending enabled. (and using standard depth test) Partly to avoid problems with the depth test and partly because the blending operation is order dependent. Tomas Akenine-Mőller 2002

33 Leture 4.2: Sampling, filtrering, and AA Why care? When does it occur? In pixels, time, texture, etc Nyquist Filters Supersampling schemes Jittered sampling Adaptive sampling in ray tracing Ulf Assarsson 2004

34 Filtering FILTERING: For magnification: Nearest or Linear (box vs Tent filter) For minification: Bilinear using mipmapping Trilinear using mipmapping Anisotropic some mipmap lookups along line Ulf of Assarsson anisotropy 2004

35 Interpolation Magnification Minification Ulf Assarsson 2004

36 Bilinear filtering using Mipmapping Ulf Assarsson 2004

37 07. Texturing: Mipmapping Image pyramid Half width and height when going upwards Average over 4 parent texels to form child texel Depending on amount of minification, determine which image to fetch from Compute d first, gives two images Bilinear interpolation in each v d u Tomas Akenine-Mőller 2002

38 07. Texturing: (u 0,v 0,d 0 ) Mipmapping Interpolate between those bilinear values Gives trilinear interpolation Level n+1 d v u Level n Constant time filtering: 8 texel accesses Tomas Akenine-Mőller 2002

39 Anisotropic texture filtering Ulf Assarsson 2004

40 07. Texturing: 05. Texturing Most important: Texturing, environment mapping Bump mapping 3D-textures, Particle systems Sprites and billboards

41 07. Texturing: Environment mapping Assumes the environment is infinitely far away Sphere mapping For details, see OH Cube mapping is the norm nowadays Advantages: no singularities as in sphere map Much less distortion Gives better result Not dependent on a view position Modified by Ulf Assarsson 2004 Tomas Akenine-Mőller 2002

42 07. Texturing: Cube mapping eye n y z x Simple math: compute reflection vector, r Largest abs-value of component, determines which cube face. Example: r=(5,-1,2) gives POS_X face Divide r by abs(5) gives (u,v)=(-1/5,2/5) If your hardware has this feature, then it does all the work Tomas Akenine-Mőller 2002

43 07. Texturing: Bump mapping by Blinn in 1978 Inexpensive way of simulating wrinkles and bumps on geometry Too expensive to model these geometrically Instead let a texture modify the normal at each pixel, and then use this normal to compute lighting per pixel geometry + = Bump map Bump mapped geometry Stores heights: can derive normals Tomas Akenine-Mőller 2002

44 07. Texturing: 3D Textures 3D textures: Feasible on modern hardware as well Texture filtering is no longer trilinear Rather quadlinear (linear interpolation 4 times) Enables new possibilities Can store light in a room, for example Tomas Akenine-Mőller 2002

45 07. Texturing: GLbyte M[64]= { 127,0,0,127, 127,0,0,127, 127,0,0,127, 127,0,0,127, 0,127,0,0, 0,127,0,127, 0,127,0,127, 0,127,0,0, 0,0,127,0, 0,0,127,127, 0,0,127,127, 0,0,127,0, 127,127,0,0, 127,127,0,127, 127,127,0,127, 127,127,0,0}; Sprites Sprites (=älvor) was a technique on older home computers, e.g. VIC64. As opposed to billboards sprites does not use the frame buffer. They are rasterized directly to the screen using a special chip. A special bitregister also marked colliding sprites. void display(void) { glclearcolor(0.0,1.0,1.0,1.0); glclear(gl_color_buffer_bit); glenable (GL_BLEND); glblendfunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glrasterpos2d(xpos1,ypos1); glpixelzoom(8.0,8.0); gldrawpixels(width,height, GL_RGBA, GL_BYTE, M); } glpixelzoom(1.0,1.0); glutswapbuffers();

46 07. Texturing: Billboards 2D images used in 3D environments Common for trees, explosions, clouds, lens flares

47 07. Texturing: Billboards Rotate them towards viewer Either by rotation matrix or by orthographic projection

48 07. Texturing: Billboards Fix correct transparency by blending AND using alphatest glenable(gl_alpha_test); glalphafunc(gl_greater, 0.1); Color Buffer Depth Buffer With blending Threshold > 0. If alpha value in texture is lower than this threshold value, the pixel is not rendered to. I.e., neither frame buffer nor z-buffer is updated. Which is what we want to achieve. E.g. here: With alpha test

49 07. Texturing: n axial billboarding The rotation axis is fixed and disregarding the view position (Also called Impostors)

50 Lecture 6.1: Intersection Tests 4 techniques: Analythic Geometric e.g. ray vs box (3 slabs) SAT Test: 1. axes ortho to side of A, 2. axes ortho to side of B 3. crossprod of edges Dynamic tests Know how they work E.g., describe an algorithm for intersection between a ray and a polygon. Know equations for ray, sphere, cylinder, plane Ulf Assarsson 2004

51 Analytical: Ray/plane intersection Ray: r(t)=o+td Plane formula: n p + d = 0 o d n Replace p by r(t) and solve for t: n (o+td) + d = 0 n o+tn d + d = 0 t = (-d -n o) / (n d) Tomas Akenine-Mőller 2003

52 Tomas Akenine-Mőller 2003 Analytical: Ray/sphere test Sphere center: c, and radius r Ray: r(t)=o+td Sphere formula: p-c =r Replace p by r(t): r(t)-c =r 0 ) ) ( ( ) ) ( ( 2 r t t c r c r 1 0 ) ( ) ( ) ) 2(( 2 2 d c ο c ο d c ο r t t 0 ) ( ) ( 2 r t t c d o c d o 0 ) ( ) ( ) ) 2(( ) ( 2 2 r t t c ο c ο d c ο d d o d c r This is a standard quadratic equation. Solve for t.

53 Lecture 6.2: Spatial Data Structures and Speed-Up Techniques Speed-up techniques Culling Backface View frustum (hierarchical) Portal Occlusion Culling Detail Levels-of-detail How to construct and use the spatial data structures BVH, BSP-trees (polygon aligned + axis aligned) Ulf Assarsson 2004

54 Lecture 6.2: Spatial data structures BVH, Grids (recursive/hierarchical), octrees/quadtree, BVH spherical / OBB / AABB, BSP (polygon / axis aligned, kdtrees) How to use, what they look like, how to construct (if mentioned in the course) Ulf Assarsson 2004

55 Ray Tracing Summary of the Ray tracingalgorithm: Image plane light trace() Point is in shadow shade() trace() trace() shade() main()-calls trace() for each pixel trace(): should return color of closest hit point along ray. 1. calls findclosestintersection() 2. If any object intersected call shade(). Shade(): should compute color at hit point 1. For each light source, shoot shadow ray to determine if light source is visible If not in shadow, compute diffuse + specular contribution. 2. Compute ambient contribution 3. Call trace() recursively for the reflection- and refraction ray. Tomas Akenine-Mőller 2002

56 Lecture 7-8: Ray tracing Adaptive Super Sampling Jittering How to stop recursion? (Transmission) Speedup techniques Spatial data structures Optimizations for BVHs skippointer tree BVH-traversal (You do not need to learn the ray traversal algorithms for Grids nor AA-BSP trees) Shadow cache Material (Fresnel: metall, dielectrics) Constructive Solid Geometry Ulf Assarsson 2004

57 09. Curves and Surfaces: Objectives p 1 Introduce the types of curves Interpolating Blending polynomials for interpolation of 4 control points (fit curve to 4 control points) Hermite fit curve to 2 control points + 2 derivatives (tangents) Bezier 2 interpolating control points + 2 intermediate points to define the tangents B-spline To get C 2 continuity NURBS Different weights of the control points and The control points can be at non-uniform intervalls p 0 p 2 p 3

58 09. Curves and Surfaces: Splines and Basis If we examine the cubic B-spline from the perspective of each control (data) point, each interior point contributes (through the blending functions) to four segments We can rewrite p(u) in terms of the data points as p( u) B ( u) i defining the basis functions {B i (u)} p i

59 u 09. Curves and Surfaces: B-Splines These are our control points, p 0 - p 8, to which we want to approximate a curve p 0 p 1 p 2 p 3 p 4 p5 p 6 p 7 p 8 100% u= Illustration of how the control points are evenly (uniformly) distributed along the parameterisation u of the curve p(u). In each point p(u) of the curve, for a given u, the point is defined as a weighted sum of the closest 4 surrounding points. Below are shown the weights for each point along u=01 p 0 p 1 p 2 p 3 p 4 p 5 p 6 p 7 p 8 u

60 SUMMARY B-Splines 100% In each point p(u) of the curve, for a given u, the point is defined as a weighted sum of the closest 4 surrounding points. Below are shown the weights for each point along u=01 Blendfunction B 1 (u) for point p 1 p 0 p 1 p 2 p 3 p 4 p 5 p 6 p 7 p 8 The weight function (blend function) B pi (u) for a point p i can thus be written as a translation of a basis function B(t). B pi (u) = B(u-i) u B(t): 100% t Our complete B-spline curve p(u) can thus be written as: p( u) B ( u) i p i

61 09. Curves and Surfaces: NURBS NURBS is similar to B-Splines except that: 1. The control points can have different weights, w i, (heigher weight makes the curve go closer to that control point) 2. The control points do not have to be at uniform distances (u=0,1,2,3...) along the parameterisation u. E.g.: u=0, 0.5, 0.9, 4, 14, NURBS = Non-Uniform Rational B-Splines The NURBS-curve is thus defined as: Division with the sum of the weights, to make the combined weights sum up to 1, at each position along the curve. Otherwise, a translation of the curve is introduced (which can be fun but normally not desired)

62 09. Curves and Surfaces: NURBS Allowing control points at non-uniform distances means that the basis functions B pi () are being streched and non-uniformly located. E.g.: Each curve B pi () should of course look smooth and C 2 continuous. But it is not so easy to draw smoothly by hand... u

63 Lecture 10.1: Collision Detection 3 types of algorithms: With rays Fast but not exact With BVH Pseudo code is simple to derive Slower but exact For lots of objects. why? Course pruning of obviously non-colliding objects Sweep-and-prune Ulf Assarsson 2004

64 10.2 Vertex and Fragment Shaders: Vertex- and Fragment shaders Understand the following shaders Especially the first two

65 10. Vertex and Fragment Shaders: Wave Motion Vertex Shader uniform float time; uniform float xs, zs; void main() { float s; s = *sin(xs*time)*sin(zs*time); gl_vertex.y = s*gl_vertex.y; gl_position = gl_modelviewprojectionmatrix*gl_vertex; }

66 10. Vertex and Fragment Shaders: Particle System uniform vec3 init_vel; uniform float g, m, t; void main() { vec3 object_pos; object_pos.x = gl_vertex.x + vel.x*t; object_pos.y = gl_vertex.y + vel.y*t - g/(2.0*m)*t*t; object_pos.z = gl_vertex.z + vel.z*t; gl_position = gl_modelviewprojectionmatrix* vec4(object_pos,1); }

67 10. Vertex and Fragment Shaders: Vertex Shader for per Fragment Lighting /* vertex shader for per-fragment Phong shading */ varying vec3 normale; varying vec4 positione; void main() { normale = gl_normalmatrixmatrix*gl_normal; positione = gl_modelviewmatrix*gl_vertex; gl_position = gl_modelviewprojectionmatrix*gl_vertex; }

68 10. Vertex and Fragment Shaders: Fragment Shader for per Fragment Lighting varying vec3 normale; varying vec4 positione; void main() { vec3 norm = normalize(normale); vec3 lightv = normalize(gl_lightsource[0].position-positione.xyz); vec3 viewv = normalize(positione); vec3 halfv = normalize(lightv + viewv); vec4 diffuse = max(0, dot(lightv, viewv)) *gl_frontmaterial.diffuse*gl_lightsource[0].diffuse; vec4 ambient = gl_frontmaterial.ambient*gl_lightsource[0].ambient;

69 10. Vertex and Fragment Shaders: Fragment Shader for per Fragment Lighting int f; if(dot(lightv, viewv)> 0.0) f =1.0); else f = 0.0; vec3 specular = f*pow(max(0, dot(norm, halfv), gl_frontmaterial.shininess) *gl_frontmaterial.specular*gl_lightsource[0].specular); vec3 color = vec3(ambient + diffuse + specular); gl_fragcolor = vec4(color, 1.0); }

70 Lecture 11: Shadows + Reflection Point light / Area light Three ways of thinking about shadows The basis for different algorithms. Shadow mapping Be able to describe the algorithm Shadow volumes Be able to describe the algorithm Stencil buffer, 4-pass algorithm, Z-pass, Z-fail, Creating quads from the silhouette edges as seen from the light source, etc Pros and cons of shadow volumes vs shadow maps Planar reflections how to do. Why not using environment mapping? Ulf Assarsson 2004

71 Ways of thinking about shadows As separate objects (like Peter Pan's shadow) This corresponds to planar shadows As volumes of space that are dark This corresponds to shadow volumes As places not seen from a light source looking at the scene. This corresponds to shadow maps Note that we already "have shadows" for objects facing away from light Tomas Akenine-Mőller 2002

72 Using the Shadow Map When scene is viewed, check viewed location in light's shadow buffer If point's depth is (epsilon) greater than shadow depth, object is in shadow. shadow depth map For each pixel, compare distance to light with the depth stored in the shadow map 1. Render a shadow depth map from light source. 2. Render from eye. For each generated pixel, transform (warp) the x,y,z-coordinate to light space and compare depth with the stored depth value in the shadow map. If greater point is in shadow Else point is in light Problem: bias / offset neededtomas Akenine-Mőller 2002

73 Tomas Akenine-Mőller 2002

74 Shadow volumes Shadow volume concept Create volumes of space in shadow from each polygon in light. Each triangle creates 3 projecting quads Tomas Akenine-Mőller 2002

75 Using the Volume To test a point, count the number of polygons between it and the eye. If we look through more frontfacing than backfacing polygons, then in shadow. backfacing frontfacing Tomas Akenine-Mőller 2002

76 How to implement shadow volumes with stencil buffer (Z-pass) A four pass process [Heidmann91]: 1st Pass: render the scene with just ambient lighting. Turn off updating Z-buffer and writing to color buffer (i.e. Z-compare, draw to stencil only). 2nd pass: render front facing shadow volume polygons to stencil buffer, incrementing count. 3rd pass: render backfacing shadow volume polygons to stencil, decrementing. 4th pass: render diffuse and specular where stencil buffer is 0. Tomas Akenine-Mőller 2002

77 a=#shadow volumes a point is located within. a is independent of in which direction we count. Choose point at infinity. That point is always outside shadow, due to the caping of the shadow volumes Tomas Akenine-Mőller 2002

78 Compared to Z-pass: Invert z-test Invert stencil inc/dec I.e., count to infinity instead of from eye. Tomas Akenine-Mőller 2002

79 Shadow maps vs shadow volumes Shadow Volumes Good: Anything can shadow anything, including selfshadowing, and the shadows are sharp. Bad: 3 or 4 passes, shadow polygons must be generated and rendered lots of polygons & fill, Shadow Maps Good: Anything to anything, constant cost regardless of complexity, map can sometimes be reused. Bad: Frustum limited. Jagged shadows if res too low, biasing headaches. Tomas Akenine-Mőller 2002

80 Merging Volumes Edge shared by two polygons facing the light creates front and backfacing quad. This interior edge makes two quads, which cancel out Tomas Akenine-Mőller 2002

81 Silhouette Edges From the light s view, caster interior edges do not contribute to the shadow volume. Finding the silhouette edge gets rid of many useless shadow volume polygons. Tomas Akenine-Mőller 2002

82 Planar reflections Assume plane is z=0 Then apply glscalef(1,1,-1); Effect: z Tomas Akenine-Mőller 2002

83 Planar reflections Backfacing becomes front facing! Lights should be reflected as well Need to clip (using stencil buffer) See example on clipping: Tomas Akenine-Mőller 2002

84 Planar reflections How should you render? 1) the ground plan polygon into the stencil buffer 2) the scaled (1,1,-1) model, but mask with stencil buffer Reflect light pos as well Use front face culling 3) the ground plane (semi-transparent) 4) the unscaled model Tomas Akenine-Mőller 2002

85 Lektion 11 Global Illumination Global belysning: Why is not standard ray tracing enough? Light transport notation, rendering eq., BRDFs Monte Carlo Ray Tracing Path tracing Photon mapping L o L e f r ( x,, ') L ( x, ')( ' n) d' i Ray tracing Global Illumination Ulf Assarsson 2004

86 Lektion 12: Perspective correct texturing Taxonomy: Sort first sort middle sort last fragment sort last image Bandwidth Why it is a problem How to solve it Be able to sketch the architecture of a moder graphics card Ulf Assarsson 2004

87 Department of Computer Engineering Application PCI-E x16 Vertex shader Vertex shader Vertex shader Primitive assembly Geo shader Geo shader Clipping Fragment Generation Geo shader On NVIDIA 8000-series: Vertex-, Geometryand Fragment shaders allocated from a pool of 128 processors Fragment shader Fragment shader Fragment shader Fragment Merge Fragment Merge Fragment Merge