#include "buttons.h"
#include "windows.h"
#include "cone.h"


/****************************************/
/* Draws the missile on the screen.    	*/
/****************************************/
void TARGET_DRAW(void) {
int r;
GLfloat x, x1, x2, x3;
GLfloat y, y1, y2, y3;
GLfloat z, z1, z2, z3;
GLfloat mag;
double  den, angle1, angle2;


   glDrawBuffer(GL_BACK);
   glPolygonMode(GL_FRONT, GL_FILL);


   // Adjust location and view angle.
   glLoadIdentity();
   glTranslated(250, 200, 0);
   glRotated(yAngle, 0, 1, 0);  // CW from above (YAW)
   glRotated(pAngle, 0, 0, 1);  // CW from viewer (PITCH)
   glRotated(rAngle, 1, 0, 0);  // CW from side (ROLL)


   // Build a cone.
   den = 4.5 * (faces / 10);
   angle1 = 0.0;
   for (r = 1; r < faces; r++) {
       angle2 = (pi * r) / den;
       x1 = 0.0;			// vertix 1 (CCW)
       y1 = 0.0;
       z1 = -scale;
       x2 = 0.5 * scale * cos(angle1);	// vertix 2
       y2 = 0.5 * scale * sin(angle1);
       z2 = 0.0;  			
       x3 = 0.5 * scale * cos(angle2);	// vertix 3
       y3 = 0.5 * scale * sin(angle2);
       z3 = 0.0;


       // Determine normal (UNIT!) vector.
       x  = (y1-y2)*(z1+z2)+(y2-y3)*(z2+z3)+(y3-y1)*(z3+z1);
       y  = (z1-z2)*(x1+x2)+(z2-z3)*(x2+x3)+(z3-z1)*(x3+x1);
       z  = (x1-x2)*(y1+y2)+(x2-x3)*(y2+y3)+(x3-x1)*(y3+y1);
       mag= sqrt((x*x) + (y*y) + (z*z));
       if (mag == 0.0) {
          break;
       } else {
          x /= mag;		
          y /= mag;
          z /= mag;
          glNormal3f(x, y, z);		// assign normalized vectors
       }


       // Draw
       glBegin(GL_TRIANGLES);
         glVertex3f(x1, y1, z1);
         glVertex3f(x2, y2, z2); 
         glVertex3f(x3, y3, z3);
       glEnd();


       angle1 = angle2;
   }


   glLoadIdentity();
   glutSwapBuffers();
}




/****************************************/
/* Displays target in TARGET window.    */
/****************************************/
void TARGET_DISPLAY(void) {
GLfloat MatAmbient[]     = {0.8, 0.0, 0.0, 1.0}; 


GLfloat MatDiffuse[]     = {0.0, 0.8, 0.0, 1.0}; 
GLfloat Light1Diffuse[]  = {1.0, 1.0, 1.0, 1.0}; 
GLfloat Light1Position[] = {1.0, 1.0, 3.0, 0.0};


GLfloat MatShininess[]   = {4.0};
GLfloat MatSpecular[]    = {0.0, 0.0, 1.0, 1.0}; 
GLfloat Light2Specular[] = {1.0, 1.0, 1.0, 1.0}; 
GLfloat Light2Position[] = {lightX, lightY, 1000.0, 1.0};


   glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);
   glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_TRUE);
   glLoadIdentity();
   glTranslated(250, 300, 0);


   // Ambient "light source".
   glMaterialfv(GL_FRONT, GL_AMBIENT, MatAmbient);


   // Diffuse light source.
   glMaterialfv(GL_FRONT, GL_DIFFUSE, MatDiffuse);
   glLightfv(GL_LIGHT1, GL_DIFFUSE,  Light1Diffuse);
   glLightfv(GL_LIGHT1, GL_POSITION, Light1Position);


   // Spectral light source.
   glMaterialfv(GL_FRONT, GL_SPECULAR, MatSpecular);
   glMaterialfv(GL_FRONT, GL_SHININESS, MatShininess);
   glLightfv(GL_LIGHT2, GL_SPECULAR, Light2Specular);
   glLightfv(GL_LIGHT2, GL_POSITION, Light2Position);


   glEnable(GL_LIGHTING);
   if (light1 == 1) glEnable(GL_LIGHT1);
               else glDisable(GL_LIGHT1);
   if (light2 == 1) glEnable(GL_LIGHT2);
               else glDisable(GL_LIGHT2);
   if (shade == 0)  glShadeModel(GL_FLAT);
               else glShadeModel(GL_SMOOTH);                       
   TARGET_DRAW();
   glDisable(GL_LIGHTING);
}


/****************************************/
/* Animates target in TARGET window.    */
/****************************************/
void TARGET_ANIMATE(void) {
   pAngle += angleStep;
   system("sleep 0.1");
   TARGET_WINDOW.CLEAR(); 
   TARGET_DISPLAY();
}


/****************************************/
/* Main window display.                 */
/****************************************/
void MAIN_WINDOW(void) {
   glDrawBuffer(GL_BACK);


   glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
   glColor3f(0.6, 0.6, 0.6);
   glBegin(GL_QUADS);
     glVertex2i(       0,         0);
     glVertex2i(winWidth,         0);
     glVertex2i(winWidth, winHeight);
     glVertex2i(       0, winHeight);
   glEnd();


   ROLL_BUTTON.DRAW();
   LIT1_BUTTON.DRAW();
   LIT2_BUTTON.DRAW();
   L_U_BUTTON.DRAW();
   L_D_BUTTON.DRAW();
   L_C_BUTTON.DRAW();
   L_L_BUTTON.DRAW();
   L_R_BUTTON.DRAW();
   SHAD_BUTTON.DRAW();
   FACE_BUTTON.DRAW();
   EXIT_BUTTON.DRAW_HILITE(0.7, 0.0, 0.0);
   TARGET_WINDOW.DRAW();
   TARGET_WINDOW.CLEAR();


   glutSwapBuffers();


   TARGET_DISPLAY();
}


/************************************************************/
/* CALLBACK FUNTIONS.                                       */
/************************************************************/
/****************************************/
/* Mouse control.                       */
/****************************************/
void myMouse(int button, int state, int x, int y) {
   y = (winHeight - y);
   if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
      glFinish();
      if (ROLL_BUTTON.SELECTED(x, y)) { 
         ROLL_BUTTON.CLICK();
         if (idle == 0) {
            glutIdleFunc(TARGET_ANIMATE);
            idle = 1;
         } else {
            glutIdleFunc(NULL);
            idle = 0;
         }
      }


      if (LIT1_BUTTON.SELECTED(x, y)) { 
         LIT1_BUTTON.CLICK();
         if (light1 == 0) {
            light1 = 1;
         } else {
            light1 = 0;
         }         
         TARGET_DISPLAY();
      }
      if (LIT2_BUTTON.SELECTED(x, y)) { 
         LIT2_BUTTON.CLICK();
         if (light2 == 0) {
            light2 = 1;
         } else {
            light2 = 0;
         }         
         TARGET_DISPLAY();
      }
      if (L_L_BUTTON.SELECTED(x, y)) { 
         L_L_BUTTON.CLICK();
         lightX = 1000.0;
         lightY = 0.0;
         TARGET_DISPLAY();
      }
      if (L_R_BUTTON.SELECTED(x, y)) { 
         L_R_BUTTON.CLICK();
         lightX = -1000.0;
         lightY = 0.0;
         TARGET_DISPLAY();
      }
      if (L_U_BUTTON.SELECTED(x, y)) { 
         L_U_BUTTON.CLICK();
         lightX = 0.0;
         lightY = -1000.0;
         TARGET_DISPLAY();
      }
      if (L_D_BUTTON.SELECTED(x, y)) { 
         L_D_BUTTON.CLICK();
         lightX = 0.0;
         lightY = 1000.0;
         TARGET_DISPLAY();
      }
      if (L_C_BUTTON.SELECTED(x, y)) { 
         L_C_BUTTON.CLICK();
         lightX = 0.0;
         lightY = 0.0;
         TARGET_DISPLAY();
      }
      if (SHAD_BUTTON.SELECTED(x, y)) { 
         SHAD_BUTTON.CLICK();
         if (shade == 0) {
            shade = 1;
         } else {
            shade = 0;
         }         
         TARGET_DISPLAY();
      }
      if (FACE_BUTTON.SELECTED(x, y)) { 
         FACE_BUTTON.CLICK();
         faces *= 2;
         if (faces > 180) faces = 11; 
         TARGET_DISPLAY();
      }


      if (EXIT_BUTTON.SELECTED(x, y)) { 
         EXIT_BUTTON.CLICK();
         glutDestroyWindow(window);
         exit(0);                   
      }
   }
}


/****************************************/
/* Resizes screen (if required)         */
/****************************************/
void myResize(int width, int height) {
   glutReshapeWindow(winWidth, winHeight);                    
}


/****************************************/
/* Redisplays screen (if required)      */
/****************************************/
void myDisplay(void) {


   drawFlag = glutLayerGet(GLUT_NORMAL_DAMAGED);
   if (drawFlag == 1) {
      MAIN_WINDOW();
      drawFlag = 0;
   } else {
      glutSwapBuffers();
   } 
}


/****************************************/
/* Initializes OPENGL parameters    	*/
/****************************************/
void myInit(void) {
   glPointSize(1);
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   glClear(GL_COLOR_BUFFER_BIT); 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity(); 
   glOrtho(0.0, (GLdouble)winWidth, 
           0.0, (GLdouble)winHeight, -1000.0, 1000.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();  
}


/************************************************************/
/* MAIN.                                                    */
/************************************************************/
int main(int argc, char **argv) {
   glutInit(&argc, argv) ;
   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);  
   glutInitWindowSize(winWidth, winHeight);
   glutInitWindowPosition(winX, winY);
   window = glutCreateWindow("SHADING by R. Marsh.");


   glutDisplayFunc(myDisplay);
   glutReshapeFunc(myResize);
   glutMouseFunc(myMouse);
   
   myInit();


   glutMainLoop();


   return 1;
}