Graphics lecture notes 19: Rendering (Ch.8)

Graphics lecture notes 19: Rendering (contd.)

Light that reaches the eye from the point P: I= ambient + diffuse + specular component intensities
Each of the above terms depends on three different light source models (intensity terms), as well as material properties characterized by a different constant specific to the object in the scene.
The diffuse light contribution has an additional multiplicative factor, proportional to (s.m), and the specular component has a multiplicative factor (h.m)^f

Exercise: Which of these terms is affected as the eye or the light source moves?

Color: The above calculations are carried out separately for each of the primary colors (R, G, B); often all the specular components are chosen to be equal. Figure 8.17 (p.423) give example properties of common material objects for the above lighting model; e.g., see the contrast between the coefficient values for black plastic and gold.

Shading is applied at the projection step in the OpenGL pipeline, just before clipping.

Effect of Clipping: When part of a polygonal face is clipped away by the canonical view volume, new vertices are created (intersection of the face and one of the sides of the view volume). Colors for such a vertex may be obtained by linear interpolation between colors associated with old vertices between which it is located.

Light sources in OpenGL: 0-8 sources may be specified, referred to as GL_LIGHT0, ..., GL_LIGHT7. Each source must be explicitly set up (defining its properties) and then enabled, e.g.,
GLfloat lpos[]= [3.0, 4.0, 5.0, 1.0]; GLfloat fpos[]= [1.0, 0.0, 0.0, 0];
glLightfv(GL_LIGHT0, GL_POSITION, lpos); glLightfv(GL_LIGHT1, GL_POSITION, fpos);

GLfloat amb0[]={0.1, 0.1, 0.5, 1}; GLfloat amb1[]={0.1, 0.1, 0.1, 1};
glLightfv(GL_LIGHT0, GL_AMBIENT, amb0); glLightfv(GL_LIGHT1, GL_AMBIENT, amb1);

GLfloat diff0[]={0.3, 0.3, 0, 1};
glLightfv(GL_LIGHT0, GL_DIFFUSE, diff0);

GLfloat spec1[]={1, 0.8, 0, 1};
glLightfv(GL_LIGHT1, GL_SPECULAR, spec1);

GLfloat dir[]={2, 1, 4};
glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, dir); // let this one be a spotlight instead of a point source
glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 30); // spotlight cutoff half-angle in degrees
glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 2); // spotlight intensity decay exponent for cosine(angle from center ray)

glLIGHTf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0);
glLIGHTf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 2.0);
glLIGHTf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 3.0);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0); glEnable(GL_LIGHT1);

GLfloat amb[]={0.1, 0.1, 0.1}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, amb); //global ambient light

glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); // to force accurate computation of true direction of eye from each vertex
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); // to force back faces to be shaded

Default light source properties:

Ambient: black.
Diffuse: white for LIGHT0, black for others.
Specular: white for LIGHT0, black for others.

All are omnidirectional point sources (unless otherwise specified).
Attenuation parameters are 1, 0, 0, i.e., no attenuation (1/(1+0+0)).

Diffuse light (associated with a light source) does come from a specific direction, although it is reflected equally in all directions when it hits a surface; but ambient light does not come from a specific direction.

Moving light sources: In the display callback function, we may push and pop the GL_MODELVIEW matrix, with code that translates the position of the light source between glPushMatrix() and glPopMatrix(), then set the camera position with gluLookAt, then draw the object and call glutSwapBuffers().

To have the light move with the camera, set up the light source position to be (0,0,0), i.e., the position of the eye.

Material properties: Coefficients must be stored in vectors, and declared using glMaterialfv, e.g.,
Glfloat diff[] = [0.8, 0. 8, 0.6, 1];
glMaterialfv(GL_FRONT/BACK/FRONT_AND_BACK, GL_AMBIENT/SPECULAR/DIFFUSE/AMBIENT_AND_DIFFUSE/EMISSION, diff);
(emission is used to make a surface glow with its own light)
Equation 8.11, p.430, shows the computations performed.

SDL specification example:

light 3 4 5 .8 .8 .8
background 1 1 1
globalAmbient .1 .1 .1
ambient .2 .6 0 diffuse .8 .2 .1 specular 1 1 1 specularExponent 20
scale 4 4 4 sphere

Gouraud shading invoked by glShadeModel(GL_SMOOOTH) :

For each scan line, find the color at the leftmost pixel by interpolation of colors at the top and bottom of the left edge of the polygon;

For each scan line, ... rightmost pixel ...

For each pixel on the scan line, find the color by interpolating between the leftmost and rightmost pixels corresponding to that scan line.

Interpolation is speeded up by computing the increments required with each successive scan line and each successive pixel.

Phong shading: For better rendering of highlights, use Phong shading, in which the normal vectors are interpolated, instead of the colors.

Removing hidden surfaces: Depth buffer approach using pseudodepth, Fig.8.31, p.438.

Sources of texture maps:

1. Bitmap textures: A 2D array (image) of texel values (color intensities corresponding to different positions) is first computed and stored, possibly using a function that is evaluated more than once.

Procedural textures: A function may be used to compute a specific texel value when needed.

Pasting texture onto a face: Use the function glTexCoord2f() to associate a point in 2D texture space with each vertex of the face, as in:
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex3f(1.0, 2, 1);
...
glTexCoord2f(0.9, 0.0); glVertex3f(5.0, 5, 5);

By default, texture maps are used to tile a face, ignoring the integral part of fractions in tex coordinates; an alternative is to clamp the texture values instead.

Two frequently used texture mapping techniques are:

Associate with each vertex of each face an index pointing to the corresponding texture coordinates.

Wrap a single texture around each object, associating texture coordinates with each vertex.

Linear interpolation does not produce the best results in texture mapping, though computations are fast. Better results are obtained by accurately computing the desired distortions in the initial texture map obtained as a result of perspective projection.

Glowing object texturing: set up the visible intensity at each vertex to be an element from the texture map, e.g.,
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

Modulating object reflection coefficient:
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

Bump mapping: Use a scalar function texture(s,t) perturb the normal vector at each spot on the face.

Rotating textured cube example: fig.8.52.