chapter 6 b

openGL supports directional, positional and spot lights (read on your own).

openGL allows you to specify a stationary light, a light that moves independently of objects in the scene, and one that moves with the observer.

• Stationary Light : any modifications to the ModelView matrix also affect the position of the light source. To keep the light stationary, set its position only after performing all model view transformations.
• Independent Light : apply model view transformations to the light position command. If you want these to be independent of the transformations applied to the object then isolate the transformations in a push/pop matrix block. Any transformations applied to the object also affect the light.
• Moves with the Viewpoint : set the light position before setting any viewing transformations. Since the initial viewpoint is at 0,0,0, the light position might be initialized equivalently. Application of viewing transformations will now move the light along with the observer at a distance of 0,0,0. Of course, specifying the light position at some distance from the viewpoint will keep this distance constant when applying viewing transformations.

We have discussed viewing transformations. The modelview matrix mode composes all transformations applied to objects (models) and the observers position (viewpoint). The viewpoint can be moved via the following openGL command :

void gluLookAt(GLdouble ex, GLdouble ey, GLdouble ez, GLdouble cx, GLdouble cy, GLdouble cz, GLdouble upx, GLdouble upy, GLdouble upz);

• The observers position is captured by ex,ey,ez
• the observers line of sight (a point in the scene) is defined by cx,cy,cz
• upx,upy,upz specify which direction is up. Typically upy = 1.0.

Lighting Model Selection : openGL allows the programmer to specify 4 components of the lighting model used in a scene.

• 1. Global Ambient Ilumination for the scene :

  GLfloat lmodel_ambient[] = {0.2,0.2,0.2,1.0}; //default value

  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);

• 2. Whether the viewer is local to the scene or considered to be at an infinite distance from the scene (default). When the viewpoint is local to the scene then specular highlight intensity depends on the vertex normal, light vector, and viewer vector. Defining a local viewpoint gives more realistic results but incurs the overhead of normal/vector determination.

  glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE);

• 3. Whether to use one-sided or two-sided lighting (for cut-away display of objects for example):

  glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

• 4. To separate specular color from ambient (for more realistic texture mapping lighting results - not supported in version 1.2 of openGL...checking on later versions).

Polygon Shading Models

Flat Shading

The simplest shading model is flat shading. In this model, polygonal boundaries can be seen and the object has a faceted appearance. The approach applies the illumination model once to compute a single color intensity that is then used to color the entire surface of a polygon.

This approach only makes sense if

• the light source is at infinity (N'L is constant across the face of the polygon)
• the observer is at infinity (N'V is constant)
• the polygon is not an approximation of a curved surface.

If either 1). or 2). is not true then constant shading can still be carried out by computing the normal, light and viewer vectors once. Typically the center of the polygon or the first vextex of the polygon is used for the vector determination.

Interpolated Shading

As an alternative to flat shading, an illumination model might carry out the illumination calculation for each pixel that intersects the surface of a polygon. For a large complex scene with many polygons such an algorithm would be prohibitively expensive.

Algorithms that approximate the above brute force illumination calculation use interpolated shading. Gouraud smooth shading is probably the best known and most general of the interpolated shading algorithms. Phong smooth shading is a more costly interpolated algorithm but one which produces better results. Both are discussed later.

Shading of polygon meshes that approximate a curved surface must address some interesting problems.

• Adjacent polygons within the mesh might exhibit very different orientations. Vector calculations for the lighting model will produce very different color intensities for neighboring polygons in this instance. The mesh will have a faceted appearance whether constant shading or interpolated shading is used.
• Increasing the number of polygons in the mesh will only accentuate the problem: known as the Mach band effect. The Mach band effect has to do with the way receptors in the eye react to light intensity changes. The easiest way to understand the Mach band effect is to look at the perceived intensity change where two walls of a room intersect. There appears to be a darker band (near the intersection) along the wall with a lower light intensity. This effect is only a perceived one and not an actual intensity change. Mach banding can make a fine grained polygon mesh look pretty awful.

Smooth shading of polygonal meshes attempts to address the faceting problem and the Mach band effect by using color information from adjacent polygons within the mesh. How this is done is discussed in the following sections.

Gouraud Smooth Shading

Gouraud shading is a color interpolation algorithm that eliminates most but not all Mach banding problems (still evident when a very rapid intensity change occurs).

What are the basics of color interpolation?

• Assume the polygon to be shaded is a triangle and that the three vertex normals are available.
• A selected illumination model can then be used to determine the color intensity for the three vertices: I1, I2, I3.
• The linear color interpolation occurs during scan line conversion and is a very efficient incremental algorithm.
• Assume that vertex1 with intensity I1 intersects scanline y1, vertex2 with I2 intersects scanline y2, and vertex3 with I3 intersects scanline y3.
• The algorithm must be able to determine the color intensity across all scanlines that intersect the triangle.
• Assume an arbitrary scanline ys, intersects the polygon.
• Let the intensity at the left intersection of the polygon and the scanline = Ia, and at the right edge = Ib. Ia and Ib are calculated as follows :

Ia = I1 - (I1-I2)*(y1-ys)/(y1-y2)

Ib = I1 - (I1-I3)*(y1-ys)/(y1-y3)

To find the intensity, Ip of a point along the edge defined by the left and right intersections of the scanline and the polygon use :

Ip = Ib - (Ib - Ia)*(xb-xp)/(xb-xa)

Gouraud shading requires that

• The normal at each vertex of the polygon is known. If the vertex normals are not directly available they may be calculated by averaging the surface normals of all polygons incident on the vertex.
• Apply an illumination model using the vertex normals to calculate a vertex color intensity.
• Apply linear color interpolation across all scanlines intersected by the polygon. The linear interpolation is made more efficient by using a difference equation (as in the scan conversion algorithm)=> an incremental change in y over intersecting scanlines, and an incremental change in x across the scanline.

Phong Smooth Shading

Phong's model also uses linear interpolation but here the normal vector is the interpolated value and not color intensities. The model requires that vertex normals are available or determined through averaging. The linear interpolation of normal vectors proceeds as in Gouraud shading and the interpolation is applied to the three components of the vector.

Previously we discussed the fact that illumination models must be applied in the world coordinate system because perspective transformation can modify the angles between N, L, V, and R, producing incorrect lighting results.

• In Gouraud's algorithm color intensity at a vertex is determined by applying the illumination calculation in world coordinate space and all proceeds correctly.
• In Phong's algorithm the color calculation is performed during rasterization (in screen coordinate space) which complicates matters significantly.
  • The normal at each pixel along the scanline must be normalized and mapped back into world coordinate space where the illumination model is then applied. This process is very costly and only makes sense if the rendered image is to faithfully capture realistic specular reflections.

What does the Phong model give you that Gouraud's does not? Refer to figure 16.21 of text.

a). If a highlight falls on a vertex : G's model will interpolate the highlighted vertex with the non-highlighted vertices. This does not produce a highlight but a lighter intensity that gradually darkens across the face of the polygon.

b). P's model accurately reproduces the vertex highlight.

c). If the highlight falls in the interior of the polygon : G's model interpolates only non-highlighted vertices so no highlight is produced.

d). P's model captures the interior highlight.

e). Mach banding : G's model alleviates many mach banding effects while P removes all effects.

Problems with Interpolated Shading

• The polygonal silhouette edges of the object are still visible.
• Perspective distortion causes foreshortening of edges along which the interpolation occurs.
• Orientation dependence can cause the same point on the surface to have different intensities as the surface rotates. This happens because the intersecting scanline with the polygon will have different lengths dependent on the geometry of the polygon. Because the interpolation occurs across the intersecting scanline the interpolated values may be quite different for the same point.
• If two adjacent polygons do not share a vertex along a common edge then color discontinuity can arise.
• Unrepresentative vertex normals.
• 
• 

Adding Surface Detail to Objects

• Simply add some additional surface polygons to a base polygon (i.e. polygons representing doors, windows, or lettering) => Surface Detail Polygons.
• Texture Mapping
  • A technique to map an image onto a surface to approximate detail. The process was developed by Catmull in 1974 and refined by Blinn and Newell in 1976. Although maps may be 1-D, 2-D, or 3-D this discussion deals only with 2-D maps.

Texture Mapping (OpenGL Redbook Texture discussion)

The image to be applied is called a texture map with individual components of the map referred to as texels. The map resides in a 2-D texture coordinate space, with coordinates specified by (s, t).

The texture mapping algorithm is a two step process that occurs during rasterization.

• The four corners of a screen pixel are mapped onto the surface of the object that the pixel intersects.
• The surface may be curved.
• The four corners of the surface pixel are then mapped onto the texture.
• The texture pixel is defined by four corners in (s, t) space and is a quadrilateral.
• This quadrilateral will only be an approximation of the surface pixel if the surface is curved.
• Each texel color is weighted based on the proportion of the area of the quadrilateral it occupies.
• The color intensity of the screen pixel is then determined by summing all the weighted texel colors.

If the (s, t) coordinates fall outside of the map, then one can think of the map as being replicated. The mapping proceeds as described above.

If the surface to be mapped is a polygon then it is advantageous to assign texture coordinates directly to the polygon vertices. Linear interpolation of the texture coordinates can be applied during scanline conversion.

Again, due to orientation-dependence, interpolating can cause texture distortion due to the foreshortening that occurs with perspective transformation.

It should be obvious that texturing is an expensive process

• the two step mapping process
• application of a filter (perhaps more complex than the simple box filter described above)
• summing of texels

=> hardware support is highly desirable.

Texture Mapping in openGL

A very large and complicated topic area of openGL. The following discussion is not all inclusive, deals only with 2-D issues.

Texture mapping is performed in RGBA mode.

The steps to get a texture going are :

• Create a texture object and specify a texture for the object.
  • A texture can be loaded from a file or produced by the application program. If you are interested in program created textures then refer to the Texture Chapter in the openGL book for several examples. The following deals only with .rgb texture files. Examples for reading and using different image files can be found in the GamingTutors/GamingTutorsPCWinandGlut/Textures folder.

  Example

  //loading the texture file

  char* filename;

  RGBImageRec *image = NULL;

  image = rgbImageLoad(filename);

  //create the texture object

  glPixelStorei(GL_UNPACK_ALIGNMENT,1);

  GLuint whichTexture; //texture ID

  glGenTextures(1, &whichTexture); /*returns 1 unused texture ID*/

  glBindTexture(GL_TEXTURE_2D, whichTexture); //create and bind the texture to the ID

  //specify the texture

  glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, image->sizeX, image->sizeY, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->data);

  End Example

  glPixelStorei

  Specifies how to store the pixel data for the image in memory. In this case the data is unpacked and aligned on 2-byte boundaries

  glTexImage2D

  The first argument should be as specified, the second specifies the number of resolutions required for the map (0), the third describes the internal format of texels in the map [a list of possible values on page 361], width and height of the image are provided next, followed by the size of the texture border, if any. The next two arguments specify the format of the texture image data. The last is a pointer to the texture data. Note that sizeX, sizeY, and data are fields of the RGBImageRec pointer.

• Indicate how the texture is to be applied to each pixel.
  • One of four functions can be used to specify how the final color of a textured fragment is determined. Typically specified in init.

    Replace mode : just use the texture data, GL_REPLACE.

    Decal mode : like replace but blends alpha component, GL_DECAL.

    Modulate mode : texture is used to scale the fragments color, GL_MODULATE.

    Blend mode : blends texture and fragment color, GL_TEXTURE_ENV_COLOR, GL_BLEND.

  Example

  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

  End Example

• Enable texturing, typically in init, but can be turned on/off as needed.

  glEnable(GL_TEXTURE_2D);

• Specify how the texture is to be repeated and filtered for (s, t) coordinates. The below is a sufficient set.

  Example

  //how to repeat

  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_REPEAT);

  /*how to filter: magnify if fragment maps to a small portion of a texel, minify if the fragment maps to a large collection of texels. Third parameter specifies filtering method : nearest => use texel coordinates closest to pixel center, linear => use a weighted sum of 2X2 array of texels that lie nearest to center of pixel.*/

  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

  End Example

Many other options available, listed on page 412.

• Draw the scene supplying texture coordinates and geometric coordinates. You must specify your own texture coordinates or allow openGL to compute the coordinates for you.

  Example

  /*An example of user defined texture coordinates. Find in the samples/samples1 texture folder.*/

  for (i = 0; i < 6; i++) {//draws a cube

  glBegin(GL_POLYGON);

  glNormal3fv(n[i]); glTexCoord2fv(t[i][0]); glVertex3fv(c[i][0]);

  glNormal3fv(n[i]); glTexCoord2fv(t[i][1]); glVertex3fv(c[i][1]);

  glNormal3fv(n[i]); glTexCoord2fv(t[i][2]); glVertex3fv(c[i][2]);

  glNormal3fv(n[i]); glTexCoord2fv(t[i][3]); glVertex3fv(c[i][3]);

  glEnd();

  /*An example of openGL computed texture coordinates*/

  glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);

  glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);

  glEnable(GL_TEXTURE_GEN_S);

  glEnable(GL_TEXTURE_GEN_T);

  auxSolidTorus(1.0,1.0);

  End Example

Other possibilities for last parameter of TexGen command listed on page 413.

It is possible to change texture parameters and texture generation modes on the fly during execution. All commands stay in effect until disabled or respecified with a new command.

Examples follow.