Upcoming SlideShare
×

# CG OpenGL surface detection+illumination+rendering models-course 9

3,888 views

Published on

Computer Graphics
OpenGL - Visible-surface detection Methods + Illumination Models & surface-rendering models

Published in: Design, Technology, Art & Photos
4 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

Views
Total views
3,888
On SlideShare
0
From Embeds
0
Number of Embeds
237
Actions
Shares
0
137
0
Likes
4
Embeds 0
No embeds

No notes for slide

### CG OpenGL surface detection+illumination+rendering models-course 9

1. 1. Visible-surface detection Methods + Illumination Models & surface- rendering models Chen Jing-Fung (2006/12/8) Assistant Research Fellow, Digital Media Center, National Taiwan Normal UniversityCh9: Computer Graphics with OpenGL 3th, Hearn BakerCh11-6: Computer Graphics with OpenGL 3th, Hearn BakerCh10: Computer Graphics with OpenGL 3th, Hearn Baker
2. 2. Visible-surface• Visible-surface detection – Polygon’s vertices & plane have some relationship – Back-face detection – Back-face removals – Concave Polygons – Depth-Buffer method
3. 3. Visible-surface detection• How to describe the surface? – Object-space • Compare objects or parts of objects in the scene – We should label as visible – Advantage: effectively locate visible surfaces in the same case – Image-space • Visibility is decided each pixel position’s point (the closest to viewer) on the projection plane • Most interface is only image-space
4. 4. Object- & Image- space• The major differences is in the basic approaches about the various visible- surface detection algorithms – Sorting method • Based on facilitate depth (interval distance) which used to divide surfaces in a scene – Coherence method • Using the regularities in a scene
5. 5. Polygon’s vertices & plane plane: Ax  By  Cz  D  0• Using three points resolve a plane (x1,y1,z1) NPlaneany plane function: Ax  By  Cz  D  0 (x ,y ,z ) 2 2 2 (x3,y3,z3) – Each intercept between the plane and the axis • x-axis: A/D, y-axis: B/D, z-axis: C/D  (A / D)xk  (B / D)y k  (C / D)zk  1 k=1,2,3 ,Cramer’s rule: 1 y1 z1 x1 1 z1 x1 y1 1 A  1 y 2 z2 B  x2 1 z2 C  x2 y 2 1 1 y3 z3 x3 1 z3 x3 y3 1 x1 y1 z1 D   x2 y2 z2 x3 y3 z3
6. 6. Back-face detection (object-space)• Simplify the back-face test (right-hand) – N is a polygon surface’s normal vector – Vview is a viewing direction vector from our camera position plane: Ax  By  Cz  D  0 Our monitor: xv N=(A,B,C) zv Vview N=(A,B,C) yv Vview Back face: Vview．N > 0 If plane Vview // zv axis, C<0, we label any C=0, cannot see any polygon as a back face face
7. 7. Back-face removals• In general, back-face removal can eliminate about partly or completely of polygon surfaces – Convex surface: C 0 C=0, cannot see any face • All hidden surfaces C < 0, we label any polygon as a back face – C>0 C > 0, hidden surface C0 – Concave surface: • Like to combine two convex objects One face is be partially hidden by other faces of the object
8. 8. OpenGL and Concave Polygons • A tessellator object in the GLU library can tessellate a given polygon into flat convex polygons – Draw a simple polygon without holes • basic idea is to describe a contour mytess = gluNewTess(); //includegluTessProperty() gluTessBeginPolygon(mytess, NULL); //send them off to be rendered gluTessBeginContour(mytess);// draw contour (outside) for(i=0; i < n_vertices; i++) glTessVertex(mytess,vertex[i],vertex[i]); gluTessEndContour(); gluTessEndPolygon(mytess);
9. 9. • Tessellation algorithm in OpenGL is based on the winding rule to set the winding numbergluTessProperty(mytess,GLU_TESS_WINDING_RULE,*);GLU_TESS_WINDING_ODDGLU_TESS_WINDING_NONZEROGLU_TESS_WINDING_POSITIVEGLU_TESS_WINDING_NEGATIVEGLU_TESS_WINDING_ABS_GEQ_TWOhttp://pheatt.emporia.edu
10. 10. Depth-Buffer method• A common image-space approach for detecting visible surfaces is depth- buffer method – One pixel position at a time appear to the surface – Also called to z-buffer method • Object depth is usually measured along z axis of a viewing system
11. 11. Depth buffer• Three surfaces and view plane overlap pixel position (x,y) on the view plane – The visible surface has the smallest depth value  P Py aP  b  pseudodepth ( x, y, z )   x , , z  P P P   z z z  View plane Depthvalue = 1.0 yv -> far (x,y) xv Depthvalue=0.0 -> near zv
12. 12. Possible data type to hold face data Class face{ int nVerts; //number of vertices in vertex-array Point *pt; //array of vertices in real screen coord’s float *depth; //array of vertex depths Plane plane; //data for the plane of the face Exface extent; //the extent of the face //other properties };Ch13: Computer Graphics 2th, F. S. Hill Jr.
13. 13. Depth-Buffer Algorithm• Initialize the depth buffer and frame buffer so that for all buffer positions (x,y) depthBuff (x,y) = 1.0, frameBuff (x,y) = backgndColor• Process each polygon in a scene, one at a time – For each projected (x,y) pixel position of a polygon, calculate the depth z (if not allready known) – If z < depthBuff(x,y), compute the surface color at that position and set depthBuff (x,y) = z, frameBuff (x,y) = surfColor(x,y)
14. 14. Basic flow of depth- buffer algorithm• pseudocode for (each face F) for (each pixel (x,y) covering the face){ depth = depth of F at (x,y); if (depth < d[x][y]) { //F is closest so far c = color of F at (x,y) //set the pixel color at (x,y) to c d[x][y] = depth; //updata the depth buffer } }
15. 15. A-Buffer Method• Extension of above depth-buffer ideas is A-Buffer procedure – Combined with antialiasing, area-averaging and visiblity-detection method – Developed at Lucasfilm Studios to include in the surface-rendering system called REYES (Renders Everything You Ever Saw) – The buffer region is referred to as the accumulation buffer • Store a variety of surface data and depth values
16. 16. Two fields in A-buffer method• Each position in the A-buffer has two fields: – Depth field • Stores a real-number value (+,- or 0) – Surface data field • Stores surface data or a pointer
17. 17. Two buffer representations about A-buffer • A single surface overlaps the pixel, the surface depth, color and other information RGB and – Buffer list depth≧0 other info • More than one surface overlaps the pixel, a linked list of surface data (also can list the priority) Surf1 Surf2 depth<0 info info …
18. 18. A-buffer• Summary the surface information in A- buffer – RGB intensity components – Opacity parameter (percent of transparency) – Depth – Percent of area coverage – Surface identifier – Other surface-rendering parameters
19. 19. Design a pick-buffer program in OpenGL• Interactive to select objects – Pointing screen positions (ps. We cann’t use OpenGL to directly pick at any position) • Design pick window to form a revised view volume • Assign integer ID to point a object • Intersect those objects and the revised view volume which are stored in a pick- buffer array
20. 20. Picking a screen’s procedure• Create and display a scene• Pick a screen position and the mouse callback function – Set up a pick buffer – Activate the picking operations (selection mode) – Initialize an ID name stack for object ID – Save the current viewing and geometric- transformation matrix – Specify a pick window for the mouse input
21. 21. – Assign identifiers to objects and reprocess the screen using revised view volumne. (pick information is stored in pick buffer)– Restore the original viewing and geometric- transformation matrix– Determine the number of objects that have been picked and return to the normal rendering mode– Process the pick information
22. 22. • Pick-buffer glSelectBuffer (pickBuffSize, pickBuffer); – This buffer array store the integer information for each object – Several records of information store in pick buffer • Depending on the size and location of the pick window
23. 23. Each record in pick- buffer’s information• The stack position of the object which is the number of identifiers in the name stack up to and including the position of the picked object• Min depth of the picked object• Max depth of the same object• The list of the identifies in the name stack from the first (bottom) identifier to the identifier for the picked object Range = 0.0~1.0 multiplied by 232-1
24. 24. • The OpenGL picking operations are activated with glRenderMode (GL_SELECT); – Means a scene is processed through the viewing pipeline (not stored in frame buffer) – A record each object have been displayed in normal rendering mode is placed in pick-buffer • This command returns the number of picked object (record in the pick-buffer)
25. 25. After mouse hit• To return to the normal rendering mode (the default) glRenderMode (GL_RENDER);• third option (GL_FEEDBACK) – Store object coordinates without displaying
26. 26. Buffer depth test demo
27. 27. OpenGL visibility- detection function• Back-face removal glEnable (GL_CULL_FACE); glCullFace (mode); glDisable(GL_CULL_FACE); – Where mode can be changed • GL_FRONT: remove the back faces – The viewing position is inside a building • GL_BACK: remove the front faces – The viewing position moves outside the building • GL_FRONT_AND_BACK :remove both front and back faces – Eliminate all polygon surfaces in a scene – Another front-facing view function • glFrontFace()
28. 28. OpenGL Depth-Buffer Functions• Using the OpenGL depth-buffer visibility-detection routines – First, modify the GLUT initialization function (still frame) glutInitDisplayMode ( GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH ); – Depth buffer values can be initialized glClear (GL_DEPTH_BUFFER_BIT); • Refresh buffer of the background color
29. 29. • The OpenGL depth-buffer visibility- detection routines are activated glEnable (GL_DEPTH_TEST); glPolygonMode (GL_FRONT_AND_BACK,GL_LINE); glColor3f (0.0,0.0,0.0); v1 //--object’s description-- glBegin(GL_POLYGON); glVertex3fv (v1); glEdgeFlag (GL_FALSE); glVertex3fv (v2); v2 v3 glEdgeFlag (GL_TRUE); glVertex3fv (v3); glEnd();
30. 30. • The depth-buffer visibility testing use other initial value for the max-depth glClearDepth (maxDepth); glClear(GL_DEPTH_BUFFER_BIT); – The depth buffer is initialized with the default value 1.0 (maximum depth-buffer in OpenGL) – This function can be used to speed up the depth-buffer routines • That is like many distant objects behind the foreground objects minimum depth-buffer in OpenGL = 0.0
31. 31. Projection application• Projection coordinates in OpenGL – normalize the range -1.0~1.0 – The depth values between near and far are normalized to the range 0.0~1.0 • Default: Near: 0.0; far:1.0 glDepthRange (nearnormdepth, farnormdepth) – Any value can be set including nearnormdepth>farnormdepth
32. 32. Other option aboutdepth-buffer in OpenGL glDepthFunc (testCondition); – Parameter testCondition can be assigned 8 symbolic constants • GL_LESS (default), GL_GREATER, GL_EQUAL, GL_NOTEQUAL, GL_LEQUAL, GL_GEQUAL, GL_NEVER (no point), GL_ALWAYS (all points). – They are used to compare each incoming pixel z value with present z value in the depth-buffer – GL_LESS: the depth-value is less than current value in the depth-buffer
33. 33. Set the depth-buffer state• Set the state of the depth-buffer to read-only or read-write glDepthMask (writeState); – writeState = GL_TRUE (default): read- write – writeState = GL_FALSE: only can retrieve values
34. 34. The advantage of the setting state• The feature is useful in complicated background v.s. different foreground objects can be displayed – Disable the background write mode and process foreground • Allow to generate a series of frames with different foreground objects • Or one object in different positions for an animation sequence. • Therefore, only depth values for the background are saved
35. 35. OpenGL Depth-Cueing Function• Varity brightness of an object is like object’s distance function from the viewing position Depth-cueing method dmax  d glEnable (GL_FOG); fdepth (d )  dmax  dmin glFogi (GL_FOG_MODE, GL_LINEAR); • Can set different values for dmax and dmin glFogf (GL_FOG_START, minDepth); glFogf (GL_FOG_END, maxDepth); Default: dmax=1.0, dmin=0.0
36. 36. Approaches to infinity• There are many complex pictures which could be compose to the simple component – Tesselations could based on a single regular polygon • Only a triangle, square and hexagon tile the plane
37. 37. Drawing simple tesselations• Consider how to draw in an application the 3-gon tillings – The 3-gon version • Row : draw those side-by-side equilateral triangles which are all the same orientation • Other row must be offset horizontally by ½ the base of the triangle (each line is drawn only once) • Clipping can be used to chop off the tilings at the borders of the desired window
38. 38. Drawing simple tesselations• Code fragment for i=1~ rowsnum for j=1 ~ colsnum if i=Odd offset+=shift else offset = 0 Triangle (j*colWidth+offset, i*rowWidth, 1);
39. 39. Illumination Models & surface-rendering modelsCh10: Computer Graphics with OpenGL 3th, Hearn Baker
40. 40. outline• Basic illumination models• Polygon rendering methods• OpenGL lights 40
41. 41. Basic illumination models• Ambient light• Diffuse reflection• Specular reflection• Combine diffuse & specular reflection• Light refraction 41
42. 42. Ambient light• Ambient light set a general brightness level in a scene – object combine all background lighting ~ the global diffuse reflections• Assuming that only monochromatic lighting – Intensity parameter Ia – Ambient light’s reflections • a simply form of diffuse reflection • Independent of viewing direction & spatial orientation of a surface 42
43. 43. Diffuse reflection (1)• Diffuse reflection model – Assume the incident light is scattered with equal intensity in all directions (ideal diffuse reflectors) • the reflected radiant light energy is calculated with Lambert’s cosine law radiant energy per unit time Intensity  projected area cos N ~  constant dA cos N 43
44. 44. Diffuse reflection (2)• Radiant energy from a surface area element dA in direction ψN relative to the surface normal direction is proportional to cos ψN – a monochromatic light source, kd:0.0~1.0 N ψN Incident light Highly reflective surface kd=1.0 ψN dA Radiant-energy direction Absorbs the incident light kd=0.0 44
45. 45. Lighting & reflection (1)• Background lighting effects – Every surface is fully illuminated by the ambient light Ia – Ambient lighting contribution to the diffuse reflection at any point – Produces a abnormally flat shading Iambdiff=kdIa kd:0.0~1.0 abnormally flat shading … 45
46. 46. Lighting & reflection (2)• Modeling the amount of incident light (Il,incident) on a surface (A) from a light source with intensity (Il) Il,incident=Il cosθ• The diffuse reflections N θ A Incident light θ A cosθ Il,diff=kdIl,incident=kdIl cosθ Incoming light ⊥ the surface => θ= 0°, Il,diffuse=kdIl cosθ≦0.0, light source is behind the surface 46
47. 47.  kd Il (N  L), if N  L  0Il ,diff   0.0, if N  L  0 N L θ Psource  Psurf To light cosθ=N．L L source Psource  Psurf • Diffuse reflections from a spherical surface • Point light source color = white • Diffuse reflectivity coefficient : 0 <= kd <= 1 47
48. 48. kaIa  kd Il (N  L), if N  L  0 Idiff   k a Ia , if N  L  0• Combine the ambient & point- source intensity calculations the total diffuse reflection – Ambient- reflection coefficient ka 48
50. 50. • The specular reflection direction for a position on an illuminated surface N R L θ θ φ V N: normal surface vector R: ideal specular reflection Rs L: the direction toward the point light source V: point to viewer An ideal reflector (perfect mirror) Il,incident = Rs & we would see reflected light when V and R coincide 50
51. 51. Specular-refection function• The variation of specular intensity with angle of incidence is described by Fresnel’s laws of reflection N L θ θR Il ,spec  W ( )Il cos  ns φ V – Spectral-reflection function W(θ) – The intensity of the light source Il – φ: between the viewing angle (V) and R 51
52. 52. cos  ns 52
53. 53. Specular-reflection coefficient • Approximate variation of the specular-reflection coefficient for different materials, as a function of the angle of incidence – W(θ): 0.0~1.0 – In general, W(θ) tends to increase (θ=0°->90°°) – θ=90°, W(θ)=1 • All of the incidence is reflected Ex: glass, -θ=0°->4% of the incident light on a glass surface -and most of the rangeθ-> < 10% 53
54. 54. Simple specular- θreflection function (1) θ• Many opaque materials’ specular- reflection is nearly constant – Set ks=W(θ), ks:0.0~1.0 ksIl ( V  R )ns , if V  R  0 and N  L  0Il ,spec   0.0, if V  R  0 or N  L  0 – R? can be computed from L and N R + L = (2N．L) N => R = (2N．L) N - L 54
55. 55. Simple specular- reflection function (2) H• We replace V．R with N．H L Nα R φ V – Replace cosφ with cosα LV Halfway vector H LV – Advantage • For nonplanar surfaces, N．H requires less computation than V．R because R related with N – Viewer and light source is sufficiently far • V, L and H are all constant If α > 90°, N．H = negative and set Il,spec=0.0 55
56. 56. ksIl (N  H)ns , if N  H  0Il ,spec   0.0, if N  H  0 56
57. 57. Combined diffuse and specular reflection• A single point light source I  Idiff  Ispec  kaIa  kd Il (N  L)  ksIl (N  H)ns• Multiple light sources n I  Iambdiff   [Il ,diff  Il ,spec ] l 1 n  kaIa   Il [kd (N  Ll )  ks (N  Hl )ns ] l 1 57
58. 58. Wire-frame Ambient lightingDiffuse reflections from ambient Diffuse and specular reflections fromlighting + a single point source ambient lighting + a single point source 58
59. 59. Light refraction (1) 59
60. 60. Light refraction (2)• Snell’s law i sin r  sin i r – Different material have different refracted coefficience ηair~ 1 (ηmaterial) ηglass~ 1.61 60
61. 61. Polygon rendering methods• Flat surface rendering• Gouraud surface rendering• Phong surface rendering 61
62. 62. Flat surface rendering • Flat surface rendering is also called constant-intensity surface rendering – In general, flat surface rendering provides an accurate display • Polygon is one polyhedron’s face (flat face) • All light sources are sufficiently far, N．L = constant • The viewing position is also sufficiently far, V．R = constant glShadeModel(GL_FLAT) ksIl ( V  R )ns , if V  R  0 and N  L  0 Il ,spec   0.0, if V  R  0 or N  L  0 62
63. 63. N Gouraud surface rendering• Gouraud surface rendering is also called intensity-interpolation surface rendering – Linear interpolates vertex intensity – Each polygon section of a tessellated curved surface • Determine the average unit normal vector at each vertex of the polygon • Apply an illumination model to obtain the light intensity at that position • Linearly interpolate the vertex intensities over the projected area glShadeModel(GL_SMOOTH) N1  N2  N3  N4 N N1  N2  N3  N4 63
64. 64. Two surface rendering Using Flat surface Using Gouraudmesh rendering surface rendering glEnable(GL_COLOR_MATERIAL); //object’s color 64
65. 65. N’Phong surface rendering • Phong surface rendering is also called normal-vector interpolation rendering – Each polygon section of a tessellated curved surface • Determine the average unit normal vector at each vertex • Linearly interpolate the vertex normal over the projected area • Apply an illumination model at positions along scan lines to calculate pixel intensities N( )  (1  )N1  ( )N2 N (  )  (1   )N3  (  )N2 65
66. 66. OpenGL lights• OpenGL light-source function – light-source position – Light-source colors• OpenGL global lighting parameters• OpenGL surface-property function• OpenGL Spotlights 66
67. 67. OpenGL light-source function• Multiple point light sources can be included in OpenGL scene description which has various properties. glLight*(lightName, lightProperty, propertyValue); – Function name’s suffix code: i (int) or f (float) – v (vector): • propertyValue use v to represent a pointer to an array • lightName: GL_LIGHT0,…,GL_LIGHT7 • lightProperty: can be assigned one of ten symbolic property constants 67
68. 68. OpenGL light-source position // light1 is designated as a local source at (2.0,0.0,3.0) GLfloat light1PosType [ ] = {2.0, 0.0, 3.0, 1.0} //light2 is a distant source with light emission in –y axis GLfloat light2PosType [ ] = {0.0, 1.0, 0.0, 0.0} glLightfv(GL_LIGHT1, GL_POSITION, light1PosType); glEnable(GL_LIGHT1); // turn on light1 …. 68
69. 69. OpenGL Light-source colors• Light-source colors (R,G,B,A) – The symbolic color-property • GL_AMBIENT, GL_DIFFUSE and GL_SPECULAR GLfloat color1 [ ] = {0.0, 0.0, 0.0, 1.0}//black GLfloat color2 [ ] = {1.0, 1.0, 1.0, 1.0}//white glLightfv (GL_LIGHT3, GL_AMBIENT, color1); … 69
70. 70. Energylight = 1 dl Energylight = 1/dl2• Radial-intensity attenuation coefficients with dl as the distance from a light-source position – Three OpenGL property constants • GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION and GL_QUADRATIC_ATTENUATION • Each coefficients a0, a1, a2 <- which can be designated a0 glLightfv (GL_LIGHT6, GL_CONSTANT_ATTENUATION, 1.5); … 70
71. 71. OpenGL global lighting parameters• OpenGL lighting parameters can be specified at the global level glLightModel* (paramName, ParamValue); – Besides the ambient color for individual light sources, we can also set it to be background lighting as a global value • Ex: set background lighting to a low-intensity dark- blue color and an alpha value = 1.0 globalAmbient [ ] = {0.0, 0.0, 0.3, 1.0} glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbient); Default global Ambient color = (0.2,0.2,0.2,1.0) //dark gray 71
72. 72. OpenGL surface- property function• Reflection coefficients and other optical properties for surfaces glMaterial*(surFace, surfProperty, propertyValue); – Parameter surFace • GL_FRONT, GL_BACK or GL_FRONT_AND_BACK – Parameter surfProperty is a symbolic constant identifying a surface parameter • Isurf, ka, ks, or ns – Parameter propertyValue is set to the corresponding value with surfProperty • All properties are specified as vector values • Beside ns(the specular-reflection exponent) 72
73. 73. Ambient & diffuse realization • The ambient and diffuse coefficients should be assigned the same vector values – GL_AMBIENT_AND_DIFFUSE • To set the specular-reflection exponent – GL_SHININESS • The range of the value : 0 ~ 128 diffuseCoeff [ ] = {0.2, 0.4, 0.9, 1.0};//light-blue color specularCoeff [ ] = {1.0, 1.0, 1.0, 1.0};//white light glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, diffuseCoeff); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specularCoeff); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, 25.0); 73
74. 74. OpenGL Spotlights• Spotlights is directional light sources – Three OpenGL property constants for directional effects • GL_SPOT_DIRECTION, GL_SPOT_CUTOFF and GL_SPOT_EXPONENT – Ex: θl = 30°, cone axis= x-axis and the attenuation exponent = 2.5 GLfloat dirVector [ ] = {1.0, 0.0, 0.0}; To object Vobj glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, dirVector); vertex α glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 30.0); glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 2.5); cone axis Light source θl 74 demo