开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
bigtest.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：59k
源码类别：

GIS编程

开发平台：

Visual C++

bigtest.c：源码内容
  2. /**
  3.  * My first GLUT prog.
  4.  * Uses most GLUT calls to prove it all works.
  5.  * G Edwards, 30 Aug 95.
  6.  *
  7.  * Notes:
  8.  * Display lists are not shared between windows, and there doesn't seem to be
  9.  *  any provision for this in GLUT. See glxCreateContext.
  10.  *
  11.  * The windows are internally indexed 0,1,2,3,4,5,6. The actual window ids
  12.  * returned by glut are held in winId[0], ...
  13.  *
  14.  * Todo:
  15.  *
  16.  * Could reorder the windows so 0,1,2,3,4,5,6 are the gfx, 7,8 text.
  17.  *
  18.  * 30 Aug 95  GJE  Created. Version 1.00
  19.  * 05 Sep 95  GJE  Version 1.01. 
  20.  * 07 Sep 95  GJE  Version 1.02. More or less complete. All possible GLUT
  21.  *                 calls used, except dials/buttons/tablet/spaceball stuff.
  22.  * 15 Sep 95  GJE  Add "trackball" code.
  23.  *
  24.  *  Calls not used yet: these callbacks are registered but inactive.
  25.  *
  26.  *  glutSpaceball<xxx>Func
  27.  *  glutButtonBoxFunc
  28.  *  glutDialsFunc
  29.  *  glutTabletMotionFunc
  30.  *  glutTabletButtonFunc
  31.  *
  32.  * Tested on:
  33.  *  R3K Indigo Starter
  34.  *  R4K Indigo Elan
  35.  *  R4K Indy XZ
  36.  *  R4K Indy XL
  37.  *  R4K Indigo2 Extreme
  38.  */
  40. #include <GL/glut.h>
  41. #include <stdio.h>
  42. #include <stdlib.h>
  43. #include <string.h>
  44. #include <math.h>
  46. /* Controls */
  48. #define VERSION    "1.00"
  49. #define DATE       "16Sep95"
  50. #define DELAY      1000 /* delay for timer test */
  51. #define MENUDELAY  200  /* hack to fix glutMenuStateFunc bug */
  52. #define MAXWIN     9    /* max no. of windows */
  54. unsigned int AUTODELAY = 1500;   /* delay in demo mode  */
  56. #define VERSIONLONG "Version " VERSION "/" DATE ", compiled " __DATE__ ", " __TIME__ ", file " __FILE__
  58. int pos[MAXWIN][2] =
  59. {
  60.   {50, 150},            /* win 0  */
  61.   {450, 150},           /* win 1  */
  62.   {50, 600},            /* win 2  */
  63.   {450, 600},           /* win 3  */
  64.   {10, 10},             /* subwin 4 (relative to parent win 0) */
  65.   {300, 400},           /* help win 5  */
  66.   {850, 150},           /* cmap win 6  */
  67.   {850, 600},           /* cmap win 7  */
  68.   {250, 450}            /* text win 8  */
  69. };
  71. int size[MAXWIN][2] =
  72. {
  73.   {350, 350},           /* win 0  */
  74.   {350, 350},           /* win 1  */
  75.   {350, 350},           /* win 2  */
  76.   {350, 350},           /* win 3  */
  77.   {200, 200},           /* subwin 4  */
  78.   {700, 300},           /* help win 5  */
  79.   {350, 350},           /* cmap win 6  */
  80.   {350, 350},           /* cmap win 7  */
  81.   {800, 450}            /* text win 8  */
  82. };
  84. /* Macros */
  86. #define PR     if(debug)printf
  88. /* #define GLNEWLIST(a, b)  glNewList(a, b), fprintf(stderr,
  89.    "creating list %d n", a); */
  90. /* #define GLCALLLIST(a)    glCallList(a), fprintf(stderr,
  91.    "calling list %d n", a); */
  92. /* #define GLUTSETWINDOW(x) glutSetWindow(x), fprintf(stderr,
  93.    "gsw at %dn", __LINE__) */
  95. /* Globals */
  97. int winId[MAXWIN] =
  98. {0};                    /* table of glut window id's  */
  99. GLboolean winVis[MAXWIN] =
  100. {GL_FALSE};                /* is window visible  */
  102. GLboolean text[MAXWIN] =
  103. {GL_FALSE};                /* is text on  */
  104. GLboolean winFreeze[MAXWIN] =
  105. {GL_FALSE};                /* user requested menuFreeze  */
  106. GLboolean menuFreeze = GL_FALSE;  /* menuFreeze while menus posted  */
  107. GLboolean timerOn = GL_FALSE;  /* timer active  */
  108. GLboolean animation = GL_TRUE;  /* idle func animation on  */
  109. GLboolean debug = GL_FALSE;  /* dump all events  */
  110. GLboolean showKeys = GL_FALSE;  /* dump key events  */
  111. GLboolean demoMode = GL_FALSE;  /* run automatic demo  */
  112. GLboolean backdrop = GL_FALSE;  /* use backdrop polygon  */
  113. GLboolean passive = GL_FALSE;  /* report passive motions  */
  114. GLboolean leftDown = GL_FALSE;  /* left button down ?  */
  115. GLboolean middleDown = GL_FALSE;  /* middle button down ?  */
  117. int displayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH;
  118. int currentShape = 0;   /* current glut shape  */
  119. int scrollLine = 0, scrollCol = 0;  /* help scrolling params  */
  120. int lineWidth = 1;      /* line width  */
  121. int angle = 0;      /* global rotation angle  */
  122. char *textPtr[1000] =
  123. {0};                    /* pointers to text window text  */
  124. int textCount = 0, helpCount = 0;  /* text list indexes  */
  125. float scaleFactor = 0.0;  /* window size scale factor  */
  127. #ifdef ALPHA
  128. #undef ALPHA  /* Avoid problems with DEC's ALPHA machines. */
  129. #endif
  131. int menu1, menu2, menu3, menu4, menu5, menu6 = 0, menu7, menu8;
  132. enum {
  133.   RGBA, INDEX, SINGLE, DOUBLEBUFFER, DEPTH, ACCUM, ALPHA, STENCIL, MULTISAMPLE,
  134.   STEREO, MODES
  135. };
  136. char *modeNames[] =
  137. {"RGBA", "INDEX", "SINGLE", "DOUBLE", "DEPTH", "ACCUM",
  138.   "ALPHA", "STENCIL", "MULTISAMPLE", "STEREO"};
  139. int glutMode[] =
  140. {GLUT_RGBA, GLUT_INDEX, GLUT_SINGLE, GLUT_DOUBLE, GLUT_DEPTH,
  141.   GLUT_ACCUM, GLUT_ALPHA, GLUT_STENCIL, GLUT_MULTISAMPLE, GLUT_STEREO};
  142. int modes[MODES] =
  143. {0};
  144. GLboolean menuButton[3] =
  145. {0, 0, 1};
  146. enum {
  147.   MOUSEBUTTON, MOUSEMOTION, APPLY, RESET
  148. };
  150. /* Prototypes */
  152. void gfxInit(int);
  153. void drawScene(void);
  154. void idleFunc(void);
  155. void reshapeFunc(int width, int height);
  156. void visible(int state);
  157. void keyFunc(unsigned char key, int x, int y);
  158. void mouseFunc(int button, int state, int x, int y);
  159. void motionFunc(int x, int y);
  160. void passiveMotionFunc(int x, int y);
  161. void entryFunc(int state);
  162. void specialFunc(int key, int x, int y);
  163. void menuStateFunc(int state);
  164. void timerFunc(int value);
  165. #if 0
  166. void delayedReinstateMenuStateCallback(int value);
  167. #endif
  168. void menuFunc(int value);
  169. void showText(void);
  170. void textString(int x, int y, char *str, void *font);
  171. void strokeString(int x, int y, char *str, void *font);
  172. void makeMenus(void);
  173. int idToIndex(int id);
  174. void setInitDisplayMode(void);
  175. void createMenu6(void);
  176. void removeCallbacks(void);
  177. void addCallbacks(void);
  178. void dumpIds(void);
  179. void updateHelp(void);
  180. void updateAll(void);
  181. void killWindow(int index);
  182. void makeWindow(int index);
  183. void warning(char *msg);
  184. void autoDemo(int);
  185. void positionWindow(int index);
  186. void reshapeWindow(int index);
  187. void iconifyWindow(int index);
  188. void showWindow(int index);
  189. void hideWindow(int index);
  190. void pushWindow(int index);
  191. void popWindow(int index);
  192. void attachMenus(void);
  193. void killAllWindows(void);
  194. void makeAllWindows(void);
  195. void updateText(void);
  196. void updateScrollWindow(int index, char **ptr);
  197. void redefineShapes(int shape);
  198. GLboolean match(char *, char *);
  199. void checkArgs(int argc, char *argv[]);
  200. void scaleWindows(float);
  201. void commandLineHelp(void);
  202. void trackBall(int mode, int button, int state, int x, int y);
  204. void spaceballMotionCB(int, int, int);
  205. void spaceballRotateCB(int, int, int);
  206. void spaceballButtonCB(int, int);
  207. void buttonBoxCB(int, int);
  208. void dialsCB(int, int);
  209. void tabletMotionCB(int, int);
  210. void tabletButtonCB(int, int, int, int);
  212. /* strdup is actually not a standard ANSI C or POSIX routine
  213.    so implement a private one.  OpenVMS does not have a strdup; Linux's
  214.    standard libc doesn't declare strdup by default (unless BSD or SVID
  215.    interfaces are requested). */
  216. static char *
  217. stralloc(const char *string)
  218. {
  219.   char *copy;
  221.   copy = malloc(strlen(string) + 1);
  222.   if (copy == NULL)
  223.     return NULL;
  224.   strcpy(copy, string);
  225.   return copy;
  226. }
  228. /* main */
  230. int
  231. main(int argc, char **argv)
  232. {
  234. /* General init */
  236.   glutInit(&argc, argv);
  238. /* Check args */
  240.   checkArgs(argc, argv);
  242. /* Scale window position/size if needed. Ignore aspect ratios. */
  244.   if (scaleFactor > 0.0)
  245.     scaleWindows(scaleFactor);
  246.   else
  247.     scaleWindows(glutGet(GLUT_SCREEN_WIDTH) / 1280.0);
  249. /* Set initial display mode */
  251.   modes[RGBA] = 1;
  252.   modes[DOUBLEBUFFER] = 1;
  253.   modes[DEPTH] = 1;
  254.   setInitDisplayMode();
  256. /* Set up menus */
  258.   makeMenus();
  260. /* Make some windows */
  262.   makeWindow(0);
  263.   makeWindow(1);
  265. /* Global callbacks */
  267.   glutIdleFunc(idleFunc);
  268.   glutMenuStateFunc(menuStateFunc);
  270. /* Start demo if needed */
  272.   if (demoMode)
  273.     autoDemo(-2);
  275. /* Fall into event loop */
  277.   glutMainLoop();
  278.   return 0;             /* ANSI C requires main to return int. */
  279. }
  281. /* gfxInit - Init opengl for each window */
  283. void
  284. gfxInit(int index)
  285. {
  286.   GLfloat grey10[] =
  287.   {0.10, 0.10, 0.10, 1.0};
  288.   GLfloat grey20[] =
  289.   {0.2, 0.2, 0.2, 1.0};
  290.   GLfloat black[] =
  291.   {0.0, 0.0, 0.0, 0.0};
  292.   GLfloat diffuse0[] =
  293.   {1.0, 0.0, 0.0, 1.0};
  294.   GLfloat diffuse1[] =
  295.   {0.0, 1.0, 0.0, 1.0};
  296.   GLfloat diffuse2[] =
  297.   {1.0, 1.0, 0.0, 1.0};
  298.   GLfloat diffuse3[] =
  299.   {0.0, 1.0, 1.0, 1.0};
  300.   GLfloat diffuse4[] =
  301.   {1.0, 0.0, 1.0, 1.0};
  303. #define XX  3
  304. #define YY  3
  305. #define ZZ  -2.5
  307.   float vertex[][3] =
  308.   {
  309.     {-XX, -YY, ZZ},
  310.     {+XX, -YY, ZZ},
  311.     {+XX, +YY, ZZ},
  312.     {-XX, +YY, ZZ}
  313.   };
  315. /* warning: This func mixes RGBA and CMAP calls in an ugly
  316.    fashion */
  318.   redefineShapes(currentShape);  /* set up display lists  */
  319.   glutSetWindow(winId[index]);  /* hack - redefineShapes
  320.                                    changes glut win */
  322. /* Shaded backdrop square (RGB or CMAP) */
  324.   glNewList(100, GL_COMPILE);
  325.   glPushAttrib(GL_LIGHTING);
  326.   glDisable(GL_LIGHTING);
  327.   glBegin(GL_POLYGON);
  329.   glColor4fv(black);
  330.   glIndexi(0);
  331.   glVertex3fv(vertex[0]);
  333.   glColor4fv(grey10);
  334.   glIndexi(3);
  335.   glVertex3fv(vertex[1]);
  337.   glColor4fv(grey20);
  338.   glIndexi(4);
  339.   glVertex3fv(vertex[2]);
  341.   glColor4fv(grey10);
  342.   glIndexi(7);
  343.   glVertex3fv(vertex[3]);
  345.   glEnd();
  346.   glPopAttrib();
  347.   glIndexi(9);
  348.   glEndList();
  350. /* Set proj+view */
  352.   glMatrixMode(GL_PROJECTION);
  353.   glLoadIdentity();
  354.   gluPerspective(40.0, 1.0, 1.0, 20.0);
  355.   glMatrixMode(GL_MODELVIEW);
  356.   glLoadIdentity();
  357.   gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.);
  358.   glTranslatef(0.0, 0.0, -1.0);
  360.   if (index == 6 || index == 7)
  361.     goto colorindex;
  363. /* Set basic material, lighting for RGB windows */
  365.   if (index == 0)
  366.     glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse0);
  367.   else if (index == 1)
  368.     glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse1);
  369.   else if (index == 2)
  370.     glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse2);
  371.   else if (index == 3)
  372.     glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse3);
  373.   else if (index == 4)
  374.     glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse4);
  376.   glEnable(GL_LIGHTING);
  377.   glEnable(GL_LIGHT0);
  378.   glEnable(GL_DEPTH_TEST);
  380.   if (index == 4)
  381.     glClearColor(0.15, 0.15, 0.15, 1);
  382.   else
  383.     glClearColor(0.1, 0.1, 0.1, 1.0);
  385.   return;
  387. /* Set GL basics for CMAP windows 6,7 */
  389. colorindex:
  391.   glEnable(GL_DEPTH_TEST);
  392.   if (glutGet(GLUT_WINDOW_COLORMAP_SIZE) < 16)
  393.     warning("Color map size too small for color index window");
  395. /* Try to reuse an existing color map */
  397.   if ((index == 6) && (winId[7] != 0)) {
  398.     glutCopyColormap(winId[7]);
  399.   } else if ((index == 7) && (winId[6] != 0)) {
  400.     glutCopyColormap(winId[6]);
  401.   } else {
  402.     glutSetColor(8, 0.1, 0.1, 0.1);
  403.     glutSetColor(9, 1.0, 0.5, 0.0);
  404.     glutSetColor(10, 1.0, 0.6, 0.8);
  405.   }
  406.   glClearIndex(8);
  407.   glIndexi(index + 3);
  409. }
  411. /* makeMenus - Create popup menus */
  413. void
  414. makeMenus(void)
  415. {
  417. /* General control / debug */
  419.   menu2 = glutCreateMenu(menuFunc);
  420.   glutAddMenuEntry("toggle auto demo mode (a)", 312);
  421.   glutAddMenuEntry("toggle freezing in menus", 300);
  422.   glutAddMenuEntry("toggle text per window (t)", 301);
  423.   glutAddMenuEntry("toggle global timer", 302);
  424.   glutAddMenuEntry("toggle global animation", 303);
  425.   glutAddMenuEntry("toggle per window animation", 304);
  426.   glutAddMenuEntry("toggle debug prints (D)", 305);
  427.   glutAddMenuEntry("toggle shaded backdrop", 307);
  428.   glutAddMenuEntry("toggle passive motion callback", 308);
  429.   glutAddMenuEntry("increase line width (l)", 310);
  430.   glutAddMenuEntry("decrease line width  (L)", 311);
  432. /* Shapes */
  434.   menu3 = glutCreateMenu(menuFunc);
  435.   glutAddMenuEntry("sphere", 200);
  436.   glutAddMenuEntry("cube", 201);
  437.   glutAddMenuEntry("cone", 202);
  438.   glutAddMenuEntry("torus", 203);
  439.   glutAddMenuEntry("dodecahedron", 204);
  440.   glutAddMenuEntry("octahedron", 205);
  441.   glutAddMenuEntry("tetrahedron", 206);
  442.   glutAddMenuEntry("icosahedron", 207);
  443.   glutAddMenuEntry("teapot", 208);
  445. /* Open/close windows */
  447.   menu4 = glutCreateMenu(menuFunc);
  448.   glutAddMenuEntry("open all windows", 450);
  449.   glutAddMenuEntry("close all windows", 451);
  450.   glutAddMenuEntry(" ", 9999);
  451.   glutAddMenuEntry("create win 0", 400);
  452.   glutAddMenuEntry("create win 1", 401);
  453.   glutAddMenuEntry("create win 2", 402);
  454.   glutAddMenuEntry("create win 3", 403);
  455.   glutAddMenuEntry("create sub window", 404);
  456.   glutAddMenuEntry("create color index win 6", 406);
  457.   glutAddMenuEntry("create color index win 7", 407);
  458.   glutAddMenuEntry(" ", 9999);
  459.   glutAddMenuEntry("destroy win 0", 410);
  460.   glutAddMenuEntry("destroy win 1", 411);
  461.   glutAddMenuEntry("destroy win 2", 412);
  462.   glutAddMenuEntry("destroy win 3", 413);
  463.   glutAddMenuEntry("destroy sub window", 414);
  464.   glutAddMenuEntry("destroy color index win 6", 416);
  465.   glutAddMenuEntry("destroy color index win 7", 417);
  467. /* Window manager stuff */
  469.   menu5 = glutCreateMenu(menuFunc);
  470.   glutAddMenuEntry("move current win", 430);
  471.   glutAddMenuEntry("resize current win", 431);
  472.   glutAddMenuEntry("iconify current win", 432);
  473.   glutAddMenuEntry("show current win", 433);
  474.   glutAddMenuEntry("hide current win", 434);
  475.   glutAddMenuEntry("push current win", 435);
  476.   glutAddMenuEntry("pop current win", 436);
  477.   glutAddMenuEntry(" ", 9999);
  478.   glutAddMenuEntry("move win 1", 420);
  479.   glutAddMenuEntry("resize win 1", 421);
  480.   glutAddMenuEntry("iconify win 1", 422);
  481.   glutAddMenuEntry("show win 1", 423);
  482.   glutAddMenuEntry("hide win 1", 424);
  483.   glutAddMenuEntry("push win 1", 425);
  484.   glutAddMenuEntry("pop win 1", 426);
  486. /* Gfx modes */
  488.   createMenu6();        /* build dynamically  */
  490. /* Texty reports */
  492.   menu7 = glutCreateMenu(menuFunc);
  493.   glutAddMenuEntry("report current win modes", 700);
  494.   glutAddMenuEntry("report current device data", 701);
  495.   glutAddMenuEntry("check OpenGL extensions", 702);
  496.   glutAddMenuEntry("dump internal data (d)", 703);
  498. /* Play with menus */
  500.   menu8 = glutCreateMenu(menuFunc);
  501.   glutAddMenuEntry("toggle menus on left button", 805);
  502.   glutAddMenuEntry("toggle menus on middle button", 806);
  503.   glutAddMenuEntry("toggle menus on right button", 807);
  504.   glutAddMenuEntry("---------------------------", 9999);
  505.   glutAddMenuEntry("add plain items", 800);
  506.   glutAddMenuEntry("add submenu items", 801);
  507.   glutAddMenuEntry("change new entries to plain items", 802);
  508.   glutAddMenuEntry("change new entries to submenus", 803);
  509.   glutAddMenuEntry("remove all new items", 804);
  510.   glutAddMenuEntry("---------------------------", 9999);
  512. /* Main menu */
  514.   menu1 = glutCreateMenu(menuFunc);
  515.   glutAddSubMenu("control", menu2);
  516.   glutAddSubMenu("shapes", menu3);
  517.   glutAddSubMenu("windows", menu4);
  518.   glutAddSubMenu("window ops", menu5);
  519.   glutAddSubMenu("gfx modes", menu6);
  520.   glutAddSubMenu("reports", menu7);
  521.   glutAddSubMenu("menus", menu8);
  522.   glutAddMenuEntry("help (h)", 101);
  523.   glutAddMenuEntry("quit (esc)", 100);
  524. }
  526. /* createMenu6 - Dynamically rebuild menu of display modes to
  527.    show current choices */
  529. void
  530. createMenu6(void)
  531. {
  532.   char str[100];
  533.   int i;
  535.   if (menu6 != 0)
  536.     glutDestroyMenu(menu6);
  537.   menu6 = glutCreateMenu(menuFunc);
  539.   for (i = 0; i < MODES; i++) {
  540.     sprintf(str, "%srequest %s", (modes[i] ? "+ " : "   "), modeNames[i]);
  541.     glutAddMenuEntry(str, 602 + i);
  542.   }
  543. }
  545. /* menuFunc - Process return codes from popup menus */
  547. void
  548. menuFunc(int value)
  549. {
  550.   static int initItems = 10;
  551.   int items, m;
  553.   if (initItems == 0) {
  554.     glutSetMenu(menu8);
  555.     initItems = glutGet(GLUT_MENU_NUM_ITEMS);
  556.   }
  557.   PR("Menu returned value %d n", value);
  559.   switch (value) {
  561. /* GLUT shapes */
  563.   case 200:
  564.   case 201:
  565.   case 202:
  566.   case 203:
  567.   case 204:
  568.   case 205:
  569.   case 206:
  570.   case 207:
  571.   case 208:
  572.     redefineShapes(value - 200);
  573.     break;
  575. /* Overall controls */
  577.   case 300:
  578.     menuFreeze = !menuFreeze;
  579.     break;
  581.   case 301:
  582.     text[idToIndex(glutGetWindow())] = !(text[idToIndex(glutGetWindow())]);
  583.     break;
  585.   case 302:
  586.     timerOn = !timerOn;
  587.     if (timerOn)
  588.       glutTimerFunc(DELAY, timerFunc, 1);
  589.     break;
  591.   case 303:
  592.     animation = !animation;
  593.     if (animation)
  594.       glutIdleFunc(idleFunc);
  595.     else
  596.       glutIdleFunc(NULL);
  597.     break;
  599.   case 304:
  600.     winFreeze[idToIndex(glutGetWindow())] = !(winFreeze[idToIndex(
  601.           glutGetWindow())]);
  602.     break;
  604.   case 305:
  605.     debug = !debug;
  606.     break;
  608.   case 307:
  609.     backdrop = !backdrop;
  610.     break;
  612.   case 308:
  613.     passive = !passive;
  614.     if (passive)
  615.       glutPassiveMotionFunc(passiveMotionFunc);
  616.     else
  617.       glutPassiveMotionFunc(NULL);
  618.     break;
  620.   case 310:
  621.     lineWidth += 1;
  622.     updateAll();
  623.     break;
  625.   case 311:
  626.     lineWidth -= 1;
  627.     if (lineWidth < 1)
  628.       lineWidth = 1;
  629.     updateAll();
  630.     break;
  632.   case 312:
  633.     demoMode = !demoMode;
  634.     if (demoMode)
  635.       autoDemo(-2);
  636.     break;
  638. /* Window create/destroy. */
  640. /* Creates */
  642.   case 400:
  643.     makeWindow(0);
  644.     break;
  646.   case 401:
  647.     makeWindow(1);
  648.     break;
  650.   case 402:
  651.     makeWindow(2);
  652.     break;
  654.   case 403:
  655.     makeWindow(3);
  656.     break;
  658.   case 404:
  659.     makeWindow(4);
  660.     break;
  662.   case 406:
  663.     makeWindow(6);
  664.     break;
  666.   case 407:
  667.     makeWindow(7);
  668.     break;
  670. /* Destroys */
  672.   case 410:
  673.     killWindow(0);
  674.     break;
  676.   case 411:
  677.     killWindow(1);
  678.     break;
  680.   case 412:
  681.     killWindow(2);
  682.     break;
  684.   case 413:
  685.     killWindow(3);
  686.     break;
  688.   case 414:
  689.     killWindow(4);
  690.     break;
  692.   case 416:
  693.     killWindow(6);
  694.     break;
  696.   case 417:
  697.     killWindow(7);
  698.     break;
  700.   case 450:
  701.     makeAllWindows();
  702.     break;
  704.   case 451:
  705.     killAllWindows();
  706.     break;
  708. /* Window movements etc. */
  710.   case 420:
  711.     positionWindow(1);
  712.     break;
  714.   case 421:
  715.     reshapeWindow(1);
  716.     break;
  718.   case 422:
  719.     iconifyWindow(1);
  720.     break;
  722.   case 423:
  723.     showWindow(1);
  724.     break;
  726.   case 424:
  727.     hideWindow(1);
  728.     break;
  730.   case 425:
  731.     pushWindow(1);
  732.     break;
  734.   case 426:
  735.     popWindow(1);
  736.     break;
  738.   case 430:
  739.     positionWindow(idToIndex(glutGetWindow()));
  740.     break;
  742.   case 431:
  743.     reshapeWindow(idToIndex(glutGetWindow()));
  744.     break;
  746.   case 432:
  747.     iconifyWindow(idToIndex(glutGetWindow()));
  748.     break;
  750.   case 433:
  751.     showWindow(idToIndex(glutGetWindow()));
  752.     break;
  754.   case 434:
  755.     hideWindow(idToIndex(glutGetWindow()));
  756.     break;
  758.   case 435:
  759.     pushWindow(idToIndex(glutGetWindow()));
  760.     break;
  762.   case 436:
  763.     popWindow(idToIndex(glutGetWindow()));
  764.     break;
  766. /* Test gfx modes. */
  768.   case 600:
  769.     makeWindow(3);
  770.     break;
  772.   case 601:
  773.     killWindow(3);
  774.     break;
  776.   case 602:
  777.   case 603:
  778.   case 604:
  779.   case 605:
  780.   case 606:
  781.   case 607:
  782.   case 608:
  783.   case 609:
  784.   case 610:
  785.   case 611:
  786.     modes[value - 602] = !modes[value - 602];
  787.     setInitDisplayMode();
  788.     break;
  790. /* Text reports */
  792. /* This is pretty ugly. */
  794. #define INDENT 30
  795. #define REPORTSTART(text)                          
  796.         printf("n" text "n");                    
  797.         textPtr[0] = (char *)malloc(strlen(text)+1); 
  798. strcpy(textPtr[0], text);                  
  799.         textCount = 1;
  801. #define REPORTEND                                  
  802.         scrollLine = 0;                            
  803.         textPtr[textCount] = NULL;                 
  804.         makeWindow(8);                             
  805.         updateText();
  807. #define GLUTGET(name)                              
  808.        {                                           
  809.           char str[100], str2[100];                
  810.           int s, len;                              
  811.           sprintf(str, # name);                    
  812.           len = (int) strlen(# name);              
  813.           for(s = 0 ; s < INDENT-len; s++)         
  814.             strcat(str, " ");                      
  815.           sprintf(str2, ": %dn",glutGet(name));   
  816.   strcat(str, str2);                       
  817.   printf(str);                             
  818.   textPtr[textCount] = stralloc(str);      
  819.     textCount++;                             
  820.        }
  822.   case 700:
  824.     printf("XXXXXX glutGetWindow = %dn", glutGetWindow());
  825.     REPORTSTART("glutGet():");
  827.     GLUTGET(GLUT_WINDOW_X);
  828.     GLUTGET(GLUT_WINDOW_Y);
  829.     GLUTGET(GLUT_WINDOW_WIDTH);
  830.     GLUTGET(GLUT_WINDOW_HEIGHT);
  831.     GLUTGET(GLUT_WINDOW_BUFFER_SIZE);
  832.     GLUTGET(GLUT_WINDOW_STENCIL_SIZE);
  833.     GLUTGET(GLUT_WINDOW_DEPTH_SIZE);
  834.     GLUTGET(GLUT_WINDOW_RED_SIZE);
  835.     GLUTGET(GLUT_WINDOW_GREEN_SIZE);
  836.     GLUTGET(GLUT_WINDOW_BLUE_SIZE);
  837.     GLUTGET(GLUT_WINDOW_ALPHA_SIZE);
  838.     GLUTGET(GLUT_WINDOW_ACCUM_RED_SIZE);
  839.     GLUTGET(GLUT_WINDOW_ACCUM_GREEN_SIZE);
  840.     GLUTGET(GLUT_WINDOW_ACCUM_BLUE_SIZE);
  841.     GLUTGET(GLUT_WINDOW_ACCUM_ALPHA_SIZE);
  842.     GLUTGET(GLUT_WINDOW_DOUBLEBUFFER);
  843.     GLUTGET(GLUT_WINDOW_RGBA);
  844.     GLUTGET(GLUT_WINDOW_PARENT);
  845.     GLUTGET(GLUT_WINDOW_NUM_CHILDREN);
  846.     GLUTGET(GLUT_WINDOW_COLORMAP_SIZE);
  847.     GLUTGET(GLUT_WINDOW_NUM_SAMPLES);
  848.     GLUTGET(GLUT_STEREO);
  849.     GLUTGET(GLUT_SCREEN_WIDTH);
  850.     GLUTGET(GLUT_SCREEN_HEIGHT);
  851.     GLUTGET(GLUT_SCREEN_HEIGHT_MM);
  852.     GLUTGET(GLUT_SCREEN_WIDTH_MM);
  853.     GLUTGET(GLUT_MENU_NUM_ITEMS);
  854.     GLUTGET(GLUT_DISPLAY_MODE_POSSIBLE);
  855.     GLUTGET(GLUT_INIT_DISPLAY_MODE);
  856.     GLUTGET(GLUT_INIT_WINDOW_X);
  857.     GLUTGET(GLUT_INIT_WINDOW_Y);
  858.     GLUTGET(GLUT_INIT_WINDOW_WIDTH);
  859.     GLUTGET(GLUT_INIT_WINDOW_HEIGHT);
  860.     GLUTGET(GLUT_ELAPSED_TIME);
  862.     REPORTEND;
  863.     break;
  865. #define GLUTDEVGET(name)                         
  866.         {                                        
  867.           char str[100], str2[100];              
  868.           int len, s;                            
  869.           sprintf(str, # name);                  
  870.           len = (int) strlen(# name);            
  871.           for(s = 0 ; s < INDENT-len; s++)       
  872.             strcat(str, " ");                    
  873.           sprintf(str2, ": %dn",                
  874.      glutDeviceGet(name));               
  875.   strcat(str, str2);                     
  876.   printf(str);                           
  877.   textPtr[textCount] = stralloc(str);    
  878.     textCount++;                           
  879. }
  881.   case 701:
  882.     REPORTSTART("glutDeviceGet():");
  884.     GLUTDEVGET(GLUT_HAS_KEYBOARD);
  885.     GLUTDEVGET(GLUT_HAS_MOUSE);
  886.     GLUTDEVGET(GLUT_HAS_SPACEBALL);
  887.     GLUTDEVGET(GLUT_HAS_DIAL_AND_BUTTON_BOX);
  888.     GLUTDEVGET(GLUT_HAS_TABLET);
  889.     GLUTDEVGET(GLUT_NUM_MOUSE_BUTTONS);
  890.     GLUTDEVGET(GLUT_NUM_SPACEBALL_BUTTONS);
  891.     GLUTDEVGET(GLUT_NUM_BUTTON_BOX_BUTTONS);
  892.     GLUTDEVGET(GLUT_NUM_DIALS);
  893.     GLUTDEVGET(GLUT_NUM_TABLET_BUTTONS);
  895.     REPORTEND;
  896.     break;
  898. #define EXTCHECK(name)                           
  899.         {                                        
  900.           char str[100], str2[100];              
  901.           int len, s;                            
  902.           sprintf(str, # name);                  
  903.           len = (int) strlen(# name);            
  904.           for(s = 0 ; s < INDENT-len; s++)       
  905.             strcat(str, " ");                    
  906.           sprintf(str2, ": %sn",                
  907.      glutExtensionSupported(# name)?     
  908.        "yes": "no");                     
  909.   strcat(str, str2);                     
  910.   printf(str);                           
  911.   textPtr[textCount] = stralloc(str);    
  912.     textCount++;                           
  913.         }
  915.   case 702:
  916.     REPORTSTART("glutExtensionSupported():");
  918.     EXTCHECK(GL_EXT_abgr);
  919.     EXTCHECK(GL_EXT_blend_color);
  920.     EXTCHECK(GL_EXT_blend_minmax);
  921.     EXTCHECK(GL_EXT_blend_logic_op);
  922.     EXTCHECK(GL_EXT_blend_subtract);
  923.     EXTCHECK(GL_EXT_polygon_offset);
  924.     EXTCHECK(GL_EXT_texture);
  925.     EXTCHECK(GL_EXT_guaranteed_to_fail);
  926.     EXTCHECK(GLX_SGI_swap_control);
  927.     EXTCHECK(GLX_SGI_video_sync);
  928.     EXTCHECK(GLX_SGIS_multi_sample);
  930.     REPORTEND;
  931.     break;
  933.   case 703:
  934.     dumpIds();
  935.     break;
  937. /* Mess around with menus */
  939.   case 800:
  940.     if (glutGetMenu() != menu8)  /* just a test  */
  941.       printf("glutGetMenu() returned unexpected valuen");
  942.     glutAddMenuEntry("help", 101);
  943.     glutAddMenuEntry("help", 101);
  944.     glutAddMenuEntry("help", 101);
  945.     glutAddMenuEntry("help", 101);
  946.     glutAddMenuEntry("help", 101);
  947.     break;
  949.   case 801:
  950.     glutAddSubMenu("shapes", menu3);
  951.     glutAddSubMenu("shapes", menu3);
  952.     glutAddSubMenu("shapes (a long string to break menus with)", menu3);
  953.     glutAddSubMenu("shapes", menu3);
  954.     glutAddSubMenu("shapes", menu3);
  955.     break;
  957.   case 802:
  958.     items = glutGet(GLUT_MENU_NUM_ITEMS);
  959.     for (m = initItems + 1; m <= items; m++) {
  960.       glutChangeToMenuEntry(m, "help", 101);
  961.     }
  962.     break;
  964.   case 803:
  965.     items = glutGet(GLUT_MENU_NUM_ITEMS);
  966.     for (m = initItems + 1; m <= items; m++) {
  967.       glutChangeToSubMenu(m, "shapes", menu3);
  968.     }
  969.     break;
  971.   case 804:
  972.     items = glutGet(GLUT_MENU_NUM_ITEMS);
  973.     /* reverse order so renumbering not aproblem  */
  974.     for (m = items; m >= initItems + 1; m--) {
  975.       glutRemoveMenuItem(m);
  976.     }
  977.     break;
  979.   case 805:
  980.     menuButton[0] = !menuButton[0];
  981.     attachMenus();
  982.     break;
  984.   case 806:
  985.     menuButton[1] = !menuButton[1];
  986.     attachMenus();
  987.     break;
  989.   case 807:
  990.     menuButton[2] = !menuButton[2];
  991.     attachMenus();
  992.     break;
  994. /* Direct menu items.  */
  996.   case 100:
  997.     exit(0);
  998.     break;
  1000.   case 101:
  1001.     if (winId[5] == 0)
  1002.       makeWindow(5);
  1003.     else
  1004.       killWindow(5);
  1005.     break;
  1007.   case 9999:
  1008.     break;
  1010.   default:
  1011.     fprintf(stderr, "07Unhandled case %d in menu callbackn", value);
  1012.   }
  1014. }
  1016. /* redefineShapes - Remake the shapes display lists */
  1018. void
  1019. redefineShapes(int shape)
  1020. {
  1021.   int i;
  1023. #define C3                
  1024.      switch(i)        
  1025.  {                
  1026.      case 0:      
  1027.      case 3:      
  1028.        C1;        
  1029.        break;     
  1030.                   
  1031.      case 1:      
  1032.      case 2:      
  1033.      case 4:      
  1034.      case 6:      
  1035.      case 7:      
  1036.        C2;        
  1037.        break;     
  1038.  }                
  1039.  currentShape = shape
  1041.   for (i = 0; i < MAXWIN; i++) {
  1042.     if (winId[i]) {
  1043.       glutSetWindow(winId[i]);
  1044.       if (glIsList(i + 1))
  1045.         glDeleteLists(i + 1, 1);
  1046.       glNewList(i + 1, GL_COMPILE);
  1048.       switch (shape) {
  1050. #undef  C1
  1051. #define C1  glutSolidSphere(1.5, 10, 10)
  1052. #undef  C2
  1053. #define C2  glutWireSphere(1.5, 10, 10)
  1055.       case 0:
  1056.         C3;
  1057.         break;
  1059. #undef  C1
  1060. #define C1 glutSolidCube(2)
  1061. #undef  C2
  1062. #define C2 glutWireCube(2)
  1064.       case 1:
  1065.         C3;
  1066.         break;
  1068. #undef  C1
  1069. #define C1 glutSolidCone(1.5, 1.75, 10, 10);
  1070. #undef  C2
  1071. #define C2 glutWireCone(1.5, 1.75, 10, 10);
  1073.       case 2:
  1074.         C3;
  1075.         break;
  1077. #undef  C1
  1078. #define C1 glutSolidTorus(0.5, 1.1, 10, 10)
  1079. #undef  C2
  1080. #define C2 glutWireTorus(0.5, 1.1, 10, 10)
  1082.       case 3:
  1083.         C3;
  1084.         break;
  1086. #undef  C1
  1087. #define C1 glScalef(.8, .8, .8);glutSolidDodecahedron()
  1088. #undef  C2
  1089. #define C2 glScalef(.8, .8, .8);glutWireDodecahedron()
  1091.       case 4:
  1092.         C3;
  1093.         break;
  1095. #undef  C1
  1096. #define C1 glScalef(1.5, 1.5, 1.5);glutSolidOctahedron()
  1097. #undef  C2
  1098. #define C2 glScalef(1.5, 1.5, 1.5);glutWireOctahedron()
  1100.       case 5:
  1101.         C3;
  1102.         break;
  1104. #undef  C1
  1105. #define C1 glScalef(1.8, 1.8, 1.8);glutSolidTetrahedron()
  1106. #undef  C2
  1107. #define C2 glScalef(1.8, 1.8, 1.8);glutWireTetrahedron()
  1109.       case 6:
  1110.         C3;
  1111.         break;
  1113. #undef  C1
  1114. #define C1 glScalef(1.5, 1.5, 1.5);glutSolidIcosahedron()
  1115. #undef  C2
  1116. #define C2 glScalef(1.5, 1.5, 1.5);glutWireIcosahedron()
  1118.       case 7:
  1119.         C3;
  1120.         break;
  1122. #undef  C1
  1123. #define C1 glutSolidTeapot(1.5);
  1124. #undef  C2
  1125. #define C2 glutWireTeapot(1.5);
  1127.       case 8:
  1128.         C3;
  1129.         break;
  1130.       }
  1131.       glEndList();
  1132.     }
  1133.   }
  1134. }
  1136. /* positionWindow - Shift a window */
  1138. void
  1139. positionWindow(int index)
  1140. {
  1141.   int x, y;
  1143.   if (winId[index] == 0)
  1144.     return;
  1146.   glutSetWindow(winId[index]);
  1147.   x = glutGet(GLUT_WINDOW_X);
  1148.   y = glutGet(GLUT_WINDOW_Y);
  1149.   glutPositionWindow(x + 50, y + 50);
  1150. }
  1152. /* reshapeWindow - Change window size a little */
  1154. void
  1155. reshapeWindow(int index)
  1156. {
  1157.   int x, y;
  1159.   if (winId[index] == 0)
  1160.     return;
  1161.   glutSetWindow(winId[index]);
  1162.   x = glutGet(GLUT_WINDOW_WIDTH);
  1163.   y = glutGet(GLUT_WINDOW_HEIGHT);
  1164. /* glutReshapeWindow(x * (index % 2? 0.8: 1.2), y * (index % 2? 
  1166.    1.2: 0.8)); */
  1167.   glutReshapeWindow((int) (x * 1.0), (int) (y * 0.8));
  1168. }
  1170. /* iconifyWindow - Iconify a window */
  1172. void
  1173. iconifyWindow(int index)
  1174. {
  1175.   if (winId[index] == 0)
  1176.     return;
  1177.   glutSetWindow(winId[index]);
  1178.   glutIconifyWindow();
  1179. }
  1181. /* showWindow - Show a window (map or uniconify it) */
  1183. void
  1184. showWindow(int index)
  1185. {
  1186.   if (winId[index] == 0)
  1187.     return;
  1188.   glutSetWindow(winId[index]);
  1189.   glutShowWindow();
  1190. }
  1192. /* hideWindow - Hide a window (unmap it) */
  1194. void
  1195. hideWindow(int index)
  1196. {
  1197.   if (winId[index] == 0)
  1198.     return;
  1199.   glutSetWindow(winId[index]);
  1200.   glutHideWindow();
  1201. }
  1203. /* pushWindow - Push a window */
  1205. void
  1206. pushWindow(int index)
  1207. {
  1208.   if (winId[index] == 0)
  1209.     return;
  1210.   glutSetWindow(winId[index]);
  1211.   glutPushWindow();
  1212. }
  1214. /* popWindow - Pop a window */
  1216. void
  1217. popWindow(int index)
  1218. {
  1219.   if (winId[index] == 0)
  1220.     return;
  1221.   glutSetWindow(winId[index]);
  1222.   glutPopWindow();
  1223. }
  1225. /* drawScene - Draw callback, triggered by expose events etc.
  1226.    in GLUT. */
  1228. void
  1229. drawScene(void)
  1230. {
  1231.   int winIndex;
  1233.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  1235.   winIndex = idToIndex(glutGetWindow());
  1236.   /* printf("drawScene for index %d, id %dn", winIndex,
  1237.      glutGetWindow());  */
  1239.   glPushMatrix();
  1240.   glLineWidth(lineWidth);
  1241.   if (backdrop)
  1242.     glCallList(100);
  1244.   /* Left button spinning  */
  1246.   trackBall(APPLY, 0, 0, 0, 0);
  1248.   /* Apply continuous spinning  */
  1250.   glRotatef(angle, 0, 1, 0);
  1252.   glCallList(winIndex + 1);
  1253.   glPopMatrix();
  1255.   if (text[winIndex])
  1256.     showText();
  1258.   glutSwapBuffers();
  1259. }
  1261. /* showText - Render some text in the current GLUT window */
  1263. void
  1264. showText(void)
  1265. {
  1266.   glMatrixMode(GL_PROJECTION);
  1267.   glPushMatrix();
  1268.   glLoadIdentity();
  1269.   gluOrtho2D(0, 100, 0, 100);
  1270.   glMatrixMode(GL_MODELVIEW);
  1271.   glPushMatrix();
  1272.   glLoadIdentity();
  1274.   glColor3f(1.0, 1.0, 1.0);
  1275.   glIndexi(7);
  1277.   glDisable(GL_DEPTH_TEST);
  1278.   glDisable(GL_LIGHTING);
  1280.   glLineWidth(lineWidth);
  1282.   textString(1, 1, "GLUT_BITMAP_8_BY_13", GLUT_BITMAP_8_BY_13);
  1283.   textString(1, 5, "GLUT_BITMAP_9_BY_15", GLUT_BITMAP_9_BY_15);
  1284.   textString(1, 10, "GLUT_BITMAP_TIMES_ROMAN_10", GLUT_BITMAP_TIMES_ROMAN_10);
  1285.   textString(1, 15, "GLUT_BITMAP_TIMES_ROMAN_24", GLUT_BITMAP_TIMES_ROMAN_24);
  1287.   strokeString(1, 25, "GLUT_STROKE_ROMAN", GLUT_STROKE_ROMAN);
  1288.   strokeString(1, 35, "GLUT_STROKE_MONO_ROMAN", GLUT_STROKE_MONO_ROMAN);
  1290.   glEnable(GL_DEPTH_TEST);
  1291.   glEnable(GL_LIGHTING);
  1293.   glMatrixMode(GL_PROJECTION);
  1294.   glPopMatrix();
  1295.   glMatrixMode(GL_MODELVIEW);
  1296.   glPopMatrix();
  1298. }
  1300. /* textString - Bitmap font string */
  1302. void
  1303. textString(int x, int y, char *msg, void *font)
  1304. {
  1305.   glRasterPos2f(x, y);
  1306.   while (*msg) {
  1307.     glutBitmapCharacter(font, *msg);
  1308.     msg++;
  1309.   }
  1310. }
  1312. /* strokeString - Stroke font string */
  1314. void
  1315. strokeString(int x, int y, char *msg, void *font)
  1316. {
  1317.   glPushMatrix();
  1318.   glTranslatef(x, y, 0);
  1319.   glScalef(.04, .04, .04);
  1320.   while (*msg) {
  1321.     glutStrokeCharacter(font, *msg);
  1322.     msg++;
  1323.   }
  1324.   glPopMatrix();
  1325. }
  1327. /* idleFunc - GLUT idle func callback - animates windows */
  1329. void
  1330. idleFunc(void)
  1331. {
  1332.   int i;
  1334.   if (!leftDown && !middleDown)
  1335.     angle += 1;
  1336.     angle = angle % 360;
  1338.   for (i = 0; i < MAXWIN; i++) {
  1339.     if (winId[i] && winVis[i] && !winFreeze[i]) {
  1340.       glutSetWindow(winId[i]);
  1341.       glutPostRedisplay();
  1342.     }
  1343.   }
  1344. }
  1346. /* reshapeFunc - Reshape callback. */
  1348. void
  1349. reshapeFunc(int width, int height)
  1350. {
  1351.   int winId;
  1352.   float aspect;
  1354.   winId = glutGetWindow();
  1355.   PR("reshape callback for window id %d n", winId);
  1357.   glViewport(0, 0, width, height);
  1358.   aspect = (float) width / height;
  1360.   glMatrixMode(GL_PROJECTION);
  1361.   glLoadIdentity();
  1362.   gluPerspective(40.0, aspect, 1.0, 20.0);
  1363.   glMatrixMode(GL_MODELVIEW);
  1364. }
  1366. /* visible - Visibility callback. Turn off rendering in
  1367.    invisible windows */
  1369. void
  1370. visible(int state)
  1371. {
  1372.   int winId;
  1373.   static GLboolean someVisible = GL_TRUE;
  1375.   winId = glutGetWindow();
  1376.   /* printf("visible: state = %d n", state);  */
  1378.   if (state == GLUT_VISIBLE) {
  1379.     PR("Window id %d visible n", winId);
  1380.     winVis[idToIndex(winId)] = GL_TRUE;
  1381.   } else {
  1382.     PR("Window %d not visible n", winId);
  1383.     winVis[idToIndex(winId)] = GL_FALSE;
  1384.   }
  1386.   if ((winVis[0] == GL_FALSE) && (winVis[1] == GL_FALSE) && (winVis[2] == GL_FALSE)
  1387.     && (winVis[3] == GL_FALSE) && (winVis[6] == GL_FALSE) && (winVis[7] ==
  1388.       GL_FALSE)) {
  1389.     glutIdleFunc(NULL);
  1390.     PR("All windows not visible; idle func disabledn");
  1391.     someVisible = GL_FALSE;
  1392.   } else {
  1393.     if (!someVisible) {
  1394.       PR("Some windows now visible; idle func enabledn");
  1395.       someVisible = GL_TRUE;
  1396.       if (animation)
  1397.         glutIdleFunc(idleFunc);
  1398.     }
  1399.   }
  1400. }
  1402. /* keyFunc - Ascii key callback */
  1404. /* ARGSUSED1 */
  1405. void
  1406. keyFunc(unsigned char key, int x, int y)
  1407. {
  1408.   int i, ii;
  1410.   if (debug || showKeys)
  1411.     printf("Ascii key '%c' 0x%02xn", key, key);
  1413.   switch (key) {
  1414.   case 0x1b:
  1415.     exit(0);
  1416.     break;
  1418.   case 'a':
  1419.     demoMode = !demoMode;
  1420.     if (demoMode)
  1421.       autoDemo(-2);
  1422.     break;
  1424.   case 's':
  1425.     AUTODELAY = AUTODELAY * 0.666;
  1426.     break;
  1428.   case 'S':
  1429.     AUTODELAY = AUTODELAY * 1.5;
  1430.     break;
  1432.   case 'q':
  1433.     killWindow(idToIndex(glutGetWindow()));
  1434.     break;
  1436.   case 'k':
  1437.     showKeys = !showKeys;
  1438.     break;
  1440.   case 'p':
  1441.     demoMode = !demoMode;
  1442.     if (demoMode)
  1443.       autoDemo(-999);
  1444.     break;
  1446.   case 'D':
  1447.     debug = !debug;
  1448.     break;
  1450.   case 'd':
  1451.     dumpIds();
  1452.     break;
  1454.   case 'h':
  1455.     if (winId[5] == 0)
  1456.       makeWindow(5);
  1457.     else
  1458.       killWindow(5);
  1459.     break;
  1461.   case 't':
  1462.     ii = idToIndex(glutGetWindow());
  1463.     text[ii] = !text[ii];
  1464.     break;
  1466.   case 'r':
  1467.     trackBall(RESET, 0, 0, 0, 0);
  1468.     break;
  1470.   case 'l':
  1471.     lineWidth += 1;
  1472.     updateAll();
  1473.     break;
  1475.   case 'L':
  1476.     lineWidth -= 1;
  1477.     if (lineWidth < 1)
  1478.       lineWidth = 1;
  1479.     updateAll();
  1480.     break;
  1482.   case '0':
  1483.   case '1':
  1484.   case '2':
  1485.   case '3':
  1486.   case '4':
  1487.   case '6':
  1488.     i = key - '0';
  1489.     winVis[i] = !winVis[i];
  1490.     break;
  1492.   case ')':
  1493.     makeWindow(0);
  1494.     break;
  1496.   case '!':
  1497.     makeWindow(1);
  1498.     break;
  1500.   case '@':
  1501.     makeWindow(2);
  1502.     break;
  1504.   case '#':
  1505.     makeWindow(3);
  1506.     break;
  1508.   }
  1509. }
  1511. /* specialFunc - Special keys callback (F keys, cursor keys
  1512.    etc. */
  1514. /* ARGSUSED1 */
  1515. void
  1516. specialFunc(int key, int x, int y)
  1517. {
  1518.   if (debug || showKeys)
  1519.     printf("Special key %dn", key);
  1521.   switch (key) {
  1522.   case GLUT_KEY_PAGE_DOWN:
  1523.     scrollLine += 10;
  1524.     updateHelp();
  1525.     updateText();
  1526.     break;
  1528.   case GLUT_KEY_PAGE_UP:
  1529.     scrollLine -= 10;
  1530.     updateHelp();
  1531.     updateText();
  1532.     break;
  1534.   case GLUT_KEY_DOWN:
  1535.     scrollLine += 1;
  1536.     updateHelp();
  1537.     updateText();
  1538.     break;
  1540.   case GLUT_KEY_UP:
  1541.     scrollLine -= 1;
  1542.     updateHelp();
  1543.     updateText();
  1544.     break;
  1546.   case GLUT_KEY_HOME:
  1547.     scrollLine = 0;
  1548.     updateHelp();
  1549.     updateText();
  1550.     break;
  1552.   case GLUT_KEY_END:
  1553.     scrollLine = 9999;
  1554.     updateHelp();
  1555.     updateText();
  1556.     break;
  1558.   case GLUT_KEY_RIGHT:
  1559.     scrollCol -= 1;
  1560.     updateHelp();
  1561.     updateText();
  1562.     break;
  1564.   case GLUT_KEY_LEFT:
  1565.     scrollCol += 1;
  1566.     updateHelp();
  1567.     updateText();
  1568.     break;
  1569.   }
  1570. }
  1572. /* mouseFunc - Mouse button callback */
  1574. void
  1575. mouseFunc(int button, int state, int x, int y)
  1576. {
  1577.   PR("Mouse button %d, state %d, at pos %d, %dn", button, state, x, y);
  1579.   trackBall(MOUSEBUTTON, button, state, x, y);
  1580. }
  1582. /* motionFunc - Mouse movement (with a button down) callback */
  1584. void
  1585. motionFunc(int x, int y)
  1586. {
  1587.   PR("Mouse motion at %d, %dn", x, y);
  1589.   trackBall(MOUSEMOTION, 0, 0, x, y);
  1591.   glutPostRedisplay();
  1592. }
  1594. /* passiveMotionFunc - Mouse movement (with no button down)
  1595.    callback */
  1597. void
  1598. passiveMotionFunc(int x, int y)
  1599. {
  1600.   printf("Mouse motion at %d, %dn", x, y);
  1601. }
  1603. /* entryFunc - Window entry event callback */
  1605. void
  1606. entryFunc(int state)
  1607. {
  1608.   int winId = glutGetWindow();
  1609.   PR("Entry event: window id %d (index %d), state %d n", winId, idToIndex(
  1610.       winId), state);
  1611. }
  1613. /* menuStateFunc - Callback to tell us when menus are popped
  1614.    up/down. */
  1616. int menu_state = GLUT_MENU_NOT_IN_USE;
  1618. void
  1619. menuStateFunc(int state)
  1620. {
  1621.   printf("menu stated = %dn", state);
  1622.   menu_state = state;
  1624.   if (glutGetWindow() == 0) {
  1625.     PR("menuStateFunc: window invalidn");
  1626.     return;
  1627.   }
  1628.   PR("Menus are%sin usen", state == GLUT_MENU_IN_USE ? " " : " not ");
  1630.   if ((state == GLUT_MENU_IN_USE) && menuFreeze)
  1631.     glutIdleFunc(NULL);
  1632.   else if (animation)
  1633.     glutIdleFunc(idleFunc);
  1634. }
  1636. /* timerFunc - General test of global timer */
  1638. void
  1639. timerFunc(int value)
  1640. {
  1641.   printf("timer callback: value %dn", value);
  1642.   if (timerOn) {
  1643.     glutTimerFunc(DELAY, timerFunc, 1);
  1644.   }
  1645. }
  1647. #if 0
  1648. /* delayedReinstateMenuStateCallback - Hack to reinstate
  1649.    MenuStateCallback after a while.  */
  1651. void
  1652. delayedReinstateMenuStateCallback(int state)
  1653. {
  1654.   glutMenuStateFunc(menuStateFunc);
  1655. }
  1657. #endif
  1659. /* setInitDisplayMode - update display modes from display mode
  1660.    menu */
  1662. void
  1663. setInitDisplayMode(void)
  1664. {
  1665.   int i;
  1667.   displayMode = 0;
  1669.   for (i = 0; i < MODES; i++) {
  1670.     if (modes[i]) {
  1671.       /* printf("Requesting %s n", modeNames[i]);  */
  1672.       displayMode |= glutMode[i];
  1673.     }
  1674.   }
  1676.   glutInitDisplayMode(displayMode);
  1678.   createMenu6();
  1679.   if (!glutGet(GLUT_DISPLAY_MODE_POSSIBLE))
  1680.     warning("This display mode not supportedn");
  1681. }
  1683. /* makeWindow - Create one of the windows */
  1685. void
  1686. makeWindow(int index)
  1687. {
  1688.   char str[99];
  1690.   if (winId[index] != 0) {
  1691.     /* warning("Attempt to create window which is already
  1692.        created");  */
  1693.     return;
  1694.   }
  1695.   switch (index) {
  1697.   case 0:              /* ordinary RGB windows  */
  1698.   case 1:
  1699.   case 2:
  1700.   case 3:
  1702.     setInitDisplayMode();
  1703.     glutInitWindowPosition(pos[index][0], pos[index][1]);
  1704.     glutInitWindowSize(size[index][0], size[index][1]);
  1705.     winId[index] = glutCreateWindow(" ");
  1706.     PR("Window %d id = %d n", index, winId[index]);
  1707.     gfxInit(index);
  1709.     addCallbacks();
  1711.     sprintf(str, "window %d (RGB)", index);
  1712.     glutSetWindowTitle(str);
  1713.     sprintf(str, "icon %d", index);
  1714.     glutSetIconTitle(str);
  1715.     glutSetMenu(menu1);
  1716.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  1717.     break;
  1719.   case 4:              /* subwindow  */
  1721.     setInitDisplayMode();
  1722.     winId[index] = glutCreateSubWindow(winId[0], pos[index][0], pos[index]
  1723.       [1], size[index][0], size[index][1]);
  1724.     PR("Window %d id = %d n", index, winId[index]);
  1725.     gfxInit(index);
  1726.     glutDisplayFunc(drawScene);
  1727.     glutVisibilityFunc(visible);
  1728.     glutReshapeFunc(reshapeFunc);
  1730.     break;
  1732.   case 5:              /* help window  */
  1733.   case 8:              /* text window  */
  1734.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  1735.     glutInitWindowPosition(pos[index][0], pos[index][1]);
  1736.     glutInitWindowSize(size[index][0], size[index][1]);
  1737.     winId[index] = glutCreateWindow(" ");
  1738.     PR("Window %d id = %d n", index, winId[index]);
  1740.     /* addCallbacks();  */
  1741.     glutKeyboardFunc(keyFunc);
  1742.     glutSpecialFunc(specialFunc);
  1744.     glClearColor(0.15, 0.15, 0.15, 1.0);
  1745.     glColor3f(1, 1, 1);
  1746.     glMatrixMode(GL_PROJECTION);
  1747.     glLoadIdentity();
  1748.     gluOrtho2D(0, 300, 0, 100);
  1749.     glMatrixMode(GL_MODELVIEW);
  1750.     glLoadIdentity();
  1752.     if (index == 5) {
  1753.       glutDisplayFunc(updateHelp);
  1754.       glutSetWindowTitle("help (RGB) win 5");
  1755.       glutSetIconTitle("help");
  1756.     } else {
  1757.       glutDisplayFunc(updateText);
  1758.       glutSetWindowTitle("text (RGB) win 8");
  1759.       glutSetIconTitle("text");
  1760.     }
  1761.     glutSetMenu(menu1);
  1762.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  1763.     break;
  1765.   case 6:              /* color index window  */
  1766.   case 7:              /* color index window  */
  1767.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_INDEX | GLUT_DEPTH);
  1768.  if (glutGet(GLUT_DISPLAY_MODE_POSSIBLE)) {
  1769.  glutInitWindowPosition(pos[index][0], pos[index][1]);
  1770.  glutInitWindowSize(size[index][0], size[index][1]);
  1771.  winId[index] = glutCreateWindow(" ");
  1772.  PR("Window %d id = %d n", index, winId[index]);
  1774.  gfxInit(index);
  1776.  addCallbacks();
  1778.  sprintf(str, "window %d (color index)", index);
  1779.  glutSetWindowTitle(str);
  1780.  sprintf(str, "icon %d", index);
  1781.  glutSetIconTitle(str);
  1782.  glutSetMenu(menu1);
  1783.  glutAttachMenu(GLUT_RIGHT_BUTTON);
  1784.  }
  1785.     break;
  1787.   }
  1788. }
  1790. /* killWindow - Kill one of the main windows */
  1792. void
  1793. killWindow(int index)
  1794. {
  1795.   int i;
  1797.   if (winId[index] == 0) {
  1798.     /* fprintf(stderr, "Attempt to kill invalid window in
  1799.        killWindown");  */
  1800.     return;
  1801.   }
  1802.   PR("Killing win %dn", index);
  1803.   glutSetWindow(winId[index]);
  1805.   /* Disable all callbacks for safety, although
  1806.      glutDestroyWindow  should do this.  */
  1808.   removeCallbacks();
  1810.   glutDestroyWindow(winId[index]);
  1811.   winId[index] = 0;
  1812.   winVis[index] = GL_FALSE;
  1814. #if 0
  1815.   /* If we reinstate the menu state func here, prog breaks.  So
  1816.      reinstate it a little later.  */
  1817.   glutTimerFunc(MENUDELAY, delayedReinstateMenuStateCallback, 1);
  1818. #endif
  1820.   if (index == 5) {     /* help  */
  1821.     scrollLine = 0;
  1822.     scrollCol = 0;
  1823.   }
  1824.   if (index == 8) {     /* text window  */
  1825.     for (i = 0; textPtr[i] != NULL; i++) {
  1826.       free(textPtr[i]); /* free the text strings  */
  1827.       textPtr[i] = NULL;
  1828.     }
  1829.   }
  1830. }
  1832. /* addCallbacks - Add some standard callbacks after creating a
  1833.    window */
  1835. void
  1836. addCallbacks(void)
  1837. {
  1838.   glutDisplayFunc(drawScene);
  1839.   glutVisibilityFunc(visible);
  1840.   glutReshapeFunc(reshapeFunc);
  1841.   glutKeyboardFunc(keyFunc);
  1842.   glutSpecialFunc(specialFunc);
  1843.   glutMouseFunc(mouseFunc);
  1844.   glutMotionFunc(motionFunc);
  1845.   glutEntryFunc(entryFunc);
  1847. /* Callbacks for exotic input devices. Must get my dials &
  1848.    buttons back. */
  1850.   glutSpaceballMotionFunc(spaceballMotionCB);
  1851.   glutSpaceballRotateFunc(spaceballRotateCB);
  1852.   glutSpaceballButtonFunc(spaceballButtonCB);
  1854.   glutButtonBoxFunc(buttonBoxCB);
  1855.   glutDialsFunc(dialsCB);
  1857.   glutTabletMotionFunc(tabletMotionCB);
  1858.   glutTabletButtonFunc(tabletButtonCB);
  1859. }
  1861. /* removeCallbacks - Remove all callbacks before destroying a
  1862.    window. GLUT probably does this  anyway but we'll be safe. */
  1864. void
  1865. removeCallbacks(void)
  1866. {
  1867.   glutVisibilityFunc(NULL);
  1868.   glutReshapeFunc(NULL);
  1869.   glutKeyboardFunc(NULL);
  1870.   glutSpecialFunc(NULL);
  1871.   glutMouseFunc(NULL);
  1872.   glutMotionFunc(NULL);
  1873.   glutEntryFunc(NULL);
  1874. }
  1876. /* updateHelp - Update the help window after user scrolls. */
  1878. void
  1879. updateHelp(void)
  1880. {
  1881.   static char *helpPtr[] =
  1882.   {
  1883.     "(Use PGUP, PGDN, HOME, END, arrows to scroll help text)          ",
  1884.     "                                                                ",
  1885.     "A demo program for GLUT.                                        ",
  1886.     "G Edwards, Aug 95                                               ",
  1887.     "Exercises 99% of GLUT calls                                     ",
  1888.     VERSIONLONG,
  1889.     "                                                                ",
  1890.     "This text uses GLUT_STROKE_MONO_ROMAN font, a built-in vector font.",
  1891.     "(Try resizing the help window).                                 ",
  1892.     "                                                                ",
  1893.     "Keys:                                                           ",
  1894.     " esc   quit                                                     ",
  1895.     " t     toggle text on/off in each window                        ",
  1896.     " h     toggle help                                              ",
  1897.     " q     quit current window                                      ",
  1898.     " a     auto demo                                                ",
  1899.     " p     pause/unpause demo                                       ",
  1900.     " l     increase line width (gfx & stroke text)                  ",
  1901.     " L     decrease line width (gfx & stroke text)                  ",
  1902.     " r     reset transforms                                         ",
  1903.     " k     show keyboard events                                     ",
  1904.     " D     show all events                                          ",
  1905.     "                                                                ",
  1906.     "Mouse:                                                          ",
  1907.     " Left button:    rotate                                         ",
  1908.     " Middle button:  pan                                            ",
  1909.     " Left + middle:  zoom                                           ",
  1910.     NULL};
  1912.   updateScrollWindow(5, helpPtr);
  1913. }
  1915. /* updateText - Update a text window */
  1917. void
  1918. updateText(void)
  1919. {
  1920.   int i;
  1922.   if (textPtr[0] == NULL) {
  1923.     for (i = 0; i < 20; i++) {
  1924.       textPtr[i] = (char *) malloc(50);
  1925.       strcpy(textPtr[i], "no current text");
  1926.     }
  1927.     textPtr[20] = NULL;
  1928.   }
  1929.   updateScrollWindow(8, textPtr);
  1930. }
  1932. /* updateScrollWindow */
  1934. void
  1935. updateScrollWindow(int index, char **ptr)
  1936. {
  1937.   int i, j, lines = 0;
  1939.   if (winId[index] == 0)
  1940.     return;
  1942.   glutSetWindow(winId[index]);
  1944.   for (i = 0; ptr[i] != NULL; i++)
  1945.     lines++;
  1947.   if (scrollLine < 0)
  1948.     scrollLine = 0;
  1949.   if (scrollLine > (lines - 5))
  1950.     scrollLine = lines - 5;
  1952.   glClear(GL_COLOR_BUFFER_BIT);
  1954.   glLineWidth(lineWidth);
  1956.   for (i = scrollLine, j = 1; ptr[i] != NULL; i++, j++)
  1957.     strokeString(scrollCol * 50, 100 - j * 6, ptr[i],
  1958.       GLUT_STROKE_MONO_ROMAN);
  1960.   glutSwapBuffers();
  1962. }
  1964. /* updateAll - Update all visible windows after soem global
  1965.    change, eg. line width */
  1967. void
  1968. updateAll(void)
  1969. {
  1970.   int i;
  1972.   if (winId[5] != 0)
  1973.     updateHelp();
  1975.   if (winId[8] != 0)
  1976.     updateText();
  1978.   for (i = 0; i < MAXWIN; i++)
  1979.     if (winId[i]) {
  1980.       glutSetWindow(winId[i]);
  1981.       glutPostRedisplay();
  1982.     }
  1983. }
  1985. /* idToIndex - Convert GLUT window id to our internal index */
  1987. int
  1988. idToIndex(int id)
  1989. {
  1990.   int i;
  1991.   for (i = 0; i < MAXWIN; i++) {
  1992.     if (winId[i] == id)
  1993.       return i;
  1994.   }
  1995.   fprintf(stderr, "error: id %d not found n", id);
  1996.   return (-1);
  1997. }
  1999. /* warning - warning messages */
  2001. void
  2002. warning(char *msg)
  2003. {
  2004.   fprintf(stderr, "07");
  2006.   if (debug) {
  2007.     fprintf(stderr, "%s", msg);
  2008.     if (msg[strlen(msg)] != 'n')
  2009.       fprintf(stderr, "%s", "n");
  2010.   }
  2011. }
  2013. /* dumpIds - Debug: dump some internal data  */
  2015. void
  2016. dumpIds(void)
  2017. {
  2018.   int i, j;
  2020.   printf("nInternal data:n");
  2022.   for (i = 0; i < MAXWIN; i++)
  2023.     printf("Index %d, glut win id %d, visibility %dn", i, winId[i],
  2024.       winVis[i]);
  2026.   for (i = 0; i < MAXWIN; i++) {
  2027.     if (winId[i])
  2028.       glutSetWindow(winId[i]);
  2029.     else {
  2030.       printf("index %d - no glut windown", i);
  2031.       continue;
  2032.     }
  2034.     for (j = 1; j <= MAXWIN; j++)
  2035.       printf("Index %d, display list %d %s definedn", i, j, glIsList(j) ?
  2036.         "is " : "not");
  2037.   }
  2038. }
  2040. /* autoDemo - Run auto demo/test This is a bit tricky. We need
  2041.    to start a timer sequence which progressively orders things
  2042.    to be done. The work really gets done when we return from
  2043.    our callback. Have to think about the event loop / callback
  2044.    design here. */
  2046. void
  2047. autoDemo(int value)
  2048. {
  2050. #define STEP(a, b)  
  2051.     case a:         
  2052.         action(a);  
  2053. glutTimerFunc(AUTODELAY * b, autoDemo, next(a); 
  2054. break;
  2056.   static int index = 0;
  2057.   static int count = 0;
  2058.   static int restartValue = -2;
  2060.   if (value == -999)
  2061.     value = restartValue;
  2063.   restartValue = value;
  2065. #define AUTODELAY2 (unsigned int) (AUTODELAY*0.66)
  2067.   /* fprintf(stderr, "autoDemo: value %d n", value);  */
  2069.   if (!demoMode)
  2070.     return;
  2072.   if (menu_state == GLUT_MENU_IN_USE) {
  2073.     glutTimerFunc(AUTODELAY / 2, autoDemo, value);
  2074.     return;
  2075.   }
  2076.   switch (value) {
  2078. /* Entry point; kill off existing windows. */
  2080.   case -2:
  2081.     killAllWindows();
  2082.     glutTimerFunc(AUTODELAY / 2, autoDemo, 1);
  2083.     break;
  2085. /* Start making windows */
  2087.   case -1:
  2088.     makeWindow(0);
  2089.     glutTimerFunc(AUTODELAY, autoDemo, 0);  /* skip case 0
  2090.                                                first time  */
  2091.     break;
  2093. /* Change shape & backdrop */
  2095.   case 0:
  2096.     currentShape = (currentShape + 1) % 9;
  2097.     redefineShapes(currentShape);
  2098.     count += 1;
  2099.     if (count % 2)
  2100.       backdrop = !backdrop;
  2101.     glutTimerFunc(AUTODELAY, autoDemo, 1);
  2102.     break;
  2104. /* Keep making windows */
  2106.   case 1:
  2107.     makeWindow(1);
  2108.     glutTimerFunc(AUTODELAY, autoDemo, 2);
  2109.     break;
  2111.   case 2:
  2112.     makeWindow(2);
  2113.     glutTimerFunc(AUTODELAY, autoDemo, 3);
  2114.     break;
  2116.   case 3:
  2117.     makeWindow(3);
  2118.     glutTimerFunc(AUTODELAY, autoDemo, 4);
  2119.     break;
  2121.   case 4:
  2122.     makeWindow(4);
  2123.     glutTimerFunc(AUTODELAY, autoDemo, 5);
  2124.     break;
  2126.   case 5:
  2127.     makeWindow(5);
  2128.     glutTimerFunc(AUTODELAY * 2, autoDemo, 51);
  2129.     break;
  2131.   case 51:
  2132.     makeWindow(6);
  2133.     glutTimerFunc(AUTODELAY * 2, autoDemo, 52);
  2134.     break;
  2136.   case 52:
  2137.     makeWindow(7);
  2138.     glutTimerFunc(AUTODELAY * 2, autoDemo, 53);
  2139.     break;
  2141. /* Kill last 3 windows, leave 4 up. */
  2143.   case 53:
  2144.     killWindow(7);
  2145.     glutTimerFunc(AUTODELAY, autoDemo, 54);
  2146.     break;
  2148.   case 54:
  2149.     killWindow(6);
  2150.     glutTimerFunc(AUTODELAY, autoDemo, 6);
  2151.     break;
  2153.   case 6:
  2154.     killWindow(5);
  2155.     glutTimerFunc(AUTODELAY, autoDemo, 7);
  2156.     break;
  2158.   case 7:
  2159.     killWindow(4);
  2160.     glutTimerFunc(AUTODELAY, autoDemo, 700);
  2161.     break;
  2163. /* Change shape again */
  2165.   case 700:
  2166.     currentShape = (currentShape + 1) % 9;
  2167.     redefineShapes(currentShape);
  2168.     glutTimerFunc(AUTODELAY, autoDemo, 701);
  2169.     break;
  2171. /* Cycle 4 main windows through various window ops.  */
  2173.   case 701:
  2174.     positionWindow(index);
  2175.     index = (index + 1) % 4;
  2176.     glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 701 : 702);
  2177.     break;
  2179.   case 702:
  2180.     reshapeWindow(index);
  2181.     index = (index + 1) % 4;
  2182.     glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 702 : 703);
  2183.     break;
  2185.   case 703:
  2186.     iconifyWindow(index);
  2187.     index = (index + 1) % 4;
  2188.     glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 703 : 704);
  2189.     break;
  2191.   case 704:
  2192.     showWindow(index);
  2193.     index = (index + 1) % 4;
  2194.     glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 704 : 705);
  2195.     break;
  2197.   case 705:
  2198.     hideWindow(index);
  2199.     index = (index + 1) % 4;
  2200.     glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 705 : 706);
  2201.     break;
  2203.   case 706:
  2204.     showWindow(index);
  2205.     index = (index + 1) % 4;
  2206.     glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 706 : 707);
  2207.     break;
  2209.   case 707:
  2210.     pushWindow(index);
  2211.     index = (index + 1) % 4;
  2212.     glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 707 : 708);
  2213.     break;
  2215.   case 708:
  2216.     popWindow(index);
  2217.     index = (index + 1) % 4;
  2218.     glutTimerFunc(AUTODELAY2, autoDemo, index > 0 ? 708 : 8);
  2219.     break;
  2221. /* Kill all windows */
  2223.   case 8:
  2224.     killWindow(3);
  2225.     glutTimerFunc(AUTODELAY, autoDemo, 9);
  2226.     break;
  2228.   case 9:
  2229.     killWindow(2);
  2230.     glutTimerFunc(AUTODELAY, autoDemo, 10);
  2231.     break;
  2233.   case 10:
  2234.     killWindow(1);
  2235.     glutTimerFunc(AUTODELAY, autoDemo, 11);
  2236.     break;
  2238.   case 11:
  2239.     killWindow(0);
  2240.     glutTimerFunc(AUTODELAY, autoDemo, -1);  /* back to start  */
  2241.     break;
  2242.   }
  2244. }
  2246. /* attachMenus - Attach/detach menus to/from mouse buttons */
  2248. void
  2249. attachMenus(void)
  2250. {
  2251.   int i, b;
  2252.   int button[3] =
  2253.   {GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, GLUT_RIGHT_BUTTON};
  2255.   for (i = 0; i < MAXWIN; i++) {
  2256.     if (winId[i] != 0) {
  2257.       for (b = 0; b < 3; b++) {
  2258.         glutSetWindow(winId[i]);
  2259.         glutSetMenu(menu1);
  2260.         if (menuButton[b])
  2261.           glutAttachMenu(button[b]);
  2262.         else
  2263.           glutDetachMenu(button[b]);
  2264.       }
  2265.     }
  2266.   }
  2267. }
  2269. /* killAllWindows - Kill all windows (except 0) */
  2271. void
  2272. killAllWindows(void)
  2273. {
  2274.   int w;
  2276.   for (w = 1; w < MAXWIN; w++)
  2277.     if (winId[w])
  2278.       killWindow(w);
  2279. }
  2281. /* makeAllWindows - Make all windows */
  2283. void
  2284. makeAllWindows(void)
  2285. {
  2286.   int w;
  2288.   for (w = 0; w < MAXWIN; w++)
  2289.     if (!winId[w])
  2290.       makeWindow(w);
  2291. }
  2293. /* checkArgs - Check command line args */
  2295. void
  2296. checkArgs(int argc, char *argv[])
  2297. {
  2298.   int argp;
  2299.   GLboolean quit = GL_FALSE;
  2300.   GLboolean error = GL_FALSE;
  2302. #define AA argv[argp]
  2304. #if 0
  2305. #define NEXT argp++;      
  2306.     if(argp >= argc) 
  2307.     {                
  2308.        Usage();      
  2309.        Exit(1);      
  2310.     }
  2311. #endif
  2313.   argp = 1;
  2314.   while (argp < argc) {
  2315.     if (match(AA, "-help")) {
  2316.       commandLineHelp();
  2317.       quit = GL_TRUE;
  2318.     } else if (match(AA, "-version")) {
  2319.       printf(VERSIONLONG "n");
  2320.       quit = GL_TRUE;
  2321.     } else if (match(AA, "-auto")) {
  2322.       demoMode = GL_TRUE;
  2323.     } else if (match(AA, "-scale")) {
  2324.       argp++;
  2325.       scaleFactor = atof(argv[argp]);
  2326.     } else {
  2327.       fprintf(stderr, "Unknown arg: %sn", AA);
  2328.       error = GL_TRUE;
  2329.       quit = GL_TRUE;
  2330.     }
  2331.     argp++;
  2332.   }
  2334.   if (error) {
  2335.     commandLineHelp();
  2336.     exit(1);
  2337.   }
  2338.   if (quit)
  2339.     exit(0);
  2340. }
  2342. /* commandLineHelp - Command line help */
  2344. void
  2345. commandLineHelp(void)
  2346. {
  2347.   printf("Usage:n");
  2348.   printf(" -h[elp]            this stuffn");
  2349.   printf(" -v[ersion]         show versionn");
  2350.   printf(" -a[uto]            start in auto demo moden");
  2351.   printf(" -s[cale] f         scale windows by fn");
  2352.   printf("Standard GLUT args:n");
  2353.   printf(" -iconic            start iconicn");
  2354.   printf(" -display DISP      use display DISPn");
  2355.   printf(" -direct            use direct rendering (default)n");
  2356.   printf(" -indirect          use indirect renderingn");
  2357.   printf(" -sync              use synchronous X protocoln");
  2358.   printf(" -gldebug           check OpenGL errorsn");
  2359.   printf(" -geometry WxH+X+Y  standard X window spec (overridden here) n");
  2360. }
  2362. /* match - Match a string (any unique substring). */
  2364. GLboolean
  2365. match(char *arg, char *t)
  2366. {
  2367.   if (strstr(t, arg))
  2368.     return GL_TRUE;
  2369.   else
  2370.     return GL_FALSE;
  2371. }
  2373. /* scaleWindows - Scale initial window sizes ansd positions */
  2375. void
  2376. scaleWindows(float scale)
  2377. {
  2378.   int i;
  2380.   for (i = 0; i < MAXWIN; i++) {
  2381.     pos[i][0] = pos[i][0] * scale;
  2382.     pos[i][1] = pos[i][1] * scale;
  2383.     size[i][0] = size[i][0] * scale;
  2384.     size[i][1] = size[i][1] * scale;
  2385.   }
  2386. }
  2388. /* trackBall - A simple trackball (not with proper rotations). */
  2390. /** A simple trackball with spin = left button
  2391.                            pan  = middle button
  2392.                            zoom = left + middle
  2393.    Doesn't have proper trackball rotation, ie axes which remain fixed in
  2394.    the scene. We should use the trackball code from 4Dgifts. */
  2396. #define STARTROTATE(x, y)     
  2397. {                             
  2398.     startMX = x;              
  2399.     startMY = y;              
  2400. }
  2402. #define STOPROTATE(x, y)      
  2403. {                             
  2404.     steadyXangle = varXangle; 
  2405.     steadyYangle = varYangle; 
  2406. }
  2408. #define STARTPAN(x, y)        
  2409. {                             
  2410.     startMX = x;              
  2411.     startMY = y;              
  2412. }
  2414. #define STOPPAN(x, y)         
  2415. {                             
  2416.     steadyX = varX;           
  2417.     steadyY = varY;           
  2418. }
  2420. #define STARTZOOM(x, y)       
  2421. {                             
  2422.     startMX = x;              
  2423.     startMY = y;              
  2424. }
  2426. #define STOPZOOM(x, y)        
  2427. {                             
  2428.     steadyZ = varZ;           
  2429. }
  2431. static float
  2432. fixAngle(float angle)
  2433. {
  2434.   return angle - floor(angle / 360.0) * 360.0;
  2435. }
  2437. void
  2438. trackBall(int mode, int button, int state, int x, int y)
  2439. {
  2440.   static int startMX = 0, startMY = 0;  /* initial mouse pos  */
  2441.   static int deltaMX = 0, deltaMY = 0;  /* initial mouse pos  */
  2442.   static float steadyXangle = 0.0, steadyYangle = 0.0;
  2443.   static float varXangle = 0.0, varYangle = 0.0;
  2444.   static float steadyX = 0.0, steadyY = 0.0, steadyZ = 0.0;
  2445.   static float varX = 0.0, varY = 0.0, varZ = 0.0;
  2447.   switch (mode) {
  2449.   case RESET:
  2450.     steadyXangle = steadyYangle = steadyX = steadyY = steadyZ = 0.0;
  2451.     break;
  2453.   case MOUSEBUTTON:
  2455.     if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN && !middleDown) {
  2456.       STARTROTATE(x, y);
  2457.       leftDown = GL_TRUE;
  2458.     } else if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN &&
  2459.       middleDown) {
  2460.       STOPPAN(x, y);
  2461.       STARTZOOM(x, y);
  2462.       leftDown = GL_TRUE;
  2463.     } else if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN &&
  2464.       !leftDown) {
  2465.       STARTPAN(x, y);
  2466.       middleDown = GL_TRUE;
  2467.     } else if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN &&
  2468.       leftDown) {
  2469.       STOPROTATE(x, y);
  2470.       STARTZOOM(x, y);
  2471.       middleDown = GL_TRUE;
  2472.     } else if (state == GLUT_UP && button == GLUT_LEFT_BUTTON && !middleDown) {
  2473.       STOPROTATE(x, y);
  2474.       leftDown = GL_FALSE;
  2475.     } else if (state == GLUT_UP && button == GLUT_LEFT_BUTTON && middleDown) {
  2476.       STOPZOOM(x, y);
  2477.       STARTROTATE(x, y);
  2478.       leftDown = GL_FALSE;
  2479.     } else if (state == GLUT_UP && button == GLUT_MIDDLE_BUTTON && !leftDown) {
  2480.       STOPPAN(x, y);
  2481.       middleDown = GL_FALSE;
  2482.     } else if (state == GLUT_UP && button == GLUT_MIDDLE_BUTTON && leftDown) {
  2483.       STOPZOOM(x, y);
  2484.       STARTROTATE(x, y);
  2485.       middleDown = GL_FALSE;
  2486.     }
  2487.     break;
  2489.   case APPLY:
  2491.     if (leftDown && !middleDown) {
  2492.       glTranslatef(steadyX, steadyY, steadyZ);
  2493.       glRotatef(varXangle, 0, 1, 0);
  2494.       glRotatef(varYangle, 1, 0, 0);
  2495.     }
  2496.     /* Middle button pan  */
  2498.     else if (middleDown && !leftDown) {
  2499.       glTranslatef(varX, varY, steadyZ);
  2500.       glRotatef(steadyXangle, 0, 1, 0);
  2501.       glRotatef(steadyYangle, 1, 0, 0);
  2502.     }
  2503.     /* Left + middle zoom.  */
  2505.     else if (leftDown && middleDown) {
  2506.       glTranslatef(steadyX, steadyY, varZ);
  2507.       glRotatef(steadyXangle, 0, 1, 0);
  2508.       glRotatef(steadyYangle, 1, 0, 0);
  2509.     }
  2510.     /* Nothing down.  */
  2512.     else {
  2513.       glTranslatef(steadyX, steadyY, steadyZ);
  2514.       glRotatef(steadyXangle, 0, 1, 0);
  2515.       glRotatef(steadyYangle, 1, 0, 0);
  2516.     }
  2517.     break;
  2519.   case MOUSEMOTION:
  2521.     deltaMX = x - startMX;
  2522.     deltaMY = startMY - y;
  2524.     if (leftDown && !middleDown) {
  2525.       varXangle = fixAngle(steadyXangle + deltaMX);
  2526.       varYangle = fixAngle(steadyYangle + deltaMY);
  2527.     } else if (middleDown && !leftDown) {
  2528.       varX = steadyX + deltaMX / 100.0;
  2529.       varY = steadyY + deltaMY / 100.0;
  2530.     } else if (leftDown && middleDown) {
  2531.       varZ = steadyZ - deltaMY / 50.0;
  2532.     }
  2533.     break;
  2534.   }
  2536. }
  2538. /* Callbacks for exotic input devices. These have not been
  2539.    tested yet owing to the usual complete absence of such
  2540.    devices in the UK support group. */
  2542. /* spaceballMotionCB */
  2544. void
  2545. spaceballMotionCB(int x, int y, int z)
  2546. {
  2547.   printf("spaceballMotionCB: translations are X %d, Y %d, Z %dn", x, y, z);
  2548. }
  2550. /* spaceballRotateCB */
  2552. void
  2553. spaceballRotateCB(int x, int y, int z)
  2554. {
  2555.   printf("spaceballRotateCB: rotations are X %d, Y %d, Z %dn", x, y, z);
  2556. }
  2558. /* spaceballButtonCB */
  2560. void
  2561. spaceballButtonCB(int button, int state)
  2562. {
  2563.   printf("spaceballButtonCB: button %d, state %dn", button, state);
  2564. }
  2566. /* buttonBoxCB */
  2568. void
  2569. buttonBoxCB(int button, int state)
  2570. {
  2571.   printf("buttonBoxCB: button %d, state %dn", button, state);
  2572. }
  2574. /* dialsCB */
  2576. void
  2577. dialsCB(int dial, int value)
  2578. {
  2579.   printf("dialsCB: dial %d, value %dn", dial, value);
  2580. }
  2582. /* tabletMotionCB */
  2584. void
  2585. tabletMotionCB(int x, int y)
  2586. {
  2587.   printf("tabletMotionCB: X %d, Y %dn", x, y);
  2588. }
  2590. /* tabletButtonCB */
  2592. /* ARGSUSED2 */
  2593. void
  2594. tabletButtonCB(int button, int state, int dummy1, int dummy2)
  2595. {
  2596.   printf("tabletButtonCB: button %d, state %dn", button, state);
  2597. }