/* konata8.c - Don Yang (uguu.org)

   07/20/08
                                                                           */

#include<assert.h>
#include<sys/time.h>
#include<GL/glut.h>
#include<math.h>
#include<stdio.h>
#include<stdlib.h>

typedef int s;
typedef double _;
typedef void r;
struct
{
   _ S,
          _,
          K, M, E,
          R, h, I,
          i, A, H;
} W[512], *X;
s Y, Z, k, l;

_ m,

       n[1024][3],
       o[1024][3],

       p, q,
       A, E, I, M,
       B, F, J, NM,
       C, G, K, O,
       D, H, L, P,

       d, e, f, g, h, i, j,
       KO, NA, TA, a, b, c, Q, R;

GLfloat S[4][4] =
{
   {1, 1, 1, 1},
   {0, 1, -1, 0},
   {0, -1, 1, 0},
   {1, .9, .9, .8}
};

_ T(_ y)
{
   return y * ((rand() & 32767) - 16384) / 16384.;
}

_ U(_ w, _ x, _ y, _ z)
{
   e = w + j * (x - w);
   f = x + j * (y - x);
   g = y + j * (z - y);
   h = e + j * (f - e);
   i = f + j * (g - f);
   return h + j * (i - h);
}

_ V(_ w, _ x, _ y, _ z)
{
   e = j * j;
   f = 1 - j;
   g = f * f;
   h = 2 * j * f;
   return 3 * (-g * w + (g - h) * x + (h - e) * y + e * z);
}

r yx(_ t, _ u, _ v,
                  _ w, _ x, _ y)
{
   a = u * y - x * v;
   b = w * v - t * y;
   c = t * x - w * u;
}

r zx()
{
   glutPostRedisplay();
}

r xy(s y, s x)
{
   zx();
}

r zy(unsigned char z, s y, s x)
{
   glFlush();
   exit(0);
}

r xz()
{
   struct timeval t;
   gettimeofday(&t, NULL);
   m = t.tv_sec + t.tv_usec / 1000000.;
}

r yz()
{
   xz();

   if( m >= q )
   {
      p = q;
      q = m + 0.5 + (rand() & 32767) / 8192.;
      A = D;
      E = H;
      I = L;
      M = P;
      B = D + D - C;
      F = H + H - G;
      J = L + L - K;
      NM = P + P - O;
      D = T(128);
      H = T(128);
      L = T(128);
      C = D + 0.4 * T(128);
      G = H + 0.4 * T(128);
      K = L + 0.4 * T(128);

      P = T(Q);
      O = P + 0.4 * T(Q);
   }

   for(j = (m - p) / (q - p);
       Z - Y &&
         m - W[Z].S >= 30;
       Z = (Z + 1) & 511);

   if( m - W[Y].S >= 0.06 )
   {
      Y = (Y + 1) & 511;
      W[Y].S = m;
   }

   X = &W[Y];
   X->K = U(A, B, C, D);
   X->M = U(E, F, G, H);
   X->E = U(I, J, K, L);

   X->R = V(
      A, B, C, D);
   X->h = V(
      E, F, G, H);
   X->I = V(
      I, J, K, L);
   if( (d = X->R * X->R +
             X->h * X->h +
             X->I * X->I) > R )
   {
      d = sqrt(d);
      X->R /= d;
      X->h /= d;
      X->I /= d;
   }

   yx(X->R, X->h, X->I, 0, 0, 1);
   X->i = 1;
   X->A = X->H = 0;
   if( (d = a * a + b * b + c * c) > R )
   {
      d = sqrt(d);
      X->i = a / d;
      X->A = b / d;
      X->H = c / d;
   }

   a = X->R;
   b = X->h;
   c = X->I;

   e = sin(X->_ =
            U(M, NM, O, P));
   f = cos(X->_);
   g = 1 - f;
   KO = a * b;
   NA = a * c;
   TA = b * c;
   h = X->i;
   i = X->A;
   d = X->H;
   X->i = (g * a * a + f) * h
             + (g * KO - c * e) * i
             + (g * NA + b * e) * d;
   X->A = (g * KO + c * e) * h
             + (g * b * b + f) * i
             + (g * TA - a * e) * d;
   X->H = (g * NA - b * e) * h
             + (g * TA + a * e) * i
             + (g * c * c + f) * d;

   n[k = Y * 2][0] =
      W[Y].K - 16 * W[Y].i;
   n[k][1] = W[Y].M - 16 * W[Y].A;
   n[k][2] = W[Y].E - 16 * W[Y].H;
   n[l = k + 1][0] = W[Y].K + 16 * W[Y].i;
   n[l][1] = W[Y].M + 16 * W[Y].A;
   n[l][2] = W[Y].E + 16 * W[Y].H;

   yx(W[Y].R, W[Y].h, W[Y].I,
                W[Y].i, W[Y].A, W[Y].H);
   o[l][0] = o[k][0] = a;
   o[l][1] = o[k][1] = b;
   o[l][2] = o[k][2] = c;

   glDrawBuffer(GL_BACK);
   glClear(GL_COLOR_BUFFER_BIT);

   k = glutGet(GLUT_WINDOW_WIDTH);
   l = glutGet(GLUT_WINDOW_HEIGHT);
   b = c = 1;
   d = (k > l)
      ? (b = k / (_)l)
      : (c = l / (_)k);
   glViewport(0, 0, k, l);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glFrustum(-b, b, -c, c, 10, 12800);
   gluLookAt(0, 0, 1280,  0, 0, 0,  0, 1, 0);

   glLightfv(GL_LIGHT0, GL_DIFFUSE, *S);
   glLightfv(GL_LIGHT0, GL_SPECULAR, *S);
   glLightfv(GL_LIGHT0, GL_POSITION, S[1]);
   glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, S[2]);
   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, S[3]);
   glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 4);

   glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);

   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();

   glEnableClientState(GL_VERTEX_ARRAY);
   glEnableClientState(GL_NORMAL_ARRAY);
   glVertexPointer(3, GL_DOUBLE, 0, n);
   glNormalPointer(GL_DOUBLE, 0, o);

   glBegin(GL_QUAD_STRIP);
      glColor4d(a = 0, 0, 0, 0);
      for(k = Z; k != Y; k = (k + 1) & 511)
      {
         glArrayElement(k * 2);
         glArrayElement(k * 2 + 1);
         if( a < 0.8 )
            glColor4d(1, 0.53, 0.67, a += 0.04);
      }
   glEnd();

   glutSwapBuffers();
   glFlush();
}

s main(s y, char **x)
{
   glutInit(&y, x);
   glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
   glutSetWindow(glutCreateWindow("Konata"));
   Q = atan2(0, -1);
   R = 0.000001;

   glutDisplayFunc(yz);
   glutIdleFunc(zx);
   glutReshapeFunc(xy);
   glutKeyboardFunc(zy);

   glEnable(GL_BLEND);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   glEnable(GL_NORMALIZE);
   glShadeModel(GL_SMOOTH);

   glBlendFunc(GL_SRC_ALPHA, GL_ONE);

   xz();
   srand((s)m);

   q = W[0].S = m - 1;
   C = T(128);
   G = T(128);
   K = T(128);
   O = T(Q);
   D =
   H =
   L =
   M =
   Y = Z = 0;
   glutMainLoop();
   return 0;
}