CS 354 Surfaces, Programmable Tessellation, and NPR Graphics

4,175 views

Published on

May 1, 2012; CS 354 Computer Graphics; University of Texas at Austin

Published in: Technology, Art & Photos
1 Comment
4 Likes
Statistics
Notes
No Downloads
Views
Total views
4,175
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
126
Comments
1
Likes
4
Embeds 0
No embeds

No notes for slide

CS 354 Surfaces, Programmable Tessellation, and NPR Graphics

  1. 1. CS 354Surfaces &Programmable TessellationMark KilgardUniversity of TexasMay 1, 2012
  2. 2. CS 354 2 Today’s material  In-class quiz  On performance analysis lecture  Lecture topic  Surfaces  Programmable tessellation  Non-photorealistic rendering
  3. 3. CS 354 3 My Office Hours  Tuesday, before class  Painter (PAI) 5.35  8:45 a.m. to 9:15  Thursday, after class  ACE 6.302  11:00 a.m. to 12  Randy’s office hours  Monday & Wednesday  11 a.m. to 12:00  Painter (PAI) 5.33
  4. 4. CS 354 4 Last time, this time  Last lecture, we discussed  Graphics Performance Analysis  This lecture  Surfaces, programmable tessellation, non-photorealistic graphics  Projects  Project 4 on ray tracing on Piazza  Due Thursday May 3, 2012 (extended)
  5. 5. CS 354 5 On a sheet of paper Daily Quiz • Write your EID, name, and date • Write #1, #2, #3 followed by its answer  Multiple choice: If a 3D application renders no faster when the window is  Multiple choice: A task is split into resized smaller, the mostly likely to be two subtasks A and B consisting of effective tuning listed below is 25% and 75% of the total work. If a) enable mipmap texture filtering task B is optimized to be 5 times faster, how much faster is the overall b) optimize the efficiency of the task once B is optimized? application’s C/C++ rendering code c) defragment the hard drive a) 1.6x faster d) enable vertex retrace b) 2.0x faster synchronization for the buffer swaps e) remove instructions from the c) 2.5x faster fragment shaders d) 3.1x faster  Name a type of ray that is easily traced coherently. e) 5.0x faster
  6. 6. CS 354 6 Modeling with Patches  Triangles  Good for rendering  Not as great for modeling  No curvature  Assigning texture coordinates is hard  Easier to model with patches
  7. 7. CS 354 7 Types of Patches Triangular patch Quadrilateral patch Notice fractional tessellation scheme in wire-frame pattern
  8. 8. CS 354 8 Bezier Triangle Control Points P(u,v) = u3 b300 b003 + 3 u2v b210 b012 b102 + 3 uv2 b120 b021 + v3 b030 b201 b111 b030 + 3 u2w b201 + 6 uvw b111 + 3 v2w b021 b120 b210 + 3 uw2 b102 + 3 uv2 b012 + w3 b003 where w=1-u-v b300
  9. 9. CS 354 9 “Precise” Evaluation Math for Bezier Triangle Exampleprecise vec4 www = w*w*w * vec4(b300,1), precise vec4 wuE = wwu3 + wuu3, uuu = u*u*u * vec4(b030,1), uvE = uvv3 + uuv3, vvv = v*v*v * vec4(b003,1), wvE = wwv3 + wvv3, E = wuE + uvE + wvE; wwu3 = 3*w*w*u * vec4(b210,1), wuu3 = 3*w*u*u * vec4(b120,1), precise vec4 C = www + uuu + vvv; wwv3 = 3*w*w*v * vec4(b201,1), uuv3 = 3*u*u*v * vec4(b021,1), precise vec4 p = C + E; wvv3 = 3*w*v*v * vec4(b102,1), uvv3 = 3*u*v*v * vec4(b012,1), wuv6 = 6*w*u*v * vec4(b111,1);Notice evaluation needs homogenous coordinates, hence vec4(x,1)precise keyword ensures exact ordering of floating-point operations
  10. 10. CS 354 10 Tessellated Bezier Triangle Patch Bezier triangle’s tessellation Bezier triangle’s control point hull
  11. 11. CS 354 11 Bi-cubic Patch Mesh b13 b23 b03 b33 b02 b12 b22 b32 b01 b11 b21 b31 b10 b20 b00 b30
  12. 12. CS 354 12 Utah Teapot: Bi-cubic Patch Mesh
  13. 13. CS 354 13 Ed Catmull’s Gumbo
  14. 14. CS 354 14 Bi-cubic Patches Used in Production Rendering  Production renderers for film and video rely on surfaces
  15. 15. CS 354 15 Amplification of Standard Triangle Meshes Tessellation results in triangle amplification with curvature Original faceted mesh Results of Phong shading of curved
  16. 16. CS 354 16 Surfaces are Determined by Their Control Points Moving control points displaces the evaluated surfaces
  17. 17. CS 354 17 Motivation for Programmable Tessellation  Extreme geometric detail  Displacement mapping  Animated by control points  Adaptive detail  No cracks!  No discontinuities  All done on GPU © Kenneth Scott, id Software 2008
  18. 18. CS 354 18 Continuous Level-of-Detail  Close models get more triangles  Adaptation should be done by the GPU © Pixolator @ ZBrushCentral © Pixolator @ ZBrushCentral © Pixolator @ ZBrushCentral extreme tessellation medium tessellation coarse tessellation
  19. 19. CS 354 19 Scalability  View-dependent Level-of-Detail © Pixolator @ ZBrushCentral © Bay Raitt
  20. 20. CS 354 20 Displacement Mapping  Sample displacement value from a texture  Displace vertex along its normal © Kenneth Scott, id Software 2008
  21. 21. CS 354 21 Art Pipeline for Tessellation Control Cage Smooth Surface Displaced SurfaceProgrammable Tessellation Generate LODs … GPU Polygon Mesh Pre-processing of patch content, off GPU
  22. 22. CS 354 22 Iso-line Tessellation  Intended for hair, particular animation and combing  Scientific visualization applications too
  23. 23. CS 354 23 Visual Artifact Avoidance  Water-tightness of mesh is an issue  Similarly, gradient & normal continuity  Programmable tessellation has the necessary programmability to avoid such artifacts Example of unaddressed issue causing cracking
  24. 24. CS 354 24 Tools Allow Authoring of 3D Tessellation Content  3D modeling tools support generating content from made of surface patches  Same model for  OpenGL 4.0  DirectX 11 sub-division surface modeling tool sculpting tools
  25. 25. CS 354 25 OpenGL 2.1 vs. OpenGL 3.1 with Geometry Shaders primitive primitive indices indices topology & topology & in-band vertex in-band vertex attributes attributes index to vertex index to vertex attribute attribute puller puller vertex vertex attributes attributes vertex vertex shader shader assembled assembled primitive programmable primitive geometry fixed-function shader primitive stream clipping, clipping, setup, & setup, & rasterization rasterization fragments fragments fragment fragment shader shader OpenGL 3.1 OpenGL 2.1 supports geometry shaders
  26. 26. CS 354 26 OpenGL 3.1 with Geometry vs. OpenGL 4.0 with Tessellation indices primitive rectangular & indices primitive topology & triangluar topology & in-band vertex patch in-band vertex attributes index to vertex attributes index to vertex attribute attribute vertex puller puller vertex attributes attributes vertex attributes control point vertex vertex shader (vertex) shader shader control assembled points assembled primitive primitive level-of-detail parameters tessellation programmable control (hull) geometry geometry shader shader shader fixed-function tessellation patch control primitive stream primitive stream generator points & clipping, parameters clipping, setup, & setup, & rasterization tessellation rasterization evaluation fragments (domain) fragments fine primitive topology shader fragment fragment (u, v) coordinates shader shader OpenGL 3.1 OpenGL 4.0 supports geometry shaders supports programmable tessellation
  27. 27. CS 354 27 DirectX 11: Hull and Domain Shaders  Same hardware Input Assembler functionality as in Vertex Shader OpenGL 4.0 Hull Shader  Also exposed in Direct3D 11 New for Tessellator D3D11  Shader stage Domain Shader naming differences  Hull = Control Geometry Shader Stream Output  Domain = Evaluation Rasterizer Pixel Shader Output Merger
  28. 28. CS 354 28 Provide High-level Context for OpenGL 4.0’s Entire Dataflow  Show entire flow of various kinds of data within OpenGL  Vertices, fragments, pixels, filtered texels, buffer data  Include geometry shading & texture buffer objects  ARB extensions circa OpenGL 3.1  Ignores  Details of fixed-function & programmable operation within blocks  Evaluators  Display lists  Queries & errors  State changes  Accumulation  Feedback & selection  Uniform (bindable, parameter) buffer objects
  29. 29. CS 354 29 High-level Flow of Data within OpenGL 3.1 + Geometry Shaders + Texture Buffer Objects primitive topology, transformed Legend Vertex Vertex vertex data Geometric primitive assembly & vertices assembly primitive processing batch transformed processing programmable pixels operations type, vertex fragments vertex data attributes point, line, and polygon fixed-function filtered texels geometry operations fragments vertex Transform texture buffer data transform feedback fetches buffer objects feedback pixels in framebuffer object textures buffer objects primitive batch type, vertex texture stenciling, depth testing, blending vertex indices, vertex attributes texture fetches buffer buffer data, objects Texture Fragment Raster unmap Framebuffer mapping fragment processing operations buffer texture Command Buffer fetches parser store pixel map buffer, pack get buffer buffer data objects image and bitmap texture pixel fragments image pixel image or unpack Pixel specification texture image buffer specification packing objects pixels to pack image rectangles, bitmaps Image Pixel Pixel primitive unpacking unpacked processing pixels processing copy pixels, copy texture image
  30. 30. CS 354 30 Add Programmable Tessellation  Adds to the data flow  Control point processing  Similar to a vertex shader, but operates on control points  Patch assembly & control processing  Single Program Multiple Data execution  One thread of program execution per output control point  Allows patch basis conversions and level-of-detail computation  Level-of-detail requires computing reductions over all instances  Basis conversion example: reduce a Catmull-Clark subdivision patch to an approximating Bezier patch  Patch tessellation generator  Rectangular and triangle patches  Continuous and discrete tessellation  Patch evaluation shading  Given patch’s transformed control points and a (u,v) position within the patch domain, evaluate vertex position, gradients, and surface normal  Feeds evaluated vertex to conventional vertex shader  Added into previous diagram…  Clean fit: simply adds stages above vertex shading for tessellation
  31. 31. CS 354 31 Patch Control point Patch tessellation Patch evaluation assembly & processing transformed transformed generation transformed processing control points processing patch patch, bivariate patch tessellation control patch topology, evaluated patch vertex domain texture fetches points primitive topology, transformed Legend Geometric primitive Vertex Vertex vertex data patch data assembly & assembly primitive processing programmable vertices batch transformed processing operations pixels type, vertex vertex data attributes point, line, fragments and polygon fixed-function geometry operations filtered texels fragments vertex Transform texture buffer data transform feedback fetches buffer objects feedback pixels in framebuffer object textures buffer objects primitive batch type, vertex texture stenciling, depth testing, blending vertex indices, vertex attributes texture fetches buffer buffer data, objects Texture Fragment Raster unmap Framebuffer mapping fragment processing operations buffer texture Command Buffer fetches parser store pixel map buffer, pack get buffer buffer data objects image and bitmap texture fragments pixel image pixel image or unpack Pixel specification texture image buffer specification packing objects pixels to pack image rectangles, bitmaps Image Pixel Pixel primitive unpacking unpacked processing pixels processing copy pixels, copy texture image
  32. 32. CS 354 32 Displacement Mapping
  33. 33. CS 354 33 Displacement Mapping
  34. 34. CS 354 34 Displacement Mapping • Displacement Mapping - Sample displacement value from a texture - Displace vertex along its normal • Watertight Normals - cross product of a pair of tangent, bi-tangent vectors - discontinuities occur at shared corners and edges - define corner and edge ownership
  35. 35. CS 354 35 Tessellation Shader Example: Starting Simple  Control point (vertex) shader transforms vertex positions to eye- space  Simple 4x3 affine matrix transformation  Tessellation control shader accepts a 3 control points  Forms a standard triangle  Passes each control point on to tessellation valuation  Computes a level-of-detail scalar for each edge based on the scaled window-space length of each edge  So the tessellation of the generated triangle patch adapts to the screen- space size of the triangle  Tessellation evaluation shader runs at each tessellated vertex of triangle patch  Gets 3 control points + (u,v,w) barycentric triangle weights  Weights control points to make a new position  Computes a surface normal  The normal is constant for the entire triangle in this case, but generally the normal would vary  Outputs barycentric weights as RGB color (to visualize)
  36. 36. CS 354 36 Simple Example Rendered Original single triangle Visualization of barycentric weights used by tessellation evaluation shader Adaptive tessellation automatically tessellates distant, small triangle less and close, large triangle more
  37. 37. 37 GLSL Control Point (Vertex)CS 354 Shader uniform vec2 wh; // scaled width&height of screen#version 400 compatibility out vec3 eye_space_pos; out vec2 scaled_window_space_pos;// Multiply XYZ vertex by 4x3 modelview out vec3 eye_normal;// matrix (assumed non-projective)vec3 transform(precise vec3 v) void main(void){ { vec3 r; eye_space_pos = // Remember: GLSL is oddly column-major transform(gl_Vertex.xyz); // so [col][row] for (int i=0; i<3; i++) { vec4 ndc_pos = r[i] = v[0]*gl_ModelViewMatrix[0][i] + gl_ModelViewProjectionMatrix * v[1]*gl_ModelViewMatrix[1][i] + vec4(gl_Vertex.xyz,1); v[2]*gl_ModelViewMatrix[2][i] + scaled_window_space_pos = gl_ModelViewMatrix[3][i]; wh*(ndc_pos.xy / ndc_pos.w); } return r; // Pass along two sets of texture} coordinates... gl_TexCoord[0] = gl_MultiTexCoord0; gl_TexCoord[1] = gl_MultiTexCoord1; mat3 nm = gl_NormalMatrix; vec3 n = gl_Normal; eye_normal = normalize(nm * n); }
  38. 38. CS 354 GLSL Tessellation Control Shader 38 void main(void) { sharable_len[TID] = #version 400 compatibility distance(scaled_window_space_pos[TID], layout(vertices=3) out; scaled_window_space_pos[(TID+1)%3]); barrier(); // thread ID #define TID gl_InvocationID float len0 = sharable_len[0], len1 = sharable_len[1], out float sharable_len[]; len2 = sharable_len[2]; in vec3 eye_space_pos[]; eye_space_pos2[TID] = eye_space_pos[TID]; in vec2 scaled_window_space_pos[]; // Limit level-of-detail output to thread 0 out vec3 eye_space_pos2[]; if (TID == 0) { // Outer LOD gl_TessLevelOuter[0]=len1;//V1-to-V2 edge gl_TessLevelOuter[1]=len2;//V2-to-V0 edge gl_TessLevelOuter[2]=len0;//V0-to-V1 edge // Inner LOD gl_TessLevelInner[0] = max(len0, max(len1, len2)); } }
  39. 39. CS 354 39 GLSL Tessellation Evaluation Shader#version 400 compatibility void main(void) { vec3 barycentric_weights =layout(triangles) in; gl_TessCoord;layout(ccw) in;layout(fractional_odd_spacing) in; vec3 v[3]; for (int i = 0; i < 3; i++) {in float sharable_len[]; v[i] = eye_space_pos2[i];in vec3 eye_space_pos2[]; } vec3 p = lerp3(v, barycentric_weights);vec3 lerp3(in vec3 attrs[3], vec3 uvw) gl_Position ={ applyPerspective(gl_ProjectionMatrix, return attrs[0] * uvw[0] + p); attrs[1] * uvw[1] + attrs[2] * uvw[2]; vec3 dpdv = eye_space_pos2[1] -} eye_space_pos2[0]; vec3 dpdw = eye_space_pos2[2] - eye_space_pos2[0];vec4 applyPerspective(mat4 affine_matrix, vec3 normal = cross(dpdv, dpdw); vec3 v){ // Show barycentric weights as color. vec4 r; vec4 color = vec4(barycentric_weights, 1.0); r[0] = affine_matrix[0][0] * v[0]; gl_FrontColor = color; r[1] = affine_matrix[1][1] * v[1]; gl_TexCoord[0] = r[2] = affine_matrix[2][2] * v[2] + vec4(normalize(normal), affine_matrix[3][2]; r[3] = -v[2]; length(normalize(normal))); return r; gl_TexCoord[1] = vec4(p, 1);} }
  40. 40. CS 354 40 More Complicated Example: Adaptive PN Triangles  Idea: Send a triangle mesh with positions & normals  Have the tessellation unit tessellated a curved triangle that matches the per-triangle positions & normals  Nice because existing triangle meshes can get extra triangle detail  Details  Same control point (vertex) shader as before  Tessellation control shader  Input: 3 control points + normals  Output: 10 control points for a Bezier triangle patch  Output: 6 controls points for quadratic normal interpolation  Output: adaptive level-of-detail (LOD) based on edge lengths in scaled window space  Tessellation evaluation shader  Does cubic interpolation of Bezier triangle to compute position  Does quadratic interpolation to compute surface normal
  41. 41. CS 354 41 Adaptive PN Triangles Tessellation Rendered Tessellated & Phong shaded Original monkey head faceted mesh Visualization of barycentric Wire frame of weights used by tessellation adaptive tessellation evaluation shader
  42. 42. Adaptive PN Triangle TessellationCS 354 42 Control Shader // Compute triangle LOD parameters.#version 400 compatibility// interior control points are per-patch // Each of 3 threads computes each of 3layout(vertices=3) out; // edge lengths. gl_TessLevelOuter[TID] =#define TID gl_InvocationID // thread ID distance(scaled_window_space_pos[TIDm1],#define P eye_space_pos#define P2 eye_space_pos2 scaled_window_space_pos[TID]);#define N eye_normal barrier();in vec3 eye_space_pos[]; gl_TessLevelInner[0] = max(gl_TessLevelOuter[0],in vec2 scaled_window_space_pos[];in vec3 eye_normal[]; max(gl_TessLevelOuter[1],out vec3 eye_space_pos2[]; gl_TessLevelOuter[2]));out vec3 eye_space_normal[];out vec3 ccw_cp[]; // ccw_cp[TID] is the control point immediateout vec3 cw_cp[]; // counter-clockwise from P[TID]out vec3 mid_normal[]; // cwc_cp[TID] is the control point immediatepatch out vec3 b111; // clockwise from P[TID] ccw_cp[TID] = (2*P[TID] + P[TIDp1] –void main(void) dot(P[TIDp1]-{ P[TID],N[TID])*N[TID])/3.0; // TIDp1 = counter-clockwise (plus 1) cw_cp[TID] = (2*P[TID] + P[TIDm1] – // control point index from TID dot(P[TIDm1]- int TIDp1 = TID<2 ? TID+1 : 0; P[TID],N[TID])*N[TID])/3.0; // ^^ Means TIDp1 = (TID+1)%3; // TIDm1 = clockwise (minus 1) control point P2[TID] = ccw_cp[TID] + cw_cp[TID]; // index from TID // (b210+b120+b021+b012+b102+b201)/6.0 int TIDm1 = TID>0 ? TID-1 : 2; vec3 E = (P2[0] + P2[1] + P2[2])/6.0, // ^^ Means TIDp1 = (TID+2)%3; V = (P[0] + P[1] + P[3])/3.0; b111 = E + (E-V)/2.0; P2[TID] = P[TID]; eye_space_normal[TID] = N[TID]; float v = 2*dot(P[TIDp1]-P[TID],N[TID]+N[TIDp1]) / dot(P[TIDp1]-P[TID],P[TIDp1]-P[TID]); vec3 h = N[TID] + N[TIDp1] - v*(P[TIDp1]-P[TID]); mid_normal[TID] = normalize(h); }
  43. 43. CS 354 43 PN Triangle 1. Control Shader 1. Compute window-space edge distances  Thread parallel  Scaled edge length = exterior (edge) LOD 2.  Maximum scaled edge length = interior LOD 2. Compute Bezier triangle edge control points 3.  Thread parallel 3. Compute Bezier triangle central control point 4. 4. Pass through eye-space position & normal  Thread parallel 5. Compute quadratic normal edge control points 5.  Thread parallel
  44. 44. CS 354 44 Adaptive PN Triangle Tessellation Evaluation Shader (1 of 3)#version 400 compatibilitylayout(triangles) in;layout(ccw) in; // 10 input control points forlayout(fractional_even_spacing) in; // Bezier triangle position// Assumes matrix in gluPerspective form in precise vec3// Intended to be cheaper than full 4x4 eye_space_pos2[];// transform by projection matrix in precise vec3 ccw_cp[];// Compiles to just 5 MAD ops in precise vec3 cw_cp[];precise vec4 applyPerspective( patch in precise vec3 b111; precise mat4 affine_matrix, precise vec4 v) // 6 input control points for{ precise vec4 r; // quadratic normal interpolation r[0] = affine_matrix[0][0] * v[0]; in precise vec3 r[1] = affine_matrix[1][1] * v[1]; eye_space_normal[]; r[2] = affine_matrix[2][2] * v[2] + in vec3 mid_normal[]; affine_matrix[3][2]*v[3]; r[3] = -v[2]; return r;}
  45. 45. Adaptive PN Triangle TessellationCS 354 45 Evaluation Shader (2 of 3)void main(void){ // Evaluate position by weighting triangle Weight the position control points with // vertex positions with the generated // (cubic) Bezier triangle basis // vertexs precise vec4 www = w*w*w * vec4(b300,1), // barycentric weights. uuu = u*u*u * vec4(b030,1), vec3 barycentric_weights = gl_TessCoord; vvv = v*v*v * vec4(b003,1), precise float u = barycentric_weights.x, wwu3 = 3*w*w*u * vec4(b210,1), v = barycentric_weights.y, wuu3 = 3*w*u*u * vec4(b120,1), w = barycentric_weights.z; wwv3 = 3*w*w*v * vec4(b201,1), // w should be 1-u-v uuv3 = 3*u*u*v * vec4(b021,1), vec3 triangle_vertex[3]; wvv3 = 3*w*v*v * vec4(b102,1), for (int i = 0; i < 3; i++) { uvv3 = 3*u*v*v * vec4(b012,1), triangle_vertex[i] = eye_space_pos2[i]; wuv6 = 6*w*u*v * vec4(b111,1), } wuE = wwu3 + wuu3, // 10 position control points of a Bezier uvE = uvv3 + uuv3, triangle wvE = wwv3 + wvv3, precise vec3 b300 = eye_space_pos2[0], E = wuE + uvE + wvE, b030 = eye_space_pos2[1], C = www + uuu + vvv, b003 = eye_space_pos2[2], p = C + E, b210 = ccw_cp[0], clip_space_p = b201 = cw_cp[0], applyPerspective(gl_ProjectionMatrix, p); b021 = ccw_cp[1], gl_Position = clip_space_p; b120 = cw_cp[1], b102 = ccw_cp[2], b012 = cw_cp[2];
  46. 46. CS 354 46 Adaptive PN Triangle Tessellation Evaluation Shader (3 of 3) // Weight the normal control points with a quadratic basis vec3 n200 = eye_space_normal[0], n020 = eye_space_normal[1], n002 = eye_space_normal[2], n110 = mid_normal[0], n011 = mid_normal[1], n101 = mid_normal[2], normal = n200*w*w + n020*u*u + n002*v*v + n110*w*u + n011*u*v + n101*w*v; // Visualize barycentric weights as color. vec4 color = vec4(barycentric_weights, 1.0); gl_FrontColor = color; // Output the normalized surface normal gl_TexCoord[0] = vec4(normalize(normal),1); // Output the (perspective-divided) eye-space view vector gl_TexCoord[1] = vec4(p.xyz/p.w, 1); }
  47. 47. CS 354 47 PN Triangle Evaluation Shader 1. Bezier triangle position evaluation • Cubic evaluation using 10 position control points • ~80 Multiply-Add operations 2. Apply perspective transformation • Multiply position by spare frustum matrix • 5 Multiply-Add operations 3. Bezier triangle normal evaluation • Quadratic evaluation using 6 normal control points • 3×12 Multiply-Add operations 4. Output vectors • Barycentric coordinates encoded as color • Normalized surface normal and eye direction vectors
  48. 48. CS 354 48 Careful About Cracks at Patch Seams artificially injected cracks  Patch seams need to be computed very carefully  Otherwise you get cracks  Animation makes cracks obvious!  Be sure of the following  Your LOD parameters at the seam of two patches are computed bit-for-bit identical  The control points that influence the evaluation along a patch edge are bit-for-bit identical and use symmetric evaluation  Influence means has “non-zero weight”  A+B+C ≠ C+B+A in floating-point  precise keyword can help this
  49. 49. CS 354 49 Other Surface Representations  Polynomial functions  As seen  Subdivision schemes  Refine mesh, smooth mesh, repeat  Implicit surfaces  Also known as iso-surfaces  F(x,y,z) = 0
  50. 50. CS 354 50 Subdivision Schemes  Many schemes  Catmull-Clark  Basic idea
  51. 51. CS 354 51 Catmull-Clark Example  Works on any closed base mesh
  52. 52. CS 354 52 Meta-balls: Implicit Surfaces  Iso-surface of union of multiple implicit functions
  53. 53. CS 354 53 Non-photorealistic Graphics  Motivation  Realism can obscure when you want to elucidate or convey a mood medical illustration three takes on a house
  54. 54. CS 354 54 Imitate Artistic Effect
  55. 55. CS 354 55 Simulation a Brush  How does a brush behave when painting?  Geometry of the brush  Physics of the brush
  56. 56. CS 354 56 Brush Stroke Examples
  57. 57. CS 354 57 Detecting Artistic Features  Silhouette  Contour lines  Highlights  Ridge and valley lines
  58. 58. CS 354 58 Finding Silhouette Edges  Silhouette = edge shared by both a front- and back-facing surface w.r.t. the viewer Recall: shadow volumes can be extruded from silhouettes edges
  59. 59. CS 354 59 Artistic Texturing  Collect or arrange marks in a specific arrangement half-toning
  60. 60. CS 354 60 Toon Shading  Quantized shading results  Short for cartoon shading  Instead of continuous fall off
  61. 61. CS 354 61 Next Class  Next lecture  Review for Final  In-class course evaluation  Reading  Chapter 10, 524-555  Finish Project 4  Simple ray tracer  Due Wednesday, now Thursday May 3, 2012

×