From 16775bf1ff2060a587889c5fe9375390574ca141 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 13 Oct 2026 22:39:35 +0000 Subject: [PATCH 1/7] Phase 30 (1/n) : build Linux, banc de mesure des ressources, plan - Portabilite GCC/Clang : les constructeurs a argument par defaut `= {}` sur une struct imbriquee (Heightmap, TerrainQuadtree, TerrainStreamer) deviennent des surcharges qui deleguent (CWG 1397, refuse hors MSVC). GLFW_INCLUDE_NONE evite d'exiger sous Linux. - Comptabilite de la memoire GPU : toute allocation passe par VulkanContext::allocateMemory / freeMemory (octets vivants, pics, blocs, appels vkAllocateMemory). RAM du processus lue au systeme (core/ProcessMemory). Bilan "Ressources (PHASE 30)" au chargement, toutes les 10 s et en fin de partie. - Outils de banc : --quit-after=S (fermeture propre), --freeze-anim (images comparables au pixel), tools/make_bench_zone.py (zone proxy 5001x5001 a la vraie echelle quand les donnees LiDAR sont absentes). - NOTES-PHASE30.md : mesure de reference, revue du noyau Vulkan, plan. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2 --- CMakeLists.txt | 6 + NOTES-PHASE30.md | 155 +++++++++++++++++++ src/assets/Heightmap.hpp | 9 +- src/core/ProcessMemory.cpp | 65 ++++++++ src/core/ProcessMemory.hpp | 31 ++++ src/main.cpp | 76 +++++++++- src/renderer/SwapChain.cpp | 19 +-- src/renderer/SwapChain.hpp | 4 +- src/renderer/TerrainStreamer.hpp | 6 +- src/renderer/Texture.cpp | 17 +-- src/renderer/Texture.hpp | 3 +- src/renderer/VulkanBuffer.cpp | 26 ++-- src/renderer/VulkanBuffer.hpp | 4 +- src/renderer/VulkanContext.cpp | 95 +++++++++++- src/renderer/VulkanContext.hpp | 56 +++++++ src/world/TerrainQuadtree.hpp | 5 +- tools/make_bench_zone.py | 249 +++++++++++++++++++++++++++++++ 17 files changed, 767 insertions(+), 59 deletions(-) create mode 100644 NOTES-PHASE30.md create mode 100644 src/core/ProcessMemory.cpp create mode 100644 src/core/ProcessMemory.hpp create mode 100644 tools/make_bench_zone.py diff --git a/CMakeLists.txt b/CMakeLists.txt index 27c4db5..6f00e68 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -75,6 +75,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 @@ -138,12 +139,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/NOTES-PHASE30.md b/NOTES-PHASE30.md new file mode 100644 index 0000000..d72ad8d --- /dev/null +++ b/NOTES-PHASE30.md @@ -0,0 +1,155 @@ +# Phase 30 - 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 30)` | 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. diff --git a/src/assets/Heightmap.hpp b/src/assets/Heightmap.hpp index 787dd21..b5cbed6 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). 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..8e05682 --- /dev/null +++ b/src/core/ProcessMemory.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include +#include + +namespace vercora { + +// PHASE 30. 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..c83245f 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,13 @@ 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 30, pour le BANC DE MESURE (voir NOTES-PHASE30.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 +// // 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 +881,20 @@ int main(int argc, char** argv) { std::string sceneFileArgument; std::string editorAssetsArgument; std::string sceneArgument; + // PHASE 30 : 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; for (int i = 1; i < argc; ++i) { const std::string argument = argv[i]; if (argument == "--dump-world") { @@ -1029,6 +1051,20 @@ 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.rfind("--", 0) == 0) { logWarn("Option inconnue, ignoree : " + argument); } else if (sceneArgument.empty()) { @@ -2289,9 +2325,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 30 : 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 30) : " + 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 30) : " + processMemoryLine() + ", " + + context.gpuMemoryLine() + "."); + } + const double now = glfwGetTime(); const float deltaTime = static_cast(now - lastTime); lastTime = now; @@ -2301,6 +2356,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 30 : 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 @@ -3682,7 +3740,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 +3761,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 +3792,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 +3818,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 +3844,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 +3904,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 +3976,12 @@ int main(int argc, char** argv) { // S'assurer que le GPU a fini avant de detruire quoi que ce soit. renderer.waitIdle(); + // PHASE 30 : 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 30) : " + processMemoryLine() + ", " + + context.gpuMemoryLine() + "."); + if (frameProfile.frames > 0) { const auto per = [&](uint64_t total) { const double value = static_cast(total) / diff --git a/src/renderer/SwapChain.cpp b/src/renderer/SwapChain.cpp index eec6a33..0844370 100644 --- a/src/renderer/SwapChain.cpp +++ b/src/renderer/SwapChain.cpp @@ -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); @@ -342,16 +339,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 30 : 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..17841f7 100644 --- a/src/renderer/SwapChain.hpp +++ b/src/renderer/SwapChain.hpp @@ -1,5 +1,7 @@ #pragma once +#include "renderer/VulkanContext.hpp" // GpuAllocation + #include #include @@ -68,7 +70,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/TerrainStreamer.hpp b/src/renderer/TerrainStreamer.hpp index 9035a09..c4e6cd6 100644 --- a/src/renderer/TerrainStreamer.hpp +++ b/src/renderer/TerrainStreamer.hpp @@ -176,7 +176,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; diff --git a/src/renderer/Texture.cpp b/src/renderer/Texture.cpp index 86a210f..6acf046 100644 --- a/src/renderer/Texture.cpp +++ b/src/renderer/Texture.cpp @@ -111,9 +111,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,16 +137,9 @@ 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 30 : 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; } diff --git a/src/renderer/Texture.hpp b/src/renderer/Texture.hpp index 4bc55a3..c609500 100644 --- a/src/renderer/Texture.hpp +++ b/src/renderer/Texture.hpp @@ -4,6 +4,7 @@ // 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 @@ -74,7 +75,7 @@ private: 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/VulkanBuffer.cpp b/src/renderer/VulkanBuffer.cpp index 0efebe8..b1d3447 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 30 : 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..0da2b27 100644 --- a/src/renderer/VulkanBuffer.hpp +++ b/src/renderer/VulkanBuffer.hpp @@ -1,5 +1,7 @@ #pragma once +#include "renderer/VulkanContext.hpp" // GpuAllocation + #include #include @@ -76,7 +78,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..fde4b3b 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,28 @@ void VulkanContext::pickPhysicalDevice() { VkPhysicalDeviceProperties props{}; vkGetPhysicalDeviceProperties(physicalDevice_, &props); logInfo(std::string("GPU selectionne : ") + props.deviceName); + + // PHASE 30 : 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 +421,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 +432,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..4a71e83 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 30. 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 30. 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,28 @@ public: // Format de profondeur retenu (D32 de preference, avec fallbacks). VkFormat findDepthFormat() const; + // PHASE 30. 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 30. 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_; } + private: void createInstance(); void setupDebugMessenger(); @@ -110,6 +159,13 @@ private: QueueFamilyIndices queueIndices_; bool anisotropyEnabled_ = false; + bool unifiedMemory_ = false; + + // 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/tools/make_bench_zone.py b/tools/make_bench_zone.py new file mode 100644 index 0000000..7992871 --- /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 30. 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()) From 7f2d538768a293fe1b42f9b6290c2597b88ce788 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 13 Oct 2026 23:08:23 +0000 Subject: [PATCH 2/7] Phase 30 (2/n) : geometrie compacte, pool de sous-allocation, early-Z - Formats GPU : le format de travail Vertex (68 o) n'est plus televerse. Objets et vegetation : ObjectVertex 44 o (conversion exacte). Terrain : TerrainVertex 16 o (deux altitudes f32 + deux normales snorm16) ; x/z, cible de morphing et UV sont recalcules par terrain.vert depuis gl_VertexIndex et DrawItem::grid, au bit pres (`precise`). - Topologie des tuiles televersee UNE fois, en uint16 (96 Ko de moins par tuile). Indices des maillages d'objets en uint16. - GpuBufferPool + RangeAllocator : toute la geometrie dans des blocs de 4 Mo ; ecriture DIRECTE en memoire unifiee (GPU integre, lavapipe), staging conserve sur GPU discret (--force-staging pour l'eprouver), barriere ecriture-apres-lecture ajoutee devant les copies (validation de synchronisation a zero). - Rendu : terrain dessine apres la vegetation (early-Z) et culling de ses faces arriere. - Tests : +16 verifications (formats, positions recalculees, allocateur). Survol 900 m/s (lavapipe) : pic GPU 286 -> 89 Mo, geometrie terrain 188 -> 33 Mo, ~17 000 -> 21 vkAllocateMemory, streaming 4,5 -> 1,6 ms par image. Foret : 8,3 -> 12,4 images/s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2 --- CMakeLists.txt | 1 + shaders/terrain.vert | 102 +++++--- src/main.cpp | 39 ++- src/renderer/DrawItem.hpp | 19 +- src/renderer/GpuBufferPool.cpp | 178 ++++++++++++++ src/renderer/GpuBufferPool.hpp | 109 +++++++++ src/renderer/GpuVertex.hpp | 118 +++++++++ src/renderer/Mesh.cpp | 111 +-------- src/renderer/Mesh.hpp | 92 +++---- src/renderer/Pipeline.cpp | 28 ++- src/renderer/Pipeline.hpp | 44 ++-- src/renderer/RangeAllocator.hpp | 117 +++++++++ src/renderer/Renderer.cpp | 345 +++++++++++++++++++++++++-- src/renderer/Renderer.hpp | 89 ++++++- src/renderer/TerrainMesh.cpp | 148 ++++++++---- src/renderer/TerrainMesh.hpp | 18 ++ src/renderer/TerrainNodeMesh.cpp | 116 ++++++--- src/renderer/TerrainNodeMesh.hpp | 20 ++ src/renderer/TerrainStreamer.cpp | 226 ++++++++++-------- src/renderer/TerrainStreamer.hpp | 68 +++--- src/renderer/UniformBufferObject.hpp | 8 + src/renderer/VertexFormat.hpp | 84 ++++--- src/renderer/VulkanBuffer.hpp | 8 +- src/renderer/VulkanContext.cpp | 1 + src/renderer/VulkanContext.hpp | 12 + tests/logic_tests.cpp | 207 ++++++++++++++++ 26 files changed, 1845 insertions(+), 463 deletions(-) create mode 100644 src/renderer/GpuBufferPool.cpp create mode 100644 src/renderer/GpuBufferPool.hpp create mode 100644 src/renderer/GpuVertex.hpp create mode 100644 src/renderer/RangeAllocator.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 6f00e68..1025535 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -117,6 +117,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 diff --git a/shaders/terrain.vert b/shaders/terrain.vert index 7f2f968..e1d87e7 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 30 : la grille de la heightmap. x = origine (Heightmap:: + // worldCoord(0)), y = pas en metres, z = nombre de CELLULES par cote. + vec4 terrainGrid; } ubo; -// Meme push constant que cube.vert : les 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 30) : place du maillage dans la grille de la heightmap - +// x, y = indices (ix, iz) du premier sommet, z = pas en echantillons entre deux +// sommets voisins, w = sommets par rangee. Voir renderer/DrawItem.hpp. layout(push_constant) uniform PushConstants { mat4 model; vec4 params; + ivec4 grid; } pc; -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 30 : 16 octets par sommet au lieu de 68 (renderer/GpuVertex.hpp, +// TerrainVertex). Le buffer ne porte plus que ce qui ne se DEDUIT pas de +// l'indice du sommet : les deux altitudes et les deux normales (x et z en +// snorm16, y reconstruit). Position horizontale, cible de morphing horizontale +// et UV sont recalcules ci-dessous ; la couleur de sommet valait toujours blanc. +layout(location = 0) in float inHeight; +layout(location = 1) in float inMorphHeight; +layout(location = 2) in vec2 inNormalXZ; +layout(location = 3) in vec2 inMorphNormalXZ; layout(location = 0) out vec3 fragTint; layout(location = 1) out vec3 fragNormal; layout(location = 2) out vec3 fragWorldPos; layout(location = 3) out vec2 fragUV; +// Une normale de champ de hauteur pointe toujours vers le haut : y se deduit de +// x et z. Meme formule que unpackTerrainNormal (renderer/GpuVertex.hpp). +vec3 decodeNormal(vec2 xz) { + return vec3(xz.x, sqrt(max(0.0, 1.0 - xz.x * xz.x - xz.y * xz.y)), xz.y); +} + void main() { + // --- Place du sommet dans la grille ----------------------------------- + // gl_VertexIndex est l'indice LOCAL du sommet dans son maillage : le + // Renderer lie chaque maillage a son decalage dans le bloc partage plutot + // que de passer un vertexOffset au draw (voir Renderer::recordCommandBuffer). + // Les indices de grille sont ECRETES sur le bord du terrain exactement comme + // le fait TerrainNodeMesh.cpp, et la cible de morphing est le sommet aux + // indices locaux arrondis au pair inferieur (grille du parent). + const int perRow = pc.grid.w; + const int i = gl_VertexIndex % perRow; + const int j = gl_VertexIndex / perRow; + const int cells = int(ubo.terrainGrid.z); + const int gx = min(pc.grid.x + i * pc.grid.z, cells); + const int gz = min(pc.grid.y + j * pc.grid.z, cells); + const int mx = min(pc.grid.x + (i & ~1) * pc.grid.z, cells); + const int mz = min(pc.grid.y + (j & ~1) * pc.grid.z, cells); + + // `precise` : interdit au compilateur de fusionner la multiplication et + // l'addition en un FMA. Sans lui le resultat pourrait differer d'un ULP de + // Heightmap::worldCoord ; avec lui il est identique AU BIT PRES (addition et + // multiplication flottantes sont correctement arrondies en Vulkan). + precise float x = ubo.terrainGrid.x + float(gx) * ubo.terrainGrid.y; + precise float z = ubo.terrainGrid.x + float(gz) * ubo.terrainGrid.y; + precise float morphX = ubo.terrainGrid.x + float(mx) * ubo.terrainGrid.y; + precise float morphZ = ubo.terrainGrid.x + float(mz) * ubo.terrainGrid.y; + + const vec3 inPosition = vec3(x, inHeight, z); + const vec3 inMorphPos = vec3(morphX, inMorphHeight, morphZ); + // --- Geomorphing (CDLOD) ------------------------------------------------ // La distance est mesuree sur la position NON MORPHEE : c'est ce qui garantit // qu'un sommet partage par deux tuiles voisines obtient le meme facteur des @@ -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/main.cpp b/src/main.cpp index c83245f..300a926 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -144,6 +144,9 @@ namespace { // 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) // // Le terrain synthetique n'est PAS supprime, et pour deux raisons distinctes : // il reste la scene de reference des tests (monde deterministe, arbres a @@ -895,6 +898,9 @@ int main(int argc, char** argv) { // optimisation ne change pas l'image. float quitAfterSeconds = 0.0f; bool freezeAnimation = false; + // PHASE 30 : --force-staging televerse la geometrie par staging meme en + // memoire unifiee (le chemin d'un GPU discret), pour l'eprouver ici. + bool forceStaging = false; for (int i = 1; i < argc; ++i) { const std::string argument = argv[i]; if (argument == "--dump-world") { @@ -1065,6 +1071,8 @@ int main(int argc, char** argv) { } } else if (argument == "--freeze-anim") { freezeAnimation = true; + } else if (argument == "--force-staging") { + forceStaging = true; } else if (argument.rfind("--", 0) == 0) { logWarn("Option inconnue, ignoree : " + argument); } else if (sceneArgument.empty()) { @@ -1199,7 +1207,10 @@ int main(int argc, char** argv) { CompositeCollisionSolver worldSolver; MeshData sceneMesh; + // PHASE 30 : le terrain d'un seul bloc (--no-lod) au format GPU compact. + TerrainGpuMesh sceneTerrain; RenderOptions renderOptions; + renderOptions.forceStaging = forceStaging; Inventory inventory; @@ -1219,7 +1230,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 30 : 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() }; @@ -1301,8 +1315,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 30 : 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 @@ -3564,9 +3589,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 30 : + // 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()) { diff --git a/src/renderer/DrawItem.hpp b/src/renderer/DrawItem.hpp index cda27a3..453ffbd 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 30, 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 30 (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..93454cf --- /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 de geometrie dans %u bloc(s) de %.1f Mo au total%s", + static_cast(usedBytes_) / (1024.0 * 1024.0), blockCount(), + static_cast(capacityBytes_) / (1024.0 * 1024.0), + mapped_ ? ", ecriture directe (memoire unifiee)" : ", par staging"); + return text; +} + +} // namespace vercora diff --git a/src/renderer/GpuBufferPool.hpp b/src/renderer/GpuBufferPool.hpp new file mode 100644 index 0000000..6d9982d --- /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 30. 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 30. 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-PHASE30.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..838b64b --- /dev/null +++ b/src/renderer/GpuVertex.hpp @@ -0,0 +1,118 @@ +#pragma once + +#include "renderer/Vertex.hpp" + +#include + +#include +#include +#include + +namespace vercora { + +// PHASE 30. 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..26aa707 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 30. 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 30 : 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..da52769 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 30, 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 30 : 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..10d0d45 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 30 : 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 30 : 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-PHASE30.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-PHASE30.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..69afaec --- /dev/null +++ b/src/renderer/RangeAllocator.hpp @@ -0,0 +1,117 @@ +#pragma once + +#include +#include +#include + +namespace vercora { + +// PHASE 30. 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..ce7a9c4 100644 --- a/src/renderer/Renderer.cpp +++ b/src/renderer/Renderer.cpp @@ -18,6 +18,7 @@ #include #include +#include #include #include @@ -25,6 +26,26 @@ namespace vercora { namespace { +// PHASE 30 : 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"). @@ -44,6 +65,23 @@ Renderer::Renderer(VulkanContext& context, Window& window, : context_(context), window_(window), options_(options) { swapChain_ = std::make_unique(context_, window_); + // PHASE 30 : 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) createDescriptorSetLayout(); @@ -88,6 +126,15 @@ Renderer::Renderer(VulkanContext& context, Window& window, Renderer::~Renderer() { VkDevice device = context_.device(); + // PHASE 30 : 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 +163,236 @@ 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 30 : 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)); + + const GpuRange vertexRange = geometryPool_->allocate(vertexBytes); + GpuRange indexRange; + try { + indexRange = geometryPool_->allocate(indexBytes); + } catch (...) { + geometryPool_->release(vertexRange); + throw; + } + + RangeWrite vertexWrite = beginRangeWrite(vertexRange); + auto* vertices = static_cast(vertexWrite.destination); + for (uint32_t v = 0; v < vertexCount; ++v) { + vertices[v] = toObjectVertex(meshData.vertices[v]); + } + finishRangeWrite(vertexWrite); + + RangeWrite indexWrite = beginRangeWrite(indexRange); + 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(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::make_unique( + *geometryPool_, VertexLayout::Object, vertexRange, vertexCount, indexRange, + shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32, 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); + const GpuRange vertexRange = geometryPool_->allocate(vertexBytes); + GpuRange indexRange; + try { + indexRange = geometryPool_->allocate(indexBytes); + } catch (...) { + geometryPool_->release(vertexRange); + throw; + } + RangeWrite vertexWrite = beginRangeWrite(vertexRange); + std::memcpy(vertexWrite.destination, vertices.data(), static_cast(vertexBytes)); + finishRangeWrite(vertexWrite); + RangeWrite indexWrite = beginRangeWrite(indexRange); + std::memcpy(indexWrite.destination, indices.data(), static_cast(indexBytes)); + 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::make_unique( + *geometryPool_, VertexLayout::Terrain, vertexRange, vertexCount, indexRange, + VK_INDEX_TYPE_UINT32, static_cast(indices.size()), true)); +} + +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 = beginRangeWrite(shared.range); + 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]; + const GpuRange range = geometryPool_->allocate( + static_cast(vertexCount) * sizeof(TerrainVertex)); + RangeWrite write = beginRangeWrite(range); + + TerrainMeshWrite result; + result.vertices = static_cast(write.destination); + result.mesh = registerMesh(std::make_unique( + *geometryPool_, VertexLayout::Terrain, range, vertexCount, shared.range, + shared.type, shared.count, false)); + 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 30 : 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_; @@ -441,6 +692,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 +776,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 +819,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 +859,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 +952,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 30 : 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-PHASE30.md). Gain : -26 % + // de temps de rendu en foret (lavapipe). + static constexpr std::array kDrawOrder{ + Material::Object, Material::Foliage, Material::Terrain }; + + // PHASE 30 : 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 30 : 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 +1014,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 +1031,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 +1054,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 +1074,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..4e65c54 100644 --- a/src/renderer/Renderer.hpp +++ b/src/renderer/Renderer.hpp @@ -1,6 +1,8 @@ #pragma once #include "renderer/DrawItem.hpp" +#include "renderer/GpuBufferPool.hpp" +#include "renderer/GpuVertex.hpp" #include "renderer/Pipeline.hpp" // pour ShaderSet #include "renderer/VulkanBuffer.hpp" // pour BufferUploader @@ -11,6 +13,8 @@ #include #include #include +#include +#include #include namespace vercora { @@ -49,6 +53,12 @@ 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 30. 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; }; // Orchestre le rendu : geometries enregistrees, UBO/descriptors, command @@ -85,6 +95,48 @@ public: // toute autre information. MeshHandle addMesh(const MeshData& meshData, bool log = true); + // PHASE 30 : 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 30 : 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 30 : 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 @@ -233,7 +285,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 +318,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 30, voir setTerrainGrid() static constexpr int kMaxFramesInFlight = 2; @@ -306,12 +359,45 @@ private: void uploadInstances(const std::vector& instanced); void recreateSwapChain(); + // PHASE 30. 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); + VulkanContext& context_; Window& window_; RenderOptions options_; std::unique_ptr swapChain_; + // PHASE 30 : 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 +434,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/TerrainMesh.cpp b/src/renderer/TerrainMesh.cpp index 9fc398c..00c87d1 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 30 : 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 30, 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..bbd52c8 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 30. 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..dc8475e 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 30 : 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,97 @@ 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; } +void writeTerrainNodeVertices(const Heightmap& heightmap, const TerrainQuadtree& quadtree, + uint32_t nodeIndex, TerrainVertex* out, + bool reuseParentGrid) { + 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..fa44c8f 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,23 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& // diagonale que TerrainMesh. Calculee une fois par appelant et reutilisee. std::vector terrainNodeIndices(uint32_t nodeCells); +// PHASE 30. 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); + } // namespace vercora diff --git a/src/renderer/TerrainStreamer.cpp b/src/renderer/TerrainStreamer.cpp index fa8384c..539b909 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 30 : 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 30 : 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 30 : 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 30 : 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 c4e6cd6..929708c 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 30 : +// 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 30 (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 : @@ -245,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 30 : 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 30. 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 30 : 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 @@ -341,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 30 : 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 30 : 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/UniformBufferObject.hpp b/src/renderer/UniformBufferObject.hpp index 9f129bf..76a1dde 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 30. 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..3a32c80 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 30 : 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.hpp b/src/renderer/VulkanBuffer.hpp index 0da2b27..f283dcb 100644 --- a/src/renderer/VulkanBuffer.hpp +++ b/src/renderer/VulkanBuffer.hpp @@ -33,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 30 : 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, diff --git a/src/renderer/VulkanContext.cpp b/src/renderer/VulkanContext.cpp index fde4b3b..248a4f5 100644 --- a/src/renderer/VulkanContext.cpp +++ b/src/renderer/VulkanContext.cpp @@ -235,6 +235,7 @@ void VulkanContext::pickPhysicalDevice() { VkPhysicalDeviceProperties props{}; vkGetPhysicalDeviceProperties(physicalDevice_, &props); logInfo(std::string("GPU selectionne : ") + props.deviceName); + deviceType_ = props.deviceType; // PHASE 30 : proprietes memoire lues UNE fois (voir findMemoryType), et // detection de la memoire unifiee. diff --git a/src/renderer/VulkanContext.hpp b/src/renderer/VulkanContext.hpp index 4a71e83..6ed7bef 100644 --- a/src/renderer/VulkanContext.hpp +++ b/src/renderer/VulkanContext.hpp @@ -133,6 +133,17 @@ public: // Faux sur un GPU discret classique (hors BAR redimensionnable). bool unifiedMemory() const { return unifiedMemory_; } + // PHASE 30. 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(); @@ -160,6 +171,7 @@ private: 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). diff --git a/tests/logic_tests.cpp b/tests/logic_tests.cpp index 96f53e2..0fcc4c2 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" @@ -10098,6 +10100,210 @@ void testBushPlacement() { } } +// --------------------------------------------------------------------------- +// PHASE 30 : 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 testGpuFormatsPhase30() { + section("Phase 30 : formats GPU compacts et pool de geometrie"); + + check(sizeof(ObjectVertex) == 44 && sizeof(TerrainVertex) == 16 && + sizeof(DrawItemPush) == 96, + "Phase 30 : 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; + TerrainQuadtree::Params qparams; + qparams.nodeCells = 64; + + bool identical = true; + bool positionsExact = true; + bool uvExact = true; + uint32_t nodesChecked = 0; + for (const Heightmap::Params& hp : { even, odd }) { + 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) { + 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 > 80, "Tuiles : toutes les tuiles des deux grilles verifiees"); + 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"); @@ -10118,6 +10324,7 @@ int main() { testGrassMesh(); testGrassPhase18(); testTileMeshingIsThreadSafe(); + testGpuFormatsPhase30(); testVegetationPlacement(); testGrassPlacement(); testInstanceLayout(); From 14cf563604c678e93825fffd0f8c052b3d60825b Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 13 Oct 2026 23:19:04 +0000 Subject: [PATCH 3/7] Phase 30 (3/n) : orthophoto lue par tranches directement dans le staging - TextureFile : loadTextureFileHeader (memes controles, aucun texel) et readTexturePayload (complete ou par tranche, flux deja ouvert) ; loadTextureFile reste la composition des deux. - Texture : les texels sont ecrits dans le staging par une source, et le staging (4 Mo au plus) est REUTILISE par bandes de rangees de blocs au lieu de couvrir toute la chaine de mipmaps. - Renderer::setTerrainTextureFromFile : l'orthophoto n'est plus jamais tenue en RAM a cote du staging et de l'image. Mesure (lavapipe) : pic RAM au chargement 302 -> 234 Mo, pic GPU au chargement 89 -> 50,5 Mo (le pic GPU de la partie en foret devient le regime etabli), chargement 0,49 -> 0,34 s, image identique au bit pres. Tests : +3 verifications (lectures entiere / par tranches). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2 --- src/assets/TextureFile.cpp | 38 ++++++-- src/assets/TextureFile.hpp | 21 +++++ src/main.cpp | 7 +- src/renderer/Renderer.cpp | 22 +++++ src/renderer/Renderer.hpp | 6 ++ src/renderer/Texture.cpp | 186 +++++++++++++++++++++++++------------ src/renderer/Texture.hpp | 16 +++- tests/logic_tests.cpp | 56 +++++++++++ 8 files changed, 281 insertions(+), 71 deletions(-) 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..3f0fac7 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 30. 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 30. 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/main.cpp b/src/main.cpp index 300a926..dfbc034 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1351,9 +1351,12 @@ int main(int argc, char** argv) { " -i data/ortho -o " + orthoPath); } else { try { - const TextureData ortho = loadTextureFile(orthoPath); + // PHASE 30 : 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(); logInfo("Orthophoto : " + diff --git a/src/renderer/Renderer.cpp b/src/renderer/Renderer.cpp index ce7a9c4..dd1a4ac 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" @@ -20,6 +21,7 @@ #include #include #include +#include #include namespace vercora { @@ -609,6 +611,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); } diff --git a/src/renderer/Renderer.hpp b/src/renderer/Renderer.hpp index 4e65c54..799691f 100644 --- a/src/renderer/Renderer.hpp +++ b/src/renderer/Renderer.hpp @@ -163,6 +163,12 @@ public: // coloration procedurale est visible. void setTerrainTexture(const TextureData& data); + // PHASE 30. 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); diff --git a/src/renderer/Texture.cpp b/src/renderer/Texture.cpp index 6acf046..700d9a7 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); } @@ -144,18 +155,59 @@ void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels, } 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 30 : 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; @@ -166,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 c609500..56a7e1d 100644 --- a/src/renderer/Texture.hpp +++ b/src/renderer/Texture.hpp @@ -9,6 +9,7 @@ #include #include +#include namespace vercora { @@ -44,6 +45,19 @@ public: // l'orthophoto - voir createSampler. Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue, const TextureData& data, bool repeat = false); + + // PHASE 30. 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 30. 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; @@ -69,7 +83,7 @@ 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); diff --git a/tests/logic_tests.cpp b/tests/logic_tests.cpp index 0fcc4c2..55dfd49 100644 --- a/tests/logic_tests.cpp +++ b/tests/logic_tests.cpp @@ -3199,6 +3199,62 @@ void testTextureFile() { threw = true; } check(threw, "Refus : fichier .vcto absent"); + + // --- PHASE 30 : 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_phase30_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 30 : loadTextureFile rend la charge utile complete"); + check(headerOnly.pixels.empty() && headerOnly.payloadSize() == payload.size() && + headerOnly.mips.size() == full.mips.size(), + "Phase 30 : 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 30 : lecture directe et lecture par tranches = memes octets"); + std::filesystem::remove(path); + } } void testGrassMesh() { From 6b87698133d3812dafb4f489676810989ab4e641 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 13 Oct 2026 23:23:38 +0000 Subject: [PATCH 4/7] Phase 30 (4/n) : construction des tuiles interieures sans relecture Les voisins d'un sommet, au pas du noeud, sont les sommets voisins de la tuile ; ceux du parent, au pas double, les sommets a deux rangs. Loin du bord (aucun indice ecrete), writeTerrainNodeVertices lit donc les altitudes UNE fois dans une grille bordee de deux rangs au lieu de cinq lectures ecretees par echantillon, puis applique exactement les memes operations flottantes que sampleGrid. Les tuiles de bord et le temoin --no-tile-cache gardent le chemin de reference. Tests : resultat identique au bit pres sur toutes les tuiles de trois grilles, chemin rapide exerce aux pas 1, 2, 4 et 8. Survol (lavapipe, Release) : geometrie d'une tuile ~190 -> ~104 us, streaming terrain 1,3-1,6 -> 0,9 ms par image. Image identique. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2 --- src/assets/Heightmap.hpp | 6 ++ src/renderer/TerrainNodeMesh.cpp | 112 +++++++++++++++++++++++++++++++ src/renderer/TerrainNodeMesh.hpp | 8 +++ tests/logic_tests.cpp | 19 +++++- 4 files changed, 143 insertions(+), 2 deletions(-) diff --git a/src/assets/Heightmap.hpp b/src/assets/Heightmap.hpp index b5cbed6..e777415 100644 --- a/src/assets/Heightmap.hpp +++ b/src/assets/Heightmap.hpp @@ -161,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 30. 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/renderer/TerrainNodeMesh.cpp b/src/renderer/TerrainNodeMesh.cpp index dc8475e..686eafc 100644 --- a/src/renderer/TerrainNodeMesh.cpp +++ b/src/renderer/TerrainNodeMesh.cpp @@ -227,9 +227,121 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& 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 30 : 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*/, diff --git a/src/renderer/TerrainNodeMesh.hpp b/src/renderer/TerrainNodeMesh.hpp index fa44c8f..a7e5dde 100644 --- a/src/renderer/TerrainNodeMesh.hpp +++ b/src/renderer/TerrainNodeMesh.hpp @@ -83,4 +83,12 @@ void writeTerrainNodeVertices(const Heightmap& heightmap, const TerrainQuadtree& uint32_t nodeIndex, TerrainVertex* out, bool reuseParentGrid = true); +// PHASE 30. 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/tests/logic_tests.cpp b/tests/logic_tests.cpp index 55dfd49..3b295d5 100644 --- a/tests/logic_tests.cpp +++ b/tests/logic_tests.cpp @@ -10235,6 +10235,13 @@ void testGpuFormatsPhase30() { 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; @@ -10242,7 +10249,9 @@ void testGpuFormatsPhase30() { bool positionsExact = true; bool uvExact = true; uint32_t nodesChecked = 0; - for (const Heightmap::Params& hp : { even, odd }) { + 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; @@ -10250,6 +10259,10 @@ void testGpuFormatsPhase30() { 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); @@ -10283,7 +10296,9 @@ void testGpuFormatsPhase30() { ++nodesChecked; } } - check(nodesChecked > 80, "Tuiles : toutes les tuiles des deux grilles verifiees"); + 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, From 29e9a09199c4af378c7d49dfe5fc5db8b5979139 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 13 Oct 2026 23:26:10 +0000 Subject: [PATCH 5/7] Phase 30 (5/n) : option --vsync (presentation FIFO) Le plus gros levier de consommation du jeu : en mode non plafonne (IMMEDIATE, le defaut des mesures), le GPU tourne a 100 % pour produire des images qu'un ecran a 60 Hz n'affichera pas. --vsync choisit FIFO, le seul mode garanti par Vulkan ; CPU et GPU attendent l'ecran. Desactive par defaut pour ne pas changer les mesures d'images/s du projet. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2 --- src/main.cpp | 11 +++++++++++ src/renderer/Renderer.cpp | 2 +- src/renderer/Renderer.hpp | 5 +++++ src/renderer/SwapChain.cpp | 14 ++++++++++++-- src/renderer/SwapChain.hpp | 5 ++++- 5 files changed, 33 insertions(+), 4 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index dfbc034..6c20737 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -147,6 +147,10 @@ namespace { // 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 @@ -901,6 +905,10 @@ int main(int argc, char** argv) { // PHASE 30 : --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 30 : --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") { @@ -1073,6 +1081,8 @@ int main(int argc, char** argv) { 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()) { @@ -1211,6 +1221,7 @@ int main(int argc, char** argv) { TerrainGpuMesh sceneTerrain; RenderOptions renderOptions; renderOptions.forceStaging = forceStaging; + renderOptions.vsync = vsync; Inventory inventory; diff --git a/src/renderer/Renderer.cpp b/src/renderer/Renderer.cpp index dd1a4ac..5730209 100644 --- a/src/renderer/Renderer.cpp +++ b/src/renderer/Renderer.cpp @@ -65,7 +65,7 @@ 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 30 : le pool de geometrie. En memoire unifiee (GPU integre, // lavapipe), ses blocs sont mappes et la geometrie y est ecrite DIRECTEMENT diff --git a/src/renderer/Renderer.hpp b/src/renderer/Renderer.hpp index 799691f..7825922 100644 --- a/src/renderer/Renderer.hpp +++ b/src/renderer/Renderer.hpp @@ -59,6 +59,11 @@ struct RenderOptions { // lit. Sert a eprouver sur la machine de developpement le chemin d'un GPU // discret (option --force-staging). bool forceStaging = false; + + // PHASE 30. 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 diff --git a/src/renderer/SwapChain.cpp b/src/renderer/SwapChain.cpp index 0844370..f3407e1 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(); @@ -110,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 30 : 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()) { diff --git a/src/renderer/SwapChain.hpp b/src/renderer/SwapChain.hpp index 17841f7..be5b125 100644 --- a/src/renderer/SwapChain.hpp +++ b/src/renderer/SwapChain.hpp @@ -17,7 +17,9 @@ class Window; // pas), ce qui evite d'invalider le pipeline graphique. class SwapChain { public: - SwapChain(VulkanContext& context, Window& window); + // `vsync` (PHASE 30) : 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; @@ -61,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_; From f15fb63b7d69656466fcd46e0972eb8c7c3a7e24 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 13 Oct 2026 23:44:17 +0000 Subject: [PATCH 6/7] Phase 30 (6/n) : bilan, robustesse des televersements, notes - Renderer : un maillage possede ses plages des leur reservation (allocateMesh) et ses copies ne sont confiees a l'image suivante qu'une fois toutes ses ecritures reussies - plus de plage perdue ni de copie visant une plage rendue si la memoire vient a manquer. - Ligne "Ressources (PHASE 30)" : bilan du pool de geometrie. - main.cpp : le C4244 connu de la Phase 27 rendu explicite. - NOTES-PHASE30.md : execution, bilan chiffre avant/apres sur les trois scenarios, verification (images, validation standard et de synchronisation, controle negatif), limites, reproduction. - MEMORY.md : section Phase 30. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2 --- MEMORY.md | 39 ++++++++ NOTES-PHASE30.md | 157 +++++++++++++++++++++++++++++++++ src/main.cpp | 6 +- src/renderer/GpuBufferPool.cpp | 8 +- src/renderer/Renderer.cpp | 84 ++++++++++-------- src/renderer/Renderer.hpp | 8 +- 6 files changed, 258 insertions(+), 44 deletions(-) diff --git a/MEMORY.md b/MEMORY.md index e221516..c3ba245 100644 --- a/MEMORY.md +++ b/MEMORY.md @@ -2650,3 +2650,42 @@ Tests **3807/3807** (3636 avant), 0 `[Validation]` au demarrage. - Relecture : seuls main.cpp et foliage.vert modifies ; Forest/Vegetation/faune/ artisanat/collision/activites identiques octet pour octet ; chemin w >= 0 du shader inchange. - Outil : `build-release\` existe desormais (profil Release hors du `build\` Debug). + +## PHASE 30 (2026-10-13) - optimisation des ressources (detail : NOTES-PHASE30.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 30)` 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-PHASE30.md b/NOTES-PHASE30.md index d72ad8d..b32ecdf 100644 --- a/NOTES-PHASE30.md +++ b/NOTES-PHASE30.md @@ -153,3 +153,160 @@ NON RETENU, et pourquoi : 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 30)` 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 30)` 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/src/main.cpp b/src/main.cpp index 6c20737..cc7e8e4 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1369,7 +1369,7 @@ int main(int argc, char** argv) { if (orthoMatchesTerrain(ortho, *heightmap)) { 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 " + @@ -2383,7 +2383,7 @@ int main(int argc, char** argv) { if (loopSeconds - lastResourceLog >= 10.0) { lastResourceLog = loopSeconds; logInfo("Ressources (PHASE 30) : " + processMemoryLine() + ", " + - context.gpuMemoryLine() + "."); + context.gpuMemoryLine() + ". " + renderer.geometryLine() + "."); } const double now = glfwGetTime(); @@ -4023,7 +4023,7 @@ int main(int argc, char** argv) { // "vivants" sont donc ceux du jeu en regime etabli, les pics ceux de la // session entiere. logInfo("Ressources en fin de partie (PHASE 30) : " + processMemoryLine() + ", " + - context.gpuMemoryLine() + "."); + context.gpuMemoryLine() + ". " + renderer.geometryLine() + "."); if (frameProfile.frames > 0) { const auto per = [&](uint64_t total) { diff --git a/src/renderer/GpuBufferPool.cpp b/src/renderer/GpuBufferPool.cpp index 93454cf..eb29c36 100644 --- a/src/renderer/GpuBufferPool.cpp +++ b/src/renderer/GpuBufferPool.cpp @@ -168,10 +168,10 @@ uint32_t GpuBufferPool::blockCount() const { std::string GpuBufferPool::statsLine() const { char text[160]; std::snprintf(text, sizeof(text), - "%.1f Mo de geometrie dans %u bloc(s) de %.1f Mo au total%s", - static_cast(usedBytes_) / (1024.0 * 1024.0), blockCount(), - static_cast(capacityBytes_) / (1024.0 * 1024.0), - mapped_ ? ", ecriture directe (memoire unifiee)" : ", par staging"); + "%.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; } diff --git a/src/renderer/Renderer.cpp b/src/renderer/Renderer.cpp index 5730209..b650f51 100644 --- a/src/renderer/Renderer.cpp +++ b/src/renderer/Renderer.cpp @@ -241,23 +241,20 @@ MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) { const VkDeviceSize indexBytes = static_cast(indexCount) * (shortIndices ? sizeof(uint16_t) : sizeof(uint32_t)); - const GpuRange vertexRange = geometryPool_->allocate(vertexBytes); - GpuRange indexRange; - try { - indexRange = geometryPool_->allocate(indexBytes); - } catch (...) { - geometryPool_->release(vertexRange); - throw; - } + // 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()); - RangeWrite vertexWrite = beginRangeWrite(vertexRange); auto* vertices = static_cast(vertexWrite.destination); for (uint32_t v = 0; v < vertexCount; ++v) { vertices[v] = toObjectVertex(meshData.vertices[v]); } - finishRangeWrite(vertexWrite); - - RangeWrite indexWrite = beginRangeWrite(indexRange); if (shortIndices) { auto* indices = static_cast(indexWrite.destination); for (uint32_t k = 0; k < indexCount; ++k) { @@ -267,6 +264,7 @@ MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) { std::memcpy(indexWrite.destination, meshData.indices.data(), static_cast(indexBytes)); } + finishRangeWrite(vertexWrite); finishRangeWrite(indexWrite); if (log) { @@ -275,9 +273,22 @@ MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) { std::to_string(indexCount / 3) + " triangles, " + std::to_string((vertexBytes + indexBytes + 1023) / 1024) + " Ko."); } - return registerMesh(std::make_unique( - *geometryPool_, VertexLayout::Object, vertexRange, vertexCount, indexRange, - shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32, indexCount, true)); + 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, @@ -296,19 +307,14 @@ MeshHandle Renderer::addTerrainMesh(const std::vector& vertices, } const VkDeviceSize vertexBytes = static_cast(vertexCount) * sizeof(TerrainVertex); const VkDeviceSize indexBytes = static_cast(indices.size()) * sizeof(uint32_t); - const GpuRange vertexRange = geometryPool_->allocate(vertexBytes); - GpuRange indexRange; - try { - indexRange = geometryPool_->allocate(indexBytes); - } catch (...) { - geometryPool_->release(vertexRange); - throw; - } - RangeWrite vertexWrite = beginRangeWrite(vertexRange); + // 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)); - finishRangeWrite(vertexWrite); - RangeWrite indexWrite = beginRangeWrite(indexRange); std::memcpy(indexWrite.destination, indices.data(), static_cast(indexBytes)); + finishRangeWrite(vertexWrite); finishRangeWrite(indexWrite); if (log) { @@ -316,9 +322,7 @@ MeshHandle Renderer::addTerrainMesh(const std::vector& vertices, " sommets, " + std::to_string(indices.size() / 3) + " triangles, " + std::to_string((vertexBytes + indexBytes) / (1024 * 1024)) + " Mo."); } - return registerMesh(std::make_unique( - *geometryPool_, VertexLayout::Terrain, vertexRange, vertexCount, indexRange, - VK_INDEX_TYPE_UINT32, static_cast(indices.size()), true)); + return registerMesh(std::move(mesh)); } uint32_t Renderer::addSharedIndices(const std::vector& indices) { @@ -332,7 +336,13 @@ uint32_t Renderer::addSharedIndices(const std::vector& indices) { 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 = beginRangeWrite(shared.range); + 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) { @@ -352,15 +362,17 @@ Renderer::TerrainMeshWrite Renderer::beginTerrainMesh(uint32_t vertexCount, throw std::runtime_error("Tuile de terrain : topologie partagee inconnue."); } const SharedIndices& shared = sharedIndices_[sharedIndices]; - const GpuRange range = geometryPool_->allocate( - static_cast(vertexCount) * sizeof(TerrainVertex)); - RangeWrite write = beginRangeWrite(range); + // 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::make_unique( - *geometryPool_, VertexLayout::Terrain, range, vertexCount, shared.range, - shared.type, shared.count, false)); + result.mesh = registerMesh(std::move(mesh)); if (write.staging) { pendingTerrainWrites_.emplace(result.mesh, std::move(write)); } diff --git a/src/renderer/Renderer.hpp b/src/renderer/Renderer.hpp index 7825922..b1ed60e 100644 --- a/src/renderer/Renderer.hpp +++ b/src/renderer/Renderer.hpp @@ -3,6 +3,7 @@ #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 @@ -23,7 +24,6 @@ class VulkanContext; class Window; class SwapChain; class Camera; -class Mesh; class Texture; struct MeshData; struct TextureData; @@ -385,6 +385,12 @@ private: // 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_; From b2410c365eff009b1b8d716da3a2c74c8218f776 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 14 Oct 2026 19:34:37 +0000 Subject: [PATCH 7/7] Documentation : README, etat de MEMORY.md, suite de l'audit - README.md (nouveau) : demarrage rapide - build Windows et Linux, donnees, lancement et options, tests, arborescence. - MEMORY.md : index des notes jusqu'a la Phase 30, bloc "Etat verifie" a jour (builds, tests, ressources journalisees, formats GPU, options, validation de synchronisation, mesure sans GPU), prochaines etapes 0bis et 4 mises a jour. - NOTES-AUDIT-GLOBAL.md : suite donnee par la Phase 30. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2 --- MEMORY.md | 43 +++++++++++++++++++-- NOTES-AUDIT-GLOBAL.md | 14 +++++++ README.md | 88 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 142 insertions(+), 3 deletions(-) create mode 100644 README.md diff --git a/MEMORY.md b/MEMORY.md index c3ba245..5ef4df4 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-PHASE30.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-14, fin de Phase 30) + +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 30 : `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 30 (formats GPU, allocateur, orthophoto par tranches). +- **Ressources** : chaque partie journalise `Ressources (PHASE 30)` 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-PHASE30.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 30 : 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 30** + (topologie uint16 unique, TerrainVertex de 16 o). Suite possible : tirer + les altitudes d'un SSBO (16 -> ~4,5 o/sommet), voir NOTES-PHASE30.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. diff --git a/NOTES-AUDIT-GLOBAL.md b/NOTES-AUDIT-GLOBAL.md index 19837a0..5a944fd 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 30, 2026-10-13) + +L'optimisation des ressources de `NOTES-PHASE30.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/README.md b/README.md new file mode 100644 index 0000000..7de579b --- /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-PHASE30.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 30)` : 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-PHASE30.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