CS 371 Computer Graphics Spring 2005

Goals Animation via the Idle Callback Function OpenGL Window Interaction Callback Functions Using the Mouse (easy version) Creating a Menu Adding Keyboard Input A More Interesting Example

Lecture 18: More OpenGL

Goals

• Simple animation
• More on GLUT window interaction functions

Animation via the Idle Callback Function

• In order to allow for animation, GLUT provides an "idle" callback mechanism.
• On each pass through glutMainLoop(), if there are no outstanding events, the idle callback (if defined) will be invoked once.
• Normally, you design this function to change the state of your scene, and then ask GLUT to redisplay it by invoking glutPostRedisplay(), which creates a "display" event, which is handled by glutMainLoop().
• It is tempting to render from inside the idle function: DON'T!
• To create a smoother animation, we use double buffering: all rendering is performed on an offscreen buffer, which is then "swapped" onto the screen.
• The program animiate3D animates the sphere of basic3D. Here are the relevant changes to basic3D

  Extra constanst and variables:
  
  // current angle and change in angle
  static const double deltaAngle = 1.0;
  double angle = 0.0;
  
  // The GLUT window idle callback function
  void idle(void) {
    // increment current angle
    angle+=deltaAngle;
    // and reset if too large
    if(angle >= 360.00)
      angle = 0.0;
    // force a redraw!
    glutPostRedisplay();
  }
  
  // At the end of display callback, swap buffers instead of flushing
  void display(void) {
    // We will do a local transform to the sphere
    // First, make sure we have the correct matrix stack
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix(); // Now duplicate top of stack
    // add a rotation to the modelview matrix
    glRotated(angle,0.0,0.0,1.0); // Then rotate around z-axis
    // Erase window, then redraw teapot
    glClear(GL_COLOR_BUFFER_BIT);
    // Draw a sphere of radius .5, with 10 longitude lines and 15 latitude lines
    glutWireSphere(0.5,10,15);
    glPopMatrix(); // first get rid of local transform
    glutSwapBuffers();  // swap buffer to screen; no glFlush() necessary
  }
  
  // At the end of initWindowInfo, register the idle callback
  void initWindowInfo(void) {
    ...
    glutIdleFunc(idle);
  }
  
  // in main, request double buffering
  int main(int argc, char** argv) {
    glutInit(&argc, argv);
  
    // use double-buffering for smoother animation
    glutInitDisplayMode(GLUT_DOUBLE);
    glutInitWindowSize(VIEWPORTWIDTH, VIEWPORTHEIGHT);
    glutInitWindowPosition(CORNER_X, CORNER_Y);
    ...
  }
  

OpenGL Window Interaction Callback Functions

• How can we use the mouse, keyboard and menus in our program?
• GLUT provides facility to define callback functions to handle these events.
• Just as the user-defined reshape method required parameters (int x, int y), these callbacks each require their own parameter list.
• Note: you can give your callbacks any names you want, I chose obvious ones.
  • The mouse callback: mouse(int button, int state, int x, int y). Here button is one of GLUT_LEFT_BUTTON (or MIDDLE or RIGHT) and state is one of GLUT_UP (or DOWN); x and y are the mouse location in "GLUT" coordinates (upper left corner of window is (0,0)).
  • The keyboard callback: keyboard(unsigned char c, int x, int y). Here c is the character typed and (x,y) are the mouse position.
  • Menu construction differs from the above.
    • There is a menu callback function menu(int choice), where choice is an integer label associated with the menu item.
    • The menu is created (and its callback function registered) via glutCreateMenu(menu_callback_func)
    • Entries are added to the menu via glutAddMenuEntry(char *itemName, int value) where itemName is a string naming the item, and value is the quantity passed to the menu callback function.
    • Finally, the menu must be associated with a mouse button, via glutAttachMenu(int button).
• We illustrate these callbacks in the examples below.

Using the Mouse (easy version)

• Here we merely test if button is pressed, we do not use the location.
• Program mouse3D uses mouse clicks to pause and resume the animation in animate3D. Here are the relevant differences:

  // Variables
  // Animation state
  bool isAnimated = true;
  
  // The GLUT window mouse callback function
  void mouse(int button, int state, int x, int y) {
    // am I pressing the left mouse button
    if(state == GLUT_DOWN && button == GLUT_LEFT_BUTTON) {
      if (isAnimated)
        glutIdleFunc(NULL);  // turn off animation
      else
        glutIdleFunc(idle);  // turn on animation
      isAnimated=!isAnimated;// change state
    }
  }
  
  // Don't forget to register mouse callback
  void initWindowInfo(void) {
    ...
    glutMouseFunc(mouse);
  }
  

Creating a Menu

• The program menu3D creates a menu attached to the middle mouse button which controls the speed of the animation by adjusting the angle change.

  // Constants and variables...
  // Menu item constants
  enum {SLOW_ITEM, MEDIUM_ITEM, FAST_ITEM, QUIT_ITEM};
  
  // Menu callback: choice is value of the chosen menu entry
  void menu(int choice) {
    switch(choice) {
    case SLOW_ITEM:
      deltaAngle=.5;
      break;
    case MEDIUM_ITEM:
      deltaAngle=1;
      break;
    case FAST_ITEM:
      deltaAngle=2;
      break;
    case QUIT_ITEM:
      exit(0);
      break;
    default:
      break;
    }
  }
  
  // Create the menu, add the items, and attach to the mouse button
  void initWindowInfo(void) {
    ... //other initWindow code
    ...
    // create menu
    glutCreateMenu(menu); // simultaneously registers callback
    // add entries: 2nd parameter is value returned when entry is selected
    glutAddMenuEntry("Slow",SLOW_ITEM);
    glutAddMenuEntry("Medium",MEDIUM_ITEM);
    glutAddMenuEntry("Fast",FAST_ITEM);
    glutAddMenuEntry("Quit",QUIT_ITEM);
  
    // attach button to menu: overrides mouse callback for MIDDLE button
    glutAttachMenu(GLUT_MIDDLE_BUTTON);
  }
  

Adding Keyboard Input

• Program keyboard3D allows the user to toggle between two shapes by pressing the 's' key.

  // state variables
  bool isSphere = true;
  
  // The GLUT window keyboard callback function
  void keyboard(unsigned char key, int x, int y) {
    // we don't care where the mouse is, so ignore x & y
    // Use 's' for toggling shape
    if(key == 's')
      isSphere = !isSphere;
  }
  
  // The display method checks ``isSphere''
  void display(void) {
    // We will do a local transform to the sphere
    // First, make sure we have the correct matrix stack
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix(); // Now duplicate top of stack
    // add a rotation to the modelview matrix
    glRotated(angle,0.0,0.0,1.0); // Then rotate around z-axis
    // Erase window, then redraw teapot
    glClear(GL_COLOR_BUFFER_BIT);
    // Draw current state
    if(isSphere)
      // sphere of radius .5, with 10 longitude lines and 15 latitude lines
      glutWireSphere(0.5,10,15);
    else
      // torus of radii .25 and .5, with 10 longitude and 15 latitude lines
      glutWireTorus(0.25,0.5,10,15);
    glPopMatrix(); // first get rid of local transform
    glutSwapBuffers();  // swap buffer to screen; no glFlush() necessary
  }
  
  // Don't forget to register keyboard callback
  void initWindowInfo(void) {
    ...
    glutKeyboardFunc(keyboard);
  }
  

A More Interesting Example

• The program planet makes more use of transforms and allows the camera limited movement (along its line of sight).
• The planet spins around its own axis (as does the sun) and it orbits the sun (but unrealistically, since I cheat by using a rotation matrix to simulate the orbit!).

  // current angle and change in angle (used for all revolutions)
  double deltaAngle = 1.0;
  double angle = 0.0;
  
  // state variables
  bool isAnimated = true;
  
  // celestial body info
  double sunRadius = 0.5;
  double planetRadius = 0.1;
  double distanceToSun = 2.0;
  Point3Dd sunAxis(1,3,1);
  Point3Dd planetAxis(1,1,1);
  // OpenGL wants its transforms as 1-D arrays in COLUMN-MAJOR order
  double* sunTrans;
  double* planetTrans;
  
  // A transform that rotates vector (0,0,1) to vector dir about (0,0,1) x dir
  Transform4Dd rotateToAxis(const Point3Dd& dir) {
    Point3Dd axis = dir;
    axis.normalize();
    Point3Dd zAxis(0,0,1);
    Point3Dd cross = zAxis.cross(axis);
    cross.normalize();
    return MakeRotation(acos(zAxis.dot(axis)),cross);
  }
  
  // set up sun and planet transforms and convert to openGL format
  // Note: GetArray returns matrices in COLUMN-MAJOR order
  void initUniverse() {
    sunTrans= GetArray(rotateToAxis(sunAxis));
    // note order of multiplication!
    planetTrans = GetArray(MakeTranslation(0,0,distanceToSun)*
  			 rotateToAxis(planetAxis));
  }
  
  // The GLUT window keyboard callback function
  void keyboard(unsigned char key, int x, int y) {
    // we don't care where the mouse is, so ignore x & y
    Point3Dd dir = eye - lookAt;
    dir.normalize();
    switch(key) {
    case 'o' : // zoom out
      eye+=dir;
      lookAt+=dir;
      break;
    case 'i' : // zoom in
      eye-=dir;
      lookAt-=dir;
      break;
    }
    // Reset the camera here, since we never adjust the camera
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(eye.x, eye.y, eye.z,
  	    lookAt.x, lookAt.y, lookAt.z,
  	    up.x, up.y, up.z);
  }
  
  // The GLUT window display callback function
  // Note: transforms that change over time are computed here
  void display(void) {
    // We will do a local transform to the sphere
    // First, make sure we have the correct matrix stack
    glMatrixMode(GL_MODELVIEW);
    // Erase window
    glClear(GL_COLOR_BUFFER_BIT);
    glPushMatrix(); // Now duplicate top of stack
    // Sun's location affects planet
    glTranslated(sunLocation.x, sunLocation.y, sunLocation.z);
    glPushMatrix(); // but it's orientation and spin don't affect planet
    glMultMatrixd(sunTrans);
    glRotated(angle,0,0,1); // done here since angle keeps changing
    glutWireSphere(sunRadius,10,15);
    glPopMatrix(); // remove sun's spin and orientation
    // now add planet's transform
    glPushMatrix();
    glRotated(angle,orbitAxis.x,orbitAxis.y,orbitAxis.z); // orbit planet around sun
    glMultMatrixd(planetTrans);
    glRotated(angle,0,0,1); // done here since angle keeps changing
    glutWireSphere(planetRadius,10,15);
    glPopMatrix(); // first get rid of planet transform
    glPopMatrix(); // now get rid of sun's location
    glutSwapBuffers();  // swap buffer to screen; no glFlush() necessary
  }
  
  

• Note how the transform for the planet uses the transform for the sun. This keeps the planet in the sun's coordinate system.