/* gate5.c (ruriko.c) - Don Yang (uguu.org)

   Optimize pass 6

   01/21/01
                                                                           */

#ifdef _WIN32
   #include<windows.h>
#endif
#include<GL/glut.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>

#define G(_)      GL_##_
#define List(_)   gl##_##List
#define Func(_)   gl##_##Func
#define Mode(_)   glMatrixMode(G(_)); glLoadIdentity();
#define P0(_)     void _(void)
#define P1(_)     void _(int *Q, float N, float O, int P)

int i, j,
    H, I, J,
    L,
    A, B, C, D, E, F,
    k, l, K;
float PI,
      s, q,
      p,
      u, v, w,
      x, y, z,
      M,
      e, f, g, h, m, n, o,
      r, a, b, d,
      c = CLOCKS_PER_SEC;
clock_t t, nt;

P0(A0)
{
   if( t == nt )
   {
      t = clock();
      nt = t + c;
   }
   s =
      (L == 0)
         ?  (clock() - t) / c
         :  (L == 3)
            ?  (nt - clock()) / c
            :  1;
   if( s > 1 )    s = 1;
   if( s < 0 )    s = 0;

   if( clock() >= nt )
   {
      nt = (t = clock()) + c;
      if( L == 1 )
      {
         if( M <= 0 )
            M = 999.0 / H;
         p = 1;
      }
      else if( L == 3 )
      {
         if( I == 3000 )
            I = H;
         H = 0;
         p = 0;

         e = (rand() % K) * PI / l;
         f = (rand() % K) * PI / l;
         g = (rand() % l) * PI / K - PI / 8;
         h = (rand() % l) * PI / K - PI / 8;
         m = (rand() % k) + 64;
      }
      L = (L + 1) % 4;
   }

   if( p > 0 )
      p += M;
   H++;
   q = (float)(J++ % 360);
   n = ((f - e) * H) / I + e;
   o = ((h - g) * H) / I + g;
   v = m * sin(o);
   u = m * cos(o) * sin(n);
   w = m * cos(o) * cos(n) + p / 2;
   x = u / -9;
   y = v / -9;
   z = w / -9 + p / 3;

   glutPostRedisplay();
}

P1(CP)
{
   b = 0;
   List(New)(*Q = glGenLists(1), G(COMPILE));
      for(i = 0; i < 11; i++)
      {
         d = (PI * 2 * (i + 1)) / 11;
         glColor4d(1, 1, 1, 0.7);
         glVertex3d(0, 0, P);
         glBegin(G(TRIANGLE_STRIP));
            for(j = 0; j < 8; j++)
            {
               r = j / 7.0;
               r *= r;
               glColor4d(1 - r, 1 - 0.7 * r, 1 - 0.5 * r, 0.3);
               glVertex3d(N * j * cos(b), N * j * sin(b), P - O * j * j);
               glVertex3d(N * j * cos(d), N * j * sin(d), P - O * j * j);
            }
         glEnd();
         b = d;
      }
   List(End)();
}

P1(CR)
{
   #define R()      glColor4d(1.00, 1.00, 1.00, 1.00)
   #define S()       glColor4d(0.50, 1.00, 1.00, 0.90)
   #define T()       glColor4d(0.12, 0.63, 0.81, 0.60)
   #define V(x, y) \
      r = (O - N) * (y) + N; \
      a = (d - b) * (x) + b; \
      glVertex3d(r * cos(a), r * sin(a), 0);
   #define U(c1, u1, v1, c2, u2, v2, c3, u3, v3) \
      c1(); V(u1, v1); \
      c2(); V(u2, v2); \
      c3(); V(u3, v3);
   #define W(c1, u1, v1, c2, u2, v2, c3, u3, v3) \
      U(c1, u1, v1, c2, u2, v2, c3, u3, v3); \
      U(c1, u1, (1-v1), c2, u2, (1-v2), c3, u3, (1-v3));
   #define X(c1, u1, v1, c2, u2, v2, c3, u3, v3, c4, u4, v4) \
      U(c1, u1, v1, c2, u2, v2, c3, u3, v3); \
      c4(); V(u4, v4);
   #define Y(c1, u1, v1, c2, u2, v2, c3, u3, v3, c4, u4, v4) \
      X(c1, u1, v1, c2, u2, v2, c3, u3, v3, c4, u4, v4); \
      X(c1, u1, (1-v1), c2, u2, (1-v2), c3, u3, (1-v3), c4, u4, (1-v4));

   b = i = 0;
   List(New)(*Q = glGenLists(1), G(COMPILE));
      for(; i < P; i++)
      {
         d = (float)((PI * 2 * (i + 1)) / P);

         glBegin(G(QUADS));
            X
            (
               S,  0.00, 0.62,
               S,  0.01, 0.62,
               S,  0.01, 0.38,
               S,  0.00, 0.38
            );
            Y
            (
               S,  0.00, 0.38,
               S,  0.01, 0.38,
               T,  0.01, 0.00,
               T,  0.00, 0.16
            );
            X
            (
               S,  0.01, 0.38,
               S,  0.01, 0.62,
               R, 0.02, 0.62,
               R, 0.02, 0.38
            );
            Y
            (
               S,  0.01, 0.38,
               R, 0.02, 0.38,
               R, 0.05, 0.00,
               T,  0.01, 0.00
            );
            X
            (
               R, 0.02, 0.38,
               R, 0.02, 0.62,
               R, 0.05, 1.00,
               R, 0.05, 0.00
            );
            X
            (
               R, 0.05, 0.00,
               R, 0.05, 1.00,
               R, 0.08, 1.00,
               R, 0.08, 0.00
            );
            X
            (
               R, 0.08, 0.00,
               R, 0.08, 1.00,
               R, 0.14, 1.00,
               R, 0.14, 0.00
            );
            X
            (
               R, 0.14, 0.00,
               R, 0.14, 1.00,
               R, 0.22, 0.62,
               R, 0.22, 0.38
            );
            Y
            (
               S,  0.22, 0.00,
               R, 0.22, 0.38,
               R, 0.30, 0.50,
               S,  0.30, 0.38
            );
            Y
            (
               S,  0.30, 0.38,
               R, 0.30, 0.50,
               S,  0.36, 0.50,
               S,  0.36, 0.38
            );
            Y
            (
               T,  0.30, 0.00,
               S,  0.30, 0.38,
               S,  0.36, 0.38,
               T,  0.36, 0.16
            );
            X
            (
               S,  0.36, 0.38,
               S,  0.36, 0.62,
               S,  0.40, 0.62,
               S,  0.40, 0.38
            );
            Y
            (
               S,  0.36, 0.38,
               S,  0.40, 0.38,
               T,  0.40, 0.16,
               T,  0.36, 0.16
            );
            Y
            (
               T,  0.36, 0.16,
               T,  0.40, 0.16,
               T,  0.40, 0.00,
               T,  0.36, 0.00
            );
            for(j = 8; j < 20; j++)
            {
               Y
               (
                  T,  (j / 20.0), 0.00,
                  T,  (j / 20.0), 0.16,
                  T,  ((j + 1) / 20.0), 0.16,
                  T,  ((j + 1) / 20.0), 0.00
               );
               Y
               (
                  S,  (j / 20.0), 0.38,
                  S,  ((j + 1) / 20.0), 0.38,
                  T,  ((j + 1) / 20.0), 0.16,
                  T,  (j / 20.0), 0.16
               );
               X
               (
                  S,  (j / 20.0), 0.38,
                  S,  (j / 20.0), 0.62,
                  S,  ((j + 1) / 20.0), 0.62,
                  S,  ((j + 1) / 20.0), 0.38
               );
            }
         glEnd();
         glBegin(G(TRIANGLES));
            W
            (
               T,  0.00, 0.00,
               T,  0.00, 0.16,
               T,  0.01, 0.00
            );
            W
            (
               R, 0.14, 0.00,
               R, 0.22, 0.38,
               S,  0.22, 0.00
            );
            U
            (
               R, 0.22, 0.38,
               R, 0.22, 0.62,
               R, 0.30, 0.50
            );
            W
            (
               S,  0.22, 0.00,
               S,  0.30, 0.38,
               T,  0.30, 0.00
            );
            W
            (
               T,  0.30, 0.00,
               T,  0.36, 0.16,
               T,  0.36, 0.00
            );
         glEnd();

         b = d;
      }
   List(End)();
}

P0(R0)
{
   glDrawBuffer(G(BACK));
   glClear(G(COLOR_BUFFER_BIT));

   b = (float)glutGet(GLUT_WINDOW_WIDTH);
   d = (float)glutGet(GLUT_WINDOW_HEIGHT);
   if( i > j )
   {
      b /= d;
      d = 1;
   }
   else
   {
      d /= b;
      b = 1;
   }
   Mode(PROJECTION);
   glFrustum(-b * 9, b * 9, -d * 9, d * 9, 5, 9999);

   Mode(MODELVIEW);

   glScalef(4, 4, 4);
   gluLookAt(u, v, w,
             x, y, z,  0, 1, 0);

   glPushMatrix();
      glScalef(s, s, s);
      glPushMatrix();
         glRotatef(q, 0, 0, 1);
         glScalef(-1, 1, 1);
         List(Call)(A);
         List(Call)(C);
      glPopMatrix();
      glRotatef(q, 0, 0, -1);
      List(Call)(B);
   glPopMatrix();

   if( p > 0 )
   {
      glTranslatef(0, 0, p);
      List(Call)(D);
      List(Call)((H & 1) ? E : F);
   }

   glutSwapBuffers();
   glFlush();
}

void K0(unsigned char c, int u, int v)
{
   glFinish();
   exit(EXIT_SUCCESS);
}

int main(int P, char **Q)
{
   glutInit(&P, Q);

   srand(time(NULL));
   PI = atan2(0, -1);
   K = 2 * (l = 2 * (k = 256));

   glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
   glutInitWindowSize(640, 480);

   glutSetWindow(glutCreateWindow("Ruriko"));
   Func(utDisplay)(R0);
   Func(utKeyboard)(K0);
   Func(utIdle)(A0);

   glEnable(G(BLEND));
   Func(Blend)(G(SRC_ALPHA), G(ONE));

   t = nt =
   L = H = J = 0;
   I = 3000;
   s = q = p = M = 0;
   e = f = g = h =
   u = v = x = y = z = 0;
   m =
   w = k;

   CR(&A, 60, 75, 2);
   CR(&B, 100, 110, 3);
   CR(&C, 155, 165, 8);

   CP(&E, 20, 8, 28);
   CP(&F, 18, 4, 30);

   List(New)(D = glGenLists(1), G(COMPILE));
      glColor4d(0.5, 0.8, 0.9, 0.3);
      glutSolidSphere(26, 14, 7);
   List(End)();

   glutMainLoop();
   return 0;
}