/* Affichage de la fonction de Rosenbrock à l'aide de polygones.
   Francois faure, UJF-Grenoble, 2003
*/

#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include "traqueboule.h"

const int W_fen = 600;  // largeur fenetre
const int H_fen = 600;  // hauteur fenetre


// fonction de Rosenbrock tabulée
const int w_img = 10; // largeur tableau ros
const int h_img = 10; // hauteur tableau ros
GLfloat ros[h_img*w_img*3]; // points (x,y,z)
GLfloat norm[h_img*w_img*3]; // normales (x,y,z)
GLfloat tex[h_img*w_img*2]; // coordonnees de texture
GLuint indices[2*(w_img-1)*h_img];     // indices pour des TRIANGLE_STRIP
// espace couvert par la fonction
const float xmin = -1.0, xmax=1.0, ymin=-1.0, ymax = 1.0;
float zMax = 0;

// mode d'affichage du treillis
bool wireFrame = false;

// matériau
GLfloat m_emission[] =  {0, 0, 0};
GLfloat m_ambient[] =   {1,1,1};
GLfloat m_diffuse[] =   {0.5,0.5,0.5};
GLfloat m_specular[] =  {0.5,0.5,0.5};
GLfloat m_shininess =   20.0;

// caractéristiques globales de l'éclairage
GLfloat l_ambient[] = {0.1,0.1,0.1};
GLint l_localViewer = GL_TRUE;
GLint l_twoSides = GL_TRUE;
GLint l_separateDiffuseAndSpecular = GL_SINGLE_COLOR;
//GLint l_separateDiffuseAndSpecular = GL_SEPARATE_SPECULAR_COLOR;

// lumière 0
bool lumiere0 = true;
GLfloat l0_position[] = {0,0,0,1};
GLfloat l0_ambient[] = {0.1,0.1,0.1};
GLfloat l0_diffuse[] = {1,0,0};
GLfloat l0_specular[] = {0,1,0};

// lumière 1
bool lumiere1 = false;
GLfloat l1_position[] = {0,0,0,1};
GLfloat l1_ambient[] = {0.1,0.1,0.1};
GLfloat l1_diffuse[] = {1,0,0};
GLfloat l1_specular[] = {0,1,0};
GLfloat lattitude1 = 90;
GLfloat longitude1 = 0;
GLfloat distance1 = 2;


static GLubyte checkImage[2][2][3];
static GLuint texName;

void init_textures()
{
   checkImage[0][0][0]=checkImage[0][0][1]=checkImage[0][0][2]=(GLubyte) 50;
   checkImage[0][1][0]=checkImage[0][1][1]=checkImage[0][1][2]=(GLubyte) 255;
   checkImage[1][0][0]=checkImage[1][0][1]=checkImage[1][0][2]=(GLubyte) 255;
   checkImage[1][1][0]=checkImage[1][1][1]=checkImage[1][1][2]=(GLubyte) 50;

   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

   glGenTextures(1, &texName);
   glBindTexture(GL_TEXTURE_2D, texName);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 
                   GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
                   GL_NEAREST);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2,
                2, 0, GL_RGB, GL_UNSIGNED_BYTE,
                checkImage);

   glBindTexture(GL_TEXTURE_2D, 0);
}


// calcul des points d'échantillonnage
void calculer_rosenbrock()
{
	int index=0;
	for( int i=0; i<w_img; ++i ) 
		for( int j=0; j<h_img; ++j )
		{  
			float x = xmin +  i * (xmax-xmin)/(w_img-1) ; 
			float y = ymin +  j * (ymax-ymin)/(h_img-1) ;
			// fonction de Rosenbrock
			float z = 100*(y-x*x)*(y-x*x) + (1-x)*(1-x);

			// points de la surface
			ros[index  ] = x;
			ros[index+1] = y;
			ros[index+2] = z;
			
			// vecteurs normaux à la surface
			float dzdx = -400*x*(y-x*x) - 2*(1-x);
			float dzdy = 200*(y-x*x);
			norm[index  ]=-dzdx;
			norm[index+1]=-dzdy;
			norm[index+2]=1;
			
			printf("normale: %f %f %f\n",norm[index], norm[index+1], norm[index+2]);
			 
			index+=3;
			
			if(z>zMax) zMax=z;
			//printf("%f %f %f\n",x,y,z);
			
			tex[2*(i*h_img+j)  ] = (GLfloat) i/(w_img-1);
			tex[2*(i*h_img+j)+1] = (GLfloat) j/(h_img-1);
		}
	
	// enumeration des indices pour un parcours TRIANGLE_STRIP
	index=0;
	for(int i=1; i<w_img; i++){
		for(int j=0; j<h_img; ++j)
		{
			indices[index++]= (i-1)*h_img+j;
			indices[index++]= (i  )*h_img+j;
		}
	}
	
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3,GL_FLOAT,0,ros);
	glEnableClientState(GL_NORMAL_ARRAY);
	glNormalPointer(GL_FLOAT,0,norm);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glTexCoordPointer(2,GL_FLOAT,0,tex);
}

// Actions d'affichage
void display(void)
{
	// Details sur le mode de tracé
	glEnable( GL_DEPTH_TEST );              // effectuer le test de profondeur
	//glPolygonMode(GL_FRONT,GL_FILL);
	if( wireFrame ) glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
	else glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
	glEnable(GL_LIGHTING);
	if( lumiere0 ) glEnable(GL_LIGHT0); else glDisable(GL_LIGHT0);
	if( lumiere1 ) glEnable(GL_LIGHT1); else glDisable(GL_LIGHT1);
	glEnable(GL_NORMALIZE);
	
	// materiau
	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION,  m_emission);
	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,   m_ambient);
	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,   m_diffuse);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,  m_specular);
	glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, m_shininess);
	
	// modele global d'eclairage
	glLightModelfv( GL_LIGHT_MODEL_AMBIENT, l_ambient );
	glLightModeli ( GL_LIGHT_MODEL_LOCAL_VIEWER, l_localViewer );
	glLightModeli ( GL_LIGHT_MODEL_TWO_SIDE, l_twoSides );
	glLightModeli ( GL_LIGHT_MODEL_COLOR_CONTROL, l_separateDiffuseAndSpecular );

	// lumiere 0
	glLightfv( GL_LIGHT0, GL_AMBIENT,   l0_ambient );
	glLightfv( GL_LIGHT0, GL_DIFFUSE,   l0_diffuse );
	glLightfv( GL_LIGHT0, GL_SPECULAR,  l0_specular );

	// lumiere 1
	glLightfv( GL_LIGHT1, GL_AMBIENT,   l1_ambient );
	glLightfv( GL_LIGHT1, GL_DIFFUSE,   l1_diffuse );
	glLightfv( GL_LIGHT1, GL_SPECULAR,  l1_specular );

	// Effacer tout
	glClearColor (0.0, 0.0, 0.0, 0.0);
	glClear( GL_COLOR_BUFFER_BIT  | GL_DEPTH_BUFFER_BIT); // la couleur et le z

	glLoadIdentity();  // repere camera 
	glLightfv( GL_LIGHT0, GL_POSITION,  l0_position );
	
	tbVisuTransform(); // origine et orientation de la scene
	
	// position lumière 1
	if(lumiere1){
		glPushMatrix(); 
		glRotatef( lattitude1, 0,0,1 );  // position lumière
		glRotatef( longitude1, 0,1,0 );
		glTranslatef( distance1, 0,0);
		glLightfv( GL_LIGHT1, GL_POSITION,  l1_position );
		glDisable(GL_LIGHTING);
		glutSolidSphere(0.1,82,82);
		glColor3f(1,1,1);
		glEnable(GL_LIGHTING);
		glPopMatrix();
	}
	
	
	glScalef(1,1,1/zMax);  // aplatir la fonction

	//glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, texName);
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

	// Tracer la fonction
	for( int i=0; i<w_img-1; i++ )
	{
		glDrawElements(GL_TRIANGLE_STRIP,2*h_img, GL_UNSIGNED_INT,indices+i*2*h_img);
	}
        glBindTexture(GL_TEXTURE_2D, 0);
	glDisable(GL_TEXTURE_2D);

	glutSwapBuffers();
}

// pour changement de taille ou desiconification
void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective (50, (float)w/h, 1, 10);
   glMatrixMode(GL_MODELVIEW);
}

// prise en compte du clavier
void keyboard(unsigned char key, int x, int y)
{
	//printf("key %d pressed at %d,%d\n",key,x,y); fflush(stdout);
	switch (key) {
		case 27:     // touche ESC
			exit(0);
		case '0':
			lumiere0 = !lumiere0;
			glutPostRedisplay();
			break;
		case '1':
			lumiere1 = !lumiere1;
			glutPostRedisplay();
			break;
		case 'w':
			wireFrame = !wireFrame;
			glutPostRedisplay();
			break;
	}
}

// prise en compte des touches spéciales du clavier
void specialKeys(int key, int x, int y)
{
	//printf("specialkey %d pressed at %d,%d\n",key,x,y); fflush(stdout);
	switch (key) {
		case GLUT_KEY_DOWN:
			longitude1 = longitude1 -1;
			glutPostRedisplay();
			break;
		case GLUT_KEY_UP:
			longitude1 = longitude1 + 1;
			glutPostRedisplay();
			break;
		case GLUT_KEY_LEFT:
			lattitude1 = lattitude1 +1;
			glutPostRedisplay();
			break;
		case GLUT_KEY_RIGHT:
			lattitude1 = lattitude1 -1;
			glutPostRedisplay();
			break;
	}
}

// programme principal
int main(int argc, char** argv)
{
	glutInit(&argc, argv);

	// couches du framebuffer utilisees par l'application
	glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH );

	// position et taille de la fenetre
	glutInitWindowPosition(200, 100);
	glutInitWindowSize(W_fen,H_fen);
	glutCreateWindow(argv[0]);

	// initialisations diverses
	calculer_rosenbrock();
	init_textures();

	// Initialisation du point de vue
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glTranslatef(0,0,-4);   
	tbInitTransform();     // initialisation du point de vue
	tbHelp();                      // affiche l'aide sur la traqueboule

	// cablage des callback
	glutReshapeFunc(reshape);
	glutKeyboardFunc(keyboard);
	glutSpecialFunc(specialKeys);
	glutDisplayFunc(display);
	glutMouseFunc(tbMouseFunc);    // traqueboule utilise la souris 
	glutMotionFunc(tbMotionFunc);  // traqueboule utilise la souris

	// lancement de la boucle principale
	glutMainLoop();
	return 0;  // instruction jamais exécutée
}