1. Illumination & Reflectance Dr. Amy Zhang

2. Outline 2  Illumination and Reflectance  The Phong Reflectance Model  Shading in OpenGL

3. Two Components of Illumination  Light sources with:  Emittance spectrum (color)  Geometry (position and direction)  Directional attenuation (falloff)  Surface properties with:  Reflectance spectrum (color)  Geometry (position, orientation, and micro-structure)  Absorption 3

4. Computer Graphics Jargon 4  Illumination: the transport of energy from light sources between points via direct and indirect paths  Lighting: the process of computing the light intensity reflected from a specific 3 ‐ D point  Shading: the process of assigning a color to a pixel based on the illumination in the scene

5. Direct and Global Illumination 5  Direct illumination: A surface point receives light directly from all light sources in the scene  Computed by the local illumination model  Determine which light sources are visible  Global illumination: A surface point receives light after the light rays interact with other objects in the scene I = I direct + I reflected + Itransmitted

6. Directional Light Sources 6  All of the rays from a directional light source have a common direction (parallel)  The direction is a constant at every point in the scene  It is as if the light source was infinitely far away from the surface that it is illuminating

7. Point Light Sources 7  The rays emitted from a point light radially diverge from the source  Direction to the light changes at each point

8. Other Light Sources 8  Spotlights  Area light sources  Light source occupies a 2D area (polygon)  Generates soft shadows.

9. Linearity of Light 9 = +  + Paul Haeberli, Grafica Obscura

10. 10

11. Outline 11  Illumination and Reflectance  The Phong Reflectance Model  Shading in OpenGL

12. OpenGL Reflectance Model  A simple model that can be computed rapidly  Has three components  Diffuse  Specular  Ambient  Uses four vectors  To source  To viewer  Normal  Perfect reflector

13. Ideal Diffuse Reflectance 13  Surface reflects light equally in all directions  Why? Examples?

14. Lambert’s Cosine Law 14  Diffuse reflectance scales with cosine of angle

15. Ideal Diffuse Reflectance 15  Lambertian reflection model  I L : The incoming light intensity  k d : The diffuse reflection coefficient  N: Surface normal  cos  i = N · L if vectors normalized  There are also three coefficients, k dr, k dg, k db that show how much of each color component is reflected

16. Ideal Specular Reflectance 16  Normal is determined by local orientation  Angle of incidence = angle of reflection  The three vectors must be coplanar  Ideal Specular Reflectance  Surface reflects light only at mirror angle

17. Reflection Vector R 17  The vector R can be computed from the incident ray direction L and the surface normal N  Note that all vectors have unit length

18. 18  How much light is seen? Depends on:  Angle of incident light  Angle to the viewer  k s is the absorption coef

19. Non-ideal Reflectors 19  Real materials tend to deviate significantly from ideal mirror reflectors  Introduce an empirical model that is consistent with our experience  The amount of reflected light is greatest in the direction of the perfect mirror reflection  The reflected light forms a “beam” pattern around this mirror direction

20. Phong Specular Reflection 20  Phong proposed using a term that dropped off as the angle between the viewer and the ideal reflection increased. n is the shininess coefficient  The cosine lobe gets more narrow with increasing n.  Values of  between 100 and 200 correspond to metals  Values between 5 and 10 give surface that look like plastic

21. Blinn & Torrance Variation 21  The specular term in the Phong model is problematic because it requires the calculation of R and V for each vertex  Blinn suggested an more efficient approximation using the halfway vector halfway vector H between L and V  H is the normal to the (imaginary) surface that maximally reflects light in the V direction

22. 22  No need to compute reflection vector R at every point  Is is a function only of N, if:  the viewer is very far away and V does not change for all points on the object (e.g., orthographic projection)  L does not change for all points on the object (e.g., directional lights)  Resulting model is known as the modified Phong or Blinn lighting model  Specified in OpenGL standard

23. Ambient Light  Ambient light is the result of multiple interactions between (large) light sources and the objects in the environment  It represents the reflection of all indirect illumination  Amount and color depend on both the color of the light(s) and the material properties of the object  Add k a I a to diffuse and specular terms reflection coef intensity of ambient light

24.  Distance Terms  The light from a point source that reaches a surface is inversely proportional to the square of the distance between them  We can add a factor of the form 1/(a + bd +cd 2 ) to the diffuse and specular terms  The constant and linear terms soften the effect of the point source

25. The Phong Illumination Model 25  Sum of three components: diffuse reflection + specular reflection + ambient  Ambient represents the reflection of all indirect illumination

26. 26

27. 27  Each light source has separate diffuse, specular, and ambient terms to allow for maximum flexibility even though this form does not have a physical justification  Separate red, green and blue components. Hence, 9 coefficients for each point source  I dr, I dg, I db, I sr, I sg, I sb, I ar, I ag, I ab  Material properties match light source properties  Nine absorption coefficients  k dr, k dg, k db, k sr, k sg, k sb, k ar, k ag, k ab  Shininess coefficient 

28. Phong Reflectance Model 28

29. Phong Examples 29  The direction of the light source and the n are varied

30. The Plastic Look 30  The Phong illumination model is an approximation of a surface with a specular and a diffuse layer  E.g., shiny plastic, varnished wood, gloss paint

31. Phong Reflectance Model 31  Single light source:

32. Phong Reflectance Model 32  Multiple light sources:

33. Computation of Vectors  L and V are specified by the application  Can compute R from L and N  Problem is determining N  OpenGL leaves determination of normal to application  Exception for GLU quadrics and Bezier surfaces

34. Plane Normals  Equation of plane: ax+by+cz+d = 0  we know that plane is determined by three points p 0, p 1, p 2 or normal n and p 0  Normal can be obtained by n = ( p 1 - p 0 ) × ( p 2 - p 0 ) p0p0 p2p2 p1p1

35. Normal to Sphere  Surface implicit function f(x, y, z) = 0  Normal given by gradient vector  Unit sphere f(p)=p·p-1  n = [ ∂ f/ ∂ x, ∂ f /∂ y, ∂ f/ ∂ z] T =p

36. Parametric Form  For unit sphere  Tangent plane determined by vectors  Normal given by cross product x=x(u,v)=cos u cos v y=y(u,v)=cos u sin v z= z(u,v)=sin u ∂p/∂u = [∂x/∂u, ∂y/∂u, ∂z/∂u]T ∂p/∂v = [∂x/∂v, ∂y/∂v, ∂z/∂v]T n = ∂p/∂u × ∂p/∂v

37. General Case  We can compute parametric normals for other simple cases  Quadrics  Parametric polynomial surfaces  Bezier surface patches

38. Outline 38  Illumination and Reflectance  The Phong Reflectance Model  Shading in OpenGL

39. Objectives  Introduce the OpenGL shading functions  Discuss polygonal shading  Flat  Smooth  Gouraud

40. Steps in OpenGL shading 1. Specify normals 2. Enable shading and select model 3. Specify lights 4. Specify material properties

41. Normals  In OpenGL the normal vector is part of the state  Set by glNormal*()  glNormal3f(x, y, z);  glNormal3fv(p);  Usually we want to set the normal to have unit length so cosine calculations are correct  Length can be affected by transformations  Note that scaling does not preserved length  glEnable(GL_NORMALIZE) allows for autonormalization at a performance penalty

42. Normal for Triangle p1p1 p0p0 p2p2 n plane n ·(p - p 0 ) = 0 n = (p 2 - p 0 ) ×(p 1 - p 0 ) normalize n  n/ |n| p Note that right-hand rule determines outward face

43. Enabling Shading  Shading calculations are enabled by  glEnable(GL_LIGHTING)  Once lighting is enabled, glColor() ignored  Must enable each light source individually  glEnable(GL_LIGHTi) i=0,1….. At least 8 light sources  Can choose light model parameters  glLightModeli(parameter, GL_TRUE)  GL_LIGHT_MODEL_LOCAL_VIEWER do not use simplifying distant viewer assumption in calculation  GL_LIGHT_MODEL_TWO_SIDED shades both sides of polygons independently  Time consuming

44. Defining a Point Light Source  For each light source, we can set an RGBA for the diffuse, specular, and ambient components, and for the position GL float diffuse0[]={1.0, 0.0, 0.0, 1.0}; GL float ambient0[]={1.0, 0.0, 0.0, 1.0}; GL float specular0[]={1.0, 0.0, 0.0, 1.0}; Glfloat light0_pos[]={1.0, 2.0, 3,0, 1.0}; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightv(GL_LIGHT0, GL_POSITION, light0_pos); glLightv(GL_LIGHT0, GL_AMBIENT, ambient0); glLightv(GL_LIGHT0, GL_DIFFUSE, diffuse0); glLightv(GL_LIGHT0, GL_SPECULAR, specular0);

45. Distance and Direction  The source colors are specified in RGBA  The position is given in homogeneous coordinates  If w =1.0, a finite location  If w =0.0, a parallel source with the given direction vector  The coefficients in the distance terms (1/(a+bd+cd 2 ))  by default a=1.0 ( GL_CONSTANT_ATTENUATION ),  b=c=0.0 ( GL_LINEAR_ATTENUATION, GL_QUADRATIC_ATTENUATION ). Change by a= 0.80; glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, a);

46. Spotlights  Use glLightv to set  Direction GL_SPOT_DIRECTION  Cutoff GL_SPOT_CUTOFF  Attenuation GL_SPOT_EXPONENT  Proportional to cos     

47. Global Ambient Light  Ambient light depends on color of light sources  A red light in a white room will cause a red ambient term that disappears when the light is turned off  OpenGL also allows a global ambient term that is often helpful for testing  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient)

48. Moving Light Sources  Light sources are geometric objects whose positions or directions are affected by the model-view matrix  Depending on where we place the position (direction) setting function, we can  Move the light source(s) with the object(s)  Fix the object(s) and move the light source(s)  Fix the light source(s) and move the object(s)  Move the light source(s) and object(s) independently

49. Material Properties  Material properties are also part of the OpenGL state and match the terms in the modified Phong model  Set by glMaterialv() GLfloat ambient[] = {0.2, 0.2, 0.2, 1.0}; GLfloat diffuse[] = {1.0, 0.8, 0.0, 1.0}; GLfloat specular[] = {1.0, 1.0, 1.0, 1.0}; GLfloat shine = 100.0 glMaterialf(GL_FRONT, GL_AMBIENT, ambient); glMaterialf(GL_FRONT, GL_DIFFUSE, diffuse); glMaterialf(GL_FRONT, GL_SPECULAR, specular); glMaterialf(GL_FRONT, GL_SHININESS, shine);

50. Front and Back Faces  The default is shade only front faces which works correctly for convex objects  If we set two sided lighting, OpenGL will shade both sides of a surface  Each side can have its own properties which are set by using GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK in glMaterialf back faces not visibleback faces visible

51. Emissive Term  We can simulate a light source in OpenGL by giving a material an emissive component  This component is unaffected by any sources or transformations GLfloat emission[] = 0.0, 0.3, 0.3, 1.0); glMaterialf(GL_FRONT, GL_EMISSION, emission);

52. Transparency  Material properties are specified as RGBA values  The A value can be used to make the surface translucent  The default is that all surfaces are opaque regardless of A  Later we will enable blending and use this feature

53. Efficiency  Because material properties are part of the state, if we change materials for many surfaces, we can affect performance  We can make the code cleaner by defining a material structure and setting all materials during initialization  We can then select a material by a pointer typedef struct materialStruct { GLfloat ambient[4]; GLfloat diffuse[4]; GLfloat specular[4]; GLfloat shineness; } MaterialStruct;

54. Polygonal Shading  Shading calculations are done for each vertex  Vertex colors become vertex shades  By default, vertex shades are interpolated across the polygon  glShadeModel(GL_SMOOTH);  If we use glShadeModel(GL_FLAT); the color at the first vertex will determine the shade of the whole polygon

55. Polygon Normals  Polygons have a single normal  Shades at the vertices as computed by the Phong model can be almost same  Identical for a distant viewer (default) or if there is no specular component  Consider model of sphere  Want different normals at each vertex even though this concept is not quite correct mathematically

56. Smooth Shading  We can set a new normal at each vertex  Easy for sphere model  If centered at origin, n = p  Now smooth shading works  Note silhouette edge

57. Mesh Shading  The previous example is not general because we knew the normal at each vertex analytically  For polygonal models, Gouraud proposed we use the average of the normals around a mesh vertex n = (n 1 +n 2 +n 3 +n 4 )/ |n 1 +n 2 +n 3 +n 4 |

58. Gouraud and Phong Shading  Gouraud Shading  Find average normal at each vertex (vertex normals)  Apply modified Phong model at each vertex  Interpolate vertex shades across each polygon  Phong shading  Find vertex normals  Interpolate vertex normals across edges  Interpolate edge normals across polygon  Apply modified Phong model at each fragment

59. Comparison  If the polygon mesh approximates surfaces with a high curvatures, Phong shading may look smooth while Gouraud shading may show edges  Phong shading requires much more work than Gouraud shading  Until recently not available in real time systems  Now can be done using fragment shaders  Both need data structures to represent meshes so we can obtain vertex normals

60. The end 60  Questions and answers