home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / newopg.zip / STAR.C < prev    next >
Text File  |  1995-03-04  |  6KB  |  308 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <math.h>
  5. #include <time.h>
  6. #include "GL/gl.h"
  7. #include "GL/glu.h"
  8. #include "tk.h"
  9.  
  10.  
  11. #define PI 3.141592657
  12.  
  13. enum {
  14.     NORMAL = 0,
  15.     WEIRD = 1
  16. };
  17.  
  18. enum {
  19.     STREAK = 0,
  20.     CIRCLE = 1
  21. };
  22.  
  23. #define MAXSTARS 400
  24. #define MAXPOS 10000
  25. #define MAXWARP 10
  26. #define MAXANGLES 6000
  27.  
  28.  
  29. typedef struct _starRec {
  30.     GLint type;
  31.     float x[2], y[2], z[2];
  32.     float offsetX, offsetY, offsetR, rotation;
  33. } starRec;
  34.  
  35.  
  36. GLenum doubleBuffer, directRender;
  37. GLint windW, windH;
  38.  
  39. GLenum flag = NORMAL;
  40. GLint starCount = MAXSTARS / 2;
  41. float speed = 1.0;
  42. GLint nitro = 0;
  43. starRec stars[MAXSTARS];
  44. float sinTable[MAXANGLES];
  45.  
  46.  
  47. float Sin(float angle)
  48. {
  49.  
  50.     return (sinTable[(GLint)angle]);
  51. }
  52.  
  53. float Cos(float angle)
  54. {
  55.  
  56.     return (sinTable[((GLint)angle+(MAXANGLES/4))%MAXANGLES]);
  57. }
  58.  
  59. void NewStar(GLint n, GLint d)
  60. {
  61.  
  62.     if (rand()%4 == 0) {
  63.     stars[n].type = CIRCLE;
  64.     } else {
  65.     stars[n].type = STREAK;
  66.     }
  67.     stars[n].x[0] = (float)(rand() % MAXPOS - MAXPOS / 2);
  68.     stars[n].y[0] = (float)(rand() % MAXPOS - MAXPOS / 2);
  69.     stars[n].z[0] = (float)(rand() % MAXPOS + d);
  70.     if (rand()%4 == 0 && flag == WEIRD) {
  71.     stars[n].offsetX = (float)(rand() % 100 - 100 / 2);
  72.     stars[n].offsetY = (float)(rand() % 100 - 100 / 2);
  73.     stars[n].offsetR = (float)(rand() % 25 - 25 / 2);
  74.     } else {
  75.     stars[n].offsetX = 0.0;
  76.     stars[n].offsetY = 0.0;
  77.     stars[n].offsetR = 0.0;
  78.     }
  79. }
  80.  
  81. void RotatePoint(float *x, float *y, float rotation)
  82. {
  83.     float tmpX, tmpY;
  84.  
  85.     tmpX = *x * Cos(rotation) - *y * Sin(rotation);
  86.     tmpY = *y * Cos(rotation) + *x * Sin(rotation);
  87.     *x = tmpX;
  88.     *y = tmpY;
  89. }
  90.  
  91. void MoveStars(void)
  92. {
  93.     float offset;
  94.     GLint n;
  95.  
  96.     offset = speed * 60.0;
  97.  
  98.     for (n = 0; n < starCount; n++) {
  99.     stars[n].x[1] = stars[n].x[0];
  100.     stars[n].y[1] = stars[n].y[0];
  101.     stars[n].z[1] = stars[n].z[0];
  102.     stars[n].x[0] += stars[n].offsetX;
  103.     stars[n].y[0] += stars[n].offsetY;
  104.     stars[n].z[0] -= offset;
  105.         stars[n].rotation += stars[n].offsetR;
  106.         if (stars[n].rotation > MAXANGLES) {
  107.             stars[n].rotation = 0.0;
  108.     }
  109.     }
  110. }
  111.  
  112. GLenum StarPoint(GLint n)
  113. {
  114.     float x0, y0, x1, y1, width;
  115.     GLint i;
  116.  
  117.     x0 = stars[n].x[0] * windW / stars[n].z[0];
  118.     y0 = stars[n].y[0] * windH / stars[n].z[0];
  119.     RotatePoint(&x0, &y0, stars[n].rotation);
  120.     x0 += windW / 2.0;
  121.     y0 += windH / 2.0;
  122.  
  123.     if (x0 >= 0.0 && x0 < windW && y0 >= 0.0 && y0 < windH) {
  124.     if (stars[n].type == STREAK) {
  125.         x1 = stars[n].x[1] * windW / stars[n].z[1];
  126.         y1 = stars[n].y[1] * windH / stars[n].z[1];
  127.         RotatePoint(&x1, &y1, stars[n].rotation);
  128.         x1 += windW / 2.0;
  129.         y1 += windH / 2.0;
  130.  
  131.         glLineWidth(MAXPOS/100.0/stars[n].z[0]+1.0);
  132.         glColor3f(1.0, (MAXWARP-speed)/MAXWARP, (MAXWARP-speed)/MAXWARP);
  133.         if (fabs(x0-x1) < 1.0 && fabs(y0-y1) < 1.0) {
  134.         glBegin(GL_POINTS);
  135.             glVertex2f(x0, y0);
  136.         glEnd();
  137.         } else {
  138.         glBegin(GL_LINES);
  139.             glVertex2f(x0, y0);
  140.             glVertex2f(x1, y1);
  141.         glEnd();
  142.         }
  143.     } else {
  144.         width = MAXPOS / 10.0 / stars[n].z[0] + 1.0;
  145.         glColor3f(1.0, 0.0, 0.0);
  146.         glBegin(GL_POLYGON);
  147.         for (i = 0; i < 8; i++) {
  148.             float x = x0 + width * Cos((float)i*MAXANGLES/8.0);
  149.             float y = y0 + width * Sin((float)i*MAXANGLES/8.0);
  150.             glVertex2f(x, y);
  151.         };
  152.         glEnd();
  153.     }
  154.     return GL_TRUE;
  155.     } else {
  156.     return GL_FALSE;
  157.     }
  158. }
  159.  
  160. void ShowStars(void)
  161. {
  162.     GLint n;
  163.  
  164.     glClear(GL_COLOR_BUFFER_BIT);
  165.  
  166.     for (n = 0; n < starCount; n++) {
  167.     if (stars[n].z[0] > speed || (stars[n].z[0] > 0.0 && speed < MAXWARP)) {
  168.         if (StarPoint(n) == GL_FALSE) {
  169.         NewStar(n, MAXPOS);
  170.         }
  171.     } else {
  172.         NewStar(n, MAXPOS);
  173.     }
  174.     }
  175. }
  176.  
  177. static void Init(void)
  178. {
  179.     float angle;
  180.     GLint n;
  181.  
  182.     srand((unsigned int)time(NULL));
  183.  
  184.     for (n = 0; n < MAXSTARS; n++) {
  185.     NewStar(n, 100);
  186.     }
  187.  
  188.     angle = 0.0;
  189.     for (n = 0; n < MAXANGLES ; n++) {
  190.     sinTable[n] = sin(angle);
  191.         angle += PI / (MAXANGLES / 2.0);
  192.     }
  193.  
  194.     glClearColor(0.0, 0.0, 0.0, 0.0);
  195.  
  196.     glDisable(GL_DITHER);
  197. }
  198.  
  199. void Reshape(int width, int height)
  200. {
  201.  
  202.     windW = (GLint)width;
  203.     windH = (GLint)height;
  204.  
  205.     glViewport(0, 0, windW, windH);
  206.  
  207.     glMatrixMode(GL_PROJECTION);
  208.     glLoadIdentity();
  209.     gluOrtho2D(-0.5, windW+0.5, -0.5, windH+0.5);
  210.     glMatrixMode(GL_MODELVIEW);
  211. }
  212.  
  213. static GLenum Key(int key, GLenum mask)
  214. {
  215.  
  216.     switch (key) {
  217.       case TK_ESCAPE:
  218.     tkQuit();
  219.       case TK_SPACE:
  220.     flag = (flag == NORMAL) ? WEIRD : NORMAL;
  221.     break;
  222.       case TK_t:
  223.     nitro = 1;
  224.     break;
  225.       default:
  226.     return GL_FALSE;
  227.     }
  228.     return GL_TRUE;
  229. }
  230.  
  231. void Idle(void)
  232. {
  233.  
  234.     MoveStars();
  235.     ShowStars();
  236.     if (nitro > 0) {
  237.     speed = (float)(nitro / 10) + 1.0;
  238.     if (speed > MAXWARP) {
  239.         speed = MAXWARP;
  240.     }
  241.     if (++nitro > MAXWARP*10) {
  242.         nitro = -nitro;
  243.     }
  244.     } else if (nitro < 0) {
  245.     nitro++;
  246.     speed = (float)(-nitro / 10) + 1.0;
  247.     if (speed > MAXWARP) {
  248.         speed = MAXWARP;
  249.     }
  250.     }
  251.  
  252.     glFlush();
  253.     if (doubleBuffer) {
  254.     tkSwapBuffers();
  255.     }
  256. }
  257.  
  258. static GLenum Args(int argc, char **argv)
  259. {
  260.     GLint i;
  261.  
  262.     doubleBuffer = GL_FALSE;
  263.     directRender = GL_TRUE;
  264.  
  265.     for (i = 1; i < argc; i++) {
  266.     if (strcmp(argv[i], "-sb") == 0) {
  267.         doubleBuffer = GL_FALSE;
  268.     } else if (strcmp(argv[i], "-db") == 0) {
  269.         doubleBuffer = GL_TRUE;
  270.     } else if (strcmp(argv[i], "-dr") == 0) {
  271.         directRender = GL_TRUE;
  272.     } else if (strcmp(argv[i], "-ir") == 0) {
  273.         directRender = GL_FALSE;
  274.     }
  275.     }
  276.     return GL_TRUE;
  277. }
  278.  
  279. void main(int argc, char **argv)
  280. {
  281.     GLenum type;
  282.  
  283.     if (Args(argc, argv) == GL_FALSE) {
  284.     tkQuit();
  285.     }
  286.  
  287.     windW = 300;
  288.     windH = 300;
  289.     tkInitPosition(0, 0, 300, 300);
  290.  
  291.     type = TK_RGB;
  292.     type |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  293.     type |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  294.     tkInitDisplayMode(type);
  295.  
  296.     if (tkInitWindow("Stars") == GL_FALSE) {
  297.     tkQuit();
  298.     }
  299.  
  300.     Init();
  301.  
  302.     tkExposeFunc(Reshape);
  303.     tkReshapeFunc(Reshape);
  304.     tkKeyDownFunc(Key);
  305.     tkIdleFunc(Idle);
  306.     tkExec();
  307. }
  308.