diff --git a/CMakeLists.txt b/CMakeLists.txt index 2e4e6ca..72df8c4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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 , 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 $<$:VERCORA_DEBUG> diff --git a/MEMORY.md b/MEMORY.md index 673c7c8..6b2779a 100644 --- a/MEMORY.md +++ b/MEMORY.md @@ -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). diff --git a/NOTES-AUDIT-GLOBAL.md b/NOTES-AUDIT-GLOBAL.md index 19837a0..b5d5a68 100644 --- a/NOTES-AUDIT-GLOBAL.md +++ b/NOTES-AUDIT-GLOBAL.md @@ -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`. diff --git a/NOTES-PHASE32.md b/NOTES-PHASE32.md new file mode 100644 index 0000000..b26f559 --- /dev/null +++ b/NOTES-PHASE32.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). + - `` incluait `` (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 diff --git a/README.md b/README.md new file mode 100644 index 0000000..d1282a2 --- /dev/null +++ b/README.md @@ -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 diff --git a/shaders/terrain.vert b/shaders/terrain.vert index 7f2f968..7fc41a7 100644 --- a/shaders/terrain.vert +++ b/shaders/terrain.vert @@ -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 diff --git a/src/assets/Heightmap.hpp b/src/assets/Heightmap.hpp index 787dd21..cbc14b2 100644 --- a/src/assets/Heightmap.hpp +++ b/src/assets/Heightmap.hpp @@ -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; diff --git a/src/assets/TextureFile.cpp b/src/assets/TextureFile.cpp index 09b6faa..58f162b 100644 --- a/src/assets/TextureFile.cpp +++ b/src/assets/TextureFile.cpp @@ -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(kHeaderSize), std::ios::beg); - texture.pixels.resize(static_cast(total)); - if (!file.read(reinterpret_cast(texture.pixels.data()), - static_cast(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(kHeaderSize + offset), std::ios::beg); + if (!file.read(static_cast(destination), static_cast(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(texture.payloadSize())); + readTexturePayload(path, texture, texture.pixels.data()); + return texture; +} + } // namespace vercora diff --git a/src/assets/TextureFile.hpp b/src/assets/TextureFile.hpp index 56cd911..dc00f74 100644 --- a/src/assets/TextureFile.hpp +++ b/src/assets/TextureFile.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include @@ -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. diff --git a/src/core/ProcessMemory.cpp b/src/core/ProcessMemory.cpp new file mode 100644 index 0000000..396a247 --- /dev/null +++ b/src/core/ProcessMemory.cpp @@ -0,0 +1,65 @@ +#include "core/ProcessMemory.hpp" + +#include + +#if defined(_WIN32) +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +// Avec PSAPI_VERSION 2 (le defaut depuis Windows 7), GetProcessMemoryInfo est +// K32GetProcessMemoryInfo, exportee par kernel32 : aucune bibliotheque de plus +// a lier. +# include +#elif defined(__linux__) +# include +# include +#endif + +namespace vercora { + +ProcessMemory processMemory() { + ProcessMemory memory; +#if defined(_WIN32) + PROCESS_MEMORY_COUNTERS counters{}; + if (GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) { + memory.residentBytes = static_cast(counters.WorkingSetSize); + memory.peakResidentBytes = static_cast(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(memory.residentBytes) / (1024.0 * 1024.0), + static_cast(memory.peakResidentBytes) / (1024.0 * 1024.0)); + return text; +} + +} // namespace vercora diff --git a/src/core/ProcessMemory.hpp b/src/core/ProcessMemory.hpp new file mode 100644 index 0000000..3b5cd4d --- /dev/null +++ b/src/core/ProcessMemory.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include +#include + +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 diff --git a/src/main.cpp b/src/main.cpp index 59e562e..df581e6 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -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(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(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(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(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(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(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(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(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(total) / diff --git a/src/renderer/DrawItem.hpp b/src/renderer/DrawItem.hpp index cda27a3..65343da 100644 --- a/src/renderer/DrawItem.hpp +++ b/src/renderer/DrawItem.hpp @@ -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 diff --git a/src/renderer/GpuBufferPool.cpp b/src/renderer/GpuBufferPool.cpp new file mode 100644 index 0000000..eb29c36 --- /dev/null +++ b/src/renderer/GpuBufferPool.cpp @@ -0,0 +1,178 @@ +#include "renderer/GpuBufferPool.hpp" + +#include +#include + +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 : blocks_) { + if (block) { + destroyBlock(*block); + } + } +} + +std::unique_ptr GpuBufferPool::createBlock(VkDeviceSize capacity, + bool dedicated) { + auto block = std::make_unique(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(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 : 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(usedBytes_) / (1024.0 * 1024.0), + static_cast(capacityBytes_) / (1024.0 * 1024.0), blockCount(), + mapped_ ? "ecriture directe (memoire unifiee)" : "televersement par staging"); + return text; +} + +} // namespace vercora diff --git a/src/renderer/GpuBufferPool.hpp b/src/renderer/GpuBufferPool.hpp new file mode 100644 index 0000000..a88a6e8 --- /dev/null +++ b/src/renderer/GpuBufferPool.hpp @@ -0,0 +1,109 @@ +#pragma once + +#include "renderer/RangeAllocator.hpp" +#include "renderer/VulkanContext.hpp" // GpuAllocation + +#include + +#include +#include +#include +#include + +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 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> blocks_; + + VkDeviceSize usedBytes_ = 0; + VkDeviceSize capacityBytes_ = 0; +}; + +} // namespace vercora diff --git a/src/renderer/GpuVertex.hpp b/src/renderer/GpuVertex.hpp new file mode 100644 index 0000000..2ba1268 --- /dev/null +++ b/src/renderer/GpuVertex.hpp @@ -0,0 +1,118 @@ +#pragma once + +#include "renderer/Vertex.hpp" + +#include + +#include +#include +#include + +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(std::lround(clamped * 32767.0f)); +} + +inline float unpackSnorm16(int16_t value) { + return std::max(static_cast(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(index) * spacing; +} + +} // namespace vercora diff --git a/src/renderer/Mesh.cpp b/src/renderer/Mesh.cpp index d33f665..4cf6fe8 100644 --- a/src/renderer/Mesh.cpp +++ b/src/renderer/Mesh.cpp @@ -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 -#include - 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(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(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 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( - 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( - 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 { diff --git a/src/renderer/Mesh.hpp b/src/renderer/Mesh.hpp index 5b3482c..8c5009a 100644 --- a/src/renderer/Mesh.hpp +++ b/src/renderer/Mesh.hpp @@ -1,55 +1,50 @@ #pragma once +#include "renderer/GpuBufferPool.hpp" + #include #include -#include 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 createDeviceLocalBuffer( - VulkanContext& context, - BufferUploader& uploader, - const void* data, - VkDeviceSize size, - VkBufferUsageFlags usage); - - std::unique_ptr vertexBuffer_; - std::unique_ptr 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 diff --git a/src/renderer/Pipeline.cpp b/src/renderer/Pipeline.cpp index e7649c8..3fcfebf 100644 --- a/src/renderer/Pipeline.cpp +++ b/src/renderer/Pipeline.cpp @@ -41,15 +41,15 @@ Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayo const std::array 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(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 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 bindings{ bindingDescription }; std::vector 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{}; diff --git a/src/renderer/Pipeline.hpp b/src/renderer/Pipeline.hpp index d6f2b39..8f50806 100644 --- a/src/renderer/Pipeline.hpp +++ b/src/renderer/Pipeline.hpp @@ -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. diff --git a/src/renderer/RangeAllocator.hpp b/src/renderer/RangeAllocator.hpp new file mode 100644 index 0000000..c1ebe88 --- /dev/null +++ b/src/renderer/RangeAllocator.hpp @@ -0,0 +1,117 @@ +#pragma once + +#include +#include +#include + +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::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(k)); + std::size_t insertAt = k; + if (padding > 0) { + free_.insert(free_.begin() + static_cast(insertAt), + Span{ span.offset, padding }); + ++insertAt; + } + if (tailSize > 0) { + free_.insert(free_.begin() + static_cast(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(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(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(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 free_; // trie par decalage croissant, jamais deux contigues +}; + +} // namespace vercora diff --git a/src/renderer/Renderer.cpp b/src/renderer/Renderer.cpp index 308de99..86d013b 100644 --- a/src/renderer/Renderer.cpp +++ b/src/renderer/Renderer.cpp @@ -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 #include +#include #include +#include #include 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(context_, window_); + swapChain_ = std::make_unique(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( + 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(context_, *this, meshData, log); +MeshHandle Renderer::registerMesh(std::unique_ptr 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(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( + 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(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(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(vertexCount) * sizeof(ObjectVertex); + const VkDeviceSize indexBytes = static_cast(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(vertexWrite.destination); + for (uint32_t v = 0; v < vertexCount; ++v) { + vertices[v] = toObjectVertex(meshData.vertices[v]); + } + if (shortIndices) { + auto* indices = static_cast(indexWrite.destination); + for (uint32_t k = 0; k < indexCount; ++k) { + indices[k] = static_cast(meshData.indices[k]); + } + } else { + std::memcpy(indexWrite.destination, meshData.indices.data(), + static_cast(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 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(*geometryPool_, layout, vertexRange, vertexCount, + indexRange, indexType, indexCount, true); +} + +MeshHandle Renderer::addTerrainMesh(const std::vector& vertices, + const std::vector& 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(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(vertexCount) * sizeof(TerrainVertex); + const VkDeviceSize indexBytes = static_cast(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(indices.size())); + RangeWrite vertexWrite = beginRangeWrite(mesh->vertexRange()); + RangeWrite indexWrite = beginRangeWrite(mesh->indexRange()); + std::memcpy(vertexWrite.destination, vertices.data(), static_cast(vertexBytes)); + std::memcpy(indexWrite.destination, indices.data(), static_cast(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& 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(indices.size()); + shared.type = shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32; + shared.range = geometryPool_->allocate(static_cast(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(write.destination); + for (std::size_t k = 0; k < indices.size(); ++k) { + out[k] = static_cast(indices[k]); + } + } else { + std::memcpy(write.destination, indices.data(), indices.size() * sizeof(uint32_t)); + } + finishRangeWrite(write); + sharedIndices_.push_back(shared); + return static_cast(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( + *geometryPool_, VertexLayout::Terrain, + geometryPool_->allocate(static_cast(vertexCount) * sizeof(TerrainVertex)), + vertexCount, shared.range, shared.type, shared.count, false); + RangeWrite write = beginRangeWrite(mesh->vertexRange()); + + TerrainMeshWrite result; + result.vertices = static_cast(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(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( + 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 staging, VkBuffer destination) { +void Renderer::enqueueCopy(std::unique_ptr 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(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(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 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(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(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(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 diff --git a/src/renderer/Renderer.hpp b/src/renderer/Renderer.hpp index 922cc7a..fd52d78 100644 --- a/src/renderer/Renderer.hpp +++ b/src/renderer/Renderer.hpp @@ -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 #include #include +#include +#include #include 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& vertices, + const std::vector& 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& 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 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& 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 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); + + // 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 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_; + // 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 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_; + + // Tuiles commencees (beginTerrainMesh) dont l'ecriture passe par un + // staging, en attente de leur endTerrainMesh. + std::unordered_map 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 staging; VkBuffer destination = VK_NULL_HANDLE; + VkDeviceSize destinationOffset = 0; VkDeviceSize size = 0; }; std::vector pendingCopies_; diff --git a/src/renderer/SwapChain.cpp b/src/renderer/SwapChain.cpp index eec6a33..2477edf 100644 --- a/src/renderer/SwapChain.cpp +++ b/src/renderer/SwapChain.cpp @@ -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; diff --git a/src/renderer/SwapChain.hpp b/src/renderer/SwapChain.hpp index 81e190d..e65b268 100644 --- a/src/renderer/SwapChain.hpp +++ b/src/renderer/SwapChain.hpp @@ -1,5 +1,7 @@ #pragma once +#include "renderer/VulkanContext.hpp" // GpuAllocation + #include #include @@ -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 images_; std::vector 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; diff --git a/src/renderer/TerrainMesh.cpp b/src/renderer/TerrainMesh.cpp index 9fc398c..b363c95 100644 --- a/src/renderer/TerrainMesh.cpp +++ b/src/renderer/TerrainMesh.cpp @@ -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(xp - xm) * spacing); + const float dhdz = (heightmap.at(ix, zp) - heightmap.at(ix, zm)) / + (static_cast(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& 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(xp - xm) * spacing); - const float dhdz = (heightmap.at(ix, zp) - heightmap.at(ix, zm)) / - (static_cast(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(res) * res); + mesh.indices.reserve(static_cast(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(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 diff --git a/src/renderer/TerrainMesh.hpp b/src/renderer/TerrainMesh.hpp index 4ba978d..12ec0fd 100644 --- a/src/renderer/TerrainMesh.hpp +++ b/src/renderer/TerrainMesh.hpp @@ -1,7 +1,12 @@ #pragma once +#include "renderer/GpuVertex.hpp" #include "renderer/MeshData.hpp" +#include +#include +#include + 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 vertices; + std::vector indices; + std::string name; +}; +TerrainGpuMesh terrainGpuMeshData(const Heightmap& heightmap); + } // namespace vercora diff --git a/src/renderer/TerrainNodeMesh.cpp b/src/renderer/TerrainNodeMesh.cpp index 6ebe4c8..0d160ee 100644 --- a/src/renderer/TerrainNodeMesh.cpp +++ b/src/renderer/TerrainNodeMesh.cpp @@ -89,9 +89,16 @@ std::vector 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 +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(node.level)) + " (" + - std::to_string(node.ix0) + "," + std::to_string(node.iz0) + ")"; - mesh.vertices.resize(static_cast(verts) * verts); - for (uint32_t j = 0; j < verts; ++j) { for (uint32_t i = 0; i < verts; ++i) { // Indices de grille du sommet, ECRETES sur le bord du terrain. @@ -157,43 +159,209 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& ? parentGrid[static_cast(j / 2u) * parentVerts + (i / 2u)] : parentSample; - Vertex& vertex = mesh.vertices[static_cast(j) * verts + i]; - vertex.pos = here.position; - vertex.normal = here.normal; - vertex.morphPos = parent.position; - vertex.morphNormal = parent.normal; - - // Teinte neutre : le fragment shader colore par altitude et par - // pente. Reserve a une future classification LiDAR par sommet. - vertex.color = { 1.0f, 1.0f, 1.0f }; - - // UV sur TOUT le terrain (et non sur la tuile) : c'est le repere - // naturel d'une future orthophoto, et il doit rester continu d'une - // tuile a l'autre. - vertex.uv = { static_cast(gx) / static_cast(cells), - static_cast(gz) / static_cast(cells) }; + sink(static_cast(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(node.level)) + " (" + + std::to_string(node.ix0) + "," + std::to_string(node.iz0) + ")"; + mesh.vertices.resize(static_cast(verts) * verts); + + forEachNodeVertex(heightmap, quadtree, nodeIndex, reuseParentGrid, + [&](std::size_t v, uint32_t gx, uint32_t gz, + const GridSample& here, const GridSample& parent) { + Vertex& vertex = mesh.vertices[v]; + vertex.pos = here.position; + vertex.normal = here.normal; + vertex.morphPos = parent.position; + vertex.morphNormal = parent.normal; + + // Teinte neutre : le fragment shader colore par altitude et par + // pente. Reserve a une future classification LiDAR par sommet. + vertex.color = { 1.0f, 1.0f, 1.0f }; + + // UV sur TOUT le terrain (et non sur la tuile) : c'est le repere + // naturel d'une future orthophoto, et il doit rester continu d'une + // tuile a l'autre. + vertex.uv = { static_cast(gx) / static_cast(cells), + static_cast(gz) / static_cast(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(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 grid; + grid.resize(static_cast(span) * span); + for (uint32_t jj = 0; jj < span; ++jj) { + const float* row = heights + static_cast(node.iz0 - 2u * stride + + jj * stride) * res; + const float* sample = row + (node.ix0 - 2u * stride); + float* destination = grid.data() + static_cast(jj) * span; + for (uint32_t ii = 0; ii < span; ++ii) { + destination[ii] = sample[static_cast(ii) * stride]; + } + } + const auto at = [&](uint32_t ii, uint32_t jj) { + return grid[static_cast(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(2u * stride) * spacing; + const float parentStep = static_cast(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 parents; + parents.resize(static_cast(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(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(j / 2u) * parentVerts + (i / 2u)]; + + TerrainVertex& packed = out[static_cast(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 diff --git a/src/renderer/TerrainNodeMesh.hpp b/src/renderer/TerrainNodeMesh.hpp index 8244232..d5743ab 100644 --- a/src/renderer/TerrainNodeMesh.hpp +++ b/src/renderer/TerrainNodeMesh.hpp @@ -1,5 +1,6 @@ #pragma once +#include "renderer/GpuVertex.hpp" #include "renderer/MeshData.hpp" #include @@ -63,4 +64,31 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& // diagonale que TerrainMesh. Calculee une fois par appelant et reutilisee. std::vector 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 diff --git a/src/renderer/TerrainStreamer.cpp b/src/renderer/TerrainStreamer.cpp index fa8384c..17dd7af 100644 --- a/src/renderer/TerrainStreamer.cpp +++ b/src/renderer/TerrainStreamer.cpp @@ -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(quadtree_.nodeCells() + 1) * - (quadtree_.nodeCells() + 1) * sizeof(Vertex) + - static_cast(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(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(quadtree_.rootLevel()) - static_cast(params_.pinnedTopLevels) + 1); - const std::size_t bytesPerNode = - static_cast(quadtree_.nodeCells() + 1) * - (quadtree_.nodeCells() + 1) * sizeof(Vertex) + - static_cast(quadtree_.trianglesPerNode()) * 3 * sizeof(uint32_t); - for (uint32_t index = 0; index < quadtree_.nodeCount(); ++index) { if (static_cast(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(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& 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& 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& 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& nodes) { for (uint64_t micros : perTileMicros) { geometryMicros_ += micros; } + + // --- 3. Livraison, thread de rendu --------------------------------------- + const auto t2 = Clock::now(); + for (std::size_t k = 0; k < nodes.size(); ++k) { + const MeshHandle mesh = batchWrites_[k].mesh; + if (!batchErrors_[k].empty()) { + if (mesh != kInvalidMesh) { + renderer_.removeMesh(mesh); + } + continue; + } + renderer_.endTerrainMesh(mesh); + batchMeshes_[k] = mesh; + ++builtNodes_; + } + uploadMicros_ += microsBetween(t2, Clock::now()); } -MeshHandle TerrainStreamer::uploadNode(uint32_t nodeIndex, MeshData& data) { +MeshHandle TerrainStreamer::buildNode(uint32_t nodeIndex) { + // Chemin SEQUENTIEL : reserve, ecrit, livre une tuile. C'est le chemin du + // sommet epingle (construit avant la premiere frame) et, depuis que le + // defaut est meshThreads = 1, celui de la construction courante. + // + // PHASE 32 : plus aucun MeshData ici. Les sommets sont ecrits au format + // compact directement dans la zone reservee - la memoire que le GPU lira + // en memoire unifiee, un staging sinon. Le poste "televersement" ne compte + // plus que la reservation et la livraison. + const auto t0 = Clock::now(); + Renderer::TerrainMeshWrite write; try { - const auto t1 = Clock::now(); - // Les indices sont poses ICI et non dans terrainNodeMeshData, pour que - // les deux postes soient chronometres separement (voir buildProfile). - data.indices = sharedIndices(); - const auto t2 = Clock::now(); - // log = false : plusieurs tuiles par frame, une ligne chacune rendrait la - // sortie inexploitable (et couterait plus que l'upload). - const MeshHandle mesh = renderer_.addMesh(data, false); - const auto t3 = Clock::now(); - - ++builtNodes_; - indicesMicros_ += microsBetween(t1, t2); - uploadMicros_ += microsBetween(t2, t3); - return mesh; + write = renderer_.beginTerrainMesh( + (quadtree_.nodeCells() + 1) * (quadtree_.nodeCells() + 1), sharedIndexSet_); } catch (const std::exception& e) { - // Une tuile qu'on ne sait pas construire ne doit pas arreter le jeu : - // elle sera simplement absente, et le message dit laquelle. Le cas - // realiste est un manque de memoire GPU, pas une donnee invalide. + uploadMicros_ += microsBetween(t0, Clock::now()); + // Le cas realiste est un manque de memoire GPU, pas une donnee + // invalide : la tuile sera simplement absente, et le message dit + // laquelle. logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) + " non televersee (" + e.what() + ")."); return kInvalidMesh; } -} - -MeshHandle TerrainStreamer::buildNode(uint32_t nodeIndex) { - // Chemin SEQUENTIEL : maille une tuile puis la televerse, sans jamais garder - // plus d'un MeshData en vie. C'est le chemin du sommet epingle (construit - // avant la premiere frame) et, depuis que le defaut est meshThreads = 1, - // celui de la construction courante. - // - // Ne pas passer par meshBatch ici n'est pas une duplication gratuite : - // meshBatch dimensionne un vecteur de MeshData pour TOUT le lot, ce qui fait - // vivre jusqu'a 53 tuiles simultanement (~15 Mo) la ou ce chemin-ci n'en - // tient qu'une. Mesure : le pic memoire du processus montait de 5,6 Mo quand - // tout passait par le lot. Le chemin par defaut retrouve ainsi exactement le - // profil memoire d'avant la Phase 19. - const auto t0 = Clock::now(); + const auto t1 = Clock::now(); try { - scratchMesh_ = terrainNodeMeshData(heightmap_, quadtree_, nodeIndex, false, - params_.cacheTileWork); + writeTerrainNodeVertices(heightmap_, quadtree_, nodeIndex, write.vertices, + params_.cacheTileWork); } catch (const std::exception& e) { - geometryMicros_ += microsBetween(t0, Clock::now()); + geometryMicros_ += microsBetween(t1, Clock::now()); + renderer_.removeMesh(write.mesh); logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) + " non maillee (" + e.what() + ")."); return kInvalidMesh; } - const uint64_t micros = microsBetween(t0, Clock::now()); + const auto t2 = Clock::now(); + renderer_.endTerrainMesh(write.mesh); + const auto t3 = Clock::now(); + + const uint64_t micros = microsBetween(t1, t2); geometryMicros_ += micros; meshWallMicros_ += micros; - return uploadNode(nodeIndex, scratchMesh_); + uploadMicros_ += microsBetween(t0, t1) + microsBetween(t2, t3); + ++builtNodes_; + return write.mesh; } bool TerrainStreamer::evictOne() { @@ -354,11 +383,6 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition, fallbackCount_ = 0; uncoveredCount_ = 0; - const std::size_t bytesPerNode = - static_cast(quadtree_.nodeCells() + 1) * - (quadtree_.nodeCells() + 1) * sizeof(Vertex) + - static_cast(quadtree_.trianglesPerNode()) * 3 * sizeof(uint32_t); - const bool priming = (frameCounter_ <= params_.primingFrames); uint32_t uploadsLeft = priming ? std::numeric_limits::max() : params_.maxUploadsPerFrame; @@ -402,14 +426,13 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition, // --- 1b/1c. Maillage puis televersement --------------------------------- // Deux chemins, et le choix se fait sur la TAILLE DU LOT : // - // - lot parallelisable : tout le lot est maille d'abord (meshBatch, aucun - // appel Vulkan, plusieurs threads), puis televerse en sequence ; - // - sinon : chaque tuile est maillee et televersee a la suite, sans jamais - // garder plus d'un MeshData en vie. C'est le chemin par DEFAUT, et il - // est identique a celui d'avant la Phase 19, cout memoire compris. + // - lot parallelisable : tout le lot est reserve, puis ecrit (meshBatch, + // aucun appel Vulkan pendant l'ecriture, plusieurs threads), puis livre ; + // - sinon : chaque tuile est reservee, ecrite et livree a la suite. C'est + // le chemin par DEFAUT. // - // Dans les deux cas les addMesh ont lieu sur le thread de rendu, en - // sequence, et dans l'ordre de selection - donc du plus proche au plus + // Dans les deux cas les appels au Renderer ont lieu sur le thread de rendu, + // en sequence, et dans l'ordre de selection - donc du plus proche au plus // lointain. // Suivi du plus gros lot : il doit compter les DEUX chemins, sinon le bilan @@ -429,17 +452,19 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition, " non maillee (" + batchErrors_[k] + ")."); continue; } - // Faire de la place AVANT de televerser, sinon le pic de residence - // depasserait le plafond le temps d'un upload. (Le maillage, lui, - // n'alloue rien sur le GPU : c'est bien l'upload qui doit etre couvert.) - while (resident_.size() >= params_.maxResidentNodes) { - if (!evictOne()) { - break; // tout est utilise cette frame : on laisse deborder + MeshHandle mesh = kInvalidMesh; + if (parallel) { + mesh = batchMeshes_[k]; // place deja faite par meshBatch + } else { + // Faire de la place AVANT de reserver, sinon le pic de residence + // depasserait le plafond le temps d'une tuile. + while (resident_.size() >= params_.maxResidentNodes) { + if (!evictOne()) { + break; // tout est utilise cette frame : on laisse deborder + } } + mesh = buildNode(nodeIndex); } - - const MeshHandle mesh = parallel ? uploadNode(nodeIndex, batchMeshes_[k]) - : buildNode(nodeIndex); if (mesh == kInvalidMesh) { continue; } @@ -447,20 +472,13 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition, ResidentNode node; node.mesh = mesh; - node.bytes = bytesPerNode; + node.bytes = bytesPerNode_; node.lastUsedFrame = frameCounter_; resident_.emplace(nodeIndex, node); - residentBytes_ += bytesPerNode; + residentBytes_ += bytesPerNode_; --pendingCount_; // finalement servie dans la frame meme } - // Le lot ne doit pas garder ses maillages en vie jusqu'a la frame suivante : - // ce sont ~287 Ko par tuile. - if (parallel) { - batchMeshes_.clear(); - batchMeshes_.shrink_to_fit(); - } - // --- 2. Choix des ancetres de repli (PHASE 12) -------------------------- // Rien a faire dans le cas courant : en regime etabli toute la selection est // residente, l'ensemble reste vide et les passes suivantes ne coutent rien. @@ -489,6 +507,7 @@ void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition, // --- 3. Emission --------------------------------------------------------- const bool hasFallback = !fallbackAncestors_.empty(); + const int32_t vertsPerRow = static_cast(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(grid.ix0), static_cast(grid.iz0), + static_cast(grid.stride), vertsPerRow); out.push_back(item); ++drawnCount_; }; diff --git a/src/renderer/TerrainStreamer.hpp b/src/renderer/TerrainStreamer.hpp index 9035a09..84e5edb 100644 --- a/src/renderer/TerrainStreamer.hpp +++ b/src/renderer/TerrainStreamer.hpp @@ -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 @@ -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& 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& 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 batchNodes_; - std::vector batchMeshes_; // rempli seulement sur le chemin parallele std::vector 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 batchWrites_; + std::vector 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 diff --git a/src/renderer/Texture.cpp b/src/renderer/Texture.cpp index 86a210f..257e9b0 100644 --- a/src/renderer/Texture.cpp +++ b/src/renderer/Texture.cpp @@ -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(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(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(data.pixels.size()); + const VkDeviceSize total = static_cast(data.payloadSize()); + const uint32_t mipLevels = static_cast(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(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 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((mip.width + 3u) / 4u) * 8u + : static_cast(mip.width) * 4u; + const uint32_t rows = (mip.height + texelsPerRow - 1u) / texelsPerRow; + const uint32_t rowsPerBand = static_cast( + std::max(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(row) * rowBytes; + band.bytes = static_cast(count) * rowBytes; + bands.push_back(band); + } + } VkCommandBufferAllocateInfo allocInfo{}; allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; @@ -175,60 +218,74 @@ void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue, VkCommandBuffer commandBuffer = VK_NULL_HANDLE; vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer); - VkCommandBufferBeginInfo beginInfo{}; - beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; - vkBeginCommandBuffer(commandBuffer, &beginInfo); - - const uint32_t mipLevels = static_cast(data.mips.size()); - - transitionLayout(commandBuffer, image_, mipLevels, - VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - 0, VK_ACCESS_TRANSFER_WRITE_BIT, - VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); - + // --- Un lot de bandes par remplissage du staging ------------------------ std::vector regions; - regions.reserve(mipLevels); - for (uint32_t level = 0; level < mipLevels; ++level) { - const TextureMipLevel& mip = data.mips[level]; - VkBufferImageCopy region{}; - region.bufferOffset = mip.offset; - // 0 = "serre sur l'extent de l'image". Indispensable pour un format - // compresse, ou bufferRowLength se compterait en TEXELS et non en blocs : - // le calculer a la main serait une occasion d'erreur gratuite. - region.bufferRowLength = 0; - region.bufferImageHeight = 0; - region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - region.imageSubresource.mipLevel = level; - region.imageSubresource.baseArrayLayer = 0; - region.imageSubresource.layerCount = 1; - region.imageOffset = { 0, 0, 0 }; - region.imageExtent = { mip.width, mip.height, 1 }; - regions.push_back(region); + std::size_t next = 0; + bool first = true; + while (next < bands.size()) { + regions.clear(); + VkDeviceSize used = 0; + while (next < bands.size() && used + bands[next].bytes <= stagingSize) { + const Band& band = bands[next]; + source(stagingBytes + used, band.payloadOffset, band.bytes); + + VkBufferImageCopy region{}; + region.bufferOffset = used; + // 0 = "serre sur l'extent de la copie". Indispensable pour un format + // compresse, ou bufferRowLength se compterait en TEXELS et non en + // blocs : le calculer a la main serait une occasion d'erreur + // gratuite. + region.bufferRowLength = 0; + region.bufferImageHeight = 0; + region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + region.imageSubresource.mipLevel = band.level; + region.imageSubresource.baseArrayLayer = 0; + region.imageSubresource.layerCount = 1; + region.imageOffset = { 0, static_cast(band.y), 0 }; + region.imageExtent = { data.mips[band.level].width, band.height, 1 }; + regions.push_back(region); + + used += band.bytes; + ++next; + } + const bool last = (next == bands.size()); + + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + vkBeginCommandBuffer(commandBuffer, &beginInfo); + + if (first) { + transitionLayout(commandBuffer, image_, mipLevels, + VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 0, VK_ACCESS_TRANSFER_WRITE_BIT, + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); + } + vkCmdCopyBufferToImage(commandBuffer, staging.handle(), image_, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + static_cast(regions.size()), regions.data()); + if (last) { + transitionLayout(commandBuffer, image_, mipLevels, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); + } + vkEndCommandBuffer(commandBuffer); + + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE); + // Transfert a l'initialisation : attendre est simple et sans + // consequence sur la boucle de rendu, qui n'a pas encore demarre - et + // c'est ce qui rend le staging reutilisable pour la tranche suivante. + vkQueueWaitIdle(queue); + first = false; } - vkCmdCopyBufferToImage(commandBuffer, staging.handle(), image_, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - static_cast(regions.size()), regions.data()); - - transitionLayout(commandBuffer, image_, mipLevels, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, - VK_PIPELINE_STAGE_TRANSFER_BIT, - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); - - vkEndCommandBuffer(commandBuffer); - - VkSubmitInfo submitInfo{}; - submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submitInfo.commandBufferCount = 1; - submitInfo.pCommandBuffers = &commandBuffer; - vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE); - // Transfert unique a l'initialisation : attendre est simple et sans - // consequence sur la boucle de rendu, qui n'a pas encore demarre. - vkQueueWaitIdle(queue); - vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); } diff --git a/src/renderer/Texture.hpp b/src/renderer/Texture.hpp index 4bc55a3..795afee 100644 --- a/src/renderer/Texture.hpp +++ b/src/renderer/Texture.hpp @@ -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 #include +#include 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; + + // 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; diff --git a/src/renderer/UniformBufferObject.hpp b/src/renderer/UniformBufferObject.hpp index 9f129bf..a367205 100644 --- a/src/renderer/UniformBufferObject.hpp +++ b/src/renderer/UniformBufferObject.hpp @@ -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 diff --git a/src/renderer/VertexFormat.hpp b/src/renderer/VertexFormat.hpp index 1a6116a..37b6fdf 100644 --- a/src/renderer/VertexFormat.hpp +++ b/src/renderer/VertexFormat.hpp @@ -1,7 +1,7 @@ #pragma once +#include "renderer/GpuVertex.hpp" #include "renderer/InstanceData.hpp" -#include "renderer/Vertex.hpp" #include @@ -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 vertexAttributeDescriptions() { - std::array 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 objectAttributeDescriptions() { + std::array 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 terrainAttributeDescriptions() { + std::array 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 diff --git a/src/renderer/VulkanBuffer.cpp b/src/renderer/VulkanBuffer.cpp index 0efebe8..b89a982 100644 --- a/src/renderer/VulkanBuffer.cpp +++ b/src/renderer/VulkanBuffer.cpp @@ -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; } } diff --git a/src/renderer/VulkanBuffer.hpp b/src/renderer/VulkanBuffer.hpp index 4880b97..ab99309 100644 --- a/src/renderer/VulkanBuffer.hpp +++ b/src/renderer/VulkanBuffer.hpp @@ -1,5 +1,7 @@ #pragma once +#include "renderer/VulkanContext.hpp" // GpuAllocation + #include #include @@ -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 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; }; diff --git a/src/renderer/VulkanContext.cpp b/src/renderer/VulkanContext.cpp index d20b36f..3b93501 100644 --- a/src/renderer/VulkanContext.cpp +++ b/src/renderer/VulkanContext.cpp @@ -3,6 +3,8 @@ #include "core/Logger.hpp" #include "core/Window.hpp" +#include +#include #include #include #include @@ -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(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& candidates, VkImageTiling tiling, VkFormatFeatureFlags features) const { diff --git a/src/renderer/VulkanContext.hpp b/src/renderer/VulkanContext.hpp index 2561e78..a85f2c1 100644 --- a/src/renderer/VulkanContext.hpp +++ b/src/renderer/VulkanContext.hpp @@ -3,6 +3,7 @@ #include #include +#include #include namespace vercora { @@ -41,6 +42,32 @@ struct SwapChainSupportDetails { std::vector 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 diff --git a/src/world/TerrainQuadtree.hpp b/src/world/TerrainQuadtree.hpp index ae47ac3..2324788 100644 --- a/src/world/TerrainQuadtree.hpp +++ b/src/world/TerrainQuadtree.hpp @@ -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. diff --git a/tests/logic_tests.cpp b/tests/logic_tests.cpp index 4476914..e43f7ff 100644 --- a/tests/logic_tests.cpp +++ b/tests/logic_tests.cpp @@ -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 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((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(header), sizeof(header)); + out.write(reinterpret_cast(payload.data()), + static_cast(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 whole(payload.size()); + readTexturePayload(path, headerOnly, whole.data()); + std::vector 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(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(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(b) / 15.0f; + const float angle = 6.2831853f * static_cast(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 written(static_cast(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(gx) / static_cast(cells) == r.uv.x && + static_cast(gz) / static_cast(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 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; + 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(); diff --git a/tools/make_bench_zone.py b/tools/make_bench_zone.py new file mode 100644 index 0000000..b279898 --- /dev/null +++ b/tools/make_bench_zone.py @@ -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=" 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("> 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="> 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())