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/Window.cpp
src/core/Camera.cpp src/core/Camera.cpp
src/core/Paths.cpp src/core/Paths.cpp
src/core/ProcessMemory.cpp
src/assets/ObjLoader.cpp src/assets/ObjLoader.cpp
src/assets/Heightmap.cpp src/assets/Heightmap.cpp
src/assets/TerrainFile.cpp src/assets/TerrainFile.cpp
@@ -153,6 +154,7 @@ add_executable(vercora
src/editor/SceneFile.cpp src/editor/SceneFile.cpp
src/renderer/VulkanContext.cpp src/renderer/VulkanContext.cpp
src/renderer/VulkanBuffer.cpp src/renderer/VulkanBuffer.cpp
src/renderer/GpuBufferPool.cpp
src/renderer/Mesh.cpp src/renderer/Mesh.cpp
src/renderer/TerrainMesh.cpp src/renderer/TerrainMesh.cpp
src/renderer/TerrainNodeMesh.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_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. # VERCORA_DEBUG : active les validation layers uniquement en configuration Debug.
# GLM_FORCE_RADIANS : GLM travaille en radians (evite les surprises d'unites). # 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] # 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. # (et non [-1,1] comme OpenGL) -> indispensable pour un depth buffer correct.
target_compile_definitions(vercora PRIVATE target_compile_definitions(vercora PRIVATE
GLFW_INCLUDE_VULKAN GLFW_INCLUDE_VULKAN
GLFW_INCLUDE_NONE
GLM_FORCE_RADIANS GLM_FORCE_RADIANS
GLM_FORCE_DEPTH_ZERO_TO_ONE GLM_FORCE_DEPTH_ZERO_TO_ONE
$<$<CONFIG:Debug>:VERCORA_DEBUG> $<$<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-PHASE11.md`, `NOTES-PHASE12.md`, `NOTES-PHASE-VELO.md`,
`NOTES-PHASE-ESCALADE.md`, `NOTES-PHASE15.md`, `NOTES-PHASE16.md`, `NOTES-PHASE-ESCALADE.md`, `NOTES-PHASE15.md`, `NOTES-PHASE16.md`,
`NOTES-PHASE17.md`, `NOTES-PHASE18.md`, `NOTES-PHASE19.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. 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 ## 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** 2026-08-23 : **F3/F4 selectionnent l'objet pose suivant/precedent SANS viser**
(detail plus bas, section Phase 15). (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) ## 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 - **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 collision, catalogue, placement et serialisation sont deja agnostiques du
format. Compter un analyseur JSON, le conteneur `.glb`, les accesseurs et format. Compter un analyseur JSON, le conteneur `.glb`, les accesseurs et
l'aplatissement de la hierarchie de noeuds. 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 cout d'une tuile apres les optimisations exactes de cette phase, et
`terrainNodeMeshData` est deja PURE. Le seul obstacle est `terrainNodeMeshData` est deja PURE. Le seul obstacle est
`Renderer::addMesh`, qui doit rester sur le thread de rendu. `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 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 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. 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 de morphing plutot que position complete) : deux economies faciles, chiffrees
dans NOTES-PHASE10.md. Le partage de l'index buffer economiserait aussi dans NOTES-PHASE10.md. Le partage de l'index buffer economiserait aussi
98 Ko par tuile epinglee. 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 - 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 `precip.*.spv` ; teste depuis I: et OK. `dist\VercoraDemo` NON remplace (decision
utilisateur). `deploy_beta_to_desktop.ps1` est a revoir. 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 :** 3. **Écosystème Faune & Flore :**
- Comportements étendus de la faune (troupeaux, pâturage, cycles repos/déplacement selon l'heure météo). - 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. - 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 #version 450
// Meme bloc uniforme que les shaders du cube, avec un membre supplementaire en // Meme bloc uniforme que les shaders du cube, avec des membres supplementaires
// fin de bloc (terrain). Cote C++ il n'y a qu'une seule struct // en fin de bloc. Cote C++ il n'y a qu'une seule struct UniformBufferObject :
// UniformBufferObject : les shaders du cube declarent simplement une version // les shaders declarent chacun la version tronquee du bloc qui leur suffit, ce
// tronquee du bloc, ce qui est legal (la plage du descriptor peut etre plus // qui est legal (la plage du descriptor peut etre plus grande que le bloc
// grande que le bloc declare, jamais l'inverse). // declare, jamais l'inverse).
layout(binding = 0) uniform UniformBufferObject { layout(binding = 0) uniform UniformBufferObject {
mat4 view; mat4 view;
mat4 proj; mat4 proj;
@@ -14,39 +14,82 @@ layout(binding = 0) uniform UniformBufferObject {
// quels que soient les parametres de generation (et demain, les vraies // 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]). // altitudes LiDAR, qui seront en metres NGF et pas du tout dans [0,16]).
vec4 terrain; 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; } 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 // signature de layout, ce qui permet au Renderer de pousser la model matrix de
// la meme facon quel que soit le materiau. // la meme facon quel que soit le materiau.
// params.x = debut de la bande de geomorphing, params.y = fin, en metres depuis // 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 // la camera. Bande vide (y <= x) = pas de morphing : c'est le cas du terrain
// dessine d'un seul bloc (option --no-lod). // 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 { layout(push_constant) uniform PushConstants {
mat4 model; mat4 model;
vec4 params; vec4 params;
ivec4 grid;
} pc; } pc;
layout(location = 0) in vec3 inPosition; // PHASE 32 : 16 octets par sommet au lieu de 68 (renderer/GpuVertex.hpp,
layout(location = 1) in vec3 inColor; // TerrainVertex). Le buffer ne porte plus que ce qui ne se DEDUIT pas de
layout(location = 2) in vec3 inNormal; // l'indice du sommet : les deux altitudes et les deux normales (x et z en
// UV du sommet sur TOUT le terrain (0,0 au coin nord-ouest, 1,1 au sud-est), // snorm16, y reconstruit). Position horizontale, cible de morphing horizontale
// et non sur la tuile de quadtree : c'est ce qui rend la coordonnee continue // et UV sont recalcules ci-dessous ; la couleur de sommet valait toujours blanc.
// d'une tuile a l'autre et independante du niveau de detail. Voir layout(location = 0) in float inHeight;
// TerrainNodeMesh.cpp. PHASE 11 : desormais consomme, pour l'orthophoto. layout(location = 1) in float inMorphHeight;
layout(location = 3) in vec2 inUV; layout(location = 2) in vec2 inNormalXZ;
layout(location = 3) in vec2 inMorphNormalXZ;
// 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;
layout(location = 0) out vec3 fragTint; layout(location = 0) out vec3 fragTint;
layout(location = 1) out vec3 fragNormal; layout(location = 1) out vec3 fragNormal;
layout(location = 2) out vec3 fragWorldPos; layout(location = 2) out vec3 fragWorldPos;
layout(location = 3) out vec2 fragUV; 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() { 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) ------------------------------------------------ // --- Geomorphing (CDLOD) ------------------------------------------------
// La distance est mesuree sur la position NON MORPHEE : c'est ce qui garantit // 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 // 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 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); vec4 worldPos = pc.model * vec4(position, 1.0);
gl_Position = ubo.proj * ubo.view * worldPos; gl_Position = ubo.proj * ubo.view * worldPos;
fragWorldPos = worldPos.xyz; 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 // L'UV n'est PAS morphe. Il est une fonction affine de la position dans la
// la grille du terrain entier, donc la cible de morphing d'un sommet - qui // grille du terrain entier, donc la cible de morphing d'un sommet - qui est
// est un autre noeud de cette meme grille - a naturellement l'UV de sa // un autre noeud de cette meme grille - a naturellement l'UV de sa propre
// propre position. Interpoler entre les deux decalerait la photo par rapport // position. Interpoler entre les deux decalerait la photo par rapport au
// au relief pendant la transition de niveau, exactement ce qu'on cherche a // relief pendant la transition de niveau, exactement ce qu'on cherche a
// eviter. Le leger glissement de la texture qu'on pourrait attendre pendant // eviter. Le leger glissement de la texture qu'on pourrait attendre pendant
// un morph est en realite le comportement CORRECT : la surface se deforme, // un morph est en realite le comportement CORRECT : la surface se deforme,
// la photo reste accrochee a ses coordonnees geographiques. // la photo reste accrochee a ses coordonnees geographiques. Meme expression
fragUV = inUV; // 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 // Le terrain est genere DIRECTEMENT en espace monde et son DrawItem porte la
// matrice IDENTITE : mat3(model) est donc exact ici sans discussion. Il // 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 // Genere immediatement la grille par bruit fractal. Lance
// std::runtime_error si les parametres ne peuvent pas produire une surface // std::runtime_error si les parametres ne peuvent pas produire une surface
// (resolution < 2, taille <= 0, ...). // (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 // Adopte une grille DEJA CONSTRUITE, sans rien generer : c'est par ici
// qu'entrent les donnees LiDAR (voir assets/TerrainFile.hpp). // 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. // [0, resolution-1] : appeler avec ix = -1 renvoie la colonne 0.
float at(int64_t ix, int64_t iz) const; 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). // Position monde d'un echantillon (le long de X pour ix, de Z pour iz).
float worldCoord(uint32_t index) const; float worldCoord(uint32_t index) const;
+30 -8
Voir le fichier
@@ -57,7 +57,7 @@ double TextureData::metresPerTexel() const {
return 0.5 * (perX + perY); return 0.5 * (perX + perY);
} }
TextureData loadTextureFile(const std::string& path) { TextureData loadTextureFileHeader(const std::string& path) {
std::ifstream file(path, std::ios::binary); std::ifstream file(path, std::ios::binary);
if (!file) { if (!file) {
throw std::runtime_error("Texture : fichier introuvable ou illisible : " + path); 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."); ". 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" + logInfo("Texture : " + texture.label + " " + std::to_string(texture.width) + "x" +
std::to_string(texture.height) + ", " + std::to_string(mipLevels) + std::to_string(texture.height) + ", " + std::to_string(mipLevels) +
" mipmaps, " + " mipmaps, " +
@@ -164,4 +157,33 @@ TextureData loadTextureFile(const std::string& path) {
return texture; 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 } // namespace vercora
+21
Voir le fichier
@@ -1,6 +1,7 @@
#pragma once #pragma once
#include <cstdint> #include <cstdint>
#include <istream>
#include <string> #include <string>
#include <vector> #include <vector>
@@ -57,6 +58,12 @@ struct TextureData {
// journal de demarrage : c'est le chiffre qui dit si la texture est a la // journal de demarrage : c'est le chiffre qui dit si la texture est a la
// hauteur du niveau de detail du terrain. // hauteur du niveau de detail du terrain.
double metresPerTexel() const; 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 // Charge un .vcto. Lance std::runtime_error avec un message exploitable si le
@@ -65,6 +72,20 @@ struct TextureData {
// annonces, ...). // annonces, ...).
TextureData loadTextureFile(const std::string& path); 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 // 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 // c'est la seule formule qui lie les deux formats a leur taille, et que le
// chargeur ET les tests s'en servent. // 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/AssetCatalog.hpp"
#include "editor/EditorController.hpp" #include "editor/EditorController.hpp"
#include "core/Paths.hpp" #include "core/Paths.hpp"
#include "core/ProcessMemory.hpp"
#include "editor/EditorScene.hpp" #include "editor/EditorScene.hpp"
#include "editor/PlacedObject.hpp" #include "editor/PlacedObject.hpp"
#include "editor/SceneFile.hpp" #include "editor/SceneFile.hpp"
@@ -137,6 +138,20 @@ namespace {
// objets poses, eux, font partie du monde et sont affiches et solides dans le // objets poses, eux, font partie du monde et sont affiches et solides dans le
// jeu normal - c'est justement le point. // 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 : // Le terrain synthetique n'est PAS supprime, et pour deux raisons distinctes :
// il reste la scene de reference des tests (monde deterministe, arbres a // 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 // 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 sceneFileArgument;
std::string editorAssetsArgument; std::string editorAssetsArgument;
std::string sceneArgument; 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) { for (int i = 1; i < argc; ++i) {
const std::string argument = argv[i]; const std::string argument = argv[i];
if (argument == "--dump-world") { if (argument == "--dump-world") {
@@ -1029,6 +1065,24 @@ int main(int argc, char** argv) {
} }
} else if (argument.rfind("--ortho=", 0) == 0) { } else if (argument.rfind("--ortho=", 0) == 0) {
orthoArgument = argument.substr(std::strlen("--ortho=")); 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) { } else if (argument.rfind("--", 0) == 0) {
logWarn("Option inconnue, ignoree : " + argument); logWarn("Option inconnue, ignoree : " + argument);
} else if (sceneArgument.empty()) { } else if (sceneArgument.empty()) {
@@ -1163,7 +1217,11 @@ int main(int argc, char** argv) {
CompositeCollisionSolver worldSolver; CompositeCollisionSolver worldSolver;
MeshData sceneMesh; MeshData sceneMesh;
// PHASE 32 : le terrain d'un seul bloc (--no-lod) au format GPU compact.
TerrainGpuMesh sceneTerrain;
RenderOptions renderOptions; RenderOptions renderOptions;
renderOptions.forceStaging = forceStaging;
renderOptions.vsync = vsync;
Inventory inventory; Inventory inventory;
@@ -1183,7 +1241,10 @@ int main(int argc, char** argv) {
// produisait 25 M de sommets et 50 M de triangles cote CPU, // produisait 25 M de sommets et 50 M de triangles cote CPU,
// recopies ensuite sur le GPU. // recopies ensuite sur le GPU.
if (!dumpWorldOnly && !useLod) { 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() }; renderOptions.heightRange = { heightmap->minHeight(), heightmap->maxHeight() };
@@ -1265,8 +1326,19 @@ int main(int argc, char** argv) {
// nombre d'instances qui les utiliseront ensuite. // nombre d'instances qui les utiliseront ensuite.
// Avec le quadtree, il n'y a pas de geometrie de scene unique : chaque // Avec le quadtree, il n'y a pas de geometrie de scene unique : chaque
// tuile est enregistree et liberee par le TerrainStreamer. // tuile est enregistree et liberee par le TerrainStreamer.
const MeshHandle sceneMeshHandle = MeshHandle sceneMeshHandle =
sceneMesh.empty() ? kInvalidMesh : renderer.addMesh(sceneMesh); 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 // 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); " -i data/ortho -o " + orthoPath);
} else { } else {
try { 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)) { if (orthoMatchesTerrain(ortho, *heightmap)) {
renderer.setTerrainTexture(ortho); renderer.setTerrainTextureFromFile(ortho, orthoPath);
renderer.setOrthoMix(1.0f); renderer.setOrthoMix(1.0f);
groundDetailPattern = ortho.metresPerTexel(); groundDetailPattern = static_cast<float>(ortho.metresPerTexel());
logInfo("Orthophoto : " + logInfo("Orthophoto : " +
std::to_string(ortho.metresPerTexel()) + std::to_string(ortho.metresPerTexel()) +
" m/texel pour un terrain au pas de " + " 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 // fenetre, dont la Phase 18 a montre qu'il varie de ~15 % entre deux
// runs identiques. Chargement exclu : il precede la boucle. // runs identiques. Chargement exclu : il precede la boucle.
const auto loopStart = ProfileClock::now(); 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()) { while (!window.shouldClose()) {
window.pollEvents(); 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 double now = glfwGetTime();
const float deltaTime = static_cast<float>(now - lastTime); const float deltaTime = static_cast<float>(now - lastTime);
lastTime = now; lastTime = now;
@@ -2301,6 +2395,9 @@ int main(int argc, char** argv) {
// demarrage, donc la valeur reste petite et n'use pas la precision // demarrage, donc la valeur reste petite et n'use pas la precision
// d'un float, contrairement a une horloge absolue. // d'un float, contrairement a une horloge absolue.
const float elapsedSeconds = static_cast<float>(now); 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) ------------------------ // --- Bascule du MODE EDITEUR (PHASE 15) ------------------------
// Traitee AVANT camera.update : entrer en edition change le mode et // 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); frameProfile.streamingMicros += profileMicros(tf1, tf2);
} else if (sceneMeshHandle != kInvalidMesh) { } else if (sceneMeshHandle != kInvalidMesh) {
// Terrain d'un seul bloc : sommets deja en coordonnees monde // Terrain d'un seul bloc : sommets deja en coordonnees monde
// -> matrice identite, et pas de bande de morphing. // -> matrice identite, et pas de bande de morphing. PHASE 32 :
drawItems.push_back({ sceneMeshHandle, glm::mat4(1.0f), // une seule "tuile" qui couvre toute la grille au pas 1.
Material::Terrain }); 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()) { 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.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage; item.material = Material::Foliage;
// Amplitude d'ondulation NULLE : un tronc ne plie pas. // 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); instancedItems.push_back(item);
}; };
pushTrees(treeInstances, sceneryTreeMeshHandle); pushTrees(treeInstances, sceneryTreeMeshHandle);
@@ -3703,7 +3804,7 @@ int main(int argc, char** argv) {
// seul materiau qui s'en sert : un arbre pousse 0 et // seul materiau qui s'en sert : un arbre pousse 0 et
// traverse le meme pipeline, inchange. // traverse le meme pipeline, inchange.
item.params = { vegetation->params().grassSway, item.params = { vegetation->params().grassSway,
elapsedSeconds, 0.0f, animationSeconds, 0.0f,
vegetation->params().grassCutout }; vegetation->params().grassCutout };
instancedItems.push_back(item); instancedItems.push_back(item);
} }
@@ -3734,7 +3835,7 @@ int main(int argc, char** argv) {
// pas par un masque - ces plantes sont peu nombreuses, // pas par un masque - ces plantes sont peu nombreuses,
// le budget de sommets n'est pas le sujet. // le budget de sommets n'est pas le sujet.
item.params = { 0.35f * vegetation->params().grassSway, item.params = { 0.35f * vegetation->params().grassSway,
elapsedSeconds, 0.0f, 0.0f }; animationSeconds, 0.0f, 0.0f };
instancedItems.push_back(item); instancedItems.push_back(item);
} }
} }
@@ -3760,7 +3861,7 @@ int main(int argc, char** argv) {
item.instances = instances.data(); item.instances = instances.data();
item.count = static_cast<uint32_t>(instances.size()); item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage; 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); instancedItems.push_back(item);
}; };
pushRocks(boulderInstances, boulderMeshHandle); pushRocks(boulderInstances, boulderMeshHandle);
@@ -3786,7 +3887,7 @@ int main(int argc, char** argv) {
item.instances = instances.data(); item.instances = instances.data();
item.count = static_cast<uint32_t>(instances.size()); item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage; item.material = Material::Foliage;
item.params = { sway, elapsedSeconds, 0.0f, 0.0f }; item.params = { sway, animationSeconds, 0.0f, 0.0f };
instancedItems.push_back(item); instancedItems.push_back(item);
}; };
pushBushes(shrubInstances, shrubMeshHandle, 0.04f); pushBushes(shrubInstances, shrubMeshHandle, 0.04f);
@@ -3846,7 +3947,7 @@ int main(int argc, char** argv) {
renderer.setWeatherVisuals(visuals.fogColor, visuals.fogDensityPerMeter, renderer.setWeatherVisuals(visuals.fogColor, visuals.fogDensityPerMeter,
visuals.precipitation, visuals.snow, visuals.precipitation, visuals.snow,
visuals.fallVelocity, visuals.groundDarkening, visuals.fallVelocity, visuals.groundDarkening,
elapsedSeconds); animationSeconds);
frameProfile.weatherVisualsMicros += profileMicros(tw0, ProfileClock::now()); frameProfile.weatherVisualsMicros += profileMicros(tw0, ProfileClock::now());
// Journal BORNE PAR LE TEMPS (lecon de la Phase 24 : "sur // 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. // S'assurer que le GPU a fini avant de detruire quoi que ce soit.
renderer.waitIdle(); 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) { if (frameProfile.frames > 0) {
const auto per = [&](uint64_t total) { const auto per = [&](uint64_t total) {
const double value = static_cast<double>(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 - // profondeur. Une force nulle - le cas de tous les DrawItem du jeu -
// laisse le rendu strictement identique a celui d'avant la Phase 15. // laisse le rendu strictement identique a celui d'avant la Phase 15.
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f}; 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. // 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 // melanger obligerait a garder `mesh` et `material` - inutiles au GPU - dans un
// budget de push constants qui ne fait que 128 octets garantis. // 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 // 96 octets depuis la Phase 32 (le bloc `grid` du terrain) : toujours en
// maxPushConstantsSize. // dessous des 128 garantis par la spec Vulkan pour maxPushConstantsSize.
struct DrawItemPush { struct DrawItemPush {
glm::mat4 model{1.0f}; glm::mat4 model{1.0f};
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.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 // 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 "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 { namespace vercora {
Mesh::Mesh(VulkanContext& context, Mesh::Mesh(GpuBufferPool& pool, VertexLayout layout,
BufferUploader& uploader, const GpuRange& vertices, uint32_t vertexCount,
const MeshData& data, const GpuRange& indices, VkIndexType indexType, uint32_t indexCount,
bool log) { bool ownsIndices)
// --- Validation AVANT toute allocation Vulkan --------------------------- : pool_(pool), layout_(layout), vertices_(vertices), indices_(indices),
// Un index hors limites ne produit pas d'erreur a la creation du buffer : indexType_(indexType), vertexCount_(vertexCount), indexCount_(indexCount),
// il se manifesterait au draw, sous forme de lecture hors du vertex buffer ownsIndices_(ownsIndices) {}
// (comportement indefini cote GPU). Mieux vaut refuser ici, avec un message
// qui dit quoi. Mesh::~Mesh() {
if (data.vertices.empty()) { pool_.release(vertices_);
throw std::runtime_error("Mesh vide : aucun sommet (" + data.name + ")."); 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 { void Mesh::draw(VkCommandBuffer commandBuffer) const {
+46 -46
Voir le fichier
@@ -1,55 +1,50 @@
#pragma once #pragma once
#include "renderer/GpuBufferPool.hpp"
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include <cstdint> #include <cstdint>
#include <memory>
namespace vercora { namespace vercora {
class VulkanContext; // PHASE 32. Format des sommets d'un maillage, tel que son pipeline les lit
class VulkanBuffer; // (voir renderer/GpuVertex.hpp). Un maillage de terrain ne peut etre dessine
class BufferUploader; // qu'avec Material::Terrain, un maillage d'objet qu'avec les autres : le
struct MeshData; // 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 // Un maillage pret a etre dessine : une plage de sommets et une plage d'indices
// leurs compteurs. Interchangeable par construction : le Renderer ne sait pas // dans les blocs partages du GpuBufferPool, et leurs compteurs.
// d'ou vient la geometrie (fichier .obj, cube code en dur, terrain genere plus
// tard), il recoit un Mesh et l'affiche.
// //
// L'upload passe par VulkanBuffer (staging host-visible -> device-local), le // PHASE 32 : un Mesh ne possede PLUS de buffer Vulkan. Il possede des PLAGES,
// meme chemin que la Phase 1, factorise ici en une seule fonction. // 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 // Le televersement (conversion des sommets, ecriture directe ou staging) est
// BufferUploader (le Renderer), qui l'enregistre en tete du command buffer de la // fait par le Renderer avant de construire le Mesh : cette classe ne fait que
// frame suivante ; le constructeur revient des que la geometrie a ete recopiee // decrire et dessiner.
// 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.
class Mesh { class Mesh {
public: public:
// `uploader` recoit les copies staging -> device-local. Il doit vivre plus Mesh(GpuBufferPool& pool, VertexLayout layout,
// longtemps que la frame en cours (en pratique c'est le Renderer lui-meme). const GpuRange& vertices, uint32_t vertexCount,
// Lance std::runtime_error si la geometrie est vide ou incoherente. const GpuRange& indices, VkIndexType indexType, uint32_t indexCount,
// `log` a false pour les geometries creees en masse (les tuiles du quadtree bool ownsIndices);
// 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(); ~Mesh();
Mesh(const Mesh&) = delete; Mesh(const Mesh&) = delete;
Mesh& operator=(const Mesh&) = delete; Mesh& operator=(const Mesh&) = delete;
// Lie les buffers du mesh au command buffer courant. // Emet le draw indexe. A appeler apres avoir lie les plages du maillage
void bind(VkCommandBuffer commandBuffer) const; // (Renderer::recordCommandBuffer, qui evite les liaisons redondantes), les
// descriptor sets et le pipeline.
// Emet le draw indexe. A appeler apres bind() et apres avoir lie les
// descriptor sets / le pipeline.
void draw(VkCommandBuffer commandBuffer) const; void draw(VkCommandBuffer commandBuffer) const;
// PHASE 11 : meme dessin, repete `instanceCount` fois. Les instances lisent // PHASE 11 : meme dessin, repete `instanceCount` fois. Les instances lisent
@@ -60,22 +55,27 @@ public:
uint32_t vertexCount() const { return vertexCount_; } uint32_t vertexCount() const { return vertexCount_; }
uint32_t indexCount() const { return indexCount_; } 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: private:
// Cree un buffer device-local et CONFIE a l'uploader la copie depuis un GpuBufferPool& pool_;
// staging temporaire. Commun au vertex buffer et a l'index buffer. VertexLayout layout_ = VertexLayout::Object;
static std::unique_ptr<VulkanBuffer> createDeviceLocalBuffer( GpuRange vertices_;
VulkanContext& context, GpuRange indices_;
BufferUploader& uploader, VkIndexType indexType_ = VK_INDEX_TYPE_UINT32;
const void* data,
VkDeviceSize size,
VkBufferUsageFlags usage);
std::unique_ptr<VulkanBuffer> vertexBuffer_;
std::unique_ptr<VulkanBuffer> indexBuffer_;
uint32_t vertexCount_ = 0; uint32_t vertexCount_ = 0;
uint32_t indexCount_ = 0; uint32_t indexCount_ = 0;
bool ownsIndices_ = true;
}; };
} // namespace vercora } // 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 }; const std::array<VkPipelineShaderStageCreateInfo, 2> stages = { vertStage, fragStage };
// Vertex input : un binding entrelace, et autant d'attributs que le vertex // Vertex input : un binding entrelace, au format de la famille de shaders
// shader en consomme reellement - quatre (pos, color, normal, uv) pour les // (PHASE 32, voir renderer/GpuVertex.hpp) - ObjectVertex pour les objets
// objets, six pour le terrain, dont la cible de geomorphing. Le STRIDE, lui, // et la vegetation, TerrainVertex pour le terrain.
// reste toujours sizeof(Vertex) : le format de sommet cote C++ est unique. const VkVertexInputBindingDescription bindingDescription =
const auto bindingDescription = vertexBindingDescription(); shaders.terrainVertexLayout ? terrainBindingDescription()
const auto attributeDescriptions = vertexAttributeDescriptions(); : objectBindingDescription();
const uint32_t attributeCount = shaders.usesMorphAttributes const std::array<VkVertexInputAttributeDescription, 4> attributeDescriptions =
? static_cast<uint32_t>(attributeDescriptions.size()) shaders.terrainVertexLayout ? terrainAttributeDescriptions()
: 4u; : objectAttributeDescriptions();
// PHASE 11 : un materiau instancie decrit DEUX bindings (sommets et // PHASE 11 : un materiau instancie decrit DEUX bindings (sommets et
// instances) et concatene leurs attributs. Les tableaux sont construits ici // 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<VkVertexInputBindingDescription> bindings{ bindingDescription };
std::vector<VkVertexInputAttributeDescription> attributes( 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. // PHASE 27 : une passe plein ecran ne lit AUCUN buffer de sommets.
if (shaders.fullscreenOverlay) { if (shaders.fullscreenOverlay) {
@@ -99,6 +99,14 @@ Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayo
rasterizer.lineWidth = 1.0f; rasterizer.lineWidth = 1.0f;
rasterizer.cullMode = VK_CULL_MODE_NONE; // pas de culling : triangle toujours visible rasterizer.cullMode = VK_CULL_MODE_NONE; // pas de culling : triangle toujours visible
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE; 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; rasterizer.depthBiasEnable = VK_FALSE;
VkPipelineMultisampleStateCreateInfo multisampling{}; VkPipelineMultisampleStateCreateInfo multisampling{};
+30 -14
Voir le fichier
@@ -14,22 +14,20 @@ struct ShaderSet {
std::string vertexSpv; std::string vertexSpv;
std::string fragmentSpv; std::string fragmentSpv;
// true si le vertex shader consomme les attributs de geomorphing // true si le vertex shader lit le format de sommet du TERRAIN
// (locations 4 et 5, voir Vertex.hpp). Seul terrain.vert le fait. // (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 // PHASE 32 : jusqu'ici ce drapeau (usesMorphAttributes) ne faisait que
// le vertex input un attribut qu'aucun shader ne lit fait emettre aux // TRONQUER la description d'un format unique de 68 octets, pour ne pas
// couches de validation "Vertex attribute at location 4 not consumed by // declarer aux shaders d'objets les attributs de morphing qu'ils ne lisent
// vertex shader", et le contrat du projet est zero message de validation. Le // pas (zero message de validation). Les deux familles ont desormais chacune
// format de sommet reste unique cote C++ ; c'est seulement sa DESCRIPTION au // leur format, et les octets inutiles ont quitte les buffers eux-memes.
// pipeline qui est tronquee pour les materiaux qui n'en lisent qu'une partie bool terrainVertexLayout = false;
// (ce que Vulkan autorise : un binding peut avoir un stride plus grand que
// la somme des attributs decrits).
bool usesMorphAttributes = false;
// PHASE 11. true si le pipeline doit decrire le second binding de sommets, // PHASE 11. true si le pipeline doit decrire le second binding de sommets,
// cadence par instance (voir VertexFormat.hpp). Meme raisonnement que // cadence par instance (voir VertexFormat.hpp). C'est une CORRECTION, pas
// usesMorphAttributes : c'est une CORRECTION, pas une optimisation. Decrire // une optimisation (zero message de validation). Decrire
// un binding d'instances a un pipeline non instancie obligerait a lier un // 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 // 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. // 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 // fabrique un triangle couvrant a partir de gl_VertexIndex), pas de test
// ni d'ecriture de profondeur, melange par alpha. // ni d'ecriture de profondeur, melange par alpha.
bool fullscreenOverlay = false; 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 // 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" }; inline const ShaderSet kObjectShaders{ "cube.vert.spv", "cube.frag.spv" };
// Shaders de la Phase 4 : coloration par altitude et par pente + Blinn-Phong. // 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). // 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. // 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 "renderer/Renderer.hpp"
#include "assets/DetailNoise.hpp" #include "assets/DetailNoise.hpp"
#include "assets/TextureFile.hpp"
#include "core/Camera.hpp" #include "core/Camera.hpp"
#include "core/Logger.hpp" #include "core/Logger.hpp"
@@ -18,13 +19,35 @@
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cstdio>
#include <cstring> #include <cstring>
#include <fstream>
#include <stdexcept> #include <stdexcept>
namespace vercora { namespace vercora {
namespace { 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 // 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 // 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"). // ("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, Renderer::Renderer(VulkanContext& context, Window& window,
const RenderOptions& options) const RenderOptions& options)
: context_(context), window_(window), options_(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) createCommandPool(); // requis avant les buffers (transferts staging)
@@ -88,6 +128,15 @@ Renderer::Renderer(VulkanContext& context, Window& window,
Renderer::~Renderer() { Renderer::~Renderer() {
VkDevice device = context_.device(); 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_) { for (VkSemaphore s : imageAvailableSemaphores_) {
vkDestroySemaphore(device, s, nullptr); vkDestroySemaphore(device, s, nullptr);
} }
@@ -116,32 +165,248 @@ void Renderer::waitIdle() const {
vkDeviceWaitIdle(context_.device()); vkDeviceWaitIdle(context_.device());
} }
MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) { MeshHandle Renderer::registerMesh(std::unique_ptr<Mesh> mesh) {
// 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);
++liveMeshCount_; ++liveMeshCount_;
if (!freeMeshSlots_.empty()) { if (!freeMeshSlots_.empty()) {
const MeshHandle handle = freeMeshSlots_.back(); const MeshHandle handle = freeMeshSlots_.back();
freeMeshSlots_.pop_back(); freeMeshSlots_.pop_back();
meshes_[handle] = std::move(mesh); meshes_[handle] = std::move(mesh);
return handle; return handle;
} }
meshes_.push_back(std::move(mesh)); meshes_.push_back(std::move(mesh));
return static_cast<MeshHandle>(meshes_.size() - 1); 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) { void Renderer::removeMesh(MeshHandle handle) {
if (handle >= meshes_.size() || !meshes_[handle]) { if (handle >= meshes_.size() || !meshes_[handle]) {
return; // deja libere, ou poignee invalide : ne rien faire est sans risque 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) // 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 // mais ses plages de geometrie survivent le temps que les frames deja
// aient fini de les lire. Voir le commentaire de declaration. // soumises aient fini de les lire. Voir le commentaire de declaration.
retiredMeshes_.push_back({ std::move(meshes_[handle]), kMaxFramesInFlight + 1 }); retiredMeshes_.push_back({ std::move(meshes_[handle]), kMaxFramesInFlight + 1 });
freeMeshSlots_.push_back(handle); freeMeshSlots_.push_back(handle);
--liveMeshCount_; --liveMeshCount_;
@@ -358,6 +623,26 @@ void Renderer::setTerrainTexture(const TextureData& data) {
" Mo sur le GPU."); " 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) { void Renderer::setOrthoMix(float mix) {
options_.orthoMix = std::clamp(mix, 0.0f, 1.0f); 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.precip = precip_;
ubo.fall = fall_; ubo.fall = fall_;
ubo.detail = detail_; ubo.detail = detail_;
ubo.terrainGrid = terrainGrid_;
std::memcpy(uniformBuffers_[frameIndex]->mapped(), &ubo, sizeof(ubo)); 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 // - 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 // qu'aux tuiles pas encore CONSTRUITES (budget), pas a une latence de
// transfert. // 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) { if (!staging || destination == VK_NULL_HANDLE) {
return; return;
} }
PendingCopy copy; PendingCopy copy;
copy.size = staging->size(); copy.size = staging->size();
copy.destination = destination; copy.destination = destination;
copy.destinationOffset = destinationOffset;
copy.staging = std::move(staging); copy.staging = std::move(staging);
stagingBytesInFlight_ += static_cast<std::size_t>(copy.size); stagingBytesInFlight_ += static_cast<std::size_t>(copy.size);
pendingCopies_.push_back(std::move(copy)); pendingCopies_.push_back(std::move(copy));
@@ -565,8 +853,10 @@ void Renderer::flushCopiesNow() {
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(commandBuffer, &beginInfo); vkBeginCommandBuffer(commandBuffer, &beginInfo);
recordCopyAfterReadBarrier(commandBuffer);
for (const PendingCopy& copy : pendingCopies_) { for (const PendingCopy& copy : pendingCopies_) {
VkBufferCopy region{}; VkBufferCopy region{};
region.dstOffset = copy.destinationOffset;
region.size = copy.size; region.size = copy.size;
vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination, vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination,
1, &region); 1, &region);
@@ -603,8 +893,10 @@ void Renderer::recordPendingCopies(VkCommandBuffer commandBuffer) {
return; return;
} }
recordCopyAfterReadBarrier(commandBuffer);
for (PendingCopy& copy : pendingCopies_) { for (PendingCopy& copy : pendingCopies_) {
VkBufferCopy region{}; VkBufferCopy region{};
region.dstOffset = copy.destinationOffset;
region.size = copy.size; region.size = copy.size;
vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination, vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination,
1, &region); 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 // 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" // 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. // 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; 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) { for (const DrawItem& item : items) {
if (item.material != material) { 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. // un pointeur nul). Signaler serait bruyant a 60 Hz.
continue; continue;
} }
if (meshes_[item.mesh]->layout() != expectedLayout) {
continue; // meme raison : le GPU lirait des octets d'un autre format
}
if (!pipelineBound) { if (!pipelineBound) {
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
@@ -723,17 +1065,17 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
pipelineBound = true; 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, // pousses d'un seul coup : ils sont contigus dans DrawItemPush,
// dont le layout reproduit exactement le bloc push_constant des // dont le layout reproduit exactement le bloc push_constant des
// shaders (voir DrawItem.hpp). // 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(), vkCmdPushConstants(commandBuffer, pipelines_[m]->layout(),
VK_SHADER_STAGE_VERTEX_BIT, 0, VK_SHADER_STAGE_VERTEX_BIT, 0,
static_cast<uint32_t>(sizeof(DrawItemPush)), &push); static_cast<uint32_t>(sizeof(DrawItemPush)), &push);
const Mesh& mesh = *meshes_[item.mesh]; const Mesh& mesh = *meshes_[item.mesh];
mesh.bind(commandBuffer); bindMesh(mesh);
mesh.draw(commandBuffer); mesh.draw(commandBuffer);
} }
@@ -746,7 +1088,8 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
if (item.material != material || item.count == 0) { if (item.material != material || item.count == 0) {
continue; continue;
} }
if (item.mesh >= meshes_.size() || !meshes_[item.mesh]) { if (item.mesh >= meshes_.size() || !meshes_[item.mesh] ||
meshes_[item.mesh]->layout() != expectedLayout) {
continue; continue;
} }
@@ -765,7 +1108,7 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
static_cast<uint32_t>(sizeof(DrawItemPush)), &push); static_cast<uint32_t>(sizeof(DrawItemPush)), &push);
const Mesh& mesh = *meshes_[item.mesh]; const Mesh& mesh = *meshes_[item.mesh];
mesh.bind(commandBuffer); bindMesh(mesh);
// Binding 1 : la tranche du buffer d'instances qui appartient a cet // Binding 1 : la tranche du buffer d'instances qui appartient a cet
// objet. L'offset a ete calcule par uploadInstances, dans le meme // objet. L'offset a ete calcule par uploadInstances, dans le meme
+106 -2
Voir le fichier
@@ -1,6 +1,9 @@
#pragma once #pragma once
#include "renderer/DrawItem.hpp" #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/Pipeline.hpp" // pour ShaderSet
#include "renderer/VulkanBuffer.hpp" // pour BufferUploader #include "renderer/VulkanBuffer.hpp" // pour BufferUploader
@@ -11,6 +14,8 @@
#include <array> #include <array>
#include <cmath> #include <cmath>
#include <memory> #include <memory>
#include <string>
#include <unordered_map>
#include <vector> #include <vector>
namespace vercora { namespace vercora {
@@ -19,7 +24,6 @@ class VulkanContext;
class Window; class Window;
class SwapChain; class SwapChain;
class Camera; class Camera;
class Mesh;
class Texture; class Texture;
struct MeshData; struct MeshData;
struct TextureData; struct TextureData;
@@ -49,6 +53,17 @@ struct RenderOptions {
// deux se recouvrent bien. Sans texture chargee, la valeur est ignoree (le // deux se recouvrent bien. Sans texture chargee, la valeur est ignoree (le
// binding pointe alors sur un texel blanc). // binding pointe alors sur un texel blanc).
float orthoMix = 0.0f; 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 // Orchestre le rendu : geometries enregistrees, UBO/descriptors, command
@@ -85,6 +100,48 @@ public:
// toute autre information. // toute autre information.
MeshHandle addMesh(const MeshData& meshData, bool log = true); 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 // Libere une geometrie et rend sa poignee reutilisable. Indispensable depuis
// la Phase 10 : le streaming par tuiles cree et detruit des maillages en // la Phase 10 : le streaming par tuiles cree et detruit des maillages en
// permanence, alors que jusque-la une geometrie enregistree vivait aussi // permanence, alors que jusque-la une geometrie enregistree vivait aussi
@@ -111,6 +168,12 @@ public:
// coloration procedurale est visible. // coloration procedurale est visible.
void setTerrainTexture(const TextureData& data); 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). // Bascule coloration procedurale <-> orthophoto (voir RenderOptions).
// Sans effet visible si aucune texture n'a ete chargee. // Sans effet visible si aucune texture n'a ete chargee.
void setOrthoMix(float mix); void setOrthoMix(float mix);
@@ -233,7 +296,7 @@ public:
// garanti par construction - le seul appelant est addMesh, et removeMesh // garanti par construction - le seul appelant est addMesh, et removeMesh
// DIFFERE la destruction des buffers de kMaxFramesInFlight + 1 frames. // DIFFERE la destruction des buffers de kMaxFramesInFlight + 1 frames.
void enqueueCopy(std::unique_ptr<VulkanBuffer> staging, 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. // Octets de staging en attente d'enregistrement + en attente d'execution.
// Sert au journal de diagnostic du streaming. // 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 precip_{0.0f, 0.0f, 0.0f, 0.0f};
glm::vec4 fall_{0.0f, -6.5f, 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 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; static constexpr int kMaxFramesInFlight = 2;
@@ -306,12 +370,51 @@ private:
void uploadInstances(const std::vector<InstancedDrawItem>& instanced); void uploadInstances(const std::vector<InstancedDrawItem>& instanced);
void recreateSwapChain(); 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_; VulkanContext& context_;
Window& window_; Window& window_;
RenderOptions options_; RenderOptions options_;
std::unique_ptr<SwapChain> swapChain_; 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 // 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 : // partagent le meme descriptor set layout et le meme push constant range :
// seuls les shaders different. // seuls les shaders different.
@@ -348,6 +451,7 @@ private:
struct PendingCopy { struct PendingCopy {
std::unique_ptr<VulkanBuffer> staging; std::unique_ptr<VulkanBuffer> staging;
VkBuffer destination = VK_NULL_HANDLE; VkBuffer destination = VK_NULL_HANDLE;
VkDeviceSize destinationOffset = 0;
VkDeviceSize size = 0; VkDeviceSize size = 0;
}; };
std::vector<PendingCopy> pendingCopies_; std::vector<PendingCopy> pendingCopies_;
+17 -16
Voir le fichier
@@ -26,8 +26,8 @@ const char* presentModeName(VkPresentModeKHR mode) {
} // namespace } // namespace
SwapChain::SwapChain(VulkanContext& context, Window& window) SwapChain::SwapChain(VulkanContext& context, Window& window, bool vsync)
: context_(context), window_(window) { : context_(context), window_(window), vsync_(vsync) {
// Le format de profondeur est fixe une fois pour toutes (il ne depend pas de // 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. // la taille) : le render pass, cree une seule fois, s'y refere.
depthFormat_ = context_.findDepthFormat(); depthFormat_ = context_.findDepthFormat();
@@ -66,10 +66,7 @@ void SwapChain::cleanupSizeDependent() {
vkDestroyImage(device, depthImage_, nullptr); vkDestroyImage(device, depthImage_, nullptr);
depthImage_ = VK_NULL_HANDLE; depthImage_ = VK_NULL_HANDLE;
} }
if (depthImageMemory_ != VK_NULL_HANDLE) { context_.freeMemory(depthAllocation_);
vkFreeMemory(device, depthImageMemory_, nullptr);
depthImageMemory_ = VK_NULL_HANDLE;
}
for (VkFramebuffer fb : framebuffers_) { for (VkFramebuffer fb : framebuffers_) {
vkDestroyFramebuffer(device, fb, nullptr); vkDestroyFramebuffer(device, fb, nullptr);
@@ -113,6 +110,16 @@ VkPresentModeKHR SwapChain::choosePresentMode(
// FIFO : seul mode dont Vulkan garantit la presence. Fallback ultime. // FIFO : seul mode dont Vulkan garantit la presence. Fallback ultime.
// A rebasculer sur MAILBOX/FIFO quand le jeu sera jouable : le tearing n'est // A rebasculer sur MAILBOX/FIFO quand le jeu sera jouable : le tearing n'est
// acceptable que pour du profilage. // 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, for (VkPresentModeKHR wanted : { VK_PRESENT_MODE_IMMEDIATE_KHR,
VK_PRESENT_MODE_MAILBOX_KHR }) { VK_PRESENT_MODE_MAILBOX_KHR }) {
if (std::find(modes.begin(), modes.end(), wanted) != modes.end()) { if (std::find(modes.begin(), modes.end(), wanted) != modes.end()) {
@@ -342,16 +349,10 @@ void SwapChain::createDepthResources() {
VkMemoryRequirements memRequirements{}; VkMemoryRequirements memRequirements{};
vkGetImageMemoryRequirements(device, depthImage_, &memRequirements); vkGetImageMemoryRequirements(device, depthImage_, &memRequirements);
VkMemoryAllocateInfo allocInfo{}; // PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; depthAllocation_ = context_.allocateMemory(memRequirements,
allocInfo.allocationSize = memRequirements.size; VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
allocInfo.memoryTypeIndex = context_.findMemoryType( vkBindImageMemory(device, depthImage_, depthAllocation_.memory, 0);
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);
VkImageViewCreateInfo viewInfo{}; VkImageViewCreateInfo viewInfo{};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+7 -2
Voir le fichier
@@ -1,5 +1,7 @@
#pragma once #pragma once
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include <vector> #include <vector>
@@ -15,7 +17,9 @@ class Window;
// pas), ce qui evite d'invalider le pipeline graphique. // pas), ce qui evite d'invalider le pipeline graphique.
class SwapChain { class SwapChain {
public: 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();
SwapChain(const SwapChain&) = delete; SwapChain(const SwapChain&) = delete;
@@ -59,6 +63,7 @@ private:
// MAX_ENUM = "pas encore choisi", pour que le premier choix soit toujours logge. // MAX_ENUM = "pas encore choisi", pour que le premier choix soit toujours logge.
VkPresentModeKHR presentMode_ = VK_PRESENT_MODE_MAX_ENUM_KHR; VkPresentModeKHR presentMode_ = VK_PRESENT_MODE_MAX_ENUM_KHR;
bool vsync_ = false;
std::vector<VkImage> images_; std::vector<VkImage> images_;
std::vector<VkImageView> imageViews_; std::vector<VkImageView> imageViews_;
@@ -68,7 +73,7 @@ private:
// par le render pass). Recree en meme temps que la swapchain au resize. // par le render pass). Recree en meme temps que la swapchain au resize.
VkFormat depthFormat_ = VK_FORMAT_UNDEFINED; VkFormat depthFormat_ = VK_FORMAT_UNDEFINED;
VkImage depthImage_ = VK_NULL_HANDLE; VkImage depthImage_ = VK_NULL_HANDLE;
VkDeviceMemory depthImageMemory_ = VK_NULL_HANDLE; GpuAllocation depthAllocation_;
VkImageView depthImageView_ = VK_NULL_HANDLE; VkImageView depthImageView_ = VK_NULL_HANDLE;
VkRenderPass renderPass_ = VK_NULL_HANDLE; VkRenderPass renderPass_ = VK_NULL_HANDLE;
+103 -45
Voir le fichier
@@ -9,6 +9,58 @@
namespace vercora { 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) { MeshData terrainMeshData(const Heightmap& heightmap) {
const uint32_t res = heightmap.resolution(); const uint32_t res = heightmap.resolution();
if (res < 2) { if (res < 2) {
@@ -53,25 +105,8 @@ MeshData terrainMeshData(const Heightmap& heightmap) {
// LiDAR : sol / vegetation / bati) sans toucher au shader. // LiDAR : sol / vegetation / bati) sans toucher au shader.
vertex.color = { 1.0f, 1.0f, 1.0f }; vertex.color = { 1.0f, 1.0f, 1.0f };
// Normale analytique de la surface y = h(x,z) : le vecteur normal // Normale par differences centrees, voir gridNormal.
// vaut (-dh/dx, 1, -dh/dz). Les derivees sont estimees par vertex.normal = gridNormal(heightmap, ix, iz, res, spacing);
// 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));
// UV sur tout le terrain. Pas encore consomme (pas de texturing), // UV sur tout le terrain. Pas encore consomme (pas de texturing),
// mais c'est le repere naturel pour y plaquer une orthophoto le jour // 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. // ici oblige a la changer la-bas aussi.
// //
// Enroulement anti-horaire vu de dessus (+Y), coherent avec la convention // 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 // des .obj de la Phase 3. C'est ce qui a rendu le back-face culling du
// sans effet visible aujourd'hui, mais ca rend le back-face culling // terrain activable sans retoucher la geometrie (PHASE 32, voir
// activable sans retoucher la geometrie. // ShaderSet::cullBackFaces).
for (uint32_t iz = 0; iz < cells; ++iz) { appendGridIndices(res, mesh.indices);
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;
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) { if (mesh.indices.size() % 3 != 0) {
throw std::runtime_error("TerrainMesh : nombre d'index non multiple de 3."); throw std::runtime_error("TerrainMesh : nombre d'index non multiple de 3.");
} }
@@ -145,4 +158,49 @@ MeshData terrainMeshData(const Heightmap& heightmap) {
return mesh; 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 } // namespace vercora
+18
Voir le fichier
@@ -1,7 +1,12 @@
#pragma once #pragma once
#include "renderer/GpuVertex.hpp"
#include "renderer/MeshData.hpp" #include "renderer/MeshData.hpp"
#include <cstdint>
#include <string>
#include <vector>
namespace vercora { namespace vercora {
class Heightmap; class Heightmap;
@@ -20,4 +25,17 @@ class Heightmap;
// Lance std::runtime_error si la grille ne peut pas produire un maillage sain. // Lance std::runtime_error si la grille ne peut pas produire un maillage sain.
MeshData terrainMeshData(const Heightmap& heightmap); 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 } // namespace vercora
+198 -30
Voir le fichier
@@ -89,9 +89,16 @@ std::vector<uint32_t> terrainNodeIndices(uint32_t nodeCells) {
return indices; return indices;
} }
MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& quadtree, namespace {
uint32_t nodeIndex, bool withIndices,
bool reuseParentGrid) { // 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()) { if (nodeIndex >= quadtree.nodeCount()) {
throw std::runtime_error("TerrainNodeMesh : indice de noeud hors limites."); 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 j = 0; j < verts; ++j) {
for (uint32_t i = 0; i < verts; ++i) { for (uint32_t i = 0; i < verts; ++i) {
// Indices de grille du sommet, ECRETES sur le bord du terrain. // 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)] ? parentGrid[static_cast<std::size_t>(j / 2u) * parentVerts + (i / 2u)]
: parentSample; : parentSample;
Vertex& vertex = mesh.vertices[static_cast<std::size_t>(j) * verts + i]; sink(static_cast<std::size_t>(j) * verts + i, gx, gz, here, parent);
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) };
} }
} }
}
// 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) { if (withIndices) {
mesh.indices = terrainNodeIndices(nodeCells); 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) { for (const Vertex& vertex : mesh.vertices) {
if (!std::isfinite(vertex.pos.x) || !std::isfinite(vertex.pos.y) || if (!std::isfinite(vertex.pos.x) || !std::isfinite(vertex.pos.y) ||
!std::isfinite(vertex.pos.z) || !std::isfinite(vertex.normal.y) || !std::isfinite(vertex.pos.z) || !std::isfinite(vertex.normal.y) ||
!std::isfinite(vertex.morphPos.y)) { !std::isfinite(vertex.morphPos.y)) {
throw std::runtime_error( throwNonFinite();
"TerrainNodeMesh : coordonnee ou normale non finie (NaN/infini) "
"produite par la heightmap.");
} }
} }
return mesh; 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 } // namespace vercora
+28
Voir le fichier
@@ -1,5 +1,6 @@
#pragma once #pragma once
#include "renderer/GpuVertex.hpp"
#include "renderer/MeshData.hpp" #include "renderer/MeshData.hpp"
#include <cstdint> #include <cstdint>
@@ -63,4 +64,31 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree&
// diagonale que TerrainMesh. Calculee une fois par appelant et reutilisee. // diagonale que TerrainMesh. Calculee une fois par appelant et reutilisee.
std::vector<uint32_t> terrainNodeIndices(uint32_t nodeCells); 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 } // namespace vercora
+125 -101
Voir le fichier
@@ -20,15 +20,19 @@ TerrainStreamer::TerrainStreamer(const Heightmap& heightmap, Renderer& renderer,
quadtree_(heightmap, params.quadtree) { quadtree_(heightmap, params.quadtree) {
logInfo(quadtree_.describe()); logInfo(quadtree_.describe());
const std::size_t bytesPerNode = static_cast<std::size_t>(quadtree_.nodeCells() + 1) * // PHASE 32 : une tuile ne pese plus que ses sommets, au format compact
(quadtree_.nodeCells() + 1) * sizeof(Vertex) + // (16 octets au lieu de 68) ; sa topologie est televersee UNE fois pour
static_cast<std::size_t>(quadtree_.trianglesPerNode()) * // toutes, ici, en uint16.
3 * sizeof(uint32_t); 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) + logInfo("Streaming terrain : au plus " + std::to_string(params_.maxResidentNodes) +
" tuiles residentes (" + " tuiles residentes (" +
std::to_string(params_.maxResidentNodes * bytesPerNode / (1024 * 1024)) + std::to_string(params_.maxResidentNodes * bytesPerNode_ / (1024 * 1024)) +
" Mo de geometrie GPU), " + std::to_string(params_.maxUploadsPerFrame) + " Mo de geometrie GPU, " + std::to_string(bytesPerNode_ / 1024) +
" construites par frame."); " 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(); pinTopLevels();
} }
@@ -46,11 +50,6 @@ void TerrainStreamer::pinTopLevels() {
const int lowest = std::max(0, static_cast<int>(quadtree_.rootLevel()) - const int lowest = std::max(0, static_cast<int>(quadtree_.rootLevel()) -
static_cast<int>(params_.pinnedTopLevels) + 1); 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) { for (uint32_t index = 0; index < quadtree_.nodeCount(); ++index) {
if (static_cast<int>(quadtree_.node(index).level) < lowest) { if (static_cast<int>(quadtree_.node(index).level) < lowest) {
continue; continue;
@@ -61,19 +60,19 @@ void TerrainStreamer::pinTopLevels() {
} }
ResidentNode node; ResidentNode node;
node.mesh = mesh; node.mesh = mesh;
node.bytes = bytesPerNode; node.bytes = bytesPerNode_;
node.pinned = true; node.pinned = true;
// Jamais rajeunie ensuite : elle n'est de toute facon pas evincable. // Jamais rajeunie ensuite : elle n'est de toute facon pas evincable.
node.lastUsedFrame = 0; node.lastUsedFrame = 0;
resident_.emplace(index, node); resident_.emplace(index, node);
residentBytes_ += bytesPerNode; residentBytes_ += bytesPerNode_;
++pinnedCount_; ++pinnedCount_;
} }
logInfo("Sommet du quadtree epingle : " + std::to_string(pinnedCount_) + logInfo("Sommet du quadtree epingle : " + std::to_string(pinnedCount_) +
" tuiles de niveau " + std::to_string(lowest) + " a " + " tuiles de niveau " + std::to_string(lowest) + " a " +
std::to_string(static_cast<int>(quadtree_.rootLevel())) + " (" + 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 " " Mo), jamais evincees. C'est ce qui rend le repli sur l'ancetre "
"toujours disponible."); "toujours disponible.");
} }
@@ -107,11 +106,11 @@ const std::vector<uint32_t>& TerrainStreamer::sharedIndices() const {
// n'aurait parie sur la boucle d'indices. // n'aurait parie sur la boucle d'indices.
// //
// Construite a la premiere tuile puis simplement RECOPIEE dans le MeshData. // 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 // PHASE 32 : elle n'est meme plus recopiee. Le chantier de renderer que
// toutes les tuiles - economiserait en plus 96 Ko par tuile residente, mais // cette note annoncait (NOTES-PHASE18.md) est fait : un UNIQUE buffer
// demanderait de dissocier sommets et indices dans Renderer::addMesh : c'est // d'indices GPU, en uint16, sert toutes les tuiles - 96 Ko economises par
// un chantier de renderer, pas de streaming (voir NOTES-PHASE18.md). // tuile residente, et une seule liaison d'indices par image.
if (indexTemplate_.empty() || !params_.cacheTileWork) { if (indexTemplate_.empty()) {
indexTemplate_ = terrainNodeIndices(quadtree_.nodeCells()); indexTemplate_ = terrainNodeIndices(quadtree_.nodeCells());
} }
return indexTemplate_; return indexTemplate_;
@@ -148,19 +147,40 @@ bool TerrainStreamer::wantsParallel(std::size_t count) const {
} }
void TerrainStreamer::meshBatch(const std::vector<uint32_t>& nodes) { void TerrainStreamer::meshBatch(const std::vector<uint32_t>& nodes) {
batchMeshes_.clear();
batchErrors_.clear(); batchErrors_.clear();
batchMeshes_.resize(nodes.size());
batchErrors_.resize(nodes.size()); batchErrors_.resize(nodes.size());
batchMeshes_.assign(nodes.size(), kInvalidMesh);
batchWrites_.assign(nodes.size(), Renderer::TerrainMeshWrite{});
if (nodes.empty()) { if (nodes.empty()) {
return; return;
} }
// Le corps d'un travailleur. Il ne touche QUE batchMeshes_[k] et // --- 1. Reservation, thread de rendu -----------------------------------
// batchErrors_[k] pour k dans [begin, end) - des elements deja alloues, donc // Faire de la place AVANT de reserver, sinon le pic de residence depasserait
// ni le vecteur ni sa capacite ne bougent pendant l'execution. Tout le reste // le plafond le temps du lot. Les tuiles deja reservees de ce lot comptent
// de ce qu'il lit (heightmap_, quadtree_, params_) est const pour la duree // comme residentes : elles le seront a la fin de la frame.
// de la session. 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 // 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 // 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) { const auto worker = [&](std::size_t begin, std::size_t end) {
for (std::size_t k = begin; k < end; ++k) { 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 { try {
batchMeshes_[k] = terrainNodeMeshData(heightmap_, quadtree_, nodes[k], writeTerrainNodeVertices(heightmap_, quadtree_, nodes[k],
false, params_.cacheTileWork); batchWrites_[k].vertices, params_.cacheTileWork);
} catch (const std::exception& e) { } catch (const std::exception& e) {
// Une exception ne doit JAMAIS traverser la frontiere d'un // Une exception ne doit JAMAIS traverser la frontiere d'un
// std::thread : elle appellerait std::terminate. Elle est donc // std::thread : elle appellerait std::terminate. Elle est donc
// capturee ici et rendue a l'appelant comme une donnee. // capturee ici et rendue a l'appelant comme une donnee.
batchErrors_[k] = e.what(); batchErrors_[k] = e.what();
batchMeshes_[k] = MeshData{};
} catch (...) { } catch (...) {
batchErrors_[k] = "exception inconnue"; 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) { for (uint64_t micros : perTileMicros) {
geometryMicros_ += micros; 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 { try {
const auto t1 = Clock::now(); write = renderer_.beginTerrainMesh(
// Les indices sont poses ICI et non dans terrainNodeMeshData, pour que (quadtree_.nodeCells() + 1) * (quadtree_.nodeCells() + 1), sharedIndexSet_);
// 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;
} catch (const std::exception& e) { } catch (const std::exception& e) {
// Une tuile qu'on ne sait pas construire ne doit pas arreter le jeu : uploadMicros_ += microsBetween(t0, Clock::now());
// elle sera simplement absente, et le message dit laquelle. Le cas // Le cas realiste est un manque de memoire GPU, pas une donnee
// realiste est un manque de memoire GPU, pas une donnee invalide. // invalide : la tuile sera simplement absente, et le message dit
// laquelle.
logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) + logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) +
" non televersee (" + e.what() + ")."); " non televersee (" + e.what() + ").");
return kInvalidMesh; return kInvalidMesh;
} }
} const auto t1 = Clock::now();
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();
try { try {
scratchMesh_ = terrainNodeMeshData(heightmap_, quadtree_, nodeIndex, false, writeTerrainNodeVertices(heightmap_, quadtree_, nodeIndex, write.vertices,
params_.cacheTileWork); params_.cacheTileWork);
} catch (const std::exception& e) { } 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) + logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) +
" non maillee (" + e.what() + ")."); " non maillee (" + e.what() + ").");
return kInvalidMesh; 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; geometryMicros_ += micros;
meshWallMicros_ += micros; meshWallMicros_ += micros;
return uploadNode(nodeIndex, scratchMesh_); uploadMicros_ += microsBetween(t0, t1) + microsBetween(t2, t3);
++builtNodes_;
return write.mesh;
} }
bool TerrainStreamer::evictOne() { bool TerrainStreamer::evictOne() {
@@ -354,11 +383,6 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
fallbackCount_ = 0; fallbackCount_ = 0;
uncoveredCount_ = 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); const bool priming = (frameCounter_ <= params_.primingFrames);
uint32_t uploadsLeft = priming ? std::numeric_limits<uint32_t>::max() uint32_t uploadsLeft = priming ? std::numeric_limits<uint32_t>::max()
: params_.maxUploadsPerFrame; : params_.maxUploadsPerFrame;
@@ -402,14 +426,13 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
// --- 1b/1c. Maillage puis televersement --------------------------------- // --- 1b/1c. Maillage puis televersement ---------------------------------
// Deux chemins, et le choix se fait sur la TAILLE DU LOT : // Deux chemins, et le choix se fait sur la TAILLE DU LOT :
// //
// - lot parallelisable : tout le lot est maille d'abord (meshBatch, aucun // - lot parallelisable : tout le lot est reserve, puis ecrit (meshBatch,
// appel Vulkan, plusieurs threads), puis televerse en sequence ; // aucun appel Vulkan pendant l'ecriture, plusieurs threads), puis livre ;
// - sinon : chaque tuile est maillee et televersee a la suite, sans jamais // - sinon : chaque tuile est reservee, ecrite et livree a la suite. C'est
// garder plus d'un MeshData en vie. C'est le chemin par DEFAUT, et il // le chemin par DEFAUT.
// est identique a celui d'avant la Phase 19, cout memoire compris.
// //
// Dans les deux cas les addMesh ont lieu sur le thread de rendu, en // Dans les deux cas les appels au Renderer ont lieu sur le thread de rendu,
// sequence, et dans l'ordre de selection - donc du plus proche au plus // en sequence, et dans l'ordre de selection - donc du plus proche au plus
// lointain. // lointain.
// Suivi du plus gros lot : il doit compter les DEUX chemins, sinon le bilan // 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] + ")."); " non maillee (" + batchErrors_[k] + ").");
continue; continue;
} }
// Faire de la place AVANT de televerser, sinon le pic de residence MeshHandle mesh = kInvalidMesh;
// depasserait le plafond le temps d'un upload. (Le maillage, lui, if (parallel) {
// n'alloue rien sur le GPU : c'est bien l'upload qui doit etre couvert.) mesh = batchMeshes_[k]; // place deja faite par meshBatch
while (resident_.size() >= params_.maxResidentNodes) { } else {
if (!evictOne()) { // Faire de la place AVANT de reserver, sinon le pic de residence
break; // tout est utilise cette frame : on laisse deborder // 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) { if (mesh == kInvalidMesh) {
continue; continue;
} }
@@ -447,20 +472,13 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
ResidentNode node; ResidentNode node;
node.mesh = mesh; node.mesh = mesh;
node.bytes = bytesPerNode; node.bytes = bytesPerNode_;
node.lastUsedFrame = frameCounter_; node.lastUsedFrame = frameCounter_;
resident_.emplace(nodeIndex, node); resident_.emplace(nodeIndex, node);
residentBytes_ += bytesPerNode; residentBytes_ += bytesPerNode_;
--pendingCount_; // finalement servie dans la frame meme --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) -------------------------- // --- 2. Choix des ancetres de repli (PHASE 12) --------------------------
// Rien a faire dans le cas courant : en regime etabli toute la selection est // 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. // 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 --------------------------------------------------------- // --- 3. Emission ---------------------------------------------------------
const bool hasFallback = !fallbackAncestors_.empty(); const bool hasFallback = !fallbackAncestors_.empty();
const int32_t vertsPerRow = static_cast<int32_t>(quadtree_.nodeCells() + 1);
auto emit = [&](const TerrainQuadtree::SelectedNode& node, MeshHandle mesh) { auto emit = [&](const TerrainQuadtree::SelectedNode& node, MeshHandle mesh) {
DrawItem item; DrawItem item;
item.mesh = mesh; item.mesh = mesh;
@@ -497,6 +516,11 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
item.model = glm::mat4(1.0f); item.model = glm::mat4(1.0f);
item.material = Material::Terrain; item.material = Material::Terrain;
item.params = glm::vec4(node.morphStart, node.morphEnd, 0.0f, 0.0f); 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); out.push_back(item);
++drawnCount_; ++drawnCount_;
}; };
+43 -31
Voir le fichier
@@ -3,6 +3,7 @@
#include "core/Frustum.hpp" #include "core/Frustum.hpp"
#include "renderer/DrawItem.hpp" #include "renderer/DrawItem.hpp"
#include "renderer/MeshData.hpp" #include "renderer/MeshData.hpp"
#include "renderer/Renderer.hpp" // Renderer::TerrainMeshWrite
#include "world/TerrainQuadtree.hpp" #include "world/TerrainQuadtree.hpp"
#include <glm/glm.hpp> #include <glm/glm.hpp>
@@ -16,7 +17,6 @@
namespace vercora { namespace vercora {
class Heightmap; class Heightmap;
class Renderer;
// Fait le lien entre le quadtree (qui decide QUOI dessiner) et le Renderer (qui // 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 // 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 // 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. // budget sont servies dans les frames suivantes, les plus PROCHES d'abord.
// //
// 2. PLAFOND DE RESIDENCE (maxResidentNodes). Chaque tuile consomme deux // 2. PLAFOND DE RESIDENCE (maxResidentNodes). Il bornait a l'origine deux
// allocations Vulkan (vertex + index), et vkAllocateMemory est plafonne par // choses : la memoire, et le nombre d'allocations Vulkan (deux par tuile,
// maxMemoryAllocationCount (typiquement 4096). Le plafond garde une marge // plafonnees par maxMemoryAllocationCount, typiquement 4096). PHASE 32 :
// confortable en plus de borner la RAM. // 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 // 3. EVICTION LRU, jamais sur une tuile utilisee dans la frame courante, ni
// sur une tuile du sommet epingle (point 4). // sur une tuile du sommet epingle (point 4).
@@ -87,8 +89,9 @@ public:
// staging vivant simultanement (64 tuiles ~ 25 Mo). // staging vivant simultanement (64 tuiles ~ 25 Mo).
uint32_t maxUploadsPerFrame = 64; uint32_t maxUploadsPerFrame = 64;
// Plafond de tuiles gardees sur le GPU. 512 tuiles = 1024 allocations // Plafond de tuiles gardees sur le GPU. 512 tuiles = ~200 Mo au format
// Vulkan et ~200 Mo au format de sommet de la Phase 10. // 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; uint32_t maxResidentNodes = 512;
// Frames pendant lesquelles le budget par frame est LEVE, au demarrage : // 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 // Ni la Heightmap ni le Renderer ne sont possedes ; les deux doivent vivre
// plus longtemps que le streamer. // plus longtemps que le streamer.
TerrainStreamer(const Heightmap& heightmap, Renderer& renderer, 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();
TerrainStreamer(const TerrainStreamer&) = delete; TerrainStreamer(const TerrainStreamer&) = delete;
@@ -241,33 +248,34 @@ private:
bool pinned = false; bool pinned = false;
}; };
// PHASE 19. Maille les tuiles `nodes` dans `batchMeshes_`, en parallele // PHASE 19. Construit les tuiles `nodes` dans `batchMeshes_`, le maillage
// au-dela de deux tuiles. AUCUN appel Vulkan : c'est toute la raison pour // en parallele au-dela de deux tuiles. PHASE 32 : les emplacements sont
// laquelle cette etape peut quitter le thread de rendu sans rien changer a // reserves d'abord sur le thread de rendu (Renderer::beginTerrainMesh), les
// la synchronisation du moteur. // 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 // Chaque thread ecrit dans des ZONES DISJOINTES deja reservees : il n'y a
// dimensionnes : il n'y a ni verrou, ni file, ni compteur partage - donc // ni verrou, ni file, ni compteur partage - donc aucun etat sur lequel une
// aucun etat sur lequel une course serait possible. Une tuile qui echoue // course serait possible. Une tuile qui echoue depose son message dans
// depose son message dans `batchErrors_[k]`, jamais dans un journal (les // `batchErrors_[k]`, jamais dans un journal (les fonctions de
// fonctions de journalisation ne sont pas prevues pour plusieurs threads) : // journalisation ne sont pas prevues pour plusieurs threads) : c'est
// c'est l'appelant qui journalise, apres la jonction. // l'appelant qui journalise, apres la jonction.
void meshBatch(const std::vector<uint32_t>& nodes); void meshBatch(const std::vector<uint32_t>& nodes);
// true si un lot de `count` tuiles vaut la peine de partir sur des threads. // true si un lot de `count` tuiles vaut la peine de partir sur des threads.
bool wantsParallel(std::size_t count) const; bool wantsParallel(std::size_t count) const;
// Pose la topologie commune puis televerse. SEQUENTIEL, thread de rendu. // PHASE 32. Construit une tuile : reserve sa place dans le pool de
// Renvoie kInvalidMesh en cas d'echec (la tuile est alors simplement // geometrie (Renderer::beginTerrainMesh), y ECRIT ses sommets au format
// sautee : un trou d'une frame vaut mieux qu'un arret du jeu). // compact, la livre. SEQUENTIEL, thread de rendu. Chemin par DEFAUT depuis
MeshHandle uploadNode(uint32_t nodeIndex, MeshData& data); // 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
// Maille ET televerse une tuile, en sequence, sans jamais garder plus d'un // frame vaut mieux qu'un arret du jeu).
// MeshData en vie. Chemin par DEFAUT depuis que meshThreads vaut 1, et
// chemin du sommet epingle.
MeshHandle buildNode(uint32_t nodeIndex); 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; const std::vector<uint32_t>& sharedIndices() const;
// Libere la tuile la moins recemment utilisee qui n'a pas servi dans la // 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 - // locales, uniquement pour garder leur capacite d'une frame a l'autre -
// meme raison que selection_ et fallbackAncestors_. // meme raison que selection_ et fallbackAncestors_.
std::vector<uint32_t> batchNodes_; std::vector<uint32_t> batchNodes_;
std::vector<MeshData> batchMeshes_; // rempli seulement sur le chemin parallele
std::vector<std::string> batchErrors_; 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 // PHASE 32 : la topologie commune, televersee une fois (Renderer::
// d'une tuile a l'autre ; il n'en vit jamais qu'un. // addSharedIndices), et la taille GPU d'une tuile (ses sommets seuls).
MeshData scratchMesh_; uint32_t sharedIndexSet_ = 0;
std::size_t bytesPerNode_ = 0;
// PHASE 19 : temps de MUR de l'etape de maillage, a comparer a // 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 // 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, Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
const TextureData& data, bool repeat) 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) { : 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."); 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()); const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
createImage(data.width, data.height, mipLevels, format); createImage(data.width, data.height, mipLevels, format);
uploadAndTransition(commandPool, queue, data); uploadAndTransition(commandPool, queue, data, source);
createView(format, mipLevels); createView(format, mipLevels);
createSampler(mipLevels, repeat); createSampler(mipLevels, repeat);
} }
@@ -111,9 +122,7 @@ Texture::~Texture() {
if (image_ != VK_NULL_HANDLE) { if (image_ != VK_NULL_HANDLE) {
vkDestroyImage(device, image_, nullptr); vkDestroyImage(device, image_, nullptr);
} }
if (memory_ != VK_NULL_HANDLE) { context_.freeMemory(allocation_);
vkFreeMemory(device, memory_, nullptr);
}
} }
void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels, 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{}; VkMemoryRequirements requirements{};
vkGetImageMemoryRequirements(device, image_, &requirements); vkGetImageMemoryRequirements(device, image_, &requirements);
VkMemoryAllocateInfo allocInfo{}; // PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; allocation_ = context_.allocateMemory(requirements, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
allocInfo.allocationSize = requirements.size; vkBindImageMemory(device, image_, allocation_.memory, 0);
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);
deviceSize_ = requirements.size; deviceSize_ = requirements.size;
} }
void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue, void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
const TextureData& data) { const TextureData& data, const PixelSource& source) {
VkDevice device = context_.device(); 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 // PHASE 32 : un staging de 4 Mo au plus, REUTILISE tranche apres tranche,
// contigus dans le fichier, donc les offsets de copie sont ceux du .vcto. // au lieu d'un staging de la taille de toute la chaine. Pour l'orthophoto
VulkanBuffer staging(context_, total, // 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_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
staging.writeToBuffer(data.pixels.data(), total); staging.map();
staging.unmap(); 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{}; VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; 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; VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer); vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
VkCommandBufferBeginInfo beginInfo{}; // --- Un lot de bandes par remplissage du staging ------------------------
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);
std::vector<VkBufferImageCopy> regions; std::vector<VkBufferImageCopy> regions;
regions.reserve(mipLevels); std::size_t next = 0;
for (uint32_t level = 0; level < mipLevels; ++level) { bool first = true;
const TextureMipLevel& mip = data.mips[level]; while (next < bands.size()) {
VkBufferImageCopy region{}; regions.clear();
region.bufferOffset = mip.offset; VkDeviceSize used = 0;
// 0 = "serre sur l'extent de l'image". Indispensable pour un format while (next < bands.size() && used + bands[next].bytes <= stagingSize) {
// compresse, ou bufferRowLength se compterait en TEXELS et non en blocs : const Band& band = bands[next];
// le calculer a la main serait une occasion d'erreur gratuite. source(stagingBytes + used, band.payloadOffset, band.bytes);
region.bufferRowLength = 0;
region.bufferImageHeight = 0; VkBufferImageCopy region{};
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; region.bufferOffset = used;
region.imageSubresource.mipLevel = level; // 0 = "serre sur l'extent de la copie". Indispensable pour un format
region.imageSubresource.baseArrayLayer = 0; // compresse, ou bufferRowLength se compterait en TEXELS et non en
region.imageSubresource.layerCount = 1; // blocs : le calculer a la main serait une occasion d'erreur
region.imageOffset = { 0, 0, 0 }; // gratuite.
region.imageExtent = { mip.width, mip.height, 1 }; region.bufferRowLength = 0;
regions.push_back(region); 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); 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 // le renvoie par valeur. L'en-tete reste sans cout : assets/TextureFile.hpp ne
// depend pas de Vulkan. // depend pas de Vulkan.
#include "assets/TextureFile.hpp" #include "assets/TextureFile.hpp"
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include <cstdint> #include <cstdint>
#include <functional>
namespace vercora { namespace vercora {
@@ -43,6 +45,19 @@ public:
// l'orthophoto - voir createSampler. // l'orthophoto - voir createSampler.
Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue, Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
const TextureData& data, bool repeat = false); 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();
Texture(const Texture&) = delete; Texture(const Texture&) = delete;
@@ -68,13 +83,13 @@ public:
private: private:
void createImage(uint32_t width, uint32_t height, uint32_t mipLevels, VkFormat format); void createImage(uint32_t width, uint32_t height, uint32_t mipLevels, VkFormat format);
void uploadAndTransition(VkCommandPool commandPool, VkQueue queue, void uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
const TextureData& data); const TextureData& data, const PixelSource& source);
void createView(VkFormat format, uint32_t mipLevels); void createView(VkFormat format, uint32_t mipLevels);
void createSampler(uint32_t mipLevels, bool repeat); void createSampler(uint32_t mipLevels, bool repeat);
VulkanContext& context_; VulkanContext& context_;
VkImage image_ = VK_NULL_HANDLE; VkImage image_ = VK_NULL_HANDLE;
VkDeviceMemory memory_ = VK_NULL_HANDLE; GpuAllocation allocation_;
VkImageView view_ = VK_NULL_HANDLE; VkImageView view_ = VK_NULL_HANDLE;
VkSampler sampler_ = VK_NULL_HANDLE; VkSampler sampler_ = VK_NULL_HANDLE;
VkDeviceSize deviceSize_ = 0; 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 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 fall{0.0f, -6.5f, 0.0f, 0.0f};
alignas(16) glm::vec4 detail{0.0f, 0.0f, 1.0f, 1.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 } // namespace vercora
+53 -31
Voir le fichier
@@ -1,7 +1,7 @@
#pragma once #pragma once
#include "renderer/GpuVertex.hpp"
#include "renderer/InstanceData.hpp" #include "renderer/InstanceData.hpp"
#include "renderer/Vertex.hpp"
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
@@ -24,60 +24,82 @@ namespace vercora {
// Consequence concrete : la logique de jeu se compile et se teste sans GPU (voir // 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. // tests/logic_tests.cpp), y compris sur une machine ou le SDK n'est pas installe.
// Un seul binding, sommets entrelaces. // PHASE 32 : DEUX formats de sommet, un par famille de shaders (voir
inline VkVertexInputBindingDescription vertexBindingDescription() { // 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{}; VkVertexInputBindingDescription binding{};
binding.binding = 0; binding.binding = 0;
binding.stride = sizeof(Vertex); binding.stride = sizeof(ObjectVertex);
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return binding; return binding;
} }
// Mapping des attributs vers les location(...) du vertex shader. // 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
// Six attributs depuis la Phase 10 : les deux derniers portent la cible de // shaders ne lisait, ne sont plus dans le buffer).
// geomorphing du terrain (voir Vertex.hpp) et ne sont decrits qu'aux pipelines inline std::array<VkVertexInputAttributeDescription, 4> objectAttributeDescriptions() {
// dont le vertex shader les lit reellement. std::array<VkVertexInputAttributeDescription, 4> attrs{};
// `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{};
attrs[0].binding = 0; attrs[0].binding = 0;
attrs[0].location = 0; attrs[0].location = 0;
attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT; 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].binding = 0;
attrs[1].location = 1; attrs[1].location = 1;
attrs[1].format = VK_FORMAT_R32G32B32_SFLOAT; 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].binding = 0;
attrs[2].location = 2; attrs[2].location = 2;
attrs[2].format = VK_FORMAT_R32G32B32_SFLOAT; attrs[2].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[2].offset = offsetof(Vertex, normal); attrs[2].offset = offsetof(ObjectVertex, normal);
// Deux composantes seulement -> format R32G32. // Deux composantes seulement -> format R32G32.
attrs[3].binding = 0; attrs[3].binding = 0;
attrs[3].location = 3; attrs[3].location = 3;
attrs[3].format = VK_FORMAT_R32G32_SFLOAT; 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 return attrs;
// 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);
attrs[5].binding = 0; // --- Terrain : TerrainVertex, 16 octets --------------------------------------
attrs[5].location = 5; inline VkVertexInputBindingDescription terrainBindingDescription() {
attrs[5].format = VK_FORMAT_R32G32B32_SFLOAT; VkVertexInputBindingDescription binding{};
attrs[5].offset = offsetof(Vertex, morphNormal); 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; return attrs;
} }
@@ -98,7 +120,7 @@ inline VkVertexInputBindingDescription instanceBindingDescription() {
return binding; 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. // 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 // 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 // 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{}; VkMemoryRequirements memRequirements{};
vkGetBufferMemoryRequirements(device, buffer_, &memRequirements); vkGetBufferMemoryRequirements(device, buffer_, &memRequirements);
VkMemoryAllocateInfo allocInfo{}; // PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; try {
allocInfo.allocationSize = memRequirements.size; allocation_ = context_.allocateMemory(memRequirements, properties);
allocInfo.memoryTypeIndex = } catch (...) {
context_.findMemoryType(memRequirements.memoryTypeBits, properties); vkDestroyBuffer(device, buffer_, nullptr);
throw;
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
throw std::runtime_error("Echec de l'allocation memoire d'un buffer.");
} }
vkBindBufferMemory(device, buffer_, memory_, 0); vkBindBufferMemory(device, buffer_, allocation_.memory, 0);
} }
VulkanBuffer::~VulkanBuffer() { VulkanBuffer::~VulkanBuffer() {
VkDevice device = context_.device(); VkDevice device = context_.device();
if (mapped_ != nullptr) { if (mapped_ != nullptr) {
vkUnmapMemory(device, memory_); vkUnmapMemory(device, allocation_.memory);
mapped_ = nullptr; mapped_ = nullptr;
} }
if (buffer_ != VK_NULL_HANDLE) { if (buffer_ != VK_NULL_HANDLE) {
vkDestroyBuffer(device, buffer_, nullptr); vkDestroyBuffer(device, buffer_, nullptr);
} }
if (memory_ != VK_NULL_HANDLE) { context_.freeMemory(allocation_);
vkFreeMemory(device, memory_, nullptr);
}
} }
void VulkanBuffer::map() { void VulkanBuffer::map() {
if (mapped_ == nullptr) { if (mapped_ == nullptr) {
vkMapMemory(context_.device(), memory_, 0, size_, 0, &mapped_); vkMapMemory(context_.device(), allocation_.memory, 0, size_, 0, &mapped_);
} }
} }
void VulkanBuffer::unmap() { void VulkanBuffer::unmap() {
if (mapped_ != nullptr) { if (mapped_ != nullptr) {
vkUnmapMemory(context_.device(), memory_); vkUnmapMemory(context_.device(), allocation_.memory);
mapped_ = nullptr; mapped_ = nullptr;
} }
} }
+8 -4
Voir le fichier
@@ -1,5 +1,7 @@
#pragma once #pragma once
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include <memory> #include <memory>
@@ -31,10 +33,12 @@ public:
virtual ~BufferUploader() = default; virtual ~BufferUploader() = default;
// Enregistre une copie de `staging` (integralite de sa taille) vers // Enregistre une copie de `staging` (integralite de sa taille) vers
// `destination`. Prend possession de `staging`, qui sera detruit quand la // `destination`, a partir de l'octet `destinationOffset` (PHASE 32 : la
// frame ayant execute la copie sera terminee. // 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, virtual void enqueueCopy(std::unique_ptr<VulkanBuffer> staging,
VkBuffer destination) = 0; VkBuffer destination, VkDeviceSize destinationOffset) = 0;
}; };
// Buffer Vulkan reutilisable : creation, allocation memoire, bind, map, // Buffer Vulkan reutilisable : creation, allocation memoire, bind, map,
@@ -76,7 +80,7 @@ private:
VulkanContext& context_; VulkanContext& context_;
VkDeviceSize size_ = 0; VkDeviceSize size_ = 0;
VkBuffer buffer_ = VK_NULL_HANDLE; VkBuffer buffer_ = VK_NULL_HANDLE;
VkDeviceMemory memory_ = VK_NULL_HANDLE; GpuAllocation allocation_;
void* mapped_ = nullptr; void* mapped_ = nullptr;
}; };
+91 -5
Voir le fichier
@@ -3,6 +3,8 @@
#include "core/Logger.hpp" #include "core/Logger.hpp"
#include "core/Window.hpp" #include "core/Window.hpp"
#include <algorithm>
#include <cstdio>
#include <cstring> #include <cstring>
#include <set> #include <set>
#include <stdexcept> #include <stdexcept>
@@ -233,6 +235,29 @@ void VulkanContext::pickPhysicalDevice() {
VkPhysicalDeviceProperties props{}; VkPhysicalDeviceProperties props{};
vkGetPhysicalDeviceProperties(physicalDevice_, &props); vkGetPhysicalDeviceProperties(physicalDevice_, &props);
logInfo(std::string("GPU selectionne : ") + props.deviceName); 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 { bool VulkanContext::isDeviceSuitable(VkPhysicalDevice device) const {
@@ -397,13 +422,10 @@ SwapChainSupportDetails VulkanContext::querySwapChainSupport() const {
} }
uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const { uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const {
VkPhysicalDeviceMemoryProperties memProperties{}; for (uint32_t i = 0; i < memoryProperties_.memoryTypeCount; ++i) {
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memProperties);
for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) {
const bool typeOk = (typeFilter & (1u << i)) != 0; const bool typeOk = (typeFilter & (1u << i)) != 0;
const bool propsOk = const bool propsOk =
(memProperties.memoryTypes[i].propertyFlags & properties) == properties; (memoryProperties_.memoryTypes[i].propertyFlags & properties) == properties;
if (typeOk && propsOk) { if (typeOk && propsOk) {
return i; return i;
} }
@@ -411,6 +433,70 @@ uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlag
throw std::runtime_error("Aucun type de memoire adapte trouve."); 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, VkFormat VulkanContext::findSupportedFormat(const std::vector<VkFormat>& candidates,
VkImageTiling tiling, VkImageTiling tiling,
VkFormatFeatureFlags features) const { VkFormatFeatureFlags features) const {
+68
Voir le fichier
@@ -3,6 +3,7 @@
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include <optional> #include <optional>
#include <string>
#include <vector> #include <vector>
namespace vercora { namespace vercora {
@@ -41,6 +42,32 @@ struct SwapChainSupportDetails {
std::vector<VkPresentModeKHR> presentModes; 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 : // Regroupe l'etat "global" Vulkan qui ne change pas au resize :
// instance, debug messenger, surface, GPU physique, device logique, queues. // instance, debug messenger, surface, GPU physique, device logique, queues.
class VulkanContext { class VulkanContext {
@@ -84,6 +111,39 @@ public:
// Format de profondeur retenu (D32 de preference, avec fallbacks). // Format de profondeur retenu (D32 de preference, avec fallbacks).
VkFormat findDepthFormat() const; 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: private:
void createInstance(); void createInstance();
void setupDebugMessenger(); void setupDebugMessenger();
@@ -110,6 +170,14 @@ private:
QueueFamilyIndices queueIndices_; QueueFamilyIndices queueIndices_;
bool anisotropyEnabled_ = false; 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 } // 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 // pour le rendu que pour la COLLISION (voir la note de decouplage dans
// MEMORY.md). L'arbre n'en garde que des bornes. // MEMORY.md). L'arbre n'en garde que des bornes.
// Lance std::runtime_error si les parametres sont inexploitables. // 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 // Remplit `out` avec les noeuds a dessiner, tries du plus proche au plus
// lointain. `out` est vide au prealable ; sa capacite est conservee. // lointain. `out` est vide au prealable ; sa capacite est conservee.
+278
Voir le fichier
@@ -37,6 +37,8 @@
#include "editor/PlacedObject.hpp" #include "editor/PlacedObject.hpp"
#include "editor/SceneFile.hpp" #include "editor/SceneFile.hpp"
#include "renderer/DrawItem.hpp" #include "renderer/DrawItem.hpp"
#include "renderer/GpuVertex.hpp"
#include "renderer/RangeAllocator.hpp"
#include "renderer/TerrainMesh.hpp" #include "renderer/TerrainMesh.hpp"
#include "renderer/TerrainNodeMesh.hpp" #include "renderer/TerrainNodeMesh.hpp"
#include "world/AnimalMesh.hpp" #include "world/AnimalMesh.hpp"
@@ -3197,6 +3199,62 @@ void testTextureFile() {
threw = true; threw = true;
} }
check(threw, "Refus : fichier .vcto absent"); 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() { 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() { int main() {
std::printf("=== Tests logiques Vercora (headless, sans Vulkan) ===\n"); std::printf("=== Tests logiques Vercora (headless, sans Vulkan) ===\n");
@@ -10890,6 +11167,7 @@ int main() {
testGrassMesh(); testGrassMesh();
testGrassPhase18(); testGrassPhase18();
testTileMeshingIsThreadSafe(); testTileMeshingIsThreadSafe();
testGpuFormatsPhase32();
testVegetationPlacement(); testVegetationPlacement();
testGrassPlacement(); testGrassPlacement();
testInstanceLayout(); 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())