代码分析-CSDN博客

这是susu给我的一份关于glut的示例代码，里面涉及到的内容有：用glut来完成菜单管理，文本显示，显示列表，材质，光照，多窗口显示，鼠标事件处理，键盘事件处理，菜单事件处理，窗口创建，缩放，销毁，动画播放，定时器等功能，运行效果如图：

我分成几个部分来对代码进行分析：

1，命令行参数检查

void checkArgs( int argc, char * argv[])
{
   int argp;
  GLboolean quit = GL_FALSE;
  GLboolean error = GL_FALSE;
#define AA argv[argp]
  argp = 1 ;
   while (argp < argc)
  {
     if (match(AA, " -help " ))
    {
      commandLineHelp();
      quit = GL_TRUE;
    }
     else if (match(AA, " -version " ))
    {
      printf(VERSIONLONG " \n " );
      quit = GL_TRUE;
    }
     else if (match(AA, " -auto " ))
    { // 自动运行
      demoMode = GL_TRUE;
    }
     else if (match(AA, " -scale " ))
    { // 放缩
      argp ++ ;
      scaleFactor = atof(argv[argp]); // 设置缩放因子
    }
     else
    { // 出错处理
      fprintf(stderr, " Unknown arg: %s\n " , AA);
      error = GL_TRUE;
      quit = GL_TRUE;
    }
    argp ++ ;
  }
GLboolean match( char * arg, char * t)
{
   if (strstr(t, arg))
     return GL_TRUE;
   else
     return GL_FALSE;
}
   if (error)
  {
    commandLineHelp();
    exit( 1 );
  }
   if (quit)
    exit( 0 );
}

这里match函数考虑到-help可能被输入为-h等形式，因此用的是strstr而不是strcmp来进行字符串的匹配。

2，窗口的缩放

通过对窗口原点和大小的调整就可以实现窗口的缩放。

int pos[MAXWIN][ 2 ] =
{ // 各个窗口的左上角坐标
  { 50 , 150 },             /* win 0   */
  { 450 , 150 },            /* win 1   */
  { 50 , 600 },             /* win 2   */
  { 450 , 600 },            /* win 3   */
  { 10 , 10 },              /* subwin 4 (relative to parent win 0) */
  { 300 , 400 },            /* help win 5   */
  { 850 , 150 },            /* cmap win 6   */
  { 850 , 600 },            /* cmap win 7   */
  { 250 , 450 }             /* text win 8   */
};
int size[MAXWIN][ 2 ] =
{ // 各个窗口大小(宽度，高度)
  { 350 , 350 },            /* win 0   */
  { 350 , 350 },            /* win 1   */
  { 350 , 350 },            /* win 2   */
  { 350 , 350 },            /* win 3   */
  { 200 , 200 },            /* subwin 4   */
  { 700 , 300 },            /* help win 5   */
  { 350 , 350 },            /* cmap win 6   */
  { 350 , 350 },            /* cmap win 7   */
  { 800 , 450 }             /* text win 8   */
};
void scaleWindows( float scale)
{ // 放缩初始窗口大小和位置
   int i;
   for (i = 0 ; i < MAXWIN; i ++ )
  {
    pos[i][ 0 ] = pos[i][ 0 ] * scale; // x坐标
    pos[i][ 1 ] = pos[i][ 1 ] * scale; // y坐标
    size[i][ 0 ] = size[i][ 0 ] * scale; // 宽度
    size[i][ 1 ] = size[i][ 1 ] * scale; // 高度
  }
}

3，设置显示模式、

Int型的数组modes用来记录各个模式位的值（0或者1），从而表明窗口是否支持这种模式。displayMode |= glutMode[i];通过这样的按位或运算最终获得窗口的显示模式。

int modes[MODES] = { 0 };
modes[RGBA] = 1 ;
  modes[DOUBLEBUFFER] = 1 ;
  modes[DEPTH] = 1 ;
  setInitDisplayMode()
void setInitDisplayMode( void )
{ // 设置初始显示模式
   int i;
  displayMode = 0 ;
   for (i = 0 ; i < MODES; i ++ ) {
     if (modes[i]) {
       /* printf("Requesting %s \n", modeNames[i]);   */
      displayMode |= glutMode[i]; // 进行按位或运行,
    }
  }
  glutInitDisplayMode(displayMode);
  createMenu6();
   if ( ! glutGet(GLUT_DISPLAY_MODE_POSSIBLE))
    warning( " This display mode not supported\n " );
}

4，菜单管理

menu1到menu8这8个int型变量用来保存创建的菜单项，并且menu2到menu8都作为menu1的子菜单加入到menu1中。

创建菜单

void makeMenus(void)

{//创建弹出菜单

/**//* General control / debug */

menu2 = glutCreateMenu(menuFunc);

glutAddMenuEntry("toggle auto demo mode (a)", 312);

glutAddMenuEntry("toggle freezing in menus", 300);

glutAddMenuEntry("toggle text per window (t)", 301);

glutAddMenuEntry("toggle global timer", 302);

glutAddMenuEntry("toggle global animation", 303);

glutAddMenuEntry("toggle per window animation", 304);

glutAddMenuEntry("toggle debug prints (D)", 305);

glutAddMenuEntry("toggle shaded backdrop", 307);

glutAddMenuEntry("toggle passive motion callback", 308);

glutAddMenuEntry("increase line width (l)", 310);

glutAddMenuEntry("decrease line width (L)", 311);

/**//* Shapes */

menu3 = glutCreateMenu(menuFunc);

glutAddMenuEntry("sphere", 200);

glutAddMenuEntry("cube", 201);

glutAddMenuEntry("cone", 202);

glutAddMenuEntry("torus", 203);

glutAddMenuEntry("dodecahedron", 204);

glutAddMenuEntry("octahedron", 205);

glutAddMenuEntry("tetrahedron", 206);

glutAddMenuEntry("icosahedron", 207);

glutAddMenuEntry("teapot", 208);

/**//* Open/close windows */

menu4 = glutCreateMenu(menuFunc);

glutAddMenuEntry("open all windows", 450);

glutAddMenuEntry("close all windows", 451);

glutAddMenuEntry(" ", 9999);

glutAddMenuEntry("create win 0", 400);

glutAddMenuEntry("create win 1", 401);

glutAddMenuEntry("create win 2", 402);

glutAddMenuEntry("create win 3", 403);

glutAddMenuEntry("create sub window", 404);

glutAddMenuEntry("create color index win 6", 406);

glutAddMenuEntry("create color index win 7", 407);

glutAddMenuEntry(" ", 9999);

glutAddMenuEntry("destroy win 0", 410);

glutAddMenuEntry("destroy win 1", 411);

glutAddMenuEntry("destroy win 2", 412);

glutAddMenuEntry("destroy win 3", 413);

glutAddMenuEntry("destroy sub window", 414);

glutAddMenuEntry("destroy color index win 6", 416);

glutAddMenuEntry("destroy color index win 7", 417);

/**//* Window manager stuff */

menu5 = glutCreateMenu(menuFunc);

glutAddMenuEntry("move current win", 430);

glutAddMenuEntry("resize current win", 431);

glutAddMenuEntry("iconify current win", 432);

glutAddMenuEntry("show current win", 433);

glutAddMenuEntry("hide current win", 434);

glutAddMenuEntry("push current win", 435);

glutAddMenuEntry("pop current win", 436);

glutAddMenuEntry(" ", 9999);

glutAddMenuEntry("move win 1", 420);

glutAddMenuEntry("resize win 1", 421);

glutAddMenuEntry("iconify win 1", 422);

glutAddMenuEntry("show win 1", 423);

glutAddMenuEntry("hide win 1", 424);

glutAddMenuEntry("push win 1", 425);

glutAddMenuEntry("pop win 1", 426);

/**//* Gfx modes */

createMenu6(); /**//* build dynamically */

/**//* Texty reports */

menu7 = glutCreateMenu(menuFunc);

glutAddMenuEntry("report current win modes", 700);

glutAddMenuEntry("report current device data", 701);

glutAddMenuEntry("check OpenGL extensions", 702);

glutAddMenuEntry("dump internal data (d)", 703);

/**//* Play with menus */

menu8 = glutCreateMenu(menuFunc);

glutAddMenuEntry("toggle menus on left button", 805);

glutAddMenuEntry("toggle menus on middle button", 806);

glutAddMenuEntry("toggle menus on right button", 807);

glutAddMenuEntry("---------------------------", 9999);

glutAddMenuEntry("add plain items", 800);

glutAddMenuEntry("add submenu items", 801);

glutAddMenuEntry("change new entries to plain items", 802);

glutAddMenuEntry("change new entries to submenus", 803);

glutAddMenuEntry("remove all new items", 804);

glutAddMenuEntry("---------------------------", 9999);

/**//* Main menu */

menu1 = glutCreateMenu(menuFunc);

glutAddSubMenu("control", menu2);

glutAddSubMenu("shapes", menu3);

glutAddSubMenu("windows", menu4);

glutAddSubMenu("window ops", menu5);

glutAddSubMenu("gfx modes", menu6);

glutAddSubMenu("reports", menu7);

glutAddSubMenu("menus", menu8);

glutAddMenuEntry("help (h)", 101);

glutAddMenuEntry("quit (esc)", 100);

}

5，创建窗口

本文中创建的窗口有4种类型，第1种是普通的RGB窗口，用来显示要绘制的图形，第2种是第1种窗口的子窗口（类似于“画中画”的效果），第3种是文本窗口和帮助窗口，第4种是颜色索引窗口。设置好窗口的显示模式，并根据保存的窗口大小和位置创建完窗口后，就可以对窗口进行OpenGL绘制的初始化工作，这是在gfxInit函数中完成的，最后就是为窗口加上各种事件处理函数。

创建窗口

void makeWindow(int index)

{//建立窗口

char str[99];

if (winId[index] != 0)

{//已经存在的窗口

/**//* warning("Attempt to create window which is already

created"); */

return;

}

switch (index)

{

//普通的RGB窗口

case 0: /**//* ordinary RGB windows */

case 1:

case 2:

case 3:

setInitDisplayMode();

glutInitWindowPosition(pos[index][0], pos[index][1]);//窗口左上角位置

glutInitWindowSize(size[index][0], size[index][1]);//窗口大小

winId[index] = glutCreateWindow(" ");//保存窗口标识符

PR("Window %d id = %d \n", index, winId[index]);

gfxInit(index);//初始化openGL

addCallbacks();

sprintf(str, "window %d (RGB)", index);

glutSetWindowTitle(str);

sprintf(str, "icon %d", index);

glutSetIconTitle(str);

glutSetMenu(menu1);

glutAttachMenu(GLUT_RIGHT_BUTTON);

break;

case 4: /**//* subwindow 子窗口*/

setInitDisplayMode();

winId[index] = glutCreateSubWindow(winId[0], pos[index][0], pos[index]

[1], size[index][0], size[index][1]);

PR("Window %d id = %d \n", index, winId[index]);

gfxInit(index);

glutDisplayFunc(drawScene);

glutVisibilityFunc(visible);

glutReshapeFunc(reshapeFunc);

break;

case 5: /**//* help window 帮助窗口*/

case 8: /**//* text window 文本窗口*/

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

glutInitWindowPosition(pos[index][0], pos[index][1]);

glutInitWindowSize(size[index][0], size[index][1]);

winId[index] = glutCreateWindow(" ");

PR("Window %d id = %d \n", index, winId[index]);

/**//* addCallbacks(); */

glutKeyboardFunc(keyFunc);

glutSpecialFunc(specialFunc);

glClearColor(0.15, 0.15, 0.15, 1.0);

glColor3f(1, 1, 1);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0, 300, 0, 100);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

if (index == 5)

{

glutDisplayFunc(updateHelp);

glutSetWindowTitle("help (RGB) win 5");

glutSetIconTitle("help");

} else

{

glutDisplayFunc(updateText);

glutSetWindowTitle("text (RGB) win 8");

glutSetIconTitle("text");

}

glutSetMenu(menu1);

glutAttachMenu(GLUT_RIGHT_BUTTON);

break;

case 6: /**//* color index window 颜色索引窗口*/

case 7: /**//* color index window */

glutInitDisplayMode(GLUT_DOUBLE | GLUT_INDEX | GLUT_DEPTH);

glutInitWindowPosition(pos[index][0], pos[index][1]);

glutInitWindowSize(size[index][0], size[index][1]);

winId[index] = glutCreateWindow(" ");

PR("Window %d id = %d \n", index, winId[index]);

gfxInit(index);

addCallbacks();

sprintf(str, "window %d (color index)", index);

glutSetWindowTitle(str);

sprintf(str, "icon %d", index);

glutSetIconTitle(str);

glutSetMenu(menu1);

glutAttachMenu(GLUT_RIGHT_BUTTON);

break;

}

为每个窗口初始化OpenGL时，首先通过redefineShapes为窗口建立其显示列表，然后渲染其背景矩阵，接着进行投影变换和视图变换，为了简单起见，作者采用了默认的白色光源来进行材质和光源位置的设置，最后就是启用光照并设置窗口的背景颜色。

OpenGL初始化
void gfxInit(int index)
{//为每个窗口初始化OpenGL

  GLfloat grey10[] =
  {0.10, 0.10, 0.10, 1.0};
  GLfloat grey20[] =
  {0.2, 0.2, 0.2, 1.0};

  GLfloat black[] =
  {0.0, 0.0, 0.0, 0.0};

  //光源位置
  GLfloat diffuse0[] =
  {1.0, 0.0, 0.0, 1.0};
  GLfloat diffuse1[] =
  {0.0, 1.0, 0.0, 1.0};
  GLfloat diffuse2[] =
  {1.0, 1.0, 0.0, 1.0};
  GLfloat diffuse3[] =
  {0.0, 1.0, 1.0, 1.0};
  GLfloat diffuse4[] =
  {1.0, 0.0, 1.0, 1.0};

#define XX  3
#define YY  3
#define ZZ  -2.5

  //背景的包围矩阵
  float vertex[][3] =
  {
    {-XX, -YY, ZZ},
    {+XX, -YY, ZZ},
    {+XX, +YY, ZZ},
    {-XX, +YY, ZZ}
  };

/* warning: This func mixes RGBA and CMAP calls in an ugly
   fashion */

  redefineShapes(currentShape);  /* set up display lists 建立显示列表 */
  glutSetWindow(winId[index]); //设置为当前窗口
                               /* hack - redefineShapes
                                   changes glut win */

/* Shaded backdrop square (RGB or CMAP) */
//渲染背景矩阵
  glNewList(100, GL_COMPILE);
  glPushAttrib(GL_LIGHTING);
  glDisable(GL_LIGHTING);
  glBegin(GL_POLYGON);

  glColor4fv(black);
  glIndexi(0);
  glVertex3fv(vertex[0]);

  glColor4fv(grey10);
  glIndexi(3);
  glVertex3fv(vertex[1]);

  glColor4fv(grey20);
  glIndexi(4);
  glVertex3fv(vertex[2]);

  glColor4fv(grey10);
  glIndexi(7);
  glVertex3fv(vertex[3]);

  glEnd();
  glPopAttrib();
  glIndexi(9);
  glEndList();

/* Set proj+view */
//投影变换和视图变换
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(40.0, 1.0, 1.0, 20.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.);//gluLookAt前三个参数表示了观察点的位置，中间三个参数表示了观察目标的位置，最后三个参数代表从(0,0,0)到 (x,y,z)的直线，它表示了观察者认为的“上”方向
  glTranslatef(0.0, 0.0, -1.0);//移入屏幕一个单位

  if (index == 6 || index == 7)//颜色索引模式
    goto colorindex;

/* Set basic material, lighting for RGB windows */
//材质和光源位置的设置(默认的白色光源)
  if (index == 0)
    glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse0);
  else if (index == 1)
    glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse1);
  else if (index == 2)
    glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse2);
  else if (index == 3)
    glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse3);
  else if (index == 4)
    glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse4);

  //启用光源
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable(GL_DEPTH_TEST);

  if (index == 4)
    glClearColor(0.15, 0.15, 0.15, 1);//设置子窗口的背景颜色
  else
    glClearColor(0.1, 0.1, 0.1, 1.0);//其他窗口的背景颜色

  return;

/* Set GL basics for CMAP windows 6,7 */
//颜色索引模式
colorindex:

  glEnable(GL_DEPTH_TEST);
  if (glutGet(GLUT_WINDOW_COLORMAP_SIZE) < 16)
    warning("Color map size too small for color index window");

/* Try to reuse an existing color map */

  if ((index == 6) && (winId[7] != 0))
  {
    glutCopyColormap(winId[7]);
  } else if ((index == 7) && (winId[6] != 0)) {
    glutCopyColormap(winId[6]);
  } else {
    glutSetColor(8, 0.1, 0.1, 0.1);
    glutSetColor(9, 1.0, 0.5, 0.0);
    glutSetColor(10, 1.0, 0.6, 0.8);
  }
  glClearIndex(8);
  glIndexi(index + 3);

}
void addCallbacks(void)
{//为窗口增加回调函数
  glutDisplayFunc(drawScene);
  glutVisibilityFunc(visible);
  glutReshapeFunc(reshapeFunc);
  glutKeyboardFunc(keyFunc);
  glutSpecialFunc(specialFunc);
  glutMouseFunc(mouseFunc);
  glutMotionFunc(motionFunc);
  glutEntryFunc(entryFunc);

/* Callbacks for exotic input devices. Must get my dials &
   buttons back. */

  glutSpaceballMotionFunc(spaceballMotionCB);
  glutSpaceballRotateFunc(spaceballRotateCB);
  glutSpaceballButtonFunc(spaceballButtonCB);

  glutButtonBoxFunc(buttonBoxCB);
  glutDialsFunc(dialsCB);

  glutTabletMotionFunc(tabletMotionCB);
  glutTabletButtonFunc(tabletButtonCB);
}

6，动画效果

我在MFC中是通过设置一个定时器，并且在定时方法中修改旋转角度来刷新屏幕的，从而实现动画旋转的效果，在这里作者把这部分代码放到窗口的空闲事件处理函数中进行。每次执行时角度都进行了变换，并且通知窗口强制其重绘。

/* idleFunc - GLUT idle func callback - animates windows */
void idleFunc( void )
{
   int i;
   if ( ! leftDown && ! middleDown) // 旋转角度加1
    angle += 1 ;
    angle = angle % 360 ;
   for (i = 0 ; i < MAXWIN; i ++ )
  {
     if (winId[i] && winVis[i] && ! winFreeze[i])
    {
      glutSetWindow(winId[i]);
      glutPostRedisplay(); // 强制重画
    }
  }
}

7，自动演示

这里采用了一个小的技巧来实现多个窗口连续创建的自动演示功能。通过执行当前的动作后，为下一个应该接着发生的动作设置一个定时器，从而实现动作之间的接连发送效果。

旋转动画
void autoDemo(int value)
{
  static int index = 0;
  static int count = 0;
  static int restartValue = -2;
  if (value == -999)
    value = restartValue;
  restartValue = value;
#define AUTODELAY2 (unsigned int) (AUTODELAY*0.66)
  /* fprintf(stderr, "autoDemo: value %d \n", value);  */
  if (!demoMode)
    return;
  if (menu_state == GLUT_MENU_IN_USE)
  {
    glutTimerFunc(AUTODELAY / 2, autoDemo, value);
    return;
  }
  switch (value)
  {
/* Entry point; kill off existing windows. */
  case -2:
    killAllWindows();
    glutTimerFunc(AUTODELAY / 2, autoDemo, 1);
    break;
/* Start making windows */
  case -1:
    makeWindow(0);
    glutTimerFunc(AUTODELAY, autoDemo, 0);  /* skip case 0
                                               first time  */
    break;
/* Change shape & backdrop */
  case 0:
    currentShape = (currentShape + 1) % 9;
    redefineShapes(currentShape);
    count += 1;
    if (count % 2)
      backdrop = !backdrop;
    glutTimerFunc(AUTODELAY, autoDemo, 1);
    break;
/* Keep making windows */
  case 1:
    makeWindow(1);
    glutTimerFunc(AUTODELAY, autoDemo, 2);
    break;
  case 2:
    makeWindow(2);
    glutTimerFunc(AUTODELAY, autoDemo, 3);
    break;
  case 3:
    makeWindow(3);
    glutTimerFunc(AUTODELAY, autoDemo, 4);
    break;
  case 4:
    makeWindow(4);
    glutTimerFunc(AUTODELAY, autoDemo, 5);
    break;
  case 5:
    makeWindow(5);
    glutTimerFunc(AUTODELAY * 2, autoDemo, 51);
    break;
  case 51:
    makeWindow(6);
    glutTimerFunc(AUTODELAY * 2, autoDemo, 52);
   break;
  case 52:
    makeWindow(7);
    glutTimerFunc(AUTODELAY * 2, autoDemo, 53);
    break;
/* Kill last 3 windows, leave 4 up. */
  case 53:
    killWindow(7);
    glutTimerFunc(AUTODELAY, autoDemo, 54);
    break;
  case 54:
    killWindow(6);
    glutTimerFunc(AUTODELAY, autoDemo, 6);
    break;
  case 6:
    killWindow(5);
    glutTimerFunc(AUTODELAY, autoDemo, 7);
    break;
  case 7:
    killWindow(4);
    glutTimerFunc(AUTODELAY, autoDemo, 700);
    break;
/* Change shape again */
  case 700:
    currentShape = (currentShape + 1) % 9;
    redefineShapes(currentShape);
    glutTimerFunc(AUTODELAY, autoDemo, 701);
    break;
/* Cycle 4 main windows through various window ops.  */
  case 701:
    positionWindow(index);
    index = (index + 1) % 4;
    glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 701 : 702);
    break;
  case 702:
    reshapeWindow(index);
    index = (index + 1) % 4;
    glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 702 : 703);
    break;
  case 703:
    iconifyWindow(index);
    index = (index + 1) % 4;
    glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 703 : 704);
    break;
  case 704:
    showWindow(index);
    index = (index + 1) % 4;
    glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 704 : 705);
    break;
  case 705:
    hideWindow(index);
    index = (index + 1) % 4;
    glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 705 : 706);
    break;
  case 706:
    showWindow(index);
    index = (index + 1) % 4;
    glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 706 : 707);
    break;
  case 707:
    pushWindow(index);
    index = (index + 1) % 4;
    glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 707 : 708);
    break;
  case 708:
    popWindow(index);
    index = (index + 1) % 4;
    glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 708 : 8);
    break;
/* Kill all windows */
  case 8:
    killWindow(3);
    glutTimerFunc(AUTODELAY, autoDemo, 9);
    break;
  case 9:
    killWindow(2);
    glutTimerFunc(AUTODELAY, autoDemo, 10);
    break;
  case 10:
    killWindow(1);
    glutTimerFunc(AUTODELAY, autoDemo, 11);
    break;
  case 11:
    killWindow(0);
    glutTimerFunc(AUTODELAY, autoDemo, -1);  /* back to start  */
    break;
  }
}

8，图形绘制代码部分

所有窗口都使用drawScene来绘制其图形，只是各个窗口调用的显示列表不同而已，这通过各个窗口的标识符来进行区别，并且通过调用trackBall(APPLY, 0, 0, 0, 0);来绘制鼠标左键控制的结果（旋转后的角度或者平移后的距离），如果窗口还有文本要显示，则调用showText来显示文本信息。

图形绘制代码
void drawScene(void)
{
  int winIndex;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  winIndex = idToIndex(glutGetWindow());
  /* printf("drawScene for index %d, id %d\n", winIndex,
     glutGetWindow());  */
  glPushMatrix();
  glLineWidth(lineWidth);
  if (backdrop)
    glCallList(100);
  /* Left button spinning  */
  trackBall(APPLY, 0, 0, 0, 0);//鼠标左键控制结果的绘制
  /* Apply continuous spinning  */
  glRotatef(angle, 0, 1, 0);//绕y轴旋转
  glCallList(winIndex + 1);
  glPopMatrix();
  if (text[winIndex])
    showText();//显示文本
  glutSwapBuffers();
}
/* showText - Render some text in the current GLUT window */
void showText(void)
{
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  gluOrtho2D(0, 100, 0, 100);
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();
  glColor3f(1.0, 1.0, 1.0);
  glIndexi(7);
  glDisable(GL_DEPTH_TEST);
  glDisable(GL_LIGHTING);
  glLineWidth(lineWidth);
  textString(1, 1, "GLUT_BITMAP_8_BY_13", GLUT_BITMAP_8_BY_13);
  textString(1, 5, "GLUT_BITMAP_9_BY_15", GLUT_BITMAP_9_BY_15);
  textString(1, 10, "GLUT_BITMAP_TIMES_ROMAN_10", GLUT_BITMAP_TIMES_ROMAN_10);
  textString(1, 15, "GLUT_BITMAP_TIMES_ROMAN_24", GLUT_BITMAP_TIMES_ROMAN_24);

  strokeString(1, 25, "GLUT_STROKE_ROMAN", GLUT_STROKE_ROMAN);
  strokeString(1, 35, "GLUT_STROKE_MONO_ROMAN", GLUT_STROKE_MONO_ROMAN);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_LIGHTING);
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}

9.文本显示

这里有两种文本的显示方式，第一种采用位图字体来显示文本，第二种采用Stroke 字体来显示文本。

void textString( int x, int y, char * msg, void * font)
{ // 显示文本,x,y是起始坐标，msg：要显示的文本,font:显示的字体
  glRasterPos2f(x, y); // 定位位图字体
   while ( * msg)
  {
    glutBitmapCharacter(font, * msg);
    msg ++ ;
  }
}

/* strokeString - Stroke font string */
void strokeString( int x, int y, char * msg, void * font)
{
  glPushMatrix();
  glTranslatef(x, y, 0 );
  glScalef(. 04 , . 04 , . 04 );
   while ( * msg)
  {
    glutStrokeCharacter(font, * msg);
    msg ++ ;
  }
  glPopMatrix();
}

10,显示列表

显示列表由于是已经编译好的代码段，因此可以加快程序的速度。这里每种要绘制的图形(如球，茶壶等)都有实体和虚体两种模式可以选择。

显示列表
void redefineShapes(int shape)
{
  int i;
//根据窗口号来绘制两种不同类型的图形
#define C3                \
        switch(i)        \
     {                \
         case 0:      \
         case 3:      \
           C1;        \
           break;     \
                      \
         case 1:      \
         case 2:      \
         case 4:      \
         case 6:      \
         case 7:      \
           C2;        \
           break;     \
     }                \
     currentShape = shape
  for (i = 0; i < MAXWIN; i++)
  {//为每个要创建的窗口建立显示列表
    if (winId[i])
    {
      glutSetWindow(winId[i]);
      if (glIsList(i + 1))
        glDeleteLists(i + 1, 1);//若已经存在显示列表，就删除掉
      glNewList(i + 1, GL_COMPILE);//为当前窗口新建显示列表
      switch (shape)
      {
#undef  C1
#define C1  glutSolidSphere(1.5, 10, 10)
#undef  C2
#define C2  glutWireSphere(1.5, 10, 10)
      case 0:
        C3;
        break;
#undef  C1
#define C1 glutSolidCube(2)
#undef  C2
#define C2 glutWireCube(2)
      case 1:
        C3;
        break;
#undef  C1
#define C1 glutSolidCone(1.5, 1.75, 10, 10);
#undef  C2
#define C2 glutWireCone(1.5, 1.75, 10, 10);
      case 2:
        C3;
        break;
#undef  C1
#define C1 glutSolidTorus(0.5, 1.1, 10, 10)
#undef  C2
#define C2 glutWireTorus(0.5, 1.1, 10, 10)
      case 3:
        C3;
        break;
#undef  C1
#define C1 glScalef(.8, .8, .8);glutSolidDodecahedron()
#undef  C2
#define C2 glScalef(.8, .8, .8);glutWireDodecahedron()

      case 4:
        C3;
        break;
#undef  C1
#define C1 glScalef(1.5, 1.5, 1.5);glutSolidOctahedron()
#undef  C2
#define C2 glScalef(1.5, 1.5, 1.5);glutWireOctahedron()
      case 5:
        C3;
        break;
#undef  C1
#define C1 glScalef(1.8, 1.8, 1.8);glutSolidTetrahedron()
#undef  C2
#define C2 glScalef(1.8, 1.8, 1.8);glutWireTetrahedron()
      case 6:
        C3;
        break;
#undef  C1
#define C1 glScalef(1.5, 1.5, 1.5);glutSolidIcosahedron()
#undef  C2
#define C2 glScalef(1.5, 1.5, 1.5);glutWireIcosahedron()
      case 7:
        C3;
        break;
#undef  C1
#define C1 glutSolidTeapot(1.5);
#undef  C2
#define C2 glutWireTeapot(1.5);
      case 8:
        C3;
        break;
      }
      glEndList();
    }
  }
}

11，鼠标事件处理

这里鼠标有三种控制方式，1）左键进行旋转。2）中键进行xy平面的平移。3）左键+中键进行关于Z轴的平移（产生缩放的效果）。鼠标的事件模式这里有RESET，MOUSEBUTTON，APPLY， MOUSEMOTION四种,其中RESET是用来对清空以往的操作，让图形回到原点处。MOUSEBUTTON是鼠标按下激发的，用来记录下鼠标的位置，MOUSEMOTION是鼠标按下后并移动鼠标时，用来计算旋转的角度或者平移的距离，而最终这些变换后产生的效果的绘制是APPLY发生的，在这里进行了实际的旋转和平移动作。

鼠标控制
void trackBall(int mode, int button, int state, int x, int y)
{//鼠标控制
  static int startMX = 0, startMY = 0;  /* initial mouse pos  */
  static int deltaMX = 0, deltaMY = 0;  /* initial mouse pos  */
  static float steadyXangle = 0.0, steadyYangle = 0.0;//绕x,y轴旋转的角度
  static float varXangle = 0.0, varYangle = 0.0;
  static float steadyX = 0.0, steadyY = 0.0, steadyZ = 0.0;//；沿坐标轴缩放的比例
  static float varX = 0.0, varY = 0.0, varZ = 0.0;

  switch (mode)
  {

  case RESET://重置
    steadyXangle = steadyYangle = steadyX = steadyY = steadyZ = 0.0;
    break;

  case MOUSEBUTTON:

    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN && !middleDown)
    {//左键按下
      STARTROTATE(x, y);//开始旋转,记录起始点坐标
      leftDown = GL_TRUE;
    }
    else if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN &&
      middleDown)
    {//原来中键已按下且未放开，这时按下左键，则停止移动，开始缩放
      STOPPAN(x, y);
      STARTZOOM(x, y);
      leftDown = GL_TRUE;
    }
    else if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN &&
      !leftDown)
    {//中键按下，开始移动
      STARTPAN(x, y);
      middleDown = GL_TRUE;
    }
    else if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN &&
      leftDown)
    {//原来左键已按下且未放开，这时按下中键，则停止旋转，开始缩放
      STOPROTATE(x, y);
      STARTZOOM(x, y);
      middleDown = GL_TRUE;
    }
    else if (state == GLUT_UP && button == GLUT_LEFT_BUTTON && !middleDown)
    {//左键放开且中键未按下，停止旋转
      STOPROTATE(x, y);
      leftDown = GL_FALSE;
    }
    else if (state == GLUT_UP && button == GLUT_LEFT_BUTTON && middleDown)
    {//原来左中键已按下且未放开，这时放开左键，则停止缩放，开始旋转
      STOPZOOM(x, y);
      STARTROTATE(x, y);
      leftDown = GL_FALSE;
    }
    else if (state == GLUT_UP && button == GLUT_MIDDLE_BUTTON && !leftDown)
    {
      STOPPAN(x, y);
      middleDown = GL_FALSE;
    }
    else if (state == GLUT_UP && button == GLUT_MIDDLE_BUTTON && leftDown)
    {
      STOPZOOM(x, y);
      STARTROTATE(x, y);
      middleDown = GL_FALSE;
    }
    break;

  case APPLY://结果的绘制
    if (leftDown && !middleDown)
    {//旋转
      glTranslatef(steadyX, steadyY, steadyZ);
      glRotatef(varXangle, 0, 1, 0);//绕y轴旋转
      glRotatef(varYangle, 1, 0, 0);//绕x轴旋转
    }
    /* Middle button pan  */
    else if (middleDown && !leftDown)
    {//平移
      glTranslatef(varX, varY, steadyZ);//在xy平面内平移
      glRotatef(steadyXangle, 0, 1, 0);
      glRotatef(steadyYangle, 1, 0, 0);
    }
    /* Left + middle zoom.  */
    else if (leftDown && middleDown)
    {//缩放(其实不能说缩放，只是让z轴的距离变化，镜头推近推远产生缩放的感觉)
      glTranslatef(steadyX, steadyY, varZ);
      glRotatef(steadyXangle, 0, 1, 0);
      glRotatef(steadyYangle, 1, 0, 0);
    }
    /* Nothing down.  */
    else
    {
      glTranslatef(steadyX, steadyY, steadyZ);
      glRotatef(steadyXangle, 0, 1, 0);
      glRotatef(steadyYangle, 1, 0, 0);
    }
    break;

  case MOUSEMOTION:

    deltaMX = x - startMX;//计算x的偏移量
    deltaMY = startMY - y;//y的偏移量

    if (leftDown && !middleDown)
    {//旋转
      varXangle = fixAngle(steadyXangle + deltaMX);//计算旋转后对于y轴的角度
      varYangle = fixAngle(steadyYangle + deltaMY);//计算旋转后对于x轴的角度
    }
    else if (middleDown && !leftDown)
    {//移动
      varX = steadyX + deltaMX / 100.0;//平移后相对于x轴的距离
      varY = steadyY + deltaMY / 100.0;//平移后相对于y轴的距离
    }
    else if (leftDown && middleDown)
    {//缩放
      varZ = steadyZ - deltaMY / 50.0;//相对于z轴的缩放比例
    }
    break;
  }

}

最后，代码中还加入了对空间球，图形板，拨号按键盒的事件处理支持。