122 lignes
5.8 KiB
GLSL
122 lignes
5.8 KiB
GLSL
#version 450
|
|
|
|
// Meme bloc uniforme que le vertex shader : on n'y lit que viewPos, mais un bloc
|
|
// uniforme se declare a l'identique dans les deux etages (meme binding, meme
|
|
// layout). Cote C++, le descriptor set layout doit donc exposer ce binding au
|
|
// stage FRAGMENT en plus du stage VERTEX.
|
|
layout(binding = 0) uniform UniformBufferObject {
|
|
mat4 view;
|
|
mat4 proj;
|
|
vec3 viewPos;
|
|
vec4 terrain;
|
|
// PHASE 23 : cycle jour/nuit. xyz = direction VERS la lumiere, w = intensite
|
|
// directe dans [0, 1]. Voir renderer/UniformBufferObject.hpp.
|
|
vec4 sun;
|
|
// rgb = couleur de la lumiere, a = MULTIPLICATEUR de l'ambiante ci-dessous.
|
|
vec4 sunColor;
|
|
// PHASE 27 : meteo visible et micro-relief. Voir
|
|
// renderer/UniformBufferObject.hpp pour le sens de chaque composante.
|
|
vec4 fog; // rgb = couleur, a = extinction en 1/m (0 = aucun brouillard)
|
|
vec4 precip; // x = intensite, y = neige, z = temps, w = assombrissement sol mouille
|
|
vec4 fall; // xyz = vitesse de chute en monde (m/s)
|
|
vec4 detail; // micro-relief : x = force, y/z = fondu (m), w = motif (m)
|
|
} ubo;
|
|
|
|
layout(location = 0) in vec3 fragColor;
|
|
layout(location = 1) in vec3 fragNormal;
|
|
layout(location = 2) in vec3 fragWorldPos;
|
|
// PHASE 15 : teinte de temoin de l'editeur. x = force (0 = aucune), yzw =
|
|
// couleur. Voir le commentaire du push constant dans cube.vert.
|
|
layout(location = 3) in vec4 fragTint;
|
|
|
|
layout(location = 0) out vec4 outColor;
|
|
|
|
// --- Lumiere directionnelle, fixe en dur pour la Phase 2 ---
|
|
// Direction de PROPAGATION de la lumiere (celle vers laquelle elle voyage) :
|
|
// venant d'en haut, legerement de la gauche et de l'avant. Une directionnelle
|
|
// n'a pas de position : tous les rayons sont paralleles, comme le soleil.
|
|
// PHASE 23 : la direction et la couleur de la lumiere ne sont plus des
|
|
// constantes. Elles viennent de l'UBO, donc de la position solaire calculee
|
|
// par world/Weather.hpp a partir de l'heure de jeu. Il n'y a qu'UN soleil
|
|
// dans le jeu, et c'est celui-la.
|
|
|
|
const float kAmbientStrength = 0.15; // evite que les faces a l'ombre soient noires
|
|
const float kSpecularStrength = 0.35;
|
|
const float kShininess = 32.0; // plus grand = tache speculaire plus petite
|
|
|
|
// --- PHASE 27 : brouillard de distance ------------------------------------
|
|
// Loi d'extinction exponentielle (Beer-Lambert) : la part de la couleur de la
|
|
// surface qui atteint l'oeil vaut exp(-sigma * d). sigma = ubo.fog.a vient de
|
|
// weatherVisualsFor(), qui le tire de la PRECIPITATION LOCALE calculee par la
|
|
// meteo ; il vaut exactement zero par temps sec, et alors cette fonction rend
|
|
// la couleur inchangee au bit pres. La couleur du voile est celle du ciel.
|
|
// MEME fonction dans terrain.frag, foliage.frag et cube.frag : un arbre et le
|
|
// sol sur lequel il pousse doivent disparaitre dans la brume ensemble.
|
|
vec3 applyFog(vec3 color, vec3 worldPos) {
|
|
float sigma = ubo.fog.a;
|
|
if (sigma <= 0.0) {
|
|
return color;
|
|
}
|
|
float d = length(ubo.viewPos - worldPos);
|
|
return mix(ubo.fog.rgb, color, exp(-sigma * d));
|
|
}
|
|
|
|
void main() {
|
|
// Les varyings sont interpoles entre sommets : leur longueur n'est plus
|
|
// garantie, d'ou le normalize().
|
|
vec3 N = normalize(fragNormal);
|
|
vec3 L = normalize(ubo.sun.xyz); // surface -> lumiere
|
|
vec3 V = normalize(ubo.viewPos - fragWorldPos); // surface -> observateur
|
|
|
|
// Blinn-Phong : on utilise le "half vector" entre L et V plutot que le
|
|
// vecteur reflechi de Phong. Moins cher (pas de reflect()) et sans la
|
|
// coupure abrupte de Phong quand l'angle depasse 90 degres.
|
|
vec3 H = normalize(L + V);
|
|
|
|
// Lambert : l'intensite depend du cosinus de l'angle normale/lumiere.
|
|
// max(..., 0) : une face qui tourne le dos a la lumiere ne recoit rien
|
|
// (sans ca, le produit scalaire negatif retirerait de la lumiere).
|
|
float diffuse = max(dot(N, L), 0.0);
|
|
|
|
// Pas de reflet speculaire sur une face non eclairee.
|
|
float specular = diffuse > 0.0
|
|
? kSpecularStrength * pow(max(dot(N, H), 0.0), kShininess)
|
|
: 0.0;
|
|
|
|
// L'ambiant et le diffus teintent la couleur de la face ; le speculaire est
|
|
// un reflet de la lumiere elle-meme, il s'ajoute donc sans etre teinte.
|
|
// PHASE 23 : l'intensite directe et le multiplicateur d'ambiante viennent du
|
|
// cycle jour/nuit. En plein jour, sun.w = 1 et sunColor.a = 1 : l'expression
|
|
// ci-dessous est alors mot pour mot celle de la Phase 2.
|
|
vec3 kLightColor = ubo.sunColor.rgb;
|
|
float ambient = kAmbientStrength * ubo.sunColor.a;
|
|
diffuse *= ubo.sun.w;
|
|
specular *= ubo.sun.w;
|
|
|
|
vec3 lit = fragColor * kLightColor * (ambient + diffuse)
|
|
+ kLightColor * specular;
|
|
|
|
// --- Teinte de temoin (PHASE 15) ---------------------------------------
|
|
// L'editeur doit distinguer d'un coup d'oeil trois etats du MEME modele :
|
|
// l'objet pose, le fantome qui suit la visee, et l'objet selectionne.
|
|
//
|
|
// Une teinte plutot qu'une TRANSPARENCE, ce qui serait pourtant le rendu
|
|
// habituel d'un fantome : le melange alpha impose de trier les objets par
|
|
// profondeur a chaque image, ou d'accepter des artefacts. C'est le choix que
|
|
// le projet a deja fait deux fois - la vegetation de la Phase 11 fond ses
|
|
// arbres par RETRECISSEMENT et non par transparence, et l'herbe est faite de
|
|
// quads opaques - pour la meme raison. Une teinte forte plus un ambiant
|
|
// releve donne un objet parfaitement identifiable, opaque, sans tri, sans
|
|
// second pipeline et sans etat de blending.
|
|
//
|
|
// Force nulle (tout le reste du jeu) : la branche n'est meme pas prise, le
|
|
// rendu est bit a bit celui d'avant la Phase 15.
|
|
if (fragTint.x > 0.0) {
|
|
vec3 tinted = fragTint.yzw * kLightColor * (0.55 + 0.45 * diffuse)
|
|
+ kLightColor * specular;
|
|
lit = mix(lit, tinted, clamp(fragTint.x, 0.0, 1.0));
|
|
}
|
|
|
|
outColor = vec4(applyFog(lit, fragWorldPos), 1.0);
|
|
}
|