mirror.cpp

Go to the documentation of this file.

 
#include <GL/glut.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <math.h>

#ifdef WIN32
#define near zNear
#define far zFar
#endif

#define PI_ 3.14159265358979323846


// The arbitrary mirror is made using Stencil buffer.
//  Approach is based on those proposed in "Improving Shadows
//  and Reflections via the Stencil buffer".
// 

#include <stdio.h>
#include "math.h"

typedef struct Point3Struct {
        double x, y, z;
} Point3;


bool normalize ( double[3]);
void add ( double[3], double[3]);

void renderMirrorSurfacePolygons(void);
void draw_scene(void);
void renderMirrorSurfacePolygons(void);
void mirrorMatrix(GLfloat [4][4], 
    GLfloat [3],
    GLfloat [3]);
void computeReflectionMatrixForMirror(GLfloat [4][4]);
void computeMirrorClipPlane(GLdouble [4]);
void drawBorder(void);


//focus
float z = 15.0;

bool changed = false;

bool FillPolygons = true;

  GLfloat colorWhite[4] = {1,1,1,1};
  GLfloat colorDarkGrey[4]    = { 0.2, 0.2, 0.2, 0.0 };
   
   GLfloat ambient[] = { 0.1, 0.1, 0.1, 1.0 };
   GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
   GLfloat no_specular[] = { .0, .0, .0, 1.0 };

bool Specular = false;
bool Lighting = true;

GLfloat LightPos[4]  = {5.00, 5.0, 5.0, 1.0};
GLfloat LightPos2[4] = {-10, -10, -10, 1};

GLfloat mirror_vertices[4][3] = { {-2, -2, -7}, {-2, 2, -7}, {2, 2, -7}, {2, -2, -7} };
GLfloat mirror_center[3] = {0, 0, -7};
GLfloat mirror_normal[3];

GLfloat border_vertices[4][3] = { {-2.5, -2.5, -7}, {-2.5, 2.5, -7}, {2.5, 2.5, -7}, {2.5, -2.5, -7} };

bool RotateMirrorUp = false, RotateMirrorDown = false, RotateMirrorLeft = false, RotateMirrorRight = false;
bool MoveMirrorForward = false, MoveMirrorBackward = false;

//rotation variables
float AngleX=0, AngleY=0;
bool RotateUp = false, RotateDown = false, RotateLeft = false, RotateRight = false;

float CameraX = 0, CameraY = 0, CameraZ = 5.0f;

int LastTime = 0;
int TimerDelay = 50;
float FPS = 0;

void computeMirrorClipPlane(GLdouble plane[4])
{
Point3 vertex[3];
Point3Struct * vertex_ptr;
Point3 normal;
Point3Struct * normal_ptr;
double A, B, C, D;

vertex[0].x = mirror_vertices[0][0];
vertex[0].y = mirror_vertices[0][1];
vertex[0].z = mirror_vertices[0][2];

vertex[1].x = mirror_vertices[1][0];
vertex[1].y = mirror_vertices[1][1];
vertex[1].z = mirror_vertices[1][2];

vertex[2].x = mirror_vertices[2][0];
vertex[2].y = mirror_vertices[2][1];
vertex[2].z = mirror_vertices[2][2];



//determining the coefficients in plane's equation
A = ( (vertex[1].y - vertex[0].y)*(vertex[2].z - vertex[0].z) ) - ( (vertex[1].z - vertex[0].z)*(vertex[2].y - vertex[0].y) );
B = ( (vertex[1].z - vertex[0].z)*(vertex[2].x - vertex[0].x) ) - ( (vertex[2].z - vertex[0].z)*(vertex[1].x - vertex[0].x) );
C = ( (vertex[1].x - vertex[0].x)*(vertex[2].y - vertex[0].y) ) - ( (vertex[1].y - vertex[0].y)*(vertex[2].x - vertex[0].x) );
D = - ( vertex[0].x*A + vertex[0].y*B + vertex[0].z*C );
/*
if (D < 0)
    {
    //normalizing
    D = -D;
    A = -A;
    B = -B;
    C = -C;
    }
*/      
plane[0] = A;
plane[1] = B;
plane[2] = C;
plane[3] = D;

//now computing the normal for the mirror
        Point3 vertexa, vertexb, vertexc;
        double vector[3], vector2[3];
                //load three points of triangle
    vertexa.x = mirror_vertices[0][0];
    vertexa.y = mirror_vertices[0][1];
    vertexa.z = mirror_vertices[0][2];
    vertexb.x = mirror_center[0];
    vertexb.y = mirror_center[1];
    vertexb.z = mirror_center[2];
    vertexc.x = mirror_vertices[1][0];
    vertexc.y = mirror_vertices[1][1];
        vertexc.z = mirror_vertices[1][2];    
        
        //first vector a-b
        vector[0] = vertexb.x - vertexa.x;
        vector[1] = vertexb.y - vertexa.y;
        vector[2] = vertexb.z - vertexa.z;
        
        //second vector b-c
        vector2[0] = vertexc.x - vertexb.x;
        vector2[1] = vertexc.y - vertexb.y;
        vector2[2] = vertexc.z - vertexb.z;
        
        //normal is a cross product between v1 and v2
    normal.x =  (vector[1]*vector2[2] - vector[2]*vector2[1]);
    normal.y =  (vector[2]*vector2[0] - vector[0]*vector2[2]);
    normal.z =  (vector[0]*vector2[1] - vector[1]*vector2[0]);
        
        //rewriting vector
    vector[0] = normal.x;
    vector[1] = normal.y;
    vector[2] = normal.z;
    
        //normalizing the normal
if ( normalize ( vector ) )
    {
    printf(" normal is zero!\n");
    }
mirror_normal[0] = vector[0];
mirror_normal[1] = vector[1];
mirror_normal[2] = vector[2];

//compute the position of the second light source
float k;

k = (A*LightPos[0] + B*LightPos[1] + C*LightPos[2] + D) / ( -(A*A + B*B + C*C) );

LightPos2[0] = LightPos[0] + 2*k*A;
LightPos2[1] = LightPos[1] + 2*k*B;
LightPos2[2] = LightPos[2] + 2*k*C;
/*
LightPos2[0] -= mirror_center[0];
LightPos2[1] -= mirror_center[1];
LightPos2[2] -= mirror_center[2];
*/

/*
printf(" lightsource 1: %f, %f, %f lightsource 2: %f, %f, %f \n", 
    LightPos[0], LightPos[1], LightPos[2],
    LightPos2[0], LightPos2[1], LightPos2[2]);
*/

 //printf(" normal: %f, %f, %f \n", mirror_normal[0], mirror_normal[1], mirror_normal[2] );
}

void add ( double v[3], double v2[3])
{

v[0] += v2[0];
v[1] += v2[1];
v[2] += v2[2];

}

bool normalize ( double v[3])
{
double d = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
if (d != 0.0) 
    {
    v[0] /= d;
    v[1] /= d;
    v[2] /= d;
    return (false);
    }
else
    printf(" zero normal?! hmm, strange... %f \n", d);

return (true);
//printf(" len of normal is %f \n", sqrt (v[0]*v[0] + v[1]*v[1] + v[2]*v[2] ) );
}


//helper function from Bastian
void glutString( char *pstr )
{
  while (*pstr!=char(0)) {
    glutBitmapCharacter( GLUT_BITMAP_8_BY_13, int( *pstr ));
    pstr++;
  }
}

GLuint teapotList;

/* accFrustum()
 * The first 6 arguments are identical to the glFrustum() call.
 *  
 * pixdx and pixdy are anti-alias jitter in pixels. 
 * Set both equal to 0.0 for no anti-alias jitter.
 * eyedx and eyedy are depth-of field jitter in pixels. 
 * Set both equal to 0.0 for no depth of field effects.
 *
 * focus is distance from eye to plane in focus. 
 * focus must be greater than, but not equal to 0.0.
 *
 * Note that accFrustum() calls glTranslatef().  You will 
 * probably want to insure that your ModelView matrix has been 
 * initialized to identity before calling accFrustum().
 */
void accFrustum(GLdouble left, GLdouble right, GLdouble bottom, 
   GLdouble top, GLdouble near, GLdouble far, GLdouble pixdx, 
   GLdouble pixdy, GLdouble eyedx, GLdouble eyedy, GLdouble focus)
{
   GLdouble xwsize, ywsize; 
   GLdouble dx, dy;
   GLint viewport[4];

   glGetIntegerv (GL_VIEWPORT, viewport);
        
   xwsize = right - left;
   ywsize = top - bottom;
        
   dx = -(pixdx*xwsize/(GLdouble) viewport[2] + eyedx*near/focus);
   dy = -(pixdy*ywsize/(GLdouble) viewport[3] + eyedy*near/focus);
        
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glFrustum (left + dx, right + dx, bottom + dy, top + dy, near, far);
glTranslatef(-0.5, -0.5, -5);
glRotatef( AngleY, 0, 1, 0);
glRotatef( AngleX, 1, 0, 0);
glTranslatef(0.5, 0.5, 5);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glTranslatef (-eyedx, -eyedy, 0.0);
}

/*  accPerspective()
 * 
 *  The first 4 arguments are identical to the gluPerspective() call.
 *  pixdx and pixdy are anti-alias jitter in pixels. 
 *  Set both equal to 0.0 for no anti-alias jitter.
 *  eyedx and eyedy are depth-of field jitter in pixels. 
 *  Set both equal to 0.0 for no depth of field effects.
 *
 *  focus is distance from eye to plane in focus. 
 *  focus must be greater than, but not equal to 0.0.
 *
 *  Note that accPerspective() calls accFrustum().
 */
void accPerspective(GLdouble fovy, GLdouble aspect, 
   GLdouble near, GLdouble far, GLdouble pixdx, GLdouble pixdy, 
   GLdouble eyedx, GLdouble eyedy, GLdouble focus)
{
   GLdouble fov2,left,right,bottom,top;

   fov2 = ((fovy*PI_) / 180.0) / 2.0;

   top = near / (cos(fov2) / sin(fov2));
   bottom = -top;

   right = top * aspect;
   left = -right;

   accFrustum (left, right, bottom, top, near, far,
               pixdx, pixdy, eyedx, eyedy, focus);
}

void initGL(void)
{
GLenum performance = GL_NICEST; //GL_NICEST
glHint(GL_POINT_SMOOTH_HINT, performance );
glHint(GL_LINE_SMOOTH_HINT, performance );
glHint(GL_POLYGON_SMOOTH_HINT, performance );
glHint(GL_FOG_HINT, performance );
glHint(GL_PERSPECTIVE_CORRECTION_HINT, performance );

//  glEnable(GL_DEPTH_TEST);
//  glDepthFunc(GL_LESS);
  glShadeModel(GL_SMOOTH);
if (Lighting)  glEnable(GL_LIGHTING);
//  glDisable( GL_CULL_FACE );
  glEnable( GL_NORMALIZE );
glDisable(GL_CULL_FACE);  

  glLightfv(GL_LIGHT0, GL_DIFFUSE, colorWhite );
    glLightfv(GL_LIGHT0, GL_AMBIENT, colorDarkGrey );
      glLightfv(GL_LIGHT0, GL_SPECULAR, no_specular);//colorWhite );    
   
  glLightfv(GL_LIGHT1, GL_DIFFUSE, colorWhite );
    glLightfv(GL_LIGHT1, GL_AMBIENT, colorDarkGrey );
      glLightfv(GL_LIGHT1, GL_SPECULAR, no_specular);//colorWhite );    
   
   //define the linear attenuation factor in order
   // to make point light source
   glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, .001);
   glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, .001);

   GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
   GLfloat local_view[] = { 0.0 };

//   glLightfv(GL_LIGHT0, GL_POSITION, LightPos); 
  // glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
  // glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);

   //glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
   //glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
    
//   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
//   glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);

   glFrontFace (GL_CW);
if (Lighting)   glEnable(GL_LIGHTING);
//   glEnable(GL_LIGHT0);
//   glEnable(GL_AUTO_NORMAL);
   glEnable(GL_NORMALIZE);
   glEnable(GL_DEPTH_TEST);

   glClearColor(0.0, 0.0, 0.0, 0.0);
   glClearAccum(0.0, 0.0, 0.0, 0.0); 
/*  make teapot display list */
   teapotList = glGenLists(1);
   glNewList (teapotList, GL_COMPILE);
   glutSolidTeapot (0.5);
   glEndList ();
}

void renderTeapot (GLfloat x, GLfloat y, GLfloat z, 
   GLfloat ambr, GLfloat ambg, GLfloat ambb, 
   GLfloat difr, GLfloat difg, GLfloat difb, 
   GLfloat specr, GLfloat specg, GLfloat specb, GLfloat shine)
{
   GLfloat mat[4];

   glPushMatrix();
   glTranslatef (x, y, z);
   mat[0] = ambr; mat[1] = ambg; mat[2] = ambb; mat[3] = 1.0;   
   glMaterialfv (GL_FRONT, GL_AMBIENT, mat);
   mat[0] = difr; mat[1] = difg; mat[2] = difb; 
   glMaterialfv (GL_FRONT, GL_DIFFUSE, mat);
   mat[0] = specr; mat[1] = specg; mat[2] = specb;
   glMaterialfv (GL_FRONT, GL_SPECULAR, mat);
   glMaterialf (GL_FRONT, GL_SHININESS, shine*128.0);
   glCallList(teapotList);
   glPopMatrix();
}

void draw_scene(void)
{
      renderTeapot (-1.1, -0.5, -4.5, 0.1745, 0.01175, 
                    0.01175, 0.61424, 0.04136, 0.04136, 
                    0.727811, 0.626959, 0.626959, 0.6);
      renderTeapot (-0.5, -0.5, -5.0, 0.24725, 0.1995, 
                    0.0745, 0.75164, 0.60648, 0.22648, 
                    0.628281, 0.555802, 0.366065, 0.4);
      renderTeapot (0.2, -0.5, -5.5, 0.19225, 0.19225, 
                    0.19225, 0.50754, 0.50754, 0.50754, 
                    0.508273, 0.508273, 0.508273, 0.4);
      renderTeapot (1.0, -0.5, -6.0, 0.0215, 0.1745, 0.0215, 
                    0.07568, 0.61424, 0.07568, 0.633, 
                    0.727811, 0.633, 0.6);
      renderTeapot (1.8, -0.5, -6.5, 0.0, 0.1, 0.06, 0.0, 
                    0.50980392, 0.50980392, 0.50196078, 
                    0.50196078, 0.50196078, .25);
}

void renderMirrorSurfacePolygons(void)
{
//glColor3f( 1,1,1);
glBegin(GL_TRIANGLES);
    glVertex3fv(mirror_vertices[0]);
    glVertex3fv(mirror_center);
    glVertex3fv(mirror_vertices[1]);
    
    glVertex3fv(mirror_vertices[1]);
    glVertex3fv(mirror_center);
    glVertex3fv(mirror_vertices[2]);
    
    glVertex3fv(mirror_vertices[2]);
    glVertex3fv(mirror_center);
    glVertex3fv(mirror_vertices[3]);
    
    glVertex3fv(mirror_vertices[3]);
    glVertex3fv(mirror_center);
    glVertex3fv(mirror_vertices[0]);
glEnd();
}

void drawBorder(void)
{
glColor4f(.5,.5,.5, 0.5);
/*glBegin(GL_TRIANGLES);
    glVertex3fv(border_vertices[0]);
    glVertex3fv(mirror_center);
    glVertex3fv(border_vertices[1]);
    
    glVertex3fv(border_vertices[1]);
    glVertex3fv(mirror_center);
    glVertex3fv(border_vertices[2]);
    
    glVertex3fv(border_vertices[2]);
    glVertex3fv(mirror_center);
    glVertex3fv(border_vertices[3]);
    
    glVertex3fv(border_vertices[3]);
    glVertex3fv(mirror_center);
    glVertex3fv(border_vertices[0]);
glEnd();
*/
glBegin(GL_QUADS);
    glVertex3fv(border_vertices[0]);
    glVertex3fv(mirror_vertices[0]);
    glVertex3fv(mirror_vertices[1]);
    glVertex3fv(border_vertices[1]);

    glVertex3fv(border_vertices[1]);
    glVertex3fv(mirror_vertices[1]);
    glVertex3fv(mirror_vertices[2]);
    glVertex3fv(border_vertices[2]);

    glVertex3fv(border_vertices[2]);
    glVertex3fv(mirror_vertices[2]);
    glVertex3fv(mirror_vertices[3]);
    glVertex3fv(border_vertices[3]);

    glVertex3fv(border_vertices[3]);
    glVertex3fv(mirror_vertices[3]);
    glVertex3fv(mirror_vertices[0]);
    glVertex3fv(border_vertices[0]);

glEnd();
}

void mirrorMatrix(GLfloat m[4][4], 
    GLfloat p[3],
    GLfloat v[3])
{

GLfloat dot = p[0]*v[0] + p[1]*v[1] + p[2]*v[2];

m[0][0] = 1 - 2*v[0]*v[0];
m[1][0] =   - 2*v[0]*v[1];
m[2][0] =   - 2*v[0]*v[2];
m[3][0] = 2*dot*v[0];

m[0][1] =   - 2*v[1]*v[0];
m[1][1] = 1 - 2*v[1]*v[1];
m[2][1] =   - 2*v[1]*v[2];
m[3][1] = 2*dot*v[1];

m[0][2] =   - 2*v[2]*v[0];
m[1][2] =   - 2*v[2]*v[1];
m[2][2] = 1 - 2*v[2]*v[2];
m[3][2] = 2*dot*v[2];

m[0][3] = 0;
m[1][3] = 0;
m[2][3] = 0;
m[3][3] = 1;

}

void computeReflectionMatrixForMirror(GLfloat matrix[4][4])
{

mirrorMatrix((GLfloat (*)[4])&matrix[0][0], 
    &mirror_vertices[0][0],
    &mirror_normal[0]);
}

void display(void)
{
   GLint viewport[4];
if (Lighting) glEnable(GL_LIGHTING);
//    glColor3f( 1.0f, 1.0f, 1.0f );
//glDisable(GL_DEPTH_TEST);

   glClearColor(0.0, 0.0, 0.0, 0.0);
   //glClearAccum(0.0, 0.0, 0.0, 0.0); 

   glGetIntegerv (GL_VIEWPORT, viewport);
  // glClear(GL_ACCUM_BUFFER_BIT);
//glClear(GL_COLOR_BUFFER_BIT);
      accPerspective (45.0, 
         (GLdouble) viewport[2]/(GLdouble) viewport[3], 
         1.0, 15.0, 0.0, 0.0,
         0, 0, z);


    glClearStencil(0);
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

glEnable(GL_STENCIL_BUFFER_BIT);
    glEnable(GL_DEPTH_BUFFER_BIT);
    glEnable(GL_DEPTH_TEST);
    glDisable(GL_STENCIL_TEST);


//blend mirror and reflected scene
/*glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR );
glDepthFunc(GL_LESS);
glEnable(GL_BLEND);
*/
GLfloat matrix[4][4];
GLdouble clipPlane[4];


    computeMirrorClipPlane(&clipPlane[0]);

glLightfv(GL_LIGHT1, GL_POSITION, LightPos2); 
glLightfv(GL_LIGHT0, GL_POSITION, LightPos);
glEnable(GL_LIGHT1);
glDisable(GL_LIGHT0);
//glEnable(GL_LIGHT0);

//glDepthFunc(GL_LESS);
//mirror is only one
// 1)
    glEnable(GL_STENCIL_TEST);
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
    glStencilFunc(GL_ALWAYS, 1, ~0);
    glColorMask(0, 0, 0, 0);
    renderMirrorSurfacePolygons();       
       
// 2)
    glDepthRange(1,1);
    glDepthFunc(GL_ALWAYS);
    glStencilFunc(GL_EQUAL, 1, ~0);
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
    renderMirrorSurfacePolygons();

// 3)
    glDepthFunc(GL_LESS);
    glColorMask(1,1,1,1);
    glDepthRange(0,1);

// 4)

glPushMatrix();
    //returns world-space plane equation for mirror plane to use as clip plane 
//    computeMirrorClipPlane(&clipPlane[0]);
    
    //set clip plane equation
    glClipPlane(GL_CLIP_PLANE0, &clipPlane[0]);
glEnable(GL_CLIP_PLANE0);
    //returns mirrorMatrix for given mirror
    computeReflectionMatrixForMirror(
                (GLfloat (*) [4])&matrix[0][0]);
    //concatenae reflection transform into modelview matrix
    glMultMatrixf(&matrix[0][0]);

 glCullFace(GL_FRONT);
        //glMatrixMode(GL_MODELVIEW);
        //glPushMatrix();
        //glLoadIdentity();
//      glEnable(GL_CLIP_PLANE0);
        //glPopMatrix();
        draw_scene();
drawBorder();
    
    glCullFace(GL_BACK);
    glDisable(GL_CLIP_PLANE0);
glPopMatrix();

// 5)

glColorMask(0, 0, 0, 0);
glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
glDepthFunc(GL_ALWAYS);
renderMirrorSurfacePolygons();
glDepthFunc(GL_LESS);
glColorMask(1,1,1,1);

glCullFace(GL_FRONT);
glDepthFunc(GL_LESS);
glDisable(GL_STENCIL_TEST);

   glLightfv(GL_LIGHT0, GL_POSITION, LightPos); 
glEnable(GL_LIGHT0);
glDisable(GL_LIGHT1);

    draw_scene(); //draw everything except mirror
    drawBorder(); // <-- here is the difference with approach in "Improving ..."
                // because we first drawing all the reflections and only then the
                // actual scene, which passes the depth test for GL_LESS. 
                // This removes all not reflected pixels from the mirror. 
                // When using other way round, on the mirror would be teapots which
                // are behind the mirror, since they are drawn at first and never
                // deleted (or pass some depth tests).
glDepthFunc(GL_LESS);




glDisable(GL_BLEND);

         // Display framerate
glPushMatrix();
    char buf[100];
    sprintf( buf, " %0.2f fps,  X=%f, Y=%f, Z=%f, alpha=%f, beta=%f ", FPS, CameraX, CameraY, CameraZ, 
        AngleX, AngleY );
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    glDisable( GL_DEPTH_TEST );
    glDisable( GL_LIGHTING );
    glColor3f( 1.0f, 1.0f, 1.0f );
    glRasterPos2f( -1,-1 );
    glutString( buf );
    glEnable( GL_DEPTH_TEST );
if (Lighting)    glEnable(GL_LIGHTING);
glPopMatrix();
   
   glutSwapBuffers();
}

void reshape(int w, int h)
{
changed = true;
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glutPostRedisplay();
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
      case 'q':
         exit(0);
         break;
          case ' ':
                 glutPostRedisplay();
                 break;
          case 'a':
                RotateLeft = true;
                RotateRight = false;
                break;
          case 'd':
                RotateRight = true;
                RotateLeft = false;
                break;
          case 'w':
                RotateUp = true;
                RotateDown = false;
                break;
          case 's':
                RotateDown = true;
                RotateUp = false;
                break;
          case 't':
                RotateMirrorUp = true;
                RotateMirrorDown = false;
                break;
          case 'g':
                RotateMirrorDown = true;
                RotateMirrorUp = false;
                break;
          case 'f':
                RotateMirrorLeft = true;
                RotateMirrorRight = false;
                break;
          case 'h':
                RotateMirrorRight = true;
                RotateMirrorLeft = false;
                break;
          case 'v':
                MoveMirrorForward = true;
                MoveMirrorBackward = false;
                break;
          case 'b':
                MoveMirrorForward = false;
                MoveMirrorBackward = true;
                break;
          case 'o': 
                Specular = !Specular;
                if (!Specular)
                    {
                    glLightfv(GL_LIGHT0, GL_SPECULAR, no_specular);//colorWhite );    
                    glLightfv(GL_LIGHT1, GL_SPECULAR, no_specular);//colorWhite );    
                    }
                else
                    {
                    glLightfv(GL_LIGHT0, GL_SPECULAR, colorWhite );    
                    glLightfv(GL_LIGHT1, GL_SPECULAR, colorWhite );    
                    };
                break;
          case 'l': Lighting = !Lighting;
                if (Lighting)
                    glEnable(GL_LIGHTING);
                else
                    glDisable(GL_LIGHTING);
                break;
          
          case 'p': FillPolygons = !FillPolygons;
                glPolygonMode( GL_FRONT_AND_BACK, (FillPolygons ? GL_FILL : GL_LINE) );
                break;
   }
}


static void timerCallback(int)
{

int nc = glutGet(GLUT_ELAPSED_TIME);
float fSec = float(nc-LastTime) / 1000.0f;
  // Compute average frame rate from the last twenty frames
  FPS = (19.0f*FPS + 1.0f / fSec) / 20.0f;
  LastTime = nc;
  
  float fCamArc = fSec * 180.0f;
  if (RotateLeft) AngleY -= fCamArc/4;
  if (RotateRight) AngleY += fCamArc/4;
  if (RotateUp) AngleX += fCamArc/4;
  if (RotateDown) AngleX -= fCamArc/4;
  
  GLfloat angle = fCamArc/4;
  GLfloat rotatematrix[16]; 
  GLfloat translatematrix[16];
  
  if ((RotateMirrorLeft) || (RotateMirrorRight) )
    {
    //specify the rotation angle
    if (RotateMirrorLeft) angle = -angle;
    //convert from degrees to rad
//printf(" angle = %f deg, ", angle);
    angle = angle * M_PI/180.0f;
//printf(" %f rad \n", angle);
    //construct the rotation matrix
/*    rotatematrix[0] = 1; rotatematrix[1] = 0; rotatematrix[2] = 0;                  rotatematrix[3] = 0;
    rotatematrix[4] = 0; rotatematrix[5] = cos(angle); rotatematrix[6] = -sin(angle); rotatematrix[7] = 0;
    rotatematrix[8] = 0; rotatematrix[9] = sin(angle); rotatematrix[10] = cos(angle); rotatematrix[11] = 0;
    rotatematrix[12] = 0; rotatematrix[13] = 0; rotatematrix[14] = 0;                 rotatematrix[15] = 1;
*/

    rotatematrix[0] = cos(angle); rotatematrix[1] = 0; rotatematrix[2] = sin(angle); rotatematrix[3] = 0;
    rotatematrix[4] = 0;        rotatematrix[5] = 1; rotatematrix[6] = 0; rotatematrix[7] = 0;
    rotatematrix[8] = -sin(angle); rotatematrix[9] = 0; rotatematrix[10] = cos(angle); rotatematrix[11] = 0;
    rotatematrix[12] = 0; rotatematrix[13] = 0; rotatematrix[14] = 0;                 rotatematrix[15] = 1;
    
    translatematrix[0] = 1; translatematrix[1] = 0; translatematrix[2] = 0; translatematrix[3]  = -mirror_center[0];
    translatematrix[4] = 0; translatematrix[5] = 1; translatematrix[6] = 0; translatematrix[7]  = -mirror_center[1];
    translatematrix[8] = 0; translatematrix[9] = 0; translatematrix[10] = 1; translatematrix[11] = -mirror_center[2];
    translatematrix[12] = 0; translatematrix[13] = 0; translatematrix[14] = 0; translatematrix[15] = 1;

GLfloat vector[4];
    //now modify the coordinates
    for (int i=0; i<4; i++)
        {
        //first, translate the vertices 
        mirror_vertices[i][0] -= mirror_center[0];
        mirror_vertices[i][1] -= mirror_center[1];
        mirror_vertices[i][2] -= mirror_center[2];
    
        border_vertices[i][0] -= mirror_center[0];
        border_vertices[i][1] -= mirror_center[1];
        border_vertices[i][2] -= mirror_center[2];
        
        //then rotate  
        Multiply<GLfloat> (rotatematrix, mirror_vertices[i], vector);
                mirror_vertices[i][0] = vector[0];
                mirror_vertices[i][1] = vector[1];
                mirror_vertices[i][2] = vector[2];
                mirror_vertices[i][3] = vector[3];
        Multiply<GLfloat> (rotatematrix, border_vertices[i], vector);
                border_vertices[i][0] = vector[0];
                border_vertices[i][1] = vector[1];
                border_vertices[i][2] = vector[2];
                border_vertices[i][3] = vector[3];

        //and return back
        mirror_vertices[i][0] += mirror_center[0];
        mirror_vertices[i][1] += mirror_center[1];
        mirror_vertices[i][2] += mirror_center[2];
    
        border_vertices[i][0] += mirror_center[0];
        border_vertices[i][1] += mirror_center[1];
        border_vertices[i][2] += mirror_center[2];
        }//end for
    }//end if

//UP and DOWN rotations
  if ((RotateMirrorUp) || (RotateMirrorDown) )
    {
    //specify the rotation angle
    if (RotateMirrorDown) angle = -angle;
    //convert from degrees to rad
//printf(" angle = %f deg, ", angle);
    angle = angle * M_PI/180.0f;
//printf(" %f rad \n", angle);
    //construct the rotation matrix
    rotatematrix[0] = 1; rotatematrix[1] = 0; rotatematrix[2] = 0;                    rotatematrix[3] = 0;
    rotatematrix[4] = 0; rotatematrix[5] = cos(angle); rotatematrix[6] = -sin(angle); rotatematrix[7] = 0;
    rotatematrix[8] = 0; rotatematrix[9] = sin(angle); rotatematrix[10] = cos(angle); rotatematrix[11] = 0;
    rotatematrix[12] = 0; rotatematrix[13] = 0; rotatematrix[14] = 0;                 rotatematrix[15] = 1;

/*
    rotatematrix[0] = cos(angle); rotatematrix[1] = 0; rotatematrix[2] = sin(angle); rotatematrix[3] = 0;
    rotatematrix[4] = 0;        rotatematrix[5] = 1; rotatematrix[6] = 0; rotatematrix[7] = 0;
    rotatematrix[8] = -sin(angle); rotatematrix[9] = 0; rotatematrix[10] = cos(angle); rotatematrix[11] = 0;
    rotatematrix[12] = 0; rotatematrix[13] = 0; rotatematrix[14] = 0;                 rotatematrix[15] = 1;
*/        
    translatematrix[0] = 1; translatematrix[1] = 0; translatematrix[2] = 0; translatematrix[3]  = -mirror_center[0];
    translatematrix[4] = 0; translatematrix[5] = 1; translatematrix[6] = 0; translatematrix[7]  = -mirror_center[1];
    translatematrix[8] = 0; translatematrix[9] = 0; translatematrix[10] = 1; translatematrix[11] = -mirror_center[2];
    translatematrix[12] = 0; translatematrix[13] = 0; translatematrix[14] = 0; translatematrix[15] = 1;

GLfloat vector[4];
    //now modify the coordinates
    for (int i=0; i<4; i++)
        {
        //first, translate the vertices 
        mirror_vertices[i][0] -= mirror_center[0];
        mirror_vertices[i][1] -= mirror_center[1];
        mirror_vertices[i][2] -= mirror_center[2];
    
        border_vertices[i][0] -= mirror_center[0];
        border_vertices[i][1] -= mirror_center[1];
        border_vertices[i][2] -= mirror_center[2];
        
        //then rotate  
        Multiply<GLfloat> (rotatematrix, mirror_vertices[i], vector);
                mirror_vertices[i][0] = vector[0];
                mirror_vertices[i][1] = vector[1];
                mirror_vertices[i][2] = vector[2];
                mirror_vertices[i][3] = vector[3];
        Multiply<GLfloat> (rotatematrix, border_vertices[i], vector);
                border_vertices[i][0] = vector[0];
                border_vertices[i][1] = vector[1];
                border_vertices[i][2] = vector[2];
                border_vertices[i][3] = vector[3];

        //and return back
        mirror_vertices[i][0] += mirror_center[0];
        mirror_vertices[i][1] += mirror_center[1];
        mirror_vertices[i][2] += mirror_center[2];
    
        border_vertices[i][0] += mirror_center[0];
        border_vertices[i][1] += mirror_center[1];
        border_vertices[i][2] += mirror_center[2];
        }//end for
    }//end if

float distance = .10f;
if ((MoveMirrorForward) || (MoveMirrorBackward))
    {
        distance = (MoveMirrorForward ? distance : -distance );
    //modify the coordinates
    for (int i=0; i<4; i++)
        {
        //mirror 
        mirror_vertices[i][0] += mirror_normal[0] * distance;
        mirror_vertices[i][1] += mirror_normal[1] * distance;
        mirror_vertices[i][2] += mirror_normal[2] * distance;
        
        //border
        border_vertices[i][0] += mirror_normal[0] * distance;
        border_vertices[i][1] += mirror_normal[1] * distance;
        border_vertices[i][2] += mirror_normal[2] * distance;
        }//end for

    //and the center!
    mirror_center[0] += mirror_normal[0] * distance;
    mirror_center[1] += mirror_normal[1] * distance;
    mirror_center[2] += mirror_normal[2] * distance;

    }//end if
  
  glutPostRedisplay();
  glutTimerFunc(TimerDelay, timerCallback, 0);

}



/*  Main Loop
 *  Be certain you request an accumulation buffer.
 */

void keyboardUp(unsigned char key, int, int)
{
switch (key)
        {
        case 'a': RotateLeft = false;  break;
        case 'd': RotateRight = false; break;
        case 'w': RotateUp = false;  break;
        case 's': RotateDown = false; break;
        case 't': RotateMirrorUp = false; break;
        case 'g': RotateMirrorDown = false; break;
        case 'f': RotateMirrorLeft = false; break;
        case 'h': RotateMirrorRight = false; break;
        case 'v': MoveMirrorForward = false; break;
        case 'b': MoveMirrorBackward = false; break;
        }

}
 
int main(int argc, char** argv)
{

printf(" Keys: \n");
printf("\ta,d,w,s    -- to rotate about gold teapot.\n");
printf("\tf,h,t,g    -- to rotate mirror.\n");
printf("\tv,b        -- to move mirro back and force.\n");
printf("\tp          -- to toggle polygon fill mode.\n");
printf("\tl          -- to toggle lighting.\n");
printf("\to          -- to toggle specular lighting.\n");
printf("\tq    -- to Quit.\n");

   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB
                        | GLUT_STENCIL | GLUT_DEPTH); 
   glutInitWindowSize (400, 400);
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   initGL();
   glutReshapeFunc(reshape);
   glutDisplayFunc(display);
   glutKeyboardFunc(keyboard);
   glutKeyboardUpFunc(keyboardUp);
   LastTime = glutGet (GLUT_ELAPSED_TIME );
   glutTimerFunc ( TimerDelay, timerCallback, 0);
   glutMainLoop();
   return 0;
}

---