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 <GL/gl.h> 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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
Cette révision appartient à :
Claude a révisé 2026-10-13 22:39:35 +00:00
1 Parent 84a72fe30c
révision 16775bf1ff
17 fichiers modifiés
+767 -59

Aucun fichier ne correspond à votre recherche

+6
Voir le fichier
@@ -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 <GL/gl.h>, qu'il inclut sinon par defaut. Le
# moteur ne fait aucun OpenGL ; sous Windows l'en-tete vient avec le SDK et le
# defaut passait inapercu, mais sous Linux il exige les en-tetes Mesa
# (libgl-dev) pour rien. Les deux macros se combinent (voir glfw3.h).
# VERCORA_DEBUG : active les validation layers uniquement en configuration Debug.
# GLM_FORCE_RADIANS : GLM travaille en radians (evite les surprises d'unites).
# GLM_FORCE_DEPTH_ZERO_TO_ONE : Vulkan attend une profondeur clip dans [0,1]
# (et non [-1,1] comme OpenGL) -> indispensable pour un depth buffer correct.
target_compile_definitions(vercora PRIVATE
GLFW_INCLUDE_VULKAN
GLFW_INCLUDE_NONE
GLM_FORCE_RADIANS
GLM_FORCE_DEPTH_ZERO_TO_ONE
$<$<CONFIG:Debug>:VERCORA_DEBUG>
+155
Voir le fichier
@@ -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).
- `<GLFW/glfw3.h>` incluait `<GL/gl.h>` (present avec le SDK Windows, absent
sans libgl-dev sous Linux). `GLFW_INCLUDE_NONE` ajoute a cote de
`GLFW_INCLUDE_VULKAN`.
Le projet compile desormais sans avertissement nouveau avec GCC 13 (Release
et Debug), et les tests headless passent avec Clang 18.
- **Un GPU logiciel** : lavapipe (Mesa 25.2, Vulkan 1.4) sous Xvfb 1280x720.
Les couches de validation Khronos tournent dessus. Le rendu y est
DETERMINISTE : deux executions identiques donnent 0 pixel different, ce qui
permet de prouver au bit pres qu'une optimisation ne change pas l'image.
- **Une zone proxy a la vraie echelle** : `tools/make_bench_zone.py` ecrit un
relief fBm de 5001 x 5001 au pas de 1 m avec la georeference et la plage
d'altitudes de la vraie zone (l'orthophoto versionnee s'y applique), et des
cartes de couvert tirees de l'orthophoto elle-meme. Le quadtree (8 380
noeuds), le streaming, la vegetation et tous les budgets memoire y
travaillent a la vraie echelle. Le relief n'est pas le Vercors : les
chiffres sont comparables ENTRE EUX (avant/apres), pas a ceux de l'UHD 770.
Outillage ajoute au jeu pour ce banc (et utilisable sur la machine de dev) :
| ajout | role |
|---|---|
| `VulkanContext::allocateMemory / freeMemory` | TOUTE la memoire GPU passe par le contexte, qui la compte : octets vivants, pics, blocs vivants, appels `vkAllocateMemory` |
| `core/ProcessMemory` | RAM residente et pic du processus, lus au systeme (`/proc/self/status` sous Linux, `GetProcessMemoryInfo` sous Windows) |
| ligne `Ressources ... (PHASE 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.
+8 -1
Voir le fichier
@@ -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).
+65
Voir le fichier
@@ -0,0 +1,65 @@
#include "core/ProcessMemory.hpp"
#include <cstdio>
#if defined(_WIN32)
# ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
# endif
# ifndef NOMINMAX
# define NOMINMAX
# endif
# include <windows.h>
// Avec PSAPI_VERSION 2 (le defaut depuis Windows 7), GetProcessMemoryInfo est
// K32GetProcessMemoryInfo, exportee par kernel32 : aucune bibliotheque de plus
// a lier.
# include <psapi.h>
#elif defined(__linux__)
# include <fstream>
# include <sstream>
#endif
namespace vercora {
ProcessMemory processMemory() {
ProcessMemory memory;
#if defined(_WIN32)
PROCESS_MEMORY_COUNTERS counters{};
if (GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) {
memory.residentBytes = static_cast<uint64_t>(counters.WorkingSetSize);
memory.peakResidentBytes = static_cast<uint64_t>(counters.PeakWorkingSetSize);
memory.available = true;
}
#elif defined(__linux__)
// Lignes "VmRSS: 123456 kB" et "VmHWM: 234567 kB".
std::ifstream status("/proc/self/status");
std::string line;
while (std::getline(status, line)) {
const bool rss = line.rfind("VmRSS:", 0) == 0;
const bool hwm = line.rfind("VmHWM:", 0) == 0;
if (!rss && !hwm) {
continue;
}
std::istringstream fields(line.substr(6));
uint64_t kilobytes = 0;
fields >> kilobytes;
(rss ? memory.residentBytes : memory.peakResidentBytes) = kilobytes * 1024u;
memory.available = true;
}
#endif
return memory;
}
std::string processMemoryLine() {
const ProcessMemory memory = processMemory();
if (!memory.available) {
return "RAM non mesuree (plateforme non prise en charge)";
}
char text[96];
std::snprintf(text, sizeof(text), "RAM %.1f Mo (pic %.1f Mo)",
static_cast<double>(memory.residentBytes) / (1024.0 * 1024.0),
static_cast<double>(memory.peakResidentBytes) / (1024.0 * 1024.0));
return text;
}
} // namespace vercora
+31
Voir le fichier
@@ -0,0 +1,31 @@
#pragma once
#include <cstdint>
#include <string>
namespace vercora {
// PHASE 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
+70 -6
Voir le fichier
@@ -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<double>(ProfileClock::now() - loopStart).count();
if (quitAfterSeconds > 0.0f && loopSeconds >= quitAfterSeconds) {
logInfo("--quit-after : " + std::to_string(quitAfterSeconds) +
" s de boucle ecoulees, fermeture.");
break;
}
if (loopSeconds - lastResourceLog >= 10.0) {
lastResourceLog = loopSeconds;
logInfo("Ressources (PHASE 30) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ".");
}
const double now = glfwGetTime();
const float deltaTime = static_cast<float>(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<float>(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<uint32_t>(instances.size());
item.material = Material::Foliage;
// Amplitude d'ondulation NULLE : un tronc ne plie pas.
item.params = { 0.0f, elapsedSeconds, 0.0f, 0.0f };
item.params = { 0.0f, animationSeconds, 0.0f, 0.0f };
instancedItems.push_back(item);
};
pushTrees(treeInstances, sceneryTreeMeshHandle);
@@ -3703,7 +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<uint32_t>(instances.size());
item.material = Material::Foliage;
item.params = { 0.0f, elapsedSeconds, 0.0f, -1.0f };
item.params = { 0.0f, animationSeconds, 0.0f, -1.0f };
instancedItems.push_back(item);
};
pushRocks(boulderInstances, boulderMeshHandle);
@@ -3786,7 +3844,7 @@ int main(int argc, char** argv) {
item.instances = instances.data();
item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage;
item.params = { sway, elapsedSeconds, 0.0f, 0.0f };
item.params = { sway, animationSeconds, 0.0f, 0.0f };
instancedItems.push_back(item);
};
pushBushes(shrubInstances, shrubMeshHandle, 0.04f);
@@ -3846,7 +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<double>(total) /
+5 -14
Voir le fichier
@@ -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;
+3 -1
Voir le fichier
@@ -1,5 +1,7 @@
#pragma once
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h>
#include <vector>
@@ -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;
+5 -1
Voir le fichier
@@ -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;
+4 -13
Voir le fichier
@@ -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;
}
+2 -1
Voir le fichier
@@ -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 <vulkan/vulkan.h>
@@ -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;
+11 -15
Voir le fichier
@@ -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;
}
}
+3 -1
Voir le fichier
@@ -1,5 +1,7 @@
#pragma once
#include "renderer/VulkanContext.hpp" // GpuAllocation
#include <vulkan/vulkan.h>
#include <memory>
@@ -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;
};
+90 -5
Voir le fichier
@@ -3,6 +3,8 @@
#include "core/Logger.hpp"
#include "core/Window.hpp"
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <stdexcept>
@@ -233,6 +235,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<double>(bytes) / (1024.0 * 1024.0));
return std::string(text);
};
return "GPU " + mo(gpuMemory_.liveBytes) + " (pic " + mo(gpuMemory_.peakBytes) +
"), dont device-local " + mo(gpuMemory_.liveDeviceLocalBytes) + " (pic " +
mo(gpuMemory_.peakDeviceLocalBytes) + ") ; " +
std::to_string(gpuMemory_.liveAllocations) + " blocs vivants (pic " +
std::to_string(gpuMemory_.peakAllocations) + "), " +
std::to_string(gpuMemory_.allocateCalls) + " vkAllocateMemory au total";
}
VkFormat VulkanContext::findSupportedFormat(const std::vector<VkFormat>& candidates,
VkImageTiling tiling,
VkFormatFeatureFlags features) const {
+56
Voir le fichier
@@ -3,6 +3,7 @@
#include <vulkan/vulkan.h>
#include <optional>
#include <string>
#include <vector>
namespace vercora {
@@ -41,6 +42,32 @@ struct SwapChainSupportDetails {
std::vector<VkPresentModeKHR> presentModes;
};
// PHASE 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
+4 -1
Voir le fichier
@@ -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.
+249
Voir le fichier
@@ -0,0 +1,249 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
make_bench_zone.py — fabrique une zone PROXY de 25 km2 pour MESURER le moteur
sur une machine qui n'a pas les donnees LiDAR (session cloud, CI, nouveau poste).
PHASE 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="<f4")
n = grid.shape[0]
assert grid.shape == (n, n)
header = bytearray(120)
header[0:4] = b"VCHM"
struct.pack_into("<IIIf", header, 4, 1, n, n, spacing)
struct.pack_into("<dd", header, 24, ORIGIN_EAST, ORIGIN_NORTH)
struct.pack_into("<ffII", header, 40, float(grid.min()), float(grid.max()),
EPSG, 1 if absolute else 0)
raw = label.encode("ascii")[:64]
header[56:56 + len(raw)] = raw
with open(path, "wb") as f:
f.write(header)
f.write(grid.tobytes())
def smooth(t: np.ndarray) -> np.ndarray:
return t * t * (3.0 - 2.0 * t)
def value_noise(n: int, cells: int, rng: np.random.Generator) -> np.ndarray:
"""Bruit de valeur n x n a `cells` cellules par cote, interpolation
separable (d'abord le long de X pour chaque ligne du reseau, puis le long
de Z) : 3 operations par echantillon au lieu de 4 lectures + 3 lerps."""
lattice = rng.random((cells + 2, cells + 2), dtype=np.float32)
x = np.linspace(0.0, cells, n, dtype=np.float64)
i0 = np.minimum(np.floor(x).astype(np.int64), cells)
t = smooth((x - i0).astype(np.float32))
along_x = lattice[:, i0] * (1.0 - t) + lattice[:, i0 + 1] * t # (cells+2, n)
return along_x[i0, :] * (1.0 - t)[:, None] + along_x[i0 + 1, :] * t[:, None]
def fbm(n: int, base: int, octaves: int, ridged: bool, rng) -> np.ndarray:
total = np.zeros((n, n), dtype=np.float32)
norm = 0.0
amplitude = 1.0
cells = base
for _ in range(octaves):
octave = value_noise(n, cells, rng)
if ridged:
octave = 1.0 - np.abs(2.0 * octave - 1.0)
total += amplitude * octave
norm += amplitude
amplitude *= 0.5
cells *= 2
return total / norm
def make_relief(n: int) -> np.ndarray:
rng = np.random.default_rng(SEED)
soft = fbm(n, 3, 9, False, rng) ** 1.4
ridge = fbm(n, 3, 9, True, rng)
shaped = soft + (ridge * ridge - soft) * 0.6
# Barres rocheuses facon Vercors : une marche raide la ou un bruit tres
# large franchit un seuil. Sans elles le relief n'offrirait aucune paroi
# d'escalade (pente >= 0,84) ni de pierrier (0,60-0,84).
band = value_noise(n, 4, rng)
cliff = smooth(np.clip((band - 0.55) / 0.02, 0.0, 1.0))
shaped = shaped + 0.12 * cliff
lo, hi = float(shaped.min()), float(shaped.max())
return (ALT_MIN + (shaped - lo) / (hi - lo) * (ALT_MAX - ALT_MIN)).astype(np.float32)
def decode_bc1_level(path: str, level: int) -> np.ndarray:
"""Decode le niveau `level` d'un .vcto BC1 en RGB float [0,1]."""
with open(path, "rb") as f:
data = f.read()
if data[:4] != b"VCTO":
raise SystemExit(f"{path} n'est pas un .vcto")
width, height, mips, fmt = struct.unpack_from("<IIII", data, 8)
if fmt != 1:
raise SystemExit("orthophoto attendue en BC1")
offset = 128
for k in range(level):
w, h = max(1, width >> k), max(1, height >> k)
offset += ((w + 3) // 4) * ((h + 3) // 4) * 8
w, h = max(1, width >> level), max(1, height >> level)
bx, by = (w + 3) // 4, (h + 3) // 4
blocks = np.frombuffer(data, dtype="<u2", count=bx * by * 4, offset=offset)
blocks = blocks.reshape(by, bx, 4)
c0 = blocks[..., 0].astype(np.uint32)
c1 = blocks[..., 1].astype(np.uint32)
bits = blocks[..., 2].astype(np.uint32) | (blocks[..., 3].astype(np.uint32) << 16)
def rgb565(c):
r = ((c >> 11) & 31) / 31.0
g = ((c >> 5) & 63) / 63.0
b = (c & 31) / 31.0
return np.stack([r, g, b], axis=-1)
p0, p1 = rgb565(c0), rgb565(c1)
four = (c0 > c1)[..., None]
p2 = np.where(four, (2 * p0 + p1) / 3, (p0 + p1) / 2)
p3 = np.where(four, (p0 + 2 * p1) / 3, 0.0)
palette = np.stack([p0, p1, p2, p3], axis=2) # (by, bx, 4, 3)
out = np.zeros((by * 4, bx * 4, 3), dtype=np.float32)
for py in range(4):
for px in range(4):
idx = (bits >> (2 * (py * 4 + px))) & 3
texel = np.take_along_axis(palette, idx[..., None, None].repeat(3, -1),
axis=2)[:, :, 0, :]
out[py::4, px::4, :] = texel
return out[:h, :w]
def resample(image: np.ndarray, n: int) -> np.ndarray:
"""Echantillonne l'image (rangee du nord au sud) aux n x n points de grille
(coins compris), par moyenne d'une fenetre 3 x 3 autour du texel."""
h, w = image.shape[:2]
coords = np.linspace(0.0, 1.0, n)
ys = np.clip(np.round(coords * (h - 1)).astype(np.int64), 1, h - 2)
xs = np.clip(np.round(coords * (w - 1)).astype(np.int64), 1, w - 2)
acc = np.zeros((n, n) + image.shape[2:], dtype=np.float32)
for dy in (-1, 0, 1):
for dx in (-1, 0, 1):
acc += image[(ys + dy)[:, None], (xs + dx)[None, :]]
return acc / 9.0
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__.split("\n")[1])
parser.add_argument("--force", action="store_true",
help="ecraser des fichiers existants")
args = parser.parse_args()
names = {
"terrain": "vercora_zone_1m.vchm",
"cover": "vercora_zone_canopy.vchm",
"height": "vercora_zone_canopy_height.vchm",
"lowveg": "vercora_zone_canopy_lowveg.vchm",
"lowveg_height": "vercora_zone_canopy_lowveg_height.vchm",
}
paths = {k: os.path.join(TERRAIN_DIR, v) for k, v in names.items()}
existing = [p for p in paths.values() if os.path.exists(p)]
if existing and not args.force:
print("Refus : ces fichiers existent deja (vraies donnees ?) :")
for p in existing:
print(" " + p)
print("Relancer avec --force pour les ecraser.")
return 1
if not os.path.exists(ORTHO):
print(f"Orthophoto introuvable : {ORTHO}")
return 1
t0 = time.time()
relief = make_relief(5001)
write_vchm(paths["terrain"], relief, 1.0, "vercora_zone PROXY bench (relief fBm)", True)
print(f"terrain : {paths['terrain']} ({relief.min():.1f} .. {relief.max():.1f} m, "
f"{time.time() - t0:.1f} s)")
rgb = decode_bc1_level(ORTHO, 2) # 2048 x 2048, 2,44 m/texel
rgb5 = resample(rgb, 1001)
r, g, b = rgb5[..., 0], rgb5[..., 1], rgb5[..., 2]
lum = (r + g + b) / 3.0
exg = 2.0 * g - r - b
# Foret = sombre ET verte ; prairie = verte mais claire ; roche = grise.
green = np.clip(exg / 0.06, 0.0, 1.0)
dark = np.clip((0.45 - lum) / 0.18, 0.0, 1.0)
cover = np.clip(green * dark * 1.6, 0.0, 1.0).astype(np.float32)
rng = np.random.default_rng(SEED + 1)
tall = 14.0 + 16.0 * value_noise(1001, 40, rng)
canopy = np.where(cover > 0.15, tall * np.clip(cover * 1.5, 0.3, 1.0), 0.0)
shrub = np.clip(green * (1.0 - dark) * 0.35 + cover * (1.0 - cover) * 0.5, 0.0, 0.6)
lowveg = shrub.astype(np.float32)
lowveg_h = np.where(lowveg > 0.05, 0.6 + 3.6 * value_noise(1001, 60, rng), 0.0)
write_vchm(paths["cover"], cover, 5.0, "vercora_zone PROXY couvert (ortho)", False)
write_vchm(paths["height"], canopy.astype(np.float32), 5.0,
"vercora_zone PROXY canopee", False)
write_vchm(paths["lowveg"], lowveg, 5.0, "vercora_zone PROXY vegetation basse", False)
write_vchm(paths["lowveg_height"], lowveg_h.astype(np.float32), 5.0,
"vercora_zone PROXY h vegetation basse", False)
print(f"couvert : moyenne {cover.mean():.3f}, cellules > 0,5 : "
f"{(cover > 0.5).mean() * 100:.1f} % ; F3 moyenne {lowveg.mean():.3f}")
print(f"total {time.time() - t0:.1f} s")
return 0
if __name__ == "__main__":
sys.exit(main())