/* 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 <assert.h>
#include "traqueboule.h"
#include "argumentParser.h"

// measure of computation time
#include <time.h>
clock_t start, end;
double cpu_time_used;
     



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

// methode d'affichage du treillis
const int DISPLAY_TRIANGLES=0;
const int DISPLAY_TRIANGLE_STRIP=1;
const int DISPLAY_VERTEX_ARRAY=2;
const int DISPLAY_LIST=3;
int display_method = 0;   // la méthode choisie
GLuint listindex;         // identificateur de la display list

double vitesse_rotation=0.0;  // rotation de la caméra

// espace couvert par la fonction
const float xmin = -1.0, xmax=1.0, ymin=-1.0, ymax = 1.0;
// echantillonnage
const int MAX_ECHAN=1001;
int n_hori = MAX_ECHAN-1; // nombre de colonnes
int n_vert = MAX_ECHAN-1; // nombre de lignes
// fonction tabulée
GLfloat ros[MAX_ECHAN * MAX_ECHAN * 3];          // tableau de coordonnées (dimension un)
GLfloat couleurs[MAX_ECHAN*MAX_ECHAN*3];         // tableau de couleurs (dimension un)
GLuint point_numero[2*(MAX_ECHAN-1)*MAX_ECHAN];  // ordre de parcours des sommets pour tracer des TRIANGLE_STRIP

// conversion entre indices en dimension 3 et indice en dimension 1
inline unsigned int ind( int i, int j, int k )
{
    return 3*(n_vert*i+j)+k;
}

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

            // position: x,y,z(x,y)
            ros[ind(i,j,0)] = x;
            ros[ind(i,j,1)] = y;
            ros[ind(i,j,2)] = z;

            // couleur: nuance de jaune
            couleurs[ind(i,j,0)]= z;
            couleurs[ind(i,j,1)]= z;
            couleurs[ind(i,j,2)]= 0;

            if(z>zMax)
                zMax=z; // pour tout ramener ultérieurement dans l'intervalle [0,1]
        }

    // mapping sur [0;1]
    for( int i=0; i<n_hori; ++i )
        for( int j=0; j<n_vert; ++j )
        {
            ros[ind(i,j,2)] *= 1/zMax;
            couleurs[ind(i,j,0)] *= 1/zMax;
            couleurs[ind(i,j,1)] *= 1/zMax;
            couleurs[ind(i,j,2)] *= 1/zMax;
        }

    // ordre de parcours des points pour des TRIANGLE_STRIP
    index=0;
    for(int i=1; i<n_hori; i++)
    {
        for(int j=0; j<n_vert; ++j)
        {
/*            point_numero[index++]= A COMPLETER ;
            point_numero[index++]= A COMPLETER ;*/
        }
    }

}


void afficher_par_triangles()
{
     //start = clock();
     
     glBegin(GL_TRIANGLES);
    // Tracer par bandes
    for(int i=1; i<n_hori; i++)  // n_hori-1 bandes verticales
    {
        for(int j=1; j<n_vert; ++j) // n_vert-1 rectangles par bande
        {
            // deux triangles par carré
            // i-1, j-1
            glColor3f(couleurs[ind(i-1,j-1,0)],couleurs[ind(i-1,j-1,1)],couleurs[ind(i-1,j-1,2)]);
            glVertex3f(ros[ind(i-1,j-1,0)], ros[ind(i-1,j-1,1)], ros[ind(i-1,j-1,2)]);
            // i, j-1
            glColor3f(couleurs[ind(i,j-1,0)],couleurs[ind(i,j-1,1)],couleurs[ind(i,j-1,2)]);
            glVertex3f(ros[ind(i,j-1,0)], ros[ind(i,j-1,1)], ros[ind(i,j-1,2)]);
            // i, j
            glColor3f(couleurs[ind(i,j,0)],couleurs[ind(i,j,1)],couleurs[ind(i,j,2)]);
            glVertex3f(ros[ind(i,j,0)], ros[ind(i,j,1)], ros[ind(i,j,2)]);

            // i-1, j-1
            glColor3f(couleurs[ind(i-1,j-1,0)],couleurs[ind(i-1,j-1,1)],couleurs[ind(i-1,j-1,2)]);
            glVertex3f(ros[ind(i-1,j-1,0)], ros[ind(i-1,j-1,1)], ros[ind(i-1,j-1,2)]);
            // i, j
            glColor3f(couleurs[ind(i,j,0)],couleurs[ind(i,j,1)],couleurs[ind(i,j,2)]);
            glVertex3f(ros[ind(i,j,0)], ros[ind(i,j,1)], ros[ind(i,j,2)]);
            // i-1, j
            glColor3f(couleurs[ind(i-1,j,0)],couleurs[ind(i-1,j,1)],couleurs[ind(i-1,j,2)]);
            glVertex3f(ros[ind(i-1,j,0)], ros[ind(i-1,j,1)], ros[ind(i-1,j,2)]);
        }
    }
    glEnd();

/*     end = clock();
     cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
     printf("cpu rendering time: %lf\n",cpu_time_used);*/
}


void afficher_par_triangle_strips()
{
    for(int i=1; i<n_hori; i++)
    {
        glBegin(GL_TRIANGLE_STRIP);
        for(int j=0; j<n_vert; ++j)
        {
        // A completer
		}
        glEnd();
    }

}

void afficher_par_vertex_array()
{
    // indiquer les tableaux de données utilisés
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(3,GL_FLOAT,0,ros);
    glEnableClientState(GL_COLOR_ARRAY);
    glColorPointer(3,GL_FLOAT,0,couleurs);

    // Tracer le maillage
    for( int i=0; i<n_hori-1; i++ )
    {
        // chaque appel trace une bande
/*        glDrawElements(GL_TRIANGLE_STRIP, A COMPLETER ,GL_UNSIGNED_INT,  point_numero + A COMPLETER );*/
    }
}


// Actions d'affichage
void display(void)
{
    // Details sur le mode de tracé
    glEnable( GL_DEPTH_TEST );            // effectuer le test de profondeur
    //glEnable(GL_CULL_FACE);
    //glCullFace(GL_BACK);
    glPolygonMode(GL_FRONT,GL_FILL);
    glPolygonMode(GL_BACK,GL_LINE);
    glShadeModel(GL_FLAT);

    // 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

    tbVisuTransform(); // origine et orientation de la scene

    if( display_method == DISPLAY_TRIANGLES)
    {
        afficher_par_triangles();
    }
    else if( display_method == DISPLAY_TRIANGLE_STRIP)
    {
        afficher_par_triangle_strips();
    }
    else if( display_method == DISPLAY_VERTEX_ARRAY )
    {
        afficher_par_vertex_array();
    }
    else if( display_method == DISPLAY_LIST )
    {
        glCallList( listindex );
    }
    else
        std::cerr<<"méthode d'affichage "<< display_method <<" non connue "<<std::endl;

    glutSwapBuffers();
}

// pour changement de taille ou desiconification
void reshape(int w, int h)
{
    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    //glOrtho (-1.1, 1.1, -1.1,1.1, -1000.0, 1000.0);
    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);
    }
}

// tourner la caméra
void rotate()
{
    tbRotate(vitesse_rotation,0,0,1);
}

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

    animal::parse("Comparaison de maillages. Voici la liste des options: ")
    .option(&W_fen,'L',"Largeur","largeur de la fenêtre en pixels")
    .option(&H_fen,'H',"Hauteur","hauteur de la fenêtre en pixels")
    .option(&n_hori,'c',"colonnes","finesse de l'échantillonnage horizontal (nombre de colonnes")
    .option(&n_vert,'l',"lignes","finesse de l'échantillonnage vertical (nombre de lignes)")
    .option(&display_method,'m',"methode","methode d'affichage. 0=triangles, 1=triangle_strip, 2=vertex_array, 3=display list")
    .option(&vitesse_rotation,'r',"rotation","vitesse de rotation de l'objet")
    (argc,argv);

    assert( n_hori<MAX_ECHAN );
    assert( n_vert<MAX_ECHAN );

    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
    tabuler_la_fonction();

    // display list
    listindex = glGenLists(1);
    if( listindex != 0 )
    {
        glNewList( listindex, GL_COMPILE );
        afficher_par_triangle_strips();
        glEndList();
    }
    else
        printf("La creation de liste a échoué\n");

    // 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);
    glutDisplayFunc(display);
    glutMouseFunc(tbMouseFunc);    // traqueboule utilise la souris
    glutMotionFunc(tbMotionFunc);  // traqueboule utilise la souris
    glutIdleFunc( rotate );

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