Fichiers
vercora/shaders/terrain.vert
T
Claude 7f2d538768 Phase 30 (2/n) : geometrie compacte, pool de sous-allocation, early-Z
- Formats GPU : le format de travail Vertex (68 o) n'est plus televerse.
  Objets et vegetation : ObjectVertex 44 o (conversion exacte). Terrain :
  TerrainVertex 16 o (deux altitudes f32 + deux normales snorm16) ; x/z,
  cible de morphing et UV sont recalcules par terrain.vert depuis
  gl_VertexIndex et DrawItem::grid, au bit pres (`precise`).
- Topologie des tuiles televersee UNE fois, en uint16 (96 Ko de moins par
  tuile). Indices des maillages d'objets en uint16.
- GpuBufferPool + RangeAllocator : toute la geometrie dans des blocs de
  4 Mo ; ecriture DIRECTE en memoire unifiee (GPU integre, lavapipe),
  staging conserve sur GPU discret (--force-staging pour l'eprouver),
  barriere ecriture-apres-lecture ajoutee devant les copies (validation
  de synchronisation a zero).
- Rendu : terrain dessine apres la vegetation (early-Z) et culling de ses
  faces arriere.
- Tests : +16 verifications (formats, positions recalculees, allocateur).

Survol 900 m/s (lavapipe) : pic GPU 286 -> 89 Mo, geometrie terrain
188 -> 33 Mo, ~17 000 -> 21 vkAllocateMemory, streaming 4,5 -> 1,6 ms
par image. Foret : 8,3 -> 12,4 images/s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
2026-10-13 23:08:23 +00: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 30 : 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 30) : 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 30 : 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;
}