Calculation of vectors needed for shading

• the Phong Reflection Model
  
  
  
  
• uses four vectors to calculate a color for a point p on a surface
  • n - normal to the surface at p
  • v - direction from p to the viewer (COP)
  • l - direction from p to the light source
  • r - direction a perfectly reflected ray from l would take if it hit p (depends on n)
    
    
    
    
• in general, all four vectors may be different at each point on the surface
  
  
• calculation of the normal vector
  • in OpenGL, the specification of normals to the surface is left to the programmer
  • the calculation will depend on what kind of surface, and how it is being represented
    • typically, a curved surface is being represented by a collection of flat, convex polygons that are defined by their vertices
    • the normals to a surface tesselated in this manner can be approximated by calculating the normal to each polygon
      
      
  • since we have the vertex information for a polygon, we can use a cross product to calculate the normal
    
    

    u = p1 - p0 v = p2 - p0 n = u x v = (p1 - p0) x (p2 - p0)

    
    
  • the order of the vectors in this cross product determines whether the normal points towards the inside of the surface or the outside
    • assuming the right hand rule, the cross product given here will produce the normal to the outside
      
      
      
      
  • if you have an equation for the surface, you may be able to get a more precise normal even though the surface is tesselated
    • for example, if the surface is a sphere, the normal is just the vector from the center of the sphere to the point on the surface
      
      
  • after calculating a normal, we normalize it before passing it to OpenGL
    • a normal is specified before the vertex to which it applies
    • the normal becomes part of the state of OpenGL
    • that normal will apply to all subsequently defined vertices until a new normal is defined
      
      
      
      
  • take note of the difference between specifying a normal per vertex or a normal per polygon
    • the former will produce more accurate shading across the polygon
    • the latter will result in less accurate shading across the polygon
      
      
• calculation of the view and light vectors
  • the graphics system calculates v and l based on the position of the viewer and the position of the light
  • view vector
    • since we are in the camera coordinate system at this point, the viewer is at (0,0,0)
  • light vector
    • the position of the light is specified by a call to glLight*( )
      • the current transformation matrix is applied to the light position
    • there may be more than one light, thus more than one l
      • the shading calculation is done for each light and the contributions are summed
        
        
• calculation of the reflection vector
  • specular reflections require the calculation of r
• the angle of incidence is equal to the angle of reflection in a perfect mirror
  
  
  
  
• l, n, and r are required to be coplanar
• r depends on n and l - so r must be recalculated at every point on the surface
  
  
  
  
• calculation of the halfway vector
• an approximation that reduces the amount of computation required for specular reflections utilizes the halfway vector h
  
• h is the vector halfway between the l and v vectors
  
  
  
• since h does not depend on n, it does not change as we move to a new point on the surface as r does
  
  

  is replaced with

  
  
• the halfway angle will be smaller than phi, making the specular highlights smaller than they would otherwise be
  • errors due to the use of this approximation can be mitigated by modifying the shininess exponent
    
    
• OpenGL uses this approximation for specular reflection
  
  
• transparency vectors
  • calculation of these vectors is not required since OpenGL does not model transparency this way
  • transparency is approximated by way of the alpha channel and compositing
    
    
• example - sphere.c
  
  
  
  
• example - lighting demo from CodeSampler.com

Shading Polygons

• the shading computations based on the Phong Reflection Model are very expensive
• however, lighting is essential for portraying objects in 3D
  • on the left, a sphere with lighting - on the right, a sphere without lighting (from the Redbook)
    
    
    
    
  • here is another example, from SIGGRAPH.org
    
    
• we represent curved surfaces using a mesh of flat polygons (if you use triangles they are guaranteed to be flat)
  • we can use this underlying representation of a surface to reduce the computations required for shading
  • there is always a tradeoff of realism for efficiency
  • we examine several approaches in increasing order of quality and expense
    
    
    
    
• flat shading
  
  
  • in general, n, l, and v vary as we move from point to point on a surface
    
    
  • for a flat polygon, n is constant over the surface of the polygon
  • if we assume the viewer and the light source are distant, v and l are also constant
    
    
    
    
  • so we perform the shading computation once for each polygon
  • and shade all points on the surface of the polygon using the calculated color
  • in OpenGL we specify flat shading using:
    
    

    glShadeModel(GL_FLAT);

    
    
• only one normal needs to be specified per polygon
  • for a single polygon, OpenGL uses the normal associated with the first vertex of the polygon
  • other primitive types have similar rules
    
    
• example of a flat shaded surface - you can see that each polygon is a single color
  
  
  
  
• another example
  
  
  
  
• and yet another example, from SIGGRAPH.org
  
  
• flat shading is fast, but the tessellation of the object is extremely apparent thereby reducing realism
• the human eye is especially adept at detecting differences in light intensity leading to Mach banding effects
  
  
  
• interpolative shading
  
  
  • OpenGL can interpolate surface colors across the interior of a polygon surface
    • we have seen smooth shading in the rotating cube example where each vertex is assigned a color and each face transitions smoothly between vertex colors
      
      
  • we direct OpenGL to do this by setting smooth shading
    
    

    glShadeModel(GL_SMOOTH);

    
    
• if we have lighting defined, and we specify a normal for each vertex, OpenGL can perform the shading calculation at each vertex
  • this produces a color for each vertex, which can then be interpolated to find the interior colors
  • the quality of the results will depend on how we define the normals at the vertices
  • discontinuities in the normal at an edge or vertex create discontinuities in shading between polygons
    
    
• example of smooth shading
  
  
  
  
  
• Gouraud shading
  
  
  • Gouraud shading is interpolative shading with the normals defined a certain way
    
    
  • we assign a normal to each vertex that is the normalized average of the normals of the adjacent polygons
    
    
    
• of course we must have a data structure that allows us to calculate these normals
  
  
  
  
• again, OpenGL performs the shading calculation at each vertex
  • then interpolatse the vertex colors to obtain the color of an interior point in a polygon
  • this approach can still generate discontinuities in shading along shared edges of polygons
  • it also does not perform well for specular highlights
    
    
• example, from SIGGRAPH.org
  
  
• Phong shading
  
  
  • we assign a normal to each vertex that is the normalized average of the normals of the adjacent polygons - just as for Gouraud shading
    
  • then we approximate the normal at each point on the surface of the polygon by interpolating the vertex normals
    
    
  • for example, we interpolate the normals at two vertices to get the normal at various positions along the edge joining the two vertices
    
    
    
• we then use bilinear interpolation to determine the normal at points in the interior of the polygon
  
  
• we then perform the shading computation at every point on the surface of the polygon, using the interpolated normal
  
  
• example, from SIGGRAPH.org
  
  
• OpenGL does not support Phong shading
  
  
• Very high quality rendering is done off line!

Notes and figures from:

• Interactive Computer Graphics: A Top-Down Approach Using OpenGL®, Fourth Edition, by Edward Angel, Addison-Wesley, 2005