As we said in the last two lectures, the Phong algorithm was developed by Bui-Tong Phong to approximate surface shading. The algorithm takes, as input, the following quantities:

• A unit length surface normal n = (n_x, n_y, n_z)

• A set of lights, where each light i has a unit length direction vector L_i = (L_x,L_y,L_z) and an illuminance color I_i = (I_r,I_g,I_b)

• Material properties for the surface, which consist of three components:
  • An ambient reflectance color A_rgb = (A_r,A_g,A_b)

  • An diffuse reflectance color D_rgb = (D_r,D_g,D_b)

  • An specular reflectance color and power consisting of S_rgb = (S_r,S_g,S_b) and p.

Given the above, the Phong shading algorithm is:

A_rgb + ∑ I_i ( D_rgb max(0, n • L_i) + S_rgb max(0, R_i • E)^p )

As we showed in class, R_i can be computed from L_i and n by:

R_i = 2 (n • L_i) n - L_i

Since we are transforming the scene into a coordinate system in which the camera looks into negative z, we can assume that E = (0,0,1).

Transforming surface normals

In class we also went over how to transform surface normals. A surface normal is a special kind of linear equation; it describes how far any point p is in the direction normal (ie: perpendicular) to a surface.

In particular, given a surface containing point s, the distance of any point p from that surface is n • (p - s), which is the same as (n • p) - (n • s), since all the operations are linear.

So when we transform our geometry, clearly we want to preserve the value of equations of the form n • p.

Our transformation matrix M will transform point p to (M • p). Therefore the transformation of n must be (n • M^-1). We can prove this by using the associative rule:

You can use the same matrix/vector multiply routine you are already using to transform vertices, if you just transform the inverse matrix, since:

For your convenience, I have placed code to compute the inverse of a 4×4 transformation matrix in class MatrixInverter.

Assignment due Wednesday March 26

For Wednesday March 26 I would like you to put all the pieces together, implementing the complete rendering pipeline for your animated shapes. For each animation frame:

1. Clear the image and set all z-buffer values to zero.

2. Transform all mesh vertices and normals;

3. On each transformed vertex, do Phong shading, thereby replacing surface normal n with color (r,g,b);

4. Apply perspective to each vertex;

5. For each triangle (if you have four sided polygons, split them up into two triangles):
   1. Apply the viewport transform the the triangle's three vertices;

   2. Scan-convert the triangle, thereby interpolating (r,g,b,p_z) from the three triangle vertices to each image pixel covered by the triangle.

      Remember to apply the z-buffer algorithm, so that each pixel retains the (r,g,b) of whatever triangle is nearest to the camera (ie: has the lowest p_z value at that pixel).