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

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

GIS编程

开发平台：

Visual C++

hanoi2.c：源码内容
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <signal.h>
  4. #include <sys/types.h>
  5. #include <sys/prctl.h>
  6. #include <unistd.h>
  7. #include <GL/glut.h>
  9. #define MAX_DISKS 6
  11. #define DISK_HEIGHT 0.2
  12. #define CYL_RADIUS 0.1
  13. #define CYL_HEIGHT 1.8
  14. #define OVER_CLICKS 120
  15. #define UP_CLICKS 120
  17. enum {X=0, Y, Z};
  18. enum {DL_POLE=1, DL_FLOOR, DL_DISK};        /* disk must be last */
  20. /* motion states */
  21. enum {ST_UP=1, ST_TO_1, ST_TO_2, ST_DOWN, ST_READNEXT, ST_IDLE};
  23. int motion = 1;
  24. int spinning = 1;
  25. int click = 0;
  26. int delay = 0;
  27. int direction;
  28. int state=ST_READNEXT;
  29. int c_pole;
  30. int old_pole;
  31. int c_disk;
  32. int engine_fd;
  33. int engine_pid;
  35. float pole_offset[3][2] = { { 0, -0.575 },
  36.     { 1.15, 0.575 },
  37.                             { -1.15, 0.575 } };
  38. float disk_offset[MAX_DISKS][3] = {{ 0, -0.575, 0},
  39.    { 0, -0.575, 0},   
  40.    { 0, -0.575, 0},   
  41.    { 0, -0.575, 0},   
  42.    { 0, -0.575, 0},   
  43.    { 0, -0.575, 0}};
  44. float disk_incr[3] = { 0, 0, 0 };
  46. int num_disks;
  47. struct {
  48.   int num_disks;
  49.   int disks[MAX_DISKS];
  50. } disks_on_poles[3];
  52. /*
  53.  * create display list for disk of outside radius orad
  54.  */
  55. void
  56. diskdlist(int dlist, float orad)
  57. {
  58.     GLUquadricObj *obj;
  60.     obj = gluNewQuadric();
  61.     if (obj == 0) {
  62. perror("can't alloc quadric");
  63. exit(1);
  64.     }
  65.     glNewList(dlist, GL_COMPILE);
  66.     glPushMatrix();
  67.       glColor4ub(205, 67, 100, 200);
  68.       gluQuadricDrawStyle(obj, GLU_FILL);
  70.       gluQuadricOrientation(obj, GLU_OUTSIDE);
  71.       gluCylinder(obj, orad, orad, DISK_HEIGHT, 20, 4);
  73.       gluQuadricOrientation(obj, GLU_INSIDE);
  74.       gluCylinder(obj, CYL_RADIUS, CYL_RADIUS, DISK_HEIGHT, 20, 4);
  76.       gluQuadricOrientation(obj, GLU_INSIDE);
  77.       gluDisk(obj, CYL_RADIUS, orad, 20, 4);
  79.       gluQuadricOrientation(obj, GLU_OUTSIDE);
  80.       glPushMatrix();
  81.         glTranslatef(0.0, 0.0, DISK_HEIGHT);
  82.         gluDisk(obj, CYL_RADIUS, orad, 20, 4);
  83.       glPopMatrix();
  84.     glPopMatrix();
  85.     glEndList();
  86. }
  88. /*
  89.  * create display list for pole
  90.  */
  91. void
  92. poledlist(int dlist)
  93. {
  94.     GLUquadricObj *obj;
  96.     obj = gluNewQuadric();
  97.     if (obj == 0) {
  98. perror("can't alloc quadric");
  99. exit(1);
  100.     }
  102.     glNewList(dlist, GL_COMPILE);
  103.     glPushMatrix();
  104.       glColor3ub(67, 205, 128);
  105.       gluQuadricDrawStyle(obj, GLU_FILL);
  106.       gluQuadricOrientation(obj, GLU_OUTSIDE);
  108.       gluCylinder(obj, CYL_RADIUS, CYL_RADIUS, CYL_HEIGHT, 12, 3);
  110.       gluQuadricOrientation(obj, GLU_INSIDE);
  111.       gluDisk(obj, 0.0, CYL_RADIUS, 12, 3);
  113.       gluQuadricOrientation(obj, GLU_OUTSIDE);
  114.       glPushMatrix();
  115.         glTranslatef(0.0, 0.0, CYL_HEIGHT);
  116.         gluDisk(obj, 0.0, CYL_RADIUS, 12, 3);
  117.       glPopMatrix();
  118.     glPopMatrix();
  119.     glEndList();
  121. }
  123. /*
  124.  * create display list for floor
  125.  */
  126. void
  127. floordlist(int dlist)
  128. {
  129.     glNewList(dlist, GL_COMPILE);
  130.     glPushMatrix();
  131.       glColor4ub(90, 100, 230,100);
  133.       /* top/bottom */
  134.       glBegin(GL_TRIANGLE_STRIP);
  135.       glNormal3f(0.0, 0.0, 1.0);
  136.       glVertex3f(-2.0, -2.0, 0);
  137.       glVertex3f(2.0, -2.0, 0);
  138.       glVertex3f(-2.0, 2.0, 0);
  139.       glVertex3f(2.0, 2.0, 0);
  140.       glEnd();
  141.       glPushMatrix();
  142.         glTranslatef(0, 0, -0.2);
  143.         glBegin(GL_TRIANGLE_STRIP);
  144.         glNormal3f(0.0, 0.0, -1.0);
  145.         glVertex3f(2.0, -2.0, 0);
  146.         glVertex3f(-2.0, -2.0, 0);
  147.         glVertex3f(2.0, 2.0, 0);
  148.         glVertex3f(-2.0, 2.0, 0);
  149.         glEnd();
  150.       glPopMatrix();
  152.       /* edges */
  153.       glBegin(GL_TRIANGLE_STRIP);
  154.       glNormal3f(-1.0, 0.0, 0.0);
  155.       glVertex3f(-2.0, -2.0, -0.2);
  156.       glVertex3f(-2.0, -2.0, 0);
  157.       glVertex3f(-2.0, 2.0, -0.2);
  158.       glVertex3f(-2.0, 2.0, 0);
  159.       glNormal3f(0.0, 1.0, 0.0);
  160.       glVertex3f(2.0, 2.0, -0.2);
  161.       glVertex3f(2.0, 2.0, 0);
  162.       glNormal3f(1.0, 0.0, 0.0);
  163.       glVertex3f(2.0, -2.0, -0.2);
  164.       glVertex3f(2.0, -2.0, 0);
  165.       glNormal3f(0.0, -1.0, 0.0);
  166.       glVertex3f(-2.0, -2.0, -0.2);
  167.       glVertex3f(-2.0, -2.0, 0);
  168.       glEnd();
  169.     glPopMatrix();
  170.     glEndList();
  171. }
  173. /*
  174.  * motion state machine -- idle loop
  175.  */
  176. void
  177. idle(void)
  178. {
  179.   static int over_clicks;
  180.   int rc;
  181.   char next_move[3];
  183.   if (spinning)
  184.     click++;
  186.   if (motion) {
  187.       switch(state) {
  188. case ST_READNEXT:
  189.   /*
  190.    * read an instruction from the hanoi engine
  191.    */
  192.   rc = read(engine_fd, next_move, 3);
  193.   if (rc == 3 && next_move[0] == 'M') {
  194.       /* choose poles/disks to move */
  195.         old_pole = next_move[1];
  196.       c_pole = next_move[2];
  197.       c_disk = disks_on_poles[old_pole].disks[disks_on_poles[old_pole].num_disks - 1];
  198.       state = ST_UP;
  199.       disk_incr[Z] = CYL_HEIGHT / (float)UP_CLICKS;
  200.   }
  201.   else if (rc == 3 && next_move[0] == 'D') {
  202.       state = ST_IDLE;
  203.   }
  204.   else if (rc != 0) {
  205.       fprintf(stderr,"bad read; %d, [%d%d%d]n",
  206.       rc, next_move[0], next_move[1], next_move[2]);
  207.       exit(1);
  208.   }
  209.   /* if rc == 0, do nothing this frame */
  210.   break;
  212. case ST_UP:
  213.   disk_offset[c_disk][Z] += disk_incr[Z];
  214.   if (disk_offset[c_disk][Z] >= (CYL_HEIGHT+0.1)) {
  215.       state = ST_TO_1;
  216.       over_clicks = OVER_CLICKS;
  217.       disk_incr[X] = (pole_offset[c_pole][X] 
  218.       - pole_offset[old_pole][X]) / (float)(over_clicks-1);
  219.       disk_incr[Y] = (pole_offset[c_pole][Y] 
  220.       - pole_offset[old_pole][Y]) / (float)(over_clicks-1);
  221.       disk_incr[Z] = 0.0;
  222.   }
  223.   break;
  225. case ST_DOWN:
  226.   disk_offset[c_disk][Z] -= disk_incr[Z];
  227.   if (disk_offset[c_disk][Z] <= (disks_on_poles[c_pole].num_disks*0.2+disk_incr[Z])) {
  228.       disk_offset[c_disk][Z] = disks_on_poles[c_pole].num_disks*0.2;
  229.       disks_on_poles[old_pole].num_disks --;
  230.       disks_on_poles[c_pole].disks[disks_on_poles[c_pole].num_disks ++] = c_disk;
  231.       state = ST_READNEXT;
  232.   }
  233.   break;
  235. case ST_TO_1:
  236. case ST_TO_2:
  237.   disk_offset[c_disk][X] += disk_incr[X];
  238.   disk_offset[c_disk][Y] += disk_incr[Y];
  239.   over_clicks --;
  240.   if (over_clicks == 0) {
  241.       state = ST_DOWN;
  242.       disk_incr[X] = 0.0;
  243.       disk_incr[Y] = 0.0;
  244.       disk_incr[Z] = CYL_HEIGHT / (float)UP_CLICKS;
  245.       disk_offset[c_disk][X] = pole_offset[c_pole][X]; /* paranoia */
  246.       disk_offset[c_disk][Y] = pole_offset[c_pole][Y];
  247.   }
  248.   break;
  250. case ST_IDLE:
  251.   break;
  252.       }
  253.   }
  254.   glutPostRedisplay();
  255. }
  257. void
  258. draw_scene(void)
  259. {
  260.   int i;
  261.   glPushMatrix();
  262.     glRotatef(click, 0, 0, 1);
  263.     glRotatef(click/5.0, 1, 0, 0);
  264.     for (i=0; i<3; i++) {
  265.       glPushMatrix();
  266. glTranslatef(pole_offset[i][X], pole_offset[i][Y], 0);
  267.         glCallList(DL_POLE);
  268.       glPopMatrix();
  269.     }
  270.     for(i=0; i<num_disks; i++) {
  271.       glPushMatrix();
  272. glTranslatef(disk_offset[i][X], disk_offset[i][Y], disk_offset[i][Z]);
  273. glCallList(DL_DISK+i);
  274.       glPopMatrix();
  275.     }
  276. #ifndef TOOSLOW
  277.     glCallList(DL_FLOOR);
  278. #endif
  279.   glPopMatrix();
  280. }
  282. void
  283. display(void)
  284. {
  285.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  286.   draw_scene();
  288.   glutSwapBuffers();
  289. }
  291. void
  292. decide_animation(void)
  293. {
  294.   if(motion || spinning) {
  295.     glutIdleFunc(idle);
  296.   } else {
  297.     glutIdleFunc(NULL);
  298.   }
  299. }
  301. void
  302. visible(int state)
  303. {
  304.   if (state == GLUT_VISIBLE) {
  305.     decide_animation();
  306.   } else {
  307.     glutIdleFunc(NULL);
  308.   }
  309. }
  311. void
  312. menu(int value)
  313. {
  314.   switch (value) {
  315.   case 2:
  316.     motion = 1 - motion;
  317.     decide_animation();
  318.     break;
  319.   case 3:
  320.     spinning = 1 - spinning;
  321.     decide_animation();
  322.     break;
  323.   case 666:
  324.     kill(engine_pid, SIGTERM);
  325.     exit(0);
  326.   }
  327. }
  329. int
  330. main(int argc, char *argv[])
  331. {
  332.   int c;
  333.   int i;
  335.   GLfloat mat_specular[] = { 0.7, 0.7, 0.7, 1.0 };
  336.   GLfloat mat_shininess[] = { 40.0 };
  337.   GLfloat light_position[] = { 4.5, 0.0, 4.5, 0.0 };
  339.   glutInit(&argc, argv);
  341.   num_disks = MAX_DISKS;
  342.   while((c = getopt(argc, argv, "n:s:m:")) != -1) {
  343.       switch (c) {
  344. case 'n':
  345.   num_disks = atoi(optarg);
  346.   if (num_disks < 1 || num_disks > MAX_DISKS) {
  347.       num_disks = MAX_DISKS;
  348.   }
  349.   break;
  350. case 's':
  351.   spinning = atoi(optarg) ? 1 : 0;
  352.   break;
  353. case 'm':
  354.   motion = atoi(optarg) ? 1 : 0;
  355.   break;
  356. default:
  357.   break;
  358.       }
  359.   }
  361.   glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
  362.   glutCreateWindow("Hanoi");
  363.   glutDisplayFunc(display);
  364.   glutVisibilityFunc(visible);
  365.   glMatrixMode(GL_PROJECTION);
  366.   gluPerspective(40.0, 1.0, 0.1, 10.0);
  367.   glMatrixMode(GL_MODELVIEW);
  368.   gluLookAt(0, 5.5, 3.5,
  369.     0, 0, 0,
  370.     0, 0, 1);
  371.   glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
  372. #ifndef TOOSLOW
  373.   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  374.   glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
  375.   glEnable(GL_COLOR_MATERIAL);
  376. #endif
  377. #ifndef TOOSLOW
  378.   glShadeModel(GL_SMOOTH);
  379. #endif
  380.   glEnable(GL_DEPTH_TEST);
  381.   glEnable(GL_CULL_FACE);
  382. #ifndef TOOSLOW
  383.   glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  384.   glEnable(GL_LIGHTING);
  385.   glEnable(GL_LIGHT0);
  386. #endif
  387.   glDepthFunc(GL_LEQUAL);
  388.   glClearColor(0.3, 0.3, 0.3, 0.0);
  389. #ifndef TOOSLOW
  390.   glEnable(GL_BLEND);
  391.   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  392. #endif
  394.   glPolygonMode(GL_FRONT, GL_FILL);
  396.   glutCreateMenu(menu);
  397.   glutAddMenuEntry("Toggle motion", 2);
  398.   glutAddMenuEntry("Toggle spinning", 3);
  399.   glutAddMenuEntry("Quit", 666);
  400.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  401. #if defined(GL_POLYGON_OFFSET_EXT)
  402.   if (glutExtensionSupported("GL_EXT_polygon_offset")) {
  403.     glPolygonOffsetEXT(0.5, 0.0);
  404.     glEnable(GL_POLYGON_OFFSET_EXT);
  405.   }
  406. #endif
  408.   poledlist(DL_POLE);
  409.   floordlist(DL_FLOOR);
  410.   
  411.   disks_on_poles[0].num_disks = num_disks;
  412.   for (i=0; i<num_disks; i++) {
  413.       diskdlist(DL_DISK+i, 0.3 + i*0.1);
  414.       disks_on_poles[0].disks[num_disks-i-1] = i;
  415.       disk_offset[i][Z] = 0.2*(num_disks-i-1);
  416.   }
  418.   /*
  419.    * start hanoi instruction engine
  420.    */
  421.   {
  422.       int engine_args[2];
  423.       extern void engine(int *);
  424.       int p[2];
  426.       prctl(PR_SETEXITSIG, SIGTERM);
  427.       if (-1 == pipe(p)) {
  428.   perror("can't pipe");
  429.   exit(1);
  430.       }
  431.       engine_args[0] = num_disks;
  432.       engine_args[1] = p[1];
  433.       engine_fd = p[0];
  434.       engine_pid = sproc((void(*)(void *))engine, PR_SALL, (void *)engine_args);
  435.       if (engine_pid == -1) {
  436.   perror("can't sproc");
  437.   exit(1);
  438.       }
  439.   }
  441.   glutMainLoop();
  442.   /*NOTREACHED*/
  443.   return 0;             /* ANSI C requires main to return int. */
  444. }