#ifdef _WIN32
#include <windows.h>
#endif

#include <GL/gl.h>
#include <GL/glut.h>
#include "parser.h"
#include "utils.h"
#include "trackball.h"
#include "cartoon_travail.h"
#include "sgi.h"

#define MGL_JPEG 1
#define MGL_RGB 2

using namespace MM_PARSER;

MObjet *SCENE;
Point3D OBS;
bool ATTENDRE=false;
GLuint IDTEX;
float AVANCE=-20.0;

// affectation d'une image à un identifiant de texture
GLuint initTexture(char *nom,int format)
{
  GLubyte *image;  // pour stocker les pixels de l'image texture
	GLuint tex_id;
  GLint longueur,largeur,depthi;

	switch (format) {
	case MGL_JPEG:image=read_jpg(nom,&longueur,&largeur,&depthi);break;
	case MGL_RGB:image=read_sgi(nom,&longueur,&largeur,&depthi);break;
	default:exit(1);
	}

	printf("lecture image : %d x %d x %d\n",longueur,largeur,depthi);

	// affectation identifiant
	glGenTextures(1,&tex_id); // alloue 1 identifiant à tex_id.
	glBindTexture(GL_TEXTURE_2D,tex_id); // la texture courante 2D correspond à
                                       // l'identifiant tex_id.

printf("%d\n",tex_id);
  // alignement mémoire du bitmap (indique à OpenGL comment devra être interprété le tableau "image" pour
	// le mettre dans la mémoire de texture OpenGL (très technique : cf docs OpenGL)).
  glPixelStorei(GL_UNPACK_ALIGNMENT,1);


  // affecter la GL_TEXTURE_2D (texture 2D courante) avec une texture (contenue ici dans le tableau "image")
	// on indique :
  //   - le niveau 0 de mipmap (cf cours)
  //   - le nombre d'éléments consécutifs du tableau "image" qui correspondent à un pixel (GL_RGB=3)
  //   - la longueur et la largeur (en pixels)
	//   - existance d'un bord (sert à d'éventuels recollement de texture bord à bord) : pour nous = 0 (pas de bords)
	//   - quel est le format de la texture (ici GL_RGB)
	//   - le type des éléments du tableau (unigned int)
	//   - le pointeur du tableau constituant la texture (image)
  glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,longueur,largeur,0,GL_RGB,GL_UNSIGNED_BYTE,image);


	// la suite indique différents paramètres qui seront donc identiques pour toutes les textures lues.

  // parametres de repetition en S et T (GL_CLAMP = pas de répétition; GL_REPEAT = répétition).
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);

  // filtrage texture (cf cours).
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);

  // mode (ou environement) de calcul de la couleur du fragment :
	//           GL_REPLACE = la couleur du fragment devient la couleur de texture
  //           GL_MODULATE = la couleur de texture est mixee avec la couleur
  //                         du fragment (qui contient la couleur donnée par éclairement).
	// Remarque : malgré le nom glTex*Env*, cela n'a aucun rapport avec "l'environment mapping"
  glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);



	return tex_id;
}

// en environment mapping (effet de reflexion de l'image sur la scene).
void activerTexture(GLint idtex)
{
	glBindTexture(GL_TEXTURE_2D,idtex);

	glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP);
	glEnable(GL_TEXTURE_GEN_S);

	glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP);
	glEnable(GL_TEXTURE_GEN_T);
	glEnable(GL_TEXTURE_2D);
}

void desactiverTexture() {
  glDisable(GL_TEXTURE_GEN_S);
  glDisable(GL_TEXTURE_GEN_T);
  glDisable(GL_TEXTURE_2D);
}



void myDisplay() {
    glClearColor(1,1,1,1);
    glClearDepth(1.0);
    glClearStencil(0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

    glPushMatrix();
    glTranslatef(0,0,AVANCE);
    tbMatrix();
    tracerScene(*SCENE);
    glPopMatrix();

    glutSwapBuffers();
}



void myReshape(GLint width,GLint height)
{


  glViewport(0,0,width,height);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(45,(GLfloat)width/height,1,100);

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

}

void myIdle(void)
{
  glutPostRedisplay();
}

// 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 ' ':
  case 'a':ATTENDRE=!ATTENDRE;break;
  case 'z':AVANCE+=0.3;glutPostRedisplay();break;
  case 's':AVANCE-=0.3;glutPostRedisplay();break;
  default: break;
  }
}

void myMouse(int button, int state, int x, int y)
{
  tbMouse(button, state, x, y);
}

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


// *****************************************************
// INITIALISATION OPENGL (+lecture texture+lecture objet)
void myInit()
{
  glEnable(GL_DEPTH_TEST);
  IDTEX=initTexture("degrade2.jpg",MGL_JPEG);


  glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
  glEnable(GL_COLOR_MATERIAL);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  tbInit(GLUT_LEFT_BUTTON);
}


main(int argv,char **argc)
{
  if (argv!=2) { printf("usage : run <nom fichier.brp>\n");exit(0);}

  ParserBRP obj(argc[1]);
  SCENE=obj.Lire();


  calculerNormaleSommet(SCENE);

  glutInit(&argv,argc);

  glutInitWindowSize(512,512);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);

  glutCreateWindow("Effets");

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

  myInit();

  glutMainLoop();

}