void display()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	/** Pass 1
	 * In this pass, render the scene from the light's perspective.  Then copy
	 * the depth buffer to the shadow texture.
	 */
	
	//Setup the projection matrix and store the results for use when calculating the texture matrix
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0, 1.0, 2.0, 8.0);
	glGetFloatv(GL_PROJECTION_MATRIX, lightProjectionMatrix);

	//Setup the modelview matrix to look from the light's perspective, and store the results
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(lightPosition[0], lightPosition[1], lightPosition[2], 0, 0, 0, 0, 1, 0);
	glGetFloatv(GL_MODELVIEW_MATRIX, lightViewMatrix);

	//Change the viewport so that everything rendered fits inside the shadow map
	glViewport(0, 0, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE);

	//Cull front faces to avoid z-fighting
	glCullFace(GL_FRONT);

	//Set the simplest shading model and disable writes to the color buffer for
	//a speed boost
	glDisable(GL_LIGHTING);
	glShadeModel(GL_FLAT);
	glColorMask(0,0,0,0);

	//Render the scene, which should only make changes to the depth buffer
	drawScene();

	//Copy the rendered scene into the shadow texture
	glBindTexture(GL_TEXTURE_2D, shadowTexture);
	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE);

	//Turn on normal render settings so that we can draw normally
	glCullFace(GL_BACK);
	glShadeModel(GL_SMOOTH);
	glColorMask(1,1,1,1);
	
	/** Pass 2
	 * Render the scene as though it were completely shadowed.
	 */

	//The depth buffer should be the only thing that was written to in the previous pass,
	//so go ahead and clear it.
	glClear(GL_DEPTH_BUFFER_BIT);

	//Restore the normal viewport
	glViewport(0,0,resX, resY);

	//Setup the normal projection matrix.
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0, (float)resX/(float)resY, 1.0, 100.0);
	
	//Look in the camera's direction
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(cameraPosition[0], cameraPosition[1], cameraPosition[2], 0, 0, 0, 0, 1, 0);

	//Enable dim light
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT1);
	glLightfv(GL_LIGHT1, GL_POSITION, lightPosition);
	glLightfv(GL_LIGHT1, GL_AMBIENT, matDimWhite);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, matDimWhite);
	glLightfv(GL_LIGHT1, GL_SPECULAR, matBlack);

	//Draw the scene as if it were shadowed
	drawScene();

	/** Pass 3
	 * Render the parts of the scene that aren't shadowed.
	 */

	//Enable a normal white light
	glLightfv(GL_LIGHT1, GL_DIFFUSE, matWhite);
	glLightfv(GL_LIGHT1, GL_SPECULAR, matWhite);

	//Compute the texture matrix, T = bias * lightProjection * lightView
	//Here we make use of OpenGL's texture multiplication methods to do the multiplication.
	glPushMatrix();
		glLoadIdentity();
		glLoadMatrixf(bias);
		glMultMatrixf(lightProjectionMatrix);
		glMultMatrixf(lightViewMatrix);
		glGetFloatv(GL_MODELVIEW_MATRIX, textureMatrix);
	glPopMatrix();
	
	float row0[] = {textureMatrix[0], textureMatrix[4], textureMatrix[8], textureMatrix[12]};
	float row1[] = {textureMatrix[1], textureMatrix[5], textureMatrix[9], textureMatrix[13]};
	float row2[] = {textureMatrix[2], textureMatrix[6], textureMatrix[10], textureMatrix[14]};
	float row3[] = {textureMatrix[3], textureMatrix[7], textureMatrix[11], textureMatrix[15]};
	
	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
	glTexGenfv(GL_S, GL_EYE_PLANE, row0);
    glEnable(GL_TEXTURE_GEN_S);

    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGenfv(GL_T, GL_EYE_PLANE, row1);
    glEnable(GL_TEXTURE_GEN_T);

    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGenfv(GL_R, GL_EYE_PLANE, row2);
    glEnable(GL_TEXTURE_GEN_R);

    glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGenfv(GL_Q, GL_EYE_PLANE, row3);
    glEnable(GL_TEXTURE_GEN_Q);

	glBindTexture(GL_TEXTURE_2D, shadowTexture);
	glEnable(GL_TEXTURE_2D);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
	glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);
	glAlphaFunc(GL_GEQUAL, 0.99f);
    glEnable(GL_ALPHA_TEST);

	drawScene();

	glDisable(GL_TEXTURE_2D);

    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_T);
    glDisable(GL_TEXTURE_GEN_R);
    glDisable(GL_TEXTURE_GEN_Q);
    glDisable(GL_LIGHTING);
    glDisable(GL_ALPHA_TEST);

	glFinish();
	glutSwapBuffers();
}