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