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 à :
révision
58f7da7a82
42 fichiers modifiés
+3383
-561
Aucun fichier ne correspond à votre recherche
@@ -112,6 +112,7 @@ add_executable(vercora
|
||||
src/core/Window.cpp
|
||||
src/core/Camera.cpp
|
||||
src/core/Paths.cpp
|
||||
src/core/ProcessMemory.cpp
|
||||
src/assets/ObjLoader.cpp
|
||||
src/assets/Heightmap.cpp
|
||||
src/assets/TerrainFile.cpp
|
||||
@@ -153,6 +154,7 @@ add_executable(vercora
|
||||
src/editor/SceneFile.cpp
|
||||
src/renderer/VulkanContext.cpp
|
||||
src/renderer/VulkanBuffer.cpp
|
||||
src/renderer/GpuBufferPool.cpp
|
||||
src/renderer/Mesh.cpp
|
||||
src/renderer/TerrainMesh.cpp
|
||||
src/renderer/TerrainNodeMesh.cpp
|
||||
@@ -175,12 +177,17 @@ target_link_libraries(vercora PRIVATE
|
||||
)
|
||||
|
||||
# GLFW_INCLUDE_VULKAN : GLFW inclut les headers Vulkan automatiquement.
|
||||
# GLFW_INCLUDE_NONE : ... et PAS <GL/gl.h>, qu'il inclut sinon par defaut. Le
|
||||
# moteur ne fait aucun OpenGL ; sous Windows l'en-tete vient avec le SDK et le
|
||||
# defaut passait inapercu, mais sous Linux il exige les en-tetes Mesa
|
||||
# (libgl-dev) pour rien. Les deux macros se combinent (voir glfw3.h).
|
||||
# VERCORA_DEBUG : active les validation layers uniquement en configuration Debug.
|
||||
# GLM_FORCE_RADIANS : GLM travaille en radians (evite les surprises d'unites).
|
||||
# GLM_FORCE_DEPTH_ZERO_TO_ONE : Vulkan attend une profondeur clip dans [0,1]
|
||||
# (et non [-1,1] comme OpenGL) -> indispensable pour un depth buffer correct.
|
||||
target_compile_definitions(vercora PRIVATE
|
||||
GLFW_INCLUDE_VULKAN
|
||||
GLFW_INCLUDE_NONE
|
||||
GLM_FORCE_RADIANS
|
||||
GLM_FORCE_DEPTH_ZERO_TO_ONE
|
||||
$<$<CONFIG:Debug>:VERCORA_DEBUG>
|
||||
|
||||
+78
-3
@@ -5,8 +5,10 @@ voir `NOTES-PHASE6.md`, `NOTES-PHASE7.md`, `NOTES-PHASE9.md`, `NOTES-PHASE10.md`
|
||||
`NOTES-PHASE11.md`, `NOTES-PHASE12.md`, `NOTES-PHASE-VELO.md`,
|
||||
`NOTES-PHASE-ESCALADE.md`, `NOTES-PHASE15.md`, `NOTES-PHASE16.md`,
|
||||
`NOTES-PHASE17.md`, `NOTES-PHASE18.md`, `NOTES-PHASE19.md`,
|
||||
`NOTES-PHASE20.md` et `NOTES-PHASE21.md` ; ce fichier est
|
||||
`NOTES-PHASE20.md` a `NOTES-PHASE32.md` (plus `NOTES-PHASE28-DESIGN.md`,
|
||||
`NOTES-PHASE29-DESIGN.md`) et l'audit `NOTES-AUDIT-GLOBAL.md` ; ce fichier est
|
||||
un resume vivant, mis a jour a la fin de chaque session, pas un journal complet.
|
||||
Le `README.md` a la racine donne le demarrage rapide (build, lancement, tests).
|
||||
|
||||
## Ce qu'est Vercora
|
||||
|
||||
@@ -22,6 +24,35 @@ MONDE - une partie normale les charge, les dessine et s'y cogne. Suite du
|
||||
2026-08-23 : **F3/F4 selectionnent l'objet pose suivant/precedent SANS viser**
|
||||
(detail plus bas, section Phase 15).
|
||||
|
||||
## Etat verifie (2026-10-15, fin de Phase 32 ; fusion des branches PC et cloud)
|
||||
|
||||
Ce bloc complete celui de la Phase 20 ci-dessous, qui reste vrai sauf mention.
|
||||
|
||||
- **Builds** : Windows inchange (`tools\build.bat`, `tools\run_logic_tests.bat`).
|
||||
**Linux** depuis la Phase 32 : `cmake -S . -B build-rel -G Ninja
|
||||
-DCMAKE_BUILD_TYPE=Release -DGLFW_BUILD_WAYLAND=OFF && ninja -C build-rel`
|
||||
(GCC 13 / Clang 18). Les tests headless se compilent avec la meme liste de
|
||||
sources que `run_logic_tests.bat`.
|
||||
- **Tests headless** : 3 963 verifications sans les dalles LiDAR (25 de plus
|
||||
avec elles). +20 en Phase 32 (formats GPU, allocateur, orthophoto par tranches).
|
||||
- **Ressources** : chaque partie journalise `Ressources (PHASE 32)` au
|
||||
chargement, toutes les 10 s et a la fermeture : RAM du processus, memoire GPU
|
||||
exacte (toute allocation passe par `VulkanContext::allocateMemory`), blocs et
|
||||
appels `vkAllocateMemory`, et occupation du pool de geometrie.
|
||||
- **Format GPU** : `Vertex` (68 o) n'est plus que le format CPU ; le GPU lit
|
||||
`ObjectVertex` (44 o) et `TerrainVertex` (16 o), dans les blocs de 4 Mo de
|
||||
`GpuBufferPool`. Ecriture directe en memoire unifiee (UHD 770), staging sinon
|
||||
(`--force-staging` pour l'eprouver).
|
||||
- **Options ajoutees** : `--quit-after=S`, `--freeze-anim`, `--force-staging`,
|
||||
`--vsync` (presentation FIFO, a prendre pour JOUER ; les mesures restent non
|
||||
plafonnees).
|
||||
- **Validation de synchronisation** : la variable qui fonctionne avec les couches
|
||||
1.3.275 est `VK_LAYER_ENABLES=VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT`.
|
||||
- **Sans GPU ni donnees** (session cloud) : lavapipe + Xvfb, zone proxy par
|
||||
`tools/make_bench_zone.py`. Recette complete : NOTES-PHASE32.md section 9.
|
||||
- **Comparaisons d'images** : ajouter `--no-wildlife` (la faune bouge en temps
|
||||
reel) en plus de `--lock-input --look --time-scale=0 --freeze-anim`.
|
||||
|
||||
## Etat verifie (2026-08-26, fin de Phase 20)
|
||||
|
||||
- **GPU DE CETTE MACHINE : Intel UHD 770 integree.** Il n'y a plus de GTX 960
|
||||
@@ -1675,7 +1706,10 @@ Deux points rouges, aucun imputable a la phase :
|
||||
collision, catalogue, placement et serialisation sont deja agnostiques du
|
||||
format. Compter un analyseur JSON, le conteneur `.glb`, les accesseurs et
|
||||
l'aplatissement de la hierarchie de noeuds.
|
||||
0bis. **Paralleliser la construction des tuiles** (Phase 18) : c'est 83 % du
|
||||
0bis. (Phase 32 : une tuile interieure se construit desormais sans relecture -
|
||||
~104 us en Release lavapipe - et s'ecrit directement en memoire GPU, sans
|
||||
MeshData ni copie : le gain a attendre du parallelisme a encore baisse.)
|
||||
**Paralleliser la construction des tuiles** (Phase 18) : c'est 83 % du
|
||||
cout d'une tuile apres les optimisations exactes de cette phase, et
|
||||
`terrainNodeMeshData` est deja PURE. Le seul obstacle est
|
||||
`Renderer::addMesh`, qui doit rester sur le thread de rendu.
|
||||
@@ -1686,7 +1720,10 @@ Deux points rouges, aucun imputable a la phase :
|
||||
3. ~~Transfert asynchrone des tuiles de terrain.~~ **FAIT EN PHASE 12.** Le
|
||||
verrou suivant est le **maillage CPU d'une tuile**, toujours synchrone sur le
|
||||
thread de rendu : un thread de maillage dedie est la suite logique.
|
||||
4. **Index buffer partage** entre toutes les tuiles, et **sommet allege** (delta
|
||||
4. ~~**Index buffer partage** et **sommet allege**~~ **FAITS EN PHASE 32**
|
||||
(topologie uint16 unique, TerrainVertex de 16 o). Suite possible : tirer
|
||||
les altitudes d'un SSBO (16 -> ~4,5 o/sommet), voir NOTES-PHASE32.md.
|
||||
Texte d'origine : **Index buffer partage** entre toutes les tuiles, et **sommet allege** (delta
|
||||
de morphing plutot que position complete) : deux economies faciles, chiffrees
|
||||
dans NOTES-PHASE10.md. Le partage de l'index buffer economiserait aussi
|
||||
98 Ko par tuile epinglee.
|
||||
@@ -2686,3 +2723,41 @@ Tests **3807/3807** (3636 avant), 0 `[Validation]` au demarrage.
|
||||
- Demo : `dist\VercoraDemo-candidate(.zip)` = 110,7 Mio, avec les 4 cartes de couvert et
|
||||
`precip.*.spv` ; teste depuis I: et OK. `dist\VercoraDemo` NON remplace (decision
|
||||
utilisateur). `deploy_beta_to_desktop.ps1` est a revoir.
|
||||
## PHASE 32 (2026-10-13/14) - optimisation des ressources (detail : NOTES-PHASE32.md)
|
||||
|
||||
Session cloud (Linux, sans GPU ni donnees LiDAR) : mesure sous **lavapipe +
|
||||
Xvfb** (rendu logiciel DETERMINISTE : deux runs identiques = 0 pixel
|
||||
d'ecart, donc preuves au bit pres possibles) sur une **zone proxy** a la
|
||||
vraie echelle (`tools/make_bench_zone.py` : relief fBm 5001 x 5001, georef
|
||||
et altitudes de la vraie zone, couvert tire de l'orthophoto versionnee).
|
||||
Les chiffres sont comparables avant/apres, PAS a ceux de l'UHD 770.
|
||||
|
||||
- **Build Linux** : GCC 13 / Clang 18 (`= {}` sur struct imbriquee ->
|
||||
surcharges, CWG 1397 ; `GLFW_INCLUDE_NONE`). `cmake -G Ninja
|
||||
-DGLFW_BUILD_WAYLAND=OFF`. Tests 3 963 / 3 963 (+20).
|
||||
- **Instrumentation** : toute memoire GPU via `VulkanContext::allocateMemory`
|
||||
(comptee), RAM via `core/ProcessMemory`, ligne `Ressources (PHASE 32)` au
|
||||
chargement / toutes les 10 s / en fin de partie. Options `--quit-after=S`,
|
||||
`--freeze-anim`, `--force-staging`, `--vsync`.
|
||||
- **Geometrie** : `Vertex` (68 o) reste le format CPU ; GPU = `ObjectVertex`
|
||||
44 o (exact) et `TerrainVertex` 16 o (x/z/UV/morph recalcules par
|
||||
terrain.vert depuis `gl_VertexIndex` + `DrawItem::grid`, `precise`).
|
||||
Topologie des tuiles partagee en uint16. `GpuBufferPool` (blocs 4 Mo) :
|
||||
ecriture DIRECTE en memoire unifiee, staging + barriere VERTEX_INPUT ->
|
||||
TRANSFER sinon. Tuiles interieures construites sans relecture (bit a bit).
|
||||
- **Rendu** : terrain dessine en DERNIER (early-Z) + culling de ses faces
|
||||
arriere. Orthophoto lue par tranches dans un staging de 4 Mo reutilise.
|
||||
- **Bilan survol 900 m/s** : pic GPU 285 -> 87 Mo, terrain 188 -> 33 Mo,
|
||||
vkAllocateMemory ~17 000 -> 22, streaming 4,3 -> 0,93 ms/image.
|
||||
Foret : pic GPU 103 -> 56 Mo, +44 % d'images/s (lavapipe). Chargement :
|
||||
pic RAM -68 Mo, pic GPU 89 -> 50 Mo.
|
||||
- **Image** : quantification des normales (+/- 1 niveau sur ~0,04 % des
|
||||
pixels), egalites de profondeur aux pieds des brins/troncs (24 px), et
|
||||
~250 px isoles sur parois rasantes (culling). Staging, parallele, ortho,
|
||||
tuiles rapides : identiques au bit pres a ce qu'ils remplacent.
|
||||
- **Validation** : 0 message (standard ET synchronisation, chemins direct et
|
||||
staging). Controle negatif : sans la barriere, 414 SYNC-HAZARD en survol.
|
||||
- **PIEGE** pour les comparaisons d'images : la FAUNE bouge en temps reel ;
|
||||
comparer avec `--no-wildlife`, sinon un animal deplace fait 6-11 pixels.
|
||||
- **A faire sur la machine de dev** : re-mesurer en Release sur l'UHD 770
|
||||
(profile_phase27/29.ps1, run_vulkan_check.ps1 complet).
|
||||
@@ -116,3 +116,17 @@ Le projet Vercora est sur des fondations techniques saines, stables et vérifié
|
||||
3. **Écosystème Faune & Flore :**
|
||||
- Comportements étendus de la faune (troupeaux, pâturage, cycles repos/déplacement selon l'heure météo).
|
||||
- Cueillette de baies / champignons selon l'humidité et le couvert forestier.
|
||||
|
||||
---
|
||||
|
||||
## Suite donnee (Phase 32, 2026-10-13)
|
||||
|
||||
L'optimisation des ressources de `NOTES-PHASE32.md` reprend ce rapport :
|
||||
- **D6** (heightmap entiere en RAM) : examine et CONSERVE - c'est la verite
|
||||
physique, et ses altitudes ne se codent pas sans perte sur 16 bits.
|
||||
- Les postes que cet audit ne chiffrait pas (format de sommet de 68 o,
|
||||
topologie recopiee par tuile, une allocation Vulkan par buffer, staging en
|
||||
memoire unifiee) sont traites : pic GPU du survol 285 -> 87 Mo,
|
||||
~17 000 -> 22 `vkAllocateMemory` en 30 s.
|
||||
- Le projet compile aussi sous Linux (GCC, Clang) et se mesure sans GPU
|
||||
(lavapipe), voir `README.md`.
|
||||
@@ -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
|
||||
@@ -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
@@ -1,10 +1,10 @@
|
||||
#version 450
|
||||
|
||||
// Meme bloc uniforme que les shaders du cube, avec un membre supplementaire en
|
||||
// fin de bloc (terrain). Cote C++ il n'y a qu'une seule struct
|
||||
// UniformBufferObject : les shaders du cube declarent simplement une version
|
||||
// tronquee du bloc, ce qui est legal (la plage du descriptor peut etre plus
|
||||
// grande que le bloc declare, jamais l'inverse).
|
||||
// Meme bloc uniforme que les shaders du cube, avec des membres supplementaires
|
||||
// en fin de bloc. Cote C++ il n'y a qu'une seule struct UniformBufferObject :
|
||||
// les shaders declarent chacun la version tronquee du bloc qui leur suffit, ce
|
||||
// qui est legal (la plage du descriptor peut etre plus grande que le bloc
|
||||
// declare, jamais l'inverse).
|
||||
layout(binding = 0) uniform UniformBufferObject {
|
||||
mat4 view;
|
||||
mat4 proj;
|
||||
@@ -14,39 +14,82 @@ layout(binding = 0) uniform UniformBufferObject {
|
||||
// quels que soient les parametres de generation (et demain, les vraies
|
||||
// altitudes LiDAR, qui seront en metres NGF et pas du tout dans [0,16]).
|
||||
vec4 terrain;
|
||||
vec4 sun;
|
||||
vec4 sunColor;
|
||||
vec4 fog;
|
||||
vec4 precip;
|
||||
vec4 fall;
|
||||
vec4 detail;
|
||||
// PHASE 32 : la grille de la heightmap. x = origine (Heightmap::
|
||||
// worldCoord(0)), y = pas en metres, z = nombre de CELLULES par cote.
|
||||
vec4 terrainGrid;
|
||||
} ubo;
|
||||
|
||||
// Meme push constant que cube.vert : les deux pipelines partagent la meme
|
||||
// Meme push constant que cube.vert : les pipelines partagent la meme
|
||||
// signature de layout, ce qui permet au Renderer de pousser la model matrix de
|
||||
// la meme facon quel que soit le materiau.
|
||||
// params.x = debut de la bande de geomorphing, params.y = fin, en metres depuis
|
||||
// la camera. Bande vide (y <= x) = pas de morphing : c'est le cas du terrain
|
||||
// dessine d'un seul bloc (option --no-lod).
|
||||
// grid (PHASE 32) : place du maillage dans la grille de la heightmap -
|
||||
// x, y = indices (ix, iz) du premier sommet, z = pas en echantillons entre deux
|
||||
// sommets voisins, w = sommets par rangee. Voir renderer/DrawItem.hpp.
|
||||
layout(push_constant) uniform PushConstants {
|
||||
mat4 model;
|
||||
vec4 params;
|
||||
ivec4 grid;
|
||||
} pc;
|
||||
|
||||
layout(location = 0) in vec3 inPosition;
|
||||
layout(location = 1) in vec3 inColor;
|
||||
layout(location = 2) in vec3 inNormal;
|
||||
// UV du sommet sur TOUT le terrain (0,0 au coin nord-ouest, 1,1 au sud-est),
|
||||
// et non sur la tuile de quadtree : c'est ce qui rend la coordonnee continue
|
||||
// d'une tuile a l'autre et independante du niveau de detail. Voir
|
||||
// TerrainNodeMesh.cpp. PHASE 11 : desormais consomme, pour l'orthophoto.
|
||||
layout(location = 3) in vec2 inUV;
|
||||
|
||||
// PHASE 10 - cible de geomorphing : position et normale de ce sommet dans la
|
||||
// grille du niveau de detail SUPERIEUR (voir renderer/TerrainNodeMesh.hpp).
|
||||
layout(location = 4) in vec3 inMorphPos;
|
||||
layout(location = 5) in vec3 inMorphNormal;
|
||||
// PHASE 32 : 16 octets par sommet au lieu de 68 (renderer/GpuVertex.hpp,
|
||||
// TerrainVertex). Le buffer ne porte plus que ce qui ne se DEDUIT pas de
|
||||
// l'indice du sommet : les deux altitudes et les deux normales (x et z en
|
||||
// snorm16, y reconstruit). Position horizontale, cible de morphing horizontale
|
||||
// et UV sont recalcules ci-dessous ; la couleur de sommet valait toujours blanc.
|
||||
layout(location = 0) in float inHeight;
|
||||
layout(location = 1) in float inMorphHeight;
|
||||
layout(location = 2) in vec2 inNormalXZ;
|
||||
layout(location = 3) in vec2 inMorphNormalXZ;
|
||||
|
||||
layout(location = 0) out vec3 fragTint;
|
||||
layout(location = 1) out vec3 fragNormal;
|
||||
layout(location = 2) out vec3 fragWorldPos;
|
||||
layout(location = 3) out vec2 fragUV;
|
||||
|
||||
// Une normale de champ de hauteur pointe toujours vers le haut : y se deduit de
|
||||
// x et z. Meme formule que unpackTerrainNormal (renderer/GpuVertex.hpp).
|
||||
vec3 decodeNormal(vec2 xz) {
|
||||
return vec3(xz.x, sqrt(max(0.0, 1.0 - xz.x * xz.x - xz.y * xz.y)), xz.y);
|
||||
}
|
||||
|
||||
void main() {
|
||||
// --- Place du sommet dans la grille -----------------------------------
|
||||
// gl_VertexIndex est l'indice LOCAL du sommet dans son maillage : le
|
||||
// Renderer lie chaque maillage a son decalage dans le bloc partage plutot
|
||||
// que de passer un vertexOffset au draw (voir Renderer::recordCommandBuffer).
|
||||
// Les indices de grille sont ECRETES sur le bord du terrain exactement comme
|
||||
// le fait TerrainNodeMesh.cpp, et la cible de morphing est le sommet aux
|
||||
// indices locaux arrondis au pair inferieur (grille du parent).
|
||||
const int perRow = pc.grid.w;
|
||||
const int i = gl_VertexIndex % perRow;
|
||||
const int j = gl_VertexIndex / perRow;
|
||||
const int cells = int(ubo.terrainGrid.z);
|
||||
const int gx = min(pc.grid.x + i * pc.grid.z, cells);
|
||||
const int gz = min(pc.grid.y + j * pc.grid.z, cells);
|
||||
const int mx = min(pc.grid.x + (i & ~1) * pc.grid.z, cells);
|
||||
const int mz = min(pc.grid.y + (j & ~1) * pc.grid.z, cells);
|
||||
|
||||
// `precise` : interdit au compilateur de fusionner la multiplication et
|
||||
// l'addition en un FMA. Sans lui le resultat pourrait differer d'un ULP de
|
||||
// Heightmap::worldCoord ; avec lui il est identique AU BIT PRES (addition et
|
||||
// multiplication flottantes sont correctement arrondies en Vulkan).
|
||||
precise float x = ubo.terrainGrid.x + float(gx) * ubo.terrainGrid.y;
|
||||
precise float z = ubo.terrainGrid.x + float(gz) * ubo.terrainGrid.y;
|
||||
precise float morphX = ubo.terrainGrid.x + float(mx) * ubo.terrainGrid.y;
|
||||
precise float morphZ = ubo.terrainGrid.x + float(mz) * ubo.terrainGrid.y;
|
||||
|
||||
const vec3 inPosition = vec3(x, inHeight, z);
|
||||
const vec3 inMorphPos = vec3(morphX, inMorphHeight, morphZ);
|
||||
|
||||
// --- Geomorphing (CDLOD) ------------------------------------------------
|
||||
// La distance est mesuree sur la position NON MORPHEE : c'est ce qui garantit
|
||||
// qu'un sommet partage par deux tuiles voisines obtient le meme facteur des
|
||||
@@ -64,23 +107,26 @@ void main() {
|
||||
}
|
||||
|
||||
vec3 position = mix(inPosition, inMorphPos, morph);
|
||||
vec3 normal = mix(inNormal, inMorphNormal, morph);
|
||||
vec3 normal = mix(decodeNormal(inNormalXZ), decodeNormal(inMorphNormalXZ), morph);
|
||||
|
||||
vec4 worldPos = pc.model * vec4(position, 1.0);
|
||||
|
||||
gl_Position = ubo.proj * ubo.view * worldPos;
|
||||
fragWorldPos = worldPos.xyz;
|
||||
fragTint = inColor;
|
||||
// Teinte neutre, reservee a une future classification LiDAR par sommet :
|
||||
// c'est la valeur que portaient tous les sommets de terrain jusqu'ici.
|
||||
fragTint = vec3(1.0);
|
||||
|
||||
// L'UV n'est PAS morphe. Il est deja une fonction affine de la position dans
|
||||
// la grille du terrain entier, donc la cible de morphing d'un sommet - qui
|
||||
// est un autre noeud de cette meme grille - a naturellement l'UV de sa
|
||||
// propre position. Interpoler entre les deux decalerait la photo par rapport
|
||||
// au relief pendant la transition de niveau, exactement ce qu'on cherche a
|
||||
// L'UV n'est PAS morphe. Il est une fonction affine de la position dans la
|
||||
// grille du terrain entier, donc la cible de morphing d'un sommet - qui est
|
||||
// un autre noeud de cette meme grille - a naturellement l'UV de sa propre
|
||||
// position. Interpoler entre les deux decalerait la photo par rapport au
|
||||
// relief pendant la transition de niveau, exactement ce qu'on cherche a
|
||||
// eviter. Le leger glissement de la texture qu'on pourrait attendre pendant
|
||||
// un morph est en realite le comportement CORRECT : la surface se deforme,
|
||||
// la photo reste accrochee a ses coordonnees geographiques.
|
||||
fragUV = inUV;
|
||||
// la photo reste accrochee a ses coordonnees geographiques. Meme expression
|
||||
// que TerrainNodeMesh.cpp (indice de grille / nombre de cellules).
|
||||
fragUV = vec2(float(gx), float(gz)) / float(cells);
|
||||
|
||||
// Le terrain est genere DIRECTEMENT en espace monde et son DrawItem porte la
|
||||
// matrice IDENTITE : mat3(model) est donc exact ici sans discussion. Il
|
||||
|
||||
@@ -95,7 +95,14 @@ public:
|
||||
// Genere immediatement la grille par bruit fractal. Lance
|
||||
// std::runtime_error si les parametres ne peuvent pas produire une surface
|
||||
// (resolution < 2, taille <= 0, ...).
|
||||
explicit Heightmap(const Params& params = {});
|
||||
explicit Heightmap(const Params& params);
|
||||
|
||||
// Memes parametres par defaut. Une SURCHARGE plutot qu'un argument par
|
||||
// defaut `= {}` : GCC et Clang refusent de construire une struct IMBRIQUEE
|
||||
// dotee d'initialiseurs de membres dans un argument par defaut de la classe
|
||||
// englobante (CWG 1397), la ou MSVC l'accepte. Le corps d'une fonction
|
||||
// membre, lui, voit la classe complete : la delegation compile partout.
|
||||
explicit Heightmap() : Heightmap(Params{}) {}
|
||||
|
||||
// Adopte une grille DEJA CONSTRUITE, sans rien generer : c'est par ici
|
||||
// qu'entrent les donnees LiDAR (voir assets/TerrainFile.hpp).
|
||||
@@ -154,6 +161,12 @@ public:
|
||||
// [0, resolution-1] : appeler avec ix = -1 renvoie la colonne 0.
|
||||
float at(int64_t ix, int64_t iz) const;
|
||||
|
||||
// PHASE 32. La grille brute, [iz * resolution + ix], en lecture seule. Pour
|
||||
// les boucles chaudes qui ont DEJA etabli que leurs indices sont dans la
|
||||
// grille et n'ont donc que faire de l'ecretage de at() - la construction
|
||||
// des tuiles interieures du quadtree (renderer/TerrainNodeMesh.cpp).
|
||||
const float* rawHeights() const { return heights_.data(); }
|
||||
|
||||
// Position monde d'un echantillon (le long de X pour ix, de Z pour iz).
|
||||
float worldCoord(uint32_t index) const;
|
||||
|
||||
|
||||
@@ -57,7 +57,7 @@ double TextureData::metresPerTexel() const {
|
||||
return 0.5 * (perX + perY);
|
||||
}
|
||||
|
||||
TextureData loadTextureFile(const std::string& path) {
|
||||
TextureData loadTextureFileHeader(const std::string& path) {
|
||||
std::ifstream file(path, std::ios::binary);
|
||||
if (!file) {
|
||||
throw std::runtime_error("Texture : fichier introuvable ou illisible : " + path);
|
||||
@@ -148,13 +148,6 @@ TextureData loadTextureFile(const std::string& path) {
|
||||
". Fichier tronque ou en-tete incoherent.");
|
||||
}
|
||||
|
||||
file.seekg(static_cast<std::streamoff>(kHeaderSize), std::ios::beg);
|
||||
texture.pixels.resize(static_cast<std::size_t>(total));
|
||||
if (!file.read(reinterpret_cast<char*>(texture.pixels.data()),
|
||||
static_cast<std::streamsize>(total))) {
|
||||
throw std::runtime_error("Texture : lecture interrompue dans " + path + ".");
|
||||
}
|
||||
|
||||
logInfo("Texture : " + texture.label + " " + std::to_string(texture.width) + "x" +
|
||||
std::to_string(texture.height) + ", " + std::to_string(mipLevels) +
|
||||
" mipmaps, " +
|
||||
@@ -164,4 +157,33 @@ TextureData loadTextureFile(const std::string& path) {
|
||||
return texture;
|
||||
}
|
||||
|
||||
void readTexturePayload(std::istream& file, uint64_t offset, uint64_t bytes,
|
||||
void* destination) {
|
||||
file.seekg(static_cast<std::streamoff>(kHeaderSize + offset), std::ios::beg);
|
||||
if (!file.read(static_cast<char*>(destination), static_cast<std::streamsize>(bytes))) {
|
||||
throw std::runtime_error("Texture : lecture interrompue (" + std::to_string(bytes) +
|
||||
" octets a l'offset " + std::to_string(offset) + ").");
|
||||
}
|
||||
}
|
||||
|
||||
void readTexturePayload(const std::string& path, const TextureData& header,
|
||||
void* destination) {
|
||||
std::ifstream file(path, std::ios::binary);
|
||||
if (!file) {
|
||||
throw std::runtime_error("Texture : fichier introuvable ou illisible : " + path);
|
||||
}
|
||||
try {
|
||||
readTexturePayload(file, 0, header.payloadSize(), destination);
|
||||
} catch (const std::exception&) {
|
||||
throw std::runtime_error("Texture : lecture interrompue dans " + path + ".");
|
||||
}
|
||||
}
|
||||
|
||||
TextureData loadTextureFile(const std::string& path) {
|
||||
TextureData texture = loadTextureFileHeader(path);
|
||||
texture.pixels.resize(static_cast<std::size_t>(texture.payloadSize()));
|
||||
readTexturePayload(path, texture, texture.pixels.data());
|
||||
return texture;
|
||||
}
|
||||
|
||||
} // namespace vercora
|
||||
@@ -1,6 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <istream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
@@ -57,6 +58,12 @@ struct TextureData {
|
||||
// journal de demarrage : c'est le chiffre qui dit si la texture est a la
|
||||
// hauteur du niveau de detail du terrain.
|
||||
double metresPerTexel() const;
|
||||
|
||||
// PHASE 32. Octets de TOUTE la chaine de mipmaps, deduits des niveaux :
|
||||
// c'est la taille de `pixels` une fois charge, et celle du staging.
|
||||
uint64_t payloadSize() const {
|
||||
return mips.empty() ? 0 : mips.back().offset + mips.back().size;
|
||||
}
|
||||
};
|
||||
|
||||
// Charge un .vcto. Lance std::runtime_error avec un message exploitable si le
|
||||
@@ -65,6 +72,20 @@ struct TextureData {
|
||||
// annonces, ...).
|
||||
TextureData loadTextureFile(const std::string& path);
|
||||
|
||||
// PHASE 32. Les deux moities de loadTextureFile, pour ne jamais tenir la
|
||||
// charge utile en RAM : l'en-tete d'abord (memes controles, taille du fichier
|
||||
// comprise, `pixels` reste VIDE), puis la lecture des `payloadSize()` octets
|
||||
// directement la ou l'appelant les veut - en pratique le staging mappe de la
|
||||
// texture GPU (Renderer::setTerrainTextureFromFile). Sur l'orthophoto de la
|
||||
// zone, c'est une copie de 42 Mo de moins au chargement, et autant de pic RAM.
|
||||
TextureData loadTextureFileHeader(const std::string& path);
|
||||
void readTexturePayload(const std::string& path, const TextureData& header, void* destination);
|
||||
|
||||
// Variante par TRANCHE, sur un fichier deja ouvert : `bytes` octets de la
|
||||
// charge utile a partir de son octet `offset`. Sert au televersement par
|
||||
// bandes de Texture (staging de 4 Mo au plus).
|
||||
void readTexturePayload(std::istream& file, uint64_t offset, uint64_t bytes, void* destination);
|
||||
|
||||
// Nombre d'octets d'un niveau de mipmap pour un format donne. Expose parce que
|
||||
// c'est la seule formule qui lie les deux formats a leur taille, et que le
|
||||
// chargeur ET les tests s'en servent.
|
||||
|
||||
@@ -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
|
||||
@@ -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
@@ -11,6 +11,7 @@
|
||||
#include "editor/AssetCatalog.hpp"
|
||||
#include "editor/EditorController.hpp"
|
||||
#include "core/Paths.hpp"
|
||||
#include "core/ProcessMemory.hpp"
|
||||
#include "editor/EditorScene.hpp"
|
||||
#include "editor/PlacedObject.hpp"
|
||||
#include "editor/SceneFile.hpp"
|
||||
@@ -137,6 +138,20 @@ namespace {
|
||||
// objets poses, eux, font partie du monde et sont affiches et solides dans le
|
||||
// jeu normal - c'est justement le point.
|
||||
//
|
||||
// Plus deux options de la Phase 32, pour le BANC DE MESURE (voir NOTES-PHASE32.md) :
|
||||
// vercora.exe [scene] --quit-after=S -> fermeture propre apres S secondes
|
||||
// de boucle, bilans de fin compris
|
||||
// vercora.exe [scene] --freeze-anim -> horloge d'animation des shaders
|
||||
// figee : images comparables au
|
||||
// pixel pres d'un run a l'autre
|
||||
// vercora.exe [scene] --force-staging -> geometrie televersee par staging
|
||||
// meme en memoire unifiee (chemin
|
||||
// d'un GPU discret, a eprouver)
|
||||
// vercora.exe [scene] --vsync -> presentation calee sur l'ecran
|
||||
// (FIFO) : la cadence ne depasse
|
||||
// plus le rafraichissement, CPU et
|
||||
// GPU dorment le reste du temps
|
||||
//
|
||||
// Le terrain synthetique n'est PAS supprime, et pour deux raisons distinctes :
|
||||
// il reste la scene de reference des tests (monde deterministe, arbres a
|
||||
// positions connues, cf. dumpWorld plus bas), et il sert de repli si le
|
||||
@@ -873,6 +888,27 @@ int main(int argc, char** argv) {
|
||||
std::string sceneFileArgument;
|
||||
std::string editorAssetsArgument;
|
||||
std::string sceneArgument;
|
||||
// PHASE 32 : outils de BANC DE MESURE.
|
||||
// --quit-after=S ferme proprement le jeu apres S secondes de boucle,
|
||||
// comme une fermeture de fenetre : tous les bilans de
|
||||
// fin de partie sont ecrits. Remplace le WM_CLOSE poste
|
||||
// de l'exterieur, que la Phase 26 a vu arriver en retard
|
||||
// sur une machine chargee.
|
||||
// --freeze-anim fige l'horloge d'ANIMATION des shaders (ondulation
|
||||
// de l'herbe, chute de la pluie) a zero. Avec
|
||||
// --lock-input, --look et --time-scale=0, deux images
|
||||
// d'une meme scene deviennent comparables au pixel pres,
|
||||
// ce qui est la condition pour prouver qu'une
|
||||
// optimisation ne change pas l'image.
|
||||
float quitAfterSeconds = 0.0f;
|
||||
bool freezeAnimation = false;
|
||||
// PHASE 32 : --force-staging televerse la geometrie par staging meme en
|
||||
// memoire unifiee (le chemin d'un GPU discret), pour l'eprouver ici.
|
||||
bool forceStaging = false;
|
||||
// PHASE 32 : --vsync, presentation FIFO calee sur l'ecran. Le reglage a
|
||||
// prendre pour JOUER (consommation, chauffe, pas de dechirure) ; les
|
||||
// mesures gardent le defaut non plafonne.
|
||||
bool vsync = false;
|
||||
for (int i = 1; i < argc; ++i) {
|
||||
const std::string argument = argv[i];
|
||||
if (argument == "--dump-world") {
|
||||
@@ -1029,6 +1065,24 @@ int main(int argc, char** argv) {
|
||||
}
|
||||
} else if (argument.rfind("--ortho=", 0) == 0) {
|
||||
orthoArgument = argument.substr(std::strlen("--ortho="));
|
||||
} else if (argument.rfind("--quit-after=", 0) == 0) {
|
||||
try {
|
||||
quitAfterSeconds =
|
||||
std::stof(argument.substr(std::strlen("--quit-after=")));
|
||||
if (!(quitAfterSeconds > 0.0f)) {
|
||||
logWarn("--quit-after attend une duree positive en secondes. Ignore.");
|
||||
quitAfterSeconds = 0.0f;
|
||||
}
|
||||
} catch (const std::exception&) {
|
||||
logWarn("--quit-after : duree illisible. Ignore : " + argument);
|
||||
quitAfterSeconds = 0.0f;
|
||||
}
|
||||
} else if (argument == "--freeze-anim") {
|
||||
freezeAnimation = true;
|
||||
} else if (argument == "--force-staging") {
|
||||
forceStaging = true;
|
||||
} else if (argument == "--vsync") {
|
||||
vsync = true;
|
||||
} else if (argument.rfind("--", 0) == 0) {
|
||||
logWarn("Option inconnue, ignoree : " + argument);
|
||||
} else if (sceneArgument.empty()) {
|
||||
@@ -1163,7 +1217,11 @@ int main(int argc, char** argv) {
|
||||
CompositeCollisionSolver worldSolver;
|
||||
|
||||
MeshData sceneMesh;
|
||||
// PHASE 32 : le terrain d'un seul bloc (--no-lod) au format GPU compact.
|
||||
TerrainGpuMesh sceneTerrain;
|
||||
RenderOptions renderOptions;
|
||||
renderOptions.forceStaging = forceStaging;
|
||||
renderOptions.vsync = vsync;
|
||||
|
||||
Inventory inventory;
|
||||
|
||||
@@ -1183,7 +1241,10 @@ int main(int argc, char** argv) {
|
||||
// produisait 25 M de sommets et 50 M de triangles cote CPU,
|
||||
// recopies ensuite sur le GPU.
|
||||
if (!dumpWorldOnly && !useLod) {
|
||||
sceneMesh = terrainMeshData(*heightmap);
|
||||
// PHASE 32 : directement au format GPU du terrain (16 octets par
|
||||
// sommet), sans le MeshData de 68 octets par sommet - 1,7 Go de
|
||||
// moins au pic sur la zone au pas de 1 m.
|
||||
sceneTerrain = terrainGpuMeshData(*heightmap);
|
||||
}
|
||||
|
||||
renderOptions.heightRange = { heightmap->minHeight(), heightmap->maxHeight() };
|
||||
@@ -1265,8 +1326,19 @@ int main(int argc, char** argv) {
|
||||
// nombre d'instances qui les utiliseront ensuite.
|
||||
// Avec le quadtree, il n'y a pas de geometrie de scene unique : chaque
|
||||
// tuile est enregistree et liberee par le TerrainStreamer.
|
||||
const MeshHandle sceneMeshHandle =
|
||||
MeshHandle sceneMeshHandle =
|
||||
sceneMesh.empty() ? kInvalidMesh : renderer.addMesh(sceneMesh);
|
||||
if (!sceneTerrain.vertices.empty()) {
|
||||
sceneMeshHandle = renderer.addTerrainMesh(sceneTerrain.vertices, sceneTerrain.indices,
|
||||
sceneTerrain.name);
|
||||
sceneTerrain = TerrainGpuMesh{}; // la copie CPU n'a plus de raison d'etre
|
||||
}
|
||||
// PHASE 32 : la grille de la heightmap, dont terrain.vert deduit la
|
||||
// position horizontale et l'UV de chaque sommet de terrain.
|
||||
if (terrainScene) {
|
||||
renderer.setTerrainGrid(heightmap->worldCoord(0), heightmap->spacing(),
|
||||
heightmap->resolution() - 1);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// 2 bis. Orthophoto (Phase 11). Chargee APRES le Renderer, qui possede
|
||||
@@ -1290,11 +1362,14 @@ int main(int argc, char** argv) {
|
||||
" -i data/ortho -o " + orthoPath);
|
||||
} else {
|
||||
try {
|
||||
const TextureData ortho = loadTextureFile(orthoPath);
|
||||
// PHASE 32 : l'en-tete seul d'abord (controle d'emprise), puis
|
||||
// les 42 Mo de texels lus directement dans le staging de la
|
||||
// texture - jamais tenus en RAM a cote.
|
||||
const TextureData ortho = loadTextureFileHeader(orthoPath);
|
||||
if (orthoMatchesTerrain(ortho, *heightmap)) {
|
||||
renderer.setTerrainTexture(ortho);
|
||||
renderer.setTerrainTextureFromFile(ortho, orthoPath);
|
||||
renderer.setOrthoMix(1.0f);
|
||||
groundDetailPattern = ortho.metresPerTexel();
|
||||
groundDetailPattern = static_cast<float>(ortho.metresPerTexel());
|
||||
logInfo("Orthophoto : " +
|
||||
std::to_string(ortho.metresPerTexel()) +
|
||||
" m/texel pour un terrain au pas de " +
|
||||
@@ -2289,9 +2364,28 @@ int main(int argc, char** argv) {
|
||||
// fenetre, dont la Phase 18 a montre qu'il varie de ~15 % entre deux
|
||||
// runs identiques. Chargement exclu : il precede la boucle.
|
||||
const auto loopStart = ProfileClock::now();
|
||||
// PHASE 32 : bilan des ressources une fois le monde charge, avant la
|
||||
// premiere image. Le meme bilan est ecrit toutes les 10 s, puis a la
|
||||
// fermeture avec les pics de la session.
|
||||
logInfo("Ressources apres chargement (PHASE 32) : " + processMemoryLine() + ", " +
|
||||
context.gpuMemoryLine() + ".");
|
||||
double lastResourceLog = 0.0;
|
||||
while (!window.shouldClose()) {
|
||||
window.pollEvents();
|
||||
|
||||
const double loopSeconds =
|
||||
std::chrono::duration<double>(ProfileClock::now() - loopStart).count();
|
||||
if (quitAfterSeconds > 0.0f && loopSeconds >= quitAfterSeconds) {
|
||||
logInfo("--quit-after : " + std::to_string(quitAfterSeconds) +
|
||||
" s de boucle ecoulees, fermeture.");
|
||||
break;
|
||||
}
|
||||
if (loopSeconds - lastResourceLog >= 10.0) {
|
||||
lastResourceLog = loopSeconds;
|
||||
logInfo("Ressources (PHASE 32) : " + processMemoryLine() + ", " +
|
||||
context.gpuMemoryLine() + ". " + renderer.geometryLine() + ".");
|
||||
}
|
||||
|
||||
const double now = glfwGetTime();
|
||||
const float deltaTime = static_cast<float>(now - lastTime);
|
||||
lastTime = now;
|
||||
@@ -2301,6 +2395,9 @@ int main(int argc, char** argv) {
|
||||
// demarrage, donc la valeur reste petite et n'use pas la precision
|
||||
// d'un float, contrairement a une horloge absolue.
|
||||
const float elapsedSeconds = static_cast<float>(now);
|
||||
// PHASE 32 : horloge des SHADERS seulement (--freeze-anim). La
|
||||
// logique de jeu garde elapsedSeconds.
|
||||
const float animationSeconds = freezeAnimation ? 0.0f : elapsedSeconds;
|
||||
|
||||
// --- Bascule du MODE EDITEUR (PHASE 15) ------------------------
|
||||
// Traitee AVANT camera.update : entrer en edition change le mode et
|
||||
@@ -3506,9 +3603,13 @@ int main(int argc, char** argv) {
|
||||
frameProfile.streamingMicros += profileMicros(tf1, tf2);
|
||||
} else if (sceneMeshHandle != kInvalidMesh) {
|
||||
// Terrain d'un seul bloc : sommets deja en coordonnees monde
|
||||
// -> matrice identite, et pas de bande de morphing.
|
||||
drawItems.push_back({ sceneMeshHandle, glm::mat4(1.0f),
|
||||
Material::Terrain });
|
||||
// -> matrice identite, et pas de bande de morphing. PHASE 32 :
|
||||
// une seule "tuile" qui couvre toute la grille au pas 1.
|
||||
DrawItem terrainItem{ sceneMeshHandle, glm::mat4(1.0f),
|
||||
Material::Terrain };
|
||||
terrainItem.grid = glm::ivec4(0, 0, 1,
|
||||
static_cast<int32_t>(heightmap->resolution()));
|
||||
drawItems.push_back(terrainItem);
|
||||
}
|
||||
|
||||
for (const Tree& tree : forest->trees()) {
|
||||
@@ -3682,7 +3783,7 @@ int main(int argc, char** argv) {
|
||||
item.count = static_cast<uint32_t>(instances.size());
|
||||
item.material = Material::Foliage;
|
||||
// Amplitude d'ondulation NULLE : un tronc ne plie pas.
|
||||
item.params = { 0.0f, elapsedSeconds, 0.0f, 0.0f };
|
||||
item.params = { 0.0f, animationSeconds, 0.0f, 0.0f };
|
||||
instancedItems.push_back(item);
|
||||
};
|
||||
pushTrees(treeInstances, sceneryTreeMeshHandle);
|
||||
@@ -3703,7 +3804,7 @@ int main(int argc, char** argv) {
|
||||
// seul materiau qui s'en sert : un arbre pousse 0 et
|
||||
// traverse le meme pipeline, inchange.
|
||||
item.params = { vegetation->params().grassSway,
|
||||
elapsedSeconds, 0.0f,
|
||||
animationSeconds, 0.0f,
|
||||
vegetation->params().grassCutout };
|
||||
instancedItems.push_back(item);
|
||||
}
|
||||
@@ -3734,7 +3835,7 @@ int main(int argc, char** argv) {
|
||||
// pas par un masque - ces plantes sont peu nombreuses,
|
||||
// le budget de sommets n'est pas le sujet.
|
||||
item.params = { 0.35f * vegetation->params().grassSway,
|
||||
elapsedSeconds, 0.0f, 0.0f };
|
||||
animationSeconds, 0.0f, 0.0f };
|
||||
instancedItems.push_back(item);
|
||||
}
|
||||
}
|
||||
@@ -3760,7 +3861,7 @@ int main(int argc, char** argv) {
|
||||
item.instances = instances.data();
|
||||
item.count = static_cast<uint32_t>(instances.size());
|
||||
item.material = Material::Foliage;
|
||||
item.params = { 0.0f, elapsedSeconds, 0.0f, -1.0f };
|
||||
item.params = { 0.0f, animationSeconds, 0.0f, -1.0f };
|
||||
instancedItems.push_back(item);
|
||||
};
|
||||
pushRocks(boulderInstances, boulderMeshHandle);
|
||||
@@ -3786,7 +3887,7 @@ int main(int argc, char** argv) {
|
||||
item.instances = instances.data();
|
||||
item.count = static_cast<uint32_t>(instances.size());
|
||||
item.material = Material::Foliage;
|
||||
item.params = { sway, elapsedSeconds, 0.0f, 0.0f };
|
||||
item.params = { sway, animationSeconds, 0.0f, 0.0f };
|
||||
instancedItems.push_back(item);
|
||||
};
|
||||
pushBushes(shrubInstances, shrubMeshHandle, 0.04f);
|
||||
@@ -3846,7 +3947,7 @@ int main(int argc, char** argv) {
|
||||
renderer.setWeatherVisuals(visuals.fogColor, visuals.fogDensityPerMeter,
|
||||
visuals.precipitation, visuals.snow,
|
||||
visuals.fallVelocity, visuals.groundDarkening,
|
||||
elapsedSeconds);
|
||||
animationSeconds);
|
||||
frameProfile.weatherVisualsMicros += profileMicros(tw0, ProfileClock::now());
|
||||
|
||||
// Journal BORNE PAR LE TEMPS (lecon de la Phase 24 : "sur
|
||||
@@ -3918,6 +4019,12 @@ int main(int argc, char** argv) {
|
||||
// S'assurer que le GPU a fini avant de detruire quoi que ce soit.
|
||||
renderer.waitIdle();
|
||||
|
||||
// PHASE 32 : bilan des ressources, AVANT toute destruction - les chiffres
|
||||
// "vivants" sont donc ceux du jeu en regime etabli, les pics ceux de la
|
||||
// session entiere.
|
||||
logInfo("Ressources en fin de partie (PHASE 32) : " + processMemoryLine() + ", " +
|
||||
context.gpuMemoryLine() + ". " + renderer.geometryLine() + ".");
|
||||
|
||||
if (frameProfile.frames > 0) {
|
||||
const auto per = [&](uint64_t total) {
|
||||
const double value = static_cast<double>(total) /
|
||||
|
||||
@@ -76,6 +76,18 @@ struct DrawItem {
|
||||
// profondeur. Une force nulle - le cas de tous les DrawItem du jeu -
|
||||
// laisse le rendu strictement identique a celui d'avant la Phase 15.
|
||||
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
|
||||
|
||||
// PHASE 32, Material::Terrain seulement : ou se trouve le maillage dans la
|
||||
// grille de la heightmap, pour que terrain.vert y retrouve la position
|
||||
// horizontale et l'UV de chaque sommet a partir de gl_VertexIndex au lieu
|
||||
// de les lire dans le buffer (voir renderer/GpuVertex.hpp, TerrainVertex).
|
||||
// x, y = indices de grille (ix, iz) du premier sommet
|
||||
// z = pas, en echantillons de grille, entre deux sommets voisins
|
||||
// w = sommets par rangee
|
||||
// Une tuile de quadtree pousse (node.ix0, node.iz0, node.stride, 65) ; le
|
||||
// terrain d'un seul bloc (--no-lod) pousse (0, 0, 1, resolution).
|
||||
// Ignore par les autres materiaux.
|
||||
glm::ivec4 grid{0, 0, 1, 1};
|
||||
};
|
||||
|
||||
// Ce que le Renderer pousse REELLEMENT en push constant, dans cet ordre.
|
||||
@@ -85,12 +97,15 @@ struct DrawItem {
|
||||
// melanger obligerait a garder `mesh` et `material` - inutiles au GPU - dans un
|
||||
// budget de push constants qui ne fait que 128 octets garantis.
|
||||
//
|
||||
// 80 octets : toujours tres en dessous des 128 garantis par la spec Vulkan pour
|
||||
// maxPushConstantsSize.
|
||||
// 96 octets depuis la Phase 32 (le bloc `grid` du terrain) : toujours en
|
||||
// dessous des 128 garantis par la spec Vulkan pour maxPushConstantsSize.
|
||||
struct DrawItemPush {
|
||||
glm::mat4 model{1.0f};
|
||||
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
|
||||
glm::ivec4 grid{0, 0, 1, 1};
|
||||
};
|
||||
static_assert(sizeof(DrawItemPush) == 96 && sizeof(DrawItemPush) <= 128,
|
||||
"Le bloc de push constants doit tenir dans les 128 octets garantis.");
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PHASE 11 : dessin INSTANCIE
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
@@ -1,107 +1,20 @@
|
||||
#include "renderer/Mesh.hpp"
|
||||
|
||||
#include "core/Logger.hpp"
|
||||
#include "renderer/MeshData.hpp"
|
||||
#include "renderer/VulkanBuffer.hpp"
|
||||
#include "renderer/VulkanContext.hpp"
|
||||
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
namespace vercora {
|
||||
|
||||
Mesh::Mesh(VulkanContext& context,
|
||||
BufferUploader& uploader,
|
||||
const MeshData& data,
|
||||
bool log) {
|
||||
// --- Validation AVANT toute allocation Vulkan ---------------------------
|
||||
// Un index hors limites ne produit pas d'erreur a la creation du buffer :
|
||||
// il se manifesterait au draw, sous forme de lecture hors du vertex buffer
|
||||
// (comportement indefini cote GPU). Mieux vaut refuser ici, avec un message
|
||||
// qui dit quoi.
|
||||
if (data.vertices.empty()) {
|
||||
throw std::runtime_error("Mesh vide : aucun sommet (" + data.name + ").");
|
||||
Mesh::Mesh(GpuBufferPool& pool, VertexLayout layout,
|
||||
const GpuRange& vertices, uint32_t vertexCount,
|
||||
const GpuRange& indices, VkIndexType indexType, uint32_t indexCount,
|
||||
bool ownsIndices)
|
||||
: pool_(pool), layout_(layout), vertices_(vertices), indices_(indices),
|
||||
indexType_(indexType), vertexCount_(vertexCount), indexCount_(indexCount),
|
||||
ownsIndices_(ownsIndices) {}
|
||||
|
||||
Mesh::~Mesh() {
|
||||
pool_.release(vertices_);
|
||||
if (ownsIndices_) {
|
||||
pool_.release(indices_);
|
||||
}
|
||||
if (data.indices.empty()) {
|
||||
throw std::runtime_error("Mesh vide : aucun index (" + data.name + ").");
|
||||
}
|
||||
if (data.indices.size() % 3 != 0) {
|
||||
throw std::runtime_error(
|
||||
"Mesh non triangule : " + std::to_string(data.indices.size()) +
|
||||
" index, ce qui n'est pas un multiple de 3 (" + data.name + ").");
|
||||
}
|
||||
|
||||
const auto vertexCount = static_cast<uint32_t>(data.vertices.size());
|
||||
for (uint32_t index : data.indices) {
|
||||
if (index >= vertexCount) {
|
||||
throw std::runtime_error(
|
||||
"Index hors limites dans le mesh : " + std::to_string(index) +
|
||||
" pour " + std::to_string(vertexCount) + " sommets (" + data.name + ").");
|
||||
}
|
||||
}
|
||||
|
||||
vertexCount_ = vertexCount;
|
||||
indexCount_ = static_cast<uint32_t>(data.indices.size());
|
||||
|
||||
// --- Upload GPU ---------------------------------------------------------
|
||||
vertexBuffer_ = createDeviceLocalBuffer(
|
||||
context, uploader,
|
||||
data.vertices.data(),
|
||||
sizeof(data.vertices[0]) * data.vertices.size(),
|
||||
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
|
||||
|
||||
indexBuffer_ = createDeviceLocalBuffer(
|
||||
context, uploader,
|
||||
data.indices.data(),
|
||||
sizeof(data.indices[0]) * data.indices.size(),
|
||||
VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
|
||||
|
||||
if (log) {
|
||||
logInfo("Mesh charge sur le GPU : " + data.name + " - " +
|
||||
std::to_string(vertexCount_) + " sommets, " +
|
||||
std::to_string(indexCount_ / 3) + " triangles.");
|
||||
}
|
||||
}
|
||||
|
||||
Mesh::~Mesh() = default; // les buffers se detruisent avec leurs unique_ptr
|
||||
|
||||
std::unique_ptr<VulkanBuffer> Mesh::createDeviceLocalBuffer(
|
||||
VulkanContext& context,
|
||||
BufferUploader& uploader,
|
||||
const void* data,
|
||||
VkDeviceSize size,
|
||||
VkBufferUsageFlags usage) {
|
||||
// 1. Staging host-visible : accessible au CPU, on y ecrit la geometrie.
|
||||
auto staging = std::make_unique<VulkanBuffer>(
|
||||
context, size,
|
||||
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||||
staging->writeToBuffer(data, size);
|
||||
|
||||
// 2. Buffer final device-local : rapide pour le GPU, non mappable.
|
||||
auto buffer = std::make_unique<VulkanBuffer>(
|
||||
context, size,
|
||||
VK_BUFFER_USAGE_TRANSFER_DST_BIT | usage,
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
|
||||
// 3. PHASE 12 : la copie est CONFIEE, pas attendue. Le staging part avec
|
||||
// elle - il doit survivre jusqu'a l'execution de la frame qui portera la
|
||||
// commande de copie, ce qui n'est plus une duree connue ici. C'est tout
|
||||
// le changement : avant, cette ligne bloquait le thread jusqu'a ce que le
|
||||
// GPU ait vide sa queue.
|
||||
uploader.enqueueCopy(std::move(staging), buffer->handle());
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
void Mesh::bind(VkCommandBuffer commandBuffer) const {
|
||||
const VkBuffer buffers[] = { vertexBuffer_->handle() };
|
||||
const VkDeviceSize offsets[] = { 0 };
|
||||
vkCmdBindVertexBuffers(commandBuffer, 0, 1, buffers, offsets);
|
||||
|
||||
// uint32 : suffisant pour de gros meshes, indispensable pour du terrain
|
||||
// LiDAR plus tard (uint16 plafonnerait a 65536 sommets).
|
||||
vkCmdBindIndexBuffer(commandBuffer, indexBuffer_->handle(), 0, VK_INDEX_TYPE_UINT32);
|
||||
}
|
||||
|
||||
void Mesh::draw(VkCommandBuffer commandBuffer) const {
|
||||
|
||||
+46
-46
@@ -1,55 +1,50 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/GpuBufferPool.hpp"
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
|
||||
namespace vercora {
|
||||
|
||||
class VulkanContext;
|
||||
class VulkanBuffer;
|
||||
class BufferUploader;
|
||||
struct MeshData;
|
||||
// PHASE 32. Format des sommets d'un maillage, tel que son pipeline les lit
|
||||
// (voir renderer/GpuVertex.hpp). Un maillage de terrain ne peut etre dessine
|
||||
// qu'avec Material::Terrain, un maillage d'objet qu'avec les autres : le
|
||||
// Renderer ecarte tout DrawItem qui melangerait les deux, plutot que de laisser
|
||||
// le GPU lire 16 octets la ou il en attend 44.
|
||||
enum class VertexLayout : uint8_t {
|
||||
Object, // ObjectVertex, 44 octets
|
||||
Terrain, // TerrainVertex, 16 octets
|
||||
};
|
||||
|
||||
// Un mesh pret a etre dessine : vertex buffer + index buffer device-local et
|
||||
// leurs compteurs. Interchangeable par construction : le Renderer ne sait pas
|
||||
// d'ou vient la geometrie (fichier .obj, cube code en dur, terrain genere plus
|
||||
// tard), il recoit un Mesh et l'affiche.
|
||||
// Un maillage pret a etre dessine : une plage de sommets et une plage d'indices
|
||||
// dans les blocs partages du GpuBufferPool, et leurs compteurs.
|
||||
//
|
||||
// L'upload passe par VulkanBuffer (staging host-visible -> device-local), le
|
||||
// meme chemin que la Phase 1, factorise ici en une seule fonction.
|
||||
// PHASE 32 : un Mesh ne possede PLUS de buffer Vulkan. Il possede des PLAGES,
|
||||
// rendues au pool a sa destruction - laquelle est toujours differee par le
|
||||
// Renderer de kMaxFramesInFlight + 1 images, exactement comme l'etaient les
|
||||
// buffers jusqu'ici (voir Renderer::removeMesh). La topologie peut aussi etre
|
||||
// PARTAGEE (les tuiles de terrain en ont une seule pour toutes) : le Mesh ne la
|
||||
// rend alors pas, c'est le Renderer qui la possede.
|
||||
//
|
||||
// PHASE 12 : cet upload n'ATTEND PLUS le GPU. La copie est confiee a un
|
||||
// BufferUploader (le Renderer), qui l'enregistre en tete du command buffer de la
|
||||
// frame suivante ; le constructeur revient des que la geometrie a ete recopiee
|
||||
// dans un buffer staging, sans aucune synchronisation. Consequence a garder en
|
||||
// tete : les buffers du Mesh ne contiennent la geometrie qu'a partir de
|
||||
// l'execution de cette frame - c'est-a-dire avant tout draw qui pourrait les
|
||||
// lire, puisque la copie est enregistree AVANT le render pass et separee de lui
|
||||
// par une barriere.
|
||||
// Le televersement (conversion des sommets, ecriture directe ou staging) est
|
||||
// fait par le Renderer avant de construire le Mesh : cette classe ne fait que
|
||||
// decrire et dessiner.
|
||||
class Mesh {
|
||||
public:
|
||||
// `uploader` recoit les copies staging -> device-local. Il doit vivre plus
|
||||
// longtemps que la frame en cours (en pratique c'est le Renderer lui-meme).
|
||||
// Lance std::runtime_error si la geometrie est vide ou incoherente.
|
||||
// `log` a false pour les geometries creees en masse (les tuiles du quadtree
|
||||
// de la Phase 10) : une ligne de journal par tuile noierait toute autre
|
||||
// information et couterait plus cher que l'upload lui-meme.
|
||||
Mesh(VulkanContext& context,
|
||||
BufferUploader& uploader,
|
||||
const MeshData& data,
|
||||
bool log = true);
|
||||
Mesh(GpuBufferPool& pool, VertexLayout layout,
|
||||
const GpuRange& vertices, uint32_t vertexCount,
|
||||
const GpuRange& indices, VkIndexType indexType, uint32_t indexCount,
|
||||
bool ownsIndices);
|
||||
~Mesh();
|
||||
|
||||
Mesh(const Mesh&) = delete;
|
||||
Mesh& operator=(const Mesh&) = delete;
|
||||
|
||||
// Lie les buffers du mesh au command buffer courant.
|
||||
void bind(VkCommandBuffer commandBuffer) const;
|
||||
|
||||
// Emet le draw indexe. A appeler apres bind() et apres avoir lie les
|
||||
// descriptor sets / le pipeline.
|
||||
// Emet le draw indexe. A appeler apres avoir lie les plages du maillage
|
||||
// (Renderer::recordCommandBuffer, qui evite les liaisons redondantes), les
|
||||
// descriptor sets et le pipeline.
|
||||
void draw(VkCommandBuffer commandBuffer) const;
|
||||
|
||||
// PHASE 11 : meme dessin, repete `instanceCount` fois. Les instances lisent
|
||||
@@ -60,22 +55,27 @@ public:
|
||||
|
||||
uint32_t vertexCount() const { return vertexCount_; }
|
||||
uint32_t indexCount() const { return indexCount_; }
|
||||
VertexLayout layout() const { return layout_; }
|
||||
|
||||
const GpuRange& vertexRange() const { return vertices_; }
|
||||
const GpuRange& indexRange() const { return indices_; }
|
||||
VkIndexType indexType() const { return indexType_; }
|
||||
|
||||
// Octets de geometrie PROPRES a ce maillage (la topologie partagee n'est
|
||||
// pas comptee : elle n'existe qu'une fois).
|
||||
VkDeviceSize ownedBytes() const {
|
||||
return vertices_.size + (ownsIndices_ ? indices_.size : 0);
|
||||
}
|
||||
|
||||
private:
|
||||
// Cree un buffer device-local et CONFIE a l'uploader la copie depuis un
|
||||
// staging temporaire. Commun au vertex buffer et a l'index buffer.
|
||||
static std::unique_ptr<VulkanBuffer> createDeviceLocalBuffer(
|
||||
VulkanContext& context,
|
||||
BufferUploader& uploader,
|
||||
const void* data,
|
||||
VkDeviceSize size,
|
||||
VkBufferUsageFlags usage);
|
||||
|
||||
std::unique_ptr<VulkanBuffer> vertexBuffer_;
|
||||
std::unique_ptr<VulkanBuffer> indexBuffer_;
|
||||
|
||||
GpuBufferPool& pool_;
|
||||
VertexLayout layout_ = VertexLayout::Object;
|
||||
GpuRange vertices_;
|
||||
GpuRange indices_;
|
||||
VkIndexType indexType_ = VK_INDEX_TYPE_UINT32;
|
||||
uint32_t vertexCount_ = 0;
|
||||
uint32_t indexCount_ = 0;
|
||||
bool ownsIndices_ = true;
|
||||
};
|
||||
|
||||
} // namespace vercora
|
||||
@@ -41,15 +41,15 @@ Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayo
|
||||
|
||||
const std::array<VkPipelineShaderStageCreateInfo, 2> stages = { vertStage, fragStage };
|
||||
|
||||
// Vertex input : un binding entrelace, et autant d'attributs que le vertex
|
||||
// shader en consomme reellement - quatre (pos, color, normal, uv) pour les
|
||||
// objets, six pour le terrain, dont la cible de geomorphing. Le STRIDE, lui,
|
||||
// reste toujours sizeof(Vertex) : le format de sommet cote C++ est unique.
|
||||
const auto bindingDescription = vertexBindingDescription();
|
||||
const auto attributeDescriptions = vertexAttributeDescriptions();
|
||||
const uint32_t attributeCount = shaders.usesMorphAttributes
|
||||
? static_cast<uint32_t>(attributeDescriptions.size())
|
||||
: 4u;
|
||||
// Vertex input : un binding entrelace, au format de la famille de shaders
|
||||
// (PHASE 32, voir renderer/GpuVertex.hpp) - ObjectVertex pour les objets
|
||||
// et la vegetation, TerrainVertex pour le terrain.
|
||||
const VkVertexInputBindingDescription bindingDescription =
|
||||
shaders.terrainVertexLayout ? terrainBindingDescription()
|
||||
: objectBindingDescription();
|
||||
const std::array<VkVertexInputAttributeDescription, 4> attributeDescriptions =
|
||||
shaders.terrainVertexLayout ? terrainAttributeDescriptions()
|
||||
: objectAttributeDescriptions();
|
||||
|
||||
// PHASE 11 : un materiau instancie decrit DEUX bindings (sommets et
|
||||
// instances) et concatene leurs attributs. Les tableaux sont construits ici
|
||||
@@ -59,7 +59,7 @@ Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayo
|
||||
|
||||
std::vector<VkVertexInputBindingDescription> bindings{ bindingDescription };
|
||||
std::vector<VkVertexInputAttributeDescription> attributes(
|
||||
attributeDescriptions.begin(), attributeDescriptions.begin() + attributeCount);
|
||||
attributeDescriptions.begin(), attributeDescriptions.end());
|
||||
|
||||
// PHASE 27 : une passe plein ecran ne lit AUCUN buffer de sommets.
|
||||
if (shaders.fullscreenOverlay) {
|
||||
@@ -99,6 +99,14 @@ Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayo
|
||||
rasterizer.lineWidth = 1.0f;
|
||||
rasterizer.cullMode = VK_CULL_MODE_NONE; // pas de culling : triangle toujours visible
|
||||
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
|
||||
if (shaders.cullBackFaces) {
|
||||
// PHASE 32 : voir ShaderSet::cullBackFaces. Le terrain est enroule
|
||||
// (v00, v01, v11) avec Z vers le sud ; une fois l'axe Y de la
|
||||
// projection retourne (Renderer::projectionMatrix), une face vue
|
||||
// d'en haut est tramee dans le sens ANTIHORAIRE du framebuffer.
|
||||
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
|
||||
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
||||
}
|
||||
rasterizer.depthBiasEnable = VK_FALSE;
|
||||
|
||||
VkPipelineMultisampleStateCreateInfo multisampling{};
|
||||
|
||||
@@ -14,22 +14,20 @@ struct ShaderSet {
|
||||
std::string vertexSpv;
|
||||
std::string fragmentSpv;
|
||||
|
||||
// true si le vertex shader consomme les attributs de geomorphing
|
||||
// (locations 4 et 5, voir Vertex.hpp). Seul terrain.vert le fait.
|
||||
// true si le vertex shader lit le format de sommet du TERRAIN
|
||||
// (TerrainVertex, 16 octets) ; false pour le format des objets et de la
|
||||
// vegetation (ObjectVertex, 44 octets). Voir renderer/GpuVertex.hpp.
|
||||
//
|
||||
// Ce drapeau n'est pas une optimisation mais une CORRECTION : declarer dans
|
||||
// le vertex input un attribut qu'aucun shader ne lit fait emettre aux
|
||||
// couches de validation "Vertex attribute at location 4 not consumed by
|
||||
// vertex shader", et le contrat du projet est zero message de validation. Le
|
||||
// format de sommet reste unique cote C++ ; c'est seulement sa DESCRIPTION au
|
||||
// pipeline qui est tronquee pour les materiaux qui n'en lisent qu'une partie
|
||||
// (ce que Vulkan autorise : un binding peut avoir un stride plus grand que
|
||||
// la somme des attributs decrits).
|
||||
bool usesMorphAttributes = false;
|
||||
// PHASE 32 : jusqu'ici ce drapeau (usesMorphAttributes) ne faisait que
|
||||
// TRONQUER la description d'un format unique de 68 octets, pour ne pas
|
||||
// declarer aux shaders d'objets les attributs de morphing qu'ils ne lisent
|
||||
// pas (zero message de validation). Les deux familles ont desormais chacune
|
||||
// leur format, et les octets inutiles ont quitte les buffers eux-memes.
|
||||
bool terrainVertexLayout = false;
|
||||
|
||||
// PHASE 11. true si le pipeline doit decrire le second binding de sommets,
|
||||
// cadence par instance (voir VertexFormat.hpp). Meme raisonnement que
|
||||
// usesMorphAttributes : c'est une CORRECTION, pas une optimisation. Decrire
|
||||
// cadence par instance (voir VertexFormat.hpp). C'est une CORRECTION, pas
|
||||
// une optimisation (zero message de validation). Decrire
|
||||
// un binding d'instances a un pipeline non instancie obligerait a lier un
|
||||
// buffer d'instances avant de dessiner un cube, et ne pas le decrire a un
|
||||
// pipeline instancie ferait echouer la validation sur les locations 6 a 8.
|
||||
@@ -39,6 +37,23 @@ struct ShaderSet {
|
||||
// fabrique un triangle couvrant a partir de gl_VertexIndex), pas de test
|
||||
// ni d'ecriture de profondeur, melange par alpha.
|
||||
bool fullscreenOverlay = false;
|
||||
|
||||
// PHASE 32 : elimine les faces ARRIERE avant le tramage. Reserve au
|
||||
// terrain, et c'est une propriete de la geometrie, pas un reglage : un
|
||||
// champ de hauteurs a toutes ses normales geometriques vers le haut, et un
|
||||
// rayon parti d'un oeil situe AU-DESSUS du relief rencontre toujours une
|
||||
// face avant en premier - une face arriere n'est donc jamais le pixel
|
||||
// visible, elle ne fait que couter du tramage et des tests de profondeur.
|
||||
// (Image identique au bit pres, verifiee - NOTES-PHASE32.md.) Les objets
|
||||
// et la vegetation ne s'y pretent pas : l'herbe est un quad vu des deux
|
||||
// cotes, et rien ne garantit l'enroulement des maillages .obj.
|
||||
//
|
||||
// MESURE (lavapipe, NOTES-PHASE32.md) : -10 % de temps de rendu sur le
|
||||
// panorama. L'image n'est PAS identique au bit pres : 315 pixels isoles
|
||||
// (0,03 %) changent, tous sur des parois quasi verticales vues en rasant,
|
||||
// la ou une face arriere l'emportait d'un cheveu sur la face avant par
|
||||
// erreur d'arrondi de profondeur. C'est desormais toujours la face avant.
|
||||
bool cullBackFaces = false;
|
||||
};
|
||||
|
||||
// Shaders de la Phase 2 : couleur par sommet + Blinn-Phong. Utilises par le
|
||||
@@ -46,7 +61,8 @@ struct ShaderSet {
|
||||
inline const ShaderSet kObjectShaders{ "cube.vert.spv", "cube.frag.spv" };
|
||||
|
||||
// Shaders de la Phase 4 : coloration par altitude et par pente + Blinn-Phong.
|
||||
inline const ShaderSet kTerrainShaders{ "terrain.vert.spv", "terrain.frag.spv", true };
|
||||
inline const ShaderSet kTerrainShaders{ "terrain.vert.spv", "terrain.frag.spv", true,
|
||||
false, false, true };
|
||||
|
||||
// Shaders de la Phase 11 : vegetation instanciee (arbres de decor et herbe).
|
||||
// Ne lit PAS les attributs de geomorphing, mais lit le binding d'instances.
|
||||
|
||||
@@ -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
@@ -1,6 +1,7 @@
|
||||
#include "renderer/Renderer.hpp"
|
||||
|
||||
#include "assets/DetailNoise.hpp"
|
||||
#include "assets/TextureFile.hpp"
|
||||
|
||||
#include "core/Camera.hpp"
|
||||
#include "core/Logger.hpp"
|
||||
@@ -18,13 +19,35 @@
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace vercora {
|
||||
|
||||
namespace {
|
||||
|
||||
// PHASE 32 : barriere d'EXECUTION placee AVANT les copies staging -> pool.
|
||||
//
|
||||
// Avant le pool, chaque copie ecrivait un buffer neuf, que rien n'avait jamais
|
||||
// lu. Desormais une plage du pool est RECYCLEE : la copie ecrit des octets que
|
||||
// des images precedentes ont lus comme sommets ou indices. Le delai de retrait
|
||||
// (Renderer::removeMesh) garantit que ces images sont terminees, mais il le
|
||||
// garantit cote CPU, par les fences ; la validation de SYNCHRONISATION signale
|
||||
// a juste titre que rien ne l'exprime cote GPU (SYNC-HAZARD-WRITE-AFTER-READ,
|
||||
// 414 messages en 30 s de survol avec --force-staging). Un danger ecriture
|
||||
// apres lecture ne demande qu'une dependance d'EXECUTION : pas de masque
|
||||
// d'acces, l'etage d'assemblage des sommets avant, le transfert apres. Le
|
||||
// chemin d'ecriture directe (memoire unifiee) n'a pas de copie, donc pas de
|
||||
// barriere.
|
||||
void recordCopyAfterReadBarrier(VkCommandBuffer commandBuffer) {
|
||||
vkCmdPipelineBarrier(commandBuffer,
|
||||
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
|
||||
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||||
0, 0, nullptr, 0, nullptr, 0, nullptr);
|
||||
}
|
||||
|
||||
// Paire de shaders associee a chaque materiau. L'ordre suit celui de l'enum
|
||||
// Material : c'est ce tableau qui fait le lien entre le vocabulaire du gameplay
|
||||
// ("cet objet est du terrain") et celui du rendu ("ces .spv").
|
||||
@@ -42,7 +65,24 @@ const ShaderSet& shadersFor(Material material) {
|
||||
Renderer::Renderer(VulkanContext& context, Window& window,
|
||||
const RenderOptions& options)
|
||||
: context_(context), window_(window), options_(options) {
|
||||
swapChain_ = std::make_unique<SwapChain>(context_, window_);
|
||||
swapChain_ = std::make_unique<SwapChain>(context_, window_, options_.vsync);
|
||||
|
||||
// PHASE 32 : le pool de geometrie. En memoire unifiee (GPU integre,
|
||||
// lavapipe), ses blocs sont mappes et la geometrie y est ecrite DIRECTEMENT
|
||||
// : ni staging, ni copie, ni barriere. Sur un GPU discret, la memoire
|
||||
// device-local n'est pas (ou peu) mappable : chemin staging de la Phase 12.
|
||||
const bool directWrites = context_.preferDirectGeometryWrites() && !options_.forceStaging;
|
||||
geometryPool_ = std::make_unique<GpuBufferPool>(
|
||||
context_,
|
||||
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
|
||||
VK_BUFFER_USAGE_TRANSFER_DST_BIT,
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, directWrites);
|
||||
logInfo(std::string("Geometrie : pool de blocs de ") +
|
||||
std::to_string(GpuBufferPool::kDefaultBlockSize / (1024 * 1024)) + " Mo, " +
|
||||
(directWrites ? "ecriture DIRECTE (memoire unifiee, sans staging)."
|
||||
: (options_.forceStaging
|
||||
? "televersement par staging (FORCE, --force-staging)."
|
||||
: "televersement par staging (memoire device-local non mappable).")));
|
||||
|
||||
createCommandPool(); // requis avant les buffers (transferts staging)
|
||||
|
||||
@@ -88,6 +128,15 @@ Renderer::Renderer(VulkanContext& context, Window& window,
|
||||
Renderer::~Renderer() {
|
||||
VkDevice device = context_.device();
|
||||
|
||||
// PHASE 32 : rien ne doit plus lire la geometrie quand ses plages sont
|
||||
// rendues au pool (les Mesh le font en se detruisant, apres ce corps).
|
||||
vkDeviceWaitIdle(device);
|
||||
pendingTerrainWrites_.clear();
|
||||
for (SharedIndices& shared : sharedIndices_) {
|
||||
geometryPool_->release(shared.range);
|
||||
}
|
||||
sharedIndices_.clear();
|
||||
|
||||
for (VkSemaphore s : imageAvailableSemaphores_) {
|
||||
vkDestroySemaphore(device, s, nullptr);
|
||||
}
|
||||
@@ -116,32 +165,248 @@ void Renderer::waitIdle() const {
|
||||
vkDeviceWaitIdle(context_.device());
|
||||
}
|
||||
|
||||
MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) {
|
||||
// Le Mesh valide les donnees et leve une exception si elles sont
|
||||
// incoherentes, avant toute allocation durable. Construit AVANT de toucher
|
||||
// aux tableaux : si la construction echoue, aucun emplacement n'a ete
|
||||
// consomme.
|
||||
auto mesh = std::make_unique<Mesh>(context_, *this, meshData, log);
|
||||
MeshHandle Renderer::registerMesh(std::unique_ptr<Mesh> mesh) {
|
||||
++liveMeshCount_;
|
||||
|
||||
if (!freeMeshSlots_.empty()) {
|
||||
const MeshHandle handle = freeMeshSlots_.back();
|
||||
freeMeshSlots_.pop_back();
|
||||
meshes_[handle] = std::move(mesh);
|
||||
return handle;
|
||||
}
|
||||
|
||||
meshes_.push_back(std::move(mesh));
|
||||
return static_cast<MeshHandle>(meshes_.size() - 1);
|
||||
}
|
||||
|
||||
Renderer::RangeWrite Renderer::beginRangeWrite(const GpuRange& range) {
|
||||
RangeWrite write;
|
||||
write.range = range;
|
||||
if (range.mapped != nullptr) {
|
||||
// Memoire unifiee : on ecrit la ou le GPU lira. Sans danger pour la
|
||||
// synchronisation - une plage n'est rendue au pool qu'une fois que plus
|
||||
// aucune image en vol ne la lit (Renderer::removeMesh), et l'ecriture
|
||||
// hote est visible du GPU a la soumission suivante (memoire coherente).
|
||||
write.destination = range.mapped;
|
||||
return write;
|
||||
}
|
||||
write.staging = std::make_unique<VulkanBuffer>(
|
||||
context_, range.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||||
write.staging->map();
|
||||
write.destination = write.staging->mapped();
|
||||
return write;
|
||||
}
|
||||
|
||||
void Renderer::finishRangeWrite(RangeWrite& write) {
|
||||
if (write.staging) {
|
||||
write.staging->unmap();
|
||||
enqueueCopy(std::move(write.staging), write.range.buffer, write.range.offset);
|
||||
}
|
||||
write.destination = nullptr;
|
||||
}
|
||||
|
||||
MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) {
|
||||
// --- Validation AVANT toute allocation ----------------------------------
|
||||
// Un index hors limites ne produit pas d'erreur a la creation du buffer :
|
||||
// il se manifesterait au draw, sous forme de lecture hors du vertex buffer
|
||||
// (comportement indefini cote GPU). Mieux vaut refuser ici, avec un message
|
||||
// qui dit quoi. Si la geometrie est refusee, aucun emplacement n'a ete
|
||||
// consomme.
|
||||
if (meshData.vertices.empty()) {
|
||||
throw std::runtime_error("Mesh vide : aucun sommet (" + meshData.name + ").");
|
||||
}
|
||||
if (meshData.indices.empty()) {
|
||||
throw std::runtime_error("Mesh vide : aucun index (" + meshData.name + ").");
|
||||
}
|
||||
if (meshData.indices.size() % 3 != 0) {
|
||||
throw std::runtime_error(
|
||||
"Mesh non triangule : " + std::to_string(meshData.indices.size()) +
|
||||
" index, ce qui n'est pas un multiple de 3 (" + meshData.name + ").");
|
||||
}
|
||||
const auto vertexCount = static_cast<uint32_t>(meshData.vertices.size());
|
||||
for (uint32_t index : meshData.indices) {
|
||||
if (index >= vertexCount) {
|
||||
throw std::runtime_error(
|
||||
"Index hors limites dans le mesh : " + std::to_string(index) +
|
||||
" pour " + std::to_string(vertexCount) + " sommets (" + meshData.name + ").");
|
||||
}
|
||||
}
|
||||
const auto indexCount = static_cast<uint32_t>(meshData.indices.size());
|
||||
|
||||
// PHASE 32 : sommets au format ObjectVertex (44 octets, conversion exacte)
|
||||
// et indices en uint16 des que le maillage a au plus 65 536 sommets - le
|
||||
// cas de TOUS les maillages d'objets du jeu. Les valeurs sont les memes,
|
||||
// seule leur largeur change.
|
||||
const bool shortIndices = vertexCount <= 65536u;
|
||||
const VkDeviceSize vertexBytes = static_cast<VkDeviceSize>(vertexCount) * sizeof(ObjectVertex);
|
||||
const VkDeviceSize indexBytes = static_cast<VkDeviceSize>(indexCount) *
|
||||
(shortIndices ? sizeof(uint16_t) : sizeof(uint32_t));
|
||||
|
||||
// Le Mesh possede ses plages DES leur allocation : si la suite echoue
|
||||
// (memoire epuisee), il les rend au pool en se detruisant. Et aucune copie
|
||||
// n'est confiee a l'image suivante avant que les DEUX ecritures aient
|
||||
// reussi - sinon une copie en attente viserait une plage deja rendue.
|
||||
auto mesh = allocateMesh(VertexLayout::Object, vertexBytes, vertexCount, indexBytes,
|
||||
shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32,
|
||||
indexCount);
|
||||
RangeWrite vertexWrite = beginRangeWrite(mesh->vertexRange());
|
||||
RangeWrite indexWrite = beginRangeWrite(mesh->indexRange());
|
||||
|
||||
auto* vertices = static_cast<ObjectVertex*>(vertexWrite.destination);
|
||||
for (uint32_t v = 0; v < vertexCount; ++v) {
|
||||
vertices[v] = toObjectVertex(meshData.vertices[v]);
|
||||
}
|
||||
if (shortIndices) {
|
||||
auto* indices = static_cast<uint16_t*>(indexWrite.destination);
|
||||
for (uint32_t k = 0; k < indexCount; ++k) {
|
||||
indices[k] = static_cast<uint16_t>(meshData.indices[k]);
|
||||
}
|
||||
} else {
|
||||
std::memcpy(indexWrite.destination, meshData.indices.data(),
|
||||
static_cast<std::size_t>(indexBytes));
|
||||
}
|
||||
finishRangeWrite(vertexWrite);
|
||||
finishRangeWrite(indexWrite);
|
||||
|
||||
if (log) {
|
||||
logInfo("Mesh charge sur le GPU : " + meshData.name + " - " +
|
||||
std::to_string(vertexCount) + " sommets, " +
|
||||
std::to_string(indexCount / 3) + " triangles, " +
|
||||
std::to_string((vertexBytes + indexBytes + 1023) / 1024) + " Ko.");
|
||||
}
|
||||
return registerMesh(std::move(mesh));
|
||||
}
|
||||
|
||||
std::unique_ptr<Mesh> Renderer::allocateMesh(VertexLayout layout, VkDeviceSize vertexBytes,
|
||||
uint32_t vertexCount, VkDeviceSize indexBytes,
|
||||
VkIndexType indexType, uint32_t indexCount) {
|
||||
const GpuRange vertexRange = geometryPool_->allocate(vertexBytes);
|
||||
GpuRange indexRange;
|
||||
try {
|
||||
indexRange = geometryPool_->allocate(indexBytes);
|
||||
} catch (...) {
|
||||
geometryPool_->release(vertexRange);
|
||||
throw;
|
||||
}
|
||||
return std::make_unique<Mesh>(*geometryPool_, layout, vertexRange, vertexCount,
|
||||
indexRange, indexType, indexCount, true);
|
||||
}
|
||||
|
||||
MeshHandle Renderer::addTerrainMesh(const std::vector<TerrainVertex>& vertices,
|
||||
const std::vector<uint32_t>& indices,
|
||||
const std::string& name, bool log) {
|
||||
if (vertices.empty() || indices.empty() || indices.size() % 3 != 0) {
|
||||
throw std::runtime_error("Terrain : geometrie vide ou non triangulee (" + name + ").");
|
||||
}
|
||||
const auto vertexCount = static_cast<uint32_t>(vertices.size());
|
||||
for (uint32_t index : indices) {
|
||||
if (index >= vertexCount) {
|
||||
throw std::runtime_error("Terrain : index " + std::to_string(index) +
|
||||
" hors des " + std::to_string(vertexCount) +
|
||||
" sommets (" + name + ").");
|
||||
}
|
||||
}
|
||||
const VkDeviceSize vertexBytes = static_cast<VkDeviceSize>(vertexCount) * sizeof(TerrainVertex);
|
||||
const VkDeviceSize indexBytes = static_cast<VkDeviceSize>(indices.size()) * sizeof(uint32_t);
|
||||
// Meme ordre que addMesh : plages possedees d'abord, copies confiees ensuite.
|
||||
auto mesh = allocateMesh(VertexLayout::Terrain, vertexBytes, vertexCount, indexBytes,
|
||||
VK_INDEX_TYPE_UINT32, static_cast<uint32_t>(indices.size()));
|
||||
RangeWrite vertexWrite = beginRangeWrite(mesh->vertexRange());
|
||||
RangeWrite indexWrite = beginRangeWrite(mesh->indexRange());
|
||||
std::memcpy(vertexWrite.destination, vertices.data(), static_cast<std::size_t>(vertexBytes));
|
||||
std::memcpy(indexWrite.destination, indices.data(), static_cast<std::size_t>(indexBytes));
|
||||
finishRangeWrite(vertexWrite);
|
||||
finishRangeWrite(indexWrite);
|
||||
|
||||
if (log) {
|
||||
logInfo("Terrain charge sur le GPU : " + name + " - " + std::to_string(vertexCount) +
|
||||
" sommets, " + std::to_string(indices.size() / 3) + " triangles, " +
|
||||
std::to_string((vertexBytes + indexBytes) / (1024 * 1024)) + " Mo.");
|
||||
}
|
||||
return registerMesh(std::move(mesh));
|
||||
}
|
||||
|
||||
uint32_t Renderer::addSharedIndices(const std::vector<uint32_t>& indices) {
|
||||
if (indices.empty() || indices.size() % 3 != 0) {
|
||||
throw std::runtime_error("Topologie partagee vide ou non triangulee.");
|
||||
}
|
||||
const uint32_t highest = *std::max_element(indices.begin(), indices.end());
|
||||
const bool shortIndices = highest <= 0xFFFFu;
|
||||
SharedIndices shared;
|
||||
shared.count = static_cast<uint32_t>(indices.size());
|
||||
shared.type = shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32;
|
||||
shared.range = geometryPool_->allocate(static_cast<VkDeviceSize>(indices.size()) *
|
||||
(shortIndices ? sizeof(uint16_t) : sizeof(uint32_t)));
|
||||
RangeWrite write;
|
||||
try {
|
||||
write = beginRangeWrite(shared.range);
|
||||
} catch (...) {
|
||||
geometryPool_->release(shared.range);
|
||||
throw;
|
||||
}
|
||||
if (shortIndices) {
|
||||
auto* out = static_cast<uint16_t*>(write.destination);
|
||||
for (std::size_t k = 0; k < indices.size(); ++k) {
|
||||
out[k] = static_cast<uint16_t>(indices[k]);
|
||||
}
|
||||
} else {
|
||||
std::memcpy(write.destination, indices.data(), indices.size() * sizeof(uint32_t));
|
||||
}
|
||||
finishRangeWrite(write);
|
||||
sharedIndices_.push_back(shared);
|
||||
return static_cast<uint32_t>(sharedIndices_.size() - 1);
|
||||
}
|
||||
|
||||
Renderer::TerrainMeshWrite Renderer::beginTerrainMesh(uint32_t vertexCount,
|
||||
uint32_t sharedIndices) {
|
||||
if (sharedIndices >= sharedIndices_.size() || vertexCount == 0) {
|
||||
throw std::runtime_error("Tuile de terrain : topologie partagee inconnue.");
|
||||
}
|
||||
const SharedIndices& shared = sharedIndices_[sharedIndices];
|
||||
// Le Mesh possede sa plage avant l'ecriture : si le staging ne peut pas
|
||||
// etre cree, il la rend au pool en se detruisant.
|
||||
auto mesh = std::make_unique<Mesh>(
|
||||
*geometryPool_, VertexLayout::Terrain,
|
||||
geometryPool_->allocate(static_cast<VkDeviceSize>(vertexCount) * sizeof(TerrainVertex)),
|
||||
vertexCount, shared.range, shared.type, shared.count, false);
|
||||
RangeWrite write = beginRangeWrite(mesh->vertexRange());
|
||||
|
||||
TerrainMeshWrite result;
|
||||
result.vertices = static_cast<TerrainVertex*>(write.destination);
|
||||
result.mesh = registerMesh(std::move(mesh));
|
||||
if (write.staging) {
|
||||
pendingTerrainWrites_.emplace(result.mesh, std::move(write));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void Renderer::endTerrainMesh(MeshHandle mesh) {
|
||||
const auto it = pendingTerrainWrites_.find(mesh);
|
||||
if (it == pendingTerrainWrites_.end()) {
|
||||
return; // ecriture directe : rien a livrer, le GPU lit deja ces octets
|
||||
}
|
||||
finishRangeWrite(it->second);
|
||||
pendingTerrainWrites_.erase(it);
|
||||
}
|
||||
|
||||
void Renderer::setTerrainGrid(float origin, float spacing, uint32_t cells) {
|
||||
terrainGrid_ = glm::vec4(origin, spacing, static_cast<float>(cells), 0.0f);
|
||||
}
|
||||
|
||||
std::string Renderer::geometryLine() const {
|
||||
return "Geometrie : " + geometryPool_->statsLine();
|
||||
}
|
||||
|
||||
void Renderer::removeMesh(MeshHandle handle) {
|
||||
if (handle >= meshes_.size() || !meshes_[handle]) {
|
||||
return; // deja libere, ou poignee invalide : ne rien faire est sans risque
|
||||
}
|
||||
// PHASE 32 : une tuile commencee mais jamais livree (ecriture en echec)
|
||||
// abandonne son staging : il n'y a rien a copier.
|
||||
pendingTerrainWrites_.erase(handle);
|
||||
|
||||
// Le mesh sort de la table tout de suite (sa poignee redevient disponible)
|
||||
// mais ses buffers Vulkan survivent le temps que les frames deja soumises
|
||||
// aient fini de les lire. Voir le commentaire de declaration.
|
||||
// mais ses plages de geometrie survivent le temps que les frames deja
|
||||
// soumises aient fini de les lire. Voir le commentaire de declaration.
|
||||
retiredMeshes_.push_back({ std::move(meshes_[handle]), kMaxFramesInFlight + 1 });
|
||||
freeMeshSlots_.push_back(handle);
|
||||
--liveMeshCount_;
|
||||
@@ -358,6 +623,26 @@ void Renderer::setTerrainTexture(const TextureData& data) {
|
||||
" Mo sur le GPU.");
|
||||
}
|
||||
|
||||
void Renderer::setTerrainTextureFromFile(const TextureData& header, const std::string& path) {
|
||||
waitIdle();
|
||||
|
||||
std::ifstream file(path, std::ios::binary);
|
||||
if (!file) {
|
||||
throw std::runtime_error("Texture : fichier introuvable ou illisible : " + path);
|
||||
}
|
||||
terrainTexture_ = std::make_unique<Texture>(
|
||||
context_, commandPool_, context_.graphicsQueue(), header,
|
||||
[&file](void* destination, uint64_t offset, uint64_t bytes) {
|
||||
readTexturePayload(file, offset, bytes, destination);
|
||||
});
|
||||
writeTextureDescriptors();
|
||||
|
||||
logInfo("Orthophoto reliee au terrain : " + std::to_string(header.width) + "x" +
|
||||
std::to_string(header.height) + ", " +
|
||||
std::to_string(terrainTexture_->deviceSize() / (1024 * 1024)) +
|
||||
" Mo sur le GPU, lue par tranches directement dans le staging.");
|
||||
}
|
||||
|
||||
void Renderer::setOrthoMix(float mix) {
|
||||
options_.orthoMix = std::clamp(mix, 0.0f, 1.0f);
|
||||
}
|
||||
@@ -441,6 +726,7 @@ void Renderer::updateUniformBuffer(uint32_t frameIndex, const Camera& camera) {
|
||||
ubo.precip = precip_;
|
||||
ubo.fall = fall_;
|
||||
ubo.detail = detail_;
|
||||
ubo.terrainGrid = terrainGrid_;
|
||||
|
||||
std::memcpy(uniformBuffers_[frameIndex]->mapped(), &ubo, sizeof(ubo));
|
||||
}
|
||||
@@ -524,13 +810,15 @@ void Renderer::destroyImageSyncObjects() {
|
||||
// - la tuile est lisible DES CETTE FRAME : le repli sur l'ancetre ne sert donc
|
||||
// qu'aux tuiles pas encore CONSTRUITES (budget), pas a une latence de
|
||||
// transfert.
|
||||
void Renderer::enqueueCopy(std::unique_ptr<VulkanBuffer> staging, VkBuffer destination) {
|
||||
void Renderer::enqueueCopy(std::unique_ptr<VulkanBuffer> staging, VkBuffer destination,
|
||||
VkDeviceSize destinationOffset) {
|
||||
if (!staging || destination == VK_NULL_HANDLE) {
|
||||
return;
|
||||
}
|
||||
PendingCopy copy;
|
||||
copy.size = staging->size();
|
||||
copy.destination = destination;
|
||||
copy.destinationOffset = destinationOffset;
|
||||
copy.staging = std::move(staging);
|
||||
stagingBytesInFlight_ += static_cast<std::size_t>(copy.size);
|
||||
pendingCopies_.push_back(std::move(copy));
|
||||
@@ -565,8 +853,10 @@ void Renderer::flushCopiesNow() {
|
||||
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
||||
vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
||||
|
||||
recordCopyAfterReadBarrier(commandBuffer);
|
||||
for (const PendingCopy& copy : pendingCopies_) {
|
||||
VkBufferCopy region{};
|
||||
region.dstOffset = copy.destinationOffset;
|
||||
region.size = copy.size;
|
||||
vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination,
|
||||
1, ®ion);
|
||||
@@ -603,8 +893,10 @@ void Renderer::recordPendingCopies(VkCommandBuffer commandBuffer) {
|
||||
return;
|
||||
}
|
||||
|
||||
recordCopyAfterReadBarrier(commandBuffer);
|
||||
for (PendingCopy& copy : pendingCopies_) {
|
||||
VkBufferCopy region{};
|
||||
region.dstOffset = copy.destinationOffset;
|
||||
region.size = copy.size;
|
||||
vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination,
|
||||
1, ®ion);
|
||||
@@ -694,9 +986,56 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
|
||||
// n'est lie qu'une fois par materiau reellement utilise (au plus deux fois
|
||||
// par frame ici). Avec quelques dizaines d'objets, ce tri "par balayage"
|
||||
// coute moins cher qu'un vrai tri, et evite de copier la liste.
|
||||
for (uint32_t m = 0; m < kMaterialCount; ++m) {
|
||||
const Material material = static_cast<Material>(m);
|
||||
//
|
||||
// PHASE 32 : le TERRAIN en dernier. Son shader de fragment est le plus
|
||||
// lourd du jeu (orthophoto, micro-relief, adret/ubac, brouillard) ; dessine
|
||||
// apres les troncs, les houppiers et l'herbe, il trouve leur profondeur
|
||||
// deja ecrite et le test de profondeur PRECOCE ecarte ses fragments caches
|
||||
// avant de les ombrer. Tout est opaque et le test est LESS : l'ordre ne
|
||||
// change l'image qu'a profondeur RIGOUREUSEMENT EGALE - le pied d'un brin
|
||||
// ou d'un tronc, pose exactement sur la surface du sol. Mesure : 24 pixels
|
||||
// sur 921 600 en foret, et une variante qui rend ces egalites au terrain
|
||||
// redonne l'image de reference au bit pres (NOTES-PHASE32.md). Gain : -26 %
|
||||
// de temps de rendu en foret (lavapipe).
|
||||
static constexpr std::array<Material, kMaterialCount> kDrawOrder{
|
||||
Material::Object, Material::Foliage, Material::Terrain };
|
||||
|
||||
// PHASE 32 : liaisons de buffers EVITEES quand elles ne changent rien. Les
|
||||
// tuiles de terrain partagent une seule topologie : elle est liee une fois
|
||||
// par image au lieu d'une fois par tuile. Les liaisons survivent aux
|
||||
// changements de pipeline (etat du command buffer, pas du pipeline).
|
||||
VkBuffer boundVertexBuffer = VK_NULL_HANDLE;
|
||||
VkDeviceSize boundVertexOffset = 0;
|
||||
VkBuffer boundIndexBuffer = VK_NULL_HANDLE;
|
||||
VkDeviceSize boundIndexOffset = 0;
|
||||
VkIndexType boundIndexType = VK_INDEX_TYPE_MAX_ENUM;
|
||||
// Decalage de LIAISON plutot que vertexOffset dans le draw : gl_VertexIndex
|
||||
// reste ainsi l'indice LOCAL du sommet dans son maillage, ce dont
|
||||
// terrain.vert se sert pour retrouver sa place dans la grille de la tuile.
|
||||
const auto bindMesh = [&](const Mesh& mesh) {
|
||||
const GpuRange& vertices = mesh.vertexRange();
|
||||
if (vertices.buffer != boundVertexBuffer || vertices.offset != boundVertexOffset) {
|
||||
vkCmdBindVertexBuffers(commandBuffer, 0, 1, &vertices.buffer, &vertices.offset);
|
||||
boundVertexBuffer = vertices.buffer;
|
||||
boundVertexOffset = vertices.offset;
|
||||
}
|
||||
const GpuRange& indices = mesh.indexRange();
|
||||
if (indices.buffer != boundIndexBuffer || indices.offset != boundIndexOffset ||
|
||||
mesh.indexType() != boundIndexType) {
|
||||
vkCmdBindIndexBuffer(commandBuffer, indices.buffer, indices.offset, mesh.indexType());
|
||||
boundIndexBuffer = indices.buffer;
|
||||
boundIndexOffset = indices.offset;
|
||||
boundIndexType = mesh.indexType();
|
||||
}
|
||||
};
|
||||
|
||||
for (const Material material : kDrawOrder) {
|
||||
const uint32_t m = static_cast<uint32_t>(material);
|
||||
bool pipelineBound = false;
|
||||
// PHASE 32 : un maillage de terrain (16 octets par sommet) ne se lit
|
||||
// qu'avec le pipeline du terrain, et reciproquement.
|
||||
const VertexLayout expectedLayout = (material == Material::Terrain)
|
||||
? VertexLayout::Terrain : VertexLayout::Object;
|
||||
|
||||
for (const DrawItem& item : items) {
|
||||
if (item.material != material) {
|
||||
@@ -709,6 +1048,9 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
|
||||
// un pointeur nul). Signaler serait bruyant a 60 Hz.
|
||||
continue;
|
||||
}
|
||||
if (meshes_[item.mesh]->layout() != expectedLayout) {
|
||||
continue; // meme raison : le GPU lirait des octets d'un autre format
|
||||
}
|
||||
|
||||
if (!pipelineBound) {
|
||||
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||||
@@ -723,17 +1065,17 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
|
||||
pipelineBound = true;
|
||||
}
|
||||
|
||||
// Transformation et parametres propres a cet objet. Les deux sont
|
||||
// Transformation et parametres propres a cet objet. Tous sont
|
||||
// pousses d'un seul coup : ils sont contigus dans DrawItemPush,
|
||||
// dont le layout reproduit exactement le bloc push_constant des
|
||||
// shaders (voir DrawItem.hpp).
|
||||
const DrawItemPush push{ item.model, item.params };
|
||||
const DrawItemPush push{ item.model, item.params, item.grid };
|
||||
vkCmdPushConstants(commandBuffer, pipelines_[m]->layout(),
|
||||
VK_SHADER_STAGE_VERTEX_BIT, 0,
|
||||
static_cast<uint32_t>(sizeof(DrawItemPush)), &push);
|
||||
|
||||
const Mesh& mesh = *meshes_[item.mesh];
|
||||
mesh.bind(commandBuffer);
|
||||
bindMesh(mesh);
|
||||
mesh.draw(commandBuffer);
|
||||
}
|
||||
|
||||
@@ -746,7 +1088,8 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
|
||||
if (item.material != material || item.count == 0) {
|
||||
continue;
|
||||
}
|
||||
if (item.mesh >= meshes_.size() || !meshes_[item.mesh]) {
|
||||
if (item.mesh >= meshes_.size() || !meshes_[item.mesh] ||
|
||||
meshes_[item.mesh]->layout() != expectedLayout) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -765,7 +1108,7 @@ void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t image
|
||||
static_cast<uint32_t>(sizeof(DrawItemPush)), &push);
|
||||
|
||||
const Mesh& mesh = *meshes_[item.mesh];
|
||||
mesh.bind(commandBuffer);
|
||||
bindMesh(mesh);
|
||||
|
||||
// Binding 1 : la tranche du buffer d'instances qui appartient a cet
|
||||
// objet. L'offset a ete calcule par uploadInstances, dans le meme
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/DrawItem.hpp"
|
||||
#include "renderer/GpuBufferPool.hpp"
|
||||
#include "renderer/GpuVertex.hpp"
|
||||
#include "renderer/Mesh.hpp" // VertexLayout
|
||||
#include "renderer/Pipeline.hpp" // pour ShaderSet
|
||||
#include "renderer/VulkanBuffer.hpp" // pour BufferUploader
|
||||
|
||||
@@ -11,6 +14,8 @@
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
namespace vercora {
|
||||
@@ -19,7 +24,6 @@ class VulkanContext;
|
||||
class Window;
|
||||
class SwapChain;
|
||||
class Camera;
|
||||
class Mesh;
|
||||
class Texture;
|
||||
struct MeshData;
|
||||
struct TextureData;
|
||||
@@ -49,6 +53,17 @@ struct RenderOptions {
|
||||
// deux se recouvrent bien. Sans texture chargee, la valeur est ignoree (le
|
||||
// binding pointe alors sur un texel blanc).
|
||||
float orthoMix = 0.0f;
|
||||
|
||||
// PHASE 32. Force le televersement de la geometrie par STAGING meme en
|
||||
// memoire unifiee, ou elle est sinon ecrite directement la ou le GPU la
|
||||
// lit. Sert a eprouver sur la machine de developpement le chemin d'un GPU
|
||||
// discret (option --force-staging).
|
||||
bool forceStaging = false;
|
||||
|
||||
// PHASE 32. Presentation calee sur l'ecran (FIFO, option --vsync) : la
|
||||
// cadence ne depasse plus le rafraichissement, et le CPU comme le GPU
|
||||
// dorment le reste du temps. Voir SwapChain::choosePresentMode.
|
||||
bool vsync = false;
|
||||
};
|
||||
|
||||
// Orchestre le rendu : geometries enregistrees, UBO/descriptors, command
|
||||
@@ -85,6 +100,48 @@ public:
|
||||
// toute autre information.
|
||||
MeshHandle addMesh(const MeshData& meshData, bool log = true);
|
||||
|
||||
// PHASE 32 : GEOMETRIE DE TERRAIN, au format compact TerrainVertex (16
|
||||
// octets, voir renderer/GpuVertex.hpp). Un tel maillage ne se dessine
|
||||
// qu'avec Material::Terrain et un DrawItem::grid qui dit ou il se trouve
|
||||
// dans la heightmap.
|
||||
//
|
||||
// Terrain d'un seul bloc (--no-lod) : sommets et topologie propres.
|
||||
MeshHandle addTerrainMesh(const std::vector<TerrainVertex>& vertices,
|
||||
const std::vector<uint32_t>& indices,
|
||||
const std::string& name, bool log = true);
|
||||
|
||||
// Topologie PARTAGEE par plusieurs maillages de terrain : les tuiles du
|
||||
// quadtree ont toutes la meme (Phase 18), et la televerser une fois au lieu
|
||||
// d'une par tuile economise 96 Ko par tuile residente. Stockee en uint16
|
||||
// quand les indices le permettent (65 x 65 sommets par tuile). Vit aussi
|
||||
// longtemps que le Renderer.
|
||||
uint32_t addSharedIndices(const std::vector<uint32_t>& indices);
|
||||
|
||||
// Tuile de terrain sur une topologie partagee, ECRITE PAR L'APPELANT :
|
||||
// beginTerrainMesh reserve la place et rend un pointeur sur `vertexCount`
|
||||
// sommets a remplir - directement la memoire que le GPU lira en memoire
|
||||
// unifiee, un staging sinon - et endTerrainMesh la livre. Entre les deux,
|
||||
// l'ecriture peut se faire depuis N'IMPORTE QUEL thread (aucun appel
|
||||
// Vulkan) : c'est ce qui laisse le maillage parallele de la Phase 19
|
||||
// ecrire sans copie intermediaire. begin et end, eux, restent sur le
|
||||
// thread de rendu, et chaque begin doit etre suivi de son end (ou d'un
|
||||
// removeMesh si l'ecriture a echoue).
|
||||
struct TerrainMeshWrite {
|
||||
MeshHandle mesh = kInvalidMesh;
|
||||
TerrainVertex* vertices = nullptr;
|
||||
};
|
||||
TerrainMeshWrite beginTerrainMesh(uint32_t vertexCount, uint32_t sharedIndices);
|
||||
void endTerrainMesh(MeshHandle mesh);
|
||||
|
||||
// PHASE 32 : grille de la heightmap, lue par terrain.vert pour recalculer
|
||||
// la position horizontale et l'UV des sommets de terrain (voir
|
||||
// UniformBufferObject::terrainGrid). A appeler une fois, avant la premiere
|
||||
// image, des qu'un terrain est charge.
|
||||
void setTerrainGrid(float origin, float spacing, uint32_t cells);
|
||||
|
||||
// PHASE 32 : bilan du pool de geometrie, pour le journal.
|
||||
std::string geometryLine() const;
|
||||
|
||||
// Libere une geometrie et rend sa poignee reutilisable. Indispensable depuis
|
||||
// la Phase 10 : le streaming par tuiles cree et detruit des maillages en
|
||||
// permanence, alors que jusque-la une geometrie enregistree vivait aussi
|
||||
@@ -111,6 +168,12 @@ public:
|
||||
// coloration procedurale est visible.
|
||||
void setTerrainTexture(const TextureData& data);
|
||||
|
||||
// PHASE 32. Meme chose, mais les texels sont lus dans `path` DIRECTEMENT
|
||||
// vers le staging de la texture : `header` vient de loadTextureFileHeader
|
||||
// et ne porte aucun texel. Evite de tenir l'orthophoto (42 Mo) en RAM en
|
||||
// plus du staging et de l'image GPU pendant le chargement.
|
||||
void setTerrainTextureFromFile(const TextureData& header, const std::string& path);
|
||||
|
||||
// Bascule coloration procedurale <-> orthophoto (voir RenderOptions).
|
||||
// Sans effet visible si aucune texture n'a ete chargee.
|
||||
void setOrthoMix(float mix);
|
||||
@@ -233,7 +296,7 @@ public:
|
||||
// garanti par construction - le seul appelant est addMesh, et removeMesh
|
||||
// DIFFERE la destruction des buffers de kMaxFramesInFlight + 1 frames.
|
||||
void enqueueCopy(std::unique_ptr<VulkanBuffer> staging,
|
||||
VkBuffer destination) override;
|
||||
VkBuffer destination, VkDeviceSize destinationOffset) override;
|
||||
|
||||
// Octets de staging en attente d'enregistrement + en attente d'execution.
|
||||
// Sert au journal de diagnostic du streaming.
|
||||
@@ -266,6 +329,7 @@ private:
|
||||
glm::vec4 precip_{0.0f, 0.0f, 0.0f, 0.0f};
|
||||
glm::vec4 fall_{0.0f, -6.5f, 0.0f, 0.0f};
|
||||
glm::vec4 detail_{0.0f, 0.0f, 1.0f, 1.0f};
|
||||
glm::vec4 terrainGrid_{0.0f, 1.0f, 1.0f, 0.0f}; // PHASE 32, voir setTerrainGrid()
|
||||
|
||||
static constexpr int kMaxFramesInFlight = 2;
|
||||
|
||||
@@ -306,12 +370,51 @@ private:
|
||||
void uploadInstances(const std::vector<InstancedDrawItem>& instanced);
|
||||
void recreateSwapChain();
|
||||
|
||||
// PHASE 32. Ecriture dans une plage du pool : `destination` pointe soit
|
||||
// dans la plage elle-meme (memoire unifiee), soit dans un staging, et
|
||||
// finishRangeWrite confie alors la copie a la prochaine image.
|
||||
struct RangeWrite {
|
||||
GpuRange range;
|
||||
void* destination = nullptr;
|
||||
std::unique_ptr<VulkanBuffer> staging;
|
||||
};
|
||||
RangeWrite beginRangeWrite(const GpuRange& range);
|
||||
void finishRangeWrite(RangeWrite& write);
|
||||
|
||||
// Inscrit un Mesh dans la table et rend sa poignee (emplacement libre
|
||||
// reutilise s'il y en a un).
|
||||
MeshHandle registerMesh(std::unique_ptr<Mesh> mesh);
|
||||
|
||||
// Reserve les deux plages d'un maillage a topologie propre et les confie
|
||||
// AUSSITOT a un Mesh, qui les rendra au pool si la suite echoue.
|
||||
std::unique_ptr<Mesh> allocateMesh(VertexLayout layout, VkDeviceSize vertexBytes,
|
||||
uint32_t vertexCount, VkDeviceSize indexBytes,
|
||||
VkIndexType indexType, uint32_t indexCount);
|
||||
|
||||
VulkanContext& context_;
|
||||
Window& window_;
|
||||
RenderOptions options_;
|
||||
|
||||
std::unique_ptr<SwapChain> swapChain_;
|
||||
|
||||
// PHASE 32 : TOUTE la geometrie (sommets et indices, objets et terrain)
|
||||
// vit dans les blocs de ce pool. Declare AVANT les tables de maillages :
|
||||
// les membres etant detruits dans l'ordre inverse, il survit a tous les
|
||||
// Mesh, qui lui rendent leurs plages en se detruisant.
|
||||
std::unique_ptr<GpuBufferPool> geometryPool_;
|
||||
|
||||
// Topologies partagees (addSharedIndices), rendues a la destruction.
|
||||
struct SharedIndices {
|
||||
GpuRange range;
|
||||
uint32_t count = 0;
|
||||
VkIndexType type = VK_INDEX_TYPE_UINT16;
|
||||
};
|
||||
std::vector<SharedIndices> sharedIndices_;
|
||||
|
||||
// Tuiles commencees (beginTerrainMesh) dont l'ecriture passe par un
|
||||
// staging, en attente de leur endTerrainMesh.
|
||||
std::unordered_map<MeshHandle, RangeWrite> pendingTerrainWrites_;
|
||||
|
||||
// Un pipeline par materiau, indexe par la valeur de l'enum Material. Tous
|
||||
// partagent le meme descriptor set layout et le meme push constant range :
|
||||
// seuls les shaders different.
|
||||
@@ -348,6 +451,7 @@ private:
|
||||
struct PendingCopy {
|
||||
std::unique_ptr<VulkanBuffer> staging;
|
||||
VkBuffer destination = VK_NULL_HANDLE;
|
||||
VkDeviceSize destinationOffset = 0;
|
||||
VkDeviceSize size = 0;
|
||||
};
|
||||
std::vector<PendingCopy> pendingCopies_;
|
||||
|
||||
@@ -26,8 +26,8 @@ const char* presentModeName(VkPresentModeKHR mode) {
|
||||
|
||||
} // namespace
|
||||
|
||||
SwapChain::SwapChain(VulkanContext& context, Window& window)
|
||||
: context_(context), window_(window) {
|
||||
SwapChain::SwapChain(VulkanContext& context, Window& window, bool vsync)
|
||||
: context_(context), window_(window), vsync_(vsync) {
|
||||
// Le format de profondeur est fixe une fois pour toutes (il ne depend pas de
|
||||
// la taille) : le render pass, cree une seule fois, s'y refere.
|
||||
depthFormat_ = context_.findDepthFormat();
|
||||
@@ -66,10 +66,7 @@ void SwapChain::cleanupSizeDependent() {
|
||||
vkDestroyImage(device, depthImage_, nullptr);
|
||||
depthImage_ = VK_NULL_HANDLE;
|
||||
}
|
||||
if (depthImageMemory_ != VK_NULL_HANDLE) {
|
||||
vkFreeMemory(device, depthImageMemory_, nullptr);
|
||||
depthImageMemory_ = VK_NULL_HANDLE;
|
||||
}
|
||||
context_.freeMemory(depthAllocation_);
|
||||
|
||||
for (VkFramebuffer fb : framebuffers_) {
|
||||
vkDestroyFramebuffer(device, fb, nullptr);
|
||||
@@ -113,6 +110,16 @@ VkPresentModeKHR SwapChain::choosePresentMode(
|
||||
// FIFO : seul mode dont Vulkan garantit la presence. Fallback ultime.
|
||||
// A rebasculer sur MAILBOX/FIFO quand le jeu sera jouable : le tearing n'est
|
||||
// acceptable que pour du profilage.
|
||||
//
|
||||
// PHASE 32 : c'est l'option --vsync. FIFO, le seul mode que Vulkan
|
||||
// garantit : le CPU et le GPU attendent l'ecran au lieu de produire des
|
||||
// images que personne ne verra. C'est le plus gros levier de CONSOMMATION
|
||||
// du jeu (378 images/s mesurees sur l'UHD 770 = GPU a 100 % en permanence,
|
||||
// pour un ecran a 60 Hz). Non active par defaut : toutes les mesures du
|
||||
// projet comptent des images/s non plafonnees.
|
||||
if (vsync_) {
|
||||
return VK_PRESENT_MODE_FIFO_KHR;
|
||||
}
|
||||
for (VkPresentModeKHR wanted : { VK_PRESENT_MODE_IMMEDIATE_KHR,
|
||||
VK_PRESENT_MODE_MAILBOX_KHR }) {
|
||||
if (std::find(modes.begin(), modes.end(), wanted) != modes.end()) {
|
||||
@@ -342,16 +349,10 @@ void SwapChain::createDepthResources() {
|
||||
VkMemoryRequirements memRequirements{};
|
||||
vkGetImageMemoryRequirements(device, depthImage_, &memRequirements);
|
||||
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = memRequirements.size;
|
||||
allocInfo.memoryTypeIndex = context_.findMemoryType(
|
||||
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
|
||||
if (vkAllocateMemory(device, &allocInfo, nullptr, &depthImageMemory_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Echec de l'allocation memoire de profondeur.");
|
||||
}
|
||||
vkBindImageMemory(device, depthImage_, depthImageMemory_, 0);
|
||||
// PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
|
||||
depthAllocation_ = context_.allocateMemory(memRequirements,
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
vkBindImageMemory(device, depthImage_, depthAllocation_.memory, 0);
|
||||
|
||||
VkImageViewCreateInfo viewInfo{};
|
||||
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#include <vector>
|
||||
@@ -15,7 +17,9 @@ class Window;
|
||||
// pas), ce qui evite d'invalider le pipeline graphique.
|
||||
class SwapChain {
|
||||
public:
|
||||
SwapChain(VulkanContext& context, Window& window);
|
||||
// `vsync` (PHASE 32) : presentation calee sur l'ecran (FIFO) au lieu du
|
||||
// mode non plafonne des mesures. Voir choosePresentMode.
|
||||
SwapChain(VulkanContext& context, Window& window, bool vsync = false);
|
||||
~SwapChain();
|
||||
|
||||
SwapChain(const SwapChain&) = delete;
|
||||
@@ -59,6 +63,7 @@ private:
|
||||
|
||||
// MAX_ENUM = "pas encore choisi", pour que le premier choix soit toujours logge.
|
||||
VkPresentModeKHR presentMode_ = VK_PRESENT_MODE_MAX_ENUM_KHR;
|
||||
bool vsync_ = false;
|
||||
|
||||
std::vector<VkImage> images_;
|
||||
std::vector<VkImageView> imageViews_;
|
||||
@@ -68,7 +73,7 @@ private:
|
||||
// par le render pass). Recree en meme temps que la swapchain au resize.
|
||||
VkFormat depthFormat_ = VK_FORMAT_UNDEFINED;
|
||||
VkImage depthImage_ = VK_NULL_HANDLE;
|
||||
VkDeviceMemory depthImageMemory_ = VK_NULL_HANDLE;
|
||||
GpuAllocation depthAllocation_;
|
||||
VkImageView depthImageView_ = VK_NULL_HANDLE;
|
||||
|
||||
VkRenderPass renderPass_ = VK_NULL_HANDLE;
|
||||
|
||||
@@ -9,6 +9,58 @@
|
||||
|
||||
namespace vercora {
|
||||
|
||||
namespace {
|
||||
|
||||
// Normale analytique de la surface y = h(x,z) au noeud (ix, iz) : le vecteur
|
||||
// normal vaut (-dh/dx, 1, -dh/dz). Les derivees sont estimees par difference
|
||||
// CENTREE sur les deux voisins (plus precis et plus symetrique qu'un produit
|
||||
// vectoriel sur une seule face). Sur les bords, at() ecrete les indices : la
|
||||
// difference devient unilaterale, d'ou le pas reel (xp - xm) au denominateur
|
||||
// plutot qu'un 2 en dur - sinon les normales du bord seraient deux fois trop
|
||||
// plates.
|
||||
//
|
||||
// PHASE 32 : sortie de la boucle de terrainMeshData pour etre partagee avec
|
||||
// terrainGpuMeshData - les deux formats ont ainsi, par construction, les memes
|
||||
// normales.
|
||||
glm::vec3 gridNormal(const Heightmap& heightmap, uint32_t ix, uint32_t iz, uint32_t res,
|
||||
float spacing) {
|
||||
const int64_t xm = (ix > 0) ? ix - 1 : ix;
|
||||
const int64_t xp = (ix + 1 < res) ? ix + 1 : ix;
|
||||
const int64_t zm = (iz > 0) ? iz - 1 : iz;
|
||||
const int64_t zp = (iz + 1 < res) ? iz + 1 : iz;
|
||||
|
||||
const float dhdx = (heightmap.at(xp, iz) - heightmap.at(xm, iz)) /
|
||||
(static_cast<float>(xp - xm) * spacing);
|
||||
const float dhdz = (heightmap.at(ix, zp) - heightmap.at(ix, zm)) /
|
||||
(static_cast<float>(zp - zm) * spacing);
|
||||
|
||||
return glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
|
||||
}
|
||||
|
||||
// Deux triangles par cellule, coupes le long de la diagonale v00-v11 (voir le
|
||||
// commentaire de l'etape 2 de terrainMeshData).
|
||||
void appendGridIndices(uint32_t res, std::vector<uint32_t>& indices) {
|
||||
const uint32_t cells = res - 1;
|
||||
for (uint32_t iz = 0; iz < cells; ++iz) {
|
||||
for (uint32_t ix = 0; ix < cells; ++ix) {
|
||||
const uint32_t v00 = iz * res + ix;
|
||||
const uint32_t v10 = v00 + 1;
|
||||
const uint32_t v01 = v00 + res;
|
||||
const uint32_t v11 = v01 + 1;
|
||||
|
||||
indices.push_back(v00);
|
||||
indices.push_back(v01);
|
||||
indices.push_back(v11);
|
||||
|
||||
indices.push_back(v00);
|
||||
indices.push_back(v11);
|
||||
indices.push_back(v10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
MeshData terrainMeshData(const Heightmap& heightmap) {
|
||||
const uint32_t res = heightmap.resolution();
|
||||
if (res < 2) {
|
||||
@@ -53,25 +105,8 @@ MeshData terrainMeshData(const Heightmap& heightmap) {
|
||||
// LiDAR : sol / vegetation / bati) sans toucher au shader.
|
||||
vertex.color = { 1.0f, 1.0f, 1.0f };
|
||||
|
||||
// Normale analytique de la surface y = h(x,z) : le vecteur normal
|
||||
// vaut (-dh/dx, 1, -dh/dz). Les derivees sont estimees par
|
||||
// difference CENTREE sur les deux voisins (plus precis et plus
|
||||
// symetrique qu'un produit vectoriel sur une seule face).
|
||||
// Sur les bords, at() ecrete les indices : la difference devient
|
||||
// unilaterale, d'ou le pas reel (xp - xm) au denominateur plutot
|
||||
// qu'un 2 en dur - sinon les normales du bord seraient deux fois
|
||||
// trop plates.
|
||||
const int64_t xm = (ix > 0) ? ix - 1 : ix;
|
||||
const int64_t xp = (ix + 1 < res) ? ix + 1 : ix;
|
||||
const int64_t zm = (iz > 0) ? iz - 1 : iz;
|
||||
const int64_t zp = (iz + 1 < res) ? iz + 1 : iz;
|
||||
|
||||
const float dhdx = (heightmap.at(xp, iz) - heightmap.at(xm, iz)) /
|
||||
(static_cast<float>(xp - xm) * spacing);
|
||||
const float dhdz = (heightmap.at(ix, zp) - heightmap.at(ix, zm)) /
|
||||
(static_cast<float>(zp - zm) * spacing);
|
||||
|
||||
vertex.normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
|
||||
// Normale par differences centrees, voir gridNormal.
|
||||
vertex.normal = gridNormal(heightmap, ix, iz, res, spacing);
|
||||
|
||||
// UV sur tout le terrain. Pas encore consomme (pas de texturing),
|
||||
// mais c'est le repere naturel pour y plaquer une orthophoto le jour
|
||||
@@ -90,33 +125,11 @@ MeshData terrainMeshData(const Heightmap& heightmap) {
|
||||
// ici oblige a la changer la-bas aussi.
|
||||
//
|
||||
// Enroulement anti-horaire vu de dessus (+Y), coherent avec la convention
|
||||
// des .obj de la Phase 3. Le culling est desactive dans Pipeline, donc c'est
|
||||
// sans effet visible aujourd'hui, mais ca rend le back-face culling
|
||||
// activable sans retoucher la geometrie.
|
||||
for (uint32_t iz = 0; iz < cells; ++iz) {
|
||||
for (uint32_t ix = 0; ix < cells; ++ix) {
|
||||
const uint32_t v00 = iz * res + ix;
|
||||
const uint32_t v10 = v00 + 1;
|
||||
const uint32_t v01 = v00 + res;
|
||||
const uint32_t v11 = v01 + 1;
|
||||
// des .obj de la Phase 3. C'est ce qui a rendu le back-face culling du
|
||||
// terrain activable sans retoucher la geometrie (PHASE 32, voir
|
||||
// ShaderSet::cullBackFaces).
|
||||
appendGridIndices(res, mesh.indices);
|
||||
|
||||
mesh.indices.push_back(v00);
|
||||
mesh.indices.push_back(v01);
|
||||
mesh.indices.push_back(v11);
|
||||
|
||||
mesh.indices.push_back(v00);
|
||||
mesh.indices.push_back(v11);
|
||||
mesh.indices.push_back(v10);
|
||||
}
|
||||
}
|
||||
|
||||
// --- 3. Controle de coherence ------------------------------------------
|
||||
// Meme esprit que les gardes-fous du loader .obj (Phase 3) : on refuse de
|
||||
// pousser vers le GPU une geometrie qu'on sait cassee, plutot que d'afficher
|
||||
// une fenetre vide sans explication. Ici le generateur est deterministe,
|
||||
// donc ces tests attrapent une erreur de code (indexation, resolution), pas
|
||||
// une donnee douteuse - ils resteront pertinents quand la grille viendra du
|
||||
// LiDAR.
|
||||
if (mesh.indices.size() % 3 != 0) {
|
||||
throw std::runtime_error("TerrainMesh : nombre d'index non multiple de 3.");
|
||||
}
|
||||
@@ -145,4 +158,49 @@ MeshData terrainMeshData(const Heightmap& heightmap) {
|
||||
return mesh;
|
||||
}
|
||||
|
||||
TerrainGpuMesh terrainGpuMeshData(const Heightmap& heightmap) {
|
||||
const uint32_t res = heightmap.resolution();
|
||||
if (res < 2) {
|
||||
throw std::runtime_error(
|
||||
"TerrainMesh : une grille de " + std::to_string(res) +
|
||||
" echantillons par cote ne forme aucune cellule.");
|
||||
}
|
||||
const uint32_t cells = res - 1;
|
||||
const float spacing = heightmap.spacing();
|
||||
|
||||
TerrainGpuMesh mesh;
|
||||
mesh.name = heightmap.describe();
|
||||
mesh.vertices.resize(static_cast<std::size_t>(res) * res);
|
||||
mesh.indices.reserve(static_cast<std::size_t>(cells) * cells * 6);
|
||||
|
||||
for (uint32_t iz = 0; iz < res; ++iz) {
|
||||
for (uint32_t ix = 0; ix < res; ++ix) {
|
||||
const float height = heightmap.at(ix, iz);
|
||||
const glm::vec3 normal = gridNormal(heightmap, ix, iz, res, spacing);
|
||||
if (!std::isfinite(height) || !std::isfinite(normal.y)) {
|
||||
throw std::runtime_error(
|
||||
"TerrainMesh : coordonnee ou normale non finie (NaN/infini) "
|
||||
"produite par la heightmap.");
|
||||
}
|
||||
// Pas de geomorphing pour un bloc unique (bande de morphing vide) :
|
||||
// la cible est le sommet lui-meme, comme le laissait a zero le
|
||||
// format de 68 octets - sans effet puisque jamais lue.
|
||||
TerrainVertex& vertex = mesh.vertices[static_cast<std::size_t>(iz) * res + ix];
|
||||
vertex.height = height;
|
||||
vertex.morphHeight = height;
|
||||
vertex.normal[0] = packSnorm16(normal.x);
|
||||
vertex.normal[1] = packSnorm16(normal.z);
|
||||
vertex.morphNormal[0] = vertex.normal[0];
|
||||
vertex.morphNormal[1] = vertex.normal[1];
|
||||
}
|
||||
}
|
||||
appendGridIndices(res, mesh.indices);
|
||||
|
||||
logInfo("Maillage terrain (format GPU compact) : " + std::to_string(mesh.vertices.size()) +
|
||||
" sommets, " + std::to_string(mesh.indices.size() / 3) + " triangles, " +
|
||||
std::to_string(mesh.vertices.size() * sizeof(TerrainVertex) / (1024 * 1024)) +
|
||||
" Mo de sommets.");
|
||||
return mesh;
|
||||
}
|
||||
|
||||
} // namespace vercora
|
||||
@@ -1,7 +1,12 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/GpuVertex.hpp"
|
||||
#include "renderer/MeshData.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace vercora {
|
||||
|
||||
class Heightmap;
|
||||
@@ -20,4 +25,17 @@ class Heightmap;
|
||||
// Lance std::runtime_error si la grille ne peut pas produire un maillage sain.
|
||||
MeshData terrainMeshData(const Heightmap& heightmap);
|
||||
|
||||
// PHASE 32. Le meme terrain d'un seul bloc, au format GPU du terrain
|
||||
// (TerrainVertex, 16 octets) : c'est ce que televerse le chemin --no-lod, sans
|
||||
// construire au passage le MeshData de 68 octets par sommet (1,7 Go sur la zone
|
||||
// au pas de 1 m). vertices[v] == toTerrainVertex(terrainMeshData(h).vertices[v])
|
||||
// au bit pres et les indices sont identiques (verifie par les tests). Les
|
||||
// sommets n'ont pas de cible de geomorphing : elle vaut le sommet lui-meme.
|
||||
struct TerrainGpuMesh {
|
||||
std::vector<TerrainVertex> vertices;
|
||||
std::vector<uint32_t> indices;
|
||||
std::string name;
|
||||
};
|
||||
TerrainGpuMesh terrainGpuMeshData(const Heightmap& heightmap);
|
||||
|
||||
} // namespace vercora
|
||||
@@ -89,9 +89,16 @@ std::vector<uint32_t> terrainNodeIndices(uint32_t nodeCells) {
|
||||
return indices;
|
||||
}
|
||||
|
||||
MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
|
||||
uint32_t nodeIndex, bool withIndices,
|
||||
bool reuseParentGrid) {
|
||||
namespace {
|
||||
|
||||
// PHASE 32 : le parcours d'un noeud, commun aux deux formats de sortie
|
||||
// (MeshData de reference et TerrainVertex du GPU). `sink(v, gx, gz, here,
|
||||
// parent)` recoit chaque sommet - son indice dans la tuile, ses indices de
|
||||
// grille ecretes, son echantillon et celui de sa cible de geomorphing. Un seul
|
||||
// parcours, donc deux sorties qui ne PEUVENT PAS diverger.
|
||||
template <typename Sink>
|
||||
void forEachNodeVertex(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
|
||||
uint32_t nodeIndex, bool reuseParentGrid, Sink&& sink) {
|
||||
if (nodeIndex >= quadtree.nodeCount()) {
|
||||
throw std::runtime_error("TerrainNodeMesh : indice de noeud hors limites.");
|
||||
}
|
||||
@@ -133,11 +140,6 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree&
|
||||
}
|
||||
}
|
||||
|
||||
MeshData mesh;
|
||||
mesh.name = "tuile L" + std::to_string(static_cast<int>(node.level)) + " (" +
|
||||
std::to_string(node.ix0) + "," + std::to_string(node.iz0) + ")";
|
||||
mesh.vertices.resize(static_cast<std::size_t>(verts) * verts);
|
||||
|
||||
for (uint32_t j = 0; j < verts; ++j) {
|
||||
for (uint32_t i = 0; i < verts; ++i) {
|
||||
// Indices de grille du sommet, ECRETES sur le bord du terrain.
|
||||
@@ -157,7 +159,43 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree&
|
||||
? parentGrid[static_cast<std::size_t>(j / 2u) * parentVerts + (i / 2u)]
|
||||
: parentSample;
|
||||
|
||||
Vertex& vertex = mesh.vertices[static_cast<std::size_t>(j) * verts + i];
|
||||
sink(static_cast<std::size_t>(j) * verts + i, gx, gz, here, parent);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Controle de coherence, meme esprit que TerrainMesh : on refuse de pousser
|
||||
// vers le GPU une geometrie qu'on sait cassee. Le generateur etant
|
||||
// deterministe, ce test attrape une erreur de CODE (indexation, pas de
|
||||
// parcours), pas une donnee douteuse.
|
||||
[[noreturn]] void throwNonFinite() {
|
||||
throw std::runtime_error(
|
||||
"TerrainNodeMesh : coordonnee ou normale non finie (NaN/infini) "
|
||||
"produite par la heightmap.");
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
|
||||
uint32_t nodeIndex, bool withIndices,
|
||||
bool reuseParentGrid) {
|
||||
if (nodeIndex >= quadtree.nodeCount()) {
|
||||
throw std::runtime_error("TerrainNodeMesh : indice de noeud hors limites.");
|
||||
}
|
||||
const TerrainQuadtree::Node& node = quadtree.node(nodeIndex);
|
||||
const uint32_t nodeCells = quadtree.nodeCells();
|
||||
const uint32_t verts = nodeCells + 1;
|
||||
const uint32_t cells = heightmap.resolution() - 1;
|
||||
|
||||
MeshData mesh;
|
||||
mesh.name = "tuile L" + std::to_string(static_cast<int>(node.level)) + " (" +
|
||||
std::to_string(node.ix0) + "," + std::to_string(node.iz0) + ")";
|
||||
mesh.vertices.resize(static_cast<std::size_t>(verts) * verts);
|
||||
|
||||
forEachNodeVertex(heightmap, quadtree, nodeIndex, reuseParentGrid,
|
||||
[&](std::size_t v, uint32_t gx, uint32_t gz,
|
||||
const GridSample& here, const GridSample& parent) {
|
||||
Vertex& vertex = mesh.vertices[v];
|
||||
vertex.pos = here.position;
|
||||
vertex.normal = here.normal;
|
||||
vertex.morphPos = parent.position;
|
||||
@@ -172,28 +210,158 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree&
|
||||
// tuile a l'autre.
|
||||
vertex.uv = { static_cast<float>(gx) / static_cast<float>(cells),
|
||||
static_cast<float>(gz) / static_cast<float>(cells) };
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
if (withIndices) {
|
||||
mesh.indices = terrainNodeIndices(nodeCells);
|
||||
}
|
||||
|
||||
// Controle de coherence, meme esprit que TerrainMesh : on refuse de pousser
|
||||
// vers le GPU une geometrie qu'on sait cassee. Le generateur etant
|
||||
// deterministe, ce test attrape une erreur de CODE (indexation, pas de
|
||||
// parcours), pas une donnee douteuse.
|
||||
for (const Vertex& vertex : mesh.vertices) {
|
||||
if (!std::isfinite(vertex.pos.x) || !std::isfinite(vertex.pos.y) ||
|
||||
!std::isfinite(vertex.pos.z) || !std::isfinite(vertex.normal.y) ||
|
||||
!std::isfinite(vertex.morphPos.y)) {
|
||||
throw std::runtime_error(
|
||||
"TerrainNodeMesh : coordonnee ou normale non finie (NaN/infini) "
|
||||
"produite par la heightmap.");
|
||||
throwNonFinite();
|
||||
}
|
||||
}
|
||||
|
||||
return mesh;
|
||||
}
|
||||
|
||||
bool terrainNodeUsesFastPath(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
|
||||
uint32_t nodeIndex) {
|
||||
if (nodeIndex >= quadtree.nodeCount()) {
|
||||
return false;
|
||||
}
|
||||
const TerrainQuadtree::Node& node = quadtree.node(nodeIndex);
|
||||
const uint64_t cells = heightmap.resolution() - 1;
|
||||
const uint64_t stride = node.stride;
|
||||
// Deux pas de marge de chaque cote : les voisins d'un sommet sont a un pas,
|
||||
// ceux d'un echantillon du parent a deux pas (le pas du parent).
|
||||
const uint64_t reach = static_cast<uint64_t>(quadtree.nodeCells() + 2) * stride;
|
||||
return node.ix0 >= 2 * stride && node.iz0 >= 2 * stride &&
|
||||
node.ix0 + reach <= cells && node.iz0 + reach <= cells;
|
||||
}
|
||||
|
||||
void writeTerrainNodeVertices(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
|
||||
uint32_t nodeIndex, TerrainVertex* out,
|
||||
bool reuseParentGrid) {
|
||||
// --- PHASE 32 : chemin RAPIDE des tuiles interieures --------------------
|
||||
// Le parcours de reference lit chaque altitude ~6 fois, toujours par at()
|
||||
// et son ecretage : cinq lectures par echantillon (le point et ses quatre
|
||||
// voisins) pour les 4 225 sommets ET les 1 089 echantillons du parent. Or
|
||||
// les voisins d'un sommet, au pas du noeud, sont exactement les sommets
|
||||
// voisins de la tuile, et ceux du parent, au pas double, les sommets a
|
||||
// deux rangs. Loin du bord, ou aucun indice n'est ecrete, une grille de
|
||||
// (n + 5)^2 altitudes lues UNE fois contient donc tout.
|
||||
//
|
||||
// Les MEMES operations flottantes sur les MEMES valeurs que sampleGrid -
|
||||
// memes differences, memes divisions (le pas reel, 2 ou 4 fois le pas du
|
||||
// noeud, comme (xp - xm) la-bas), meme glm::normalize : le resultat est
|
||||
// identique au bit pres, et tests/logic_tests.cpp le verifie sur toutes les
|
||||
// tuiles de plusieurs grilles. Pres du bord, ou l'ecretage change les
|
||||
// voisins, le chemin de reference ci-dessous reste seul juge. Le temoin
|
||||
// --no-tile-cache (reuseParentGrid = false) le garde aussi : il mesure le
|
||||
// travail d'avant la Phase 18.
|
||||
if (reuseParentGrid && terrainNodeUsesFastPath(heightmap, quadtree, nodeIndex)) {
|
||||
const TerrainQuadtree::Node& node = quadtree.node(nodeIndex);
|
||||
const uint32_t verts = quadtree.nodeCells() + 1;
|
||||
const uint32_t stride = node.stride;
|
||||
const uint32_t res = heightmap.resolution();
|
||||
const float spacing = heightmap.spacing();
|
||||
const float* heights = heightmap.rawHeights();
|
||||
|
||||
// Grille bordee de deux rangs : l'indice local k correspond a
|
||||
// l'echantillon ix0 + (k - 2) * stride. thread_local : le chemin
|
||||
// parallele (Phase 19) l'appelle depuis plusieurs threads a la fois.
|
||||
const uint32_t span = verts + 4;
|
||||
thread_local std::vector<float> grid;
|
||||
grid.resize(static_cast<std::size_t>(span) * span);
|
||||
for (uint32_t jj = 0; jj < span; ++jj) {
|
||||
const float* row = heights + static_cast<std::size_t>(node.iz0 - 2u * stride +
|
||||
jj * stride) * res;
|
||||
const float* sample = row + (node.ix0 - 2u * stride);
|
||||
float* destination = grid.data() + static_cast<std::size_t>(jj) * span;
|
||||
for (uint32_t ii = 0; ii < span; ++ii) {
|
||||
destination[ii] = sample[static_cast<std::size_t>(ii) * stride];
|
||||
}
|
||||
}
|
||||
const auto at = [&](uint32_t ii, uint32_t jj) {
|
||||
return grid[static_cast<std::size_t>(jj) * span + ii];
|
||||
};
|
||||
// Les pas reels des differences centrees : (xp - xm) * spacing dans
|
||||
// sampleGrid, soit 2 pas du noeud pour un sommet, 4 pour le parent.
|
||||
const float step = static_cast<float>(2u * stride) * spacing;
|
||||
const float parentStep = static_cast<float>(4u * stride) * spacing;
|
||||
|
||||
// Grille du parent, deja quantifiee : une fois par bloc 2 x 2.
|
||||
struct ParentSample {
|
||||
float height;
|
||||
int16_t normal[2];
|
||||
};
|
||||
const uint32_t parentVerts = (verts + 1u) / 2u;
|
||||
thread_local std::vector<ParentSample> parents;
|
||||
parents.resize(static_cast<std::size_t>(parentVerts) * parentVerts);
|
||||
bool finite = true;
|
||||
for (uint32_t pj = 0; pj < parentVerts; ++pj) {
|
||||
for (uint32_t pi = 0; pi < parentVerts; ++pi) {
|
||||
const uint32_t ii = 2u * pi + 2u;
|
||||
const uint32_t jj = 2u * pj + 2u;
|
||||
const float dhdx = (at(ii + 2u, jj) - at(ii - 2u, jj)) / parentStep;
|
||||
const float dhdz = (at(ii, jj + 2u) - at(ii, jj - 2u)) / parentStep;
|
||||
const glm::vec3 normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
|
||||
ParentSample& parent = parents[static_cast<std::size_t>(pj) * parentVerts + pi];
|
||||
parent.height = at(ii, jj);
|
||||
parent.normal[0] = packSnorm16(normal.x);
|
||||
parent.normal[1] = packSnorm16(normal.z);
|
||||
finite = finite && std::isfinite(parent.height) && std::isfinite(normal.y);
|
||||
}
|
||||
}
|
||||
for (uint32_t j = 0; j < verts; ++j) {
|
||||
for (uint32_t i = 0; i < verts; ++i) {
|
||||
const uint32_t ii = i + 2u;
|
||||
const uint32_t jj = j + 2u;
|
||||
const float dhdx = (at(ii + 1u, jj) - at(ii - 1u, jj)) / step;
|
||||
const float dhdz = (at(ii, jj + 1u) - at(ii, jj - 1u)) / step;
|
||||
const glm::vec3 normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
|
||||
const ParentSample& parent =
|
||||
parents[static_cast<std::size_t>(j / 2u) * parentVerts + (i / 2u)];
|
||||
|
||||
TerrainVertex& packed = out[static_cast<std::size_t>(j) * verts + i];
|
||||
packed.height = at(ii, jj);
|
||||
packed.morphHeight = parent.height;
|
||||
packed.normal[0] = packSnorm16(normal.x);
|
||||
packed.normal[1] = packSnorm16(normal.z);
|
||||
packed.morphNormal[0] = parent.normal[0];
|
||||
packed.morphNormal[1] = parent.normal[1];
|
||||
finite = finite && std::isfinite(packed.height) && std::isfinite(normal.y);
|
||||
}
|
||||
}
|
||||
if (!finite) {
|
||||
throwNonFinite();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
bool finite = true;
|
||||
forEachNodeVertex(heightmap, quadtree, nodeIndex, reuseParentGrid,
|
||||
[&](std::size_t v, uint32_t /*gx*/, uint32_t /*gz*/,
|
||||
const GridSample& here, const GridSample& parent) {
|
||||
// Les memes octets que toTerrainVertex(Vertex) appliquee au sommet de
|
||||
// terrainNodeMeshData : altitudes recopiees, normales quantifiees.
|
||||
TerrainVertex packed;
|
||||
packed.height = here.position.y;
|
||||
packed.morphHeight = parent.position.y;
|
||||
packed.normal[0] = packSnorm16(here.normal.x);
|
||||
packed.normal[1] = packSnorm16(here.normal.z);
|
||||
packed.morphNormal[0] = packSnorm16(parent.normal.x);
|
||||
packed.morphNormal[1] = packSnorm16(parent.normal.z);
|
||||
out[v] = packed;
|
||||
finite = finite && std::isfinite(here.position.y) && std::isfinite(here.normal.y) &&
|
||||
std::isfinite(parent.position.y);
|
||||
});
|
||||
if (!finite) {
|
||||
throwNonFinite();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace vercora
|
||||
@@ -1,5 +1,6 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/GpuVertex.hpp"
|
||||
#include "renderer/MeshData.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
@@ -63,4 +64,31 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree&
|
||||
// diagonale que TerrainMesh. Calculee une fois par appelant et reutilisee.
|
||||
std::vector<uint32_t> terrainNodeIndices(uint32_t nodeCells);
|
||||
|
||||
// PHASE 32. Les MEMES sommets que terrainNodeMeshData, ecrits directement au
|
||||
// format GPU du terrain (TerrainVertex, 16 octets) dans `out`, qui doit pouvoir
|
||||
// en recevoir (nodeCells + 1)^2. C'est le chemin du TerrainStreamer : `out`
|
||||
// pointe dans la memoire que le GPU lira (ou dans un staging), et aucun
|
||||
// MeshData de 287 Ko n'est plus construit puis recopie par tuile.
|
||||
//
|
||||
// Garantie, verifiee par tests/logic_tests.cpp : pour tout noeud,
|
||||
// out[v] == toTerrainVertex(terrainNodeMeshData(...).vertices[v]) AU BIT PRES -
|
||||
// memes altitudes, memes normales avant quantification. C'est
|
||||
// terrainNodeMeshData qui reste la reference testee de la geometrie (positions,
|
||||
// morphing, bords) ; cette fonction n'en est qu'un autre format de sortie.
|
||||
//
|
||||
// Pure et sans etat partage, comme terrainNodeMeshData : appelable depuis
|
||||
// plusieurs threads sur des noeuds et des sorties distincts (Phase 19).
|
||||
// Lance std::runtime_error pour les memes raisons.
|
||||
void writeTerrainNodeVertices(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
|
||||
uint32_t nodeIndex, TerrainVertex* out,
|
||||
bool reuseParentGrid = true);
|
||||
|
||||
// PHASE 32. true si writeTerrainNodeVertices prend le chemin RAPIDE pour ce
|
||||
// noeud : une tuile assez loin du bord du terrain pour qu'aucun des
|
||||
// echantillons qu'elle lit (ses sommets, leurs voisins au pas du noeud, et
|
||||
// ceux de la grille du parent au pas double) ne soit ecrete. Expose pour que
|
||||
// les tests verifient qu'ils couvrent bien les deux chemins.
|
||||
bool terrainNodeUsesFastPath(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
|
||||
uint32_t nodeIndex);
|
||||
|
||||
} // namespace vercora
|
||||
@@ -20,15 +20,19 @@ TerrainStreamer::TerrainStreamer(const Heightmap& heightmap, Renderer& renderer,
|
||||
quadtree_(heightmap, params.quadtree) {
|
||||
logInfo(quadtree_.describe());
|
||||
|
||||
const std::size_t bytesPerNode = static_cast<std::size_t>(quadtree_.nodeCells() + 1) *
|
||||
(quadtree_.nodeCells() + 1) * sizeof(Vertex) +
|
||||
static_cast<std::size_t>(quadtree_.trianglesPerNode()) *
|
||||
3 * sizeof(uint32_t);
|
||||
// PHASE 32 : une tuile ne pese plus que ses sommets, au format compact
|
||||
// (16 octets au lieu de 68) ; sa topologie est televersee UNE fois pour
|
||||
// toutes, ici, en uint16.
|
||||
bytesPerNode_ = static_cast<std::size_t>(quadtree_.nodeCells() + 1) *
|
||||
(quadtree_.nodeCells() + 1) * sizeof(TerrainVertex);
|
||||
sharedIndexSet_ = renderer_.addSharedIndices(sharedIndices());
|
||||
logInfo("Streaming terrain : au plus " + std::to_string(params_.maxResidentNodes) +
|
||||
" tuiles residentes (" +
|
||||
std::to_string(params_.maxResidentNodes * bytesPerNode / (1024 * 1024)) +
|
||||
" Mo de geometrie GPU), " + std::to_string(params_.maxUploadsPerFrame) +
|
||||
" construites par frame.");
|
||||
std::to_string(params_.maxResidentNodes * bytesPerNode_ / (1024 * 1024)) +
|
||||
" Mo de geometrie GPU, " + std::to_string(bytesPerNode_ / 1024) +
|
||||
" Ko par tuile, topologie partagee de " +
|
||||
std::to_string(sharedIndices().size() * sizeof(uint16_t) / 1024) + " Ko), " +
|
||||
std::to_string(params_.maxUploadsPerFrame) + " construites par frame.");
|
||||
|
||||
pinTopLevels();
|
||||
}
|
||||
@@ -46,11 +50,6 @@ void TerrainStreamer::pinTopLevels() {
|
||||
const int lowest = std::max(0, static_cast<int>(quadtree_.rootLevel()) -
|
||||
static_cast<int>(params_.pinnedTopLevels) + 1);
|
||||
|
||||
const std::size_t bytesPerNode =
|
||||
static_cast<std::size_t>(quadtree_.nodeCells() + 1) *
|
||||
(quadtree_.nodeCells() + 1) * sizeof(Vertex) +
|
||||
static_cast<std::size_t>(quadtree_.trianglesPerNode()) * 3 * sizeof(uint32_t);
|
||||
|
||||
for (uint32_t index = 0; index < quadtree_.nodeCount(); ++index) {
|
||||
if (static_cast<int>(quadtree_.node(index).level) < lowest) {
|
||||
continue;
|
||||
@@ -61,19 +60,19 @@ void TerrainStreamer::pinTopLevels() {
|
||||
}
|
||||
ResidentNode node;
|
||||
node.mesh = mesh;
|
||||
node.bytes = bytesPerNode;
|
||||
node.bytes = bytesPerNode_;
|
||||
node.pinned = true;
|
||||
// Jamais rajeunie ensuite : elle n'est de toute facon pas evincable.
|
||||
node.lastUsedFrame = 0;
|
||||
resident_.emplace(index, node);
|
||||
residentBytes_ += bytesPerNode;
|
||||
residentBytes_ += bytesPerNode_;
|
||||
++pinnedCount_;
|
||||
}
|
||||
|
||||
logInfo("Sommet du quadtree epingle : " + std::to_string(pinnedCount_) +
|
||||
" tuiles de niveau " + std::to_string(lowest) + " a " +
|
||||
std::to_string(static_cast<int>(quadtree_.rootLevel())) + " (" +
|
||||
std::to_string(pinnedCount_ * bytesPerNode / (1024 * 1024)) +
|
||||
std::to_string(pinnedCount_ * bytesPerNode_ / (1024 * 1024)) +
|
||||
" Mo), jamais evincees. C'est ce qui rend le repli sur l'ancetre "
|
||||
"toujours disponible.");
|
||||
}
|
||||
@@ -107,11 +106,11 @@ const std::vector<uint32_t>& TerrainStreamer::sharedIndices() const {
|
||||
// n'aurait parie sur la boucle d'indices.
|
||||
//
|
||||
// Construite a la premiere tuile puis simplement RECOPIEE dans le MeshData.
|
||||
// Ne pas la recopier du tout - partager un unique buffer d'indices GPU entre
|
||||
// toutes les tuiles - economiserait en plus 96 Ko par tuile residente, mais
|
||||
// demanderait de dissocier sommets et indices dans Renderer::addMesh : c'est
|
||||
// un chantier de renderer, pas de streaming (voir NOTES-PHASE18.md).
|
||||
if (indexTemplate_.empty() || !params_.cacheTileWork) {
|
||||
// PHASE 32 : elle n'est meme plus recopiee. Le chantier de renderer que
|
||||
// cette note annoncait (NOTES-PHASE18.md) est fait : un UNIQUE buffer
|
||||
// d'indices GPU, en uint16, sert toutes les tuiles - 96 Ko economises par
|
||||
// tuile residente, et une seule liaison d'indices par image.
|
||||
if (indexTemplate_.empty()) {
|
||||
indexTemplate_ = terrainNodeIndices(quadtree_.nodeCells());
|
||||
}
|
||||
return indexTemplate_;
|
||||
@@ -148,19 +147,40 @@ bool TerrainStreamer::wantsParallel(std::size_t count) const {
|
||||
}
|
||||
|
||||
void TerrainStreamer::meshBatch(const std::vector<uint32_t>& nodes) {
|
||||
batchMeshes_.clear();
|
||||
batchErrors_.clear();
|
||||
batchMeshes_.resize(nodes.size());
|
||||
batchErrors_.resize(nodes.size());
|
||||
batchMeshes_.assign(nodes.size(), kInvalidMesh);
|
||||
batchWrites_.assign(nodes.size(), Renderer::TerrainMeshWrite{});
|
||||
if (nodes.empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Le corps d'un travailleur. Il ne touche QUE batchMeshes_[k] et
|
||||
// batchErrors_[k] pour k dans [begin, end) - des elements deja alloues, donc
|
||||
// ni le vecteur ni sa capacite ne bougent pendant l'execution. Tout le reste
|
||||
// de ce qu'il lit (heightmap_, quadtree_, params_) est const pour la duree
|
||||
// de la session.
|
||||
// --- 1. Reservation, thread de rendu -----------------------------------
|
||||
// Faire de la place AVANT de reserver, sinon le pic de residence depasserait
|
||||
// le plafond le temps du lot. Les tuiles deja reservees de ce lot comptent
|
||||
// comme residentes : elles le seront a la fin de la frame.
|
||||
const auto t0 = Clock::now();
|
||||
for (std::size_t k = 0; k < nodes.size(); ++k) {
|
||||
while (resident_.size() + k >= params_.maxResidentNodes) {
|
||||
if (!evictOne()) {
|
||||
break; // tout est utilise cette frame : on laisse deborder
|
||||
}
|
||||
}
|
||||
try {
|
||||
batchWrites_[k] = renderer_.beginTerrainMesh(
|
||||
(quadtree_.nodeCells() + 1) * (quadtree_.nodeCells() + 1), sharedIndexSet_);
|
||||
} catch (const std::exception& e) {
|
||||
batchErrors_[k] = e.what();
|
||||
}
|
||||
}
|
||||
uploadMicros_ += microsBetween(t0, Clock::now());
|
||||
|
||||
// --- 2. Ecriture des sommets, eventuellement en parallele ----------------
|
||||
// Le corps d'un travailleur. Il ne touche QUE la zone reservee
|
||||
// batchWrites_[k].vertices et batchErrors_[k] pour k dans [begin, end) -
|
||||
// deja allouees, donc ni les vecteurs ni leur capacite ne bougent pendant
|
||||
// l'execution. Tout le reste de ce qu'il lit (heightmap_, quadtree_,
|
||||
// params_) est const pour la duree de la session.
|
||||
//
|
||||
// Le chronometrage par tuile est fait ICI, mais il n'est PAS accumule dans
|
||||
// geometryMicros_ depuis un thread : chaque tuile depose sa duree dans son
|
||||
@@ -173,21 +193,22 @@ void TerrainStreamer::meshBatch(const std::vector<uint32_t>& nodes) {
|
||||
|
||||
const auto worker = [&](std::size_t begin, std::size_t end) {
|
||||
for (std::size_t k = begin; k < end; ++k) {
|
||||
const auto t0 = Clock::now();
|
||||
if (batchWrites_[k].vertices == nullptr) {
|
||||
continue; // reservation echouee, message deja depose
|
||||
}
|
||||
const auto t1 = Clock::now();
|
||||
try {
|
||||
batchMeshes_[k] = terrainNodeMeshData(heightmap_, quadtree_, nodes[k],
|
||||
false, params_.cacheTileWork);
|
||||
writeTerrainNodeVertices(heightmap_, quadtree_, nodes[k],
|
||||
batchWrites_[k].vertices, params_.cacheTileWork);
|
||||
} catch (const std::exception& e) {
|
||||
// Une exception ne doit JAMAIS traverser la frontiere d'un
|
||||
// std::thread : elle appellerait std::terminate. Elle est donc
|
||||
// capturee ici et rendue a l'appelant comme une donnee.
|
||||
batchErrors_[k] = e.what();
|
||||
batchMeshes_[k] = MeshData{};
|
||||
} catch (...) {
|
||||
batchErrors_[k] = "exception inconnue";
|
||||
batchMeshes_[k] = MeshData{};
|
||||
}
|
||||
perTileMicros[k] = microsBetween(t0, Clock::now());
|
||||
perTileMicros[k] = microsBetween(t1, Clock::now());
|
||||
}
|
||||
};
|
||||
|
||||
@@ -226,60 +247,68 @@ void TerrainStreamer::meshBatch(const std::vector<uint32_t>& nodes) {
|
||||
for (uint64_t micros : perTileMicros) {
|
||||
geometryMicros_ += micros;
|
||||
}
|
||||
|
||||
// --- 3. Livraison, thread de rendu ---------------------------------------
|
||||
const auto t2 = Clock::now();
|
||||
for (std::size_t k = 0; k < nodes.size(); ++k) {
|
||||
const MeshHandle mesh = batchWrites_[k].mesh;
|
||||
if (!batchErrors_[k].empty()) {
|
||||
if (mesh != kInvalidMesh) {
|
||||
renderer_.removeMesh(mesh);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
renderer_.endTerrainMesh(mesh);
|
||||
batchMeshes_[k] = mesh;
|
||||
++builtNodes_;
|
||||
}
|
||||
uploadMicros_ += microsBetween(t2, Clock::now());
|
||||
}
|
||||
|
||||
MeshHandle TerrainStreamer::uploadNode(uint32_t nodeIndex, MeshData& data) {
|
||||
MeshHandle TerrainStreamer::buildNode(uint32_t nodeIndex) {
|
||||
// Chemin SEQUENTIEL : reserve, ecrit, livre une tuile. C'est le chemin du
|
||||
// sommet epingle (construit avant la premiere frame) et, depuis que le
|
||||
// defaut est meshThreads = 1, celui de la construction courante.
|
||||
//
|
||||
// PHASE 32 : plus aucun MeshData ici. Les sommets sont ecrits au format
|
||||
// compact directement dans la zone reservee - la memoire que le GPU lira
|
||||
// en memoire unifiee, un staging sinon. Le poste "televersement" ne compte
|
||||
// plus que la reservation et la livraison.
|
||||
const auto t0 = Clock::now();
|
||||
Renderer::TerrainMeshWrite write;
|
||||
try {
|
||||
const auto t1 = Clock::now();
|
||||
// Les indices sont poses ICI et non dans terrainNodeMeshData, pour que
|
||||
// les deux postes soient chronometres separement (voir buildProfile).
|
||||
data.indices = sharedIndices();
|
||||
const auto t2 = Clock::now();
|
||||
// log = false : plusieurs tuiles par frame, une ligne chacune rendrait la
|
||||
// sortie inexploitable (et couterait plus que l'upload).
|
||||
const MeshHandle mesh = renderer_.addMesh(data, false);
|
||||
const auto t3 = Clock::now();
|
||||
|
||||
++builtNodes_;
|
||||
indicesMicros_ += microsBetween(t1, t2);
|
||||
uploadMicros_ += microsBetween(t2, t3);
|
||||
return mesh;
|
||||
write = renderer_.beginTerrainMesh(
|
||||
(quadtree_.nodeCells() + 1) * (quadtree_.nodeCells() + 1), sharedIndexSet_);
|
||||
} catch (const std::exception& e) {
|
||||
// Une tuile qu'on ne sait pas construire ne doit pas arreter le jeu :
|
||||
// elle sera simplement absente, et le message dit laquelle. Le cas
|
||||
// realiste est un manque de memoire GPU, pas une donnee invalide.
|
||||
uploadMicros_ += microsBetween(t0, Clock::now());
|
||||
// Le cas realiste est un manque de memoire GPU, pas une donnee
|
||||
// invalide : la tuile sera simplement absente, et le message dit
|
||||
// laquelle.
|
||||
logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) +
|
||||
" non televersee (" + e.what() + ").");
|
||||
return kInvalidMesh;
|
||||
}
|
||||
}
|
||||
|
||||
MeshHandle TerrainStreamer::buildNode(uint32_t nodeIndex) {
|
||||
// Chemin SEQUENTIEL : maille une tuile puis la televerse, sans jamais garder
|
||||
// plus d'un MeshData en vie. C'est le chemin du sommet epingle (construit
|
||||
// avant la premiere frame) et, depuis que le defaut est meshThreads = 1,
|
||||
// celui de la construction courante.
|
||||
//
|
||||
// Ne pas passer par meshBatch ici n'est pas une duplication gratuite :
|
||||
// meshBatch dimensionne un vecteur de MeshData pour TOUT le lot, ce qui fait
|
||||
// vivre jusqu'a 53 tuiles simultanement (~15 Mo) la ou ce chemin-ci n'en
|
||||
// tient qu'une. Mesure : le pic memoire du processus montait de 5,6 Mo quand
|
||||
// tout passait par le lot. Le chemin par defaut retrouve ainsi exactement le
|
||||
// profil memoire d'avant la Phase 19.
|
||||
const auto t0 = Clock::now();
|
||||
const auto t1 = Clock::now();
|
||||
try {
|
||||
scratchMesh_ = terrainNodeMeshData(heightmap_, quadtree_, nodeIndex, false,
|
||||
writeTerrainNodeVertices(heightmap_, quadtree_, nodeIndex, write.vertices,
|
||||
params_.cacheTileWork);
|
||||
} catch (const std::exception& e) {
|
||||
geometryMicros_ += microsBetween(t0, Clock::now());
|
||||
geometryMicros_ += microsBetween(t1, Clock::now());
|
||||
renderer_.removeMesh(write.mesh);
|
||||
logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) +
|
||||
" non maillee (" + e.what() + ").");
|
||||
return kInvalidMesh;
|
||||
}
|
||||
const uint64_t micros = microsBetween(t0, Clock::now());
|
||||
const auto t2 = Clock::now();
|
||||
renderer_.endTerrainMesh(write.mesh);
|
||||
const auto t3 = Clock::now();
|
||||
|
||||
const uint64_t micros = microsBetween(t1, t2);
|
||||
geometryMicros_ += micros;
|
||||
meshWallMicros_ += micros;
|
||||
return uploadNode(nodeIndex, scratchMesh_);
|
||||
uploadMicros_ += microsBetween(t0, t1) + microsBetween(t2, t3);
|
||||
++builtNodes_;
|
||||
return write.mesh;
|
||||
}
|
||||
|
||||
bool TerrainStreamer::evictOne() {
|
||||
@@ -354,11 +383,6 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
|
||||
fallbackCount_ = 0;
|
||||
uncoveredCount_ = 0;
|
||||
|
||||
const std::size_t bytesPerNode =
|
||||
static_cast<std::size_t>(quadtree_.nodeCells() + 1) *
|
||||
(quadtree_.nodeCells() + 1) * sizeof(Vertex) +
|
||||
static_cast<std::size_t>(quadtree_.trianglesPerNode()) * 3 * sizeof(uint32_t);
|
||||
|
||||
const bool priming = (frameCounter_ <= params_.primingFrames);
|
||||
uint32_t uploadsLeft = priming ? std::numeric_limits<uint32_t>::max()
|
||||
: params_.maxUploadsPerFrame;
|
||||
@@ -402,14 +426,13 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
|
||||
// --- 1b/1c. Maillage puis televersement ---------------------------------
|
||||
// Deux chemins, et le choix se fait sur la TAILLE DU LOT :
|
||||
//
|
||||
// - lot parallelisable : tout le lot est maille d'abord (meshBatch, aucun
|
||||
// appel Vulkan, plusieurs threads), puis televerse en sequence ;
|
||||
// - sinon : chaque tuile est maillee et televersee a la suite, sans jamais
|
||||
// garder plus d'un MeshData en vie. C'est le chemin par DEFAUT, et il
|
||||
// est identique a celui d'avant la Phase 19, cout memoire compris.
|
||||
// - lot parallelisable : tout le lot est reserve, puis ecrit (meshBatch,
|
||||
// aucun appel Vulkan pendant l'ecriture, plusieurs threads), puis livre ;
|
||||
// - sinon : chaque tuile est reservee, ecrite et livree a la suite. C'est
|
||||
// le chemin par DEFAUT.
|
||||
//
|
||||
// Dans les deux cas les addMesh ont lieu sur le thread de rendu, en
|
||||
// sequence, et dans l'ordre de selection - donc du plus proche au plus
|
||||
// Dans les deux cas les appels au Renderer ont lieu sur le thread de rendu,
|
||||
// en sequence, et dans l'ordre de selection - donc du plus proche au plus
|
||||
// lointain.
|
||||
|
||||
// Suivi du plus gros lot : il doit compter les DEUX chemins, sinon le bilan
|
||||
@@ -429,17 +452,19 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
|
||||
" non maillee (" + batchErrors_[k] + ").");
|
||||
continue;
|
||||
}
|
||||
// Faire de la place AVANT de televerser, sinon le pic de residence
|
||||
// depasserait le plafond le temps d'un upload. (Le maillage, lui,
|
||||
// n'alloue rien sur le GPU : c'est bien l'upload qui doit etre couvert.)
|
||||
MeshHandle mesh = kInvalidMesh;
|
||||
if (parallel) {
|
||||
mesh = batchMeshes_[k]; // place deja faite par meshBatch
|
||||
} else {
|
||||
// Faire de la place AVANT de reserver, sinon le pic de residence
|
||||
// depasserait le plafond le temps d'une tuile.
|
||||
while (resident_.size() >= params_.maxResidentNodes) {
|
||||
if (!evictOne()) {
|
||||
break; // tout est utilise cette frame : on laisse deborder
|
||||
}
|
||||
}
|
||||
|
||||
const MeshHandle mesh = parallel ? uploadNode(nodeIndex, batchMeshes_[k])
|
||||
: buildNode(nodeIndex);
|
||||
mesh = buildNode(nodeIndex);
|
||||
}
|
||||
if (mesh == kInvalidMesh) {
|
||||
continue;
|
||||
}
|
||||
@@ -447,20 +472,13 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
|
||||
|
||||
ResidentNode node;
|
||||
node.mesh = mesh;
|
||||
node.bytes = bytesPerNode;
|
||||
node.bytes = bytesPerNode_;
|
||||
node.lastUsedFrame = frameCounter_;
|
||||
resident_.emplace(nodeIndex, node);
|
||||
residentBytes_ += bytesPerNode;
|
||||
residentBytes_ += bytesPerNode_;
|
||||
--pendingCount_; // finalement servie dans la frame meme
|
||||
}
|
||||
|
||||
// Le lot ne doit pas garder ses maillages en vie jusqu'a la frame suivante :
|
||||
// ce sont ~287 Ko par tuile.
|
||||
if (parallel) {
|
||||
batchMeshes_.clear();
|
||||
batchMeshes_.shrink_to_fit();
|
||||
}
|
||||
|
||||
// --- 2. Choix des ancetres de repli (PHASE 12) --------------------------
|
||||
// Rien a faire dans le cas courant : en regime etabli toute la selection est
|
||||
// residente, l'ensemble reste vide et les passes suivantes ne coutent rien.
|
||||
@@ -489,6 +507,7 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
|
||||
// --- 3. Emission ---------------------------------------------------------
|
||||
const bool hasFallback = !fallbackAncestors_.empty();
|
||||
|
||||
const int32_t vertsPerRow = static_cast<int32_t>(quadtree_.nodeCells() + 1);
|
||||
auto emit = [&](const TerrainQuadtree::SelectedNode& node, MeshHandle mesh) {
|
||||
DrawItem item;
|
||||
item.mesh = mesh;
|
||||
@@ -497,6 +516,11 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition,
|
||||
item.model = glm::mat4(1.0f);
|
||||
item.material = Material::Terrain;
|
||||
item.params = glm::vec4(node.morphStart, node.morphEnd, 0.0f, 0.0f);
|
||||
// PHASE 32 : ou est la tuile dans la grille - terrain.vert en deduit la
|
||||
// position horizontale, la cible de morphing et l'UV de chaque sommet.
|
||||
const TerrainQuadtree::Node& grid = quadtree_.node(node.nodeIndex);
|
||||
item.grid = glm::ivec4(static_cast<int32_t>(grid.ix0), static_cast<int32_t>(grid.iz0),
|
||||
static_cast<int32_t>(grid.stride), vertsPerRow);
|
||||
out.push_back(item);
|
||||
++drawnCount_;
|
||||
};
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include "core/Frustum.hpp"
|
||||
#include "renderer/DrawItem.hpp"
|
||||
#include "renderer/MeshData.hpp"
|
||||
#include "renderer/Renderer.hpp" // Renderer::TerrainMeshWrite
|
||||
#include "world/TerrainQuadtree.hpp"
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
@@ -16,7 +17,6 @@
|
||||
namespace vercora {
|
||||
|
||||
class Heightmap;
|
||||
class Renderer;
|
||||
|
||||
// Fait le lien entre le quadtree (qui decide QUOI dessiner) et le Renderer (qui
|
||||
// possede les geometries GPU) : cache de tuiles residentes, construction a la
|
||||
@@ -36,10 +36,12 @@ class Renderer;
|
||||
// recopier). Il est passe de 4 a 64 pour cette raison. Les tuiles au-dela du
|
||||
// budget sont servies dans les frames suivantes, les plus PROCHES d'abord.
|
||||
//
|
||||
// 2. PLAFOND DE RESIDENCE (maxResidentNodes). Chaque tuile consomme deux
|
||||
// allocations Vulkan (vertex + index), et vkAllocateMemory est plafonne par
|
||||
// maxMemoryAllocationCount (typiquement 4096). Le plafond garde une marge
|
||||
// confortable en plus de borner la RAM.
|
||||
// 2. PLAFOND DE RESIDENCE (maxResidentNodes). Il bornait a l'origine deux
|
||||
// choses : la memoire, et le nombre d'allocations Vulkan (deux par tuile,
|
||||
// plafonnees par maxMemoryAllocationCount, typiquement 4096). PHASE 32 :
|
||||
// les tuiles vivent dans les blocs partages du GpuBufferPool, une tuile ne
|
||||
// coute plus d'allocation - le plafond ne borne plus que la memoire, a
|
||||
// 68 Ko par tuile au lieu de 385.
|
||||
//
|
||||
// 3. EVICTION LRU, jamais sur une tuile utilisee dans la frame courante, ni
|
||||
// sur une tuile du sommet epingle (point 4).
|
||||
@@ -87,8 +89,9 @@ public:
|
||||
// staging vivant simultanement (64 tuiles ~ 25 Mo).
|
||||
uint32_t maxUploadsPerFrame = 64;
|
||||
|
||||
// Plafond de tuiles gardees sur le GPU. 512 tuiles = 1024 allocations
|
||||
// Vulkan et ~200 Mo au format de sommet de la Phase 10.
|
||||
// Plafond de tuiles gardees sur le GPU. 512 tuiles = ~200 Mo au format
|
||||
// de sommet de la Phase 10, ~35 Mo depuis la Phase 32 (sommet de 16
|
||||
// octets, topologie partagee), en une dizaine de blocs de 4 Mo.
|
||||
uint32_t maxResidentNodes = 512;
|
||||
|
||||
// Frames pendant lesquelles le budget par frame est LEVE, au demarrage :
|
||||
@@ -176,7 +179,11 @@ public:
|
||||
// Ni la Heightmap ni le Renderer ne sont possedes ; les deux doivent vivre
|
||||
// plus longtemps que le streamer.
|
||||
TerrainStreamer(const Heightmap& heightmap, Renderer& renderer,
|
||||
const Params& params = {});
|
||||
const Params& params);
|
||||
// Parametres par defaut : surcharge et non `= {}`, voir Heightmap() (refus
|
||||
// de GCC/Clang, CWG 1397).
|
||||
TerrainStreamer(const Heightmap& heightmap, Renderer& renderer)
|
||||
: TerrainStreamer(heightmap, renderer, Params{}) {}
|
||||
~TerrainStreamer();
|
||||
|
||||
TerrainStreamer(const TerrainStreamer&) = delete;
|
||||
@@ -241,33 +248,34 @@ private:
|
||||
bool pinned = false;
|
||||
};
|
||||
|
||||
// PHASE 19. Maille les tuiles `nodes` dans `batchMeshes_`, en parallele
|
||||
// au-dela de deux tuiles. AUCUN appel Vulkan : c'est toute la raison pour
|
||||
// laquelle cette etape peut quitter le thread de rendu sans rien changer a
|
||||
// la synchronisation du moteur.
|
||||
// PHASE 19. Construit les tuiles `nodes` dans `batchMeshes_`, le maillage
|
||||
// en parallele au-dela de deux tuiles. PHASE 32 : les emplacements sont
|
||||
// reserves d'abord sur le thread de rendu (Renderer::beginTerrainMesh), les
|
||||
// threads y ECRIVENT les sommets - sans le moindre appel Vulkan, c'est
|
||||
// toute la raison pour laquelle cette etape peut quitter le thread de
|
||||
// rendu - puis le thread de rendu les livre (endTerrainMesh).
|
||||
//
|
||||
// Chaque thread ecrit dans des ELEMENTS DISJOINTS de vecteurs deja
|
||||
// dimensionnes : il n'y a ni verrou, ni file, ni compteur partage - donc
|
||||
// aucun etat sur lequel une course serait possible. Une tuile qui echoue
|
||||
// depose son message dans `batchErrors_[k]`, jamais dans un journal (les
|
||||
// fonctions de journalisation ne sont pas prevues pour plusieurs threads) :
|
||||
// c'est l'appelant qui journalise, apres la jonction.
|
||||
// Chaque thread ecrit dans des ZONES DISJOINTES deja reservees : il n'y a
|
||||
// ni verrou, ni file, ni compteur partage - donc aucun etat sur lequel une
|
||||
// course serait possible. Une tuile qui echoue depose son message dans
|
||||
// `batchErrors_[k]`, jamais dans un journal (les fonctions de
|
||||
// journalisation ne sont pas prevues pour plusieurs threads) : c'est
|
||||
// l'appelant qui journalise, apres la jonction.
|
||||
void meshBatch(const std::vector<uint32_t>& nodes);
|
||||
|
||||
// true si un lot de `count` tuiles vaut la peine de partir sur des threads.
|
||||
bool wantsParallel(std::size_t count) const;
|
||||
|
||||
// Pose la topologie commune puis televerse. SEQUENTIEL, thread de rendu.
|
||||
// Renvoie kInvalidMesh en cas d'echec (la tuile est alors simplement
|
||||
// sautee : un trou d'une frame vaut mieux qu'un arret du jeu).
|
||||
MeshHandle uploadNode(uint32_t nodeIndex, MeshData& data);
|
||||
|
||||
// Maille ET televerse une tuile, en sequence, sans jamais garder plus d'un
|
||||
// MeshData en vie. Chemin par DEFAUT depuis que meshThreads vaut 1, et
|
||||
// chemin du sommet epingle.
|
||||
// PHASE 32. Construit une tuile : reserve sa place dans le pool de
|
||||
// geometrie (Renderer::beginTerrainMesh), y ECRIT ses sommets au format
|
||||
// compact, la livre. SEQUENTIEL, thread de rendu. Chemin par DEFAUT depuis
|
||||
// que meshThreads vaut 1, et chemin du sommet epingle. Renvoie kInvalidMesh
|
||||
// en cas d'echec (la tuile est alors simplement sautee : un trou d'une
|
||||
// frame vaut mieux qu'un arret du jeu).
|
||||
MeshHandle buildNode(uint32_t nodeIndex);
|
||||
|
||||
// PHASE 18 : la topologie d'une tuile, commune a toutes.
|
||||
// PHASE 18 : la topologie d'une tuile, commune a toutes. PHASE 32 : elle
|
||||
// n'est plus recopiee par tuile mais televersee UNE fois (sharedIndexSet_).
|
||||
const std::vector<uint32_t>& sharedIndices() const;
|
||||
|
||||
// Libere la tuile la moins recemment utilisee qui n'a pas servi dans la
|
||||
@@ -337,12 +345,16 @@ private:
|
||||
// locales, uniquement pour garder leur capacite d'une frame a l'autre -
|
||||
// meme raison que selection_ et fallbackAncestors_.
|
||||
std::vector<uint32_t> batchNodes_;
|
||||
std::vector<MeshData> batchMeshes_; // rempli seulement sur le chemin parallele
|
||||
std::vector<std::string> batchErrors_;
|
||||
// PHASE 32 : emplacements reserves par le chemin parallele, ou les threads
|
||||
// ecrivent directement (plus aucun MeshData de 287 Ko par tuile du lot).
|
||||
std::vector<Renderer::TerrainMeshWrite> batchWrites_;
|
||||
std::vector<MeshHandle> batchMeshes_;
|
||||
|
||||
// Maillage de travail du chemin sequentiel. Membre pour garder sa capacite
|
||||
// d'une tuile a l'autre ; il n'en vit jamais qu'un.
|
||||
MeshData scratchMesh_;
|
||||
// PHASE 32 : la topologie commune, televersee une fois (Renderer::
|
||||
// addSharedIndices), et la taille GPU d'une tuile (ses sommets seuls).
|
||||
uint32_t sharedIndexSet_ = 0;
|
||||
std::size_t bytesPerNode_ = 0;
|
||||
|
||||
// PHASE 19 : temps de MUR de l'etape de maillage, a comparer a
|
||||
// geometryMicros_ qui reste, lui, la somme du travail par tuile. Les deux
|
||||
|
||||
+105
-48
@@ -72,8 +72,19 @@ TextureData Texture::whitePixelData() {
|
||||
|
||||
Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
|
||||
const TextureData& data, bool repeat)
|
||||
: Texture(context, commandPool, queue, data,
|
||||
[&data](void* destination, uint64_t offset, uint64_t bytes) {
|
||||
std::memcpy(destination, data.pixels.data() + offset,
|
||||
static_cast<std::size_t>(bytes));
|
||||
},
|
||||
repeat) {
|
||||
}
|
||||
|
||||
Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
|
||||
const TextureData& data, const PixelSource& source, bool repeat)
|
||||
: context_(context) {
|
||||
if (data.pixels.empty() || data.mips.empty()) {
|
||||
if (data.mips.empty() || data.payloadSize() == 0 ||
|
||||
(!data.pixels.empty() && data.pixels.size() < data.payloadSize())) {
|
||||
throw std::runtime_error("Texture : donnees vides.");
|
||||
}
|
||||
|
||||
@@ -95,7 +106,7 @@ Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queu
|
||||
|
||||
const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
|
||||
createImage(data.width, data.height, mipLevels, format);
|
||||
uploadAndTransition(commandPool, queue, data);
|
||||
uploadAndTransition(commandPool, queue, data, source);
|
||||
createView(format, mipLevels);
|
||||
createSampler(mipLevels, repeat);
|
||||
}
|
||||
@@ -111,9 +122,7 @@ Texture::~Texture() {
|
||||
if (image_ != VK_NULL_HANDLE) {
|
||||
vkDestroyImage(device, image_, nullptr);
|
||||
}
|
||||
if (memory_ != VK_NULL_HANDLE) {
|
||||
vkFreeMemory(device, memory_, nullptr);
|
||||
}
|
||||
context_.freeMemory(allocation_);
|
||||
}
|
||||
|
||||
void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
|
||||
@@ -139,32 +148,66 @@ void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
|
||||
VkMemoryRequirements requirements{};
|
||||
vkGetImageMemoryRequirements(device, image_, &requirements);
|
||||
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = requirements.size;
|
||||
allocInfo.memoryTypeIndex = context_.findMemoryType(
|
||||
requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
|
||||
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Texture : echec de l'allocation memoire de l'image.");
|
||||
}
|
||||
vkBindImageMemory(device, image_, memory_, 0);
|
||||
// PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
|
||||
allocation_ = context_.allocateMemory(requirements, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
vkBindImageMemory(device, image_, allocation_.memory, 0);
|
||||
deviceSize_ = requirements.size;
|
||||
}
|
||||
|
||||
void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
|
||||
const TextureData& data) {
|
||||
const TextureData& data, const PixelSource& source) {
|
||||
VkDevice device = context_.device();
|
||||
const VkDeviceSize total = static_cast<VkDeviceSize>(data.pixels.size());
|
||||
const VkDeviceSize total = static_cast<VkDeviceSize>(data.payloadSize());
|
||||
const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
|
||||
|
||||
// Un seul buffer de staging pour toute la chaine : les niveaux sont deja
|
||||
// contigus dans le fichier, donc les offsets de copie sont ceux du .vcto.
|
||||
VulkanBuffer staging(context_, total,
|
||||
// PHASE 32 : un staging de 4 Mo au plus, REUTILISE tranche apres tranche,
|
||||
// au lieu d'un staging de la taille de toute la chaine. Pour l'orthophoto
|
||||
// de la zone, c'etait 42 Mo de memoire GPU transitoire en plus de l'image
|
||||
// elle-meme : le pic de memoire GPU de TOUTE la partie se situait la, au
|
||||
// chargement. Les texels sont ecrits dans le staging par `source` -
|
||||
// directement depuis le fichier pour l'orthophoto.
|
||||
constexpr VkDeviceSize kStagingChunk = 4ull * 1024 * 1024;
|
||||
const VkDeviceSize stagingSize = std::min(total, kStagingChunk);
|
||||
VulkanBuffer staging(context_, stagingSize,
|
||||
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
||||
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||||
staging.writeToBuffer(data.pixels.data(), total);
|
||||
staging.unmap();
|
||||
staging.map();
|
||||
auto* stagingBytes = static_cast<unsigned char*>(staging.mapped());
|
||||
|
||||
// --- Decoupe en BANDES de rangees de blocs ------------------------------
|
||||
// Une bande = des rangees completes d'un niveau, assez peu pour tenir dans
|
||||
// le staging. BC1 se range par rangees de blocs de 4 texels de haut ; une
|
||||
// bande qui n'atteint pas le bas d'un niveau a donc une hauteur multiple de
|
||||
// 4, comme l'exige une copie vers un format compresse.
|
||||
struct Band {
|
||||
uint32_t level = 0;
|
||||
uint32_t y = 0;
|
||||
uint32_t height = 0;
|
||||
uint64_t payloadOffset = 0;
|
||||
uint64_t bytes = 0;
|
||||
};
|
||||
std::vector<Band> bands;
|
||||
const bool blocks = (data.format == TextureFormat::BC1);
|
||||
const uint32_t texelsPerRow = blocks ? 4u : 1u;
|
||||
for (uint32_t level = 0; level < mipLevels; ++level) {
|
||||
const TextureMipLevel& mip = data.mips[level];
|
||||
const uint64_t rowBytes = blocks ? static_cast<uint64_t>((mip.width + 3u) / 4u) * 8u
|
||||
: static_cast<uint64_t>(mip.width) * 4u;
|
||||
const uint32_t rows = (mip.height + texelsPerRow - 1u) / texelsPerRow;
|
||||
const uint32_t rowsPerBand = static_cast<uint32_t>(
|
||||
std::max<uint64_t>(1u, stagingSize / rowBytes));
|
||||
for (uint32_t row = 0; row < rows; row += rowsPerBand) {
|
||||
const uint32_t count = std::min(rowsPerBand, rows - row);
|
||||
Band band;
|
||||
band.level = level;
|
||||
band.y = row * texelsPerRow;
|
||||
band.height = std::min(count * texelsPerRow, mip.height - band.y);
|
||||
band.payloadOffset = mip.offset + static_cast<uint64_t>(row) * rowBytes;
|
||||
band.bytes = static_cast<uint64_t>(count) * rowBytes;
|
||||
bands.push_back(band);
|
||||
}
|
||||
}
|
||||
|
||||
VkCommandBufferAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
||||
@@ -175,49 +218,60 @@ void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
|
||||
VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
|
||||
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
|
||||
|
||||
// --- Un lot de bandes par remplissage du staging ------------------------
|
||||
std::vector<VkBufferImageCopy> regions;
|
||||
std::size_t next = 0;
|
||||
bool first = true;
|
||||
while (next < bands.size()) {
|
||||
regions.clear();
|
||||
VkDeviceSize used = 0;
|
||||
while (next < bands.size() && used + bands[next].bytes <= stagingSize) {
|
||||
const Band& band = bands[next];
|
||||
source(stagingBytes + used, band.payloadOffset, band.bytes);
|
||||
|
||||
VkBufferImageCopy region{};
|
||||
region.bufferOffset = used;
|
||||
// 0 = "serre sur l'extent de la copie". Indispensable pour un format
|
||||
// compresse, ou bufferRowLength se compterait en TEXELS et non en
|
||||
// blocs : le calculer a la main serait une occasion d'erreur
|
||||
// gratuite.
|
||||
region.bufferRowLength = 0;
|
||||
region.bufferImageHeight = 0;
|
||||
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
region.imageSubresource.mipLevel = band.level;
|
||||
region.imageSubresource.baseArrayLayer = 0;
|
||||
region.imageSubresource.layerCount = 1;
|
||||
region.imageOffset = { 0, static_cast<int32_t>(band.y), 0 };
|
||||
region.imageExtent = { data.mips[band.level].width, band.height, 1 };
|
||||
regions.push_back(region);
|
||||
|
||||
used += band.bytes;
|
||||
++next;
|
||||
}
|
||||
const bool last = (next == bands.size());
|
||||
|
||||
VkCommandBufferBeginInfo beginInfo{};
|
||||
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
||||
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
||||
vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
||||
|
||||
const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
|
||||
|
||||
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);
|
||||
|
||||
std::vector<VkBufferImageCopy> regions;
|
||||
regions.reserve(mipLevels);
|
||||
for (uint32_t level = 0; level < mipLevels; ++level) {
|
||||
const TextureMipLevel& mip = data.mips[level];
|
||||
VkBufferImageCopy region{};
|
||||
region.bufferOffset = mip.offset;
|
||||
// 0 = "serre sur l'extent de l'image". Indispensable pour un format
|
||||
// compresse, ou bufferRowLength se compterait en TEXELS et non en blocs :
|
||||
// le calculer a la main serait une occasion d'erreur gratuite.
|
||||
region.bufferRowLength = 0;
|
||||
region.bufferImageHeight = 0;
|
||||
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
region.imageSubresource.mipLevel = level;
|
||||
region.imageSubresource.baseArrayLayer = 0;
|
||||
region.imageSubresource.layerCount = 1;
|
||||
region.imageOffset = { 0, 0, 0 };
|
||||
region.imageExtent = { mip.width, mip.height, 1 };
|
||||
regions.push_back(region);
|
||||
}
|
||||
|
||||
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{};
|
||||
@@ -225,9 +279,12 @@ void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
|
||||
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.
|
||||
// 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;
|
||||
}
|
||||
|
||||
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
|
||||
}
|
||||
|
||||
@@ -4,10 +4,12 @@
|
||||
// le renvoie par valeur. L'en-tete reste sans cout : assets/TextureFile.hpp ne
|
||||
// depend pas de Vulkan.
|
||||
#include "assets/TextureFile.hpp"
|
||||
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
|
||||
namespace vercora {
|
||||
|
||||
@@ -43,6 +45,19 @@ public:
|
||||
// l'orthophoto - voir createSampler.
|
||||
Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
|
||||
const TextureData& data, bool repeat = false);
|
||||
|
||||
// PHASE 32. Source des texels : ecrit `bytes` octets de la charge utile, a
|
||||
// partir de l'octet `offset` (0 = debut du niveau 0, meme rangement que
|
||||
// TextureData::pixels), dans `destination` - le staging mappe.
|
||||
using PixelSource =
|
||||
std::function<void(void* destination, uint64_t offset, uint64_t bytes)>;
|
||||
|
||||
// PHASE 32. Meme texture, mais les texels ne sont PAS dans `layout` (son
|
||||
// `pixels` peut etre vide) : `source` les ecrit directement dans le
|
||||
// staging, tranche par tranche. C'est ce qui permet de lire l'orthophoto
|
||||
// depuis son fichier sans jamais la tenir en RAM.
|
||||
Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
|
||||
const TextureData& layout, const PixelSource& source, bool repeat = false);
|
||||
~Texture();
|
||||
|
||||
Texture(const Texture&) = delete;
|
||||
@@ -68,13 +83,13 @@ public:
|
||||
private:
|
||||
void createImage(uint32_t width, uint32_t height, uint32_t mipLevels, VkFormat format);
|
||||
void uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
|
||||
const TextureData& data);
|
||||
const TextureData& data, const PixelSource& source);
|
||||
void createView(VkFormat format, uint32_t mipLevels);
|
||||
void createSampler(uint32_t mipLevels, bool repeat);
|
||||
|
||||
VulkanContext& context_;
|
||||
VkImage image_ = VK_NULL_HANDLE;
|
||||
VkDeviceMemory memory_ = VK_NULL_HANDLE;
|
||||
GpuAllocation allocation_;
|
||||
VkImageView view_ = VK_NULL_HANDLE;
|
||||
VkSampler sampler_ = VK_NULL_HANDLE;
|
||||
VkDeviceSize deviceSize_ = 0;
|
||||
|
||||
@@ -85,6 +85,14 @@ struct UniformBufferObject {
|
||||
alignas(16) glm::vec4 precip{0.0f, 0.0f, 0.0f, 0.0f};
|
||||
alignas(16) glm::vec4 fall{0.0f, -6.5f, 0.0f, 0.0f};
|
||||
alignas(16) glm::vec4 detail{0.0f, 0.0f, 1.0f, 1.0f};
|
||||
|
||||
// PHASE 32. Offset 256. Grille de la heightmap, pour que terrain.vert
|
||||
// recalcule la position horizontale et l'UV d'un sommet a partir de son
|
||||
// indice (voir renderer/GpuVertex.hpp, TerrainVertex) :
|
||||
// x = origine (Heightmap::worldCoord(0)), y = pas en metres,
|
||||
// z = nombre de CELLULES par cote (resolution - 1), w = reserve.
|
||||
// Constant sur toute la partie ; seuls les shaders du terrain le declarent.
|
||||
alignas(16) glm::vec4 terrainGrid{0.0f, 1.0f, 1.0f, 0.0f};
|
||||
};
|
||||
|
||||
} // namespace vercora
|
||||
@@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/GpuVertex.hpp"
|
||||
#include "renderer/InstanceData.hpp"
|
||||
#include "renderer/Vertex.hpp"
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
@@ -24,60 +24,82 @@ namespace vercora {
|
||||
// Consequence concrete : la logique de jeu se compile et se teste sans GPU (voir
|
||||
// tests/logic_tests.cpp), y compris sur une machine ou le SDK n'est pas installe.
|
||||
|
||||
// Un seul binding, sommets entrelaces.
|
||||
inline VkVertexInputBindingDescription vertexBindingDescription() {
|
||||
// PHASE 32 : DEUX formats de sommet, un par famille de shaders (voir
|
||||
// renderer/GpuVertex.hpp) - le format de travail CPU `Vertex` n'est plus
|
||||
// televerse tel quel. Un seul binding entrelace dans les deux cas.
|
||||
|
||||
// --- Objets et vegetation : ObjectVertex, 44 octets -------------------------
|
||||
inline VkVertexInputBindingDescription objectBindingDescription() {
|
||||
VkVertexInputBindingDescription binding{};
|
||||
binding.binding = 0;
|
||||
binding.stride = sizeof(Vertex);
|
||||
binding.stride = sizeof(ObjectVertex);
|
||||
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||||
return binding;
|
||||
}
|
||||
|
||||
// Mapping des attributs vers les location(...) du vertex shader.
|
||||
//
|
||||
// Six attributs depuis la Phase 10 : les deux derniers portent la cible de
|
||||
// geomorphing du terrain (voir Vertex.hpp) et ne sont decrits qu'aux pipelines
|
||||
// dont le vertex shader les lit reellement.
|
||||
// `includeMorph` a false pour un vertex shader qui ne lit pas les locations 4/5
|
||||
// (cube.vert) : les decrire quand meme declencherait un avertissement de
|
||||
// validation. Voir ShaderSet::usesMorphAttributes.
|
||||
inline std::array<VkVertexInputAttributeDescription, 6> vertexAttributeDescriptions() {
|
||||
std::array<VkVertexInputAttributeDescription, 6> attrs{};
|
||||
// Locations 0 a 3 : position, couleur, normale, UV - les memes que depuis la
|
||||
// Phase 3, seul le stride a change (les 24 octets de morphing, qu'aucun de ces
|
||||
// shaders ne lisait, ne sont plus dans le buffer).
|
||||
inline std::array<VkVertexInputAttributeDescription, 4> objectAttributeDescriptions() {
|
||||
std::array<VkVertexInputAttributeDescription, 4> attrs{};
|
||||
|
||||
attrs[0].binding = 0;
|
||||
attrs[0].location = 0;
|
||||
attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT;
|
||||
attrs[0].offset = offsetof(Vertex, pos);
|
||||
attrs[0].offset = offsetof(ObjectVertex, pos);
|
||||
|
||||
attrs[1].binding = 0;
|
||||
attrs[1].location = 1;
|
||||
attrs[1].format = VK_FORMAT_R32G32B32_SFLOAT;
|
||||
attrs[1].offset = offsetof(Vertex, color);
|
||||
attrs[1].offset = offsetof(ObjectVertex, color);
|
||||
|
||||
attrs[2].binding = 0;
|
||||
attrs[2].location = 2;
|
||||
attrs[2].format = VK_FORMAT_R32G32B32_SFLOAT;
|
||||
attrs[2].offset = offsetof(Vertex, normal);
|
||||
attrs[2].offset = offsetof(ObjectVertex, normal);
|
||||
|
||||
// Deux composantes seulement -> format R32G32.
|
||||
attrs[3].binding = 0;
|
||||
attrs[3].location = 3;
|
||||
attrs[3].format = VK_FORMAT_R32G32_SFLOAT;
|
||||
attrs[3].offset = offsetof(Vertex, uv);
|
||||
attrs[3].offset = offsetof(ObjectVertex, uv);
|
||||
|
||||
// Position et normale du meme sommet dans la grille du niveau de detail
|
||||
// SUPERIEUR (plus grossier). Nulles sur toute geometrie qui n'est pas une
|
||||
// tuile de quadtree : sans effet, le shader ne morphe que si la bande de
|
||||
// morphing poussee par le DrawItem est non vide.
|
||||
attrs[4].binding = 0;
|
||||
attrs[4].location = 4;
|
||||
attrs[4].format = VK_FORMAT_R32G32B32_SFLOAT;
|
||||
attrs[4].offset = offsetof(Vertex, morphPos);
|
||||
return attrs;
|
||||
}
|
||||
|
||||
attrs[5].binding = 0;
|
||||
attrs[5].location = 5;
|
||||
attrs[5].format = VK_FORMAT_R32G32B32_SFLOAT;
|
||||
attrs[5].offset = offsetof(Vertex, morphNormal);
|
||||
// --- Terrain : TerrainVertex, 16 octets --------------------------------------
|
||||
inline VkVertexInputBindingDescription terrainBindingDescription() {
|
||||
VkVertexInputBindingDescription binding{};
|
||||
binding.binding = 0;
|
||||
binding.stride = sizeof(TerrainVertex);
|
||||
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||||
return binding;
|
||||
}
|
||||
|
||||
// Deux altitudes en flottant, deux normales en snorm16 (x et z, y reconstruit
|
||||
// par terrain.vert). Tout le reste se deduit de gl_VertexIndex.
|
||||
inline std::array<VkVertexInputAttributeDescription, 4> terrainAttributeDescriptions() {
|
||||
std::array<VkVertexInputAttributeDescription, 4> attrs{};
|
||||
|
||||
attrs[0].binding = 0;
|
||||
attrs[0].location = 0;
|
||||
attrs[0].format = VK_FORMAT_R32_SFLOAT;
|
||||
attrs[0].offset = offsetof(TerrainVertex, height);
|
||||
|
||||
attrs[1].binding = 0;
|
||||
attrs[1].location = 1;
|
||||
attrs[1].format = VK_FORMAT_R32_SFLOAT;
|
||||
attrs[1].offset = offsetof(TerrainVertex, morphHeight);
|
||||
|
||||
attrs[2].binding = 0;
|
||||
attrs[2].location = 2;
|
||||
attrs[2].format = VK_FORMAT_R16G16_SNORM;
|
||||
attrs[2].offset = offsetof(TerrainVertex, normal);
|
||||
|
||||
attrs[3].binding = 0;
|
||||
attrs[3].location = 3;
|
||||
attrs[3].format = VK_FORMAT_R16G16_SNORM;
|
||||
attrs[3].offset = offsetof(TerrainVertex, morphNormal);
|
||||
|
||||
return attrs;
|
||||
}
|
||||
@@ -98,7 +120,7 @@ inline VkVertexInputBindingDescription instanceBindingDescription() {
|
||||
return binding;
|
||||
}
|
||||
|
||||
// Locations 6 a 8 : les locations 0 a 5 appartiennent au sommet (voir plus haut),
|
||||
// Locations 6 a 8 : les locations basses appartiennent au sommet (voir plus haut),
|
||||
// et un pipeline instancie decrit les deux flux dans le meme espace de numeros.
|
||||
// Les trois flottants scalaires (scale, yaw, variation, fade) sont regroupes en
|
||||
// deux attributs plutot qu'en quatre : moins d'attributs a decrire, et le shader
|
||||
|
||||
@@ -27,42 +27,38 @@ VulkanBuffer::VulkanBuffer(VulkanContext& context,
|
||||
VkMemoryRequirements memRequirements{};
|
||||
vkGetBufferMemoryRequirements(device, buffer_, &memRequirements);
|
||||
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = memRequirements.size;
|
||||
allocInfo.memoryTypeIndex =
|
||||
context_.findMemoryType(memRequirements.memoryTypeBits, properties);
|
||||
|
||||
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Echec de l'allocation memoire d'un buffer.");
|
||||
// PHASE 32 : par le contexte, qui tient le compte de la memoire GPU.
|
||||
try {
|
||||
allocation_ = context_.allocateMemory(memRequirements, properties);
|
||||
} catch (...) {
|
||||
vkDestroyBuffer(device, buffer_, nullptr);
|
||||
throw;
|
||||
}
|
||||
|
||||
vkBindBufferMemory(device, buffer_, memory_, 0);
|
||||
vkBindBufferMemory(device, buffer_, allocation_.memory, 0);
|
||||
}
|
||||
|
||||
VulkanBuffer::~VulkanBuffer() {
|
||||
VkDevice device = context_.device();
|
||||
if (mapped_ != nullptr) {
|
||||
vkUnmapMemory(device, memory_);
|
||||
vkUnmapMemory(device, allocation_.memory);
|
||||
mapped_ = nullptr;
|
||||
}
|
||||
if (buffer_ != VK_NULL_HANDLE) {
|
||||
vkDestroyBuffer(device, buffer_, nullptr);
|
||||
}
|
||||
if (memory_ != VK_NULL_HANDLE) {
|
||||
vkFreeMemory(device, memory_, nullptr);
|
||||
}
|
||||
context_.freeMemory(allocation_);
|
||||
}
|
||||
|
||||
void VulkanBuffer::map() {
|
||||
if (mapped_ == nullptr) {
|
||||
vkMapMemory(context_.device(), memory_, 0, size_, 0, &mapped_);
|
||||
vkMapMemory(context_.device(), allocation_.memory, 0, size_, 0, &mapped_);
|
||||
}
|
||||
}
|
||||
|
||||
void VulkanBuffer::unmap() {
|
||||
if (mapped_ != nullptr) {
|
||||
vkUnmapMemory(context_.device(), memory_);
|
||||
vkUnmapMemory(context_.device(), allocation_.memory);
|
||||
mapped_ = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#include <memory>
|
||||
@@ -31,10 +33,12 @@ public:
|
||||
virtual ~BufferUploader() = default;
|
||||
|
||||
// Enregistre une copie de `staging` (integralite de sa taille) vers
|
||||
// `destination`. Prend possession de `staging`, qui sera detruit quand la
|
||||
// frame ayant execute la copie sera terminee.
|
||||
// `destination`, a partir de l'octet `destinationOffset` (PHASE 32 : la
|
||||
// destination est une PLAGE d'un bloc partage, voir GpuBufferPool). Prend
|
||||
// possession de `staging`, qui sera detruit quand la frame ayant execute la
|
||||
// copie sera terminee.
|
||||
virtual void enqueueCopy(std::unique_ptr<VulkanBuffer> staging,
|
||||
VkBuffer destination) = 0;
|
||||
VkBuffer destination, VkDeviceSize destinationOffset) = 0;
|
||||
};
|
||||
|
||||
// Buffer Vulkan reutilisable : creation, allocation memoire, bind, map,
|
||||
@@ -76,7 +80,7 @@ private:
|
||||
VulkanContext& context_;
|
||||
VkDeviceSize size_ = 0;
|
||||
VkBuffer buffer_ = VK_NULL_HANDLE;
|
||||
VkDeviceMemory memory_ = VK_NULL_HANDLE;
|
||||
GpuAllocation allocation_;
|
||||
void* mapped_ = nullptr;
|
||||
};
|
||||
|
||||
|
||||
@@ -3,6 +3,8 @@
|
||||
#include "core/Logger.hpp"
|
||||
#include "core/Window.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <set>
|
||||
#include <stdexcept>
|
||||
@@ -233,6 +235,29 @@ void VulkanContext::pickPhysicalDevice() {
|
||||
VkPhysicalDeviceProperties props{};
|
||||
vkGetPhysicalDeviceProperties(physicalDevice_, &props);
|
||||
logInfo(std::string("GPU selectionne : ") + props.deviceName);
|
||||
deviceType_ = props.deviceType;
|
||||
|
||||
// PHASE 32 : proprietes memoire lues UNE fois (voir findMemoryType), et
|
||||
// detection de la memoire unifiee.
|
||||
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memoryProperties_);
|
||||
const VkMemoryPropertyFlags unified = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
||||
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
|
||||
std::string heaps = "Memoire GPU : " + std::to_string(memoryProperties_.memoryHeapCount) +
|
||||
" tas -";
|
||||
for (uint32_t i = 0; i < memoryProperties_.memoryHeapCount; ++i) {
|
||||
const VkMemoryHeap& heap = memoryProperties_.memoryHeaps[i];
|
||||
heaps += " [" + std::to_string(i) + "] " +
|
||||
std::to_string(heap.size / (1024 * 1024)) + " Mo" +
|
||||
((heap.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) ? " device-local" : "");
|
||||
}
|
||||
for (uint32_t i = 0; i < memoryProperties_.memoryTypeCount; ++i) {
|
||||
if ((memoryProperties_.memoryTypes[i].propertyFlags & unified) == unified) {
|
||||
unifiedMemory_ = true;
|
||||
}
|
||||
}
|
||||
logInfo(heaps + (unifiedMemory_ ? " ; memoire UNIFIEE (device-local et host-visible)."
|
||||
: " ; memoire device-local NON mappable."));
|
||||
}
|
||||
|
||||
bool VulkanContext::isDeviceSuitable(VkPhysicalDevice device) const {
|
||||
@@ -397,13 +422,10 @@ SwapChainSupportDetails VulkanContext::querySwapChainSupport() const {
|
||||
}
|
||||
|
||||
uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const {
|
||||
VkPhysicalDeviceMemoryProperties memProperties{};
|
||||
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memProperties);
|
||||
|
||||
for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) {
|
||||
for (uint32_t i = 0; i < memoryProperties_.memoryTypeCount; ++i) {
|
||||
const bool typeOk = (typeFilter & (1u << i)) != 0;
|
||||
const bool propsOk =
|
||||
(memProperties.memoryTypes[i].propertyFlags & properties) == properties;
|
||||
(memoryProperties_.memoryTypes[i].propertyFlags & properties) == properties;
|
||||
if (typeOk && propsOk) {
|
||||
return i;
|
||||
}
|
||||
@@ -411,6 +433,70 @@ uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlag
|
||||
throw std::runtime_error("Aucun type de memoire adapte trouve.");
|
||||
}
|
||||
|
||||
GpuAllocation VulkanContext::allocateMemory(const VkMemoryRequirements& requirements,
|
||||
VkMemoryPropertyFlags properties, bool map) {
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = requirements.size;
|
||||
allocInfo.memoryTypeIndex = findMemoryType(requirements.memoryTypeBits, properties);
|
||||
|
||||
GpuAllocation allocation;
|
||||
if (vkAllocateMemory(device_, &allocInfo, nullptr, &allocation.memory) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Echec de l'allocation de " +
|
||||
std::to_string(requirements.size) +
|
||||
" octets de memoire GPU.");
|
||||
}
|
||||
allocation.size = requirements.size;
|
||||
allocation.deviceLocal = (properties & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0;
|
||||
if (map && vkMapMemory(device_, allocation.memory, 0, VK_WHOLE_SIZE, 0,
|
||||
&allocation.mapped) != VK_SUCCESS) {
|
||||
vkFreeMemory(device_, allocation.memory, nullptr);
|
||||
throw std::runtime_error("Echec du mappage d'un bloc de memoire GPU.");
|
||||
}
|
||||
|
||||
gpuMemory_.liveBytes += allocation.size;
|
||||
gpuMemory_.peakBytes = std::max(gpuMemory_.peakBytes, gpuMemory_.liveBytes);
|
||||
if (allocation.deviceLocal) {
|
||||
gpuMemory_.liveDeviceLocalBytes += allocation.size;
|
||||
gpuMemory_.peakDeviceLocalBytes =
|
||||
std::max(gpuMemory_.peakDeviceLocalBytes, gpuMemory_.liveDeviceLocalBytes);
|
||||
}
|
||||
++gpuMemory_.liveAllocations;
|
||||
gpuMemory_.peakAllocations = std::max(gpuMemory_.peakAllocations, gpuMemory_.liveAllocations);
|
||||
++gpuMemory_.allocateCalls;
|
||||
return allocation;
|
||||
}
|
||||
|
||||
void VulkanContext::freeMemory(GpuAllocation& allocation) {
|
||||
if (allocation.memory == VK_NULL_HANDLE) {
|
||||
return;
|
||||
}
|
||||
if (allocation.mapped != nullptr) {
|
||||
vkUnmapMemory(device_, allocation.memory);
|
||||
}
|
||||
vkFreeMemory(device_, allocation.memory, nullptr);
|
||||
gpuMemory_.liveBytes -= allocation.size;
|
||||
if (allocation.deviceLocal) {
|
||||
gpuMemory_.liveDeviceLocalBytes -= allocation.size;
|
||||
}
|
||||
--gpuMemory_.liveAllocations;
|
||||
allocation = GpuAllocation{};
|
||||
}
|
||||
|
||||
std::string VulkanContext::gpuMemoryLine() const {
|
||||
const auto mo = [](uint64_t bytes) {
|
||||
char text[32];
|
||||
std::snprintf(text, sizeof(text), "%.1f Mo", static_cast<double>(bytes) / (1024.0 * 1024.0));
|
||||
return std::string(text);
|
||||
};
|
||||
return "GPU " + mo(gpuMemory_.liveBytes) + " (pic " + mo(gpuMemory_.peakBytes) +
|
||||
"), dont device-local " + mo(gpuMemory_.liveDeviceLocalBytes) + " (pic " +
|
||||
mo(gpuMemory_.peakDeviceLocalBytes) + ") ; " +
|
||||
std::to_string(gpuMemory_.liveAllocations) + " blocs vivants (pic " +
|
||||
std::to_string(gpuMemory_.peakAllocations) + "), " +
|
||||
std::to_string(gpuMemory_.allocateCalls) + " vkAllocateMemory au total";
|
||||
}
|
||||
|
||||
VkFormat VulkanContext::findSupportedFormat(const std::vector<VkFormat>& candidates,
|
||||
VkImageTiling tiling,
|
||||
VkFormatFeatureFlags features) const {
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace vercora {
|
||||
@@ -41,6 +42,32 @@ struct SwapChainSupportDetails {
|
||||
std::vector<VkPresentModeKHR> presentModes;
|
||||
};
|
||||
|
||||
// PHASE 32. Un bloc de memoire GPU, avec ce qu'il faut savoir pour le rendre
|
||||
// et pour le COMPTER. Toute la memoire du moteur passe par
|
||||
// VulkanContext::allocateMemory / freeMemory : c'est ce qui permet au journal
|
||||
// de donner l'occupation GPU exacte, au lieu de la deduire de formules
|
||||
// recopiees dans chaque classe (et dont une seule serait mise a jour).
|
||||
struct GpuAllocation {
|
||||
VkDeviceMemory memory = VK_NULL_HANDLE;
|
||||
VkDeviceSize size = 0; // octets REELLEMENT alloues (memory requirements)
|
||||
bool deviceLocal = false; // DEVICE_LOCAL demande par l'appelant
|
||||
void* mapped = nullptr; // mappage persistant, si demande
|
||||
};
|
||||
|
||||
// PHASE 32. Bilan de la memoire GPU allouee par le moteur. Les pics sont ceux
|
||||
// de la session ; "appels" compte tous les vkAllocateMemory depuis le
|
||||
// demarrage, y compris ceux deja liberes - c'est le chiffre qui dit combien de
|
||||
// fois le pilote a ete sollicite, pas seulement combien de blocs vivent.
|
||||
struct GpuMemoryStats {
|
||||
uint64_t liveBytes = 0;
|
||||
uint64_t peakBytes = 0;
|
||||
uint64_t liveDeviceLocalBytes = 0;
|
||||
uint64_t peakDeviceLocalBytes = 0;
|
||||
uint64_t liveAllocations = 0;
|
||||
uint64_t peakAllocations = 0;
|
||||
uint64_t allocateCalls = 0;
|
||||
};
|
||||
|
||||
// Regroupe l'etat "global" Vulkan qui ne change pas au resize :
|
||||
// instance, debug messenger, surface, GPU physique, device logique, queues.
|
||||
class VulkanContext {
|
||||
@@ -84,6 +111,39 @@ public:
|
||||
// Format de profondeur retenu (D32 de preference, avec fallbacks).
|
||||
VkFormat findDepthFormat() const;
|
||||
|
||||
// PHASE 32. Alloue un bloc satisfaisant `requirements` dans un type de
|
||||
// memoire qui porte `properties`, et le COMPTE. Lance std::runtime_error si
|
||||
// le pilote refuse. `map` = true mappe le bloc en permanence (le type doit
|
||||
// alors etre HOST_VISIBLE).
|
||||
GpuAllocation allocateMemory(const VkMemoryRequirements& requirements,
|
||||
VkMemoryPropertyFlags properties, bool map = false);
|
||||
|
||||
// Rend le bloc (demappe s'il l'etait) et le decompte. Sans effet sur une
|
||||
// allocation vide ; remet `allocation` a zero.
|
||||
void freeMemory(GpuAllocation& allocation);
|
||||
|
||||
const GpuMemoryStats& gpuMemoryStats() const { return gpuMemory_; }
|
||||
|
||||
// Ligne de journal lisible du bilan ci-dessus.
|
||||
std::string gpuMemoryLine() const;
|
||||
|
||||
// PHASE 32. true si un type de memoire est a la fois DEVICE_LOCAL et
|
||||
// HOST_VISIBLE | HOST_COHERENT : memoire unifiee (GPU integre, lavapipe), ou
|
||||
// le CPU peut ecrire directement la ou le GPU lit, sans staging ni copie.
|
||||
// Faux sur un GPU discret classique (hors BAR redimensionnable).
|
||||
bool unifiedMemory() const { return unifiedMemory_; }
|
||||
|
||||
// PHASE 32. true si la geometrie doit etre ecrite DIRECTEMENT dans sa
|
||||
// memoire device-local mappee plutot que par staging : memoire unifiee ET
|
||||
// GPU integre (ou logiciel). Un GPU discret peut aussi exposer une memoire
|
||||
// device-local mappable (BAR, 256 Mo sans ReBAR) ; elle est trop petite et
|
||||
// trop precieuse pour y loger le terrain, il garde donc le staging.
|
||||
bool preferDirectGeometryWrites() const {
|
||||
return unifiedMemory_ &&
|
||||
(deviceType_ == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU ||
|
||||
deviceType_ == VK_PHYSICAL_DEVICE_TYPE_CPU);
|
||||
}
|
||||
|
||||
private:
|
||||
void createInstance();
|
||||
void setupDebugMessenger();
|
||||
@@ -110,6 +170,14 @@ private:
|
||||
QueueFamilyIndices queueIndices_;
|
||||
|
||||
bool anisotropyEnabled_ = false;
|
||||
bool unifiedMemory_ = false;
|
||||
VkPhysicalDeviceType deviceType_ = VK_PHYSICAL_DEVICE_TYPE_OTHER;
|
||||
|
||||
// Proprietes memoire du GPU, lues une fois : findMemoryType les
|
||||
// interrogeait a CHAQUE allocation (deux par tuile de terrain).
|
||||
VkPhysicalDeviceMemoryProperties memoryProperties_{};
|
||||
|
||||
GpuMemoryStats gpuMemory_;
|
||||
};
|
||||
|
||||
} // namespace vercora
|
||||
@@ -127,7 +127,10 @@ public:
|
||||
// pour le rendu que pour la COLLISION (voir la note de decouplage dans
|
||||
// MEMORY.md). L'arbre n'en garde que des bornes.
|
||||
// Lance std::runtime_error si les parametres sont inexploitables.
|
||||
TerrainQuadtree(const Heightmap& heightmap, const Params& params = {});
|
||||
TerrainQuadtree(const Heightmap& heightmap, const Params& params);
|
||||
// Parametres par defaut : surcharge et non `= {}`, voir Heightmap() (refus
|
||||
// de GCC/Clang, CWG 1397).
|
||||
TerrainQuadtree(const Heightmap& heightmap) : TerrainQuadtree(heightmap, Params{}) {}
|
||||
|
||||
// Remplit `out` avec les noeuds a dessiner, tries du plus proche au plus
|
||||
// lointain. `out` est vide au prealable ; sa capacite est conservee.
|
||||
|
||||
@@ -37,6 +37,8 @@
|
||||
#include "editor/PlacedObject.hpp"
|
||||
#include "editor/SceneFile.hpp"
|
||||
#include "renderer/DrawItem.hpp"
|
||||
#include "renderer/GpuVertex.hpp"
|
||||
#include "renderer/RangeAllocator.hpp"
|
||||
#include "renderer/TerrainMesh.hpp"
|
||||
#include "renderer/TerrainNodeMesh.hpp"
|
||||
#include "world/AnimalMesh.hpp"
|
||||
@@ -3197,6 +3199,62 @@ void testTextureFile() {
|
||||
threw = true;
|
||||
}
|
||||
check(threw, "Refus : fichier .vcto absent");
|
||||
|
||||
// --- PHASE 32 : en-tete seul, puis charge utile lue a la demande --------
|
||||
// Le chargement de l'orthophoto ne tient plus la charge utile en RAM : il
|
||||
// lit l'en-tete, puis des TRANCHES directement dans le staging. Les deux
|
||||
// chemins doivent rendre exactement les memes octets que loadTextureFile.
|
||||
{
|
||||
const std::string path =
|
||||
(std::filesystem::temp_directory_path() / "vercora_phase32_test.vcto").string();
|
||||
std::vector<unsigned char> payload;
|
||||
const uint32_t width = 8;
|
||||
const uint32_t height = 4;
|
||||
uint32_t levels = 0;
|
||||
for (uint32_t w = width, h = height;; w = std::max(1u, w / 2), h = std::max(1u, h / 2)) {
|
||||
for (uint32_t k = 0; k < w * h * 4; ++k) {
|
||||
payload.push_back(static_cast<unsigned char>((payload.size() * 37u + 11u) & 0xFFu));
|
||||
}
|
||||
++levels;
|
||||
if (w == 1 && h == 1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
unsigned char header[128] = {};
|
||||
std::memcpy(header, "VCTO", 4);
|
||||
const uint32_t fields[5] = { 1u, width, height, levels, 0u /* RGBA8 */ };
|
||||
std::memcpy(header + 4, fields, sizeof(fields));
|
||||
const double extent[4] = { 899000.0, 6435000.0, 904000.0, 6440000.0 };
|
||||
std::memcpy(header + 24, extent, sizeof(extent));
|
||||
const uint32_t epsg = 2154u;
|
||||
std::memcpy(header + 56, &epsg, sizeof(epsg));
|
||||
{
|
||||
std::ofstream out(path, std::ios::binary);
|
||||
out.write(reinterpret_cast<const char*>(header), sizeof(header));
|
||||
out.write(reinterpret_cast<const char*>(payload.data()),
|
||||
static_cast<std::streamsize>(payload.size()));
|
||||
}
|
||||
|
||||
const TextureData full = loadTextureFile(path);
|
||||
const TextureData headerOnly = loadTextureFileHeader(path);
|
||||
check(full.pixels == payload && full.payloadSize() == payload.size(),
|
||||
"Phase 32 : loadTextureFile rend la charge utile complete");
|
||||
check(headerOnly.pixels.empty() && headerOnly.payloadSize() == payload.size() &&
|
||||
headerOnly.mips.size() == full.mips.size(),
|
||||
"Phase 32 : l'en-tete seul decrit la meme chaine, sans aucun texel");
|
||||
|
||||
std::vector<unsigned char> whole(payload.size());
|
||||
readTexturePayload(path, headerOnly, whole.data());
|
||||
std::vector<unsigned char> banded(payload.size());
|
||||
std::ifstream in(path, std::ios::binary);
|
||||
for (uint64_t offset = 0; offset < payload.size(); offset += 24) {
|
||||
const uint64_t bytes = std::min<uint64_t>(24, payload.size() - offset);
|
||||
readTexturePayload(in, offset, bytes, banded.data() + offset);
|
||||
}
|
||||
check(whole == payload && banded == payload,
|
||||
"Phase 32 : lecture directe et lecture par tranches = memes octets");
|
||||
std::filesystem::remove(path);
|
||||
}
|
||||
}
|
||||
|
||||
void testGrassMesh() {
|
||||
@@ -10870,6 +10928,225 @@ void testBushPlacement() {
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PHASE 32 : formats GPU compacts et sous-allocation de la geometrie
|
||||
// ---------------------------------------------------------------------------
|
||||
// Ce que le GPU lit n'est plus le format de travail `Vertex` (68 octets) mais
|
||||
// ObjectVertex (44) et TerrainVertex (16), et toute la geometrie vit dans des
|
||||
// plages de blocs partages. Rien de cela ne se VOIT si c'est faux d'un octet :
|
||||
// un decalage d'allocateur ecrase la geometrie d'un voisin, une position
|
||||
// recalculee differemment fait trembler les jointures de tuiles. D'ou ces
|
||||
// verifications, faites sans GPU.
|
||||
void testGpuFormatsPhase32() {
|
||||
section("Phase 32 : formats GPU compacts et pool de geometrie");
|
||||
|
||||
check(sizeof(ObjectVertex) == 44 && sizeof(TerrainVertex) == 16 &&
|
||||
sizeof(DrawItemPush) == 96,
|
||||
"Phase 32 : 44 / 16 octets par sommet, 96 octets de push constants");
|
||||
|
||||
// --- ObjectVertex : conversion EXACTE -----------------------------------
|
||||
{
|
||||
Vertex v{};
|
||||
v.pos = { 1.25f, -3.5f, 1234.567f };
|
||||
v.color = { 0.42f, 0.13f, 0.99f };
|
||||
v.normal = { 0.1f, 0.9f, -0.2f };
|
||||
v.uv = { 0.333f, 0.777f };
|
||||
v.morphPos = { 9.0f, 9.0f, 9.0f };
|
||||
const ObjectVertex o = toObjectVertex(v);
|
||||
check(o.pos == v.pos && o.color == v.color && o.normal == v.normal && o.uv == v.uv,
|
||||
"ObjectVertex : position, couleur, normale et UV recopiees au bit pres");
|
||||
}
|
||||
|
||||
// --- snorm16 : la convention de VK_FORMAT_R16_SNORM ---------------------
|
||||
{
|
||||
float worst = 0.0f;
|
||||
for (int k = -2000; k <= 2000; ++k) {
|
||||
const float value = static_cast<float>(k) / 2000.0f;
|
||||
worst = std::max(worst, std::abs(unpackSnorm16(packSnorm16(value)) - value));
|
||||
}
|
||||
check(worst <= 0.5f / 32767.0f + 1e-7f,
|
||||
"snorm16 : erreur d'aller-retour d'au plus un demi-pas (1,5e-5)");
|
||||
check(packSnorm16(1.0f) == 32767 && packSnorm16(-1.0f) == -32767 &&
|
||||
packSnorm16(7.0f) == 32767 && packSnorm16(-7.0f) == -32767 &&
|
||||
unpackSnorm16(-32768) == -1.0f,
|
||||
"snorm16 : bornes et ecretage");
|
||||
|
||||
// Normales de champ de hauteur, du plat a la paroi (pente 20) : la
|
||||
// reconstruction de y depuis x et z quantifies reste a 1e-3 pres
|
||||
// (et a 1e-4 pres jusqu'a une pente de 5, soit 79 degres).
|
||||
float worstNormal = 0.0f;
|
||||
float worstNormalModerate = 0.0f;
|
||||
for (int a = 0; a < 64; ++a) {
|
||||
for (int b = 0; b < 16; ++b) {
|
||||
const float slope = 20.0f * static_cast<float>(b) / 15.0f;
|
||||
const float angle = 6.2831853f * static_cast<float>(a) / 64.0f;
|
||||
const glm::vec3 n = glm::normalize(
|
||||
glm::vec3(-slope * std::cos(angle), 1.0f, -slope * std::sin(angle)));
|
||||
const int16_t packed[2] = { packSnorm16(n.x), packSnorm16(n.z) };
|
||||
const float error = glm::length(unpackTerrainNormal(packed) - n);
|
||||
worstNormal = std::max(worstNormal, error);
|
||||
if (slope <= 5.0f) {
|
||||
worstNormalModerate = std::max(worstNormalModerate, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
check(worstNormal < 1e-3f && worstNormalModerate < 1e-4f,
|
||||
"TerrainVertex : normale reconstruite a 1e-4 pres jusqu'a 79 degres");
|
||||
}
|
||||
|
||||
// --- Tuiles : le format GPU est le format de reference, compacte --------
|
||||
// writeTerrainNodeVertices (chemin du streamer) doit rendre EXACTEMENT
|
||||
// toTerrainVertex(terrainNodeMeshData) pour CHAQUE noeud, grilles paire et
|
||||
// impaire, avec et sans la grille du parent mise en cache.
|
||||
{
|
||||
Heightmap::Params even;
|
||||
even.resolution = 513;
|
||||
even.worldSize = 512.0f;
|
||||
even.seed = 3030u;
|
||||
Heightmap::Params odd;
|
||||
odd.resolution = 128;
|
||||
odd.worldSize = 127.0f;
|
||||
odd.seed = 3031u;
|
||||
// Assez grande pour que des tuiles de niveau 2 et 3 soient INTERIEURES
|
||||
// (chemin rapide de writeTerrainNodeVertices a plusieurs pas).
|
||||
Heightmap::Params large;
|
||||
large.resolution = 2049;
|
||||
large.worldSize = 4096.0f;
|
||||
large.amplitude = 900.0f;
|
||||
large.seed = 3033u;
|
||||
TerrainQuadtree::Params qparams;
|
||||
qparams.nodeCells = 64;
|
||||
|
||||
bool identical = true;
|
||||
bool positionsExact = true;
|
||||
bool uvExact = true;
|
||||
uint32_t nodesChecked = 0;
|
||||
uint32_t fastNodes = 0;
|
||||
uint32_t fastStrides = 0; // masque des pas couverts par le chemin rapide
|
||||
for (const Heightmap::Params& hp : { even, odd, large }) {
|
||||
const Heightmap heightmap(hp);
|
||||
const TerrainQuadtree quadtree(heightmap, qparams);
|
||||
const uint32_t verts = qparams.nodeCells + 1;
|
||||
const uint32_t cells = heightmap.resolution() - 1;
|
||||
const float origin = heightmap.worldCoord(0);
|
||||
std::vector<TerrainVertex> written(static_cast<std::size_t>(verts) * verts);
|
||||
for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) {
|
||||
if (terrainNodeUsesFastPath(heightmap, quadtree, index)) {
|
||||
++fastNodes;
|
||||
fastStrides |= quadtree.node(index).stride;
|
||||
}
|
||||
for (const bool cached : { true, false }) {
|
||||
const MeshData reference =
|
||||
terrainNodeMeshData(heightmap, quadtree, index, false, cached);
|
||||
writeTerrainNodeVertices(heightmap, quadtree, index, written.data(), cached);
|
||||
for (std::size_t v = 0; v < written.size() && identical; ++v) {
|
||||
const TerrainVertex expected = toTerrainVertex(reference.vertices[v]);
|
||||
identical = std::memcmp(&expected, &written[v], sizeof(TerrainVertex)) == 0;
|
||||
}
|
||||
}
|
||||
// Ce que terrain.vert recalcule a partir de gl_VertexIndex et de
|
||||
// DrawItem::grid : memes indices ecretes, memes operations.
|
||||
const TerrainQuadtree::Node& node = quadtree.node(index);
|
||||
const MeshData reference = terrainNodeMeshData(heightmap, quadtree, index, false);
|
||||
for (uint32_t v = 0; v < verts * verts; ++v) {
|
||||
const uint32_t i = v % verts;
|
||||
const uint32_t j = v / verts;
|
||||
const uint32_t gx = std::min(node.ix0 + i * node.stride, cells);
|
||||
const uint32_t gz = std::min(node.iz0 + j * node.stride, cells);
|
||||
const uint32_t mx = std::min(node.ix0 + (i & ~1u) * node.stride, cells);
|
||||
const uint32_t mz = std::min(node.iz0 + (j & ~1u) * node.stride, cells);
|
||||
const Vertex& r = reference.vertices[v];
|
||||
positionsExact = positionsExact &&
|
||||
terrainGridCoord(origin, heightmap.spacing(), gx) == r.pos.x &&
|
||||
terrainGridCoord(origin, heightmap.spacing(), gz) == r.pos.z &&
|
||||
terrainGridCoord(origin, heightmap.spacing(), mx) == r.morphPos.x &&
|
||||
terrainGridCoord(origin, heightmap.spacing(), mz) == r.morphPos.z;
|
||||
uvExact = uvExact &&
|
||||
static_cast<float>(gx) / static_cast<float>(cells) == r.uv.x &&
|
||||
static_cast<float>(gz) / static_cast<float>(cells) == r.uv.y;
|
||||
}
|
||||
++nodesChecked;
|
||||
}
|
||||
}
|
||||
check(nodesChecked > 400, "Tuiles : toutes les tuiles des trois grilles verifiees");
|
||||
check(fastNodes > 0 && fastNodes < nodesChecked && (fastStrides & 0xFu) == 0xFu,
|
||||
"Tuiles : chemin rapide ET chemin de reference exerces (pas 1, 2, 4 et 8)");
|
||||
check(identical,
|
||||
"Tuiles : writeTerrainNodeVertices == toTerrainVertex(reference), au bit pres");
|
||||
check(positionsExact,
|
||||
"Tuiles : x/z et cible de morphing recalcules depuis l'indice, au bit pres");
|
||||
check(uvExact, "Tuiles : UV recalcule depuis l'indice de grille, au bit pres (CPU)");
|
||||
|
||||
const std::vector<uint32_t> topology = terrainNodeIndices(qparams.nodeCells);
|
||||
check(*std::max_element(topology.begin(), topology.end()) <= 0xFFFFu,
|
||||
"Tuiles : la topologie partagee tient en uint16");
|
||||
}
|
||||
|
||||
// --- Terrain d'un seul bloc (--no-lod) ------------------------------------
|
||||
{
|
||||
Heightmap::Params hp;
|
||||
hp.resolution = 97;
|
||||
hp.worldSize = 96.0f;
|
||||
hp.seed = 3032u;
|
||||
const Heightmap heightmap(hp);
|
||||
const MeshData reference = terrainMeshData(heightmap);
|
||||
const TerrainGpuMesh gpu = terrainGpuMeshData(heightmap);
|
||||
bool same = gpu.vertices.size() == reference.vertices.size() &&
|
||||
gpu.indices == reference.indices;
|
||||
for (std::size_t v = 0; v < gpu.vertices.size() && same; ++v) {
|
||||
TerrainVertex expected = toTerrainVertex(reference.vertices[v]);
|
||||
// Sans geomorphing, la cible est le sommet lui-meme (elle valait
|
||||
// zero dans le format de 68 octets, et n'etait jamais lue).
|
||||
expected.morphHeight = expected.height;
|
||||
expected.morphNormal[0] = expected.normal[0];
|
||||
expected.morphNormal[1] = expected.normal[1];
|
||||
same = std::memcmp(&expected, &gpu.vertices[v], sizeof(TerrainVertex)) == 0;
|
||||
}
|
||||
check(same, "Bloc unique : terrainGpuMeshData == reference compactee, memes indices");
|
||||
}
|
||||
|
||||
// --- RangeAllocator : la logique du pool, sans GPU ----------------------
|
||||
{
|
||||
RangeAllocator block(1 << 20);
|
||||
struct Taken { uint64_t offset; uint64_t size; };
|
||||
std::vector<Taken> taken;
|
||||
bool aligned = true;
|
||||
for (uint64_t k = 0; k < 40; ++k) {
|
||||
const uint64_t size = 1000 + 777 * (k % 7);
|
||||
const uint64_t offset = block.allocate(size, 256);
|
||||
if (offset == RangeAllocator::kInvalid) { aligned = false; break; }
|
||||
aligned = aligned && (offset % 256 == 0);
|
||||
taken.push_back({ offset, size });
|
||||
}
|
||||
bool disjoint = true;
|
||||
for (std::size_t a = 0; a < taken.size(); ++a) {
|
||||
for (std::size_t b = a + 1; b < taken.size(); ++b) {
|
||||
disjoint = disjoint && (taken[a].offset + taken[a].size <= taken[b].offset ||
|
||||
taken[b].offset + taken[b].size <= taken[a].offset);
|
||||
}
|
||||
}
|
||||
check(aligned && taken.size() == 40, "RangeAllocator : 40 plages alignees sur 256");
|
||||
check(disjoint, "RangeAllocator : aucune plage n'en chevauche une autre");
|
||||
|
||||
// Un trou laisse par une plage liberee est reutilise par une demande de
|
||||
// meme taille (le cas des tuiles, toutes de la meme taille).
|
||||
const Taken hole = taken[10];
|
||||
block.release(hole.offset, hole.size);
|
||||
check(block.allocate(hole.size, 256) == hole.offset,
|
||||
"RangeAllocator : un trou est reutilise par une demande de meme taille");
|
||||
|
||||
for (const Taken& t : taken) {
|
||||
block.release(t.offset, t.size);
|
||||
}
|
||||
check(block.empty() && block.freeSpanCount() == 1 &&
|
||||
block.largestFree() == block.capacity(),
|
||||
"RangeAllocator : tout liberer refusionne le bloc en une seule plage");
|
||||
check(block.allocate(block.capacity() + 1, 256) == RangeAllocator::kInvalid &&
|
||||
block.allocate(16, 3) == RangeAllocator::kInvalid,
|
||||
"RangeAllocator : demande trop grande ou alignement invalide refuses");
|
||||
}
|
||||
}
|
||||
|
||||
int main() {
|
||||
std::printf("=== Tests logiques Vercora (headless, sans Vulkan) ===\n");
|
||||
|
||||
@@ -10890,6 +11167,7 @@ int main() {
|
||||
testGrassMesh();
|
||||
testGrassPhase18();
|
||||
testTileMeshingIsThreadSafe();
|
||||
testGpuFormatsPhase32();
|
||||
testVegetationPlacement();
|
||||
testGrassPlacement();
|
||||
testInstanceLayout();
|
||||
|
||||
@@ -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())
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur