• What is GLUT?
  • A simple, cross-platform windowing system that can be used with OpenGL
• Cross-Platform Alternatives:
  • CPW
  • NGL
  • OpenML
  • Simple Direct Media Layer (SDL)

• Initialization:
  • Initialize GLUT
  • Set the display mode
  • Set the window position and size
  • Create the window
  • Register the display callback function
  • Display the window and start event processing
• The Display Callback:
  • Any void function with no parameters
  • Set by calling glutDisplayFunc(void (*f)(void))
  • Called whenever the window needs to be displayed
  • You can force a call by calling glutPostRedisplay()

Initialization

openglexamples/glut/window.c (Fragment: main)

        /**
 * The entry point of the application.
 *
 * This function contains calls to GLUT.
 *
 * @param argc  The number of command line arguments
 * @param argv  The array of command line arguments
 * @return      A status code
 */
int main(int argc, char** argv) {
  // Initialize GLUT
  glutInit(&argc, argv);

  // Set the display mode.  In this case, tell GLUT to
  // use single buffering and an RGB color model
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

  // Set the size of the window (in pixels)
  glutInitWindowSize(640, 480);

  // Set the position of the window (in screen coordinates)
  glutInitWindowPosition(0, 0);

  // Create a window with the given title
  glutCreateWindow("A GLUT Window");

  // Register the display callback function
  glutDisplayFunc(display);


  // Display window and start event processing
  glutMainLoop();

  return 0;
}
        

A Display Callback

openglexamples/glut/window.c (Fragment: displaycallback)

        /**
 * The display callback (i.e., the function that is called
 * each time the window needs to be displayed).
 *
 * This function would normally contain calls to OpenGL.  
 */
void display() {
  printf("+display()\n");

  // Calls to OpenGL go here

  printf("-display()\n");
}
        

• Parameters:
  • The new width and height of the window
• Registration:
  • glutReshapeFunc(void (*f) (int width, int height))

A Reshape Callback

openglexamples/glut/window.c (Fragment: reshapecallback)

        /**
 * The reshape callback (i.e., the function that is called
 * each time the window is re-sized).
 *
 * @param width   The new width
 * @param height  The new height
 */
void reshape(int width, int height) {
  printf("+reshape(%d,%d)\n", width, height);

  // Appropriate code goes here

  printf("+reshape(%d,%d)\n", width, height);
}
        

Registration [e.g., in main()]

openglexamples/glut/window.c (Fragment: register-reshape)

          // Register the reshape callback
  glutReshapeFunc(reshape);
        

• Parameters:
  • The key that was pressed
  • The location of the mouse when the key was pressed
• Registration:
  • glutKeyboardFunc(void (*f)(unsigned char key, int x, int y))
• Modifiers:
  • Call int glutGetModifiers()
  • Bit flags can be checked with GLUT_ACTIVE_SHIFT, GLUT_ACTIVE_CTRL, and GLUT_ACTIVE_ALT

• Parameters:
  • The key that was pressed
  • The location of the mouse when the key was pressed
• Registration:
  • glutSpecialFunc(void (*f)(int key, int x, int y))
• Key Definitions:
  • GLUT_KEY_F1 thru GLUT_KEY_F12, GLUT_KEY_LEFT, GLUT_KEY_RIGHT, GLUT_KEY_UP, GLUT_KEY_DOWN, GLUT_KEY_PAGE_UP, GLUT_KEY_PAGE_DOWN, GLUT_KEY_HOME, GLUT_KEY_END, and GLUT_KEY_INSERT

A Keyboard Callback

openglexamples/glut/keyboard.c (Fragment: keyboardcallback)

        /**
 * The keyboard callback  (i.e., the function that is called
 * each time a "normal" key is pressed).
 *
 * @param key   The ASCII code of the key that was pressed
 * @param x     The x-position of the mouse when the key was pressed
 * @param y     The y-position of the mouse when the key was pressed
 */
void keyPressed(unsigned char key, int x, int y) {
  int alt, ctrl, modifiers, shift;

  printf("+keyPressed(%d,%d,%d)\n", key, x, y);

  modifiers = glutGetModifiers();
  alt = modifiers & GLUT_ACTIVE_ALT;
  ctrl = modifiers & GLUT_ACTIVE_CTRL;
  shift = modifiers & GLUT_ACTIVE_SHIFT;
  printf("            %d %d %d \n", alt, ctrl, shift);

  // Appropriate code goes here

  printf("-keyPressed(%d,%d,%d)\n", key, x, y);
}
        

A Special Key Callback

openglexamples/glut/keyboard.c (Fragment: specialcallback)

        /**
 * The special-key callback  (i.e., the function that is called
 * each time a "special" key is pressed).
 *
 * @param key   The key that was pressed (e.g., GLUT_KEY_UP)
 * @param x     The x-position of the mouse when the key was pressed
 * @param y     The y-position of the mouse when the key was pressed
 */
void specialKeyPressed(int key, int x, int y) {
  int alt, ctrl, modifiers, shift;

  printf("+specialKeyPressed(%d,%d,%d)\n", key, x, y);

  modifiers = glutGetModifiers();
  alt = modifiers & GLUT_ACTIVE_ALT;
  ctrl = modifiers & GLUT_ACTIVE_CTRL;
  shift = modifiers & GLUT_ACTIVE_SHIFT;
  printf("            %d %d %d \n", alt, ctrl, shift);

  // Appropriate code goes here

  printf("-specialKeyPressed(%d,%d,%d)\n", key, x, y);
}
        

Registration [e.g., in main()]

openglexamples/glut/keyboard.c (Fragment: register-keyboard)

          // Register the keyboard callbacks
  glutKeyboardFunc(keyPressed);
  glutSpecialFunc(specialKeyPressed);
        

• Button Presses/Releases:
  • Register with glutMouseFunc(void (*f)(int button, int state, int x, int y))
  • button is either GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, or GLUT_RIGHT_BUTTON
  • state is either GLUT_UP or GLUT_DOWN
• Motion Events:
  • Register with glutPassiveMotionFunc(void (*f)(int x, int y))
  • Also called when the mouse is pressed/released
• Drag Events:
  • Register with glutMotionFunc(void (*f)(int x, int y))

Callbacks

openglexamples/glut/mouse.c (Fragment: mousecallbacks)

        /**
 * The mouse callback (i.e., the function that is called
 * each time a mouse button is pressed or released).
 *
 * @param button The button (e.g., GLUT_LEFT_BUTTON)
 * @param state  The state (e.g., GLUT_UP or GLUT_DOWN)
 * @param x      The x-position of the mouse
 * @param y      The y-position of the mouse
 */
void mouseClicked(int button, int state, int x, int y) {
  printf("+mouseClicked(%d,%d,%d,%d)\n", button, state, x, y);

  // Appropriate code goes here

  printf("-mouseClicked(%d,%d,%d,%d)\n", button, state, x, y);
}

/**
 * The motion callback (i.e., the function that is called
 * each time the mouse is dragged).
 *
 * @param x      The x-position of the mouse
 * @param y      The y-position of the mouse
 */
void mouseDragged(int x, int y) {
  printf("+mouseDragged(%d,%d)\n", x, y);

  // Appropriate code goes here

  printf("-mouseDragged(%d,%d)\n", x, y);
}

/**
 * The passive-motion callback (i.e., the function that is called
 * each time the mouse is moved).
 *
 * @param x      The x-position of the mouse
 * @param y      The y-position of the mouse
 */
void mouseMoved(int x, int y) {
  printf("+mouseMoved(%d,%d)\n", x, y);

  // Appropriate code goes here

  printf("-mouseMoved(%d,%d)\n", x, y);
}

        

Registration [e.g., in main()]

openglexamples/glut/mouse.c (Fragment: register-mouse)

          // Register the mouse callbacks
  glutMouseFunc(mouseClicked);
  glutPassiveMotionFunc(mouseMoved);
  glutMotionFunc(mouseDragged);
        

• Uses:
  • "Background" processing
• Registration:
  • glutIdleFunc(void (*f) (void))

• Purpose:
  • Divide a window into regions, each with its own callbacks (and OpenGL context)
• Creation/Destruction:
  • int glutCreateSubWindow(int parentWindow, int x, int y, int width, int height)
  • int glutDestroyWindow(int window)
• Considerations:
  • When a window is created it becomes the "current" window
  • glutDisplayFunc() must be called for each window (when it is "current")
  • The OpenGL context must be initialized for each window (when it is "current")

• Window Title:
  • void glutSetWindowTitle(char *name)
• Window Cursor:
  • void glutSetCursor(int cursor)
  • where cursor is one of: GLUT_CURSOR_INFO, GLUT_CURSOR_HELP, GLUT_CURSOR_WAIT, GLUT_CURSOR_TEXT, GLUT_CURSOR_CROSSHAIR, GLUT_CURSOR_NONE (or many others)

• Creating and Destroying:
  • int glutCreateMenu(void (*callback)(int value))
  • void glutDestroyMenu(int menu)
• Setting the Current Menu:
  • void setMenu(int menu)

• Adding Submenus and Menu Entries (to the current menu):
  • void glutAddSubMenu(char *name, int menu)
  • void glutAddMenuEntry(char *name, int valueToReturn)
• Activating/Deactivating Mouse Buttons:
  • void glutAttachMenu(int button)
  • void glutDetachMenu(int button)
  • where button is either GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, or GLUT_RIGHT_BUTTON

Identifiers

openglexamples/glut/menu.c (Fragment: menuEntries)

        // Menu entries
enum MenuEntry {
  MENU_COPY,
  MENU_CUT,
  MENU_HELP,
  MENU_PASTE
};
        

Callback

openglexamples/glut/menu.c (Fragment: menuClicked)

        /**
 * The menu callback
 *
 * @param menu   The menu entry that was selected
 */
void menuClicked(int menu) {
  printf("+menuClicked(%d)\n", menu);

  // Appropriate code goes here

  printf("-menuClicked(%d)\n", menu);
}
        

Setup [e.g., in main()]

openglexamples/glut/menu.c (Fragment: menuSetup)

          // Create the main menu
  mainMenu = glutCreateMenu(menuClicked);

  // Create the "File" menu
  fileMenu = glutCreateMenu(menuClicked);

  // Add menu items to the "File" menu (which is the current menu)
  glutAddMenuEntry("Copy", MENU_COPY);
  glutAddMenuEntry("Cut", MENU_CUT);
  glutAddMenuEntry("Paste", MENU_PASTE);

  // Make the main menu the current menu
  glutSetMenu(mainMenu);

  // Add the "File" menu to the main menu (which is again the current menu)
  glutAddSubMenu("File", fileMenu);

  // Add a menu item to the main menu (which is still the current menu)
  glutAddMenuEntry("Help", MENU_HELP);

  // Attach the menu to the right button
  glutAttachMenu(GLUT_RIGHT_BUTTON);