// * Positionnement (helico) 
// * Elimination faces arrieres
// * Eclairement (ambiant, diffus, spéculaire, position des sources).
// TP OPENGL 2
// Fabrice Aubert

 
#include <GL/glut.h>
   
#include <iostream>
#include <math.h>
#include "trackball.h"

// *******************************************************
// déclaration des procédures de tracé (définies en fin de source)
// *******************************************************

static void tracerHelico();
static void tracerTores();
static void tracerTetraedre();

// *************************************************
// VARIABLES GLOBALES (pour l'animation)
// *************************************************
GLfloat ANGLE_TORE1=0.0;
GLfloat ANGLE_TORE2=0.0;
GLfloat ANGLE_LUM1=0.0,ANGLE_LUM2=0.0;
GLfloat ANGLE_TETRA=0.0;

GLfloat ANGLE_ROTOR=0.0;
GLfloat ANGLE_HELICO=0.0;

// *************************************************
// PARAMETRES D'ECLAIREMENTS
// *************************************************

// pour matérialiser une source lumineuse (un peu "bidouille")
void tracerSource() {
  glDisable(GL_LIGHTING);
  glColor3f(1,1,1);
  glutWireCube(0.2);
  glEnable(GL_LIGHTING);
}

void sourceLocal(GLint light) {
  GLfloat position[4]={0,0,0,1.0}; // la lumiere est une source ponctuelle
                                   // sur l'origine
  glLightfv(light,GL_POSITION,position);
  tracerSource();
  // REMARQUE : la position à l'appel de glLightfv subit la matrice courante !!!!
  //            => lumiereLocale(GL_LIGHT0) place la lumière 0 sur l'origine du repère courant.
}


// Pour définir une lumiere blanche
void initSource(GLint light) {
  GLfloat ambient[4]={.1,.1,.1,1}; 
  GLfloat diffuse[4]={0.8,0.8,0.8,1}; 
  GLfloat speculaire[4]={.4,.4,.4,1};

  glLightfv(light,GL_AMBIENT,ambient);
  glLightfv(light,GL_DIFFUSE,diffuse);
  glLightfv(light,GL_SPECULAR,speculaire);
}




// Matériel bleu-vert avec spéculaire vert
void materielBleuVert() {
  GLfloat ambient[4]={0.1,0.1,0.1,1.0};
  GLfloat diffus[4]={0,0.4,0.7,1.0}; // diffus bleu-vert
  GLfloat speculaire[4]={0,0.8,0.0,1.0}; // spéculaire vert
  GLfloat brillance=50;

  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,ambient);
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,diffus);
  glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,speculaire);
  glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,brillance);
}

// Matériel rouge avec speculaire blanc
void materielRouge() {
  GLfloat ambient[4]={0.1,0,0,0.0};
  GLfloat diffus[4]={0.8,0,0,0.30};
  GLfloat speculaire[4]={0,0.8,0.8,1.0}; 
  GLfloat brillance=100;

  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,ambient);
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,diffus);
  glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,speculaire);
  glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,brillance);
}

// Matériel custom
void monMateriel() {
  GLfloat ambient[4]={0,0,0,0.0};
  GLfloat diffus[4]={0.8,0.8,0,0.30};
  GLfloat speculaire[4]={0.2,0.8,0.8,1.0}; 
  GLfloat brillance=100;

  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,ambient);
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,diffus);
  glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,speculaire);
  glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,brillance);
}



// ***************************************************
// DEFINITION DES CALLBACKS
// ***************************************************

// Callback de redimensionnement de fenetre
void myReshape(int width, int height) {
  glViewport(0, 0, (GLint) width, (GLint) height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity(); 
  
  gluPerspective(45,(GLfloat)width/height,1.0,30.0);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  tbReshape(width,height);
}


// Callback IDLE
void myIdle() {
  // mettre à jour les paramètres évolutifs 
  // ICI ...
  ANGLE_TORE1+=0.8; if (ANGLE_TORE1>360) ANGLE_TORE1-=360;
  ANGLE_TORE2+=0.5; if (ANGLE_TORE2>360) ANGLE_TORE2-=360;
  ANGLE_TETRA+=0.1; if (ANGLE_TETRA>360) ANGLE_TETRA-=360;

  ANGLE_ROTOR += 10;
  ANGLE_HELICO += 3;

  ANGLE_LUM1 += 3;
  ANGLE_LUM2 += 20;

  glutPostRedisplay();
}


// Callback de la souris
void myMouse(int button, int status, int x, int y) {
  tbMouse(button, status, x, y);
  if (button==GLUT_LEFT_BUTTON)
    {
      if (status==GLUT_DOWN)
      {
          printf("Position souris = %d,%d\n",x,y);
        }
    }

}

void myMotion(int x,int y) {
  tbMotion(x, y);
}


// CallBack clavier
void myKey(unsigned char c,int x,int y) {
  switch (c) {
  case 27: exit(1); break; // sortie violente si appui sur "Echap"
		//	case ' ':
  default: break;
  }
}
	

// callback de tracé
void myDisplay() {
  glClearColor(0,0,0,0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity();
  glPushMatrix();
  glTranslatef(0,0,-8); // "recule" le repère courant
  tbMatrix();

  //tracerHelico();
 
  //tracerTores();
  
  tracerTetraedre();

  glPopMatrix();
  glutSwapBuffers();
}



// **************************************************************
// Initialisation + MAIN
// **************************************************************
void myInit() {
  glEnable(GL_DEPTH_TEST);

  //glEnable(GL_LIGHTING); // active le calcul d'éclairement

  glEnable(GL_LIGHT0);  // active la source 0 pour le calcul d'éclairement
  initSource(GL_LIGHT0);

  glEnable(GL_LIGHT1);  // active la source 1 pour le calcul d'éclairement
  initSource(GL_LIGHT1);

  //glEnable(GL_CULL_FACE);
  
  //glEnable(GL_COLOR_MATERIAL); // les glColor seront interprétés comme caractéristiques de matériel.
  //glColorMaterial(GL_FRONT_AND_BACK,GL_DIFFUSE); // les glColor modifient la caractéristique DIFFUSE.

  tbInit(GLUT_LEFT_BUTTON);

}


int main(int argc, char **argv)
{
  glutInit(&argc,argv);
  glutInitWindowSize(512,512);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
	
  glutCreateWindow("TP 2 - M1");

  glutReshapeFunc(myReshape);
  glutDisplayFunc(myDisplay);
  glutMouseFunc(myMouse);
  glutKeyboardFunc(myKey);
  glutIdleFunc(myIdle);
  glutMotionFunc(myMotion);
  myInit();

  glutMainLoop();

  return 0;
}

// ======================================================================================
// ======================================================================================
// Squelettes de tracé pour les exercices
// ======================================================================================

void tracerRotor(float scale) 
{
  glPushMatrix();

  glColor3f(0, 1, 0);

  // Support
  glutSolidCone(0.3*scale, 0.3*scale, 10, 10);

  glTranslatef(0, 0, 0.3*scale);

  // Pale 1
  glPushMatrix();
  glScalef(30*scale, 1, 0.3*scale);
  glutSolidCube(0.2*scale);
  glPopMatrix();

  // Pale 2
  glPushMatrix();
  glScalef(1, 30*scale, 0.3*scale);
  glutSolidCube(0.2*scale);
  glPopMatrix();

  glPopMatrix();
}

// Partie avant
void tracerCockpit()
{
  glPushMatrix();

  glPushMatrix();

  materielRouge();
  glColor3f(1, 0, 0);

  glScalef(1.3, 1, 1);
  glutWireSphere(1.5, 20, 20);

  glPopMatrix();

  // Roto sup
  glRotatef(-90, 1, 0, 0);

  glRotatef(ANGLE_ROTOR, 0, 0, 1);
  glTranslatef(0, 0, 1.5);
  tracerRotor(1);

  glPopMatrix();
}
  
// Partie arrière
void tracerQueue()
{
  glPushMatrix();

  materielRouge();
  glColor3f(1, 0, 0);

  glPushMatrix();
  glRotatef(90, 0, 1, 0);
  glTranslatef(0, 0, 1);
  glutWireCone(1.1, 3.4, 20, 20);
  glPopMatrix();

  glTranslatef(3.6, 0, 0.3);

  glRotatef(ANGLE_ROTOR, 0, 0, 1);
  tracerRotor(0.4);

  glPopMatrix();
}


void tracerHelico() {
  glPushMatrix();

  glRotatef(ANGLE_HELICO, 0, 1, 0);
  tracerCockpit();
  tracerQueue();
  
  glPopMatrix();
}


void tracerTores() {

  glPushMatrix();

  // Centre
  glTranslatef(1.5, 0, 0);
  glRotatef(ANGLE_TORE2, 1, 0, 0);

  // ext
  glRotatef(ANGLE_LUM1, 0, 0, 1);
  glTranslatef(0, 0.7, 0);

  glRotatef(ANGLE_LUM2, 1, 0, 0);
  glTranslatef(0, 0.7, 0);

  sourceLocal(GL_LIGHT1);

  glPopMatrix();

  glPushMatrix();
  materielRouge();
    glTranslatef(-1.5,0,0);
    //glColor3f(0,0,1);
    glRotatef(ANGLE_TORE1,0,1,0);
    glutSolidTorus(0.3,1,50,50);
  glPopMatrix();



  glPushMatrix();
  monMateriel();
    glTranslatef(1.5,0,0);
    glRotatef(ANGLE_TORE2,1,0,0);
    //glColor3f(0,1,0);
    glutSolidTorus(0.3,1,50,50);
  glPopMatrix();
    
}


void tracerTetraedre() {
  glPushMatrix();
  glRotatef(ANGLE_TETRA,1,1,-0.5);
  glScalef(3,3,3);
  glBegin(GL_TRIANGLES); { // les sommets sont pris 3 par 3 pour en faire des triangles
//     glColor3f(1,0,0);
//     glVertex3f(0,1,0);
//     glVertex3f(0,0,1);
//     glVertex3f(1,0,0);

    
    glColor3f(0,1,0);
    glVertex3f(1,0,0);
    glVertex3f(0,0,1);
    glVertex3f(0,0,0);

    glColor3f(0,0,1);
    glVertex3f(0,0,1);
    glVertex3f(0,1,0);
    glVertex3f(0,0,0);

    glColor3f(1,1,0);
    glVertex3f(0,0,0);
    glVertex3f(0,1,0);
    glVertex3f(1,0,0);
    
  }
  glEnd();
  glPopMatrix();
}