lhark
/
ripple
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Nettoyage du code

master
lhark 8 years ago
parent
10a5dd3216
commit
cc52e5c0c7
7 changed files with 9 additions and 368 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      addPacketDisplacement.vert
  2. 6
      displayMicroMesh.vert
  3. 141
      nuanceurFragmentsSolution.glsl
  4. 73
      nuanceurGeometrieSolution.glsl
  5. 130
      nuanceurSommetsSolution.glsl
  6. 5
      rasterizeWaveMeshPosition.vert
  7. 19
      ripple.cpp

3
addPacketDisplacement.vert
View File

@ -19,7 +19,8 @@ out Attribs {
void main(void) 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.Att1 = Att1;
Out.Att2 = Att2; Out.Att2 = Att2;
gl_PointSize = 5; gl_PointSize = 5;

6
displayMicroMesh.vert
View File

@ -22,14 +22,12 @@ out Attribs {
void main(void) void main(void)
{ {
Out.texuv = Vertex; 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 */ if (pos.w <= 0.0) { /* No position data -> no water here */
Out.pos = vec3(0); Out.pos = vec3(0);
gl_Position = vec4(0,0,0,-1); gl_Position = vec4(0,0,0,-1);
} else { } 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); gl_Position = matrProj * matrVisu * matrModel * vec4(Out.pos, 1);
} }
} }

141
nuanceurFragmentsSolution.glsl
View File

@ -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);
}

73
nuanceurGeometrieSolution.glsl
View File

@ -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();
}
}

130
nuanceurSommetsSolution.glsl
View File

@ -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;
}

5
rasterizeWaveMeshPosition.vert
View File

@ -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 { out Attribs {
vec3 pos; vec3 pos;
@ -17,6 +17,7 @@ out Attribs {
void main(void) void main(void)
{ {
Out.pos = 0.5 * SCENE_EXTENT * vec3(Vertex.x, 0, Vertex.y); 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.); gl_Position = matrProj * matrVisu * matrModel * vec4(Out.pos, 1.);
} }

19
ripple.cpp
View File

@ -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) double distCam = 0.0; // distance (coord. sphériques)
glm::vec3 cameraPos = glm::vec3(10.17, 22.13, 59.49); glm::vec3 cameraPos = glm::vec3(10.17, 22.13, 59.49);
float movementIncr = 0.8; float movementIncr = 0.8;
/* Movement direction */
float goF = 0; /* Forward */ float goF = 0; /* Forward */
float goR = 0; /* Right */ float goR = 0; /* Right */
float goB = 0; /* Back */ float goB = 0; /* Back */
@ -128,7 +129,7 @@ float goD = 0; /* Down */
// variables d'état // variables d'état
bool enPerspective = false; // indique si on est en mode Perspective (true) ou Ortho (false) 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 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 GLenum modePolygone = GL_FILL; // comment afficher les polygones
// FBOs // FBOs
@ -194,8 +195,6 @@ void updatePackets()
if (enmouvement) if (enmouvement)
packets->AdvectWavePackets(INIT_WAVE_SPEED); packets->AdvectWavePackets(INIT_WAVE_SPEED);
// TODO Setup wide projection for InitiateWaveField (RasterizeWaveMeshPosition)
if (!debug) if (!debug)
heightFBO->CommencerCapture(); heightFBO->CommencerCapture();
int displayedPackets = 0; int displayedPackets = 0;
@ -227,8 +226,6 @@ void updatePackets()
/* TODO Use Buffer mapping for better performance */ /* TODO Use Buffer mapping for better performance */
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
//displayPacketOutlined(packetChunk / 12);
/* TODO EvaluatePackets(packetChunk) */
addPacketDisplacement(displayedPackets); addPacketDisplacement(displayedPackets);
displayedPackets = 0; displayedPackets = 0;
packetChunk = 0; packetChunk = 0;
@ -261,8 +258,6 @@ void updatePackets()
glBindBuffer(GL_ARRAY_BUFFER, vboPacket); glBindBuffer(GL_ARRAY_BUFFER, vboPacket);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
//displayPacketOutlined();
/* TODO EvaluatePackets(packetChunk) */
addPacketDisplacement(displayedPackets); addPacketDisplacement(displayedPackets);
displayedPackets = 0; displayedPackets = 0;
packetChunk = 0; packetChunk = 0;
@ -271,13 +266,9 @@ void updatePackets()
glBindBuffer(GL_ARRAY_BUFFER, vboPacket); glBindBuffer(GL_ARRAY_BUFFER, vboPacket);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(packetData), packetData);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
//displayPacketOutlined(packetChunk / 12);
/* TODO EvaluatePackets(packetChunk) */
addPacketDisplacement(displayedPackets); addPacketDisplacement(displayedPackets);
if (!debug) if (!debug)
heightFBO->TerminerCapture(); heightFBO->TerminerCapture();
/* TODO DisplayScene */
/* TODO Get camera center */
} }
@ -710,11 +701,6 @@ void afficherModele()
{ {
// Dessiner le modèle // Dessiner le modèle
matrModel.PushMatrix(); { matrModel.PushMatrix(); {
// mise à l'échelle
matrModel.Scale( 5.0, 5.0, 5.0 );
/* Create texture terrain positions */ /* Create texture terrain positions */
posFBO->CommencerCapture(); posFBO->CommencerCapture();
rasterizeWaveMeshPosition(); rasterizeWaveMeshPosition();
@ -768,7 +754,6 @@ void FenetreTP::afficherScene()
void FenetreTP::redimensionner( GLsizei w, GLsizei h ) void FenetreTP::redimensionner( GLsizei w, GLsizei h )
{ {
std::cout << "Resizing to " << w << "×" << h << std::endl; std::cout << "Resizing to " << w << "×" << h << std::endl;
/* FIXME Is this function called on program start ? */
glViewport( 0, 0, w, h ); glViewport( 0, 0, w, h );
posFBO->Liberer(); posFBO->Liberer();
posFBO->Init(WAVETEX_WIDTH_FACTOR * w, WAVETEX_HEIGHT_FACTOR * h); posFBO->Init(WAVETEX_WIDTH_FACTOR * w, WAVETEX_HEIGHT_FACTOR * h);

Write Preview
Loading…
Cancel
Save