/* Programme de creation et d'affichage d'images RGB
   Francois faure, UJF-Grenoble, 2002
*/

#include <GLUT/glut.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>

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

// image de la fonction de Rosenbrock
const int w_img = W_fen; // largeur image rgb pour rosenbrock
const int h_img = H_fen; // hauteur image rgb pour rosenbrock
GLfloat rosenbrock[h_img][w_img][4]; // 4 float/pixel (r,g,b,a). Les pixels sont stockÈs par ligne.

// la tache
const int w_tache = 32;
const int h_tache = 32;
GLfloat tache[h_tache][w_tache][4]; // 4 float/pixel (r,g,b,a).
float x_tache= -1.0, y_tache= -1.0;

// calcul des couleurs des pixels
void calculer_rosenbrock()
{
    float valueMax = 0;
    for( int j=0; j<h_img; ++j )
        for( int i=0; i<w_img; ++i )
        {
            float x = (float) i/w_img - 0.5; //application de [0,w_img[ sur [-0.5,0.5[
            float y = (float) j/h_img - 0.5; //application de [0,h_img[ sur [-0.5,0.5[

            // fonction de Rosenbrock
            float luminosite = 100*(y-x*x)*(y-x*x) + (1-x)*(1-x);

            rosenbrock[j][i][0] = luminosite;
            rosenbrock[j][i][1] = 0;
            rosenbrock[j][i][2] = 0;
            rosenbrock[j][i][3] = 1;
            if( luminosite>valueMax ) valueMax = luminosite;
        }

    // mapping sur [0;255]
    printf("valeur max = %f\n",valueMax);
    for( int j=0; j<h_img; ++j )
        for( int i=0; i<w_img; ++i )
            rosenbrock[j][i][0] /= valueMax;


}

// calcul des couleurs des pixels
void calculer_tache()
{
    for( int j=0; j<h_tache; ++j )   // pour chaque ligne (ordonnÈe)
        for( int i=0; i<w_tache; ++i )
        {
            float x = (float) i/w_tache - 0.5; //application de [0,w_img[ sur [-0.5,0.5[
            float y = (float) j/h_tache - 0.5; //application de [0,h_img[ sur [-0.5,0.5[
            // (x,y) est la position du point dans le nouveau repere
            float distance = sqrt(x*x + y*y);
            float luminosite, alpha;
            if( distance >0.5 ){
                luminosite = 0.0;
                alpha = 0.0;
            }
            else {
                luminosite = 1-2*distance;
                alpha = 1.0;
            }
            // la luminosite est fonction de la distance au centre
            tache[j][i][0] = luminosite;
            tache[j][i][1] = luminosite;
            tache[j][i][2] = 0;
            tache[j][i][3] = alpha;
        }
}


// Actions d'affichage
void display(void)
{
   printf("display\n"); fflush(stdout);

   // Details sur le mode de tracÈ
   glPixelStorei (GL_UNPACK_ALIGNMENT, 1); // format des tableaux
   glEnable( GL_DEPTH_TEST );              // effectuer le test de profondeur
   glEnable( GL_ALPHA_TEST );              // effectuer le test d'opacite
   glAlphaFunc( GL_GREATER, 0 );           // fonction d'opacite utilisÈe

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

   // Tracer la tache
   glRasterPos3f(x_tache,y_tache,1); // positionnement du coin inferieur gauche
   glDrawPixels(w_tache,h_tache,GL_RGBA,GL_FLOAT,tache);

   // Tracer les axes du repËre
   glColor3f(1,1,1);
   glBegin(GL_LINES);
   glVertex3f(-1.0,0.0,0.0);
   glVertex3f( 1.0,0.0,0.0);
   glVertex3f( 0.0,-1.0,0.0);
   glVertex3f( 0.0, 1.0,0.0);
   glEnd();

   // Tracer la fonction
   glRasterPos3f(-1,-1,-1); // positionnement du coin inferieur gauche
   glDrawPixels(w_img,h_img,GL_RGBA,GL_FLOAT,rosenbrock);

   glFlush();  // declenche l'affichage
   //glutSwapBuffers();
}

// pour changement de taille ou desiconification
void reshape(int w, int h)
{
   printf("reshape %d,%d\n",w,h); fflush(stdout);
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho (-1, 1, -1,1, -10.0, 10.0);
   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 'g':
         y_tache -= 0.01;
         glutPostRedisplay(); // force le reaffichage
         break;
      case 't':
         y_tache += 0.01;
         glutPostRedisplay(); // force le reaffichage
         break;
      case 'f':
         x_tache -= 0.01;
         break;
      case 'h':
         x_tache += 0.01;
         glutPostRedisplay(); // force le reaffichage
         break;
   }
}

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

   // couches du framebuffer utilisees par l'application
   glutInitDisplayMode( GLUT_SINGLE | 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();
   calculer_tache();

   // cablage des callback
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutDisplayFunc(display);

   // lancement de la boucle principale
   glutMainLoop();
   return 0;  // instruction jamais executee
}