lhark/ripple
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Nettoyage du code

Browse source
This commit is contained in:
lhark 2017-12-11 17:20:40 -05:00
parent 10a5dd3216
commit cc52e5c0c7
7 changed files with 9 additions and 368 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
addPacketDisplacement.vert
View file

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

6
displayMicroMesh.vert
View file

@ -22,14 +22,12 @@ out Attribs {
void main(void)
{
Out.texuv = Vertex;
/* TODO setup Linear sampler */
vec4 pos = texture(waterPos, Vertex);
vec4 pos = texture(waterPos, Out.texuv);
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, Vertex).rgb;
Out.pos = pos.xyz + texture(waterHeight, Out.texuv).rgb;
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;
in vec2 TexCoord;
layout(location=0) in vec2 Vertex;
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.);
}

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