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

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

GIS编程

开发平台：

Visual C++

lorenz.c：源码内容
  1. /*
  2.  * Lorenz Attractor Demo
  3.  *
  4.  * Adapted from code originally written for the 4D60GT by
  5.  * Aaron T. Ferrucci (aaronf@cse.ucsc.edu), 7/3/92.
  6.  *
  7.  * Description:
  8.  *
  9.  * This program shows some particles stuck in a Lorenz attractor (the parameters
  10.  * used are r=28, b=8/3, sigma=10). The eye is attracted to the red particle,
  11.  * with a force directly proportionate to distance. A command line
  12.  * puts the whole mess inside a box made of hexagons. I think this helps to
  13.  * maintain the illusion of 3 dimensions, but it can slow things down.
  14.  * Other options allow you to play with the redraw rate and the number of new
  15.  * lines per redraw. So you can customize it to the speed of your machine.
  16.  * 
  17.  * For general info on Lorenz attractors I recommend "An Introduction to
  18.  * the Lorenz Equations", IEEE Transactions on Circuits and Systems, August '83.
  19.  *
  20.  * Bugs: hidden surface removal doesn't apply to hexagons, and
  21.  * works poorly on lines when they are too close together.
  22.  *
  23.  * Notes on OpenGL port:
  24.  * 
  25.  * The timer functions do not exist in OpenGL, so the drawing occurs in a
  26.  * continuous loop, controlled by step, stop and go input from the keyboard.
  27.  * Perhaps system function could be called to control timing.
  28.  *
  29.  */
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <string.h>
  34. #include <math.h>
  35. #include <time.h>
  36. #include <GL/glut.h>
  38. float
  39. random_float(void)
  40. {
  41.   return (float)rand()/RAND_MAX;
  42. }
  44. void
  45. seed_random_float(long seed)
  46. {
  47.   srand(seed);
  48. }
  50. static GLuint asphere;
  52. #define POINTMASK 511
  53. #define G (0.002) /* eyept to red sphere gravity */
  54. #define LG (0.3)
  55. #define CUBESIDE (120.)
  56. #define CUBESCALE (23.)
  57. #define CUBEOFFX (-4.)
  58. #define CUBEOFFY (0.)
  59. #define CUBEOFFZ (57.)
  60. #define FALSE 0
  61. #define TRUE 1
  63. /* globals */
  64. float sigma = 10., r = 28., b = 8./3., dt = 0.003;
  65. int rp = 0, bp = 0, gp = 0, yp = 0, mp = 0;
  66. long xmax, ymax, zmax, zmin;
  67. float rv[POINTMASK+1][3], /* red points */
  68. bv[POINTMASK+1][3], /* blue points */
  69. gv[POINTMASK+1][3], /* green points */
  70. yv[POINTMASK+1][3], /* yellow points */
  71. mv[POINTMASK+1][3]; /* magenta points */
  73. int lpf; /* number of new lines per frame */
  75. float eyex[3], /* eye location */
  76.  eyev[3], /* eye velocity */
  77.  eyel[3]; /* lookat point location */
  78. GLint fovy = 600;
  79. float dx, dy, dz;
  80. GLUquadricObj *quadObj;
  82. float cubeoffx = CUBEOFFX;
  83. float cubeoffy = CUBEOFFY;
  84. float cubeoffz = CUBEOFFZ;
  85. float farplane = 80.;
  87. int animate = 1;
  89. /* option flags */
  90. GLboolean hexflag, /* hexagons? */
  91. sflag, 
  92. fflag,
  93. wflag,
  94. gflag,
  95. debug;
  97. /* option values */
  98. short hexbright; /* brightness for hexagon color */
  99. int speed, /* speed (number of new line segs per redraw) */
  100.     frame; /* frame rate (actually noise value for TIMER0) */
  101. float a = 0,
  102.     da; /* hexagon rotational velocity (.1 degree/redraw) */
  103. float gravity;
  105. /* function declarations */
  106. void init_3d(void);
  107. void init_graphics(void);
  108. void draw_hexcube(void);
  109. void draw_hexplane(void);
  110. void draw_hexagon(void);
  111. void move_eye(void);
  112. void redraw(void);
  113. void next_line(float v[][3], int *p);
  114. void parse_args(int argc, char **argv);
  115. void print_usage(char*);
  116. void print_info(void);
  117. void sphdraw(float args[4]);
  118. void setPerspective(int angle, float aspect, float zNear, float zFar);
  121. static void Reshape(int width, int height)
  122. {
  124.       glViewport(0,0,width,height);
  125.       glClear(GL_COLOR_BUFFER_BIT);
  126.       xmax = width;
  127.       ymax = height;
  128. }
  130. /* ARGSUSED1 */
  131. static void Key(unsigned char key, int x, int y)
  132. {
  134.     switch (key) {
  135.       case 'g':
  136. animate = 1;
  137. glutPostRedisplay();
  138. break;
  139.       case 's':
  140.  animate = 0;
  141.  glutPostRedisplay();
  142.  break;
  143.       case 27:
  144. gluDeleteQuadric(quadObj);
  145. exit(0);
  146.     }
  147. }
  149. static void Draw(void)
  150. {
  151.     int i;
  153.     if (animate) {
  154. i = speed;
  155. while (i--) {
  156.     next_line(rv, &rp);
  157.     next_line(bv, &bp);
  158.     next_line(gv, &gp);
  159.     next_line(yv, &yp);
  160.     next_line(mv, &mp);
  161. }
  162. glPushMatrix();
  163. move_eye();
  164. redraw();
  165. glPopMatrix();
  166.     }
  167. }
  169. int main(int argc, char **argv)
  170. {
  171.     glutInitWindowSize(600, 600);
  173.     glutInit(&argc, argv);
  175.     parse_args(argc, argv);
  177.     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  179.     glutCreateWindow("Lorenz Attractors");
  181.     init_3d();
  182.     init_graphics();
  184.     /* draw the first POINTMASK points in each color */
  185.     while(rp < POINTMASK) {
  186. next_line(rv, &rp);
  187. next_line(bv, &bp);
  188. next_line(gv, &gp);
  189. next_line(yv, &yp);
  190. next_line(mv, &mp);
  191.     }
  193.     eyex[0] = eyex[1] = eyex[2] = 0.;
  194.     eyel[0] = rv[rp][0];
  195.     eyel[1] = rv[rp][1];
  196.     eyel[2] = rv[rp][2];
  198.     glPushMatrix();
  199.     move_eye();
  200.     redraw();
  201.     glPopMatrix();
  203.     glutReshapeFunc(Reshape);
  204.     glutKeyboardFunc(Key);
  205.     glutIdleFunc(Draw);
  206.     glutDisplayFunc(Draw);
  207.     glutMainLoop();
  208.     return 0;             /* ANSI C requires main to return int. */
  209. }
  211. /* compute the next point on the path according to Lorenz' equations. */
  212. void next_line(float v[][3], int *p)
  213. {
  215.     dx = sigma * (v[*p][1] - v[*p][0]) * dt;
  216.     dy = (r*v[*p][0] - v[*p][1] + v[*p][0]*v[*p][2]) * dt;
  217.     dz = (v[*p][0] *v[*p][1] + b*v[*p][2]) * dt;
  219.     v[(*p + 1) & POINTMASK][0] = v[*p][0] + dx;
  220.     v[(*p + 1) & POINTMASK][1] = v[*p][1] + dy;
  221.     v[(*p + 1) & POINTMASK][2] = v[*p][2] - dz;
  222.     *p = (*p + 1) & POINTMASK;
  223. }
  225. void drawLines(int index, float array[POINTMASK][3])
  226. {
  227.     int p;
  228.     int i;
  230. #define LINE_STEP 4
  232.     p = (index+1)&POINTMASK;
  233.     i = LINE_STEP-(p % LINE_STEP);
  234.     if (i == LINE_STEP) i=0;
  235.     glBegin(GL_LINE_STRIP);
  236. /* draw points in order from oldest to newest */
  237. while(p != index) {
  238.     if (i == 0) {
  239. glVertex3fv(array[p]);
  240. i = LINE_STEP;
  241.     } 
  242.     i--;
  243.     p = (p+1) & POINTMASK;
  244. }
  245. glVertex3fv(array[index]);
  246.     glEnd();
  247. }
  249. void redraw(void)
  250. {
  251.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  253.     if(hexflag)
  254. draw_hexcube();
  256.     glColor3f(1.0, 0.0, 0.0);
  257.     drawLines(rp, rv);
  258.     sphdraw(rv[rp]);
  260.     glColor3f(0.0, 0.0, 1.0);
  261.     drawLines(bp, bv);
  262.     sphdraw(bv[bp]);
  264.     glColor3f(0.0, 1.0, 0.0);
  265.     drawLines(gp, gv);
  266.     sphdraw(gv[gp]);
  268.     glColor3f(1.0, 0.0, 1.0);
  269.     drawLines(yp, yv);
  270.     sphdraw(yv[yp]);
  272.     glColor3f(0.0, 1.0, 1.0);
  273.     drawLines(mp, mv);
  274.     sphdraw(mv[mp]);
  276.     glutSwapBuffers();
  277. }
  279. void move_eye(void)
  280. {
  281.     /* first move the eye */
  282.     eyev[0] += gravity * (rv[rp][0] - eyex[0]);
  283.     eyev[1] += gravity * (rv[rp][1] - eyex[1]);
  284.     eyev[2] += gravity * (rv[rp][2] - eyex[2]);
  286.     /* adjust position using new velocity */
  287.     eyex[0] += eyev[0] * dt;
  288.     eyex[1] += eyev[1] * dt;
  289.     eyex[2] += eyev[2] * dt;
  291.     /* move the lookat point */
  292.     /* it catches up to the red point if it's moving slowly enough */
  293.     eyel[0] += LG * (rv[rp][0] - eyel[0]);
  294.     eyel[1] += LG * (rv[rp][1] - eyel[1]);
  295.     eyel[2] += LG * (rv[rp][2] - eyel[2]);
  297.     /* change view */
  298.     gluLookAt(eyex[0], eyex[1], eyex[2], eyel[0], eyel[1], eyel[2],
  299.       0, 1, 0);
  300. }
  302. void draw_hexcube(void)
  303. {
  305.     a += da;
  306.     if(a >= 720.) /* depends on slowest rotation factor */
  307. a = 0.;
  309.     /* draw hexplanes, without changing z-values */
  310.     glDepthMask(GL_FALSE); 
  311.     glDisable(GL_DEPTH_TEST);
  313.     /* x-y plane */
  314.     glColor3f(0.2, 0.2, 0.6);
  315.     glPushMatrix();
  316.     glTranslatef(cubeoffx, cubeoffy, cubeoffz);
  317.     glScalef(CUBESCALE, CUBESCALE, CUBESCALE);
  318.     draw_hexplane();
  319.     glPopMatrix();
  321.     /* x-y plane, translated */
  322.     glPushMatrix();
  323.     glTranslatef(cubeoffx, cubeoffy, cubeoffz - 2*CUBESIDE);
  324.     glScalef(CUBESCALE, CUBESCALE, CUBESCALE);
  325.     draw_hexplane();
  326.     glPopMatrix();
  328.     glColor3f(0.6, 0.2, 0.2);
  329.     /* x-z plane, translate low */
  330.     glPushMatrix();
  331.     glRotatef(90, 1.0, 0.0, 0.0);
  332.     glTranslatef(cubeoffx, cubeoffz - CUBESIDE, -cubeoffy + CUBESIDE);
  333.     glScalef(CUBESCALE, CUBESCALE, CUBESCALE);
  334.     draw_hexplane();
  335.     glPopMatrix();
  337.     /* x-z plane, translate high */
  338.     glPushMatrix();
  339.     glRotatef(90, 1.0, 0.0, 0.0);
  340.     glTranslatef(cubeoffx, cubeoffz - CUBESIDE, -cubeoffy - CUBESIDE);
  341.     glScalef(CUBESCALE, CUBESCALE, CUBESCALE);
  342.     draw_hexplane();
  343.     glPopMatrix();
  345.     glColor3f(0.2, 0.6, 0.2);
  346.     /* y-z plane, translate low */
  347.     glPushMatrix();
  348.     glRotatef(90, 0.0, 1.0, 0.0);
  349.     glTranslatef(-cubeoffz + CUBESIDE, cubeoffy, cubeoffx + CUBESIDE);
  350.     glScalef(CUBESCALE, CUBESCALE, CUBESCALE);
  351.     draw_hexplane();
  352.     glPopMatrix();
  354.     /* y-z plane, translate high */
  355.     glPushMatrix();
  356.     glRotatef (90, 0.0, 1.0, 0.0);
  357.     glTranslatef(-cubeoffz + CUBESIDE, cubeoffy, cubeoffx - CUBESIDE);
  358.     glScalef(CUBESCALE, CUBESCALE, CUBESCALE);
  359.     draw_hexplane();
  360.     glPopMatrix();
  362.     glFlush();
  363.     glDepthMask(GL_TRUE);
  364.     glEnable(GL_DEPTH_TEST);
  365. }
  367. float hex_data[8][3] =  {
  368.     {0., 0., 0.},
  369.     {1.155, 0., 0.},
  370.     {0.577, 1., 0.},
  371.     {-0.577, 1., 0.},
  372.     {-1.155, 0., 0.},
  373.     {-0.577, -1., 0.},
  374.     {0.577, -1., 0.},
  375.     {1.155, 0., 0.},
  376. };
  378. /* draws a hexagon 2 units across, in the x-y plane, */
  379. /* centered at <0, 0, 0> */
  381. void draw_hexagon(void)
  382. {
  383.     if(wflag) {
  384. glPushMatrix();
  385. glRotatef(a, 0.0, 0.0, 1.0);
  386.     }
  388.     glBegin(GL_TRIANGLE_FAN);
  389. glVertex3fv(hex_data[0]);
  390. glVertex3fv(hex_data[1]);
  391. glVertex3fv(hex_data[2]);
  392. glVertex3fv(hex_data[3]);
  393. glVertex3fv(hex_data[4]);
  394. glVertex3fv(hex_data[5]);
  395. glVertex3fv(hex_data[6]);
  396. glVertex3fv(hex_data[7]);
  397.     glEnd();
  399.     if(wflag)
  400. glPopMatrix();
  401. }
  403. void tmp_draw_hexplane(void)
  404. {
  405.     glRectf(-2.0, -2.0, 2.0, 2.0);
  406. }
  408. /* draw 7 hexagons */
  409. void draw_hexplane(void)
  410. {
  411.     if(wflag) {
  412. glPushMatrix();
  413. glRotatef(-0.5*a, 0.0, 0.0, 1.0);
  414.     }
  416.     /* center , <0, 0, 0> */
  417.     draw_hexagon();
  419.     /* 12 o'clock, <0, 4, 0> */
  420.     glTranslatef(0., 4., 0.);
  421.     draw_hexagon();
  423.     /* 10 o'clock, <-3.464, 2, 0> */
  424.     glTranslatef(-3.464, -2., 0.);
  425.     draw_hexagon();
  427.     /* 8 o'clock, <-3.464, -2, 0> */
  428.     glTranslatef(0., -4., 0.);
  429.     draw_hexagon();
  431.     /* 6 o'clock, <0, -4, 0> */
  432.     glTranslatef(3.464, -2., 0.);
  433.     draw_hexagon();
  435.     /* 4 o'clock, <3.464, -2, 0> */
  436.     glTranslatef(3.464, 2., 0.);
  437.     draw_hexagon();
  439.     /* 2 o'clock, <3.464, 2, 0> */
  440.     glTranslatef(0., 4., 0.);
  441.     draw_hexagon();
  443.     if(wflag)
  444. glPopMatrix();
  445. }
  447. void sphdraw(float args[3])
  448. {
  449.     glPushMatrix();
  450.     glTranslatef(args[0], args[1], args[2]);
  451.     glCallList(asphere);
  452.     glPopMatrix();
  453. }
  455. void setPerspective(int angle, float aspect, float zNear, float zFar)
  456. {
  457.     glPushAttrib(GL_TRANSFORM_BIT);
  458.     glMatrixMode(GL_PROJECTION);
  459.     gluPerspective(angle * 0.1, aspect, zNear, zFar);
  460.     glPopAttrib();
  461. }
  463. /* initialize global 3-vectors */
  464. void init_3d(void)
  465. {
  466.     (void)seed_random_float((long)time((time_t*)NULL));
  468.     /* initialize colored points */
  469.     rv[0][0] = (float)random_float() * 10.;
  470.     rv[0][1] = (float)random_float() * 10.;
  471.     rv[0][2] = (float)random_float() * 10. - 10.;
  473.     bv[0][0] = rv[0][0] + (float)random_float()*5.;
  474.     bv[0][1] = rv[0][1] + (float)random_float()*5.;
  475.     bv[0][0] = rv[0][2] + (float)random_float()*5.;
  477.     gv[0][0] = rv[0][0] + (float)random_float()*5.;
  478.     gv[0][1] = rv[0][1] + (float)random_float()*5.;
  479.     gv[0][0] = rv[0][2] + (float)random_float()*5.;
  481.     yv[0][0] = rv[0][0] + (float)random_float()*5.;
  482.     yv[0][1] = rv[0][1] + (float)random_float()*5.;
  483.     yv[0][0] = rv[0][2] + (float)random_float()*5.;
  485.     mv[0][0] = rv[0][0] + (float)random_float()*5.;
  486.     mv[0][1] = rv[0][1] + (float)random_float()*5.;
  487.     mv[0][0] = rv[0][2] + (float)random_float()*5.;
  489.     /* initialize eye velocity */
  490.     eyev[0] = eyev[1] = eyev[2] = 0.;
  491. }
  494. void init_graphics(void)
  495. {
  496.     int width = 600;
  497.     int height = 600;
  499.     xmax = width;
  500.     ymax = height;
  501.     glDrawBuffer(GL_BACK);
  502.     glEnable(GL_DEPTH_TEST);
  503.     glClearColor(0.0, 0.0, 0.0, 0.0);
  504.     glClearDepth(1.0);
  506.     glEnable(GL_CULL_FACE);
  507.     glCullFace(GL_BACK);
  509.     glViewport(0, 0, xmax, ymax);
  510.     setPerspective(fovy, (float)xmax/(float)ymax, 0.01, farplane);
  511.     quadObj = gluNewQuadric();
  512.     gluQuadricNormals(quadObj, GLU_NONE);
  513.     asphere = glGenLists(1);
  514.     glNewList(asphere, GL_COMPILE);
  515.     gluSphere(quadObj, 0.3, 12, 8);
  516.     glEndList();
  517. }
  519. #define USAGE "usage message: this space for rentn"
  520. void parse_args(int argc, char **argv)
  521. {
  522.     hexflag = sflag = fflag = wflag = gflag = debug = FALSE;
  524.     while (--argc) {
  525. if (strcmp("-X", argv[argc]) == 0) {
  526.     debug = TRUE;
  527. } else if (strcmp("-h", argv[argc]) == 0) {
  528.     print_usage(argv[0]);
  529.     exit(1);
  530. } else if (strcmp("-i", argv[argc]) == 0) {
  531.     print_info();
  532.     exit(1);
  533. } else if (strcmp("-x", argv[argc]) == 0) {
  534.     hexflag = TRUE;
  535.     farplane = 300.;
  536. } else if (strcmp("-s", argv[argc]) == 0) {
  537.     sflag = TRUE;
  538.     if (argv[argc+1])
  539. speed = atoi(argv[argc+1]);
  540.     else {
  541. printf("%s: -s option requires an argument.n", argv[0]);
  542. exit(1);
  543.     }
  544. } else if (strcmp("-f", argv[argc]) == 0) {
  545.     fflag = TRUE;
  546.     if (argv[argc+1])
  547. frame = atoi(argv[argc+1]);
  548.     else {
  549. printf("%s: -f option requires an argument.n", argv[0]);
  550. exit(1);
  551.     }
  552.     if(frame < 0) {
  553. fprintf(stderr, "Try a small positive value for n");
  554. fprintf(stderr, "'f'; this is the number of vertical ");
  555. fprintf(stderr, "retraces per redrawn");
  556. fprintf(stderr, "Try %s -h for helpn", argv[0]);
  557. exit(1);
  558.     }
  559. } else if (strcmp("-w", argv[argc]) == 0) {
  560.     wflag = TRUE;
  561.     if (argv[argc+1])
  562. da = atof(argv[argc+1]);
  563.     else {
  564. printf("%s: -w option requires an argument.n", argv[0]);
  565. exit(1);
  566.     }
  567.     if(da > 10.) {
  568. fprintf(stderr, "That's a large rotational velocity ('w')");
  569. fprintf(stderr, " but you asked for itn");
  570.     }
  571.     break;
  572. } else if (strcmp("-g", argv[argc]) == 0) {
  573.     gflag = TRUE;
  574.     if (argv[argc+1])
  575. gravity = atof(argv[argc+1]);
  576.     else {
  577. printf("%s: -g option requires an argument.n", argv[0]);
  578. exit(1);
  579.     }
  580.     if(gravity <= 0) {
  581. fprintf(stderr, "Gravity ('g') should be positiven");
  582. fprintf(stderr, "Try %s -h for helpn", argv[0]);
  583.     }
  584. } else if (strcmp("-?", argv[argc]) == 0) {
  585.     fprintf(stderr, USAGE);
  586. }
  587.     }
  589.     /* set up default values */
  590.     if(!sflag)
  591. speed = 3;
  592.     if(!fflag)
  593. frame = 2;
  594.     if(!wflag)
  595. da = 0.;
  596.     if(!gflag)
  597. gravity = G;
  598. }
  600. void print_usage(char *program)
  601. {
  602. printf("nUsage: %s [-h] [-i] [-x] [-s speed]", program);
  603. printf(" [-w rot_v] [-g gravity]nn");
  604. printf("-h              Print this message.n");
  605. printf("-i              Print information about the demo.n");
  606. printf("-x              Enclose the particles in a box made of hexagons.n");
  607. printf("-s speed        Sets the number of new line segments per redraw n");
  608. printf("                interval per line. Default value: 3.n");
  610. /*** The X port does not currently include a timer, so this feature is disabled.
  611. printf("-f framenoise   Sets the number of vertical retraces per redrawn");
  612. printf("                interval. Example: -f 2 specifies one redraw pern");
  613. printf("                2 vertical retraces, or 30 frames per second.n");
  614. printf("                Default value: 2.n");
  615. ************/
  617. printf("-w rot_v        Spins the hexagons on their centers, and the sidesn");
  618. printf("                of the box on their centers. Hexagons spin at then");
  619. printf("                rate rot_v degrees per redraw, and box sides spinn");
  620. printf("                at -rot_v/2 degrees per redraw.n");
  621. printf("-g gravity      Sets the strength of the attraction of the eye ton");
  622. printf("                the red particle. Actually, it's not gravity sincen");
  623. printf("                the attraction is proportionate to distance.n");
  624. printf("                Default value: 0.002. Try large values!n");
  625. /* input added for GLX port */
  626. printf(" Executions control:  n");
  627. printf("    <spacebar> step through single framesn");
  628. printf("    g begin continuous framesn");
  629. printf("    s stop continuous framesn");
  631. }
  633. void print_info(void)
  634. {
  635. printf("nLORENZ ATTRACTOR DEMOnn");
  636. printf("This program shows some particles stuck in a Lorenz attractor (the n");
  637. printf("parameters used are r=28, b=8/3, sigma=10). The eye is attracted to n");
  638. printf("the red particle, with a force directly proportional to distance. n");
  639. printf("A command line argument puts the particles inside a box made of hexagons, n");
  640. printf("helping  to maintain the sense of 3 dimensions, but it can slow things down.n");
  641. printf("Other options allow you to play with the redraw rate and gravity.nn");
  643. printf("Try lorenz -h for the usage message.n");
  644. }