/* 
   Laura Toma 
   Rajiv Wickremesinghe
   Ravin de Souza
   1998
 */


#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <limits.h>

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

/* ********************************************************************** */

#define PI (4*atan(1))
#define DEG2RAD(d) ((d)/180*PI)

/* global */
#define SCALE 90
GLfloat param_sph_r = SCALE*0.3;
GLfloat param_cyl_r = SCALE*0.2;
GLfloat param_r = SCALE*0.8;
GLfloat param_n = 6;
GLfloat param_t = 0;
int flag_fill = 1;
int flag_axes = 0;
int flag_animFwd = 1;

int flag_lighting = 1;
int flag_translate = 0;
int flag_spin = 0;
GLfloat param_spin = 0;
GLfloat param_speed = 4;	/* speed modifier */

GLuint theRing;

     
void drawPin();
void drawRing();

void
refreshDisplayList() {
  theRing = glGenLists(1);
  glNewList(theRing, GL_COMPILE);
  drawRing();
  glEndList();
}


void
drawSphere() {
  GLUquadricObj *q1;
  int f;
  
  f = (flag_fill?2:1);
  q1 = gluNewQuadric();
  assert(q1);
  gluQuadricDrawStyle(q1, (GLenum)(flag_fill?GLU_FILL:GLU_LINE));
  gluQuadricNormals(q1, (GLenum)GLU_SMOOTH);
  gluSphere(q1, param_sph_r, f*12, f*8);
}

void
drawCylinder(GLfloat height) {
  GLUquadricObj *q1;
  int f;
  
  f = (flag_fill?2:1);
  q1 = gluNewQuadric();
  assert(q1);
  gluQuadricDrawStyle(q1, (GLenum)(flag_fill?GLU_FILL:GLU_LINE));
  gluQuadricNormals(q1, (GLenum)GLU_SMOOTH);
  gluCylinder(q1, param_cyl_r, param_cyl_r/2, height,
			  f*6, f*8);
}


void
drawAxes() {
  if(!flag_axes) return;

  glBegin(GL_LINES);
  {
    glColor3f(1.0, 0.5, 0.5);  
    glVertex3f(-1, 0, 0);
    glColor3f(1, 1, 1);
    glVertex3f(1, 0, 0);
    
    glColor3f(0.5, 1.0, 0.5);  
    glVertex3f(0, -1, 0);
    glColor3f(1, 1, 1);
    glVertex3f(0, 1, 0);
  }
  glEnd();
}

void
drawPin() {
  GLfloat d, height;

  d = sqrt(param_sph_r * param_sph_r - param_cyl_r * param_cyl_r);
  height = (param_r * sin(DEG2RAD(180/param_n)) - d);

  glPushMatrix();
  drawSphere();

  glPushMatrix();
  glRotatef(-90, 1, 0, 0);
  glTranslatef(0, 0, d);
  drawCylinder(height);
  glPopMatrix();

  glRotatef(90, 1, 0, 0);
  glRotatef(-360/param_n, 0, 1, 0);
  glTranslatef(0, 0, d);
  drawCylinder(height);

  glPopMatrix();
}


void
drawRing() {
  int i;
  drawAxes();
  for(i=0; i<param_n; i++) {
    glPushMatrix();
    glTranslatef(param_r, 0, 0);
    glRotatef(180/param_n, 0, 0, 1);
    drawAxes();
    drawPin();
    glPopMatrix();
    glRotatef(360/param_n, 0, 0 ,1);
  }
}

/*
 * translate from p to q, in the proportion t along a line
 * this is a simple translate
 */
void
ppTranslate(GLfloat *p, GLfloat *q, GLfloat t) {
  glTranslatef((q[0]-p[0])*t, (q[1]-p[1])*t, (q[2]-p[2])*t);
}

/*
 * translate from p to q, in the proportion t along an arc
 * (so that it looks like a rotation)
 *
 * we will rotate around a vector through the midpoint
 * of pq, and perp to pq.
 */
void
ppRotate(GLfloat *p, GLfloat *q, GLfloat t) {
  GLfloat mid[3];		/* midpoint of pq*/
  GLfloat n[3];			/* a normal */
  int i;

  /* compute the midpoint */
  for(i=0; i<3; i++) {
    mid[i] = (q[i] - p[i])/2;
  }

  /* find a normal to mid */
  // we know we are on a cube, so..
  n[0] = (q[0] - p[0]) - 0;
  n[1] = (q[1] - p[1]) - (q[1] - p[1]);
  n[2] = 0 - (q[2] - p[2]);

  /* do the 'translation by rotation' by bringing to mid,
   * rotating, and then pushing back */
  glTranslatef(mid[0], mid[1], mid[2]);
  glRotatef(180*t, n[0], n[1], n[2]);
  glTranslatef(-mid[0], -mid[1], -mid[2]);

  /* make sure the object is oriented correctly-
   * undo the rotation we did before */
  glRotatef(-180*t, n[0], n[1], n[2]);
}

void 
display(void) {
  GLfloat p[] = {0, 0, 0}; // src
  GLfloat q[] = {100, 100, -100}; // dest

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  if(flag_lighting) {
    glEnable(GL_LIGHTING);
  } else {
    glDisable(GL_LIGHTING);
  }
  glPushMatrix();

  if(flag_animFwd) {
    ppTranslate(p, q, param_t);
  } else {
    ppRotate(p, q, param_t);
  }
  glRotatef(param_spin, 1, 0, -1);
  //glScalef(5, 5, 5);
  glCallList(theRing);
  glPopMatrix();

  glutSwapBuffers();
}



/* ********************************************************************** */
/* menus/callbacks */


void
node_menu(int value) {
  param_n = value;

  refreshDisplayList();
  glutPostRedisplay();
}


void
animate() {
  if(flag_translate) {
    param_t += 0.005 * param_speed * (flag_animFwd?1:-1);
    
    if((param_t >= 1) || (param_t <= 0)) {
      if(param_t > 1)    param_t = 1;
      if(param_t < 0)    param_t = 0;
      flag_translate = 0;
      flag_animFwd = !flag_animFwd;
    }
  }

  if(flag_spin) {
    param_spin = fmod(param_spin + 2*param_speed, 360);
  }

  glutPostRedisplay();

  // probably better to turn off callback when we are not moving...
  if(!flag_translate && !flag_spin)
	glutIdleFunc(NULL);
}



void
main_menu(int value) {
  switch (value){
  case 1:
    flag_fill = !flag_fill;
    flag_lighting = flag_fill;	/* if fill, lighting on, off o/w */
    refreshDisplayList();
    glutPostRedisplay();
    break;
  case 2:
    flag_spin = !flag_spin;
	glutIdleFunc(animate);
    break;
  case 3:
    flag_lighting = !flag_lighting;
    glutPostRedisplay();
    break;
  case 9:
    exit(0);
    break;
  default:
    assert(0);
  }
}

void
keypress(unsigned char key, int x, int y) {
  switch(key) {
  case 't':
    printf("t=%f\n", param_t);
    break;
  case 13:			/* enter */
    printf("animation: %s\n", (flag_animFwd?"FWD":"BACK"));
    flag_translate = 1;
	glutIdleFunc(animate);
    break;
  case 'f':
    flag_fill = !flag_fill;
    refreshDisplayList();
    glutPostRedisplay();    
    break;
  case '+':
  case '=':
    param_speed++;
    break;
  case '-':
    param_speed--;
    if(param_speed < 1) param_speed = 1;
    break;
  case 'q':
    exit(0);
    break;
  default:
    break;
  } 
}

/* ********************************************************************** */

void 
init() {
  GLfloat light_position[] = {1.0, 1.0, 10.0, 0.0};
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  GLfloat light_ambient[] = {0.5, 0, 1, 0.0};
  glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_LIGHT0);
  glEnable(GL_LIGHTING);
  glClearColor(0, 0, 0, 0);   /* Background color = Black*/
  glShadeModel(GL_SMOOTH);    /* Smooth shading */


  //GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};
  //GLfloat light_ambient[] = {0.6, 0.6, 1.0, 0.0};
  //GLfloat light_ambient[] = {0.6, 0, 1, 0.0};
  //GLfloat spot_direction[] = {-1, -1, -1};
  //GLfloat mat_ambient[] = {0.8, 0.8, 0.8, 1.0};
  //GLfloat mat_diffuse[] = {1.0, 0.5, 0.8, 1.0};
  //GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
  //GLfloat mat_shininess[] = {100};

  //glClearColor(0, 0, 0, 0);   /* Background color = Black*/

  //glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  //glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  /* glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0); */
/*   glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 2.0); */
/*   glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.5); */
/*   glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction); */
/*   glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); */
/*   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); */
/*   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);  */
/*   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);  */
/*   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);  */
/*   glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);  */
  //glEnable(GL_DEPTH_TEST);
  //\glEnable(GL_LIGHT0);

  refreshDisplayList();

  //glShadeModel(GL_SMOOTH);
  //glShadeModel(GL_FLAT);
}

void
reshape(int w, int h) {
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(80.0, (GLfloat)w/h,/* angle, aspect */
				 1, 350);		   /* near, far */
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt(0, 0, 150,		/* eye */
			0, 0, 0,		/* center */
			0, 1, 0);		/* up */
}


int main(int argc, char **argv)
{
  int node_menu_id;

  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize(600, 500);
  glutInitWindowPosition(100,100);
  glutCreateWindow(argv[0]);
  
  init();
  glutDisplayFunc(display);
  // glutMotionFunc(motion);

  glutCreateMenu(node_menu);
  node_menu_id = glutGetMenu();
  glutAddMenuEntry("2 nodes", 2);
  glutAddMenuEntry("3 nodes", 3);
  glutAddMenuEntry("4 nodes", 4);
  glutAddMenuEntry("5 nodes", 5);
  glutAddMenuEntry("6 nodes", 6);

  glutCreateMenu(main_menu);
  glutAddSubMenu("Nodes", node_menu_id);
  glutAddMenuEntry("Fill/Wireframe", 1);
  glutAddMenuEntry("Spin", 2);
  glutAddMenuEntry("Lighting", 3);
  glutAddMenuEntry("Quit", 9);
  glutAttachMenu(GLUT_LEFT_BUTTON);

  glutKeyboardFunc(keypress);
  glutReshapeFunc(reshape);
  glutMainLoop();
  return 0;
}