ripple/ripple.cpp

#include <stdlib.h>
#include <iostream>
#include "inf2705.h"
#include "constants.h"
#include "FBO.h"
#include "Packets.h"
#include "util.h"

#define SOL 1

enum {LocAttrib, LocUniform}; /* Shader location type */
enum {
    RWMP_SHADER,
    APD_SHADER,
    DPO_SHADER,
    DMM_SHADER,
    DT_SHADER,
    RAA_SHADER,
    NB_SHADERS
}; /* Shaders stages */

// variables pour l'utilisation des nuanceurs
GLuint prog;      // votre programme de nuanceurs
GLuint progRasterizeWaveMeshPosition;
GLuint progAddPacketDisplacement;
GLuint progDisplayPacketOutlined;
GLuint progDisplayMicroMesh;
GLuint progDisplayTerrain;
GLuint progRenderAA;
GLint locVertex = -1;
GLint locNormal = -1;
GLint locTexCoord = -1;
GLint locmatrModel = -1;
GLint locmatrVisu = -1;
GLint locmatrProj = -1;
GLint locmatrNormale = -1;
GLint loclaTexture = -1;
// Locations for RasterizeWaveMeshPosition shader
GLint locVertexRWMP = -1;
GLint locTexCoordRWMP = -1;
GLint locmatrModelRWMP = -1;
GLint locmatrVisuRWMP = -1;
GLint locmatrProjRWMP = -1;
GLint locmatrNormaleRWMP = -1;
// Locations for AddPacketDisplacement shader
GLuint locPosAPD = -1;
GLuint locAtt1APD = -1;
GLuint locAtt2APD = -1;
GLuint locmatrModelAPD = -1;
GLuint locmatrVisuAPD = -1;
GLuint locmatrProjAPD = -1;
GLuint locTexAPD = -1;
// Locations for DisplayPacketOutlined shader
GLuint locPosDPO = -1;
GLuint locAtt1DPO = -1;
GLuint locAtt2DPO = -1;
GLuint locmatrModelDPO = -1;
GLuint locmatrVisuDPO = -1;
GLuint locmatrProjDPO = -1;
GLuint locTexDPO = -1;
// Locations for DisplayMicroMesh shader
GLuint locVertexDMM = -1;
GLuint locTexCoordDMM = -1;
GLuint locmatrModelDMM = -1;
GLuint locmatrVisuDMM = -1;
GLuint locmatrProjDMM = -1;
GLuint locTerrainTexDMM = -1;
GLuint locWaterPosTexDMM = -1;
GLuint locWaterHeightTexDMM = -1;
// Locationss for DisplayTerrain shader
GLuint locVertexDT = -1;
GLuint locmatrModelDT = -1;
GLuint locmatrVisuDT = -1;
GLuint locmatrProjDT = -1;
GLuint locTerrainTexDT = -1;
// Locations for RenderAA shader
GLuint locVertexRAA = -1;
GLuint locTexCoordRAA = -1;
GLuint locmatrModelRAA = -1;
GLuint locmatrVisuRAA = -1;
GLuint locmatrProjRAA = -1;
GLuint locTexRAA = -1;

GLuint indLightSource;
GLuint indFrontMaterial;
GLuint indLightModel;
GLuint indvarsUnif;
GLuint progBase;  // le programme de nuanceurs de base
GLint locVertexBase = -1;
GLint locColorBase = -1;
GLint locmatrModelBase = -1;
GLint locmatrVisuBase = -1;
GLint locmatrProjBase = -1;

GLuint vao[NB_SHADERS];
GLuint vbo[5];
GLuint ubo[4];
GLuint vbosQuad[2]; /* Vertex & Tex Coord */
GLuint vboPacket;
GLuint vboHeightField;
GLuint vboDMM[2]; /* Vertex & Index */

// matrices de du pipeline graphique
MatricePipeline matrModel;
MatricePipeline matrVisu;
MatricePipeline matrProj;
MatricePipeline matrProjWide;

// les formes
FormeSphere *sphere = NULL, *sphereLumi = NULL;
FormeTheiere *theiere = NULL;
FormeTore *tore = NULL;
FormeCylindre *cylindre = NULL;
FormeCylindre *cone = NULL;

// variables pour définir le point de vue
double thetaCam = 0.0;        // angle de rotation de la caméra (coord. sphériques)
double phiCam = 0.0;          // angle de rotation de la caméra (coord. sphériques)
double distCam = 0.0;         // distance (coord. sphériques)

// variables d'état
bool enPerspective = false;   // indique si on est en mode Perspective (true) ou Ortho (false)
bool enmouvement = false;     // le modèle est en mouvement/rotation automatique ou non
bool afficheAxes = true;      // indique si on affiche les axes
GLenum modePolygone = GL_FILL; // comment afficher les polygones

// FBOs
FBO *posFBO;
FBO *heightFBO;
FBO *aaFBO;

// Terrain mesh size
const int terrainW = 1024;
const int terrainH = 1024;

// Wave Packets
Packets *packets;
int packetBudget = 10000;
/* Wave packets:
 * vec4: xy = position, zw = direction
 * vec4: x = amplitude, y = wavelength, z = phase offset, w = enveloppe size
 * vec4: for rendering x = center of wave bending circle*/
GLfloat packetData[PACKET_GPU_BUFFER_SIZE * 3 * 4];

int nIndexDMM = 0;

////////////////////////////////////////
// déclaration des variables globales //
////////////////////////////////////////

// partie 1: illumination
int modele = 1;                  // le modèle à afficher

// partie 3: texture
GLuint texTerrain = 0;
GLuint textureECHIQUIER = 0;

// définition des lumières
struct LightSourceParameters
{
   glm::vec4 ambient;
   glm::vec4 diffuse;
   glm::vec4 specular;
   glm::vec4 position;
   glm::vec3 spotDirection;
   float spotExposant;
   float spotAngle;            // ([0.0,90.0] ou 180.0)
   float constantAttenuation;
   float linearAttenuation;
   float quadraticAttenuation;
} LightSource[1] = { { glm::vec4( 1.0, 1.0, 1.0, 1.0 ),
                       glm::vec4( 1.0, 1.0, 1.0, 1.0 ),
                       glm::vec4( 1.0, 1.0, 1.0, 1.0 ),
                       glm::vec4( 4, 1, 15, 1.0 ),
                       glm::vec3( -5.0, -2.0, -10.0 ),
                       1.0,       // l'exposant du cône
                       15.0,      // l'angle du cône du spot
                       1., 0., 0. } };

// définition du matériau
struct MaterialParameters
{
   glm::vec4 emission;
   glm::vec4 ambient;
   glm::vec4 diffuse;
   glm::vec4 specular;
   float shininess;
} FrontMaterial = { glm::vec4( 0.0, 0.0, 0.0, 1.0 ),
                    glm::vec4( 0.1, 0.1, 0.1, 1.0 ),
                    glm::vec4( 1.0, 0.1, 1.0, 1.0 ),
                    glm::vec4( 1.0, 1.0, 1.0, 1.0 ),
                    100.0 };

struct LightModelParameters
{
   glm::vec4 ambient; // couleur ambiante
   int localViewer;   // doit-on prendre en compte la position de l'observateur? (local ou à l'infini)
   int twoSide;       // éclairage sur les deux côtés ou un seul?
} LightModel = { glm::vec4(0,0,0,1), false, false };

struct
{
   // partie 1: illumination
   int typeIllumination;     // 0:Lambert, 1:Gouraud, 2:Phong
   int utiliseBlinn;         // indique si on veut utiliser modèle spéculaire de Blinn ou Phong
   int utiliseDirect;        // indique si on utilise un spot style Direct3D ou OpenGL
   int afficheNormales;      // indique si on utilise les normales comme couleurs (utile pour le débogage)
   // partie 3: texture
   int texnumero;            // numéro de la texture appliquée
   int utiliseCouleur;       // doit-on utiliser la couleur de base de l'objet en plus de celle de la texture?
   int afficheTexelNoir;     // un texel noir doit-il être affiché 0:noir, 1:mi-coloré, 2:transparent?
} varsUnif = { 2, false, false, false,
               0, true, 0 };
// ( En glsl, les types 'bool' et 'int' sont de la même taille, ce qui n'est pas le cas en C++.
// Ci-dessus, on triche donc un peu en déclarant les 'bool' comme des 'int', mais ça facilite la
// copie directe vers le nuanceur où les variables seront bien de type 'bool'. )


/* Forward declarations */
void displayPacketOutlined(int count);
void addPacketDisplacement(int count);
void displayTerrain();
void displayMicroMesh();


void verifierAngles()
{
   if ( thetaCam > 360.0 )
      thetaCam -= 360.0;
   else if ( thetaCam < 0.0 )
      thetaCam += 360.0;

   const GLdouble MINPHI = -90.0, MAXPHI = 90.0;
   if ( phiCam > MAXPHI )
      phiCam = MAXPHI;
   else if ( phiCam < MINPHI )
      phiCam = MINPHI;
}

void calculerPhysique( )
{
   if ( enmouvement )
   {
      static int sensTheta = 1;
      static int sensPhi = 1;
      thetaCam += 0.3 * sensTheta;
      phiCam += 0.5 * sensPhi;
      //if ( thetaCam <= 0. || thetaCam >= 360.0 ) sensTheta = -sensTheta;
      if ( phiCam < -90.0 || phiCam > 90.0 ) sensPhi = -sensPhi;

      static int sensAngle = 1;
      LightSource[0].spotAngle += sensAngle * 0.3;
      if ( LightSource[0].spotAngle < 5.0 ) sensAngle = -sensAngle;
      if ( LightSource[0].spotAngle > 60.0 ) sensAngle = -sensAngle;

      // De temps à autre, alterner entre le modèle d'illumination: Lambert, Gouraud, Phong
      static float type = 0;
      type += 0.005;
      varsUnif.typeIllumination = fmod(type,3);
   }

   verifierAngles();
}


void updatePackets()
{
    // Compute wave packets
    packets->AdvectWavePackets(INIT_WAVE_SPEED);

    // TODO Setup wide projection for InitiateWaveField (RasterizeWaveMeshPosition)

    heightFBO->CommencerCapture();
    int displayedPackets = 0;
    int packetChunk =0;
    /* Standard wave packets */
    for (int i = 0; i < packets->m_usedPackets; ++i) {
        int pk = packets->m_usedPacket[i];
        /* Test for 3rd vertex (sliding point) */
        if (!packets->m_packet[pk].use3rd) {
            /* Position */
            packetData[packetChunk++] = packets->m_packet[pk].midPos.x();
            packetData[packetChunk++] = packets->m_packet[pk].midPos.y();
            /* Direction */
            packetData[packetChunk++] = packets->m_packet[pk].travelDir.x();
            packetData[packetChunk++] = packets->m_packet[pk].travelDir.y();
            /* Att1 */
            packetData[packetChunk++] = packets->m_packet[pk].ampOld;
            packetData[packetChunk++] = 2.0f * M_PI / packets->m_packet[pk].k;
            packetData[packetChunk++] = packets->m_packet[pk].phase;
            packetData[packetChunk++] = packets->m_packet[pk].envelope;
            /* Att2 */
            packetData[packetChunk++] = packets->m_packet[pk].bending;
            packetData[packetChunk++] = 0.0;
            packetData[packetChunk++] = 0.0;
            packetData[packetChunk++] = 0.0;
            displayedPackets++;
            if (packetChunk >= PACKET_GPU_BUFFER_SIZE * 3 * 4) {
                glBindBuffer(GL_ARRAY_BUFFER, vboPacket);
                /* TODO Use Buffer mapping for better performance */
                glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData);
                glBindBuffer(GL_ARRAY_BUFFER, 0);
                //displayPacketOutlined(packetChunk / 12);
                /* TODO EvaluatePackets(packetChunk) */
                addPacketDisplacement(packetChunk / 12);
                packetChunk = 0;
            }
        }
    }
    // printf("PacketData[0] = %f , %f\n", packetData[0], packetData[1]);
    /* Ghost packets */
    for (int i = 0; i < packets->m_usedGhosts; ++i) {
        int pk = packets->m_usedGhost[i];
        /* Position */
        packetData[packetChunk++] = packets->m_ghostPacket[pk].pos.x();
        packetData[packetChunk++] = packets->m_ghostPacket[pk].pos.y();
        /* Direction */
        packetData[packetChunk++] = packets->m_ghostPacket[pk].dir.x();
        packetData[packetChunk++] = packets->m_ghostPacket[pk].dir.y();
        /* Att1 */
        packetData[packetChunk++] = packets->m_ghostPacket[pk].ampOld;
        packetData[packetChunk++] = 2.0f * M_PI / packets->m_ghostPacket[pk].k;
        packetData[packetChunk++] = packets->m_ghostPacket[pk].phase;
        packetData[packetChunk++] = packets->m_ghostPacket[pk].envelope;
        /* Att2 */
        packetData[packetChunk++] = packets->m_ghostPacket[pk].bending;
        packetData[packetChunk++] = 0.0;
        packetData[packetChunk++] = 0.0;
        packetData[packetChunk++] = 0.0;
        displayedPackets++;
        if (packetChunk >= PACKET_GPU_BUFFER_SIZE * 3 * 4) {
            glBindBuffer(GL_ARRAY_BUFFER, vboPacket);
            glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            //displayPacketOutlined();
            /* TODO EvaluatePackets(packetChunk) */
            addPacketDisplacement(packetChunk / 12);
            packetChunk = 0;
        }
    }
    glBindBuffer(GL_ARRAY_BUFFER, vboPacket);
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    //displayPacketOutlined(packetChunk / 12);
    /* TODO EvaluatePackets(packetChunk) */
    addPacketDisplacement(packetChunk / 12);
    heightFBO->TerminerCapture();
    /* TODO DisplayScene */
    /* TODO Get camera center */
}


void chargerTextures()
{
   unsigned char *pixels;
   GLsizei largeur, hauteur;
   if ( ( pixels = ChargerImage( WATER_TERRAIN_FILE, largeur, hauteur ) ) != NULL )
   {
      glGenTextures( 1, &texTerrain );
      glBindTexture( GL_TEXTURE_2D, texTerrain );
      glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, largeur, hauteur, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
      glBindTexture( GL_TEXTURE_2D, 0 );
      delete[] pixels;
   }

   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
}


/* Create program and link it
 * Input : filenames for vertex, geometry and fragment shader, or NULL*/
GLuint createShader(const GLchar *shaders[3])
{
    GLuint prog;
    GLenum shaderType[3] = {
        GL_VERTEX_SHADER,
        GL_GEOMETRY_SHADER,
        GL_FRAGMENT_SHADER
    };
    prog = glCreateProgram();
    for (int i = 0; i < 3; ++i) {
        if (shaders[i] != NULL) {
            printf("Compiling %s ...\n", shaders[i]);
            const GLchar *shaderStr = ProgNuanceur::lireNuanceur(shaders[i]);
            if (shaderStr == NULL)
                break;
            GLuint s = glCreateShader(shaderType[i]);
            glShaderSource( s, 1, &shaderStr, NULL );
            glCompileShader( s );
            glAttachShader( prog, s );
            ProgNuanceur::afficherLogCompile( s );
            delete [] shaderStr;
        }
    }
    glLinkProgram(prog);
    ProgNuanceur::afficherLogLink(prog);
    return prog;
}


GLuint
getloc(GLuint prog, const GLchar *name, const int type)
{
	GLuint loc;
	switch (type) {
	case LocAttrib:
		loc = glGetAttribLocation(prog, name);
		break;
	case LocUniform:
		loc = glGetUniformLocation(prog, name);
		break;
	}
	if (loc == -1)
		fprintf(stderr, "Cannot find location for %s\n", name);
	return loc;
}


void chargerNuanceurs()
{
   // charger le nuanceur de base
   {
      // créer le programme
      progBase = glCreateProgram();

      // attacher le nuanceur de sommets
      {
         GLuint nuanceurObj = glCreateShader( GL_VERTEX_SHADER );
         glShaderSource( nuanceurObj, 1, &ProgNuanceur::chainesSommetsMinimal, NULL );
         glCompileShader( nuanceurObj );
         glAttachShader( progBase, nuanceurObj );
         ProgNuanceur::afficherLogCompile( nuanceurObj );
      }
      // attacher le nuanceur de fragments
      {
         GLuint nuanceurObj = glCreateShader( GL_FRAGMENT_SHADER );
         glShaderSource( nuanceurObj, 1, &ProgNuanceur::chainesFragmentsMinimal, NULL );
         glCompileShader( nuanceurObj );
         glAttachShader( progBase, nuanceurObj );
         ProgNuanceur::afficherLogCompile( nuanceurObj );
      }

      // faire l'édition des liens du programme
      glLinkProgram( progBase );

      ProgNuanceur::afficherLogLink( progBase );
      // demander la "Location" des variables
      locVertexBase = getloc( progBase, "Vertex", LocAttrib );
      locColorBase = getloc( progBase, "Color", LocAttrib );
      locmatrModelBase = getloc( progBase, "matrModel", LocUniform );
      locmatrVisuBase = getloc( progBase, "matrVisu", LocUniform );
      locmatrProjBase = getloc( progBase, "matrProj", LocUniform );
   }

   // Load RasterizeWaveMeshPosition shader
   {
      // créer le programme
      const GLchar *shaders[3] = {"rasterizeWaveMeshPosition.vert", NULL, "rasterizeWaveMeshPosition.frag"};
      progRasterizeWaveMeshPosition = createShader(shaders);
      // demander la "Location" des variables
      locVertexRWMP = getloc( progRasterizeWaveMeshPosition, "Vertex" , LocAttrib);
      locTexCoordRWMP = getloc( progRasterizeWaveMeshPosition, "TexCoord" , LocAttrib);
      locmatrModelRWMP = getloc( progRasterizeWaveMeshPosition, "matrModel" , LocUniform);
      locmatrVisuRWMP = getloc( progRasterizeWaveMeshPosition, "matrVisu" , LocUniform);
      locmatrProjRWMP = getloc( progRasterizeWaveMeshPosition, "matrProj" , LocUniform);
   }

   // Load AddPacketDisplacement shader
   {
      // créer le programme
      const GLchar *shaders[3] = {"addPacketDisplacement.vert", "addPacketDisplacement.geom", "addPacketDisplacement.frag"};
      progAddPacketDisplacement = createShader(shaders);
      // demander la "Location" des variables
      locPosAPD = getloc( progAddPacketDisplacement, "Pos" , LocAttrib);
      locAtt1APD = getloc( progAddPacketDisplacement, "Att1" , LocAttrib);
      locAtt2APD = getloc( progAddPacketDisplacement, "Att2" , LocAttrib);
      locmatrModelAPD = getloc( progAddPacketDisplacement, "matrModel" , LocUniform);
      locmatrVisuAPD = getloc( progAddPacketDisplacement, "matrVisu" , LocUniform);
      locmatrProjAPD = getloc( progAddPacketDisplacement, "matrProj" , LocUniform);
      locTexAPD = getloc( progAddPacketDisplacement, "tex" , LocUniform);
   }

   // Load DisplayPacketOutlined shader
   {
      const GLchar *shaders[3] = {"displayPacketOutlined.vert", "displayPacketOutlined.geom", "displayPacketOutlined.frag"};
      progDisplayPacketOutlined = createShader(shaders);
      locPosDPO = getloc( progDisplayPacketOutlined, "Pos" , LocAttrib);
      locAtt1DPO = getloc( progDisplayPacketOutlined, "Att1" , LocAttrib);
      locAtt2DPO = getloc( progDisplayPacketOutlined, "Att2" , LocAttrib);
      locmatrModelDPO = getloc( progDisplayPacketOutlined, "matrModel" , LocUniform);
      locmatrVisuDPO = getloc( progDisplayPacketOutlined, "matrVisu" , LocUniform);
      locmatrProjDPO = getloc( progDisplayPacketOutlined, "matrProj" , LocUniform);
      locTexDPO = getloc( progDisplayPacketOutlined, "tex" , LocUniform);
   }

   // Load DisplayMicroMesh shader
   {
      const GLchar *shaders[3] = {"displayMicroMesh.vert", "displayMicroMesh.geom", "displayMicroMesh.frag"};
      progDisplayMicroMesh = createShader(shaders);
      locVertexDMM = getloc( progDisplayMicroMesh, "Vertex" , LocAttrib);
      locTexCoordDMM = getloc( progDisplayMicroMesh, "TexCoord" , LocAttrib);
      locmatrModelDMM = getloc( progDisplayMicroMesh, "matrModel" , LocUniform);
      locmatrVisuDMM = getloc( progDisplayMicroMesh, "matrVisu" , LocUniform);
      locmatrProjDMM = getloc( progDisplayMicroMesh, "matrProj" , LocUniform);
      locTerrainTexDMM = getloc( progDisplayMicroMesh, "terrain" , LocUniform);
      locWaterPosTexDMM = getloc( progDisplayMicroMesh, "waterPos" , LocUniform);
      locWaterHeightTexDMM = getloc( progDisplayMicroMesh, "waterHeight" , LocUniform);
   }

   // Load DisplayTerrain shader
   {
      const GLchar *shaders[3] = {"displayTerrain.vert", NULL, "displayTerrain.frag"};
      progDisplayTerrain = createShader(shaders);
      locVertexDT = getloc( progDisplayTerrain, "Vertex" , LocAttrib);
      locmatrModelDT = getloc( progDisplayTerrain, "matrModel" , LocUniform);
      locmatrVisuDT = getloc( progDisplayTerrain, "matrVisu" , LocUniform);
      locmatrProjDT = getloc( progDisplayTerrain, "matrProj" , LocUniform);
      locTerrainTexDT = getloc( progDisplayTerrain, "terrain" , LocUniform);
   }

   // Load RenderAA shader
   {
      const GLchar *shaders[3] = {"renderAA.vert", NULL, "RenderAA.frag"};
      progRenderAA = createShader(shaders);
      locVertexRAA = getloc( progRenderAA, "Vertex" , LocAttrib);
      locTexCoordRAA = getloc( progRenderAA, "TexCoord" , LocAttrib);
      locmatrModelRAA = getloc( progRenderAA, "matrModel" , LocUniform);
      locmatrVisuRAA = getloc( progRenderAA, "matrVisu" , LocUniform);
      locmatrProjRAA = getloc( progRenderAA, "matrProj" , LocUniform);
      locTexRAA = getloc( progRenderAA, "tex" , LocUniform);
   }
}


// Create a screen space quad
void initQuad()
{
   GLfloat vertices[3*2*2] = {
      -1.0, -1.0,    1.0, -1.0,   -1.0,  1.0,
       1.0, -1.0,    1.0,  1.0,   -1.0,  1.0
   };
   GLfloat texcoords[3*2*2] = {
      0.0, 1.0,   1.0, 1.0,   0.0, 0.0,
      1.0, 1.0,   1.0, 0.0,   0.0, 0.0
   };

   // allouer les objets OpenGL
   /* TODO Add support for RenderAA shader */
   glGenBuffers( 2, vbosQuad );

   /* Prepare VAO for RasterizeWaveMeshPosition shader */
   glBindVertexArray(vao[RWMP_SHADER]);
   // Bind vertices VBO
   glBindBuffer( GL_ARRAY_BUFFER, vbosQuad[0] );
   glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW );
   glVertexAttribPointer( locVertexRWMP, 2, GL_FLOAT, GL_FALSE, 0, 0 );
   glEnableVertexAttribArray(locVertexRWMP);
   // Bind texture coord VBO
   glBindBuffer( GL_ARRAY_BUFFER, vbosQuad[1] );
   glBufferData( GL_ARRAY_BUFFER, sizeof(texcoords), texcoords, GL_STATIC_DRAW );
   glVertexAttribPointer( locTexCoordRWMP, 2, GL_FLOAT, GL_FALSE, 0, 0 );
   glEnableVertexAttribArray(locTexCoordRWMP);

   /* Prepare VAO for RenderAA shader */
   glBindVertexArray(vao[RAA_SHADER]);
   // Bind vertices VBO
   glBindBuffer( GL_ARRAY_BUFFER, vbosQuad[0] );
   glVertexAttribPointer( locVertexRAA, 2, GL_FLOAT, GL_FALSE, 0, 0 );
   glEnableVertexAttribArray(locVertexRAA);
   // Bind texture coord VBO
   glBindBuffer( GL_ARRAY_BUFFER, vbosQuad[1] );
   glVertexAttribPointer( locTexCoordRAA, 2, GL_FLOAT, GL_FALSE, 0, 0 );
   glEnableVertexAttribArray(locTexCoordRAA);
}


// Create the buffer to store wave packets
void initPacketMesh()
{
    glGenBuffers(1, &vboPacket);

    glBindVertexArray(vao[APD_SHADER]);
    glBindBuffer(GL_ARRAY_BUFFER, vboPacket);
    glBufferData(GL_ARRAY_BUFFER, sizeof(packetData), NULL, GL_DYNAMIC_DRAW);
    glVertexAttribPointer(locPosAPD, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 12, (void*)0);
    glVertexAttribPointer(locAtt1APD, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 12, (void*)4);
    glVertexAttribPointer(locAtt2APD, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 12, (void*)8);
    glEnableVertexAttribArray(locPosAPD);
    glEnableVertexAttribArray(locAtt1APD);
    glEnableVertexAttribArray(locAtt2APD);

    glBindVertexArray(vao[DPO_SHADER]);
    glBindBuffer(GL_ARRAY_BUFFER, vboPacket);
    /* No need to initialize the buffer a second time */
    glVertexAttribPointer(locPosDPO, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 12, (void*)0);
    glVertexAttribPointer(locAtt1DPO, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 12, (void*)4);
    glVertexAttribPointer(locAtt2DPO, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 12, (void*)8);
    glEnableVertexAttribArray(locPosDPO);
    glEnableVertexAttribArray(locAtt1DPO);
    glEnableVertexAttribArray(locAtt2DPO);

    glBindVertexArray(0);
}


void initHeightFieldMesh()
{
    GLfloat *data = new GLfloat[terrainW * terrainH * 6 * 2];
    /* TODO Benchmark usefullness of parallel for */
    #pragma omp parallel for
    for (int y=0; y<terrainH; ++y) {
        for (int x=0; x<terrainW; ++x) {
            data[(y*terrainW + x) * 12 + 0] = 2.0 * (float)(x) / terrainW - 1.0;
            data[(y*terrainW + x) * 12 + 1] = 2.0 * (float)(y) / terrainH - 1.0;
            data[(y*terrainW + x) * 12 + 2] = 2.0 * (float)(x) / terrainW - 1.0;
            data[(y*terrainW + x) * 12 + 3] = 2.0 * (float)(y+1) / terrainH - 1.0;
            data[(y*terrainW + x) * 12 + 4] = 2.0 * (float)(x+1) / terrainW - 1.0;
            data[(y*terrainW + x) * 12 + 5] = 2.0 * (float)(y) / terrainH - 1.0;
            data[(y*terrainW + x) * 12 + 6] = 2.0 * (float)(x) / terrainW - 1.0;
            data[(y*terrainW + x) * 12 + 7] = 2.0 * (float)(y+1) / terrainH - 1.0;
            data[(y*terrainW + x) * 12 + 8] = 2.0 * (float)(x+1) / terrainW - 1.0;
            data[(y*terrainW + x) * 12 + 9] = 2.0 * (float)(y+1) / terrainH - 1.0;
            data[(y*terrainW + x) * 12 + 10] = 2.0 * (float)(x+1) / terrainW - 1.0;
            data[(y*terrainW + x) * 12 + 11] = 2.0 * (float)(y) / terrainH - 1.0;
        }
    }

    glGenBuffers(1, &vboHeightField);
    glBindVertexArray(vao[DT_SHADER]);
    glBindBuffer(GL_ARRAY_BUFFER, vboHeightField);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * terrainW * terrainH * 12, data, GL_STATIC_DRAW);
    glVertexAttribPointer(locVertexDT, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(locVertexDT);

    glBindVertexArray(0);
    delete [] data;
}


// initialisation d'openGL
void initialiser()
{
   // donner l'orientation du modèle
   thetaCam = 0.0;
   phiCam = 0.0;
   distCam = 90.0;

   // Create FBOs
   posFBO = new FBO();
   heightFBO = new FBO();
   aaFBO = new FBO();

   // Create Packets
   packets = new Packets(packetBudget);

   // couleur de l'arrière-plan
   glClearColor( 0.5, 0.6, 0.8, 0.0 );

   // activer les etats openGL
   glEnable( GL_DEPTH_TEST );

   // charger les textures
   chargerTextures();

   // allouer les UBO pour les variables uniformes
   glGenBuffers( 4, ubo );
   glGenVertexArrays(NB_SHADERS, vao);

   // charger les nuanceurs
   chargerNuanceurs();

   // Initialize VBOs
   initQuad();
   initPacketMesh();
   initHeightFieldMesh();
}

void conclure()
{
   glUseProgram( 0 );
   glDeleteVertexArrays( NB_SHADERS, vao );
   glDeleteBuffers( 4, vbo );
   glDeleteBuffers( 4, ubo );
   delete sphere;
   delete sphereLumi;
   delete theiere;
   delete tore;
   delete cylindre;
   delete cone;
   delete posFBO;
   delete heightFBO;
   delete aaFBO;
   delete packets;
}

/* TODO rename according to convention */
void rasterizeWaveMeshPosition()
{
    glUseProgram(progRasterizeWaveMeshPosition);
    glUniformMatrix4fv( locmatrProjRWMP, 1, GL_FALSE, matrProjWide );
    glUniformMatrix4fv( locmatrVisuRWMP, 1, GL_FALSE, matrVisu );
    glUniformMatrix4fv( locmatrModelRWMP, 1, GL_FALSE, matrModel );
    glBindVertexArray(vao[RWMP_SHADER]);
    glDrawArrays(GL_TRIANGLES, 0, 6);
    glBindVertexArray(0);
    glUseProgram(0);
}

void displayPacketOutlined(int count)
{
    glUseProgram(progDisplayPacketOutlined);
    glBindVertexArray(vao[DPO_SHADER]);
    glUniformMatrix4fv(locmatrModelDPO, 1, GL_FALSE, matrModel);
    glUniformMatrix4fv(locmatrVisuDPO, 1, GL_FALSE, matrVisu);
    glUniformMatrix4fv(locmatrProjDPO, 1, GL_FALSE, matrProj);
    glDrawArrays(GL_POINTS, 0, count);
    glBindVertexArray(0);
    glUseProgram(0);
}


void addPacketDisplacement(int count)
{
    glUseProgram(progAddPacketDisplacement);
    glBindVertexArray(vao[APD_SHADER]);
    glUniformMatrix4fv(locmatrModelAPD, 1, GL_FALSE, matrModel);
    glUniformMatrix4fv(locmatrVisuAPD, 1, GL_FALSE, matrVisu);
    glUniformMatrix4fv(locmatrProjAPD, 1, GL_FALSE, matrProj);
    glDrawArrays(GL_POINTS, 0, count);
    glBindVertexArray(0);
    glUseProgram(0);
}


void displayTerrain()
{
    glUseProgram(progDisplayTerrain);
    glBindVertexArray(vao[DT_SHADER]);
    glUniformMatrix4fv(locmatrModelDT, 1, GL_FALSE, matrModel);
    glUniformMatrix4fv(locmatrVisuDT, 1, GL_FALSE, matrVisu);
    glUniformMatrix4fv(locmatrProjDT, 1, GL_FALSE, matrProj);
    glActiveTexture(GL_TEXTURE0); /* Default value, can be omitted */
    glBindTexture(GL_TEXTURE_2D, texTerrain);
    glUniform1i(locTerrainTexDT, 0);
    glDrawArrays(GL_TRIANGLES, 0, terrainW * terrainH * 12);
    glBindVertexArray(0);
    glUseProgram(0);
}


void displayMicroMesh()
{
    glUseProgram(progDisplayMicroMesh);
    glBindVertexArray(vao[DMM_SHADER]);
    glUniformMatrix4fv(locmatrModelDMM, 1, GL_FALSE, matrModel);
    glUniformMatrix4fv(locmatrVisuDMM, 1, GL_FALSE, matrVisu);
    glUniformMatrix4fv(locmatrProjDMM, 1, GL_FALSE, matrProj);
    /* Setup textures */
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texTerrain);
    glUniform1i(locTerrainTexDMM, 0);
    glActiveTexture(GL_TEXTURE0 + 1);
    glBindTexture(GL_TEXTURE_2D, posFBO->GetRGBTex());
    glUniform1i(locWaterPosTexDMM, 1);
    glActiveTexture(GL_TEXTURE0 + 2);
    glBindTexture(GL_TEXTURE_2D, heightFBO->GetRGBTex());
    glUniform1i(locWaterHeightTexDMM, 2);

    glDrawElements(GL_TRIANGLES, nIndexDMM, GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);
    glUseProgram(0);
}


void afficherModele()
{
   // Dessiner le modèle
   matrModel.PushMatrix(); {

      // appliquer les rotations
      matrModel.Rotate( phiCam, -1.0, 0.0, 0.0 );
      matrModel.Rotate( thetaCam, 0.0, -1.0, 0.0 );

      // mise à l'échelle
      matrModel.Scale( 5.0, 5.0, 5.0 );

      posFBO->CommencerCapture();
      rasterizeWaveMeshPosition();
      posFBO->TerminerCapture();

      updatePackets();
      displayTerrain();
      displayMicroMesh();
      // displayTerrain();
   } matrModel.PopMatrix();
}


// fonction d'affichage
void FenetreTP::afficherScene()
{
   // effacer l'ecran et le tampon de profondeur
   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

   glUseProgram( progBase );

   // définir le pipeline graphique
   matrProj.Perspective( 45.0, (GLdouble)largeur_ / (GLdouble)hauteur_, 0.5, 4000.0 );
   matrProjWide.Perspective( 60.0, (GLdouble)largeur_ / (GLdouble)hauteur_, 0.1, 15000.0 );
   glUniformMatrix4fv( locmatrProjBase, 1, GL_FALSE, matrProj );

   //matrVisu.LookAt( 0.0, 3.0, distCam,  0.0, 0.0, 0.0,  0.0, 1.0, 0.0 );
   matrVisu.LookAt( 10.17, 22.13, 59.49,  10.17, 21.66, 58.61,  0.0, 1.0, 0.0 );

   glUniformMatrix4fv( locmatrVisuBase, 1, GL_FALSE, matrVisu );

   matrModel.LoadIdentity();
   glUniformMatrix4fv( locmatrModelBase, 1, GL_FALSE, matrModel );

   // afficher les axes
   if ( afficheAxes ) FenetreTP::afficherAxes( 1.0 );

   afficherModele();
}

// fonction de redimensionnement de la fenêtre graphique
void FenetreTP::redimensionner( GLsizei w, GLsizei h )
{
   std::cout << "Resizing to " << w << "×" << h << std::endl;
   /* FIXME Is this function called on program start ? */
   glViewport( 0, 0, w, h );
   posFBO->Liberer();
   posFBO->Init(WAVETEX_WIDTH_FACTOR * w, WAVETEX_HEIGHT_FACTOR * h);
   heightFBO->Liberer();
   heightFBO->Init(WAVETEX_WIDTH_FACTOR * w, WAVETEX_HEIGHT_FACTOR * h);
   aaFBO->Liberer();
   aaFBO->Init(AA_OVERSAMPLE_FACTOR * w, AA_OVERSAMPLE_FACTOR * h);

   /* Create/resize display mesh */
   int meshW = WAVEMESH_WIDTH_FACTOR * w; /*Ça fait un gros mouton */
   int meshH = WAVEMESH_HEIGHT_FACTOR * h;
   GLfloat *mesh = new GLfloat[meshW * meshH * 2];
   nIndexDMM = 3 * 2 * (meshW - 1) * (meshH -1);
   GLuint *index = new GLuint[nIndexDMM];
   #pragma omp parallel for
   for (int y = 0; y < meshH; ++y) {
       for (int x = 0; x < meshW; ++x) {
           mesh[(y * meshW + x) * 2 + 0] = (x + 0.5) / meshW;
           mesh[(y * meshW + x) * 2 + 1] = (y + 0.5) / meshH;
       }
   }
   #pragma omp parallel for
   for (int y = 0; y < meshH - 1; ++y) {
       for (int x = 0; x < meshW - 1; ++x) {
           index[(y * (meshW - 1) + x) * 6 + 0] = y * meshW + x;
           index[(y * (meshW - 1) + x) * 6 + 1] = y * meshW + x + 1;
           index[(y * (meshW - 1) + x) * 6 + 2] = (y + 1) * meshW + x;
           index[(y * (meshW - 1) + x) * 6 + 3] = y * meshW + x + 1;
           index[(y * (meshW - 1) + x) * 6 + 4] = (y + 1) * meshW + x + 1;
           index[(y * (meshW - 1) + x) * 6 + 5] = (y + 1) * meshW + x;
       }
   }
   glGenBuffers(2, vboDMM);
   glBindVertexArray(vao[DMM_SHADER]);
   glBindBuffer(GL_ARRAY_BUFFER, vboDMM[0]);
   glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * meshW * meshH * 2, mesh, GL_STATIC_DRAW);
   glVertexAttribPointer(locVertexDMM, 2, GL_FLOAT, GL_FALSE, 0, 0);
   glEnableVertexAttribArray(locVertexDMM);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboDMM[1]);
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * nIndexDMM, index, GL_STATIC_DRAW);
   glBindVertexArray(0);

   delete [] mesh;
   delete [] index;
}

static void echoEtats( )
{
   static std::string illuminationStr[] = { "0:Lambert", "1:Gouraud", "2:Phong" };
   static std::string reflexionStr[] = { "0:Phong", "1:Blinn" };
   static std::string spotStr[] = { "0:OpenGL", "1:Direct3D" };
   std::cout << " modèle d'illumination= " << illuminationStr[varsUnif.typeIllumination]
             << ", refléxion spéculaire= " << reflexionStr[varsUnif.utiliseBlinn]
             << ", spot= " << spotStr[varsUnif.utiliseDirect]
             << std::endl;
}

// fonction de gestion du clavier
void FenetreTP::clavier( TP_touche touche )
{
   // traitement des touches q et echap
   switch ( touche )
   {
   case TP_ECHAP:
   case TP_q: // Quitter l'application
      quit();
      break;

   case TP_x: // Activer/désactiver l'affichage des axes
      afficheAxes = !afficheAxes;
      std::cout << "// Affichage des axes ? " << ( afficheAxes ? "OUI" : "NON" ) << std::endl;
      break;

   case TP_v: // Recharger les fichiers des nuanceurs et recréer le programme
      chargerNuanceurs();
      std::cout << "// Recharger nuanceurs" << std::endl;
      break;

   case TP_p: // Permuter la projection: perspective ou orthogonale
      enPerspective = !enPerspective;
      break;

   case TP_i: // Alterner entre le modèle d'illumination: Lambert, Gouraud, Phong
      if ( ++varsUnif.typeIllumination > 2 ) varsUnif.typeIllumination = 0;
      echoEtats( );
      break;

   case TP_r: // Alterner entre le modèle de réflexion spéculaire: Phong, Blinn
       // Send one wave front
       packets->CreateCircularWavefront(0.0, 0.0, 2.0, 0.2, 1.0, 10000);
       printf("Sending a circular wavefront...\n");
      break;

   case TP_s: // Alterner entre le modèle de spot: OpenGL, Direct3D
      varsUnif.utiliseDirect = !varsUnif.utiliseDirect;
      echoEtats( );
      break;

   //case TP_l: // Alterner entre une caméra locale à la scène ou distante (localViewer)
   //   LightModel.localViewer = !LightModel.localViewer;
   //   std::cout << " localViewer=" << LightModel.localViewer << std::endl;
   //   break;

   case TP_a: // Incrémenter l'angle du cône du spot
   case TP_EGAL:
   case TP_PLUS:
      LightSource[0].spotAngle += 2.0;
      if ( LightSource[0].spotAngle > 90.0 ) LightSource[0].spotAngle = 90.0;
      std::cout <<  " spotAngle=" << LightSource[0].spotAngle << std::endl;
      break;
   case TP_z: // Décrémenter l'angle du cône du spot
   case TP_MOINS:
   case TP_SOULIGNE:
      LightSource[0].spotAngle -= 2.0;
      if ( LightSource[0].spotAngle < 0.0 ) LightSource[0].spotAngle = 0.0;
      std::cout <<  " spotAngle=" << LightSource[0].spotAngle << std::endl;
      break;

   case TP_d: // Incrémenter l'exposant du spot
   case TP_BARREOBLIQUE:
      LightSource[0].spotExposant += 0.3;
      if ( LightSource[0].spotExposant > 89.0 ) LightSource[0].spotExposant = 89.0;
      std::cout <<  " spotExposant=" << LightSource[0].spotExposant << std::endl;
      break;
   case TP_e: // Décrémenter l'exposant du spot
   case TP_POINT:
      LightSource[0].spotExposant -= 0.3;
      if ( LightSource[0].spotExposant < 0.0 ) LightSource[0].spotExposant = 0.0;
      std::cout <<  " spotExposant=" << LightSource[0].spotExposant << std::endl;
      break;

   case TP_j: // Incrémenter le coefficient de brillance
   case TP_CROCHETDROIT:
      FrontMaterial.shininess *= 1.1;
      std::cout << " FrontMaterial.shininess=" << FrontMaterial.shininess << std::endl;
      break;
   case TP_u: // Décrémenter le coefficient de brillance
   case TP_CROCHETGAUCHE:
      FrontMaterial.shininess /= 1.1; if ( FrontMaterial.shininess < 0.0 ) FrontMaterial.shininess = 0.0;
      std::cout << " FrontMaterial.shininess=" << FrontMaterial.shininess << std::endl;
      break;

   case TP_DROITE:
      LightSource[0].position.x += 0.3;
      break;
   case TP_GAUCHE:
      LightSource[0].position.x -= 0.3;
      break;
   case TP_BAS:
      LightSource[0].position.y += 0.3;
      break;
   case TP_HAUT:
      LightSource[0].position.y -= 0.3;
      break;

   case TP_FIN:
      LightSource[0].spotDirection.x += 0.6;
      break;
   case TP_DEBUT:
      LightSource[0].spotDirection.x -= 0.6;
      break;
   case TP_PAGEPREC:
      LightSource[0].spotDirection.y += 0.6;
      break;
   case TP_PAGESUIV:
      LightSource[0].spotDirection.y -= 0.6;
      break;

   case TP_m: // Choisir le modèle affiché: cube, tore, sphère, théière, cylindre, cône
      if ( ++modele > 6 ) modele = 1;
      std::cout << " modele=" << modele << std::endl;
      break;

   case TP_0:
      thetaCam = 0.0; phiCam = 0.0; distCam = 30.0; // placer les choses afin d'avoir une belle vue
      break;

   case TP_t: // Choisir la texture utilisée: aucune, dé, échiquier
      varsUnif.texnumero++;
      if ( varsUnif.texnumero > 2 ) varsUnif.texnumero = 0;
      std::cout << " varsUnif.texnumero=" << varsUnif.texnumero << std::endl;
      break;

   // case TP_c: // Changer l'affichage de l'objet texturé avec couleurs ou sans couleur
   //    varsUnif.utiliseCouleur = !varsUnif.utiliseCouleur;
   //    std::cout << " utiliseCouleur=" << varsUnif.utiliseCouleur << std::endl;
   //    break;

   case TP_o: // Changer l'affichage des texels noirs (noir, mi-coloré, transparent)
      varsUnif.afficheTexelNoir++;
      if ( varsUnif.afficheTexelNoir > 2 ) varsUnif.afficheTexelNoir = 0;
      std::cout << " afficheTexelNoir=" << varsUnif.afficheTexelNoir << std::endl;
      break;

   case TP_g: // Permuter l'affichage en fil de fer ou plein
      modePolygone = ( modePolygone == GL_FILL ) ? GL_LINE : GL_FILL;
      glPolygonMode( GL_FRONT_AND_BACK, modePolygone );
      break;

   case TP_n: // Utiliser ou non les normales calculées comme couleur (pour le débogage)
      varsUnif.afficheNormales = !varsUnif.afficheNormales;
      break;

   case TP_ESPACE: // Permuter la rotation automatique du modèle
      enmouvement = !enmouvement;
      break;

   default:
      std::cout << " touche inconnue : " << (char) touche << std::endl;
      imprimerTouches();
      break;
   }

}

// fonction callback pour un clic de souris
int dernierX = 0; // la dernière valeur en X de position de la souris
int dernierY = 0; // la derniere valeur en Y de position de la souris
static enum { deplaceCam, deplaceSpotDirection, deplaceSpotPosition } deplace = deplaceCam;
static bool pressed = false;
void FenetreTP::sourisClic( int button, int state, int x, int y )
{
   pressed = ( state == TP_PRESSE );
   if ( pressed )
   {
      // on vient de presser la souris
      dernierX = x;
      dernierY = y;
      switch ( button )
      {
      case TP_BOUTON_GAUCHE: // Tourner l'objet
         deplace = deplaceCam;
         break;
      case TP_BOUTON_MILIEU: // Modifier l'orientation du spot
         deplace = deplaceSpotDirection;
         break;
      case TP_BOUTON_DROIT: // Déplacer la lumière
         deplace = deplaceSpotPosition;
         break;
      }
   }
   else
   {
      // on vient de relâcher la souris
   }
}

void FenetreTP::sourisWheel( int x, int y ) // Changer la taille du spot
{
   const int sens = +1;
   LightSource[0].spotAngle += sens*y;
   if ( LightSource[0].spotAngle > 90.0 ) LightSource[0].spotAngle = 90.0;
   if ( LightSource[0].spotAngle < 0.0 ) LightSource[0].spotAngle = 0.0;
   std::cout <<  " spotAngle=" << LightSource[0].spotAngle << std::endl;
}

// fonction de mouvement de la souris
void FenetreTP::sourisMouvement( int x, int y )
{
   if ( pressed )
   {
      int dx = x - dernierX;
      int dy = y - dernierY;
      switch ( deplace )
      {
      case deplaceCam:
         thetaCam -= dx / 3.0;
         phiCam   -= dy / 3.0;
         break;
      case deplaceSpotDirection:
         LightSource[0].spotDirection.x += 0.06 * dx;
         LightSource[0].spotDirection.y -= 0.06 * dy;
         // std::cout << " LightSource[0].spotDirection=" << glm::to_string(LightSource[0].spotDirection) << std::endl;
         break;
      case deplaceSpotPosition:
         LightSource[0].position.x += 0.03 * dx;
         LightSource[0].position.y -= 0.03 * dy;
         // std::cout << " LightSource[0].position=" << glm::to_string(LightSource[0].position) << std::endl;
         //glm::vec3 ecranPos( x, hauteur_-y, ecranLumi[2] );
         //LightSource[0].position = glm::vec4(glm::unProject( ecranPos, VM, P, cloture ), 1.0);
         break;
      }

      dernierX = x;
      dernierY = y;

      verifierAngles();
   }
}

int main( int argc, char *argv[] )
{
   // créer une fenêtre
   FenetreTP fenetre( "INF2705 TP" );

   // allouer des ressources et définir le contexte OpenGL
   initialiser();

   bool boucler = true;
   while ( boucler )
   {
      // mettre à jour la physique
      calculerPhysique( );

      // affichage
      fenetre.afficherScene();
      fenetre.swap();

      // récupérer les événements et appeler la fonction de rappel
      boucler = fenetre.gererEvenement();
   }

   // détruire les ressources OpenGL allouées
   conclure();

   return 0;
}