lhark
6 years ago
7 changed files with 9 additions and 368 deletions
@ -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); |
|||
} |
|||
@ -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(); |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
Loading…
Reference in new issue