From 16775bf1ff2060a587889c5fe9375390574ca141 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 13 Oct 2026 22:39:35 +0000 Subject: [PATCH] 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())