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 à :
1 Parent
29e9a09199
révision
f15fb63b7d
6 fichiers modifiés
+258
-44
Aucun fichier ne correspond à votre recherche
@@ -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).
|
||||
@@ -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
@@ -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) {
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
|
||||
@@ -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_;
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur