Previous Lecture Summary

OpenGL provides for a depth buffer to render images with hidden surfaces eliminated. The depth buffer is configurable, meaning not only can its use be optimized for hidden surface elimination, it can be used for additional operations as well.

The depth buffer contains a set of values, each of which relates to a pixel on the screen. Use of the depth buffer is enabled with glEnable(GL_DEPTH_TEST).

Points, lines, polygons, and characters are reduced during rendering to pixels, each with its own color and x and y coordinates. Also, when the depth buffer is enabled, a z coordinate is computed for each pixel. This coordinate effectively specifies the distance from pixel to eye.

Before a pixel's color is written to the framebuffer, its z value is compared with the value already stored in the depth buffer. If the incoming pixel is nearer (that is, if it has a lower z value), its color is written into the framebuffer and its z value is written into the depth buffer. If it is farther (that is, if it has a greater z value), the incoming color and z value are discarded. Thus, at any point in the drawing, the values in the depth buffer represent the distance to the item which currently is closest to the eye. By first clearing the depth buffer to the maximum depth value and then rendering all primitives using the depth buffer algorithm, an image including only the nearest surfaces to the eye is produced.

Mapping Transformed Z to Screen Z

Mathematically, z coordinates are treated just like x and y coordinates. After transformation, clipping, and perspective division, they occupy the range

-1.0 through 1.0, corresponding to the near and far clipping planes. Just as you specify a viewport transformation to map x and y from this range to a window's boundaries, so must you specify a mapping of z coordinates. The default mapping of 0,1 maps the near plane to 0 and the far plane to 1. With this mapping, the depth buffer range is fully utilized.

This mapping can be changed. glDepthRange(nearClip, farClip) specifies a linear mapping of the normalized z coordinates in this range to window z coordinates. For example, the call

     glDepthRange(0.0, 0.5);

will cause OpenGL to use only half of the depth buffer range. Regardless of the actual depth buffer implementation, window coordinate depth values are treated as though they range from 0.0 through 1.0 (like color components). Thus, the values accepted by glDepthRange are both clamped to this range before they are accepted.

Recall also that each depth buffer location must be initialized to its farthest value prior to rendering. Set the initialization value by calling glClearDepth(depth), then call glClear to clear the buffer to that value. On some systems, performance is increased if the depth buffer and the framebuffer are initialized at the same time. To accomplish this, pass both GL_COLOR_BUFFER_BIT and GL_DEPTH_BUFFER_BIT in the same glClear call.

    glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );

Depth Buffer Precision

It was previously asserted that a depth buffer value, in effect, specifies the distance from pixel to eye. While this is true, the relationship between distance and z is linear only in an orthographic projection. In the case of a perspective projection, the relationship is non-linear, sometimes very much so.

The degree of non-linearity is controlled by the ratio of far to near in the perspective call. The greater the ratio, the greater the non-linearity.

When the projection matrix is defined by

   gluPerspective(fovy, aspect, nearClip, farClip);

and the z viewport transformation is defined by

   glDepthRange(near
vp, farvp);

then z_eye and z_screen are related by the following equations:

In practice, non-linearity increases depth buffer precision in a small range adjacent to the near clipping plane and reduces precision throughout the rest of the viewing volume. While some precision increase near the viewer can be desirable, the effect of substantial non-linearity is to defeat depth buffer operation throughout much of the viewing volume. Experience shows that ratios greater than 1000 have this undesired result.

The ratio of far to near is most easily controlled by simply moving the near clipping plane away from the eye position. Note that changing near in the perspective call has no effect on the projection of x and y and so has little effect on the resulting image. Instead, its effect is limited to the position of the near clipping plane and the projection of Z values. Because of this, you should always move the near plane as far from the eye as possible.

Lecture Objectives

At the completion of this lecture, you will be able to

• Perform viewing transformations to look at different areas of the scene
  
  
• Program an alternative way of viewing a scene
  
  
• Use mouse input to control the view
  

Moving the Eye

• Default orientation of the eye
  
  
  • At the origin
    
    
  • Looking down the negative z axis
    
    
• Suppose you want to look somewhere else
  
  
  • You can use a viewing transformation to change the position and orientation of the viewpoint (eye)
    
    

  

Viewing Transformations

• Generally composed of rotations and translations
  
  
• Invoked before modeling transformations
  
  
• Several ways to accomplish a viewing transformation
  
  
  • Use glTranslatef() and/or glRotatef() directly
    
    
  • Use the gluLookAt() utility function
    
    
  • Combine several modeling transformations to create your own viewing matrix
    

Notes:

Modeling transformations take object coordinates to world coordinates; viewing transformations take world coordinates to eye coordinates; the projection transformation takes eye coordinates to normalized device coordinates (NDCs); and the viewport transformation takes NDCs to window coordinates.

Viewing transformations are simply a group of modeling transformations. They are typically done right after the first glPushMatrix in our drawScene to set up where our eye is located and where it is looking.

You have already seen an example of a viewing transformation. Earlier examples used glTranslatef(0.0, 0.0, -distance) to position the objects within our viewing volume. This is just a simple viewing transformation to position the eye so that it is no longer in the middle of the scene.

Lab: Viewing Transformation Exercise

1. Change directory to siggraph_2001_demos/bin.
   
   
2. Run ./projection, the projection tutorial program.
   
   
3. Determine the viewing transformation for each of these images
   
   
   • Modify only the parameters to gluLookAt
     
     
   • Do not change the parameters to gluPerspective
     
     

Using gluLookAt() to Look Elsewhere

GLvoid gluLookAt( GLdouble eyex, GLdouble eyey, 
GLdouble eyez, GLdouble centerx, GLdouble 
centery, GLdouble centerz, GLdouble upx, 
GLdouble upy, GLdouble upz )

• Creates a viewing matrix that allows you to look somewhere other than the origin of your scene
  
  

  

Notes:

The eye point (eye^x , eye^y, eye ^z) is specified in world coordinates.

The reference point (center^x, center ^y, center^z) indicates the center of the scene (where we want to look).

The vector (up^x, up ^y, up^z) defines which direction is up. The up vector must not be parallel to the line of sight from the eye to the reference point.

gluLookAt() Viewing Frustum

• The viewing frustum stays connected to the eye
  
  
• The line between the eye point and the reference point is called the line of sight
  
  
• The frustum is always aligned down the line of sight
  
  

  

Notes:

Often, programmers construct a scene around the origin or some other convenient location, then they want to look at it from an arbitrary point to get a good view of it. As its name suggests, the gluLookAt() utility routine is designed for just this purpose.

gluLookAt() and the Matrix Mode

gluLookAt() is really a set of modeling transformations grouped together

• Use glPushMatrix() when you want to save the created matrix
  
  
• Use on the ModelView stack

      glMatrixMode( GL_MODELVIEW )
      ...
      glPushMatrix();
           /* Position the eye on the +z axis,
           * look at ( xRef, yRef, zRef ),
           * and define +y to be `up' 
           */
           gluLookAt( 0.0, 0.0, 10.0, xRef, yRef, zRef, 
                      0.0, 1.0, 0.0 );
   
           glPushMatrix();
                /* modeling transformation */
                /* draw object */
           glPopMatrix();
           ...
      glPopMatrix();
  

Example: lookat.c

/* lookat.c - use input from the keyboard to control the viewpoint
 *
 *     F1 key          - print help information
 *     Left Arrow Key  - move the reference point to the left
 *     Right Arrow Key - move the reference point to the right
 *     Up Arrow Key    - move the reference point up
 *     Down Arrow Key  - move the reference point down
 *     Escape key      - exit the program
 */

#include <GL/glut.h>    /* includes gl.h, glu.h */

#include <math.h>
#include <stdio.h>     /* for printf */

/*  Function Prototypes  */

GLvoid  initgfx( GLvoid );
GLvoid  drawScene( GLvoid );
GLvoid  reshape( GLsizei, GLsizei );
GLvoid  keyboard( GLubyte, GLint, GLint );
GLvoid  specialkeys( GLint, GLint, GLint );

void printHelp( char * );

/* Global Definitions */

#define KEY_ESC     27      /* ascii value for the escape key */

/* Global Variables */

static GLdouble          xRef = 0.0, yRef = 0.0;

static char *progname;

GLvoid
main( int argc, char *argv[] )
{
    GLsizei width, height;

    glutInit( &argc, argv );

    width = glutGet( GLUT_SCREEN_WIDTH ); 
    height = glutGet( GLUT_SCREEN_HEIGHT );
    glutInitWindowPosition( 4, height / 4 );
    glutInitWindowSize( (width / 2) - 4, height / 2 );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
    glutCreateWindow( argv[0] );

    initgfx();

    glutKeyboardFunc( keyboard );
    glutSpecialFunc( specialkeys );
    glutReshapeFunc( reshape );
    glutDisplayFunc( drawScene ); 

    progname = argv[0];
    printHelp( progname );

    glutMainLoop();
}

void
printHelp( char *progname )
{
    fprintf(stdout, "\n%s - uses keyboard input to control the "
         "location of the reference point point\n\n"
         "F1 Key          - print Help information\n"
         "Left Arrow Key  - move reference point to the left\n"
         "Right Arrow Key - move reference point to the right\n"
         "Up Arrow Key    - move reference point up\n"
         "Down Arrow Key  - move reference point down\n"
         "Escape Key      - exit the program\n\n",
         progname);
}

GLvoid
initgfx( GLvoid )
{
    glClearColor( 0.0, 0.0, 0.0, 1.0 );
    glShadeModel( GL_FLAT );
    glEnable( GL_DEPTH_TEST );
}

GLvoid
reshape( GLsizei width, GLsizei height )
{
    GLdouble     aspect;

    glViewport( 0, 0, width, height );

    aspect = (GLdouble) width / (GLdouble) height;

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 45.0, aspect, 1.0, 20.0 );
    glMatrixMode( GL_MODELVIEW );
}

GLvoid 
keyboard( GLubyte key, GLint x, GLint y )
{
    switch (key) {
    case KEY_ESC:   /* Exit when the Escape key is pressed */
         exit(0);
    }
}

GLvoid 
specialkeys( GLint key, GLint x, GLint y )
{
    switch (key) {
    case GLUT_KEY_F1:    /* print Help */
         printHelp( progname );
         break;

    case GLUT_KEY_LEFT:     /* move reference point to the left */
         xRef -= 0.5;
         if (xRef < -4.0) xRef = -4.0;
         glutPostRedisplay();
         break;

    case GLUT_KEY_RIGHT:    /* move reference point to the right */
         xRef += 0.5;
         if (xRef > 4.0) xRef = 4.0;
         glutPostRedisplay();
         break;

    case GLUT_KEY_UP:    /* move reference point up */
         yRef += 0.5;
         if (yRef > 3.0) yRef = 3.0;
         glutPostRedisplay();
         break;

    case GLUT_KEY_DOWN:     /* move reference point down */
         yRef -= 0.5;
         if (yRef < -3.0) yRef = -3.0;
         glutPostRedisplay();
         break;
    }
}

GLvoid
drawScene( GLvoid )
{
    static GLfloat  upperArmColor[] = { 1.0, 0.0, 0.0 };
    static GLfloat  lowerArmColor[] = { 0.8, 0.5, 0.5 };

    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glPushMatrix();

         /* Move the reference point */
         gluLookAt( 0.0, 0.0, 8.0, xRef, yRef, 0.0, 0.0, 1.0, 0.0 );

         XYaxes();

         /* Draw the shoulder at the new origin */
         glTranslatef( 1.0, 0.0, 0.0 ); 
         glColor3fv( upperArmColor );
         WireBox( 2.0, 0.4, 1.0 );

         /* Draw the lower arm at the end of the upper arm and 
          * rotate it 45 degrees */
         glTranslatef( 1.0, 0.0, 0.0 );
         glRotatef( 45.0, 0.0, 0.0, 1.0 );
         glTranslatef( 1.0, 0.0, 0.0 );
         glColor3fv( lowerArmColor );
         WireBox( 2.0, 0.4, 1.0 );
    glPopMatrix();

    glutSwapBuffers();
}

Notes:

This program draws a simple scene and uses the arrow keys to change the location of the eye.

Note: This program calls gluLookAt() before drawing anything in drawScene(). It also uses glPushMatrix()/glPopMatrix() to save and restore the original identity matrix.

Other Ways to See

• gluLookAt() is very good for "moving around"
  
  
  • Virtual reality
    
    
  • Architectural design
    
    
  • Visual simulation
    
    
• Other disciplines might want to view the entire model from all angles
  
  
  • Scientific visualization
    
    
  • Molecular modeling
    
    
  • CAD/CAM
    

Notes:

The gluLookAt routine is particularly useful when you want to pan across a scene (for example, a landscape).

Polar View

View your model as if it were encased in a glass sphere centered around the origin

void polarView(GLfloat distance, GLfloat azimuth,
         GLfloat incidence, GLfloat twist)
{
    glTranslatef(0.0, 0.0, -distance);
    glRotatef(-twist, 0.0, 0.0, 1.0);
    glRotatef(-incidence, 1.0, 0.0, 0.0);
    glRotatef(-azimuth, 0.0, 0.0, 1.0);
}

Notes:

The polarView() function shown emulates the IRIS GL polarview() function.

• distance is the distance from the viewpoint to the world space origin
  
  
• azimuth is the azimuthal angle in the x, y plane measured from the y axis. The azimuth angle is the viewing angle of the observer.
  
  
• incidence is the angle of incidence in the y, z plane measured from the z axis. The incidence angle is the angle of the viewport relative to the z axis.
  
  
• twist is the amount that the viewpoint is to be rotated around the line of sight using the right-hand rule.

Figuring Out the Distance

1. Find the dimensions of your model (width, height, depth)
   
   
2. Compute the maximum amount of space that your model needs in any orientation
   
   
   • Add a little extra just to be safe
     
     
3. Size should be the separation between your near and far clipping planes
   
   
   • Remember, 0.0 < near < far
     
     
   • Make the separation bigger if your program provides the ability to zoom out from the scene
     
     
4. Set distance so that your objects will be half way between the near and far clipping planes
   

Notes:

This is one way to figure out how far away from your objects you want to be. Basically, you are just finding the size of the bounding box for your scene.

1. Find the dimensions of your model (width, height, depth).

   
   
   

2. Compute the maximum amount of space that your model needs in any orientation plus a little extra for good measure.

   
   
   

3. Set the separation between your near and far clipping planes to size.

   
   
   

4. Set distance so that your objects will be half way between the near and far clipping planes.
   

Example: polarView.c

/* polarView.c - show how to combine modeling transformations to 
 *          view objects as though they are encased in a glass ball
 *
 *     F1 key          - print help information
 *     Left Arrow Key  - increment the azimuth angle 
 *     Right Arrow Key - decrement the azimuth angle
 *     Up Arrow Key    - increment the incidence angle 
 *     Down Arrow Key  - decrement the incidence angle 
 *     t Key           - increment the twist angle
 *     T Key           - decrement the twist angle
 *     R Key           - reset viewpoint
 *     Escape key      - exit the program
 */

#include <GL/glut.h>    /* includes gl.h, glu.h */

#include <math.h>
#include <stdio.h>     /* for printf */

/*  Function Prototypes  */

GLvoid  initgfx( GLvoid );
GLvoid  drawScene( GLvoid );
GLvoid  reshape( GLsizei, GLsizei );
GLvoid  keyboard( GLubyte, GLint, GLint );
GLvoid  specialkeys( GLint, GLint, GLint );

void resetView( GLvoid );
void polarView( GLfloat, GLfloat, GLfloat, GLfloat);

void printHelp( char * );

/* Global Definitions */

#define KEY_ESC     27      /* ascii value for the escape key */

/* Global Variables */

static char *progname;

static GLfloat beamWidth = 2.0, beamHeight = 0.4, beamDepth = 1.0;
static GLfloat nearClip, farClip, distance, twistAngle, incAngle, azimAngle;

void
main( int argc, char *argv[] )
{
    GLsizei width, height;

    glutInit( &argc, argv );

    width = glutGet( GLUT_SCREEN_WIDTH ); 
    height = glutGet( GLUT_SCREEN_HEIGHT );
    glutInitWindowPosition( (width / 2) + 4, height / 4 );
    glutInitWindowSize( (width / 2) - 4, height / 2 );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
    glutCreateWindow( argv[0] );

    initgfx();

    glutKeyboardFunc( keyboard );
    glutSpecialFunc( specialkeys );
    glutReshapeFunc( reshape );
    glutDisplayFunc( drawScene ); 

    progname = argv[0];
    printHelp( argv[0] );

    glutMainLoop();
}

void
printHelp( char *progname )
{
    fprintf(stdout, "\n%s - combine modeling transformations to \n" 
        "view objects as though encased in a glass ball\n\n"
        "Axes: X - red, Y - green, Z - blue\n\n"
        "F1 Key             - print Help information\n"
        "Left Arrow Key     - increment the azimuth angle\n"
        "Right Arrow Key    - decrement the azimuth angle\n"
        "Up Arrow Key       - increment the incidence angle\n"
        "Down Arrow Key     - decrement the incidence angle\n"
        "<t> Key            - increment the twist angle\n"
        "<T> Key            - decrement the twist angle\n"
        "<R> Key            - reset viewpoint\n"
        "Escape Key         - exit the program\n\n",
        progname);
}

GLvoid
initgfx( GLvoid )
{
    GLfloat maxObjectSize;

    glClearColor( 0.0, 0.0, 0.0, 1.0 );
    glShadeModel( GL_FLAT );
    glEnable( GL_DEPTH_TEST );

    /* Maximum size of all the objects in your scene */
    maxObjectSize = sqrt( ((2*beamWidth) * (2*beamWidth)) +
                          ((2*beamHeight) * (2*beamHeight)) +
                          (beamDepth * beamDepth) );

    /* Set up nearClip and farClip so that                        */ 
    /*    ( farClip - nearClip ) > maxObjectSize,                 */
    /*    and determine the viewing distance (adjust for zooming) */
    nearClip = 1.0;
    farClip = nearClip + 8*maxObjectSize; 

    resetView();
}

GLvoid
reshape( GLsizei width, GLsizei height )
{
    GLdouble               aspect;

    glViewport( 0, 0, width, height );

    aspect = (GLdouble) width / (GLdouble) height;

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 45.0, aspect, nearClip, farClip );
    glMatrixMode( GL_MODELVIEW );
}

GLvoid 
keyboard( GLubyte key, GLint x, GLint y )
{
    switch (key) {
    case 'R':
         resetView();
         glutPostRedisplay();
         break;
    case 't':
         twistAngle = fmod( (twistAngle + 5.0), 360.0 );
         glutPostRedisplay();
         break;

    case 'T':
         twistAngle = fmod( (twistAngle - 5.0), 360.0 );
         glutPostRedisplay();
         break;
    case KEY_ESC:   /* Exit whenever the Escape key is pressed */
         exit(0);
    }
}

GLvoid 
specialkeys( GLint key, GLint x, GLint y )
{
    switch (key) {
    case GLUT_KEY_F1:    /* print Help */
         printHelp( progname );
         break;

    case GLUT_KEY_LEFT:
         azimAngle = fmod( (azimAngle + 5.0), 360.0 );
         glutPostRedisplay();
         break;

    case GLUT_KEY_RIGHT:
         azimAngle = fmod( (azimAngle - 5.0), 360.0 );
         glutPostRedisplay();
         break;

    case GLUT_KEY_UP:    
         incAngle = fmod( (incAngle + 5.0), 360.0 );
         glutPostRedisplay();
         break;

    case GLUT_KEY_DOWN:     
         incAngle = fmod( (incAngle - 5.0), 360.0 );
         glutPostRedisplay();
         break;
    }
}

void
resetView( GLvoid )
{
    distance = nearClip + (farClip - nearClip) / 2.0;
    twistAngle = 0.0;          /* rotation of viewing volume (camera) */
    incAngle = 0.0;
    azimAngle = 0.0;
}

void
polarView( GLfloat distance, GLfloat azimuth, GLfloat incidence,
              GLfloat twist)
{
    glTranslatef( 0.0, 0.0, -distance);
    glRotatef( -twist, 0.0, 0.0, 1.0);
    glRotatef( -incidence, 1.0, 0.0, 0.0);
    glRotatef( -azimuth, 0.0, 0.0, 1.0);
}

GLvoid
drawScene( GLvoid )
{
    static GLfloat       upperArmColor[] = { 1.0, 0.0, 0.0 };
    static GLfloat       lowerArmColor[] = { 0.8, 0.5, 0.5 };
    
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glPushMatrix();
         polarView( distance, azimAngle, incAngle, twistAngle );
         XYZaxes();

         /* Draw the shoulder centered at the new origin */
         glTranslatef( 1.0, 0.0, 0.0 ); 
         glColor3fv( upperArmColor );
         WireBox( beamWidth, beamHeight, beamDepth );

         /* Draw the lower arm at the end of the upper arm and 
          * rotate it 45 degrees */
         glTranslatef( 1.0, 0.0, 0.0 );
         glRotatef( 45.0, 0.0, 0.0, 1.0 );
         glTranslatef( 1.0, 0.0, 0.0 );
         glColor3fv( lowerArmColor );
         WireBox( beamWidth, beamHeight, beamDepth );
    glPopMatrix();

    glutSwapBuffers();
}

Notes:

This program is similar to lookat.c, but it uses the polarView function to set the location of the eye.

The left and right arrow keys control azimuth angle, and the up and down arrow keys control the incidence angle.

Note: The program calculates the size of the robot arm in initgfx() and uses this to determine where to put the far clipping plane.

As with gluLookAt(), polarView() is called before rendering anything, and glPushMatrix/glPopMatrix are used to save and restore the resulting viewing transformation.

Mouse Input

void glutMouseFunc( void (*func)(int button, int state, int x, int y) )

• Sets up a callback function to handle mouse button events
  
  
• func() is invoked whenever the user presses or releases a mouse button
  
  
  • button indicates which button has changed state: GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, or GLUT_RIGHT_BUTTON
    
    
  • state indicates the state of the button: GLUT_DOWN or GLUT_UP
    
    
  • x and y indicate the location of the mouse (in window coordinates) when the event occurred
    

Notes:

The mouse location is reported in window coordinates.

Mouse Motion

void glutMotionFunc( void (*func)(int x, int y) )

• Sets up a callback function to handle mouse motion events
  
  
• func() is invoked whenever the mouse is moved while one of the mouse buttons is pressed
  
  
  • x and y indicate the location of the mouse (in window coordinates) when the event occurred
    

Example: mouse.c

/* mouse.c - use the mouse to control the location of the viewpoint
 *
 *  Escape key         - exit the program 
 *  Left Mouse Button  - change incidence and azimuth angles
 *  Middle Mousebutton - change the twist angle based on
 *                       horizontal mouse movement
 *  Right Mousebutton  - zoom in and out based on vertical
 *                       mouse movement
 *  R Key              - reset viewpoint
 */

#include <GL/glut.h>    /* includes gl.h, glu.h */

#include <math.h>
#include <stdio.h>     /* for printf */

/*  Function Prototypes  */

GLvoid  initgfx( GLvoid );
GLvoid  drawScene( GLvoid );
GLvoid  reshape( GLsizei, GLsizei );
GLvoid  keyboard( GLubyte, GLint, GLint );
GLvoid  mouse( GLint, GLint, GLint, GLint );
GLvoid  motion( GLint, GLint );

void resetView( GLvoid );
void polarView( GLfloat, GLfloat, GLfloat, GLfloat);

void printHelp( char * );

/* Global Definitions */

#define KEY_ESC     27      /* ascii value for the escape key */

/* Global Variables */

enum                actions { MOVE_EYE, TWIST_EYE, ZOOM, MOVE_NONE };
static GLint        action;

static GLdouble     xStart = 0.0, yStart = 0.0;

static GLfloat beamWidth = 2.0, beamHeight = 0.4, beamDepth = 1.0;
static GLfloat nearClip, farClip, distance, twistAngle, incAngle, azimAngle;

void
main( int argc, char *argv[] )
{
    GLsizei width, height;

    glutInit( &argc, argv );

    width = glutGet( GLUT_SCREEN_WIDTH ); 
    height = glutGet( GLUT_SCREEN_HEIGHT );
    glutInitWindowPosition( (width / 2) + 4, height / 4 );
    glutInitWindowSize( (width / 2) - 4, height / 2 );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
    glutCreateWindow( argv[0] );

    initgfx();

    glutMouseFunc( mouse );
    glutMotionFunc( motion );
    glutKeyboardFunc( keyboard );
    glutReshapeFunc( reshape );
    glutDisplayFunc( drawScene ); 

    printHelp( argv[0] );

    glutMainLoop();
}

void
printHelp( char *progname )
{
    fprintf(stdout, "\n%s - use the mouse to control the viewpoint\n\n"
         "Axes: X - red, Y - green, Z - blue\n\n"
         "Left Mousebutton       - move eye position\n"
         "Middle Mousebutton     - change twist angle\n"
         "Right Mousebutton      - move up / down to zoom in / out\n"
         "<R> Key                - reset viewpoint\n"
         "Escape Key             - exit the program\n",
         progname);
}

GLvoid
initgfx( GLvoid )
{
    GLfloat maxObjectSize;

    glClearColor( 0.0, 0.0, 0.0, 1.0 );
    glShadeModel( GL_FLAT );
    glEnable( GL_DEPTH_TEST );

    /* Maximum size of all the objects in your scene */
    maxObjectSize = sqrt( ((2*beamWidth) * (2*beamWidth)) +
                          ((2*beamHeight) * (2*beamHeight)) +
                          (beamDepth * beamDepth) );

    /* Set up nearClip and farClip so that                  */ 
    /*    ( farClip - nearClip ) > maxObjectSize,           */
    /*    and determine the viewing distance (adjust for zooming) */
    nearClip = 1.0;
    farClip = nearClip + 8*maxObjectSize; 
    resetView();
}

GLvoid
reshape( GLsizei width, GLsizei height )
{
    GLdouble               aspect;

    glViewport( 0, 0, width, height );

    aspect = (GLdouble) width / (GLdouble) height;

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 45.0, aspect, nearClip, farClip );
    glMatrixMode( GL_MODELVIEW );
}

GLvoid 
keyboard( GLubyte key, GLint x, GLint y )
{
    switch (key) {
    case 'R':
         resetView();
         glutPostRedisplay();
         break;
    case KEY_ESC:   /* Exit whenever the Escape key is pressed */
         exit(0);
    }
}

GLvoid 
mouse( GLint button, GLint state, GLint x, GLint y )
{
    static GLint buttons_down = 0;

    if (state == GLUT_DOWN) { /* most recent button down wins */
         buttons_down++;
         switch (button) {
         case GLUT_LEFT_BUTTON:
              /* in case there are only two mouse 
               * buttons, shift-left is equivalent to the 
               * middle mouse button
               */
              if (glutGetModifiers() == GLUT_ACTIVE_SHIFT)
                  action = TWIST_EYE;
              else
                  action = MOVE_EYE;
              break;
         case GLUT_MIDDLE_BUTTON:
              action = TWIST_EYE;
              break;
         case GLUT_RIGHT_BUTTON:
              action = ZOOM;
              break;
         }

         /* Update the saved mouse position */
         xStart = x;
         yStart = y;
    } else {
         if (--buttons_down == 0)
              action = MOVE_NONE;      /* no more buttons down */
    }
}

GLvoid
motion( GLint x, GLint y )
{
    switch (action) {
    case MOVE_EYE:
         /* Adjust the eye position based on the mouse position */
         azimAngle += (GLdouble) (x - xStart);
         incAngle -= (GLdouble) (y - yStart);
         break;
    case TWIST_EYE:
         /* Adjust the eye twist based on the mouse position */
         twistAngle = fmod(twistAngle+(x - xStart), 360.0);
         break;
    case ZOOM:
         /* Adjust the eye distance based on the mouse position */
         distance -= (GLdouble) (y - yStart)/10.0;
         break;
    default:
         printf("unknown action %d\n", action);
    }
    
    /* Update the stored mouse position for later use */
    xStart = x;
    yStart = y;

    glutPostRedisplay();
}

void
resetView( GLvoid )
{
    distance = nearClip + (farClip - nearClip) / 2.0;
    twistAngle = 0.0;    /* rotation of viewing volume (camera) */
    incAngle = 0.0;
    azimAngle = 0.0;
}

void
polarView( GLfloat distance, GLfloat azimuth, GLfloat incidence,
              GLfloat twist)
{
    glTranslatef( 0.0, 0.0, -distance);
    glRotatef( -twist, 0.0, 0.0, 1.0);
    glRotatef( -incidence, 1.0, 0.0, 0.0);
    glRotatef( -azimuth, 0.0, 0.0, 1.0);
}

GLvoid
drawScene( GLvoid )
{
    static GLfloat       upperArmColor[] = { 1.0, 0.0, 0.0 };
    static GLfloat       lowerArmColor[] = { 0.8, 0.5, 0.5 };
    
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glPushMatrix();
         polarView( distance, azimAngle, incAngle, twistAngle );
         XYZaxes();

         /* Draw the shoulder centered at the new origin */
         glTranslatef( 1.0, 0.0, 0.0 ); 
         glColor3fv( upperArmColor );
         WireBox( beamWidth, beamHeight, beamDepth );

         /* Draw the lower arm at the end of the upper arm and 
          * rotate it 45 degrees */
         glTranslatef( 1.0, 0.0, 0.0 );
         glRotatef( 45.0, 0.0, 0.0, 1.0 );
         glTranslatef( 1.0, 0.0, 0.0 );
         glColor3fv( lowerArmColor );
         WireBox( beamWidth, beamHeight, beamDepth );
    glPopMatrix();

    glutSwapBuffers();
}

Notes:

This program is the same program as polarView.c, except that it uses the mouse buttons to control the location and orientation of the viewpoint.

The left button moves the eye position and the right button changes the zoom. With a three button mouse, the middle button changes the twist angle. With a two button mouse, the twist angle is changed by holding down the Shift key while pressing the left mouse button.

When any mouse button is pressed, mouse() records the current mouse location, and sets the action flag (MOVE_EYE, TWIST_EYE, ZOOM) which is used by the motion() callback. If the left button was pressed, mouse() calls glutGetModifiers(). If GLUT_ACTIVE_SHIFT is returned, the action flag is set to TWIST_EYE rather than MOVE_EYE.

When the user moves the mouse with any mouse button down, motion() is called. This callback checks whether the action flag is set. If so, it grabs the current location of the mouse and compares in against the last saved values. It then adjusts the view parameter specified by the action flag by the difference between the changes in the x and y positions.

When the mouse button is released, the mouse() callback sets the action flag to MOVE_NONE to indicate that the program should stop tracking the location of the mouse.

Lab: Viewing

1. Change directory to ../tutorial/exercises.
   
   
2. Modify your solar8.c program. Remember to save your viewing transformation.
   
   
3. Modify your solar8.c to change the viewing transformation based on mouse or keyboard input.
   
   
   • Change the incidence, azimuth, and/or twist angles based on mouse movement or the arrow keys.
     
     
   • Change the distance from the object based on mouse movement or the arrow keys.
     
     
   • Add a toggle to reset the view when the R key is pressed.
     
     
4. * Copy your animate.c program to viewing.c and add a viewing transformation. Remember to save your viewing transformation.
   
   
5. *Modify viewing.c to change the viewing transformation based on mouse or keyboard input.
   

Notes:

* Indicates an optional laboratory exercise.

Hint: The polarView transformation works well for the solar system program. You might want to set the initial value for the incidence angle to -30 degrees.

OpenGL C Quick Reference

void gluLookAt( GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, 
GLdouble centerX, GLdouble centerY, GLdouble centerZ, 
GLdouble upX, GLdouble upY, GLdouble upZ )

Creates a viewing matrix derived from an eye point, a reference point indicating the center of the scene, and an up vector. The matrix maps the reference point to the negative z axis and the eye point to the origin, so that, when a typical projection matrix is used, the center of the scene maps to the center of the viewport. Similarly, the direction described by the up vector projected onto the viewing plane is mapped to the positive y axis so that it points upward in the viewport.

void glutMouseFunc( void (*mouse)(int button, int state, 
int x, int y) )

Sets up a callback function to handle mouse button events.

void glutMotionFunc( void (*motion)(int x, int y) )

Sets up a callback function to handle mouse motion events.

mElite 06: How to become a pilot

Download the class camera.cpp and the relative header file camera.h. Using this class you can move the perspective camera as a hypothetical pilot drive a spaceship.
For compiling you need camera.cpp, camera.h, coriolis.h, eliteutils.h, and eliteutils.c in the same directory.

In this version there are new details:

• culling of back faces has been enabled (speed bar adjustment, i.e. QUADS)
• z buffering has been enabled
• using arrow keys you can change pitch and roll angles.
• changing speed cause your spaceship moves (in the animate function there is the camera advancing proportional to the elapsed time from the last rendering)
• the usage of "q" and "w" keys permit a controlled movement
• a sight is added using orthographic projection and the function drawSight defined in the new eliteutils.c and eliteutils.h
• the mapping between radar and 3D world is changed because camera moves in a different way, the movement is rotational and not translational any more. So, we can rotate our spaceship so much that the planet can be behind us: if the planet is in front of us in the radar it will be a green point otherwise it will be red.