home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / newopg.zip / OVERLAY.C < prev    next >
Text File  |  1995-03-04  |  7KB  |  335 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, overlayInit = GL_FALSE;
  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.     if (tkSetWindowLevel(TK_OVERLAY) == GL_TRUE) {
  206.     glViewport(0, 0, windW, windH);
  207.     glMatrixMode(GL_PROJECTION);
  208.     glLoadIdentity();
  209.     gluOrtho2D(-0.5, windW+0.5, -0.5, windH+0.5);
  210.     glMatrixMode(GL_MODELVIEW);
  211.     overlayInit = GL_FALSE;
  212.     }
  213.  
  214.     if (tkSetWindowLevel(TK_RGB) == GL_TRUE) {
  215.     glViewport(0, 0, windW, windH);
  216.     glMatrixMode(GL_PROJECTION);
  217.     glLoadIdentity();
  218.     gluOrtho2D(-0.5, windW+0.5, -0.5, windH+0.5);
  219.     glMatrixMode(GL_MODELVIEW);
  220.     }
  221. }
  222.  
  223. static GLenum Key(int key, GLenum mask)
  224. {
  225.  
  226.     switch (key) {
  227.       case TK_ESCAPE:
  228.     tkQuit();
  229.       case TK_SPACE:
  230.     flag = (flag == NORMAL) ? WEIRD : NORMAL;
  231.     break;
  232.       case TK_t:
  233.     nitro = 1;
  234.     break;
  235.       default:
  236.     return GL_FALSE;
  237.     }
  238.     return GL_TRUE;
  239. }
  240.  
  241. void Idle(void)
  242. {
  243.  
  244.     if (overlayInit == GL_FALSE) {
  245.     if (tkSetWindowLevel(TK_OVERLAY) == GL_TRUE) {
  246.         glClear(GL_COLOR_BUFFER_BIT);
  247.         glColor3f(1.0, 0.0, 0.0);
  248.         glBegin(GL_POLYGON);
  249.         glVertex2i(windW/4, windH/4);
  250.         glVertex2i(windW/2, windH/4);
  251.         glVertex2i(windW/2, windH/2);
  252.         glVertex2i(windW/4, windH/2);
  253.         glEnd();
  254.         if (tkSetWindowLevel(TK_RGB) == GL_FALSE) {
  255.         printf("Can't switch to main window!\n");
  256.         }
  257.     }
  258.     overlayInit = GL_TRUE;
  259.     }
  260.  
  261.     MoveStars();
  262.     ShowStars();
  263.     if (nitro > 0) {
  264.     speed = (float)(nitro / 10) + 1.0;
  265.     if (speed > MAXWARP) {
  266.         speed = MAXWARP;
  267.     }
  268.     if (++nitro > MAXWARP*10) {
  269.         nitro = -nitro;
  270.     }
  271.     } else if (nitro < 0) {
  272.     nitro++;
  273.     speed = (float)(-nitro / 10) + 1.0;
  274.     if (speed > MAXWARP) {
  275.         speed = MAXWARP;
  276.     }
  277.     }
  278.  
  279.     glFlush();
  280.     if (doubleBuffer) {
  281.     tkSwapBuffers();
  282.     }
  283. }
  284.  
  285. static GLenum Args(int argc, char **argv)
  286. {
  287.     GLint i;
  288.  
  289.     doubleBuffer = GL_FALSE;
  290.     directRender = GL_TRUE;
  291.  
  292.     for (i = 1; i < argc; i++) {
  293.     if (strcmp(argv[i], "-sb") == 0) {
  294.         doubleBuffer = GL_FALSE;
  295.     } else if (strcmp(argv[i], "-db") == 0) {
  296.         doubleBuffer = GL_TRUE;
  297.     } else if (strcmp(argv[i], "-dr") == 0) {
  298.         directRender = GL_TRUE;
  299.     } else if (strcmp(argv[i], "-ir") == 0) {
  300.         directRender = GL_FALSE;
  301.     }
  302.     }
  303.     return GL_TRUE;
  304. }
  305.  
  306. void main(int argc, char **argv)
  307. {
  308.     GLenum type;
  309.  
  310.     if (Args(argc, argv) == GL_FALSE) {
  311.     tkQuit();
  312.     }
  313.  
  314.     windW = 300;
  315.     windH = 300;
  316.     tkInitPosition(0, 0, 300, 300);
  317.  
  318.     type = TK_OVERLAY | TK_RGB;
  319.     type |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  320.     type |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  321.     tkInitDisplayMode(type);
  322.  
  323.     if (tkInitWindow("Overlay Test") == GL_FALSE) {
  324.     tkQuit();
  325.     }
  326.  
  327.     Init();
  328.  
  329.     tkExposeFunc(Reshape);
  330.     tkReshapeFunc(Reshape);
  331.     tkKeyDownFunc(Key);
  332.     tkIdleFunc(Idle);
  333.     tkExec();
  334. }
  335.