Jeff Molofee - NeHe's OpenGL Tutorials

// Get The Points On The Edge

const Point3f& v1 = object.pVertices[face.vertexIndices[j]];

const Point3f& v2 = object.pVertices[face.vertexIndices[( j+1 )%3]];

// Calculate The Two Vertices In Distance

Point3f v3, v4;

v3.x = ( v1.x-lightPosition[0] )*INFINITY;

v3.y = ( v1.y-lightPosition[1] )*INFINITY;

v3.z = ( v1.z-lightPosition[2] )*INFINITY;

v4.x = ( v2.x-lightPosition[0] )*INFINITY;

v4.y = ( v2.y-lightPosition[1] )*INFINITY;

v4.z = ( v2.z-lightPosition[2] )*INFINITY;

I think you'll understand the next section, it justs draws the quadrilateral defined by those four points:

// Draw The Quadrilateral (As A Triangle Strip)

glBegin( GL_TRIANGLE_STRIP );

glVertex3f( v1.x, v1.y, v1.z );

glVertex3f( v1.x+v3.x, v1.y+v3.y, v1.z+v3.z );

glVertex3f( v2.x, v2.y, v2.z );

glVertex3f( v2.x+v4.x, v2.y+v4.y, v2.z+v4.z );

glEnd();

}

}

}

}

}

With that, the shadow casting section is completed. But we are not finished yet! What about drawGLScene? Lets start with the simple bits: clearing the buffers, positioning the light source, and drawing a sphere:

bool drawGLScene() {

GLmatrix16f Minv;

GLvector4f wlp, lp;

// Clear Color Buffer, Depth Buffer, Stencil Buffer

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

glLoadIdentity(); // Reset Modelview Matrix

glTranslatef(0.0f, 0.0f, –20.0f); // Zoom Into Screen 20 Units

glLightfv(GL_LIGHT1, GL_POSITION, LightPos); // Position Light1

glTranslatef(SpherePos[0], SpherePos[1], SpherePos[2]); // Position The Sphere

gluSphere(q, 1.5f, 32, 16); // Draw A Sphere

Next, we have to calculate the light's position relative to the local coordinate system of the object. The comments explain each step in detail. Minv stores the object's transformation matrix, however it is done in reverse, and with negative arguments, so it is actually the inverse of the transformation matrix. Then lp is created as a copy of the light's position, and multiplied by the matrix. Thus, lp is the light's position in the object's coordinate system.

glLoadIdentity(); // Reset Matrix

glRotatef(-yrot, 0.0f, 1.0f, 0.0f); // Rotate By –yrot On Y Axis

glRotatef(-xrot, 1.0f, 0.0f, 0.0f); // Rotate By –xrot On X Axis

glTranslatef(-ObjPos[0], –ObjPos[1], –ObjPos[2]); // Move Negative On All Axis Based On ObjPos[] Values (X, Y, Z)

glGetFloatv(GL_MODELVIEW_MATRIX,Minv); // Retrieve ModelView Matrix (Stores In Minv)

lp[0] = LightPos[0]; // Store Light Position X In lp[0]

lp[1] = LightPos[1]; // Store Light Position Y In lp[1]

lp[2] = LightPos[2]; // Store Light Position Z In lp[2]

lp[3] = LightPos[3]; // Store Light Direction In lp[3]

VMatMult(Minv, lp); // We Store Rotated Light Vector In 'lp' Array

Now, palm off some of the work to draw the room, and the object. Calling castShadow draws the shadow of the object.

glLoadIdentity(); // Reset Modelview Matrix

glTranslatef(0.0f, 0.0f, –20.0f); // Zoom Into The Screen 20 Units

DrawGLRoom(); // Draw The Room

glTranslatef(ObjPos[0], ObjPos[1], ObjPos[2]); // Position The Object

glRotatef(xrot, 1.0f, 0.0f, 0.0f); // Spin It On The X Axis By xrot

glRotatef(yrot, 0.0f, 1.0f, 0.0f); // Spin It On The Y Axis By yrot

drawObject(obj); // Procedure For Drawing The Loaded Object

castShadow(obj, lp); // Procedure For Casting The Shadow Based On The Silhouette

The following few lines draw a little orange circle where the light is:

glColor4f(0.7f, 0.4f, 0.0f, 1.0f); // Set Color To An Orange

glDisable(GL_LIGHTING); // Disable Lighting

glDepthMask(GL_FALSE); // Disable Depth Mask

glTranslatef(lp[0], lp[1], lp[2]); // Translate To Light's Position

// Notice We're Still In Local Coordinate System

gluSphere(q, 0.2f, 16, 8); // Draw A Little Yellow Sphere (Represents Light)

glEnable(GL_LIGHTING); // Enable Lighting

glDepthMask(GL_TRUE); // Enable Depth Mask

The last part updates the object's position and returns.

xrot += xspeed; // Increase xrot By xspeed

yrot += yspeed; // Increase yrot By yspeed

glFlush(); // Flush The OpenGL Pipeline

return TRUE; // Everything Went OK

}

We did specify a DrawGLRoom function, and here it is — a bunch of rectangles to cast shadows against:

void DrawGLRoom() // Draw The Room (Box)

{

glBegin(GL_QUADS); // Begin Drawing Quads

// Floor

glNormal3f(0.0f, 1.0f, 0.0f); // Normal Pointing Up

glVertex3f(-10.0f,-10.0f,-20.0f); // Back Left

glVertex3f(-10.0f,-10.0f, 20.0f); // Front Left

glVertex3f( 10.0f,-10.0f, 20.0f); // Front Right

glVertex3f( 10.0f,-10.0f,-20.0f); // Back Right

// Ceiling

glNormal3f(0.0f,-1.0f, 0.0f); // Normal Point Down

glVertex3f(-10.0f, 10.0f, 20.0f); // Front Left

glVertex3f(-10.0f, 10.0f,-20.0f); // Back Left

glVertex3f( 10.0f, 10.0f,-20.0f); // Back Right

glVertex3f( 10.0f, 10.0f, 20.0f); // Front Right

// Front Wall

glNormal3f(0.0f, 0.0f, 1.0f); // Normal Pointing Away From Viewer

glVertex3f(-10.0f, 10.0f,-20.0f); // Top Left

glVertex3f(-10.0f,-10.0f,-20.0f); // Bottom Left

glVertex3f( 10.0f,-10.0f,-20.0f); // Bottom Right

glVertex3f( 10.0f, 10.0f,-20.0f); // Top Right

// Back Wall

glNormal3f(0.0f, 0.0f,-1.0f); // Normal Pointing Towards Viewer

glVertex3f( 10.0f, 10.0f, 20.0f); // Top Right

glVertex3f( 10.0f,-10.0f, 20.0f); // Bottom Right

glVertex3f(-10.0f,-10.0f, 20.0f); // Bottom Left

glVertex3f(-10.0f, 10.0f, 20.0f); // Top Left

// Left Wall

glNormal3f(1.0f, 0.0f, 0.0f); // Normal Pointing Right

glVertex3f(-10.0f, 10.0f, 20.0f); // Top Front

glVertex3f(-10.0f,-10.0f, 20.0f); // Bottom Front

glVertex3f(-10.0f,-10.0f,-20.0f); // Bottom Back

glVertex3f(-10.0f, 10.0f,-20.0f); // Top Back

// Right Wall

glNormal3f(-1.0f, 0.0f, 0.0f); // Normal Pointing Left

glVertex3f( 10.0f, 10.0f,-20.0f); // Top Back

glVertex3f( 10.0f,-10.0f,-20.0f); // Bottom Back

glVertex3f( 10.0f,-10.0f, 20.0f); // Bottom Front

glVertex3f( 10.0f, 10.0f, 20.0f); // Top Front

glEnd(); // Done Drawing Quads

}

And before I forget, here is the VMatMult function which multiplies a vector by a matrix (get that Math textbook out again!):

void VMatMult(GLmatrix16f M, GLvector4f v) {