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

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

GIS编程

开发平台：

Visual C++

bounce.c：源码内容
  2. /**************************************************************************
  3.  *   *
  4.  *   Copyright (C) 1988, 1989, 1990, Silicon Graphics, Inc.   *
  5.  *   *
  6.  *  These coded instructions, statements, and computer programs  contain  *
  7.  *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
  8.  *  are protected by Federal copyright law.  They  may  not be disclosed  *
  9.  *  to  third  parties  or copied or duplicated in any form, in whole or  *
  10.  *  in part, without the prior written consent of Silicon Graphics, Inc.  *
  11.  *   *
  12.  **************************************************************************/
  14. /*
  15.  *  foo $Revision: 1.4 $
  16.  */
  17. #include <assert.h>
  18. #include <math.h>
  19. #include <stdio.h>
  20. #include <stdarg.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <GL/glut.h>
  25. #include "tb.h"
  26. #include "glui.h"
  28. /* Some <math.h> files do not define M_PI... */
  29. #ifndef M_PI
  30. #define M_PI 3.14159265358979323846
  31. #endif
  33. #define UDIV 12
  34. #define VDIV 12
  36. #define WALLGRIDMAX 32
  37. #define EYEZ 3.3
  39. #define TOTALBALLS 3
  41. #define R 0
  42. #define G 1
  43. #define B 2
  45. #define X 0
  46. #define Y 1
  47. #define Z 2
  48. #define W 3
  50. int wallgrid = 8; /* sqrt of the number of quads in a wall */
  51. float fatt = 1.0;
  53. int freeze = GL_FALSE;
  54. int spin = GL_FALSE;
  55. int spinning = GL_FALSE;
  56. int objecton = GL_FALSE;
  57. int normson = GL_FALSE;
  58. int lighton[3] = {GL_TRUE, GL_TRUE, GL_TRUE};
  60. int window; /* main window id */
  62. GLboolean performance = GL_FALSE; /* performance indicator */
  64. struct {
  65.    float p[3];
  66.    float d[3];
  67.    unsigned char color[3];
  68. } balls[TOTALBALLS];
  70. float ballobj[UDIV+1][VDIV+1][4];
  71. float wallobj[WALLGRIDMAX+1][WALLGRIDMAX+1][4];
  72. float wallnorms[WALLGRIDMAX+1][WALLGRIDMAX+1][3];
  73. float wallnorm[3] = { 0.0, 0.0, -1.0 };
  75. int orx, ory;
  77. float ballscale;
  78. float ballsize;
  80. int DELTAX, DELTAY;
  82. int lflag = 0;
  84. float newpos[] = { 0.0, 0.0, 0.0, 1.0 };
  86. GLfloat light_Ka[] = { 0.3, 0.3, 0.3, 1.0 };  /* ambient */
  87. GLfloat light_Ks[] = { 0.0, 0.0, 0.0, 1.0 };  /* specular */
  89. GLfloat light0_Ka[]  = { 0.0, 0.0, 0.0, 1.0 };  /* ambient */
  90. GLfloat light0_Kd[]  = { 1.0, 0.1, 0.1, 1.0 };  /* diffuse */
  91. GLfloat light0_pos[] = { 0.0, 0.0, 0.0, 1.0 };  /* position */
  93. GLfloat light1_Ka[]  = { 0.0, 0.0, 0.0, 1.0 };  /* ambient */
  94. GLfloat light1_Kd[]  = { 0.1, 1.0, 0.1, 1.0 };  /* diffuse */
  95. GLfloat light1_pos[] = { 0.0, 0.0, 0.0, 1.0 };  /* position */
  97. GLfloat light2_Ka[]  = { 0.0, 0.0, 0.0, 1.0 };  /* ambient */
  98. GLfloat light2_Kd[]  = { 0.1, 0.1, 1.0, 1.0 };  /* diffuse */
  99. GLfloat light2_pos[] = { 0.0, 0.0, 0.0, 1.0 };  /* position */
  101. GLfloat attenuation[] = { 1.0, 3.0 };
  103. GLfloat plane_Ka[] = { 0.0, 0.0, 0.0, 1.0 };  /* ambient */
  104. GLfloat plane_Kd[] = { 0.4, 0.4, 0.4, 1.0 };  /* diffuse */
  105. GLfloat plane_Ks[] = { 1.0, 1.0, 1.0, 1.0 };  /* specular */
  106. GLfloat plane_Ke[] = { 0.0, 0.0, 0.0, 1.0 };  /* emission */
  107. GLfloat plane_Se   = 30.0;                    /* shininess */
  109. GLfloat wall_Ka[] = { 0.1, 0.1, 0.1, 1.0 };  /* ambient */
  110. GLfloat wall_Kd[] = { 0.8, 0.8, 0.8, 1.0 };  /* diffuse */
  111. GLfloat wall_Ks[] = { 1.0, 1.0, 1.0, 1.0 };  /* specular */
  112. GLfloat wall_Ke[] = { 0.0, 0.0, 0.0, 1.0 };  /* emission */
  113. GLfloat wall_Se   = 20.0;                    /* shininess */
  115. GLuint wall_material, plane_material; /* material display lists */
  117. char ofile[80];
  120. /************************************************************/
  121. /* XXX - The following is an excerpt from spin.h from spin  */
  122. /************************************************************/
  124. #define POLYGON 1
  125. #define LINES 2
  126. #define TRANSPERENT 3
  127. #define DISPLAY 4
  128. #define LMATERIAL 5
  130. #define FASTMAGIC 0x5423
  132. typedef struct fastobj {
  133.     int npoints;
  134.     int colors;
  135.     int type;
  136.     int material;
  137.     int display;
  138.     int ablend;
  139.     GLint *data;
  140. } fastobj;
  142. /*
  143.  * Wrappers to do either lines or polygons
  144.  */
  145. #define PolyOrLine() if (lflag == LINES) { 
  146. glBegin(GL_LINE_LOOP); 
  147. } else { 
  148. glBegin(GL_POLYGON); 
  149. }
  151. #define EndPolyOrLine() if (lflag == LINES) { 
  152. glEnd(); 
  153. } else { 
  154. glEnd(); 
  155. }
  157. /************************* end of spin.h excerpt *************************/
  160. fastobj *obj = NULL;
  162. /* 
  164.    general purpose text routine.  draws a string according to the
  165.    format in a stroke font at x, y after scaling it by the scale
  166.    specified.  x, y and scale are all in window-space [i.e., pixels]
  167.    with origin at the lower-left.
  169. */
  171. void 
  172. text(GLuint x, GLuint y, GLfloat scale, char* format, ...)
  173. {
  174.     va_list args;
  175.     char buffer[255], *p;
  176.     GLfloat font_scale = 119.05 + 33.33;
  178.     va_start(args, format);
  179.     vsprintf(buffer, format, args);
  180.     va_end(args);
  182.     glMatrixMode(GL_PROJECTION);
  183.     glPushMatrix();
  184.     glLoadIdentity();
  185.     gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0, glutGet(GLUT_WINDOW_HEIGHT));
  187.     glMatrixMode(GL_MODELVIEW);
  188.     glPushMatrix();
  189.     glLoadIdentity();
  191.     glPushAttrib(GL_ENABLE_BIT);
  192.     glDisable(GL_LIGHTING);
  193.     glDisable(GL_TEXTURE_2D);
  194.     glEnable(GL_DEPTH_TEST);
  195.     glEnable(GL_LINE_SMOOTH);
  196.     glEnable(GL_BLEND);
  197.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  198.     glTranslatef(x, y, 0.0);
  200.     glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
  202.     for(p = buffer; *p; p++)
  203. glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
  204.   
  205.     glPopAttrib();
  207.     glPopMatrix();
  208.     glMatrixMode(GL_PROJECTION);
  209.     glPopMatrix();
  210.     glMatrixMode(GL_MODELVIEW);
  211. }
  213. float
  214. frand(void)
  215. {
  216.     return 2.0*(rand()/32768.0 - .5);
  217. }
  220. void
  221. resetballs(void)
  222. {
  223.     register short i;
  225.     balls[0].color[R] = 255;
  226.     balls[0].color[G] = 64;
  227.     balls[0].color[B] = 64;
  228.     balls[1].color[R] = 64;
  229.     balls[1].color[G] = 255;
  230.     balls[1].color[B] = 64;
  231.     balls[2].color[R] = 64;
  232.     balls[2].color[G] = 64;
  233.     balls[2].color[B] = 255;
  234.     for (i = 0; i < TOTALBALLS; i++) {
  235. balls[i].p[0] = 0.0;
  236. balls[i].p[1] = 0.0;
  237. balls[i].p[2] = 0.0;
  238. balls[i].d[0] = .1*frand();
  239. balls[i].d[1] = .1*frand();
  240. balls[i].d[2] = .1*frand();
  241.     }
  242. }
  245. void
  246. drawface(void)
  247. {
  248.     register int i,j;
  250.     glNormal3fv(wallnorm);
  251.     for (i=0; i < wallgrid; i++) {
  252. glBegin(GL_TRIANGLE_STRIP);
  253. for (j=0; j <= wallgrid; j++) {
  254.     glVertex3fv(wallobj[i][j]);
  255.     glVertex3fv(wallobj[i+1][j]);
  256. }
  257. glEnd();
  258.     }
  259. }
  262. void
  263. drawnorms(void)
  264. {
  265.     register int i,j;
  267.     glDisable(GL_LIGHTING);
  268.     glColor3ub(255, 255, 0);
  269.     for (i=0; i <= wallgrid; i++) {
  270. for (j=0; j <= wallgrid; j++) {
  271.     glBegin(GL_LINES);
  272.     glVertex3fv(wallobj[i][j]);
  273.     glVertex3fv(wallnorms[i][j]);
  274.     glEnd();
  275. }
  276.     }
  277.     glEnable(GL_LIGHTING);
  278. }
  281. void
  282. drawbox(void)
  283. {
  284.     glPushMatrix();
  286. /*  drawface(); */
  287.     glRotatef(90.0, 0.0, 1.0, 0.0);
  288.     drawface();
  289.     if (normson) drawnorms();
  290.     glRotatef(90.0, 0.0, 1.0, 0.0);
  291.     drawface();
  292.     if (normson) drawnorms();
  293.     glRotatef(90.0, 0.0, 1.0, 0.0);
  294. /*  drawface(); */
  295.     glRotatef(-90.0, 1.0, 0.0, 0.0);
  296.     drawface();
  297.     if (normson) drawnorms();
  298.     glRotatef(180.0, 1.0, 0.0, 0.0);
  299. /*  drawface(); */
  300.     glPopMatrix();
  301. }
  304. void
  305. drawfastobj(fastobj *obj)
  306. {
  307.     register GLint *p, *end;
  308.     register int npolys;
  310.     p = obj->data;
  311.     end = p + 8 * obj->npoints;
  313.     if(obj->colors) {
  314. npolys = obj->npoints/4;
  315. while(npolys--) {
  316.     PolyOrLine();
  317.     glColor3iv(p);
  318.     glVertex3fv((float *)p+4);
  319.     glColor3iv(p+8);
  320.     glVertex3fv((float *)p+12);
  321.     glColor3iv(p+16);
  322.     glVertex3fv((float *)p+20);
  323.     glColor3iv(p+24);
  324.     glVertex3fv((float *)p+28);
  325.     EndPolyOrLine();
  326.     p += 32;
  327. }
  328.     } else {
  329. while ( p < end) {
  330.     PolyOrLine();
  331.     glNormal3fv((float *)p);
  332.     glVertex3fv((float *)p+4);
  333.     glNormal3fv((float *)p+8);
  334.     glVertex3fv((float *)p+12);
  335.     glNormal3fv((float *)p+16);
  336.     glVertex3fv((float *)p+20);
  337.     glNormal3fv((float *)p+24);
  338.     glVertex3fv((float *)p+28);
  339.     EndPolyOrLine();
  340.     p += 32;
  341. }
  342.     }
  343. }
  345. void
  346. drawball(void)
  347. {
  348.     register int i,j;
  350.     for (i=0; i < UDIV; i++) {
  351. for (j=0; j < VDIV; j++) {
  352.     glBegin(GL_POLYGON);
  353.     glVertex4fv( ballobj[i][j] );
  354.     glVertex4fv( ballobj[i+1][j] );
  355.     glVertex4fv( ballobj[i+1][j+1] );
  356.     glVertex4fv( ballobj[i][j+1] );
  357.     glEnd();
  358. }
  359.     }
  360. }
  364. void
  365. drawimage(void)
  366. {
  367.     register short i;
  368.     static int start, end, last;
  370.     glutSetWindow(window);
  372.     if (performance)
  373. start = glutGet(GLUT_ELAPSED_TIME);
  375.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  377.     glPushMatrix();
  378.     tbMatrix();
  380.     for (i=0; i < TOTALBALLS; i++) {
  381. newpos[0] = balls[i].p[0];
  382. newpos[1] = balls[i].p[1];
  383. newpos[2] = balls[i].p[2];
  384. glLightfv(GL_LIGHT0 + i, GL_POSITION, newpos);
  385.     }
  387.     glCallList(wall_material);
  388.     glEnable(GL_LIGHTING);
  389.     drawbox();
  391.     glEnable(GL_DEPTH_TEST);
  393.     if (objecton)
  394.     {
  395. glCallList(plane_material);
  396. glPushMatrix();
  397. glScalef(1.5, 1.5, 1.5);
  398. glRotatef(180.0, 0.0, 0.0, 1.0);
  399. if (spin)
  400. {
  401.     orx += 50;
  402.     ory += 50;
  403. }
  404. glRotatef(orx/10.0, 1.0, 0.0, 0.0);
  405. glRotatef(ory/10.0, 0.0, 1.0, 0.0);
  406. drawfastobj(obj);
  407. glPopMatrix();
  408.     }
  410.     glDisable(GL_LIGHTING);
  412.     for (i=0; i < TOTALBALLS; i++) {
  413. if (lighton[i])
  414. {
  415.     glPushMatrix();
  416.     glTranslatef(balls[i].p[0],balls[i].p[1],balls[i].p[2]);
  417.     glColor3ubv(balls[i].color);
  418.     drawball();
  419.     glPopMatrix();
  420. }
  421.     }
  423.     glColor3f(1.0, 1.0, 1.0);
  424.     if (performance) {
  425.         if (end - last == 0) {
  426.     text(10, 73, 20, "unknown fps");
  427. } else {
  428.     text(10, 73, 20, "%.0f fps", 1.0 / ((end - last) / 1000.0));
  429. }
  430. last = start;
  431.     }
  432.     text(10, 43, 14, "Attenuation [%.2f]", fatt);
  433.     text(10, 13, 14, "Tesselation [%3d]", wallgrid);
  436.     glPopMatrix();
  437.     glutSwapBuffers();
  439.     if (performance)
  440. end = glutGet(GLUT_ELAPSED_TIME);
  441. }
  444. void
  445. initobjects(void)
  446. {
  447.     register float u,v,du,dv;
  448.     register short i,j;
  450.     du = 2.0*M_PI/UDIV;
  451.     dv = M_PI/VDIV;
  453.     u = 0.;
  454.     for (i=0; i <= UDIV; i++) {
  455. v = 0.;
  456. for (j=0; j <= VDIV; j++) {
  457.     ballobj[i][j][X] = ballsize*cos(u)*sin(v);
  458.     ballobj[i][j][Y] = ballsize*sin(u)*sin(v);
  459.     ballobj[i][j][Z] = ballsize*cos(v);
  460.     ballobj[i][j][W] = 1.0;
  461.     v += dv;
  462. }
  463. u += du;
  464.     }
  466.     for (i=0; i <= wallgrid; i++) {
  467. for (j=0; j <= wallgrid; j++) {
  468.     wallobj[i][j][X] = -1.0 + 2.0*i/wallgrid;
  469.     wallobj[i][j][Y] = -1.0 + 2.0*j/wallgrid;
  470.     wallobj[i][j][Z] = 1.0;
  471.     wallobj[i][j][W] = 1.0;
  472. }
  473.     }
  475.     for (i=0; i <= wallgrid; i++) {
  476. for (j=0; j <= wallgrid; j++) {
  477.     wallnorms[i][j][X] = wallobj[i][j][X] + wallnorm[X]*0.1;
  478.     wallnorms[i][j][Y] = wallobj[i][j][Y] + wallnorm[Y]*0.1;
  479.     wallnorms[i][j][Z] = wallobj[i][j][Z] + wallnorm[Z]*0.1;
  480. }
  481.     }
  482. }
  484. int MOUSEX, MOUSEY;
  486. static void
  487. mouse(int button, int state, int x, int y)
  488. {
  489.     MOUSEX = x;
  490.     MOUSEY = y;
  491.     tbMouse(button, state, x, y);
  492. }
  494. static void
  495. motion(int x, int y)
  496. {
  497.     DELTAX -= MOUSEX - x;
  498.     DELTAY += MOUSEY - y;
  499.     MOUSEX = x;
  500.     MOUSEY = y;
  501.     tbMotion(x, y);
  502. }
  504. /* ARGSUSED1 */
  505. void
  506. keyboard(unsigned char key, int x, int y)
  507. {
  508.     switch(key) {
  509.     case 27: /* ESC */
  510. exit(0);
  511. break;
  513.     case '+':
  514. wallgrid++;
  515. if (wallgrid > WALLGRIDMAX)
  516.     wallgrid = WALLGRIDMAX;
  517. initobjects();
  518. break;
  520.     case '-':
  521. wallgrid--;
  522. if (wallgrid < 1)
  523.     wallgrid = 1;
  524. initobjects();
  525. break;
  526.     }
  527. }
  529. void
  530. initialize(void)
  531. {
  532.     glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
  533.     window = glutCreateWindow("bounce");
  535.     initobjects();
  537.     srand(glutGet(GLUT_ELAPSED_TIME));
  539.     glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
  540.     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, light_Ka);
  542.     plane_material = glGenLists(1);
  543.     glNewList(plane_material, GL_COMPILE);
  544.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, plane_Ka);
  545.     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, plane_Kd);
  546.     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, plane_Ks);
  547.     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, plane_Ke);
  548.     glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, plane_Se);
  549.     glEndList();
  551.     wall_material = glGenLists(1);
  552.     glNewList(wall_material, GL_COMPILE);
  553.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, wall_Ka);
  554.     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, wall_Kd);
  555.     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, wall_Ks);
  556.     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, wall_Ke);
  557.     glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, wall_Se);
  558.     glEndList();
  560.     glLightfv(GL_LIGHT0, GL_AMBIENT, light0_Ka);
  561.     glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_Kd);
  562.     glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, attenuation[0]);
  563.     glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, attenuation[1]);
  564.     /* OpenGL's light0 has different specular properties than the rest
  565.        of the lights.... */
  566.     glLightfv(GL_LIGHT0, GL_SPECULAR, light_Ks);
  568.     glLightfv(GL_LIGHT1, GL_AMBIENT, light1_Ka);
  569.     glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_Kd);
  570.     glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, attenuation[0]);
  571.     glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, attenuation[1]);
  573.     glLightfv(GL_LIGHT2, GL_AMBIENT, light2_Ka);
  574.     glLightfv(GL_LIGHT2, GL_DIFFUSE, light2_Kd);
  575.     glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, attenuation[0]);
  576.     glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, attenuation[1]);
  578.     glutMotionFunc(motion);
  579.     glutMouseFunc(mouse);
  580.     glutKeyboardFunc(keyboard);
  581. }
  584. void
  585. calcball(void)
  586. {
  587.     register short i,j;
  589.     for (j=0; j < TOTALBALLS; j++) {
  590. for (i=0; i < 3; i++) {
  591.     balls[j].p[i] += balls[j].d[i];
  592.     if (fabs(balls[j].p[i]) > ballscale) {
  593. balls[j].p[i] = (balls[j].p[i] > 0.0) ?
  594. ballscale : -ballscale;
  595. balls[j].d[i] = -balls[j].d[i];
  596.     }
  597. }
  598.     }
  599. }
  601. static void menu(int value);
  602. static void idle(void);
  604. static void
  605. make_menu(void)
  606. {
  607.     static int main_menu = 0;
  609.     if (main_menu)
  610. glutDestroyMenu(main_menu);
  612.     main_menu = glutCreateMenu(menu);
  613.     glutAddMenuEntry("bounce", 0);
  614.     glutAddMenuEntry("", 0);
  615.     if (lighton[0])
  616. glutAddMenuEntry("red light off", 1);
  617.     else
  618. glutAddMenuEntry("red light on", 1);
  619.     if (lighton[1])
  620. glutAddMenuEntry("green light off", 2);
  621.     else
  622. glutAddMenuEntry("green light on", 2);
  623.     if (lighton[2])
  624. glutAddMenuEntry("blue light off", 3);
  625.     else
  626. glutAddMenuEntry("blue light on", 3);
  628.     if (freeze)
  629. glutAddMenuEntry("unfreeze lights", 4);
  630.     else
  631. glutAddMenuEntry("freeze lights", 4);
  633.     if (normson)
  634. glutAddMenuEntry("normals off", 7);
  635.     else
  636. glutAddMenuEntry("normals on", 7);
  638.     if (performance)
  639. glutAddMenuEntry("frame rate off", 8);
  640.     else
  641. glutAddMenuEntry("frame rate on", 8);
  643.     if (obj)
  644.     {
  645. if (objecton)
  646.     glutAddMenuEntry("object off", 5);
  647. else
  648.     glutAddMenuEntry("object on", 5);
  649. if (spin)
  650.     glutAddMenuEntry("object spin off", 6);
  651. else
  652.     glutAddMenuEntry("object spin on", 6);
  653.     }
  655.     glutAddMenuEntry("", 0);
  656.     glutAddMenuEntry("exit", 9);
  658.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  659. }
  661. static void
  662. menu(int value)
  663. {
  664.     switch(value) {
  665.     case 1:
  666. if ((lighton[0] = !lighton[0]))
  667.     glEnable(GL_LIGHT0);
  668. else
  669.     glDisable(GL_LIGHT0);
  670. break;
  671.     case 2:
  672. if ((lighton[1] = !lighton[1]))
  673.     glEnable(GL_LIGHT1);
  674. else
  675.     glDisable(GL_LIGHT1);
  676. break;
  677.     case 3:
  678. if ((lighton[2] = !lighton[2]))
  679.     glEnable(GL_LIGHT2);
  680. else
  681.     glDisable(GL_LIGHT2);
  682. break;
  683.     case 4:
  684. freeze =  !freeze;
  685.         if (!freeze || spinning) {
  686.   glutIdleFunc(idle);
  687.         } else {
  688.   glutIdleFunc(NULL);
  689.         }
  690. break;
  691.     case 5:
  692. if (obj)
  693.     objecton =  !objecton;
  694. else
  695.     exit(1);
  696. break;
  697.     case 6:
  698. spin =  !spin;
  699. break;
  700.     case 7:
  701.         normson = !normson;
  702.         break;
  703.     case 8:
  704. performance = !performance;
  705. break;
  706.     case 9:
  707. exit(0);
  708. break;
  709.     }
  710.     glutPostWindowRedisplay(window);
  711.     make_menu();
  712. }
  714. /**********************************************************/
  715. /* XXX - The following is a clone of fastobj.c from spin  */
  716. /**********************************************************/
  719. fastobj*
  720. readfastobj(char *name)
  721. {
  722.     FILE *inf;
  723.     fastobj *obj;
  724.     int i;
  725.     int nlongs;
  726.     int magic;
  727.     GLint *ip;
  728.     char filename[512];
  730.     inf = fopen(name,"r");
  731.     if(!inf) {
  732.    sprintf(filename,"%s",name);
  733. inf = fopen(filename,"r");
  734. if(!inf) {
  735.     fprintf(stderr,"readfast: can't open input file %sn",name);
  736.     exit(1);
  737. }
  738.     }
  739.     fread(&magic,sizeof(int),1,inf);
  740.     if(magic != FASTMAGIC) {
  741. fprintf(stderr,"readfast: bad magic in object filen");
  742. fclose(inf);
  743. exit(1);
  744.     }
  745.     obj = (fastobj *)malloc(sizeof(fastobj));
  746.     fread(&obj->npoints,sizeof(int),1,inf);
  747.     fread(&obj->colors,sizeof(int),1,inf);
  749.     /*
  750.      * Insure that the data is quad-word aligned and begins on a page
  751.      * boundary.  This shields us from the performance loss which occurs 
  752.      * whenever we try to fetch data which straddles a page boundary  (the OS
  753.      * has to map in the next virtual page and re-start the DMA transfer).
  754.      */
  755.     nlongs = 8 * obj->npoints;
  756.     obj->data = (GLint *) malloc(nlongs*sizeof(int) + 4096);
  757.     obj->data = (GLint *) (((int)(obj->data)) + 0xfff);
  758.     obj->data = (GLint *) (((int)(obj->data)) & 0xfffff000);
  760.     /* XXX Careful, sizeof(GLint) could change from implementation
  761.        to implementation making this file format implementation
  762.        dependent. -mjk */
  763.     for (i = 0, ip = obj->data;  i < nlongs/4;  i++, ip += 4)
  764. fread(ip, 3 * sizeof(GLint), 1, inf);
  765.     fclose(inf);
  766.     return obj;
  767. }
  770. /*
  771.  * objmaxpoint
  772.  *
  773.  * find the vertex farthest from the origin,
  774.  * so we can set the near and far clipping planes tightly.
  775.  */
  777. #define MAXVERT(v) if ( (len = sqrt( (*(v))  *  (*(v))  +        
  778. (*(v+1)) * (*(v+1)) +        
  779. (*(v+2)) * (*(v+2)) )) > max)  
  780. max = len;
  782. float
  783. objmaxpoint(obj)
  784. fastobj *obj;
  785. {
  786.     register float *p, *end;
  787.     register int npolys;
  788.     register float len;
  789.     register float max = 0.0;
  791.     p = (float *) (obj->data);
  793.     if (obj->colors) {
  794. npolys = obj->npoints/4;
  795. while(npolys--) {
  796.     MAXVERT(p+4);
  797.     MAXVERT(p+12);
  798.     MAXVERT(p+20);
  799.     MAXVERT(p+28);
  800.     p += 32;
  801. }
  802.     } else {
  803. end = p + 8 * obj->npoints;
  804. while ( p < end) {
  805.     MAXVERT(p+4);
  806.     MAXVERT(p+12);
  807.     MAXVERT(p+20);
  808.     MAXVERT(p+28);
  809.     p += 32;
  810. }
  811.     }
  813.     return max;
  814. }
  816. static void
  817. idle(void)
  818. {
  819.     assert(!freeze || spinning);
  820.     if (!freeze) {
  821.         calcball();
  822.     }
  823.     if (spinning) {
  824.         tbStepAnimation();
  825.     }
  826.     glutPostWindowRedisplay(window);
  827. }
  829. /* When not visible, stop animating.  Restart when visible again. */
  830. static void 
  831. visible(int vis)
  832. {
  833.   if (vis == GLUT_VISIBLE) {
  834.     if (!freeze || spinning)
  835.       glutIdleFunc(idle);
  836.   } else {
  837.     if (!freeze || spinning)
  838.       glutIdleFunc(NULL);
  839.   }
  840. }
  842. static void
  843. reshape(int width, int height)
  844. {
  845.     glViewport(0, 0, width, height);
  846.     glMatrixMode(GL_PROJECTION);
  847.     glLoadIdentity();
  848.     gluPerspective(60.0, (float)width/height, EYEZ-2.0, EYEZ+2.0);
  849.     glMatrixMode(GL_MODELVIEW);
  850.     glLoadIdentity();
  851.     glTranslatef(0.0, 0.25, -EYEZ);
  853.     tbReshape(width, height);
  854.     gluiReshape(width, height);
  855. }
  857. void
  858. update_fatt(float value)
  859. {
  860.     fatt = 5 * value;
  861.     glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, fatt);
  862.     glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, fatt);
  863.     glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, fatt);
  864.     glutPostWindowRedisplay(window);
  865. }
  867. void
  868. update_grid(float value)
  869. {
  870.     wallgrid = WALLGRIDMAX*value;
  871.     if (wallgrid < 1)
  872. wallgrid = 1;
  873.     initobjects();
  874.     glutPostWindowRedisplay(window);
  875. }
  877. void
  878. spinChange(int state)
  879. {
  880.   spinning = state;
  881.   if (spinning || !freeze) {
  882.     glutIdleFunc(idle);
  883.   } else {
  884.     glutIdleFunc(NULL);
  885.   }
  886. }
  888. int
  889. main(int argc, char **argv)
  890. {
  891.     glutInitWindowSize(512, 512);
  892.     glutInitWindowPosition(64, 64);
  893.     glutInit(&argc, argv);
  895.     if (argc > 1)
  896.     {
  897. int i;
  899. for (i=0; argv[1][i] != '/' && argv[1][i] != ''; i++);
  900. if (argv[1][i] != '/')
  901. {
  902.     strcpy(ofile, "/usr/demos/data/models/");
  903.     strcat(ofile, argv[1]);
  904. }
  905. else
  906.     strcpy(ofile, argv[1]);
  908. if (obj = readfastobj(ofile))
  909.     objecton = GL_TRUE;
  910.     }
  912.     ballsize = .04;
  913.     ballscale = 1.0 - ballsize;
  915.     initialize();
  917.     make_menu();
  919.     resetballs();
  921.     /* Use local lights for the box */
  922.     glEnable(GL_LIGHT0);
  923.     glEnable(GL_LIGHT1);
  924.     glEnable(GL_LIGHT2);
  926.     make_menu();
  927.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  929.     glutDisplayFunc(drawimage);
  930.     glutReshapeFunc(reshape);
  931.     glutVisibilityFunc(visible);
  933.     gluiHorizontalSlider(window, 130, -10, -10, 20,
  934.  (float)wallgrid/WALLGRIDMAX, update_grid);
  935.     gluiHorizontalSlider(window, 130, -40, -10, 20, fatt/5.0, update_fatt);
  937.     tbInit(GLUT_LEFT_BUTTON);
  938.     tbAnimate(1);
  939.     tbAnimateFunc(spinChange);
  941.     glutMainLoop();
  942.     return 0;             /* ANSI C requires main to return int. */
  943. }