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

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

GIS编程

开发平台：

Visual C++

noof.c：源码内容
  2. /* XXX Very crufty code follows. */
  4. #include <stdlib.h>
  5. #include <GL/glut.h>
  7. #include <math.h>
  8. #ifndef _WIN32
  9. #include <unistd.h>
  10. #else
  11. #define random rand
  12. #define srandom srand
  13. #include <process.h>
  14. #endif
  15. /* Some <math.h> files do not define M_PI... */
  16. #ifndef M_PI
  17. #define M_PI 3.14159265358979323846
  18. #endif
  19. #include <sys/types.h>
  20. #include <stdio.h>
  22. /* For portability... */
  23. #undef fcos
  24. #undef fsin
  25. #define fcos  cos
  26. #define fsin  sin
  28. /* --- shape parameters def'n --- */
  29. #define N_SHAPES 7
  30. float pos[N_SHAPES * 3];
  31. float dir[N_SHAPES * 3];
  32. float acc[N_SHAPES * 3];
  33. float col[N_SHAPES * 3];
  34. float hsv[N_SHAPES * 3];
  35. float hpr[N_SHAPES * 3];
  36. float ang[N_SHAPES];
  37. float spn[N_SHAPES];
  38. float sca[N_SHAPES];
  39. float geep[N_SHAPES];
  40. float peep[N_SHAPES];
  41. float speedsq[N_SHAPES];
  42. int blad[N_SHAPES];
  44. float ht, wd;
  46. void
  47. initshapes(int i)
  48. {
  49.   int k;
  50.   float f;
  52.   /* random init of pos, dir, color */
  53.   for (k = i * 3; k <= i * 3 + 2; k++) {
  54.     f = random() / (float)RAND_MAX;
  55.     pos[k] = f;
  56.     f = random() / (float)RAND_MAX;
  57.     f = (f - 0.5) * 0.05;
  58.     dir[k] = f;
  59.     f = random() / (float)RAND_MAX;
  60.     f = (f - 0.5) * 0.0002;
  61.     acc[k] = f;
  62.     f = random() / (float)RAND_MAX;
  63.     col[k] = f;
  64.   }
  66.   speedsq[i] = dir[i * 3] * dir[i * 3] + dir[i * 3 + 1] * dir[i * 3 + 1];
  67.   f = random() / (float)RAND_MAX;
  68.   blad[i] = 2 + (int) (f * 17.0);
  69.   f = random() / (float)RAND_MAX;
  70.   ang[i] = f;
  71.   f = random() / (float)RAND_MAX;
  72.   spn[i] = (f - 0.5) * 40.0 / (10 + blad[i]);
  73.   f = random() / (float)RAND_MAX;
  74.   sca[i] = (f * 0.1 + 0.08);
  75.   dir[i * 3] *= sca[i];
  76.   dir[i * 3 + 1] *= sca[i];
  78.   f = random() / (float)RAND_MAX;
  79.   hsv[i * 3] = f * 360.0;
  81.   f = random() / (float)RAND_MAX;
  82.   hsv[i * 3 + 1] = f * 0.6 + 0.4;
  84.   f = random() / (float)RAND_MAX;
  85.   hsv[i * 3 + 2] = f * 0.7 + 0.3;
  87.   f = random() / (float)RAND_MAX;
  88.   hpr[i * 3] = f * 0.005 * 360.0;
  89.   f = random() / (float)RAND_MAX;
  90.   hpr[i * 3 + 1] = f * 0.03;
  91.   f = random() / (float)RAND_MAX;
  92.   hpr[i * 3 + 2] = f * 0.02;
  94.   geep[i] = 0;
  95.   f = random() / (float)RAND_MAX;
  96.   peep[i] = 0.01 + f * 0.2;
  97. }
  99. int tko = 0;
  101. float bladeratio[] =
  102. {
  103.   /* nblades = 2..7 */
  104.   0.0, 0.0, 3.00000, 1.73205, 1.00000, 0.72654, 0.57735, 0.48157,
  105.   /* 8..13 */
  106.   0.41421, 0.36397, 0.19076, 0.29363, 0.26795, 0.24648,
  107.   /* 14..19 */
  108.   0.22824, 0.21256, 0.19891, 0.18693, 0.17633, 0.16687,
  109. };
  111. void
  112. drawleaf(int l)
  113. {
  115.   int b, blades;
  116.   float x, y;
  117.   float wobble;
  119.   blades = blad[l];
  121.   y = 0.10 * fsin(geep[l] * M_PI / 180.0) + 0.099 * fsin(geep[l] * 5.12 * M_PI / 180.0);
  122.   if (y < 0)
  123.     y = -y;
  124.   x = 0.15 * fcos(geep[l] * M_PI / 180.0) + 0.149 * fcos(geep[l] * 5.12 * M_PI / 180.0);
  125.   if (x < 0.0)
  126.     x = 0.0 - x;
  127.   if (y < 0.001 && x > 0.000002 && ((tko & 0x1) == 0)) {
  128.     initshapes(l);      /* let it become reborn as something
  129.                            else */
  130.     tko++;
  131.     return;
  132.   } {
  133.     float w1 = fsin(geep[l] * 15.3 * M_PI / 180.0);
  134.     wobble = 3.0 + 2.00 * fsin(geep[l] * 0.4 * M_PI / 180.0) + 3.94261 * w1;
  135.   }
  137.   /**
  138.   if(blades == 2) if (y > 3.000*x) y = x*3.000;
  139.   if(blades == 3) if (y > 1.732*x) y = x*1.732;
  140.   if(blades == 4) if (y >       x) y = x;
  141.   if(blades == 5) if (y > 0.726*x) y = x*0.726;
  142.   if(blades == 6) if (y > 0.577*x) y = x*0.577;
  143.   if(blades == 7) if (y > 0.481*x) y = x*0.481;
  144.   if(blades == 8) if (y > 0.414*x) y = x*0.414;
  145.   */
  146.   if (y > x * bladeratio[blades])
  147.     y = x * bladeratio[blades];
  149.   for (b = 0; b < blades; b++) {
  150.     glPushMatrix();
  151.     glTranslatef(pos[l * 3], pos[l * 3 + 1], pos[l * 3 + 2]);
  152.     glRotatef(ang[l] + b * (360.0 / blades), 0.0, 0.0, 1.0);
  153.     glScalef(wobble * sca[l], wobble * sca[l], wobble * sca[l]);
  154.     /**
  155.     if(tko & 0x40000) glColor3f(col[l*3], col[l*3+1], col[l*3+2]); 
  156.     else
  157.     */
  158.     glColor4ub(0, 0, 0, 0x60);
  160.     /* constrain geep cooridinates here XXX */
  161.     glEnable(GL_BLEND);
  163.     glBegin(GL_TRIANGLE_STRIP);
  164.     glVertex2f(x * sca[l], 0.0);
  165.     glVertex2f(x, y);
  166.     glVertex2f(x, -y);  /* C */
  167.     glVertex2f(0.3, 0.0);  /* D */
  168.     glEnd();
  170.     /**
  171.     if(tko++ & 0x40000) glColor3f(0,0,0);
  172.     else
  173.     */
  174.     glColor3f(col[l * 3], col[l * 3 + 1], col[l * 3 + 2]);
  175.     glBegin(GL_LINE_LOOP);
  176.     glVertex2f(x * sca[l], 0.0);
  177.     glVertex2f(x, y);
  178.     glVertex2f(0.3, 0.0);  /* D */
  179.     glVertex2f(x, -y);  /* C */
  180.     glEnd();
  181.     glDisable(GL_BLEND);
  183.     glPopMatrix();
  184.   }
  185. }
  187. void
  188. motionUpdate(int t)
  189. {
  190.   if (pos[t * 3] < -sca[t] * wd && dir[t * 3] < 0.0) {
  191.     dir[t * 3] = -dir[t * 3];
  192.   /**
  193.   acc[t*3+1] += 0.8*acc[t*3];
  194.   acc[t*3] = -0.8*acc[t*3];
  195.   */
  196.   } else if (pos[t * 3] > (1 + sca[t]) * wd && dir[t * 3] > 0.0) {
  197.     dir[t * 3] = -dir[t * 3];
  198.     /**
  199.     acc[t*3+1] += 0.8*acc[t*3];
  200.     acc[t*3] = -0.8*acc[t*3];
  201.     */
  202.   } else if (pos[t * 3 + 1] < -sca[t] * ht && dir[t * 3 + 1] < 0.0) {
  203.     dir[t * 3 + 1] = -dir[t * 3 + 1];
  204.     /**
  205.     acc[t*3] += 0.8*acc[t*3+1];
  206.     acc[t*3+1] = -0.8*acc[t*3+1];
  207.     */
  208.   } else if (pos[t * 3 + 1] > (1 + sca[t]) * ht && dir[t * 3 + 1] > 0.0) {
  209.     dir[t * 3 + 1] = -dir[t * 3 + 1];
  210.     /**
  211.     acc[t*3] += 0.8*acc[t*3+1];
  212.     acc[t*3+1] = -0.8*acc[t*3+1];
  213.     */
  214.   }
  216.   pos[t * 3] += dir[t * 3];
  217.   pos[t * 3 + 1] += dir[t * 3 + 1];
  218.   /**
  219.   dir[t*3]   += acc[t*3];
  220.   dir[t*3+1] += acc[t*3+1];
  221.   */
  222.   ang[t] += spn[t];
  223.   geep[t] += peep[t];
  224.   if (geep[t] > 360 * 5.0)
  225.     geep[t] -= 360 * 5.0;
  226.   if (ang[t] < 0.0) {
  227.     ang[t] += 360.0;
  228.   }
  229.   if (ang[t] > 360.0) {
  230.     ang[t] -= 360.0;
  231.   }
  232. }
  234. void
  235. colorUpdate(int i)
  236. {
  237.   if (hsv[i * 3 + 1] <= 0.5 && hpr[i * 3 + 1] < 0.0)
  238.     hpr[i * 3 + 1] = -hpr[i * 3 + 1];  /* adjust s */
  239.   if (hsv[i * 3 + 1] >= 1.0 && hpr[i * 3 + 1] > 0.0)
  240.     hpr[i * 3 + 1] = -hpr[i * 3 + 1];  /* adjust s */
  241.   if (hsv[i * 3 + 2] <= 0.4 && hpr[i * 3 + 2] < 0.0)
  242.     hpr[i * 3 + 2] = -hpr[i * 3 + 2];  /* adjust s */
  243.   if (hsv[i * 3 + 2] >= 1.0 && hpr[i * 3 + 2] > 0.0)
  244.     hpr[i * 3 + 2] = -hpr[i * 3 + 2];  /* adjust s */
  246.   hsv[i * 3] += hpr[i * 3];
  247.   hsv[i * 3 + 1] += hpr[i * 3 + 1];
  248.   hsv[i * 3 + 2] += hpr[i * 3 + 2];
  250.   /* --- hsv -> rgb --- */
  251. #define H(hhh) hhh[i*3  ]
  252. #define S(hhh) hhh[i*3+1]
  253. #define V(hhh) hhh[i*3+2]
  255. #define R(hhh) hhh[i*3  ]
  256. #define G(hhh) hhh[i*3+1]
  257. #define B(hhh) hhh[i*3+2]
  259.   if (V(hsv) < 0.0)
  260.     V(hsv) = 0.0;
  261.   if (V(hsv) > 1.0)
  262.     V(hsv) = 1.0;
  263.   if (S(hsv) <= 0.0) {
  264.     R(col) = V(hsv);
  265.     G(col) = V(hsv);
  266.     B(col) = V(hsv);
  267.   } else {
  268.     float f, h, p, q, t, v;
  269.     int hi;
  271.     while (H(hsv) < 0.0)
  272.       H(hsv) += 360.0;
  273.     while (H(hsv) >= 360.0)
  274.       H(hsv) -= 360.0;
  276.     if (S(hsv) < 0.0)
  277.       S(hsv) = 0.0;
  278.     if (S(hsv) > 1.0)
  279.       S(hsv) = 1.0;
  281.     h = H(hsv) / 60.0;
  282.     hi = (int) (h);
  283.     f = h - hi;
  284.     v = V(hsv);
  285.     p = V(hsv) * (1 - S(hsv));
  286.     q = V(hsv) * (1 - S(hsv) * f);
  287.     t = V(hsv) * (1 - S(hsv) * (1 - f));
  289.     if (hi <= 0) {
  290.       R(col) = v;
  291.       G(col) = t;
  292.       B(col) = p;
  293.     } else if (hi == 1) {
  294.       R(col) = q;
  295.       G(col) = v;
  296.       B(col) = p;
  297.     } else if (hi == 2) {
  298.       R(col) = p;
  299.       G(col) = v;
  300.       B(col) = t;
  301.     } else if (hi == 3) {
  302.       R(col) = p;
  303.       G(col) = q;
  304.       B(col) = v;
  305.     } else if (hi == 4) {
  306.       R(col) = t;
  307.       G(col) = p;
  308.       B(col) = v;
  309.     } else {
  310.       R(col) = v;
  311.       G(col) = p;
  312.       B(col) = q;
  313.     }
  314.   }
  315. }
  317. void
  318. gravity(float fx)
  319. {
  320.   int a, b;
  322.   for (a = 0; a < N_SHAPES; a++) {
  323.     for (b = 0; b < a; b++) {
  324.       float t, d2;
  326.       t = pos[b * 3] - pos[a * 3];
  327.       d2 = t * t;
  328.       t = pos[b * 3 + 1] - pos[a * 3 + 1];
  329.       d2 += t * t;
  330.       if (d2 < 0.000001)
  331.         d2 = 0.00001;
  332.       if (d2 < 0.1) {
  334.         float v0, v1, z;
  335.         v0 = pos[b * 3] - pos[a * 3];
  336.         v1 = pos[b * 3 + 1] - pos[a * 3 + 1];
  338.         z = 0.00000001 * fx / (d2);
  340.         dir[a * 3] += v0 * z * sca[b];
  341.         dir[b * 3] += -v0 * z * sca[a];
  342.         dir[a * 3 + 1] += v1 * z * sca[b];
  343.         dir[b * 3 + 1] += -v1 * z * sca[a];
  345.       }
  346.     }
  347.     /** apply brakes
  348.     if(dir[a*3]*dir[a*3] + dir[a*3+1]*dir[a*3+1]
  349.       > 0.0001) {
  350.       dir[a*3] *= 0.9;
  351.       dir[a*3+1] *= 0.9;
  352.     }
  353.     */
  354.   }
  355. }
  356. void
  357. oneFrame(void)
  358. {
  359.   int i;
  361.   /**
  362.   if((random() & 0xff) == 0x34){
  363.     glClear(GL_COLOR_BUFFER_BIT);
  364.   }
  366.   if((tko & 0x1f) == 0x1f){
  367.     glEnable(GL_BLEND);
  368.     glColor4f(0.0, 0.0, 0.0, 0.09);
  369.     glRectf(0.0, 0.0, wd, ht);
  370.     glDisable(GL_BLEND);
  371. #ifdef __sgi
  372.     sginap(0);
  373. #endif
  374.   }
  375.   */
  376.   gravity(-2.0);
  377.   for (i = 0; i < N_SHAPES; i++) {
  378.     motionUpdate(i);
  379. #ifdef __sgi
  380.     sginap(0);
  381. #endif
  382.     colorUpdate(i);
  383. #ifdef __sgi
  384.     sginap(0);
  385. #endif
  386.     drawleaf(i);
  387. #ifdef __sgi
  388.     sginap(0);
  389. #endif
  391.   }
  392.   glFlush();
  393. }
  395. void
  396. display(void)
  397. {
  398.   glClear(GL_COLOR_BUFFER_BIT);
  399. }
  401. void
  402. myReshape(int w, int h)
  403. {
  404.   glViewport(0, 0, w, h);
  405.   glMatrixMode(GL_PROJECTION);
  406.   glLoadIdentity();
  407.   if (w <= h) {
  408.     wd = 1.0;
  409.     ht = (GLfloat) h / (GLfloat) w;
  410.     glOrtho(0.0, 1.0,
  411.       0.0, 1.0 * (GLfloat) h / (GLfloat) w,
  412.       -16.0, 4.0);
  413.   } else {
  414.     wd = (GLfloat) w / (GLfloat) h;
  415.     ht = 1.0;
  416.     glOrtho(0.0, 1.0 * (GLfloat) w / (GLfloat) h,
  417.       0.0, 1.0,
  418.       -16.0, 4.0);
  419.   }
  420.   glMatrixMode(GL_MODELVIEW);
  421.   glLoadIdentity();
  422. }
  424. void
  425. visibility(int status)
  426. {
  427.   if (status == GLUT_VISIBLE) {
  428.     glutIdleFunc(oneFrame);
  429.   } else {
  430.     glutIdleFunc(NULL);
  431.   }
  433. }
  435. void
  436. myinit(void)
  437. {
  438.   int i;
  439.   srandom(getpid());
  440.   glClearColor(0.0, 0.0, 0.0, 1.0);
  441.   glEnable(GL_LINE_SMOOTH);
  442.   glShadeModel(GL_FLAT);
  443.   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  444.   for (i = 0; i < N_SHAPES; i++)
  445.     initshapes(i);
  446.   myReshape(200, 200);
  447. }
  449. /* ARGSUSED1 */
  450. void
  451. keys(unsigned char c, int x, int y)
  452. {
  454.   if (c == 0x1b)
  455.     exit(0);            /* escape */
  456. }
  458. int
  459. main(int argc, char **argv)
  460. {
  461.   glutInit(&argc, argv);
  462.   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  463.   glutInitWindowSize(300, 300);
  464.   glutCreateWindow(argv[0]);
  466.   myinit();
  467.   glutReshapeFunc(myReshape);
  468.   glutDisplayFunc(display);
  469.   glutKeyboardFunc(keys);
  470.   glutVisibilityFunc(visibility);
  471.   glutIdleFunc(oneFrame);
  472.   glutPostRedisplay();
  473.   glutMainLoop();
  474.   return 0;             /* ANSI C requires main to return int. */
  475. }