#version 450 layout(binding = 0) uniform UniformBufferObject { mat4 view; mat4 proj; vec3 viewPos; // x = altitude min, y = altitude max, z = dosage orthophoto, // w = force de l'indice adret/ubac (PHASE 25, voir plus bas) 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; // PHASE 11 : orthophoto BD ORTHO drapee sur le relief. Toujours reliee a une // image valide - un texel blanc quand aucune photo n'est chargee - donc // echantillonnable sans condition. C'est ubo.terrain.z qui decide si le resultat // compte, et il vaut zero dans ce cas. layout(binding = 1) uniform sampler2D orthoTexture; layout(location = 0) in vec3 fragTint; layout(location = 1) in vec3 fragNormal; layout(location = 2) in vec3 fragWorldPos; layout(location = 3) in vec2 fragUV; layout(location = 0) out vec4 outColor; // --- Lumiere directionnelle, identique a celle de la Phase 2 --------------- // 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.18; const float kSpecularStrength = 0.06; // roche/herbe : quasi mat, contrairement au cube const float kShininess = 16.0; // --- Etagement par altitude ------------------------------------------------ // Trois teintes suffisent a rendre le relief lisible sans texturing : c'est le // but de cette phase (valider que la geometrie et les normales sont correctes), // pas de faire joli. const vec3 kLowColor = vec3(0.22, 0.32, 0.17); // alpage const vec3 kMidColor = vec3(0.45, 0.42, 0.34); // roche / eboulis const vec3 kHighColor = vec3(0.93, 0.95, 0.98); // neve const vec3 kCliffColor = vec3(0.34, 0.31, 0.29); // falaise (roche nue) // --- PHASE 25 : indice visuel adret / ubac --------------------------------- // L'ecart adret/ubac existait depuis la Phase 23 - mesure, journalise, et // invisible : 14,7 C contre 10,7 C a midi sans que RIEN a l'ecran ne le montre. // // CE SHADER NE CALCULE PAS UNE DEUXIEME EXPOSITION SOLAIRE. Il reprend // exactement la grandeur de WeatherSystem::sampleAt - l'ecart entre le cosinus // d'incidence du point et celui qu'aurait du terrain PLAT au meme instant - // avec la MEME direction solaire, celle de ubo.sun.xyz, qui vient de // world/Weather.hpp. Il n'y a qu'un soleil dans ce jeu, et c'est celui de la // meteo. // // Le partage des roles est le suivant, et il est deliberé : // - ce shader fait ce que lui seul peut faire : le cosinus d'incidence PAR // FRAGMENT, a partir de la normale du relief ; // - le CPU (main.cpp) porte tout le reste - hauteur du soleil, nebulosite - // dans ubo.terrain.w, parce que ces deux regles appartiennent a la meteo et // n'ont pas a etre re-derivees ici, ou elles pourraient diverger. // // Consequence directe : l'effet suit le cycle jour/nuit tout seul. Le soleil // tourne, l'incidence de chaque versant change avec lui ; il se couche, et // ubo.terrain.w tombe a zero. Aucune regle horaire n'est ecrite nulle part. // Ecart de cosinus d'incidence qui vaut un effet COMPLET. // DOIT rester egal a WeatherParams::aspectIncidenceReference (0,35). main.cpp // verifie cette egalite au demarrage et previent si elle est rompue : un shader // ne peut pas lire un parametre C++, donc la seule protection possible est de // rendre la divergence BRUYANTE plutot que silencieuse. const float kAspectIncidenceReference = 0.35; // Les deux teintes, en MULTIPLICATEUR d'albedo. // // ELLES SONT EXACTEMENT SYMETRIQUES autour de 1, canal par canal // ((1,14 + 0,86) / 2 = 1, etc.), et ce n'est pas de l'esthetique : sur du // terrain qui n'est ni adret ni ubac le signal vaut 0, donc le melange rend le // MILIEU des deux teintes. Un milieu qui ne serait pas (1,1,1) teinterait tout // le plat du massif - un premier jeu de valeurs le faisait, d'un demi pour cent // vers le chaud. // // AMPLITUDE : +/- 14 % sur le rouge, +/- 12 % sur le bleu, au signal PLEIN. // La premiere version montait a 7 % et c'etait mesurablement trop peu : a 13 h, // l'heure ou l'ecart thermique est maximal, 93,5 % des pixels ne bougeaient pas // d'un cran sur 255 - donc un indice invisible, ce qui lui faisait manquer sa // seule raison d'etre. Le signal, lui, n'a pas change : c'est toujours celui de // la meteo. Seule l'AMPLITUDE D'AFFICHAGE a ete revue, et c'est un choix de // rendu, legitimement distinct du modele physique. // // Le plein signal demande |incidence - incidence a plat| >= 0,35, donc un // versant franchement oriente : sur du relief ordinaire l'effet reste bien en // dessous de ces bornes. const vec3 kAdretTint = vec3(1.14, 1.04, 0.88); // versant au soleil : plus dore const vec3 kUbacTint = vec3(0.86, 0.96, 1.12); // versant a l'ombre : plus bleute // --- 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)); } // =========================================================================== // PHASE 27 - MICRO-RELIEF DU SOL VU DE PRES (chantier 3) // =========================================================================== // LE PROBLEME : l'orthophoto a 0,61 m/texel, vue a pied, est agrandie jusqu'a // ce qu'un texel couvre des dizaines de pixels. Le filtrage bilineaire en fait // un aplat flou - le sol sous les pieds n'a aucun grain. // // CE QUI EST AJOUTE : de l'information dans la SEULE bande de frequences que la // photo ne porte pas, celle qui est plus fine que son texel. Les longueurs // d'onde du motif partent de ubo.detail.w (le texel de l'orthophoto, passe par // main.cpp) et descendent par octaves ; rien au-dessus du texel, donc rien qui // contredise la photo. // // CE QUI EST REEL ET CE QUI NE L'EST PAS, sans detour : le MOTIF est un bruit, // il ne represente aucun caillou reel. Mais son AMPLITUDE, elle, est pilotee // par deux donnees reelles du projet : // - le CONTRASTE LOCAL de l'orthophoto (ecart entre la photo et sa version // deux niveaux de mipmap plus floue) : un eboulis photographie est // contraste, une prairie rase est lisse, et le grain ajoute suit ; // - la PENTE du relief LiDAR : un versant raide est de la roche, plus rugueuse // qu'un replat. // // DEUX FONDUS, et c'est ce qui le garde compatible avec le LOD : // 1. par distance (ubo.detail.y -> ubo.detail.z) : l'effet n'existe qu'a // portee de marche, et le cout est nul au-dela (branche sautee) ; // 2. par OCTAVE, sur l'empreinte du pixel au sol (fwidth) : une octave dont // la longueur d'onde tombe sous deux pixels est eteinte AVANT de // scintiller. C'est la regle de Nyquist appliquee au motif, et c'est elle // qui interdit le moire en vue rasante - la ou le fondu par distance seul // echouerait. // // La normale perturbee ne sert QU'A l'eclairage : l'indice adret/ubac garde la // normale du relief, parce qu'il doit dire la meme chose que la meteo, qui ne // connait pas ce motif. // PHASE 27, binding 2 : bruit de valeur PERIODIQUE precalcule (voir // assets/DetailNoise.hpp). r = valeur, gb = derivees par unite de cellule, // codees sur [-1,5 ; +1,5]. 32 cellules sur la largeur de la texture. // // HISTORIQUE MESURE, pour ne pas y revenir : la premiere version calculait ce // bruit dans le shader (4 hash + interpolation par octave). +1 490 us par // image au ras du sol en Release sur l'UHD 770, ~200 us PAR OCTAVE (bissection : // 0 octave +330 us, 2 octaves +720 us) ; passer d'un hash entier a un hash // flottant n'y changeait rien. C'etait l'arithmetique elle-meme. Une lecture // de texture la remplace, et les mipmaps apportent en prime le filtrage des // grains sous-pixel. layout(binding = 2) uniform sampler2D detailNoise; const float kDetailNoiseCells = 32.0; const float kDetailNoiseSlopeRange = 1.5; // = kDetailNoiseSlopeRange (C++) // textureGrad et non texture : l'appel vit dans une boucle a sortie NON // uniforme (break de Nyquist) et une branche de distance, ou les derivees // implicites sont indefinies. Les derivees d'ecran de la position sont prises // hors branche par l'appelant, puis mises a l'echelle de l'octave. vec3 valueNoiseD(vec2 x, vec2 dxdx, vec2 dxdy) { vec3 t = textureGrad(detailNoise, x / kDetailNoiseCells, dxdx / kDetailNoiseCells, dxdy / kDetailNoiseCells).rgb; return vec3(t.r, (t.gb * 2.0 - 1.0) * kDetailNoiseSlopeRange); } // Octaves du motif : longueur d'onde de base, puis divisee par 2,2 a chaque // octave (un rapport non entier evite que les octaves s'alignent en grille). // SEPT octaves, donc de 0,61 m jusqu'a 5 mm. La premiere version en avait 4 // (finesse 6 cm) et la mesure l'a condamnee : a 2 m du regard, 6 cm couvrent // encore une quinzaine de pixels, et l'energie haute frequence du sol proche // n'avait PAS bouge (5,92 contre 5,91) - de l'ondulation, pas du grain. Les // octaves fines ne coutent que de pres : le fondu de Nyquist les eteint des // qu'elles passent sous deux pixels, et la boucle les saute alors. const int kDetailOctaves = 7; const float kDetailLacunarity = 2.2; // Pente du relief MACRO (1 - N.y) qui vaut une rugosite complete : 0,35, le // debut des versants ou la tuile passe deja a la teinte de falaise. const float kDetailFullSlope = 0.35; // Contraste local de l'orthophoto (distance RGB entre photo nette et floue) qui // vaut une rugosite complete : 0,12, soit ~30 niveaux sur 255. const float kDetailFullContrast = 0.12; // Pente maximale du micro-relief, sans unite (derivee de hauteur par metre, a // force 1). 0,6 : assez pour que chaque grain accroche la lumiere rasante, // pas assez pour retourner une normale. const float kDetailSlope = 1.3; // Amplitude de couleur a force 1 : au plus +/- 30 % autour de la photo sur // les pics du motif, +/- 10 % typiquement. const float kDetailAlbedo = 0.30; void main() { vec3 N = normalize(fragNormal); // Altitude ramenee dans [0,1] sur la plage reelle du terrain. Le max(...) // protege du cas degenere "terrain parfaitement plat" (division par zero). float span = max(ubo.terrain.y - ubo.terrain.x, 1e-4); float altitude = clamp((fragWorldPos.y - ubo.terrain.x) / span, 0.0, 1.0); // Degrade en deux segments : bas -> milieu, puis milieu -> haut. // smoothstep plutot que mix lineaire : les transitions de teinte ne // dessinent pas de bande nette a l'endroit du raccord. vec3 albedo = altitude < 0.5 ? mix(kLowColor, kMidColor, smoothstep(0.0, 0.5, altitude)) : mix(kMidColor, kHighColor, smoothstep(0.5, 1.0, altitude)); // Pente : N.y vaut 1 a plat et tend vers 0 sur une paroi verticale. Une // pente forte ne retient ni terre ni neige -> roche nue. C'est ce terme qui // rend les versants raides immediatement visibles, donc qui valide que les // normales sont bien calculees. float slope = 1.0 - clamp(N.y, 0.0, 1.0); albedo = mix(albedo, kCliffColor, smoothstep(0.25, 0.6, slope)); // --- Orthophoto --------------------------------------------------------- // L'UV couvre EXACTEMENT l'emprise du terrain (0,0 = coin nord-ouest). Le // niveau de mipmap est choisi par le materiel a partir des derivees de // fragUV : c'est ce qui evite le fourmillement en vue lointaine, ou un texel // de 0,61 m se projette bien en dessous du pixel. // // La photo remplace l'albedo mais PAS l'eclairage : le Blinn-Phong ci-dessous // continue de s'appliquer avec la normale du relief. Une orthophoto est prise // a la verticale par temps clair, donc deja a peu pres uniformement eclairee ; // la relancer dans le modele d'eclairage est ce qui redonne du volume aux // versants, qu'une photo plaquee telle quelle aplatit completement. vec3 ortho = texture(orthoTexture, fragUV).rgb; albedo = mix(albedo, ortho, clamp(ubo.terrain.z, 0.0, 1.0)); // --- PHASE 27 : sol mouille -------------------------------------------- // Pilote par WeatherSample::wetness (relecture de la pluie des dernieres // heures, Phase 23) via weatherVisualsFor() : ubo.precip.w vaut // wetGroundDarkening * wetness, donc exactement 0 sur un sol sec. Le sol // fonce apres l'averse et SECHE avec le modele, sans aucune regle ici. albedo *= 1.0 - clamp(ubo.precip.w, 0.0, 1.0); // fragTint vaut (1,1,1) pour le terrain synthetique : reserve a une future // classification par sommet (sol / vegetation / bati venant du LiDAR). albedo *= fragTint; vec3 L = normalize(ubo.sun.xyz); // --- PHASE 27 : micro-relief (voir l'en-tete du bloc au-dessus de main) -- vec3 Nlit = N; float detailStrength = clamp(ubo.detail.x, 0.0, 1.0); float viewDistance = length(ubo.viewPos - fragWorldPos); float distanceFade = detailStrength > 0.0 ? 1.0 - smoothstep(ubo.detail.y, ubo.detail.z, viewDistance) : 0.0; // Derivees d'ecran calculees HORS de la branche : fwidth() et le choix du // mipmap exigent un flot de controle uniforme dans le quad de pixels. vec2 footprint = fwidth(fragWorldPos.xz); vec2 posDx = dFdx(fragWorldPos.xz); vec2 posDy = dFdy(fragWorldPos.xz); float orthoLod = textureQueryLod(orthoTexture, fragUV).x; if (distanceFade > 0.0) { // Rugosite pilotee par les donnees : contraste local de la photo et // pente LiDAR. Plancher de 0,5 : meme une prairie lisse a du grain, // sinon le sol le plus courant du jeu resterait l'aplat a corriger. vec3 orthoBlur = textureLod(orthoTexture, fragUV, orthoLod + 2.0).rgb; float photoContrast = length(ortho - orthoBlur) * clamp(ubo.terrain.z, 0.0, 1.0); float roughness = clamp(max(photoContrast / kDetailFullContrast, slope / kDetailFullSlope), 0.0, 1.0); float amplitude = detailStrength * distanceFade * mix(0.5, 1.0, roughness); // Empreinte d'un pixel au sol, en metres (le plus grand des deux axes : // en vue rasante, c'est l'axe de profondeur qui s'etire). float pixelMeters = max(footprint.x, footprint.y); float wavelength = max(ubo.detail.w, 0.01); float height = 0.0; vec2 gradient = vec2(0.0); for (int o = 0; o < kDetailOctaves; ++o) { // Nyquist : plein poids tant que la longueur d'onde couvre au moins // 4 pixels, eteint a 2 pixels. (Resserre a 8 -> 4 pendant la // chasse au cout, puis RETABLI : depuis que le bruit est une // texture mipmappee, une octave ne coute qu'une lecture et les // mipmaps filtrent deja le sous-pixel. La coupure a 8 px ne faisait // plus que retirer le grain fin.) HISTORIQUE : la premiere // version (4 -> 2 pixels) faisait tourner les 7 octaves sur tout le // sol proche et coutait +1 683 us par image au ras du sol (x1,94 sur // l'image entiere, Release) - pour des octaves de 5 et 11 mm qui // tombaient a 2-4 pixels, donc invisibles ou scintillantes. float nyquist = 1.0 - smoothstep(0.25, 0.5, pixelMeters / wavelength); // Les longueurs d'onde decroissent : une octave eteinte eteint // toutes les suivantes, inutile de continuer la boucle. if (nyquist <= 0.0) { break; } // Poids de hauteur proportionnel a la longueur d'onde : la PENTE de // chaque octave est alors comparable (n' / lambda * lambda), d'ou un // sol grenu a toutes les echelles plutot qu'ondule. float octaveWeight = wavelength / max(ubo.detail.w, 0.01); if (nyquist > 0.0) { // Decalage propre a chaque octave : sans lui, toutes les octaves // partageraient l'origine de la texture periodique. vec3 n = valueNoiseD(fragWorldPos.xz / wavelength + float(o) * vec2(7.31, 3.17), posDx / wavelength, posDy / wavelength); height += nyquist * octaveWeight * (n.x - 0.5); gradient += nyquist * n.yz; // = octaveWeight * lambda0 * (n'/lambda) } wavelength /= kDetailLacunarity; } // Pas de normalisation par la somme des poids ni par le nombre // d'octaves : la premiere version faisait les deux, et divisait ainsi // l'effet par ~7 avant meme d'appliquer sa force. La hauteur reste dans // [-0,9, 0,9] environ (somme geometrique des poids), la pente par // octave est comparable a toutes les echelles. height = clamp(height, -1.0, 1.0); gradient *= 0.5; // Normale : la surface y = h(x, z) a pour normale (-dh/dx, 1, -dh/dz). // On incline la normale du relief de ce gradient (approximation exacte // a plat, bonne jusqu'aux pentes de falaise). Nlit = normalize(N + amplitude * kDetailSlope * vec3(-gradient.x, 0.0, -gradient.y)); // Couleur : modulation autour de la photo, jamais remplacement. albedo *= 1.0 + amplitude * kDetailAlbedo * height; } // --- PHASE 25 : adret / ubac ------------------------------------------- // MODULATION de l'albedo (donc de l'orthophoto), jamais un remplacement : // la photo continue de porter tout le detail, elle est seulement rechauffee // ou refroidie. // // Pourquoi ca ne fait PAS double emploi avec le diffus de Blinn-Phong, qui // assombrit deja les versants a l'ombre : l'eclairage joue sur la // LUMINOSITE, cet indice joue sur la TEINTE. Un ubac faiblement eclaire et // un adret vu de loin dans la brume peuvent avoir la meme luminosite ; la // difference d'exposition, elle, reste lisible dans la couleur. C'est aussi // ce qui rend l'indice perceptible sur une orthophoto, qui est prise a la // verticale par temps clair et arrive donc deja "a plat". float aspectStrength = clamp(ubo.terrain.w, 0.0, 1.0); if (aspectStrength > 0.0) { // Les deux cosinus sont ecretes a zero, exactement comme dans // WeatherSystem::sampleAt : une surface qui tourne le dos au soleil ne // recoit pas un rayonnement negatif, elle n'en recoit pas. float incidence = max(dot(N, L), 0.0); float flatIncidence = max(L.y, 0.0); float aspectSignal = clamp((incidence - flatIncidence) / kAspectIncidenceReference, -1.0, 1.0); // -1 -> ubac franc, 0 -> ni l'un ni l'autre, +1 -> adret franc. vec3 tint = mix(kUbacTint, kAdretTint, 0.5 + 0.5 * aspectSignal); albedo *= mix(vec3(1.0), tint, aspectStrength); } // --- Blinn-Phong, identique a la Phase 2 ------------------------------- vec3 V = normalize(ubo.viewPos - fragWorldPos); vec3 H = normalize(L + V); // PHASE 27 : Nlit = normale du relief + micro-relief de pres (egale a N // partout ailleurs). L'indice adret/ubac ci-dessus garde N. float diffuse = max(dot(Nlit, L), 0.0); float specular = diffuse > 0.0 ? kSpecularStrength * pow(max(dot(Nlit, H), 0.0), kShininess) : 0.0; // 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 = albedo * kLightColor * (ambient + diffuse) + kLightColor * specular; outColor = vec4(applyFog(lit, fragWorldPos), 1.0); }