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 à :
17 fichiers modifiés
+767
-59
Aucun fichier ne correspond à votre recherche
@@ -75,6 +75,7 @@ add_executable(vercora
|
|||||||
src/core/Window.cpp
|
src/core/Window.cpp
|
||||||
src/core/Camera.cpp
|
src/core/Camera.cpp
|
||||||
src/core/Paths.cpp
|
src/core/Paths.cpp
|
||||||
|
src/core/ProcessMemory.cpp
|
||||||
src/assets/ObjLoader.cpp
|
src/assets/ObjLoader.cpp
|
||||||
src/assets/Heightmap.cpp
|
src/assets/Heightmap.cpp
|
||||||
src/assets/TerrainFile.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_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.
|
# VERCORA_DEBUG : active les validation layers uniquement en configuration Debug.
|
||||||
# GLM_FORCE_RADIANS : GLM travaille en radians (evite les surprises d'unites).
|
# 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]
|
# 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.
|
# (et non [-1,1] comme OpenGL) -> indispensable pour un depth buffer correct.
|
||||||
target_compile_definitions(vercora PRIVATE
|
target_compile_definitions(vercora PRIVATE
|
||||||
GLFW_INCLUDE_VULKAN
|
GLFW_INCLUDE_VULKAN
|
||||||
|
GLFW_INCLUDE_NONE
|
||||||
GLM_FORCE_RADIANS
|
GLM_FORCE_RADIANS
|
||||||
GLM_FORCE_DEPTH_ZERO_TO_ONE
|
GLM_FORCE_DEPTH_ZERO_TO_ONE
|
||||||
$<$<CONFIG:Debug>:VERCORA_DEBUG>
|
$<$<CONFIG:Debug>:VERCORA_DEBUG>
|
||||||
|
|||||||
@@ -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.
|
||||||
@@ -95,7 +95,14 @@ public:
|
|||||||
// Genere immediatement la grille par bruit fractal. Lance
|
// Genere immediatement la grille par bruit fractal. Lance
|
||||||
// std::runtime_error si les parametres ne peuvent pas produire une surface
|
// std::runtime_error si les parametres ne peuvent pas produire une surface
|
||||||
// (resolution < 2, taille <= 0, ...).
|
// (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
|
// Adopte une grille DEJA CONSTRUITE, sans rien generer : c'est par ici
|
||||||
// qu'entrent les donnees LiDAR (voir assets/TerrainFile.hpp).
|
// qu'entrent les donnees LiDAR (voir assets/TerrainFile.hpp).
|
||||||
|
|||||||
@@ -0,0 +1,65 @@
|
|||||||
|
#include "core/ProcessMemory.hpp"
|
||||||
|
|
||||||
|
#include <cstdio>
|
||||||
|
|
||||||
|
#if defined(_WIN32)
|
||||||
|
# ifndef WIN32_LEAN_AND_MEAN
|
||||||
|
# define WIN32_LEAN_AND_MEAN
|
||||||
|
# endif
|
||||||
|
# ifndef NOMINMAX
|
||||||
|
# define NOMINMAX
|
||||||
|
# endif
|
||||||
|
# include <windows.h>
|
||||||
|
// Avec PSAPI_VERSION 2 (le defaut depuis Windows 7), GetProcessMemoryInfo est
|
||||||
|
// K32GetProcessMemoryInfo, exportee par kernel32 : aucune bibliotheque de plus
|
||||||
|
// a lier.
|
||||||
|
# include <psapi.h>
|
||||||
|
#elif defined(__linux__)
|
||||||
|
# include <fstream>
|
||||||
|
# include <sstream>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace vercora {
|
||||||
|
|
||||||
|
ProcessMemory processMemory() {
|
||||||
|
ProcessMemory memory;
|
||||||
|
#if defined(_WIN32)
|
||||||
|
PROCESS_MEMORY_COUNTERS counters{};
|
||||||
|
if (GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) {
|
||||||
|
memory.residentBytes = static_cast<uint64_t>(counters.WorkingSetSize);
|
||||||
|
memory.peakResidentBytes = static_cast<uint64_t>(counters.PeakWorkingSetSize);
|
||||||
|
memory.available = true;
|
||||||
|
}
|
||||||
|
#elif defined(__linux__)
|
||||||
|
// Lignes "VmRSS: 123456 kB" et "VmHWM: 234567 kB".
|
||||||
|
std::ifstream status("/proc/self/status");
|
||||||
|
std::string line;
|
||||||
|
while (std::getline(status, line)) {
|
||||||
|
const bool rss = line.rfind("VmRSS:", 0) == 0;
|
||||||
|
const bool hwm = line.rfind("VmHWM:", 0) == 0;
|
||||||
|
if (!rss && !hwm) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
std::istringstream fields(line.substr(6));
|
||||||
|
uint64_t kilobytes = 0;
|
||||||
|
fields >> kilobytes;
|
||||||
|
(rss ? memory.residentBytes : memory.peakResidentBytes) = kilobytes * 1024u;
|
||||||
|
memory.available = true;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
return memory;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string processMemoryLine() {
|
||||||
|
const ProcessMemory memory = processMemory();
|
||||||
|
if (!memory.available) {
|
||||||
|
return "RAM non mesuree (plateforme non prise en charge)";
|
||||||
|
}
|
||||||
|
char text[96];
|
||||||
|
std::snprintf(text, sizeof(text), "RAM %.1f Mo (pic %.1f Mo)",
|
||||||
|
static_cast<double>(memory.residentBytes) / (1024.0 * 1024.0),
|
||||||
|
static_cast<double>(memory.peakResidentBytes) / (1024.0 * 1024.0));
|
||||||
|
return text;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace vercora
|
||||||
@@ -0,0 +1,31 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <cstdint>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
namespace vercora {
|
||||||
|
|
||||||
|
// PHASE 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
@@ -11,6 +11,7 @@
|
|||||||
#include "editor/AssetCatalog.hpp"
|
#include "editor/AssetCatalog.hpp"
|
||||||
#include "editor/EditorController.hpp"
|
#include "editor/EditorController.hpp"
|
||||||
#include "core/Paths.hpp"
|
#include "core/Paths.hpp"
|
||||||
|
#include "core/ProcessMemory.hpp"
|
||||||
#include "editor/EditorScene.hpp"
|
#include "editor/EditorScene.hpp"
|
||||||
#include "editor/PlacedObject.hpp"
|
#include "editor/PlacedObject.hpp"
|
||||||
#include "editor/SceneFile.hpp"
|
#include "editor/SceneFile.hpp"
|
||||||
@@ -137,6 +138,13 @@ namespace {
|
|||||||
// objets poses, eux, font partie du monde et sont affiches et solides dans le
|
// objets poses, eux, font partie du monde et sont affiches et solides dans le
|
||||||
// jeu normal - c'est justement le point.
|
// 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 :
|
// Le terrain synthetique n'est PAS supprime, et pour deux raisons distinctes :
|
||||||
// il reste la scene de reference des tests (monde deterministe, arbres a
|
// 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
|
// 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 sceneFileArgument;
|
||||||
std::string editorAssetsArgument;
|
std::string editorAssetsArgument;
|
||||||
std::string sceneArgument;
|
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) {
|
for (int i = 1; i < argc; ++i) {
|
||||||
const std::string argument = argv[i];
|
const std::string argument = argv[i];
|
||||||
if (argument == "--dump-world") {
|
if (argument == "--dump-world") {
|
||||||
@@ -1029,6 +1051,20 @@ int main(int argc, char** argv) {
|
|||||||
}
|
}
|
||||||
} else if (argument.rfind("--ortho=", 0) == 0) {
|
} else if (argument.rfind("--ortho=", 0) == 0) {
|
||||||
orthoArgument = argument.substr(std::strlen("--ortho="));
|
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) {
|
} else if (argument.rfind("--", 0) == 0) {
|
||||||
logWarn("Option inconnue, ignoree : " + argument);
|
logWarn("Option inconnue, ignoree : " + argument);
|
||||||
} else if (sceneArgument.empty()) {
|
} 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
|
// fenetre, dont la Phase 18 a montre qu'il varie de ~15 % entre deux
|
||||||
// runs identiques. Chargement exclu : il precede la boucle.
|
// runs identiques. Chargement exclu : il precede la boucle.
|
||||||
const auto loopStart = ProfileClock::now();
|
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()) {
|
while (!window.shouldClose()) {
|
||||||
window.pollEvents();
|
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 double now = glfwGetTime();
|
||||||
const float deltaTime = static_cast<float>(now - lastTime);
|
const float deltaTime = static_cast<float>(now - lastTime);
|
||||||
lastTime = now;
|
lastTime = now;
|
||||||
@@ -2301,6 +2356,9 @@ int main(int argc, char** argv) {
|
|||||||
// demarrage, donc la valeur reste petite et n'use pas la precision
|
// demarrage, donc la valeur reste petite et n'use pas la precision
|
||||||
// d'un float, contrairement a une horloge absolue.
|
// d'un float, contrairement a une horloge absolue.
|
||||||
const float elapsedSeconds = static_cast<float>(now);
|
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) ------------------------
|
// --- Bascule du MODE EDITEUR (PHASE 15) ------------------------
|
||||||
// Traitee AVANT camera.update : entrer en edition change le mode et
|
// 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.count = static_cast<uint32_t>(instances.size());
|
||||||
item.material = Material::Foliage;
|
item.material = Material::Foliage;
|
||||||
// Amplitude d'ondulation NULLE : un tronc ne plie pas.
|
// 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);
|
instancedItems.push_back(item);
|
||||||
};
|
};
|
||||||
pushTrees(treeInstances, sceneryTreeMeshHandle);
|
pushTrees(treeInstances, sceneryTreeMeshHandle);
|
||||||
@@ -3703,7 +3761,7 @@ int main(int argc, char** argv) {
|
|||||||
// seul materiau qui s'en sert : un arbre pousse 0 et
|
// seul materiau qui s'en sert : un arbre pousse 0 et
|
||||||
// traverse le meme pipeline, inchange.
|
// traverse le meme pipeline, inchange.
|
||||||
item.params = { vegetation->params().grassSway,
|
item.params = { vegetation->params().grassSway,
|
||||||
elapsedSeconds, 0.0f,
|
animationSeconds, 0.0f,
|
||||||
vegetation->params().grassCutout };
|
vegetation->params().grassCutout };
|
||||||
instancedItems.push_back(item);
|
instancedItems.push_back(item);
|
||||||
}
|
}
|
||||||
@@ -3734,7 +3792,7 @@ int main(int argc, char** argv) {
|
|||||||
// pas par un masque - ces plantes sont peu nombreuses,
|
// pas par un masque - ces plantes sont peu nombreuses,
|
||||||
// le budget de sommets n'est pas le sujet.
|
// le budget de sommets n'est pas le sujet.
|
||||||
item.params = { 0.35f * vegetation->params().grassSway,
|
item.params = { 0.35f * vegetation->params().grassSway,
|
||||||
elapsedSeconds, 0.0f, 0.0f };
|
animationSeconds, 0.0f, 0.0f };
|
||||||
instancedItems.push_back(item);
|
instancedItems.push_back(item);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -3760,7 +3818,7 @@ int main(int argc, char** argv) {
|
|||||||
item.instances = instances.data();
|
item.instances = instances.data();
|
||||||
item.count = static_cast<uint32_t>(instances.size());
|
item.count = static_cast<uint32_t>(instances.size());
|
||||||
item.material = Material::Foliage;
|
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);
|
instancedItems.push_back(item);
|
||||||
};
|
};
|
||||||
pushRocks(boulderInstances, boulderMeshHandle);
|
pushRocks(boulderInstances, boulderMeshHandle);
|
||||||
@@ -3786,7 +3844,7 @@ int main(int argc, char** argv) {
|
|||||||
item.instances = instances.data();
|
item.instances = instances.data();
|
||||||
item.count = static_cast<uint32_t>(instances.size());
|
item.count = static_cast<uint32_t>(instances.size());
|
||||||
item.material = Material::Foliage;
|
item.material = Material::Foliage;
|
||||||
item.params = { sway, elapsedSeconds, 0.0f, 0.0f };
|
item.params = { sway, animationSeconds, 0.0f, 0.0f };
|
||||||
instancedItems.push_back(item);
|
instancedItems.push_back(item);
|
||||||
};
|
};
|
||||||
pushBushes(shrubInstances, shrubMeshHandle, 0.04f);
|
pushBushes(shrubInstances, shrubMeshHandle, 0.04f);
|
||||||
@@ -3846,7 +3904,7 @@ int main(int argc, char** argv) {
|
|||||||
renderer.setWeatherVisuals(visuals.fogColor, visuals.fogDensityPerMeter,
|
renderer.setWeatherVisuals(visuals.fogColor, visuals.fogDensityPerMeter,
|
||||||
visuals.precipitation, visuals.snow,
|
visuals.precipitation, visuals.snow,
|
||||||
visuals.fallVelocity, visuals.groundDarkening,
|
visuals.fallVelocity, visuals.groundDarkening,
|
||||||
elapsedSeconds);
|
animationSeconds);
|
||||||
frameProfile.weatherVisualsMicros += profileMicros(tw0, ProfileClock::now());
|
frameProfile.weatherVisualsMicros += profileMicros(tw0, ProfileClock::now());
|
||||||
|
|
||||||
// Journal BORNE PAR LE TEMPS (lecon de la Phase 24 : "sur
|
// 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.
|
// S'assurer que le GPU a fini avant de detruire quoi que ce soit.
|
||||||
renderer.waitIdle();
|
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) {
|
if (frameProfile.frames > 0) {
|
||||||
const auto per = [&](uint64_t total) {
|
const auto per = [&](uint64_t total) {
|
||||||
const double value = static_cast<double>(total) /
|
const double value = static_cast<double>(total) /
|
||||||
|
|||||||
@@ -66,10 +66,7 @@ void SwapChain::cleanupSizeDependent() {
|
|||||||
vkDestroyImage(device, depthImage_, nullptr);
|
vkDestroyImage(device, depthImage_, nullptr);
|
||||||
depthImage_ = VK_NULL_HANDLE;
|
depthImage_ = VK_NULL_HANDLE;
|
||||||
}
|
}
|
||||||
if (depthImageMemory_ != VK_NULL_HANDLE) {
|
context_.freeMemory(depthAllocation_);
|
||||||
vkFreeMemory(device, depthImageMemory_, nullptr);
|
|
||||||
depthImageMemory_ = VK_NULL_HANDLE;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (VkFramebuffer fb : framebuffers_) {
|
for (VkFramebuffer fb : framebuffers_) {
|
||||||
vkDestroyFramebuffer(device, fb, nullptr);
|
vkDestroyFramebuffer(device, fb, nullptr);
|
||||||
@@ -342,16 +339,10 @@ void SwapChain::createDepthResources() {
|
|||||||
VkMemoryRequirements memRequirements{};
|
VkMemoryRequirements memRequirements{};
|
||||||
vkGetImageMemoryRequirements(device, depthImage_, &memRequirements);
|
vkGetImageMemoryRequirements(device, depthImage_, &memRequirements);
|
||||||
|
|
||||||
VkMemoryAllocateInfo allocInfo{};
|
// PHASE 30 : par le contexte, qui tient le compte de la memoire GPU.
|
||||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
depthAllocation_ = context_.allocateMemory(memRequirements,
|
||||||
allocInfo.allocationSize = memRequirements.size;
|
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||||
allocInfo.memoryTypeIndex = context_.findMemoryType(
|
vkBindImageMemory(device, depthImage_, depthAllocation_.memory, 0);
|
||||||
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);
|
|
||||||
|
|
||||||
VkImageViewCreateInfo viewInfo{};
|
VkImageViewCreateInfo viewInfo{};
|
||||||
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||||||
|
|||||||
@@ -1,5 +1,7 @@
|
|||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
|
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||||
|
|
||||||
#include <vulkan/vulkan.h>
|
#include <vulkan/vulkan.h>
|
||||||
|
|
||||||
#include <vector>
|
#include <vector>
|
||||||
@@ -68,7 +70,7 @@ private:
|
|||||||
// par le render pass). Recree en meme temps que la swapchain au resize.
|
// par le render pass). Recree en meme temps que la swapchain au resize.
|
||||||
VkFormat depthFormat_ = VK_FORMAT_UNDEFINED;
|
VkFormat depthFormat_ = VK_FORMAT_UNDEFINED;
|
||||||
VkImage depthImage_ = VK_NULL_HANDLE;
|
VkImage depthImage_ = VK_NULL_HANDLE;
|
||||||
VkDeviceMemory depthImageMemory_ = VK_NULL_HANDLE;
|
GpuAllocation depthAllocation_;
|
||||||
VkImageView depthImageView_ = VK_NULL_HANDLE;
|
VkImageView depthImageView_ = VK_NULL_HANDLE;
|
||||||
|
|
||||||
VkRenderPass renderPass_ = VK_NULL_HANDLE;
|
VkRenderPass renderPass_ = VK_NULL_HANDLE;
|
||||||
|
|||||||
@@ -176,7 +176,11 @@ public:
|
|||||||
// Ni la Heightmap ni le Renderer ne sont possedes ; les deux doivent vivre
|
// Ni la Heightmap ni le Renderer ne sont possedes ; les deux doivent vivre
|
||||||
// plus longtemps que le streamer.
|
// plus longtemps que le streamer.
|
||||||
TerrainStreamer(const Heightmap& heightmap, Renderer& renderer,
|
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();
|
||||||
|
|
||||||
TerrainStreamer(const TerrainStreamer&) = delete;
|
TerrainStreamer(const TerrainStreamer&) = delete;
|
||||||
|
|||||||
@@ -111,9 +111,7 @@ Texture::~Texture() {
|
|||||||
if (image_ != VK_NULL_HANDLE) {
|
if (image_ != VK_NULL_HANDLE) {
|
||||||
vkDestroyImage(device, image_, nullptr);
|
vkDestroyImage(device, image_, nullptr);
|
||||||
}
|
}
|
||||||
if (memory_ != VK_NULL_HANDLE) {
|
context_.freeMemory(allocation_);
|
||||||
vkFreeMemory(device, memory_, nullptr);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
|
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{};
|
VkMemoryRequirements requirements{};
|
||||||
vkGetImageMemoryRequirements(device, image_, &requirements);
|
vkGetImageMemoryRequirements(device, image_, &requirements);
|
||||||
|
|
||||||
VkMemoryAllocateInfo allocInfo{};
|
// PHASE 30 : par le contexte, qui tient le compte de la memoire GPU.
|
||||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
allocation_ = context_.allocateMemory(requirements, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||||
allocInfo.allocationSize = requirements.size;
|
vkBindImageMemory(device, image_, allocation_.memory, 0);
|
||||||
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);
|
|
||||||
deviceSize_ = requirements.size;
|
deviceSize_ = requirements.size;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -4,6 +4,7 @@
|
|||||||
// le renvoie par valeur. L'en-tete reste sans cout : assets/TextureFile.hpp ne
|
// le renvoie par valeur. L'en-tete reste sans cout : assets/TextureFile.hpp ne
|
||||||
// depend pas de Vulkan.
|
// depend pas de Vulkan.
|
||||||
#include "assets/TextureFile.hpp"
|
#include "assets/TextureFile.hpp"
|
||||||
|
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||||
|
|
||||||
#include <vulkan/vulkan.h>
|
#include <vulkan/vulkan.h>
|
||||||
|
|
||||||
@@ -74,7 +75,7 @@ private:
|
|||||||
|
|
||||||
VulkanContext& context_;
|
VulkanContext& context_;
|
||||||
VkImage image_ = VK_NULL_HANDLE;
|
VkImage image_ = VK_NULL_HANDLE;
|
||||||
VkDeviceMemory memory_ = VK_NULL_HANDLE;
|
GpuAllocation allocation_;
|
||||||
VkImageView view_ = VK_NULL_HANDLE;
|
VkImageView view_ = VK_NULL_HANDLE;
|
||||||
VkSampler sampler_ = VK_NULL_HANDLE;
|
VkSampler sampler_ = VK_NULL_HANDLE;
|
||||||
VkDeviceSize deviceSize_ = 0;
|
VkDeviceSize deviceSize_ = 0;
|
||||||
|
|||||||
@@ -27,42 +27,38 @@ VulkanBuffer::VulkanBuffer(VulkanContext& context,
|
|||||||
VkMemoryRequirements memRequirements{};
|
VkMemoryRequirements memRequirements{};
|
||||||
vkGetBufferMemoryRequirements(device, buffer_, &memRequirements);
|
vkGetBufferMemoryRequirements(device, buffer_, &memRequirements);
|
||||||
|
|
||||||
VkMemoryAllocateInfo allocInfo{};
|
// PHASE 30 : par le contexte, qui tient le compte de la memoire GPU.
|
||||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
try {
|
||||||
allocInfo.allocationSize = memRequirements.size;
|
allocation_ = context_.allocateMemory(memRequirements, properties);
|
||||||
allocInfo.memoryTypeIndex =
|
} catch (...) {
|
||||||
context_.findMemoryType(memRequirements.memoryTypeBits, properties);
|
vkDestroyBuffer(device, buffer_, nullptr);
|
||||||
|
throw;
|
||||||
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
|
|
||||||
throw std::runtime_error("Echec de l'allocation memoire d'un buffer.");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
vkBindBufferMemory(device, buffer_, memory_, 0);
|
vkBindBufferMemory(device, buffer_, allocation_.memory, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
VulkanBuffer::~VulkanBuffer() {
|
VulkanBuffer::~VulkanBuffer() {
|
||||||
VkDevice device = context_.device();
|
VkDevice device = context_.device();
|
||||||
if (mapped_ != nullptr) {
|
if (mapped_ != nullptr) {
|
||||||
vkUnmapMemory(device, memory_);
|
vkUnmapMemory(device, allocation_.memory);
|
||||||
mapped_ = nullptr;
|
mapped_ = nullptr;
|
||||||
}
|
}
|
||||||
if (buffer_ != VK_NULL_HANDLE) {
|
if (buffer_ != VK_NULL_HANDLE) {
|
||||||
vkDestroyBuffer(device, buffer_, nullptr);
|
vkDestroyBuffer(device, buffer_, nullptr);
|
||||||
}
|
}
|
||||||
if (memory_ != VK_NULL_HANDLE) {
|
context_.freeMemory(allocation_);
|
||||||
vkFreeMemory(device, memory_, nullptr);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void VulkanBuffer::map() {
|
void VulkanBuffer::map() {
|
||||||
if (mapped_ == nullptr) {
|
if (mapped_ == nullptr) {
|
||||||
vkMapMemory(context_.device(), memory_, 0, size_, 0, &mapped_);
|
vkMapMemory(context_.device(), allocation_.memory, 0, size_, 0, &mapped_);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void VulkanBuffer::unmap() {
|
void VulkanBuffer::unmap() {
|
||||||
if (mapped_ != nullptr) {
|
if (mapped_ != nullptr) {
|
||||||
vkUnmapMemory(context_.device(), memory_);
|
vkUnmapMemory(context_.device(), allocation_.memory);
|
||||||
mapped_ = nullptr;
|
mapped_ = nullptr;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,7 @@
|
|||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
|
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||||
|
|
||||||
#include <vulkan/vulkan.h>
|
#include <vulkan/vulkan.h>
|
||||||
|
|
||||||
#include <memory>
|
#include <memory>
|
||||||
@@ -76,7 +78,7 @@ private:
|
|||||||
VulkanContext& context_;
|
VulkanContext& context_;
|
||||||
VkDeviceSize size_ = 0;
|
VkDeviceSize size_ = 0;
|
||||||
VkBuffer buffer_ = VK_NULL_HANDLE;
|
VkBuffer buffer_ = VK_NULL_HANDLE;
|
||||||
VkDeviceMemory memory_ = VK_NULL_HANDLE;
|
GpuAllocation allocation_;
|
||||||
void* mapped_ = nullptr;
|
void* mapped_ = nullptr;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|||||||
@@ -3,6 +3,8 @@
|
|||||||
#include "core/Logger.hpp"
|
#include "core/Logger.hpp"
|
||||||
#include "core/Window.hpp"
|
#include "core/Window.hpp"
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
#include <cstdio>
|
||||||
#include <cstring>
|
#include <cstring>
|
||||||
#include <set>
|
#include <set>
|
||||||
#include <stdexcept>
|
#include <stdexcept>
|
||||||
@@ -233,6 +235,28 @@ void VulkanContext::pickPhysicalDevice() {
|
|||||||
VkPhysicalDeviceProperties props{};
|
VkPhysicalDeviceProperties props{};
|
||||||
vkGetPhysicalDeviceProperties(physicalDevice_, &props);
|
vkGetPhysicalDeviceProperties(physicalDevice_, &props);
|
||||||
logInfo(std::string("GPU selectionne : ") + props.deviceName);
|
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 {
|
bool VulkanContext::isDeviceSuitable(VkPhysicalDevice device) const {
|
||||||
@@ -397,13 +421,10 @@ SwapChainSupportDetails VulkanContext::querySwapChainSupport() const {
|
|||||||
}
|
}
|
||||||
|
|
||||||
uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const {
|
uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const {
|
||||||
VkPhysicalDeviceMemoryProperties memProperties{};
|
for (uint32_t i = 0; i < memoryProperties_.memoryTypeCount; ++i) {
|
||||||
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memProperties);
|
|
||||||
|
|
||||||
for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) {
|
|
||||||
const bool typeOk = (typeFilter & (1u << i)) != 0;
|
const bool typeOk = (typeFilter & (1u << i)) != 0;
|
||||||
const bool propsOk =
|
const bool propsOk =
|
||||||
(memProperties.memoryTypes[i].propertyFlags & properties) == properties;
|
(memoryProperties_.memoryTypes[i].propertyFlags & properties) == properties;
|
||||||
if (typeOk && propsOk) {
|
if (typeOk && propsOk) {
|
||||||
return i;
|
return i;
|
||||||
}
|
}
|
||||||
@@ -411,6 +432,70 @@ uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlag
|
|||||||
throw std::runtime_error("Aucun type de memoire adapte trouve.");
|
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,
|
VkFormat VulkanContext::findSupportedFormat(const std::vector<VkFormat>& candidates,
|
||||||
VkImageTiling tiling,
|
VkImageTiling tiling,
|
||||||
VkFormatFeatureFlags features) const {
|
VkFormatFeatureFlags features) const {
|
||||||
|
|||||||
@@ -3,6 +3,7 @@
|
|||||||
#include <vulkan/vulkan.h>
|
#include <vulkan/vulkan.h>
|
||||||
|
|
||||||
#include <optional>
|
#include <optional>
|
||||||
|
#include <string>
|
||||||
#include <vector>
|
#include <vector>
|
||||||
|
|
||||||
namespace vercora {
|
namespace vercora {
|
||||||
@@ -41,6 +42,32 @@ struct SwapChainSupportDetails {
|
|||||||
std::vector<VkPresentModeKHR> presentModes;
|
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 :
|
// Regroupe l'etat "global" Vulkan qui ne change pas au resize :
|
||||||
// instance, debug messenger, surface, GPU physique, device logique, queues.
|
// instance, debug messenger, surface, GPU physique, device logique, queues.
|
||||||
class VulkanContext {
|
class VulkanContext {
|
||||||
@@ -84,6 +111,28 @@ public:
|
|||||||
// Format de profondeur retenu (D32 de preference, avec fallbacks).
|
// Format de profondeur retenu (D32 de preference, avec fallbacks).
|
||||||
VkFormat findDepthFormat() const;
|
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:
|
private:
|
||||||
void createInstance();
|
void createInstance();
|
||||||
void setupDebugMessenger();
|
void setupDebugMessenger();
|
||||||
@@ -110,6 +159,13 @@ private:
|
|||||||
QueueFamilyIndices queueIndices_;
|
QueueFamilyIndices queueIndices_;
|
||||||
|
|
||||||
bool anisotropyEnabled_ = false;
|
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
|
} // namespace vercora
|
||||||
@@ -127,7 +127,10 @@ public:
|
|||||||
// pour le rendu que pour la COLLISION (voir la note de decouplage dans
|
// pour le rendu que pour la COLLISION (voir la note de decouplage dans
|
||||||
// MEMORY.md). L'arbre n'en garde que des bornes.
|
// MEMORY.md). L'arbre n'en garde que des bornes.
|
||||||
// Lance std::runtime_error si les parametres sont inexploitables.
|
// 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
|
// Remplit `out` avec les noeuds a dessiner, tries du plus proche au plus
|
||||||
// lointain. `out` est vide au prealable ; sa capacite est conservee.
|
// lointain. `out` est vide au prealable ; sa capacite est conservee.
|
||||||
|
|||||||
@@ -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())
|
||||||
Référencer dans un nouveau ticket
Bloquer un utilisateur