render.cpp

Go to the documentation of this file.

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

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

#include "config.h"
#include "heightfield.h"
//#include "airplane.h"
#include "texture.h"
#include "scene.h"

#include "water.h"

#include "materials.h"



//MODELS are taken from 
//      http://www.3dcafe.com/asp/horror.asp
//      and then converted to very simple format

/* Despite the fact that all the models are drawn using glTriangles,
    framerate is at desired level. This is due to the usage of 
    glList's increasing performance for static objects.
   Application of depth of field or motion blur effects to the whole scene will
    decrease framerate dramatically. That is why they are presented in separate
    files on a rather simple scenes.
    */ 

// Mirror Plane is made without stencil buffer.
// The idea is taken from "Improving Shadows and Reflections via the Stencil Buffer".
// Correct behaviour of the mirror plane can be seen on the water and lighting.
// When mirror plane is disabled, all water flow goes in certain direction.
// Enabling mirror plane we see that "reflection" in the mirror plane is correct.


//equation for clipping plane (used in mirror plane)
GLdouble eqn[4] = {0, 0, 1, 0};

// Items in popup menu
enum {
  MENU_LIGHTING = 1,
  MENU_POLYMODE,
  MENU_TEXTURING,
  MENU_FRAMERATE,
  MENU_EXIT
};



static std::string model_path = "./render/models/";
static std::string model_ext  = ".model";





// Time of last call to display timer
static int g_nLastTime = 0;
// Frames per second
static float g_fFPS = 0;

// Visibility range in GL coordinates
static const int g_visibility = g_cells * g_cellsize;

// Camera data
static float g_nearPlane = 1;
static float g_farPlane = g_visibility;

static const double VIEWING_DISTANCE_MIN = 3.0;
float g_fViewDistance = 5*VIEWING_DISTANCE_MIN;


// Viewport parameters
static int g_Width = 512;                          // Initial window width
static int g_Height = 512;                         // Initial window height

// Flags for drawing state
static bool g_bFillPolygons = true;


//Movement
static bool go_Forward = false;
static bool go_Backward = false;
static bool go_Left = false;
static bool go_Right = false;

static float go_cells_per_step = 40;

void __draw_fog ()
{
    glFogi( GL_FOG_MODE, GL_LINEAR );
if (day)
    glFogfv( GL_FOG_COLOR, colorLightGreen );
else
    glFogfv( GL_FOG_COLOR, colorDarkGreen );
//    glFogf( GL_FOG_DENSITY, 0.5f );
    glFogf( GL_FOG_START, g_visibility * 0.6f );
    glFogf( GL_FOG_END, g_visibility );
//    glFogfv( GL_FOG_COLOR, colorSky );

}



/**********************************************
 **********************************************
   HELPER FUNCTIONS
 **********************************************
 *********************************************/

void glutString( char *pstr )
{
  while (*pstr!=char(0)) {
    glutBitmapCharacter( GLUT_BITMAP_8_BY_13, int( *pstr ));
    pstr++;
  }
}


/**********************************************
 **********************************************
   GL INITIALISATION / WINDOW REDRAWING
 **********************************************
 *********************************************/


void setupCamera()
{
  // Setup projection with field of view of 65 degrees
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(65.0, (float)g_Width / g_Height, g_nearPlane, g_farPlane);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();


glRotatef(g_CameraAngleX, 1, 0, 0);
glRotatef(g_CameraAngleY, 0, 1, 0);

glTranslatef(-g_CameraX,  -g_CameraZ, -g_CameraY);

gluLookAt(0, 0, 0,
        0, 0, -1, 
        0, 1, 0);



/*
  // Set up viewing transformation, looking down -Z axis
  gluLookAt(0, 0, -g_fViewDistance, 0, 0, -1, 0, 1, 0);

  if (g_bChaseCam) {
    // Put camera a bit upward
    glTranslatef( 0,-3,0 );
    glRotatef( -15, 1,0,0 );
    // Align viewing direction with plane X axis
    glRotatef( -90-g_fPlaneAngle, 0,1,0 );
  }
  else {
    // Free camera mode
    glRotatef( g_fCameraX, 1,0,0 );
    glRotatef( g_fCameraY, 0,1,0 );
  }
*/

}

void __drawModel(int model)
{

if (model == MODEL_GALLOWS) 
        {
        setMaterial( MATERIAL_WOOD );
        drawModel(model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ, 15, 70, 10, -90, 0, 90, 0.25 );
        }

if (model == MODEL_GALLOWS_ROPE) 
        {
        setMaterial( MATERIAL_RUBY );
        drawModel(model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ, 15, 70, 10, -90, 0, 90, 0.25 );
        }

if (model == MODEL_IRON_MAIDEN)
        {
        setMaterial( MATERIAL_SILVER );
        drawModel(model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ, 17, 110, 12, -90, 0, 120., 1);
        }

if (model == MODEL_CASKET_CLOSED)
        {
        setMaterial( MATERIAL_CRYPT );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ, 30, 60, 18, -90, 0, 90, .05);
        }

if (model == MODEL_CRYPT) 
        {
        setMaterial( MATERIAL_CRYPT );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ, -40, 40, 8, -90, 0, -90, 0.025 );
        }

if  (model == MODEL_GILJOTINA_1)
        {
        setMaterial( MATERIAL_WOOD );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ,  74, 70, 12, -90, 0, 90, 0.25 );
        }

if (model == MODEL_GILJOTINA_2) 
        {
        setMaterial( MATERIAL_GOLD );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ,  74, 70, 12, -90, 0, 90, 0.25 );
        }
if (model == MODEL_GILJOTINA_3)
        {//chelovek
        setMaterial( MATERIAL_SKIN );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ,  70, 70, 12, -90, 0, 90, 0.25 );
        }
if (model == MODEL_GILJOTINA_4) 
        {
        setMaterial( MATERIAL_CERAMIC );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ,  74, 70, 12, -90, 0, 90, 0.25 );
        }

if  (model == MODEL_MANCAGE_1)
        {
        setMaterial( MATERIAL_WOOD );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ, 70, 25, 12, -90, 0, 90, 0.25 );
        }
if  (model == MODEL_MANCAGE_2) 
        {
        setMaterial( MATERIAL_SILVER );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ, 70, 25, 12, -90, 0, 90, 0.25 );
        }

if  (model == MODEL_GRAVEYARD) 
        {
        setMaterial ( MATERIAL_SILVER );
        drawModel( model, model_handle[model], g_CameraX, g_CameraY, g_CameraZ, 100, 110, 17, -90, 0, -90, 0.04 );
        }

if  (model == MODEL_PLAYER) 
        {
        setMaterial( MATERIAL_SILVER );
        drawModel( model, model_handle[model], 0,0,0,//g_CameraX, g_CameraY, g_CameraZ, 
             0  ,  0, 0,
            -90, 0, -90, 
            0.25 );
        }

}


void renderScene(int pass)
{
  if (g_bLighting) {
    glEnable(GL_LIGHTING);
  }
  else {
    glDisable(GL_LIGHTING);
  }

if ( (draw_mirror_plane))// && (pass != 1) )
    {
    glClipPlane(GL_CLIP_PLANE0, eqn);
    glEnable(GL_CLIP_PLANE0);
    }
    
  // Draw ground
if  (draw_height_field)
    {
      glPushMatrix();
      glTranslatef( g_CameraX, 0, g_CameraY );//g_fHeight,0 );
          drawHeightField( g_CameraX/g_cellsize, g_CameraY/g_cellsize, g_cells, g_cells);//g_airplaneX,g_airplaneY, g_cells, g_cells );
      glPopMatrix();
    }


if ( (draw_mirror_plane) )//&& (pass != 1) )
    {
    glDisable(GL_CLIP_PLANE0);
    }

    //Draw all models
glDisable(GL_TEXTURE_2D);
for (int i=0; i<MODEL_N; i++)
    {
    if ( model_in_use[i])
        {
        glPushMatrix();
        setDiffuseMaterialColor(colorDarkBrown);
    
        if ( model_use_list[i] )
            {
            glCallList ( model_index[i] );
            }
        else
            {
            __drawModel( i );
            }//endif
        glPopMatrix();
        }//endif

    }//endfor


  //draw environment map
  
}


void display()
{
//drawDinosaur();

setDiffuseMaterialColor(colorWhite);
//glColor4fv(colorWhite);

  // Clear frame buffer and depth buffer
glEnable(GL_DEPTH_TEST);
  glClearColor( colorDarkGreen[0], colorDarkGreen[1], colorDarkGreen[2], colorDarkGreen[3] );
  
  if ((draw_mirror_plane) || (draw_mirror) )
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
        glEnable(GL_STENCIL_TEST);
    }
  else
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glDisable(GL_STENCIL_TEST);
    }
  
  
  // Setup camera and initialize modelview matrix stack
  setupCamera();
  glViewport(0, 0, g_Width, g_Height);
  

  
  
  if (draw_mirror_plane)
    {
    if (draw_fog)
                {
                __draw_fog();
                glEnable(GL_FOG);
                }
                else glDisable(GL_FOG);
                
    glClearStencil(0);
    //step 2 -- push the modelview matrix
    glPushMatrix();
    //step 3 -- mirror lies in the z=0 plane.
    // Thus we negate the Z coordinate
    glScalef( 1.0f, 1.0f, -1.0f );
    
    //step 4 -- no culling
//    glCullFace(GL_FRONT);
    //step 5
    // now drawing all the scene without care of objects behind it (there are no such!)

  // Set up the stationary light (after camera transform)
glEnable(GL_LIGHT1);
glDisable(GL_LIGHT0);
/*  g_lightPos2[0] = g_lightPos[0];
  g_lightPos2[1] = g_lightPos[1];
  g_lightPos2[2] = g_lightPos[2];
  g_lightPos2[3] = g_lightPos[3];
*/
  glLightfv(GL_LIGHT1, GL_POSITION, g_lightPos);
/*
if (day)
  glLightfv(GL_LIGHT1, GL_DIFFUSE, colorVeryLightGreen);//Green );//White );
else
  glLightfv(GL_LIGHT1, GL_DIFFUSE, colorLightGreen);//Green );//White );
*/
  glLightfv(GL_LIGHT1, GL_DIFFUSE, colorWhite );
  glLightfv(GL_LIGHT1, GL_AMBIENT, colorDarkGrey );
  glLightfv(GL_LIGHT1, GL_SPECULAR, colorWhite );


/*  //draw the Sun
  glPushMatrix();
  glTranslatef(g_lightPos2[0], g_lightPos2[1], g_lightPos2[2]);
  glutWireSphere(3, 20, 20);
  glPopMatrix();
*/


  // Render the scene
//glColor4f(1,1,1,1);


//glClipPlane(GL_CLIP_PLANE0, eqn);
//glEnable(GL_CLIP_PLANE0);

  g_CameraY = -g_CameraY;
//Disabling the fog looks a little bit unnatural, 
// but better then nothing
    
  renderScene(2);
  //glDisable(GL_FOG);
g_CameraY = -g_CameraY;
  
//glDisable(GL_CLIP_PLANE0);
    //step 6 -- no culling
//    glCullFace(GL_BACK);
    glPopMatrix();
    //step 7
    glColorMask(0, 0, 0, 0);
        glBegin(GL_TRIANGLES);
            glVertex3d(-5, -5, 0);
            glVertex3d(-5, 5, 0);
            glVertex3d(5,5,0);
            
            glVertex3d(5, 5, 0);
            glVertex3d(5, -5, 0);
            glVertex3d(-5, -5, 0);
        glEnd();
        
    glColorMask(1,1,1,1);

    //step 8 -- no unreflected objects, except framerate
    glDisable(GL_CULL_FACE);
    
//    glDisable(GL_STENCIL_TEST);
    }
    
//RENDERING THE SCENE
  if (draw_fog)
    {
    __draw_fog();
    glEnable( GL_FOG );
    }
  else glDisable(GL_FOG);

  // Set up the stationary light (after camera transform)
glEnable(GL_LIGHT0);
glDisable(GL_LIGHT1);
  glLightfv(GL_LIGHT0, GL_POSITION, g_lightPos);
/*
if (day)
  glLightfv(GL_LIGHT0, GL_DIFFUSE, colorVeryLightGreen);//Green );//White );
else 
  glLightfv(GL_LIGHT0, GL_DIFFUSE, colorLightGreen);
*/
  glLightfv(GL_LIGHT0, GL_DIFFUSE, colorWhite );
  
  glLightfv(GL_LIGHT0, GL_AMBIENT, colorDarkGrey );
  glLightfv(GL_LIGHT0, GL_SPECULAR, colorWhite );

//glColorMask(1,1,1,1);

  //draw the Sun
/*  glPushMatrix();
  glTranslatef(g_lightPos[0], g_lightPos[1], g_lightPos[2]);
  glutWireSphere(3, 20, 20);
  glPopMatrix();
  */
  // Render the scene
//if (draw_mirror_plane) glEnable(GL_CLIP_PLANE0);


  
  renderScene(1);
  
  
//if (draw_mirror_plane) glDisable(GL_CLIP_PLANE0);


  // Display framerate
glPushMatrix();
  if (g_bFrameRate) {
    char buf[200];
    sprintf( buf, "%0.2f fps,  X=%f, Y=%f, Z=%f, hf=%f, alpha=%f, beta=%f ", g_fFPS, g_CameraX, g_CameraY, g_CameraZ, 
        gethf( int(round(g_CameraX/g_cellsize)), int(round(g_CameraY/g_cellsize)) ),
        g_CameraAngleX, g_CameraAngleY );
    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 );
  }
glPopMatrix();

/*//displaySMoke
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslated( 5, 5, 5);
displaySmoke();
glPopMatrix();
*/
  // Make sure changes appear on screen
  glutSwapBuffers();
}


// Function which is called when the window size changes
void reshape(GLint width, GLint height)
{
  g_Width = width;
  g_Height = height;
}


// Function which is called once to initialize the GL
void initGL()
{
GLenum performance = GL_FASTEST; //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_COLOR_MATERIAL);
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LESS);
  glShadeModel(GL_SMOOTH);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
//  glEnable(GL_LIGHT1);
  glDisable( GL_CULL_FACE );
//  glCullFace( GL_BACK );
  glEnable( GL_NORMALIZE );


  // Fog from 0.6*visibility to visibility range
/*  if (draw_fog)
    {
    glFogi( GL_FOG_MODE, GL_LINEAR );
    glFogf( GL_FOG_START, g_visibility * 0.6f );
    glFogf( GL_FOG_END, g_visibility );
    glFogfv( GL_FOG_COLOR, colorSky );
    glEnable( GL_FOG );
    }
  else glDisable(GL_FOG);
  */
  
  // Initialize Textures
  initTextures();
  // Load the height field
    printf(" Loading the height field hf.raw_1024x1024_float...");
    std::string hffile = std::string(g_strHeightFieldFile);
  initHeightField(g_hfW, g_hfH, hffile.c_str());

  
  // Initialize Materials
  initMaterials();
  
  // init bastian's water
  initWater( 32, 32 );
  
  // Load all models
for (int i=0; i<MODEL_N; i++)
    {
    if ( model_in_use[i] )
        {
        model_handle[i] = addModel( model_path + model_name[i] + model_ext);
        if (model_handle[i] != -1)
                {
            printf(" Models: %s is added with handle %d. \n ", model_name[i].c_str(), model_handle[i]);
                }
        else
                {
            printf(" Models: %s is not added due to some errors. \n ", model_name[i].c_str() );
                continue;
                }
            
    
        // Try to use Lists for drawing the complex models
        model_index[i] = glGenLists(1);
        if ( model_index[i] != 0)
            {
            model_use_list[i] = true;
            glNewList ( model_index[i], GL_COMPILE );
                __drawModel( i );
            glEndList();    
            }
        else 
            {
            printf(" Can't create new display list for model %s. \n  Will use simple rendering. \n", model_name[i].c_str());
            model_use_list[i] = false;
            }//endif
        }//endif
    }//endfor


  // Initialize position of the camera
  g_CameraX = 27;
  g_CameraY = 80;
  g_CameraZ =  g_length  + gethf( int (round (g_CameraX/g_cellsize)), int (round (g_CameraY/g_cellsize)) );

//init smoke
//initSmoke();


}





/**********************************************
 **********************************************
   TIMER AND ANIMATION
 **********************************************
 *********************************************/

static void timerCallback(int)
{

//animate();
  // Get time in seconds after last call to the timer
  int nc = glutGet(GLUT_ELAPSED_TIME);
  float fSec = float(nc-g_nLastTime) / 1000.0f;
  // Compute average frame rate from the last twenty frames
  g_fFPS = (19.0f*g_fFPS + 1.0f / fSec) / 20.0f;
  g_nLastTime = nc;

  // Perform all animations
  // Camera movement at 1/2 rounds per second
/*  float fCamArc = fSec * 180.0f;
  if (g_bCameraUp && g_fCameraX < 90) g_fCameraX += fCamArc;
  if (g_bCameraDown && g_fCameraX > -90) g_fCameraX -= fCamArc;
  if (g_bCameraLeft) g_fCameraY += fCamArc;
  if (g_bCameraRight) g_fCameraY -= fCamArc;
*/
  float fCamArc = fSec * 180.0f / 1;
  if (g_CameraRotateUp && g_CameraAngleX > -90) g_CameraAngleX -= fCamArc;  
  if (g_CameraRotateDown && g_CameraAngleX < 90) g_CameraAngleX += fCamArc;  
  if (g_CameraRotateLeft) g_CameraAngleY -= fCamArc;  
  if (g_CameraRotateRight) g_CameraAngleY += fCamArc;  

    //water
    computeWater ( float(nc) / 1000.0f );


/*
  // Rotor movement
  g_fPropellerAngle += float(g_nPropellerRPS) * fSec * 360.0f/2.0f;
*/
/*
  // Plane rotation
  if (g_bRotateLeft) {
    g_fPlaneAngle += fSec * 360.0f / 5.0f;
    g_fRudderAngle = -60.0f;
  }
  else if (g_bRotateRight) {
    g_fPlaneAngle -= fSec * 360.0f / 5.0f;
    g_fRudderAngle = 60.0f;
  }
  else {
    g_fRudderAngle = 0.0f;
  }
*/

    //Movement
    if (go_Forward || go_Backward || go_Left || go_Right)
        {
        if (go_Right)
            {
            g_CameraY += g_cellsize * go_cells_per_step * fSec * cos (M_PI * (g_CameraAngleY - 90.0f) / 180.0f );
            g_CameraX -= g_cellsize * go_cells_per_step * fSec * sin (M_PI * (g_CameraAngleY - 90.0f) / 180.0f);
            }
        if (go_Left)
            {
            g_CameraY -= g_cellsize * go_cells_per_step * fSec * cos (M_PI * (g_CameraAngleY - 90.0f ) / 180.0f );
            g_CameraX += g_cellsize * go_cells_per_step * fSec * sin (M_PI * (g_CameraAngleY - 90.0f) / 180.0f);
            }
        if (go_Forward)
            {
            g_CameraY -= g_cellsize * go_cells_per_step * fSec * cos (M_PI * (g_CameraAngleY ) / 180.0f );
            g_CameraX += g_cellsize * go_cells_per_step * fSec * sin (M_PI * (g_CameraAngleY ) / 180.0f);
            }
        if (go_Backward)
            {
            g_CameraY += g_cellsize * go_cells_per_step * fSec * cos (M_PI * (g_CameraAngleY ) / 180.0f );
            g_CameraX -= g_cellsize * go_cells_per_step * fSec * sin (M_PI * (g_CameraAngleY ) / 180.0f);
            }
//          if (g_CameraY < 0) g_CameraY = 0;
            
            g_CameraZ = g_length + gethf( int(round (g_CameraX/g_cellsize)) , int(round (g_CameraY/g_cellsize)) );


//      g_airplaneX = g_CameraX;
//      g_airplaneY = g_CameraY;
        }
/*
  // Plane movement
  g_airplaneX += g_cellsize * g_nPropellerRPS * fSec * cos( M_PI * g_fPlaneAngle / 180.0f );
  g_airplaneY -= g_cellsize * g_nPropellerRPS * fSec * sin( M_PI * g_fPlaneAngle / 180.0f );
*/
  // Redraw and restart timer
  glutPostRedisplay();
  glutTimerFunc( g_nTimerDelay, timerCallback, 0);
}





/**********************************************
 **********************************************
   MENU AND KEYBOARD HANDLING
 **********************************************
 *********************************************/


// Just to illustrate how menus are used
// This callback is called when a menu item was selected
void selectFromMenu(int idCommand)
{
  switch (idCommand) {
  case MENU_LIGHTING:
    g_bLighting = !g_bLighting;
    break;
  case MENU_FRAMERATE:
    g_bFrameRate = !g_bFrameRate;
    break;
  case MENU_POLYMODE:
    g_bFillPolygons = !g_bFillPolygons;
    glPolygonMode (GL_FRONT_AND_BACK, g_bFillPolygons ? GL_FILL : GL_LINE);
    break;      
  case MENU_EXIT:
    printf( "Exiting.\n" );
    glutSetKeyRepeat( GLUT_KEY_REPEAT_ON );
    exit (0);
    break;
  }

  // Almost any menu selection requires a redraw
  glutPostRedisplay();
}


// Callback function called when a key was pressed
void keyboard(unsigned char key, int, int )
{
  switch (key) {
  case 27:             // ESCAPE key
    exit (0);
    break;
  case 32:
    //g_bChaseCam = !g_bChaseCam;
    break;
  case 'l':
    selectFromMenu(MENU_LIGHTING);
    break;
  case 'h':
    draw_height_field = !draw_height_field;
    break;
  case 'p':
    selectFromMenu(MENU_POLYMODE);
    break;
  case 'a':
  g_CameraRotateLeft = true;
  g_CameraRotateRight = false;
//    g_bRotateLeft = true;
    break;
  case 'd':
      g_CameraRotateRight = true;
      g_CameraRotateLeft = false;
//      g_bRotateRight = true;
        break;
  case 'x': 
        g_show_axis = !g_show_axis;
        break;
  case 's':
      g_CameraRotateDown = true;
      g_CameraRotateUp = false;
      break;
  case 'w':
      g_CameraRotateUp = true;
      g_CameraRotateDown = false;
      break;
  case 'm':
        draw_mirror_plane = !draw_mirror_plane;
        break;
  case 'q':
    printf(" Quit...\n");
     exit(0);
     break;
  case 'f':
    draw_fog = !draw_fog;
    break;
  case 'n':
    day = !day;
    
    if (day)
        {
        g_lightPos[0] = 30;
        g_lightPos[1] = 30;
        g_lightPos[2] = 30;
        }
    else
        {
        g_lightPos[0] = 30;
        g_lightPos[1] = -30;
        g_lightPos[2] = 30;
        }
    
    break;    

  }
}

void keyboardUp(unsigned char key, int,int)
{
  switch( key ) {
  case 'a':
    g_CameraRotateLeft = false;
//    g_bRotateLeft = false;
    break;
  case 'd':
    g_CameraRotateRight = false;
//    g_bRotateRight = false;
    break;
  case 's':
    g_CameraRotateDown = false;
    break;
  case 'w':
    g_CameraRotateUp = false;
    break;    
  }
}

void special( int key, int,int )
{
  switch( key ) {
  case GLUT_KEY_UP:
    go_Forward = true;
    go_Backward = false;
    break;
  case GLUT_KEY_DOWN:
    go_Forward = false;
    go_Backward = true;
    break;
  case GLUT_KEY_LEFT:
    go_Left = true;
    go_Right = false;
    break;
  case GLUT_KEY_RIGHT:
    go_Left = false;
    go_Right = true;
    break;
  }
}


void specialUp( int key, int,int )
{
  switch( key ) {
  case GLUT_KEY_UP:
    go_Forward = false;
    break;
  case GLUT_KEY_DOWN:
    go_Backward = false;
    break;
  case GLUT_KEY_LEFT:
    go_Left = false;
    break;
  case GLUT_KEY_RIGHT:
    go_Right = false;
    break;
  }
}





// This function initializes the popup menu
int buildPopupMenu()
{
  printf( "Keys:\n" );
  printf( "  l - Toggle lighting\n" );
  printf( "  p - Toggle polygon fill\n" );
  printf( "  f - Display frame rate\n" );
  printf( "  h - Toggle heigth field\n");
  printf( "  m - Draw mirror plane\n");
  printf( "  x - Show axes\n");
  printf( "  f - Draw fog \n");
  printf( "  n - Toggle day/night\n");
  printf( "  ESC,q - Exit demo\n" );


  int menu = glutCreateMenu (selectFromMenu);
  glutAddMenuEntry ("Toggle lighting\tl", MENU_LIGHTING);
  glutAddMenuEntry ("Toggle polygon fill\tp", MENU_POLYMODE);
  glutAddMenuEntry ("Display frame rate\tf", MENU_FRAMERATE);
  glutAddMenuEntry ("Exit demo\tEsc", MENU_EXIT);
  return menu;
}





/**********************************************
 **********************************************
   MAIN FUNCTION
 **********************************************
 *********************************************/

int main(int argc, char** argv)
{
  // GLUT Window Initialization:
  glutInit(&argc, argv);
  glutInitWindowSize(g_Width, g_Height);
  glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
  glutCreateWindow("CG-I GLUT example");

  glutSetKeyRepeat( GLUT_KEY_REPEAT_ON );
  glutIgnoreKeyRepeat(0);

  // Initialize OpenGL graphics state
  initGL();

  // Register callbacks:
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutKeyboardFunc(keyboard);
  glutKeyboardUpFunc(keyboardUp);
  glutSpecialFunc(special);
  glutSpecialUpFunc(specialUp);


  // Create popup menu
  buildPopupMenu();
  glutAttachMenu(GLUT_RIGHT_BUTTON);

  // Start display timer
  g_nLastTime = glutGet( GLUT_ELAPSED_TIME );
  glutTimerFunc( g_nTimerDelay, timerCallback, 0);

  // Turn the flow of control over to GLUT
  glutMainLoop();

deleteModels();

  return 0;
}

---