Phase 30 (6/n) : bilan, robustesse des televersements, notes

- Renderer : un maillage possede ses plages des leur reservation
  (allocateMesh) et ses copies ne sont confiees a l'image suivante
  qu'une fois toutes ses ecritures reussies - plus de plage perdue ni de
  copie visant une plage rendue si la memoire vient a manquer.
- Ligne "Ressources (PHASE 30)" : bilan du pool de geometrie.
- main.cpp : le C4244 connu de la Phase 27 rendu explicite.
- NOTES-PHASE30.md : execution, bilan chiffre avant/apres sur les trois
  scenarios, verification (images, validation standard et de
  synchronisation, controle negatif), limites, reproduction.
- MEMORY.md : section Phase 30.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
Cette révision appartient à :
Claude a révisé 2026-10-13 23:44:17 +00:00
1 Parent 29e9a09199
révision f15fb63b7d
6 fichiers modifiés
+258 -44

Aucun fichier ne correspond à votre recherche

+39
Voir le fichier
@@ -2650,3 +2650,42 @@ Tests **3807/3807** (3636 avant), 0 `[Validation]` au demarrage.
- Relecture : seuls main.cpp et foliage.vert modifies ; Forest/Vegetation/faune/
artisanat/collision/activites identiques octet pour octet ; chemin w >= 0 du shader inchange.
- Outil : `build-release\` existe desormais (profil Release hors du `build\` Debug).
## PHASE 30 (2026-10-13) - optimisation des ressources (detail : NOTES-PHASE30.md)
Session cloud (Linux, sans GPU ni donnees LiDAR) : mesure sous **lavapipe +
Xvfb** (rendu logiciel DETERMINISTE : deux runs identiques = 0 pixel
d'ecart, donc preuves au bit pres possibles) sur une **zone proxy** a la
vraie echelle (`tools/make_bench_zone.py` : relief fBm 5001 x 5001, georef
et altitudes de la vraie zone, couvert tire de l'orthophoto versionnee).
Les chiffres sont comparables avant/apres, PAS a ceux de l'UHD 770.
- **Build Linux** : GCC 13 / Clang 18 (`= {}` sur struct imbriquee ->
surcharges, CWG 1397 ; `GLFW_INCLUDE_NONE`). `cmake -G Ninja
-DGLFW_BUILD_WAYLAND=OFF`. Tests 3 963 / 3 963 (+20).
- **Instrumentation** : toute memoire GPU via `VulkanContext::allocateMemory`
(comptee), RAM via `core/ProcessMemory`, ligne `Ressources (PHASE 30)` au
chargement / toutes les 10 s / en fin de partie. Options `--quit-after=S`,
`--freeze-anim`, `--force-staging`, `--vsync`.
- **Geometrie** : `Vertex` (68 o) reste le format CPU ; GPU = `ObjectVertex`
44 o (exact) et `TerrainVertex` 16 o (x/z/UV/morph recalcules par
terrain.vert depuis `gl_VertexIndex` + `DrawItem::grid`, `precise`).
Topologie des tuiles partagee en uint16. `GpuBufferPool` (blocs 4 Mo) :
ecriture DIRECTE en memoire unifiee, staging + barriere VERTEX_INPUT ->
TRANSFER sinon. Tuiles interieures construites sans relecture (bit a bit).
- **Rendu** : terrain dessine en DERNIER (early-Z) + culling de ses faces
arriere. Orthophoto lue par tranches dans un staging de 4 Mo reutilise.
- **Bilan survol 900 m/s** : pic GPU 285 -> 87 Mo, terrain 188 -> 33 Mo,
vkAllocateMemory ~17 000 -> 22, streaming 4,3 -> 0,93 ms/image.
Foret : pic GPU 103 -> 56 Mo, +44 % d'images/s (lavapipe). Chargement :
pic RAM -68 Mo, pic GPU 89 -> 50 Mo.
- **Image** : quantification des normales (+/- 1 niveau sur ~0,04 % des
pixels), egalites de profondeur aux pieds des brins/troncs (24 px), et
~250 px isoles sur parois rasantes (culling). Staging, parallele, ortho,
tuiles rapides : identiques au bit pres a ce qu'ils remplacent.
- **Validation** : 0 message (standard ET synchronisation, chemins direct et
staging). Controle negatif : sans la barriere, 414 SYNC-HAZARD en survol.
- **PIEGE** pour les comparaisons d'images : la FAUNE bouge en temps reel ;
comparer avec `--no-wildlife`, sinon un animal deplace fait 6-11 pixels.
- **A faire sur la machine de dev** : re-mesurer en Release sur l'UHD 770
(profile_phase27/29.ps1, run_vulkan_check.ps1 complet).
+157
Voir le fichier
@@ -153,3 +153,160 @@ NON RETENU, et pourquoi :
25 Mo de mieux au pic du survol, pour un changement de modele d'entree, un
descripteur de plus et un shader a bords exacts. A reprendre si le pas
LiDAR s'affine.
---------------------------------------------------------------------------
## 5. Execution : ce qui a ete fait
Cinq commits sur la branche, chacun valide avant le suivant (tests headless,
couches de validation Khronos, comparaison d'images au pixel pres).
### P6 - ordre de dessin et culling (Renderer, Pipeline)
- Ordre objets -> vegetation -> TERRAIN (`kDrawOrder`). Le shader de fragment
du terrain est le plus lourd du jeu ; dessine en dernier, ses fragments
caches par les troncs et l'herbe sont ecartes par le test de profondeur
precoce. Foret : -26 % de temps de rendu a lui seul.
- `ShaderSet::cullBackFaces`, terrain seulement (champ de hauteurs : un oeil
au-dessus du relief rencontre toujours une face avant d'abord).
`frontFace = COUNTER_CLOCKWISE` une fois l'axe Y de la projection retourne,
verifie par le calcul d'aire de la spec ET a l'image.
### P1 a P4 - geometrie compacte et pool (GpuVertex, GpuBufferPool, Mesh)
- `renderer/GpuVertex.hpp` : `ObjectVertex` (44 o, conversion exacte de
`Vertex`) et `TerrainVertex` (16 o : altitude, altitude cible, normales x/z
en snorm16). `Vertex` (68 o) reste le format de TRAVAIL cote CPU : aucun
generateur ni aucun test n'a change de format.
- `terrain.vert` recalcule x/z, la cible de morphing et l'UV depuis
`gl_VertexIndex` et `DrawItem::grid` (ix0, iz0, pas, sommets par rangee) +
`UniformBufferObject::terrainGrid` (origine, pas, cellules). `precise`
interdit la fusion en FMA : les positions sont celles de
`Heightmap::worldCoord` au bit pres (verifie en C++ par les tests).
- Topologie des tuiles televersee UNE fois en uint16 (`addSharedIndices`) ;
indices des objets en uint16 ; une seule liaison d'indices par image pour
tout le terrain (`bindMesh` saute les liaisons redondantes).
- `GpuBufferPool` (blocs de 4 Mo, `RangeAllocator` premier ajustement, bloc
dedie au-dela d'un demi-bloc, un bloc vide garde en reserve) : un `Mesh` ne
possede plus de buffer mais des PLAGES, rendues au pool par le meme retrait
differe qu'avant (kMaxFramesInFlight + 1 images).
- Memoire unifiee + GPU integre ou logiciel (`preferDirectGeometryWrites`) :
blocs mappes, la geometrie est ECRITE la ou le GPU la lit - ni staging, ni
copie, ni barriere. GPU discret : staging de la Phase 12, avec une barriere
d'execution VERTEX_INPUT -> TRANSFER avant les copies (une plage recyclee a
ete lue par des images precedentes). `--force-staging` eprouve ce chemin.
- `writeTerrainNodeVertices` : les sommets d'une tuile ecrits directement au
format compact (plus de `MeshData` de 287 Ko par tuile, plus de copie).
`terrainNodeMeshData` reste la reference testee : les deux partagent le meme
parcours (`forEachNodeVertex`), ils ne peuvent pas diverger.
- `--no-lod` : `terrainGpuMeshData` produit directement le format compact
(1,7 Go de `MeshData` en moins au pic sur la zone au pas de 1 m).
### P5 - orthophoto (TextureFile, Texture)
- `loadTextureFileHeader` + `readTexturePayload` (entier ou par tranche) ;
`loadTextureFile` en est la composition.
- `Texture` remplit son staging par une source et le REUTILISE par bandes de
rangees de blocs (4 Mo au plus) au lieu d'un staging de toute la chaine.
L'orthophoto n'est plus jamais tenue en RAM.
### P7 - construction des tuiles interieures (TerrainNodeMesh)
- Loin du bord, les altitudes sont lues une fois dans une grille bordee de
deux rangs, puis les MEMES operations flottantes que `sampleGrid`. Bords et
temoin `--no-tile-cache` : chemin de reference.
### En plus du plan
- `--vsync` : presentation FIFO. Le plus gros levier de CONSOMMATION (378
images/s sur l'UHD 770 = GPU a 100 % pour un ecran a 60 Hz). Non active
par defaut : les mesures du projet comptent des images non plafonnees.
- Ligne `Ressources (PHASE 30)` completee par le bilan du pool de geometrie.
- Televersements surs en cas d'echec d'allocation : le `Mesh` possede ses
plages des leur reservation, et aucune copie n'est confiee a l'image
suivante avant que toutes les ecritures du maillage aient reussi.
- Le C4244 connu de main.cpp (Phase 27, `groundDetailPattern`) : conversion
rendue explicite, meme valeur.
## 6. Bilan chiffre (meme banc, memes scenarios, moyenne de 2 passages)
Release, lavapipe, 1280 x 720, zone proxy. "RAM" inclut ici la memoire GPU
(lavapipe l'alloue dans le processus) : sur l'UHD 770 elle n'y figure pas.
| | foret avant | foret apres | panorama avant | panorama apres | survol avant | survol apres |
|---|---:|---:|---:|---:|---:|---:|
| memoire GPU, fin de partie | 75,0 Mo | **55,5 Mo** | 71,6 Mo | **54,6 Mo** | 254 Mo | **86,7 Mo** |
| memoire GPU, pic de session | 102,6 Mo | **55,5 Mo** | 96,6 Mo | **54,6 Mo** | 285 Mo | **86,7 Mo** |
| dont geometrie de terrain (pic) | 27 Mo | **4 Mo** | 24 Mo | **4 Mo** | 188 Mo | **33 Mo** |
| blocs vkAllocateMemory vivants (pic) | 436 | **10** | 408 | **10** | 1 366 | **18** |
| appels vkAllocateMemory (session) | 439 | **13** | 411 | **13** | ~16 950 | **22** |
| pic RAM au chargement | 302 Mo | **233 Mo** | 302 Mo | **234 Mo** | 302 Mo | **234 Mo** |
| pic memoire GPU au chargement | 89,2 Mo | **50,5 Mo** | 89,2 Mo | **50,5 Mo** | 89,2 Mo | **50,5 Mo** |
| temps de chargement | 0,48 s | **0,38 s** | 0,47 s | **0,38 s** | 0,47 s | **0,38 s** |
| pic RAM de session | 463 Mo | **409 Mo** | 353 Mo | **312 Mo** | 605 Mo | **374 Mo** |
| tuile : geometrie | 167 us | **142 us** | 194 us | **139 us** | 202 us | **105 us** |
| tuile : televersement | 210 us | **0,5 us** | 207 us | **0,6 us** | 219 us | **0,7 us** |
| streaming terrain, CPU par image | 119 us | **45 us** | 58 us | **35 us** | 4,3 ms | **0,93 ms** |
| temps de rendu (drawFrame) | 120 ms | **83 ms** | 51 ms | **43 ms** | 62 ms | **52 ms** |
| images/s (lavapipe) | 8,2 | **11,8 (+44 %)** | 19,4 | **22,7 (+17 %)** | 14,6 | **18,0 (+24 %)** |
Les images/s et le temps de rendu sont ceux d'un GPU LOGICIEL : ils disent le
sens et l'ordre de grandeur du gain (moins de fragments de terrain ombres,
moins d'octets lus par sommet), pas le chiffre de l'UHD 770. Les octets, les
allocations et les couts CPU de construction, eux, ne dependent pas du GPU.
Maillages d'objets (27 maillages, 4 070 sommets, 1 504 triangles) : 295 Ko ->
188 Ko (-36 %), en 1 bloc au lieu de 54 allocations (et 54 de staging).
## 7. Verification
- **Tests headless** : 3 963 / 3 963 (3 943 avant : +20 verifications),
compiles avec GCC 13 (0 avertissement en -Wall -Wextra) et Clang 18. Les
25 verifications qui ont besoin des vraies dalles LiDAR sont ignorees ici,
comme toujours sans elles.
- **Validation Khronos** (Debug) : 0 message sur foret, panorama et survol ;
**validation de synchronisation** : 0 message, chemins direct ET staging.
Controle negatif : sans la barriere VERTEX_INPUT -> TRANSFER, 414 messages
SYNC-HAZARD-WRITE-AFTER-READ en 30 s de survol avec `--force-staging`.
- **Images** (sans faune : les animaux bougent en temps reel, leur position
depend du nombre d'images rendues) :
- foret : 353 pixels sur 921 600 (0,038 %) ; 329 a +/- 1 niveau
(normales quantifiees) et 24 aux pieds des brins et des troncs, la ou leur
profondeur EGALE celle du sol. Preuve : une variante qui rend ces egalites
au terrain redonne l'image de reference au bit pres ;
- panorama : 1 149 pixels (0,125 %), dont ~250 isoles sur les parois quasi
verticales vues en rasant (culling, voir ShaderSet::cullBackFaces) ;
- chemin staging (`--force-staging`), maillage parallele
(`--tile-threads=4`), orthophoto par tranches, chemin rapide des tuiles :
chacun IDENTIQUE au bit pres au chemin qu'il remplace ;
- `--no-lod` et LOD : identiques entre eux sur le terrain synthetique.
## 8. Ce qui reste, et pour qui
- **A re-mesurer sur l'UHD 770** : les images/s Release (`profile_phase27.ps1`,
`profile_phase29.ps1`) et `run_vulkan_check.ps1` complet. Les lignes
`Ressources (PHASE 30)` donnent desormais la memoire GPU exacte dans le
journal de chaque scenario.
- **Staging sur GPU discret** : un staging (une allocation) par
televersement, comme avant la phase. Un anneau de staging persistant
ramenerait ce chemin au niveau du chemin direct ; non ecrit faute de GPU
discret pour l'eprouver.
- **Vertex pulling du terrain** (16 -> ~4,5 o par sommet) : 25 Mo de mieux au
pic du survol. Voir section 4.
- **Cache de pipelines** (`VkPipelineCache` sur disque) : demarrage plus
rapide sur un pilote sans cache propre ; le pilote Intel en a un.
- **CPU par image** : le profil (perf) ne montre plus que le semis de l'herbe
et des arbres (Phase 18) ; rien d'autre au-dessus du bruit.
## 9. Reproduire
# Linux : dependances (Ubuntu 24.04)
apt-get install mesa-vulkan-drivers libvulkan-dev glslc vulkan-validationlayers \
ninja-build libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev \
libxkbcommon-dev xvfb imagemagick python3-numpy
cmake -S . -B build-rel -G Ninja -DCMAKE_BUILD_TYPE=Release -DGLFW_BUILD_WAYLAND=OFF
ninja -C build-rel
python3 tools/make_bench_zone.py # sans les vraies donnees seulement
Xvfb :99 -screen 0 1280x720x24 &
DISPLAY=:99 VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/lvp_icd.json \
build-rel/vercora assets/terrain/vercora_zone_1m.vchm --lock-input \
--hour=13 --time-scale=0 --freeze-anim --start=901800,6435800 \
--look=0,-8 --quit-after=30
# puis lire les lignes "Ressources", "Cout par image", "Construction de tuiles"
# validation de synchronisation : Debug + VK_LAYER_ENABLES=
# VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT
+3 -3
Voir le fichier
@@ -1369,7 +1369,7 @@ int main(int argc, char** argv) {
if (orthoMatchesTerrain(ortho, *heightmap)) {
renderer.setTerrainTextureFromFile(ortho, orthoPath);
renderer.setOrthoMix(1.0f);
groundDetailPattern = ortho.metresPerTexel();
groundDetailPattern = static_cast<float>(ortho.metresPerTexel());
logInfo("Orthophoto : " +
std::to_string(ortho.metresPerTexel()) +
" m/texel pour un terrain au pas de " +
@@ -2383,7 +2383,7 @@ int main(int argc, char** argv) {
if (loopSeconds - lastResourceLog >= 10.0) {
lastResourceLog = loopSeconds;
logInfo("Ressources (PHASE 30) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ".");
context.gpuMemoryLine() + ". " + renderer.geometryLine() + ".");
}
const double now = glfwGetTime();
@@ -4023,7 +4023,7 @@ int main(int argc, char** argv) {
// "vivants" sont donc ceux du jeu en regime etabli, les pics ceux de la
// session entiere.
logInfo("Ressources en fin de partie (PHASE 30) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ".");
context.gpuMemoryLine() + ". " + renderer.geometryLine() + ".");
if (frameProfile.frames > 0) {
const auto per = [&](uint64_t total) {
+4 -4
Voir le fichier
@@ -168,10 +168,10 @@ uint32_t GpuBufferPool::blockCount() const {
std::string GpuBufferPool::statsLine() const {
char text[160];
std::snprintf(text, sizeof(text),
"%.1f Mo de geometrie dans %u bloc(s) de %.1f Mo au total%s",
static_cast<double>(usedBytes_) / (1024.0 * 1024.0), blockCount(),
static_cast<double>(capacityBytes_) / (1024.0 * 1024.0),
mapped_ ? ", ecriture directe (memoire unifiee)" : ", par staging");
"%.1f Mo utilises sur %.1f Mo alloues en %u bloc(s), %s",
static_cast<double>(usedBytes_) / (1024.0 * 1024.0),
static_cast<double>(capacityBytes_) / (1024.0 * 1024.0), blockCount(),
mapped_ ? "ecriture directe (memoire unifiee)" : "televersement par staging");
return text;
}
+48 -36
Voir le fichier
@@ -241,23 +241,20 @@ MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) {
const VkDeviceSize indexBytes = static_cast<VkDeviceSize>(indexCount) *
(shortIndices ? sizeof(uint16_t) : sizeof(uint32_t));
const GpuRange vertexRange = geometryPool_->allocate(vertexBytes);
GpuRange indexRange;
try {
indexRange = geometryPool_->allocate(indexBytes);
} catch (...) {
geometryPool_->release(vertexRange);
throw;
}
// Le Mesh possede ses plages DES leur allocation : si la suite echoue
// (memoire epuisee), il les rend au pool en se detruisant. Et aucune copie
// n'est confiee a l'image suivante avant que les DEUX ecritures aient
// reussi - sinon une copie en attente viserait une plage deja rendue.
auto mesh = allocateMesh(VertexLayout::Object, vertexBytes, vertexCount, indexBytes,
shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32,
indexCount);
RangeWrite vertexWrite = beginRangeWrite(mesh->vertexRange());
RangeWrite indexWrite = beginRangeWrite(mesh->indexRange());
RangeWrite vertexWrite = beginRangeWrite(vertexRange);
auto* vertices = static_cast<ObjectVertex*>(vertexWrite.destination);
for (uint32_t v = 0; v < vertexCount; ++v) {
vertices[v] = toObjectVertex(meshData.vertices[v]);
}
finishRangeWrite(vertexWrite);
RangeWrite indexWrite = beginRangeWrite(indexRange);
if (shortIndices) {
auto* indices = static_cast<uint16_t*>(indexWrite.destination);
for (uint32_t k = 0; k < indexCount; ++k) {
@@ -267,6 +264,7 @@ MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) {
std::memcpy(indexWrite.destination, meshData.indices.data(),
static_cast<std::size_t>(indexBytes));
}
finishRangeWrite(vertexWrite);
finishRangeWrite(indexWrite);
if (log) {
@@ -275,9 +273,22 @@ MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) {
std::to_string(indexCount / 3) + " triangles, " +
std::to_string((vertexBytes + indexBytes + 1023) / 1024) + " Ko.");
}
return registerMesh(std::make_unique<Mesh>(
*geometryPool_, VertexLayout::Object, vertexRange, vertexCount, indexRange,
shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32, indexCount, true));
return registerMesh(std::move(mesh));
}
std::unique_ptr<Mesh> Renderer::allocateMesh(VertexLayout layout, VkDeviceSize vertexBytes,
uint32_t vertexCount, VkDeviceSize indexBytes,
VkIndexType indexType, uint32_t indexCount) {
const GpuRange vertexRange = geometryPool_->allocate(vertexBytes);
GpuRange indexRange;
try {
indexRange = geometryPool_->allocate(indexBytes);
} catch (...) {
geometryPool_->release(vertexRange);
throw;
}
return std::make_unique<Mesh>(*geometryPool_, layout, vertexRange, vertexCount,
indexRange, indexType, indexCount, true);
}
MeshHandle Renderer::addTerrainMesh(const std::vector<TerrainVertex>& vertices,
@@ -296,19 +307,14 @@ MeshHandle Renderer::addTerrainMesh(const std::vector<TerrainVertex>& vertices,
}
const VkDeviceSize vertexBytes = static_cast<VkDeviceSize>(vertexCount) * sizeof(TerrainVertex);
const VkDeviceSize indexBytes = static_cast<VkDeviceSize>(indices.size()) * sizeof(uint32_t);
const GpuRange vertexRange = geometryPool_->allocate(vertexBytes);
GpuRange indexRange;
try {
indexRange = geometryPool_->allocate(indexBytes);
} catch (...) {
geometryPool_->release(vertexRange);
throw;
}
RangeWrite vertexWrite = beginRangeWrite(vertexRange);
// Meme ordre que addMesh : plages possedees d'abord, copies confiees ensuite.
auto mesh = allocateMesh(VertexLayout::Terrain, vertexBytes, vertexCount, indexBytes,
VK_INDEX_TYPE_UINT32, static_cast<uint32_t>(indices.size()));
RangeWrite vertexWrite = beginRangeWrite(mesh->vertexRange());
RangeWrite indexWrite = beginRangeWrite(mesh->indexRange());
std::memcpy(vertexWrite.destination, vertices.data(), static_cast<std::size_t>(vertexBytes));
finishRangeWrite(vertexWrite);
RangeWrite indexWrite = beginRangeWrite(indexRange);
std::memcpy(indexWrite.destination, indices.data(), static_cast<std::size_t>(indexBytes));
finishRangeWrite(vertexWrite);
finishRangeWrite(indexWrite);
if (log) {
@@ -316,9 +322,7 @@ MeshHandle Renderer::addTerrainMesh(const std::vector<TerrainVertex>& vertices,
" sommets, " + std::to_string(indices.size() / 3) + " triangles, " +
std::to_string((vertexBytes + indexBytes) / (1024 * 1024)) + " Mo.");
}
return registerMesh(std::make_unique<Mesh>(
*geometryPool_, VertexLayout::Terrain, vertexRange, vertexCount, indexRange,
VK_INDEX_TYPE_UINT32, static_cast<uint32_t>(indices.size()), true));
return registerMesh(std::move(mesh));
}
uint32_t Renderer::addSharedIndices(const std::vector<uint32_t>& indices) {
@@ -332,7 +336,13 @@ uint32_t Renderer::addSharedIndices(const std::vector<uint32_t>& indices) {
shared.type = shortIndices ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32;
shared.range = geometryPool_->allocate(static_cast<VkDeviceSize>(indices.size()) *
(shortIndices ? sizeof(uint16_t) : sizeof(uint32_t)));
RangeWrite write = beginRangeWrite(shared.range);
RangeWrite write;
try {
write = beginRangeWrite(shared.range);
} catch (...) {
geometryPool_->release(shared.range);
throw;
}
if (shortIndices) {
auto* out = static_cast<uint16_t*>(write.destination);
for (std::size_t k = 0; k < indices.size(); ++k) {
@@ -352,15 +362,17 @@ Renderer::TerrainMeshWrite Renderer::beginTerrainMesh(uint32_t vertexCount,
throw std::runtime_error("Tuile de terrain : topologie partagee inconnue.");
}
const SharedIndices& shared = sharedIndices_[sharedIndices];
const GpuRange range = geometryPool_->allocate(
static_cast<VkDeviceSize>(vertexCount) * sizeof(TerrainVertex));
RangeWrite write = beginRangeWrite(range);
// Le Mesh possede sa plage avant l'ecriture : si le staging ne peut pas
// etre cree, il la rend au pool en se detruisant.
auto mesh = std::make_unique<Mesh>(
*geometryPool_, VertexLayout::Terrain,
geometryPool_->allocate(static_cast<VkDeviceSize>(vertexCount) * sizeof(TerrainVertex)),
vertexCount, shared.range, shared.type, shared.count, false);
RangeWrite write = beginRangeWrite(mesh->vertexRange());
TerrainMeshWrite result;
result.vertices = static_cast<TerrainVertex*>(write.destination);
result.mesh = registerMesh(std::make_unique<Mesh>(
*geometryPool_, VertexLayout::Terrain, range, vertexCount, shared.range,
shared.type, shared.count, false));
result.mesh = registerMesh(std::move(mesh));
if (write.staging) {
pendingTerrainWrites_.emplace(result.mesh, std::move(write));
}
+7 -1
Voir le fichier
@@ -3,6 +3,7 @@
#include "renderer/DrawItem.hpp"
#include "renderer/GpuBufferPool.hpp"
#include "renderer/GpuVertex.hpp"
#include "renderer/Mesh.hpp" // VertexLayout
#include "renderer/Pipeline.hpp" // pour ShaderSet
#include "renderer/VulkanBuffer.hpp" // pour BufferUploader
@@ -23,7 +24,6 @@ class VulkanContext;
class Window;
class SwapChain;
class Camera;
class Mesh;
class Texture;
struct MeshData;
struct TextureData;
@@ -385,6 +385,12 @@ private:
// reutilise s'il y en a un).
MeshHandle registerMesh(std::unique_ptr<Mesh> mesh);
// Reserve les deux plages d'un maillage a topologie propre et les confie
// AUSSITOT a un Mesh, qui les rendra au pool si la suite echoue.
std::unique_ptr<Mesh> allocateMesh(VertexLayout layout, VkDeviceSize vertexBytes,
uint32_t vertexCount, VkDeviceSize indexBytes,
VkIndexType indexType, uint32_t indexCount);
VulkanContext& context_;
Window& window_;
RenderOptions options_;