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>
Cette révision appartient à :
theoetClaude Opus 5.5 a révisé 2026-10-15 15:11:22 +02:00
révision 58f7da7a82
42 fichiers modifiés
+3424 -602

Aucun fichier ne correspond à votre recherche

+7
Voir le fichier
@@ -112,6 +112,7 @@ add_executable(vercora
src/core/Window.cpp
src/core/Camera.cpp
src/core/Paths.cpp
src/core/ProcessMemory.cpp
src/assets/ObjLoader.cpp
src/assets/Heightmap.cpp
src/assets/TerrainFile.cpp
@@ -153,6 +154,7 @@ add_executable(vercora
src/editor/SceneFile.cpp
src/renderer/VulkanContext.cpp
src/renderer/VulkanBuffer.cpp
src/renderer/GpuBufferPool.cpp
src/renderer/Mesh.cpp
src/renderer/TerrainMesh.cpp
src/renderer/TerrainNodeMesh.cpp
@@ -175,12 +177,17 @@ target_link_libraries(vercora PRIVATE
)
# GLFW_INCLUDE_VULKAN : GLFW inclut les headers Vulkan automatiquement.
# GLFW_INCLUDE_NONE : ... et PAS <GL/gl.h>, qu'il inclut sinon par defaut. Le
# moteur ne fait aucun OpenGL ; sous Windows l'en-tete vient avec le SDK et le
# defaut passait inapercu, mais sous Linux il exige les en-tetes Mesa
# (libgl-dev) pour rien. Les deux macros se combinent (voir glfw3.h).
# VERCORA_DEBUG : active les validation layers uniquement en configuration Debug.
# GLM_FORCE_RADIANS : GLM travaille en radians (evite les surprises d'unites).
# GLM_FORCE_DEPTH_ZERO_TO_ONE : Vulkan attend une profondeur clip dans [0,1]
# (et non [-1,1] comme OpenGL) -> indispensable pour un depth buffer correct.
target_compile_definitions(vercora PRIVATE
GLFW_INCLUDE_VULKAN
GLFW_INCLUDE_NONE
GLM_FORCE_RADIANS
GLM_FORCE_DEPTH_ZERO_TO_ONE
$<$<CONFIG:Debug>:VERCORA_DEBUG>
+78 -3
Voir le fichier
@@ -5,8 +5,10 @@ voir `NOTES-PHASE6.md`, `NOTES-PHASE7.md`, `NOTES-PHASE9.md`, `NOTES-PHASE10.md`
`NOTES-PHASE11.md`, `NOTES-PHASE12.md`, `NOTES-PHASE-VELO.md`,
`NOTES-PHASE-ESCALADE.md`, `NOTES-PHASE15.md`, `NOTES-PHASE16.md`,
`NOTES-PHASE17.md`, `NOTES-PHASE18.md`, `NOTES-PHASE19.md`,
`NOTES-PHASE20.md` et `NOTES-PHASE21.md` ; ce fichier est
`NOTES-PHASE20.md` a `NOTES-PHASE32.md` (plus `NOTES-PHASE28-DESIGN.md`,
`NOTES-PHASE29-DESIGN.md`) et l'audit `NOTES-AUDIT-GLOBAL.md` ; ce fichier est
un resume vivant, mis a jour a la fin de chaque session, pas un journal complet.
Le `README.md` a la racine donne le demarrage rapide (build, lancement, tests).
## Ce qu'est Vercora
@@ -22,6 +24,35 @@ MONDE - une partie normale les charge, les dessine et s'y cogne. Suite du
2026-08-23 : **F3/F4 selectionnent l'objet pose suivant/precedent SANS viser**
(detail plus bas, section Phase 15).
## Etat verifie (2026-10-15, fin de Phase 32 ; fusion des branches PC et cloud)
Ce bloc complete celui de la Phase 20 ci-dessous, qui reste vrai sauf mention.
- **Builds** : Windows inchange (`tools\build.bat`, `tools\run_logic_tests.bat`).
**Linux** depuis la Phase 32 : `cmake -S . -B build-rel -G Ninja
-DCMAKE_BUILD_TYPE=Release -DGLFW_BUILD_WAYLAND=OFF && ninja -C build-rel`
(GCC 13 / Clang 18). Les tests headless se compilent avec la meme liste de
sources que `run_logic_tests.bat`.
- **Tests headless** : 3 963 verifications sans les dalles LiDAR (25 de plus
avec elles). +20 en Phase 32 (formats GPU, allocateur, orthophoto par tranches).
- **Ressources** : chaque partie journalise `Ressources (PHASE 32)` au
chargement, toutes les 10 s et a la fermeture : RAM du processus, memoire GPU
exacte (toute allocation passe par `VulkanContext::allocateMemory`), blocs et
appels `vkAllocateMemory`, et occupation du pool de geometrie.
- **Format GPU** : `Vertex` (68 o) n'est plus que le format CPU ; le GPU lit
`ObjectVertex` (44 o) et `TerrainVertex` (16 o), dans les blocs de 4 Mo de
`GpuBufferPool`. Ecriture directe en memoire unifiee (UHD 770), staging sinon
(`--force-staging` pour l'eprouver).
- **Options ajoutees** : `--quit-after=S`, `--freeze-anim`, `--force-staging`,
`--vsync` (presentation FIFO, a prendre pour JOUER ; les mesures restent non
plafonnees).
- **Validation de synchronisation** : la variable qui fonctionne avec les couches
1.3.275 est `VK_LAYER_ENABLES=VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT`.
- **Sans GPU ni donnees** (session cloud) : lavapipe + Xvfb, zone proxy par
`tools/make_bench_zone.py`. Recette complete : NOTES-PHASE32.md section 9.
- **Comparaisons d'images** : ajouter `--no-wildlife` (la faune bouge en temps
reel) en plus de `--lock-input --look --time-scale=0 --freeze-anim`.
## Etat verifie (2026-08-26, fin de Phase 20)
- **GPU DE CETTE MACHINE : Intel UHD 770 integree.** Il n'y a plus de GTX 960
@@ -1675,7 +1706,10 @@ Deux points rouges, aucun imputable a la phase :
collision, catalogue, placement et serialisation sont deja agnostiques du
format. Compter un analyseur JSON, le conteneur `.glb`, les accesseurs et
l'aplatissement de la hierarchie de noeuds.
0bis. **Paralleliser la construction des tuiles** (Phase 18) : c'est 83 % du
0bis. (Phase 32 : une tuile interieure se construit desormais sans relecture -
~104 us en Release lavapipe - et s'ecrit directement en memoire GPU, sans
MeshData ni copie : le gain a attendre du parallelisme a encore baisse.)
**Paralleliser la construction des tuiles** (Phase 18) : c'est 83 % du
cout d'une tuile apres les optimisations exactes de cette phase, et
`terrainNodeMeshData` est deja PURE. Le seul obstacle est
`Renderer::addMesh`, qui doit rester sur le thread de rendu.
@@ -1686,7 +1720,10 @@ Deux points rouges, aucun imputable a la phase :
3. ~~Transfert asynchrone des tuiles de terrain.~~ **FAIT EN PHASE 12.** Le
verrou suivant est le **maillage CPU d'une tuile**, toujours synchrone sur le
thread de rendu : un thread de maillage dedie est la suite logique.
4. **Index buffer partage** entre toutes les tuiles, et **sommet allege** (delta
4. ~~**Index buffer partage** et **sommet allege**~~ **FAITS EN PHASE 32**
(topologie uint16 unique, TerrainVertex de 16 o). Suite possible : tirer
les altitudes d'un SSBO (16 -> ~4,5 o/sommet), voir NOTES-PHASE32.md.
Texte d'origine : **Index buffer partage** entre toutes les tuiles, et **sommet allege** (delta
de morphing plutot que position complete) : deux economies faciles, chiffrees
dans NOTES-PHASE10.md. Le partage de l'index buffer economiserait aussi
98 Ko par tuile epinglee.
@@ -2686,3 +2723,41 @@ Tests **3807/3807** (3636 avant), 0 `[Validation]` au demarrage.
- Demo : `dist\VercoraDemo-candidate(.zip)` = 110,7 Mio, avec les 4 cartes de couvert et
`precip.*.spv` ; teste depuis I: et OK. `dist\VercoraDemo` NON remplace (decision
utilisateur). `deploy_beta_to_desktop.ps1` est a revoir.
## PHASE 32 (2026-10-13/14) - optimisation des ressources (detail : NOTES-PHASE32.md)
Session cloud (Linux, sans GPU ni donnees LiDAR) : mesure sous **lavapipe +
Xvfb** (rendu logiciel DETERMINISTE : deux runs identiques = 0 pixel
d'ecart, donc preuves au bit pres possibles) sur une **zone proxy** a la
vraie echelle (`tools/make_bench_zone.py` : relief fBm 5001 x 5001, georef
et altitudes de la vraie zone, couvert tire de l'orthophoto versionnee).
Les chiffres sont comparables avant/apres, PAS a ceux de l'UHD 770.
- **Build Linux** : GCC 13 / Clang 18 (`= {}` sur struct imbriquee ->
surcharges, CWG 1397 ; `GLFW_INCLUDE_NONE`). `cmake -G Ninja
-DGLFW_BUILD_WAYLAND=OFF`. Tests 3 963 / 3 963 (+20).
- **Instrumentation** : toute memoire GPU via `VulkanContext::allocateMemory`
(comptee), RAM via `core/ProcessMemory`, ligne `Ressources (PHASE 32)` au
chargement / toutes les 10 s / en fin de partie. Options `--quit-after=S`,
`--freeze-anim`, `--force-staging`, `--vsync`.
- **Geometrie** : `Vertex` (68 o) reste le format CPU ; GPU = `ObjectVertex`
44 o (exact) et `TerrainVertex` 16 o (x/z/UV/morph recalcules par
terrain.vert depuis `gl_VertexIndex` + `DrawItem::grid`, `precise`).
Topologie des tuiles partagee en uint16. `GpuBufferPool` (blocs 4 Mo) :
ecriture DIRECTE en memoire unifiee, staging + barriere VERTEX_INPUT ->
TRANSFER sinon. Tuiles interieures construites sans relecture (bit a bit).
- **Rendu** : terrain dessine en DERNIER (early-Z) + culling de ses faces
arriere. Orthophoto lue par tranches dans un staging de 4 Mo reutilise.
- **Bilan survol 900 m/s** : pic GPU 285 -> 87 Mo, terrain 188 -> 33 Mo,
vkAllocateMemory ~17 000 -> 22, streaming 4,3 -> 0,93 ms/image.
Foret : pic GPU 103 -> 56 Mo, +44 % d'images/s (lavapipe). Chargement :
pic RAM -68 Mo, pic GPU 89 -> 50 Mo.
- **Image** : quantification des normales (+/- 1 niveau sur ~0,04 % des
pixels), egalites de profondeur aux pieds des brins/troncs (24 px), et
~250 px isoles sur parois rasantes (culling). Staging, parallele, ortho,
tuiles rapides : identiques au bit pres a ce qu'ils remplacent.
- **Validation** : 0 message (standard ET synchronisation, chemins direct et
staging). Controle negatif : sans la barriere, 414 SYNC-HAZARD en survol.
- **PIEGE** pour les comparaisons d'images : la FAUNE bouge en temps reel ;
comparer avec `--no-wildlife`, sinon un animal deplace fait 6-11 pixels.
- **A faire sur la machine de dev** : re-mesurer en Release sur l'UHD 770
(profile_phase27/29.ps1, run_vulkan_check.ps1 complet).
+14
Voir le fichier
@@ -116,3 +116,17 @@ Le projet Vercora est sur des fondations techniques saines, stables et vérifié
3. **Écosystème Faune & Flore :**
- Comportements étendus de la faune (troupeaux, pâturage, cycles repos/déplacement selon l'heure météo).
- Cueillette de baies / champignons selon l'humidité et le couvert forestier.
---
## Suite donnee (Phase 32, 2026-10-13)
L'optimisation des ressources de `NOTES-PHASE32.md` reprend ce rapport :
- **D6** (heightmap entiere en RAM) : examine et CONSERVE - c'est la verite
physique, et ses altitudes ne se codent pas sans perte sur 16 bits.
- Les postes que cet audit ne chiffrait pas (format de sommet de 68 o,
topologie recopiee par tuile, une allocation Vulkan par buffer, staging en
memoire unifiee) sont traites : pic GPU du survol 285 -> 87 Mo,
~17 000 -> 22 `vkAllocateMemory` en 30 s.
- Le projet compile aussi sous Linux (GCC, Clang) et se mesure sans GPU
(lavapipe), voir `README.md`.
+312
Voir le fichier
@@ -0,0 +1,312 @@
# Phase 32 - Optimisation des ressources (memoire GPU, RAM, allocations, CPU)
Session du 2026-10-13, en environnement cloud (Linux, sans GPU). Demande : un
plan d'optimisation des ressources "a l'octet pres", une revue du noyau moteur
et Vulkan, un banc de mesure, l'execution du plan, puis une re-mesure.
Ce fichier a deux parties : le PLAN (ecrit avant de toucher au moteur, avec la
mesure de reference) et le BILAN (apres execution, meme banc). Detail des
chiffres bruts : section "Banc de mesure".
---------------------------------------------------------------------------
## 1. Comment mesurer sans la machine de developpement
Pas de GPU, pas de Windows, pas de donnees LiDAR (le proxy reseau refuse
data.geopf.fr). Il a donc fallu :
- **Builder sous Linux.** Deux defauts de portabilite l'empechaient :
- `Heightmap(const Params& = {})`, `TerrainQuadtree(..., const Params& = {})`
et `TerrainStreamer(..., const Params& = {})` : un argument par defaut qui
construit une struct IMBRIQUEE a initialiseurs de membres est refuse par GCC
et Clang (CWG 1397), accepte par MSVC. Remplace par une surcharge qui
delegue (meme semantique, `explicit` conserve).
- `<GLFW/glfw3.h>` incluait `<GL/gl.h>` (present avec le SDK Windows, absent
sans libgl-dev sous Linux). `GLFW_INCLUDE_NONE` ajoute a cote de
`GLFW_INCLUDE_VULKAN`.
Le projet compile desormais sans avertissement nouveau avec GCC 13 (Release
et Debug), et les tests headless passent avec Clang 18.
- **Un GPU logiciel** : lavapipe (Mesa 25.2, Vulkan 1.4) sous Xvfb 1280x720.
Les couches de validation Khronos tournent dessus. Le rendu y est
DETERMINISTE : deux executions identiques donnent 0 pixel different, ce qui
permet de prouver au bit pres qu'une optimisation ne change pas l'image.
- **Une zone proxy a la vraie echelle** : `tools/make_bench_zone.py` ecrit un
relief fBm de 5001 x 5001 au pas de 1 m avec la georeference et la plage
d'altitudes de la vraie zone (l'orthophoto versionnee s'y applique), et des
cartes de couvert tirees de l'orthophoto elle-meme. Le quadtree (8 380
noeuds), le streaming, la vegetation et tous les budgets memoire y
travaillent a la vraie echelle. Le relief n'est pas le Vercors : les
chiffres sont comparables ENTRE EUX (avant/apres), pas a ceux de l'UHD 770.
Outillage ajoute au jeu pour ce banc (et utilisable sur la machine de dev) :
| ajout | role |
|---|---|
| `VulkanContext::allocateMemory / freeMemory` | TOUTE la memoire GPU passe par le contexte, qui la compte : octets vivants, pics, blocs vivants, appels `vkAllocateMemory` |
| `core/ProcessMemory` | RAM residente et pic du processus, lus au systeme (`/proc/self/status` sous Linux, `GetProcessMemoryInfo` sous Windows) |
| ligne `Ressources ... (PHASE 32)` | au chargement, toutes les 10 s, et en fin de partie (pics de session) |
| `--quit-after=S` | fermeture propre apres S s de boucle : tous les bilans sont ecrits (remplace le WM_CLOSE poste de l'exterieur) |
| `--freeze-anim` | fige l'horloge d'animation des shaders (herbe, pluie) : images comparables au pixel |
Scenarios (Release, `--lock-input --hour=13 --time-scale=0 --freeze-anim`,
30 s de boucle, deux passages chacun) :
- **foret** : a pied dans la foret sud (`--start=901800,6435800 --look=0,-8`) ;
- **panorama** : depuis le point culminant, vue lointaine sur la zone
(`--start=900175,6438524 --look=45,-6`) ;
- **survol** : `--flythrough=900,120`, le cas de stress du streaming.
## 2. Mesure de reference (avant toute optimisation)
| | foret | panorama | survol |
|---|---:|---:|---:|
| memoire GPU en fin de partie | 75,0 Mo | 71,6 Mo | 251-256 Mo |
| pic memoire GPU | 102,6 Mo | 96,6 Mo | **283-286 Mo** |
| dont geometrie de terrain (pic) | 27 Mo / 74 tuiles | 24 Mo / 67 tuiles | **188 Mo / 512 tuiles** |
| blocs `vkAllocateMemory` vivants (pic) | 436 | 408 | 1 374 |
| appels `vkAllocateMemory` sur la session | 439 | 411 | **~17 000** |
| construction d'une tuile (geometrie + televersement) | 167 + 210 us | 194 + 207 us | 202 + 219 us |
| streaming terrain, CPU par image | 119 us | 58 us | **4,1-4,5 ms** |
| RAM (pic, lavapipe compris) | 463 Mo | 353 Mo | 606 Mo |
| images/s (lavapipe, CPU) | 8,2 | 19,5 | 14,5 |
Validation : 0 message sur les trois scenarios (Debug + couches Khronos).
Repartition de la RAM du moteur (heaptrack, scenario foret) : la heightmap
1 m (100 Mo de float) et les quatre cartes de vegetation (16 Mo) font
l'essentiel ; tout le reste du moteur (quadtree 1 Mo, caches de vegetation
< 1 Mo, maillages CPU transitoires) pese moins de 3 Mo. Le reste du processus
est lavapipe lui-meme (tramage logiciel, JIT LLVM) et n'existe pas sur l'UHD 770.
## 3. Revue du noyau moteur et Vulkan
Ce qui est BIEN et ne bouge pas :
- synchronisation : 2 images en vol, semaphore de fin de rendu par image de
swapchain, fences, dependance de subpass corrigee en Phase 12 - correct ;
- une seule soumission par image, copies enregistrees en tete du command
buffer avec UNE barriere (Phase 12) - le bon choix sur un GPU sans file de
transfert dediee ;
- descriptor sets alloues une fois, aucun `vkUpdateDescriptorSets` par image ;
- push constants pour le par-objet, instanciation pour la vegetation,
orthophoto deja en BC1 avec mipmaps precalculees ;
- aucune allocation de tas notable par image cote moteur (heaptrack).
Ce qui COUTE, par ordre d'importance mesuree :
1. **Le format de sommet unique de 68 octets.** Tout passe par `Vertex`
(position, couleur, normale, UV, et 24 octets de cible de geomorphing).
Une tuile de terrain = 4 225 sommets x 68 o = 287 Ko, alors que le terrain
n'a besoin que de DEUX altitudes et DEUX normales par sommet : x, z et UV
se deduisent de l'indice du sommet, la couleur est constante (blanc).
Les maillages d'objets, eux, portent 24 octets de morphing qu'aucun de
leurs shaders ne lit.
2. **Une topologie recopiee par tuile.** Les 24 576 indices sont identiques
pour toutes les tuiles (l'en-tete de TerrainNodeMesh le dit depuis la
Phase 10) mais chaque tuile en televerse sa copie : 96 Ko par tuile, en
uint32 alors que 4 225 sommets tiennent en uint16.
3. **Une allocation Vulkan par buffer.** 2 par maillage, plus 2 de staging par
televersement : ~17 000 `vkAllocateMemory` en 30 s de survol. C'est un
appel noyau sous Windows (WDDM), arrondi a sa granularite d'allocation, et
plafonne par `maxMemoryAllocationCount` (souvent 4 096) - le plafond de 512
tuiles residentes n'existait que pour lui.
4. **Un staging inutile en memoire unifiee.** Sur l'UHD 770 (et lavapipe), la
memoire device-local EST mappable : ecrire la tuile directement la ou le
GPU la lit evite un buffer staging, une copie GPU et une barriere par tuile.
5. **Le chargement de l'orthophoto** tient trois copies de 42 Mo en meme
temps (fichier lu en RAM, staging, image GPU).
6. **Le terrain est dessine AVANT la vegetation**, sans culling des faces
arriere : en foret, le shader de terrain (le plus lourd du jeu) est execute
pour des pixels que les troncs et houppiers recouvrent ensuite.
7. **La construction d'une tuile lit chaque altitude ~6 fois** (cinq lectures
ecretees par echantillon, plus la grille du parent).
## 4. Le plan
Chaque point dit ce qu'il gagne, ce qu'il risque, et COMMENT on prouve qu'il ne
casse rien. Regle du projet appliquee : ce qui doit etre invisible est verifie
AU PIXEL PRES contre la reference (lavapipe est deterministe) ; ce qui change
l'image est chiffre en pixels touches et en ecart maximal.
| # | chantier | gain attendu | image | preuve |
|---|---|---|---|---|
| P1 | Terrain : sommet compact 16 o (2 altitudes f32 + 2 normales snorm16), x/z/UV deduits de l'indice du sommet, indices PARTAGES en uint16 | geometrie terrain -82 % (385 Ko -> 68 Ko par tuile) | normales quantifiees a 3e-5 pres : ecart d'arrondi | tests : altitudes au bit pres, normales a 1/32767 pres ; captures |
| P2 | Pool de sous-allocation (blocs de 4 Mo, premier ajustement) pour TOUTE la geometrie, liberation differee comme avant | ~17 000 -> quelques dizaines d'allocations ; fin des petits blocs | aucun | captures au bit pres ; validation |
| P3 | Ecriture DIRECTE en memoire unifiee (GPU integre/CPU), staging conserve sur GPU discret (`--force-staging` pour l'eprouver) | plus de staging ni de copie par tuile | aucun | captures identiques dans les deux modes |
| P4 | Maillages d'objets : format GPU de 44 o (sans les 24 o de morphing), exact | -35 % sur ces maillages | aucun | au bit pres |
| P5 | Orthophoto lue directement dans le staging | -42 Mo de pic RAM au chargement, une copie de 42 Mo en moins | aucun | au bit pres |
| P6 | Ordre de dessin objets -> vegetation -> terrain (early-Z) + culling des faces arriere du terrain | moins de fragments de terrain ombres | aucun (opaque, test LESS) | au bit pres |
| P7 | Tuile : altitudes lues UNE fois (grille bordee), chemin de reference garde pour les bords | geometrie de tuile ~-50 % CPU | aucun | test : bit a bit identique a la reference sur toutes les tuiles |
NON RETENU, et pourquoi :
- **Quantifier la heightmap** (100 Mo -> 50 Mo en uint16) : elle est la verite
PHYSIQUE (collision, marche, velo, escalade, semis). Les altitudes ne sont
pas des centimetres ronds (mediane paire, bouchage, raccords de dalles) : il
n'existe pas de codage 16 bits sans perte. 100 Mo est le prix de l'exactitude.
- **Cartes de vegetation en uint8** (16 -> 4 Mo) : le semis est deterministe
et compare la densite a des seuils ; quantifier deplacerait des arbres.
- **InstanceData 28 -> 20 o** : `variation` porte un entier code (gradient des
rochers, Phase 29) qui ne survit pas a un demi-flottant ; le gain (~100 Ko
par image) ne vaut pas le risque.
- **Abandonner le niveau 0 de l'orthophoto** (-32 Mo) : 0,61 -> 1,22 m/texel,
une perte de qualite visible a pied.
- **Tirer les altitudes d'un SSBO** (vertex pulling, 16 -> ~4,5 o/sommet) :
25 Mo de mieux au pic du survol, pour un changement de modele d'entree, un
descripteur de plus et un shader a bords exacts. A reprendre si le pas
LiDAR s'affine.
---------------------------------------------------------------------------
## 5. Execution : ce qui a ete fait
Cinq commits sur la branche, chacun valide avant le suivant (tests headless,
couches de validation Khronos, comparaison d'images au pixel pres).
### P6 - ordre de dessin et culling (Renderer, Pipeline)
- Ordre objets -> vegetation -> TERRAIN (`kDrawOrder`). Le shader de fragment
du terrain est le plus lourd du jeu ; dessine en dernier, ses fragments
caches par les troncs et l'herbe sont ecartes par le test de profondeur
precoce. Foret : -26 % de temps de rendu a lui seul.
- `ShaderSet::cullBackFaces`, terrain seulement (champ de hauteurs : un oeil
au-dessus du relief rencontre toujours une face avant d'abord).
`frontFace = COUNTER_CLOCKWISE` une fois l'axe Y de la projection retourne,
verifie par le calcul d'aire de la spec ET a l'image.
### P1 a P4 - geometrie compacte et pool (GpuVertex, GpuBufferPool, Mesh)
- `renderer/GpuVertex.hpp` : `ObjectVertex` (44 o, conversion exacte de
`Vertex`) et `TerrainVertex` (16 o : altitude, altitude cible, normales x/z
en snorm16). `Vertex` (68 o) reste le format de TRAVAIL cote CPU : aucun
generateur ni aucun test n'a change de format.
- `terrain.vert` recalcule x/z, la cible de morphing et l'UV depuis
`gl_VertexIndex` et `DrawItem::grid` (ix0, iz0, pas, sommets par rangee) +
`UniformBufferObject::terrainGrid` (origine, pas, cellules). `precise`
interdit la fusion en FMA : les positions sont celles de
`Heightmap::worldCoord` au bit pres (verifie en C++ par les tests).
- Topologie des tuiles televersee UNE fois en uint16 (`addSharedIndices`) ;
indices des objets en uint16 ; une seule liaison d'indices par image pour
tout le terrain (`bindMesh` saute les liaisons redondantes).
- `GpuBufferPool` (blocs de 4 Mo, `RangeAllocator` premier ajustement, bloc
dedie au-dela d'un demi-bloc, un bloc vide garde en reserve) : un `Mesh` ne
possede plus de buffer mais des PLAGES, rendues au pool par le meme retrait
differe qu'avant (kMaxFramesInFlight + 1 images).
- Memoire unifiee + GPU integre ou logiciel (`preferDirectGeometryWrites`) :
blocs mappes, la geometrie est ECRITE la ou le GPU la lit - ni staging, ni
copie, ni barriere. GPU discret : staging de la Phase 12, avec une barriere
d'execution VERTEX_INPUT -> TRANSFER avant les copies (une plage recyclee a
ete lue par des images precedentes). `--force-staging` eprouve ce chemin.
- `writeTerrainNodeVertices` : les sommets d'une tuile ecrits directement au
format compact (plus de `MeshData` de 287 Ko par tuile, plus de copie).
`terrainNodeMeshData` reste la reference testee : les deux partagent le meme
parcours (`forEachNodeVertex`), ils ne peuvent pas diverger.
- `--no-lod` : `terrainGpuMeshData` produit directement le format compact
(1,7 Go de `MeshData` en moins au pic sur la zone au pas de 1 m).
### P5 - orthophoto (TextureFile, Texture)
- `loadTextureFileHeader` + `readTexturePayload` (entier ou par tranche) ;
`loadTextureFile` en est la composition.
- `Texture` remplit son staging par une source et le REUTILISE par bandes de
rangees de blocs (4 Mo au plus) au lieu d'un staging de toute la chaine.
L'orthophoto n'est plus jamais tenue en RAM.
### P7 - construction des tuiles interieures (TerrainNodeMesh)
- Loin du bord, les altitudes sont lues une fois dans une grille bordee de
deux rangs, puis les MEMES operations flottantes que `sampleGrid`. Bords et
temoin `--no-tile-cache` : chemin de reference.
### En plus du plan
- `--vsync` : presentation FIFO. Le plus gros levier de CONSOMMATION (378
images/s sur l'UHD 770 = GPU a 100 % pour un ecran a 60 Hz). Non active
par defaut : les mesures du projet comptent des images non plafonnees.
- Ligne `Ressources (PHASE 32)` completee par le bilan du pool de geometrie.
- Televersements surs en cas d'echec d'allocation : le `Mesh` possede ses
plages des leur reservation, et aucune copie n'est confiee a l'image
suivante avant que toutes les ecritures du maillage aient reussi.
- Le C4244 connu de main.cpp (Phase 27, `groundDetailPattern`) : conversion
rendue explicite, meme valeur.
## 6. Bilan chiffre (meme banc, memes scenarios, moyenne de 2 passages)
Release, lavapipe, 1280 x 720, zone proxy. "RAM" inclut ici la memoire GPU
(lavapipe l'alloue dans le processus) : sur l'UHD 770 elle n'y figure pas.
| | foret avant | foret apres | panorama avant | panorama apres | survol avant | survol apres |
|---|---:|---:|---:|---:|---:|---:|
| memoire GPU, fin de partie | 75,0 Mo | **55,5 Mo** | 71,6 Mo | **54,6 Mo** | 254 Mo | **86,7 Mo** |
| memoire GPU, pic de session | 102,6 Mo | **55,5 Mo** | 96,6 Mo | **54,6 Mo** | 285 Mo | **86,7 Mo** |
| dont geometrie de terrain (pic) | 27 Mo | **4 Mo** | 24 Mo | **4 Mo** | 188 Mo | **33 Mo** |
| blocs vkAllocateMemory vivants (pic) | 436 | **10** | 408 | **10** | 1 366 | **18** |
| appels vkAllocateMemory (session) | 439 | **13** | 411 | **13** | ~16 950 | **22** |
| pic RAM au chargement | 302 Mo | **233 Mo** | 302 Mo | **234 Mo** | 302 Mo | **234 Mo** |
| pic memoire GPU au chargement | 89,2 Mo | **50,5 Mo** | 89,2 Mo | **50,5 Mo** | 89,2 Mo | **50,5 Mo** |
| temps de chargement | 0,48 s | **0,38 s** | 0,47 s | **0,38 s** | 0,47 s | **0,38 s** |
| pic RAM de session | 463 Mo | **409 Mo** | 353 Mo | **312 Mo** | 605 Mo | **374 Mo** |
| tuile : geometrie | 167 us | **142 us** | 194 us | **139 us** | 202 us | **105 us** |
| tuile : televersement | 210 us | **0,5 us** | 207 us | **0,6 us** | 219 us | **0,7 us** |
| streaming terrain, CPU par image | 119 us | **45 us** | 58 us | **35 us** | 4,3 ms | **0,93 ms** |
| temps de rendu (drawFrame) | 120 ms | **83 ms** | 51 ms | **43 ms** | 62 ms | **52 ms** |
| images/s (lavapipe) | 8,2 | **11,8 (+44 %)** | 19,4 | **22,7 (+17 %)** | 14,6 | **18,0 (+24 %)** |
Les images/s et le temps de rendu sont ceux d'un GPU LOGICIEL : ils disent le
sens et l'ordre de grandeur du gain (moins de fragments de terrain ombres,
moins d'octets lus par sommet), pas le chiffre de l'UHD 770. Les octets, les
allocations et les couts CPU de construction, eux, ne dependent pas du GPU.
Maillages d'objets (27 maillages, 4 070 sommets, 1 504 triangles) : 295 Ko ->
188 Ko (-36 %), en 1 bloc au lieu de 54 allocations (et 54 de staging).
## 7. Verification
- **Tests headless** : 3 963 / 3 963 (3 943 avant : +20 verifications),
compiles avec GCC 13 (0 avertissement en -Wall -Wextra) et Clang 18. Les
25 verifications qui ont besoin des vraies dalles LiDAR sont ignorees ici,
comme toujours sans elles.
- **Validation Khronos** (Debug) : 0 message sur foret, panorama et survol ;
**validation de synchronisation** : 0 message, chemins direct ET staging.
Controle negatif : sans la barriere VERTEX_INPUT -> TRANSFER, 414 messages
SYNC-HAZARD-WRITE-AFTER-READ en 30 s de survol avec `--force-staging`.
- **Images** (sans faune : les animaux bougent en temps reel, leur position
depend du nombre d'images rendues) :
- foret : 353 pixels sur 921 600 (0,038 %) ; 329 a +/- 1 niveau
(normales quantifiees) et 24 aux pieds des brins et des troncs, la ou leur
profondeur EGALE celle du sol. Preuve : une variante qui rend ces egalites
au terrain redonne l'image de reference au bit pres ;
- panorama : 1 149 pixels (0,125 %), dont ~250 isoles sur les parois quasi
verticales vues en rasant (culling, voir ShaderSet::cullBackFaces) ;
- chemin staging (`--force-staging`), maillage parallele
(`--tile-threads=4`), orthophoto par tranches, chemin rapide des tuiles :
chacun IDENTIQUE au bit pres au chemin qu'il remplace ;
- `--no-lod` et LOD : identiques entre eux sur le terrain synthetique.
## 8. Ce qui reste, et pour qui
- **A re-mesurer sur l'UHD 770** : les images/s Release (`profile_phase27.ps1`,
`profile_phase29.ps1`) et `run_vulkan_check.ps1` complet. Les lignes
`Ressources (PHASE 32)` donnent desormais la memoire GPU exacte dans le
journal de chaque scenario.
- **Staging sur GPU discret** : un staging (une allocation) par
televersement, comme avant la phase. Un anneau de staging persistant
ramenerait ce chemin au niveau du chemin direct ; non ecrit faute de GPU
discret pour l'eprouver.
- **Vertex pulling du terrain** (16 -> ~4,5 o par sommet) : 25 Mo de mieux au
pic du survol. Voir section 4.
- **Cache de pipelines** (`VkPipelineCache` sur disque) : demarrage plus
rapide sur un pilote sans cache propre ; le pilote Intel en a un.
- **CPU par image** : le profil (perf) ne montre plus que le semis de l'herbe
et des arbres (Phase 18) ; rien d'autre au-dessus du bruit.
## 9. Reproduire
# Linux : dependances (Ubuntu 24.04)
apt-get install mesa-vulkan-drivers libvulkan-dev glslc vulkan-validationlayers \
ninja-build libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev \
libxkbcommon-dev xvfb imagemagick python3-numpy
cmake -S . -B build-rel -G Ninja -DCMAKE_BUILD_TYPE=Release -DGLFW_BUILD_WAYLAND=OFF
ninja -C build-rel
python3 tools/make_bench_zone.py # sans les vraies donnees seulement
Xvfb :99 -screen 0 1280x720x24 &
DISPLAY=:99 VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/lvp_icd.json \
build-rel/vercora assets/terrain/vercora_zone_1m.vchm --lock-input \
--hour=13 --time-scale=0 --freeze-anim --start=901800,6435800 \
--look=0,-8 --quit-after=30
# puis lire les lignes "Ressources", "Cout par image", "Construction de tuiles"
# validation de synchronisation : Debug + VK_LAYER_ENABLES=
# VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT
+88
Voir le fichier
@@ -0,0 +1,88 @@
# Vercora
Jeu d'exploration de montagne solo (marche, abattage et taillage, velo,
parapente, escalade, faune, meteo, artisanat) sur une zone LiDAR reelle de
25 km2 du Vercors. Moteur maison C++20 / Vulkan, GLFW, CMake ; Windows et Linux.
Ce fichier est le demarrage rapide. L'etat du projet est dans `MEMORY.md`, le
detail de chaque phase dans `NOTES-PHASE*.md` (la derniere : `NOTES-PHASE32.md`,
optimisation des ressources).
## Construire
Prerequis communs : CMake >= 3.20, Ninja, un compilateur C++20, le SDK Vulkan
(en-tetes, chargeur, `glslc`, couches de validation). GLFW, GLM et
tinyobjloader sont telecharges par CMake dans `external/`.
**Windows** (machine de developpement) :
tools\build.bat :: Debug, couches de validation actives
tools\build.bat Release
**Linux** (Ubuntu 24.04) :
sudo apt-get install libvulkan-dev glslc vulkan-validationlayers ninja-build \
libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libxkbcommon-dev
cmake -S . -B build-rel -G Ninja -DCMAKE_BUILD_TYPE=Release -DGLFW_BUILD_WAYLAND=OFF
ninja -C build-rel
La configuration Debug definit `VERCORA_DEBUG`, seule a activer les couches de
validation Vulkan.
## Donnees
Les dalles LiDAR et les grilles `.vchm` ne sont pas versionnees ; seule
l'orthophoto `assets/terrain/vercora_zone_ortho.vcto` l'est. Les produire :
`tools/fetch_dalles.py`, `tools/lidar_to_heightmap.py`,
`tools/assemble_terrain.py`, `tools/lidar_to_canopy.py` (voir leurs en-tetes).
Sans elles, le jeu retombe sur un terrain synthetique.
Pour MESURER sans les vraies donnees (session cloud, nouveau poste),
`python3 tools/make_bench_zone.py` ecrit une zone proxy a la vraie echelle
(relief synthetique, couvert tire de l'orthophoto). Il refuse d'ecraser des
fichiers existants sans `--force`.
## Lancer
vercora assets/terrain/vercora_zone_1m.vchm # zone 25 km2, jeu complet
vercora --demo # demo : marche et vol libre
vercora terrain # terrain synthetique
Options utiles (liste complete en tete de `src/main.cpp`) :
| option | effet |
|---|---|
| `--vsync` | presentation calee sur l'ecran : le reglage pour JOUER (consommation) |
| `--start=E,N --look=yaw,pitch --lock-input` | vue reproductible (Lambert 93) |
| `--hour=H --day=D --time-scale=0` | heure et meteo figees |
| `--freeze-anim` | animation des shaders figee (captures comparables au pixel) |
| `--quit-after=S` | fermeture propre apres S s, bilans de fin ecrits |
| `--flythrough=V[,H]` | survol scripte (stress du streaming) |
| `--no-lod`, `--no-vegetation`, `--no-wildlife`, ... | temoins de mesure |
| `--force-staging` | televersement par staging meme en memoire unifiee |
Chaque partie journalise ses couts (`Cout par image`, `Cadence de boucle`,
`Construction de tuiles`) et ses ressources (`Ressources (PHASE 32)` : RAM,
memoire GPU exacte, allocations Vulkan, pool de geometrie).
## Tester
- **Logique, sans GPU** : `tools\run_logic_tests.bat` (Windows). Sous Linux,
compiler `tests/logic_tests.cpp` avec la liste de sources de ce script.
- **Vulkan reel** : `tools\run_vulkan_check.ps1` (scenarios A a J, `-Only` pour
un sous-ensemble). Contrat du projet : zero message `[Validation]`.
- **Synchronisation** : Debug avec
`VK_LAYER_ENABLES=VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT`.
- **Sans GPU (Linux)** : lavapipe (`mesa-vulkan-drivers`) sous Xvfb ; le rendu y
est deterministe. Recette : `NOTES-PHASE32.md`, section 9.
## Arborescence
src/core fenetre, camera, collisions, chemins, memoire du processus
src/assets heightmap, formats .vchm / .vcto, chargeur .obj
src/renderer Vulkan : contexte, pool de geometrie, streaming du terrain, rendu
src/world terrain, vegetation, faune, meteo, activites, artisanat
src/editor editeur de niveau (F2)
shaders/ GLSL compiles en SPIR-V par CMake
tools/ build, tests, harnais Vulkan, preparation des donnees
tests/ tests headless de la logique de jeu
+74 -28
Voir le fichier
@@ -1,10 +1,10 @@
#version 450
// Meme bloc uniforme que les shaders du cube, avec un membre supplementaire en
// fin de bloc (terrain). Cote C++ il n'y a qu'une seule struct
// UniformBufferObject : les shaders du cube declarent simplement une version
// tronquee du bloc, ce qui est legal (la plage du descriptor peut etre plus
// grande que le bloc declare, jamais l'inverse).
// 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;
@@ -14,39 +14,82 @@ layout(binding = 0) uniform UniformBufferObject {
// 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 deux pipelines partagent la meme
// 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;
layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 2) in vec3 inNormal;
// UV du sommet sur TOUT le terrain (0,0 au coin nord-ouest, 1,1 au sud-est),
// et non sur la tuile de quadtree : c'est ce qui rend la coordonnee continue
// d'une tuile a l'autre et independante du niveau de detail. Voir
// TerrainNodeMesh.cpp. PHASE 11 : desormais consomme, pour l'orthophoto.
layout(location = 3) in vec2 inUV;
// PHASE 10 - cible de geomorphing : position et normale de ce sommet dans la
// grille du niveau de detail SUPERIEUR (voir renderer/TerrainNodeMesh.hpp).
layout(location = 4) in vec3 inMorphPos;
layout(location = 5) in vec3 inMorphNormal;
// 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
@@ -64,23 +107,26 @@ void main() {
}
vec3 position = mix(inPosition, inMorphPos, morph);
vec3 normal = mix(inNormal, inMorphNormal, 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;
fragTint = inColor;
// 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 deja 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
// 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.
fragUV = inUV;
// 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
+14 -1
Voir le fichier
@@ -95,7 +95,14 @@ public:
// Genere immediatement la grille par bruit fractal. Lance
// std::runtime_error si les parametres ne peuvent pas produire une surface
// (resolution < 2, taille <= 0, ...).
explicit Heightmap(const Params& params = {});
explicit Heightmap(const Params& params);
// Memes parametres par defaut. Une SURCHARGE plutot qu'un argument par
// defaut `= {}` : GCC et Clang refusent de construire une struct IMBRIQUEE
// dotee d'initialiseurs de membres dans un argument par defaut de la classe
// englobante (CWG 1397), la ou MSVC l'accepte. Le corps d'une fonction
// membre, lui, voit la classe complete : la delegation compile partout.
explicit Heightmap() : Heightmap(Params{}) {}
// Adopte une grille DEJA CONSTRUITE, sans rien generer : c'est par ici
// qu'entrent les donnees LiDAR (voir assets/TerrainFile.hpp).
@@ -154,6 +161,12 @@ public:
// [0, resolution-1] : appeler avec ix = -1 renvoie la colonne 0.
float at(int64_t ix, int64_t iz) const;
// PHASE 32. La grille brute, [iz * resolution + ix], en lecture seule. Pour
// les boucles chaudes qui ont DEJA etabli que leurs indices sont dans la
// grille et n'ont donc que faire de l'ecretage de at() - la construction
// des tuiles interieures du quadtree (renderer/TerrainNodeMesh.cpp).
const float* rawHeights() const { return heights_.data(); }
// Position monde d'un echantillon (le long de X pour ix, de Z pour iz).
float worldCoord(uint32_t index) const;
+30 -8
Voir le fichier
@@ -57,7 +57,7 @@ double TextureData::metresPerTexel() const {
return 0.5 * (perX + perY);
}
TextureData loadTextureFile(const std::string& path) {
TextureData loadTextureFileHeader(const std::string& path) {
std::ifstream file(path, std::ios::binary);
if (!file) {
throw std::runtime_error("Texture : fichier introuvable ou illisible : " + path);
@@ -148,13 +148,6 @@ TextureData loadTextureFile(const std::string& path) {
". Fichier tronque ou en-tete incoherent.");
}
file.seekg(static_cast<std::streamoff>(kHeaderSize), std::ios::beg);
texture.pixels.resize(static_cast<std::size_t>(total));
if (!file.read(reinterpret_cast<char*>(texture.pixels.data()),
static_cast<std::streamsize>(total))) {
throw std::runtime_error("Texture : lecture interrompue dans " + path + ".");
}
logInfo("Texture : " + texture.label + " " + std::to_string(texture.width) + "x" +
std::to_string(texture.height) + ", " + std::to_string(mipLevels) +
" mipmaps, " +
@@ -164,4 +157,33 @@ TextureData loadTextureFile(const std::string& path) {
return texture;
}
void readTexturePayload(std::istream& file, uint64_t offset, uint64_t bytes,
void* destination) {
file.seekg(static_cast<std::streamoff>(kHeaderSize + offset), std::ios::beg);
if (!file.read(static_cast<char*>(destination), static_cast<std::streamsize>(bytes))) {
throw std::runtime_error("Texture : lecture interrompue (" + std::to_string(bytes) +
" octets a l'offset " + std::to_string(offset) + ").");
}
}
void readTexturePayload(const std::string& path, const TextureData& header,
void* destination) {
std::ifstream file(path, std::ios::binary);
if (!file) {
throw std::runtime_error("Texture : fichier introuvable ou illisible : " + path);
}
try {
readTexturePayload(file, 0, header.payloadSize(), destination);
} catch (const std::exception&) {
throw std::runtime_error("Texture : lecture interrompue dans " + path + ".");
}
}
TextureData loadTextureFile(const std::string& path) {
TextureData texture = loadTextureFileHeader(path);
texture.pixels.resize(static_cast<std::size_t>(texture.payloadSize()));
readTexturePayload(path, texture, texture.pixels.data());
return texture;
}
} // namespace vercora
+21
Voir le fichier
@@ -1,6 +1,7 @@
#pragma once
#include <cstdint>
#include <istream>
#include <string>
#include <vector>
@@ -57,6 +58,12 @@ struct TextureData {
// journal de demarrage : c'est le chiffre qui dit si la texture est a la
// hauteur du niveau de detail du terrain.
double metresPerTexel() const;
// PHASE 32. Octets de TOUTE la chaine de mipmaps, deduits des niveaux :
// c'est la taille de `pixels` une fois charge, et celle du staging.
uint64_t payloadSize() const {
return mips.empty() ? 0 : mips.back().offset + mips.back().size;
}
};
// Charge un .vcto. Lance std::runtime_error avec un message exploitable si le
@@ -65,6 +72,20 @@ struct TextureData {
// annonces, ...).
TextureData loadTextureFile(const std::string& path);
// PHASE 32. Les deux moities de loadTextureFile, pour ne jamais tenir la
// charge utile en RAM : l'en-tete d'abord (memes controles, taille du fichier
// comprise, `pixels` reste VIDE), puis la lecture des `payloadSize()` octets
// directement la ou l'appelant les veut - en pratique le staging mappe de la
// texture GPU (Renderer::setTerrainTextureFromFile). Sur l'orthophoto de la
// zone, c'est une copie de 42 Mo de moins au chargement, et autant de pic RAM.
TextureData loadTextureFileHeader(const std::string& path);
void readTexturePayload(const std::string& path, const TextureData& header, void* destination);
// Variante par TRANCHE, sur un fichier deja ouvert : `bytes` octets de la
// charge utile a partir de son octet `offset`. Sert au televersement par
// bandes de Texture (staging de 4 Mo au plus).
void readTexturePayload(std::istream& file, uint64_t offset, uint64_t bytes, void* destination);
// Nombre d'octets d'un niveau de mipmap pour un format donne. Expose parce que
// c'est la seule formule qui lie les deux formats a leur taille, et que le
// chargeur ET les tests s'en servent.
+65
Voir le fichier
@@ -0,0 +1,65 @@
#include "core/ProcessMemory.hpp"
#include <cstdio>
#if defined(_WIN32)
# ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
# endif
# ifndef NOMINMAX
# define NOMINMAX
# endif
# include <windows.h>
// Avec PSAPI_VERSION 2 (le defaut depuis Windows 7), GetProcessMemoryInfo est
// K32GetProcessMemoryInfo, exportee par kernel32 : aucune bibliotheque de plus
// a lier.
# include <psapi.h>
#elif defined(__linux__)
# include <fstream>
# include <sstream>
#endif
namespace vercora {
ProcessMemory processMemory() {
ProcessMemory memory;
#if defined(_WIN32)
PROCESS_MEMORY_COUNTERS counters{};
if (GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) {
memory.residentBytes = static_cast<uint64_t>(counters.WorkingSetSize);
memory.peakResidentBytes = static_cast<uint64_t>(counters.PeakWorkingSetSize);
memory.available = true;
}
#elif defined(__linux__)
// Lignes "VmRSS: 123456 kB" et "VmHWM: 234567 kB".
std::ifstream status("/proc/self/status");
std::string line;
while (std::getline(status, line)) {
const bool rss = line.rfind("VmRSS:", 0) == 0;
const bool hwm = line.rfind("VmHWM:", 0) == 0;
if (!rss && !hwm) {
continue;
}
std::istringstream fields(line.substr(6));
uint64_t kilobytes = 0;
fields >> kilobytes;
(rss ? memory.residentBytes : memory.peakResidentBytes) = kilobytes * 1024u;
memory.available = true;
}
#endif
return memory;
}
std::string processMemoryLine() {
const ProcessMemory memory = processMemory();
if (!memory.available) {
return "RAM non mesuree (plateforme non prise en charge)";
}
char text[96];
std::snprintf(text, sizeof(text), "RAM %.1f Mo (pic %.1f Mo)",
static_cast<double>(memory.residentBytes) / (1024.0 * 1024.0),
static_cast<double>(memory.peakResidentBytes) / (1024.0 * 1024.0));
return text;
}
} // namespace vercora
+31
Voir le fichier
@@ -0,0 +1,31 @@
#pragma once
#include <cstdint>
#include <string>
namespace vercora {
// PHASE 32. Memoire RESIDENTE du processus, lue au systeme : ce que le
// gestionnaire des taches appelle "jeu de travail" sous Windows, VmRSS sous
// Linux. Le pic est celui de toute la vie du processus (PeakWorkingSetSize,
// VmHWM).
//
// Jusqu'ici la RAM ne se mesurait que de l'EXTERIEUR (scripts PowerShell qui
// interrogent le processus a intervalles fixes, donc qui ratent les pics
// courts). Le jeu la journalise desormais lui-meme, au demarrage, en cours de
// partie et a la fermeture - le meme principe que le bilan de streaming.
//
// Sur une memoire UNIFIEE (GPU integre, lavapipe), la memoire GPU allouee peut
// apparaitre dans ce chiffre : le lire a cote de VulkanContext::gpuMemoryLine.
struct ProcessMemory {
uint64_t residentBytes = 0;
uint64_t peakResidentBytes = 0;
bool available = false; // false = plateforme non prise en charge
};
ProcessMemory processMemory();
// "RAM 512.3 Mo (pic 734.0 Mo)", ou "RAM non mesuree" hors plateforme connue.
std::string processMemoryLine();
} // namespace vercora
+121 -14
Voir le fichier
@@ -11,6 +11,7 @@
#include "editor/AssetCatalog.hpp"
#include "editor/EditorController.hpp"
#include "core/Paths.hpp"
#include "core/ProcessMemory.hpp"
#include "editor/EditorScene.hpp"
#include "editor/PlacedObject.hpp"
#include "editor/SceneFile.hpp"
@@ -137,6 +138,20 @@ namespace {
// objets poses, eux, font partie du monde et sont affiches et solides dans le
// jeu normal - c'est justement le point.
//
// Plus deux options de la Phase 32, pour le BANC DE MESURE (voir NOTES-PHASE32.md) :
// vercora.exe [scene] --quit-after=S -> fermeture propre apres S secondes
// de boucle, bilans de fin compris
// vercora.exe [scene] --freeze-anim -> horloge d'animation des shaders
// figee : images comparables au
// pixel pres d'un run a l'autre
// vercora.exe [scene] --force-staging -> geometrie televersee par staging
// meme en memoire unifiee (chemin
// d'un GPU discret, a eprouver)
// vercora.exe [scene] --vsync -> presentation calee sur l'ecran
// (FIFO) : la cadence ne depasse
// plus le rafraichissement, CPU et
// GPU dorment le reste du temps
//
// Le terrain synthetique n'est PAS supprime, et pour deux raisons distinctes :
// il reste la scene de reference des tests (monde deterministe, arbres a
// positions connues, cf. dumpWorld plus bas), et il sert de repli si le
@@ -873,6 +888,27 @@ int main(int argc, char** argv) {
std::string sceneFileArgument;
std::string editorAssetsArgument;
std::string sceneArgument;
// PHASE 32 : outils de BANC DE MESURE.
// --quit-after=S ferme proprement le jeu apres S secondes de boucle,
// comme une fermeture de fenetre : tous les bilans de
// fin de partie sont ecrits. Remplace le WM_CLOSE poste
// de l'exterieur, que la Phase 26 a vu arriver en retard
// sur une machine chargee.
// --freeze-anim fige l'horloge d'ANIMATION des shaders (ondulation
// de l'herbe, chute de la pluie) a zero. Avec
// --lock-input, --look et --time-scale=0, deux images
// d'une meme scene deviennent comparables au pixel pres,
// ce qui est la condition pour prouver qu'une
// optimisation ne change pas l'image.
float quitAfterSeconds = 0.0f;
bool freezeAnimation = false;
// PHASE 32 : --force-staging televerse la geometrie par staging meme en
// memoire unifiee (le chemin d'un GPU discret), pour l'eprouver ici.
bool forceStaging = false;
// PHASE 32 : --vsync, presentation FIFO calee sur l'ecran. Le reglage a
// prendre pour JOUER (consommation, chauffe, pas de dechirure) ; les
// mesures gardent le defaut non plafonne.
bool vsync = false;
for (int i = 1; i < argc; ++i) {
const std::string argument = argv[i];
if (argument == "--dump-world") {
@@ -1029,6 +1065,24 @@ int main(int argc, char** argv) {
}
} else if (argument.rfind("--ortho=", 0) == 0) {
orthoArgument = argument.substr(std::strlen("--ortho="));
} else if (argument.rfind("--quit-after=", 0) == 0) {
try {
quitAfterSeconds =
std::stof(argument.substr(std::strlen("--quit-after=")));
if (!(quitAfterSeconds > 0.0f)) {
logWarn("--quit-after attend une duree positive en secondes. Ignore.");
quitAfterSeconds = 0.0f;
}
} catch (const std::exception&) {
logWarn("--quit-after : duree illisible. Ignore : " + argument);
quitAfterSeconds = 0.0f;
}
} else if (argument == "--freeze-anim") {
freezeAnimation = true;
} else if (argument == "--force-staging") {
forceStaging = true;
} else if (argument == "--vsync") {
vsync = true;
} else if (argument.rfind("--", 0) == 0) {
logWarn("Option inconnue, ignoree : " + argument);
} else if (sceneArgument.empty()) {
@@ -1163,7 +1217,11 @@ int main(int argc, char** argv) {
CompositeCollisionSolver worldSolver;
MeshData sceneMesh;
// PHASE 32 : le terrain d'un seul bloc (--no-lod) au format GPU compact.
TerrainGpuMesh sceneTerrain;
RenderOptions renderOptions;
renderOptions.forceStaging = forceStaging;
renderOptions.vsync = vsync;
Inventory inventory;
@@ -1183,7 +1241,10 @@ int main(int argc, char** argv) {
// produisait 25 M de sommets et 50 M de triangles cote CPU,
// recopies ensuite sur le GPU.
if (!dumpWorldOnly && !useLod) {
sceneMesh = terrainMeshData(*heightmap);
// PHASE 32 : directement au format GPU du terrain (16 octets par
// sommet), sans le MeshData de 68 octets par sommet - 1,7 Go de
// moins au pic sur la zone au pas de 1 m.
sceneTerrain = terrainGpuMeshData(*heightmap);
}
renderOptions.heightRange = { heightmap->minHeight(), heightmap->maxHeight() };
@@ -1265,8 +1326,19 @@ int main(int argc, char** argv) {
// nombre d'instances qui les utiliseront ensuite.
// Avec le quadtree, il n'y a pas de geometrie de scene unique : chaque
// tuile est enregistree et liberee par le TerrainStreamer.
const MeshHandle sceneMeshHandle =
MeshHandle sceneMeshHandle =
sceneMesh.empty() ? kInvalidMesh : renderer.addMesh(sceneMesh);
if (!sceneTerrain.vertices.empty()) {
sceneMeshHandle = renderer.addTerrainMesh(sceneTerrain.vertices, sceneTerrain.indices,
sceneTerrain.name);
sceneTerrain = TerrainGpuMesh{}; // la copie CPU n'a plus de raison d'etre
}
// PHASE 32 : la grille de la heightmap, dont terrain.vert deduit la
// position horizontale et l'UV de chaque sommet de terrain.
if (terrainScene) {
renderer.setTerrainGrid(heightmap->worldCoord(0), heightmap->spacing(),
heightmap->resolution() - 1);
}
// ------------------------------------------------------------------
// 2 bis. Orthophoto (Phase 11). Chargee APRES le Renderer, qui possede
@@ -1290,11 +1362,14 @@ int main(int argc, char** argv) {
" -i data/ortho -o " + orthoPath);
} else {
try {
const TextureData ortho = loadTextureFile(orthoPath);
// PHASE 32 : l'en-tete seul d'abord (controle d'emprise), puis
// les 42 Mo de texels lus directement dans le staging de la
// texture - jamais tenus en RAM a cote.
const TextureData ortho = loadTextureFileHeader(orthoPath);
if (orthoMatchesTerrain(ortho, *heightmap)) {
renderer.setTerrainTexture(ortho);
renderer.setTerrainTextureFromFile(ortho, orthoPath);
renderer.setOrthoMix(1.0f);
groundDetailPattern = ortho.metresPerTexel();
groundDetailPattern = static_cast<float>(ortho.metresPerTexel());
logInfo("Orthophoto : " +
std::to_string(ortho.metresPerTexel()) +
" m/texel pour un terrain au pas de " +
@@ -2289,9 +2364,28 @@ int main(int argc, char** argv) {
// fenetre, dont la Phase 18 a montre qu'il varie de ~15 % entre deux
// runs identiques. Chargement exclu : il precede la boucle.
const auto loopStart = ProfileClock::now();
// PHASE 32 : bilan des ressources une fois le monde charge, avant la
// premiere image. Le meme bilan est ecrit toutes les 10 s, puis a la
// fermeture avec les pics de la session.
logInfo("Ressources apres chargement (PHASE 32) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ".");
double lastResourceLog = 0.0;
while (!window.shouldClose()) {
window.pollEvents();
const double loopSeconds =
std::chrono::duration<double>(ProfileClock::now() - loopStart).count();
if (quitAfterSeconds > 0.0f && loopSeconds >= quitAfterSeconds) {
logInfo("--quit-after : " + std::to_string(quitAfterSeconds) +
" s de boucle ecoulees, fermeture.");
break;
}
if (loopSeconds - lastResourceLog >= 10.0) {
lastResourceLog = loopSeconds;
logInfo("Ressources (PHASE 32) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ". " + renderer.geometryLine() + ".");
}
const double now = glfwGetTime();
const float deltaTime = static_cast<float>(now - lastTime);
lastTime = now;
@@ -2301,6 +2395,9 @@ int main(int argc, char** argv) {
// demarrage, donc la valeur reste petite et n'use pas la precision
// d'un float, contrairement a une horloge absolue.
const float elapsedSeconds = static_cast<float>(now);
// PHASE 32 : horloge des SHADERS seulement (--freeze-anim). La
// logique de jeu garde elapsedSeconds.
const float animationSeconds = freezeAnimation ? 0.0f : elapsedSeconds;
// --- Bascule du MODE EDITEUR (PHASE 15) ------------------------
// Traitee AVANT camera.update : entrer en edition change le mode et
@@ -3506,9 +3603,13 @@ int main(int argc, char** argv) {
frameProfile.streamingMicros += profileMicros(tf1, tf2);
} else if (sceneMeshHandle != kInvalidMesh) {
// Terrain d'un seul bloc : sommets deja en coordonnees monde
// -> matrice identite, et pas de bande de morphing.
drawItems.push_back({ sceneMeshHandle, glm::mat4(1.0f),
Material::Terrain });
// -> matrice identite, et pas de bande de morphing. PHASE 32 :
// une seule "tuile" qui couvre toute la grille au pas 1.
DrawItem terrainItem{ sceneMeshHandle, glm::mat4(1.0f),
Material::Terrain };
terrainItem.grid = glm::ivec4(0, 0, 1,
static_cast<int32_t>(heightmap->resolution()));
drawItems.push_back(terrainItem);
}
for (const Tree& tree : forest->trees()) {
@@ -3682,7 +3783,7 @@ int main(int argc, char** argv) {
item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage;
// Amplitude d'ondulation NULLE : un tronc ne plie pas.
item.params = { 0.0f, elapsedSeconds, 0.0f, 0.0f };
item.params = { 0.0f, animationSeconds, 0.0f, 0.0f };
instancedItems.push_back(item);
};
pushTrees(treeInstances, sceneryTreeMeshHandle);
@@ -3703,7 +3804,7 @@ int main(int argc, char** argv) {
// seul materiau qui s'en sert : un arbre pousse 0 et
// traverse le meme pipeline, inchange.
item.params = { vegetation->params().grassSway,
elapsedSeconds, 0.0f,
animationSeconds, 0.0f,
vegetation->params().grassCutout };
instancedItems.push_back(item);
}
@@ -3734,7 +3835,7 @@ int main(int argc, char** argv) {
// pas par un masque - ces plantes sont peu nombreuses,
// le budget de sommets n'est pas le sujet.
item.params = { 0.35f * vegetation->params().grassSway,
elapsedSeconds, 0.0f, 0.0f };
animationSeconds, 0.0f, 0.0f };
instancedItems.push_back(item);
}
}
@@ -3760,7 +3861,7 @@ int main(int argc, char** argv) {
item.instances = instances.data();
item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage;
item.params = { 0.0f, elapsedSeconds, 0.0f, -1.0f };
item.params = { 0.0f, animationSeconds, 0.0f, -1.0f };
instancedItems.push_back(item);
};
pushRocks(boulderInstances, boulderMeshHandle);
@@ -3786,7 +3887,7 @@ int main(int argc, char** argv) {
item.instances = instances.data();
item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage;
item.params = { sway, elapsedSeconds, 0.0f, 0.0f };
item.params = { sway, animationSeconds, 0.0f, 0.0f };
instancedItems.push_back(item);
};
pushBushes(shrubInstances, shrubMeshHandle, 0.04f);
@@ -3846,7 +3947,7 @@ int main(int argc, char** argv) {
renderer.setWeatherVisuals(visuals.fogColor, visuals.fogDensityPerMeter,
visuals.precipitation, visuals.snow,
visuals.fallVelocity, visuals.groundDarkening,
elapsedSeconds);
animationSeconds);
frameProfile.weatherVisualsMicros += profileMicros(tw0, ProfileClock::now());
// Journal BORNE PAR LE TEMPS (lecon de la Phase 24 : "sur
@@ -3918,6 +4019,12 @@ int main(int argc, char** argv) {
// S'assurer que le GPU a fini avant de detruire quoi que ce soit.
renderer.waitIdle();
// PHASE 32 : bilan des ressources, AVANT toute destruction - les chiffres
// "vivants" sont donc ceux du jeu en regime etabli, les pics ceux de la
// session entiere.
logInfo("Ressources en fin de partie (PHASE 32) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ". " + renderer.geometryLine() + ".");
if (frameProfile.frames > 0) {
const auto per = [&](uint64_t total) {
const double value = static_cast<double>(total) /
+17 -2
Voir le fichier
@@ -76,6 +76,18 @@ struct DrawItem {
// profondeur. Une force nulle - le cas de tous les DrawItem du jeu -
// laisse le rendu strictement identique a celui d'avant la Phase 15.
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
// PHASE 32, Material::Terrain seulement : ou se trouve le maillage dans la
// grille de la heightmap, pour que terrain.vert y retrouve la position
// horizontale et l'UV de chaque sommet a partir de gl_VertexIndex au lieu
// de les lire dans le buffer (voir renderer/GpuVertex.hpp, TerrainVertex).
// x, y = indices de grille (ix, iz) du premier sommet
// z = pas, en echantillons de grille, entre deux sommets voisins
// w = sommets par rangee
// Une tuile de quadtree pousse (node.ix0, node.iz0, node.stride, 65) ; le
// terrain d'un seul bloc (--no-lod) pousse (0, 0, 1, resolution).
// Ignore par les autres materiaux.
glm::ivec4 grid{0, 0, 1, 1};
};
// Ce que le Renderer pousse REELLEMENT en push constant, dans cet ordre.
@@ -85,12 +97,15 @@ struct DrawItem {
// melanger obligerait a garder `mesh` et `material` - inutiles au GPU - dans un
// budget de push constants qui ne fait que 128 octets garantis.
//
// 80 octets : toujours tres en dessous des 128 garantis par la spec Vulkan pour
// maxPushConstantsSize.
// 96 octets depuis la Phase 32 (le bloc `grid` du terrain) : toujours en
// dessous des 128 garantis par la spec Vulkan pour maxPushConstantsSize.
struct DrawItemPush {
glm::mat4 model{1.0f};
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
glm::ivec4 grid{0, 0, 1, 1};
};
static_assert(sizeof(DrawItemPush) == 96 && sizeof(DrawItemPush) <= 128,
"Le bloc de push constants doit tenir dans les 128 octets garantis.");
// ---------------------------------------------------------------------------
// PHASE 11 : dessin INSTANCIE
+178
Voir le fichier
@@ -0,0 +1,178 @@
#include "renderer/GpuBufferPool.hpp"
#include <cstdio>
#include <stdexcept>
namespace vercora {
GpuBufferPool::GpuBufferPool(VulkanContext& context, VkBufferUsageFlags usage,
VkMemoryPropertyFlags properties, bool mapped,
VkDeviceSize blockSize)
: context_(context), usage_(usage), properties_(properties), mapped_(mapped),
blockSize_(blockSize) {
if (mapped_) {
properties_ |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
}
}
GpuBufferPool::~GpuBufferPool() {
for (std::unique_ptr<Block>& block : blocks_) {
if (block) {
destroyBlock(*block);
}
}
}
std::unique_ptr<GpuBufferPool::Block> GpuBufferPool::createBlock(VkDeviceSize capacity,
bool dedicated) {
auto block = std::make_unique<Block>(capacity);
block->dedicated = dedicated;
VkBufferCreateInfo bufferInfo{};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferInfo.size = capacity;
bufferInfo.usage = usage_;
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
if (vkCreateBuffer(context_.device(), &bufferInfo, nullptr, &block->buffer) != VK_SUCCESS) {
throw std::runtime_error("GpuBufferPool : echec de la creation d'un bloc de " +
std::to_string(capacity) + " octets.");
}
VkMemoryRequirements requirements{};
vkGetBufferMemoryRequirements(context_.device(), block->buffer, &requirements);
try {
block->memory = context_.allocateMemory(requirements, properties_, mapped_);
} catch (...) {
vkDestroyBuffer(context_.device(), block->buffer, nullptr);
throw;
}
vkBindBufferMemory(context_.device(), block->buffer, block->memory.memory, 0);
capacityBytes_ += capacity;
return block;
}
void GpuBufferPool::destroyBlock(Block& block) {
capacityBytes_ -= block.ranges.capacity();
vkDestroyBuffer(context_.device(), block.buffer, nullptr);
block.buffer = VK_NULL_HANDLE;
context_.freeMemory(block.memory);
}
GpuRange GpuBufferPool::allocate(VkDeviceSize size) {
if (size == 0) {
throw std::runtime_error("GpuBufferPool : allocation de taille nulle.");
}
uint32_t index = UINT32_MAX;
uint64_t offset = RangeAllocator::kInvalid;
if (size > blockSize_ / 2) {
// Bloc DEDIE, a la taille exacte : un tres gros maillage ne doit ni
// gacher un bloc standard, ni l'empecher de servir aux autres.
for (uint32_t k = 0; k <= blocks_.size(); ++k) {
if (k == blocks_.size() || !blocks_[k]) {
index = k;
break;
}
}
auto block = createBlock(size, true);
offset = block->ranges.allocate(size, kAlignment);
if (index == blocks_.size()) {
blocks_.push_back(std::move(block));
} else {
blocks_[index] = std::move(block);
}
} else {
// Premier bloc standard qui a la place.
for (uint32_t k = 0; k < blocks_.size(); ++k) {
Block* block = blocks_[k].get();
if (block == nullptr || block->dedicated) {
continue;
}
offset = block->ranges.allocate(size, kAlignment);
if (offset != RangeAllocator::kInvalid) {
index = k;
break;
}
}
if (offset == RangeAllocator::kInvalid) {
for (uint32_t k = 0; k <= blocks_.size(); ++k) {
if (k == blocks_.size() || !blocks_[k]) {
index = k;
break;
}
}
auto block = createBlock(blockSize_, false);
offset = block->ranges.allocate(size, kAlignment);
if (index == blocks_.size()) {
blocks_.push_back(std::move(block));
} else {
blocks_[index] = std::move(block);
}
}
}
Block& block = *blocks_[index];
GpuRange range;
range.buffer = block.buffer;
range.offset = offset;
range.size = size;
range.block = index;
if (block.memory.mapped != nullptr) {
range.mapped = static_cast<unsigned char*>(block.memory.mapped) + offset;
}
usedBytes_ += size;
return range;
}
void GpuBufferPool::release(const GpuRange& range) {
if (!range.valid() || range.block >= blocks_.size() || !blocks_[range.block]) {
return;
}
Block& block = *blocks_[range.block];
block.ranges.release(range.offset, range.size);
usedBytes_ -= range.size;
if (!block.ranges.empty()) {
return;
}
// Bloc vide. Un bloc dedie part toujours ; un bloc standard part seulement
// s'il existe deja un AUTRE bloc standard vide - en survol, les tuiles
// evincees et construites se croisent sans cesse, et rendre puis
// reallouer 4 Mo a chaque passage a vide ramenerait les allocations que ce
// pool supprime.
bool keep = !block.dedicated;
if (keep) {
for (uint32_t k = 0; k < blocks_.size(); ++k) {
if (k != range.block && blocks_[k] && !blocks_[k]->dedicated &&
blocks_[k]->ranges.empty()) {
keep = false;
break;
}
}
}
if (!keep) {
destroyBlock(block);
blocks_[range.block].reset();
}
}
uint32_t GpuBufferPool::blockCount() const {
uint32_t count = 0;
for (const std::unique_ptr<Block>& block : blocks_) {
count += block ? 1u : 0u;
}
return count;
}
std::string GpuBufferPool::statsLine() const {
char text[160];
std::snprintf(text, sizeof(text),
"%.1f Mo utilises sur %.1f Mo alloues en %u bloc(s), %s",
static_cast<double>(usedBytes_) / (1024.0 * 1024.0),
static_cast<double>(capacityBytes_) / (1024.0 * 1024.0), blockCount(),
mapped_ ? "ecriture directe (memoire unifiee)" : "televersement par staging");
return text;
}
} // namespace vercora
+109
Voir le fichier
@@ -0,0 +1,109 @@
#pragma once
#include "renderer/RangeAllocator.hpp"
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
namespace vercora {
// PHASE 32. Une plage de geometrie dans un bloc partage.
struct GpuRange {
VkBuffer buffer = VK_NULL_HANDLE;
VkDeviceSize offset = 0;
VkDeviceSize size = 0;
// Non nul quand le bloc est mappe (memoire unifiee) : l'appelant ECRIT LA,
// et le GPU lit exactement ces octets - ni staging, ni copie.
void* mapped = nullptr;
uint32_t block = UINT32_MAX; // interne au pool
bool valid() const { return buffer != VK_NULL_HANDLE; }
};
// PHASE 32. Sous-allocation de TOUTE la geometrie du moteur (sommets et
// indices, objets et tuiles de terrain) dans quelques gros blocs Vulkan.
//
// LE PROBLEME MESURE : un vkAllocateMemory par buffer, soit deux par maillage
// plus deux de staging par televersement - ~17 000 appels en 30 s de survol
// (NOTES-PHASE32.md). Chaque appel est un aller-retour noyau sous Windows,
// arrondi a la granularite d'allocation du systeme, et le nombre de blocs
// vivants est plafonne par maxMemoryAllocationCount (souvent 4 096) : c'est ce
// plafond qui imposait les 512 tuiles residentes au plus.
//
// LE PRINCIPE : des blocs de kBlockSize octets, chacun un VkBuffer unique dans
// lequel les maillages occupent des PLAGES (RangeAllocator, premier
// ajustement). Une demande plus grande que la moitie d'un bloc recoit un bloc
// DEDIE a sa taille exacte (le terrain d'un seul bloc de --no-lod, ~400 Mo).
// Un bloc qui se vide est rendu au pilote, sauf le dernier bloc vide, garde
// pour amortir le va-et-vient du streaming.
//
// SYNCHRONISATION : AUCUNE ici. release() rend la plage IMMEDIATEMENT ; c'est
// a l'appelant de ne la rendre que lorsque plus aucune image en vol ne la lit
// - ce que fait deja le Renderer pour tout maillage retire (retiredMeshes_,
// kMaxFramesInFlight + 1 images, voir Renderer::removeMesh).
class GpuBufferPool {
public:
// `mapped` = true : les blocs sont alloues HOST_VISIBLE | HOST_COHERENT et
// mappes en permanence (memoire unifiee), les plages renvoyees portent
// alors un pointeur d'ecriture directe.
GpuBufferPool(VulkanContext& context, VkBufferUsageFlags usage,
VkMemoryPropertyFlags properties, bool mapped,
VkDeviceSize blockSize = kDefaultBlockSize);
~GpuBufferPool();
GpuBufferPool(const GpuBufferPool&) = delete;
GpuBufferPool& operator=(const GpuBufferPool&) = delete;
// 4 Mo : 60 tuiles de terrain par bloc ; la perte moyenne au pic (un
// demi-bloc) reste sous les 2 Mo.
static constexpr VkDeviceSize kDefaultBlockSize = 4ull * 1024 * 1024;
// 256 : couvre l'alignement de tout format de sommet et d'indice, et le
// nonCoherentAtomSize des GPU courants.
static constexpr VkDeviceSize kAlignment = 256;
// Lance std::runtime_error si le pilote refuse un nouveau bloc.
GpuRange allocate(VkDeviceSize size);
void release(const GpuRange& range);
bool mapped() const { return mapped_; }
// Bilan : octets reserves par des plages, octets alloues au pilote, blocs.
VkDeviceSize usedBytes() const { return usedBytes_; }
VkDeviceSize capacityBytes() const { return capacityBytes_; }
uint32_t blockCount() const;
std::string statsLine() const;
private:
struct Block {
VkBuffer buffer = VK_NULL_HANDLE;
GpuAllocation memory;
RangeAllocator ranges;
bool dedicated = false;
explicit Block(VkDeviceSize capacity) : ranges(capacity) {}
};
std::unique_ptr<Block> createBlock(VkDeviceSize capacity, bool dedicated);
void destroyBlock(Block& block);
VulkanContext& context_;
VkBufferUsageFlags usage_ = 0;
VkMemoryPropertyFlags properties_ = 0;
bool mapped_ = false;
VkDeviceSize blockSize_ = kDefaultBlockSize;
// Emplacements stables : GpuRange::block est un indice dans ce tableau, un
// bloc rendu laisse un trou (nullptr) reutilise par le suivant.
std::vector<std::unique_ptr<Block>> blocks_;
VkDeviceSize usedBytes_ = 0;
VkDeviceSize capacityBytes_ = 0;
};
} // namespace vercora
+118
Voir le fichier
@@ -0,0 +1,118 @@
#pragma once
#include "renderer/Vertex.hpp"
#include <glm/glm.hpp>
#include <algorithm>
#include <cmath>
#include <cstdint>
namespace vercora {
// PHASE 32. Les formats de sommet tels que le GPU les LIT.
//
// Jusqu'ici un seul format, `Vertex` (68 octets), servait a tout : il porte la
// position, la couleur, la normale, l'UV ET la cible de geomorphing du terrain.
// Il reste le format de TRAVAIL cote CPU - tous les generateurs (arbres,
// rochers, .obj, terrain) et tous les tests le produisent et le lisent - mais
// il n'est plus televerse tel quel. Le Renderer le CONVERTIT au televersement
// dans l'un des deux formats ci-dessous, chacun reduit a ce que son shader lit
// reellement. Comme Vertex.hpp, ce fichier ne connait pas Vulkan : la
// description des attributs au pipeline vit dans renderer/VertexFormat.hpp.
// ---------------------------------------------------------------------------
// Objets et vegetation (cube.vert, foliage.vert) : 44 octets, conversion EXACTE
// ---------------------------------------------------------------------------
// `Vertex` sans ses 24 octets de cible de geomorphing, qu'aucun de ces deux
// shaders ne lit (le pipeline ne les decrivait deja pas : seul le STRIDE les
// payait). Les flottants sont recopies tels quels : l'image est identique au
// bit pres, et les maillages d'objets pesent 35 % de moins.
struct ObjectVertex {
glm::vec3 pos;
glm::vec3 color;
glm::vec3 normal;
glm::vec2 uv;
};
static_assert(sizeof(ObjectVertex) == 44,
"ObjectVertex doit rester sans remplissage : sa taille est le stride "
"du binding 0 des pipelines objet et vegetation.");
inline ObjectVertex toObjectVertex(const Vertex& vertex) {
return ObjectVertex{ vertex.pos, vertex.color, vertex.normal, vertex.uv };
}
// ---------------------------------------------------------------------------
// Terrain (terrain.vert) : 16 octets au lieu de 68
// ---------------------------------------------------------------------------
// Une tuile de terrain est une GRILLE REGULIERE : la position horizontale d'un
// sommet, celle de sa cible de geomorphing et son UV ne dependent que de son
// indice dans la tuile et de trois entiers propres a la tuile (premier
// echantillon, pas, sommets par rangee - pousses en push constant, voir
// DrawItem::grid). Le vertex shader les recalcule avec EXACTEMENT les memes
// operations flottantes que Heightmap::worldCoord : les positions sont donc
// identiques au bit pres a celles que portait le format de 68 octets. La
// couleur, elle, valait toujours (1, 1, 1).
//
// Ne restent que ce qui ne se deduit pas de l'indice :
// - height : altitude du sommet, flottant EXACT (la verite physique) ;
// - morphHeight : altitude de sa cible dans la grille du niveau superieur ;
// - normal : composantes x et z de la normale, en snorm16 ; y se
// reconstruit (une normale de champ de hauteur pointe
// toujours vers le haut) ;
// - morphNormal : idem pour la normale de la cible.
// Seules les normales sont quantifiees : 1/32767 par composante, soit ~3e-5 -
// un ecart d'eclairage de l'ordre du centieme de niveau sur 255.
struct TerrainVertex {
float height = 0.0f;
float morphHeight = 0.0f;
int16_t normal[2] = { 0, 0 };
int16_t morphNormal[2] = { 0, 0 };
};
static_assert(sizeof(TerrainVertex) == 16,
"TerrainVertex doit rester compact : sa taille est le stride du "
"binding 0 du pipeline terrain.");
// Quantification snorm16, la convention de VK_FORMAT_R16_SNORM : l'entier c
// represente max(c / 32767, -1).
inline int16_t packSnorm16(float value) {
const float clamped = std::clamp(value, -1.0f, 1.0f);
return static_cast<int16_t>(std::lround(clamped * 32767.0f));
}
inline float unpackSnorm16(int16_t value) {
return std::max(static_cast<float>(value) / 32767.0f, -1.0f);
}
// Normale reconstruite depuis ses composantes x et z quantifiees : la
// formule exacte du vertex shader, pour que les tests mesurent ce que le GPU
// verra.
inline glm::vec3 unpackTerrainNormal(const int16_t packed[2]) {
const float x = unpackSnorm16(packed[0]);
const float z = unpackSnorm16(packed[1]);
return { x, std::sqrt(std::max(0.0f, 1.0f - x * x - z * z)), z };
}
// Conversion d'un sommet de terrain du format de travail. N'utilise que les
// altitudes et les normales : le reste se recalcule dans le shader.
inline TerrainVertex toTerrainVertex(const Vertex& vertex) {
TerrainVertex packed;
packed.height = vertex.pos.y;
packed.morphHeight = vertex.morphPos.y;
packed.normal[0] = packSnorm16(vertex.normal.x);
packed.normal[1] = packSnorm16(vertex.normal.z);
packed.morphNormal[0] = packSnorm16(vertex.morphNormal.x);
packed.morphNormal[1] = packSnorm16(vertex.morphNormal.z);
return packed;
}
// La position horizontale d'un echantillon de grille, calculee comme le fait
// terrain.vert : `origin + float(index) * spacing`, sans contraction en FMA
// (qualificatif `precise` cote shader). C'est l'expression meme de
// Heightmap::worldCoord avec origin = worldCoord(0) : le resultat est identique
// au bit pres, ce que verifie tests/logic_tests.cpp.
inline float terrainGridCoord(float origin, float spacing, uint32_t index) {
return origin + static_cast<float>(index) * spacing;
}
} // namespace vercora
+12 -99
Voir le fichier
@@ -1,107 +1,20 @@
#include "renderer/Mesh.hpp"
#include "core/Logger.hpp"
#include "renderer/MeshData.hpp"
#include "renderer/VulkanBuffer.hpp"
#include "renderer/VulkanContext.hpp"
#include <stdexcept>
#include <string>
namespace vercora {
Mesh::Mesh(VulkanContext& context,
BufferUploader& uploader,
const MeshData& data,
bool log) {
// --- Validation AVANT toute allocation Vulkan ---------------------------
// Un index hors limites ne produit pas d'erreur a la creation du buffer :
// il se manifesterait au draw, sous forme de lecture hors du vertex buffer
// (comportement indefini cote GPU). Mieux vaut refuser ici, avec un message
// qui dit quoi.
if (data.vertices.empty()) {
throw std::runtime_error("Mesh vide : aucun sommet (" + data.name + ").");
Mesh::Mesh(GpuBufferPool& pool, VertexLayout layout,
const GpuRange& vertices, uint32_t vertexCount,
const GpuRange& indices, VkIndexType indexType, uint32_t indexCount,
bool ownsIndices)
: pool_(pool), layout_(layout), vertices_(vertices), indices_(indices),
indexType_(indexType), vertexCount_(vertexCount), indexCount_(indexCount),
ownsIndices_(ownsIndices) {}
Mesh::~Mesh() {
pool_.release(vertices_);
if (ownsIndices_) {
pool_.release(indices_);
}
if (data.indices.empty()) {
throw std::runtime_error("Mesh vide : aucun index (" + data.name + ").");
}
if (data.indices.size() % 3 != 0) {
throw std::runtime_error(
"Mesh non triangule : " + std::to_string(data.indices.size()) +
" index, ce qui n'est pas un multiple de 3 (" + data.name + ").");
}
const auto vertexCount = static_cast<uint32_t>(data.vertices.size());
for (uint32_t index : data.indices) {
if (index >= vertexCount) {
throw std::runtime_error(
"Index hors limites dans le mesh : " + std::to_string(index) +
" pour " + std::to_string(vertexCount) + " sommets (" + data.name + ").");
}
}
vertexCount_ = vertexCount;
indexCount_ = static_cast<uint32_t>(data.indices.size());
// --- Upload GPU ---------------------------------------------------------
vertexBuffer_ = createDeviceLocalBuffer(
context, uploader,
data.vertices.data(),
sizeof(data.vertices[0]) * data.vertices.size(),
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
indexBuffer_ = createDeviceLocalBuffer(
context, uploader,
data.indices.data(),
sizeof(data.indices[0]) * data.indices.size(),
VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
if (log) {
logInfo("Mesh charge sur le GPU : " + data.name + " - " +
std::to_string(vertexCount_) + " sommets, " +
std::to_string(indexCount_ / 3) + " triangles.");
}
}
Mesh::~Mesh() = default; // les buffers se detruisent avec leurs unique_ptr
std::unique_ptr<VulkanBuffer> Mesh::createDeviceLocalBuffer(
VulkanContext& context,
BufferUploader& uploader,
const void* data,
VkDeviceSize size,
VkBufferUsageFlags usage) {
// 1. Staging host-visible : accessible au CPU, on y ecrit la geometrie.
auto staging = std::make_unique<VulkanBuffer>(
context, size,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
staging->writeToBuffer(data, size);
// 2. Buffer final device-local : rapide pour le GPU, non mappable.
auto buffer = std::make_unique<VulkanBuffer>(
context, size,
VK_BUFFER_USAGE_TRANSFER_DST_BIT | usage,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
// 3. PHASE 12 : la copie est CONFIEE, pas attendue. Le staging part avec
// elle - il doit survivre jusqu'a l'execution de la frame qui portera la
// commande de copie, ce qui n'est plus une duree connue ici. C'est tout
// le changement : avant, cette ligne bloquait le thread jusqu'a ce que le
// GPU ait vide sa queue.
uploader.enqueueCopy(std::move(staging), buffer->handle());
return buffer;
}
void Mesh::bind(VkCommandBuffer commandBuffer) const {
const VkBuffer buffers[] = { vertexBuffer_->handle() };
const VkDeviceSize offsets[] = { 0 };
vkCmdBindVertexBuffers(commandBuffer, 0, 1, buffers, offsets);
// uint32 : suffisant pour de gros meshes, indispensable pour du terrain
// LiDAR plus tard (uint16 plafonnerait a 65536 sommets).
vkCmdBindIndexBuffer(commandBuffer, indexBuffer_->handle(), 0, VK_INDEX_TYPE_UINT32);
}
void Mesh::draw(VkCommandBuffer commandBuffer) const {
+46 -46
Voir le fichier
@@ -1,55 +1,50 @@
#pragma once
#include "renderer/GpuBufferPool.hpp"
#include <vulkan/vulkan.h>
#include <cstdint>
#include <memory>
namespace vercora {
class VulkanContext;
class VulkanBuffer;
class BufferUploader;
struct MeshData;
// PHASE 32. Format des sommets d'un maillage, tel que son pipeline les lit
// (voir renderer/GpuVertex.hpp). Un maillage de terrain ne peut etre dessine
// qu'avec Material::Terrain, un maillage d'objet qu'avec les autres : le
// Renderer ecarte tout DrawItem qui melangerait les deux, plutot que de laisser
// le GPU lire 16 octets la ou il en attend 44.
enum class VertexLayout : uint8_t {
Object, // ObjectVertex, 44 octets
Terrain, // TerrainVertex, 16 octets
};
// Un mesh pret a etre dessine : vertex buffer + index buffer device-local et
// leurs compteurs. Interchangeable par construction : le Renderer ne sait pas
// d'ou vient la geometrie (fichier .obj, cube code en dur, terrain genere plus
// tard), il recoit un Mesh et l'affiche.
// Un maillage pret a etre dessine : une plage de sommets et une plage d'indices
// dans les blocs partages du GpuBufferPool, et leurs compteurs.
//
// L'upload passe par VulkanBuffer (staging host-visible -> device-local), le
// meme chemin que la Phase 1, factorise ici en une seule fonction.
// PHASE 32 : un Mesh ne possede PLUS de buffer Vulkan. Il possede des PLAGES,
// rendues au pool a sa destruction - laquelle est toujours differee par le
// Renderer de kMaxFramesInFlight + 1 images, exactement comme l'etaient les
// buffers jusqu'ici (voir Renderer::removeMesh). La topologie peut aussi etre
// PARTAGEE (les tuiles de terrain en ont une seule pour toutes) : le Mesh ne la
// rend alors pas, c'est le Renderer qui la possede.
//
// PHASE 12 : cet upload n'ATTEND PLUS le GPU. La copie est confiee a un
// BufferUploader (le Renderer), qui l'enregistre en tete du command buffer de la
// frame suivante ; le constructeur revient des que la geometrie a ete recopiee
// dans un buffer staging, sans aucune synchronisation. Consequence a garder en
// tete : les buffers du Mesh ne contiennent la geometrie qu'a partir de
// l'execution de cette frame - c'est-a-dire avant tout draw qui pourrait les
// lire, puisque la copie est enregistree AVANT le render pass et separee de lui
// par une barriere.
// Le televersement (conversion des sommets, ecriture directe ou staging) est
// fait par le Renderer avant de construire le Mesh : cette classe ne fait que
// decrire et dessiner.
class Mesh {
public:
// `uploader` recoit les copies staging -> device-local. Il doit vivre plus
// longtemps que la frame en cours (en pratique c'est le Renderer lui-meme).
// Lance std::runtime_error si la geometrie est vide ou incoherente.
// `log` a false pour les geometries creees en masse (les tuiles du quadtree
// de la Phase 10) : une ligne de journal par tuile noierait toute autre
// information et couterait plus cher que l'upload lui-meme.
Mesh(VulkanContext& context,
BufferUploader& uploader,
const MeshData& data,
bool log = true);
Mesh(GpuBufferPool& pool, VertexLayout layout,
const GpuRange& vertices, uint32_t vertexCount,
const GpuRange& indices, VkIndexType indexType, uint32_t indexCount,
bool ownsIndices);
~Mesh();
Mesh(const Mesh&) = delete;
Mesh& operator=(const Mesh&) = delete;
// Lie les buffers du mesh au command buffer courant.
void bind(VkCommandBuffer commandBuffer) const;
// Emet le draw indexe. A appeler apres bind() et apres avoir lie les
// descriptor sets / le pipeline.
// Emet le draw indexe. A appeler apres avoir lie les plages du maillage
// (Renderer::recordCommandBuffer, qui evite les liaisons redondantes), les
// descriptor sets et le pipeline.
void draw(VkCommandBuffer commandBuffer) const;
// PHASE 11 : meme dessin, repete `instanceCount` fois. Les instances lisent
@@ -60,22 +55,27 @@ public:
uint32_t vertexCount() const { return vertexCount_; }
uint32_t indexCount() const { return indexCount_; }
VertexLayout layout() const { return layout_; }
const GpuRange& vertexRange() const { return vertices_; }
const GpuRange& indexRange() const { return indices_; }
VkIndexType indexType() const { return indexType_; }
// Octets de geometrie PROPRES a ce maillage (la topologie partagee n'est
// pas comptee : elle n'existe qu'une fois).
VkDeviceSize ownedBytes() const {
return vertices_.size + (ownsIndices_ ? indices_.size : 0);
}
private:
// Cree un buffer device-local et CONFIE a l'uploader la copie depuis un
// staging temporaire. Commun au vertex buffer et a l'index buffer.
static std::unique_ptr<VulkanBuffer> createDeviceLocalBuffer(
VulkanContext& context,
BufferUploader& uploader,
const void* data,
VkDeviceSize size,
VkBufferUsageFlags usage);
std::unique_ptr<VulkanBuffer> vertexBuffer_;
std::unique_ptr<VulkanBuffer> indexBuffer_;
GpuBufferPool& pool_;
VertexLayout layout_ = VertexLayout::Object;
GpuRange vertices_;
GpuRange indices_;
VkIndexType indexType_ = VK_INDEX_TYPE_UINT32;
uint32_t vertexCount_ = 0;
uint32_t indexCount_ = 0;
bool ownsIndices_ = true;
};
} // namespace vercora
+18 -10
Voir le fichier
@@ -41,15 +41,15 @@ Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayo
const std::array<VkPipelineShaderStageCreateInfo, 2> stages = { vertStage, fragStage };
// Vertex input : un binding entrelace, et autant d'attributs que le vertex
// shader en consomme reellement - quatre (pos, color, normal, uv) pour les
// objets, six pour le terrain, dont la cible de geomorphing. Le STRIDE, lui,
// reste toujours sizeof(Vertex) : le format de sommet cote C++ est unique.
const auto bindingDescription = vertexBindingDescription();
const auto attributeDescriptions = vertexAttributeDescriptions();
const uint32_t attributeCount = shaders.usesMorphAttributes
? static_cast<uint32_t>(attributeDescriptions.size())
: 4u;
// Vertex input : un binding entrelace, au format de la famille de shaders
// (PHASE 32, voir renderer/GpuVertex.hpp) - ObjectVertex pour les objets
// et la vegetation, TerrainVertex pour le terrain.
const VkVertexInputBindingDescription bindingDescription =
shaders.terrainVertexLayout ? terrainBindingDescription()
: objectBindingDescription();
const std::array<VkVertexInputAttributeDescription, 4> attributeDescriptions =
shaders.terrainVertexLayout ? terrainAttributeDescriptions()
: objectAttributeDescriptions();
// PHASE 11 : un materiau instancie decrit DEUX bindings (sommets et
// instances) et concatene leurs attributs. Les tableaux sont construits ici
@@ -59,7 +59,7 @@ Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayo
std::vector<VkVertexInputBindingDescription> bindings{ bindingDescription };
std::vector<VkVertexInputAttributeDescription> attributes(
attributeDescriptions.begin(), attributeDescriptions.begin() + attributeCount);
attributeDescriptions.begin(), attributeDescriptions.end());
// PHASE 27 : une passe plein ecran ne lit AUCUN buffer de sommets.
if (shaders.fullscreenOverlay) {
@@ -99,6 +99,14 @@ Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayo
rasterizer.lineWidth = 1.0f;
rasterizer.cullMode = VK_CULL_MODE_NONE; // pas de culling : triangle toujours visible
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
if (shaders.cullBackFaces) {
// PHASE 32 : voir ShaderSet::cullBackFaces. Le terrain est enroule
// (v00, v01, v11) avec Z vers le sud ; une fois l'axe Y de la
// projection retourne (Renderer::projectionMatrix), une face vue
// d'en haut est tramee dans le sens ANTIHORAIRE du framebuffer.
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
}
rasterizer.depthBiasEnable = VK_FALSE;
VkPipelineMultisampleStateCreateInfo multisampling{};
+30 -14
Voir le fichier
@@ -14,22 +14,20 @@ struct ShaderSet {
std::string vertexSpv;
std::string fragmentSpv;
// true si le vertex shader consomme les attributs de geomorphing
// (locations 4 et 5, voir Vertex.hpp). Seul terrain.vert le fait.
// true si le vertex shader lit le format de sommet du TERRAIN
// (TerrainVertex, 16 octets) ; false pour le format des objets et de la
// vegetation (ObjectVertex, 44 octets). Voir renderer/GpuVertex.hpp.
//
// Ce drapeau n'est pas une optimisation mais une CORRECTION : declarer dans
// le vertex input un attribut qu'aucun shader ne lit fait emettre aux
// couches de validation "Vertex attribute at location 4 not consumed by
// vertex shader", et le contrat du projet est zero message de validation. Le
// format de sommet reste unique cote C++ ; c'est seulement sa DESCRIPTION au
// pipeline qui est tronquee pour les materiaux qui n'en lisent qu'une partie
// (ce que Vulkan autorise : un binding peut avoir un stride plus grand que
// la somme des attributs decrits).
bool usesMorphAttributes = false;
// PHASE 32 : jusqu'ici ce drapeau (usesMorphAttributes) ne faisait que
// TRONQUER la description d'un format unique de 68 octets, pour ne pas
// declarer aux shaders d'objets les attributs de morphing qu'ils ne lisent
// pas (zero message de validation). Les deux familles ont desormais chacune
// leur format, et les octets inutiles ont quitte les buffers eux-memes.
bool terrainVertexLayout = false;
// PHASE 11. true si le pipeline doit decrire le second binding de sommets,
// cadence par instance (voir VertexFormat.hpp). Meme raisonnement que
// usesMorphAttributes : c'est une CORRECTION, pas une optimisation. Decrire
// cadence par instance (voir VertexFormat.hpp). C'est une CORRECTION, pas
// une optimisation (zero message de validation). Decrire
// un binding d'instances a un pipeline non instancie obligerait a lier un
// buffer d'instances avant de dessiner un cube, et ne pas le decrire a un
// pipeline instancie ferait echouer la validation sur les locations 6 a 8.
@@ -39,6 +37,23 @@ struct ShaderSet {
// fabrique un triangle couvrant a partir de gl_VertexIndex), pas de test
// ni d'ecriture de profondeur, melange par alpha.
bool fullscreenOverlay = false;
// PHASE 32 : elimine les faces ARRIERE avant le tramage. Reserve au
// terrain, et c'est une propriete de la geometrie, pas un reglage : un
// champ de hauteurs a toutes ses normales geometriques vers le haut, et un
// rayon parti d'un oeil situe AU-DESSUS du relief rencontre toujours une
// face avant en premier - une face arriere n'est donc jamais le pixel
// visible, elle ne fait que couter du tramage et des tests de profondeur.
// (Image identique au bit pres, verifiee - NOTES-PHASE32.md.) Les objets
// et la vegetation ne s'y pretent pas : l'herbe est un quad vu des deux
// cotes, et rien ne garantit l'enroulement des maillages .obj.
//
// MESURE (lavapipe, NOTES-PHASE32.md) : -10 % de temps de rendu sur le
// panorama. L'image n'est PAS identique au bit pres : 315 pixels isoles
// (0,03 %) changent, tous sur des parois quasi verticales vues en rasant,
// la ou une face arriere l'emportait d'un cheveu sur la face avant par
// erreur d'arrondi de profondeur. C'est desormais toujours la face avant.
bool cullBackFaces = false;
};
// Shaders de la Phase 2 : couleur par sommet + Blinn-Phong. Utilises par le
@@ -46,7 +61,8 @@ struct ShaderSet {
inline const ShaderSet kObjectShaders{ "cube.vert.spv", "cube.frag.spv" };
// Shaders de la Phase 4 : coloration par altitude et par pente + Blinn-Phong.
inline const ShaderSet kTerrainShaders{ "terrain.vert.spv", "terrain.frag.spv", true };
inline const ShaderSet kTerrainShaders{ "terrain.vert.spv", "terrain.frag.spv", true,
false, false, true };
// Shaders de la Phase 11 : vegetation instanciee (arbres de decor et herbe).
// Ne lit PAS les attributs de geomorphing, mais lit le binding d'instances.
+117
Voir le fichier
@@ -0,0 +1,117 @@
#pragma once
#include <cstdint>
#include <limits>
#include <vector>
namespace vercora {
// PHASE 32. Gestion des plages libres d'UN bloc de memoire : premier
// ajustement, alignement, fusion des voisins a la liberation.
//
// C'est toute la logique de sous-allocation de GpuBufferPool, isolee ici sans
// la moindre dependance Vulkan pour etre testee headless (tests/logic_tests.cpp)
// : un decalage faux dans un allocateur ne se voit pas a l'ecran avant d'avoir
// ecrase la geometrie d'un autre maillage.
//
// Les tailles en jeu ne justifient pas mieux qu'une liste triee : quelques
// dizaines de plages par bloc au pire (les tuiles de terrain ont toutes la meme
// taille, donc un trou laisse par une tuile evincee est exactement celui que la
// suivante remplit).
class RangeAllocator {
public:
static constexpr uint64_t kInvalid = std::numeric_limits<uint64_t>::max();
explicit RangeAllocator(uint64_t capacity) : capacity_(capacity) {
if (capacity > 0) {
free_.push_back({ 0, capacity });
}
}
uint64_t capacity() const { return capacity_; }
uint64_t used() const { return used_; }
bool empty() const { return used_ == 0; }
// Plus grande plage libre : sert a decider s'il faut un nouveau bloc.
uint64_t largestFree() const {
uint64_t best = 0;
for (const Span& span : free_) {
best = (span.size > best) ? span.size : best;
}
return best;
}
// Reserve `size` octets alignes sur `alignment` (puissance de deux).
// Renvoie le decalage, ou kInvalid si aucune plage ne convient.
uint64_t allocate(uint64_t size, uint64_t alignment) {
if (size == 0 || alignment == 0 || (alignment & (alignment - 1)) != 0) {
return kInvalid;
}
for (std::size_t k = 0; k < free_.size(); ++k) {
const Span span = free_[k];
const uint64_t aligned = (span.offset + alignment - 1) & ~(alignment - 1);
const uint64_t padding = aligned - span.offset;
if (padding > span.size || span.size - padding < size) {
continue;
}
// La plage est decoupee en (rembourrage avant) + (reserve) + (reste).
// Le rembourrage reste LIBRE : il n'est perdu que tant qu'aucune
// demande plus petite ne le reclame.
const uint64_t tailOffset = aligned + size;
const uint64_t tailSize = span.offset + span.size - tailOffset;
free_.erase(free_.begin() + static_cast<std::ptrdiff_t>(k));
std::size_t insertAt = k;
if (padding > 0) {
free_.insert(free_.begin() + static_cast<std::ptrdiff_t>(insertAt),
Span{ span.offset, padding });
++insertAt;
}
if (tailSize > 0) {
free_.insert(free_.begin() + static_cast<std::ptrdiff_t>(insertAt),
Span{ tailOffset, tailSize });
}
used_ += size;
return aligned;
}
return kInvalid;
}
// Rend une plage obtenue par allocate. Fusionne avec les plages libres
// contigues, pour qu'une serie d'evictions reconstitue de grands trous.
void release(uint64_t offset, uint64_t size) {
if (size == 0) {
return;
}
std::size_t k = 0;
while (k < free_.size() && free_[k].offset < offset) {
++k;
}
free_.insert(free_.begin() + static_cast<std::ptrdiff_t>(k), Span{ offset, size });
used_ -= size;
// Fusion avec le suivant, puis avec le precedent.
if (k + 1 < free_.size() && free_[k].offset + free_[k].size == free_[k + 1].offset) {
free_[k].size += free_[k + 1].size;
free_.erase(free_.begin() + static_cast<std::ptrdiff_t>(k + 1));
}
if (k > 0 && free_[k - 1].offset + free_[k - 1].size == free_[k].offset) {
free_[k - 1].size += free_[k].size;
free_.erase(free_.begin() + static_cast<std::ptrdiff_t>(k));
}
}
// Nombre de plages libres disjointes : 1 pour un bloc vide, et c'est
// l'invariant que les tests verifient apres une liberation complete.
std::size_t freeSpanCount() const { return free_.size(); }
private:
struct Span {
uint64_t offset;
uint64_t size;
};
uint64_t capacity_ = 0;
uint64_t used_ = 0;
std::vector<Span> free_; // trie par decalage croissant, jamais deux contigues
};
} // namespace vercora
+362 -19
Voir le fichier
@@ -1,6 +1,7 @@
#include "renderer/Renderer.hpp"
#include "assets/DetailNoise.hpp"
#include "assets/TextureFile.hpp"
#include "core/Camera.hpp"
#include "core/Logger.hpp"
@@ -18,13 +19,35 @@
#include <algorithm>
#include <array>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <stdexcept>
namespace vercora {
namespace {
// PHASE 32 : barriere d'EXECUTION placee AVANT les copies staging -> pool.
//
// Avant le pool, chaque copie ecrivait un buffer neuf, que rien n'avait jamais
// lu. Desormais une plage du pool est RECYCLEE : la copie ecrit des octets que
// des images precedentes ont lus comme sommets ou indices. Le delai de retrait
// (Renderer::removeMesh) garantit que ces images sont terminees, mais il le
// garantit cote CPU, par les fences ; la validation de SYNCHRONISATION signale
// a juste titre que rien ne l'exprime cote GPU (SYNC-HAZARD-WRITE-AFTER-READ,
// 414 messages en 30 s de survol avec --force-staging). Un danger ecriture
// apres lecture ne demande qu'une dependance d'EXECUTION : pas de masque
// d'acces, l'etage d'assemblage des sommets avant, le transfert apres. Le
// chemin d'ecriture directe (memoire unifiee) n'a pas de copie, donc pas de
// barriere.
void recordCopyAfterReadBarrier(VkCommandBuffer commandBuffer) {
vkCmdPipelineBarrier(commandBuffer,
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
0, 0, nullptr, 0, nullptr, 0, nullptr);
}
// Paire de shaders associee a chaque materiau. L'ordre suit celui de l'enum
// Material : c'est ce tableau qui fait le lien entre le vocabulaire du gameplay
// ("cet objet est du terrain") et celui du rendu ("ces .spv").
@@ -42,7 +65,24 @@ const ShaderSet& shadersFor(Material material) {
Renderer::Renderer(VulkanContext& context, Window& window,
const RenderOptions& options)
: context_(context), window_(window), options_(options) {
swapChain_ = std::make_unique<SwapChain>(context_, window_);
swapChain_ = std::make_unique<SwapChain>(context_, window_, options_.vsync);
// PHASE 32 : le pool de geometrie. En memoire unifiee (GPU integre,
// lavapipe), ses blocs sont mappes et la geometrie y est ecrite DIRECTEMENT
// : ni staging, ni copie, ni barriere. Sur un GPU discret, la memoire
// device-local n'est pas (ou peu) mappable : chemin staging de la Phase 12.
const bool directWrites = context_.preferDirectGeometryWrites() && !options_.forceStaging;
geometryPool_ = std::make_unique<GpuBufferPool>(
context_,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, directWrites);
logInfo(std::string("Geometrie : pool de blocs de ") +
std::to_string(GpuBufferPool::kDefaultBlockSize / (1024 * 1024)) + " Mo, " +
(directWrites ? "ecriture DIRECTE (memoire unifiee, sans staging)."
: (options_.forceStaging
? "televersement par staging (FORCE, --force-staging)."
: "televersement par staging (memoire device-local non mappable).")));
createCommandPool(); // requis avant les buffers (transferts staging)
@@ -88,6 +128,15 @@ Renderer::Renderer(VulkanContext& context, Window& window,
Renderer::~Renderer() {
VkDevice device = context_.device();
// PHASE 32 : rien ne doit plus lire la geometrie quand ses plages sont
// rendues au pool (les Mesh le font en se detruisant, apres ce corps).
vkDeviceWaitIdle(device);
pendingTerrainWrites_.clear();
for (SharedIndices& shared : sharedIndices_) {
geometryPool_->release(shared.range);
}
sharedIndices_.clear();
for (VkSemaphore s : imageAvailableSemaphores_) {
vkDestroySemaphore(device, s, nullptr);
}
@@ -116,32 +165,248 @@ void Renderer::waitIdle() const {
vkDeviceWaitIdle(context_.device());
}
MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) {
// Le Mesh valide les donnees et leve une exception si elles sont
// incoherentes, avant toute allocation durable. Construit AVANT de toucher
// aux tableaux : si la construction echoue, aucun emplacement n'a ete
// consomme.
auto mesh = std::make_unique<Mesh>(context_, *this, meshData, log);
MeshHandle Renderer::registerMesh(std::unique_ptr<Mesh> mesh) {
++liveMeshCount_;
if (!freeMeshSlots_.empty()) {
const MeshHandle handle = freeMeshSlots_.back();
freeMeshSlots_.pop_back();
meshes_[handle] = std::move(mesh);
return handle;
}
meshes_.push_back(std::move(mesh));
return static_cast<MeshHandle>(meshes_.size() - 1);
}
Renderer::RangeWrite Renderer::beginRangeWrite(const GpuRange& range) {
RangeWrite write;
write.range = range;
if (range.mapped != nullptr) {
// Memoire unifiee : on ecrit la ou le GPU lira. Sans danger pour la
// synchronisation - une plage n'est rendue au pool qu'une fois que plus
// aucune image en vol ne la lit (Renderer::removeMesh), et l'ecriture
// hote est visible du GPU a la soumission suivante (memoire coherente).
write.destination = range.mapped;
return write;
}
write.staging = std::make_unique<VulkanBuffer>(
context_, range.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
write.staging->map();
write.destination = write.staging->mapped();
return write;
}
void Renderer::finishRangeWrite(RangeWrite& write) {
if (write.staging) {
write.staging->unmap();
enqueueCopy(std::move(write.staging), write.range.buffer, write.range.offset);
}
write.destination = nullptr;
}
MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) {
// --- Validation AVANT toute allocation ----------------------------------
// Un index hors limites ne produit pas d'erreur a la creation du buffer :
// il se manifesterait au draw, sous forme de lecture hors du vertex buffer
// (comportement indefini cote GPU). Mieux vaut refuser ici, avec un message
// qui dit quoi. Si la geometrie est refusee, aucun emplacement n'a ete
// consomme.
if (meshData.vertices.empty()) {
throw std::runtime_error("Mesh vide : aucun sommet (" + meshData.name + ").");
}
if (meshData.indices.empty()) {
throw std::runtime_error("Mesh vide : aucun index (" + meshData.name + ").");
}
if (meshData.indices.size() % 3 != 0) {
throw std::runtime_error(
"Mesh non triangule : " + std::to_string(meshData.indices.size()) +
" index, ce qui n'est pas un multiple de 3 (" + meshData.name + ").");
}
const auto vertexCount = static_cast<uint32_t>(meshData.vertices.size());
for (uint32_t index : meshData.indices) {
if (index >= vertexCount) {
throw std::runtime_error(
"Index hors limites dans le mesh : " + std::to_string(index) +
" pour " + std::to_string(vertexCount) + " sommets (" + meshData.name + ").");
}
}
const auto indexCount = static_cast<uint32_t>(meshData.indices.size());
// PHASE 32 : sommets au format ObjectVertex (44 octets, conversion exacte)
// et indices en uint16 des que le maillage a au plus 65 536 sommets - le
// cas de TOUS les maillages d'objets du jeu. Les valeurs sont les memes,
// seule leur largeur change.
const bool shortIndices = vertexCount <= 65536u;
const VkDeviceSize vertexBytes = static_cast<VkDeviceSize>(vertexCount) * sizeof(ObjectVertex);
const VkDeviceSize indexBytes = static_cast<VkDeviceSize>(indexCount) *
(shortIndices ? sizeof(uint16_t) : sizeof(uint32_t));
// Le Mesh possede ses plages DES leur allocation : si la suite echoue
// (memoire epuisee), il les rend au pool en se detruisant. Et aucune copie
// n'est confiee a l'image suivante avant que les DEUX ecritures aient
// reussi - sinon une copie en attente viserait une plage deja rendue.
auto mesh = allocateMesh(VertexLayout::Object, vertexBytes, vertexCount, indexBytes,
shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32,
indexCount);
RangeWrite vertexWrite = beginRangeWrite(mesh->vertexRange());
RangeWrite indexWrite = beginRangeWrite(mesh->indexRange());
auto* vertices = static_cast<ObjectVertex*>(vertexWrite.destination);
for (uint32_t v = 0; v < vertexCount; ++v) {
vertices[v] = toObjectVertex(meshData.vertices[v]);
}
if (shortIndices) {
auto* indices = static_cast<uint16_t*>(indexWrite.destination);
for (uint32_t k = 0; k < indexCount; ++k) {
indices[k] = static_cast<uint16_t>(meshData.indices[k]);
}
} else {
std::memcpy(indexWrite.destination, meshData.indices.data(),
static_cast<std::size_t>(indexBytes));
}
finishRangeWrite(vertexWrite);
finishRangeWrite(indexWrite);
if (log) {
logInfo("Mesh charge sur le GPU : " + meshData.name + " - " +
std::to_string(vertexCount) + " sommets, " +
std::to_string(indexCount / 3) + " triangles, " +
std::to_string((vertexBytes + indexBytes + 1023) / 1024) + " Ko.");
}
return registerMesh(std::move(mesh));
}
std::unique_ptr<Mesh> Renderer::allocateMesh(VertexLayout layout, VkDeviceSize vertexBytes,
uint32_t vertexCount, VkDeviceSize indexBytes,
VkIndexType indexType, uint32_t indexCount) {
const GpuRange vertexRange = geometryPool_->allocate(vertexBytes);
GpuRange indexRange;
try {
indexRange = geometryPool_->allocate(indexBytes);
} catch (...) {
geometryPool_->release(vertexRange);
throw;
}
return std::make_unique<Mesh>(*geometryPool_, layout, vertexRange, vertexCount,
indexRange, indexType, indexCount, true);
}
MeshHandle Renderer::addTerrainMesh(const std::vector<TerrainVertex>& vertices,
const std::vector<uint32_t>& indices,
const std::string& name, bool log) {
if (vertices.empty() || indices.empty() || indices.size() % 3 != 0) {
throw std::runtime_error("Terrain : geometrie vide ou non triangulee (" + name + ").");
}
const auto vertexCount = static_cast<uint32_t>(vertices.size());
for (uint32_t index : indices) {
if (index >= vertexCount) {
throw std::runtime_error("Terrain : index " + std::to_string(index) +
" hors des " + std::to_string(vertexCount) +
" sommets (" + name + ").");
}
}
const VkDeviceSize vertexBytes = static_cast<VkDeviceSize>(vertexCount) * sizeof(TerrainVertex);
const VkDeviceSize indexBytes = static_cast<VkDeviceSize>(indices.size()) * sizeof(uint32_t);
// Meme ordre que addMesh : plages possedees d'abord, copies confiees ensuite.
auto mesh = allocateMesh(VertexLayout::Terrain, vertexBytes, vertexCount, indexBytes,
VK_INDEX_TYPE_UINT32, static_cast<uint32_t>(indices.size()));
RangeWrite vertexWrite = beginRangeWrite(mesh->vertexRange());
RangeWrite indexWrite = beginRangeWrite(mesh->indexRange());
std::memcpy(vertexWrite.destination, vertices.data(), static_cast<std::size_t>(vertexBytes));
std::memcpy(indexWrite.destination, indices.data(), static_cast<std::size_t>(indexBytes));
finishRangeWrite(vertexWrite);
finishRangeWrite(indexWrite);
if (log) {
logInfo("Terrain charge sur le GPU : " + name + " - " + std::to_string(vertexCount) +
" sommets, " + std::to_string(indices.size() / 3) + " triangles, " +
std::to_string((vertexBytes + indexBytes) / (1024 * 1024)) + " Mo.");
}
return registerMesh(std::move(mesh));
}
uint32_t Renderer::addSharedIndices(const std::vector<uint32_t>& indices) {
if (indices.empty() || indices.size() % 3 != 0) {
throw std::runtime_error("Topologie partagee vide ou non triangulee.");
}
const uint32_t highest = *std::max_element(indices.begin(), indices.end());
const bool shortIndices = highest <= 0xFFFFu;
SharedIndices shared;
shared.count = static_cast<uint32_t>(indices.size());
shared.type = shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32;
shared.range = geometryPool_->allocate(static_cast<VkDeviceSize>(indices.size()) *
(shortIndices ? sizeof(uint16_t) : sizeof(uint32_t)));
RangeWrite write;
try {
write = beginRangeWrite(shared.range);
} catch (...) {
geometryPool_->release(shared.range);
throw;
}
if (shortIndices) {
auto* out = static_cast<uint16_t*>(write.destination);
for (std::size_t k = 0; k < indices.size(); ++k) {
out[k] = static_cast<uint16_t>(indices[k]);
}
} else {
std::memcpy(write.destination, indices.data(), indices.size() * sizeof(uint32_t));
}
finishRangeWrite(write);
sharedIndices_.push_back(shared);
return static_cast<uint32_t>(sharedIndices_.size() - 1);
}
Renderer::TerrainMeshWrite Renderer::beginTerrainMesh(uint32_t vertexCount,
uint32_t sharedIndices) {
if (sharedIndices >= sharedIndices_.size() || vertexCount == 0) {
throw std::runtime_error("Tuile de terrain : topologie partagee inconnue.");
}
const SharedIndices& shared = sharedIndices_[sharedIndices];
// Le Mesh possede sa plage avant l'ecriture : si le staging ne peut pas
// etre cree, il la rend au pool en se detruisant.
auto mesh = std::make_unique<Mesh>(
*geometryPool_, VertexLayout::Terrain,
geometryPool_->allocate(static_cast<VkDeviceSize>(vertexCount) * sizeof(TerrainVertex)),
vertexCount, shared.range, shared.type, shared.count, false);
RangeWrite write = beginRangeWrite(mesh->vertexRange());
TerrainMeshWrite result;
result.vertices = static_cast<TerrainVertex*>(write.destination);
result.mesh = registerMesh(std::move(mesh));
if (write.staging) {
pendingTerrainWrites_.emplace(result.mesh, std::move(write));
}
return result;
}
void Renderer::endTerrainMesh(MeshHandle mesh) {
const auto it = pendingTerrainWrites_.find(mesh);
if (it == pendingTerrainWrites_.end()) {
return; // ecriture directe : rien a livrer, le GPU lit deja ces octets
}
finishRangeWrite(it->second);
pendingTerrainWrites_.erase(it);
}
void Renderer::setTerrainGrid(float origin, float spacing, uint32_t cells) {
terrainGrid_ = glm::vec4(origin, spacing, static_cast<float>(cells), 0.0f);
}
std::string Renderer::geometryLine() const {
return "Geometrie : " + geometryPool_->statsLine();
}
void Renderer::removeMesh(MeshHandle handle) {
if (handle >= meshes_.size() || !meshes_[handle]) {
return; // deja libere, ou poignee invalide : ne rien faire est sans risque
}
// PHASE 32 : une tuile commencee mais jamais livree (ecriture en echec)
// abandonne son staging : il n'y a rien a copier.
pendingTerrainWrites_.erase(handle);
// Le mesh sort de la table tout de suite (sa poignee redevient disponible)
// mais ses buffers Vulkan survivent le temps que les frames deja soumises
// aient fini de les lire. Voir le commentaire de declaration.
// mais ses plages de geometrie survivent le temps que les frames deja
// soumises aient fini de les lire. Voir le commentaire de declaration.
retiredMeshes_.push_back({ std::move(meshes_[handle]), kMaxFramesInFlight + 1 });
freeMeshSlots_.push_back(handle);
--liveMeshCount_;
@@ -358,6 +623,26 @@ void Renderer::setTerrainTexture(const TextureData& data) {
" Mo sur le GPU.");
}
void Renderer::setTerrainTextureFromFile(const TextureData& header, const std::string& path) {
waitIdle();
std::ifstream file(path, std::ios::binary);
if (!file) {
throw std::runtime_error("Texture : fichier introuvable ou illisible : " + path);
}
terrainTexture_ = std::make_unique<Texture>(
context_, commandPool_, context_.graphicsQueue(), header,
[&file](void* destination, uint64_t offset, uint64_t bytes) {
readTexturePayload(file, offset, bytes, destination);
});
writeTextureDescriptors();
logInfo("Orthophoto reliee au terrain : " + std::to_string(header.width) + "x" +
std::to_string(header.height) + ", " +
std::to_string(terrainTexture_->deviceSize() / (1024 * 1024)) +
" Mo sur le GPU, lue par tranches directement dans le staging.");
}
void Renderer::setOrthoMix(float mix) {
options_.orthoMix = std::clamp(mix, 0.0f, 1.0f);
}
@@ -441,6 +726,7 @@ void Renderer::updateUniformBuffer(uint32_t frameIndex, const Camera& camera) {
ubo.precip = precip_;
ubo.fall = fall_;
ubo.detail = detail_;
ubo.terrainGrid = terrainGrid_;
std::memcpy(uniformBuffers_[frameIndex]->mapped(), &ubo, sizeof(ubo));
}
@@ -524,13 +810,15 @@ void Renderer::destroyImageSyncObjects() {
// - la tuile est lisible DES CETTE FRAME : le repli sur l'ancetre ne sert donc
// qu'aux tuiles pas encore CONSTRUITES (budget), pas a une latence de
// transfert.
void Renderer::enqueueCopy(std::unique_ptr<VulkanBuffer> staging, VkBuffer destination) {
void Renderer::enqueueCopy(std::unique_ptr<VulkanBuffer> staging, VkBuffer destination,
VkDeviceSize destinationOffset) {
if (!staging || destination == VK_NULL_HANDLE) {
return;
}
PendingCopy copy;
copy.size = staging->size();
copy.destination = destination;
copy.destinationOffset = destinationOffset;
copy.staging = std::move(staging);
stagingBytesInFlight_ += static_cast<std::size_t>(copy.size);
pendingCopies_.push_back(std::move(copy));
@@ -565,8 +853,10 @@ void Renderer::flushCopiesNow() {
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
recordCopyAfterReadBarrier(commandBuffer);
for (const PendingCopy& copy : pendingCopies_) {
VkBufferCopy region{};
region.dstOffset = copy.destinationOffset;
region.size = copy.size;
vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination,
1, &region);
@@ -603,8 +893,10 @@ void Renderer::recordPendingCopies(VkCommandBuffer commandBuffer) {
return;
}
recordCopyAfterReadBarrier(commandBuffer);
for (PendingCopy& copy : pendingCopies_) {
VkBufferCopy region{};
region.dstOffset = copy.destinationOffset;
region.size = copy.size;
vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination,
1, &region);
@@ -694,9 +986,56 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
// n'est lie qu'une fois par materiau reellement utilise (au plus deux fois
// par frame ici). Avec quelques dizaines d'objets, ce tri "par balayage"
// coute moins cher qu'un vrai tri, et evite de copier la liste.
for (uint32_t m = 0; m < kMaterialCount; ++m) {
const Material material = static_cast<Material>(m);
//
// PHASE 32 : le TERRAIN en dernier. Son shader de fragment est le plus
// lourd du jeu (orthophoto, micro-relief, adret/ubac, brouillard) ; dessine
// apres les troncs, les houppiers et l'herbe, il trouve leur profondeur
// deja ecrite et le test de profondeur PRECOCE ecarte ses fragments caches
// avant de les ombrer. Tout est opaque et le test est LESS : l'ordre ne
// change l'image qu'a profondeur RIGOUREUSEMENT EGALE - le pied d'un brin
// ou d'un tronc, pose exactement sur la surface du sol. Mesure : 24 pixels
// sur 921 600 en foret, et une variante qui rend ces egalites au terrain
// redonne l'image de reference au bit pres (NOTES-PHASE32.md). Gain : -26 %
// de temps de rendu en foret (lavapipe).
static constexpr std::array<Material, kMaterialCount> kDrawOrder{
Material::Object, Material::Foliage, Material::Terrain };
// PHASE 32 : liaisons de buffers EVITEES quand elles ne changent rien. Les
// tuiles de terrain partagent une seule topologie : elle est liee une fois
// par image au lieu d'une fois par tuile. Les liaisons survivent aux
// changements de pipeline (etat du command buffer, pas du pipeline).
VkBuffer boundVertexBuffer = VK_NULL_HANDLE;
VkDeviceSize boundVertexOffset = 0;
VkBuffer boundIndexBuffer = VK_NULL_HANDLE;
VkDeviceSize boundIndexOffset = 0;
VkIndexType boundIndexType = VK_INDEX_TYPE_MAX_ENUM;
// Decalage de LIAISON plutot que vertexOffset dans le draw : gl_VertexIndex
// reste ainsi l'indice LOCAL du sommet dans son maillage, ce dont
// terrain.vert se sert pour retrouver sa place dans la grille de la tuile.
const auto bindMesh = [&](const Mesh& mesh) {
const GpuRange& vertices = mesh.vertexRange();
if (vertices.buffer != boundVertexBuffer || vertices.offset != boundVertexOffset) {
vkCmdBindVertexBuffers(commandBuffer, 0, 1, &vertices.buffer, &vertices.offset);
boundVertexBuffer = vertices.buffer;
boundVertexOffset = vertices.offset;
}
const GpuRange& indices = mesh.indexRange();
if (indices.buffer != boundIndexBuffer || indices.offset != boundIndexOffset ||
mesh.indexType() != boundIndexType) {
vkCmdBindIndexBuffer(commandBuffer, indices.buffer, indices.offset, mesh.indexType());
boundIndexBuffer = indices.buffer;
boundIndexOffset = indices.offset;
boundIndexType = mesh.indexType();
}
};
for (const Material material : kDrawOrder) {
const uint32_t m = static_cast<uint32_t>(material);
bool pipelineBound = false;
// PHASE 32 : un maillage de terrain (16 octets par sommet) ne se lit
// qu'avec le pipeline du terrain, et reciproquement.
const VertexLayout expectedLayout = (material == Material::Terrain)
? VertexLayout::Terrain : VertexLayout::Object;
for (const DrawItem& item : items) {
if (item.material != material) {
@@ -709,6 +1048,9 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
// un pointeur nul). Signaler serait bruyant a 60 Hz.
continue;
}
if (meshes_[item.mesh]->layout() != expectedLayout) {
continue; // meme raison : le GPU lirait des octets d'un autre format
}
if (!pipelineBound) {
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
@@ -723,17 +1065,17 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
pipelineBound = true;
}
// Transformation et parametres propres a cet objet. Les deux sont
// Transformation et parametres propres a cet objet. Tous sont
// pousses d'un seul coup : ils sont contigus dans DrawItemPush,
// dont le layout reproduit exactement le bloc push_constant des
// shaders (voir DrawItem.hpp).
const DrawItemPush push{ item.model, item.params };
const DrawItemPush push{ item.model, item.params, item.grid };
vkCmdPushConstants(commandBuffer, pipelines_[m]->layout(),
VK_SHADER_STAGE_VERTEX_BIT, 0,
static_cast<uint32_t>(sizeof(DrawItemPush)), &push);
const Mesh& mesh = *meshes_[item.mesh];
mesh.bind(commandBuffer);
bindMesh(mesh);
mesh.draw(commandBuffer);
}
@@ -746,7 +1088,8 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
if (item.material != material || item.count == 0) {
continue;
}
if (item.mesh >= meshes_.size() || !meshes_[item.mesh]) {
if (item.mesh >= meshes_.size() || !meshes_[item.mesh] ||
meshes_[item.mesh]->layout() != expectedLayout) {
continue;
}
@@ -765,7 +1108,7 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
static_cast<uint32_t>(sizeof(DrawItemPush)), &push);
const Mesh& mesh = *meshes_[item.mesh];
mesh.bind(commandBuffer);
bindMesh(mesh);
// Binding 1 : la tranche du buffer d'instances qui appartient a cet
// objet. L'offset a ete calcule par uploadInstances, dans le meme
+106 -2
Voir le fichier
@@ -1,6 +1,9 @@
#pragma once
#include "renderer/DrawItem.hpp"
#include "renderer/GpuBufferPool.hpp"
#include "renderer/GpuVertex.hpp"
#include "renderer/Mesh.hpp" // VertexLayout
#include "renderer/Pipeline.hpp" // pour ShaderSet
#include "renderer/VulkanBuffer.hpp" // pour BufferUploader
@@ -11,6 +14,8 @@
#include <array>
#include <cmath>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
namespace vercora {
@@ -19,7 +24,6 @@ class VulkanContext;
class Window;
class SwapChain;
class Camera;
class Mesh;
class Texture;
struct MeshData;
struct TextureData;
@@ -49,6 +53,17 @@ struct RenderOptions {
// deux se recouvrent bien. Sans texture chargee, la valeur est ignoree (le
// binding pointe alors sur un texel blanc).
float orthoMix = 0.0f;
// PHASE 32. Force le televersement de la geometrie par STAGING meme en
// memoire unifiee, ou elle est sinon ecrite directement la ou le GPU la
// lit. Sert a eprouver sur la machine de developpement le chemin d'un GPU
// discret (option --force-staging).
bool forceStaging = false;
// PHASE 32. Presentation calee sur l'ecran (FIFO, option --vsync) : la
// cadence ne depasse plus le rafraichissement, et le CPU comme le GPU
// dorment le reste du temps. Voir SwapChain::choosePresentMode.
bool vsync = false;
};
// Orchestre le rendu : geometries enregistrees, UBO/descriptors, command
@@ -85,6 +100,48 @@ public:
// toute autre information.
MeshHandle addMesh(const MeshData& meshData, bool log = true);
// PHASE 32 : GEOMETRIE DE TERRAIN, au format compact TerrainVertex (16
// octets, voir renderer/GpuVertex.hpp). Un tel maillage ne se dessine
// qu'avec Material::Terrain et un DrawItem::grid qui dit ou il se trouve
// dans la heightmap.
//
// Terrain d'un seul bloc (--no-lod) : sommets et topologie propres.
MeshHandle addTerrainMesh(const std::vector<TerrainVertex>& vertices,
const std::vector<uint32_t>& indices,
const std::string& name, bool log = true);
// Topologie PARTAGEE par plusieurs maillages de terrain : les tuiles du
// quadtree ont toutes la meme (Phase 18), et la televerser une fois au lieu
// d'une par tuile economise 96 Ko par tuile residente. Stockee en uint16
// quand les indices le permettent (65 x 65 sommets par tuile). Vit aussi
// longtemps que le Renderer.
uint32_t addSharedIndices(const std::vector<uint32_t>& indices);
// Tuile de terrain sur une topologie partagee, ECRITE PAR L'APPELANT :
// beginTerrainMesh reserve la place et rend un pointeur sur `vertexCount`
// sommets a remplir - directement la memoire que le GPU lira en memoire
// unifiee, un staging sinon - et endTerrainMesh la livre. Entre les deux,
// l'ecriture peut se faire depuis N'IMPORTE QUEL thread (aucun appel
// Vulkan) : c'est ce qui laisse le maillage parallele de la Phase 19
// ecrire sans copie intermediaire. begin et end, eux, restent sur le
// thread de rendu, et chaque begin doit etre suivi de son end (ou d'un
// removeMesh si l'ecriture a echoue).
struct TerrainMeshWrite {
MeshHandle mesh = kInvalidMesh;
TerrainVertex* vertices = nullptr;
};
TerrainMeshWrite beginTerrainMesh(uint32_t vertexCount, uint32_t sharedIndices);
void endTerrainMesh(MeshHandle mesh);
// PHASE 32 : grille de la heightmap, lue par terrain.vert pour recalculer
// la position horizontale et l'UV des sommets de terrain (voir
// UniformBufferObject::terrainGrid). A appeler une fois, avant la premiere
// image, des qu'un terrain est charge.
void setTerrainGrid(float origin, float spacing, uint32_t cells);
// PHASE 32 : bilan du pool de geometrie, pour le journal.
std::string geometryLine() const;
// Libere une geometrie et rend sa poignee reutilisable. Indispensable depuis
// la Phase 10 : le streaming par tuiles cree et detruit des maillages en
// permanence, alors que jusque-la une geometrie enregistree vivait aussi
@@ -111,6 +168,12 @@ public:
// coloration procedurale est visible.
void setTerrainTexture(const TextureData& data);
// PHASE 32. Meme chose, mais les texels sont lus dans `path` DIRECTEMENT
// vers le staging de la texture : `header` vient de loadTextureFileHeader
// et ne porte aucun texel. Evite de tenir l'orthophoto (42 Mo) en RAM en
// plus du staging et de l'image GPU pendant le chargement.
void setTerrainTextureFromFile(const TextureData& header, const std::string& path);
// Bascule coloration procedurale <-> orthophoto (voir RenderOptions).
// Sans effet visible si aucune texture n'a ete chargee.
void setOrthoMix(float mix);
@@ -233,7 +296,7 @@ public:
// garanti par construction - le seul appelant est addMesh, et removeMesh
// DIFFERE la destruction des buffers de kMaxFramesInFlight + 1 frames.
void enqueueCopy(std::unique_ptr<VulkanBuffer> staging,
VkBuffer destination) override;
VkBuffer destination, VkDeviceSize destinationOffset) override;
// Octets de staging en attente d'enregistrement + en attente d'execution.
// Sert au journal de diagnostic du streaming.
@@ -266,6 +329,7 @@ private:
glm::vec4 precip_{0.0f, 0.0f, 0.0f, 0.0f};
glm::vec4 fall_{0.0f, -6.5f, 0.0f, 0.0f};
glm::vec4 detail_{0.0f, 0.0f, 1.0f, 1.0f};
glm::vec4 terrainGrid_{0.0f, 1.0f, 1.0f, 0.0f}; // PHASE 32, voir setTerrainGrid()
static constexpr int kMaxFramesInFlight = 2;
@@ -306,12 +370,51 @@ private:
void uploadInstances(const std::vector<InstancedDrawItem>& instanced);
void recreateSwapChain();
// PHASE 32. Ecriture dans une plage du pool : `destination` pointe soit
// dans la plage elle-meme (memoire unifiee), soit dans un staging, et
// finishRangeWrite confie alors la copie a la prochaine image.
struct RangeWrite {
GpuRange range;
void* destination = nullptr;
std::unique_ptr<VulkanBuffer> staging;
};
RangeWrite beginRangeWrite(const GpuRange& range);
void finishRangeWrite(RangeWrite& write);
// Inscrit un Mesh dans la table et rend sa poignee (emplacement libre
// reutilise s'il y en a un).
MeshHandle registerMesh(std::unique_ptr<Mesh> mesh);
// Reserve les deux plages d'un maillage a topologie propre et les confie
// AUSSITOT a un Mesh, qui les rendra au pool si la suite echoue.
std::unique_ptr<Mesh> allocateMesh(VertexLayout layout, VkDeviceSize vertexBytes,
uint32_t vertexCount, VkDeviceSize indexBytes,
VkIndexType indexType, uint32_t indexCount);
VulkanContext& context_;
Window& window_;
RenderOptions options_;
std::unique_ptr<SwapChain> swapChain_;
// PHASE 32 : TOUTE la geometrie (sommets et indices, objets et terrain)
// vit dans les blocs de ce pool. Declare AVANT les tables de maillages :
// les membres etant detruits dans l'ordre inverse, il survit a tous les
// Mesh, qui lui rendent leurs plages en se detruisant.
std::unique_ptr<GpuBufferPool> geometryPool_;
// Topologies partagees (addSharedIndices), rendues a la destruction.
struct SharedIndices {
GpuRange range;
uint32_t count = 0;
VkIndexType type = VK_INDEX_TYPE_UINT16;
};
std::vector<SharedIndices> sharedIndices_;
// Tuiles commencees (beginTerrainMesh) dont l'ecriture passe par un
// staging, en attente de leur endTerrainMesh.
std::unordered_map<MeshHandle, RangeWrite> pendingTerrainWrites_;
// Un pipeline par materiau, indexe par la valeur de l'enum Material. Tous
// partagent le meme descriptor set layout et le meme push constant range :
// seuls les shaders different.
@@ -348,6 +451,7 @@ private:
struct PendingCopy {
std::unique_ptr<VulkanBuffer> staging;
VkBuffer destination = VK_NULL_HANDLE;
VkDeviceSize destinationOffset = 0;
VkDeviceSize size = 0;
};
std::vector<PendingCopy> pendingCopies_;
+17 -16
Voir le fichier
@@ -26,8 +26,8 @@ const char* presentModeName(VkPresentModeKHR mode) {
} // namespace
SwapChain::SwapChain(VulkanContext& context, Window& window)
: context_(context), window_(window) {
SwapChain::SwapChain(VulkanContext& context, Window& window, bool vsync)
: context_(context), window_(window), vsync_(vsync) {
// Le format de profondeur est fixe une fois pour toutes (il ne depend pas de
// la taille) : le render pass, cree une seule fois, s'y refere.
depthFormat_ = context_.findDepthFormat();
@@ -66,10 +66,7 @@ void SwapChain::cleanupSizeDependent() {
vkDestroyImage(device, depthImage_, nullptr);
depthImage_ = VK_NULL_HANDLE;
}
if (depthImageMemory_ != VK_NULL_HANDLE) {
vkFreeMemory(device, depthImageMemory_, nullptr);
depthImageMemory_ = VK_NULL_HANDLE;
}
context_.freeMemory(depthAllocation_);
for (VkFramebuffer fb : framebuffers_) {
vkDestroyFramebuffer(device, fb, nullptr);
@@ -113,6 +110,16 @@ VkPresentModeKHR SwapChain::choosePresentMode(
// FIFO : seul mode dont Vulkan garantit la presence. Fallback ultime.
// A rebasculer sur MAILBOX/FIFO quand le jeu sera jouable : le tearing n'est
// acceptable que pour du profilage.
//
// PHASE 32 : c'est l'option --vsync. FIFO, le seul mode que Vulkan
// garantit : le CPU et le GPU attendent l'ecran au lieu de produire des
// images que personne ne verra. C'est le plus gros levier de CONSOMMATION
// du jeu (378 images/s mesurees sur l'UHD 770 = GPU a 100 % en permanence,
// pour un ecran a 60 Hz). Non active par defaut : toutes les mesures du
// projet comptent des images/s non plafonnees.
if (vsync_) {
return VK_PRESENT_MODE_FIFO_KHR;
}
for (VkPresentModeKHR wanted : { VK_PRESENT_MODE_IMMEDIATE_KHR,
VK_PRESENT_MODE_MAILBOX_KHR }) {
if (std::find(modes.begin(), modes.end(), wanted) != modes.end()) {
@@ -342,16 +349,10 @@ void SwapChain::createDepthResources() {
VkMemoryRequirements memRequirements{};
vkGetImageMemoryRequirements(device, depthImage_, &memRequirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = context_.findMemoryType(
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
if (vkAllocateMemory(device, &allocInfo, nullptr, &depthImageMemory_) != VK_SUCCESS) {
throw std::runtime_error("Echec de l'allocation memoire de profondeur.");
}
vkBindImageMemory(device, depthImage_, depthImageMemory_, 0);
// PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
depthAllocation_ = context_.allocateMemory(memRequirements,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkBindImageMemory(device, depthImage_, depthAllocation_.memory, 0);
VkImageViewCreateInfo viewInfo{};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+7 -2
Voir le fichier
@@ -1,5 +1,7 @@
#pragma once
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h>
#include <vector>
@@ -15,7 +17,9 @@ class Window;
// pas), ce qui evite d'invalider le pipeline graphique.
class SwapChain {
public:
SwapChain(VulkanContext& context, Window& window);
// `vsync` (PHASE 32) : presentation calee sur l'ecran (FIFO) au lieu du
// mode non plafonne des mesures. Voir choosePresentMode.
SwapChain(VulkanContext& context, Window& window, bool vsync = false);
~SwapChain();
SwapChain(const SwapChain&) = delete;
@@ -59,6 +63,7 @@ private:
// MAX_ENUM = "pas encore choisi", pour que le premier choix soit toujours logge.
VkPresentModeKHR presentMode_ = VK_PRESENT_MODE_MAX_ENUM_KHR;
bool vsync_ = false;
std::vector<VkImage> images_;
std::vector<VkImageView> imageViews_;
@@ -68,7 +73,7 @@ private:
// par le render pass). Recree en meme temps que la swapchain au resize.
VkFormat depthFormat_ = VK_FORMAT_UNDEFINED;
VkImage depthImage_ = VK_NULL_HANDLE;
VkDeviceMemory depthImageMemory_ = VK_NULL_HANDLE;
GpuAllocation depthAllocation_;
VkImageView depthImageView_ = VK_NULL_HANDLE;
VkRenderPass renderPass_ = VK_NULL_HANDLE;
+103 -45
Voir le fichier
@@ -9,6 +9,58 @@
namespace vercora {
namespace {
// Normale analytique de la surface y = h(x,z) au noeud (ix, iz) : le vecteur
// normal vaut (-dh/dx, 1, -dh/dz). Les derivees sont estimees par difference
// CENTREE sur les deux voisins (plus precis et plus symetrique qu'un produit
// vectoriel sur une seule face). Sur les bords, at() ecrete les indices : la
// difference devient unilaterale, d'ou le pas reel (xp - xm) au denominateur
// plutot qu'un 2 en dur - sinon les normales du bord seraient deux fois trop
// plates.
//
// PHASE 32 : sortie de la boucle de terrainMeshData pour etre partagee avec
// terrainGpuMeshData - les deux formats ont ainsi, par construction, les memes
// normales.
glm::vec3 gridNormal(const Heightmap& heightmap, uint32_t ix, uint32_t iz, uint32_t res,
float spacing) {
const int64_t xm = (ix > 0) ? ix - 1 : ix;
const int64_t xp = (ix + 1 < res) ? ix + 1 : ix;
const int64_t zm = (iz > 0) ? iz - 1 : iz;
const int64_t zp = (iz + 1 < res) ? iz + 1 : iz;
const float dhdx = (heightmap.at(xp, iz) - heightmap.at(xm, iz)) /
(static_cast<float>(xp - xm) * spacing);
const float dhdz = (heightmap.at(ix, zp) - heightmap.at(ix, zm)) /
(static_cast<float>(zp - zm) * spacing);
return glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
}
// Deux triangles par cellule, coupes le long de la diagonale v00-v11 (voir le
// commentaire de l'etape 2 de terrainMeshData).
void appendGridIndices(uint32_t res, std::vector<uint32_t>& indices) {
const uint32_t cells = res - 1;
for (uint32_t iz = 0; iz < cells; ++iz) {
for (uint32_t ix = 0; ix < cells; ++ix) {
const uint32_t v00 = iz * res + ix;
const uint32_t v10 = v00 + 1;
const uint32_t v01 = v00 + res;
const uint32_t v11 = v01 + 1;
indices.push_back(v00);
indices.push_back(v01);
indices.push_back(v11);
indices.push_back(v00);
indices.push_back(v11);
indices.push_back(v10);
}
}
}
} // namespace
MeshData terrainMeshData(const Heightmap& heightmap) {
const uint32_t res = heightmap.resolution();
if (res < 2) {
@@ -53,25 +105,8 @@ MeshData terrainMeshData(const Heightmap& heightmap) {
// LiDAR : sol / vegetation / bati) sans toucher au shader.
vertex.color = { 1.0f, 1.0f, 1.0f };
// Normale analytique de la surface y = h(x,z) : le vecteur normal
// vaut (-dh/dx, 1, -dh/dz). Les derivees sont estimees par
// difference CENTREE sur les deux voisins (plus precis et plus
// symetrique qu'un produit vectoriel sur une seule face).
// Sur les bords, at() ecrete les indices : la difference devient
// unilaterale, d'ou le pas reel (xp - xm) au denominateur plutot
// qu'un 2 en dur - sinon les normales du bord seraient deux fois
// trop plates.
const int64_t xm = (ix > 0) ? ix - 1 : ix;
const int64_t xp = (ix + 1 < res) ? ix + 1 : ix;
const int64_t zm = (iz > 0) ? iz - 1 : iz;
const int64_t zp = (iz + 1 < res) ? iz + 1 : iz;
const float dhdx = (heightmap.at(xp, iz) - heightmap.at(xm, iz)) /
(static_cast<float>(xp - xm) * spacing);
const float dhdz = (heightmap.at(ix, zp) - heightmap.at(ix, zm)) /
(static_cast<float>(zp - zm) * spacing);
vertex.normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
// Normale par differences centrees, voir gridNormal.
vertex.normal = gridNormal(heightmap, ix, iz, res, spacing);
// UV sur tout le terrain. Pas encore consomme (pas de texturing),
// mais c'est le repere naturel pour y plaquer une orthophoto le jour
@@ -90,33 +125,11 @@ MeshData terrainMeshData(const Heightmap& heightmap) {
// ici oblige a la changer la-bas aussi.
//
// Enroulement anti-horaire vu de dessus (+Y), coherent avec la convention
// des .obj de la Phase 3. Le culling est desactive dans Pipeline, donc c'est
// sans effet visible aujourd'hui, mais ca rend le back-face culling
// activable sans retoucher la geometrie.
for (uint32_t iz = 0; iz < cells; ++iz) {
for (uint32_t ix = 0; ix < cells; ++ix) {
const uint32_t v00 = iz * res + ix;
const uint32_t v10 = v00 + 1;
const uint32_t v01 = v00 + res;
const uint32_t v11 = v01 + 1;
// des .obj de la Phase 3. C'est ce qui a rendu le back-face culling du
// terrain activable sans retoucher la geometrie (PHASE 32, voir
// ShaderSet::cullBackFaces).
appendGridIndices(res, mesh.indices);
mesh.indices.push_back(v00);
mesh.indices.push_back(v01);
mesh.indices.push_back(v11);
mesh.indices.push_back(v00);
mesh.indices.push_back(v11);
mesh.indices.push_back(v10);
}
}
// --- 3. Controle de coherence ------------------------------------------
// Meme esprit que les gardes-fous du loader .obj (Phase 3) : on refuse de
// pousser vers le GPU une geometrie qu'on sait cassee, plutot que d'afficher
// une fenetre vide sans explication. Ici le generateur est deterministe,
// donc ces tests attrapent une erreur de code (indexation, resolution), pas
// une donnee douteuse - ils resteront pertinents quand la grille viendra du
// LiDAR.
if (mesh.indices.size() % 3 != 0) {
throw std::runtime_error("TerrainMesh : nombre d'index non multiple de 3.");
}
@@ -145,4 +158,49 @@ MeshData terrainMeshData(const Heightmap& heightmap) {
return mesh;
}
TerrainGpuMesh terrainGpuMeshData(const Heightmap& heightmap) {
const uint32_t res = heightmap.resolution();
if (res < 2) {
throw std::runtime_error(
"TerrainMesh : une grille de " + std::to_string(res) +
" echantillons par cote ne forme aucune cellule.");
}
const uint32_t cells = res - 1;
const float spacing = heightmap.spacing();
TerrainGpuMesh mesh;
mesh.name = heightmap.describe();
mesh.vertices.resize(static_cast<std::size_t>(res) * res);
mesh.indices.reserve(static_cast<std::size_t>(cells) * cells * 6);
for (uint32_t iz = 0; iz < res; ++iz) {
for (uint32_t ix = 0; ix < res; ++ix) {
const float height = heightmap.at(ix, iz);
const glm::vec3 normal = gridNormal(heightmap, ix, iz, res, spacing);
if (!std::isfinite(height) || !std::isfinite(normal.y)) {
throw std::runtime_error(
"TerrainMesh : coordonnee ou normale non finie (NaN/infini) "
"produite par la heightmap.");
}
// Pas de geomorphing pour un bloc unique (bande de morphing vide) :
// la cible est le sommet lui-meme, comme le laissait a zero le
// format de 68 octets - sans effet puisque jamais lue.
TerrainVertex& vertex = mesh.vertices[static_cast<std::size_t>(iz) * res + ix];
vertex.height = height;
vertex.morphHeight = height;
vertex.normal[0] = packSnorm16(normal.x);
vertex.normal[1] = packSnorm16(normal.z);
vertex.morphNormal[0] = vertex.normal[0];
vertex.morphNormal[1] = vertex.normal[1];
}
}
appendGridIndices(res, mesh.indices);
logInfo("Maillage terrain (format GPU compact) : " + std::to_string(mesh.vertices.size()) +
" sommets, " + std::to_string(mesh.indices.size() / 3) + " triangles, " +
std::to_string(mesh.vertices.size() * sizeof(TerrainVertex) / (1024 * 1024)) +
" Mo de sommets.");
return mesh;
}
} // namespace vercora
+18
Voir le fichier
@@ -1,7 +1,12 @@
#pragma once
#include "renderer/GpuVertex.hpp"
#include "renderer/MeshData.hpp"
#include <cstdint>
#include <string>
#include <vector>
namespace vercora {
class Heightmap;
@@ -20,4 +25,17 @@ class Heightmap;
// Lance std::runtime_error si la grille ne peut pas produire un maillage sain.
MeshData terrainMeshData(const Heightmap& heightmap);
// PHASE 32. Le meme terrain d'un seul bloc, au format GPU du terrain
// (TerrainVertex, 16 octets) : c'est ce que televerse le chemin --no-lod, sans
// construire au passage le MeshData de 68 octets par sommet (1,7 Go sur la zone
// au pas de 1 m). vertices[v] == toTerrainVertex(terrainMeshData(h).vertices[v])
// au bit pres et les indices sont identiques (verifie par les tests). Les
// sommets n'ont pas de cible de geomorphing : elle vaut le sommet lui-meme.
struct TerrainGpuMesh {
std::vector<TerrainVertex> vertices;
std::vector<uint32_t> indices;
std::string name;
};
TerrainGpuMesh terrainGpuMeshData(const Heightmap& heightmap);
} // namespace vercora
+198 -30
Voir le fichier
@@ -89,9 +89,16 @@ std::vector<uint32_t> terrainNodeIndices(uint32_t nodeCells) {
return indices;
}
MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
uint32_t nodeIndex, bool withIndices,
bool reuseParentGrid) {
namespace {
// PHASE 32 : le parcours d'un noeud, commun aux deux formats de sortie
// (MeshData de reference et TerrainVertex du GPU). `sink(v, gx, gz, here,
// parent)` recoit chaque sommet - son indice dans la tuile, ses indices de
// grille ecretes, son echantillon et celui de sa cible de geomorphing. Un seul
// parcours, donc deux sorties qui ne PEUVENT PAS diverger.
template <typename Sink>
void forEachNodeVertex(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
uint32_t nodeIndex, bool reuseParentGrid, Sink&& sink) {
if (nodeIndex >= quadtree.nodeCount()) {
throw std::runtime_error("TerrainNodeMesh : indice de noeud hors limites.");
}
@@ -133,11 +140,6 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree&
}
}
MeshData mesh;
mesh.name = "tuile L" + std::to_string(static_cast<int>(node.level)) + " (" +
std::to_string(node.ix0) + "," + std::to_string(node.iz0) + ")";
mesh.vertices.resize(static_cast<std::size_t>(verts) * verts);
for (uint32_t j = 0; j < verts; ++j) {
for (uint32_t i = 0; i < verts; ++i) {
// Indices de grille du sommet, ECRETES sur le bord du terrain.
@@ -157,43 +159,209 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree&
? parentGrid[static_cast<std::size_t>(j / 2u) * parentVerts + (i / 2u)]
: parentSample;
Vertex& vertex = mesh.vertices[static_cast<std::size_t>(j) * verts + i];
vertex.pos = here.position;
vertex.normal = here.normal;
vertex.morphPos = parent.position;
vertex.morphNormal = parent.normal;
// Teinte neutre : le fragment shader colore par altitude et par
// pente. Reserve a une future classification LiDAR par sommet.
vertex.color = { 1.0f, 1.0f, 1.0f };
// UV sur TOUT le terrain (et non sur la tuile) : c'est le repere
// naturel d'une future orthophoto, et il doit rester continu d'une
// tuile a l'autre.
vertex.uv = { static_cast<float>(gx) / static_cast<float>(cells),
static_cast<float>(gz) / static_cast<float>(cells) };
sink(static_cast<std::size_t>(j) * verts + i, gx, gz, here, parent);
}
}
}
// Controle de coherence, meme esprit que TerrainMesh : on refuse de pousser
// vers le GPU une geometrie qu'on sait cassee. Le generateur etant
// deterministe, ce test attrape une erreur de CODE (indexation, pas de
// parcours), pas une donnee douteuse.
[[noreturn]] void throwNonFinite() {
throw std::runtime_error(
"TerrainNodeMesh : coordonnee ou normale non finie (NaN/infini) "
"produite par la heightmap.");
}
} // namespace
MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
uint32_t nodeIndex, bool withIndices,
bool reuseParentGrid) {
if (nodeIndex >= quadtree.nodeCount()) {
throw std::runtime_error("TerrainNodeMesh : indice de noeud hors limites.");
}
const TerrainQuadtree::Node& node = quadtree.node(nodeIndex);
const uint32_t nodeCells = quadtree.nodeCells();
const uint32_t verts = nodeCells + 1;
const uint32_t cells = heightmap.resolution() - 1;
MeshData mesh;
mesh.name = "tuile L" + std::to_string(static_cast<int>(node.level)) + " (" +
std::to_string(node.ix0) + "," + std::to_string(node.iz0) + ")";
mesh.vertices.resize(static_cast<std::size_t>(verts) * verts);
forEachNodeVertex(heightmap, quadtree, nodeIndex, reuseParentGrid,
[&](std::size_t v, uint32_t gx, uint32_t gz,
const GridSample& here, const GridSample& parent) {
Vertex& vertex = mesh.vertices[v];
vertex.pos = here.position;
vertex.normal = here.normal;
vertex.morphPos = parent.position;
vertex.morphNormal = parent.normal;
// Teinte neutre : le fragment shader colore par altitude et par
// pente. Reserve a une future classification LiDAR par sommet.
vertex.color = { 1.0f, 1.0f, 1.0f };
// UV sur TOUT le terrain (et non sur la tuile) : c'est le repere
// naturel d'une future orthophoto, et il doit rester continu d'une
// tuile a l'autre.
vertex.uv = { static_cast<float>(gx) / static_cast<float>(cells),
static_cast<float>(gz) / static_cast<float>(cells) };
});
if (withIndices) {
mesh.indices = terrainNodeIndices(nodeCells);
}
// Controle de coherence, meme esprit que TerrainMesh : on refuse de pousser
// vers le GPU une geometrie qu'on sait cassee. Le generateur etant
// deterministe, ce test attrape une erreur de CODE (indexation, pas de
// parcours), pas une donnee douteuse.
for (const Vertex& vertex : mesh.vertices) {
if (!std::isfinite(vertex.pos.x) || !std::isfinite(vertex.pos.y) ||
!std::isfinite(vertex.pos.z) || !std::isfinite(vertex.normal.y) ||
!std::isfinite(vertex.morphPos.y)) {
throw std::runtime_error(
"TerrainNodeMesh : coordonnee ou normale non finie (NaN/infini) "
"produite par la heightmap.");
throwNonFinite();
}
}
return mesh;
}
bool terrainNodeUsesFastPath(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
uint32_t nodeIndex) {
if (nodeIndex >= quadtree.nodeCount()) {
return false;
}
const TerrainQuadtree::Node& node = quadtree.node(nodeIndex);
const uint64_t cells = heightmap.resolution() - 1;
const uint64_t stride = node.stride;
// Deux pas de marge de chaque cote : les voisins d'un sommet sont a un pas,
// ceux d'un echantillon du parent a deux pas (le pas du parent).
const uint64_t reach = static_cast<uint64_t>(quadtree.nodeCells() + 2) * stride;
return node.ix0 >= 2 * stride && node.iz0 >= 2 * stride &&
node.ix0 + reach <= cells && node.iz0 + reach <= cells;
}
void writeTerrainNodeVertices(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
uint32_t nodeIndex, TerrainVertex* out,
bool reuseParentGrid) {
// --- PHASE 32 : chemin RAPIDE des tuiles interieures --------------------
// Le parcours de reference lit chaque altitude ~6 fois, toujours par at()
// et son ecretage : cinq lectures par echantillon (le point et ses quatre
// voisins) pour les 4 225 sommets ET les 1 089 echantillons du parent. Or
// les voisins d'un sommet, au pas du noeud, sont exactement les sommets
// voisins de la tuile, et ceux du parent, au pas double, les sommets a
// deux rangs. Loin du bord, ou aucun indice n'est ecrete, une grille de
// (n + 5)^2 altitudes lues UNE fois contient donc tout.
//
// Les MEMES operations flottantes sur les MEMES valeurs que sampleGrid -
// memes differences, memes divisions (le pas reel, 2 ou 4 fois le pas du
// noeud, comme (xp - xm) la-bas), meme glm::normalize : le resultat est
// identique au bit pres, et tests/logic_tests.cpp le verifie sur toutes les
// tuiles de plusieurs grilles. Pres du bord, ou l'ecretage change les
// voisins, le chemin de reference ci-dessous reste seul juge. Le temoin
// --no-tile-cache (reuseParentGrid = false) le garde aussi : il mesure le
// travail d'avant la Phase 18.
if (reuseParentGrid && terrainNodeUsesFastPath(heightmap, quadtree, nodeIndex)) {
const TerrainQuadtree::Node& node = quadtree.node(nodeIndex);
const uint32_t verts = quadtree.nodeCells() + 1;
const uint32_t stride = node.stride;
const uint32_t res = heightmap.resolution();
const float spacing = heightmap.spacing();
const float* heights = heightmap.rawHeights();
// Grille bordee de deux rangs : l'indice local k correspond a
// l'echantillon ix0 + (k - 2) * stride. thread_local : le chemin
// parallele (Phase 19) l'appelle depuis plusieurs threads a la fois.
const uint32_t span = verts + 4;
thread_local std::vector<float> grid;
grid.resize(static_cast<std::size_t>(span) * span);
for (uint32_t jj = 0; jj < span; ++jj) {
const float* row = heights + static_cast<std::size_t>(node.iz0 - 2u * stride +
jj * stride) * res;
const float* sample = row + (node.ix0 - 2u * stride);
float* destination = grid.data() + static_cast<std::size_t>(jj) * span;
for (uint32_t ii = 0; ii < span; ++ii) {
destination[ii] = sample[static_cast<std::size_t>(ii) * stride];
}
}
const auto at = [&](uint32_t ii, uint32_t jj) {
return grid[static_cast<std::size_t>(jj) * span + ii];
};
// Les pas reels des differences centrees : (xp - xm) * spacing dans
// sampleGrid, soit 2 pas du noeud pour un sommet, 4 pour le parent.
const float step = static_cast<float>(2u * stride) * spacing;
const float parentStep = static_cast<float>(4u * stride) * spacing;
// Grille du parent, deja quantifiee : une fois par bloc 2 x 2.
struct ParentSample {
float height;
int16_t normal[2];
};
const uint32_t parentVerts = (verts + 1u) / 2u;
thread_local std::vector<ParentSample> parents;
parents.resize(static_cast<std::size_t>(parentVerts) * parentVerts);
bool finite = true;
for (uint32_t pj = 0; pj < parentVerts; ++pj) {
for (uint32_t pi = 0; pi < parentVerts; ++pi) {
const uint32_t ii = 2u * pi + 2u;
const uint32_t jj = 2u * pj + 2u;
const float dhdx = (at(ii + 2u, jj) - at(ii - 2u, jj)) / parentStep;
const float dhdz = (at(ii, jj + 2u) - at(ii, jj - 2u)) / parentStep;
const glm::vec3 normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
ParentSample& parent = parents[static_cast<std::size_t>(pj) * parentVerts + pi];
parent.height = at(ii, jj);
parent.normal[0] = packSnorm16(normal.x);
parent.normal[1] = packSnorm16(normal.z);
finite = finite && std::isfinite(parent.height) && std::isfinite(normal.y);
}
}
for (uint32_t j = 0; j < verts; ++j) {
for (uint32_t i = 0; i < verts; ++i) {
const uint32_t ii = i + 2u;
const uint32_t jj = j + 2u;
const float dhdx = (at(ii + 1u, jj) - at(ii - 1u, jj)) / step;
const float dhdz = (at(ii, jj + 1u) - at(ii, jj - 1u)) / step;
const glm::vec3 normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
const ParentSample& parent =
parents[static_cast<std::size_t>(j / 2u) * parentVerts + (i / 2u)];
TerrainVertex& packed = out[static_cast<std::size_t>(j) * verts + i];
packed.height = at(ii, jj);
packed.morphHeight = parent.height;
packed.normal[0] = packSnorm16(normal.x);
packed.normal[1] = packSnorm16(normal.z);
packed.morphNormal[0] = parent.normal[0];
packed.morphNormal[1] = parent.normal[1];
finite = finite && std::isfinite(packed.height) && std::isfinite(normal.y);
}
}
if (!finite) {
throwNonFinite();
}
return;
}
bool finite = true;
forEachNodeVertex(heightmap, quadtree, nodeIndex, reuseParentGrid,
[&](std::size_t v, uint32_t /*gx*/, uint32_t /*gz*/,
const GridSample& here, const GridSample& parent) {
// Les memes octets que toTerrainVertex(Vertex) appliquee au sommet de
// terrainNodeMeshData : altitudes recopiees, normales quantifiees.
TerrainVertex packed;
packed.height = here.position.y;
packed.morphHeight = parent.position.y;
packed.normal[0] = packSnorm16(here.normal.x);
packed.normal[1] = packSnorm16(here.normal.z);
packed.morphNormal[0] = packSnorm16(parent.normal.x);
packed.morphNormal[1] = packSnorm16(parent.normal.z);
out[v] = packed;
finite = finite && std::isfinite(here.position.y) && std::isfinite(here.normal.y) &&
std::isfinite(parent.position.y);
});
if (!finite) {
throwNonFinite();
}
}
} // namespace vercora
+28
Voir le fichier
@@ -1,5 +1,6 @@
#pragma once
#include "renderer/GpuVertex.hpp"
#include "renderer/MeshData.hpp"
#include <cstdint>
@@ -63,4 +64,31 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree&
// diagonale que TerrainMesh. Calculee une fois par appelant et reutilisee.
std::vector<uint32_t> terrainNodeIndices(uint32_t nodeCells);
// PHASE 32. Les MEMES sommets que terrainNodeMeshData, ecrits directement au
// format GPU du terrain (TerrainVertex, 16 octets) dans `out`, qui doit pouvoir
// en recevoir (nodeCells + 1)^2. C'est le chemin du TerrainStreamer : `out`
// pointe dans la memoire que le GPU lira (ou dans un staging), et aucun
// MeshData de 287 Ko n'est plus construit puis recopie par tuile.
//
// Garantie, verifiee par tests/logic_tests.cpp : pour tout noeud,
// out[v] == toTerrainVertex(terrainNodeMeshData(...).vertices[v]) AU BIT PRES -
// memes altitudes, memes normales avant quantification. C'est
// terrainNodeMeshData qui reste la reference testee de la geometrie (positions,
// morphing, bords) ; cette fonction n'en est qu'un autre format de sortie.
//
// Pure et sans etat partage, comme terrainNodeMeshData : appelable depuis
// plusieurs threads sur des noeuds et des sorties distincts (Phase 19).
// Lance std::runtime_error pour les memes raisons.
void writeTerrainNodeVertices(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
uint32_t nodeIndex, TerrainVertex* out,
bool reuseParentGrid = true);
// PHASE 32. true si writeTerrainNodeVertices prend le chemin RAPIDE pour ce
// noeud : une tuile assez loin du bord du terrain pour qu'aucun des
// echantillons qu'elle lit (ses sommets, leurs voisins au pas du noeud, et
// ceux de la grille du parent au pas double) ne soit ecrete. Expose pour que
// les tests verifient qu'ils couvrent bien les deux chemins.
bool terrainNodeUsesFastPath(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
uint32_t nodeIndex);
} // namespace vercora
+125 -101
Voir le fichier
@@ -20,15 +20,19 @@ TerrainStreamer::TerrainStreamer(const Heightmap& heightmap, Renderer& renderer,
quadtree_(heightmap, params.quadtree) {
logInfo(quadtree_.describe());
const std::size_t bytesPerNode = static_cast<std::size_t>(quadtree_.nodeCells() + 1) *
(quadtree_.nodeCells() + 1) * sizeof(Vertex) +
static_cast<std::size_t>(quadtree_.trianglesPerNode()) *
3 * sizeof(uint32_t);
// PHASE 32 : une tuile ne pese plus que ses sommets, au format compact
// (16 octets au lieu de 68) ; sa topologie est televersee UNE fois pour
// toutes, ici, en uint16.
bytesPerNode_ = static_cast<std::size_t>(quadtree_.nodeCells() + 1) *
(quadtree_.nodeCells() + 1) * sizeof(TerrainVertex);
sharedIndexSet_ = renderer_.addSharedIndices(sharedIndices());
logInfo("Streaming terrain : au plus " + std::to_string(params_.maxResidentNodes) +
" tuiles residentes (" +
std::to_string(params_.maxResidentNodes * bytesPerNode / (1024 * 1024)) +
" Mo de geometrie GPU), " + std::to_string(params_.maxUploadsPerFrame) +
" construites par frame.");
std::to_string(params_.maxResidentNodes * bytesPerNode_ / (1024 * 1024)) +
" Mo de geometrie GPU, " + std::to_string(bytesPerNode_ / 1024) +
" Ko par tuile, topologie partagee de " +
std::to_string(sharedIndices().size() * sizeof(uint16_t) / 1024) + " Ko), " +
std::to_string(params_.maxUploadsPerFrame) + " construites par frame.");
pinTopLevels();
}
@@ -46,11 +50,6 @@ void TerrainStreamer::pinTopLevels() {
const int lowest = std::max(0, static_cast<int>(quadtree_.rootLevel()) -
static_cast<int>(params_.pinnedTopLevels) + 1);
const std::size_t bytesPerNode =
static_cast<std::size_t>(quadtree_.nodeCells() + 1) *
(quadtree_.nodeCells() + 1) * sizeof(Vertex) +
static_cast<std::size_t>(quadtree_.trianglesPerNode()) * 3 * sizeof(uint32_t);
for (uint32_t index = 0; index < quadtree_.nodeCount(); ++index) {
if (static_cast<int>(quadtree_.node(index).level) < lowest) {
continue;
@@ -61,19 +60,19 @@ void TerrainStreamer::pinTopLevels() {
}
ResidentNode node;
node.mesh = mesh;
node.bytes = bytesPerNode;
node.bytes = bytesPerNode_;
node.pinned = true;
// Jamais rajeunie ensuite : elle n'est de toute facon pas evincable.
node.lastUsedFrame = 0;
resident_.emplace(index, node);
residentBytes_ += bytesPerNode;
residentBytes_ += bytesPerNode_;
++pinnedCount_;
}
logInfo("Sommet du quadtree epingle : " + std::to_string(pinnedCount_) +
" tuiles de niveau " + std::to_string(lowest) + " a " +
std::to_string(static_cast<int>(quadtree_.rootLevel())) + " (" +
std::to_string(pinnedCount_ * bytesPerNode / (1024 * 1024)) +
std::to_string(pinnedCount_ * bytesPerNode_ / (1024 * 1024)) +
" Mo), jamais evincees. C'est ce qui rend le repli sur l'ancetre "
"toujours disponible.");
}
@@ -107,11 +106,11 @@ const std::vector<uint32_t>& TerrainStreamer::sharedIndices() const {
// n'aurait parie sur la boucle d'indices.
//
// Construite a la premiere tuile puis simplement RECOPIEE dans le MeshData.
// Ne pas la recopier du tout - partager un unique buffer d'indices GPU entre
// toutes les tuiles - economiserait en plus 96 Ko par tuile residente, mais
// demanderait de dissocier sommets et indices dans Renderer::addMesh : c'est
// un chantier de renderer, pas de streaming (voir NOTES-PHASE18.md).
if (indexTemplate_.empty() || !params_.cacheTileWork) {
// PHASE 32 : elle n'est meme plus recopiee. Le chantier de renderer que
// cette note annoncait (NOTES-PHASE18.md) est fait : un UNIQUE buffer
// d'indices GPU, en uint16, sert toutes les tuiles - 96 Ko economises par
// tuile residente, et une seule liaison d'indices par image.
if (indexTemplate_.empty()) {
indexTemplate_ = terrainNodeIndices(quadtree_.nodeCells());
}
return indexTemplate_;
@@ -148,19 +147,40 @@ bool TerrainStreamer::wantsParallel(std::size_t count) const {
}
void TerrainStreamer::meshBatch(const std::vector<uint32_t>& nodes) {
batchMeshes_.clear();
batchErrors_.clear();
batchMeshes_.resize(nodes.size());
batchErrors_.resize(nodes.size());
batchMeshes_.assign(nodes.size(), kInvalidMesh);
batchWrites_.assign(nodes.size(), Renderer::TerrainMeshWrite{});
if (nodes.empty()) {
return;
}
// Le corps d'un travailleur. Il ne touche QUE batchMeshes_[k] et
// batchErrors_[k] pour k dans [begin, end) - des elements deja alloues, donc
// ni le vecteur ni sa capacite ne bougent pendant l'execution. Tout le reste
// de ce qu'il lit (heightmap_, quadtree_, params_) est const pour la duree
// de la session.
// --- 1. Reservation, thread de rendu -----------------------------------
// Faire de la place AVANT de reserver, sinon le pic de residence depasserait
// le plafond le temps du lot. Les tuiles deja reservees de ce lot comptent
// comme residentes : elles le seront a la fin de la frame.
const auto t0 = Clock::now();
for (std::size_t k = 0; k < nodes.size(); ++k) {
while (resident_.size() + k >= params_.maxResidentNodes) {
if (!evictOne()) {
break; // tout est utilise cette frame : on laisse deborder
}
}
try {
batchWrites_[k] = renderer_.beginTerrainMesh(
(quadtree_.nodeCells() + 1) * (quadtree_.nodeCells() + 1), sharedIndexSet_);
} catch (const std::exception& e) {
batchErrors_[k] = e.what();
}
}
uploadMicros_ += microsBetween(t0, Clock::now());
// --- 2. Ecriture des sommets, eventuellement en parallele ----------------
// Le corps d'un travailleur. Il ne touche QUE la zone reservee
// batchWrites_[k].vertices et batchErrors_[k] pour k dans [begin, end) -
// deja allouees, donc ni les vecteurs ni leur capacite ne bougent pendant
// l'execution. Tout le reste de ce qu'il lit (heightmap_, quadtree_,
// params_) est const pour la duree de la session.
//
// Le chronometrage par tuile est fait ICI, mais il n'est PAS accumule dans
// geometryMicros_ depuis un thread : chaque tuile depose sa duree dans son
@@ -173,21 +193,22 @@ void TerrainStreamer::meshBatch(const std::vector<uint32_t>& nodes) {
const auto worker = [&](std::size_t begin, std::size_t end) {
for (std::size_t k = begin; k < end; ++k) {
const auto t0 = Clock::now();
if (batchWrites_[k].vertices == nullptr) {
continue; // reservation echouee, message deja depose
}
const auto t1 = Clock::now();
try {
batchMeshes_[k] = terrainNodeMeshData(heightmap_, quadtree_, nodes[k],
false, params_.cacheTileWork);
writeTerrainNodeVertices(heightmap_, quadtree_, nodes[k],
batchWrites_[k].vertices, params_.cacheTileWork);
} catch (const std::exception& e) {
// Une exception ne doit JAMAIS traverser la frontiere d'un
// std::thread : elle appellerait std::terminate. Elle est donc
// capturee ici et rendue a l'appelant comme une donnee.
batchErrors_[k] = e.what();
batchMeshes_[k] = MeshData{};
} catch (...) {
batchErrors_[k] = "exception inconnue";
batchMeshes_[k] = MeshData{};
}
perTileMicros[k] = microsBetween(t0, Clock::now());
perTileMicros[k] = microsBetween(t1, Clock::now());
}
};
@@ -226,60 +247,68 @@ void TerrainStreamer::meshBatch(const std::vector<uint32_t>& nodes) {
for (uint64_t micros : perTileMicros) {
geometryMicros_ += micros;
}
// --- 3. Livraison, thread de rendu ---------------------------------------
const auto t2 = Clock::now();
for (std::size_t k = 0; k < nodes.size(); ++k) {
const MeshHandle mesh = batchWrites_[k].mesh;
if (!batchErrors_[k].empty()) {
if (mesh != kInvalidMesh) {
renderer_.removeMesh(mesh);
}
continue;
}
renderer_.endTerrainMesh(mesh);
batchMeshes_[k] = mesh;
++builtNodes_;
}
uploadMicros_ += microsBetween(t2, Clock::now());
}
MeshHandle TerrainStreamer::uploadNode(uint32_t nodeIndex, MeshData& data) {
MeshHandle TerrainStreamer::buildNode(uint32_t nodeIndex) {
// Chemin SEQUENTIEL : reserve, ecrit, livre une tuile. C'est le chemin du
// sommet epingle (construit avant la premiere frame) et, depuis que le
// defaut est meshThreads = 1, celui de la construction courante.
//
// PHASE 32 : plus aucun MeshData ici. Les sommets sont ecrits au format
// compact directement dans la zone reservee - la memoire que le GPU lira
// en memoire unifiee, un staging sinon. Le poste "televersement" ne compte
// plus que la reservation et la livraison.
const auto t0 = Clock::now();
Renderer::TerrainMeshWrite write;
try {
const auto t1 = Clock::now();
// Les indices sont poses ICI et non dans terrainNodeMeshData, pour que
// les deux postes soient chronometres separement (voir buildProfile).
data.indices = sharedIndices();
const auto t2 = Clock::now();
// log = false : plusieurs tuiles par frame, une ligne chacune rendrait la
// sortie inexploitable (et couterait plus que l'upload).
const MeshHandle mesh = renderer_.addMesh(data, false);
const auto t3 = Clock::now();
++builtNodes_;
indicesMicros_ += microsBetween(t1, t2);
uploadMicros_ += microsBetween(t2, t3);
return mesh;
write = renderer_.beginTerrainMesh(
(quadtree_.nodeCells() + 1) * (quadtree_.nodeCells() + 1), sharedIndexSet_);
} catch (const std::exception& e) {
// Une tuile qu'on ne sait pas construire ne doit pas arreter le jeu :
// elle sera simplement absente, et le message dit laquelle. Le cas
// realiste est un manque de memoire GPU, pas une donnee invalide.
uploadMicros_ += microsBetween(t0, Clock::now());
// Le cas realiste est un manque de memoire GPU, pas une donnee
// invalide : la tuile sera simplement absente, et le message dit
// laquelle.
logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) +
" non televersee (" + e.what() + ").");
return kInvalidMesh;
}
}
MeshHandle TerrainStreamer::buildNode(uint32_t nodeIndex) {
// Chemin SEQUENTIEL : maille une tuile puis la televerse, sans jamais garder
// plus d'un MeshData en vie. C'est le chemin du sommet epingle (construit
// avant la premiere frame) et, depuis que le defaut est meshThreads = 1,
// celui de la construction courante.
//
// Ne pas passer par meshBatch ici n'est pas une duplication gratuite :
// meshBatch dimensionne un vecteur de MeshData pour TOUT le lot, ce qui fait
// vivre jusqu'a 53 tuiles simultanement (~15 Mo) la ou ce chemin-ci n'en
// tient qu'une. Mesure : le pic memoire du processus montait de 5,6 Mo quand
// tout passait par le lot. Le chemin par defaut retrouve ainsi exactement le
// profil memoire d'avant la Phase 19.
const auto t0 = Clock::now();
const auto t1 = Clock::now();
try {
scratchMesh_ = terrainNodeMeshData(heightmap_, quadtree_, nodeIndex, false,
params_.cacheTileWork);
writeTerrainNodeVertices(heightmap_, quadtree_, nodeIndex, write.vertices,
params_.cacheTileWork);
} catch (const std::exception& e) {
geometryMicros_ += microsBetween(t0, Clock::now());
geometryMicros_ += microsBetween(t1, Clock::now());
renderer_.removeMesh(write.mesh);
logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) +
" non maillee (" + e.what() + ").");
return kInvalidMesh;
}
const uint64_t micros = microsBetween(t0, Clock::now());
const auto t2 = Clock::now();
renderer_.endTerrainMesh(write.mesh);
const auto t3 = Clock::now();
const uint64_t micros = microsBetween(t1, t2);
geometryMicros_ += micros;
meshWallMicros_ += micros;
return uploadNode(nodeIndex, scratchMesh_);
uploadMicros_ += microsBetween(t0, t1) + microsBetween(t2, t3);
++builtNodes_;
return write.mesh;
}
bool TerrainStreamer::evictOne() {
@@ -354,11 +383,6 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
fallbackCount_ = 0;
uncoveredCount_ = 0;
const std::size_t bytesPerNode =
static_cast<std::size_t>(quadtree_.nodeCells() + 1) *
(quadtree_.nodeCells() + 1) * sizeof(Vertex) +
static_cast<std::size_t>(quadtree_.trianglesPerNode()) * 3 * sizeof(uint32_t);
const bool priming = (frameCounter_ <= params_.primingFrames);
uint32_t uploadsLeft = priming ? std::numeric_limits<uint32_t>::max()
: params_.maxUploadsPerFrame;
@@ -402,14 +426,13 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
// --- 1b/1c. Maillage puis televersement ---------------------------------
// Deux chemins, et le choix se fait sur la TAILLE DU LOT :
//
// - lot parallelisable : tout le lot est maille d'abord (meshBatch, aucun
// appel Vulkan, plusieurs threads), puis televerse en sequence ;
// - sinon : chaque tuile est maillee et televersee a la suite, sans jamais
// garder plus d'un MeshData en vie. C'est le chemin par DEFAUT, et il
// est identique a celui d'avant la Phase 19, cout memoire compris.
// - lot parallelisable : tout le lot est reserve, puis ecrit (meshBatch,
// aucun appel Vulkan pendant l'ecriture, plusieurs threads), puis livre ;
// - sinon : chaque tuile est reservee, ecrite et livree a la suite. C'est
// le chemin par DEFAUT.
//
// Dans les deux cas les addMesh ont lieu sur le thread de rendu, en
// sequence, et dans l'ordre de selection - donc du plus proche au plus
// Dans les deux cas les appels au Renderer ont lieu sur le thread de rendu,
// en sequence, et dans l'ordre de selection - donc du plus proche au plus
// lointain.
// Suivi du plus gros lot : il doit compter les DEUX chemins, sinon le bilan
@@ -429,17 +452,19 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
" non maillee (" + batchErrors_[k] + ").");
continue;
}
// Faire de la place AVANT de televerser, sinon le pic de residence
// depasserait le plafond le temps d'un upload. (Le maillage, lui,
// n'alloue rien sur le GPU : c'est bien l'upload qui doit etre couvert.)
while (resident_.size() >= params_.maxResidentNodes) {
if (!evictOne()) {
break; // tout est utilise cette frame : on laisse deborder
MeshHandle mesh = kInvalidMesh;
if (parallel) {
mesh = batchMeshes_[k]; // place deja faite par meshBatch
} else {
// Faire de la place AVANT de reserver, sinon le pic de residence
// depasserait le plafond le temps d'une tuile.
while (resident_.size() >= params_.maxResidentNodes) {
if (!evictOne()) {
break; // tout est utilise cette frame : on laisse deborder
}
}
mesh = buildNode(nodeIndex);
}
const MeshHandle mesh = parallel ? uploadNode(nodeIndex, batchMeshes_[k])
: buildNode(nodeIndex);
if (mesh == kInvalidMesh) {
continue;
}
@@ -447,20 +472,13 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
ResidentNode node;
node.mesh = mesh;
node.bytes = bytesPerNode;
node.bytes = bytesPerNode_;
node.lastUsedFrame = frameCounter_;
resident_.emplace(nodeIndex, node);
residentBytes_ += bytesPerNode;
residentBytes_ += bytesPerNode_;
--pendingCount_; // finalement servie dans la frame meme
}
// Le lot ne doit pas garder ses maillages en vie jusqu'a la frame suivante :
// ce sont ~287 Ko par tuile.
if (parallel) {
batchMeshes_.clear();
batchMeshes_.shrink_to_fit();
}
// --- 2. Choix des ancetres de repli (PHASE 12) --------------------------
// Rien a faire dans le cas courant : en regime etabli toute la selection est
// residente, l'ensemble reste vide et les passes suivantes ne coutent rien.
@@ -489,6 +507,7 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
// --- 3. Emission ---------------------------------------------------------
const bool hasFallback = !fallbackAncestors_.empty();
const int32_t vertsPerRow = static_cast<int32_t>(quadtree_.nodeCells() + 1);
auto emit = [&](const TerrainQuadtree::SelectedNode& node, MeshHandle mesh) {
DrawItem item;
item.mesh = mesh;
@@ -497,6 +516,11 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
item.model = glm::mat4(1.0f);
item.material = Material::Terrain;
item.params = glm::vec4(node.morphStart, node.morphEnd, 0.0f, 0.0f);
// PHASE 32 : ou est la tuile dans la grille - terrain.vert en deduit la
// position horizontale, la cible de morphing et l'UV de chaque sommet.
const TerrainQuadtree::Node& grid = quadtree_.node(node.nodeIndex);
item.grid = glm::ivec4(static_cast<int32_t>(grid.ix0), static_cast<int32_t>(grid.iz0),
static_cast<int32_t>(grid.stride), vertsPerRow);
out.push_back(item);
++drawnCount_;
};
+43 -31
Voir le fichier
@@ -3,6 +3,7 @@
#include "core/Frustum.hpp"
#include "renderer/DrawItem.hpp"
#include "renderer/MeshData.hpp"
#include "renderer/Renderer.hpp" // Renderer::TerrainMeshWrite
#include "world/TerrainQuadtree.hpp"
#include <glm/glm.hpp>
@@ -16,7 +17,6 @@
namespace vercora {
class Heightmap;
class Renderer;
// Fait le lien entre le quadtree (qui decide QUOI dessiner) et le Renderer (qui
// possede les geometries GPU) : cache de tuiles residentes, construction a la
@@ -36,10 +36,12 @@ class Renderer;
// recopier). Il est passe de 4 a 64 pour cette raison. Les tuiles au-dela du
// budget sont servies dans les frames suivantes, les plus PROCHES d'abord.
//
// 2. PLAFOND DE RESIDENCE (maxResidentNodes). Chaque tuile consomme deux
// allocations Vulkan (vertex + index), et vkAllocateMemory est plafonne par
// maxMemoryAllocationCount (typiquement 4096). Le plafond garde une marge
// confortable en plus de borner la RAM.
// 2. PLAFOND DE RESIDENCE (maxResidentNodes). Il bornait a l'origine deux
// choses : la memoire, et le nombre d'allocations Vulkan (deux par tuile,
// plafonnees par maxMemoryAllocationCount, typiquement 4096). PHASE 32 :
// les tuiles vivent dans les blocs partages du GpuBufferPool, une tuile ne
// coute plus d'allocation - le plafond ne borne plus que la memoire, a
// 68 Ko par tuile au lieu de 385.
//
// 3. EVICTION LRU, jamais sur une tuile utilisee dans la frame courante, ni
// sur une tuile du sommet epingle (point 4).
@@ -87,8 +89,9 @@ public:
// staging vivant simultanement (64 tuiles ~ 25 Mo).
uint32_t maxUploadsPerFrame = 64;
// Plafond de tuiles gardees sur le GPU. 512 tuiles = 1024 allocations
// Vulkan et ~200 Mo au format de sommet de la Phase 10.
// Plafond de tuiles gardees sur le GPU. 512 tuiles = ~200 Mo au format
// de sommet de la Phase 10, ~35 Mo depuis la Phase 32 (sommet de 16
// octets, topologie partagee), en une dizaine de blocs de 4 Mo.
uint32_t maxResidentNodes = 512;
// Frames pendant lesquelles le budget par frame est LEVE, au demarrage :
@@ -176,7 +179,11 @@ public:
// Ni la Heightmap ni le Renderer ne sont possedes ; les deux doivent vivre
// plus longtemps que le streamer.
TerrainStreamer(const Heightmap& heightmap, Renderer& renderer,
const Params& params = {});
const Params& params);
// Parametres par defaut : surcharge et non `= {}`, voir Heightmap() (refus
// de GCC/Clang, CWG 1397).
TerrainStreamer(const Heightmap& heightmap, Renderer& renderer)
: TerrainStreamer(heightmap, renderer, Params{}) {}
~TerrainStreamer();
TerrainStreamer(const TerrainStreamer&) = delete;
@@ -241,33 +248,34 @@ private:
bool pinned = false;
};
// PHASE 19. Maille les tuiles `nodes` dans `batchMeshes_`, en parallele
// au-dela de deux tuiles. AUCUN appel Vulkan : c'est toute la raison pour
// laquelle cette etape peut quitter le thread de rendu sans rien changer a
// la synchronisation du moteur.
// PHASE 19. Construit les tuiles `nodes` dans `batchMeshes_`, le maillage
// en parallele au-dela de deux tuiles. PHASE 32 : les emplacements sont
// reserves d'abord sur le thread de rendu (Renderer::beginTerrainMesh), les
// threads y ECRIVENT les sommets - sans le moindre appel Vulkan, c'est
// toute la raison pour laquelle cette etape peut quitter le thread de
// rendu - puis le thread de rendu les livre (endTerrainMesh).
//
// Chaque thread ecrit dans des ELEMENTS DISJOINTS de vecteurs deja
// dimensionnes : il n'y a ni verrou, ni file, ni compteur partage - donc
// aucun etat sur lequel une course serait possible. Une tuile qui echoue
// depose son message dans `batchErrors_[k]`, jamais dans un journal (les
// fonctions de journalisation ne sont pas prevues pour plusieurs threads) :
// c'est l'appelant qui journalise, apres la jonction.
// Chaque thread ecrit dans des ZONES DISJOINTES deja reservees : il n'y a
// ni verrou, ni file, ni compteur partage - donc aucun etat sur lequel une
// course serait possible. Une tuile qui echoue depose son message dans
// `batchErrors_[k]`, jamais dans un journal (les fonctions de
// journalisation ne sont pas prevues pour plusieurs threads) : c'est
// l'appelant qui journalise, apres la jonction.
void meshBatch(const std::vector<uint32_t>& nodes);
// true si un lot de `count` tuiles vaut la peine de partir sur des threads.
bool wantsParallel(std::size_t count) const;
// Pose la topologie commune puis televerse. SEQUENTIEL, thread de rendu.
// Renvoie kInvalidMesh en cas d'echec (la tuile est alors simplement
// sautee : un trou d'une frame vaut mieux qu'un arret du jeu).
MeshHandle uploadNode(uint32_t nodeIndex, MeshData& data);
// Maille ET televerse une tuile, en sequence, sans jamais garder plus d'un
// MeshData en vie. Chemin par DEFAUT depuis que meshThreads vaut 1, et
// chemin du sommet epingle.
// PHASE 32. Construit une tuile : reserve sa place dans le pool de
// geometrie (Renderer::beginTerrainMesh), y ECRIT ses sommets au format
// compact, la livre. SEQUENTIEL, thread de rendu. Chemin par DEFAUT depuis
// que meshThreads vaut 1, et chemin du sommet epingle. Renvoie kInvalidMesh
// en cas d'echec (la tuile est alors simplement sautee : un trou d'une
// frame vaut mieux qu'un arret du jeu).
MeshHandle buildNode(uint32_t nodeIndex);
// PHASE 18 : la topologie d'une tuile, commune a toutes.
// PHASE 18 : la topologie d'une tuile, commune a toutes. PHASE 32 : elle
// n'est plus recopiee par tuile mais televersee UNE fois (sharedIndexSet_).
const std::vector<uint32_t>& sharedIndices() const;
// Libere la tuile la moins recemment utilisee qui n'a pas servi dans la
@@ -337,12 +345,16 @@ private:
// locales, uniquement pour garder leur capacite d'une frame a l'autre -
// meme raison que selection_ et fallbackAncestors_.
std::vector<uint32_t> batchNodes_;
std::vector<MeshData> batchMeshes_; // rempli seulement sur le chemin parallele
std::vector<std::string> batchErrors_;
// PHASE 32 : emplacements reserves par le chemin parallele, ou les threads
// ecrivent directement (plus aucun MeshData de 287 Ko par tuile du lot).
std::vector<Renderer::TerrainMeshWrite> batchWrites_;
std::vector<MeshHandle> batchMeshes_;
// Maillage de travail du chemin sequentiel. Membre pour garder sa capacite
// d'une tuile a l'autre ; il n'en vit jamais qu'un.
MeshData scratchMesh_;
// PHASE 32 : la topologie commune, televersee une fois (Renderer::
// addSharedIndices), et la taille GPU d'une tuile (ses sommets seuls).
uint32_t sharedIndexSet_ = 0;
std::size_t bytesPerNode_ = 0;
// PHASE 19 : temps de MUR de l'etape de maillage, a comparer a
// geometryMicros_ qui reste, lui, la somme du travail par tuile. Les deux
+130 -73
Voir le fichier
@@ -72,8 +72,19 @@ TextureData Texture::whitePixelData() {
Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
const TextureData& data, bool repeat)
: Texture(context, commandPool, queue, data,
[&data](void* destination, uint64_t offset, uint64_t bytes) {
std::memcpy(destination, data.pixels.data() + offset,
static_cast<std::size_t>(bytes));
},
repeat) {
}
Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
const TextureData& data, const PixelSource& source, bool repeat)
: context_(context) {
if (data.pixels.empty() || data.mips.empty()) {
if (data.mips.empty() || data.payloadSize() == 0 ||
(!data.pixels.empty() && data.pixels.size() < data.payloadSize())) {
throw std::runtime_error("Texture : donnees vides.");
}
@@ -95,7 +106,7 @@ Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queu
const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
createImage(data.width, data.height, mipLevels, format);
uploadAndTransition(commandPool, queue, data);
uploadAndTransition(commandPool, queue, data, source);
createView(format, mipLevels);
createSampler(mipLevels, repeat);
}
@@ -111,9 +122,7 @@ Texture::~Texture() {
if (image_ != VK_NULL_HANDLE) {
vkDestroyImage(device, image_, nullptr);
}
if (memory_ != VK_NULL_HANDLE) {
vkFreeMemory(device, memory_, nullptr);
}
context_.freeMemory(allocation_);
}
void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
@@ -139,32 +148,66 @@ void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
VkMemoryRequirements requirements{};
vkGetImageMemoryRequirements(device, image_, &requirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = requirements.size;
allocInfo.memoryTypeIndex = context_.findMemoryType(
requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
throw std::runtime_error("Texture : echec de l'allocation memoire de l'image.");
}
vkBindImageMemory(device, image_, memory_, 0);
// PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
allocation_ = context_.allocateMemory(requirements, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkBindImageMemory(device, image_, allocation_.memory, 0);
deviceSize_ = requirements.size;
}
void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
const TextureData& data) {
const TextureData& data, const PixelSource& source) {
VkDevice device = context_.device();
const VkDeviceSize total = static_cast<VkDeviceSize>(data.pixels.size());
const VkDeviceSize total = static_cast<VkDeviceSize>(data.payloadSize());
const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
// Un seul buffer de staging pour toute la chaine : les niveaux sont deja
// contigus dans le fichier, donc les offsets de copie sont ceux du .vcto.
VulkanBuffer staging(context_, total,
// PHASE 32 : un staging de 4 Mo au plus, REUTILISE tranche apres tranche,
// au lieu d'un staging de la taille de toute la chaine. Pour l'orthophoto
// de la zone, c'etait 42 Mo de memoire GPU transitoire en plus de l'image
// elle-meme : le pic de memoire GPU de TOUTE la partie se situait la, au
// chargement. Les texels sont ecrits dans le staging par `source` -
// directement depuis le fichier pour l'orthophoto.
constexpr VkDeviceSize kStagingChunk = 4ull * 1024 * 1024;
const VkDeviceSize stagingSize = std::min(total, kStagingChunk);
VulkanBuffer staging(context_, stagingSize,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
staging.writeToBuffer(data.pixels.data(), total);
staging.unmap();
staging.map();
auto* stagingBytes = static_cast<unsigned char*>(staging.mapped());
// --- Decoupe en BANDES de rangees de blocs ------------------------------
// Une bande = des rangees completes d'un niveau, assez peu pour tenir dans
// le staging. BC1 se range par rangees de blocs de 4 texels de haut ; une
// bande qui n'atteint pas le bas d'un niveau a donc une hauteur multiple de
// 4, comme l'exige une copie vers un format compresse.
struct Band {
uint32_t level = 0;
uint32_t y = 0;
uint32_t height = 0;
uint64_t payloadOffset = 0;
uint64_t bytes = 0;
};
std::vector<Band> bands;
const bool blocks = (data.format == TextureFormat::BC1);
const uint32_t texelsPerRow = blocks ? 4u : 1u;
for (uint32_t level = 0; level < mipLevels; ++level) {
const TextureMipLevel& mip = data.mips[level];
const uint64_t rowBytes = blocks ? static_cast<uint64_t>((mip.width + 3u) / 4u) * 8u
: static_cast<uint64_t>(mip.width) * 4u;
const uint32_t rows = (mip.height + texelsPerRow - 1u) / texelsPerRow;
const uint32_t rowsPerBand = static_cast<uint32_t>(
std::max<uint64_t>(1u, stagingSize / rowBytes));
for (uint32_t row = 0; row < rows; row += rowsPerBand) {
const uint32_t count = std::min(rowsPerBand, rows - row);
Band band;
band.level = level;
band.y = row * texelsPerRow;
band.height = std::min(count * texelsPerRow, mip.height - band.y);
band.payloadOffset = mip.offset + static_cast<uint64_t>(row) * rowBytes;
band.bytes = static_cast<uint64_t>(count) * rowBytes;
bands.push_back(band);
}
}
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
@@ -175,60 +218,74 @@ void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
transitionLayout(commandBuffer, image_, mipLevels,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
0, VK_ACCESS_TRANSFER_WRITE_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
// --- Un lot de bandes par remplissage du staging ------------------------
std::vector<VkBufferImageCopy> regions;
regions.reserve(mipLevels);
for (uint32_t level = 0; level < mipLevels; ++level) {
const TextureMipLevel& mip = data.mips[level];
VkBufferImageCopy region{};
region.bufferOffset = mip.offset;
// 0 = "serre sur l'extent de l'image". Indispensable pour un format
// compresse, ou bufferRowLength se compterait en TEXELS et non en blocs :
// le calculer a la main serait une occasion d'erreur gratuite.
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.mipLevel = level;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageOffset = { 0, 0, 0 };
region.imageExtent = { mip.width, mip.height, 1 };
regions.push_back(region);
std::size_t next = 0;
bool first = true;
while (next < bands.size()) {
regions.clear();
VkDeviceSize used = 0;
while (next < bands.size() && used + bands[next].bytes <= stagingSize) {
const Band& band = bands[next];
source(stagingBytes + used, band.payloadOffset, band.bytes);
VkBufferImageCopy region{};
region.bufferOffset = used;
// 0 = "serre sur l'extent de la copie". Indispensable pour un format
// compresse, ou bufferRowLength se compterait en TEXELS et non en
// blocs : le calculer a la main serait une occasion d'erreur
// gratuite.
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.mipLevel = band.level;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageOffset = { 0, static_cast<int32_t>(band.y), 0 };
region.imageExtent = { data.mips[band.level].width, band.height, 1 };
regions.push_back(region);
used += band.bytes;
++next;
}
const bool last = (next == bands.size());
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
if (first) {
transitionLayout(commandBuffer, image_, mipLevels,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
0, VK_ACCESS_TRANSFER_WRITE_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
}
vkCmdCopyBufferToImage(commandBuffer, staging.handle(), image_,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
static_cast<uint32_t>(regions.size()), regions.data());
if (last) {
transitionLayout(commandBuffer, image_, mipLevels,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
}
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffer;
vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
// Transfert a l'initialisation : attendre est simple et sans
// consequence sur la boucle de rendu, qui n'a pas encore demarre - et
// c'est ce qui rend le staging reutilisable pour la tranche suivante.
vkQueueWaitIdle(queue);
first = false;
}
vkCmdCopyBufferToImage(commandBuffer, staging.handle(), image_,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
static_cast<uint32_t>(regions.size()), regions.data());
transitionLayout(commandBuffer, image_, mipLevels,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffer;
vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
// Transfert unique a l'initialisation : attendre est simple et sans
// consequence sur la boucle de rendu, qui n'a pas encore demarre.
vkQueueWaitIdle(queue);
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
}
+17 -2
Voir le fichier
@@ -4,10 +4,12 @@
// le renvoie par valeur. L'en-tete reste sans cout : assets/TextureFile.hpp ne
// depend pas de Vulkan.
#include "assets/TextureFile.hpp"
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h>
#include <cstdint>
#include <functional>
namespace vercora {
@@ -43,6 +45,19 @@ public:
// l'orthophoto - voir createSampler.
Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
const TextureData& data, bool repeat = false);
// PHASE 32. Source des texels : ecrit `bytes` octets de la charge utile, a
// partir de l'octet `offset` (0 = debut du niveau 0, meme rangement que
// TextureData::pixels), dans `destination` - le staging mappe.
using PixelSource =
std::function<void(void* destination, uint64_t offset, uint64_t bytes)>;
// PHASE 32. Meme texture, mais les texels ne sont PAS dans `layout` (son
// `pixels` peut etre vide) : `source` les ecrit directement dans le
// staging, tranche par tranche. C'est ce qui permet de lire l'orthophoto
// depuis son fichier sans jamais la tenir en RAM.
Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
const TextureData& layout, const PixelSource& source, bool repeat = false);
~Texture();
Texture(const Texture&) = delete;
@@ -68,13 +83,13 @@ public:
private:
void createImage(uint32_t width, uint32_t height, uint32_t mipLevels, VkFormat format);
void uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
const TextureData& data);
const TextureData& data, const PixelSource& source);
void createView(VkFormat format, uint32_t mipLevels);
void createSampler(uint32_t mipLevels, bool repeat);
VulkanContext& context_;
VkImage image_ = VK_NULL_HANDLE;
VkDeviceMemory memory_ = VK_NULL_HANDLE;
GpuAllocation allocation_;
VkImageView view_ = VK_NULL_HANDLE;
VkSampler sampler_ = VK_NULL_HANDLE;
VkDeviceSize deviceSize_ = 0;
+8
Voir le fichier
@@ -85,6 +85,14 @@ struct UniformBufferObject {
alignas(16) glm::vec4 precip{0.0f, 0.0f, 0.0f, 0.0f};
alignas(16) glm::vec4 fall{0.0f, -6.5f, 0.0f, 0.0f};
alignas(16) glm::vec4 detail{0.0f, 0.0f, 1.0f, 1.0f};
// PHASE 32. Offset 256. Grille de la heightmap, pour que terrain.vert
// recalcule la position horizontale et l'UV d'un sommet a partir de son
// indice (voir renderer/GpuVertex.hpp, TerrainVertex) :
// x = origine (Heightmap::worldCoord(0)), y = pas en metres,
// z = nombre de CELLULES par cote (resolution - 1), w = reserve.
// Constant sur toute la partie ; seuls les shaders du terrain le declarent.
alignas(16) glm::vec4 terrainGrid{0.0f, 1.0f, 1.0f, 0.0f};
};
} // namespace vercora
+53 -31
Voir le fichier
@@ -1,7 +1,7 @@
#pragma once
#include "renderer/GpuVertex.hpp"
#include "renderer/InstanceData.hpp"
#include "renderer/Vertex.hpp"
#include <vulkan/vulkan.h>
@@ -24,60 +24,82 @@ namespace vercora {
// Consequence concrete : la logique de jeu se compile et se teste sans GPU (voir
// tests/logic_tests.cpp), y compris sur une machine ou le SDK n'est pas installe.
// Un seul binding, sommets entrelaces.
inline VkVertexInputBindingDescription vertexBindingDescription() {
// PHASE 32 : DEUX formats de sommet, un par famille de shaders (voir
// renderer/GpuVertex.hpp) - le format de travail CPU `Vertex` n'est plus
// televerse tel quel. Un seul binding entrelace dans les deux cas.
// --- Objets et vegetation : ObjectVertex, 44 octets -------------------------
inline VkVertexInputBindingDescription objectBindingDescription() {
VkVertexInputBindingDescription binding{};
binding.binding = 0;
binding.stride = sizeof(Vertex);
binding.stride = sizeof(ObjectVertex);
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return binding;
}
// Mapping des attributs vers les location(...) du vertex shader.
//
// Six attributs depuis la Phase 10 : les deux derniers portent la cible de
// geomorphing du terrain (voir Vertex.hpp) et ne sont decrits qu'aux pipelines
// dont le vertex shader les lit reellement.
// `includeMorph` a false pour un vertex shader qui ne lit pas les locations 4/5
// (cube.vert) : les decrire quand meme declencherait un avertissement de
// validation. Voir ShaderSet::usesMorphAttributes.
inline std::array<VkVertexInputAttributeDescription, 6> vertexAttributeDescriptions() {
std::array<VkVertexInputAttributeDescription, 6> attrs{};
// Locations 0 a 3 : position, couleur, normale, UV - les memes que depuis la
// Phase 3, seul le stride a change (les 24 octets de morphing, qu'aucun de ces
// shaders ne lisait, ne sont plus dans le buffer).
inline std::array<VkVertexInputAttributeDescription, 4> objectAttributeDescriptions() {
std::array<VkVertexInputAttributeDescription, 4> attrs{};
attrs[0].binding = 0;
attrs[0].location = 0;
attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[0].offset = offsetof(Vertex, pos);
attrs[0].offset = offsetof(ObjectVertex, pos);
attrs[1].binding = 0;
attrs[1].location = 1;
attrs[1].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[1].offset = offsetof(Vertex, color);
attrs[1].offset = offsetof(ObjectVertex, color);
attrs[2].binding = 0;
attrs[2].location = 2;
attrs[2].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[2].offset = offsetof(Vertex, normal);
attrs[2].offset = offsetof(ObjectVertex, normal);
// Deux composantes seulement -> format R32G32.
attrs[3].binding = 0;
attrs[3].location = 3;
attrs[3].format = VK_FORMAT_R32G32_SFLOAT;
attrs[3].offset = offsetof(Vertex, uv);
attrs[3].offset = offsetof(ObjectVertex, uv);
// Position et normale du meme sommet dans la grille du niveau de detail
// SUPERIEUR (plus grossier). Nulles sur toute geometrie qui n'est pas une
// tuile de quadtree : sans effet, le shader ne morphe que si la bande de
// morphing poussee par le DrawItem est non vide.
attrs[4].binding = 0;
attrs[4].location = 4;
attrs[4].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[4].offset = offsetof(Vertex, morphPos);
return attrs;
}
attrs[5].binding = 0;
attrs[5].location = 5;
attrs[5].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[5].offset = offsetof(Vertex, morphNormal);
// --- Terrain : TerrainVertex, 16 octets --------------------------------------
inline VkVertexInputBindingDescription terrainBindingDescription() {
VkVertexInputBindingDescription binding{};
binding.binding = 0;
binding.stride = sizeof(TerrainVertex);
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return binding;
}
// Deux altitudes en flottant, deux normales en snorm16 (x et z, y reconstruit
// par terrain.vert). Tout le reste se deduit de gl_VertexIndex.
inline std::array<VkVertexInputAttributeDescription, 4> terrainAttributeDescriptions() {
std::array<VkVertexInputAttributeDescription, 4> attrs{};
attrs[0].binding = 0;
attrs[0].location = 0;
attrs[0].format = VK_FORMAT_R32_SFLOAT;
attrs[0].offset = offsetof(TerrainVertex, height);
attrs[1].binding = 0;
attrs[1].location = 1;
attrs[1].format = VK_FORMAT_R32_SFLOAT;
attrs[1].offset = offsetof(TerrainVertex, morphHeight);
attrs[2].binding = 0;
attrs[2].location = 2;
attrs[2].format = VK_FORMAT_R16G16_SNORM;
attrs[2].offset = offsetof(TerrainVertex, normal);
attrs[3].binding = 0;
attrs[3].location = 3;
attrs[3].format = VK_FORMAT_R16G16_SNORM;
attrs[3].offset = offsetof(TerrainVertex, morphNormal);
return attrs;
}
@@ -98,7 +120,7 @@ inline VkVertexInputBindingDescription instanceBindingDescription() {
return binding;
}
// Locations 6 a 8 : les locations 0 a 5 appartiennent au sommet (voir plus haut),
// Locations 6 a 8 : les locations basses appartiennent au sommet (voir plus haut),
// et un pipeline instancie decrit les deux flux dans le meme espace de numeros.
// Les trois flottants scalaires (scale, yaw, variation, fade) sont regroupes en
// deux attributs plutot qu'en quatre : moins d'attributs a decrire, et le shader
+11 -15
Voir le fichier
@@ -27,42 +27,38 @@ VulkanBuffer::VulkanBuffer(VulkanContext& context,
VkMemoryRequirements memRequirements{};
vkGetBufferMemoryRequirements(device, buffer_, &memRequirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex =
context_.findMemoryType(memRequirements.memoryTypeBits, properties);
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
throw std::runtime_error("Echec de l'allocation memoire d'un buffer.");
// PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
try {
allocation_ = context_.allocateMemory(memRequirements, properties);
} catch (...) {
vkDestroyBuffer(device, buffer_, nullptr);
throw;
}
vkBindBufferMemory(device, buffer_, memory_, 0);
vkBindBufferMemory(device, buffer_, allocation_.memory, 0);
}
VulkanBuffer::~VulkanBuffer() {
VkDevice device = context_.device();
if (mapped_ != nullptr) {
vkUnmapMemory(device, memory_);
vkUnmapMemory(device, allocation_.memory);
mapped_ = nullptr;
}
if (buffer_ != VK_NULL_HANDLE) {
vkDestroyBuffer(device, buffer_, nullptr);
}
if (memory_ != VK_NULL_HANDLE) {
vkFreeMemory(device, memory_, nullptr);
}
context_.freeMemory(allocation_);
}
void VulkanBuffer::map() {
if (mapped_ == nullptr) {
vkMapMemory(context_.device(), memory_, 0, size_, 0, &mapped_);
vkMapMemory(context_.device(), allocation_.memory, 0, size_, 0, &mapped_);
}
}
void VulkanBuffer::unmap() {
if (mapped_ != nullptr) {
vkUnmapMemory(context_.device(), memory_);
vkUnmapMemory(context_.device(), allocation_.memory);
mapped_ = nullptr;
}
}
+8 -4
Voir le fichier
@@ -1,5 +1,7 @@
#pragma once
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h>
#include <memory>
@@ -31,10 +33,12 @@ public:
virtual ~BufferUploader() = default;
// Enregistre une copie de `staging` (integralite de sa taille) vers
// `destination`. Prend possession de `staging`, qui sera detruit quand la
// frame ayant execute la copie sera terminee.
// `destination`, a partir de l'octet `destinationOffset` (PHASE 32 : la
// destination est une PLAGE d'un bloc partage, voir GpuBufferPool). Prend
// possession de `staging`, qui sera detruit quand la frame ayant execute la
// copie sera terminee.
virtual void enqueueCopy(std::unique_ptr<VulkanBuffer> staging,
VkBuffer destination) = 0;
VkBuffer destination, VkDeviceSize destinationOffset) = 0;
};
// Buffer Vulkan reutilisable : creation, allocation memoire, bind, map,
@@ -76,7 +80,7 @@ private:
VulkanContext& context_;
VkDeviceSize size_ = 0;
VkBuffer buffer_ = VK_NULL_HANDLE;
VkDeviceMemory memory_ = VK_NULL_HANDLE;
GpuAllocation allocation_;
void* mapped_ = nullptr;
};
+91 -5
Voir le fichier
@@ -3,6 +3,8 @@
#include "core/Logger.hpp"
#include "core/Window.hpp"
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <stdexcept>
@@ -233,6 +235,29 @@ void VulkanContext::pickPhysicalDevice() {
VkPhysicalDeviceProperties props{};
vkGetPhysicalDeviceProperties(physicalDevice_, &props);
logInfo(std::string("GPU selectionne : ") + props.deviceName);
deviceType_ = props.deviceType;
// PHASE 32 : proprietes memoire lues UNE fois (voir findMemoryType), et
// detection de la memoire unifiee.
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memoryProperties_);
const VkMemoryPropertyFlags unified = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
std::string heaps = "Memoire GPU : " + std::to_string(memoryProperties_.memoryHeapCount) +
" tas -";
for (uint32_t i = 0; i < memoryProperties_.memoryHeapCount; ++i) {
const VkMemoryHeap& heap = memoryProperties_.memoryHeaps[i];
heaps += " [" + std::to_string(i) + "] " +
std::to_string(heap.size / (1024 * 1024)) + " Mo" +
((heap.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) ? " device-local" : "");
}
for (uint32_t i = 0; i < memoryProperties_.memoryTypeCount; ++i) {
if ((memoryProperties_.memoryTypes[i].propertyFlags & unified) == unified) {
unifiedMemory_ = true;
}
}
logInfo(heaps + (unifiedMemory_ ? " ; memoire UNIFIEE (device-local et host-visible)."
: " ; memoire device-local NON mappable."));
}
bool VulkanContext::isDeviceSuitable(VkPhysicalDevice device) const {
@@ -397,13 +422,10 @@ SwapChainSupportDetails VulkanContext::querySwapChainSupport() const {
}
uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const {
VkPhysicalDeviceMemoryProperties memProperties{};
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memProperties);
for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) {
for (uint32_t i = 0; i < memoryProperties_.memoryTypeCount; ++i) {
const bool typeOk = (typeFilter & (1u << i)) != 0;
const bool propsOk =
(memProperties.memoryTypes[i].propertyFlags & properties) == properties;
(memoryProperties_.memoryTypes[i].propertyFlags & properties) == properties;
if (typeOk && propsOk) {
return i;
}
@@ -411,6 +433,70 @@ uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlag
throw std::runtime_error("Aucun type de memoire adapte trouve.");
}
GpuAllocation VulkanContext::allocateMemory(const VkMemoryRequirements& requirements,
VkMemoryPropertyFlags properties, bool map) {
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = requirements.size;
allocInfo.memoryTypeIndex = findMemoryType(requirements.memoryTypeBits, properties);
GpuAllocation allocation;
if (vkAllocateMemory(device_, &allocInfo, nullptr, &allocation.memory) != VK_SUCCESS) {
throw std::runtime_error("Echec de l'allocation de " +
std::to_string(requirements.size) +
" octets de memoire GPU.");
}
allocation.size = requirements.size;
allocation.deviceLocal = (properties & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0;
if (map && vkMapMemory(device_, allocation.memory, 0, VK_WHOLE_SIZE, 0,
&allocation.mapped) != VK_SUCCESS) {
vkFreeMemory(device_, allocation.memory, nullptr);
throw std::runtime_error("Echec du mappage d'un bloc de memoire GPU.");
}
gpuMemory_.liveBytes += allocation.size;
gpuMemory_.peakBytes = std::max(gpuMemory_.peakBytes, gpuMemory_.liveBytes);
if (allocation.deviceLocal) {
gpuMemory_.liveDeviceLocalBytes += allocation.size;
gpuMemory_.peakDeviceLocalBytes =
std::max(gpuMemory_.peakDeviceLocalBytes, gpuMemory_.liveDeviceLocalBytes);
}
++gpuMemory_.liveAllocations;
gpuMemory_.peakAllocations = std::max(gpuMemory_.peakAllocations, gpuMemory_.liveAllocations);
++gpuMemory_.allocateCalls;
return allocation;
}
void VulkanContext::freeMemory(GpuAllocation& allocation) {
if (allocation.memory == VK_NULL_HANDLE) {
return;
}
if (allocation.mapped != nullptr) {
vkUnmapMemory(device_, allocation.memory);
}
vkFreeMemory(device_, allocation.memory, nullptr);
gpuMemory_.liveBytes -= allocation.size;
if (allocation.deviceLocal) {
gpuMemory_.liveDeviceLocalBytes -= allocation.size;
}
--gpuMemory_.liveAllocations;
allocation = GpuAllocation{};
}
std::string VulkanContext::gpuMemoryLine() const {
const auto mo = [](uint64_t bytes) {
char text[32];
std::snprintf(text, sizeof(text), "%.1f Mo", static_cast<double>(bytes) / (1024.0 * 1024.0));
return std::string(text);
};
return "GPU " + mo(gpuMemory_.liveBytes) + " (pic " + mo(gpuMemory_.peakBytes) +
"), dont device-local " + mo(gpuMemory_.liveDeviceLocalBytes) + " (pic " +
mo(gpuMemory_.peakDeviceLocalBytes) + ") ; " +
std::to_string(gpuMemory_.liveAllocations) + " blocs vivants (pic " +
std::to_string(gpuMemory_.peakAllocations) + "), " +
std::to_string(gpuMemory_.allocateCalls) + " vkAllocateMemory au total";
}
VkFormat VulkanContext::findSupportedFormat(const std::vector<VkFormat>& candidates,
VkImageTiling tiling,
VkFormatFeatureFlags features) const {
+68
Voir le fichier
@@ -3,6 +3,7 @@
#include <vulkan/vulkan.h>
#include <optional>
#include <string>
#include <vector>
namespace vercora {
@@ -41,6 +42,32 @@ struct SwapChainSupportDetails {
std::vector<VkPresentModeKHR> presentModes;
};
// PHASE 32. Un bloc de memoire GPU, avec ce qu'il faut savoir pour le rendre
// et pour le COMPTER. Toute la memoire du moteur passe par
// VulkanContext::allocateMemory / freeMemory : c'est ce qui permet au journal
// de donner l'occupation GPU exacte, au lieu de la deduire de formules
// recopiees dans chaque classe (et dont une seule serait mise a jour).
struct GpuAllocation {
VkDeviceMemory memory = VK_NULL_HANDLE;
VkDeviceSize size = 0; // octets REELLEMENT alloues (memory requirements)
bool deviceLocal = false; // DEVICE_LOCAL demande par l'appelant
void* mapped = nullptr; // mappage persistant, si demande
};
// PHASE 32. Bilan de la memoire GPU allouee par le moteur. Les pics sont ceux
// de la session ; "appels" compte tous les vkAllocateMemory depuis le
// demarrage, y compris ceux deja liberes - c'est le chiffre qui dit combien de
// fois le pilote a ete sollicite, pas seulement combien de blocs vivent.
struct GpuMemoryStats {
uint64_t liveBytes = 0;
uint64_t peakBytes = 0;
uint64_t liveDeviceLocalBytes = 0;
uint64_t peakDeviceLocalBytes = 0;
uint64_t liveAllocations = 0;
uint64_t peakAllocations = 0;
uint64_t allocateCalls = 0;
};
// Regroupe l'etat "global" Vulkan qui ne change pas au resize :
// instance, debug messenger, surface, GPU physique, device logique, queues.
class VulkanContext {
@@ -84,6 +111,39 @@ public:
// Format de profondeur retenu (D32 de preference, avec fallbacks).
VkFormat findDepthFormat() const;
// PHASE 32. Alloue un bloc satisfaisant `requirements` dans un type de
// memoire qui porte `properties`, et le COMPTE. Lance std::runtime_error si
// le pilote refuse. `map` = true mappe le bloc en permanence (le type doit
// alors etre HOST_VISIBLE).
GpuAllocation allocateMemory(const VkMemoryRequirements& requirements,
VkMemoryPropertyFlags properties, bool map = false);
// Rend le bloc (demappe s'il l'etait) et le decompte. Sans effet sur une
// allocation vide ; remet `allocation` a zero.
void freeMemory(GpuAllocation& allocation);
const GpuMemoryStats& gpuMemoryStats() const { return gpuMemory_; }
// Ligne de journal lisible du bilan ci-dessus.
std::string gpuMemoryLine() const;
// PHASE 32. true si un type de memoire est a la fois DEVICE_LOCAL et
// HOST_VISIBLE | HOST_COHERENT : memoire unifiee (GPU integre, lavapipe), ou
// le CPU peut ecrire directement la ou le GPU lit, sans staging ni copie.
// Faux sur un GPU discret classique (hors BAR redimensionnable).
bool unifiedMemory() const { return unifiedMemory_; }
// PHASE 32. true si la geometrie doit etre ecrite DIRECTEMENT dans sa
// memoire device-local mappee plutot que par staging : memoire unifiee ET
// GPU integre (ou logiciel). Un GPU discret peut aussi exposer une memoire
// device-local mappable (BAR, 256 Mo sans ReBAR) ; elle est trop petite et
// trop precieuse pour y loger le terrain, il garde donc le staging.
bool preferDirectGeometryWrites() const {
return unifiedMemory_ &&
(deviceType_ == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU ||
deviceType_ == VK_PHYSICAL_DEVICE_TYPE_CPU);
}
private:
void createInstance();
void setupDebugMessenger();
@@ -110,6 +170,14 @@ private:
QueueFamilyIndices queueIndices_;
bool anisotropyEnabled_ = false;
bool unifiedMemory_ = false;
VkPhysicalDeviceType deviceType_ = VK_PHYSICAL_DEVICE_TYPE_OTHER;
// Proprietes memoire du GPU, lues une fois : findMemoryType les
// interrogeait a CHAQUE allocation (deux par tuile de terrain).
VkPhysicalDeviceMemoryProperties memoryProperties_{};
GpuMemoryStats gpuMemory_;
};
} // namespace vercora
+4 -1
Voir le fichier
@@ -127,7 +127,10 @@ public:
// pour le rendu que pour la COLLISION (voir la note de decouplage dans
// MEMORY.md). L'arbre n'en garde que des bornes.
// Lance std::runtime_error si les parametres sont inexploitables.
TerrainQuadtree(const Heightmap& heightmap, const Params& params = {});
TerrainQuadtree(const Heightmap& heightmap, const Params& params);
// Parametres par defaut : surcharge et non `= {}`, voir Heightmap() (refus
// de GCC/Clang, CWG 1397).
TerrainQuadtree(const Heightmap& heightmap) : TerrainQuadtree(heightmap, Params{}) {}
// Remplit `out` avec les noeuds a dessiner, tries du plus proche au plus
// lointain. `out` est vide au prealable ; sa capacite est conservee.
+278
Voir le fichier
@@ -37,6 +37,8 @@
#include "editor/PlacedObject.hpp"
#include "editor/SceneFile.hpp"
#include "renderer/DrawItem.hpp"
#include "renderer/GpuVertex.hpp"
#include "renderer/RangeAllocator.hpp"
#include "renderer/TerrainMesh.hpp"
#include "renderer/TerrainNodeMesh.hpp"
#include "world/AnimalMesh.hpp"
@@ -3197,6 +3199,62 @@ void testTextureFile() {
threw = true;
}
check(threw, "Refus : fichier .vcto absent");
// --- PHASE 32 : en-tete seul, puis charge utile lue a la demande --------
// Le chargement de l'orthophoto ne tient plus la charge utile en RAM : il
// lit l'en-tete, puis des TRANCHES directement dans le staging. Les deux
// chemins doivent rendre exactement les memes octets que loadTextureFile.
{
const std::string path =
(std::filesystem::temp_directory_path() / "vercora_phase32_test.vcto").string();
std::vector<unsigned char> payload;
const uint32_t width = 8;
const uint32_t height = 4;
uint32_t levels = 0;
for (uint32_t w = width, h = height;; w = std::max(1u, w / 2), h = std::max(1u, h / 2)) {
for (uint32_t k = 0; k < w * h * 4; ++k) {
payload.push_back(static_cast<unsigned char>((payload.size() * 37u + 11u) & 0xFFu));
}
++levels;
if (w == 1 && h == 1) {
break;
}
}
unsigned char header[128] = {};
std::memcpy(header, "VCTO", 4);
const uint32_t fields[5] = { 1u, width, height, levels, 0u /* RGBA8 */ };
std::memcpy(header + 4, fields, sizeof(fields));
const double extent[4] = { 899000.0, 6435000.0, 904000.0, 6440000.0 };
std::memcpy(header + 24, extent, sizeof(extent));
const uint32_t epsg = 2154u;
std::memcpy(header + 56, &epsg, sizeof(epsg));
{
std::ofstream out(path, std::ios::binary);
out.write(reinterpret_cast<const char*>(header), sizeof(header));
out.write(reinterpret_cast<const char*>(payload.data()),
static_cast<std::streamsize>(payload.size()));
}
const TextureData full = loadTextureFile(path);
const TextureData headerOnly = loadTextureFileHeader(path);
check(full.pixels == payload && full.payloadSize() == payload.size(),
"Phase 32 : loadTextureFile rend la charge utile complete");
check(headerOnly.pixels.empty() && headerOnly.payloadSize() == payload.size() &&
headerOnly.mips.size() == full.mips.size(),
"Phase 32 : l'en-tete seul decrit la meme chaine, sans aucun texel");
std::vector<unsigned char> whole(payload.size());
readTexturePayload(path, headerOnly, whole.data());
std::vector<unsigned char> banded(payload.size());
std::ifstream in(path, std::ios::binary);
for (uint64_t offset = 0; offset < payload.size(); offset += 24) {
const uint64_t bytes = std::min<uint64_t>(24, payload.size() - offset);
readTexturePayload(in, offset, bytes, banded.data() + offset);
}
check(whole == payload && banded == payload,
"Phase 32 : lecture directe et lecture par tranches = memes octets");
std::filesystem::remove(path);
}
}
void testGrassMesh() {
@@ -10870,6 +10928,225 @@ void testBushPlacement() {
}
}
// ---------------------------------------------------------------------------
// PHASE 32 : formats GPU compacts et sous-allocation de la geometrie
// ---------------------------------------------------------------------------
// Ce que le GPU lit n'est plus le format de travail `Vertex` (68 octets) mais
// ObjectVertex (44) et TerrainVertex (16), et toute la geometrie vit dans des
// plages de blocs partages. Rien de cela ne se VOIT si c'est faux d'un octet :
// un decalage d'allocateur ecrase la geometrie d'un voisin, une position
// recalculee differemment fait trembler les jointures de tuiles. D'ou ces
// verifications, faites sans GPU.
void testGpuFormatsPhase32() {
section("Phase 32 : formats GPU compacts et pool de geometrie");
check(sizeof(ObjectVertex) == 44 && sizeof(TerrainVertex) == 16 &&
sizeof(DrawItemPush) == 96,
"Phase 32 : 44 / 16 octets par sommet, 96 octets de push constants");
// --- ObjectVertex : conversion EXACTE -----------------------------------
{
Vertex v{};
v.pos = { 1.25f, -3.5f, 1234.567f };
v.color = { 0.42f, 0.13f, 0.99f };
v.normal = { 0.1f, 0.9f, -0.2f };
v.uv = { 0.333f, 0.777f };
v.morphPos = { 9.0f, 9.0f, 9.0f };
const ObjectVertex o = toObjectVertex(v);
check(o.pos == v.pos && o.color == v.color && o.normal == v.normal && o.uv == v.uv,
"ObjectVertex : position, couleur, normale et UV recopiees au bit pres");
}
// --- snorm16 : la convention de VK_FORMAT_R16_SNORM ---------------------
{
float worst = 0.0f;
for (int k = -2000; k <= 2000; ++k) {
const float value = static_cast<float>(k) / 2000.0f;
worst = std::max(worst, std::abs(unpackSnorm16(packSnorm16(value)) - value));
}
check(worst <= 0.5f / 32767.0f + 1e-7f,
"snorm16 : erreur d'aller-retour d'au plus un demi-pas (1,5e-5)");
check(packSnorm16(1.0f) == 32767 && packSnorm16(-1.0f) == -32767 &&
packSnorm16(7.0f) == 32767 && packSnorm16(-7.0f) == -32767 &&
unpackSnorm16(-32768) == -1.0f,
"snorm16 : bornes et ecretage");
// Normales de champ de hauteur, du plat a la paroi (pente 20) : la
// reconstruction de y depuis x et z quantifies reste a 1e-3 pres
// (et a 1e-4 pres jusqu'a une pente de 5, soit 79 degres).
float worstNormal = 0.0f;
float worstNormalModerate = 0.0f;
for (int a = 0; a < 64; ++a) {
for (int b = 0; b < 16; ++b) {
const float slope = 20.0f * static_cast<float>(b) / 15.0f;
const float angle = 6.2831853f * static_cast<float>(a) / 64.0f;
const glm::vec3 n = glm::normalize(
glm::vec3(-slope * std::cos(angle), 1.0f, -slope * std::sin(angle)));
const int16_t packed[2] = { packSnorm16(n.x), packSnorm16(n.z) };
const float error = glm::length(unpackTerrainNormal(packed) - n);
worstNormal = std::max(worstNormal, error);
if (slope <= 5.0f) {
worstNormalModerate = std::max(worstNormalModerate, error);
}
}
}
check(worstNormal < 1e-3f && worstNormalModerate < 1e-4f,
"TerrainVertex : normale reconstruite a 1e-4 pres jusqu'a 79 degres");
}
// --- Tuiles : le format GPU est le format de reference, compacte --------
// writeTerrainNodeVertices (chemin du streamer) doit rendre EXACTEMENT
// toTerrainVertex(terrainNodeMeshData) pour CHAQUE noeud, grilles paire et
// impaire, avec et sans la grille du parent mise en cache.
{
Heightmap::Params even;
even.resolution = 513;
even.worldSize = 512.0f;
even.seed = 3030u;
Heightmap::Params odd;
odd.resolution = 128;
odd.worldSize = 127.0f;
odd.seed = 3031u;
// Assez grande pour que des tuiles de niveau 2 et 3 soient INTERIEURES
// (chemin rapide de writeTerrainNodeVertices a plusieurs pas).
Heightmap::Params large;
large.resolution = 2049;
large.worldSize = 4096.0f;
large.amplitude = 900.0f;
large.seed = 3033u;
TerrainQuadtree::Params qparams;
qparams.nodeCells = 64;
bool identical = true;
bool positionsExact = true;
bool uvExact = true;
uint32_t nodesChecked = 0;
uint32_t fastNodes = 0;
uint32_t fastStrides = 0; // masque des pas couverts par le chemin rapide
for (const Heightmap::Params& hp : { even, odd, large }) {
const Heightmap heightmap(hp);
const TerrainQuadtree quadtree(heightmap, qparams);
const uint32_t verts = qparams.nodeCells + 1;
const uint32_t cells = heightmap.resolution() - 1;
const float origin = heightmap.worldCoord(0);
std::vector<TerrainVertex> written(static_cast<std::size_t>(verts) * verts);
for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) {
if (terrainNodeUsesFastPath(heightmap, quadtree, index)) {
++fastNodes;
fastStrides |= quadtree.node(index).stride;
}
for (const bool cached : { true, false }) {
const MeshData reference =
terrainNodeMeshData(heightmap, quadtree, index, false, cached);
writeTerrainNodeVertices(heightmap, quadtree, index, written.data(), cached);
for (std::size_t v = 0; v < written.size() && identical; ++v) {
const TerrainVertex expected = toTerrainVertex(reference.vertices[v]);
identical = std::memcmp(&expected, &written[v], sizeof(TerrainVertex)) == 0;
}
}
// Ce que terrain.vert recalcule a partir de gl_VertexIndex et de
// DrawItem::grid : memes indices ecretes, memes operations.
const TerrainQuadtree::Node& node = quadtree.node(index);
const MeshData reference = terrainNodeMeshData(heightmap, quadtree, index, false);
for (uint32_t v = 0; v < verts * verts; ++v) {
const uint32_t i = v % verts;
const uint32_t j = v / verts;
const uint32_t gx = std::min(node.ix0 + i * node.stride, cells);
const uint32_t gz = std::min(node.iz0 + j * node.stride, cells);
const uint32_t mx = std::min(node.ix0 + (i & ~1u) * node.stride, cells);
const uint32_t mz = std::min(node.iz0 + (j & ~1u) * node.stride, cells);
const Vertex& r = reference.vertices[v];
positionsExact = positionsExact &&
terrainGridCoord(origin, heightmap.spacing(), gx) == r.pos.x &&
terrainGridCoord(origin, heightmap.spacing(), gz) == r.pos.z &&
terrainGridCoord(origin, heightmap.spacing(), mx) == r.morphPos.x &&
terrainGridCoord(origin, heightmap.spacing(), mz) == r.morphPos.z;
uvExact = uvExact &&
static_cast<float>(gx) / static_cast<float>(cells) == r.uv.x &&
static_cast<float>(gz) / static_cast<float>(cells) == r.uv.y;
}
++nodesChecked;
}
}
check(nodesChecked > 400, "Tuiles : toutes les tuiles des trois grilles verifiees");
check(fastNodes > 0 && fastNodes < nodesChecked && (fastStrides & 0xFu) == 0xFu,
"Tuiles : chemin rapide ET chemin de reference exerces (pas 1, 2, 4 et 8)");
check(identical,
"Tuiles : writeTerrainNodeVertices == toTerrainVertex(reference), au bit pres");
check(positionsExact,
"Tuiles : x/z et cible de morphing recalcules depuis l'indice, au bit pres");
check(uvExact, "Tuiles : UV recalcule depuis l'indice de grille, au bit pres (CPU)");
const std::vector<uint32_t> topology = terrainNodeIndices(qparams.nodeCells);
check(*std::max_element(topology.begin(), topology.end()) <= 0xFFFFu,
"Tuiles : la topologie partagee tient en uint16");
}
// --- Terrain d'un seul bloc (--no-lod) ------------------------------------
{
Heightmap::Params hp;
hp.resolution = 97;
hp.worldSize = 96.0f;
hp.seed = 3032u;
const Heightmap heightmap(hp);
const MeshData reference = terrainMeshData(heightmap);
const TerrainGpuMesh gpu = terrainGpuMeshData(heightmap);
bool same = gpu.vertices.size() == reference.vertices.size() &&
gpu.indices == reference.indices;
for (std::size_t v = 0; v < gpu.vertices.size() && same; ++v) {
TerrainVertex expected = toTerrainVertex(reference.vertices[v]);
// Sans geomorphing, la cible est le sommet lui-meme (elle valait
// zero dans le format de 68 octets, et n'etait jamais lue).
expected.morphHeight = expected.height;
expected.morphNormal[0] = expected.normal[0];
expected.morphNormal[1] = expected.normal[1];
same = std::memcmp(&expected, &gpu.vertices[v], sizeof(TerrainVertex)) == 0;
}
check(same, "Bloc unique : terrainGpuMeshData == reference compactee, memes indices");
}
// --- RangeAllocator : la logique du pool, sans GPU ----------------------
{
RangeAllocator block(1 << 20);
struct Taken { uint64_t offset; uint64_t size; };
std::vector<Taken> taken;
bool aligned = true;
for (uint64_t k = 0; k < 40; ++k) {
const uint64_t size = 1000 + 777 * (k % 7);
const uint64_t offset = block.allocate(size, 256);
if (offset == RangeAllocator::kInvalid) { aligned = false; break; }
aligned = aligned && (offset % 256 == 0);
taken.push_back({ offset, size });
}
bool disjoint = true;
for (std::size_t a = 0; a < taken.size(); ++a) {
for (std::size_t b = a + 1; b < taken.size(); ++b) {
disjoint = disjoint && (taken[a].offset + taken[a].size <= taken[b].offset ||
taken[b].offset + taken[b].size <= taken[a].offset);
}
}
check(aligned && taken.size() == 40, "RangeAllocator : 40 plages alignees sur 256");
check(disjoint, "RangeAllocator : aucune plage n'en chevauche une autre");
// Un trou laisse par une plage liberee est reutilise par une demande de
// meme taille (le cas des tuiles, toutes de la meme taille).
const Taken hole = taken[10];
block.release(hole.offset, hole.size);
check(block.allocate(hole.size, 256) == hole.offset,
"RangeAllocator : un trou est reutilise par une demande de meme taille");
for (const Taken& t : taken) {
block.release(t.offset, t.size);
}
check(block.empty() && block.freeSpanCount() == 1 &&
block.largestFree() == block.capacity(),
"RangeAllocator : tout liberer refusionne le bloc en une seule plage");
check(block.allocate(block.capacity() + 1, 256) == RangeAllocator::kInvalid &&
block.allocate(16, 3) == RangeAllocator::kInvalid,
"RangeAllocator : demande trop grande ou alignement invalide refuses");
}
}
int main() {
std::printf("=== Tests logiques Vercora (headless, sans Vulkan) ===\n");
@@ -10890,6 +11167,7 @@ int main() {
testGrassMesh();
testGrassPhase18();
testTileMeshingIsThreadSafe();
testGpuFormatsPhase32();
testVegetationPlacement();
testGrassPlacement();
testInstanceLayout();
+249
Voir le fichier
@@ -0,0 +1,249 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
make_bench_zone.py — fabrique une zone PROXY de 25 km2 pour MESURER le moteur
sur une machine qui n'a pas les donnees LiDAR (session cloud, CI, nouveau poste).
PHASE 32. Les dalles LiDAR (data/lidar, plusieurs Go) et les .vchm qui en sont
tires ne sont pas versionnes ; seule l'orthophoto vercora_zone_ortho.vcto l'est.
Sans terrain de zone, le jeu retombe sur le terrain synthetique 128x128 : un
banc de mesure n'y exerce ni le streaming de 8 000 noeuds, ni la vegetation a
l'echelle, ni rien de ce qui pese reellement en memoire.
Ce script ecrit, dans assets/terrain/ (ignore par git, *.vchm) :
vercora_zone_1m.vchm 5001 x 5001 au pas de 1 m
vercora_zone_canopy.vchm couvert 0..1, 1001 x 1001 au pas de 5 m
vercora_zone_canopy_height.vchm hauteur de canopee (m)
vercora_zone_canopy_lowveg.vchm fraction de vegetation basse (F3)
vercora_zone_canopy_lowveg_height.vchm hauteur de vegetation basse (m)
CE QUI EST VRAI ET CE QUI NE L'EST PAS, sans detour :
- L'EMPRISE, la RESOLUTION, la georeference et la plage d'altitudes
(1029-2285 m) sont celles de la vraie zone : le quadtree, le streaming,
l'orthophoto (qui s'y applique, orthoMatchesTerrain passe) et tous les
budgets memoire travaillent donc a la vraie echelle.
- Le RELIEF est un bruit fractal (fBm + cretes, la recette de
Heightmap::Params), pas le Vercors.
- Le COUVERT est tire de la VRAIE orthophoto (indice de vert sur le niveau de
mipmap 2048 x 2048) : les arbres poussent la ou la photo montre de la foret,
mais sur un relief qui n'est pas le sien.
Les chiffres de MEMOIRE et de COUT obtenus sur cette zone sont donc
representatifs a l'ordre de grandeur et comparables ENTRE EUX (avant / apres
une optimisation) ; ils ne remplacent pas une mesure sur les vraies donnees.
python tools/make_bench_zone.py # ecrit dans assets/terrain/
python tools/make_bench_zone.py --force # ecrase des fichiers existants
Refuse d'ecraser un fichier existant sans --force : sur la machine de
developpement, ces noms sont ceux des VRAIES donnees.
Dependances : numpy.
"""
from __future__ import annotations
import argparse
import os
import struct
import sys
import time
import numpy as np
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TERRAIN_DIR = os.path.join(ROOT, "assets", "terrain")
ORTHO = os.path.join(TERRAIN_DIR, "vercora_zone_ortho.vcto")
# Emprise de la vraie zone (en-tete de vercora_zone_ortho.vcto).
ORIGIN_EAST = 899000.0
ORIGIN_NORTH = 6440000.0
EXTENT_M = 5000.0
EPSG = 2154
ALT_MIN = 1029.0
ALT_MAX = 2285.0
SEED = 20261013
def write_vchm(path: str, grid: np.ndarray, spacing: float, label: str,
absolute: bool) -> None:
"""Ecrit un .vchm version 1 (format : src/assets/TerrainFile.hpp)."""
grid = np.ascontiguousarray(grid, dtype="<f4")
n = grid.shape[0]
assert grid.shape == (n, n)
header = bytearray(120)
header[0:4] = b"VCHM"
struct.pack_into("<IIIf", header, 4, 1, n, n, spacing)
struct.pack_into("<dd", header, 24, ORIGIN_EAST, ORIGIN_NORTH)
struct.pack_into("<ffII", header, 40, float(grid.min()), float(grid.max()),
EPSG, 1 if absolute else 0)
raw = label.encode("ascii")[:64]
header[56:56 + len(raw)] = raw
with open(path, "wb") as f:
f.write(header)
f.write(grid.tobytes())
def smooth(t: np.ndarray) -> np.ndarray:
return t * t * (3.0 - 2.0 * t)
def value_noise(n: int, cells: int, rng: np.random.Generator) -> np.ndarray:
"""Bruit de valeur n x n a `cells` cellules par cote, interpolation
separable (d'abord le long de X pour chaque ligne du reseau, puis le long
de Z) : 3 operations par echantillon au lieu de 4 lectures + 3 lerps."""
lattice = rng.random((cells + 2, cells + 2), dtype=np.float32)
x = np.linspace(0.0, cells, n, dtype=np.float64)
i0 = np.minimum(np.floor(x).astype(np.int64), cells)
t = smooth((x - i0).astype(np.float32))
along_x = lattice[:, i0] * (1.0 - t) + lattice[:, i0 + 1] * t # (cells+2, n)
return along_x[i0, :] * (1.0 - t)[:, None] + along_x[i0 + 1, :] * t[:, None]
def fbm(n: int, base: int, octaves: int, ridged: bool, rng) -> np.ndarray:
total = np.zeros((n, n), dtype=np.float32)
norm = 0.0
amplitude = 1.0
cells = base
for _ in range(octaves):
octave = value_noise(n, cells, rng)
if ridged:
octave = 1.0 - np.abs(2.0 * octave - 1.0)
total += amplitude * octave
norm += amplitude
amplitude *= 0.5
cells *= 2
return total / norm
def make_relief(n: int) -> np.ndarray:
rng = np.random.default_rng(SEED)
soft = fbm(n, 3, 9, False, rng) ** 1.4
ridge = fbm(n, 3, 9, True, rng)
shaped = soft + (ridge * ridge - soft) * 0.6
# Barres rocheuses facon Vercors : une marche raide la ou un bruit tres
# large franchit un seuil. Sans elles le relief n'offrirait aucune paroi
# d'escalade (pente >= 0,84) ni de pierrier (0,60-0,84).
band = value_noise(n, 4, rng)
cliff = smooth(np.clip((band - 0.55) / 0.02, 0.0, 1.0))
shaped = shaped + 0.12 * cliff
lo, hi = float(shaped.min()), float(shaped.max())
return (ALT_MIN + (shaped - lo) / (hi - lo) * (ALT_MAX - ALT_MIN)).astype(np.float32)
def decode_bc1_level(path: str, level: int) -> np.ndarray:
"""Decode le niveau `level` d'un .vcto BC1 en RGB float [0,1]."""
with open(path, "rb") as f:
data = f.read()
if data[:4] != b"VCTO":
raise SystemExit(f"{path} n'est pas un .vcto")
width, height, mips, fmt = struct.unpack_from("<IIII", data, 8)
if fmt != 1:
raise SystemExit("orthophoto attendue en BC1")
offset = 128
for k in range(level):
w, h = max(1, width >> k), max(1, height >> k)
offset += ((w + 3) // 4) * ((h + 3) // 4) * 8
w, h = max(1, width >> level), max(1, height >> level)
bx, by = (w + 3) // 4, (h + 3) // 4
blocks = np.frombuffer(data, dtype="<u2", count=bx * by * 4, offset=offset)
blocks = blocks.reshape(by, bx, 4)
c0 = blocks[..., 0].astype(np.uint32)
c1 = blocks[..., 1].astype(np.uint32)
bits = blocks[..., 2].astype(np.uint32) | (blocks[..., 3].astype(np.uint32) << 16)
def rgb565(c):
r = ((c >> 11) & 31) / 31.0
g = ((c >> 5) & 63) / 63.0
b = (c & 31) / 31.0
return np.stack([r, g, b], axis=-1)
p0, p1 = rgb565(c0), rgb565(c1)
four = (c0 > c1)[..., None]
p2 = np.where(four, (2 * p0 + p1) / 3, (p0 + p1) / 2)
p3 = np.where(four, (p0 + 2 * p1) / 3, 0.0)
palette = np.stack([p0, p1, p2, p3], axis=2) # (by, bx, 4, 3)
out = np.zeros((by * 4, bx * 4, 3), dtype=np.float32)
for py in range(4):
for px in range(4):
idx = (bits >> (2 * (py * 4 + px))) & 3
texel = np.take_along_axis(palette, idx[..., None, None].repeat(3, -1),
axis=2)[:, :, 0, :]
out[py::4, px::4, :] = texel
return out[:h, :w]
def resample(image: np.ndarray, n: int) -> np.ndarray:
"""Echantillonne l'image (rangee du nord au sud) aux n x n points de grille
(coins compris), par moyenne d'une fenetre 3 x 3 autour du texel."""
h, w = image.shape[:2]
coords = np.linspace(0.0, 1.0, n)
ys = np.clip(np.round(coords * (h - 1)).astype(np.int64), 1, h - 2)
xs = np.clip(np.round(coords * (w - 1)).astype(np.int64), 1, w - 2)
acc = np.zeros((n, n) + image.shape[2:], dtype=np.float32)
for dy in (-1, 0, 1):
for dx in (-1, 0, 1):
acc += image[(ys + dy)[:, None], (xs + dx)[None, :]]
return acc / 9.0
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__.split("\n")[1])
parser.add_argument("--force", action="store_true",
help="ecraser des fichiers existants")
args = parser.parse_args()
names = {
"terrain": "vercora_zone_1m.vchm",
"cover": "vercora_zone_canopy.vchm",
"height": "vercora_zone_canopy_height.vchm",
"lowveg": "vercora_zone_canopy_lowveg.vchm",
"lowveg_height": "vercora_zone_canopy_lowveg_height.vchm",
}
paths = {k: os.path.join(TERRAIN_DIR, v) for k, v in names.items()}
existing = [p for p in paths.values() if os.path.exists(p)]
if existing and not args.force:
print("Refus : ces fichiers existent deja (vraies donnees ?) :")
for p in existing:
print(" " + p)
print("Relancer avec --force pour les ecraser.")
return 1
if not os.path.exists(ORTHO):
print(f"Orthophoto introuvable : {ORTHO}")
return 1
t0 = time.time()
relief = make_relief(5001)
write_vchm(paths["terrain"], relief, 1.0, "vercora_zone PROXY bench (relief fBm)", True)
print(f"terrain : {paths['terrain']} ({relief.min():.1f} .. {relief.max():.1f} m, "
f"{time.time() - t0:.1f} s)")
rgb = decode_bc1_level(ORTHO, 2) # 2048 x 2048, 2,44 m/texel
rgb5 = resample(rgb, 1001)
r, g, b = rgb5[..., 0], rgb5[..., 1], rgb5[..., 2]
lum = (r + g + b) / 3.0
exg = 2.0 * g - r - b
# Foret = sombre ET verte ; prairie = verte mais claire ; roche = grise.
green = np.clip(exg / 0.06, 0.0, 1.0)
dark = np.clip((0.45 - lum) / 0.18, 0.0, 1.0)
cover = np.clip(green * dark * 1.6, 0.0, 1.0).astype(np.float32)
rng = np.random.default_rng(SEED + 1)
tall = 14.0 + 16.0 * value_noise(1001, 40, rng)
canopy = np.where(cover > 0.15, tall * np.clip(cover * 1.5, 0.3, 1.0), 0.0)
shrub = np.clip(green * (1.0 - dark) * 0.35 + cover * (1.0 - cover) * 0.5, 0.0, 0.6)
lowveg = shrub.astype(np.float32)
lowveg_h = np.where(lowveg > 0.05, 0.6 + 3.6 * value_noise(1001, 60, rng), 0.0)
write_vchm(paths["cover"], cover, 5.0, "vercora_zone PROXY couvert (ortho)", False)
write_vchm(paths["height"], canopy.astype(np.float32), 5.0,
"vercora_zone PROXY canopee", False)
write_vchm(paths["lowveg"], lowveg, 5.0, "vercora_zone PROXY vegetation basse", False)
write_vchm(paths["lowveg_height"], lowveg_h.astype(np.float32), 5.0,
"vercora_zone PROXY h vegetation basse", False)
print(f"couvert : moyenne {cover.mean():.3f}, cellules > 0,5 : "
f"{(cover > 0.5).mean() * 100:.1f} % ; F3 moyenne {lowveg.mean():.3f}")
print(f"total {time.time() - t0:.1f} s")
return 0
if __name__ == "__main__":
sys.exit(main())