Fichiers
vercora/shaders/terrain.vert
T
theoetClaude Opus 5.5 58f7da7a82 Fusion de la branche cloud (optimisation des ressources) en Phase 32
Fusionne github/ccr-8fe70239-2xoxym (session cloud du 13-14/10) dans les
phases 30-31 faites sur le PC (rochers visibles, builds separes, densite
des rochers, demo candidate).

La phase cloud, nommee "Phase 30" dans ses commits, devient la Phase 32 :
- NOTES-PHASE30.md (add/add) : la version du PC (rochers) est gardee ;
  celle du cloud devient NOTES-PHASE32.md.
- MEMORY.md : sections 30 (rochers), 31, puis 32 (optimisation) dans
  l'ordre chronologique ; etat verifie en tete renomme fin de Phase 32.
- References a l'optimisation renommees Phase 32 dans README.md,
  NOTES-AUDIT-GLOBAL.md, les commentaires du code et les libelles de tests.
  Les references aux rochers (Phase 30 PC) sont inchangees.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 15:11:22 +02:00

138 lignes
6.8 KiB
GLSL

#version 450
// Meme bloc uniforme que les shaders du cube, avec des membres supplementaires
// en fin de bloc. Cote C++ il n'y a qu'une seule struct UniformBufferObject :
// les shaders declarent chacun la version tronquee du bloc qui leur suffit, ce
// qui est legal (la plage du descriptor peut etre plus grande que le bloc
// declare, jamais l'inverse).
layout(binding = 0) uniform UniformBufferObject {
mat4 view;
mat4 proj;
vec3 viewPos;
// x = altitude minimale du terrain, y = altitude maximale, zw = reserve.
// Passe par l'UBO plutot que code en dur : la coloration reste correcte
// quels que soient les parametres de generation (et demain, les vraies
// altitudes LiDAR, qui seront en metres NGF et pas du tout dans [0,16]).
vec4 terrain;
vec4 sun;
vec4 sunColor;
vec4 fog;
vec4 precip;
vec4 fall;
vec4 detail;
// PHASE 32 : la grille de la heightmap. x = origine (Heightmap::
// worldCoord(0)), y = pas en metres, z = nombre de CELLULES par cote.
vec4 terrainGrid;
} ubo;
// Meme push constant que cube.vert : les pipelines partagent la meme
// signature de layout, ce qui permet au Renderer de pousser la model matrix de
// la meme facon quel que soit le materiau.
// params.x = debut de la bande de geomorphing, params.y = fin, en metres depuis
// la camera. Bande vide (y <= x) = pas de morphing : c'est le cas du terrain
// dessine d'un seul bloc (option --no-lod).
// grid (PHASE 32) : place du maillage dans la grille de la heightmap -
// x, y = indices (ix, iz) du premier sommet, z = pas en echantillons entre deux
// sommets voisins, w = sommets par rangee. Voir renderer/DrawItem.hpp.
layout(push_constant) uniform PushConstants {
mat4 model;
vec4 params;
ivec4 grid;
} pc;
// PHASE 32 : 16 octets par sommet au lieu de 68 (renderer/GpuVertex.hpp,
// TerrainVertex). Le buffer ne porte plus que ce qui ne se DEDUIT pas de
// l'indice du sommet : les deux altitudes et les deux normales (x et z en
// snorm16, y reconstruit). Position horizontale, cible de morphing horizontale
// et UV sont recalcules ci-dessous ; la couleur de sommet valait toujours blanc.
layout(location = 0) in float inHeight;
layout(location = 1) in float inMorphHeight;
layout(location = 2) in vec2 inNormalXZ;
layout(location = 3) in vec2 inMorphNormalXZ;
layout(location = 0) out vec3 fragTint;
layout(location = 1) out vec3 fragNormal;
layout(location = 2) out vec3 fragWorldPos;
layout(location = 3) out vec2 fragUV;
// Une normale de champ de hauteur pointe toujours vers le haut : y se deduit de
// x et z. Meme formule que unpackTerrainNormal (renderer/GpuVertex.hpp).
vec3 decodeNormal(vec2 xz) {
return vec3(xz.x, sqrt(max(0.0, 1.0 - xz.x * xz.x - xz.y * xz.y)), xz.y);
}
void main() {
// --- Place du sommet dans la grille -----------------------------------
// gl_VertexIndex est l'indice LOCAL du sommet dans son maillage : le
// Renderer lie chaque maillage a son decalage dans le bloc partage plutot
// que de passer un vertexOffset au draw (voir Renderer::recordCommandBuffer).
// Les indices de grille sont ECRETES sur le bord du terrain exactement comme
// le fait TerrainNodeMesh.cpp, et la cible de morphing est le sommet aux
// indices locaux arrondis au pair inferieur (grille du parent).
const int perRow = pc.grid.w;
const int i = gl_VertexIndex % perRow;
const int j = gl_VertexIndex / perRow;
const int cells = int(ubo.terrainGrid.z);
const int gx = min(pc.grid.x + i * pc.grid.z, cells);
const int gz = min(pc.grid.y + j * pc.grid.z, cells);
const int mx = min(pc.grid.x + (i & ~1) * pc.grid.z, cells);
const int mz = min(pc.grid.y + (j & ~1) * pc.grid.z, cells);
// `precise` : interdit au compilateur de fusionner la multiplication et
// l'addition en un FMA. Sans lui le resultat pourrait differer d'un ULP de
// Heightmap::worldCoord ; avec lui il est identique AU BIT PRES (addition et
// multiplication flottantes sont correctement arrondies en Vulkan).
precise float x = ubo.terrainGrid.x + float(gx) * ubo.terrainGrid.y;
precise float z = ubo.terrainGrid.x + float(gz) * ubo.terrainGrid.y;
precise float morphX = ubo.terrainGrid.x + float(mx) * ubo.terrainGrid.y;
precise float morphZ = ubo.terrainGrid.x + float(mz) * ubo.terrainGrid.y;
const vec3 inPosition = vec3(x, inHeight, z);
const vec3 inMorphPos = vec3(morphX, inMorphHeight, morphZ);
// --- Geomorphing (CDLOD) ------------------------------------------------
// La distance est mesuree sur la position NON MORPHEE : c'est ce qui garantit
// qu'un sommet partage par deux tuiles voisines obtient le meme facteur des
// deux cotes, donc que le bord reste soude. Prendre la position morphee
// rendrait le calcul recursif et instable.
//
// Le terrain etant genere directement en espace monde avec une model matrix
// identite, inPosition EST deja la position monde ; le pc.model ci-dessous
// reste applique pour ne rien casser si un jour une tuile etait transformee.
float morphSpan = pc.params.y - pc.params.x;
float morph = 0.0;
if (morphSpan > 0.0) {
float distance = length(ubo.viewPos - inPosition);
morph = clamp((distance - pc.params.x) / morphSpan, 0.0, 1.0);
}
vec3 position = mix(inPosition, inMorphPos, morph);
vec3 normal = mix(decodeNormal(inNormalXZ), decodeNormal(inMorphNormalXZ), morph);
vec4 worldPos = pc.model * vec4(position, 1.0);
gl_Position = ubo.proj * ubo.view * worldPos;
fragWorldPos = worldPos.xyz;
// Teinte neutre, reservee a une future classification LiDAR par sommet :
// c'est la valeur que portaient tous les sommets de terrain jusqu'ici.
fragTint = vec3(1.0);
// L'UV n'est PAS morphe. Il est une fonction affine de la position dans la
// grille du terrain entier, donc la cible de morphing d'un sommet - qui est
// un autre noeud de cette meme grille - a naturellement l'UV de sa propre
// position. Interpoler entre les deux decalerait la photo par rapport au
// relief pendant la transition de niveau, exactement ce qu'on cherche a
// eviter. Le leger glissement de la texture qu'on pourrait attendre pendant
// un morph est en realite le comportement CORRECT : la surface se deforme,
// la photo reste accrochee a ses coordonnees geographiques. Meme expression
// que TerrainNodeMesh.cpp (indice de grille / nombre de cellules).
fragUV = vec2(float(gx), float(gz)) / float(cells);
// Le terrain est genere DIRECTEMENT en espace monde et son DrawItem porte la
// matrice IDENTITE : mat3(model) est donc exact ici sans discussion. Il
// redeviendrait faux si on appliquait au terrain une echelle verticale
// differente de l'horizontale - dans ce cas il faudrait transposer l'inverse
// cote CPU. Voir TerrainMesh.cpp.
fragNormal = mat3(pc.model) * normal;
}