sheet06.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 "torus.h"
#include "texture.h"
#include "math.h"
#include "heightfield.h"



// Example of the projective texturing technique. 
// The grass texture is being projected on the sphere and
//  two walls.

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

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

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

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


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

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


// Rotation
static bool g_bRotateLeft = false;
static bool g_bRotateRight = false;
static bool g_bRotateDown = false;
static bool g_bRotateUp = false;

// Camera movement
static bool g_bCameraUp = false;
static bool g_bCameraDown = false;
static bool g_bCameraLeft = false;
static bool g_bCameraRight = false;
static float g_fCameraX = 0;
static float g_fCameraY = 0;

// Current camera position
static float g_eyePoint[4];



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

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




// Just for your reference: This function computes eye position
// in world coordinates (not used after all)
// It has to be called after the complete camera transformation has been set up.
void computeCameraPosition( float *eyePoint )
{
  // Projected eye position:
  //   In the projection step (gluProject(), the eye position is mapped from (0,0,0) to
  //   (0,0, - (n*f) / (f-n)), where n and f are near and far plane.
  float eyeProject[4];
  eyeProject[0] = 0;
  eyeProject[1] = 0;
  eyeProject[2] = - (g_nearPlane * g_farPlane) / (g_farPlane - g_nearPlane);
  eyeProject[3] = 0;

  // Multiply projected eye position with inverse projection to get
  // eye point of the camera in world coordinates
  float modelviewT[16];
  glGetFloatv( GL_TRANSPOSE_MODELVIEW_MATRIX, modelviewT );
  float projectionT[16];
  glGetFloatv( GL_TRANSPOSE_PROJECTION_MATRIX, projectionT );

  // Compute inverse matrices
  float inverse_projection[16];
  float inverse_modelview[16];
  Invert<float> (projectionT, inverse_projection);
  Invert<float> (modelviewT, inverse_modelview);

  float eyeCamera[4];
  Multiply<float> (inverse_projection, eyeProject, eyeCamera );
  Multiply<float> (inverse_modelview,  eyeCamera, eyePoint );
}



// This function transforms the (light source) positions into eye coordinates,
// to be called right after setup of camera transformation modelview
void computeLightPosition( const float *lightPosWorld, float *lightPosEye )
{
  // Now that the camera transformation is set up, the current modelview
  // matrix transforms world coordinates to eye coordinates, and is
  // the correct transformation matrix for the light sources
  float projection[16];
  glGetFloatv( GL_TRANSPOSE_MODELVIEW_MATRIX, projection );
  Multiply<float> (projection, lightPosWorld, lightPosEye );
}



/**********************************************
 **********************************************
   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);

  // Initializa modelview
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

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

  // Free camera mode
  glRotatef( g_fCameraX, 1,0,0 );
  glRotatef( g_fCameraY, 0,1,0 );

  // Compute the position of the light source in eye coordinates
  computeLightPosition( g_lightPos, g_lightPosEye );
}



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

  // Draw torus
  glPushMatrix();
//  glRotatef( g_fTorusX, 0,1,0 );
//  glRotatef( g_fTorusY, 1,0,0 );
  drawTorus( g_eyePoint );
  glPopMatrix();



  // Draw ground
  glPushMatrix();
  glTranslatef( 0,-5,0 );
  glRotatef( -90, 1,0,0 );
  drawHeightField( 0,0, (int)g_farPlane, (int)g_farPlane );
  glPopMatrix();
}


void display()
{
  // Clear frame buffer and depth buffer
  glClearColor( colorSky[0], colorSky[1], colorSky[2], colorSky[3] );
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
  // Setup camera and initialize modelview matrix stack
  setupCamera();
glGetFloatv(GL_MODELVIEW_MATRIX, ModelViewMatrix);
  
  glViewport(0, 0, g_Width, g_Height);
  
  // Set up the stationary light (after camera transform)
  glLightfv(GL_LIGHT0, GL_POSITION, g_lightPos);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, colorWhite );
  glLightfv(GL_LIGHT0, GL_AMBIENT, colorDarkGrey );
  glLightfv(GL_LIGHT0, GL_SPECULAR, colorWhite );
  
  // Fog from 0.6*visibility to visibility range
  glFogi( GL_FOG_MODE, GL_LINEAR );
  glFogf( GL_FOG_START, g_farPlane * 0.6f );
  glFogf( GL_FOG_END, g_farPlane );
  glFogfv( GL_FOG_COLOR, colorSky );
  glEnable( GL_FOG );

  // Render the scene
  renderScene();


  // Display framerate
  if (g_bFrameRate) {
    char buf[100];
    sprintf( buf, "%0.2f fps", g_fFPS );
    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 );
  }

  // Make sure changes appear onscreen
  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()
{
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LESS);
  glShadeModel(GL_SMOOTH);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable( GL_CULL_FACE );
  glCullFace( GL_BACK );
  glEnable( GL_NORMALIZE );

  // Init Cg
  initTorus();
  // Load the textures
  initTextures();

  // Load the height field
  printf( "Loading height field %s, size %i x %i ... ",
          g_strHeightFieldFile, g_hfW, g_hfH );
  initHeightField();
  printf( "success.\n" );
}





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

static void timerCallback(int)
{
  // 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;
*/
  // Plane rotation
  if (g_bRotateLeft) {
    g_fTorusX += fSec * 360.0f / 5.0f;
  }
  else if (g_bRotateRight) {
    g_fTorusX -= fSec * 360.0f / 5.0f;
  }
  if (g_bRotateUp) {
    g_fTorusY += fSec * 360.0f / 5.0f;
  }
  else if (g_bRotateDown) {
    g_fTorusY -= fSec * 360.0f / 5.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();
}


float sExpFunc( int n )
{
  return float(n*n) / 2.0f + 0.01f;
}


// 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 'l':
    selectFromMenu(MENU_LIGHTING);
    break;
  case 'f':
    selectFromMenu(MENU_FRAMERATE);
    break;
  case 'p':
    selectFromMenu(MENU_POLYMODE);
    break;
  case '1':
    g_specularExponent = sExpFunc( 1 );
    break;
  case '2':
    g_specularExponent = sExpFunc( 2 );
    break;
  case '3':
    g_specularExponent = sExpFunc( 3 );
    break;
  case '4':
    g_specularExponent = sExpFunc( 4 );
    break;
  case '5':
    g_specularExponent = sExpFunc( 5 );
    break;
  case '6':
    g_specularExponent = sExpFunc( 6 );
    break;
  case '7':
    g_specularExponent = sExpFunc( 7 );
    break;
  case '8':
    g_specularExponent = sExpFunc( 8 );
    break;
  case '9':
    g_specularExponent = sExpFunc( 9 );
    break;
  case '0':
    g_specularExponent = sExpFunc( 0 );
    break;
  case 'a':
    g_bRotateLeft = true;
    break;
  case 'd':
    g_bRotateRight = true;
    break;
  case 's':
    g_bRotateUp = true;
    break;
  case 'w':
    g_bRotateDown = true;
    break;
  }
}

void keyboardUp(unsigned char key, int,int)
{
  switch( key ) {
  case 'a':
    g_bRotateLeft = false;
    break;
  case 'd':
    g_bRotateRight = false;
    break;
  case 's':
    g_bRotateUp = false;
    break;
  case 'w':
    g_bRotateDown = false;
    break;
  }
}

void special( int key, int,int )
{
  switch( key ) {
  case GLUT_KEY_F1:
    g_bPerPixelLighting = true;
    break;
  case GLUT_KEY_F2:
    g_bPerPixelLighting = false;
    break;
  case GLUT_KEY_F3:
    g_bBlinnPhong = true;
    break;
  case GLUT_KEY_F4:
    g_bBlinnPhong = false;
    break;
  case GLUT_KEY_UP:
    g_bCameraUp = true;
    break;
  case GLUT_KEY_DOWN:
    g_bCameraDown = true;
    break;
  case GLUT_KEY_LEFT:
    g_bCameraLeft = true;
    break;
  case GLUT_KEY_RIGHT:
    g_bCameraRight = true;
    break;
  }
}


void specialUp( int key, int,int )
{
  switch( key ) {
  case GLUT_KEY_UP:
    g_bCameraUp = false;
    break;
  case GLUT_KEY_DOWN:
    g_bCameraDown = false;
    break;
  case GLUT_KEY_LEFT:
    g_bCameraLeft = false;
    break;
  case GLUT_KEY_RIGHT:
    g_bCameraRight = false;
    break;
  }
}





// This function initializes the popup menu
int buildPopupMenu()
{
  printf( "Keys:\n" );

//  printf( "  F1 - Per Pixel Lighting ON\n" );
//  printf( "  F2 - Per Pixel Lighting OFF\n" );

//  printf( "  F3 - Specular Term ON\n" );
//  printf( "  F4 - Specular Tern OFF\n\n" );

//  printf( "  0-9 - Set specular exponent to n^2/4\n\n" );

//  printf( "  Cursor keys - rotate camera\n" );
//  printf( "  A,S,D,W     - rotate Torus\n\n" );

  printf( "  p - Toggle polygon fill\n" );
  printf( "  f   - Display frame rate\n" );
  printf( "  ESC - Exit demo\n" );


  int menu = glutCreateMenu (selectFromMenu);
  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();
  return 0;
}

---