/* Auteur: Nicolas JANEY                  */
/* nicolas.janey@univ-fcomte.fr           */
/* Avril 2001                             */
/* Illustration du calcul des normales    */
/* moyennes pour l'algorithme de Gouraud  */

#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

#include <math.h>

#include "ModuleCouleurs.h"
#include "ModuleFleche.h"
#include "ModuleFont.h"
#include "ModuleManipulateur.h"
#include "ModuleMatriceVecteur.h"
#include "ModuleMenus.h"
#include "ModuleReshape.h"

static vecteur p[6] = { { 0.0F,0.0F,0.0F },
                        { -5.0F,-4.0F,-3.0F },
                        { 1.0F,-5.0F,-4.0F },
                        { 4.0F,1.0F,-5.0F },
                        { 2.0F,5.0F,-4.0F },
                        { -2.0F,4.0F,-4.0F } };
static vecteur cf[5];
static vecteur np[6];
static vecteur nf[5];

static int s = 0 ;
static int aff = 0 ;

void myinit(void) {
  GLfloat shinines[] = { 0.0 };
  GLfloat l_pos[] = { 1.0,1.0,1.0,0.0 };
  glClearColor(1.0F,1.0F,1.0F,1.0F) ;
  glMaterialfv(GL_FRONT,GL_SPECULAR,couleurNoir());
  glMaterialfv(GL_FRONT,GL_SHININESS,shinines);
  glLightfv(GL_LIGHT0,GL_POSITION,l_pos);
  glEnable(GL_LIGHT0);
  glDepthFunc(GL_LESS);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_AUTO_NORMAL);
  glEnable(GL_NORMALIZE);
}

void calculNormaleFacette(vecteur p1,vecteur p2,vecteur p3,vecteur n) {
  vecteur v1;
  vecteur v2;
  calculVecteurNorme(p1,p2,v1) ;
  calculVecteurNorme(p1,p3,v2) ;  
  produitVectoriel(v1,v2,n);
}

void calculNormaleMoyenne(vecteur n1,vecteur n2,vecteur n) {
  n[0] = n1[0]+n2[0];
  n[1] = n1[1]+n2[1];
  n[2] = n1[2]+n2[2];
  normalise(n);
}

void calculNormaleMoyenne(vecteur n1,vecteur n2,vecteur n3,vecteur n4,vecteur n5,vecteur n) {
  n[0] = n1[0]+n2[0]+n3[0]+n4[0]+n5[0];
  n[1] = n1[1]+n2[1]+n3[1]+n4[1]+n5[1];
  n[2] = n1[2]+n2[2]+n3[2]+n4[2]+n5[2];
  normalise(n);
}

void calculCentreFacette(vecteur p1,vecteur p2,vecteur p3,vecteur p) {
  p[0] = (p1[0]+p2[0]+p3[0])/3.0F;
  p[1] = (p1[1]+p2[1]+p3[1])/3.0F;
  p[2] = (p1[2]+p2[2]+p3[2])/3.0F;
}

void normal3(vecteur p,vecteur n,char *m1,char *m2) {
  glPushMatrix() ;
  glTranslatef(p[0],p[1],p[2]) ;
  flecheEnVolume(n[0]*5,n[1]*5,n[2]*5,0.2F,0.8F,0.05F);
  glPopMatrix() ;
  glPushMatrix() ;
  if ( aff ) {
    placeFontCursor(p[0]+n[0]*4.8F,p[1]+n[1]*4.8F,p[2]+n[2]*4.8F) ;
    deplacementCursor(6,0,0) ;
    simpleBitmapOutput(REGULAR8x13,m1) ;
    deplacementCursor(26,0,0) ;
    simpleBitmapOutput(REGULAR6x10,m2) ;
    deplacementCursor(6,-6,0) ;
    simpleBitmapOutput(DESSIN,"TF") ; }
  glPopMatrix() ;
}

void normal2(vecteur p,vecteur n,char *m1,char *m2) {
  glPushMatrix() ;
  glTranslatef(p[0],p[1],p[2]) ;
  flecheEnVolume(n[0]*5,n[1]*5,n[2]*5,0.2F,0.8F,0.05F);
  glPopMatrix() ;
  glPushMatrix() ;
  if ( aff ) {
    placeFontCursor(p[0]+n[0]*4.8F,p[1]+n[1]*4.8F,p[2]+n[2]*4.8F) ;
    deplacementCursor(6,0,0) ;
    simpleBitmapOutput(REGULAR8x13,m1) ;
    deplacementCursor(16,0,0) ;
    simpleBitmapOutput(REGULAR6x10,m2) ;
    deplacementCursor(6,-6,0) ;
    simpleBitmapOutput(DESSIN,"TF") ; }
  glPopMatrix() ;
}

void normal1(vecteur p,vecteur n,char *m1) {
  glPushMatrix() ;
  glTranslatef(p[0],p[1],p[2]) ;
  flecheEnVolume(n[0]*5,n[1]*5,n[2]*5,0.2F,0.8F,0.05F);
  glPopMatrix() ;
  glPushMatrix() ;
  if ( aff ) {
    placeFontCursor(p[0]+n[0]*4.8F,p[1]+n[1]*4.8F,p[2]+n[2]*4.8F) ;
    deplacementCursor(6,10,0) ;
    simpleBitmapOutput(REGULAR8x13,m1) ;
    deplacementCursor(6,4,0) ;
    simpleBitmapOutput(DESSIN,"TF") ; }
  glPopMatrix() ;
}

void normal(vecteur p,vecteur n) {
  glPushMatrix() ;
  glTranslatef(p[0],p[1],p[2]) ;
  flecheEnVolume(n[0]*5,n[1]*5,n[2]*5,0.2F,0.8F,0.05F);
  glPopMatrix() ;
}

void affichageNormales(void) {
  glMaterialfv(GL_FRONT,GL_EMISSION,couleurRougeFonce());
  glMaterialfv(GL_FRONT,GL_DIFFUSE,couleurRouge());
  normal1(p[0],np[0],"N") ;
  glMaterialfv(GL_FRONT,GL_EMISSION,couleurVertFonce());
  glMaterialfv(GL_FRONT,GL_DIFFUSE,couleurVert());
  normal3(p[1],np[1],"NP","1") ;
  normal3(p[2],np[2],"NP","2") ;
  normal3(p[3],np[3],"NP","3") ;
  normal3(p[4],np[4],"NP","4") ;
  normal3(p[5],np[5],"NP","5") ;
  glMaterialfv(GL_FRONT,GL_EMISSION,couleurBleuFonce());
  glMaterialfv(GL_FRONT,GL_DIFFUSE,couleurBleu());
  normal2(cf[0],nf[0],"N","1") ;
  normal2(cf[1],nf[1],"N","2") ;
  normal2(cf[2],nf[2],"N","3") ;
  normal2(cf[3],nf[3],"N","4") ;
  normal2(cf[4],nf[4],"N","5") ;
}

void scene1(void) {
  glMaterialfv(GL_FRONT,GL_EMISSION,couleurNoir());
  glMaterialfv(GL_FRONT,GL_DIFFUSE,couleurGrisClair());
  glEnable(GL_LIGHTING);
  glPushMatrix();
  glBegin(GL_TRIANGLES) ;
  glNormal3fv(np[0]) ;
  glVertex3fv(p[0]) ;
  glNormal3fv(np[1]) ;
  glVertex3fv(p[1]) ;
  glNormal3fv(np[2]) ;
  glVertex3fv(p[2]) ;
  glNormal3fv(np[0]) ;
  glVertex3fv(p[0]) ;
  glNormal3fv(np[2]) ;
  glVertex3fv(p[2]) ;
  glNormal3fv(np[3]) ;
  glVertex3fv(p[3]) ;
  glNormal3fv(np[0]) ;
  glVertex3fv(p[0]) ;
  glNormal3fv(np[3]) ;
  glVertex3fv(p[3]) ;
  glNormal3fv(np[4]) ;
  glVertex3fv(p[4]) ;
  glNormal3fv(np[0]) ;
  glVertex3fv(p[0]) ;
  glNormal3fv(np[4]) ;
  glVertex3fv(p[4]) ;
  glNormal3fv(np[5]) ;
  glVertex3fv(p[5]) ;
  glNormal3fv(np[0]) ;
  glVertex3fv(p[0]) ;
  glNormal3fv(np[5]) ;
  glVertex3fv(p[5]) ;
  glNormal3fv(np[1]) ;
  glVertex3fv(p[1]) ;
  glEnd() ;
  affichageNormales();
  glPopMatrix();
}

void scene2(void) {
  glMaterialfv(GL_FRONT,GL_EMISSION,couleurNoir());
  glMaterialfv(GL_FRONT,GL_DIFFUSE,couleurGrisClair());
  glEnable(GL_LIGHTING);
  glPushMatrix();
  glBegin(GL_TRIANGLES) ;
  glNormal3fv(nf[0]) ;
  glVertex3fv(p[0]) ;
  glVertex3fv(p[1]) ;
  glVertex3fv(p[2]) ;
  glNormal3fv(nf[1]) ;
  glVertex3fv(p[0]) ;
  glVertex3fv(p[2]) ;
  glVertex3fv(p[3]) ;
  glNormal3fv(nf[2]) ;
  glVertex3fv(p[0]) ;
  glVertex3fv(p[3]) ;
  glVertex3fv(p[4]) ;
  glNormal3fv(nf[3]) ;
  glVertex3fv(p[0]) ;
  glVertex3fv(p[4]) ;
  glVertex3fv(p[5]) ;
  glNormal3fv(nf[4]) ;
  glVertex3fv(p[0]) ;
  glVertex3fv(p[5]) ;
  glVertex3fv(p[1]) ;
  glEnd() ;
  affichageNormales();
  glPopMatrix();
}

void display(void) {
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  if ( s )
    scene1() ;
    else
    scene2() ;
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
}

void key(unsigned char key,int x,int y) {
  if ( keyManipulateur(key,x,y) )
    glutPostRedisplay();
    else
    switch ( key ) {
      case 0x0D : aff = (aff+1)%2;
                  glutPostRedisplay();
                  break;
      case 32   : s = (s+1)%2;
                  glutPostRedisplay();
                  break; }
}

int main(int argc,char **argv) {
  glutInit(&argc,argv);
  calculCentreFacette(p[0],p[1],p[2],cf[0]);
  calculCentreFacette(p[0],p[2],p[3],cf[1]);
  calculCentreFacette(p[0],p[3],p[4],cf[2]);
  calculCentreFacette(p[0],p[4],p[5],cf[3]);
  calculCentreFacette(p[0],p[5],p[1],cf[4]);
  calculNormaleFacette(p[0],p[1],p[2],nf[0]);
  calculNormaleFacette(p[0],p[2],p[3],nf[1]);
  calculNormaleFacette(p[0],p[3],p[4],nf[2]);
  calculNormaleFacette(p[0],p[4],p[5],nf[3]);
  calculNormaleFacette(p[0],p[5],p[1],nf[4]);
  calculNormaleMoyenne(nf[0],nf[1],nf[2],nf[3],nf[4],np[0]);
  calculNormaleMoyenne(nf[0],nf[1],np[2]);
  calculNormaleMoyenne(nf[1],nf[2],np[3]);
  calculNormaleMoyenne(nf[2],nf[3],np[4]);
  calculNormaleMoyenne(nf[3],nf[4],np[5]);
  calculNormaleMoyenne(nf[4],nf[0],np[1]);
  glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE);
  glutInitWindowSize(350,250); 
  glutInitWindowPosition(50,50); 
  glutCreateWindow("Calcul des normales moyennes"); 
  myinit(); 
  creationMenuBasique();
  setParametresOrthoBasique(-7.0,7.0,-7.0,7.0,-50.0,50.0);
  setManipulateurDistance(1.0F);
  setManipulateurSourisAngle(-30.0F,0.0F,0.0F) ;
  glutReshapeFunc(reshapeOrthoBasique);
  glutKeyboardFunc(key);
  glutSpecialFunc(specialBasique);
  glutMotionFunc(motionBasique);
  glutMouseFunc(sourisBasique);
  glutDisplayFunc(display);
  glutMainLoop();
  return(0);
}