/*
 * 3-D gear wheels.  This program is in the public domain.
 *
 * Brian Paul
 */

/*
   Conversion to Helium by Edouard.Thiel@lif.univ-mrs.fr 

   20/03/2003 : Meilleur gestion de la fluidité dans rotations ;
                affichage fps.
*/


#include <heliumGL.h>


#define INC_ANGLE 1.0
#define NB_ROT 5


enum { ROT_NONE, ROT_XP, ROT_XM, ROT_YP, ROT_YM, ROT_ZP, ROT_ZM };
int next_rot = ROT_NONE;

GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
GLint gear1, gear2, gear3;
GLfloat angle = 0.0;
int nb_rot = 0;

int nb_frames = 0;

He_node *princ, *panel, *mess_fps, *glarea;



/**

  Draw a gear wheel.  You'll probably want to call this function when
  building a display list since we do a lot of trig here.
 
  Input:  inner_radius - radius of hole at center
          outer_radius - radius at center of teeth
          width - width of gear
          teeth - number of teeth
          tooth_depth - depth of tooth

 **/

static void
gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
  GLint teeth, GLfloat tooth_depth)
{
  GLint i;
  GLfloat r0, r1, r2;
  GLfloat angle, da;
  GLfloat u, v, len;

  r0 = inner_radius;
  r1 = outer_radius - tooth_depth / 2.0;
  r2 = outer_radius + tooth_depth / 2.0;

  da = 2.0 * M_PI / teeth / 4.0;

  glShadeModel(GL_FLAT);

  glNormal3f(0.0, 0.0, 1.0);

  /* draw front face */
  glBegin(GL_QUAD_STRIP);
  for (i = 0; i <= teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;
    glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
  }
  glEnd();

  /* draw front sides of teeth */
  glBegin(GL_QUADS);
  da = 2.0 * M_PI / teeth / 4.0;
  for (i = 0; i < teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;

    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
  }
  glEnd();

  glNormal3f(0.0, 0.0, -1.0);

  /* draw back face */
  glBegin(GL_QUAD_STRIP);
  for (i = 0; i <= teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
  }
  glEnd();

  /* draw back sides of teeth */
  glBegin(GL_QUADS);
  da = 2.0 * M_PI / teeth / 4.0;
  for (i = 0; i < teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;

    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
  }
  glEnd();

  /* draw outward faces of teeth */
  glBegin(GL_QUAD_STRIP);
  for (i = 0; i < teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;

    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
    u = r2 * cos(angle + da) - r1 * cos(angle);
    v = r2 * sin(angle + da) - r1 * sin(angle);
    len = sqrt(u * u + v * v);
    u /= len;
    v /= len;
    glNormal3f(v, -u, 0.0);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
    glNormal3f(cos(angle), sin(angle), 0.0);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
    u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
    v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
    glNormal3f(v, -u, 0.0);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
    glNormal3f(cos(angle), sin(angle), 0.0);
  }

  glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
  glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);

  glEnd();

  glShadeModel(GL_SMOOTH);

  /* draw inside radius cylinder */
  glBegin(GL_QUAD_STRIP);
  for (i = 0; i <= teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;
    glNormal3f(-cos(angle), -sin(angle), 0.0);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
  }
  glEnd();

}


void glarea_init (He_node *hn)
{
    static GLfloat pos[4]   = {5.0, 5.0, 10.0, 0.0};
    static GLfloat red[4]   = {0.8, 0.1,  0.0, 1.0};
    static GLfloat green[4] = {0.0, 0.8,  0.2, 1.0};
    static GLfloat blue[4]  = {0.2, 0.2,  1.0, 1.0};

    glLightfv(GL_LIGHT0, GL_POSITION, pos);
    glEnable(GL_CULL_FACE);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_DEPTH_TEST);

    /* make the gears */
    gear1 = glGenLists(1);
    if (gear1 == 0) { printf ("gears: glGenLists\n"); HeQuit(1);}
    glNewList(gear1, GL_COMPILE);
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
    gear(1.0, 4.0, 1.0, 20, 0.7);
    glEndList();

    gear2 = glGenLists(1);
    if (gear2 == 0) { printf ("gears: glGenLists\n"); HeQuit(1);}
    glNewList(gear2, GL_COMPILE);
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
    gear(0.5, 2.0, 2.0, 10, 0.7);
    glEndList();

    gear3 = glGenLists(1);
    if (gear3 == 0) { printf ("gears: glGenLists\n"); HeQuit(1);}
    glNewList(gear3, GL_COMPILE);
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
    gear(1.3, 2.0, 0.5, 10, 0.7);
    glEndList();

    glEnable(GL_NORMALIZE);
}


void glarea_resize (He_node *hn, int width, int height)
{
    GLfloat h = (GLfloat) height / (GLfloat) width;

    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0, 0.0, -40.0);
}

void glarea_repaint (He_node *hn)
{
    /* Angle rotation modifié au moment affichage pour fluidité */
    switch (next_rot) {
        case ROT_XP : view_rotx += INC_ANGLE; break;
        case ROT_XM : view_rotx -= INC_ANGLE; break;
        case ROT_YP : view_roty += INC_ANGLE; break;
        case ROT_YM : view_roty -= INC_ANGLE; break;
        case ROT_ZP : view_rotz += INC_ANGLE; break;
        case ROT_ZM : view_rotz -= INC_ANGLE; break;
    }
    if (nb_rot > 0) nb_rot-=1; else next_rot = ROT_NONE;    

    nb_frames++;
    
    /* view */
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glPushMatrix();
    glRotatef(view_rotx, 1.0, 0.0, 0.0);
    glRotatef(view_roty, 0.0, 1.0, 0.0);
    glRotatef(view_rotz, 0.0, 0.0, 1.0);

    glPushMatrix();
    glTranslatef(-3.0, -2.0, 0.0);
    glRotatef(angle, 0.0, 0.0, 1.0);
    glCallList(gear1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(3.1, -2.0, 0.0);
    glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
    glCallList(gear2);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(-3.1, 4.2, 0.0);
    glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
    glCallList(gear3);
    glPopMatrix();

    glPopMatrix();
    
    angle += 2.0;
    HePostRepaint(hn);
}

void glarea_event (He_node *hn, He_event *hev)
{
    switch (hev->type) {
      case KeyPress : switch (hev->sym) {
      
        case XK_Left :
        case XK_KP_Left :  next_rot = ROT_YP; nb_rot = NB_ROT; break;
        
        case XK_Right :
        case XK_KP_Right : next_rot = ROT_YM; nb_rot = NB_ROT; break;
        
        case XK_Up :
        case XK_KP_Up :    next_rot = ROT_XP; nb_rot = NB_ROT; break;
        
        case XK_Down :
        case XK_KP_Down :  next_rot = ROT_XM; nb_rot = NB_ROT; break;
        
        case XK_z :        next_rot = ROT_ZP; nb_rot = NB_ROT; break;
        
        case XK_Z :        next_rot = ROT_ZM; nb_rot = NB_ROT; break;
        
        case XK_q :
        case XK_Q :
        case XK_Escape :   HeQuit(0);         break;
      } break;
    }
}


void princ_resize (He_node *hn, int width, int height)
{
    HeExpand (glarea, NULL, HE_BOTTOM_RIGHT);
}

int fps_proc (int h, void *data)
{
    char buf[80];
    
    sprintf (buf, "%d", nb_frames);
    HeSetMessageLabel (mess_fps, buf);
    nb_frames = 0;
    
    return TRUE;
}

int main (int argc, char *argv[])
{
    int attr_list[] = {
      GLX_RGBA,
      GLX_DOUBLEBUFFER,
      GLX_DEPTH_SIZE, 1,
      None
    };
  
    HeInit (&argc, &argv);
    
    princ = HeCreateFrame();
    HeSetFrameLabel (princ, "Gears");
    HeSetFrameResizeProc (princ, princ_resize);
    
    panel = HeCreatePanel (princ);
    HeCreateMessageP (panel, "FPS:", TRUE);
    mess_fps = HeCreateMessageP (panel, "     ", FALSE);
    HeFit (panel);
    HeAddTimeout (1000, fps_proc, NULL);
    
    glarea = HeCreateGLArea (princ, attr_list, NULL);
    HeJustify (glarea, panel, HE_TOP);
    HeSetWidth (glarea, 300);
    HeSetHeight (glarea, 300);
    HeSetGLAreaInitProc (glarea, glarea_init);
    HeSetGLAreaRepaintProc (glarea, glarea_repaint);
    HeSetGLAreaEventProc (glarea, glarea_event);
    HeSetGLAreaResizeProc (glarea, glarea_resize);
    
    HeSetTip (glarea,
	"Pour tourner : Left, Right, Up, Down, z, Z\n"
	"Pour quitter : q, Q, Esc" );
    
    HeFit (princ);
    
    return HeMainLoop (princ);
}