Nettoyage du code

addPacketDisplacement.vert

@@ -19,7 +19,8 @@ out Attribs {
 
 void main(void)
 {
-    Out.Pos = Pos;
+    /* The coordinate inversion compensate for Direct3D flipped drawing coordinates */
+    Out.Pos = Pos * vec4(1,-1,1,-1);
     Out.Att1 = Att1;
     Out.Att2 = Att2;
     gl_PointSize = 5;

displayMicroMesh.vert

@@ -22,14 +22,12 @@ out Attribs {
 void main(void)
 {
     Out.texuv = Vertex;
-    /* TODO setup Linear sampler */
+    vec4 pos = texture(waterPos, Out.texuv);
-    vec4 pos = texture(waterPos, Vertex);
     if (pos.w <= 0.0) { /* No position data -> no water here */
         Out.pos = vec3(0);
         gl_Position = vec4(0,0,0,-1);
     } else {
-        /* TODO setup Linear sampler */
+        Out.pos = pos.xyz + texture(waterHeight, Out.texuv).rgb;
-        Out.pos = pos.xyz + texture(waterHeight, Vertex).rgb;
         gl_Position = matrProj * matrVisu * matrModel * vec4(Out.pos, 1);
     }
 }

nuanceurFragmentsSolution.glsl

@@ -1,141 +0,0 @@
-#version 410
-
-// Définition des paramètres des sources de lumière
-layout (std140) uniform LightSourceParameters
-{
-   vec4 ambient;
-   vec4 diffuse;
-   vec4 specular;
-   vec4 position;
-   vec3 spotDirection;
-   float spotExponent;
-   float spotCutoff;            // ([0.0,90.0] ou 180.0)
-   float constantAttenuation;
-   float linearAttenuation;
-   float quadraticAttenuation;
-} LightSource[1];
-
-// Définition des paramètres des matériaux
-layout (std140) uniform MaterialParameters
-{
-   vec4 emission;
-   vec4 ambient;
-   vec4 diffuse;
-   vec4 specular;
-   float shininess;
-} FrontMaterial;
-
-// Définition des paramètres globaux du modèle de lumière
-layout (std140) uniform LightModelParameters
-{
-   vec4 ambient;       // couleur ambiante
-   bool localViewer;   // observateur local ou à l'infini?
-   bool twoSide;       // éclairage sur les deux côtés ou un seul?
-} LightModel;
-
-layout (std140) uniform varsUnif
-{
-   // partie 1: illumination
-   int typeIllumination;     // 0:Lambert, 1:Gouraud, 2:Phong
-   bool utiliseBlinn;        // indique si on veut utiliser modèle spéculaire de Blinn ou Phong
-   bool utiliseDirect;       // indique si on utilise un spot style Direct3D ou OpenGL
-   bool 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
-   bool 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?
-};
-
-uniform sampler2D laTexture;
-
-/////////////////////////////////////////////////////////////////
-
-in Attribs {
-   vec3 lumiDir, spotDir;
-   vec3 normale, obsVec;
-   vec2 texCoord;
-   vec4 couleur;
-} AttribsIn;
-
-out vec4 FragColor;
-
-float calculerSpot( in vec3 spotDir, in vec3 L )
-{
-   float spotFacteur;
-   float spotDot = dot( L, normalize( spotDir ) );
-   if ( utiliseDirect ) // modèle Direct3D
-   {
-      float cosAngleInterne = cos(radians(LightSource[0].spotCutoff));
-      float exposant = 1.01 + LightSource[0].spotExponent / 2.0;
-      float cosAngleExterne = pow( cos(radians(LightSource[0].spotCutoff)), exposant );
-      // calculer le facteur spot avec la fonction smoothstep()
-      spotFacteur = smoothstep( cosAngleExterne, cosAngleInterne, spotDot );
-   }
-   else // modèle OpenGL
-   {
-      spotFacteur = ( spotDot > cos(radians(LightSource[0].spotCutoff)) ) ? pow( spotDot, LightSource[0].spotExponent ) : 0.0;
-   }
-   return( spotFacteur );
-}
-
-vec4 calculerReflexion( in vec3 L, in vec3 N, in vec3 O )
-{
-   vec4 coul = FrontMaterial.emission + FrontMaterial.ambient * LightModel.ambient;
-
-   // calcul de la composante ambiante
-   coul += FrontMaterial.ambient * LightSource[0].ambient;
-
-   // calcul de l'éclairage seulement si le produit scalaire est positif
-   float NdotL = max( 0.0, dot( N, L ) );
-   if ( NdotL > 0.0 )
-   {
-      // calcul de la composante diffuse
-      //coul += ( utiliseCouleur ? FrontMaterial.diffuse : vec4(1.0) ) * LightSource[0].diffuse * NdotL;
-      coul += FrontMaterial.diffuse * LightSource[0].diffuse * NdotL;
-
-      // calcul de la composante spéculaire (Blinn ou Phong)
-      float NdotHV = max( 0.0, ( utiliseBlinn ) ? dot( normalize( L + O ), N ) : dot( reflect( -L, N ), O ) );
-      coul += FrontMaterial.specular * LightSource[0].specular * ( ( NdotHV == 0.0 ) ? 0.0 : pow( NdotHV, FrontMaterial.shininess ) );
-   }
-   return( coul );
-}
-
-void main( void )
-{
-   vec3 L = normalize( AttribsIn.lumiDir ); // vecteur vers la source lumineuse
-   vec3 N = normalize( AttribsIn.normale ); // vecteur normal
-   //vec3 N = normalize( gl_FrontFacing ? AttribsIn.normale : -AttribsIn.normale );
-   vec3 O = normalize( AttribsIn.obsVec );  // position de l'observateur
-
-   // calculer la réflexion:
-   //   si illumination de 1:Gouraud, prendre la couleur interpolée qui a été reçue
-   //   si illumination de 2:Phong, le faire!
-   //   si illumination de 0:Lambert, faire comme Phong, même si les normales sont les mêmes pour tous les fragments
-   vec4 coul = ( typeIllumination == 1 ) ? AttribsIn.couleur : calculerReflexion( L, N, O );
-
-   // calculer l'influence du spot
-   float spotFacteur = calculerSpot( AttribsIn.spotDir, L );
-   coul *= spotFacteur;
-   //if ( spotFacteur <= 0.0 ) discard; // pour éliminer tout ce qui n'est pas dans le cône
-   // calcul de la composante ambiante
-   //coul += FrontMaterial.ambient * LightSource[0].ambient;
-
-   // appliquer la texture s'il y a lieu
-   if ( texnumero != 0 )
-   {
-      vec4 couleurTexture = texture( laTexture, AttribsIn.texCoord );
-      // comment afficher un texel noir?
-      if ( couleurTexture.r < 0.1 && couleurTexture.g < 0.1 && couleurTexture.b < 0.1 &&
-           spotFacteur > 0.0 )
-         if ( afficheTexelNoir == 1 )
-            couleurTexture = coul / 2.0;
-         else if ( afficheTexelNoir == 2 )
-            discard;
-      coul *= couleurTexture;
-   }
-
-   // assigner la couleur finale
-   FragColor = clamp( coul, 0.0, 1.0 );
-
-   if ( afficheNormales ) FragColor = vec4(N,1.0);
-}

nuanceurGeometrieSolution.glsl

@@ -1,73 +0,0 @@
-#version 410
-
-layout(triangles) in;
-layout(triangle_strip, max_vertices = 3) out;
-
-uniform mat4 matrModel;
-uniform mat4 matrVisu;
-uniform mat4 matrProj;
-uniform mat3 matrNormale;
-
-layout (std140) uniform varsUnif
-{
-   // partie 1: illumination
-   int typeIllumination;     // 0:Lambert, 1:Gouraud, 2:Phong
-   bool utiliseBlinn;        // indique si on veut utiliser modèle spéculaire de Blinn ou Phong
-   bool utiliseDirect;       // indique si on utilise un spot style Direct3D ou OpenGL
-   bool 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
-   bool 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?
-};
-
-in Attribs {
-   vec3 lumiDir, spotDir;
-   vec3 normale, obsVec;
-   vec2 texCoord;
-   vec4 couleur;
-} AttribsIn[];
-
-out Attribs {
-   vec3 lumiDir, spotDir;
-   vec3 normale, obsVec;
-   vec2 texCoord;
-   vec4 couleur;
-} AttribsOut;
-
-void main()
-{
-   // si illumination est Lambert, calculer une nouvelle normale
-   vec3 n = vec3(0.0);
-   if ( typeIllumination == 0 )
-   {
-      vec3 p0 = gl_in[0].gl_Position.xyz;
-      vec3 p1 = gl_in[1].gl_Position.xyz;
-      vec3 p2 = gl_in[2].gl_Position.xyz;
-      n = cross( p1-p0, p2-p0 ); // cette nouvelle normale est déjà dans le repère de la caméra
-                                 // il n'est pas nécessaire de la multiplier par matrNormale
-   }
-   // ou faire une moyenne, MAIS CE N'EST PAS CE QU'ON VEUT!
-   // if ( typeIllumination == 0 )
-   // {
-   //    // calculer le centre
-   //    for ( int i = 0 ; i < gl_in.length() ; ++i )
-   //    {
-   //       n += AttribsIn[i].normale;
-   //    }
-   //    n /= gl_in.length();
-   // }
-
-   // émettre les sommets
-   for ( int i = 0 ; i < gl_in.length() ; ++i )
-   {
-      gl_Position = matrProj * gl_in[i].gl_Position; // on termine la transformation débutée dans le nuanceur de sommets
-      AttribsOut.lumiDir = AttribsIn[i].lumiDir;
-      AttribsOut.spotDir = AttribsIn[i].spotDir;
-      AttribsOut.normale = ( typeIllumination == 0 ) ? n : AttribsIn[i].normale;
-      AttribsOut.obsVec = AttribsIn[i].obsVec;
-      AttribsOut.texCoord = AttribsIn[i].texCoord;
-      AttribsOut.couleur = AttribsIn[i].couleur;
-      EmitVertex();
-   }
-}

nuanceurSommetsSolution.glsl

@@ -1,130 +0,0 @@
-#version 410
-
-// Définition des paramètres des sources de lumière
-layout (std140) uniform LightSourceParameters
-{
-   vec4 ambient;
-   vec4 diffuse;
-   vec4 specular;
-   vec4 position;
-   vec3 spotDirection;
-   float spotExponent;
-   float spotCutoff;            // ([0.0,90.0] ou 180.0)
-   float constantAttenuation;
-   float linearAttenuation;
-   float quadraticAttenuation;
-} LightSource[1];
-
-// Définition des paramètres des matériaux
-layout (std140) uniform MaterialParameters
-{
-   vec4 emission;
-   vec4 ambient;
-   vec4 diffuse;
-   vec4 specular;
-   float shininess;
-} FrontMaterial;
-
-// Définition des paramètres globaux du modèle de lumière
-layout (std140) uniform LightModelParameters
-{
-   vec4 ambient;       // couleur ambiante
-   bool localViewer;   // observateur local ou à l'infini?
-   bool twoSide;       // éclairage sur les deux côtés ou un seul?
-} LightModel;
-
-layout (std140) uniform varsUnif
-{
-   // partie 1: illumination
-   int typeIllumination;     // 0:Lambert, 1:Gouraud, 2:Phong
-   bool utiliseBlinn;        // indique si on veut utiliser modèle spéculaire de Blinn ou Phong
-   bool utiliseDirect;       // indique si on utilise un spot style Direct3D ou OpenGL
-   bool 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
-   bool 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?
-};
-
-uniform mat4 matrModel;
-uniform mat4 matrVisu;
-uniform mat4 matrProj;
-uniform mat3 matrNormale;
-
-/////////////////////////////////////////////////////////////////
-
-layout(location=0) in vec4 Vertex;
-layout(location=2) in vec3 Normal;
-layout(location=3) in vec4 Color;
-layout(location=8) in vec4 TexCoord;
-
-out Attribs {
-   vec3 lumiDir, spotDir;
-   vec3 normale, obsVec;
-   vec2 texCoord;
-   vec4 couleur;
-} AttribsOut;
-
-vec4 calculerReflexion( in vec3 L, in vec3 N, in vec3 O )
-{
-   vec4 coul = FrontMaterial.emission + FrontMaterial.ambient * LightModel.ambient;
-
-   // calcul de la composante ambiante
-   coul += FrontMaterial.ambient * LightSource[0].ambient;
-
-   // calcul de l'éclairage seulement si le produit scalaire est positif
-   float NdotL = max( 0.0, dot( N, L ) );
-   if ( NdotL > 0.0 )
-   {
-      // calcul de la composante diffuse
-      //coul += ( utiliseCouleur ? FrontMaterial.diffuse : vec4(1.0) ) * LightSource[0].diffuse * NdotL;
-      coul += FrontMaterial.diffuse * LightSource[0].diffuse * NdotL;
-
-      // calcul de la composante spéculaire (Blinn ou Phong)
-      float NdotHV = max( 0.0, ( utiliseBlinn ) ? dot( normalize( L + O ), N ) : dot( reflect( -L, N ), O ) );
-      coul += FrontMaterial.specular * LightSource[0].specular * ( ( NdotHV == 0.0 ) ? 0.0 : pow( NdotHV, FrontMaterial.shininess ) );
-   }
-   return( coul );
-}
-
-void main( void )
-{
-   // transformation standard du sommet, ** sans la projection **
-   gl_Position = matrVisu * matrModel * Vertex;
-
-   // calculer la normale qui sera interpolée pour le nuanceur de fragment
-   AttribsOut.normale = matrNormale * Normal;
-
-   // calculer la position du sommet (dans le repère de la caméra)
-   vec3 pos = vec3( matrVisu * matrModel * Vertex );
-
-   // vecteur de la direction de la lumière (dans le repère de la caméra)
-   AttribsOut.lumiDir = vec3( ( matrVisu * LightSource[0].position ).xyz - pos );
-
-   // vecteur de la direction vers l'observateur (dans le repère de la caméra)
-   AttribsOut.obsVec = ( LightModel.localViewer ?
-                         normalize(-pos) :        // =(0-pos) un vecteur qui pointe vers le (0,0,0), c'est-à-dire vers la caméra
-                         vec3( 0.0, 0.0, 1.0 ) ); // on considère que l'observateur (la caméra) est à l'infini dans la direction (0,0,1)
-   // vecteur de la direction du spot (en tenant compte seulement des rotations de la caméra)
-   AttribsOut.spotDir = inverse(mat3(matrVisu)) * -LightSource[0].spotDirection;
-   // On accepte aussi: (si on suppose que .spotDirection est déjà dans le repère de la caméra)
-   //AttribsOut.spotDir = -LightSource[0].spotDirection;
-   // On accepte aussi: (car matrVisu a seulement une translation et pas de rotation => "mat3(matrVisu) == I" )
-   //AttribsOut.spotDir = -LightSource[0].spotDirection;
-   // On accepte aussi: (car c'était le calcul qui était dans la solution précédente présentée dans le lab!)
-   //AttribsOut.spotDir = -( matrVisu * vec4(LightSource[0].spotDirection,1.0) ).xyz;
-
-   // si illumination est 1:Gouraud, calculer la réflexion ici, sinon ne rien faire de plus
-   if ( typeIllumination == 1 )
-   {
-      vec3 L = normalize( AttribsOut.lumiDir ); // calcul du vecteur de la surface vers la source lumineuse
-      vec3 N = normalize( AttribsOut.normale ); // vecteur normal
-      vec3 O = normalize( AttribsOut.obsVec );  // position de l'observateur
-      AttribsOut.couleur = calculerReflexion( L, N, O );
-   }
-   //else
-   //   couleur = vec4(0.0); // inutile
-
-   // assigner les coordonnées de texture
-   AttribsOut.texCoord = TexCoord.st;
-}

rasterizeWaveMeshPosition.vert

@@ -7,8 +7,8 @@ uniform mat4 matrProj;
 
 /////////////////////////////////////////////////////////////////
 
-in vec2 Vertex;
+layout(location=0) in vec2 Vertex;
-in vec2 TexCoord;
+layout(location=1) in vec2 TexCoord;
 
 out Attribs {
     vec3 pos;
@@ -17,6 +17,7 @@ out Attribs {
 void main(void)
 {
     Out.pos = 0.5 * SCENE_EXTENT * vec3(Vertex.x, 0, Vertex.y);
+    /* Direct3D and OpenGL don't render with the same screen coordinates */
     gl_Position = matrProj * matrVisu * matrModel * vec4(Out.pos, 1.);
 }
 

ripple.cpp

@@ -118,6 +118,7 @@ double phiCam = 0.0;          // angle de rotation de la caméra (coord. sphéri
 double distCam = 0.0;         // distance (coord. sphériques)
 glm::vec3 cameraPos = glm::vec3(10.17, 22.13, 59.49);
 float movementIncr = 0.8;
+/* Movement direction */
 float goF = 0; /* Forward */
 float goR = 0; /* Right */
 float goB = 0; /* Back */
@@ -128,7 +129,7 @@ float goD = 0; /* Down */
 // variables d'état
 bool enPerspective = false;   // indique si on est en mode Perspective (true) ou Ortho (false)
 bool enmouvement = true;     // le modèle est en mouvement/rotation automatique ou non
-bool afficheAxes = true;      // indique si on affiche les axes
+bool afficheAxes = false;      // indique si on affiche les axes
 GLenum modePolygone = GL_FILL; // comment afficher les polygones
 
 // FBOs
@@ -194,8 +195,6 @@ void updatePackets()
     if (enmouvement)
         packets->AdvectWavePackets(INIT_WAVE_SPEED);
 
-    // TODO Setup wide projection for InitiateWaveField (RasterizeWaveMeshPosition)
-
     if (!debug)
         heightFBO->CommencerCapture();
     int displayedPackets = 0;
@@ -227,8 +226,6 @@ void updatePackets()
                 /* 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(displayedPackets);
                 displayedPackets = 0;
                 packetChunk = 0;
@@ -261,8 +258,6 @@ void updatePackets()
             glBindBuffer(GL_ARRAY_BUFFER, vboPacket);
             glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData);
             glBindBuffer(GL_ARRAY_BUFFER, 0);
-            //displayPacketOutlined();
-            /* TODO EvaluatePackets(packetChunk) */
             addPacketDisplacement(displayedPackets);
             displayedPackets = 0;
             packetChunk = 0;
@@ -271,13 +266,9 @@ void updatePackets()
     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(displayedPackets);
     if (!debug)
         heightFBO->TerminerCapture();
-    /* TODO DisplayScene */
-    /* TODO Get camera center */
 }
 
 
@@ -710,11 +701,6 @@ void afficherModele()
 {
    // Dessiner le modèle
    matrModel.PushMatrix(); {
-
-
-      // mise à l'échelle
-      matrModel.Scale( 5.0, 5.0, 5.0 );
-
       /* Create texture terrain positions */
       posFBO->CommencerCapture();
       rasterizeWaveMeshPosition();
@@ -768,7 +754,6 @@ void FenetreTP::afficherScene()
 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);