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

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

GIS编程

开发平台：

Visual C++

asteroids.c：源码内容
  2. /* Copyright (c) Mark J. Kilgard, 1997, 1998. */
  4. /* This program is freely distributable without licensing fees
  5.    and is provided without guarantee or warrantee expressed or
  6.    implied. This program is -not- in the public domain. */
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <math.h>
  12. #include <GL/glut.h>
  14. /* Some <math.h> files do not define M_PI... */
  15. #ifndef M_PI
  16. #define M_PI 3.14159265358979323846
  17. #endif
  19. void initWindow(void);
  21. float angle = 0.0;
  22. int left, right;
  23. int leftTime, rightTime;
  24. int thrust, thrustTime;
  25. int joyThrust = 0, joyLeft = 0, joyRight = 0;
  26. float x = 20, y = 20, xv, yv, v;
  27. int shield = 0, joyShield = 0, cursor = 1;
  28. int lastTime;
  29. int paused = 0;
  30. int resuming = 1;
  31. int originalWindow = 0, currentWindow;
  33. typedef struct {
  34.   int inuse;
  36.   float x;
  37.   float y;
  39.   float v;
  40.   float xv;
  41.   float yv;
  43.   int expire;
  44. } Bullet;
  46. #define MAX_BULLETS 10
  48. Bullet bullet[MAX_BULLETS];
  50. int
  51. allocBullet(void)
  52. {
  53.   int i;
  55.   for (i=0; i<MAX_BULLETS; i++) {
  56.     if (!bullet[i].inuse) {
  57.       return i;
  58.     }
  59.   }
  60.   return -1;
  61. }
  63. void
  64. initBullet(int i, int time)
  65. {
  66.   float c = cos(angle*M_PI/180.0);
  67.   float s = sin(angle*M_PI/180.0);
  69.   bullet[i].inuse = 1;
  70.   bullet[i].x = x + 2 * c;
  71.   bullet[i].y = y + 2 * s;
  72.   bullet[i].v = 0.025;
  73.   bullet[i].xv = xv + c * bullet[i].v;
  74.   bullet[i].yv = yv + s * bullet[i].v;
  75.   bullet[i].expire = time + 1000;
  76. }
  78. void
  79. advanceBullets(int delta, int time)
  80. {
  81.   int i;
  83.   for (i=0; i<MAX_BULLETS; i++) {
  84.     if (bullet[i].inuse) {
  85.       float x, y;
  87.       if (time > bullet[i].expire) {
  88. bullet[i].inuse = 0;
  89. continue;
  90.       }
  91.       x = bullet[i].x + bullet[i].xv * delta;
  92.       y = bullet[i].y + bullet[i].yv * delta;
  93.       x = x / 40.0;
  94.       bullet[i].x = (x - floor(x))*40.0;
  95.       y = y / 40.0;
  96.       bullet[i].y = (y - floor(y))*40.0;
  97.     }
  98.   }
  99. }
  101. void
  102. shotBullet(void)
  103. {
  104.   int entry;
  106.   entry = allocBullet();
  107.   if (entry >= 0) {
  108.     initBullet(entry, glutGet(GLUT_ELAPSED_TIME));
  109.   }
  110. }
  112. void
  113. drawBullets(void)
  114. {
  115.   int i;
  117.   glBegin(GL_POINTS);
  118.   glColor3f(1.0, 0.0, 1.0);
  119.   for (i=0; i<MAX_BULLETS; i++) {
  120.     if (bullet[i].inuse) {
  121.       glVertex2f(bullet[i].x, bullet[i].y);
  122.     }
  123.   }
  124.   glEnd();
  125. }
  127. void
  128. drawShip(float angle)
  129. {
  130.   float rad;
  132.   glPushMatrix();
  133.   glTranslatef(x, y, 0.0);
  134.   glRotatef(angle, 0.0, 0.0, 1.0);
  135.   if (thrust) {
  136.     glColor3f(1.0, 0.0, 0.0);
  137.     glBegin(GL_LINE_STRIP);
  138.     glVertex2f(-0.75, -0.5);
  139.     glVertex2f(-1.75, 0);
  140.     glVertex2f(-0.75, 0.5);
  141.     glEnd();
  142.   }
  143.   glColor3f(1.0, 1.0, 0.0);
  144.   glBegin(GL_LINE_LOOP);
  145.   glVertex2f(2.0, 0.0);
  146.   glVertex2f(-1.0, -1.0);
  147.   glVertex2f(-0.5, 0.0);
  148.   glVertex2f(-1.0, 1.0);
  149.   glVertex2f(2.0, 0.0);
  150.   glEnd();
  151.   if (shield) {
  152.     glColor3f(0.1, 0.1, 1.0);
  153.     glBegin(GL_LINE_LOOP);
  154.     for (rad=0.0; rad<12.0; rad += 1.0) {
  155.       glVertex2f(2.3 * cos(2*rad/M_PI)+0.2, 2.0 * sin(2*rad/M_PI));
  156.     }
  157.     glEnd();
  158.   }
  159.   glPopMatrix();
  160. }
  162. void
  163. display(void)
  164. {
  165.   glClear(GL_COLOR_BUFFER_BIT);
  166.   drawShip(angle);
  167.   drawBullets();
  168.   glutSwapBuffers();
  169. }
  171. void
  172. idle(void)
  173. {
  174.   int time, delta;
  176.   time = glutGet(GLUT_ELAPSED_TIME);
  177.   if (resuming) {
  178.     lastTime = time;
  179.     resuming = 0;
  180.   }
  181.   if (left) {
  182.     delta = time - leftTime;
  183.     angle = angle + delta * 0.4;
  184.     leftTime = time;
  185.   }
  186.   if (right) {
  187.     delta = time - rightTime;
  188.     angle = angle - delta * 0.4;
  189.     rightTime = time;
  190.   }
  191.   if (thrust) {
  192.     delta = time - thrustTime;
  193.     v = delta * 0.00004;
  194.     xv = xv + cos(angle*M_PI/180.0) * v;
  195.     yv = yv + sin(angle*M_PI/180.0) * v;
  196.     thrustTime = time;
  197.   }
  198.   delta = time - lastTime;
  199.   x = x + xv * delta;
  200.   y = y + yv * delta;
  201.   x = x / 40.0;
  202.   x = (x - floor(x))*40.0;
  203.   y = y / 40.0;
  204.   y = (y - floor(y))*40.0;
  205.   lastTime = time;
  206.   advanceBullets(delta, time);
  207.   glutPostWindowRedisplay(currentWindow);
  208. }
  210. void
  211. visible(int vis)
  212. {
  213.   if (vis == GLUT_VISIBLE) {
  214.     if (!paused) {
  215.       glutIdleFunc(idle);
  216.     }
  217.   } else {
  218.     glutIdleFunc(NULL);
  219.   }
  220. }
  222. /* ARGSUSED1 */
  223. void
  224. key(unsigned char key, int px, int py)
  225. {
  226.   switch (key) {
  227.   case 27:
  228.     exit(0);
  229.     break;
  230.   case 'A':
  231.   case 'a':
  232.     thrust = 1;
  233.     thrustTime = glutGet(GLUT_ELAPSED_TIME);
  234.     break;
  235.   case 'S':
  236.   case 's':
  237.     shield = 1;
  238.     break;
  239.   case 'C':
  240.   case 'c':
  241.     cursor = !cursor;
  242.     glutSetCursor(
  243.       cursor ? GLUT_CURSOR_INHERIT : GLUT_CURSOR_NONE);
  244.     break;
  245.   case 'z':
  246.   case 'Z':
  247.     x = 20;
  248.     y = 20;
  249.     xv = 0;
  250.     yv = 0;
  251.     break;
  252.   case 'f':
  253.     glutGameModeString("400x300:16@60");
  254.     glutEnterGameMode();
  255.     initWindow();
  256.     break;
  257.   case 'g':
  258.     glutGameModeString("640x480:16@60");
  259.     glutEnterGameMode();
  260.     initWindow();
  261.     break;
  262.   case 'l':
  263.     if (originalWindow != 0 && currentWindow != originalWindow) {
  264.       glutLeaveGameMode();
  265.       currentWindow = originalWindow;
  266.     }
  267.     break;
  268.   case 'P':
  269.   case 'p':
  270.     paused = !paused;
  271.     if (paused) {
  272.       glutIdleFunc(NULL);
  273.     } else {
  274.       glutIdleFunc(idle);
  275.       resuming = 1;
  276.     }
  277.     break;
  278.   case 'Q':
  279.   case 'q':
  280.   case ' ':
  281.     shotBullet();
  282.     break;
  283.   }
  284. }
  286. /* ARGSUSED1 */
  287. void
  288. keyup(unsigned char key, int x, int y)
  289. {
  290.   switch (key) {
  291.   case 'A':
  292.   case 'a':
  293.     thrust = 0;
  294.     break;
  295.   case 'S':
  296.   case 's':
  297.     shield = 0;
  298.     break;
  299.   }
  300. }
  302. /* ARGSUSED1 */
  303. void
  304. special(int key, int x, int y)
  305. {
  306.   switch (key) {
  307.   case GLUT_KEY_F1:
  308.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  309.     glEnable(GL_BLEND);
  310.     glEnable(GL_LINE_SMOOTH);
  311.     glEnable(GL_POINT_SMOOTH);
  312.     break;
  313.   case GLUT_KEY_F2:
  314.     glDisable(GL_BLEND);
  315.     glDisable(GL_LINE_SMOOTH);
  316.     glDisable(GL_POINT_SMOOTH);
  317.     break;
  318.   case GLUT_KEY_UP:
  319.     thrust = 1;
  320.     thrustTime = glutGet(GLUT_ELAPSED_TIME);
  321.     break;
  322.   case GLUT_KEY_LEFT:
  323.     left = 1;
  324.     leftTime = glutGet(GLUT_ELAPSED_TIME);
  325.     break;
  326.   case GLUT_KEY_RIGHT:
  327.     right = 1;
  328.     rightTime = glutGet(GLUT_ELAPSED_TIME);
  329.     break;
  330.   }
  331. }
  333. /* ARGSUSED1 */
  334. void
  335. specialup(int key, int x, int y)
  336. {
  337.   switch (key) {
  338.   case GLUT_KEY_UP:
  339.     thrust = 0;
  340.     break;
  341.   case GLUT_KEY_LEFT:
  342.     left = 0;
  343.     break;
  344.   case GLUT_KEY_RIGHT:
  345.     right = 0;
  346.     break;
  347.   }
  348. }
  350. /* ARGSUSED3 */
  351. void
  352. joystick(unsigned int buttons, int x, int y, int z)
  353. {
  354.   if (buttons & 0x1) {
  355.     thrust = 1;
  356.     thrustTime = glutGet(GLUT_ELAPSED_TIME);
  357.     joyThrust = 1;
  358.   } else {
  359.     if (joyThrust) {
  360.       thrust = 0;
  361.       joyThrust = 0;
  362.     }
  363.   }
  364.   if (buttons & 0x2) {
  365.     shotBullet();
  366.   }
  367.   if (buttons & 0x4) {
  368.     shield = 1;
  369.     joyShield = 1;
  370.   } else {
  371.     if (joyShield) {
  372.       shield = 0;
  373.       joyShield = 0;
  374.     }
  375.   }
  376.   if (x < -300) {
  377.     left = 1;
  378.     leftTime = glutGet(GLUT_ELAPSED_TIME);
  379.     joyLeft = 1;
  380.   } else {
  381.     /* joyLeft helps avoid "joystick in neutral"
  382.        from continually stopping rotation. */
  383.     if (joyLeft) {
  384.       left = 0;
  385.       joyLeft = 0;
  386.     }
  387.   }
  388.   if (x > 300) {
  389.     right = 1;
  390.     rightTime = glutGet(GLUT_ELAPSED_TIME);
  391.     joyRight = 1;
  392.   } else {
  393.     /* joyRight helps avoid "joystick in neutral"
  394.        from continually stopping rotation. */
  395.     if (joyRight) {
  396.       right = 0;
  397.       joyRight = 0;
  398.     }
  399.   }
  400. }
  402. void
  403. initWindow(void)
  404. {
  405.   glutIgnoreKeyRepeat(1);
  407.   glutDisplayFunc(display);
  408.   glutVisibilityFunc(visible);
  409.   glutKeyboardFunc(key);
  410.   glutKeyboardUpFunc(keyup);
  411.   glutSpecialFunc(special);
  412.   glutSpecialUpFunc(specialup);
  413.   glutJoystickFunc(joystick, 100);
  415.   glMatrixMode(GL_PROJECTION);
  416.   glLoadIdentity();
  417.   glOrtho(0, 40, 0, 40, 0, 40);
  418.   glMatrixMode(GL_MODELVIEW); 
  419.   glPointSize(3.0);
  421.   currentWindow = glutGetWindow();
  422. }
  424. int
  425. main(int argc, char **argv)
  426. {
  427.   glutInit(&argc, argv);
  428.   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  430.   if (argc > 1 && !strcmp(argv[1], "-fullscreen")) {
  431.     glutGameModeString("640x480:16@60");
  432.     glutEnterGameMode();
  433.   } else {
  434.     originalWindow = glutCreateWindow("asteroids");
  435.   }
  437.   initWindow();
  439.   glutMainLoop();
  440.   return 0;             /* ANSI C requires main to return int. */
  441. }