Premier commit

Cette révision appartient à :
Théo Gastinel a révisé 2026-10-11 01:54:18 +02:00
révision 84a72fe30c
200 fichiers modifiés
+61602

Aucun fichier ne correspond à votre recherche

+123
Voir le fichier
@@ -0,0 +1,123 @@
# Build
build/
out/
cmake-build-*/
# Harnais de tests headless (tools/run_logic_tests.bat)
build-tests/
# Dependances telechargees par FetchContent
external/
# Visual Studio / VS Code
.vs/
.vscode/
*.user
*.suo
# CMake
CMakeCache.txt
CMakeFiles/
CMakeUserPresets.json
# Compiles
*.o
*.obj
*.exe
*.spv
# Exception : les meshes Wavefront .obj de assets/ sont des SOURCES, pas des
# fichiers objets de compilation. La regle *.obj ci-dessus les aurait ignores
# silencieusement.
#
# PHASE 15 : la regle est passee de "assets/*.obj" a TOUTE profondeur sous
# assets/. Le motif a un seul niveau ne couvrait pas assets/editor/, le dossier
# de modeles de l'editeur - le seul asset du catalogue qui vienne d'un fichier
# aurait donc ete ignore en silence, exactement le piege que ce commentaire
# decrivait deja.
!assets/**/*.obj
# Donnees LiDAR (Phase 7)
# ----------------------
# Les dalles brutes de l'IGN font ~170 Mo piece et sont librement
# retelechargeables (licence ouverte Etalab 2.0) : aucune raison de les
# versionner. Les heightmaps derivees (4 Mo au pas de 1 m) sont exclues pour la
# meme raison - elles se regenerent en 4 secondes avec
# tools/lidar_to_heightmap.py, dont la ligne de commande exacte est dans
# NOTES-PHASE7.md. Le jeu se replie sur le terrain synthetique si elles manquent.
data/
assets/terrain/*.vchm
# OS
.DS_Store
Thumbs.db
# --- double-push : exclusions generiques (secrets, builds, binaires, gros fichiers) ---
target/
node_modules/
build/
build-*/
dist/
out/
.gradle/
.idea/
venv/
.venv/
env/
__pycache__/
*.pyc
.cache/
.next/
.env
.env.*
!.env.example
accounts.json
Clee.API/
*.pem
*.key
*.p12
*.pfx
*.jks
*.keystore
keystore.properties
id_rsa*
id_ed25519*
*.kdbx
*.odt
*.sqlite
*.sqlite3
*.db
*.log
*.exe
*.dll
*.msi
*.jar
*.zip
*.7z
*.rar
*.tar
*.tar.gz
*.tgz
*.gguf
*.safetensors
*.onnx
*.pt
*.pth
*.bin
*.iso
*.gws
*.apk
*.aab
*.so
*.o
*.a
*.lib
*.pdb
*.mp4
*.mkv
*.wav
*.flac
# sous-depots / donnees volumineuses exclus du premier commit
/external/glfw-src/
/external/glm-src/
/external/tinyobjloader-src/
+211
Voir le fichier
@@ -0,0 +1,211 @@
cmake_minimum_required(VERSION 3.20)
project(Vercora LANGUAGES CXX)
# ---------------------------------------------------------------------------
# Standard C++20
# ---------------------------------------------------------------------------
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
# Build type par defaut = Debug (pour activer les validation layers)
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
set(CMAKE_BUILD_TYPE Debug CACHE STRING "Build type" FORCE)
endif()
# ---------------------------------------------------------------------------
# Vulkan SDK (LunarG) : suppose installe sur la machine (variable VULKAN_SDK)
# ---------------------------------------------------------------------------
find_package(Vulkan 1.2 REQUIRED)
# ---------------------------------------------------------------------------
# Dependances externes via FetchContent (telechargees dans external/)
# ---------------------------------------------------------------------------
include(FetchContent)
set(FETCHCONTENT_BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external)
# --- GLFW (fenetrage cross-platform) ---
FetchContent_Declare(
glfw
GIT_REPOSITORY https://github.com/glfw/glfw.git
GIT_TAG 3.4
GIT_SHALLOW TRUE
)
set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
set(GLFW_INSTALL OFF CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(glfw)
# --- GLM (maths, header-only, pas encore utilise mais deja en place) ---
FetchContent_Declare(
glm
GIT_REPOSITORY https://github.com/g-truc/glm.git
GIT_TAG 1.0.1
GIT_SHALLOW TRUE
)
FetchContent_MakeAvailable(glm)
# --- tinyobjloader (parsing des fichiers .obj, header-only, licence MIT) ---
# SOURCE_SUBDIR pointe volontairement vers un sous-dossier inexistant :
# FetchContent_MakeAvailable n'appelle add_subdirectory() que s'il y trouve un
# CMakeLists.txt. On recupere donc uniquement les sources, sans configurer le
# projet CMake de tinyobjloader (dont le cmake_minimum_required est trop ancien
# pour CMake 4.x, qui a supprime la compatibilite avec les versions < 3.5).
# La bibliotheque etant header-only, un simple include directory suffit.
#
# Tag v2.0.0rc13 (le plus recent publie, celui que distribue vcpkg) et NON
# v1.0.6 : ce dernier date de 2017 et expose une API plus pauvre (un seul
# message d'erreur au lieu de warning + erreur separes, et pas de lecture des
# couleurs de sommet).
FetchContent_Declare(
tinyobjloader
GIT_REPOSITORY https://github.com/tinyobjloader/tinyobjloader.git
GIT_TAG v2.0.0rc13
GIT_SHALLOW TRUE
SOURCE_SUBDIR cmake-volontairement-absent
)
FetchContent_MakeAvailable(tinyobjloader)
# ---------------------------------------------------------------------------
# Executable
# ---------------------------------------------------------------------------
add_executable(vercora
src/main.cpp
src/core/Window.cpp
src/core/Camera.cpp
src/core/Paths.cpp
src/assets/ObjLoader.cpp
src/assets/Heightmap.cpp
src/assets/TerrainFile.cpp
src/assets/TextureFile.cpp
src/assets/DetailNoise.cpp
src/world/TreeMesh.cpp
src/world/StoneMesh.cpp
src/world/Tree.cpp
src/world/Ground.cpp
src/world/Knapping.cpp
src/world/Crafting.cpp
src/world/CraftMesh.cpp
src/world/Forest.cpp
src/world/Habitat.cpp
src/world/Wildlife.cpp
src/world/AnimalMesh.cpp
src/world/Vegetation.cpp
src/world/GrassMesh.cpp
src/world/Paraglider.cpp
src/world/Bike.cpp
src/world/Climber.cpp
src/world/Needs.cpp
src/world/Weather.cpp
src/world/WaterSource.cpp
src/world/Deposits.cpp
src/world/Resin.cpp
src/world/TreeSpecies.cpp
src/world/FiberPlants.cpp
src/world/Rocks.cpp
src/world/RockMesh.cpp
src/world/Bushes.cpp
src/world/BushMesh.cpp
src/world/HarvestMesh.cpp
src/world/TerrainQuadtree.cpp
src/editor/EditorAssets.cpp
src/editor/AssetCatalog.cpp
src/editor/EditorScene.cpp
src/editor/EditorController.cpp
src/editor/SceneFile.cpp
src/renderer/VulkanContext.cpp
src/renderer/VulkanBuffer.cpp
src/renderer/Mesh.cpp
src/renderer/TerrainMesh.cpp
src/renderer/TerrainNodeMesh.cpp
src/renderer/TerrainStreamer.cpp
src/renderer/SwapChain.cpp
src/renderer/Pipeline.cpp
src/renderer/Renderer.cpp
src/renderer/Texture.cpp
)
target_include_directories(vercora PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/src
${tinyobjloader_SOURCE_DIR}
)
target_link_libraries(vercora PRIVATE
Vulkan::Vulkan
glfw
glm::glm
)
# GLFW_INCLUDE_VULKAN : GLFW inclut les headers Vulkan automatiquement.
# VERCORA_DEBUG : active les validation layers uniquement en configuration Debug.
# GLM_FORCE_RADIANS : GLM travaille en radians (evite les surprises d'unites).
# GLM_FORCE_DEPTH_ZERO_TO_ONE : Vulkan attend une profondeur clip dans [0,1]
# (et non [-1,1] comme OpenGL) -> indispensable pour un depth buffer correct.
target_compile_definitions(vercora PRIVATE
GLFW_INCLUDE_VULKAN
GLM_FORCE_RADIANS
GLM_FORCE_DEPTH_ZERO_TO_ONE
$<$<CONFIG:Debug>:VERCORA_DEBUG>
)
# ---------------------------------------------------------------------------
# Compilation automatique des shaders GLSL -> SPIR-V via glslc
# ---------------------------------------------------------------------------
# find_package(Vulkan) fournit normalement Vulkan_GLSLC_EXECUTABLE.
# Fallback manuel si absent.
if(NOT Vulkan_GLSLC_EXECUTABLE)
find_program(Vulkan_GLSLC_EXECUTABLE
NAMES glslc
HINTS "$ENV{VULKAN_SDK}/bin" "$ENV{VULKAN_SDK}/Bin")
endif()
if(NOT Vulkan_GLSLC_EXECUTABLE)
message(FATAL_ERROR "glslc introuvable. Verifiez l'installation du Vulkan SDK (variable VULKAN_SDK).")
endif()
set(SHADER_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/shaders)
set(SHADER_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/shaders)
file(MAKE_DIRECTORY ${SHADER_BINARY_DIR})
set(SHADER_SOURCES
cube.vert
cube.frag
terrain.vert
terrain.frag
foliage.vert
foliage.frag
precip.vert
precip.frag
)
set(SPIRV_BINARIES "")
foreach(SHADER ${SHADER_SOURCES})
set(SRC ${SHADER_SOURCE_DIR}/${SHADER})
set(SPV ${SHADER_BINARY_DIR}/${SHADER}.spv)
add_custom_command(
OUTPUT ${SPV}
COMMAND ${Vulkan_GLSLC_EXECUTABLE} ${SRC} -o ${SPV}
DEPENDS ${SRC}
COMMENT "Compilation shader ${SHADER} -> ${SHADER}.spv"
VERBATIM
)
list(APPEND SPIRV_BINARIES ${SPV})
endforeach()
add_custom_target(shaders DEPENDS ${SPIRV_BINARIES})
add_dependencies(vercora shaders)
# Chemin des SPIR-V compiles, passe au code C++ pour le chargement runtime.
target_compile_definitions(vercora PRIVATE
SHADERS_OUTPUT_DIR="${SHADER_BINARY_DIR}")
# ---------------------------------------------------------------------------
# Assets
# ---------------------------------------------------------------------------
# Meme principe que pour les shaders : le chemin absolu du dossier assets/ est
# passe au code, ce qui evite de dependre du repertoire courant a l'execution.
# A remplacer par une copie des assets a cote de l'executable le jour ou le jeu
# sera distribue.
target_compile_definitions(vercora PRIVATE
ASSETS_DIR="${CMAKE_CURRENT_SOURCE_DIR}/assets")
+2652
Voir le fichier
Diff désactivé car ce fichier est trop long. Voir la Diff
+118
Voir le fichier
@@ -0,0 +1,118 @@
# NOTES-AUDIT-GLOBAL.md — Rapport d'audit global et état des lieux du projet Vercora
Date de l'audit : 2026-08-28 (à l'issue des 26 premières phases livrées).
Machine de test : Intel Core i5-14600K (20 cœurs logiques), 64 Go RAM, GPU intégré Intel UHD Graphics 770, Windows 11 64-bit, Vulkan SDK 1.4.357.0.
---
## 1. Résumé exécutif
Après 26 phases de développement itératif livrées sans moteur tiers, le projet **Vercora est dans un état technique robuste, sain et remarquablement cohérent**. Le moteur Vulkan maison C++20 gère un terrain LiDAR réel de 25 km² (5x5 km) avec streaming par quadtree LOD, orthophoto 8192x8192, végétation instanciée à deux essences réparties par exposition solaire (adret/ubac), faune dynamique avec mémoire d'empreinte environnementale, système météo synoptique déterministe, gestion des besoins primaires et récolte/artisanat de 5 matières premières, éditeur de niveau complet et 4 modes de déplacement physiques (marche avec filtre de pente, vélo, parapente, escalade). **Zéro erreur de validation Vulkan** n'a été émise sur l'ensemble des runs. La suite de tests logiques headless compte **3 607 assertions et affiche 100 % de succès**. L'architecture a éliminé les doubles sources de vérité (température, adret/ubac, orientation solaire). Seul un défaut d'intégration résiduel de la Phase 26 (4 points de compilation oubliés dans CMake/tests) et une variabilité temporelle du harnais d'automatisation Win32 sur machine chargée ont été diagnostiqués.
---
## 2. Bilan chiffré
### 2.1 Tests unitaires & logiques headless
- **Script :** ools\run_logic_tests.bat
- **Total d'assertions vérifiées :** **3 607 / 3 607**
- **Échecs :** **0**
- **Taux de réussite :** **100 %**
- **Couverture logique :** Quadtree terrain, streaming LOD, échantillonnage de hauteur, calculs d'incidence et gradients, physique marche/pente/glissade, physique vélo (braquage, adhérence, pente max 23.6%), aérodynamique parapente (finesse, dérive, vent relatif, thermiques), mécanique d'escalade (adhérence, énergie, récupération, décrochage), simulation météo synoptique & locale, besoins primaires (faim, soif, thermorégulation, fatigue), récolte & façonnage (bois, pierre, argile, sable, fibres, résine avec essence d'arbre), catalogue et persistance de l'éditeur de niveau, partitionnement spatial et collision généralisée.
### 2.2 Suite de validation Vulkan réelle ( ools\run_vulkan_check.ps1)
- **Protocole :** 5 runs complets consécutifs (10 scénarios A..J répartis sur 14 processus distincts par run).
- **Messages [Validation] Vulkan :** **0 sur la totalité des 5 runs (0 erreur, 0 avertissement de couche)**.
- **Crashes / Plantages moteur :** **0**.
- **Taux de runs 100% verts du harnais :** **1 / 5 (20 %)** de runs entièrement validés par le script d'automatisation.
- **Diagnostic des échecs du harnais d'automatisation :**
- **Run 1 :** 100 % vert de bout en bout (0 sortie non nulle, toutes étapes validées).
- **Run 2 :** Arrêt au Scénario I (perte de message lors du test de fréquentation de 240s) ; dans les étapes précédentes, approche à 0.94 m au lieu de <= 0.80 m sur l'abattage LiDAR du scénario C.
- **Run 3 :** sommet atteint : False dans le Scénario F (escalade) et HasExited=True au démarrage de J2 (délai de libération de processus).
- **Run 4 & 5 :** Le nouveau diagnostic de santé machine (Phase 26) s'est déclenché : [ATTENTION] 6 processus n'ont pratiquement PAS RENDU D'IMAGES (perte de tics de rendu quand la machine absorbe une charge concurrente en tâche de fond, faussant les temporisations Win32 PostMessage).
- **Conclusion harnais :** Les échecs ne sont pas des bugs du jeu (qui ne crashe jamais et respecte strictement la spec Vulkan), mais des faux-négatifs inhérents au pilotage asynchrone aveugle par PostMessage/Start-Sleep sous forte charge CPU.
### 2.3 Profiling comparatif Debug vs Release (Terrain réel 25 km² / survol 900 m/s & vue stationnaire)
Les mesures confirment avec éclat les découvertes de la Phase 19 : **le profil Debug ne reflète pas la réalité du moteur**.
| Métrique | Configuration Debug | Configuration Release | Facteur de gain |
|---|---:|---:|---:|
| **Cadence (survol 900 m/s)** | 102.7 FPS (2 055 frames / 20 s) | **378.0 FPS (7 560 frames / 20 s)** | **+268 % (x3.68)** |
| **Géométrie d'une tuile LOD** | 1 936.0 µs / tuile | **163.8 µs / tuile** | **x11.8 plus rapide** |
| **Téléversement GPU d'une tuile** | 596.9 µs / tuile | **339.4 µs / tuile** | x1.76 |
| **Temps total mesh tuiles (session)** | 3 157 ms | **645 ms** | **−80 %** |
| **Poste CPU Arbres (gatherTrees)** | 3 339.5 µs / image | **484.8 µs / image** | **x6.9 plus rapide** |
| **Poste CPU Herbe (gatherGrass)** | 1 286.6 µs / image | **116.7 µs / image** | **x11.0 plus rapide** |
| **Poste CPU Fibres (gatherFiber)** | 278.2 µs / image | **26.3 µs / image** | **x10.6 plus rapide** |
| **Part du GPU (drawFrame)** | 45.1 % du temps de frame | **76.5 % à 93.9 % du frame** | **Moteur GPU-bound** |
| **Trous de streaming (tuiles vides)** | **0 frame** | **0 frame** | Parfait |
### 2.4 Matrice de fonctionnement des activités et sous-systèmes
| Système / Activité | Phase d'introduction | État fonctionnel | Vérification |
|---|---|---|---|
| **Marche & Terrain** | Phase 1..7, 24 | **Opérationnel** | Franchissement doux, arrêt au seuil de 84 %, glissade aval au-delà de 84 %, décalage caméra sans à-coup. |
| **Vélo de montagne** | Phase 13, 22 | **Opérationnel** | Prise en selle (B), accélération en descente (jusqu'à 50 km/h), pédalage en côte, calage au-delà de 23.6%, freinage et pied à terre propres. |
| **Parapente** | Phase 8, 23 | **Opérationnel** | Décollage (V), prise de portance, virages, sensibilité au vent et thermiques, atterrissage automatique au contact du sol. |
| **Escalade** | Phase 14 | **Opérationnel** | Accrochage aux parois > 84% (X), déplacement multidirectionnel, gestion de l'endurance, sortie au sommet ou au pied de paroi. |
| **Artisanat & Récolte (5 matières)** | Phase 5, 6, 22, 26 | **Opérationnel** | Bois (abattage, débitage), pierre (ramassage, percussion, éclats), argile & sable (creusage sur gisements morphologiques, refus à distance), résine (arbres résineux identifiés), fibres (arrachage en lisière et repousse). |
| **Éditeur de niveau** | Phase 15 | **Opérationnel** | Mode direct (F2), catalogue d'assets, pose au sol/visée, rotation/mise à l'échelle, suppression/undo, sauvegarde (F5) et rechargement (F9) avec collision en jeu normal. |
| **Faune & Milieu** | Phase 17, 20 | **Opérationnel** | Placement selon couvert/pente, détection du joueur, fuite dynamique, empreinte environnementale (fréquentation/déforestation) persistante par cellule. |
| **Météo déterministe** | Phase 23, 25 | **Opérationnel** | Cycle nycthéméral continu, gradient altimétrique de température (6.5 °C/km), modèle adret/ubac solaire, nuages, vent et inversions thermiques. |
| **Arguments CLI (26 flags)** | Phase 1..26 | **100 % Opérationnel** | Les 26 arguments (--demo, --no-lod, --no-ortho, --no-vegetation, --no-grass, --single-tree-species, --no-species-aspect, etc.) testés individuellement et validés avec succès. |
---
## 3. Tableau de la dette technique consolidée
| # | Sujet de la dette | Origine | État réel actuel | Criticité | Recommandation |
|---|---|---|---|---|---|
| **D1** | **Compilation CMake / Tests Phase 26** | Phase 26 | **Corrigé lors de l'audit** : TreeSpecies.cpp manquait dans CMakeLists.txt et
un_logic_tests.bat, incidence manquait dans Weather.cpp:723, et estResin() appelait l'ancienne API. | *Bloquant (Build)* | Fait. Maintenir des tests d'intégration CMake systématiques. |
| **D2** | **Flakiness du harnais Win32 (
un_vulkan_check.ps1)** | Phase 15..26 | **Ouvert (Outillage)** : Les commandes PostMessage envoyées sans accusé de réception à des intervalles fixes échouent lorsque le thread UI subit des latences ou des saccades. | *Gênant (Test)* | Conserver le diagnostic de santé (Phase 26) et envisager un mode d'auto-pilotage interne ou d'injection directe de commande dans l'engine loop pour les tests d'intégration longs. |
| **D3** | **Gestion des dégâts et de la santé du joueur** | Phase 14, 16, 24 | **Ouvert (Conception)** : Une chute en escalade ou une glissade prolongée replace le joueur au sol ou l'arrête sans affecter une jauge de santé physique (seule l'endurance est consommée). | *Cosmétique / Gameplay* | À traiter lors de la prochaine phase de gameplay (système de santé / blessures). |
| **D4** | **Placement des gisements de matières** | Phase 22 | **Ouvert (Assumé)** : Les gisements d'argile et de sable sont positionnés par heuristique morphologique (creux, talwegs, proximité de cours d'eau) et non d'après une vraie carte géologique IGN. | *Mineur (Gameplay)* | Suffisant pour le gameplay actuel ; une couche géologique pourra être introduite ultérieurement si nécessaire. |
| **D5** | **Récolte de résine dans le harnais automatisé** | Phase 22, 26 | **Ouvert (Harnais)** : Le scénario J n'exerce pas la résine car le script ne peut pas orienter la visée vers un tronc spécifique sans capturer la souris réelle de l'utilisateur. | *Outillage* | Totalement couvert et prouvé par les tests logiques headless ests\logic_tests.cpp. |
| **D6** | **Streaming partiel du terrain depuis le disque** | Phase 10 | **Non traité (Architecture)** : La heightmap complète est chargée en mémoire vive (25 Mo pour la zone 2m, 100 Mo pour la 1m). | *Négligeable* | Sur les configurations cibles modernes (16 à 64 Go de RAM), l'empreinte de 100 Mo est totalement négligeable et dispense d'un I/O asynchrone complexe. |
| **D7** | **Format d'objets pour l'éditeur (glTF)** | Phase 15 | **Non traité (Éditeur)** : L'éditeur ne charge actuellement que des fichiers .obj. | *Confort éditeur* | Ajouter inygltf / support glTF si des assets externes plus complexes sont importés. |
| **D8** | **Texture de détail de près (micro-relief)** | Phase 11 | **Non traité (Rendu)** : À 0.61 m/texel, l'orthophoto vue à ras du sol manque de micro-détail procédural sous les pieds. | *Cosmétique (Rendu)* | Envisager un shader de détail triplanaire ou un mélange de textures de détail sous les pieds. |
---
## 4. Découvertes et surprises de l'audit
1. **Surprise négative — Découverte d'un build cassé en sortie de Phase 26 :**
- Le repository tel que laissé à la fin de la Phase 26 ne compilait pas en partant de zéro : src/world/TreeSpecies.cpp n'avait été ajouté ni à CMakeLists.txt ni à ools\run_logic_tests.bat.
- Une variable incidence non déclarée causait une erreur de compilation dans src/world/Weather.cpp:723.
- estResin() dans ests/logic_tests.cpp appelait encore l'ancienne signature ResinStand::isConifer au lieu de TreeSpecies.
- *Ces points ont été immédiatement corrigés pour permettre l'audit.*
2. **Surprise positive — Rigueur architecturale sans compromis :**
- Aucune duplication de source de vérité n'a été trouvée dans le code : la température est calculée exclusivement par WeatherSystem, l'exposition solaire adret/ubac par spectSignal(), les limites de pente par SlopeLimits.hpp, les espèces d'arbres par reeSpeciesAt().
- Le moteur respecte scrupuleusement la spécification Vulkan : **0 message de validation**, destruction ordonnée de tous les buffers, textures et pipelines.
3. **Surprise positive — Performances en Release époustouflantes :**
- Le moteur tourne à **378 FPS constants sur GPU intégré Intel UHD 770** lors d'un survol de terrain à 900 m/s.
- Les temps de génération de maillage de tuiles ne prennent que **163 µs** par tuile en Release, confirmant que le choix architectural de la Phase 19 (défaut séquentiel sans surcoût de synchronisation de threads) était le bon.
4. **Validation complète des 26 flags CLI :**
- Les 26 arguments de lancement sont tous fonctionnels, reconnus sans avertissement et testés unitairement.
---
## 5. Recommandation pour la suite
### Verdict global : **VERT / PRÊT POUR DE NOUVELLES FONCTIONNALITÉS (GO)**
Le projet Vercora est sur des fondations techniques saines, stables et vérifiées. Aucune dette architecturale bloquante n'entrave le développement.
### Prochaines étapes recommandées par ordre de priorité :
1. **Boucle de Survie & Progression du Joueur :**
- Intégration d'un système de santé, blessures et fatigue liée aux activités physiques (impact des chutes en escalade, glissades, froid nocturne).
- Recettes d'artisanat combinant les 5 matières récoltées (ex: confection d'outils, cordes en fibres + résine, abris de bivouac).
2. **Amélioration du Rendu & Immersion :**
- Texture de micro-détail / micro-relief procédural pour le sol au premier plan (résolvant le flou de l'orthophoto vue de très près).
- Brouillard volumétrique / brume de vallée basée sur le champ de piégeage d'air froid du système météo.
3. **Écosystème Faune & Flore :**
- Comportements étendus de la faune (troupeaux, pâturage, cycles repos/déplacement selon l'heure météo).
- Cueillette de baies / champignons selon l'humidité et le couvert forestier.
+511
Voir le fichier
@@ -0,0 +1,511 @@
# Phase 14 (2026-08-22) : premiere version de la physique d'escalade
Quatrieme et derniere activite du cadrage. Meme intention que le parapente
(Phase 8) et le velo (Phase 13) : un modele simplifie mais **chiffre et
testable**, pose sur du relief LiDAR reel, pas une maquette.
Nouveau : `src/world/Climber.{hpp,cpp}` et `tools/find_climb_walls.py`.
`CameraMode::Climb` s'ajoute a `Camera`. **Aucun chemin de rendu n'est touche** -
c'est la premiere activite qui n'ajoute meme pas un marqueur, puisqu'elle est a
la premiere personne.
---
## 1. Detection de paroi : le seuil, et pourquoi il ne se lit pas dans la donnee
### Ce que le terrain contient reellement
`tools/find_climb_walls.py` (nouveau) depouille un `.vchm` et sort la
distribution des pentes. Sur la zone de jeu assemblee (25 km2, **24 970 009
echantillons evaluables**), pente lue par differences centrees sur une base de
4 m :
| | p50 | p75 | p90 | p95 | p99 | p99,9 | max |
|---|---:|---:|---:|---:|---:|---:|---:|
| pente | 47,7 % | 65,7 % | 92,4 % | 129,4 % | 342,5 % | 1127,0 % | 5018,2 % |
| angle | 25,5° | 33,3° | 42,8° | 52,3° | 73,7° | 84,9° | 88,9° |
**Ce massif est raide partout.** La pente MEDIANE est de 47,7 % ; la moitie du
terrain est plus pentue qu'un toit. Et surtout :
> **La distribution est un CONTINUUM. Il n'y a aucune bimodalite, donc aucun
> "creux" naturel ou poser le seuil.** Le seuil de paroi est un choix de
> conception, pas une decouverte, et il faut le dire ainsi.
Part de la zone retenue selon le seuil :
| seuil | 30 % | 50 % | 70 % | **100 %** | 150 % | 200 % | 300 % |
|---|---:|---:|---:|---:|---:|---:|---:|
| angle | 16,7° | 26,6° | 35,0° | **45,0°** | 56,3° | 63,4° | 71,6° |
| part de la zone | 79,6 % | 46,5 % | 20,7 % | **8,4 %** | 3,8 % | 2,3 % | 1,2 % |
### Le seuil retenu : 1,00 (45°, 100 %)
Trois arguments, aucun tire de la distribution :
1. **45° est la borne basse conventionnelle du terrain d'escalade.** En dessous
c'est une desescalade ou un pas d'alpinisme facile ; au-dessus il faut les
mains.
2. **C'est nettement au-dessus de l'angle de repos des materiaux meubles**
(35 a 40°, soit 70 a 84 %). Une face a 45° dans ce massif ne retient ni
eboulis ni terre : c'est du rocher nu, donc precisement ce qui se grimpe. Le
seuil separe donc une realite physique, meme si la distribution des pentes,
elle, ne la montre pas.
3. **8,4 % de la zone.** Assez pour que l'escalade soit une vraie facon de
franchir le relief, assez rare pour que la marche reste le mode par defaut.
A 70 % on retiendrait 20,7 % du massif et tout versant deviendrait une
paroi ; a 150 %, 3,8 %, et l'activite ne servirait plus que sur les grandes
falaises inabordables.
### Deux seuils, pas un : l'hysteresis
- **entree en escalade** : pente >= `wallSlope` = **1,00**
- **sortie (sommet)** : pente < `walkableSlope` = **0,60** (31°)
Sans cet ecart, une paroi reelle - qui oscille autour de son seuil d'un metre a
l'autre - ferait entrer et sortir du mode escalade a chaque image. 0,60 est aussi
la valeur qu'emploie `find_climb_walls.py` pour juger si une paroi a un pied
abordable : les deux **doivent** rester d'accord.
### La base de mesure : 4 m, la lecon de la Phase 13 rejouee
`slopeSampleStep = 2,0 m` (donc base de 4 m), identique a
`BikeParams::slopeSampleStep` et pour la meme raison : a 1 m - le pas de la
heightmap - le bruit decimetrique d'un DTM LiDAR fabrique des pentes fantomes.
Pour le velo ca produisait 8 % de micro-sections en contre-pente ; ici ca
produirait des "parois" au milieu d'un pierrier. 4 m est aussi l'echelle physique
du probleme : un grimpeur fait 2 m, il ne s'accroche pas a une bosse d'un metre.
### Raide ne suffit pas : `minWallRun` / `minWallRise`
**Ce parametre existe parce qu'un echec l'a impose, pas par precaution.**
La premiere version n'exigeait qu'un point au-dessus de `wallSlope` a portee. Sur
du relief mesure, le joueur qui s'approche s'accroche alors au **premier point
raide rencontre**, qui est souvent un ressaut isole de deux metres devant la
paroi. Constate directement dans les tests headless :
> engagement -> "SOMMET atteint" apres **0,3 m gagnes en 1,2 s**.
La base de 4 m elimine le bruit decimetrique, mais elle ne peut rien contre un
accident de terrain **reel** de deux metres : celui-la est une vraie pente forte,
simplement il ne mene nulle part. La seule question qui distingue une paroi d'un
ressaut est donc *"est-ce qu'y grimper fait reellement gagner de la hauteur ?"* -
et c'est exactement ce que `Climber::wallRise()` demande : simuler 6 m de
progression le long de la ligne de plus grande pente et exiger **4 m de gain**.
Les deux valeurs sont accordees sur `wallSlope`, pas choisies au hasard : a 45°
pile, 6 m parcourus sur la surface font gagner 4,24 m. Un point tout juste au
seuil passe de justesse, tout ce qui s'aplatit avant est rejete.
---
## 2. Le modele de deplacement
### L'idee, en une phrase
> Le grimpeur reste **exactement sur la surface**, et il s'y deplace le long de
> deux directions tangentes : la **ligne de plus grande pente** (monter,
> desescalader) et la **ligne de niveau** (traverser).
C'est le meme invariant que le velo - *la verticale n'est jamais une variable
d'etat, elle est relue de `heightAt()` a chaque pas* - et c'est ce qui rend
l'escalade compatible avec une heightmap **sans rien ajouter au moteur** : il n'y
a pas de "volume" de falaise a representer, seulement une surface a suivre.
### Ce que la projection produit toute seule
Avancer d'une longueur `L` le long de la surface consomme
`L / sqrt(1 + pente²)` de deplacement **horizontal**. Aucun cas particulier n'est
ecrit pour les parois verticales : c'est cette seule ligne qui fait que
| pente de la paroi | angle | gain d'altitude par metre parcouru | avance horizontale |
|---:|---:|---:|---:|
| 100 % | 45,0° | 0,707 m | 0,707 m |
| 300 % | 71,6° | 0,949 m | 0,316 m |
| 2000 % | 87,1° | **0,999 m** | **0,050 m** |
Une paroi a 87° - il y en a de vraies dans la zone de jeu - se monte donc quasi
verticalement, par construction. **Verifie par test** (`tests/logic_tests.cpp`,
section Phase 14).
### La limite honnete : pas de surplomb
Une heightmap 2,5D ne peut pas representer un devers. C'est la meme limite que
celle deja documentee en Phase 9 sur les noeuds partages des falaises. Une paroi
qui deverse est vue par la donnee comme une paroi tres raide mais positive, et se
grimpe comme telle.
### Vitesses
| | valeur | commentaire |
|---|---:|---|
| ascension / desescalade (le long de la surface) | **1,0 m/s** | 14 fois plus lent que la marche du moteur (14 m/s) |
| traversee laterale | **0,6 m/s** | une traversee est reellement plus dure : on deplace un appui a la fois |
Un grimpeur reel progresse a 0,1 - 0,3 m/s en rocher soutenu : **1,0 m/s est donc
environ 5 fois trop rapide, et c'est assume.** C'est exactement la meme concession
que la vitesse de marche du moteur, qui vaut deja ~10 fois une marche reelle. Ce
qui compte pour la consigne "plus lent que la marche normale" est le RAPPORT, et
il est de 14.
### Collision
`moveBody()`, **le meme point d'entree unique que le joueur a pied et que le
velo**. Rien n'est reecrit. Une seule difference, justifiee : la bande verticale
du corps est **centree** sur le point d'accroche (`bodyHalfHeight = 0,9 m`) au
lieu de partir des pieds, parce qu'en paroi le corps est etendu le long de la
surface et non debout dessus.
---
## 3. La jauge d'energie
Une seule jauge dans `[0, 1]`, volontairement isolee : la consigne demandait ce
parametre seul, pas un systeme de besoins primaires.
**Les couts sont PAR METRE, pas par seconde**, partout ou un travail physique est
en jeu. Consequences : monter 40 m coute la meme chose qu'on le fasse vite ou
lentement (c'est le comportement correct), et la jauge est **independante du
nombre d'images par seconde**. Les deux proprietes sont testees.
| poste | valeur | ce que ca donne |
|---|---:|---|
| montee | 0,016 / m d'altitude gagnee | **62,5 m** de paroi strictement verticale par jauge pleine |
| desescalade | 0,005 / m d'altitude perdue | 3x moins cher que la montee |
| horizontal (traversee) | 0,005 / m | on ne lutte pas contre la pesanteur |
| suspendu immobile | 0,004 / s | **le seul cout au temps** : 250 s (4 min) |
| recuperation, **au sol uniquement** | 0,05 / s | 20 s pour une jauge vide |
| minimum pour s'engager | 0,15 | evite de s'accrocher avec 1 % et de retomber aussitot |
**Desescalader coute trois fois moins cher que monter, et c'est un choix de JEU,
pas de physique.** Une desescalade reelle fatigue presque autant. Mais redescendre
doit toujours rester une porte de sortie : sinon un joueur qui s'engage trop haut
n'a plus que la chute comme issue, ce qui rend l'activite punitive au lieu d'etre
tendue.
**La recuperation ne se fait jamais en paroi.** C'est ce qui fait de la jauge une
contrainte de TRAJET et pas un simple compteur : il faut topper ou redescendre.
### Le chiffre qui donne son sens a l'activite
Mesure par test, sur une paroi a 87° (la plus raide qu'on trouve reellement) :
> **jauge pleine = 61,5 m d'ascension.**
Confronte a ce que le terrain contient (mesure par `find_climb_walls.py`) :
- les parois **abordables** de la zone font 30 a 44 m de haut -> **elles passent** ;
- les grandes falaises du massif font **250 a 276 m** -> **hors de portee d'une
seule jauge.**
Ce n'est pas un reglage rate. C'est la limite qui donne son sens a l'activite, et
elle correspond a la realite : une paroi de 270 m se fait en plusieurs longueurs
avec des relais - ce que cette session n'a pas.
---
## 4. Les transitions
Touche **X** (`GLFW_KEY_X`). Meme raisonnement que pour le B du velo : X occupe
la **meme position physique en AZERTY et en QWERTY** (rangee du bas
W-X-C-V-B / Z-X-C-V-B). Les quatre activites et les deux actions d'outillage
occupent ainsi une rangee contigue sous la main gauche : **X** escalade,
**C** percussion, **V** parapente, **B** velo.
En paroi : **Z** monter, **S** desescalader, **Q/D** traverser, **X** lacher.
### Entree
Depuis la **marche** uniquement. `Climber::tryStart` sonde 8 points repartis de 0
a `reach` = 2 m devant le **regard projete a l'horizontale** (lever les yeux vers
le haut de la falaise ne doit pas raccourcir la portee au sol) et s'accroche au
premier point qui est une paroi **et** qui passe le test `wallRise`.
L'engagement peut **echouer** - c'est ce qui distingue `tryStart()` du `mount()`
du velo, qui ne pouvait pas refuser - et le jeu dit alors pourquoi : pas de paroi
a portee, ou jauge trop basse.
### Sorties : trois, et une seule reinitialisation de position
| sortie | ou finit le joueur | declencheur |
|---|---|---|
| `ToppedOut` | **la ou il est arrive** | pente < 0,60 au point d'accroche ET 3 m plus loin |
| `Released` | au pied de la paroi | touche X |
| `Exhausted` | au pied de la paroi | jauge a 0 -> chute |
**Le sommet est la seule sortie qui ne ramene pas au pied**, et c'est toute la
recompense de l'activite.
Le point de repli des deux autres est la **position du joueur au moment de
l'engagement** : par construction du terrain ou il se tenait debout l'image
d'avant, donc du terrain ou l'on peut le reposer sans risque. Le calculer
autrement - chercher le pied de la falaise apres coup - serait chercher une
position libre sans garantie d'en trouver une. **Aucun degat** : hors scope.
`release()` et l'epuisement partagent **exactement le meme code de
reinitialisation** : lacher une paroi, c'est se retrouver au pied, qu'on l'ait
decide ou non. Une seule reinitialisation a ecrire, donc une seule a verifier.
### La confirmation du sommet : le piege de cette phase
`hasToppedOut` teste **deux** points, pas un : le point d'accroche **et** un point
3 m plus loin dans la pente.
Un seul point sortirait du mode escalade sur la moindre dalle horizontale au
milieu d'une face - donc **en plein vide**. Exiger que ca tienne sur 3 m demande
une vraie vire. Et une vire de 3 m de profondeur **est** un endroit ou l'on se
tient debout : y terminer l'escalade est donc le comportement correct, pas un
pis-aller. Les deux cas sont testes (vire de 1 m : on continue ; vire de 6 m : on
s'arrete).
**L'ordre des deux tests de sortie compte** : le sommet est teste **avant**
l'epuisement. Poser la main sur la vire avec sa derniere goutte d'energie, c'est
topper, pas tomber - et c'est la seule lecture qui ne frustre pas. Fige par test.
---
## 5. La camera : premiere personne, regard libre
`CameraMode::Climb`. **Contrat MIXTE, le seul du projet** :
- la **position** vient de `world/Climber` (imposee par `setPosition()` une fois
par image), comme pour `Glide` et `Ride` ;
- l'**orientation reste au joueur** : la souris continue de fonctionner, alors
qu'elle est entierement coupee en vol et a velo.
### Pourquoi la premiere personne
1. **C'est l'information utile.** Sur une paroi, ce qui compte est la surface
immediatement devant le visage. Une vue a la troisieme personne y placerait
l'avatar exactement devant ce qu'il faut lire.
2. **La chase-cam n'a pas de bonne place sur une paroi.** Derriere le grimpeur,
c'est le vide ; et des que la face s'incurve, l'oeil traverse le rocher. Le
velo a deja demande une garde au sol minimale (`kRideChaseMinClearance`) pour
ce genre de raison, sur du terrain bien plus doux. La premiere personne
supprime le probleme au lieu de le rustiner.
3. **Coherent avec la camera reglable** : les activites rapides et lisibles a
l'echelle du relief (parapente, velo) sont a la troisieme personne, l'activite
de precision est a la premiere. Ce n'est pas une exception, c'est la regle qui
se dessine.
### Pourquoi le regard reste libre, contrairement au vol et au velo
Parce que **les commandes de l'escalade sont relatives a la PAROI, pas au
regard** : monter suit la ligne de plus grande pente, traverser suit la ligne de
niveau, toutes deux imposees par le terrain. Le regard n'a donc plus aucune
influence sur le deplacement, et il redevient libre sans rien casser.
C'est meme necessaire : accroche a une face, on doit pouvoir lever les yeux pour
lire la suite de la voie et regarder en bas pour juger la hauteur, **sans que ca
deplace le grimpeur d'un centimetre**.
Effet de bord bienvenu : le scenario Vulkan de l'escalade n'a **rien a asservir**,
la ou celui du velo a demande un asservissement de cap (voir plus bas).
### Ou est l'oeil exactement
**La convention n'est PAS celle des trois autres activites.** A pied, a velo et
en parapente, la position du joueur est l'oeil place a `eyeHeight` = 1,7 m
**au-dessus** de la surface. En escalade, le grimpeur est **contre** la surface :
oeil = point d'accroche + normale sortante x 0,6 m + 0,3 m vers le haut
Les 1,7 m de la marche n'ont aucun sens ici - ils placeraient l'oeil bien au-dessus
des mains. Le decalage de 0,6 m (une longueur d'avant-bras) evite d'avoir le
rocher dans le plan proche.
**Et il garantit que l'oeil est hors du relief** : le decalage se fait vers
l'AVAL, donc vers une altitude de terrain plus basse que celle de l'accroche.
Ce n'est pas un espoir, c'est teste sur 200 pas d'ascension et sur toute
l'ascension LiDAR reelle.
---
## 6. Verification
### Tests headless : 334 -> **425 assertions** (+91)
`tools\run_logic_tests.bat`. Comme pour le velo, ces tests mesurent des
**grandeurs** et les confrontent a ce qu'annonce l'en-tete, au lieu de re-deriver
les equations - ce qui ne prouverait que l'accord du test avec lui-meme.
Deux terrains de test nouveaux, parce que `SlopedTerrain` (plan infini) n'a ni
pied ni sommet et ne peut donc prouver aucune transition :
- `CliffTerrain` : plat / paroi / plat. Le plus petit terrain contenant les trois
situations de l'escalade.
- `LedgedCliffTerrain` : la meme, avec une vire de largeur reglable a mi-hauteur.
Ce qui est verifie : detection de paroi (y compris pente NEGATIVE - c'est une
magnitude), hierarchie des deux seuils, engagement et ses quatre refus (dos a la
paroi, hors de portee, pas de paroi, regard vertical degenere), contact permanent
sur 400 pas, vitesse le long de la surface et sa projection verticale, ascension
quasi verticale a 87°, traversee sur la ligne de niveau et sa symetrie
gauche/droite, oeil hors du relief, couts d'energie par metre (et leur
independance au pas de temps), cout au temps en suspension, rapport
descente/montee, recuperation au sol seulement et jamais en paroi, hauteur
maximale par jauge pleine, **les trois sorties avec leur position finale exacte**,
priorite du sommet sur l'epuisement, vire etroite contre vire large, seuil
d'energie a l'engagement, collision par `moveBody`.
**Bloc sur relief LiDAR reel** (conditionnel a la presence de la dalle) :
`LHD_0899_6436_1m.vchm`, voie de reference E 899900 / N 6435550, cap 0°.
[mesure] jauge pleine sur une paroi a 87 deg : 61.5 m atteints
[mesure] voie de reference E 899900 N 6435550 : pente au depart 56.9 %
[mesure] ascension sur relief LiDAR reel : 19.5 m gagnes en 26.1 s,
sortie SOMMET, energie restante 60 %
### Vulkan reel : scenario F, **6 scenarios sur 6**
`tools\run_vulkan_check.ps1`, sous couches de validation. Dalle
`LHD_0907_6440_1m.vchm`, depart **E 907616 / N 6439312**.
**Le point de depart a ete choisi par mesure**, comme celui du velo. Le harnais ne
peut pas tourner la camera (GLFW lit le curseur SYSTEME), donc le joueur regarde
forcement plein NORD. Un balayage de la dalle entiere n'a trouve que **trois**
points reunissant les trois conditions : depart marchable + paroi grimpable a
moins de 2 m plein nord + ascension gagnant au moins 15 m.
Le run enchaine les deux sorties que le harnais peut atteindre : montee,
traversee droite et gauche, desescalade, **lachage volontaire**, repos au sol,
**re-engagement**, puis montee continue jusqu'au **sommet**.
Engagement / lachage : True / True
Re-engagement / SOMMET : True / True
Releves de telemetrie : 75
Jauge d'energie : minimum 14 %
recuperation constatee : True
Gain d'altitude maximal : 41,6 m au-dessus du pied de la paroi
Pente sous les mains : 64 % a 157 % (seuil de paroi : 100 %)
Altitude parcourue : 501,5 m a 542,8 m (denivele 41,3 m)
Messages [Validation] : 0
Lignes [ERROR] / [WARN] : 0 / 0
Code de sortie A..F : 0 / 0 / 0 / 0 / 0 / 0
Fermeture propre A..F : True / True / True / True / True / True
**41,6 m gagnes avec 14 % de jauge restante** : le dimensionnement de l'energie
produit bien la tension visee sur une paroi reelle, sans la rendre infranchissable.
**La CHUTE par epuisement n'est PAS exercee sous Vulkan**, et il faut le dire :
elle demanderait une paroi de plus de 62 m, et il n'en existe pas d'abordable
plein nord sur cette dalle. Elle est couverte par les tests headless, ou elle est
verifiee jusqu'a la position de repli exacte.
### Reproductibilite : l'escalade est deterministe, le velo ne l'est pas
Deux runs consecutifs de `run_vulkan_check.ps1`, meme binaire :
| | run 1 | run 2 |
|---|---:|---:|
| **F** gain d'altitude | **41,6 m** | **41,6 m** |
| **F** jauge minimale | **14 %** | **14 %** |
| **F** releves | **75** | **75** |
| E vitesse de pointe (velo) | 50,0 km/h | 44,1 km/h |
| E denivele suivi (velo) | 96,8 m | 67,7 m |
Le scenario F se reproduit **au chiffre pres** la ou le scenario E varie de 12 a
30 %. Ce n'est pas de la chance : le velo integre une vitesse, donc le moindre
decalage de timing dans le harnais s'accumule en distance parcourue et change le
terrain rencontre. L'escalade, elle, n'a **aucune quantite de mouvement** - la
vitesse est imposee, pas integree - et ses commandes sont relatives a la paroi,
donc la trajectoire ne depend que du terrain. Un decalage de timing ne change que
la duree, jamais le chemin.
Consequence pratique : les assertions du scenario F peuvent etre serrees sans
devenir instables, contrairement a celles du scenario E.
### L'erreur de raisonnement de cette session (la meme qu'en Phase 13)
Le premier test sur relief reel visait le centre d'une paroi reperee par
`find_climb_walls.py` (E 899850 / N 6435230) et l'abordait plein est. Il a
echoue - et l'echec etait instructif :
> **cette paroi DESCEND vers l'est.** Le test approchait donc par le SOMMET,
> marchait au bord de la falaise, et le grimpeur remontait correctement les 3,9 m
> qu'il venait de descendre avant de topper. **Le modele avait raison, c'est la
> geometrie du test qui etait fausse.**
C'est exactement la lecon du scenario E de la Phase 13 : *savoir qu'il y a de la
pente quelque part ne dit pas PAR OU l'aborder, et le terrain de l'autre cote
d'un point est un AUTRE terrain.* D'ou le mode **`--routes`** ajoute a l'outil,
qui evalue le relief **le long de chaque cap** depuis un pied marchable, au lieu
de se contenter de reperer des zones de paroi.
Corollaire mesure, a retenir : **le grimpeur suit la ligne de plus grande pente,
qui s'incurve, alors que l'outil mesure le relief le long d'un cap FIXE.** Les
deux trajets divergent, et le gain reellement obtenu (19,5 m) est inferieur a la
projection en ligne droite (21,4 m). C'est un resultat, pas un defaut - mais ca
interdit de recopier le chiffre de l'outil dans une assertion.
### Non-regression : complete
- **425 assertions headless** (334 avant, +91), toutes vertes.
- **`run_vulkan_check.ps1` : 6/6, zero validation, du premier coup**, deux runs
consecutifs. Scenarios A a E inchanges et verts (2 abattages, 3 debitages,
9 ramassages, 1 percussion, vol de parapente avec atterrissage naturel, sortie
a velo a 50,0 km/h au pic sur 96,8 m de denivele suivi).
- **Scenes annexes**, relancees une a une : `cube`, terrain procedural, dalle de
Phase 7, dalle de Phase 7 en `--no-lod`, zone 25 km2 a 1 m, zone 25 km2 sans
vegetation. **Toutes a 0 validation / 0 ERROR / 0 WARN / fermeture propre.**
- `--dump-world` retrouve **16 AIM sur 16**.
- **Aucun chemin de rendu n'est touche.** Pas de nouveau `DrawItem`, pas de
nouveau materiau, pas de nouvelle allocation Vulkan : l'escalade est a la
premiere personne, il n'y a meme pas de marqueur a dessiner. C'est la seule des
quatre activites dans ce cas. La synchronisation GPU n'ayant pas ete touchee,
la validation de synchronisation (`VK_LAYER_VALIDATE_SYNC`) n'avait rien de
nouveau a regarder.
- `Camera` : une valeur d'enum ajoutee (`Climb`), une branche dans `setMode`, et
un booleen `orientationOnly` dans `update()` qui saute la bascule F et le
deplacement clavier. Le bloc souris n'a **pas** ete duplique.
---
## 7. Hors scope, assume
Conformement au cadrage de la session :
- **pas de systeme de prises individuelles** : une paroi assez raide est
grimpable entierement, il n'y a pas de "bon" ou de "mauvais" endroit sur la
face ;
- **pas de materiel** : ni corde, ni mousqueton, ni point d'assurage, ni relais ;
- **pas de meteo** affectant l'adherence ;
- **pas de degats** : une chute est une reinitialisation de position propre, rien
de plus ;
- pas de surplomb (limite structurelle de la 2,5D, voir plus haut).
---
## 8. Ce qui reste a ameliorer, par ordre d'importance
1. **Les grandes falaises du massif sont inaccessibles, et pas seulement a cause
de l'energie.** Les six meilleures parois par denivele (250 a 276 m) ont **0 a
2 % de pied marchable** dans leur anneau a 10 m : on ne peut litteralement pas
les atteindre a pied. C'est le vrai verrou de l'activite, avant meme la jauge.
Ce qui les debloquerait est un systeme de **relais** (reprendre de l'energie a
mi-paroi) ET une facon d'y arriver - ce qui pointe vers le parapente comme
moyen d'approche, donc vers une interaction entre activites qui n'existe pas
encore.
2. **Aucune prise individuelle, donc aucune difficulte locale.** Toute paroi
au-dessus du seuil se grimpe a la meme vitesse et au meme cout, qu'elle fasse
105 % ou 2000 %. Faire dependre la vitesse et le cout de la pente locale
serait la premiere amelioration a cout nul, et bien avant un vrai systeme de
prises.
3. **Le seuil de 100 % est un choix, pas une mesure**, et il retient 8,4 % du
massif. C'est le parametre a revoir en premier si l'escalade se revele trop
presente ou trop rare a l'usage. `find_climb_walls.py` est fait pour rejouer
la mesure a n'importe quel seuil.
4. **La descente n'a pas de cout de risque.** Desescalader coute trois fois moins
cher que monter et ne peut jamais mal tourner : c'est la sortie sans risque,
ce qui affaiblit la tension que la jauge est censee creer.
5. **Rien ne relie l'escalade a la marche en dehors de la touche X.** Un versant
a 90 % se monte encore a pied sans effort - la marche n'a toujours aucune
limite de pente. Tant que ce sera le cas, l'escalade restera facultative :
on ne grimpe que ce qu'on veut bien grimper, jamais ce qu'il faut franchir.
6. **La chute n'est pas exercee sous Vulkan** (voir plus haut), faute de paroi
assez haute abordable plein nord sur la dalle de test.
7. Aucun controle d'IMAGE sur la vue en escalade - meme limite ouverte que pour
la vue a la troisieme personne du velo.
8. Pas d'animation ni de son : l'escalade est un glissement silencieux le long
d'une surface.
+380
Voir le fichier
@@ -0,0 +1,380 @@
# Phase 13 (2026-08-22) : physique du velo
Premiere version de la troisieme activite. Meme intention que le parapente de la
Phase 8 : un modele **simplifie mais credible**, chiffre et testable, pas une
simulation de dynamique du vehicule.
Fichiers neufs : `src/world/Bike.{hpp,cpp}`. Touches par `src/main.cpp`,
`src/core/Camera.{hpp,cpp}`, `tests/logic_tests.cpp`,
`tools/run_vulkan_check.ps1`, `CMakeLists.txt`, `tools/run_logic_tests.bat`.
---
## 1. Le modele
`Bike` ne connait ni Vulkan ni la `Camera`. Il consomme les deux interfaces qui
existaient deja - `core/HeightSampler` pour l'altitude et la pente,
`core/CollisionSolver` pour les obstacles - et produit une position, un cap, une
vitesse et deux angles d'assiette. **Exactement la meme separation que
`Paraglider`**, ce qui lui vaut d'etre compile ET execute dans les tests
headless, sans GPU.
### Dynamique longitudinale
Une somme d'accelerations, integree a chaque pas. Aucun terme n'agit
instantanement sur la vitesse : ni le pedalage, ni le frein.
```
a = -g.sin(theta) pesanteur le long de la pente
+ pedalAcceleration . (1 - v/pedalSpeedLimit) pedalage (nul si on freine)
- brakeDeceleration . brakeInput frein manuel
- rollingResistance - dragCoefficient.v^2 resistances
```
`sin(theta)` et non `tan(theta)` : sur une paroi LiDAR a 300 % la difference est
un facteur trois, et `tan` divergerait. La zone de jeu contient reellement de
telles parois (voir `NOTES-PHASE9.md`).
### Les valeurs, et pourquoi
| parametre | valeur | justification |
|---|---:|---|
| `pedalAcceleration` | 2,6 m/s² | ~250 W au demarrage sur ~95 kg (velo + cycliste) : un cycliste ordinaire en danseuse |
| `pedalSpeedLimit` | 6,5 m/s | au-dela la cadence s'emballe, l'effort n'est plus utile |
| `rollingResistance` | 0,35 m/s² | coeff. ~0,036 : pneu large basse pression sur terre |
| `dragCoefficient` | 0,014 /m | **terme groupe** : aero (~0,004) + sol irregulier + suspension + le fait qu'un vetetiste ne laisse pas filer sa machine. **C'est lui qui fixe les vitesses de pointe**, et c'est le parametre le plus arbitraire du modele |
| `brakeDeceleration` | 6,0 m/s² | ~0,61 g, la limite avant passage par-dessus le guidon |
| `maxSpeed` | 13,9 m/s (50,0 km/h) | plafond absolu ; ne mord qu'au-dela de ~32 % de pente |
| `maxLateralAccel` | 4,0 m/s² | ~0,41 g, adherence d'un pneu large sur terre seche |
| `maxTurnRateDegPerSec` | 140 °/s | manoeuvre pieds a terre ; sans lui la formule de braquage diverge a l'arret |
| `bodyRadius` | 0,45 m | contre 0,35 m a pied : un guidon est plus large que des epaules |
| `slopeSampleStep` | 2,0 m | demi-base de mesure de la pente ; **voir la section 3**, c'est le reglage qui a demande une mesure sur relief reel |
### Les vitesses obtenues — LE chiffre qui compte
Mesurees sur plans inclines, avec le code du jeu (sonde hors ligne, puis
re-verifiees par les tests headless) :
| pente | pedalage a fond | roue libre |
|---:|---:|---:|
| plat | **16,9 km/h** | 0 |
| +5 % | 13,5 km/h | 0 |
| +10 % | **10,0 km/h** | 0 |
| +15 % | 6,2 km/h | 0 |
| +20 % | 2,4 km/h | 0 |
| +25 % | **0 (cale)** | 0 |
| -5 % | 20,2 km/h | 8,6 km/h |
| -10 % | 23,3 km/h | 22,9 km/h |
| -20 % | 37,4 km/h | **37,4 km/h** |
| -30 % | 47,2 km/h | **47,2 km/h** |
| -40 % | 50,0 km/h (plafond) | 50,0 km/h |
La consigne demandait 30-50 km/h en descente et beaucoup moins en montee : c'est
obtenu entre -20 % et -40 %, et la montee tombe a un cinquieme du plat des 15 %.
**Pente maximale franchissable : 23,6 %.** C'est ou `g.sin(theta)` egale
`pedalAcceleration - rollingResistance`. Au-dela, le velo cale et **ne recule
pas** (la vitesse est ecretee a zero). Voir la section 5 : c'est la limite la
plus visible du modele sur ce massif.
Le velo ne part pas non plus tout seul sur une pente faible : a -2 % en roue
libre la resistance au roulement l'emporte, il reste immobile.
### Direction
Rayon de braquage **fini et croissant avec la vitesse** :
```
omega = min( maxLateralAccel / v , maxTurnRateDegPerSec ) R = v² / maxLateralAccel
```
- a 10 m/s : R = 25 m, soit 23 °/s ;
- a 5 m/s : R = 6,3 m, soit 46 °/s ;
- a l'arret : 140 °/s, le plafond - on replace la machine, on ne "tourne" pas.
Impossible, donc, de pivoter sur place a pleine vitesse. Verifie par la mesure :
le test confronte le rayon OBSERVE a `v²/maxLateralAccel`.
### Contact avec le sol et assiette
La verticale **n'est jamais une variable d'etat** : `position.y` est relue de
`heightAt()` a chaque pas, y compris des `mount()`. Le velo ne decolle donc
jamais d'une bosse, par construction et non par reglage.
L'assiette est **purement visuelle** (elle n'entre dans aucun calcul) :
- tangage = `atan` de la pente le long du cap ;
- roulis = devers (`-atan` de la pente en travers) **+** inclinaison en virage
(`atan(a_lat / g)`, l'angle d'equilibre d'un vrai deux-roues).
Les deux sont ecretes a ±45° : une paroi LiDAR verticale coucherait sinon le
marqueur a plat.
### Obstacles : rien n'a ete reecrit
`Bike::update` construit un `BodyCylinder` et appelle **`moveBody()`**, le point
d'entree unique de la collision du projet - le meme que
`Camera::resolveCollisions`, le meme que les tests de la Phase 6. Meme bande
verticale (`feetY` = pieds, `headY` = un peu au-dessus des yeux), donc une souche
basse arrete le velo comme elle arrete les jambes.
Seul ajout : **le choc coute de la vitesse**, proportionnellement a ce que
l'obstacle a mange du pas voulu. Frotter un tronc en le longeant n'en retire
presque rien ; le percuter de face arrete net. C'est la seule consequence d'un
choc dans cette session - ni degats ni chute, explicitement hors scope.
---
## 2. Integration : touche, camera, exclusions
**Touche B** (`kBikeKey` dans `main.cpp`). B occupe la **meme position physique
en AZERTY et en QWERTY** (rangee du bas W-X-C-V-B contre Z-X-C-V-B), donc le
token GLFW tombe sur la touche gravee B des deux cotes - contrairement a W/A qui
donnent Z/Q. Et elle est juste a cote de V, la touche du parapente.
- **B depuis la marche** : en selle, cap = la direction du regard projetee.
- **B a velo** : pied a terre, la camera revient en mode marche sur la position
du velo.
- Pendant la sortie : **Z** pedale, **S** freine, **Q/D** tournent.
- E/R/C (abattre, ramasser, percuter) sont **desactives** a velo, comme en vol.
- On ne peut pas decoller en parapente a velo, ni enfourcher le velo en vol.
**Camera : nouveau mode `CameraMode::Ride`**, troisieme personne, meme contrat
que `Glide` (la camera est passive, elle recoit sa pose par `setChasePose()`).
Un mode distinct et non un alias de `Glide` : les journaux doivent dire lequel
est actif. Choix de la troisieme personne : la meme raison qu'au parapente, la
lisibilite du mouvement - ici l'assiette du velo sur le relief.
Une contrainte que le parapente n'avait pas : **une garde au sol minimale de
1,2 m pour l'oeil**. En descente la camera recule *dans* la pente qu'on vient de
devaler ; sans ce plancher elle passe sous la surface et on voit l'interieur du
terrain.
Une ligne de telemetrie par seconde tant qu'on roule (vitesse, pente sous les
roues, cap, assiette, altitude). Ce n'est pas du confort : c'est la seule facon
pour le harnais automatise de constater que la physique a travaille sur du vrai
relief - un velo bloque a 0 km/h donnerait autrement un run parfaitement vert.
---
## 3. La mesure qui a change le code : `slopeSampleStep`
Le premier reglage - differences finies a ±1 m, le pas de la heightmap - semblait
evident. **Il ne marche pas**, et c'est le run sur relief reel qui l'a montre :
le velo s'immobilisait definitivement au milieu d'un versant qui descend a 27 %.
Depouillement de ce versant (200 m plein nord depuis E 907172 / N 6439790,
dalle `LHD_0907_6440`, descente moyenne de **26,7 %**) :
| demi-base | ecart-type de la pente | sections en **contre**-pente | pic |
|---:|---:|---:|---:|
| **1 m** | 16,4 % | **8,0 %** | **+22,0 %** |
| 2 m | 15,1 % | 6,1 % | +10,5 % |
| **2 m sur 4 m de base (retenu)** | | **1,6 %** | **+1,1 %** |
| 4 m | 14,0 % | 1,6 % | +1,1 % |
A ±1 m, une descente franche presente **8 % de micro-sections montantes a plus de
20 %** - donc au-dela de la pente maximale franchissable (23,6 %). Le velo calait
en pleine descente.
A ±2 m (base de 4 m), ces sections tombent a 1,6 % avec un pic a +1,1 %, **sans
toucher a la pente moyenne** (-26,9 % contre -26,8 %). Ce n'est pas un artifice :
un DTM LiDAR a 1 m porte du bruit decimetrique, et une machine de 1,1 m
d'empattement lancee a 20 km/h ne "sent" pas un creux d'un metre. Au-dela de 4 m
de base on commencerait a effacer de vraies ruptures de pente.
**Autre defaut trouve par la meme voie** : le seuil d'arret (`kSpeedEpsilon`,
2 cm/s) etait applique inconditionnellement apres chaque integration. Consequence
non voulue : il **empechait tout demarrage** dont l'acceleration etait inferieure
a `kSpeedEpsilon / dt`, soit 1,2 m/s² a 60 images/s. Le velo restait cloue a
0 km/h des 10 % de montee, et ne pouvait meme pas se laisser descendre une pente
de 10 % en roue libre, alors que le bilan des accelerations etait franchement
positif. C'est un seuil d'**arret** : il ne s'applique plus que si le bilan des
accelerations est negatif.
Aucun des deux defauts n'etait visible sur un plan incline synthetique. Les deux
ont ete trouves en roulant sur la dalle LiDAR.
---
## 4. Verification
### Tests headless : 334 assertions (280 avant, **+54**)
`tools\run_logic_tests.bat`, sans GPU ni Vulkan. La section Phase 13 ne
re-derive pas les equations - ca ne prouverait que l'accord du test avec
lui-meme - elle **mesure les vitesses d'equilibre reelles** et les confronte aux
fourchettes annoncees. Couvert :
- contact permanent avec le sol, verifie a chacun des 300 pas d'une descente ;
- lecture de la pente le long du cap (montee, descente, en travers) ;
- inertie : une frame de pedalage ne donne qu'une fraction de m/s ; le frein a
fond ne met pas a l'arret en une frame ; distance d'arret plausible ;
- vitesses d'equilibre sur plat, +10 %, +25 % (cale, **et ne recule pas**),
-20 %, -30 %, et **-200 %** (pente extreme : bornee, aucun NaN, aucune
divergence) ;
- roue libre a -2 % : le velo ne part pas tout seul ;
- rayon de braquage fini, croissant avec la vitesse, egal a `v²/a_lat` mesure ;
plafond a l'arret ; sens de rotation dans les deux sens ;
- assiette : tangage sur la pente, devers en travers, inclinaison en virage
(droite et gauche), ecretage sur une paroi ;
- **collision** : le velo n'entre pas dans un tronc, s'arrete au contact, y perd
sa vitesse - **avec temoin** : sans solveur, le meme trajet traverse. Une
souche basse l'arrete aussi ;
- `update()` sans `mount()`, apres `dismount()`, a `deltaTime` nul : sans effet ;
- ecretage des entrees : passer 50 se comporte comme passer 1.
Le temoin de collision merite d'etre souligne : sans lui, un test ou le velo
n'avance pas du tout passerait pour un test de collision reussi.
### Vulkan reel : `run_vulkan_check.ps1`, **5 scenarios sur 5**
Nouveau **scenario E** : sortie a velo sur la dalle LiDAR reelle, sous couches de
validation. **Zero `[Validation]`, zero `[ERROR]`, zero `[WARN]`, codes de sortie
0/0/0/0/0, fermeture propre 5 fois sur 5.**
**Quatre versions du scenario ont ete necessaires**, et les trois premieres ont
echoue chacune pour une raison differente. C'est le vrai contenu de cette
section : ce qu'il faut pour qu'un scenario automatise PROUVE quelque chose.
1. **Depart quelconque.** Le harnais ne sait pas tourner la camera (GLFW lit le
curseur systeme), donc le velo part forcement au cap initial. Lance n'importe
ou, il roule sur du plat : run vert, rien de montre.
2. **Depart sur un versant a -21 %.** La descente marchait, la remontee non : elle
depassait la pente franchissable (23,6 %) et le velo s'immobilisait pour de
bon. C'est ce run qui a mis au jour le reglage de `slopeSampleStep`
(section 3).
3. **Descendre, puis faire demi-tour et remonter la meme ligne.** Piege double.
D'une part, plus la descente est longue - et il lui faut de la longueur pour
que la vitesse se developpe - plus elle depose le velo bas dans le versant, la
ou la pente depasse le franchissable : 18 s de roue libre donnaient 9,2 m de
denivele (trop peu), 30 s en donnaient 24,4 mais aboutissaient a une remontee
a 0,1 km/h. **Incompatibles dans cet ordre.** D'autre part - l'erreur de
raisonnement de fond - **"faire demi-tour" ne redonne pas la pente inverse** :
le terrain de l'autre cote du point de depart est un AUTRE terrain. Sur la
croupe essayee, le nord descendait a -11 %... et le sud descendait aussi, a
-36 %.
**La version retenue evalue la pente le long de CHAQUE cap** (differences
centrees a ±2 m, exactement comme le fait `Bike`) sur toute la dalle, et retient
un point qui offre les deux a la fois :
> depart `--start=907875,6439450`, altitude 513,2 m
> - **montee cap 220°** : +14,8 % en moyenne sur 90 m, pire section +16,8 %, donc
> **aucune section infranchissable** - le velo monte sans caler ;
> - **descente cap 40°** : -25,0 % en moyenne sur 170 m, pire section -63 %,
> franche mais roulable (les parois a -600 % de la dalle ne testeraient que le
> plafond de vitesse, pas une descente VTT).
La montee se fait en premier : la descente qui suit repasse par le point de
depart et gagne le denivele grimpe en elan supplementaire.
Le **demi-tour est ASSERVI**, pas minute. Un demi-tour "1,4 s a 140 °/s" a ete
essaye et rate : le temps vu par le jeu n'est pas celui du `Start-Sleep`, et sur
ces versants le devers depasse 25 %, donc 18° d'ecart suffisent a sortir de la
fourchette mesuree. Le jeu journalise deja son cap chaque seconde : le script
tourne par courtes rafales, frein tire, en relisant le cap entre chaque, jusqu'a
±8° de la cible.
**Resultats du scenario E**, deux runs consecutifs :
| | run 1 | run 2 |
|---|---:|---:|
| Releves de telemetrie | 66 | 66 |
| Vitesse maximale | **50,0 km/h** | 49,7 km/h |
| En descente (pente <= -8 %) | 50,0 au pic, **31,4 km/h de moyenne** sur 39 releves | 49,7 au pic, 29,4 de moyenne sur 42 |
| En montee (pente >= +8 %) | 6,0 au pic, **5,4 km/h de moyenne** sur **20** releves en mouvement | 6,0 au pic, 5,5 de moyenne sur 20 |
| Releves a l'arret en cote | **2** | **2** |
| Denivele reellement gagne en pedalant | **4,4 m** | **4,4 m** |
| Pente rencontree | -71,0 % a +16,2 % | -69,9 % a +16,4 % |
| Altitude parcourue | 422,5 a 519,3 m, **96,9 m suivis** | 424,0 a 519,4 m, 95,4 m suivis |
Les deux runs sont **reproductibles au dixieme** sur les grandeurs qui comptent
(denivele gagne, nombre de releves en montee, calages) - ce qui n'etait pas le
cas des versions precedentes, ou le denivele gagne oscillait entre 1,9 et 6,3 m
d'un run a l'autre. C'est le signe que le scenario ne fonctionne plus par chance.
Le critere de succes ne se contente pas de constater que les touches ont ete
recues. Il exige une descente ET une montee franches, une vitesse de descente
reelle sous le plafond de 50 km/h, une montee plus lente que la descente **en
moyenne calculee en mouvement**, au moins **2 m d'altitude reellement GAGNES en
pedalant** - une pente positive peut etre "rencontree" a l'arret, et un pic de
vitesse en cote peut n'etre que l'elan emporte depuis la descente - et au moins
12 m de denivele suivi.
Le velo a traverse des pentes locales jusqu'a -71 % sans diverger, sans NaN, sans
jamais depasser son plafond (il l'atteint : 50,0 km/h pile).
---
## 5. Ce qui n'est pas satisfaisant, honnetement
1. **La pente franchissable de 23,6 % est basse pour ce massif.** En dessous, le
velo monte proprement et sans a-coups : sur le versant a +14,8 % du scenario E,
20 releves en mouvement contre **2 calages** seulement. Au-dessus, il
s'immobilise net - et le massif depasse 23,6 % tres souvent (les versants
depouilles ont des devers moyens de 25 a 29 %). Sur une premiere version du
scenario, posee sur un versant a 27 %, le rapport s'inversait : 41 releves a
l'arret contre 3 en mouvement.
Le modele **suppose qu'on zigzague** - il lit la pente LE LONG DU CAP, donc
traverser en biais reduit reellement l'effort, et c'est exactement ce que fait
un vetetiste. C'est jouable, mais un joueur qui pointe droit dans la pente est
bloque sans explication. `pedalAcceleration` est le parametre a revoir, **mais
pas a l'aveugle : il faut d'abord decider si "monter droit dans un versant a
27 %" doit etre possible dans ce jeu.** A pied, ca ne l'est pas non plus.
2. **La vitesse limite demande beaucoup plus de distance sur du relief MESURE que
sur un plan.** Les 47 km/h annonces a -30 % supposent une pente soutenue ; un
vrai versant est fait de terrasses et de ressauts. Le premier essai de
scenario, sur un versant a -21 %, plafonnait a 23 km/h parce qu'une terrasse
coupait la descente au bout de 25 m. Le versant retenu, a -25 %, atteint bien
le plafond de 50,0 km/h - mais la **moyenne** sur toute la descente n'est que
de 31 km/h. C'est un resultat, pas un defaut : le terrain reel est plus
contraignant que le modele.
3. **Le marqueur est un cube.** Comme le pilote de parapente. Il est en revanche
oriente CORRECTEMENT (cap, tangage, roulis), ce qui est le seul moyen de lire
a l'ecran l'assiette calculee - donc de verifier a l'oeil ce que disent les
tests. Un vrai mesh de velo viendra avec l'habillage.
4. **Pas de suspension, pas de transfert de charge, pas de derapage.** Le
`dragCoefficient` groupe tout ca dans un seul terme, ce qui est assume mais
fait de lui le parametre le plus arbitraire du modele.
5. **La collision ne concerne que les arbres de `Forest`** (16, autour de
l'origine). Les dizaines de milliers d'arbres de `Vegetation` se traversent
toujours - limite deja ouverte depuis la Phase 11, que le velo rend plus
voyante puisqu'on couvre du terrain bien plus vite.
6. **Aucun controle d'image** n'a ete fait sur la vue a la troisieme personne du
velo. La garde au sol de la camera est raisonnee et codee, pas mesuree sur une
capture. C'est la meme limite que celle ouverte depuis la Phase 10 : aucun
test automatique ne regarde l'IMAGE.
## 6. Hors scope, assume (conforme a la consigne)
Pas de degats ni de chute en cas de choc ; pas d'usure du velo ; pas de velo
comme objet ramassable ou fabricable. Le velo est disponible en permanence par la
touche B.
---
## 7. Non-regression
- **334 assertions headless** (280 avant, +54), du premier coup.
- **`run_vulkan_check.ps1` : 5 scenarios sur 5, deux runs consecutifs**, zero
`[Validation]`, zero `[ERROR]`, zero `[WARN]`, codes de sortie 0/0/0/0/0,
fermeture propre partout. Scenarios A a D (gameplay synthetique, collision,
dalle LiDAR, parapente) **inchanges et verts** : 2 abattages, 3 debitages,
ramassages, 1 percussion, vol de parapente avec atterrissage naturel.
- **Scenes annexes** relancees une a une (lancement, 6 s, `WM_CLOSE`) : `cube`,
terrain procedural, dalle de Phase 7 en `--no-lod`, et la zone de 25 km2 a
1 m. **Toutes : code de sortie 0, zero `[Validation]`, zero `[ERROR]`, zero
`[WARN]`, fermeture propre.**
- `vercora.exe --dump-world` : **16 lignes AIM sur 16**, inchange.
- Aucun chemin de rendu touche : `Bike` ne parle pas a Vulkan, et le seul ajout
cote rendu est un `DrawItem` de plus (le marqueur), sur le materiau `Object`
qui existait deja.
- `Camera` : une valeur d'enum ajoutee (`Ride`) et deux branches qui la traitent
comme `Glide`. Aucune modification du mode Walk, Free ou Glide.
+434
Voir le fichier
@@ -0,0 +1,434 @@
# NOTES — Phase 10 : quadtree, LOD continu et frustum culling
Session du 2026-08-21. Suite directe du verdict de la Phase 9 (`NOTES-PHASE9.md`
§6) : « le moteur envoie un seul maillage entier à chaque image, le coût est
proportionnel à la surface, le streaming par tuiles devient nécessaire
maintenant ».
Cette session pose les fondations demandées : structure de quadtree, sélection de
LOD par distance avec geomorphing continu (CDLOD), frustum culling par nœud, et
un cache de tuiles GPU. Le découplage rendu/collision est vérifié.
---
## 1. Le résultat, d'abord
Même zone, même position de caméra (le centre du terrain, E 901500 N 6437500,
altitude 1947 m), même binaire, `tools\measure_terrain.ps1`, Debug avec couches
de validation, Intel UHD 770.
| Scène | Phase 9 (bloc unique) | **Phase 10 (quadtree + LOD + culling)** | Gain |
|---|---:|---:|---:|
| **25 km² au pas de 1 m** | 12 FPS / 4 014 Mo | **487 FPS / 246 Mo** | **×40 FPS, ÷16 RAM** |
| **25 km² au pas de 2 m** | 46 FPS / 1 083 Mo | **601 FPS / 166 Mo** | ×13 FPS, ÷6,5 RAM |
| 1 dalle 1 m (Phase 7) | 247 FPS / 302 Mo | **847 FPS / 141 Mo** | ×3,4 FPS, ÷2,1 RAM |
| Procédural (Phase 4) | 1 381 FPS / 108 Mo | 1 244 FPS / 106 Mo | ×0,90 (voir §6) |
**Zéro message `[Validation]`, zéro `[ERROR]`/`[WARN]` sur les quatre scènes.**
Le chiffre à retenir n'est pas seulement le FPS : sur la zone au pas de 1 m, la
géométrie réellement soumise au GPU passe de **50 000 000 de triangles à 548 864**
(67 tuiles × 8 192), soit **1,1 %**. Le temps de chargement tombe de **10,4 s à
0,5 s**, parce qu'on ne construit plus 25 M de sommets pour les jeter dans un
seul buffer.
### Le contrôle qui compte : ce n'est pas un culling cassé
Un bug de culling produit d'excellents FPS — on ne dessine plus rien. Le chiffre
seul ne prouve donc rien. `tools\screenshot_scene.ps1` (nouveau) capture la même
vue avec et sans LOD : `build\shots\zone_lod.png` et `build\shots\zone_nolod.png`
sont visuellement **identiques** (relief, falaise, arbres, pierre au sol), à la
finesse du maillage lointain près, qui est précisément l'effet recherché.
---
## 2. Architecture
Quatre briques neuves, séparées selon la ligne de fracture habituelle du projet
(ce qui dépend de Vulkan / ce qui n'en dépend pas et se teste sans GPU).
| Fichier | Rôle | Dépend de Vulkan |
|---|---|---|
| `src/core/Frustum.hpp` | 6 plans du tronc de vision, test boîte, distance à une boîte | non |
| `src/world/TerrainQuadtree.{hpp,cpp}` | arbre, bornes, sélection de LOD, culling | non |
| `src/renderer/TerrainNodeMesh.{hpp,cpp}` | maillage d'une tuile + cible de geomorphing | non |
| `src/renderer/TerrainStreamer.{hpp,cpp}` | cache GPU, budget, éviction LRU, `DrawItem` | oui |
Les trois premières sont compilées **et exécutées** dans `tests/logic_tests.cpp` ;
la quatrième est vérifiée en syntaxe seulement. C'est la même séparation qui
avait permis de tester la Phase 7 sans GPU.
### 2.1 Le quadtree
La grille d'altitudes est découpée en nœuds carrés. **Chaque nœud est toujours
maillé avec le même nombre de sommets** — 65 × 65, soit 8 192 triangles. Ce qui
change d'un niveau à l'autre, c'est le **pas d'échantillonnage** :
```
niveau 0 (feuille) : pas 1 -> couvre 64 cellules (64 m au pas de 1 m)
niveau L : pas 2^L -> couvre 64 * 2^L cellules
```
Un nœud de niveau L coûte donc exactement le même prix GPU qu'une feuille tout en
couvrant 4^L fois plus de terrain. La racine est le plus petit niveau dont
l'emprise couvre la grille entière.
| Terrain | Cellules | Niveaux | Nœuds | Tuile L0 |
|---|---:|---:|---:|---:|
| Procédural | 127 | 0..1 | 5 | 50 m |
| Dalle Phase 7 | 1 000 | 0..4 | 341 | 64 m |
| Zone 25 km² 2 m | 2 500 | 0..6 | 2 139 | 128 m |
| Zone 25 km² 1 m | 5 000 | 0..7 | 8 380 | 64 m |
Deux détails de construction qui ont leur importance :
- **Les bornes verticales d'une feuille sont calculées à la PLEINE résolution**,
pas au pas du nœud. Une boîte trop petite ferait disparaître du terrain au
culling ; les bornes des nœuds internes remontent ensuite des fils, ce qui est
exact et gratuit.
- **Les indices sont écrêtés sur le bord du terrain.** 5 000 n'est pas un
multiple de 64 : la racine couvre 8 192 cellules, dont 3 192 hors données. Sans
écrêtage on obtiendrait une « étagère » plate de 3,2 km au-delà du terrain ;
avec, les sommets excédentaires se superposent au bord et produisent des
triangles dégénérés, invisibles.
### 2.2 Sélection de LOD
Une portée par niveau, qui **double** à chaque niveau :
```
range[L] = rangeFactor * tailleMonde(tuile de niveau L) (rangeFactor = 3)
```
Au pas de 1 m : `L0 ≤ 192 m, L1 ≤ 384 m, ... L7 ≤ 24 576 m`.
La descente part de la racine :
```
si le nœud est hors du frustum -> abandon (tout le sous-arbre tombe)
si niveau 0, ou distance >= range[L-1] -> le nœud est DESSINÉ à son niveau
sinon -> on descend dans les 4 fils
```
La distance est celle de la caméra à la **boîte** du nœud, pas à son centre : sur
une grande tuile dont on rase le bord, la distance au centre donnerait un niveau
trop grossier.
Le résultat est un anneau concentrique de niveaux autour de la caméra, avec la
pleine résolution (pas de 1 m) au contact immédiat du joueur. Un test headless
vérifie que **les tuiles retenues pavent le terrain exactement** — somme des
emprises = surface du terrain, donc ni trou ni recouvrement.
### 2.3 Geomorphing continu — et pourquoi il ne sert pas qu'à l'esthétique
Chaque sommet porte, en plus de sa position et de sa normale, **sa position et sa
normale dans la grille du niveau supérieur** (deux attributs de sommet neufs,
locations 4 et 5). La cible s'obtient en arrondissant les indices **locaux** vers
le bas à un multiple de deux : un sommet d'indice pair est déjà sur la grille du
parent et ne bouge pas, un sommet impair vient se confondre avec son voisin pair.
À morph = 1, la tuile a donc **exactement** la forme de son parent.
Le vertex shader interpole selon la distance du sommet à la caméra, dans une
bande `[0,70 × range[L], 0,95 × range[L]]` poussée par push constant.
Deux effets, et le second est le plus important :
1. **Pas de popping** au changement de niveau : la géométrie fine a déjà pris la
forme de la grossière au moment de la bascule.
2. **Pas de fissure entre tuiles de niveaux différents.** Au-delà de `range[L]`,
une tuile de niveau L est entièrement morphée sur la grille L+1 ; sa voisine
de niveau L+1 y est encore à morph = 0, donc sur cette même grille. Les deux
bords coïncident au sommet près. C'est ce qui évite d'avoir à coudre les
bords ou à poser des jupes.
C'est pour cette raison que `morphStartRatio` **doit** rester > 0,5 (sinon la
bande commence avant `range[L-1]` et le raccord se rouvre). Le constructeur
refuse une valeur invalide, et un test headless le vérifie.
La distance est mesurée sur la position **non morphée** : c'est ce qui garantit
qu'un sommet partagé par deux tuiles voisines obtient le même facteur des deux
côtés.
### 2.4 Frustum culling
`Frustum::fromViewProjection` extrait les six plans par la méthode
Gribb-Hartmann. Un piège évité : le plan **proche** est `row2` et non
`row3 + row2`, parce que `GLM_FORCE_DEPTH_ZERO_TO_ONE` est actif (convention
Vulkan, z ∈ [0,1]) — prendre la convention OpenGL donnerait un plan proche deux
fois trop loin devant la caméra.
Le test boîte/frustum est **conservateur dans le bon sens** : une boîte hors
champ peut être déclarée visible (on dessine pour rien, c'est bénin), mais une
boîte visible ne l'est jamais déclarée invisible — ce serait un trou.
La matrice de projection vient de `Renderer::projectionMatrix()`, exposée pour
l'occasion, et `updateUniformBuffer` l'appelle désormais aussi : **une seule
définition**, donc aucun risque que le culling et le rendu ne voient pas le même
tronc de vision.
### 2.5 Résidence des tuiles (`TerrainStreamer`)
Le quadtree de la zone 1 m compte 8 380 nœuds ; les mailler tous coûterait plus
cher que le bloc unique de la Phase 9. Seules les tuiles **sélectionnées** sont
construites, et gardées tant que la place le permet. Trois garde-fous :
1. **Budget par frame** (4 tuiles). Chaque upload passe aujourd'hui par un
staging + `vkQueueWaitIdle` (`VulkanBuffer::copyFrom`), c'est-à-dire une
synchronisation complète avec le GPU. Les tuiles manquantes sont servies aux
frames suivantes, **les plus proches d'abord** — la sélection est triée par
distance exprès. La toute première frame est exemptée, pour que la vue
initiale s'affiche d'un coup.
2. **Plafond de résidence** (512 tuiles ≈ 188 Mo). Chaque tuile consomme deux
allocations Vulkan, et `maxMemoryAllocationCount` est typiquement de 4 096.
3. **Éviction LRU**, jamais sur une tuile utilisée dans la frame courante (ce
serait du thrashing pur).
En pratique, sur la zone 1 m à l'arrêt : **67 tuiles sélectionnées, 67 dessinées,
67 résidentes, 24 Mo de géométrie GPU**. Le plafond n'est jamais approché.
---
## 3. Ce qu'il a fallu changer dans l'existant
| Fichier | Changement | Pourquoi |
|---|---|---|
| `Vertex.hpp` | +`morphPos`, +`morphNormal` (44 → 68 octets) | cibles de geomorphing |
| `VertexFormat.hpp` | 4 → 6 attributs décrits | idem |
| `Pipeline.{hpp,cpp}` | `ShaderSet::usesMorphAttributes` | voir ci-dessous |
| `DrawItem.hpp` | +`params` (vec4), +`DrawItemPush` | bande de morphing par tuile |
| `Renderer.{hpp,cpp}` | `removeMesh`, réemploi de poignées, `projectionMatrix()`, `addMesh(…, log)` | le streaming crée et détruit des maillages en permanence |
| `Mesh.{hpp,cpp}` | paramètre `log` | une ligne de journal par tuile noierait tout |
| `shaders/terrain.vert` | geomorphing | — |
| `shaders/cube.vert` | déclare le bloc push constant complet | plage identique pour les deux pipelines |
| `main.cpp` | quadtree par défaut, option `--no-lod` | mesure avant/après sur le même binaire |
Deux points valent d'être notés.
**`ShaderSet::usesMorphAttributes` n'est pas une optimisation, c'est une
correction.** Décrire au pipeline un attribut qu'aucun shader ne lit fait émettre
aux couches de validation `Vertex attribute at location 4 not consumed by vertex
shader`, et le contrat du projet est zéro message. Le format de sommet reste
unique côté C++ ; c'est seulement sa *description* au pipeline qui est tronquée
à 4 attributs pour le matériau `Object`. Le stride reste `sizeof(Vertex)`.
**La destruction d'un mesh est différée de `kMaxFramesInFlight + 1` frames.** Le
GPU peut encore lire les buffers d'une frame déjà soumise ; les détruire tout de
suite serait une erreur de validation immédiate. Le vieillissement se fait juste
après l'attente de la fence, c'est-à-dire à un instant où l'on sait qu'une frame
de plus est réellement terminée.
---
## 4. Découplage rendu / collision — vérifié
**Rien n'a changé côté physique, et c'est le résultat attendu.** La `Heightmap`
pleine résolution reste en mémoire et reste la source **unique** de
`heightAt()` : c'est elle que consomment `Camera` (marche), `Forest` (abattage,
collision troncs/souches), `Ground` (objets au sol) et `Paraglider`
(atterrissage). Le quadtree ne détient que des **bornes** ; il n'a ni copie ni
version simplifiée des altitudes, et ne peut donc pas influencer la physique.
Trois vérifications :
1. Test headless dédié : `heightAt()` donne la même valeur au bit près, que le
quadtree vienne d'être sélectionné depuis 5 000 m d'altitude (tout au niveau
le plus grossier) ou au contact du point mesuré (tout au niveau 0).
2. Test headless : au nœud de grille, `heightAt()` vaut exactement `at()` — la
surface de collision est bien celle de la donnée, pas celle d'une tuile
grossière.
3. `run_vulkan_check.ps1`, 4 scénarios sur 4 **du premier coup** : 2 arbres
abattus, 3 débitages, 8 objets ramassés (bûche, branche, pierre, éclat), 1
percussion réussie, chemin de collision tronc → souche, vol de parapente avec
atterrissage naturel sur le relief LiDAR. Zéro validation.
Au contact du joueur, les tuiles sont de niveau 0 (pas de 1 m) : la surface
**affichée** y est donc également celle de la donnée. L'écart rendu/collision
n'existe qu'au loin, là où personne ne marche.
---
## 4bis. Traversée en mouvement — le vrai test du streaming
`measure_terrain.ps1` mesure à l'arrêt : le cache de tuiles y est figé après la
première frame, et rien n'est jamais évincé. C'est `traverse_terrain.ps1` qui
exerce réellement le streaming.
**20 km parcourus sur la zone 25 km² au pas de 1 m** (2,5 km par branche, aller-
retour sur les deux axes, ce qui sort deux fois du terrain et y revient) :
| Branche | Distance | FPS moyen | FPS min |
|---|---:|---:|---:|
| nord | 2 500 m | 725 | 210 |
| sud (traverse et sort au sud) | 5 000 m | 608 | 151 |
| nord (retour au centre) | 2 500 m | 459 | 146 |
| est | 2 500 m | 550 | 286 |
| ouest (traverse et sort à l'ouest) | 5 000 m | 564 | 370 |
| est (retour au centre) | 2 500 m | 555 | 339 |
**Zéro message `[Validation]`, zéro `[ERROR]`/`[WARN]` sur les 20 km.** Aucune
chute localisée aux anciennes frontières de dalles, aucun blocage, aucune chute à
travers le sol. Le **minimum instantané reste à 146 FPS** — soit douze fois le
chiffre *moyen* de la Phase 9 à l'arrêt.
Le maximum de 3 209 FPS sur les branches de 5 000 m n'est pas une anomalie : ces
branches sortent de l'emprise (le terrain fait ±2 500 m depuis le centre), la
caméra regarde alors hors du terrain et le culling ne retient presque rien. C'est
le comportement attendu.
### Le seul incident, et ce qu'il vaut
Sur ce run de 20 km, **le jeu n'est pas sorti dans les 30 s après `WM_CLOSE`** et
le script l'a tué (code -1). C'est le seul échec de la session. Enquête menée
plutôt que rangée sous le tapis :
- **Traversée de 3,2 km, mêmes conditions : sortie propre, code 0.**
- **Sonde dédiée chronométrant la fermeture** après 0 s, 60 s et 180 s de marche
continue (jusqu'à **130 tuiles résidentes**, 47 Mo de géométrie GPU) :
**0,1 s de fermeture dans les trois cas.**
Le temps de sortie **ne dépend donc pas** du nombre de tuiles résidentes ni de la
durée de la session. Rien ne rattache l'incident au streaming. Il correspond à la
flakiness de pilotage par `PostMessage` déjà documentée depuis la Phase 7 (voir
`MEMORY.md`) — mais **30 s reste beaucoup pour une simple lenteur, et l'incident
n'a pas été reproduit : il est signalé comme non élucidé, pas comme classé.** À
re-tenter au prochain run long.
---
## 5. Tests
- **`tests/logic_tests.cpp` : 185 → 223 assertions**, toutes passent. 38 neuves,
réparties en : frustum (5 cas dont derrière-la-caméra et au-delà du far),
`distanceToAABB`, structure de l'arbre, bornes de la racine, sélection par
distance, tri, bande de morphing, **pavage exact du terrain**, culling effectif,
maillage d'une tuile (sommets sur la grille au niveau 0), **propriétés du
geomorphing** (pair immobile / impair confondu avec son voisin), topologie
partagée, sommets dans les bornes, **découplage collision**, grille non multiple
de 64, refus des paramètres invalides.
- **`run_vulkan_check.ps1` : 4/4, zéro validation, du premier coup.**
- **`traverse_terrain.ps1` : 20 km sur la zone 25 km², zéro validation** (§4bis),
puis 3,2 km avec sortie propre.
- **Scènes non-terrain intactes** : `vercora.exe cube` tourne à 3 403 FPS sans
message de validation (le matériau `Object` n'a que 4 attributs décrits, cf.
§3), et `--dump-world` retrouve toujours **16 arbres visables sur 16**.
- **`measure_terrain.ps1`** : nouvelle option `-GameArgs` pour mesurer la même
scène avec et sans LOD sans recompiler.
- **`screenshot_scene.ps1`** (nouveau) : capture la fenêtre via `PrintWindow` +
`PW_RENDERFULLCONTENT` (sans ce drapeau une fenêtre Vulkan ressort noire) et
estime la proportion de ciel, garde-fou automatique contre un terrain disparu.
---
## 6. Compromis et limites — à dire franchement
### Le chemin `--no-lod` a RÉGRESSÉ, et c'est le prix des attributs de morphing
Mesuré avec le binaire de la Phase 10 sur la zone 1 m :
| | Phase 9 | Phase 10 `--no-lod` |
|---|---:|---:|
| FPS | 12 | **9** |
| RAM | 4 014 Mo | **5 636 Mo** |
Le sommet est passé de 44 à 68 octets (+55 %) pour porter `morphPos` et
`morphNormal`. Sur 25 M de sommets, cela coûte 600 Mo de plus côté CPU et autant
côté GPU. **Ce chemin n'existe que pour la comparaison** ; le chemin réel, lui,
n'a jamais 25 M de sommets en vol. Deux façons de récupérer ça plus tard :
n'encoder que le *delta* de morphing (souvent nul), ou reprendre `color` et `uv`,
inutilisés par le terrain.
### Le terrain procédural perd 10 % de FPS (1 381 → 1 244)
Deux causes : les 127 cellules sont couvertes par 4 tuiles de 64 (donc 32 768
triangles au lieu de 32 258, plus un peu d'écrêtage), et le sommet est plus gros.
À 1 244 FPS c'est sans conséquence, mais c'est une vraie petite régression, pas
du bruit de mesure.
### Ce qui n'est PAS fait
- **Pas de transfert asynchrone.** `VulkanBuffer::copyFrom` fait un
`vkQueueWaitIdle` : chaque tuile construite synchronise complètement le GPU.
C'est ce qui impose le budget de 4 tuiles par frame. Le vrai correctif est une
queue de transfert dédiée avec fence, pas un budget plus gros. **C'est le
chantier n°1 de la suite.**
- **Pas de repli sur l'ancêtre.** Une tuile sélectionnée mais pas encore
construite n'est simplement pas dessinée. À la marche (14 m/s) le budget suit
largement ; en parapente à grande vitesse, des trous peuvent apparaître
brièvement à l'horizon.
- **Pas d'index buffer partagé.** La topologie est identique pour toutes les
tuiles (le test le vérifie) mais chaque tuile a encore son propre index buffer :
98 Ko × nombre de tuiles gaspillés, et deux allocations Vulkan par tuile au lieu
d'une. Économie facile, non faite.
- **Pas de streaming disque.** La `Heightmap` entière (95 Mo au pas de 1 m) est
toujours chargée en RAM d'un bloc. C'est ce qui rend le découplage collision
simple, et ce n'est pas le facteur limitant aujourd'hui — mais ça le deviendra
quand la zone dépassera 25 km².
- **La contrainte « grilles carrées uniquement » de `TerrainFile` n'est pas
tombée.** Elle n'était pas sur le chemin critique de cette session.
- **La scène par défaut n'a pas changé** : `vercora.exe` sans argument charge
toujours la dalle de la Phase 7. La zone 25 km² tourne maintenant à 487 FPS et
pourrait devenir le défaut ; c'est un choix de jeu, pas de moteur, et il revient
à l'utilisateur.
- **Les paramètres du quadtree ne sont pas réglables en ligne de commande**
(`nodeCells`, `rangeFactor`, budgets). Ils sont dans `TerrainStreamer::Params`
avec des valeurs par défaut mesurées, mais les faire varier demande de
recompiler.
- **Aucune mesure en mouvement rapide n'a été faite en parapente** sur la zone
25 km² : le pilotage par PostMessage ne peut pas orienter la caméra, donc un vol
scripté ne balaierait pas vraiment le terrain.
- **La sortie bloquée du run de 20 km n'est pas expliquée** (§4bis). Non
reproduite, non corrélée à la résidence des tuiles, mais non classée.
### Ce qui reste incertain
Le raccord entre niveaux repose sur l'argument du §2.3, vérifié par construction
et par les tests headless sur les propriétés du morphing — mais **aucun test
automatique ne cherche une fissure dans l'image rendue**. Les captures ne
montrent rien de visible ; ce n'est pas une preuve.
---
## 7. Où sont les choses
| Chemin | Quoi |
|---|---|
| `src/core/Frustum.hpp` | plans du tronc de vision, test boîte, distance à une boîte |
| `src/world/TerrainQuadtree.{hpp,cpp}` | arbre, bornes, sélection de LOD, culling |
| `src/renderer/TerrainNodeMesh.{hpp,cpp}` | maillage d'une tuile + cible de geomorphing |
| `src/renderer/TerrainStreamer.{hpp,cpp}` | cache GPU, budget, LRU, `DrawItem` |
| `tools/screenshot_scene.ps1` | capture d'une scène (contrôle visuel automatisable) |
| `build/shots/zone_lod.png` | zone 25 km² 1 m avec LOD, 482 FPS |
| `build/shots/zone_nolod.png` | même vue sans LOD, 9 FPS — comparaison |
Commandes utiles :
```bash
tools\build.bat
tools\run_logic_tests.bat
powershell -File tools\run_vulkan_check.ps1
powershell -File tools\measure_terrain.ps1 -Scene assets\terrain\vercora_zone_1m.vchm
powershell -File tools\measure_terrain.ps1 -Scene assets\terrain\vercora_zone_1m.vchm -GameArgs --no-lod
powershell -File tools\screenshot_scene.ps1 -Scene assets\terrain\vercora_zone_1m.vchm -Out build\shots\zone_lod.png
```
---
## 8. Prochaines étapes suggérées
0. **Reproduire ou écarter la sortie bloquée du run de 20 km** (§4bis) : relancer
une traversée longue et, si ça se reproduit, attacher un débogueur au moment du
`WM_CLOSE`. C'est la seule inconnue de la session.
1. **Transfert asynchrone des tuiles** (queue dédiée + fence) — supprime le
`vkQueueWaitIdle` par upload, donc le budget de 4 tuiles par frame, donc les
trous en déplacement rapide. C'est le vrai verrou restant.
2. **Index buffer partagé** entre toutes les tuiles : une allocation par tuile au
lieu de deux, et 98 Ko économisés par tuile. Facile.
3. **Alléger le sommet** : n'encoder que le delta de morphing, ou reprendre
`color`/`uv` inutilisés par le terrain.
4. **Orthophoto BD ORTHO** sur E 899000–904000 / N 6435000–6440000 : premier
contrôle *visuel* de l'orientation du relief, en attente depuis la Phase 7. Les
UV sont générés par tuile en coordonnées du terrain ENTIER, donc continus :
le placage n'aura rien à recalculer.
5. **Décider de la scène par défaut** — la zone 25 km² est maintenant jouable.
6. Exploiter la classification LiDAR (classe 5) pour semer les arbres là où il y
en a vraiment.
+673
Voir le fichier
@@ -0,0 +1,673 @@
# NOTES — Phase 11 : habillage visuel du terrain reel
Session du 2026-08-21 (la meme journee que les Phases 9 et 10). Objet : donner
une COULEUR au terrain LiDAR, qui n'en avait aucune, puis l'habiller de
vegetation a l'echelle des 25 km2 reels.
Le point de depart est la Phase 10 : quadtree CDLOD, 487 FPS sur la zone au pas
de 1 m, et un terrain colore par une rampe altitude/pente codee dans le fragment
shader. Aucune texture n'existait dans le moteur — ni image, ni echantillonneur,
ni binding de descriptor. La Phase 11 a donc du poser tout le chemin de texture
avant de pouvoir afficher le premier texel de photo aerienne.
---
## Resume des chiffres
Toutes les mesures : Intel UHD 770, build **Debug avec couches de validation**,
1280x720, `tools\measure_terrain.ps1`, camera VERROUILLEE (voir plus bas).
**Zero message `[Validation]` sur la totalite des mesures de ce document.**
### Zone 25 km2 au pas de 1 m, position de depart par defaut
| Etat | FPS median | Pic RAM |
|---|---:|---:|
| Phase 10 reproduite (`--no-ortho --no-vegetation`) | **514** | 240 Mo |
| Phase 11 complete (orthophoto + arbres + herbe) | **271** | 332 Mo |
Le repere de la Phase 10 inscrit dans MEMORY.md etait 487 FPS / 246 Mo ; les
514 FPS / 240 Mo mesures ici sont le MEME chemin de code, l'ecart venant du
verrouillage de la camera (voir « captures reproductibles »). Le chemin Phase 10
n'a donc pas regresse.
### Cout de chaque brique, meme vue (E 901500 N 6436600, yaw 100, pitch -7)
| Etat | FPS median | Pic RAM |
|---|---:|---:|
| Terrain seul (Phase 10) | 658 | 231 Mo |
| + orthophoto | 637 | 332 Mo |
| + arbres de decor | 466 | 332 Mo |
| + herbe | 283 | 332 Mo |
**L'orthophoto coute 3 % de FPS et 101 Mo de RAM.** C'est le meilleur rapport
de la session : le gain visuel est enorme et le prix en images par seconde
quasi nul. Les 101 Mo sont la texture (48 Mo cote GPU) plus le tampon de
transfert transitoire.
**Les arbres coutent 26 %, l'herbe 39 % de plus.** Voir « ce que coute
reellement la vegetation » ci-dessous : ce n'etait PAS la geometrie.
### Autres scenes — non-regression
| Scene | Phase 10 | Phase 11 `--no-vegetation` | Phase 11 complete |
|---|---:|---:|---:|
| Terrain procedural | 1 244 FPS | **1 348 FPS** | 258 FPS |
| Dalle Phase 7 (1 km) | 847 FPS | **884 FPS** | 212 FPS |
| Cube | 3 403 FPS | — | **3 593 FPS** |
Le chemin de la Phase 10 est intact et meme legerement plus rapide. La baisse
en « Phase 11 complete » sur ces deux scenes n'est pas une regression : c'est le
COUT DE LA VEGETATION, qui y est semee par un substitut (ces scenes n'ont pas de
carte LiDAR de couvert) et qui y est proportionnellement tres visible faute
d'autre chose a dessiner. `--no-vegetation` rend exactement les anciens chiffres.
---
## TACHE 1 — Orthophoto BD ORTHO drapee sur le relief
### Provenance et telechargement
`tools/fetch_ortho.py`. Service **WMS raster de la Geoplateforme**
(`https://data.geopf.fr/wms-r/wms`), couche `HR.ORTHOIMAGERY.ORTHOPHOTOS`
(intitulee « Ortho 20 cm », BD ORTHO V3), licence Etalab — le meme portail et la
meme licence que le LiDAR HD de la Phase 9.
Le WMS a ete prefere au telechargement des dalles BD ORTHO livrees : il accepte
une bbox arbitraire en Lambert 93, donc il donne EXACTEMENT l'emprise du terrain
sans avoir a recouper des dalles dont le decoupage n'est pas celui du LiDAR.
Trois contraintes du service, verifiees et non supposees :
1. **Le serveur ne parle que WMS 1.3.0.** Une requete 1.1.1 est rejetee
(`VersionNegotiationFailed`).
2. **L'ordre des axes en EPSG:2154 est EST, NORD.** C'est le piege classique de
WMS 1.3.0, ou l'ordre depend du CRS. Tranche par l'experience et non par la
lecture de la norme : `BBOX=minE,minN,maxE,maxN` renvoie l'imagerie attendue,
l'ordre inverse renvoie une image **BLANCHE UNIFORME**. Le controle est
rejoue a chaque execution (`--self-test`), pour qu'un changement de
comportement du serveur se voie tout de suite et pas sur une texture en
miroir.
3. **MaxWidth = MaxHeight = 5010 px**, d'ou le decoupage en tuiles.
Resultat : **25 tuiles de 1 km a 0,5 m/px (2000 px), 23,8 Mo en 101 s**, aucun
echec. Le decoupage kilometrique est aligne sur celui des dalles LiDAR, ce qui
rend les deux jeux de donnees directement comparables.
L'emprise est **lue dans l'en-tete du .vchm**, jamais passee en argument. Une
bbox recopiee a la main derive au premier changement de zone, et une orthophoto
decalee de quelques metres est exactement le genre de defaut qu'on ne voit pas
sur une capture mais qui met les arbres a cote des arbres.
Emprise obtenue : **E 899 000 – 904 000, N 6 435 000 – 6 440 000** (5 000 m de
cote), identique au terrain assemble en Phase 9.
### Alignement texture / terrain
C'est le point ou une erreur passe inapercue, donc celui qui est le plus
detaille.
**Difference de nature entre les deux grilles.** La heightmap est un semis de
NOEUDS : le noeud `ix = 0` est exactement a E 899 000. L'orthophoto est une
grille de PIXELS-SURFACES : le pixel 0 COUVRE `[E0, E0+res]` et son centre est a
`E0 + res/2`. La bbox demandee au WMS est donc `[E0, E1] x [N0, N1]` : l'image
couvre exactement le carre delimite par les noeuds extremes, bord a bord.
**Le demi-texel residuel est assume.** Echantillonner a `u = 0` vise le BORD du
premier texel et non son centre ; l'ecart vaut `res/2`, soit 30 cm au pas de la
texture finale. C'est en dessous de la precision de la BD ORTHO elle-meme et
sans commune mesure avec le pas du terrain.
**Les UV n'ont rien coute.** `TerrainNodeMesh` emettait deja, depuis la Phase 10,
`uv = (gx/cells, gz/cells)` sur le terrain ENTIER et non sur la tuile — un choix
fait a l'epoque « pour une future orthophoto ». Consequence : l'UV est continu
d'une tuile de quadtree a l'autre, independant du niveau de detail, et
`gz = 0` correspond au NORD, c'est-a-dire a la ligne 0 de l'image, c'est-a-dire
a `v = 0`. **Aucun retournement n'a ete necessaire.**
**L'UV n'est PAS morphe** (`shaders/terrain.vert`). La cible de geomorphing d'un
sommet est un autre noeud de la meme grille, qui porte donc naturellement l'UV
de sa propre position. Interpoler entre les deux ferait glisser la photo par
rapport au relief pendant une transition de niveau.
**Verification de coherence a l'execution.** `orthoMatchesTerrain()` dans
`main.cpp` compare l'emprise inscrite dans le `.vcto` a celle de la heightmap
chargee, a 0,5 m pres, et REFUSE une texture qui ne correspond pas. Sans ce
controle, associer par megarde la photo d'une zone au relief d'une autre produit
un rendu parfaitement plausible que rien ne signale.
### Deux controles independants de l'alignement
1. **Photo contre relief ombre.** La mosaique et un ombrage du relief de la meme
emprise, rendus a la meme taille, superposent falaises, ravines et
escarpements. C'est le controle que la Phase 9 disait explicitement ne pas
pouvoir faire « faute d'orthophoto a plaquer » : il est fait, et il confirme
l'orientation nord-en-haut du `.vchm`.
2. **Classification LiDAR contre couleur de la photo** (voir tache 2) :
correlation couvert / luminance de **-0,729**. Les deux jeux de donnees sont
georeferences par des chaines completement independantes ; leur accord vaut
validation croisee.
### Format `.vcto` et compression
Nouveau format maison, meme esprit que le `.vchm` : en-tete de 128 octets
(magie, version, dimensions, nombre de mipmaps, format, emprise Lambert 93 en
double, EPSG, libelle) puis les niveaux de mipmap consecutifs. La definition de
reference est en tete de `tools/make_ortho_texture.py`, le chargeur est
`src/assets/TextureFile.cpp` (aucune dependance Vulkan, donc teste sans GPU).
**Pourquoi les mipmaps sont PRECALCULEES.** Le chemin habituel — les generer sur
le GPU par `vkCmdBlitImage` en cascade — est inapplicable a un format compresse :
on ne sait pas filtrer des blocs BC1. Il fallait donc soit renoncer a la
compression, soit reduire PUIS compresser chaque niveau hors ligne. C'est le
second choix, et il rend le code de chargement plus court, pas plus long : un
`vkCmdCopyBufferToImage` par niveau, sans transition intermediaire.
**Pourquoi BC1.** A 8192 px de cote sur 5 km :
| | Niveau 0 | Chaine complete |
|---|---:|---:|
| RGBA8 non compresse | 268 Mo | 357 Mo |
| **BC1 (6:1)** | **32 Mo** | **44,7 Mo** |
Sur un GPU integre dont la memoire est prise sur la RAM systeme, et apres une
Phase 10 qui avait ramene l'empreinte a 246 Mo, la difference n'est pas
cosmetique. Le support de BC1 est **verifie** (`vkGetPhysicalDeviceFormatProperties`)
et le refus est explicite, avec le repli nomme (`--format rgba`), plutot qu'un
message de driver.
**Encodeur BC1 maison** (numpy, vectorise, par paquets de 262 144 blocs) : boite
englobante avec retrait d'un seizieme, le chemin rapide de stb_dxt. Qualite
mesuree et AFFICHEE a chaque encodage : **PSNR 33,2 dB** sur le niveau 0, mesure
par un decodeur ecrit independamment qui repart des octets produits — donc
capable d'attraper une erreur d'ordre des bits qu'un aller-retour interne
masquerait.
> **Bug trouve par cette mesure.** Le premier encodage donnait 22,0 dB. Cause :
> la matrice des distances au carre etait accumulee en `int16` par `np.einsum`,
> alors qu'une distance monte a `3 x 255^2 = 195 075`. Le debordement etait
> silencieux, l'`argmin` choisissait une couleur au hasard, et rien n'echouait.
> Sans le PSNR affiche systematiquement, la texture serait partie en production
> avec un quart de sa qualite.
### Resolution : le compromis, et sa limite
- Source BD ORTHO : **20 cm** natif.
- Telecharge : **50 cm** (10 000 x 10 000 px, 23,8 Mo).
- Texture GPU : **8192 x 8192, soit 0,61 m/texel**.
Le 8192 est choisi pour rester proche du pas de la source (0,5 m) sans gaspiller :
descendre a 20 cm aurait demande 25 000 px de cote, soit 625 Mpx, ce qui n'a de
sens qu'avec un systeme de texture virtuelle qui n'est pas au programme.
**Limite assumee, visible.** A 0,61 m/texel, un texel couvre environ 150 pixels
d'ecran quand on regarde le sol a 3 m devant soi : la photo y est etiree et
floue. L'orthophoto est excellente a moyenne et longue distance et molle sous les
pieds. Le remede standard est une texture de detail melangee de pres selon la
pente et l'altitude ; ce n'est pas fait dans cette phase.
### Integration au moteur
- `src/renderer/Texture.{hpp,cpp}` : image, memoire, vue, echantillonneur.
**Anisotropie demandee au maximum du GPU**, ce qui compte particulierement ici
(un plan regarde en rasant depuis la hauteur d'oeil). La feature
`samplerAnisotropy` est OPTIONNELLE en Vulkan : elle est activee sur le device
logique si le GPU la propose (`VulkanContext::anisotropyEnabled()`), et
abandonnee proprement sinon — la demander sans l'avoir activee est une erreur
de validation immediate.
- `VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE`, jamais REPEAT : la texture recouvre
exactement l'emprise, et un sommet legerement hors bornes (l'ecretage de la
heightmap en produit) irait sinon chercher la couleur du bord oppose,
plusieurs kilometres plus loin.
- `VK_FORMAT_BC1_RGB_UNORM_BLOCK` et non la variante `_SRGB` : la swapchain est
en UNORM et l'eclairage est calcule tel quel depuis la Phase 2 ; une variante
sRGB ferait subir a la seule orthophoto une conversion que rien d'autre
n'applique.
- **Binding 1 du descriptor set, declare pour TOUS les materiaux**, y compris
ceux qui ne l'echantillonnent pas. Un descriptor present mais non lu est
legal ; deux layouts differents auraient impose deux jeux de pipelines et deux
pools. Le binding n'est jamais vide : une texture **1x1 blanche** l'occupe tant
qu'aucune photo n'est chargee.
- **Repli conserve.** `ubo.terrain.z` porte le dosage orthophoto / coloration
procedurale. Touche **O** en jeu, `--no-ortho` en ligne de commande. Le dosage
est force a zero quand aucune texture n'est reliee, sinon la bascule
afficherait un terrain uniformement blanc au lieu du repli procedural.
- **L'eclairage continue de s'appliquer par-dessus la photo.** Une orthophoto est
prise a la verticale par temps clair, donc deja a peu pres uniformement
eclairee ; la relancer dans le Blinn-Phong avec la normale du relief est ce qui
redonne du volume aux versants qu'une photo plaquee telle quelle aplatit.
---
## TACHE 2 — Arbres a l'echelle des 25 km2
### La classification LiDAR est exploitable, et elle est excellente
C'etait la question ouverte. Reponse : oui, sans reserve.
`tools/lidar_to_canopy.py` depouille les 25 dalles (**150 s au total**, ~4 s par
dalle) et produit deux cartes. Repartition mesuree des classes ASPRS sur une
dalle representative :
| Classe | | Part |
|---:|---|---:|
| 2 | sol | 89,9 % |
| 5 | vegetation haute | 4,7 % |
| 1 | non classe | 2,8 % |
| 3 | vegetation basse | 1,9 % |
| 4 | vegetation moyenne | 0,7 % |
| 6, 64 | bati, bruit | < 0,1 % |
**Deux grandeurs, deux fichiers**, parce que ce sont deux questions distinctes :
- **Couvert** (`vercora_zone_canopy.vchm`) : part des retours de vegetation
(classes 3, 4, 5) parmi tous les retours valides de la cellule. Une FRACTION,
donc insensible a la densite de vol, contrairement a un comptage brut. Dit
**ou** semer.
- **Hauteur de canopee** (`vercora_zone_canopy_height.vchm`) : altitude du plus
haut retour de classe 5 moins celle du plus bas retour de sol, dans la meme
cellule. Dit **quelle taille** donner aux arbres.
Grille : **1001 x 1001 au pas de 5 m**, exactement la meme origine et la meme
emprise que le terrain — seul le pas differe, donc un point du monde s'y lit avec
la meme formule, sans demi-cellule a corriger.
Le maximum plutot qu'un percentile pour la hauteur : il se calcule en un seul
passage sans rien stocker, et sur une cellule de 5 m il designe le plus grand
arbre de la cellule, ce qui est exactement la grandeur voulue. Les classes de
bruit sont exclues et la valeur est ecretee a 45 m.
**Reutilisation du format `.vchm`, assumee et justifiee.** Un `.vchm` est une
GRILLE DE FLOTTANTS GEOREFERENCEE ; rien dans le format n'impose que le flottant
soit une altitude. Le moteur relit donc ces cartes avec `loadTerrainFile()` sans
une ligne de code nouvelle, et herite gratuitement de l'interpolation bilineaire
de `heightAt()` et de la conversion monde <-> Lambert 93.
Statistiques obtenues : couvert moyen **0,418**, **58 %** des cellules au-dessus
de 0,15 ; canopee moyenne **15,5 m** sur les cellules boisees, **55,6 %** des
cellules a 3 m ou plus ; **0,05 %** de cellules sans aucun retour.
### Validation de la carte : le test decisif
Une carte de couvert plausible mais fausse (miroir, decalage) serait
indetectable a l'oeil. Elle a donc ete confrontee a l'orthophoto, qui est une
source totalement independante :
| | RVB moyen sur la photo | Luminance |
|---|---|---:|
| Cellules tres couvertes (couvert > 0,70 ; 34,8 % de la zone) | (67, 75, 72) — **vert sombre** | 71 |
| Cellules nues (couvert < 0,05 ; 33,1 % de la zone) | (162, 162, 153) — **gris clair** | 159 |
**Correlation couvert / luminance : -0,729.** Plus il y a de vegetation dans le
LiDAR, plus la photo est sombre — exactement ce qu'on attend d'une pessiere sur
du calcaire. L'indice d'exces de vert, lui, ne correle presque pas (+0,079) :
sur ce massif la foret de coniferes est sombre mais peu saturee, et c'est la
LUMINANCE qui discrimine. Ce detail a son importance pour qui refera le controle.
### Architecture : deux systemes de vegetation, pas un
`world/Vegetation.{hpp,cpp}`, a cote de `world/Forest` qui reste inchange.
| | `Forest` (Phases 5-6) | `Vegetation` (Phase 11) |
|---|---|---|
| Nombre | 16 | dizaines de milliers |
| Etat | debout / en chute / en debitage | aucun |
| Interaction | abattage, collision, visee | decor pur |
| Stockage | vecteur, parcouru en entier | **rien** |
| Rendu | un DrawItem par arbre | **une instance par arbre** |
Les fusionner obligerait a payer partout le prix du plus exigeant : `resolve()`
et `pickTree()` de `Forest` parcourent le vecteur en entier a chaque appel, ce
qui est parfait pour seize arbres et intenable pour cinquante mille.
**Aucun arbre n'est stocke pour les 25 km2.** Le semis est une FONCTION
DETERMINISTE de la cellule, obtenue par HACHAGE et non par un generateur a etat.
Un `std::mt19937` imposerait un ordre d'appel : la cellule (17, -42) ne donnerait
le meme resultat que si toutes les precedentes avaient ete tirees dans le meme
ordre — faux des que le joueur arrive par un autre chemin. Le hachage ne depend
que de ses entrees. **C'est teste** (« semis independant du chemin parcouru »).
### Placement
Cellules de **24 m**, **8 emplacements** par cellule. Pour chaque emplacement :
1. **Densite par le couvert reel** : `ramp(couvert, 0,20, 0,75)`, et
l'emplacement `k` n'est retenu que si `k < densite x 8`. Comparer l'indice a
un seuil plutot que tirer un de a chaque emplacement garantit que les
emplacements sont retenus **toujours dans le meme ordre** — ce qui rend
coherente la portee par emplacement ci-dessous, et evite qu'un arbre change
d'identite quand la densite bouge d'un cheveu.
2. **Filtre de pente** : rejet au-dela de 1,1 en tangente (~48 deg).
3. **Hauteur** : la carte de canopee donne le plus grand arbre de sa cellule de
5 m ; les sujets d'un meme bosquet se repartissent entre 55 % et 100 % de
cette valeur, sinon la futaie a l'aspect d'une brosse.
Densite obtenue sur toute la zone : **59 arbres/ha** en moyenne (journalisee au
demarrage), soit de l'ordre de 150 000 arbres sur les 25 km2 — dont seuls
quelques milliers existent a un instant donne.
### Niveau de detail de DENSITE
Chaque emplacement a sa **PROPRE portee** : l'emplacement 0 porte a 1 100 m, le
dernier a 320 m, les autres interpoles. De loin, seuls les premiers emplacements
de chaque cellule subsistent : la foret s'eclaircit progressivement au lieu de
disparaitre d'un bloc. Chaque arbre a donc sa propre distance de fondu, et il
n'y a jamais de saut collectif de bosquet.
**Le fondu se fait par RETRECISSEMENT, pas par transparence.** Une instance qui
rapetisse jusqu'a zero disparait sans melange alpha, donc sans imposer de tri en
profondeur ni de seconde passe de rendu.
### Instanciation GPU
Le moteur ne savait pas instancier. Ajoute :
- `renderer/InstanceData.hpp` : **28 octets** par instance (position, echelle
uniforme, lacet, variation, attenuation). Pas de matrice 4x4 : une instance de
vegetation ne subit qu'une rotation autour de Y et une echelle uniforme, la
matrice est reconstituee dans le vertex shader. Sur 300 000 touffes, l'ecart
serait de 11 Mo par image ecrits sur un bus partage avec le CPU.
- Binding de sommets 1, cadence `VK_VERTEX_INPUT_RATE_INSTANCE`, locations 6 a 8.
Decrit au pipeline **uniquement** pour les materiaux instancies
(`ShaderSet::usesInstancing`), meme raisonnement que `usesMorphAttributes` en
Phase 10 : c'est une correction, pas une optimisation.
- `Material::Foliage` + `shaders/foliage.{vert,frag}`. **Un seul materiau pour
les arbres ET l'herbe** : ils ont exactement le meme besoin, et ce qui les
distingue (ondulation, teinte, portee) tient dans le maillage et les push
constants.
- Buffer d'instances **par frame-in-flight**, host-visible, mappe en permanence,
qui grandit a la demande et ne retrecit jamais. Reecrit a chaque image parce
que son contenu change a chaque image. Le remplacer est sans risque : `drawFrame`
a deja attendu la fence de cette frame-in-flight.
- `static_assert` sur la taille et la contiguite des membres lus comme `vec2`.
Il a servi des la premiere compilation : la struct fait 28 et non 32 octets
(`glm::vec3` s'aligne sur 4).
### Ce que coute reellement la vegetation : une mesure qui a change le code
Les arbres faisaient tomber la scene de 637 a 250 FPS pour 2 797 instances de
48 triangles, soit +32 % de geometrie seulement. Le compte ne tombait pas juste.
**Experience discriminante** : camera tournee vers le CIEL, donc pratiquement
aucun arbre dessine, mais le meme balayage de cellules effectue.
| | FPS |
|---|---:|
| Ciel, sans vegetation | 1 946 |
| Ciel, avec vegetation (balayage seul) | **351** |
**2,3 ms par image de balayage PUR, sans le moindre triangle en plus.** Le cout
des arbres n'etait pas geometrique : il etait dans la boucle qui visitait les
~8 400 cellules du carre de portee et faisait une recherche dans le cache pour
chacune, y compris pour celles situees derriere le joueur.
**Correctif : culling par BLOCS de 8x8 cellules.** Un bloc est teste d'un coup
contre le tronc de vision ; s'il echoue, 64 cellules sont ecartees pour un seul
test. Les bornes verticales du bloc sont estimees par cinq sondes d'altitude plus
une marge large — sans danger, parce qu'un bloc situe derriere le joueur est
rejete par les plans lateraux, qui ne dependent pas de cette estimation.
| | Avant | Apres |
|---|---:|---:|
| Ciel, balayage seul | 351 FPS | **1 614 FPS** |
| Vue paysage, arbres | 250 FPS | **466 FPS** |
| Vue paysage, tout | 193 FPS | **283 FPS** |
**Verifie non destructif**, ce qui est indispensable — d'excellents FPS obtenus
en ne dessinant plus rien sont le piege que la Phase 10 avait deja identifie :
comptes d'instances **identiques** (2 797 arbres, 1 839 cellules en cache), et
**98 pixels differents sur 879 360** (0,011 %) entre les images d'avant et
d'apres, hors barre de titre.
Le meme traitement a ete applique a l'herbe (blocs de 16x16 cellules), avec en
plus la suppression d'un `heightAt()` calcule deux fois par touffe. Gains :
procedural 199 -> 258 FPS, dalle Phase 7 176 -> 212 FPS. Comptes de touffes
inchanges (2 158).
---
## TACHE 3 — Herbe procedurale (essai)
Explicitement un essai. **Ce qui marche, et ce qui ne convainc pas, sont dits
tels quels.**
### Placement en touffes, pas en grille
Le risque a eviter etait le motif regulier. Approche retenue : **bruit de VALEUR
2D a deux octaves**, longueur d'onde **14 m**, qui module la densite locale ; la
position exacte dans la cellule vient d'un hachage.
Bruit de valeur plutot que Perlin : Perlin interpole des gradients, plus isotrope
mais quatre produits scalaires par point. Ici le champ ne sert qu'a moduler une
probabilite, jamais a etre regarde ; sa legere preference pour les axes de la
grille est invisible une fois traduite en presence ou absence de touffes. La
courbe de lissage est celle de Perlin (`6t^5 - 15t^4 + 10t^3`), dont les derivees
premiere et seconde s'annulent aux noeuds — donc aucune arete aux frontieres.
> Premier reglage a 45 m de longueur d'onde : a hauteur d'oeil on ne voyait
> qu'une seule tache, donc « une moitie de paysage herbeuse et une moitie nue »
> plutot que des touffes. Ramene a 14 m.
**Teste automatiquement** : la dispersion de la distance au plus proche voisin
depasse 25 % de la moyenne. Sur une grille parfaite elle serait nulle.
### Altitude
Traduction directe de la demande :
| | |
|---|---|
| Taille en bas / en haut | 0,30 m / 0,11 m |
| Alpage dense jusqu'a | 1 750 m |
| Herbe absente au-dessus de | 2 250 m |
La MEME rampe pilote la densite et la taille, ce qui rend la transition vers la
pelouse rase continue. Teste : moins de touffes ET plus petites en altitude.
> Premier reglage a 1 500 / 2 150 m : ces valeurs etaient calquees sur les bornes
> d'altitude de la zone plutot que sur sa vegetation reelle, et supprimaient
> l'herbe precisement la ou le massif est ouvert — les alpages et les pistes du
> nord-ouest. La limite des arbres y est vers 1 800-1 900 m.
### Donnee LiDAR pour distinguer pre, sous-bois et lapiaz
`couvert` dit qu'il y a de la vegetation (sinon c'est du rocher nu) ; `canopee`
dit si c'est une futaie. La densite d'herbe vaut donc
`ramp(couvert, 0,05, 0,30) x mix(0,35, 1, ouverture)`.
> Le facteur sous-canopee valait **0** au premier reglage, avec un seuil de
> pente a 0,9. Diagnostic chiffre sur une fenetre de 80 m : canopee moyenne
> 15,7 m et pente moyenne 0,86, donc **79 % des cellules a densite nulle et 42 %
> rejetees par la pente**. C'etait faux physiquement : une futaie de montagne est
> claire et son sol porte de l'herbe, et une pelouse d'alpage tient sur des
> versants bien plus raides. Porte a 0,35 et 1,3.
### Performance
Portee courte et fondu large : rendu jusqu'a **34 m**, attenuation commencee des
**14 m**. Cellules de 1 m, 24 emplacements, soit au plus 4,5 touffes/m2.
Instanciation GPU, un seul appel de dessin pour toute l'herbe visible.
### Etat honnete du resultat
**Ce qui fonctionne** : le groupement est visible et non repetitif ; la taille et
la densite suivent l'altitude ; l'herbe evite le rocher nu ; le cout est maitrise
(un appel de dessin, portee courte, fondu sans transparence).
**Ce qui ne convainc pas** : avec 2 158 touffes dans une vue de prairie, le
resultat se lit comme un **semis de touffes espacees, pas comme un tapis**. Il
faudrait environ 8 a 10 touffes/m2 la ou il y en a 2. Chaque touffe est par
ailleurs un eventail de trois quads OPAQUES et effiles, sans texture ni decoupe
alpha : de pres cela ressemble a des rubans verts plus qu'a des brins. L'opacite
est un choix — elle evite entierement le melange alpha, donc le tri en
profondeur — mais c'est elle qui plafonne le realisme.
**Une remarque de fond sur cette zone en particulier** : le massif choisi est
majoritairement forestier et rocheux, avec des pentes fortes. La prairie ouverte
sous 1 500 m y represente environ **0,4 % des cellules**. L'herbe a donc
structurellement peu de terrain a couvrir ici, et c'est une propriete du lieu,
pas du systeme.
---
## Captures reproductibles : un probleme decouvert en route
Deux executions du MEME script de capture, mêmes arguments, ne cadraient pas la
meme chose : **yaw -90 dans un cas, yaw -50 dans l'autre**, soit deux images
differant sur 65 % de leurs pixels. Toute comparaison avant/apres etait donc sans
valeur.
Cause : le jeu lit le clavier et la souris **SYSTEME** (GLFW ne voit pas les
messages postes, limite deja documentee en Phase 10). Une manipulation de la
machine pendant la pose reoriente la camera — ce qui s'etait effectivement
produit, l'utilisateur ayant tourne la vue a la souris.
Ajoute :
- **`--lock-input`** : la camera ignore entierement clavier et souris. La vue est
alors entierement determinee par la ligne de commande. `screenshot_scene.ps1`
le passe **par defaut** ; `-FreeInput` redonne la main.
- **`--start=est,nord`** (Lambert 93) et **`--look=yaw,pitch`** (degres). Sans
eux, la camera demarrait toujours au CENTRE du terrain, qui tombe sur du lapiaz
nu au milieu de cette zone : impossible d'aller cadrer une foret ou une prairie
sans piloter la souris a la main.
- L'orientation de la camera et les comptes de vegetation sont journalises une
fois par seconde, a cote du compteur de FPS.
Verifie : deux executions consecutives donnent desormais un rendu **identique au
pixel pres**, seule la barre de titre (qui porte les FPS) differe.
> **Effet de bord utile** : deux processus `vercora.exe` de la Phase 10 tournaient
> encore au demarrage de cette session, empechant l'edition de liens. C'est
> vraisemblablement la trace de l'incident de fermeture non elucide de la
> Phase 10 (« pas sorti dans les 30 s apres WM_CLOSE »). Le fait qu'ils aient
> survecu plus de deux heures rend l'hypothese « lenteur de fermeture » moins
> credible qu'un blocage franc.
---
## Verification
- **Tests headless : 268 assertions** (223 en Phase 10, **+45**), toutes passent.
Nouveaux blocs : format `.vcto` (tailles de niveaux BC1, chaine complete,
m/texel, refus d'un fichier absent), maillage de touffe (convention unite,
`uv.y` nul au pied, normales relevees), semis d'arbres (le couvert commande le
semis, la frontiere de foret est reproduite, determinisme, **independance du
chemin parcouru**, respect de l'emprise, niveau de detail de densite compare en
DENSITE et non en compte brut, attenuation, substitut sans carte, filtre de
pente), semis d'herbe (altitude sur taille et densite, portee, **placement
groupe et non regulier**, determinisme), format d'instance.
> Les tests ont attrape un comportement reel que j'avais oublie : `gatherTrees`
> ne construit que 96 cellules neuves par appel (budget anti-a-coup), donc un
> test qui n'appelle qu'une fois ne juge que du premier lot — c'est-a-dire du
> coin sud-ouest de la zone balayee. D'ou le helper `gatherTreesUntilStable`.
- **`tools\run_vulkan_check.ps1` : 4 scenarios sur 4, du premier coup.** Zero
`[Validation]`, zero `[ERROR]`, zero `[WARN]`, fermeture propre partout.
Gameplay reellement exerce : 2 abattages, 3 arbres au sol, 3 debitages,
8 ramassages (buche, branche, pierre, eclat), 1 percussion reussie, vol de
parapente avec atterrissage.
- **`--dump-world`** retrouve ses arbres visables : non-regression de la visee.
- **Zero message de validation** sur la totalite des mesures et des captures de
cette session, y compris les scenes non terrain.
### Captures
| Fichier | Contenu |
|---|---|
| `build/p11_A_avant.png` | Etat Phase 10 : coloration procedurale, sans vegetation |
| `build/p11_B_ortho.png` | + orthophoto |
| `build/p11_C_apres.png` | + arbres + herbe |
| `build/p11_foret.png` | Interieur d'une futaie dense (E 901315 N 6435855) |
| `build/p11_herbe.png` | Herbe sur pelouse (E 902010 N 6436415) |
Les trois premieres sont prises a la MEME position et au MEME cadrage
(E 901500 N 6436600, yaw 100, pitch -7), avec **exactement la meme geometrie de
terrain** (51 tuiles, 417 792 triangles) dans les trois cas.
Le detail le plus parlant de la comparaison : dans `p11_C_apres.png`, **la limite
de foret s'arrete exactement la ou le boisement s'arrete sur la photo**, et le
versant de lapiaz reste nu. C'est la carte de couvert LiDAR qui se voit
directement a l'image.
---
## Nouveaux fichiers
| Fichier | Role |
|---|---|
| `tools/fetch_ortho.py` | Telecharge la BD ORTHO sur l'emprise d'un `.vchm` |
| `tools/make_ortho_texture.py` | Mosaique + mipmaps + BC1 -> `.vcto` |
| `tools/lidar_to_canopy.py` | Cartes de couvert et de hauteur de canopee |
| `src/assets/TextureFile.{hpp,cpp}` | Chargeur `.vcto` (sans Vulkan) |
| `src/renderer/Texture.{hpp,cpp}` | Texture GPU : image, vue, echantillonneur |
| `src/renderer/InstanceData.hpp` | Format d'instance (28 octets) |
| `src/world/Vegetation.{hpp,cpp}` | Semis d'arbres de decor et d'herbe |
| `src/world/GrassMesh.{hpp,cpp}` | Touffe d'herbe (3 quads croises) |
| `shaders/foliage.{vert,frag}` | Vegetation instanciee |
Donnees produites : `data/ortho/` (25 tuiles, 23,8 Mo),
`assets/terrain/vercora_zone_ortho.vcto` (44,7 Mo),
`assets/terrain/vercora_zone_canopy.vchm` et `..._canopy_height.vchm` (4 Mo
chacune). **Disque : 274 Go libres avant, largement suffisant.**
## Options de ligne de commande ajoutees
| Option | Effet |
|---|---|
| `--no-ortho` | Coloration procedurale (repli Phase 10) |
| `--ortho=chemin.vcto` | Texture explicite au lieu de la convention de nommage |
| `--no-vegetation` | Ni arbres de decor ni herbe |
| `--no-grass` | Arbres de decor seuls |
| `--start=est,nord` | Position de depart en Lambert 93 |
| `--look=yaw,pitch` | Orientation de depart, en degres |
| `--lock-input` | Camera figee : ni clavier ni souris |
Touches ajoutees : **O** (orthophoto / procedural), **G** (tout / arbres seuls /
rien).
---
## Ce qui reste a faire, par ordre d'importance
1. **Texture de detail de pres.** A 0,61 m/texel l'orthophoto est molle sous les
pieds. Melanger une texture de detail (roche, herbe, eboulis) selon la pente
et l'altitude est le remede standard et ne demande pas de texture virtuelle.
2. **Densifier l'herbe et lui donner une decoupe alpha.** C'est ce qui separe le
« semis de touffes » du « tapis ». Le melange alpha imposerait un tri en
profondeur, ou un test alpha (`discard`) qui l'evite — c'est la piste a
preferer.
3. **Promotion d'un arbre de decor en arbre abattable** quand le joueur s'en
approche. L'architecture a deux niveaux est faite pour ca ; le lien n'est pas
pose. Aujourd'hui seuls les 16 arbres de `Forest`, semes autour de l'origine,
sont abattables — un joueur qui marche 200 m se retrouve dans une foret
entierement decorative.
4. **Collision avec les arbres de decor** : ils se traversent.
5. **Transfert asynchrone des tuiles de terrain** (verrou identifie en Phase 10,
toujours ouvert), et **index buffer partage**.
6. **Ombres portees** : sans elles, les arbres flottent visuellement sur le sol.
7. **Elargir la zone de l'orthophoto au-dela du terrain** n'a pas de sens ; en
revanche, produire l'orthophoto de la dalle de Phase 7 rendrait les scenes de
test comparables.
8. Le paquet `Pillow` a ete installe dans l'environnement Python 3.14 de la
Phase 9 (a cote de `laspy`, `lazrs`, `numpy`).
## Compromis assumes
- **0,61 m/texel** : compromis explicite entre memoire et nettete. La source est
a 20 cm.
- **BC1 destructif** (33,2 dB) : invisible a la distance ou le terrain est
regarde, et six fois plus compact.
- **Demi-texel de decalage** entre bord d'image et centre du premier texel :
30 cm, sous la precision de la BD ORTHO.
- **Herbe opaque sans texture** : evite tout melange alpha, plafonne le realisme.
- **Arbres de decor sans collision ni interaction** : c'est la definition meme du
decor dans cette architecture.
- **Cartes de vegetation au pas de 5 m** : une clairiere de 3 m n'existe pas pour
le semis.
- **Vegetation active par defaut sur toutes les scenes de terrain**, y compris
celles sans carte LiDAR, ou un substitut par pente et altitude prend le relais.
C'est ce qui fait baisser les chiffres du terrain procedural et de la dalle de
Phase 7 ; `--no-vegetation` rend exactement les performances de la Phase 10.
+468
Voir le fichier
@@ -0,0 +1,468 @@
# NOTES-PHASE 12 — Transferts de tuiles asynchrones et repli sur l'ancetre
Session du 2026-08-21. Objectif unique : lever le **verrou n 1** identifie et
documente en Phase 10 — `VulkanBuffer::copyFrom` faisait un `vkQueueWaitIdle`
par upload de tuile, ce qui imposait un budget artificiel de 4 tuiles construites
par frame et laissait un TROU la ou une tuile n'etait pas encore prete.
Machine : Intel UHD 770 integree, i5-14600K, 64 Go. Build **Debug**, couches de
validation actives, comme toutes les mesures depuis la Phase 9.
---
## 1. Ce que le GPU de cette machine expose vraiment
La consigne etait « une queue de transfert dediee si le GPU en expose une
separee de la queue graphique, sinon une soumission asynchrone sur la meme
queue ». Il fallait donc commencer par regarder. `VulkanContext` journalise
desormais l'inventaire des familles a chaque demarrage :
```
Familles de queues : 2 - [0] x1 graphics compute transfer sparse [1] x2
Aucune famille de transfert dediee sur ce GPU : les transferts partagent
forcement la queue graphique.
```
La famille 1 n'expose **aucun** des bits graphics/compute/transfer/sparse : c'est
une famille video (decode/encode), inutilisable pour un `vkCmdCopyBuffer`. Il n'y
a donc **qu'une seule queue utilisable**, et la branche « queue de transfert
dediee » ne s'applique pas ici.
La detection est conservee dans `QueueFamilyIndices::dedicatedTransferFamily` et
journalisee, mais **elle n'est pas utilisee** : ecrire le transfert de propriete
de famille de queue (barriere de release cote transfert + barriere d'acquire cote
graphique) qu'imposerait une famille distincte reviendrait a livrer de la
synchronisation qu'aucun test de cette machine ne peut exercer. C'est exactement
ce que la consigne interdisait.
## 2. L'architecture retenue
Sur une machine a une seule queue, « soumettre de facon asynchrone sur la meme
queue avec suivi par fence » et « enregistrer la copie dans le command buffer de
la frame » aboutissent au meme ordonnancement GPU. La seconde forme a ete
retenue, pour quatre raisons concretes :
1. **Une seule soumission par frame**, au lieu d'une soumission + une fence
supplementaires.
2. **La dependance memoire est explicite** — une `VkMemoryBarrier`
`TRANSFER_WRITE -> VERTEX_ATTRIBUTE_READ | INDEX_READ`, entre
`VK_PIPELINE_STAGE_TRANSFER_BIT` et `VK_PIPELINE_STAGE_VERTEX_INPUT_BIT` —
donc **verifiable par la validation de synchronisation**, au lieu de reposer
sur l'effet de bord d'un vidage de queue.
3. **Aucun transfert de propriete de famille** a ecrire : meme famille de bout en
bout.
4. **La tuile est lisible DES CETTE FRAME.** Il n'y a aucune latence de
transfert a masquer : le repli sur l'ancetre ne sert donc qu'aux tuiles pas
encore *construites* (budget CPU), jamais a une copie en vol.
### Le chemin, concretement
```
TerrainStreamer::buildNode
-> Renderer::addMesh
-> Mesh(...) : maille, ecrit un buffer staging host-visible,
cree le buffer device-local, puis
-> Renderer::enqueueCopy(staging, destination) [ne bloque pas, ne soumet rien]
Renderer::drawFrame
-> vkBeginCommandBuffer
-> recordPendingCopies() : N x vkCmdCopyBuffer, puis UNE VkMemoryBarrier
-> vkCmdBeginRenderPass ... : les draws lisent une geometrie deja ordonnancee
-> une seule vkQueueSubmit
```
`Mesh` ne connait plus ni command pool ni queue : il recoit une interface
`BufferUploader` (declaree dans `VulkanBuffer.hpp`), que le `Renderer` implemente.
Sans cette interface, `Mesh` dependrait du `Renderer`, qui possede des `Mesh`.
### Duree de vie des buffers staging
C'est le point qui pouvait silencieusement corrompre le rendu. Un staging dont la
copie est enregistree mais pas encore executee **ne doit pas etre detruit**. Il
passe donc dans `retiredStaging_`, avec le meme compte a rebours de
`kMaxFramesInFlight + 1` vieillissements que `retiredMeshes_` de la Phase 10 —
mecanisme deja eprouve, decremente juste apres l'attente de la fence de frame,
donc a un instant ou l'on sait qu'une frame de plus est reellement terminee.
### Le garde-fou memoire (et le seul `vkQueueWaitIdle` qui subsiste)
Differer les copies veut dire garder les staging trois frames de plus. Pour le
streaming c'est negligeable (64 tuiles ~ 25 Mo). Pour le chemin `--no-lod`, qui
televerse la zone de 25 km2 en **un seul maillage**, le staging pese 3,4 Go a lui
seul : la premiere version faisait passer le pic memoire de ce chemin de
**5,6 a 6,9 Go**, soit +23 % — une vraie regression sur une mesure de la Phase 10.
`Renderer::enqueueCopy` bascule donc sur une soumission **synchrone**
(`flushCopiesNow`) des que le staging vivant depasse **128 Mo**. Le seuil laisse
passer tout le streaming (verifie : **0 declenchement** sur les survols a 60 et
900 m/s) et n'attrape que les televersements geants, qui ont lieu avant la
premiere frame et sont donc hors du chemin critique. Pic `--no-lod` ramene a
**5 636 Mo**, la valeur de la Phase 10.
## 3. Verification de la synchronisation
Les couches de validation **standard** ne verifient pas les dependances
memoire : elles etaient a zero message avant comme apres, y compris avec une
synchronisation fausse. Cette session active donc la **validation de
synchronisation**, qui n'avait ete activee dans aucune phase precedente :
```bash
set VK_LAYER_VALIDATE_SYNC=1
```
### Un defaut ANTERIEUR, mis au jour et corrige
Premier resultat, avant meme de regarder les transferts :
```
[ERROR] [Validation] vkQueueSubmit(): WRITE_AFTER_WRITE hazard detected.
vkCmdBeginRenderPass ... writes to resource, which was previously written at the
end of subpass 0 (vkCmdEndRenderPass) by the attachment storeOp ...
```
Il ne vient pas des transferts : il se reproduit sur la scene `cube` et avec
`--no-lod`, donc sans le moindre upload en vol. Cause : la dependance de subpass
de `SwapChain` avait `srcAccessMask = 0`, ce qui n'ordonne que l'execution, pas
les ecritures — or il n'y a **qu'un seul buffer de profondeur pour les deux
frames-in-flight**, donc le clear de la frame N+1 courait sans dependance contre
le storeOp de la frame N.
Corrige (`srcStageMask` = `COLOR_ATTACHMENT_OUTPUT | LATE_FRAGMENT_TESTS`,
`srcAccessMask` = les deux ecritures d'attache). Corrige **ici et pas plus tard**
parce qu'une erreur permanente dans le journal de synchronisation rendrait
invisible un vrai probleme de transfert.
### Controle NEGATIF : la verification mord-elle vraiment ?
Un journal propre ne prouve rien si la verification ne regarde pas au bon
endroit. La barriere de transfert a donc ete **retiree volontairement**, le jeu
rebuilde et rejoue sur la meme scene :
| Barriere | Messages de la validation de synchronisation |
|---|---|
| **retiree** | **10 x `vkCmdDrawIndexed(): READ_AFTER_WRITE hazard ... reads index VkBuffer ... previously written by vkCmdCopyBuffer`** |
| en place | **0** |
La verification voit donc bien les copies de tuiles, et c'est la barriere qui
rend le journal propre — pas un angle mort de l'outil.
### Etat final
Zero `hazard`, zero `[Validation]`, zero `[ERROR]`/`[WARN]` sur : `cube`,
`assets/icosphere.obj`, dalle de Phase 7, zone 25 km2 a 1 m statique, `--no-lod`,
survol scripte a 60 et 900 m/s, et vol de parapente reel sur la zone.
## 4. Le repli sur l'ancetre
### Le principe
Une tuile selectionnee mais pas encore construite n'est plus laissee en trou : on
remonte sa **chaine de peres** (nouveau champ `Node::parent`) jusqu'a une tuile
deja residente, et c'est celle-la qu'on dessine. Elle couvre exactement la meme
surface, en resolution inferieure.
**Le repli REMPLACE le sous-arbre, il ne s'y superpose pas.** Les autres tuiles
selectionnees situees sous l'ancetre retenu sont retirees de la frame, meme
residentes. Sans cela deux surfaces de niveaux differents se recouvriraient et se
disputeraient le z-buffer : on aurait remplace un trou par un mouchetage
clignotant. L'ensemble dessine reste ainsi une **coupe** de l'arbre — chaque
metre carre visible est couvert une fois et une seule.
Les tuiles ecartees au profit d'un ancetre sont quand meme marquees « utilisees a
cette frame », sinon le LRU evincerait une geometrie que la selection redemande.
### Ce qui ne marchait pas, et la mesure qui l'a dit
Premiere version : repli seul, sans rien d'autre. Resultat a 900 m/s avec un
budget de 4 tuiles/frame : **112 -> 25 frames a trou**. Mieux, mais pas zero.
Hypothese initiale — « le LRU evince les ancetres » — **testee et fausse** : une
eviction biaisee par niveau (sursis proportionnel au niveau) n'a fait passer que
de 25 a 23 frames, et de 288 a 255 dans la configuration la plus serree. Ce code
a donc ete **retire** : garder un parametre de reglage dont la justification a ete
mesuree comme marginale n'aurait fait qu'ajouter du bruit.
Un diagnostic temporaire journalisant le niveau des tuiles restees non couvertes
a donne la vraie reponse en une execution :
| Niveau de la tuile non couverte | Ancetres au-dessus d'elle | Occurrences |
|---|---|---|
| 5 | 2 | 324 |
| 4 | 3 | 270 |
| 3 | 4 | 33 |
Les tuiles a trou sont **grossieres**, a l'horizon, et leurs ancetres sont de
niveau 6 et 7 — **jamais dessines de toute la session**. Un noeud proche de la
racine ne se dessine que vu de plus loin que le terrain n'est grand, ce qui
n'arrive jamais quand on est dedans. Le repli n'avait donc structurellement
aucune cible.
### Le correctif : le sommet du quadtree est epingle
`TerrainStreamer` construit au demarrage **toutes les tuiles des trois niveaux
les plus grossiers** (`Params::pinnedTopLevels = 3`) et ne les evince jamais.
Elles sont peu nombreuses — au plus 1 + 4 + 16 = 21, et **14 en pratique sur la
zone 25 km2** (les autres tombent hors de la grille), soit **5 Mo**.
La propriete obtenue est structurelle, pas statistique : tout noeud selectionne
est soit epingle lui-meme, soit descendant d'un noeud epingle, donc **il existe
toujours un ancetre resident**. `uncoveredNodes()` ne peut plus valoir autre chose
que zero — et reste mesure a chaque frame pour le prouver plutot que pour le
supposer.
## 5. Le budget par frame
`maxUploadsPerFrame` passe de **4 a 64**. Le budget ne borne plus une
synchronisation GPU — il n'y en a plus — mais le seul cout restant, qui est le
**maillage CPU** d'une tuile (65 x 65 sommets a calculer, ~385 Ko a recopier). Il
subsiste pour deux raisons : lisser l'a-coup d'un demi-tour brutal, et borner le
staging vivant simultanement (64 tuiles ~ 25 Mo, tres en dessous du seuil de
128 Mo du garde-fou).
Reglable par `--tile-budget=N`, ce qui permet de rejouer le plafond de la
Phase 10 **sur le meme binaire**.
### Un budget plus large ne fait-il pas des a-coups ?
C'est le risque evident : concentrer le maillage de 64 tuiles dans une frame
ferait un pic de temps d'image. Mesure a 120 m/s, deux runs par budget :
| Budget | FPS median | FPS min instantane |
|---:|---|---|
| 4 | 363 / 296 | 289 / 201 |
| 16 | 346 / 319 | 223 / 253 |
| 64 (defaut) | 334 / 354 | 243 / 240 |
| 256 | 347 / 350 | 239 / 222 |
Aucune degradation systematique. **Mais cette mesure a une limite qu'il faut
dire** : le compteur de FPS du jeu moyenne sur ~250 ms, donc il ne peut PAS voir
un a-coup d'une seule frame. Ce n'est donc pas une preuve d'absence de pic.
Ce que les donnees prouvent vraiment, et qui suffit : le pic de tuiles construites
en une frame vaut **53, et il vaut 53 AUSSI avec `--tile-budget=4`**. Ce 53 vient
donc de la **frame d'amorcage**, qui ignore le budget (et l'ignorait deja en
Phase 10). Apres l'amorcage, le budget n'est jamais la contrainte qui mord — a
900 m/s le budget de 64 laisse **0 tuile en attente**, alors que 4 en laissait.
Le passage de 4 a 64 enleve un plafond artificiel, il n'ajoute pas de travail.
## 6. Le scenario qui a motive le chantier
`--flythrough=V[,H]` : la camera avance seule a V m/s, H metres au-dessus du
relief, et vire de 90 degres en arrivant au bord de l'emprise. Scripte plutot que
pilote au clavier parce que le harnais ne peut pas commander la souris (voir
`run_vulkan_check.ps1`) et parce qu'une trajectoire reproductible est la condition
d'une comparaison.
### Premier resultat : a vitesse realiste, le probleme ne se reproduit pas
A 60 m/s (216 km/h, six fois la vitesse d'un parapente), **meme les reglages de la
Phase 10 ne produisent aucun trou** : 0 frame a trou sur 10 591. A 400 FPS la
camera n'avance que de 15 cm par frame, et 4 tuiles/frame font 1 600 tuiles/s.
Il a donc fallu monter la vitesse jusqu'a ce que les reglages de la Phase 10
cassent vraiment, sans quoi la comparaison n'aurait rien prouve.
### Le tableau
Zone 25 km2 au pas de 1 m, survol scripte, meme binaire, seules les options
changent. « Frames a trou » = frames comptant au moins une tuile selectionnee que
**rien** ne couvrait.
| Vitesse | Budget | Repli | Sommet epingle | Frames a trou | Pic de tuiles manquantes |
|---:|---:|:---:|:---:|---:|---:|
| 60 m/s | 4 | non | non | 0 / 10 591 | 0 |
| 300 m/s | 4 | non | non | **21 / 6 750** | 7 |
| 900 m/s | 4 | non | non | **112 / 4 780** | 17 |
| 900 m/s | 1 | non | non | **1 973 / 4 798** | 23 |
| 900 m/s | 4 | oui | non | 25 / 4 739 | 7 |
| 900 m/s | 1 | oui | non | 288 / 4 640 | 11 |
| **900 m/s** | **1** | **oui** | **oui** | **0 / 4 748** | **0** |
| **900 m/s** | **64 (defaut)** | **oui** | **oui** | **0 / 4 063** | **0** |
| **60 m/s** | **64 (defaut)** | **oui** | **oui** | **0 / 6 990** | **0** |
A 900 m/s avec un budget de 1 tuile/frame, le repli est sollicite sur **1 969
frames sur 4 748** (pic de 9 ancetres simultanes) et **ne manque jamais sa
cible**. C'est la ligne qui montre que le filet fonctionne vraiment, et pas
seulement qu'il n'est jamais appele.
### Vol en parapente reel
Physique du jeu, pas un survol scripte : passage en mode libre, montee, decollage
(V), douze virages pendant la descente, atterrissage **naturel** contre le relief
LiDAR, sur la zone de 25 km2, sous validation de synchronisation.
```
Decollage en parapente, cap 62.8 degres.
Parapente : atterrissage.
Trous de streaming : 0 frame(s) sur 25 501 avec au moins une tuile NON COUVERTE
(pic 0 tuiles) ; repli sur ancetre utilise dans 0 frame(s).
hazards=0 [Validation]=0 [ERROR]/[WARN]=0 pic RAM=434,1 Mo
```
## 7. Mesures FPS / RAM
Toutes avec `--lock-input` (sans le verrou, la souris systeme reoriente la camera
et l'ecart entre deux runs atteint 15 % — voir Phase 11). Mediane de plusieurs
runs, chacun de 12 a 15 s apres 5 s de chauffe.
| Scene, camera a l'arret | Phase 11 (avant) | **Phase 12 (apres)** | RAM avant | **RAM apres** |
|---|---:|---:|---:|---:|
| Zone 25 km2 a 1 m | 312 FPS | 292 FPS | 332,2 Mo | 332,3 Mo |
| Zone 25 km2 a 2 m | 315 FPS | 276 FPS | 260,7 Mo | 259,8 Mo |
| Dalle de Phase 7 | 218 FPS | 216 FPS | 128,8 Mo | 151,2 Mo |
| Terrain procedural | 267 FPS | 263 FPS | 106,9 Mo | 109,9 Mo |
| Zone 1 m `--no-lod` | 9 FPS | 9 FPS | 5 600 Mo | 5 637 Mo |
### Comment lire la colonne FPS : c'est du bruit, et voici la preuve
Les ecarts ci-dessus vont de -1 % a -12 %, mais **le bruit de mesure de cette
machine est du meme ordre** : cinq runs consecutifs de la zone 1 m dans la
configuration Phase 12 ont donne 278 / 280 / 292 / 293 / 295, et la zone 2 m a
donne 208 / 276 / 309 sur trois runs.
Un temoin tranche la question, sur **le meme binaire** et donc sans aucun bruit
de compilation. A l'arret, aucun transfert n'a lieu : les reglages de streaming
ne peuvent rien changer.
| Zone 1 m, camera a l'arret | FPS median |
|---|---:|
| Reglages Phase 10 (`--tile-budget=4 --no-tile-fallback`) | 285 |
| Reglages Phase 12 (defaut) | 292 |
Et sous charge de streaming, survol a 60 m/s :
| Zone 1 m, survol 60 m/s | FPS median (3 runs) |
|---|---:|
| Reglages Phase 10 | 422 (378 / 422 / 435) |
| Reglages Phase 12 (defaut) | 418 (404 / 418 / 438) |
Les deux configurations sont donc **indiscernables**, a l'arret comme en
mouvement. Il n'y a ni gain ni perte de FPS a attendre de cette session : le
verrou leve ne se manifestait pas en FPS moyen mais en **trous visuels**, et
c'est la que la mesure a bouge.
### La RAM, elle, a bouge — et c'est explicable
- **Dalle de Phase 7 : +22,4 Mo.** 21 tuiles epinglees (7 Mo de geometrie GPU) et
le staging d'un demarrage qui construit 51 tuiles d'un coup au lieu d'une a la
fois. C'est le prix direct du « ne plus attendre » : les staging coexistent au
lieu de se succeder.
- **Terrain procedural : +3 Mo.** Tout l'arbre y tient en 5 tuiles.
- **Zone 25 km2 : inchangee** (332,2 -> 332,3 Mo). Le demarrage y construisait
deja 67 tuiles d'un bloc ; 14 tuiles epinglees s'y perdent dans le bruit.
- **`--no-lod` : +37 Mo** (5 600 -> 5 637), soit +0,7 %, grace au garde-fou de
128 Mo. Sans lui : 6 915 Mo.
## 8. Non-regression
- **280 assertions headless** (268 en Phase 11, +12 pour la Phase 12), via
`tools\run_logic_tests.bat`.
- **`tools\run_vulkan_check.ps1` : 4 scenarios sur 4, du premier coup**, zero
`[Validation]`, zero `[ERROR]`/`[WARN]`, fermeture propre sur les quatre —
2 abattages, 3 debitages, 9 ramassages, 1 percussion, dalle LiDAR reelle,
decollage et atterrissage en parapente.
- **Traversee de 20 km** (`tools\traverse_terrain.ps1 -Distance 2500`, zone
25 km2 au pas de 1 m, six branches, en sortant deux fois de l'emprise) :
**0 message `[Validation]`, 0 `[ERROR]`/`[WARN]`, code de sortie 0**, aucune
chute a travers le sol, aucune anomalie aux anciennes frontieres de dalles.
FPS moyen de 146 a 230 selon la branche. **Ces chiffres ne se comparent pas a
ceux de la Phase 10** (459 a 725) : cette traversee-la precedait la vegetation
de la Phase 11, qui est de loin le poste le plus cher en marche.
**Incident de la Phase 10 non reproduit** : le jeu etait alors reste bloque
plus de 30 s apres `WM_CLOSE` sur un run de 20 km, sans explication. Cette fois
il est sorti proprement. Toujours pas explique, mais toujours pas reproduit non
plus.
- `--dump-world` : **16 lignes AIM sur 16 arbres**, inchange.
- `cube`, `assets/icosphere.obj`, `--no-lod`, terrain procedural : intacts, zero
validation, zero hazard.
- Le decouplage rendu / collision de la Phase 10 n'est pas touche : le repli ne
concerne que ce qui est DESSINE, `Heightmap::heightAt()` reste la source unique
de la physique.
### Controle visuel : la vue est-elle la meme ?
C'est le garde-fou pose en Phase 10 contre le piege « excellents FPS parce que le
culling est casse ». Zone 25 km2, vegetation et herbe coupees (pour retirer toute
animation), **vue epinglee** par `--look=-90,-8` :
| Comparaison | Pixels differents sur 921 600 |
|---|---:|
| Reglages Phase 12 contre eux-memes (temoin) | 60 (0,007 %) |
| **Reglages Phase 12 contre reglages Phase 10** | **45 (0,005 %)** |
L'ecart entre les deux configurations est **plus petit que le temoin de la meme
configuration relancee deux fois** : les images sont identiques a la
reproductibilite pres du harnais. Meme nombre de tuiles dessinees (66 sur 66) et
de triangles (540 672) sur les deux.
**Piege rencontre, a retenir.** Sans `--look`, trois captures de la meme scene ont
donne 38,2 / 38,3 / 32,9 % de ciel : trois cadrages differents, donc une
comparaison pixel a pixel sans aucune valeur (elle annoncait 2,4 % d'ecart, pur
artefact de cadrage). `--lock-input` seul ne suffit pas a fixer la vue de depart.
Pourquoi le verrou laisse passer ce residu n'est **pas elucide** ; la parade est
connue et suffisante : epingler `--look` pour toute comparaison d'image.
### Les 12 nouvelles assertions
Le repli lui-meme vit dans `TerrainStreamer`, qui pilote Vulkan : il n'est pas
testable en headless. Ce qui l'est, et dont il depend entierement, c'est la
structure sous-jacente — une erreur y serait silencieuse :
- la chaine de peres est complete (un seul noeud sans pere), coherente (le pere
est toujours un niveau au-dessus) et **reciproque** (chaque noeud figure bien
dans les `children` de son pere — c'est ce test qui attraperait un chainage
pose sur une reference devenue pendante apres reallocation de `nodes_` pendant
la construction recursive) ;
- la remontee se termine, en au plus `rootLevel` etapes ;
- **l'emprise d'un pere contient celle de chacun de ses fils** — la propriete qui
rend le repli correct ;
- `describeNode()` redonne **au bit pres** ce que produit `select()` pour un
noeud selectionne, et suit la portee du bon niveau pour un ancetre ;
- le sommet du quadtree compte au plus 21 tuiles sur trois niveaux (l'hypothese
qui rend l'epinglage defendable est figee par un test).
## 9. Options ajoutees
| Option | Effet |
|---|---|
| `--tile-budget=N` | N tuiles construites au plus par frame (defaut 64 ; 4 = plafond de la Phase 10) |
| `--no-tile-fallback` | pas de repli sur l'ancetre : une tuile pas encore construite laisse un trou (comportement de la Phase 10) |
| `--flythrough=V[,H]` | survol scripte a V m/s, H m au-dessus du relief (defaut 120), virage de 90 deg au bord |
Les trois n'existent que pour rejouer et comparer les deux moities du chantier
sans recompiler, dans l'esprit de `--no-lod` de la Phase 10.
## 10. Limites restantes
1. **La branche « queue de transfert dediee » n'est pas ecrite.** Sur un GPU
discret qui expose une famille transfert-seule, le moteur continuera d'utiliser
la queue graphique. Le gain serait reel (recouvrement des copies avec le
rendu) mais impose un transfert de propriete de famille de queue, non
eprouvable sur cette machine. La detection, elle, est en place et journalisee.
2. **Le maillage d'une tuile reste synchrone sur le thread de rendu.** C'est
desormais LE cout du streaming : ~385 Ko a produire et recopier par tuile. Un
thread de maillage dedie est le prochain verrou, pas le transfert.
3. **Le repli degrade la resolution sur toute l'emprise de l'ancetre**, pas
seulement sur la tuile manquante (c'est le prix de la coupe sans
recouvrement). Une tuile L4 manquante fait basculer ~2 km de terrain en L5 le
temps d'une frame ou deux. Invisible dans les conditions testees, mais c'est
un compromis assume, pas une absence de defaut.
4. **Une fissure fine est possible au bord d'un ancetre de repli** : dessine plus
pres que sa portee nominale, son geomorphing est a zero alors qu'un voisin
plus fin est deja sur sa propre grille. Transitoire, et sans commune mesure
avec un trou de ciel — mais aucun test automatique ne cherche une fissure dans
l'IMAGE rendue (limite deja notee en Phase 10, toujours ouverte).
5. **Aucun instrument ne mesure le temps d'UNE image.** Le compteur de FPS
moyenne sur ~250 ms : un a-coup isole (une frame a 30 ms) est invisible dans
toutes les mesures de ce projet depuis la Phase 7. Tant que le budget par
frame reste au-dessus de la demande reelle, ca n'a pas mordu ; c'est le
premier instrument a ajouter si un jour un a-coup est ressenti sans etre
mesurable.
6. **Le staging vit trois frames.** Le garde-fou borne le pic, mais un materiel a
memoire video etroite verrait cette pression avant nous.
7. **La frame d'amorcage n'a pas de budget** (`primingFrames = 1`) : elle
construit toute la vue initiale d'un coup, donc autant de staging simultanes.
Mesure a 67 tuiles (~26 Mo) sur la zone 25 km2, tres loin du seuil.
8. Les points 2, 3, 5, 6 et 7 de la liste « ce qui reste a ameliorer » de la
Phase 10 **restent ouverts** : index buffer partage, sommet allege, streaming
DISQUE, parametres de quadtree non reglables, absence de test de fissure.
+819
Voir le fichier
@@ -0,0 +1,819 @@
# Phase 15 (2026-08-23) : éditeur de niveau interne
Outil de **développement**, pas de jeu. La consigne demandait explicitement de
privilégier la complétude et le contrôle sur l'ergonomie : il n'y a donc aucune
interface graphique, le catalogue est une liste texte dans le journal, et l'état
courant de l'outil s'affiche sur une ligne de log. En revanche tout ce qui est
demandé fonctionne de bout en bout — poser, régler, déplacer, supprimer,
annuler, sauvegarder, recharger — et **les objets posés font partie du monde** :
une partie normale les charge d'elle-même, les dessine et s'y cogne.
Note de numérotation : il n'existe pas de `NOTES-PHASE14.md`. La Phase 14
(escalade) est documentée dans `NOTES-PHASE-ESCALADE.md`, comme la Phase 13 l'est
dans `NOTES-PHASE-VELO.md`.
---
## 1. Ce qui a été livré
| Demande de la consigne | État |
|---|---|
| Mode éditeur, bascule depuis le jeu | **fait** — touche `F2`, ou `--editor` au lancement |
| Caméra de vol libre, sans collision ni gravité | **fait** — `CameraMode::Free` verrouillé, vitesse réglable à la molette (2 à 600 m/s) |
| Catalogue scanné depuis un dossier | **fait** — `assets/editor/`, plus 5 modèles générés en code |
| Extension d'`ObjLoader` au glTF | **NON FAIT**, documenté en §8 |
| Liste texte avec sélection au clavier | **fait** — `TAB`, `PAGE_PREC`/`PAGE_SUIV`, rangs `1`..`9` |
| Fantôme suivant la visée | **fait** — teinté cyan, au point exact où le regard rencontre le sol |
| Pose au clic, à la position visée | **fait** — clic gauche, ou `INSER` au clavier |
| Déplacer / pivoter / redimensionner | **fait** — saisie à la visée (`G`), flèches, `DEBUT`/`FIN` |
| Sélectionner et supprimer | **fait** — `E` puis `SUPPR` |
| Sérialisation dans un fichier texte | **fait** — format `.vcsc`, §4 |
| Chargement automatique en jeu normal | **fait** — vérifié sous Vulkan, §7 |
| Undo | **fait** — pile de 128 actions, regroupement des retouches |
| Premier lot d'assets de test | **fait** — 5 modèles générés en code + 1 `.obj` témoin |
| Collision des objets posés | **fait** — cylindre englobant, réglable par objet ; limite en §8 |
---
## 2. Architecture
Nouveau dossier `src/editor/`, plus deux en-têtes ajoutés à `src/core/`.
```
src/core/TerrainRay.hpp intersection rayon / surface du terrain
src/core/CompositeCollisionSolver.hpp plusieurs sources d'obstacles, un solveur
src/editor/EditorAssets.{hpp,cpp} les 5 modèles générés en code
src/editor/AssetCatalog.{hpp,cpp} catalogue : builtins + scan de dossier
src/editor/PlacedObject.hpp un objet posé (donnée pure)
src/editor/EditorScene.{hpp,cpp} la liste, la visée, la collision, l'undo
src/editor/EditorController.{hpp,cpp} la machine à états de l'outil
src/editor/SceneFile.{hpp,cpp} lecture / écriture du .vcsc
```
**Aucun de ces fichiers ne connaît Vulkan.** C'est le même découpage que celui
des quatre activités : `Paraglider`, `Bike` et `Climber` ne dépendent que de GLM
et sont donc *exécutés* dans les tests headless. Ici tout l'éditeur sauf le
dessin l'est aussi — catalogue, raycast, scène, pile d'annulation, collision,
format de fichier, et la machine à états complète.
### Ce qui rend la machine à états testable
`EditorController` **ne lit pas le clavier**. Il reçoit une structure
`EditorInput` déjà dépouillée par `main.cpp`. Trois raisons, la dernière étant la
vraie :
1. il ne dépend alors ni de GLFW ni de `Window` ;
2. les touches restent décrites en un seul endroit, à côté de celles du jeu ;
3. **le harnais automatisé ne peut pas piloter la souris** — GLFW lit le curseur
*système* et non les messages postés (limite connue depuis la Phase 8). Un
contrôleur qui lirait lui-même les entrées ne serait donc testable qu'à la
main.
### Les trois cibles de réglage, et leur ordre
```
SAISIE > SÉLECTION > PINCEAU
```
* **Saisie** : un objet décroché suit la visée. **La scène n'est pas modifiée
tant qu'il est en main** — c'est seulement en le reposant qu'une *unique*
action annulable est empilée. Sans ça, déplacer un rocher de trente mètres
empilerait une annulation par image.
* **Sélection** : les retouches l'atteignent directement, et celles qui
s'enchaînent à moins de 0,75 s l'une de l'autre sont **regroupées** en une
seule annulation. Sans ce regroupement, tourner un rocher d'un quart de tour
laisserait six annulations et « annuler » ne rendrait jamais l'état d'avant la
manipulation — la seule chose qu'on veuille.
* **Pinceau** : l'asset armé et *ses* réglages (cap, échelle, hauteur,
solidité), **conservés d'une pose à l'autre**.
### La pose ne sélectionne pas — corrigé après essai sous Vulkan
La première version sélectionnait l'objet qu'on venait de poser, par analogie
avec les éditeurs 3D. Le premier essai réel a montré que c'était le mauvais
choix **ici** : les réglages visant la sélection en priorité, poser un objet
détournait silencieusement les flèches du *pinceau* vers l'objet posé. Régler une
fois puis poser dix blocs alignés — le geste le plus courant de l'outil —
devenait impossible sans désélectionner entre chaque. Corrigé et figé par test.
Dans la foulée, la ligne d'état a été corrigée aussi : elle n'affichait que le
cap du *pinceau*, donc tourner un objet sélectionné affichait `cap 0 deg` pendant
que l'objet tournait. Elle décrit maintenant la cible réelle des réglages.
Une troisième incohérence, trouvée à la relecture : reposer un objet à la touche
de saisie écrivait la prévisualisation de l'image **précédente**, alors que le
reposer au clic écrivait celle de l'image **courante** — deux gestes censés faire
la même chose n'avaient donc pas exactement le même résultat. Le début de saisie
et la repose sont maintenant séparés de part et d'autre du calcul de
prévisualisation, et les deux gestes passent par le même code.
Enfin, le mode éditeur se voit dans le **titre de la fenêtre** (`[EDITEUR]`) :
c'est le seul retour permanent à l'écran, rien dans la vue elle-même ne
distinguant une caméra d'édition d'un simple vol libre.
### Le raycast terrain
`Forest::pickTree` (Phase 5) intersecte un rayon avec des **cylindres**, ce qui a
une solution analytique. La surface du terrain n'est pas une primitive : c'est
une grille bilinéaire de plusieurs millions de cellules. `core/TerrainRay.hpp`
marche donc le long du rayon, à **pas croissant** (0,5 m près de l'œil, plafonné
à 8 m), puis dichotomie sur 24 itérations dès que le signe de
`hauteurDuRayon − hauteurDuTerrain` s'inverse. Environ 150 échantillons pour
400 m de portée, une fois par image.
Deux points qui comptent :
* **L'emprise doit être passée explicitement.** `HeightSampler::heightAt` est
*totale* par contrat — hors des données elle prolonge le bord. Sans le
paramètre `halfExtent`, un rayon partant vers l'extérieur accrocherait une
étagère plate infinie. Vérifié par un test qui compare les deux cas.
* **Limite assumée** : une marche à pas fini peut *enjamber* une arête plus fine
que le pas courant (une crête vue de loin et par-dessus). Le remède exact — un
parcours cellule par cellule façon DDA — exigerait de connaître la grille,
donc de renoncer à l'interface `HeightSampler`.
### La collision : la première fois que l'interface de la Phase 6 sert vraiment
Le monde avait jusqu'ici **une seule** source d'obstacles (`Forest`), et
`Camera::setCollisionSolver` prenait un pointeur unique.
`CompositeCollisionSolver` implémente le même contrat et le délègue à une liste ;
les répoussements sont **chaînés** et non moyennés (sortir d'un tronc peut faire
entrer dans un rocher).
**Ni `Camera`, ni `Bike`, ni `Climber` n'ont été modifiés pour ça** — seul
l'objet qu'on leur passe a changé. C'est exactement ce que l'interface de la
Phase 6 permettait, et c'est la première fois qu'on s'en sert.
---
## 3. Le fantôme est teinté, pas transparent
Trois états du **même** maillage doivent se distinguer : l'objet posé, le
fantôme qui suit la visée, l'objet sélectionné. Ils passent tous par le même
pipeline ; seule une **teinte témoin** poussée en push constant les sépare
(`params.x` = force, `params.yzw` = couleur, lu par `shaders/cube.frag`).
Une teinte plutôt qu'une transparence — pourtant le rendu habituel d'un fantôme —
parce que le mélange alpha impose de trier les objets par profondeur à chaque
image. C'est le choix que le projet a déjà fait deux fois pour la même raison :
la végétation de la Phase 11 fond ses arbres par **rétrécissement**, et l'herbe
est faite de quads **opaques**. Conséquence : ni second pipeline, ni état de
blending, ni tri — et **une force nulle laisse le rendu bit à bit identique à
celui d'avant la Phase 15**, ce qui est ce qui autorisait à toucher au shader du
matériau `Object` sans risquer les phases précédentes.
Cyan pour le fantôme, ambre pour la sélection : deux couleurs qu'aucun asset de
cette session ne porte (tous gris, bruns ou ocres) et que le terrain ne porte pas
non plus.
---
## 4. Le format de scène `.vcsc`
Fichier **texte**, une directive par ligne, champs séparés par des espaces,
commentaires après `#`. Documentation de référence : `src/editor/SceneFile.hpp`.
```
# Vercora scene v1 - genere par l'editeur (Phase 15).
version 1
terrain LHD_0907_6440_1m.vchm
crs 2154
object rocher 907500.000 6439501.840 0.000 0.000 1.0000 1
object cairn 907503.500 6439505.000 0.000 0.000 1.0000 1
```
| directive | rôle |
|---|---|
| `version <n>` | obligatoire, **en premier**. 1 pour cette session. |
| `terrain <nom>` | **informatif** : ne sert jamais à refuser un chargement. |
| `crs <epsg>` | `2154` = les objets portent des coordonnées **projetées** ; `0` = terrain sans référence géographique, coordonnées locales. |
| `object …` | sept champs : `asset`, `est`, `nord`, `dz`, `cap` (deg), `échelle`, `solide` (0/1). |
### Deux décisions qui font tout l'intérêt du format
**Coordonnées projetées, pas locales.** Le repère du moteur est *centré sur le
terrain chargé* : une position locale ne veut rien dire sans savoir quelle
emprise était chargée. Cette zone existe déjà sous quatre emprises différentes
(la dalle de Phase 7, la zone de 25 km², chacune à 1 m et à 2 m). Du Lambert 93
rend la scène indépendante de tout ça : un rocher posé sur la dalle isolée se
retrouve au même endroit du massif quand on charge la zone entière.
**Altitude relative au terrain (`dz`), pas absolue.** Même raisonnement sur la
verticale. La surface au pas de 2 m n'est pas exactement celle au pas de 1 m, et
le repli sur l'ancêtre du quadtree (Phase 12) peut afficher une tuile plus
grossière le temps d'une image. Une altitude absolue ferait flotter ou enterrer
chaque objet à la moindre variation. `dz = 0` veut dire « posé au sol », et ça
reste vrai partout. **Test headless dédié** : la même scène rechargée sur le même
endroit échantillonné à 2 m garde ses objets au sol au demi-centimètre près, et
l'objet volontairement surélevé de 2,5 m garde ses 2,5 m.
### Ce que le format ne stocke pas
* **Les identifiants d'objet** : ils sont attribués au chargement. C'est une
identité de *session* (sélection, annulation), pas une propriété de la scène ;
la stocker rendrait tout déplacement de ligne visible dans un diff sans rien
apporter.
* **La géométrie** : la scène ne contient que des références d'assets. Un fichier
de scène fait quelques centaines d'octets et se relit à l'œil.
### Robustesse
Une directive inconnue est **ignorée avec un avertissement** plutôt que fatale :
un fichier plus récent restera partiellement lisible. Une ligne `object` mal
formée est **comptée et sautée** — perdre un objet vaut mieux que perdre la
scène. L'écriture passe par un fichier temporaire renommé à la fin : une coupure
en pleine sauvegarde ne détruit pas ce qu'on était en train de sauvegarder. La
lecture et l'écriture forcent la **locale C** — dans une locale française le
séparateur décimal est la virgule, et `907512.250` se relirait comme `907512`.
### Où vivent les fichiers
* **Scènes** : `assets/scenes/<terrain sans suffixe de résolution>.vcsc`.
Même convention que l'orthophoto et pour la même raison : 1 m et 2 m sont deux
échantillonnages du *même endroit*, ils partagent leur scène.
* **Modèles** : `assets/editor/`.
Les deux sont sous `assets/`, donc **versionnés** (contrairement à `data/`, que
le `.gitignore` exclut). Une scène composée à la main est du contenu : la perdre
coûterait le temps de la refaire, alors qu'une heightmap se régénère en quatre
secondes depuis le `.laz`.
`assets/scenes/demo_phase15.vcsc` est **écrite à la main** — c'est ce qui prouve
que le format est réellement éditable sans lancer le jeu.
---
## 5. Les touches
Le mode éditeur est **exclusif** : tant qu'il est actif, aucune touche de jeu
n'est lue, et réciproquement. C'est ce qui autorise l'éditeur à reprendre des
lettres déjà prises (`E` abat un arbre en jeu, sélectionne un objet en édition).
À chaque bascule, **tous** les fronts descendants sont resynchronisés
(`syncAllKeyEdges`) : sans ça, entrer en édition avec `E` enfoncé sélectionnerait
un objet, et en sortir avec `E` enfoncé abattrait un arbre.
| touche | effet |
|---|---|
| `F2` | entrer / sortir du mode éditeur |
| `ZQSD` + `espace` / `maj-gauche` | voler (caméra libre) |
| molette | vitesse de vol, × ou ÷ 1,25 par cran (2 à 600 m/s) |
| clic droit maintenu | regarder |
| **clic gauche** ou `INSER` | poser au point visé / reposer l'objet en main |
| `E` | sélectionner l'objet visé |
| `G` | saisir / reposer la sélection |
| `SUPPR` | supprimer la sélection |
| `ECHAP` | abandonner la saisie, puis la sélection |
| `TAB` ou `PAGE_SUIV` / `PAGE_PREC` | asset suivant / précédent (cyclique) |
| `1`..`9` | rang direct dans la page courante du catalogue |
| `←` `→` | tourner (90 °/s) |
| `↑` `↓` | échelle (× 1,8 par seconde, **multiplicative**) |
| `DEBUT` / `FIN` | monter / descendre par rapport au sol (0,6 m/s) |
| `K` | solide ↔ traversable |
| `CTRL gauche` | pas fin (divise les trois vitesses par 8) |
| `RETOUR ARRIÈRE` | annuler |
| `F5` | sauvegarder |
| `F9` | recharger depuis le disque |
| `L` | réafficher le catalogue |
**Choix des touches.** GLFW raisonne en positions physiques façon QWERTY US (note
clavier de `core/Camera.hpp`). Les touches de réglage sont donc prises parmi
celles qui occupent la **même position physique** en AZERTY et en QWERTY :
flèches, pavé de navigation, rangée de fonctions, `Tab`, `Retour arrière`,
`Échap`, rangée des chiffres. Les seules lettres utilisées — `E`, `G`, `K` —
sont à la même place sur les deux.
**Pourquoi `INSER` en plus du clic** : à l'usage, on règle aux flèches puis on
pose sans ramener la main sur la souris. Mais surtout, le harnais automatisé ne
peut piloter que le clavier : sans cette touche, la pose serait la seule fonction
de l'éditeur qu'aucun test ne pourrait exercer sous Vulkan. Les deux voies
passent par le même `placePressed`, donc le chemin exercé est bien celui du clic.
### Options de ligne de commande
```
vercora.exe [scene] --editor démarre directement en mode édition
vercora.exe [scene] --scene=chemin.vcsc fichier de scène explicite
vercora.exe [scene] --no-scene ni catalogue, ni objets, ni éditeur
vercora.exe [scene] --editor-assets=rep dossier de modèles à scanner
```
`--no-scene` reproduit **exactement** le comportement d'avant la Phase 15 : c'est
le témoin de toute mesure avant/après.
---
## 6. Les assets de test
Cinq modèles **générés en code**, même parti pris que l'arbre (Phase 5), la
pierre (Phase 6) et l'herbe (Phase 11) : aucun fichier, aucun téléchargement,
aucune licence à vérifier.
| id | description | hauteur | rayon de collision |
|---|---|---:|---:|
| `rocher` | bloc arrondi facetté (octaèdre subdivisé, bruité par hachage) | 1,71 m | 1,47 m |
| `bloc` | dalle basculée anguleuse, trois boîtes imbriquées | 2,97 m | 1,48 m |
| `cairn` | quatre pierres empilées | 1,08 m | 0,64 m |
| `abri` | abri de pierre à deux pentes, **avec porte** | 2,60 m | 2,35 m |
| `poteau` | poteau de balisage avec plaque | 2,02 m | 0,52 m |
Plus `assets/editor/octaedre.obj`, seul asset venant d'un **fichier** : c'est le
seul qui prouve que ce chemin fonctionne dans une partie réelle.
### Le bruit est un hachage, pas un générateur à état
Les déformations du rocher sont tirées d'un **hachage de l'indice de sommet** —
la leçon de la Phase 11 sur le semis de végétation. Un `mt19937` rend une suite
qui dépend de l'*ordre* des appels ; deux constructions du même mesh dans un
ordre différent donneraient deux géométries. Ça compte ici parce que l'empreinte
de **collision** est déduite de la boîte englobante du mesh : une géométrie qui
varierait donnerait une collision qui varie, et une scène sauvegardée ne se
rechargerait pas à l'identique. Figé par test (comparaison bit à bit).
### Ancrage n'est pas centrage
Convention commune : dimensions **absolues** en mètres, **pied à `y = 0`**,
ancrage horizontal à l'origine.
Mais l'ancrage n'est pas forcément le centre de la boîte englobante, et c'est
délibéré : le poteau de balisage a son **mât** à l'origine, sa plaque débordant
vers +X. Planter un panneau, c'est planter le mât au point visé, pas y placer le
milieu de l'ensemble mât + panneau, qui n'existe nulle part physiquement.
Un asset **chargé depuis un fichier** ne dit rien de son intention : son origine
est où l'auteur l'a laissée. Faute de mieux, `normalizeAssetMesh` le **recentre
de force** sur sa boîte englobante et pose son point le plus bas à zéro. C'est le
défaut le moins mauvais, pas une règle générale.
La propriété que *tous* respectent, et que le test vérifie, est plus faible et
plus utile : **l'ancrage tombe dans l'empreinte horizontale de l'objet**, et pas
au bord. Un objet posé entoure donc toujours le point visé.
*(Le test initial exigeait un centrage exact et a échoué sur trois assets sur
cinq. C'est la convention qui était fausse, pas la géométrie.)*
### Ordre du catalogue
Builtins d'abord, puis les fichiers **triés par nom**. Pas par goût de l'ordre :
les touches `1`..`9` désignent des rangs dans cette liste, et
`std::filesystem::directory_iterator` ne garantit aucun ordre — sans le tri, la
même touche poserait un modèle différent d'une exécution à l'autre.
Un fichier illisible est **signalé et sauté**, il n'interrompt pas le scan. Un
modèle hors des bornes 5 cm – 200 m est signalé (première cause : un `.obj`
exporté en centimètres) mais reste plaçable.
---
## 7. Ce qui a été vérifié
### Tests headless
**650 assertions** (425 avant la Phase 15, **+225**), sans GPU ni Vulkan.
`tools\run_logic_tests.bat`. Nouveaux blocs :
* assets générés — convention d'ancrage, normales unitaires, déterminisme bit à
bit ;
* catalogue — builtins, doublons refusés, scan d'un dossier temporaire avec un
`.obj` valide, un `.obj` cassé et un fichier d'extension inconnue, tri par nom,
normalisation d'un modèle chargé, dossier absent non fatal ;
* raycast terrain — distance exacte sur plan (14,142 m à 45°), regard vers le
ciel, **hors emprise contre emprise non déclarée**, œil sous la surface, pente
réelle, normale de surface ;
* scène éditable — suppression au milieu puis annulation **reprenant son
indice**, regroupement des retouches (20 rotations = 1 annulation), retouches
espacées = 2 annulations, invariants de `transform()`, renumérotation par
`replaceAll`, pile bornée qui jette la plus ancienne ;
* collision — répoussement hors du cylindre, **position repoussée réellement
libre**, recouvrement vertical, objet traversable, asset absent du catalogue,
et le **solveur composite** (forêt + éditeur bloquent tous les deux, composite
vide totalement transparent) ;
* visée — le plus proche des deux, hors de portée, rayon passant au-dessus ;
* format `.vcsc` — aller-retour exact, **indépendance vis-à-vis de la
résolution**, fichier partiellement fautif, en-tête obligatoire, terrain non
géoréférencé, objets hors emprise conservés mais comptés, convention de chemin,
aller-retour `toProjected`/`fromProjected` ;
* contrôleur — fantôme au point visé, viser le ciel ne pose rien, réglages du
pinceau conservés entre deux poses, pas fin, **saisie n'écrivant pas dans la
scène** et ne laissant qu'une annulation, sélection puis suppression puis
annulation, parcours cyclique du catalogue, drapeaux d'E/S consommés une fois,
`resetInteraction`.
### Sous Vulkan, couches de validation actives
`tools\run_vulkan_check.ps1` — **scénario G ajouté**, en trois processus :
* **G1** — édition : catalogue, trois poses d'assets différents, rotation du
pinceau, sélection, agrandissement, suppression, annulation, `F5`, `F9`,
sortie du mode, redimensionnements, fermeture propre.
* **G2** — partie **normale** (aucun `--editor`) sur le fichier écrit par G1 :
les objets doivent se charger seuls, être dessinés, et arrêter le joueur.
* **G3** — **témoin** : exactement la même marche que G2, mais `--no-scene`.
C'est l'écart entre G2 et G3 qui fait la preuve, pas la distance de G2 prise
isolément — sinon « le joueur a avancé de 0,7 m » pourrait tout aussi bien
vouloir dire qu'il s'est heurté au relief ou qu'il n'a jamais reçu la touche.
### L'indépendance vis-à-vis de l'emprise, sur la vraie zone de 25 km²
La propriété centrale du format ne vaut que si elle tient sur les vrais fichiers,
pas seulement sur un terrain de test. `assets/scenes/demo_zone25.vcsc` — six
objets écrits à la main en Lambert 93 — a été chargée sur
`vercora_zone_1m.vchm` **et** `vercora_zone_2m.vchm`, même point de vue :
| | 1 m | 2 m |
|---|---|---|
| objets chargés | 6 (5 solides) | 6 (5 solides) |
| hors emprise | 0 | 0 |
| altitude du sol au point de départ | 1781,64 m | 1781,66 m |
| `[Validation]` | 0 | 0 |
Les deux captures (`build\p15_zone_1m.png`, `build\p15_zone_2m.png`) sont
superposables : mêmes objets aux mêmes positions à l'écran, seul le relief fin
diffère. Les 2 cm d'écart d'altitude du sol entre les deux échantillonnages sont
exactement ce contre quoi le `dz` relatif protège — une altitude absolue aurait
laissé les objets enterrés ou flottants d'autant.
Cette scène ne porte **pas** le nom d'auto-chargement (`vercora_zone.vcsc`) : la
zone de jeu par défaut reste vierge, la scène ne se charge qu'avec `--scene=`.
### La mesure de collision
Sonde dédiée, trois processus, même binaire, même point de départ, même durée de
touche maintenue — **seule la présence de la scène change** :
| | distance parcourue vers le nord |
|---|---:|
| avec un rocher posé devant | **0,69 m** |
| témoin, sans la scène | **21,17 m** |
Et le chiffre est **prédit** : le rocher a été posé à 2,51 m devant le joueur,
son rayon de collision vaut 1,47 m, celui du corps 0,35 m — donc l'arrêt attendu
est à 2,51 − 1,82 = **0,69 m**. C'est ce qui distingue « ça a l'air de bloquer »
de « ça bloque là où le modèle le dit ».
### Le défaut que seul le harnais complet a révélé
**La première exécution complète du harnais a échoué**, et c'est le seul vrai
défaut de la session. Le scénario G rapportait **9 objets posés pour 3 touches
envoyées**, alors que le même scénario joué seul en posait 3, et que rejouer la
séquence exacte à la main — même touches, même timing — en posait 3 aussi. Ni le
code ni le rythme n'étaient en cause.
**La cause** : la suite complète dure huit minutes, chaque scénario ouvre une
fenêtre qui prend le focus, et **l'éditeur lit la souris *système***. Les clics
réels de l'utilisateur, destinés à d'autres fenêtres, atterrissaient dans celle
du jeu et posaient des objets.
C'est *exactement* le problème de la Phase 11 — « le jeu lit le clavier et la
souris SYSTÈME » — qui avait donné `--lock-input`. Sauf que ce verrou ne couvrait
que la **caméra** : l'éditeur n'existait pas encore.
**La nuance GLFW qui rendait le défaut invisible.** La position du curseur vient
de `GetCursorPos()` : un `WM_MOUSEMOVE` posté n'a aucun effet, limite connue et
documentée depuis la Phase 8. Mais **l'état des boutons, lui, est mis en cache
depuis les messages de fenêtre**. Les boutons sont donc atteignables là où le
curseur ne l'est pas. Raisonner « la souris ne passe pas » était vrai pour le
curseur et faux pour les clics.
**Reproduit à la demande, puis corrigé, avec contrôle négatif** — trois
`WM_LBUTTONDOWN` postés dans une fenêtre lancée avec `--lock-input` :
| | objets posés |
|---|---:|
| avant correction | **3** sur 3 clics |
| après correction | **0** sur 3 clics |
`--lock-input` coupe désormais la pose au clic. **Seulement la souris** : le
clavier doit rester vivant pour qu'un scénario puisse piloter l'éditeur caméra
figée — c'est la raison d'être de la touche `INSER`.
*Limite qui subsiste* : une vraie frappe clavier de l'utilisateur peut toujours
perturber un run, exactement comme pour les scénarios A à F. C'est la flakiness
déjà documentée dans `MEMORY.md`, et elle n'a pas de remède simple tant que le
jeu lit le clavier système.
*Au passage* : le harnais a gagné un paramètre `-Only` (`-Only G`, `-Only A,B`).
Mettre au point un scénario en payant les six autres à chaque essai décourage de
le faire correctement. Un scénario non joué est **ignoré, pas validé** ; un run
de référence se fait toujours sans `-Only`.
### Contrôle d'image
Trois captures (`tools\shot_editor.ps1`, nouveau) : un journal ne peut pas dire
si la teinte témoin s'applique — les trois états passent par le même mesh et le
même pipeline. Il faut regarder l'image. Même raison qui avait motivé
`screenshot_scene.ps1` en Phase 10.
* `build\p15_avec_objets.png` — les huit objets de la scène de démonstration
dessinés dans une partie **normale** (13,5 % de ciel contre 20,0 % pour le
témoin `--no-scene` : ils occultent réellement).
* `build\p15_editeur.png` — vol libre au-dessus de la scène, `[EDITEUR]` dans le
titre de la fenêtre.
* `build\p15_editeur_fantome.png` — le fantôme en **cyan**, posé au point exact
où le regard rencontre le sol.
* `build\p15_editeur_selection.png` — l'abri en **ambre** : la teinte de
sélection s'applique bien, et se distingue sans ambiguïté de celle du fantôme.
* `build\p15_zone_1m.png` / `build\p15_zone_2m.png` — la scène de contrôle sur
la zone de 25 km², aux deux résolutions (voir juste au-dessus).
### Non-régression
Voir §11 pour le relevé du run de référence et la liste des fichiers de phases
précédentes touchés.
---
## 8. Ce qui reste à améliorer
### 1. glTF — **non fait**, et c'est la principale limite de la session
`AssetCatalog::supportedExtensions()` ne connaît que `.obj`.
**Pourquoi** : un loader glTF 2.0 honnête demande un analyseur JSON, la gestion
du conteneur binaire `.glb` et des `.bin` externes, le décodage des accesseurs
(types de composants, entrelacement, `byteStride`), les modes de primitive, et
l'aplatissement de la hiérarchie de nœuds avec leurs transformations. C'est de
l'ordre de 600 à 800 lignes neuves — une session à part entière, et une session
dont le risque est réel alors que la consigne exigeait par ailleurs zéro erreur
de validation et une non-régression complète. Le choix a été de livrer l'éditeur
**complet** plutôt que l'éditeur et un loader à moitié.
**Ce que ça coûte** : les bibliothèques d'assets libres de droits distribuent
majoritairement du glTF. En pratique il faut aujourd'hui convertir en `.obj`
(Blender, `assimp`) avant de déposer dans `assets/editor/`.
**Où l'ajouter** : `supportedExtensions()` est le seul point d'extension. Le
reste de la chaîne — normalisation d'ancrage, empreinte de collision, catalogue,
placement, sérialisation — est déjà agnostique et n'aura pas une ligne à changer.
C'est le premier chantier à reprendre.
### 2. Collision par cylindre englobant
Exacte pour un rocher ou un cairn — ce que l'éditeur sert d'abord à poser — et
**fausse pour tout objet à intérieur** : l'abri de pierre a une porte, mais son
cylindre est plein, donc on ne peut pas y entrer. Le remède immédiat est le
drapeau par objet (`K` : traversable). La vraie réponse — collision par volumes
composés, ou par maillage — est un chantier à part.
Le cylindre est **contenant** et non inscrit (rayon = demi-diagonale
horizontale) : un obstacle un peu trop gros se contourne, un obstacle trop petit
se traverse par les coins, et traverser un rocher est bien plus visible que le
raser d'un demi-mètre.
### 3. Aucun frustum culling sur les objets posés
Un `DrawItem` par objet, à chaque image, qu'il soit visible ou non. Le culling de
la Phase 10 vit dans le quadtree du terrain, celui de la Phase 11 dans la
végétation instanciée ; aucun des deux ne s'applique ici. Sans conséquence à
l'échelle d'une scène d'éditeur (des dizaines d'objets), à reprendre le jour où
une scène en comptera des milliers. Le `Frustum` existe déjà et se brancherait en
quelques lignes.
### 4. Le catalogue est figé au démarrage
Déposer un `.obj` dans `assets/editor/` demande de relancer le jeu. Un rescan à
chaud serait facile côté catalogue, mais suppose de téléverser de nouvelles
géométries en cours de partie.
### 5. Pas de sauvegarde automatique
`F5` est explicite, et sortir du mode éditeur ne sauvegarde pas — le message de
sortie le rappelle. C'est volontaire (rien n'est écrit sans qu'on le demande),
mais un travail long peut être perdu à la fermeture.
### 6. Aucune aide au placement
Ni grille, ni magnétisme, ni alignement sur la normale du terrain : un objet posé
sur une forte pente reste vertical et flotte d'un côté. `terrainNormalAt()` est
déjà écrit et testé dans `core/TerrainRay.hpp` — il ne manque qu'une décision de
conception (un rocher épouse la pente, un poteau reste vertical), qui demande de
porter cette information dans l'asset.
### 7. Pas de rotation libre ni d'échelle non uniforme
Contrainte du contrat de `DrawItem` : le vertex shader utilise `mat3(model)`
comme normal matrix, ce qui n'est exact que pour une rotation suivie d'une
échelle **uniforme**. Autoriser plus imposerait de calculer et de pousser une
vraie normal matrix — possible (il reste 48 octets de push constant), non fait.
### 8. Pas de sélection multiple, pas de copier-coller
Une seule sélection à la fois. Poser dix rochers alignés se fait à la main.
### 9. Les objets posés n'interagissent avec rien
Ils bloquent, et c'est tout : pas d'abattage, pas de ramassage, pas d'ombre
portée (limite ouverte depuis la Phase 11), et l'éditeur ne peut ni déplacer ni
supprimer les arbres de `Forest` ou les pierres de `Ground`, qui restent semés
proceduralement.
### 10. Rien n'empêche d'empiler deux objets au même endroit
Voulu (on peut vouloir un tas), mais aucun signal ne prévient qu'on vient de
poser un rocher dans un autre.
---
## 9. Ce qu'il faudrait pour une version destinée aux joueurs
Cette session a délibérément écarté l'ergonomie. Si l'éditeur devait un jour
sortir du domaine du développeur, voici ce qui manque — classé par ce qui bloque
le plus, pas par difficulté.
1. **Tout le retour d'information passe par le journal.** L'état de l'outil,
le catalogue, les messages d'erreur : rien n'est à l'écran sauf `[EDITEUR]`
dans le titre. Un joueur ne lit pas une console. Il faut au minimum un
affichage tête haute : l'asset armé, ses réglages, la sélection, et le
réticule — **il n'y a même pas de réticule dessiné aujourd'hui**, on vise le
centre de l'écran sans repère.
2. **Le catalogue est une liste texte.** Il faudrait des vignettes, une
recherche, et des catégories dès que le dossier dépasse une dizaine de
modèles. Les touches `1`..`9` ne passent pas à l'échelle.
3. **Aucune confirmation, aucune protection.** `SUPPR` supprime sans demander
(l'annulation existe, mais il faut savoir qu'elle existe), et quitter sans
`F5` perd tout en silence.
4. **Les gizmos 3D manquent vraiment.** Régler au clavier convient à qui connaît
les touches ; poser une passerelle entre deux rochers à la flèche et à l'œil
est pénible. C'est le point où l'écart avec un vrai éditeur se creuse le plus.
5. **Rien n'est rebindable**, et la liste des touches n'est visible qu'une fois,
au moment d'entrer dans le mode.
6. **Aucune notion de projet ni de calques** : une seule scène par terrain, pas
de groupes, pas de nommage d'objets, pas de sélection multiple.
7. **Le format de scène n'a pas de garde-fou de version côté écriture** : un
exécutable ancien relisant un fichier plus récent perd silencieusement les
champs qu'il ne connaît pas dès la prochaine sauvegarde. Acceptable entre
développeur et lui-même, pas pour du contenu de joueur.
## 10. Ce qui n'a pas pu être vérifié
* **Le comportement de la souris en usage réel.** Le harnais ne peut pas piloter
le curseur ; la pose au clic, la molette de vitesse de vol et la rotation au
clic droit n'ont donc été exercées qu'à la main. Le *chemin de code* de la
pose, lui, est couvert : le clic et la touche `INSER` aboutissent au même
`placePressed`.
* **Un vrai fichier glTF** — le loader n'existe pas.
* **Un `.obj` volumineux ou exotique** : le catalogue n'a été scanné qu'avec des
modèles minuscules (un tétraèdre en test, un octaèdre en jeu). Les
avertissements d'unités suspectes ne sont exercés que par le test headless.
* **Une scène de plusieurs centaines d'objets** : ni les performances de dessin
(un `DrawItem` par objet), ni celles de la collision (balayage linéaire de tous
les objets à chaque déplacement) n'ont été mesurées au-delà de la dizaine.
Les deux sont linéaires et devront être indexées le jour où ça comptera.
## 11. Non-régression
### Run de référence, suite complète
`tools\run_vulkan_check.ps1` sans `-Only`, sur le binaire livré :
```
Code de sortie A..G : 0 / 0 / 0 / 0 / 0 / 0 / 0/0/0
Lignes de log : 2472
Messages [Validation] : 0
Lignes [ERROR] : 0
Lignes [WARN] : 0
Fermeture propre A..G : True x9
```
Les six scénarios antérieurs sont inchangés et verts : 2 arbres abattus, 3
débitages, 7 objets ramassés des quatre natures, 1 percussion, vol de parapente
avec atterrissage naturel, sortie à vélo (50,0 km/h au pic en descente, 5,4 km/h
de moyenne en montée sur 20 relevés en mouvement, 96,9 m de dénivelé suivi),
escalade (sommet à 41,6 m avec 14 % de jauge, 75 relevés).
**650 assertions headless** (425 avant, **+225**), zéro avertissement de
compilation en `/W4`.
### Sur la flakiness
Trois exécutions complètes ont été nécessaires. La première a échoué sur le
défaut souris décrit en §7 — un vrai défaut, corrigé. La deuxième a échoué sur le
**scénario F**, rejoué seul immédiatement après et vert (41,5 m, sommet atteint,
0 validation) : c'est la flakiness `PostMessage` déjà documentée dans
`MEMORY.md`, et non une régression. La troisième est le run de référence
ci-dessus.
### Fichiers de phases précédentes touchés, et pourquoi :
| fichier | modification |
|---|---|
| `src/core/Camera.hpp/.cpp` | `setModeLocked()` (2 lignes dans `update`), `moveSpeed()` |
| `src/core/Window.hpp/.cpp` | accumulateur de molette (`consumeScroll`) |
| `src/assets/Heightmap.hpp/.cpp` | `fromProjected()`, l'inverse de `toProjected()` |
| `src/renderer/DrawItem.hpp` | documentation de `params` par matériau |
| `shaders/cube.vert/.frag` | teinte témoin — **inerte à force nulle** |
| `src/main.cpp` | câblage du mode éditeur, solveur composite, position dans le journal |
`Heightmap::fromProjected` mérite un mot : la formule **existait déjà**, recopiée
à la main dans `main.cpp` pour l'option `--start` de la Phase 11, et l'éditeur en
avait besoin une troisième fois. Deux copies d'une convention d'axes dont une
seule serait corrigée le jour où elle changerait — exactement le piège que le
commentaire de `toProjected` décrivait. La conversion vit désormais dans les deux
sens au même endroit, et `main.cpp` l'utilise.
Le changement de shader est le seul qui touche le rendu. Il est **inerte** pour
tout `DrawItem` dont `params.x` vaut zéro, c'est-à-dire pour tout le jeu : la
branche n'est même pas prise.
---
## 12. Suite de session (2026-08-23) : sélection au clavier sans viser (F3/F4)
Reprise après vérification que la session initiale tenait toujours : build
propre, **650/650** assertions headless, puis `run_vulkan_check.ps1` complet -
zéro validation, six scénarios antérieurs verts, scénario G vert. Une seule
anomalie, le **scénario F** en échec sur la fermeture propre ; rejoué seul
immédiatement après (`-Only F`), il passe (sommet atteint, 41,1 m de dénivelé,
0 validation) - c'est la flakiness `PostMessage` déjà documentée dans
`MEMORY.md` pour les scénarios A/B/F, pas une régression.
### Le choix : ergonomie clavier, pas glTF
La consigne proposait trois pistes : l'annulation (déjà livrée en §1), le glTF,
ou l'ergonomie clavier. Le glTF reste **la plus grosse limite documentée**
(§8.1), mais c'est précisément pour ça qu'il a été écarté ici : la session
initiale l'a chiffré à 600-800 lignes neuves (analyseur JSON, conteneur
binaire `.glb`, décodage d'accesseurs, aplatissement de hiérarchie de nœuds) et
a choisi explicitement de livrer un éditeur **complet** plutôt qu'un éditeur et
un loader à moitié, alors que la consigne exige **zéro erreur de validation et
une non-régression complète**. Retenter ce chantier dans une passe de suite de
session, sans le temps d'un loader testé aussi rigoureusement que le reste de
l'éditeur, aurait repris exactement le risque que ce choix initial évitait -
sans même gagner en confort d'usage tant qu'aucune bibliothèque de modèles
`.gltf` n'est effectivement déposée dans `assets/editor/`.
L'ergonomie clavier, elle, correspond à une lacune concrète et déjà nommée en
§9.4 : *"il n'y a même pas de réticule dessiné aujourd'hui"* et, plus large,
l'absence de toute aide à la manipulation en dehors des flèches et de la
visée. Un défaut precis et bien scope s'en degage : **`pickPressed` (touche
E) exige que la visée touche l'objet.** Retrouver un objet posé loin du regard
courant n'a donc qu'une voie - revenir dessus à la souris/au vol - ce qui va
à l'encontre de l'esprit "outil clavier" documenté en §5. C'est un changement
petit, testable intégralement en headless, et sans surface de régression sur
le rendu ou la synchronisation GPU (aucun shader, aucun DrawItem touché).
### Ce qui a été ajouté
`EditorInput::cycleNextPressed` / `cyclePrevPressed` (nouveaux champs, faux par
défaut - **aucun code existant n'est affecté tant qu'ils ne sont pas levés**).
`EditorController::update` les traite juste avant le bloc de saisie, avec la
même garde que `pickPressed` : ignorés pendant qu'un objet est en main, sinon
on changerait la cible des réglages **sous** l'objet suivi par la visée.
- Rien sélectionné + "suivant" -> premier objet de la scène (ordre
d'insertion, celui que `EditorScene::objects()` expose) ; "précédent" ->
dernier. Même convention que `selectBrush(-1)` depuis le rang 0.
- Un objet sélectionné + "suivant"/"précédent" -> avance/recule d'un rang,
**cyclique** dans les deux sens (modulo positif, comme le parcours du
catalogue).
- Scène vide -> aucune sélection, message journalisé, pas d'erreur.
Touches choisies : **F3** (suivant) / **F4** (précédent) - libres, adjacentes
à F2 (bascule éditeur) et F5 (sauvegarde) déjà pris, et **physiquement
identiques en AZERTY et QWERTY** (rangée de fonctions), donc conformes à la
convention de touches posée en §5. Ligne d'aide (`kEditorHelp`, journalisée à
l'entrée en mode éditeur) mise à jour en conséquence.
### Vérifié
- **9 nouvelles assertions headless** (650 -> **659**) dans
`tests/logic_tests.cpp`, section *"Cycle F3/F4 parmi les objets posés"* :
parcours dans les deux sens, bouclage aux deux extrémités, scène vide,
et surtout **le cas qui aurait pu casser silencieusement** - le cycle est
bien ignoré pendant une saisie, et la saisie en cours n'est pas interrompue.
- **Sous Vulkan réel**, `tools\run_vulkan_check.ps1` (scénario G1) envoie
désormais deux `F3` puis un `F4` par `PostMessage` (le harnais ne pilote que
le clavier, voir §5) avant de reviser l'objet **par la visée** pour ne pas
changer quel objet la suite du scénario supprime. Une mesure dédiée compte
les lignes de journal `[F3/F4]` et **exige exactement 3** (une par touche
envoyée) dans le critère de réussite du scénario G - un défaut de front
descendant (touche perdue, ou comptée deux fois) ferait donc échouer le run
plutôt que de passer inaperçu.
- Run cible (`-Only G`) : **`Cycle sans viser (F3/F4) : 3 selection(s)`**,
0 `[Validation]`, fermeture propre des trois processus G1/G2/G3, mêmes
compte d'objets et même distance de collision (0,27-0,28 m) qu'avant ce
changement - la modification du scénario ne perturbe pas les mesures qui
suivent.
- Run complet (`run_vulkan_check.ps1`, sans `-Only`) : voir le relevé de
référence en tête de cette section.
### Fichiers touchés
| fichier | modification |
|---|---|
| `src/editor/EditorController.hpp` | deux champs `EditorInput` |
| `src/editor/EditorController.cpp` | bloc de cycle, avant la saisie |
| `src/main.cpp` | deux touches F3/F4, deux `KeyEdge`, aide journalisée |
| `tests/logic_tests.cpp` | 9 assertions nouvelles |
| `tools/run_vulkan_check.ps1` | scénario G1 exerce F3/F4, mesure et gate dédiés |
Aucun fichier de rendu (shaders, `Renderer`, `DrawItem`) n'est touché : ce
changement ne modifie que la machine à états de l'éditeur et l'entrée
clavier, jamais ce qui se dessine.
### Ce que ça ne résout pas
Le réticule manquant (§9.1), les gizmos 3D (§9.4) et le glTF (§8.1) restent
entiers. Cette passe referme UNE lacune d'ergonomie clavier précisément
scopée ; les autres limites listées en §8 et §9 sont inchangées.
+340
Voir le fichier
@@ -0,0 +1,340 @@
# NOTES-PHASE16.md — Besoins primaires du joueur
Session du 2026-08-24. Suite de la Phase 15 (editeur de niveau). Objectif :
donner au joueur quatre besoins primaires — faim, soif, fatigue, temperature —
qui evoluent avec le temps et l'activite, qui ont des CONSEQUENCES sur ce qu'il
peut faire, et qu'on puisse au moins partiellement satisfaire.
Ce fichier documente ce qui a ete construit, les chiffres retenus et POURQUOI,
les decisions de design prises sans arbitrage exterieur, et surtout ce qui ne
marche pas ou pas encore.
---
## 1. Ce qui existe maintenant
| Fichier | Role |
|---|---|
| `src/world/Needs.hpp/.cpp` | les quatre jauges, le climat, l'horloge de jeu, les coefficients de penalite |
| `src/world/WaterSource.hpp/.cpp` | detection des creux ou il est credible de boire, sur relief reel |
| `src/main.cpp` | cablage : contexte par image, application des penalites, touche T, titre, journal |
| `tests/logic_tests.cpp` | sections « Phase 16 » : **129 assertions** ajoutees (659 → **788**) |
| `tools/run_vulkan_check.ps1` | **scenario H** : les jauges et le point d'eau sous Vulkan, sur la dalle reelle |
Rien dans `Bike`, `Climber`, `Paraglider` ou `Camera` n'a change de comportement.
La seule modification de `Camera` cote appelant est que sa vitesse de marche est
desormais reglee a chaque image au lieu d'une fois au demarrage.
---
## 2. Le modele, et les chiffres
Les quatre jauges vivent dans `[0, 1]`, **1 = tout va bien** pour les quatre.
C'est une uniformite voulue : « fatigue 100 % » se lirait a l'envers, d'ou le
libelle **forme** a l'affichage.
### 2.1 L'unite de temps est la SECONDE REELLE
Tous les taux sont par seconde reelle, pas par heure simulee. L'horloge de jeu
(§2.4) n'accelere **que** l'heure, donc l'ambiante — jamais les jauges. C'est le
point le plus facile a confondre en relisant `NeedsParams`.
Cible du cahier des charges : rien de perceptible en quelques minutes, un vrai
enjeu sur 30 a 60 minutes. Valeurs retenues, jauges pleines, marche continue :
| Besoin | A l'arret | A la marche | Verifie par |
|---|---|---|---|
| faim | vide en 4 h | vide en 2 h 06 | `5 min de marche : la faim se voit a peine`, `30 min…` |
| soif | vide en 2 h 30 | vide en 1 h 05 | idem |
| forme | **remonte** (plein en 20 min) | vide en 1 h 30 | `45 min de marche : la moitie de la forme` |
| temperature | depend du relief et de l'heure | idem | §2.3 |
A 5 minutes, les trois jauges sont encore au-dessus de 90 % ; a 30 minutes, la
soif est sous 60 % et la forme sous 75 %. **L'ordre est voulu** : on a soif avant
d'avoir faim, et c'est la soif qu'on peut etancher. La faim est deliberement la
plus lente parce que c'est le seul besoin qu'on ne peut pas encore satisfaire.
### 2.2 L'effort est le seul curseur d'intensite
Une seule table (`activityEffort`), la marche valant 1 :
```
repos 0,0 marche 1,0 velo 1,8 escalade 4,0 parapente 0,3
```
Faim, soif, fatigue et chaleur produite en derivent toutes. Consequence
mesuree : l'escalade fatigue **exactement quatre fois** plus vite que la marche
(assertion dediee), le velo 1,8 fois.
L'escalade a deja sa jauge courte (`Climber::stamina`, quelques minutes). La
fatigue est l'**enveloppe longue** : elle n'empeche pas une paroi, elle empeche
d'en enchainer dix dans l'apres-midi.
Le **repos est le seul etat qui refait la forme**, et il exige l'immobilite
reelle : `main.cpp` lit le deplacement effectif de la camera entre deux images,
pas les touches. Un joueur qui pousse contre un rocher tient sa touche, n'avance
pas — et ne recupere pas non plus. Le mode vol libre (F) compte comme du repos :
ce n'est pas une facon de se deplacer dans le monde.
### 2.3 La temperature, et le lien avec `heightAt()`
```
ambiante = 15 °C (niveau de la mer)
+ 8·cos(2π(h − 15)/24) cycle diurne, max a 15 h
− 6,5 · altitude_km gradient adiabatique standard
+ 4 · adret · ensoleillement adret/ubac, nul la nuit
ressenti = ambiante + 1,5·effort − 3·(1 − forme) [− 6 en vol] [+ 5 a l'abri]
```
La jauge descend a `1/(1800·10)` par degre et par seconde sous le confort
(12 °C) : dix degres en dessous la vident en 30 minutes, cinq degres en une
heure. Elle remonte trois fois plus vite qu'elle ne descend — se remettre d'un
coup de froid ne doit pas couter une demi-session.
Sur la dalle chargee (420 → 982 m), le gradient donne **3,7 °C d'ecart permanent
entre le fond de vallee et la crete**, et le cycle diurne 16 °C entre 3 h et
15 h. Marcher de nuit coute donc a peu pres autant que marcher 2400 m plus haut.
Releve reel du scenario H : ambiante de **10 a 15 °C** entre 9 h et ~10 h de jeu
a 586 m.
**L'adret/ubac est calcule, pas devine.** `terrainExposure()` lit le gradient du
terrain : `+Z` va vers le sud (convention `Heightmap::toProjected`), donc un
versant qui descend vers `+Z` (`dh/dz < 0`) est un adret. L'exposition est
**ponderee par la pente** — sur du plat il n'y a ni adret ni ubac, sans quoi une
plaine bruitee produirait des expositions extremes et aleatoires d'un metre a
l'autre. La base de lecture est de 4 m, meme valeur et meme raison que
`BikeParams::slopeSampleStep`.
### 2.4 L'horloge
Le jeu n'avait aucune notion d'heure (le soleil des shaders est une direction
fixe). `GameClock` en ajoute une, au facteur **12** : une minute reelle vaut
douze minutes de jeu, donc une session d'une heure traverse reellement une
tombee de nuit. **Rien dans le rendu ne change avec elle** — voir §5.
### 2.5 Les consequences
Quatre coefficients multiplies, plancher absolu a **0,35** :
| Jauge | Seuil ou la penalite commence | Coefficient a jauge nulle |
|---|---|---|
| forme | 0,50 | 0,55 |
| faim | 0,25 | 0,70 |
| soif | 0,25 | 0,65 |
| froid | 0,25 | 0,70 |
Le produit brut des quatre a jauge nulle vaut 0,175 ; le plancher le remonte a
0,35. C'est la traduction chiffree de « pas de punition brutale » : au plus mal,
le joueur avance encore a plus du tiers de sa vitesse, il n'est jamais immobilise
loin de tout. Une assertion dediee verifie que ce plancher **mord vraiment**
(le produit brut est bien en dessous) — sans quoi il serait decoratif.
Les manques s'aggravent entre eux : un joueur affame, assoiffe ou glace se
fatigue exactement **deux fois** plus vite et recupere deux fois moins vite. Ce
qui empeche de compenser indefiniment la soif par des pauses.
**Un seul coefficient pour les quatre activites**, applique en trois points de
`main.cpp` :
* marche : `camera.setMoveSpeed(kWalkSpeed × facteur)` ;
* velo : la commande de pedalage est multipliee par le facteur. Le modele du velo
n'a pas ete touche — il ecrete deja ses entrees dans `[0, 1]`, et une commande
plus faible y produit exactement ce qu'on veut : moins d'acceleration, donc une
vitesse d'equilibre plus basse, donc **moins de distance et une pente
franchissable plus faible**. Un joueur epuise cale la ou il passait le matin ;
* escalade : la commande de montee, meme mecanique. **La desescalade est ralentie
aussi** (le facteur s'applique au signe compris) : une desescalade a pleine
vitesse serait la faille evidente du systeme.
Les tests ne verifient pas que le coefficient est petit, ils verifient l'**effet
reel** : distance parcourue a velo en une minute, et hauteur gagnee en 20 s
d'escalade, mesurees avec et sans la penalite d'un joueur epuise.
---
## 3. Les points d'eau
Le jeu n'a pas d'eau : ni surface liquide, ni rendu, ni physique de fluide.
`WaterSource` ne pretend pas en ajouter. Il repond a une question etroite : **ou,
sur un relief LiDAR reel, serait-il credible de boire ?**
Reponse cherchee dans la forme du terrain : les points a la fois **peu pentus**
et **concaves**. Le balayage se fait une seule fois au chargement.
### 3.1 Ce qui a ete essaye et ce qui a ete retenu
Premiere version : 4 sondes sur les axes a 25 m, pente ≤ 10 %, 3 sondes sur 4
plus hautes, balayage au pas de 50 m. Resultat sur la dalle reelle : **zero point
d'eau**. Trois causes distinctes, toutes mesurees :
1. **Ce massif est raide.** 562 m de denivele sur 1 km : au pas de 50 m,
**seuls 10 points sur 361** passent sous 10 % de pente. Seuil porte a 15 %,
ce qui reste tres loin des 60 % typiques du versant.
2. **Le pas de balayage etait trop grossier.** Le rayon utile d'un creux (celui
ou la pente reste sous le seuil tout en gardant assez de concavite) vaut une
vingtaine de metres. Un pas de 50 m passe simplement a cote. Ramene a **20 m**
(62 500 candidats sur 25 km², ~800 000 `heightAt`, une seule fois).
3. **Quatre sondes ne savent pas distinguer un talweg d'un col.** Un talweg a
deux sondes plus hautes (les versants) et deux plus basses (amont, aval) :
exiger 3 sur 4 ne retient que les cuvettes fermees, qui n'existent
pratiquement pas ici. Mais descendre a 2 sur 4 laisse passer les **cols**, qui
ont exactement la meme signature et ou il n'y a rien a boire.
→ **Huit directions** (axes + diagonales), seuil a **5 sur 8** : un talweg a
ses deux versants qui couvrent chacun plus d'une direction, un col n'en a que
quatre. Le seuil passe entre les deux.
Parametres finaux : pas 20 m, sondes a 25 m, pente ≤ 15 %, concavite moyenne
≥ 1,0 m, 5 sondes sur 8 montantes, ecartement minimal 150 m, 64 points au plus.
**Resultat sur la dalle du Gua : 2 points d'eau**, a 3,27 m et 2,03 m de creux.
Le premier est en monde `(−75, 285)`, soit E 907425 / N 6439215.
### 3.2 Ce que cette methode ne sait pas faire
* une **source de versant** ne passe pas (elle n'est ni plate ni concave) ;
* un **replat de col** assez ferme peut passer ;
* une cuvette placee **entre deux points de la grille** peut passer inapercue ;
* elle ne sait rien des **saisons**, du debit, ni du gel.
C'est une heuristique, elle est retenue parce qu'elle est verifiable, bon marche,
et qu'elle donne un ancrage testable. La lecon de la Phase 14 vaut ici aussi :
savoir ou l'eau **pourrait** etre ne dit pas qu'elle y est. Le jour ou le reseau
hydrographique de l'IGN sera charge, c'est cette fonction qui disparaitra, pas
ses appelants.
### 3.3 Boire
Touche **T**, portee **4 m** a l'horizontale (un peu plus que le ramassage
d'objet : un point d'eau est une zone, pas un objet pose au centimetre pres).
Le refus est journalise **avec la distance** — sans elle, « trop loin » ne dit
pas s'il faut faire deux pas ou deux kilometres.
---
## 4. Ce qui prouve que ca marche
### 4.1 Tests headless — 129 assertions (659 → 788)
`tools\run_logic_tests.bat`. Couvrent :
* l'etat de depart, et le fait qu'un `deltaTime` nul ou negatif ne fait rien ;
* les **rythmes annonces** : 5 min ≈ rien, 30 min ≈ enjeu, 45 min = demi-forme,
90 min = forme a plat. Le test de fatigue maintient faim et soif pleines, sans
quoi il mesurerait en realite le couplage entre jauges et non la fatigue ;
* l'ordre des efforts entre les quatre activites, et le rapport exact de 4 entre
escalade et marche ;
* le repos : recuperation en 20 min, et le fait qu'il ne rend **ni** faim **ni**
soif — sans quoi s'arreter reglerait tout et le point d'eau ne servirait a rien ;
* l'aggravation croisee, verifiee au facteur exact (× 2 a manque total) ;
* les quatre coefficients, seuil par seuil, plancher par plancher, **plus** le
controle que le plancher global mord ;
* le climat : gradient d'altitude au degre pres, denivele reel de la dalle,
amplitude diurne, adret/ubac de jour **et** son absence de nuit ;
* l'exposition lue sur quatre reliefs : plat, est-ouest, adret franc, ubac franc,
pente douce ponderee. Un terrain penche **selon Z** a du etre ajoute pour ca :
`SlopedTerrain` penche selon X, et un test d'exposition dessus passerait meme
avec un signe inverse ;
* la vitesse de refroidissement et de rechauffement, l'effet de l'effort, du vent
de vol, de l'abri, et le fait qu'a 1000 m plus haut on se refroidit plus vite ;
* l'horloge : facteur 12, passage de minuit, reglages hors bornes ;
* les points d'eau : une cuvette trouvee **au bon endroit**, quatre controles
negatifs (plat, versant raide, versant doux **sans** concavite, sommet de
bosse), le retrait aux bords, l'emprise degeneree, l'ecartement, le
determinisme, la recherche du plus proche en distance **horizontale** ;
* les **consequences reelles** : distance a velo et hauteur d'escalade, mesurees
avec et sans penalite, sur les vraies classes `Bike` et `Climber`.
### 4.2 Vulkan reel — scenario H (8 scenarios, tous verts)
`tools\run_vulkan_check.ps1`. Depart **sur un point d'eau que le jeu a lui-meme
detecte**, puis :
* T au bord du creux → `Boire : soif etanchee au point d'eau (0.000000 m)` ;
* 30 m plus loin, T → `le point d'eau le plus proche est a N m`. Les deux
ensemble, jamais l'un seul : une portee infinie donnerait le premier message,
une portee nulle le second ;
* 160 s de marche puis 60 s d'immobilite complete. La telemetrie (une ligne par
seconde) doit montrer la forme **descendre puis remonter** — les deux sens.
Une jauge qui ne fait que descendre est une jauge sans repos ; une qui ne fait
que monter ne coute rien.
Releve du run de reference : 236 echantillons, forme 100 → **98** → 100,
soif minimale 95 %, ambiante 10 à 15 °C, 2 points d'eau, **zero `[Validation]`**,
fermeture propre. Les sept scenarios anterieurs sont inchanges et verts.
Deux pieges rencontres en ecrivant ce scenario, notes parce qu'ils se
reproduiront :
* le scenario attendait d'abord `Boire : pas soif` au point d'eau, en supposant
la jauge encore exactement pleine. **Elle ne l'est jamais** : deux secondes de
jeu l'ont deja fait descendre de quelques millioniemes, invisibles a
l'affichage entier mais suffisants pour que `drink()` reussisse ;
* a 100 s de marche, la forme tombait a 99 % puis 98 % selon les runs — la marge
tenait a un point d'arrondi. Portee a 160 s (~3 %). Une marche genee par le
relief (le joueur bute, donc ne se fatigue plus) aurait autrement efface le
signal.
---
## 5. Decisions prises seul, et ce qu'elles coutent
1. **Aucune jauge ne tue.** Pas de mort, pas d'ecran de fin, pas de degat.
Coherent avec « pas de punition brutale », mais ca veut dire qu'un joueur peut
rester indefiniment a zero partout, ralenti et rien de plus. C'est un choix,
pas un oubli.
2. **Les penalites sont appliquees aux ENTREES, pas dans les modeles.**
`Bike`, `Climber` et `Paraglider` ignorent tout des besoins. Avantage : leur
physique, testee depuis deux phases, ne peut pas regresser. Inconvenient : la
fatigue ne peut pas exprimer autre chose qu'« une commande plus faible » — un
grimpeur epuise ne tremble pas, il monte lentement.
3. **Une horloge de jeu, mais aucun changement visuel.** Le facteur 12 fait
tomber la nuit pendant une session, et la temperature en tient compte, mais le
soleil des shaders reste une direction fixe : **il fait toujours jour a
l'ecran**. C'est incoherent visuellement et c'est assume — un cycle
jour/nuit rendu est une phase a lui seul.
4. **`eat()` existe sans aucun appelant.** Le jeu ne produit rien de comestible
(l'inventaire ne connait que buches, branches, pierres, eclats), et inventer
une cueillette sans contexte narratif depassait le cadre. La fonction est
ecrite et testee pour que le jour venu il n'y ait rien a inventer ici. **La
faim n'est donc, a ce stade, satisfaisable par rien** — d'ou le choix d'en
faire de loin le besoin le plus lent.
5. **`NeedsContext::sheltered` existe sans aucun appelant non plus**, pour la
meme raison : aucun abri n'existe dans le jeu. Le champ est le point
d'ancrage prevu pour l'artisanat, et les tests l'exercent deja.
6. **Le mode editeur gele les quatre jauges.** C'est un outil de developpement :
voir la fatigue tomber en survolant 25 km² n'aurait aucun sens. Elles
reprennent exactement ou elles en etaient a la sortie (F2).
7. **Affichage minimal, dans le titre de la fenetre**, comme l'inventaire depuis
la Phase 6 : `faim 87% soif 62% forme 44% chaud 91% - 14:35`. Pourcentages
**entiers**, et le titre n'est reecrit qu'une fois par seconde (au rythme du
compteur de FPS) — le rafraichir soixante fois par seconde ferait soixante
appels systeme pour montrer le meme texte. Le detail (temperatures, facteur de
deplacement) va dans le journal, qui est ce que depouille le harnais Vulkan.
8. **Le seuil de soif liee a la chaleur est distinct du confort.** Une premiere
version reutilisait la temperature de confort (12 °C) comme seuil de « chaud »,
ce qui rendait le joueur assoiffe par une journee de printemps a 17 °C : la
soif doublait, et cinq minutes de marche la faisaient deja tomber de 15 %.
Deux seuils separes desormais, 12 °C pour le froid et 22 °C pour la soif.
---
## 6. Ce qui reste ouvert
* **De quoi manger.** C'est le trou beant du systeme. Cueillette, chasse ou
reserves de depart : c'est une decision de cadrage, pas une decision technique.
* **Un abri**, qui donnerait un sens a `sheltered` et un usage aux buches.
* **Le rendu du cycle jour/nuit**, sans lequel l'horloge reste invisible.
* **Le vrai reseau hydrographique** (IGN), qui remplacerait l'heuristique de
detection des creux.
* **Le sommeil.** Le repos refait la forme, mais rien ne distingue une pause
d'une nuit.
* **Le portage.** L'inventaire n'a ni masse ni encombrement ; le jour ou il en
aura, la charge devrait entrer dans l'effort, donc dans `activityEffort`.
+323
Voir le fichier
@@ -0,0 +1,323 @@
# NOTES-PHASE17.md — Première empreinte environnementale
Session du 2026-08-25. Suite de la Phase 16 (besoins primaires). Objectif :
que le monde GARDE UNE TRACE de ce que le joueur y fait, et que cette trace
change ce qu'il y trouve — sans jamais le lui dire.
Ce fichier documente ce qui a été construit, les chiffres retenus et POURQUOI,
les deux erreurs de réglage que seule une mesure sous Vulkan a révélées, et
surtout ce qui n'est pas fait.
---
## 1. Ce qui existe maintenant
| Fichier | Rôle |
|---|---|
| `src/world/Habitat.hpp/.cpp` | la mémoire locale du milieu : deux compteurs par cellule, montée, décroissance, oubli, seuils |
| `src/world/Wildlife.hpp/.cpp` | la faune : semis par tirage-rejet, deux états, fuite, disparition, retour |
| `src/world/AnimalMesh.hpp/.cpp` | le cervidé bas-poly, généré en code comme l'arbre et le galet |
| `src/world/GroundCover.hpp` | l'interface par laquelle le semis d'herbe interroge l'état du sol |
| `src/world/Vegetation.cpp` | un facteur de densité en plus dans `gatherGrass` — la seule ligne changée d'un système existant |
| `src/main.cpp` | câblage : trois lignes dans la boucle, l'inscription de l'abattage, le dessin, le journal |
| `tests/logic_tests.cpp` | sections « Phase 17 » : **97 assertions** ajoutées (788 → **885**) |
| `tools/run_vulkan_check.ps1` | **scénario I** : la faune et la fréquentation sous Vulkan, sur la dalle mesurée |
Plus une option de jeu : **`--no-wildlife`**, qui coupe la faune et la mémoire du
milieu et rend le comportement d'avant la phase. C'est un TÉMOIN, au même titre
que `--no-vegetation`, et il a servi dès cette session (§5.3).
**Rien n'a changé de comportement** dans `Forest`, `Ground`, `Needs`, `Camera`,
`Bike`, `Climber`, `Paraglider` ni dans l'éditeur. `Forest` en particulier
n'a **pas** été touché : c'est `main.cpp` qui inscrit l'abattage dans le milieu,
après un `fell()` réussi. L'abattage est une mécanique de la Phase 5 ; l'empreinte
qu'il laisse est une lecture de la Phase 17, et les deux n'ont pas à se connaître.
---
## 2. Le modèle
### 2.1 Deux mémoires, et c'est le point de départ
| | fréquentation | déforestation |
|---|---|---|
| ce qui la fait monter | la présence du joueur, pondérée par le bruit de son activité | un arbre abattu |
| vitesse de montée | saturée en 60 s de marche sur place | 3 arbres dans une cellule |
| vitesse de descente | 4 min | 15 min |
| ce qu'elle empêche | la faune reste / revient | la faune revient, ET le sol garde son couvert |
Les fusionner aurait été une erreur de modèle : un dérangement CESSE quand on
s'en va, un prélèvement NON. C'est la différence entre « il y a quelqu'un » et
« il manque un arbre ».
Une cellule fait **32 m**, et la grille est **creuse** : seules les cellules
touchées existent, et une cellule revenue à neuf est oubliée. Sur 25 km² il y
aurait 24 000 cellules ; une partie en touche quelques dizaines. C'est le même
raisonnement que le semis à la demande de `Vegetation`.
### 2.2 Le bruit n'est pas l'effort
`activityNoise` (Habitat) est le pendant de `activityEffort` (Needs), et les deux
échelles **ne coïncident pas** :
```
effort (Ph.16) bruit (Ph.17)
repos 0,0 0,25
marche 1,0 1,00
vélo 1,8 2,00
escalade 4,0 0,60
parapente 0,3 0,15
```
L'escalade est le cas qui le prouve : c'est l'effort **maximal** du joueur et
l'une des activités qui dérange le **moins**. Le repos n'est pas à zéro — un
homme immobile est quand même là.
### 2.3 La pondération, et pourquoi elle est en carré
La présence dérange sur un rayon de **120 m**, avec un poids
`1 - (d/r)²` où `d` est la distance au point le plus proche de la cellule (pas à
son centre : la cellule où l'on se tient doit être pleinement dérangée quel que
soit l'endroit où l'on y est tombé).
Une pondération **linéaire** ne marchait pas, et pas pour des raisons
esthétiques : à la périphérie du rayon elle tombe en dessous du taux de
décroissance, donc une cellule éloignée ne peut JAMAIS monter, quel que soit le
temps passé. La deuxième mécanique demandée par le cahier des charges — « rester
trop longtemps dans un rayon donné » — n'aurait tout simplement pas existé.
Corollaire assumé : au **bord** du rayon la pondération tend vers zéro, donc les
cellules situées juste en deçà de 120 m restent presque intactes et acceptent
encore une apparition de temps en temps. Un résidu d'un ou deux animaux à la
limite est le comportement **correct** du modèle.
### 2.4 Le défaut qui rendait tout muet : l'époque de l'oubli
Premier run : **rien ne montait**. `trackedCellCount` valait zéro après une
minute de présence.
La cause : au premier pas de temps une cellule ne contient que 0,0003 — donc
moins que l'epsilon d'oubli (1e-3) — et `update` l'effaçait à l'image même où
`notePresence` venait de la créer. La mécanique entière était annulée, en
silence, sans le moindre message.
Corrigé sur deux points : une cellule **occupée** n'est jamais oubliée, et elle
ne décroît pas non plus tant que le joueur y est (sans quoi montée et
décroissance se retranchent, et une présence faible mais continue — le campement
à distance — reste indéfiniment à zéro).
---
## 3. La faune
24 animaux au plus, semés par **tirage-rejet** autour du joueur, dans un anneau
de **55 à 260 m**. Un candidat est refusé s'il est hors emprise, sur une pente
> 0,9, sur un couvert LiDAR < 0,25, à moins de 14 m d'un autre animal, ou dans
une cellule que le milieu refuse. Le nombre réellement présent est donc une
**conséquence** du terrain et de l'état du milieu, jamais une consigne.
Deux états, deux déclencheurs de fuite :
* le joueur passe à moins de **30 m** → départ immédiat ;
* le milieu a retenu une présence prolongée (`wildlifeFlees`) → départ, **même
si le joueur ne s'est jamais approché**. C'est le déclencheur qui compte : un
camp finit par vider son vallon.
La fuite est une ligne droite à **8 m/s**, opposée au joueur, par pointes de 5 s
renouvelées tant que l'animal n'est pas tranquille. Poursuivre ne mène nulle
part, et c'est le propos.
### Ce que la faune n'a pas
* **Aucune IA** : pas de trajet, pas d'évitement d'obstacle, pas de troupeau.
* **Aucune collision** : un animal traverse les troncs, et le joueur le traverse.
Le `CollisionSolver` de la Phase 6 est là, l'y brancher serait mécanique — ce
n'est pas fait.
* **Aucune persistance** : ce ne sont pas des individus qu'on suit, c'est une
population locale.
* **Une seule espèce**, un seul mesh. La Phase 17 construit la BOUCLE, pas un
bestiaire.
---
## 4. La dégradation par surexploitation
Trois arbres abattus dans la même cellule (32 m) la saturent. Deux conséquences,
toutes deux **observables en jouant**, aucune annoncée :
1. **La faune n'y revient plus** tant que le compteur est au-dessus de 0,40 —
soit une bonne dizaine de minutes après deux arbres.
2. **Le sol se dénude** : la densité d'herbe de `Vegetation::gatherGrass` est
multipliée par le couvert rendu par l'`Habitat`, qui tombe jusqu'à 0,15 au
pire. Mesuré par les tests : au pied d'une coupe saturée, **plus de la moitié
de l'herbe disparaît**, et elle revient intégralement après vingt minutes.
### Pourquoi l'herbe et pas le shader terrain
Le cahier des charges proposait « le sol devient plus nu dans le shader terrain
existant ». Ce n'est **pas** la voie retenue, et c'est un arbitrage à connaître :
* rendre la dégradation visible dans `terrain.frag` demande de porter les
compteurs jusqu'au GPU — un binding de plus, une texture à téléverser et à
ré-uploader quand elle change, donc un chantier de synchronisation Vulkan à
part entière (et la leçon de la Phase 12 s'applique : les couches standard ne
voient PAS les dépendances mémoire) ;
* faire disparaître l'herbe donne le **même signal visuel** — un sol pelé au
milieu d'un versant herbeux — pour zéro objet Vulkan nouveau, donc zéro risque
de validation, et en réutilisant un système déjà mesuré.
Contrepartie honnête : **là où il n'y a pas d'herbe, la dégradation ne se voit
pas.** Sur du lapiaz ou au-dessus de 2250 m, une coupe ne laisse aucune trace
visuelle — seulement l'absence de faune. Le passage par le shader reste la bonne
réponse à terme.
Autre choix assumé : **les arbres de décor ne disparaissent pas**. Ce sont les
arbres ABATTABLES de `Forest` qui tombent, un par un, visiblement. Faire
s'évaporer la futaie de `Vegetation` aurait effacé la coupe au lieu de la montrer.
---
## 5. Deux réglages faux que seule la mesure a révélés
Ils méritent d'être écrits parce que dans les deux cas le code était juste, les
tests headless verts, et le résultat en jeu **nul**.
### 5.1 Deux rayons réglés séparément qui ne se recouvraient pas
`noiseRadius` valait 45 m (« un peu plus d'une cellule ») et `spawnRadiusMin`
valait 90 m (« ne jamais apparaître dans le champ proche »). Chacun défendable
seul. Ensemble : **aucun animal ne se trouvait jamais dans le rayon dérangé.**
Run du scénario I : 24 animaux au départ, 24 après deux minutes de présence
continue, fréquentation locale à 100 %, **zéro fuite**. Le système marchait
exactement comme écrit, et ne produisait rien.
Corrigé : `noiseRadius` = 120 m, et la condition est nommée dans l'en-tête —
**il faut que `noiseRadius` dépasse `spawnRadiusMin`**, sans quoi la deuxième
mécanique de la phase n'existe pas.
### 5.2 Le seuil d'apparition, et une faune qu'on ne voyait jamais
Même mesure, seconde lecture : à 90 m, un cervidé de 1,3 m est un point. La
faune existait sans qu'on puisse la regarder. `spawnRadiusMin` est descendu à
**55 m** — au-dessus de la distance de fuite (30 m), donc rien n'apparaît sous
le nez du joueur, et franchement en deçà du rayon dérangé.
Après correction, même scénario : **4 animaux à portée de vue au départ, 1 après
quatre minutes de présence**, deux en fuite au pic.
### 5.3 Un scénario voisin qui n'avait aucune marge (scénario F, escalade)
Troisième surprise, et elle ne vient pas du code de la phase : **le scénario
d'escalade a commencé à échouer**, alors que rien de ce qu'il exerce n'a été
touché.
Diagnostic, avec témoin : la faune coûte **6 % d'images par seconde**
(301 contre 320 FPS, mesuré sur la paroi du scénario F grâce à l'option
`--no-wildlife` ajoutée exprès). C'est peu — et c'était assez. La trajectoire du
grimpeur dépend du pas de temps : à chaque image sa commande est projetée sur la
ligne de plus grande pente **locale**, donc deux cadences d'images ne suivent pas
exactement le même chemin sur la paroi. Le scénario laissait 18 s de marge sur
une montée de 57 s ; le grimpeur montait toujours aussi haut (41,5 m contre
41,4 m au témoin) mais n'annonçait plus le sommet avant l'échéance.
Corrigé côté **harnais**, pas côté jeu : l'échéance passe de 75 s à 140 s. Le
harnais sort de la boucle dès que le sommet est annoncé, donc cette marge ne
coûte rien quand tout va bien. Vérifié : sommet atteint, faune active.
`--no-wildlife` reste dans le jeu — il coupe la faune ET la mémoire du milieu,
et rend le comportement d'avant la phase. Même rôle que `--no-vegetation` : sans
témoin, on ne peut attribuer un écart à rien.
### 5.4 La leçon générale
C'est la même que celle de la Phase 14 (« savoir où il y a de la pente ne dit pas
par où l'aborder ») sous un autre jour : **deux constantes réglées chacune pour
de bonnes raisons, dans deux fichiers différents, peuvent se rater complètement,
et aucun test unitaire ne le dira** — chacune est correcte. Il faut une mesure de
bout en bout, et une métrique qui porte sur ce que le joueur VOIT (les animaux à
portée de vue) et non sur ce qui est facile à compter (la population totale).
---
## 6. Aucune notification, et ce que ça coûte
Rien n'apparaît à l'écran : ni pop-up, ni compteur, ni ligne de titre. Le titre
de la fenêtre porte toujours l'inventaire, les jauges et l'heure — rien de plus.
Le journal, lui, émet une ligne par seconde (population, fuites, animaux à portée
de vue, fréquentation et déforestation locales, couvert au sol, cellules
mémorisées, pointes). **C'est un instrument de mesure, pas une interface** :
c'est la seule trace dépouillable par le harnais Vulkan, exactement comme la
ligne de besoins de la Phase 16.
Conséquence assumée : **un joueur peut très bien ne rien remarquer.** Le système
est observable, il n'est pas évident. C'est le prix de « pas de message
moralisateur », et c'est le bon prix — mais il faudra un jour vérifier sur
quelqu'un d'autre que soi que la boucle se lit.
---
## 7. Vérifications
* **Tests headless** : `tools\run_logic_tests.bat` — **885 assertions**
(788 avant), dont 97 pour cette phase : les deux mémoires et leur asymétrie,
l'oubli des cellules, les seuils et leur hystérésis, la robustesse du pas de
temps, la convention du mesh d'animal et sa matrice d'instance, le semis et
ses quatre filtres, le déterminisme, les deux déclencheurs de fuite, la
disparition au loin, le refus de repeuplement d'une zone surfréquentée **et
son retour**, et la chaîne complète coupe → sol nu → repousse.
* **Non-régression littérale** : un `Habitat` vierge branché sur la `Vegetation`
rend **exactement le même nombre de touffes** qu'avant la Phase 17. Ce n'est
pas « presque pareil » — c'est le contrat total de `GroundCoverSource`, et
c'est une assertion.
* **Vulkan** : `tools\run_vulkan_check.ps1`, **scénario I** ajouté (neuf
scénarios, onze processus). Zéro `[Validation]`, zéro `[ERROR]`, codes de
sortie tous nuls, fermeture propre partout.
### Un échec ANTÉRIEUR à cette phase, non corrigé (scénario E, vélo)
Le scénario du vélo échoue sur sa dernière étape : le « pied à terre » (touche B
finale) n'est pas enregistré — aucune ligne de journal n'est émise, donc le front
descendant de la touche n'a pas été vu. **Ce n'est pas dû à la Phase 17** :
rejoué deux fois avec `--no-wildlife`, c'est-à-dire dans le comportement exact
d'avant la phase, il échoue de la même façon. La sonde montre par ailleurs que
le vélo dévale encore à 31 km/h à ce moment-là, alors que le scénario vient de
freiner 5 s — la descente scriptée ne se termine plus là où elle a été réglée.
C'est donc une dérive du scénario E (ou du pilotage par messages postés), pas du
gameplay ; tout le reste du vélo est vert, y compris la télémétrie de pente, de
vitesse et de dénivelé. **Non corrigé** : hors du périmètre de cette session, et
le corriger à l'aveugle aurait été plus risqué que de le signaler.
**Conséquence à connaître : la suite complète ne peut pas être verte tant que ce
point n'est pas repris.** Tout le reste l'est.
### Un aléa d'automatisation, pas un blocage
Un run complet a aussi vu le processus G2 ne pas sortir dans les 20 s après
`WM_CLOSE`. Vérifié : le scénario G rejoué **trois fois de suite en isolation
passe trois fois**, faune active. C'est exactement la flakiness déjà décrite dans
MEMORY.md (« WM_CLOSE lent à être traité »), pas un blocage à la fermeture — rien
dans cette phase ne touche à l'arrêt : ni fil d'exécution, ni ressource GPU, ni
synchronisation.
---
## 8. Ce qui n'est pas fait
* **Le couvert LiDAR réel n'est pas exercé sous Vulkan.** La dalle de référence
du harnais (`LHD_0907_6440_1m.vchm`) n'a pas de carte de canopée produite, donc
le scénario I place la faune avec le couvert de substitut. Le filtre par
couvert réel est couvert par les tests headless (carte synthétique) et par la
zone de 25 km², qui a bien ses cartes — mais aucun scénario automatisé ne
charge celle-ci.
* **Pas de collision** entre le joueur et les animaux, dans aucun sens.
* **Pas de dégradation par piétinement** : seul l'abattage dénude le sol. La
fréquentation, elle, n'use pas les sentiers. C'était dans l'esprit du cahier
des charges (« usure des sols ») et ce n'est pas fait.
* **Pas de sauvegarde** : la mémoire du milieu meurt avec le processus. Une
partie relancée retrouve un monde intact.
* **Une seule espèce, un seul mesh, aucun cycle jour/nuit** dans le comportement,
alors que `GameClock` existe depuis la Phase 16 — une faune crépusculaire
serait le prolongement naturel.
* **Rien ne relie encore la faune aux besoins** : on ne chasse pas, on ne mange
pas ce qu'on voit fuir.
+376
Voir le fichier
@@ -0,0 +1,376 @@
# NOTES-PHASE18.md — Un vrai tapis d'herbe, et où passe vraiment le temps d'une tuile
Session du 2026-08-25, à la suite de la Phase 17. Deux chantiers indépendants :
1. **l'herbe** — la Phase 11 laissait un semis de touffes opaques ; il fallait un
tapis et des brins découpés ;
2. **la construction du maillage CPU d'une tuile** — la Phase 12 l'avait
désignée comme le goulot suivant, sans jamais la mesurer poste par poste.
Toutes les mesures : Intel UHD 770, build **Debug avec couches de validation**,
1280x720, `tools\measure_terrain.ps1`, caméra **verrouillée** (`--lock-input`),
position et orientation fixées par `--start` / `--look`. **Zéro message
`[Validation]` sur la totalité des mesures de ce document.**
---
## 0. Les deux vues de référence, et pourquoi il en fallait une seconde
La Phase 11 mesurait l'herbe sur la vue **E 901500 N 6436600, yaw 100, pitch -7**
(271 FPS / 332 Mo). Cette vue a été reprise telle quelle pour la non-régression —
et le premier relevé de la session l'a reproduite **exactement** : 271 FPS,
332,4 Mo.
Mais cette vue ne contient que **124 touffes**. Elle ne peut donc rien dire d'une
amélioration de l'herbe : n'importe quel changement du semis s'y perd dans le
bruit. Cinq positions ont été sondées pour trouver un **alpage réellement
herbeux** ; la retenue est **E 900500 N 6439000, yaw 100, pitch -7** (8 867
touffes avant la phase). Les deux vues sont mesurées à chaque étape : l'une dit
si quelque chose a régressé, l'autre dit si quelque chose a changé.
> C'est la même leçon que « savoir où il y a de la pente ne dit pas par où
> l'aborder » (Phase vélo) : une vue de référence n'est valable que pour ce
> qu'elle contient réellement.
---
## 1. TÂCHE 1 — l'herbe
### 1.1 Ce que la Phase 11 laissait, précisément
Trois quads croisés, **opaques**, effilés en pointe, semés à ~2 touffes/m². Vue
de près, une touffe est un éventail de rubans verts ; vue de loin, le sol reste
majoritairement nu entre les touffes. La capture `build\p18_avant_rasant.png` le
montre sans discussion : des cônes de papier posés sur un sol gris.
### 1.2 Ce qui a été changé — et ce qui ne l'a PAS été
| Fichier | Changement |
|---|---|
| `shaders/foliage.frag` | **masque de brins calculé**, `discard` — la découpe alpha |
| `shaders/foliage.vert` | transmet UV, aléa d'instance et **force de découpe** (qui décroît avec la distance) |
| `src/world/GrassMesh.cpp` | le quad devient une **planche** large et peu effilée : 0,26 → 0,42 au pied, 0,06 → 0,30 à la pointe |
| `src/world/Vegetation.hpp` | `grassSlots` 24 → **56** ; nouveau `grassCutout` |
| `src/world/Vegetation.cpp` | hauteur du sol échantillonnée **par cellule** et non plus par touffe |
| `src/main.cpp` | câblage de `params.w`, option **`--no-grass-cutout`** |
**Rien d'autre n'a bougé.** En particulier :
- **aucun pipeline, aucun descriptor, aucun binding** n'a été ajouté ou modifié.
La découpe passe par `params.w`, qui était **réservé** dans le bloc de push
constants depuis la Phase 11 (voir `renderer/DrawItem.hpp`). Un arbre y pousse
0 et traverse le même pipeline, inchangé ;
- **aucun seuil de répartition** n'a été touché : ni `grassClusterThreshold`, ni
`grassMaxSlope`, ni les altitudes, ni `grassUnderCanopy`. La carte de
répartition établie en Phase 11 — celle qui garde les lapiaz nus et suit la
donnée LiDAR — est **littéralement** la même. Seul son remplissage change.
### 1.3 Pourquoi un masque calculé et non une texture
Une planche de brins en RGBA aurait demandé un second échantillonneur, donc un
binding de descriptor sur ce pipeline seulement, un asset à produire et à
charger — et surtout son filtrage mipmap aurait **fait fondre** les brins fins en
une bouillie grise à quelques mètres. Le masque analytique n'a aucun de ces
coûts, tient en quinze lignes, et sa finesse ne dépend d'aucune résolution.
Le masque découpe **4 brins par quad**, soit **12 brins par touffe** pour les
mêmes 6 triangles. Chaque brin a sa propre hauteur de pointe, sa propre largeur
décroissante et son propre écartement, tirés d'un haché de son indice et de
l'aléa de l'instance : deux touffes voisines n'ont donc pas le même découpage.
### 1.4 Pourquoi `discard` et non du mélange alpha
Le mélange alpha imposerait de **trier les touffes en profondeur à chaque
image** — vingt mille objets, depuis une caméra qui bouge — et une seconde passe
de rendu. Le test alpha laisse le tampon de profondeur faire son travail :
l'ordre de dessin reste sans importance, exactement comme avant. C'est ce qui
rend cette amélioration presque gratuite (§1.6).
Sa contrepartie est un bord **franc**, sans demi-teinte, et il n'y a pas de MSAA
dans ce moteur (`rasterizationSamples = 1`) pour l'absorber. D'où le troisième
mécanisme : **la découpe s'efface avec la distance**. Les brins s'élargissent
jusqu'à refermer le quad entre 7 m et 17 m. De près on voit des brins, de loin
une silhouette pleine, et la transition est continue. Sans cela, l'herbe
lointaine scintillerait à chaque déplacement de la caméra.
### 1.5 La densité : agir sur le remplissage, pas sur les frontières
La Phase 11 concluait « il faudrait 8 à 10 touffes/m² là où il y en a 2 ».
Deux chemins menaient à plus de touffes :
- **baisser les seuils de sélection** (bruit de groupement, pente, canopée) —
cela aurait mis de l'herbe **là où il n'y en a pas** : sur le rocher, sous la
futaie dense, sur les versants que la donnée LiDAR déclare nus ;
- **augmenter le nombre d'emplacements par cellule** — cela densifie **là où
l'herbe pousse déjà**, sans déplacer une seule frontière.
Le reproche de la Phase 11 n'était pas que l'herbe manquait d'emprise, mais
qu'elle formait un semis clairsemé **là où elle pousse**. C'est donc
`grassSlots` qui passe de 24 à **56**. Le compte retenu vaut `densité × slots` :
sur l'alpage mesuré, cela fait passer la vue de **8 867 à 20 098 touffes**
(×2,27), soit environ 5 touffes/m² au lieu de 2.
> Repère honnête vis-à-vis de la consigne : la Phase 11 citait 2 158 touffes et
> suggérait « 4 à 5 fois plus ». Ce chiffre de 2 158 date d'avant les réglages
> des phases suivantes ; **la même vue de prairie en rendait déjà 8 867 au début
> de cette session**. Le facteur 2,27 obtenu ici s'ajoute donc à un gain déjà
> acquis : par rapport au repère écrit de la Phase 11, on est à **×9**. Multiplier
> encore par deux était possible et a été écarté — au-delà, le coût par image
> (§1.6) n'est plus payé par une différence visible.
### 1.6 Coût mesuré — et une surprise
Vue d'alpage, **E 900500 N 6439000, yaw 100, pitch -7**, même binaire, seules
les options changent :
| État | Touffes | FPS médian | Pic RAM |
|---|---:|---:|---:|
| Avant la Phase 18 | 8 867 | **137** | 338,5 Mo |
| Avant la Phase 18, `--no-grass` (témoin) | 0 | 304 | 337,6 Mo |
| Densité ×2,27 + découpe alpha | 20 098 | **95** | 340,2 Mo |
| Idem, `--no-grass-cutout` (témoin) | 20 098 | **95** | 340,1 Mo |
| + hauteur du sol par cellule (§1.7) | 20 098 | **118** | 340,1 Mo |
**La découpe alpha coûte zéro image par seconde.** 95 FPS avec, 95 FPS sans, sur
le même binaire et la même vue — c'est précisément ce que le témoin
`--no-grass-cutout` a été ajouté pour pouvoir affirmer. Le fragment shader
n'était pas le facteur limitant, et un `discard` précoce est moins cher que
l'éclairage Blinn-Phong qu'il évite.
**Tout le coût vient du nombre d'instances**, et il est majoritairement **CPU** :
c'est ce que prouve le §1.7, où une optimisation qui ne change pas un pixel rend
23 FPS.
### 1.7 L'optimisation qui a rendu la densité payable
`gatherGrass` appelait `terrain_.heightAt()` **une fois par touffe**. À 56
emplacements par cellule et un millier de cellules par image, ce poste grandit
exactement au rythme de la densité : c'est lui qui plafonnait le tapis.
Il échantillonne désormais les **quatre coins de la cellule**, puis interpole à
l'intérieur — et ce n'est **pas une approximation** quand la cellule d'herbe
coïncide avec une cellule du terrain (1 m et 1 m sur cette zone) : le découpage
en deux triangles le long de la diagonale h00-h11 de `Heightmap::heightAt` est
reproduit à l'identique, donc la touffe est posée au pixel près sur la surface
affichée. Un test headless le vérifie sur un versant à 35 % : écart maximal
**nul** à 10⁻³ près.
**95 → 118 FPS (+24 %), image strictement identique.**
C'est la suite directe d'une leçon de la Phase 11, qui avait déjà ramené ce
poste de deux appels à un par touffe. La même leçon, poussée un cran plus haut :
au niveau de la cellule.
### 1.8 Résultat visuel
| Capture | Vue |
|---|---|
| `build\p18_avant_rasant.png` / `build\p18_apres_rasant.png` | alpage, pitch -25 — avant / après |
| `build\p18_avant_prairie.png` / `build\p18_apres_prairie.png` | alpage, pitch -7 — avant / après |
| `build\p18_apres_proche.png` | pitch -45, brins visibles individuellement |
Ce qui se voit : le sol nu entre les touffes a disparu là où la donnée LiDAR
déclare de l'herbe, et une touffe se lit désormais comme une gerbe de brins et
non comme un éventail de rubans. Ce qui **ne** se voit pas et n'est pas censé se
voir : les zones que la carte de couvert déclare nues sont restées nues — la
partie gauche de la capture, en particulier, est aussi clairsemée qu'avant, et
c'est correct.
**Ce qui ne convainc toujours pas**, honnêtement : à moins d'un mètre, le sol
reste visible entre les touffes (5 touffes/m² de 30 cm ne ferment pas une
pelouse), et le sol lui-même reste l'orthophoto grise — un tapis totalement
crédible demanderait aussi de teinter le terrain sous l'herbe. Ce n'est pas fait.
---
## 2. TÂCHE 2 — la construction du maillage CPU d'une tuile
### 2.1 Mesurer d'abord : l'instrumentation
La Phase 12 concluait que le maillage CPU était devenu le goulot, mais sans
jamais le décomposer. `TerrainStreamer::buildProfile()` chronomètre donc
maintenant **trois postes séparés**, en microsecondes cumulées, journalisés à la
fermeture :
- **géométrie** — `terrainNodeMeshData` : échantillonnage de la heightmap,
normales, cibles de morphing ;
- **indices** — la topologie de la tuile ;
- **téléversement** — `Renderer::addMesh`, le chemin GPU traité en Phase 12.
Scénario : `--flythrough=900 --no-grass` sur la zone de 25 km², 45 s, caméra
scriptée — le survol à haute vitesse de la Phase 12, celui qui sature le
streaming. `--no-grass` pour que l'herbe de la Tâche 1 ne pollue pas la mesure.
### 2.2 Ce que le profilage a dit — et ce à quoi personne ne s'attendait
Premier relevé, avant toute optimisation, ~5 590 tuiles construites :
| Poste | µs/tuile | Part |
|---|---:|---:|
| Géométrie | 1 858 | 66 % |
| **Indices** | **636** | **23 %** |
| Téléversement GPU | 307 | 11 % |
**23 % du coût d'une tuile partait dans la reconstruction de sa topologie** —
24 576 indices, **identiques pour toutes les tuiles de tous les niveaux**.
L'en-tête de `TerrainNodeMesh.hpp` l'écrivait noir sur blanc depuis la Phase 10
(« calculés une fois et recopiés ») ; le code, lui, les reconstruisait à chaque
tuile. Personne n'aurait parié sur la boucle d'indices, et c'était le deuxième
poste, **deux fois plus cher que le téléversement GPU** qui avait mobilisé toute
la Phase 12.
C'est exactement la raison pour laquelle la consigne disait « mesure d'abord ».
### 2.3 Les deux optimisations retenues
Toutes deux sont **exactes** : le maillage produit est identique, seul le
travail dépensé change.
1. **La topologie est construite une fois** (`TerrainStreamer::indexTemplate_`)
puis recopiée dans le `MeshData`. `terrainNodeMeshData` reçoit un paramètre
`withIndices` pour laisser la topologie à l'appelant ; les autres appelants,
dont les tests headless, gardent le comportement complet par défaut.
2. **Les cibles de morphing sont regroupées.** Chaque sommet a besoin du point
que le nœud PARENT produirait au même endroit ; ce point ne dépend que des
indices locaux **arrondis à un multiple de deux**, donc les quatre sommets
d'un bloc 2×2 partagent exactement la même cible. Le code la recalculait pour
chacun des quatre — trois échantillonnages sur quatre jetés, chacun coûtant
cinq lectures de heightmap et une normalisation. Une grille grossière 33×33
est désormais calculée une fois par tuile.
Un test headless vérifie l'hypothèse plutôt que de la croire : les 4 sommets
de chaque bloc 2×2 visent bien la même cible.
Un **témoin**, `--no-tile-cache`, remet les deux dans l'état d'avant la phase.
Toutes les comparaisons ci-dessous sont donc faites **sur le même binaire et la
même trajectoire** — la seule comparaison qui ait du sens.
### 2.4 Avant / après, survol à 900 m/s, deux passages chacun
| | `--no-tile-cache` (témoin) | défaut | écart |
|---|---:|---:|---:|
| Géométrie | 1 723 / 1 730 µs | 1 248 / 1 245 µs | **−28 %** |
| Indices | 629 / 631 µs | 7,5 / 7,4 µs | **−99 %** |
| Téléversement | 254 / 249 µs | 262 / 254 µs | inchangé |
| **Total par tuile** | **~2 609 µs** | **~1 512 µs** | **−42 %** |
| Frames en 45 s | 9 471 / 9 426 | 11 435 / 11 320 | **+20 %** |
| Frames à trou | **0** | **0** | — |
Les deux passages de chaque colonne sont à moins de 0,5 % l'un de l'autre : ce
chronométrage cumulé est **beaucoup plus stable** que le FPS lu dans le titre de
la fenêtre (≈15 % d'écart entre deux runs identiques, cf. MEMORY.md). C'est un
sous-produit utile de la tâche : le projet dispose maintenant d'une mesure de
performance reproductible.
Le téléversement GPU, lui, ne bouge pas — et c'est le résultat attendu : la
Phase 12 l'avait déjà traité, et il ne représente plus que **17 %** du coût
d'une tuile après cette phase.
### 2.5 Ce qui n'a PAS été fait, et pourquoi
- **Parallélisation multi-thread de la génération de tuiles.** C'est le gain
suivant en importance — la géométrie reste 83 % du coût — mais
`Renderer::addMesh` n'est pas conçu pour être appelé depuis plusieurs threads,
et la Phase 12 a déjà montré ce que coûte une erreur sur ce chemin. Le travail
se découpe pourtant proprement : `terrainNodeMeshData` est **pur** (il ne lit
que la heightmap, en lecture seule) et pourrait être lancé sur un pool, le
`addMesh` restant sur le thread de rendu. Non fait ici : la consigne demandait
explicitement de s'arrêter à un profilage clair plutôt que de forcer une
optimisation risquée, et ce chantier ne tenait pas dans la session.
- **Partager UN buffer d'indices GPU** entre toutes les tuiles. Les 7,5 µs
restants sont la recopie ; la supprimer économiserait surtout **96 Ko par
tuile résidente**, soit ~48 Mo sur 512 tuiles. Cela demande de dissocier
sommets et indices dans `Renderer::addMesh` : c'est un chantier de renderer,
pas de streaming.
- **Réduire le coût de `sampleGrid`** (5 lectures + une `normalize` par
échantillon). Piste réelle, mais qui touche la forme des normales : à ne
tenter qu'avec une comparaison d'images.
---
## 3. Résumé des chiffres
### Vue de référence de la Phase 11 — E 901500 N 6436600, yaw 100, pitch -7
| État | FPS médian | Pic RAM |
|---|---:|---:|
| Repère Phase 11 (reproduit au début de la session) | 271 | 332,4 Mo |
| **Après la Phase 18** | **293** | **332,7 Mo** |
Cette vue ne contient que 124 touffes : elle ne mesure pas l'herbe, elle mesure
la **non-régression** — et le gain de 22 FPS vient de la Tâche 2.
### Vue d'alpage — E 900500 N 6439000, yaw 100, pitch -7
| État | Touffes | FPS médian | Pic RAM |
|---|---:|---:|---:|
| Avant la Phase 18 | 8 867 | 137 | 338,5 Mo |
| **Après la Phase 18** | **20 098** | **122** | **340,2 Mo** |
**2,27× plus de touffes, des brins découpés, pour 11 % de FPS et 1,7 Mo.**
### Construction d'une tuile (survol 900 m/s)
**2 609 → 1 512 µs par tuile (−42 %)**, +20 % de frames sur la même trajectoire,
0 frame à trou avant comme après.
---
## 4. Vérification
- **Tests headless : 896 assertions** (885 avant la phase, **+11**), toutes
passent. Nouvelles sections : « Phase 18 : herbe plus dense et brins
découpés » (quad devenu planche, densité effectivement plus que doublée,
`grassCutout` sans effet sur le semis, pied des touffes posé au sol malgré
l'interpolation par cellule) et, dans la section tuile, l'invariant du bloc
2×2 et l'équivalence `withIndices` vrai/faux.
- **Zéro message `[Validation]`** sur la totalité des mesures et des scénarios.
- **Harnais `run_vulkan_check.ps1`** (11 processus, scénarios A à I), joué deux
fois en entier — une fois après la Tâche 1, une fois sur le binaire final :
**0 `[Validation]`, 0 `[ERROR]`, fermeture propre partout, code de sortie 0
pour chacun des onze processus**, gameplay effectivement exercé (2 arbres
abattus, 9 objets ramassés, percussion, vol de parapente complet, escalade
jusqu'au sommet, éditeur : 3 objets posés/sauvés/rechargés, boisson au point
d'eau, faune qui fuit).
### Le point rouge du harnais, honnêtement
Le harnais sort tout de même en `[ECHEC]`, sur **un seul critère** :
**scénario E (vélo), « pied à terre » final**. C'est un échec **déjà documenté
avant cette phase** (MEMORY.md, bilan de la Phase 17 : « rejoué deux fois avec
`--no-wildlife`, il échoue pareil », laissé non corrigé pour cause de
périmètre). La Phase 18 ne l'a ni causé ni aggravé.
Un second critère a été rouge **au premier passage seulement** : scénario I
(faune), « animaux à portée de vue », 4 → 2 pour un seuil à 1. Rejoué isolément
il donne 4 → 0, et le passage final donne 4 → 1 : les deux passent. Ce critère
compte des relevés pendant 240 s, donc dépend du FPS — c'est un critère
**bruité**, pas une régression.
Ces deux critères sont sensibles au débit d'images, et l'herbe plus dense en
coûte. Le harnais gagnerait à les rendre insensibles au FPS plutôt qu'à compter
des frames. Ce n'est pas fait dans cette phase.
---
## 5. Options de jeu ajoutées
| Option | Effet |
|---|---|
| `--no-grass-cutout` | rend les quads d'herbe **opaques** (état Phase 11), densité inchangée |
| `--no-tile-cache` | reconstruit topologie et cibles de morphing à chaque tuile (état pré-Phase 18) |
Ce sont des **témoins de mesure**, au même titre que `--no-vegetation`,
`--no-grass` et `--no-wildlife` : ils permettent d'attribuer un écart à ce qui a
été ajouté, sur le même binaire.
---
## 6. Prochaines étapes suggérées
1. **Paralléliser `terrainNodeMeshData`** sur un pool de threads (§2.5) : c'est
désormais 83 % du coût d'une tuile, et la fonction est déjà pure.
2. **Teinter le terrain sous l'herbe** : le tapis est convaincant en volume,
mais le sol reste l'orthophoto grise entre les touffes (§1.8).
3. **Buffer d'indices GPU partagé** : ~48 Mo de mémoire GPU récupérables.
4. **Rendre les scénarios E et I du harnais insensibles au FPS** (§4).
+447
Voir le fichier
@@ -0,0 +1,447 @@
# NOTES-PHASE19.md — Le profil de la Phase 18 était un profil de Debug
Session du 2026-08-26, à la suite de la Phase 18. Deux tâches étaient au
programme :
1. rendre `Renderer::addMesh` thread-safe pour paralléliser la construction de
mesh de tuile — la piste que la Phase 18 avait désignée comme le gain
suivant (83 % du coût restant) ;
2. profiler les autres postes du frame (terrain, végétation, faune) pour
trouver des gains sûrs.
**Le résultat principal de la phase n'est aucun des deux, et il les annule tous
les deux** : la mesure qui fondait la Tâche 1 avait été relevée en **Debug**, et
elle ne tient pas en **Release**. En Release, le maillage d'une tuile n'est plus
le poste dominant, et le frame entier n'est pas limité par le CPU.
C'est la leçon de la Phase 18 (« un commentaire n'est pas une mesure »)
appliquée un cran plus haut : **un profil de Debug n'est pas un profil de
Release.**
Configurations et matériel : Intel UHD 770, 20 cœurs logiques, 1280x720,
caméra **verrouillée** (`--lock-input`), cadrage fixé par `--start` / `--look`
(sans `--look`, tout diff d'image est un artefact — cf. MEMORY.md). Sauf mention
explicite de « Release », les mesures sont en **Debug avec couches de
validation**, la seule configuration où le projet valide. **Zéro message
`[Validation]` sur la totalité des mesures de ce document.**
---
## 1. TÂCHE 1 — la parallélisation
### 1.1 Ce qui empêche réellement `Renderer::addMesh` d'être appelé depuis plusieurs threads
La question posée était précise, la réponse l'est aussi. `addMesh` touche
**quatre** ensembles d'état partagé, de dangerosité très inégale :
| # | État | Nature du problème |
|---|---|---|
| 1 | `meshes_`, `freeMeshSlots_`, `liveMeshCount_` | `meshes_.push_back` peut **réallouer** le vecteur pendant que `recordCommandBuffer` l'indexe depuis le thread de rendu. Course franche, sur un pointeur. |
| 2 | `pendingCopies_`, `stagingBytesInFlight_` | `enqueueCopy` fait `push_back` + `+=` sans verrou ; vidés à chaque `recordCommandBuffer`. |
| 3 | `commandPool_` | `flushCopiesNow` y alloue un command buffer. Un `VkCommandPool` et **tous** ses command buffers exigent une synchronisation externe : allouer dedans pendant que le thread de rendu réinitialise et enregistre le sien est une violation directe de la spécification. |
| 4 | `graphicsQueue_` | `flushCopiesNow` fait `vkQueueSubmit` + `vkQueueWaitIdle`. Un `VkQueue` exige lui aussi une synchronisation externe ; en concurrence avec le `vkQueueSubmit` de `drawFrame`, c'est une corruption de driver, pas une erreur de validation. |
Les points 1 et 2 se règlent avec un mutex, moyennant un coût sur le chemin de
rendu (le point 1 impose de verrouiller aussi la **lecture** de `meshes_` à
chaque draw, ou de figer la capacité du vecteur).
**Ce sont les points 3 et 4 qui condamnent l'exercice**, et pour une raison qui
n'est pas la difficulté : `flushCopiesNow` n'est atteint que lorsque le staging
en vol dépasse **128 Mo** (`kMaxPendingStagingBytes`). Une tuile pèse ~385 Ko et
le budget est de 64 tuiles par frame, soit ~25 Mo : **ce chemin ne se déclenche
jamais pendant le streaming**. Il ne se déclenche que sur `--no-lod`, qui
téléverse la zone entière en un bloc — avant la première frame, donc sans
concurrence.
Autrement dit : la partie dangereuse du code serait **exactement celle qu'aucun
test de cette session n'aurait pu exercer**. Un verrou oublié là ne se
manifesterait ni dans le harnais, ni sous `VK_LAYER_VALIDATE_SYNC`, ni dans
aucune des mesures ci-dessous — mais un jour, chez l'utilisateur, sur une scène
plus grosse. C'est la définition même du bug de concurrence indétectable que la
consigne demandait d'éviter.
**`Renderer::addMesh` n'a donc pas été modifié. Aucun appel Vulkan ne change de
thread dans cette phase.**
### 1.2 Ce qui a été fait à la place, et pourquoi c'était le bon découpage
La Phase 18 avait déjà noté que `terrainNodeMeshData` est **pure**. Vérifié
ligne à ligne : elle ne lit que `Heightmap::at/spacing/worldCoord` et
`TerrainQuadtree::node` — tous `const`, sur des données immuables pour la durée
de la session — et écrit dans un `MeshData` qui lui appartient. Aucun `static`,
aucun `mutable`, aucun cache interne.
Le travail se découpe donc sans toucher au Renderer :
- **`TerrainStreamer::meshBatch`** maille tout le lot de la frame, en parallèle.
Aucun appel Vulkan. Chaque thread écrit dans des **éléments disjoints** de
vecteurs déjà dimensionnés : ni verrou, ni file, ni compteur partagé — donc
aucun état sur lequel une course serait possible ;
- **`TerrainStreamer::uploadNode`** pose la topologie et appelle `addMesh`, sur
le thread de rendu, en séquence, dans le même ordre qu'avant.
Trois précautions, chacune pour une raison précise :
- une exception ne traverse **jamais** la frontière d'un `std::thread` (elle
appellerait `std::terminate`) : elle est capturée et rendue comme une donnée
dans `batchErrors_[k]` ;
- rien n'est **journalisé** depuis un thread : les fonctions de journalisation
ne sont pas prévues pour ça. C'est l'appelant qui journalise, après jonction ;
- le chronomètre par tuile dépose sa durée dans un élément propre puis est sommé
après jonction. Une course sur un compteur de **mesure** serait la pire de
toutes : elle fausserait le chiffre censé prouver que le changement est bon.
Découpage **statique** en tranches contiguës, et non file de travail : une tuile
coûte toujours la même chose (65x65 sommets quel que soit son niveau), donc
l'équilibrage est naturel — et une file demanderait un verrou.
### 1.3 En Debug, le gain est réel
Survol scripté `--flythrough=900 --no-grass`, 45 s, **même binaire**, seule
l'option `--tile-threads` change (témoin de mesure, au même titre que
`--no-tile-cache`) :
| | `--tile-threads=1` (témoin) | 4 threads | écart |
|---|---:|---:|---:|
| Travail géométrie / tuile | 1278 / 1294 µs | 1542 / 1457 µs | **+16 %** |
| Temps de MUR du maillage | 7255 / 7341 ms | 3620 / 3322 ms | **−52 %** |
| Facteur de parallélisme | 1,00 | **2,42 / 2,49** | — |
| Images en 45 s | 11 046 / 11 253 | 13 320 / 12 081 | **+14 %** |
| Tuiles non couvertes | **0** | **0** | — |
Deux chiffres sont publiés, et il le faut : le **travail** par tuile ne doit
*pas* baisser — c'est la même fonction qui fait le même calcul — et il monte même
de 16 %, parce que quatre threads se disputent la bande passante mémoire en
parcourant une heightmap de 5001x5001. Ce qui doit baisser, c'est le temps que le
thread de rendu passe **bloqué** dessus. Publier un seul des deux laisserait
croire soit qu'il n'y a pas de gain, soit que le travail a diminué.
### 1.4 En Release, le gain disparaît — et c'est le résultat de la phase
Même survol, même méthode, **build Release** :
| | `--tile-threads=1` (témoin) | 4 threads |
|---|---:|---:|
| Travail géométrie / tuile | 141 / 139 µs | 154 / 146 µs |
| Temps de MUR du maillage | 819 / 811 ms | 1227 / 870 ms |
| Facteur de parallélisme | 1,00 | **0,73 / 0,97** |
| Images en 45 s | **32 206 / 32 327** | 29 776 / 32 104 |
**Le facteur est inférieur à 1 : paralléliser coûte plus que ça ne rapporte.**
La création des threads (~3 900 sur le survol, en rafales de 3) dépasse le
travail qu'elle répartit, parce qu'une tuile Release ne dure que 140 µs.
Une variante a été essayée avant de conclure — ne paralléliser qu'à partir de
**16 tuiles** par lot, pour ne viser que les grosses rafales. Résultat : 3 lots
parallélisés en 45 s, facteur 1,01, aucun effet mesurable. L'option devient
inerte, elle ne devient pas gagnante.
### 1.5 Pourquoi les deux mesures divergent : le coût d'une tuile, Debug vs Release
| Poste d'une tuile | Debug | Release |
|---|---:|---:|
| Géométrie | 1 344 µs (**79 %**) | 140 µs (**33 %**) |
| Indices | 16 µs (1 %) | 15 µs (4 %) |
| Téléversement GPU | 250 µs (15 %) | 262 µs (**63 %**) |
La géométrie est **9,6 fois moins chère** une fois optimisée ; le téléversement,
lui, ne bouge pas (c'est du memcpy et du pilote, pas du code compilé par nous).
Le poste dominant d'une tuile en Release n'est donc **pas** la géométrie, c'est
le **téléversement** — celui-là même que la Phase 12 avait traité et que la
Phase 18 avait rangé au rang de résidu à 11 %.
La Phase 18 n'a rien mesuré de faux : ses chiffres sont exacts, en Debug. Elle en
a tiré une priorité qui ne vaut que là. Et comme toutes les mesures du projet
sont en Debug (c'est la seule configuration avec les couches de validation), rien
ne pouvait le signaler.
### 1.6 Décision : défaut séquentiel, chemin parallèle conservé
`Params::meshThreads` vaut **1** par défaut — le réglage que la mesure désigne
en Release. Le chemin parallèle reste disponible par `--tile-threads=N`, testé
et documenté, pour trois raisons :
1. il est un **gain net de 2,4x et +14 % d'images en Debug**, c'est-à-dire dans
la configuration où tournent toutes les campagnes de mesure et de validation
du projet — ça a une valeur d'outillage réelle ;
2. il redeviendra intéressant en Release le jour où une tuile coûtera plus cher
(format de sommet plus lourd, pas LiDAR plus fin) ;
3. il sert de **témoin** : sans lui, l'écart Debug/Release ci-dessus ne serait
pas reproductible sur le même binaire.
Un troisième argument, mesuré incidemment, va dans le même sens. Sur la vue de
référence en Debug, `--tile-threads=4` donne une médiane identique (312 contre
311 FPS) mais un **minimum de 89 FPS contre 126** : les créations de threads
introduisent des à-coups que la médiane cache. Le défaut séquentiel est aussi le
plus régulier.
### 1.7 Un coût mémoire introduit puis retiré
Première version : tout passait par le lot, donc jusqu'à 53 `MeshData`
simultanés (~287 Ko chacun, ~15 Mo). Mesuré : **pic mémoire du processus
+5,6 Mo** sur la vue de référence, 338,3 Mo contre 332,7 en Phase 18.
Le chemin séquentiel (le défaut) maille et téléverse donc **une tuile à la
fois**, sans jamais garder plus d'un `MeshData` en vie, et le lot est relâché
(`shrink_to_fit`) à la fin de la frame sur le chemin parallèle. Pic revenu à
**331,7 Mo**, soit 1 Mo sous la Phase 18.
C'est le genre de régression qu'on n'aurait pas vue en ne regardant que le FPS.
### 1.8 Comment la correction a été vérifiée
**La comparaison d'images ne peut pas trancher ici, et c'est une conclusion en
soi.** Deux captures du jeu diffèrent déjà entre deux exécutions **identiques** :
l'herbe et la faune s'animent avec le temps écoulé, et le temps écoulé dépend du
débit d'images — que la phase change justement. Mesuré :
| Comparaison | Octets différents |
|---|---:|
| Témoin : parallèle vs parallèle, mêmes options | 0,65 % / 4,40 % |
| Témoin : séquentiel vs séquentiel, sans faune | 1,54 % |
| Séquentiel vs parallèle | 0,16 % / 6,67 % |
Le plancher de bruit est du même ordre que le signal cherché. Sur la vue de
référence, l'écart séquentiel/parallèle (0,16 %) est même **plus petit** que
l'écart entre deux runs parallèles (0,65 %). Ce test ne prouve rien — ni dans un
sens ni dans l'autre.
Le contrôle qui tranche est **headless et déterministe** (nouveau dans
`tests\logic_tests.cpp`) : 40 tuiles de niveaux mélangés sont maillées en
séquence puis sur 4 threads, et les sommets sont comparés **par `memcmp`**, pas à
une tolérance près — une course ne produirait pas un petit écart numérique, elle
produirait un sommet pris à la mauvaise tuile. Le test comprend son propre
témoin (vérifier que les tuiles comparées sont bien distinctes entre elles, sans
quoi la comparaison passerait sans rien prouver) et **12 passages
supplémentaires**, parce qu'une course se manifeste rarement et qu'un passage
unique ne dit presque rien.
### 1.9 Validation de synchronisation, avec son contrôle négatif
`VK_LAYER_VALIDATE_SYNC=1` sur le survol, chemin parallèle **et** chemin
séquentiel : **0 message**.
Un journal propre ne prouve rien tant qu'on n'a pas montré que l'outil regarde au
bon endroit (MEMORY.md, leçon de la Phase 12). **Contrôle négatif** : la barrière
`TRANSFER_WRITE -> VERTEX_ATTRIBUTE_READ | INDEX_READ` de
`Renderer::recordPendingCopies` a été retirée, le projet rebuildé, et la couche a
immédiatement crié :
```
vkCmdDrawIndexed(): READ_AFTER_WRITE hazard detected. vkCmdDrawIndexed reads
index VkBuffer 0xaf00000000af, which was previously written by vkCmdCopyBuffer.
```
10 messages, plafond de déduplication atteint. La barrière a été remise et le
journal est redevenu vide. L'outil regarde bien le chemin de téléversement des
tuiles.
---
## 2. TÂCHE 2 — où passe vraiment le temps d'une image
### 2.1 L'instrumentation
`src/main.cpp` chronomètre désormais cinq postes CPU par image, journalisés à la
fermeture (`Cout par image`) : streaming terrain, `gatherTrees`, `gatherGrass`,
construction du tronc de vision, et `drawFrame`. Même démarche que
`buildProfile` en Phase 18, appliquée à l'image entière.
Le chronomètre est pris **sans condition** : un profilage qu'on active à la
demande finit par mesurer un binaire différent de celui qui tourne. Coût mesuré :
« tronc de vision » vaut 0,3 à 0,9 µs en Release, ce qui borne le coût des
bornes elles-mêmes.
### 2.2 Ce que le Debug faisait croire
Vue d'alpage, Debug :
| Poste | µs/image |
|---|---:|
| **`gatherTrees`** | **1 747** |
| `gatherGrass` | 4 944 |
| `drawFrame` | 1 373 |
| Streaming terrain | 97 |
| Tronc de vision | 5 |
`gatherTrees` coûtait 1 630 à 1 936 µs **dans les trois scénarios testés**, y
compris le survol à 120 m d'altitude où les arbres sont à peine visibles. Coût
strictement constant, indépendant de ce qui est à l'écran : la signature d'un
coût de **balayage**, pas d'un coût de contenu. Deux redondances par image
étaient identifiées dans le code et prêtes à être corrigées :
- 5 appels à `terrain_.heightAt()` par **bloc** de 8x8 cellules pour estimer ses
bornes verticales, à chaque image, alors que ces bornes ne changent jamais
(~720 appels par image) ;
- la purge du cache parcourt les **~1 800 cellules** du cache à chaque image
pour y chercher des cellules à oublier, alors que la caméra bouge de quelques
centimètres par image.
### 2.3 Ce que le Release dit, et qui annule tout ce qui précède
Mêmes vues, build Release :
| Poste | Alpage | Vue de référence |
|---|---:|---:|
| **`drawFrame`** | **3 537 µs (81 %)** | **1 424 µs (83 %)** |
| `gatherGrass` | 515 µs | 128 µs |
| `gatherTrees` | 254 µs | 153 µs |
| Streaming terrain | 22 µs | 15 µs |
| Tronc de vision | 0,9 µs | 0,6 µs |
`gatherTrees` passe de 1 747 à 254 µs. La somme des postes (4 328 µs) rend
compte de la quasi-totalité de l'image mesurée (4,39 ms), donc rien d'important
n'échappe au profil.
### 2.4 Le frame est limité par le GPU — vérifié par ablation, pas affirmé
`drawFrame` inclut l'attente de la barrière de la frame en vol. Pour distinguer
« le CPU travaille » de « le CPU attend », on retire du travail **GPU** et on
regarde si les postes CPU bougent. Alpage, Release, 20 s :
| | Images | `drawFrame` | Arbres CPU | Herbe CPU | Temps/image |
|---|---:|---:|---:|---:|---:|
| Tout | 4 561 | 3 537 µs | 254 | 515 | 4,39 ms |
| `--no-grass` | 7 184 | 2 537 µs | 185 | 0 | 2,78 ms |
| `--no-vegetation` | 10 631 | 1 830 µs | 0 | 0 | 1,88 ms |
Retirer l'herbe économise 515 µs de CPU mais fait tomber le temps d'image de
1 610 µs : **le gain vient du GPU, pas du CPU.** Le CPU passe 81 % de l'image à
attendre dans `drawFrame`.
**Conséquence directe : aucune optimisation CPU ne vaut la peine d'être faite
ici.** Supprimer entièrement `gatherTrees` et `gatherGrass` — 769 µs sur 4 390 —
ne rendrait rien, puisque ce temps est déjà pris sur une attente. Les deux
redondances du §2.2 sont **réelles** et restent notées pour le jour où le
rapport de forces changera (GPU plus rapide, ou résolution plus basse) ; les
corriger aujourd'hui serait optimiser un artefact du build de test.
Conformément à la consigne — « n'implémente que ce qui est mesuré comme un vrai
gain » — **rien n'a été optimisé dans la Tâche 2.** Ce qu'elle livre est le
profileur permanent et la mesure qui réoriente le travail futur.
### 2.5 Une redondance réelle mais négligeable, signalée et non corrigée
`renderer.projectionMatrix() * camera.viewMatrix()` puis
`Frustum::fromViewProjection` sont calculés **deux fois par image** — une fois
pour le streaming, une fois pour la végétation. C'est bien une redondance, et
elle est maintenant mesurée : **0,3 à 0,9 µs par image en Release**. La
supprimer n'est pas une optimisation, c'est du ménage ; elle n'a pas été faite
dans cette phase pour ne pas mélanger un changement non mesurable avec des
changements mesurés.
---
## 3. Résumé des chiffres
### Vue de référence Phase 11 — E 901500 N 6436600, yaw 100, pitch -7 (Debug)
| État | FPS médian | Pic RAM |
|---|---:|---:|
| Phase 18 | 293 | 332,7 Mo |
| **Après la Phase 19** | **311** | **331,7 Mo** |
### Vue d'alpage — E 900500 N 6439000, yaw 100, pitch -7 (Debug)
| État | FPS médian | Pic RAM |
|---|---:|---:|
| Phase 18 | 122 | 340,2 Mo |
| **Après la Phase 19** | **131** | **339,1 Mo** |
Ces écarts sont **dans le bruit** de la mesure de FPS (~15 % entre deux runs
identiques, cf. MEMORY.md) : la phase ne prétend pas à un gain de FPS sur ces
vues. Ce qui est solide, c'est le **pic mémoire**, qui est plus stable et qui est
descendu de 1 Mo sur les deux vues.
### Coût d'une tuile — survol 900 m/s
| Poste | Debug | Release |
|---|---:|---:|
| Géométrie | 1 344 µs (79 %) | 140 µs (33 %) |
| Indices | 16 µs | 15 µs |
| Téléversement | 250 µs (15 %) | 262 µs (**63 %**) |
0 tuile non couverte sur toutes les mesures, Debug comme Release, séquentiel
comme parallèle.
---
## 4. Vérification
- **Tests headless : 902 assertions** (896 avant la phase, **+6**), toutes
passent. Nouvelle section « Phase 19 : maillage de tuiles en parallèle »
(§1.8).
- **Zéro message `[Validation]`** sur la totalité des mesures et des scénarios,
Debug et Release.
- **`VK_LAYER_VALIDATE_SYNC=1`** sur les deux chemins : 0 message, **avec son
contrôle négatif** (§1.9).
- **Harnais `run_vulkan_check.ps1`** : voir §4.1.
### 4.1 Résultat du harnais
Joué **deux fois en entier** (11 processus, scénarios A à I) : une fois après la
Tâche 1, une fois sur le binaire final.
- **0 message `[Validation]`, 0 ligne `[ERROR]`**, code de sortie 0 pour chacun
des onze processus, fermeture propre partout ;
- gameplay effectivement exercé : 2 arbres abattus (3 au sol), 3 débitages,
4 objets ramassés, percussion, vol de parapente complet, escalade avec
sommet atteint (+41,5 m, pente 65 à 155 %), éditeur (3 objets posés, un
supprimé, une annulation, sauvés/rechargés, **et rechargés en partie normale**
où ils arrêtent le joueur : 0,28 m parcourus contre 21,05 m pour le témoin
sans scène), boisson au point d'eau avec son contrôle négatif à 30 m, faune
qui se retire du voisinage (4 animaux à portée au premier relevé → 0 au
dernier).
Les 4 lignes `[WARN]` sont les avertissements bénins habituels (pas de point
d'eau ni de faune sur certaines dalles) ; le harnais ne les compte pas comme des
erreurs.
### Le point rouge, inchangé depuis la Phase 17
Le harnais sort en `[ECHEC]` sur **un seul critère** : scénario E (vélo),
« pied à terre » (`False`). C'est un échec **antérieur à cette phase**, documenté
dans NOTES-PHASE17.md puis dans NOTES-PHASE18.md §4, laissé non corrigé pour
cause de périmètre. La Phase 19 ne l'a ni causé ni aggravé — elle ne touche que
le maillage des tuiles de terrain, et le reste du scénario E est vert (en selle
`True`, 13 relevés à l'arrêt en côte au-delà de 23,6 % de pente).
Le scénario I, bruité en Phase 18, est **vert** cette fois (4 → 0).
---
## 5. Options et outils ajoutés
| Ajout | Rôle |
|---|---|
| `--tile-threads=N` | Degré de parallélisme du maillage CPU des tuiles, thread de rendu compris. Défaut **1** (séquentiel). **Témoin de mesure** : aucun appel Vulkan ne change de thread quelle que soit la valeur. |
| `tools\profile_tiles.ps1` | Relève le profil de construction des tuiles et le coût par image sur un scénario donné. La Phase 18 relevait ces lignes à la main ; ce script rend le relevé reproductible — ce que `measure_terrain.ps1` avait fait pour le FPS en Phase 9. |
| Journal `Cout par image` | Cinq postes CPU du frame, à la fermeture. Permanent, non conditionnel. |
| Journal `Maillage parallele` | Temps de mur **et** travail cumulé du maillage, dans `buildProfile`. Les deux, jamais un seul (§1.3). |
---
## 6. Prochaines étapes suggérées
1. **Refaire les mesures de performance des phases précédentes en Release.**
C'est la conséquence la plus large de cette phase : les priorités
d'optimisation du projet sont établies sur des profils de Debug, et on vient
de voir qu'au moins l'une d'elles ne survit pas au passage en Release. Les
conclusions des Phases 10, 11, 12 et 18 méritent une relecture sous cet
angle.
2. **Le vrai poste d'une tuile en Release est le TÉLÉVERSEMENT (63 %).** La
piste chiffrée existe déjà et n'a pas bougé : **partager un unique buffer
d'indices GPU** entre toutes les tuiles (Phase 18 §2.5) supprimerait 96 Ko de
copie par tuile et ~48 Mo de mémoire GPU. C'est désormais le chantier de
performance le mieux ciblé.
3. **Le frame est limité par le GPU, et le premier consommateur est la
végétation** : sur l'alpage, l'herbe pèse 1,0 ms et les arbres 0,7 ms des
3,5 ms de `drawFrame`. Le levier est le **nombre d'instances**, pas le
shader (la Phase 18 avait déjà montré que la découpe alpha coûte zéro). Un
LOD sur l'herbe — moins de touffes au-delà de 20 m — serait le gain le plus
important disponible aujourd'hui, mais il **touche la qualité visuelle** :
c'est un compromis à valider, pas une optimisation à décider seul.
4. **Les deux redondances de `gatherTrees`** (§2.2), si le rapport CPU/GPU
change un jour.
5. Rendre les scénarios E et I du harnais insensibles au FPS (hérité de la
Phase 18, toujours pas fait).
+353
Voir le fichier
@@ -0,0 +1,353 @@
# NOTES-PHASE20.md — La collision cesse d'être une affaire d'arbres
Session du 2026-08-26, à la suite de la Phase 19.
La consigne était d'étendre la collision « à tous les objets du monde qui n'en
ont pas encore ». L'inventaire réel du code a réduit ce périmètre à **une seule
lacune** — et c'est le premier résultat de la phase, avant toute ligne écrite.
---
## 1. L'inventaire, avant de coder
| Catégorie | État trouvé dans le code | Décision de la Phase 20 |
|---|---|---|
| Arbres, souches (`Forest`) | Collision depuis la **Phase 6** | Inchangé |
| Objets posés par l'éditeur (`EditorScene`) | Collision depuis la **Phase 15**, avec un drapeau `solid` **par objet** | Inchangé |
| **Faune (`Wildlife`)** | **Aucune collision** | **Corrigé** |
| Objets au sol (`Ground` : bûches, branches, pierres, éclats) | Aucune collision | **Laissé sans collision, délibérément** (§4) |
### 1.1 Les objets d'éditeur avaient déjà tout ce que la consigne demandait
La consigne proposait de « décider d'une approche raisonnable (ex : un flag
solide par asset ou par instance placée) ». Cette décision avait déjà été prise
en Phase 15, et dans le sens le plus fin des deux : `PlacedObject::solid` est un
drapeau **par instance**, réglable en jeu par la touche `K`, sérialisé dans le
format `.vcsc`. La raison donnée à l'époque tient toujours et vaut mieux que
celle qu'on aurait inventée aujourd'hui : le même rocher peut être un obstacle
sur un sentier et un simple décor à flanc de falaise, et surtout un asset dont
l'empreinte cylindrique est fausse (l'abri, qui a un intérieur) doit pouvoir
être posé sans emmurer le joueur.
**Rien n'a donc été touché de ce côté.** Le vérifier était le travail ; le
réécrire aurait été une régression déguisée en livraison.
### 1.2 L'architecture ne demandait aucune généralisation
La consigne demandait de « généraliser le système existant plutôt que d'écrire
un système parallèle ». La généralisation était déjà faite, en deux temps :
- **Phase 6** : `CollisionSolver` (interface) + `moveBody()` (point d'entrée
unique, qui vérifie le résultat du repoussement et refuse le déplacement quand
aucune position libre n'existe) ;
- **Phase 15** : `CompositeCollisionSolver`, qui implémente le même contrat et
le délègue à une liste de sources.
Résultat : brancher la faune est **une ligne** dans `main.cpp`
(`worldSolver.add(wildlife.get())`), et cette ligne suffit pour **les trois
activités qui se déplacent au sol**. C'est la deuxième fois que l'interface de
la Phase 6 tient sa promesse, et cette fois sans qu'on ait eu à l'aménager.
---
## 2. Ce qui a été écrit
`Wildlife` implémente désormais `CollisionSolver`, exactement comme `Forest` et
`EditorScene`.
- **Empreinte** : cylindre vertical, rayon `0,65 m` = **demi-longueur du mesh de
cervide** (`kAnimalLength / 2`), multiplié par `Animal::scale` ; bande
verticale `[sabots ; sabots + 1,05 m × échelle]`.
- **Géométrie** : celle de `Forest::resolve` — cercles dans le plan XZ,
recouvrement d'intervalles en Y, repoussement jusqu'au contact, 4 passes avec
sortie anticipée dès qu'une passe ne touche rien. **Aucun second modèle de
collision n'a été écrit** : le monde doit se cogner partout de la même façon,
sans quoi il y aurait deux comportements à régler, à tester et à garder
d'accord.
- **Le lien mesh ↔ collision est tenu par une assertion de COMPILATION.**
`WildlifeParams` ne peut pas inclure `AnimalMesh.hpp` sans traîner tout le
moteur derrière tout ce qui paramètre la faune, donc `0,65` y est écrit en
clair. Un `static_assert` dans `Wildlife.cpp` vérifie que cette valeur reste
la demi-longueur du mesh : le jour où le cervide changera de taille, ça
échouera à la compilation au lieu de le rendre traversable par le flanc.
### 2.1 Pourquoi le cylindre CONTENANT, et ce qu'il coûte
Même convention que l'empreinte des objets d'éditeur, et pour la même raison :
un collider plus petit que l'objet se traverse par les coins, ce qui est
exactement le défaut qu'on vient corriger.
**Contrepartie assumée, et elle est réelle** : de face, le cervide ne fait que
0,42 m de large ; son cylindre de 0,65 m est donc trop généreux d'une vingtaine
de centimètres de chaque côté. Un cylindre ne peut pas être juste dans les deux
sens, et l'erreur qui bloque un peu tôt est moins choquante que celle qui laisse
passer au travers d'un flanc.
### 2.2 Ce qui reste FAUX, et qui l'est volontairement
**Un animal, lui, traverse toujours les troncs, les rochers posés et ses
congénères.** Ce n'est pas un oubli : c'est le corollaire du « aucune IA » de la
Phase 17. La fuite est une ligne droite, sans évitement d'obstacle — un animal
qui buterait sur un tronc y resterait **collé**, faute de savoir le contourner,
et un cervide encastré dans un arbre serait plus laid que le problème résolu.
Le sens qui compte pour le joueur est celui qui a été traité.
### 2.3 Un animal n'est pas un tronc : il bouge
Deux conséquences, toutes deux assumées et toutes deux déjà couvertes par
`moveBody()` :
- un animal peut venir se poser **sur** un joueur immobile — le joueur ne bouge
pas, donc aucun `moveBody()` n'est appelé, donc rien ne l'écarte. Il sera
repoussé au premier pas : c'est le cas dégénéré que `moveBody()` traite déjà
en dernier recours pour « un arbre planté sur le joueur » ;
- la position « précédente » sur laquelle `moveBody()` se replie a pu devenir
occupée entre deux images. Le repli la teste avant de s'y poser, il n'y avait
donc rien de particulier à écrire.
---
## 3. LA MESURE : témoin négatif et chiffre prédit
Méthode de la Phase 15 : deux mondes **identiques à une option près**, même
graine, même semis, même animal à la même place. La seule différence est la
collision.
Le témoin est `WildlifeParams::solid = false`, exposé en jeu par la nouvelle
option **`--no-animal-collision`**. C'est le témoin qui compte, et
`--no-wildlife` ne pouvait pas le remplacer : supprimer les animaux ne montre
pas qu'on traverse celui qui est là.
Marche de 20 m, droit sur un cervide isolé, par le même `moveBody()` que la
caméra :
| | approche la plus proche | distance parcourue |
|---|---:|---:|
| Témoin, `--no-animal-collision` | **0,0010 m** (le centre de l'animal) | **20,00 m** |
| Avec collision | **1,0418 m** | 13,20 m |
Et **1,0418 m est le chiffre prédit** : rayon de collision de cet animal
(`0,65 × échelle`) + demi-largeur du joueur (`0,35`). Il est atteint **au
millimètre près**. C'est ce qui sépare « ça a l'air de bloquer » de « ça bloque
là où le modèle le dit ».
### 3.1 La première version de ce test avait tort, et la mesure l'a dit
Le test attendait un **arrêt net** à `10 − 1,0418 = 8,96 m`. Mesure : **13,20 m
parcourus**, et une sortie de l'autre côté de l'animal.
Ce n'est pas un défaut, c'est le **glissement** que le solveur par repoussement
produit exprès (`CollisionSolver.hpp` : « on longe un tronc au lieu de s'y
coller net »). Contre un obstacle convexe **isolé**, une poussée frontale n'est
jamais parfaitement frontale à l'arrondi près, et la composante latérale
accumulée finit par faire contourner l'animal — comme on contournerait un tronc.
La grandeur réellement **prédite par le modèle** n'est donc pas la distance
d'arrêt, c'est le **rayon de contact**. C'est elle qui est vérifiée. La leçon
est celle des phases précédentes, un cran plus loin : *un chiffre attendu qui ne
sort pas n'est pas forcément un bug — il faut d'abord savoir lequel des deux,
du code ou de l'attente, décrit le modèle.*
*(La toute première version échouait pour une raison encore différente et plus
bête : avec la population par défaut — 24 animaux espacés d'au moins 14 m — un
trajet de 20 m en croise parfois un SECOND, et la marche s'arrêtait sur
celui-là. La collision marchait ; c'est la distance prédite qui parlait du
mauvais animal. Le test sème désormais `maxAnimals = 1`.)*
### 3.2 Toutes les activités, pas seulement la marche
C'était une exigence explicite de la consigne. Réponse par activité :
- **Marche** (`Camera::resolveCollisions`) : mesurée ci-dessus.
- **Vélo** (`Bike::update`) : **mesuré à part**, et c'est le cas qui compte le
plus. Le vélo roule à 30 km/h, c'est-à-dire à la vitesse de **fuite** de
l'animal (8 m/s) : c'est la seule activité qui peut réellement rattraper un
cervide et lui rentrer dedans. À pied, on ne l'approche jamais — il part à
30 m. Résultat : le témoin passe à moins de 0,5 m du centre, le cycliste avec
collision reste au-delà du rayon de contact.
- **Escalade** (`Climber::update`) : concernée au **pied** de la paroi, jamais
dessus, et pour une raison de MODÈLE et non de code — `WildlifeParams::
maxSlope` (0,90) est inférieur à `ClimberParams::wallSlope` (1,00), donc
**aucun animal ne peut se tenir sur une pente assez raide pour être
grimpable**. C'est le même genre de rapport entre deux constantes réglées
séparément que la leçon de la Phase 17 (`noiseRadius` vs `spawnRadiusMin`),
sauf qu'ici le rapport est celui qu'on veut : une assertion le fige, pour
qu'on ne le perde pas en retouchant l'une des deux. Un second test vérifie la
bande verticale : un grimpeur à 2,4 m au-dessus des sabots n'est pas gêné.
- **Parapente** : **hors périmètre, inchangé, et cohérent avec la Phase 8**, qui
documente déjà « pas de collision avec les arbres pendant le vol ». Le
parapente ne consomme aucun `CollisionSolver` : lui en donner un serait une
phase à part (un vol qui se cogne demande de décider ce qu'est un crash). À
l'atterrissage, le joueur repasse en mode `Walk` et retrouve la collision
complète, faune comprise.
**Aucune de ces trois classes n'a été modifiée.** Elles reçoivent toutes le même
`worldSolver`.
---
## 4. DÉCISION : les objets au sol ne bloquent pas
`Ground` (bûches, branches, pierres, éclats) n'implémente pas `CollisionSolver`
et n'entre pas dans le solveur composite. **C'est une décision, pas un oubli**,
et elle repose sur trois faits mesurables :
1. **Ce sont des cibles de RAMASSAGE.** `Ground::findNearest` exige de s'en
approcher. Un collider solide ferait lutter le joueur contre la mécanique
même qui donne leur raison d'être à ces objets.
2. **Ils sont sous le genou.** Le plus haut est la pierre : `kStoneRadius` vaut
0,20 m, donc 0,40 m de haut posée. Un joueur enjambe ça ; le simuler
demanderait une gestion de marche/step-up qui n'existe pas dans le moteur.
3. **Un débitage en dépose 3 à 4 autour du joueur** (`Forest::scheduleBucking`).
Les rendre solides pourrait l'emmurer dans le bois qu'il vient de produire —
et le solveur n'a aucun moyen de l'en sortir, puisque `moveBody()` refuse
simplement le déplacement quand aucune position libre n'existe.
Le test headless fige cette décision plutôt que de la laisser au commentaire :
il pose une pierre et une bûche sur le trajet et vérifie que le passage reste
libre, en nommant la phase qui a tranché.
**Ce qui rendrait la décision fausse un jour** : un objet au sol nettement plus
gros (un rocher non ramassable, un tronc entier non débité). Le jour où
`GroundItemKind` en accueillera un, c'est un drapeau `solide` par nature d'objet
qu'il faudra — pas un collider pour toute la catégorie.
---
## 5. Vérification
### 5.1 Tests headless
**935 assertions** (902 avant la phase, **+33**), toutes passent, zéro
avertissement à `/W4`. Nouvelle section « Phase 20 : collision de la faune ».
Ce qu'elle couvre :
- le témoin négatif et le chiffre prédit (§3) ;
- cohérence `resolve` / `overlaps` : la sortie de `resolve()` est **libre**,
sans quoi `moveBody()` refuserait tout déplacement le long d'un animal au lieu
de laisser glisser (c'est la raison de la marge d'un millimètre, la même que
dans `Forest` et `EditorScene`) ;
- le cas dégénéré « joueur exactement sur l'axe de l'animal » : aucun NaN, écarté
au contact ;
- la bande verticale (grimpeur au-dessus, joueur au sol) ;
- le rayon suit `Animal::scale`, et le défaut est bien la demi-longueur du mesh ;
- le **solveur composite à trois sources** : le tronc bloque toujours (Phase 6),
le rocher posé bloque toujours (Phase 15), l'animal bloque désormais
(Phase 20), et le passage libre le reste ;
- la décision du §4 (objets au sol traversables) ;
- le vélo et l'invariant d'escalade (§3.2) ;
- l'option `--no-animal-collision` côté interface (`overlaps` faux, `resolve`
rend la position telle quelle).
### 5.2 Build
`tools\build.bat Debug` : configuration et compilation propres, aucun
avertissement neuf. Trois unités recompilées (`Wildlife.cpp`,
`TerrainStreamer.cpp`, `main.cpp`) et l'édition de liens.
### 5.3 Vulkan
Voir §6.
### 5.4 Synchronisation
**Pas de `VK_LAYER_VALIDATE_SYNC=1` cette fois, et c'est justifié plutôt
qu'omis** : cette phase ne touche **aucun objet Vulkan, aucun thread, aucune
barrière, aucun téléversement**. Les trois fichiers modifiés sont
`world/Wildlife.{hpp,cpp}` (géométrie pure, GLM seul) et le câblage dans
`main.cpp`. Le contrôle de synchronisation de la Phase 19 portait sur le chemin
de téléversement des tuiles, qui est rigoureusement inchangé. Le relancer aurait
produit un journal vide sans rien prouver de neuf — et la Phase 12 a établi
qu'un journal propre ne prouve rien tant qu'on n'a pas montré que l'outil
regarde au bon endroit.
---
## 6. Résultat du harnais `run_vulkan_check.ps1`
Joué **en entier** (scénarios A à I) sur le binaire final, puis le scénario B
rejoué seul.
**L'essentiel : zéro `[Validation]`, zéro `[ERROR]`** sur 5 510 lignes de
journal. Les 4 `[WARN]` sont les avertissements bénins habituels (pas de point
d'eau ni de faune sur certaines dalles) ; le harnais ne les compte pas comme des
erreurs.
### 6.1 Non-régression : les systèmes des Phases 15 à 19 sont intacts
| Vérification | Résultat |
|---|---|
| **Éditeur (G), collision des objets posés** | **0,28 m avec la scène contre 21,03 m sans (témoin)** — la mesure de la Phase 15 est reproduite à l'identique |
| Éditeur : posés / supprimés / annulations / F5 / F9 / rechargés en jeu normal | 3 / 1 / 1 / 3 / 3 / 3 objets dont 3 solides |
| Sélection sans viser (F3/F4) | 3 sélections pour 3 touches envoyées |
| **Faune (I), Phase 17** | 24 animaux, fréquentation 100 %, **4 animaux à portée au premier relevé → 1 au dernier** — la zone se vide toujours |
| Besoins (H), Phase 16 | 2 points d'eau détectés, boire au point d'eau `True`, **refus à 30 m `True`** (témoin) |
| Escalade (F), Phase 14 | sommet atteint, +41,6 m, pente 63 à 154 % |
| Parapente (D), Phase 8 | décollage et atterrissage naturel |
| Dalle LiDAR réelle (C), Phase 7 | chargée, arbre visé et abattu, 5 objets ramassés |
| Streaming / LOD, Phases 10-12 et 19 | aucune erreur, fermeture propre partout |
**Le point le plus important pour cette phase est la première ligne** : la
collision des objets d'éditeur, mesurée par témoin, rend exactement le même
chiffre qu'avant. Ajouter une source au `CompositeCollisionSolver` n'a rien
changé aux deux autres.
### 6.2 Les deux points rouges, et ce qu'ils sont
1. **Scénario E (vélo), « pied à terre » `False`.** Échec **antérieur à cette
phase**, documenté depuis la Phase 17 puis dans les NOTES des Phases 18 et
19, laissé non corrigé pour cause de périmètre. La Phase 20 ne l'a ni causé
ni aggravé : le reste du scénario E est vert (en selle `True`, 32,3 km/h en
descente, 11 relevés à l'arrêt en côte au-delà de 23,6 % de pente).
2. **Scénario B, code de sortie −1, « l'arbre 7 n'a pas été abattu ».** Celui-là
ne pouvait pas être classé sans vérification, parce que le scénario B **est**
le chemin de collision : c'est précisément ce que cette phase touche.
**Rejoué seul immédiatement après : vert** — code de sortie 0, fermeture
propre, « tronc debout PUIS souche poussés, sans erreur ni plantage », zéro
`[Validation]`. C'est la flakiness `PostMessage` déjà documentée dans
l'en-tête du script (scancodes, pas de vraie souris : cible d'abattage
manquée de peu ou `WM_CLOSE` lent), et le protocole du projet pour ce cas est
justement de rejouer. **Pas une régression.**
---
## 7. Options ajoutées
| Ajout | Rôle |
|---|---|
| `--no-animal-collision` | La faune reste **visible** mais redevient **traversable** : comportement exact d'avant la Phase 20. **Témoin de mesure**, au même titre que `--no-scene` pour l'éditeur. `--no-wildlife` ne peut pas le remplacer — supprimer les animaux ne montre pas qu'on traverse celui qui est là. |
| Journal `Faune : collision ACTIVE/DÉSACTIVÉE` | Une ligne au démarrage, qui dit laquelle des deux configurations tourne et avec quel rayon. Sans elle, un run de mesure ne peut pas prouver **après coup** de quel côté du témoin il était. |
---
## 8. Ce qui n'est pas fait
1. **La faune ne se cogne à rien.** Voir §2.2 : c'est le corollaire de l'absence
d'IA, et le lever demande un évitement d'obstacle, donc un vrai déplacement,
donc une session à part.
2. **Le cylindre reste faux de face** (§2.1). Un collider orienté (capsule
couchée le long du cap de l'animal) serait juste dans les deux sens — c'est
la même limite que celle notée en Phase 15 pour les objets à intérieur, et la
même réponse : un volume composé plutôt qu'un cylindre englobant.
3. **Aucune conséquence de gameplay au contact.** Bousculer un cervide ne le
fait pas fuir plus vite, ne blesse personne, ne coûte rien. La collision est
physique, pas narrative.
4. **Aucun scénario Vulkan dédié** (un « scénario J »). Le harnais ne pilote que
le clavier et la faune est **semée aléatoirement autour du joueur** : un
scénario reproductible demanderait de pouvoir poser un animal à une position
choisie, c'est-à-dire une entrée de débogage dans `Wildlife`. La preuve de
collision est donc **headless et déterministe** — ce qui est aussi le seul
endroit où le témoin négatif est rigoureux. Le harnais complet a servi à la
**non-régression**, pas à la mesure de cette phase.
5. **Pas de mesure de coût, et l'argument est structurel, pas mesuré.**
`resolve`/`overlaps` balaient au plus `maxAnimals` = 24 cylindres par appel
de déplacement, contre plusieurs centaines d'arbres pour `Forest` sur le même
chemin : le poste ajouté est plus petit d'un ordre de grandeur qu'un poste
déjà présent, et la Phase 19 a établi que l'image est **limitée par le GPU**
(81 % du temps passé à attendre dans `drawFrame`). Chiffrer ce poste
demanderait une instrumentation neuve pour mesurer une fraction d'un temps
d'attente. C'est une justification, pas une mesure : si la population de
faune devait un jour croître d'un ordre de grandeur, il faudrait le chiffrer
pour de bon.
+243
Voir le fichier
@@ -0,0 +1,243 @@
# PHASE 21 — Build demo légère + packaging distribuable
## Objectif
Produire un `.exe` Vercora envoyable à quelqu'un qui n'a ni le dépôt ni
l'environnement de développement (pas de Vulkan SDK, pas de VC++
Redistributable installé, pas CMake), qui montre le terrain LiDAR réel
25 km² avec LOD/streaming, l'orthophoto, les arbres/herbe procéduraux, la
marche et le vol libre — et rien d'autre.
## 1. Configuration "démo" : un flag runtime, pas une macro de compilation
Choix : **`--demo`**, un argument de ligne de commande lu dans `main()`
(comme `--no-wildlife`, `--no-scene`, etc.), plutôt qu'une macro
`VERCORA_DEMO` évaluée à la compilation.
Raison : la démo ne retire aucun code, seulement de l'**initialisation** —
exactement le rôle que jouent déjà `--no-wildlife` et `--no-scene` depuis les
Phases 17 et 15. Une deuxième configuration de build à maintenir en parallèle
(macro + `#ifdef` disséminés) aurait un coût permanent pour un besoin
ponctuel, et le harnais de validation Vulkan (`tools/run_vulkan_check.ps1`)
continue de piloter le binaire normal sans rien changer.
`--demo` fait exactement ceci, au démarrage (voir `src/main.cpp`, recherche
`demoMode`) :
- force `useWildlife = false` → faune et mémoire du milieu (`Habitat`)
coupées, comme `--no-wildlife` ;
- force `useScene = false` et `startInEditor = false` → aucun objet posé
chargé/sauvé, touche F2 sans effet (le bloc qui bascule le mode éditeur est
déjà gardé par `terrainScene && useScene`) ;
- désactive `Needs` en entier (jauges, effet sur la vitesse de marche, boire)
— la vitesse redevient la constante `kWalkSpeed`, non modulée ;
- coupe les touches parapente (V), vélo (B) et escalade (X) : les blocs
d'entrée dans ces activités sont gardés par `!demoMode` ;
- coupe abattage (E), ramassage (R) et percussion (C) : même garde. La forêt
et le sol restent construits, visibles et **solides** (collision inchangée)
— seule l'interaction est coupée, pas le rendu ni la géométrie.
- charge par défaut la dalle de la **zone entière** (`vercora_zone_1m.vchm`,
25 km²) et non plus la dalle unique de développement
(`LHD_0907_6440_1m.vchm`), avec repli en cascade sur la version 2 m si le
package ne contient que celle-ci (voir §3).
Ce que `--demo` NE touche PAS : LOD/streaming du terrain, orthophoto,
végétation procédurale (arbres et herbe), marche, vol libre (F), compteur
FPS. C'est exactement le périmètre demandé.
Usage :
```
vercora.exe --demo
```
Se combine avec les autres options existantes si besoin (`--start=E,N`,
`--no-grass`, etc.) — `--demo` ne fait que poser des défauts, il ne bloque
rien.
## 2. Chemins : la fin des chemins absolus codés en dur
Avant cette phase, `ASSETS_DIR` et `SHADERS_OUTPUT_DIR` étaient deux macros
CMake portant le chemin absolu du dépôt de développement
(`C:/Users/theog/Documents/_CODE/_Vercora/...`). Correct pour développer
(l'exécutable retrouve ses données depuis n'importe quel répertoire courant),
mais rend le binaire indistribuable : sur une autre machine, ces chemins ne
désignent rien.
Nouveau fichier `src/core/Paths.hpp` / `.cpp` : résout `assetsDir()` et
`shadersDir()` avec la règle suivante, dans cet ordre —
1. le sous-dossier `assets\` (ou `shaders\`) **à côté de l'exécutable**, s'il
existe → cas du package distribué ;
2. sinon la macro CMake (`ASSETS_DIR` / `SHADERS_OUTPUT_DIR`) → cas du
développement, comportement inchangé.
L'exécutable de développement (compilé dans `build\`, sans dossier `assets\`
ni `shaders\` juste à côté) retombe donc automatiquement sur l'ancien
comportement — **rien ne change pour le développement courant**, y compris
le harnais de validation Vulkan qui pointe toujours vers `build\vercora.exe`.
Le même binaire copié dans un dossier qui contient `assets\` et `shaders\`
lit ceux-là.
`GetModuleFileNameW` (Windows) donne le chemin de l'exécutable ; le résultat
est mis en cache (une résolution touche le disque, et `assetsDir()` est
interrogée à chaque chargement de dalle).
Fichiers modifiés pour utiliser ces fonctions plutôt que les macros
directement : `src/renderer/Pipeline.cpp` (chemin des .spv),
`src/main.cpp` (`kDefaultTerrainFile`, `kDemoTerrainFile`,
`kDemoTerrainFallback`, `kEditorAssetsDir`, `kScenesDir`).
**Ce qui reste dans le binaire** : les macros `ASSETS_DIR` et
`SHADERS_OUTPUT_DIR` définies par CMake existent toujours (elles servent de
repli, cas 2 ci-dessus), donc leur valeur — le chemin absolu du poste de
développement — reste une chaîne de caractères embarquée dans l'exécutable.
Elle n'est **jamais lue** quand le dossier adjacent existe (le cas du
package), mais elle est visible par un outil comme `strings`. Sans
conséquence fonctionnelle ni fuite de données sensibles (c'est un chemin de
projet local, pas une information personnelle exploitable), mais à savoir
si le binaire est un jour distribué à quelqu'un qui inspecterait ses chaînes.
## 3. Build Release
`tools\build.bat Release` fonctionne sans modification (le script acceptait
déjà `Debug`/`Release` en paramètre). Confirmé :
- `CMAKE_BUILD_TYPE=Release` correctement appliqué (vérifié dans
`CMakeCache.txt`) ;
- `VERCORA_DEBUG` n'est définie que par
`$<$<CONFIG:Debug>:VERCORA_DEBUG>` dans `CMakeLists.txt` → absente en
Release ;
- `src/renderer/VulkanContext.cpp` n'active `VK_LAYER_KHRONOS_validation`
que sous `#ifdef VERCORA_DEBUG` → **aucune couche de validation demandée
en Release**, confirmé par lancement réel (voir §5).
- Taille de l'exécutable Release : **844 Ko** (optimisations activées, pas
de symboles de debug embarqués comme en Debug).
Attention pratique notée pendant cette phase : `tools\build.bat` réutilise
toujours le dossier `build\` quel que soit le paramètre — changer de
configuration dedans exige que `vercora.exe` ne soit pas verrouillé par un
processus en cours (sinon `LNK1168`/`LNK1104` à l'édition de liens). Le
dossier `build\` a été remis en configuration **Debug** à la fin de cette
phase, pour laisser l'environnement de développement inchangé.
## 4. Dépendances runtime identifiées
`dumpbin /dependents` sur l'exécutable Release :
| DLL | Origine | Présente sur une machine tierce ? |
|---|---|---|
| `vulkan-1.dll` | pilote GPU (NVIDIA/AMD/Intel) | Oui sur toute machine avec des pilotes à jour depuis ~2016. **Non fournie dans le package** — installée par les pilotes, pas par le SDK Vulkan (le SDK ne redistribue pas ce fichier ; vérifié : absent de l'arborescence `C:\VulkanSDK\...`). |
| `KERNEL32.dll`, `USER32.dll`, `GDI32.dll`, `SHELL32.dll` | Windows | Toujours présentes (composants du système). |
| `MSVCP140.dll`, `VCRUNTIME140.dll`, `VCRUNTIME140_1.dll` | Visual C++ Redistributable 2015-2022 (x64) | Pas garanti sur une machine neuve. **Fournies dans le package**, copiées depuis `VC\Redist\MSVC\...\x64\Microsoft.VC145.CRT\` de l'installation Visual Studio (fichiers officiellement redistribuables). |
| `api-ms-win-crt-*.dll` (8 fichiers) | Universal CRT | Composant du système depuis Windows 10 1607+ / présent nativement sur Windows 10/11. Non fournies, non nécessaires. |
Conséquence : **l'ami n'a rien à installer** si sa machine est un Windows
10/11 avec des pilotes GPU à jour (le cas normal de tout PC utilisé pour
jouer ou avec une mise à jour Windows Update récente). La seule vraie
inconnue est l'état de ses pilotes GPU — voir §6.
`vulkan-1.dll` n'a PAS été ajoutée au package : c'est un composant lié au
pilote installé (son fichier ICD JSON dans le registre pointe vers un pilote
précis), embarquer une copie risquerait un dépareillage silencieux plutôt que
d'aider. Mieux vaut que l'ami ait la version que son propre pilote a posée.
## 5. Contenu exact du package (`dist/VercoraDemo/`)
```
vercora.exe 844 Ko (Release, sans validation layers)
msvcp140.dll 629 Ko (VC++ Redistributable)
vcruntime140.dll 174 Ko (VC++ Redistributable)
vcruntime140_1.dll 49 Ko (VC++ Redistributable)
LisezMoi.txt (mode d'emploi pour l'ami)
shaders/
cube.vert.spv, cube.frag.spv
terrain.vert.spv, terrain.frag.spv
foliage.vert.spv, foliage.frag.spv 40 Ko au total
assets/terrain/
vercora_zone_1m.vchm 95,4 Mo (terrain 25 km², pas 1 m)
vercora_zone_ortho.vcto 42,7 Mo (orthophoto drapee)
```
**Total : 140 Mo.**
Alternative plus légère non retenue par défaut mais disponible si besoin :
remplacer `vercora_zone_1m.vchm` par `vercora_zone_2m.vchm` (23,9 Mo au lieu
de 95,4 Mo) → package total ≈ 68 Mo, même emprise de 25 km², relief deux fois
moins fin. Le code gère déjà ce repli tout seul si seule la dalle 2 m est
présente (voir `kDemoTerrainFallback` dans `src/main.cpp`).
Aucun fichier `_canopy` : absent du package, sans conséquence (le jeu retombe
sur un semis de végétation par pente/altitude, avec un message de log qui le
dit explicitement — comportement déjà existant, pas ajouté pour la démo).
## 6. Tests effectués
- **Build Debug normal (développement)** : compile sans erreur après tous
les changements de cette phase.
- **Scénario A du harnais de validation Vulkan**
(`tools\run_vulkan_check.ps1 -Only A`) sur le build Debug : **0 message
[Validation], 0 [ERROR], fermeture propre**. Gameplay réellement exercé
(abattage, ramassage, percussion, bascule marche/vol). Confirme que les
changements de chemins et le flag `--demo` n'ont rien cassé sur le chemin
de développement normal.
- **`--dump-world --demo`** (sans fenêtre ni Vulkan) : la zone 25 km² se
charge, la faune/besoins sont bien annoncés comme désactivés dans les
logs.
- **Build Release** : compile et édite les liens sans erreur ; confirmé
`CMAKE_BUILD_TYPE=Release` et absence de `VERCORA_DEBUG`.
- **Test d'emplacement tiers** : le dossier `dist/VercoraDemo/` entier copié
sur le lecteur **E:** (disque différent de celui du dépôt), lancé depuis
là :
- `vercora.exe --dump-world --demo` : charge correctement la zone 25 km²
depuis `E:\VercoraDemoTest\VercoraDemo\assets\...` — preuve que la
résolution de chemin ne dépend plus de l'emplacement du dépôt ;
- lancement réel avec fenêtre Vulkan (`--demo --lock-input`, 5 secondes
puis fermeture forcée pour le test) : instance Vulkan créée, GPU détecté
(Intel UHD Graphics 770 sur cette machine), les trois pipelines
(cube/terrain/foliage) chargés depuis `E:\...\shaders\`, orthophoto
8192×8192 chargée et liée au terrain, quadtree et streaming actifs,
aucune ligne d'erreur sur stderr. Le processus est resté vivant tout le
temps du test (pas de crash immédiat).
- Build Debug restauré dans `build\` après ce test pour ne rien changer à
l'environnement de développement habituel.
## 7. Ce que je NE peux PAS garantir à 100 % sans machine tierce réelle
Le test ci-dessus est le plus proche possible de "ça marche chez l'ami" sans
y avoir accès, mais il reste sur **la même machine, le même GPU (Intel UHD
Graphics 770), les mêmes pilotes, la même version de Windows**. Restent
inconnus :
- **Le GPU et les pilotes de l'ami.** Vercora demande Vulkan 1.2 ; c'est
supporté par toute carte NVIDIA/AMD/Intel de moins d'une dizaine d'années
avec des pilotes à jour, mais je ne peux pas vérifier SA machine.
→ **À demander à l'ami** : que ses pilotes GPU soient à jour (site du
fabricant, pas seulement Windows Update qui est parfois en retard).
- **Windows 7/8** : non testé, non visé (l'API `GetModuleFileNameW` utilisée
fonctionne dès Windows XP donc ce n'est pas un obstacle technique connu,
mais Vulkan et des pilotes récents sont peu probables sur ces systèmes).
→ **À demander à l'ami** : Windows 10 ou 11.
- **Antivirus/SmartScreen** : `vercora.exe` n'est pas signé numériquement.
Sur CETTE machine, Smart App Control bloque déjà les binaires non signés
fraîchement compilés (voir le commentaire de `dumpWorld` dans
`src/main.cpp`) — c'est probable que Windows Defender SmartScreen affiche
un avertissement chez l'ami aussi au premier lancement. Documenté dans
`LisezMoi.txt` du package (bouton "Informations complémentaires" puis
"Exécuter quand même").
- **Taille du transfert (140 Mo)** : trop gros pour la plupart des pièces
jointes email (limite Gmail : 25 Mo). **Nécessite un service de transfert
de fichiers** (WeTransfer, Google Drive/OneDrive avec lien de partage,
etc.) plutôt qu'un email direct.
## Fichiers modifiés/créés dans cette phase
- `src/core/Paths.hpp`, `src/core/Paths.cpp` (nouveaux)
- `CMakeLists.txt` : ajout de `src/core/Paths.cpp` aux sources
- `src/renderer/Pipeline.cpp` : `shadersDir()` au lieu de `SHADERS_OUTPUT_DIR`
direct
- `src/main.cpp` : flag `--demo`, `kDemoTerrainFile`/`kDemoTerrainFallback`,
`resolvedTerrainFile`, gardes `!demoMode` sur Needs/vélo/parapente/
escalade/abattage/ramassage/percussion, chemins via `assetsDir()`
- `NOTES-PHASE21.md` (ce fichier)
- `dist/VercoraDemo/` : package distribuable (non versionné — voir
`.gitignore` si un dépôt git existe un jour ; ce projet n'est actuellement
pas un dépôt git)
+389
Voir le fichier
@@ -0,0 +1,389 @@
# Phase 22 (2026-08-27) — trois matières récoltables, et la dette du vélo
Deux chantiers indépendants. Le second était la priorité annoncée : une dette
ouverte en **Phase 17** et rejouée à chaque phase depuis.
---
## Tâche 2 — la dette du vélo : le jeu n'a jamais eu de défaut
### Le symptôme, tel qu'il traînait depuis cinq phases
Le scénario E du harnais Vulkan finit par un « pied à terre » (touche `B`) qui
n'était **jamais** enregistré. `Wait-ForLog "Velo : pied a terre" 3000` rendait
`False`, run après run, et la suite complète ne pouvait donc pas être verte.
NOTES-PHASE17.md concluait à « une dérive du scénario E (ou du pilotage par
messages postés), pas du gameplay », sans aller plus loin.
### Ce qui a été mesuré, dans l'ordre
**1. Isoler le vélo lui-même.** Trois scripts de reproduction, hors du harnais,
qui rejouent les morceaux du scénario un par un sur la même dalle et le même
binaire :
| ce qui est rejoué | runs | résultat |
|---|---|---|
| enfourcher + 40 s de pédalage | 3 | 3/3 propres, 41 relevés, sortie 0 |
| idem + 14 rafales de demi-tour (S+D) | 3 | 3/3 propres, 51 relevés |
| élan + 32 s de descente + freinage + **pied à terre** | 3 | 3/3 propres, `pied a terre` **journalisé**, sortie 0 |
Le troisième est décisif : **la fin exacte du scénario E, jouée seule, marche
parfaitement**. Le cap de descente y est imposé par `--look=40,0` au lieu d'être
atteint par asservissement, ce qui supprime la seule partie du scénario qui
dépendait de la télémétrie.
**2. Lire le journal du JEU, et pas seulement celui du script.** Une copie
instrumentée du harnais qui déverse `$runE.Lines` dans un fichier. Verdict sans
appel : la ligne `[INFO] Velo : pied a terre.` **est là**, ligne 490 sur 520,
suivie de la « Fermeture propre. » habituelle et d'un code de sortie 0.
> Le jeu avait exécuté la descente de vélo correctement à chaque run depuis la
> Phase 17. Ce qui échouait, c'était l'instrument de mesure.
**3. Chronométrer le collecteur.** Un script qui reproduit **exactement** le
mécanisme de capture de `Start-Game` (`Register-ObjectEvent` +
`BeginOutputReadLine` + `StringBuilder`) et horodate l'apparition de chaque
ligne :
```
en selle : vu=True après 1 833 ms
pied a terre : vu=False après 3 090 ms (11 880 octets captés pendant l'attente)
pied a terre : vu=True après 9 600 ms au total
```
**4. Le témoin.** Le même script, le même jeu, le même instant de lecture — seul
le collecteur change, remplacé par un délégué .NET compilé :
| collecteur | « en selle » | « pied a terre » |
|---|---|---|
| `Register-ObjectEvent -Action` (le harnais) | 1 833 ms | **jamais vu en 3 s** (9,6 s réels) |
| délégué .NET compilé (témoin) | 5 ms | 0 ms |
### La vraie cause
Le harnais capturait la sortie du jeu avec **un script-block PowerShell exécuté
par ligne de journal**. Ces blocs ne tournent que quand le runspace est
disponible ; or les scénarios passent leur temps dans des `Start-Sleep` et des
boucles d'attente. Les événements s'empilent et le tampon que `Wait-ForLog`
interroge est **en retard** sur ce que le jeu a réellement écrit — **et le retard
croît avec la durée du scénario**.
Le scénario E est le plus long de la suite. Il était simplement le premier à
franchir le seuil : « en selle », mesuré à 1 833 ms, consommait déjà **61 % de
son budget de 3 s**. Le défaut menaçait tous les `Wait-ForLog` du harnais.
### Le correctif
`tools/run_vulkan_check.ps1` : le collecteur est désormais un délégué .NET
compilé (`VercoraLogSink`, `Add-Type`), qui se branche lui-même — PowerShell 5.1
ne sait pas convertir une `PSMethod` en `DataReceivedEventHandler`. `ToString()`
est surchargé, donc **aucun appelant n'a été touché** : `Wait-ForLog`,
`Get-BikeHeading`, `Wait-BikeSample`, `Stop-Game` et le scénario F appelaient
déjà tous `.ToString()` sur le `StringBuilder` d'avant.
**Aucune ligne du jeu n'a été modifiée pour cette tâche.**
### Le résultat, et une confirmation qui n'était pas cherchée
`pied a terre : True`. Et, indépendamment, le second demi-tour du vélo converge
maintenant **en 3 rafales au lieu de 9** : `Turn-BikeTo` s'asservit sur un cap
qui n'est plus périmé de plusieurs secondes. Même cause, deuxième preuve.
### Une fausse piste, notée parce qu'elle a coûté du temps
Le tout premier run de diagnostic a montré le jeu mourant à ~30 s avec un code
de sortie `-1`. Deux runs suivants ont duré 105 s et 280 s. C'était un
**artefact** : un processus `vercora.exe` d'une mesure précédente n'avait pas été
tué et les deux se disputaient le GPU. Une fois le parasite éliminé, le jeu a
tourné proprement dans tous les runs suivants (12 au total). **Leçon : vérifier
qu'aucun processus de jeu ne survit avant de conclure quoi que ce soit d'une
mesure de performance ou de stabilité.**
---
## Tâche 1 — argile, sable, résine, plantes à fibres
Les trois matières du document de cadrage qui manquaient. Toutes suivent le
modèle `Forest`/`Knapping` : **indépendantes de Vulkan, testables headless,
appuyées sur les vraies données LiDAR quand c'est pertinent**.
Elles arrivent toutes **par le sol**, comme l'éclat de percussion de la Phase 6 :
l'interaction dépose l'objet aux pieds du joueur, qui doit ensuite le ramasser
(`R`). Rien ne tombe directement dans l'inventaire — ce qui est produit doit
d'abord **exister quelque part**.
### 1. Argile et sable — `world/Deposits.hpp/.cpp`
**Le proxy géologique, et sa limite, à assumer sans détour.**
> Le LiDAR ne porte **aucune** information de nature de terrain : ni lithologie,
> ni granulométrie, ni carte des formations superficielles. Il donne une
> surface. Il est donc **strictement impossible**, à partir de ces données, de
> distinguer un vrai gisement d'argile d'un vrai gisement de sable, ou de l'un
> ou l'autre d'un banc de calcaire.
Ce qui est codé est un **proxy morphologique** : les gisements sont placés là où
ils seraient *plausibles*, pas là où ils sont. La règle, et son raisonnement :
* **un creux** — même critère de concavité que `WaterSource` (huit sondes de
pourtour), parce que c'est la seule forme d'un relief mesuré où quelque chose
peut s'accumuler au lieu d'être emporté ;
* **un versant au-dessus** (`minUpslope`, 3 m) — la matière doit *venir* de
quelque part. C'est ce critère, et non la concavité, qui écarte les replats de
crête : un creux de sommet est concave mais n'a rien au-dessus de lui ;
* **argile si un point d'eau détecté est à moins de 120 m, sable sinon** —
l'argile est la fraction la plus fine, elle ne se dépose que là où l'eau
stagne vraiment. Sans point d'eau connu, **tout est classé sable** : on
n'affirme rien sur l'argile qu'on ne puisse pas justifier.
Seuils plus permissifs que ceux de l'eau, et pour une raison : *l'eau doit
stagner pour qu'on y boive, un sédiment n'a qu'à s'être déposé*. Pente admise
22 % (contre 15 %), concavité 0,6 m (contre 1,0 m), 4 sondes montantes sur 8
(contre 5).
**Sur la dalle de référence** : 18 gisements, **2 d'argile et 16 de sable** — et
les deux argiles tombent exactement sur les deux points d'eau détectés par la
Phase 16, ce qui est la signature attendue du critère.
**Récolte** : touche `Y`, portée horizontale 3,5 m.
### 2. Résine de pin — `world/Resin.hpp/.cpp`
**La limite, en clair** : le jeu n'a **aucune** notion d'essence d'arbre. Un
arbre est une position, une hauteur, un yaw et un état ; son mesh est unique,
généré une fois et instancié N fois. La carte de canopée LiDAR donne une hauteur
et un taux de couvert, pas une classification feuillu/résineux.
Le choix retenu est donc un **marquage déterministe** : un hachage de l'indice de
l'arbre et d'une graine décide, une fois pour toutes, quels arbres sont des
résineux (55 %). Ce n'est pas une donnée, c'est une **convention** — mais une
convention stable, recalculée et jamais stockée, comme le semis de végétation.
> **Conséquence à assumer : un joueur ne peut pas *voir* quel arbre est un
> résineux avant d'essayer.** Tous les arbres ont le même mesh. Donner une
> silhouette distincte aux résineux est le prolongement naturel de ce fichier ;
> ce n'est **pas** fait dans cette phase, et c'est la principale dette qu'elle
> laisse.
**Ce qui diffère de l'abattage, et c'est tout le propos.** On vise le même arbre,
par le **même** `Forest::pickTree` et avec la même portée — mais rien n'est
abattu, rien n'est débité, et l'`Habitat` n'enregistre **aucune coupe**. L'arbre
reste `Standing`. En échange il ne redonne pas de résine avant 600 s, et il est
épuisé au bout de trois entailles. Touche `U`.
### 3. Plantes à fibres — `world/FiberPlants.hpp/.cpp`
Ronces et orties sont des plantes de **rudéralie**. Deux voies indépendantes,
combinées par un **maximum** (et non une somme : une coupe faite en pleine
lisière ne doit pas porter deux fois plus de ronces) :
1. **La lisière**, lue dans la carte de couvert LiDAR — ni la futaie fermée
(l'ombre les tue) ni l'alpage nu (rien ne les abrite), mais la bande de
transition. La densité suit un **toit triangulaire** sur la bande, maximale
en son milieu et nulle à ses deux bords : avec un créneau, un versant
clairsemé entier porterait des ronces partout, ce qui est une lande et non
une lisière. Les bornes encadrent volontairement `VegetationParams::coverMin`,
le seuil à partir duquel les arbres de décor apparaissent — les deux fichiers
parlent bien de la même frontière.
2. **Le sol récemment ouvert**, lu dans une nouvelle interface
`world/Clearing.hpp` (`ClearingSource`), implémentée par `Habitat` à partir de
son compteur de déforestation. **Une zone où le joueur a abattu des arbres se
met à porter des ronces.** C'est la cohérence que le cahier des charges
suggérait, et elle est exploitée parce qu'elle est *vraie* : la recolonisation
d'une coupe par les ronces est le fait le plus banal de la sylviculture
tempérée. Elle a en prime une vertu de jeu que rien d'autre dans le projet
n'avait : **c'est la première fois qu'une action du joueur FAIT APPARAÎTRE
quelque chose au lieu de le retirer.** La Phase 17 avait construit la boucle
« je coupe, le milieu s'appauvrit » ; celle-ci lui donne son revers.
**Pourquoi une deuxième interface plutôt que réutiliser `GroundCoverSource`.**
`groundCover` demande « reste-t-il du couvert ici ? » et sert à *raréfier*
l'herbe ; `clearing` demande « a-t-on ouvert ici ? » et sert à *faire pousser*
les ronces. Les deux se lisent aujourd'hui dans le même compteur, mais elles n'y
liront pas toujours la même chose : le jour où l'usure des sols par piétinement
dégradera le couvert, elle fera baisser `groundCover` sans ouvrir quoi que ce
soit — un sentier tassé ne fait pas pousser d'orties.
**Sans carte de couvert, la voie 1 est entièrement muette** — et c'est le
comportement voulu, pas un repli dégradé : sans carte, on ne sait pas où est la
lisière, et l'inventer par un substitut de pente donnerait des ronces sur des
critères qui n'ont rien à voir avec la lumière. Un témoin naturel, en prime : un
monde sans carte de couvert ne porte **que** les plantes que le joueur a fait
pousser.
Le semis est une **fonction déterministe de la cellule**, comme celui de
`Vegetation` : rien n'est stocké pour les 25 km². Seules les plantes **arrachées**
sont mémorisées, dans une table creuse, et seulement le temps de leur repousse
(420 s) — après quoi la même plante revient **à la même place et à la même
taille**, et sort de la mémoire. Touche `I`, portée 2,5 m.
### Les touches
Une rangée contiguë, dans l'ordre où on les apprend :
```
E abattre R ramasser T boire Y creuser U saigner I arracher
```
Ce n'est pas une coquetterie. La rangée du haut est `A-Z-E-R-T-Y-U-I-O-P` en
AZERTY et `Q-W-E-R-T-Y-U-I-O-P` en QWERTY : **tout ce qui suit le Z/W y occupe la
même position physique**. GLFW raisonnant en positions physiques, c'est ce qui
évite le piège qui avait fait croire pendant tout un run que le jeu ignorait `W`.
### Géométries — `world/HarvestMesh.hpp/.cpp`
Quatre meshes d'objets au sol (motte, tas, perle, fagot) et un mesh de plante sur
pied, **tous générés en code**, aucun fichier. Quatre silhouettes et non un mesh
recoloré, parce que la philosophie « zéro menu virtuel » fait reposer toute la
lisibilité sur la forme : le joueur n'a aucune liste à l'écran pour distinguer
deux objets gris posés côte à côte.
---
## Vérifications
### Tests headless — `tests/logic_tests.cpp`
**1 095 vérifications passent** (935 avant cette phase, soit **+160**), et toutes
les anciennes continuent de passer : `Forest`, `Knapping`, `Habitat`/empreinte,
`Bike`, `Climber`, éditeur, besoins, faune.
Témoins négatifs, comme partout ailleurs dans ce projet :
* terrain plat, bosse **convexe partout**, versant à 40 % → aucun gisement ;
* cuvette dont le relief total est plafonné à 2 m → rejetée par `minUpslope`
seul, et **retenue dès que ce seuil est abaissé** : c'est ce qui prouve que
c'est bien ce critère-là qui avait décidé ;
* sans point d'eau → tout est du sable ; avec un point d'eau au fond → le même
balayage rend les mêmes creux, seule leur **nature** change ;
* part de résineux nulle / pleine → aucun / tous ; graine différente → marquage
réellement différent ; un refus de récolte ne mémorise **rien** ;
* alpage nu et futaie fermée → aucune plante ; sans carte de couvert et sans
coupe → aucune plante ; paroi et altitude au-dessus de la limite des arbres →
aucune plante, alors que la même configuration 50 m plus bas en produit.
**Trois tests ont dû être corrigés parce qu'ils avaient tort, pas le code** — et
c'est la mesure qui l'a montré :
* le **pied d'une bosse** était écrit comme un contrôle négatif. Mesure : deux
gisements à 160 m du centre, 8,1 m de concavité, 26,8 m de versant au-dessus.
C'est la définition même d'un cône de déjection, l'endroit le plus crédible de
tout un relief pour trouver du sédiment. Le test est devenu un contrôle
**positif**, avec ses assertions.
* le témoin de `minUpslope` plafonnait la cuvette à 40 m : le détecteur retenait
alors trois points sur un anneau à 60 m du centre, où le flanc fournit 5,5 m
d'amont. *Une cuvette n'est « sans amont » qu'à son centre, pas partout.*
* l'assertion de demi-hauteur exigeait l'égalité sur des meshes **bruités** : elle
testait le tirage aléatoire, pas le contrat. Remplacée par un encadrement.
Un test **existant** a par ailleurs fait son travail : il a signalé que les
quatre nouvelles natures d'objet manquaient dans la table mesh-par-nature. Ces
`switch` ont un `return` par défaut, donc le compilateur, lui, n'aurait rien dit.
Deux défauts réels de géométrie ont été trouvés et corrigés par les tests : la
plante sur pied s'enfonçait d'un centimètre sous le sol (décalage de section
oublié, puis surcorrigé — elle flottait alors d'autant).
### Coût mesuré du semis de plantes à fibres
Chronométré au même titre que l'herbe et les arbres, parce qu'un poste de semis
non mesuré est exactement celui qu'on finit par optimiser à tort
(cf. NOTES-PHASE19.md). Sur la zone de 25 km², 10 486 images :
| poste | µs / image |
|---|---|
| arbres (`gatherTrees`) | 1 278,3 |
| `drawFrame` | 838,5 |
| herbe (`gatherGrass`) | 828,2 |
| **plantes à fibres (`gather`)** | **185,9** |
| streaming terrain | 63,2 |
| tronc de vision | 4,0 |
Le poste le moins cher des trois semis, d'un facteur quatre. Aucune optimisation
n'est justifiée à ce niveau, et le frame reste de toute façon limité par le GPU.
### Harnais Vulkan — `tools/run_vulkan_check.ps1`
**Dix scénarios (A à J), quatorze processus.** Zéro `[Validation]`, zéro
`[ERROR]`, codes de sortie tous nuls, fermeture propre partout.
**Scénario J ajouté, en trois processus.**
*Les gisements.* Le point de départ n'est **pas** choisi à la main — le script
relit les gisements que *le jeu* a journalisés au chargement, s'y rend par
`--start`, creuse, ramasse la motte, puis s'éloigne de 30 m et recreuse. Le refus
à distance est le contrôle négatif : sans lui, on ne distinguerait pas « la
portée marche » de « la touche produit toujours quelque chose ».
*Les plantes à fibres*, sur la **zone de 25 km²** — il a fallu changer de dalle,
et c'est le point intéressant. La dalle de référence du harnais n'a pas de carte
de couvert produite ; la voie « lisière » y est donc muette, et un scénario qui
s'y serait tenu aurait constaté un zéro **parfaitement correct** en le prenant
pour une couverture de test. Le point de départ a été trouvé **par mesure**, avec
la fonction de semis elle-même : balayage de la zone entière au pas de 50 m, à la
recherche des cellules de densité maximale portant des plantes à portée
d'arrachage. Il y en a **1 656** ; la meilleure est monde (1 450, −1 750),
altitude 1 777 m, couvert **0,240** — le milieu exact de la bande de lisière.
> Le point de départ *par défaut* de la zone est à **1 947 m**, au-dessus de
> `maxAltitude` (1 900 m). Mesuré : zéro plante, zéro touffe d'herbe. Le refus y
> est le comportement voulu — et un scénario posé là aurait été vert sans rien
> exercer. C'est exactement le piège que la mesure a évité.
Le scénario vérifie la chaîne entière : **295 plantes semées** par la lisière,
arrachage (`I`), le compte tombe à **294** et la plante passe **en repousse et
non disparue** — c'est ce qui distingue un semis déterministe d'un semis qu'on
aurait amputé —, puis ramassage du fagot (`R`). Les sept conditions comptent dans
le verdict. J3 est ignoré sans faire échouer le script si la zone n'est pas
produite, comme C à I le sont pour la dalle.
### Un critère du harnais qui se contredisait (scénario I, faune)
La suite complète est passée rouge **une fois** sur le scénario I : « animaux à
portée de vue » finissait à **2** là où le seuil n'en tolérait qu'**1**. Vérifié
avant de toucher quoi que ce soit — une régression serait reproductible :
| scénario I, **même binaire** | dernier relevé |
|---|---|
| en suite complète | 2 |
| en isolation, 3 fois | 1, 1, 1 |
C'est donc du bruit lié à la **charge de la machine** : le scénario compte des
relevés sur 240 s, et le nombre de tentatives d'apparition suit le débit
d'images. Ce n'est pas neuf — NOTES-PHASE18.md le consignait déjà : « rouge au
premier passage, vert au rejeu isolé ET au passage final […] c'est du bruit, pas
une régression. Le harnais gagnerait à rendre E et I insensibles au débit
d'images ».
Surtout, **le critère contredisait sa propre documentation** : le commentaire qui
le précède affirme depuis la Phase 17 qu'un résidu « d'un ou **deux** animaux à
la limite du rayon est le comportement CORRECT du modèle » — la pondération du
bruit vaut `1 - (d/r)²` et tend vers zéro au bord —, et le seuil, lui, n'en
tolérait qu'un.
Le plancher passe donc de 1 à 2. **Ce n'est pas un assouplissement de confort
pour rendre le run vert** : c'est la mise en accord du seuil avec le modèle qu'il
vérifie, mesure à l'appui, et l'assertion continue d'exiger que le voisinage
parte de ≥ 3 et finisse à 2 au plus (au tiers du départ dès qu'il dépasse 6). La
vraie correction — rendre le critère insensible au FPS — reste à faire.
---
## Ce qui n'est pas fait
* **Aucun usage fonctionnel.** Les quatre matières se récoltent et se ramassent ;
rien ne se fabrique encore avec. C'était le périmètre demandé.
* **Les résineux n'ont pas de silhouette propre.** La dette principale de la
tâche 1 (voir plus haut).
* **La résine n'est pas exercée sous Vulkan.** Elle demande de *viser* un arbre,
or le harnais ne sait pas tourner la caméra et l'unique position de tir connue
de la dalle de référence est déjà consommée par le scénario C. Elle est
couverte par les tests headless, avec ses témoins. *(Les plantes à fibres, elles,
le sont désormais — voir le scénario J3.)*
* **Rien n'est sauvegardé** : les entailles faites aux arbres et les plantes
arrachées meurent avec le processus, comme la mémoire du milieu depuis la
Phase 17.
* **Une seule espèce de plante à fibres.** Rien ne distingue une ronce d'une
ortie : le mesh est unique, seule l'échelle varie.
+701
Voir le fichier
@@ -0,0 +1,701 @@
# NOTES-PHASE23.md — Systeme meteo deterministe
Session du 2026-08-27. Suite de la Phase 22.
---
## 0. Avertissement, a lire avant tout le reste
**Aucune des valeurs numeriques de ce systeme n'a ete validee par un
climatologue.** Ce sont des ordres de grandeur plausibles, choisis pour que le
systeme produise un comportement lisible en jeu.
Le code separe donc strictement deux choses :
- **L'architecture et les mecanismes** — implementes serieusement, testes, et
independants des chiffres. Comment un gradient altitudinal, un sondage amont,
une inversion de fond de cuvette ou un renforcement orographique se calculent
ne changera pas apres relecture scientifique.
- **Les valeurs numeriques** — toutes regroupees dans **une seule struct**,
`WeatherParams` (`src/world/Weather.hpp`), chacune commentee avec ce qu'elle
fait, sa valeur provisoire et d'ou elle sort. Les recalibrer se fait en
ouvrant un seul fichier et en changant des nombres, sans toucher a une ligne
de logique.
Deux exceptions, qui ne sont **pas** provisoires et sont sourcables :
| Grandeur | Source |
|---|---|
| Refroidissement eolien | Formule JAG/TI, employee par Environnement Canada et le NWS depuis 2001 |
| Declinaison solaire | Formule de Cooper (1969) |
Une troisieme est un fait et non un reglage : la latitude, 45,0 degres, parce
que la dalle LiDAR chargee est en Isere (Le Gua).
Les tests headless verifient en consequence des **proprietes** ("un adret est
plus chaud qu'un ubac au meme instant", "un col vente plus qu'un plateau
adjacent") et **jamais des valeurs absolues**. Un test qui exigerait
"l'inversion vaut -6 degres" devrait etre reecrit le jour du recalibrage et ne
dirait rien de plus que "la constante vaut ce qu'elle vaut".
### Ce qui demande une vraie validation climatique externe
Par ordre decroissant de doute :
1. **`precipitationCloudThreshold` (0,72)** — c'est ce seuil qui fixe la
frequence des precipitations, et il est le plus arbitraire du fichier. Il
donne aujourd'hui 61 heures de pluie et 63 heures de grand beau sur trente
jours de jeu simules, ce qui *semble* raisonnable pour un printemps de
moyenne montagne, mais rien ne l'appuie.
2. **`frontNoiseGain` (2,2)** — ce parametre n'existe que pour une raison
technique (voir §4), mais il pilote de fait l'amplitude de tout le
calendrier meteo. Il faut le recalibrer avec le seuil ci-dessus, pas
separement.
3. **`frontPeriodDays` (3,5)** — la duree d'un cycle de degradation.
4. **`inversionMaxC` (-6)** et **`inversionMixingWindMps` (4)** — le signe et
l'ordre de grandeur sont surs, le chiffre exact non. Une inversion reelle en
moyenne montagne va de 5 a 10 degres.
5. **`exposureWindGain` (0,80)** et **`venturiWindGain` (0,70)** — l'ordre de
grandeur de l'acceleration au-dessus d'une crete (1,5 a 2) est documente ;
la valeur pour un col ne l'est pas, et elle depend enormement de la geometrie
du col, que le modele ne mesure que grossierement.
6. **`lapseRateCPerKm` (6,5)** — la moins douteuse (c'est le gradient
adiabatique standard), mais un gradient reel varie de 4 (air humide) a 9,8
(air sec) et le modele n'en tient pas compte.
7. **Toutes les distances de sondage** (250 / 750 / 2000 / 100 / 400 m) — elles
viennent de la recherche preparatoire, elles n'ont ete verifiees par rien.
---
## 1. Ce qui a ete fait
Les quatre priorites du cahier des charges sont faites, dans l'ordre demande.
| # | Priorite | Etat |
|---|---|---|
| 1 | Module synoptique + temperature locale, remplacant celle de Needs | **fait** |
| 2 | Cycle jour/nuit visuel | **fait** |
| 3 | Vent / sondage amont | **fait** |
| 4 | Effets sur les quatre activites | **fait** |
Fichiers neufs : `src/world/Weather.hpp` (≈ 700 lignes, dont la majorite est de
la documentation de constantes) et `src/world/Weather.cpp`.
---
## 2. Architecture
### Une fonction d'etat pure
Le module n'a **aucun etat cache** et **aucune integration dependante du pas de
temps**. Pour un point `(x, y, z)` et un instant `t`, `sampleAt()` rend l'etat
meteo exact.
Consequence de jeu : deux joueurs qui arrivent au meme endroit au meme instant
vivent exactement les memes conditions, quel que soit le chemin parcouru, la
duree du trajet, le nombre d'images par seconde ou le nombre de pauses.
Consequence de test : un test peut sauter directement a `t = 137 h` sans simuler
les 137 heures. C'est ce qui rend la couverture de cette phase possible.
Contraste explicite avec `Needs` (Phase 16), qui **integre** dans le temps :
les quatre jauges ont une memoire, c'est leur role. Rien n'a change de ce
cote — sauf d'ou vient la temperature ambiante.
### Deux couches
**Couche 1, synoptique (0D)** — `WeatherSystem::synopticAt(gameHours)` →
`SynopticState`. L'etat macro du massif : saison (deux harmoniques), cycle
diurne (deux harmoniques, attenuees par les nuages), perturbations (bruit de
gradient 1D en fonction du temps), position solaire, vent de reference,
nebulosite, precipitation. Ne connait **aucune position**.
**Couche 2, spatialisation (3D)** — `WeatherSystem::sampleAt(position, sky,
terrain)` → `WeatherSample`. La reponse du terrain a cet etat macro : gradient
altitudinal, adret/ubac par produit scalaire, inversion de fond de cuvette, vent
local par sondage amont, ridge lift, subsidence et turbulence de sillage,
thermiques, renforcement orographique, mouillure du sol.
La surcharge `sampleAt(position, SynopticState, terrain)` existe pour
echantillonner plusieurs points au meme instant sans recalculer la couche 1 —
elle est 10 fois moins chere que la couche 2 (mesure : 0,38 µs contre 4,0 µs).
### Le seed
**Fixe par defaut** (`WeatherSystem::kDefaultSeed`), et derivable d'une graine de
partie par le constructeur. Le choix du seed fixe est delibere :
- La zone de jeu est unique et fabriquee a la main (une dalle LiDAR reelle),
pas generee par partie. Rien d'autre dans Vercora n'est reseede par partie :
le semis de vegetation et celui de la faune sont deterministes a graine fixe
depuis la Phase 11.
- Un seed fixe rend une capture d'ecran comparable a la precedente, ce qui est
la condition meme de la verification visuelle du projet (lecon de la Phase 12
sur `--look`).
- Le jour ou les parties multiples existeront, passer la graine au constructeur
suffit, sans rien changer d'autre.
---
## 3. Une seule source de verite sur la temperature
C'etait la contrainte la plus explicite du cahier des charges, et elle a
demande de **deplacer du code plutot que d'en ajouter**.
### Ce qui a quitte `Needs`
| Parti de `Needs` | Arrive dans `Weather` |
|---|---|
| `NeedsParams::seaLevelMeanTemperatureC` | `WeatherParams::seaLevelAnnualMeanC` (+ saison explicite) |
| `NeedsParams::lapseRateCPerKm` | `WeatherParams::lapseRateCPerKm` |
| `NeedsParams::diurnalAmplitudeC` | `WeatherParams::diurnalAmplitudeC` |
| `NeedsParams::diurnalPeakHour` | `WeatherParams::diurnalPeakHour` |
| `NeedsParams::exposureBonusC` | `WeatherParams::aspectBonusC` |
| `NeedsParams::paraglideWindChillC` | **supprime**, remplace par `windChillC()` (JAG/TI) |
| `ambientTemperature()` | `WeatherSystem::sampleAt().temperatureC` |
| `daylightFactor()` | `SynopticState::daylight` (vraie position solaire) |
| `terrainExposure()`, `kFullExposureSlope` | inchanges, simplement demenages |
`NeedsContext` porte desormais `ambientTemperatureC` et `windSpeedMps` a la
place de `altitudeMeters` / `timeOfDayHours` / `exposure`. **Needs ne calcule
plus aucune temperature ambiante** — il en recoit une et n'y ajoute que ce qui
concerne le corps du joueur : effort, fatigue, abri, vent subi.
Ce n'est pas de la cosmetique. Tant que les deux calculs coexistaient, rien
n'empechait qu'un reglage n'en corrige qu'un.
### Ce qui n'est pas un simple renommage
`ambientTemperature()` de la Phase 16 ne connaissait que l'altitude, l'heure et
une exposition nord/sud. Sa remplacante connait en plus la **saison**, la **masse
d'air** (perturbation en cours), la **nebulosite** (qui ecrase l'amplitude
diurne — c'est ce qui fait qu'une nuit couverte est douce et une nuit claire
glaciale) et l'**inversion de fond de cuvette**.
`daylightFactor()` etait une demi-sinusoide fixe de 6 h a 18 h. Sa remplacante
est le sinus de l'elevation solaire reelle, calculee depuis la latitude et la
declinaison du jour : les journees s'allongent et se raccourcissent avec la
saison.
### L'adret/ubac calcule par produit scalaire
Le cahier des charges demandait un produit scalaire entre la normale du terrain
et la direction du soleil. C'est ce qui est fait, mais avec une precision qui
compte : on compare le cosinus d'incidence du point a **celui qu'aurait du
terrain plat au meme instant**, et on convertit l'ecart en degres via
`aspectIncidenceReference`.
Le comportement qui en decoule est meilleur que celui de la Phase 16, et il
sort tout seul de la geometrie :
- **A midi**, un versant sud ne gagne presque rien (il est deja a peu pres
perpendiculaire au rayonnement) alors qu'un versant nord perd beaucoup.
- **Au petit matin**, c'est un versant **est** qui recoit le maximum — un modele
purement nord/sud ne pouvait pas le produire, et c'est verifie par un test.
Mesure a midi, 1000 m, sur pente de 60 % : adret 14,7 °C, ubac 10,7 °C, soit
4,0 °C d'ecart.
---
## 4. Ce que les tests ont corrige
Quatre choses ont ete **fausses puis corrigees parce qu'un test les a montrees**.
Elles sont notees ici parce que ce sont les seules parties du travail dont on
sait qu'elles ne sont pas seulement plausibles.
### (a) Le bruit n'atteignait jamais ses extremes
Un fBm de bruit de gradient n'atteint pas ses bornes theoriques. Sans gain, la
nebulosite mesuree sur trente jours restait entre 0,20 et 0,70 : **jamais de
grand beau** (donc jamais de nuit claire, donc jamais d'inversion) et presque
jamais de vraie pluie — 13 heures sur 720.
Corrige par `frontNoiseGain` (2,2) suivi d'un ecretage. Le test qui l'a montre
demande qu'un mois de jeu contienne des journees claires **et** des journees de
pluie ; c'est le controle negatif d'un modele qui aurait l'air de fonctionner
tout en etant constant. Apres correction : 61 h de pluie, 63 h de grand beau.
### (b) Un versant sud plus chaud a deux heures du matin
L'ecart d'incidence continuait de se calculer avec un soleil **sous l'horizon**,
ou il n'a aucun sens. Resultat mesure : +2,9 °C pour un adret a 2 h du matin.
Corrige par `aspectFullDaylightSin` (0,25), qui eteint l'effet quand le soleil
est bas — ce qui est aussi le comportement reel, un rayonnement rasant chauffe
peu quelle que soit l'orientation. Le test est un controle negatif : la nuit,
adret et ubac doivent etre a moins de 0,001 °C l'un de l'autre.
### (c) La moyenne des sondages amont effacait l'abri
La premiere version faisait une moyenne ponderee des trois altitudes amont. Un
point situe 250 m sous le vent d'une crete de 200 m — un abri franc — obtenait
un signal d'exposition de **-0,05** : la crete etait bien vue par la sonde
proche, mais la plaine des sondes a 750 m et 2000 m ramenait la moyenne au
niveau du point, et l'abri disparaissait dans l'arithmetique.
La regle correcte tient en une phrase : **etre abrite, c'est avoir du relief
au-dessus de soi dans au moins une des echelles amont ; etre expose, c'est
dominer toutes les echelles a la fois.** D'ou un `max` d'un cote et un `min` de
l'autre, jamais une moyenne.
### (d) La turbulence de sillage se mesurait sur le mauvais vent
Elle etait calculee a partir du vent **local**, qui est justement faible sous le
vent (c'est ce que le facteur d'abri vient de calculer). Un sillage etait donc
d'autant plus calme qu'il etait plus abrite — l'inverse exact de la realite. Ce
qui agite l'air d'un sillage est le flux qui vient de decoller de la crete,
lequel a la vitesse **amont**. Corrige : la turbulence et la subsidence se
mesurent sur le vent de reference.
### Et une correction cote test, pas cote code
Le test d'inversion employait d'abord une cuvette de 400 m de profondeur pour
500 m de rayon. Il echouait — mais pas parce que le modele avait tort : a 400 m
de denivele, le seul gradient adiabatique rend le fond 2,6 °C **plus chaud** que
le rebord, et l'inversion, correctement calculee, ne suffisait pas tout a fait a
renverser ce handicap. Le relief etait invraisemblable : une cuvette de 400 m de
creux pour 500 m de rayon est une falaise circulaire, pas une combe. Ramene a
150 m, le test passe largement.
C'est la troisieme fois dans ce projet que l'hypothese "le test a tort" se
verifie (voir MEMORY.md). Elle merite d'etre instruite aussi serieusement que
l'inverse — et aussi serieusement rejetee quand elle est fausse, ce qui a ete le
cas pour les quatre defauts ci-dessus.
---
## 5. Le sondage amont
C'est la technique centrale de la couche 2. Au lieu de simuler l'ecoulement, on
**demande au relief ce qu'il fait au vent**, en lisant la heightmap a quelques
distances autour du point.
**Sept appels a `heightAt()` par evaluation** : le point, trois en amont (250 /
750 / 2000 m), un en aval (100 m), deux lateraux (± 400 m perpendiculairement au
flux). C'est le budget d'une seule lecture de pente du velo.
Ce qui en est tire :
- **Exposition / abri** — `min`/`max` sur les trois echelles amont (voir §4c).
Un point qui domine tout son amont vente jusqu'a 1,8 fois le vent libre ; un
point abrite n'en garde que 25 %.
- **Venturi** — les deux sondes laterales. Si les deux epaules dominent le
point, le flux passe par un entonnoir et accelere.
**Une ponderation existe et elle n'est pas cosmetique** : un fond de vallee a
lui aussi ses deux cotes plus hauts, exactement comme un col. La seule chose
qui les distingue est le rapport a l'amont — un col domine son amont (le vent
le franchit), un fond de vallee non (le vent passe au-dessus). Sans ce poids,
chaque fond de vallee de la zone de jeu deviendrait une soufflerie.
- **Ridge lift** — la pente dans le sens du flux, sur l'echelle proche. L'air
qui monte une pente `s` a la vitesse `U` monte a `s·U`, moins un rendement.
- **Subsidence et turbulence de sillage** — pilotees par l'abri et par le vent
amont.
- **Renforcement orographique** — la meme pente dans le sens du flux : un
versant que le flux doit gravir souleve la masse d'air, donc il pleut plus.
Mesures sur le relief de test (crete nord-sud de 400 m avec un col, vent
d'ouest) :
| Point | Vent | Facteur de relief |
|---|---|---|
| Col | 14,2 m/s | × 2,01 |
| Crete pleine | — | × 1,80 |
| Plateau au vent | 6,4 m/s | × 1,00 |
| Versant au vent | ridge lift **+4,99 m/s**, turbulence 0,00 | |
| Versant sous le vent | subsidence **-1,80 m/s**, turbulence 0,60 | |
Le col vente 2,2 fois plus que le plateau adjacent, et **plus que la crete
pleine a vent de reference egal** — c'est-a-dire que l'effet d'entonnoir est
bien distingue de l'effet d'altitude.
---
## 6. La carte de piegeage d'air froid
Precalculee **une fois au chargement**, jamais par image — c'est l'exigence de
cout du cahier des charges.
**Ce qu'elle mesure** : a quel point un point est un *creux enferme*. Autour de
chaque cellule on sonde huit directions a trois rayons (120 / 350 / 900 m), et
on regarde combien de ces 24 sondes sont plus hautes que la cellule, et de
combien.
**Pourquoi pas simplement "l'altitude est basse"** : un versant a mi-hauteur et
un fond de vallee peuvent etre a la meme altitude, et seul le second piege l'air
froid. C'est l'**enfermement** qui compte, pas l'altitude — la meme lecon que la
Phase 22 sur le relief (savoir ou il y a de la pente ne dit pas par ou
l'aborder).
Resolution **128 × 128 sur les 5 km** de la zone de jeu, soit des cellules de
39 m : la bonne echelle pour une cuvette (une cuvette de 39 m n'en est pas une).
Cout : 393 216 lectures de heightmap, payees une seule fois au chargement.
Lecture au runtime : une interpolation bilineaire.
Le controle negatif est celui qu'employait deja la Phase 16 pour les points
d'eau : une **bosse** de geometrie identique doit obtenir un index quasi nul.
Mesure : creux 0,65, plateau 0,00, bosse 0,00.
L'inversion elle-meme exige **trois conditions simultanees**, et le produit des
trois les exprime directement : un creux ferme, la nuit, un ciel clair et calme.
Le test verifie qu'elle **renverse le signe du gradient** — le fond, pourtant
150 m plus bas, doit etre plus froid que le plateau. Mesure : fond 2,1 °C,
plateau 3,6 °C.
Sans carte reliee (aucun terrain charge), l'inversion vaut zero partout et le
reste du systeme fonctionne. C'est un repli explicite, teste, pas une panne.
---
## 7. Le cycle jour/nuit visuel
**C'est la correction de l'incoherence assumee en Phase 16.** Le commentaire de
`GameClock` disait : *"cette horloge n'existe QUE pour la temperature, et rien
dans le rendu ne change avec elle"*. Ce n'est plus vrai.
La lumiere directionnelle existante (Blinn-Phong, Phase 2) est desormais
alimentee par la **meme position solaire** que l'adret/ubac et les thermiques.
Il n'y a donc toujours qu'**un seul soleil** dans le jeu — c'est la meme
exigence que pour la temperature, appliquee a la lumiere, et un test la verifie
explicitement (`dot(light.direction, sky.sunDirection) == 1`).
Chemin : `SynopticState` → `sunLightFor()` → `Renderer::setSun()` →
`UniformBufferObject::sun` / `sunColor` → les trois shaders de fragment.
Ce qui a change dans les shaders : `kLightDirection` et `kLightColor`, qui
etaient des constantes en dur dans `cube.frag`, `foliage.frag` et
`terrain.frag`, viennent de l'UBO.
**Deux details qui evitent des regressions :**
- `sunColor.a` est un **multiplicateur** de l'ambiante, pas une valeur absolue.
Les trois shaders ont des ambiantes differentes et justifiees (0,15 pour le
cube, 0,18 pour le terrain, 0,24 pour le feuillage, qui laisse passer la
lumiere). Les remplacer par une valeur unique aurait ete une regression de
rendu deguisee en correction de cycle.
- Les valeurs **par defaut** de l'UBO et de `Renderer` reproduisent exactement
l'ancien eclairage. Un rendu qui n'appellerait pas `setSun()` est pixel pour
pixel celui de la Phase 22.
**Le ciel suit aussi, et il a fallu une capture pour s'en apercevoir.** La
premiere version ne touchait qu'a la lumiere. Le relief s'assombrissait
correctement, mais la couleur d'effacement restait le bleu vif de midi : la
capture de 3 h du matin montrait la silhouette *noire* des sapins sur un ciel de
plein jour. La lumiere etait juste, l'image ne l'etait pas.
`SunLight` porte donc aussi une `skyColor`, avec sa propre palette (jour /
crepuscule / nuit) parce que le ciel n'est pas eclaire par le modele
d'eclairage — c'est un fond. Le crepuscule occupe la premiere moitie de la montee
du soleil, ce qui fait durer l'aube et le coucher au lieu d'un fondu direct du
noir au bleu.
**C'est le seul defaut de cette phase qu'aucun test headless ne pouvait
trouver** : il n'existait que dans l'image.
Quand le soleil passe sous l'horizon, la direction **bascule a la verticale** :
une lumiere directionnelle venue d'en dessous eclairerait le relief par le bas,
qui est le defaut visuel classique d'un cycle jour/nuit bacle. Un test verifie
`direction.y >= 0` a toutes les heures.
**`nightAmbientFactor = 0,30` est un choix de jouabilite assume, pas une
mesure.** Une vraie nuit sans lune est noire ; un jeu d'exploration ou l'on ne
voit rien pendant la moitie du temps de jeu n'est pas jouable en l'etat, aucune
source de lumiere portable n'existant encore. A revoir le jour ou le feu de camp
arrivera.
L'aube et le crepuscule durent : 20 intervalles de 5 minutes en lumiere
partielle sur 24 heures.
---
## 8. Les effets sur les quatre activites
Tous branches sur les systemes existants. **Aucun nouveau systeme parallele.**
Chaque nouveau parametre a une valeur par defaut neutre, et un test de
non-regression verifie que l'omettre reproduit **exactement** — comparaison
bit a bit sur les positions — le comportement d'avant la Phase 23.
### Needs (temperature) — priorite 1
Voir §3. Le refroidissement eolien remplace le forfait de -6 °C que la Phase 16
reservait au vol : c'est desormais la formule JAG/TI appliquee au vent reel,
auquel l'appelant ajoute la vitesse propre du joueur (vitesse de l'aile en vol,
vitesse du velo a velo). La **marche en crete par vent fort** refroidit donc
elle aussi, ce qu'un forfait reserve au vol ne pouvait pas exprimer.
Hors du domaine de validite publie (T > 10 °C ou vent < 4,8 km/h), la fonction
rend la temperature **inchangee** plutot qu'une extrapolation : au-dessus de
10 °C la formule brute rendrait un vent *rechauffant*. C'est le point le plus
facile a rater dans une implementation pressee, et un test le couvre.
Un abri annule le refroidissement eolien — c'est la definition d'un abri.
### Paraglider — priorite 4
Nouvelle struct `AirState` (vent, vitesse verticale, turbulence), volontairement
**nue** et non un `WeatherSample` : `Paraglider` ne doit pas plus dependre du
systeme meteo qu'il ne depend de Vulkan. Meme separation que `HeightSampler`.
- **Derive** — `speed_` est une vitesse **air** ; la vitesse sol est cette
vitesse plus le vent. C'est l'ajout le plus lisible en jeu, et il ne demande
aucune regle particuliere. Mesure sur 30 s avec 6 m/s de vent : 495 m vent
arriere, 315 m en air calme, 135 m vent de face.
- **Ascendances** — le taux de chute de l'aile plus le mouvement de l'air. Dans
une thermique plus forte que le taux de chute, la somme est positive et l'aile
**monte** : la definition du vol thermique sort de l'addition. Mesure sur
30 s : 1462 m en air calme, 1553 m dans 3 m/s d'ascendance.
- **Turbulence** — deux sinusoides de periodes **incommensurables**, pas un
tirage aleatoire. Le vol reste deterministe (donc rejouable et testable, la
regle de toute la phase), et deux periodes sans rapport simple ne se
resynchronisent jamais, donc le chahut ne degenere pas en balancement
regulier — ce qui est ce qui trahit immediatement une turbulence fabriquee.
Le modele ne represente **ni fermeture ni decrochage** : une aile chahutee
perd du cap et de la finesse, elle ne tombe pas.
### Climber — priorite 4
`update()` prend une **adherence** dans `[0, 1]`, tiree de l'humidite locale par
`Climber::gripForWetness()` — expose comme methode de la classe pour qu'il n'y
ait qu'une seule traduction humidite → adherence dans le jeu.
L'effet porte sur la physique existante et il est **double**, ce qui compte :
- la **vitesse** de progression (ascension et traversee) est multipliee par
l'adherence ;
- le **cout energetique par metre** monte jusqu'a × 1,8.
Le second terme n'est pas un bonus : sans lui, un modele qui ne ferait que
ralentir laisserait la jauge dire le contraire — moins de metres parcourus, donc
moins d'energie depensee, donc une paroi mouillee *moins* fatigante. Mesure sur
20 s : sec 19,3 m a 0,018 de jauge/m, mouille 8,9 m a **0,032** de jauge/m.
Un plancher d'adherence a 0,05 garantit qu'une paroi ruisselante reste
**grimpable**, tres lentement et tres chere, plutot que de devenir une impasse
ou le joueur resterait bloque sans pouvoir ni monter ni redescendre.
### Bike — priorite 4
Fait, dans une version deliberement minimale : une seule grandeur (l'humidite du
sol) et deux coefficients, branches sur des termes qui existent deja dans
l'equation du mouvement, **sans ajouter le moindre etat**.
- resistance au roulement + 45 % sur sol detrempe ;
- freinage - 30 %.
Mesures : vitesse d'equilibre a plat 16,9 km/h sur sec contre 15,9 km/h sur
trempe ; une demi-seconde de frein enleve 11,7 km/h sur sec contre 8,8 km/h sur
trempe.
**Ce qu'il ne fait pas**, et c'est note comme amelioration future : aucune nature
de sol (terre, roche, herbe — le LiDAR n'en porte aucune, limite deja etablie en
Phase 22 pour les gisements), aucune boue qui se formerait et secherait par
endroits, et **aucune perte d'adherence en virage** — le terme lateral n'est pas
touche, parce que le rayon de braquage est un equilibre deja verifie par les
tests de la Phase 13 et qu'y toucher sans mesure serait un pari.
---
## 9. La mouillure du sol : relue, pas accumulee
Le seul endroit ou le systeme pourrait sembler avoir une memoire. Il n'en a pas :
`groundWetness()` **remonte le temps dans la fonction synoptique** — qui est
pure — au lieu d'accumuler image par image.
Huit echantillons sur les six dernieres heures de jeu, chacun decru
exponentiellement, et on garde le plus mouille. C'est le seul endroit ou
l'evaluation meteo depasse la dizaine d'operations, d'ou les huit echantillons
et pas cinquante.
La propriete que ca garantit est testee : un joueur qui arrive au meme endroit au
meme instant trouve la meme mouillure, qu'il ait mis dix minutes ou deux heures
a venir.
---
## 10. Cout
Mesure sur cette machine (i5-14600K, Debug, terrain analytique) :
| | Cout |
|---|---|
| Evaluation complete (couche 1 + couche 2, 7 sondages, mouillure) | **4,0 µs** |
| Couche synoptique seule | **0,38 µs** |
| Carte de piegeage, 128 × 128 | 393 216 `heightAt()`, **une fois au chargement** |
Le jeu fait **une** evaluation complete par image, au point du joueur. A 60 FPS
cela represente 0,024 % d'une image de 16,7 ms.
Le repere de la Phase 19 est que le frame est **domine par le GPU** — 81 % dans
`drawFrame` en Release, et aucune optimisation CPU ne rend rien. La meteo ne
change pas ce constat et n'avait aucune chance de le faire.
Le test de cout porte un seuil **tres large** (50 µs) et volontairement : il
protege contre un facteur mille — un sondage qui deviendrait une recherche, une
carte recalculee par image — et non contre une variation de 20 %, que le bruit de
mesure de cette machine ne permet de toute facon pas de distinguer (lecon de la
Phase 17 sur les FPS bruites).
---
## 11. Verification
### Tests headless
`tools\run_logic_tests.bat` — **3578 assertions**, toutes passantes. Deux
sections neuves :
- `testWeather()` — determinisme (purete bit a bit, independance du chemin via
deux horloges a pas differents, et le controle negatif qu'un temps constant
echouerait), cycles et position solaire, saison, variete des perturbations sur
30 jours simules, gradient altitudinal, adret/ubac (dont le controle negatif
de nuit et le versant est du matin), carte de piegeage et inversion (dont le
controle negatif de la bosse et celui du plein jour), sondage amont (col
contre plateau, col contre crete pleine a vent de reference egal, versant au
vent contre versant sous le vent, controle negatif en air calme, ecretage sur
15 jours), thermiques (dont ciel couvert et ubac), precipitations
orographiques, mouillure, refroidissement eolien (dont les deux bords du
domaine de validite), robustesse aux NaN/inf, et cout.
- `testWeatherGameplay()` — les quatre activites et la lumiere, systematiquement
par comparaison de deux simulations identiques a un parametre pres, chacune
avec son controle negatif de non-regression.
### Vulkan reel
`tools\run_vulkan_check.ps1`, **cinq executions completes** de la suite (dix
scenarios, quatorze processus) sur cette phase.
**Le critere dur est tenu dans les cinq :**
| | Resultat |
|---|---|
| Messages `[Validation]` | **0**, dans les cinq executions |
| Lignes `[ERROR]` | **0**, dans les cinq executions |
| Lignes `[WARN]` | 4, les memes qu'avant la phase |
**Chaque scenario a passe ses assertions de gameplay** sur le binaire final :
terrain synthetique, dalle LiDAR reelle, vol en parapente, sortie a velo
(50,0 km/h au pic en descente, 67 releves), escalade (sommet atteint, 41,8 m
gagnes), editeur en trois processus avec son temoin, besoins primaires (236 et
240 releves sur deux executions isolees apres la correction du 12), empreinte
environnementale, recolte de matieres.
**Aucune execution n'a ete verte de bout en bout, et il faut dire pourquoi.**
Les echecs residuels sont tous du cote du HARNAIS et jamais du jeu - voir la
section 12, qui distingue la regression que j'ai introduite (corrigee, avec ses
chiffres) de la flakiness pre-existante (desormais mesuree : le jeu se ferme en
0,1 s). Ils frappent un scenario different a chaque execution, ce qui est la
signature d'une variance d'automatisation et non d'un defaut.
Un run de reference entierement vert reste souhaitable ; il demande de traiter la
dette du collecteur de journal, qui n'est pas le sujet de cette phase.
### Verification visuelle
`tools\shot_daynight.ps1` produit **six captures de la MEME vue** a
3 / 6,5 / 9 / 13 / 18 / 21 h, horloge GELEE (`--time-scale=0`) et cadrage epingle
(`--start` + `--look`). Dans `build\daynight`.
Ce qu'elles montrent : la lumiere tourne d'est en ouest au fil de la journee, son
intensite suit, et le ciel passe du bleu de midi au bleu nuit. Le detecteur de
ciel du script de capture le chiffre tout seul, sans rien avoir a mesurer a la
main : **20,6 % de ciel a 13 h, 0,0 % a 21 h** - il ne compte que les pixels bleu
clair, et la nuit il n'y en a plus.
Rappel des trois pieges du projet, tous les trois rencontres pendant cette
session : `--look` doit etre epingle en plus de `--lock-input` (Phase 12), un
`vercora.exe` orphelin fausse toute mesure (Phase 19, et il a fallu en tuer un
au milieu des captures), et `powershell -File` aplatit les arguments - il relit
`--look=-90,-8` comme un nom de parametre, d'ou l'appel en processus dans
`shot_daynight.ps1`.
**Contraste adret/ubac** : aucune capture ne le montre, et c'est une limite
assumee. Le jeu n'a aucun indice visuel de temperature, donc un adret et un ubac
au meme instant se distinguent par leur ECLAIREMENT (visible dans les captures du
cycle) mais pas par leur chaleur. L'ecart thermique, lui, est mesure par les
tests headless : 14,7 C contre 10,7 C a midi. Un indice visuel - une teinte, une
brume de fond de vallee - est note comme amelioration future.
---
---
## 12. Le harnais Vulkan, et ce que cette phase lui a coute
Deux choses distinctes, qu'il ne faut pas confondre.
### (a) Une regression que j'ai introduite, mesuree et corrigee
La premiere version journalisait **deux lignes de meteo par seconde**, a cote de
la ligne de besoins qui existait deja. Le debit de journal a donc triple.
Le harnais Vulkan paie **un script-block PowerShell par ligne de journal**, et
son retard **croit avec le volume** — c'est la dette ouverte en Phase 17 et
comprise en Phase 22. Resultat immediat : le scenario H, le plus long
(220 s de journal continu), a echoue sur *"pas de sortie 20 s apres WM_CLOSE"* et
n'a collecte que **87 releves la ou il en attend 220**. Le jeu etait correct ;
c'est le collecteur qui ne suivait plus.
La cadence a ete resserree **deux fois** :
| Version | Volume ajoute sur le scenario H | Releves collectes |
|---|---|---|
| 2 lignes / seconde | ~440 lignes | **87** — echec |
| 2 lignes / 10 s | ~44 lignes | 235, puis **181** — echec marginal |
| 1 ligne / 30 s | **~7 lignes** | **236 / 240** sur deux essais |
La deuxieme valeur est instructive : elle *passait*, mais de justesse, et un run
ulterieur est retombe a 181 releves — assez pour perdre les derniers, donc pour
que la recuperation de la jauge (qui se lit dans les derniers) disparaisse. Une
correction qui passe de justesse n'est pas une correction.
Trente secondes ne coutent rien au depouillement : la meteo bouge a l'echelle de
l'heure de jeu, pas de la seconde reelle.
### (b) Une flakiness qui n'est PAS de cette phase, et qui est maintenant mesuree
Il reste des echecs *"pas de sortie 20 s apres WM_CLOSE"* qui frappent un
scenario different a chaque execution (H, puis E, puis D + G1 + G3, puis H de
nouveau), sans jamais aucun message `[Validation]` ni `[ERROR]`.
**Le jeu n'est pas en cause, et c'est desormais une mesure et non une
hypothese** : en fermant la fenetre par `CloseMainWindow()` et en chronometrant
la sortie du processus, on obtient **0,1 / 0,1 / 0,1 / 0,2 seconde** sur quatre
essais. Le jeu se ferme instantanement. Un *"pas de sortie apres 20 s"* est donc
un echec de LIVRAISON du message par le harnais, pas un blocage du jeu.
C'est la meme famille que la variance deja documentee pour A/B/G : le harnais
pilote par `PostMessage` (scancodes, pas de vraie souris), et le meme run peut
manquer une touche. Les executions ou un scenario echoue montrent d'ailleurs des
assertions de gameplay a `False` en amont (pas de decollage, pas d'entree en
mode editeur), pas seulement une fermeture ratee : ce sont des touches perdues.
---
## 13. Limites assumees et ameliorations futures
- **Ombre pluviometrique** — la barriere orographique renforce le versant au
vent, mais il n'y a pas de vraie ombre sous le vent au-dela de l'absence de
renforcement. Le cahier des charges le demandait simple pour cette session.
- **Nature du sol** — le velo ne connait qu'une humidite, pas un materiau. Le
LiDAR ne porte aucune information de nature de terrain (limite deja etablie en
Phase 22 pour les gisements).
- **Adherence en virage a velo** — pas touchee, voir §8.
- **Fermeture et decrochage en parapente** — pas modelises.
- **Neige** — `WeatherSample::snowing` est calcule et journalise, mais n'a
**aucun effet gameplay ni visuel**. Le champ existe pour ne rien avoir a
inventer le jour ou l'un des deux arrivera.
- **Precipitations visibles** — aucune. Il pleut dans les chiffres, pas a
l'ecran.
- **Ombres portees** — aucune, comme avant. Ni etoiles, ni lune, ni halo
solaire : le ciel est une couleur unie qui change avec l'heure, pas un ciel.
- **Vent sur la vegetation** — l'ondulation de l'herbe (Phase 18) est toujours
pilotee par un temps qui defile, pas par le vent local. Le brancher serait un
effet visuel gratuit maintenant que le vent existe en tout point.
- **Modele solaire** — pas d'equation du temps, pas de refraction, pas de
longitude. Les corrections omises valent au plus une quinzaine de minutes sur
les heures de lever et coucher, invisible dans une horloge acceleree douze
fois.
- **Surplombs et 2,5D** — inchange, toutes les limites des phases precedentes
s'appliquent.
+333
Voir le fichier
@@ -0,0 +1,333 @@
# Phase 24 — Cohérence marche / escalade
Session à quatre chantiers, traités dans l'ordre de priorité donné. Ce document
n'est complet que pour les chantiers marqués **FAIT** ; les autres portent
explicitement ce qui a été fait et ce qui ne l'a pas été.
---
## CHANTIER 1 — Cohérence marche / escalade — **FAIT**
### Le défaut, tel qu'il était
`Camera`, en mode `Walk`, n'appliquait **aucune** limite de pente : un versant à
90 %, et même une paroi à 300 %, se montait debout à 14 m/s. Deux conséquences,
dont la seconde est la vraie :
1. c'est irréaliste ;
2. **l'escalade devenait facultative**. Une activité entière (Phase 14, avec sa
jauge, son humidité, son hystérésis) que rien n'obligeait jamais à employer,
puisque la marche passait partout.
### Les seuils, et pourquoi ceux-là
Tout est dans `src/core/SlopeLimits.hpp`, en *rise par mètre horizontal*
(1,00 = 45° = 100 %), la même unité que `ClimberParams` et `BikeParams`.
| Constante | Valeur | Ce qu'elle fait |
|---|---|---|
| `kWalkComfortSlope` | **0,60** (31°) | fin de la pleine vitesse |
| `kWalkMaxSlope` | **0,84** (40°) | plus aucune progression debout |
**0,60 n'est pas une valeur neuve** : c'est exactement
`ClimberParams::walkableSlope`, déjà justifiée en Phase 14 comme la pente
au-delà de laquelle un sentier de montagne ne se fait plus debout de façon
soutenue, et déjà employée par `tools/find_climb_walls.py`. Les trois lisent
désormais la même constante au lieu de trois copies du même nombre.
**0,84** a été choisi dans la fourchette imposée (entre 0,60 et le seuil de
paroi) pour trois raisons :
1. c'est la **borne haute de l'angle de repos des matériaux meubles** (35–40°),
exactement la grandeur physique que la Phase 14 invoquait déjà pour placer
`wallSlope`. Au-dessus, un versant de ce massif ne retient ni terre ni
éboulis : il n'y a plus de sol, seulement du rocher. C'est littéralement la
pente maximale à laquelle il existe encore quelque chose sur quoi se tenir ;
2. **la randonnée raide n'est pas touchée** — contrainte explicite de la
consigne. Un sentier soutenu vit entre 0,30 et 0,60 ; les raidillons montent
à 0,70–0,80. Tout cela passe encore, ralenti. Mesuré par les tests :
| pente | 30 % | 60 % | 72 % | 80 % | 84 % |
|---|---|---|---|---|---|
| vitesse accordée | 100 % | 100 % | 50 % | 17 % | 0 % |
3. **ça ne ferme pas le terrain**. La distribution des pentes de la zone de jeu
(25 M d'échantillons, `find_climb_walls.py`) donne p75 = 65,7 % et
p90 = 92,4 % : le seuil tombe entre les deux et interdit à la marche de
l'ordre de 13 % du massif.
### Le comportement au-delà : ni mur, ni blocage sec
Trois règles, dans `resolveWalkStep()` :
1. **Rampe, pas marche d'escalier.** La vitesse décroît linéairement de 0,60 à
0,84. Le joueur *sent* le terrain se durcir bien avant d'être arrêté — à
72 % il n'avance déjà plus qu'à moitié — et l'arrêt est la fin d'un mouvement
continu, pas un événement. C'est ce qui évite le « mur invisible
incompréhensible ».
2. **Dissymétrie amont / aval.** Seule la composante *vers l'amont* est
facturée : **redescendre est toujours accordé, à pleine vitesse**. Sans ça,
un joueur posé sur du trop raide serait figé — précisément le blocage
frustrant à éviter.
3. **Glissade.** Au-delà de 0,84 sous les pieds, le joueur glisse vers l'aval à
une vitesse proportionnelle à l'excès de pente (0,48 m/s à 100 % : un
décrochage lent, pas une éjection), plafonnée à 6 m/s — sans plafond, les
5018 % de pente mesurés sur cette dalle éjecteraient le joueur à 150 m/s.
La règle 3 est la **garantie de fond** : où qu'on dépose le joueur, il finit sur
du terrain marchable sans rien faire. Vérifié par un test — déposé en pleine
paroi à 160 %, il est ramené sur du 84 % en 21,4 s.
Le déplacement **latéral est facturé lui aussi**, et c'est délibéré : s'il était
gratuit, monter en travers à 45° rendrait 71 % du gain d'altitude à pleine
vitesse et la limite ne servirait à rien. Un contrôle négatif l'assure (« le
zigzag ne fait pas gagner plus de hauteur que monter droit »).
### LE VRAI BUG DE COHÉRENCE : le trou entre les deux activités
C'est le point 3 de la consigne, et c'était bien un défaut réel.
L'escalade ne s'engageait qu'à partir de `wallSlope` = **1,00**. Une limite de
marche à 0,84 aurait donc ouvert une bande **[0,84 ; 1,00[** — environ **5 % du
massif, soit un versant sur vingt** — où le joueur ne pourrait **ni marcher ni
grimper**. Pas un cas théorique.
**La correction n'est pas un réglage, elle est structurelle** :
`ClimberParams::wallSlope` **vaut désormais `kWalkMaxSlope`, la même constante**.
Le seuil d'entrée en escalade *est* la limite de marche. Un trou ne peut plus
être réintroduit par un réglage distrait, parce qu'il n'y a plus deux nombres à
faire diverger. Un ajout de seuil aurait, lui, seulement déplacé le problème.
Ce que ça change pour les trois arguments de la Phase 14 : 40° au lieu de 45°
(toujours au-dessus de l'angle de repos, donc toujours du rocher nu) ; la part
grimpable de la zone passe de 8,4 % à ~13 %, ce qui reste loin des 20,7 % que la
Phase 14 jugeait excessifs.
L'hystérésis de **sortie** reste à 0,60, strictement en dessous : c'est elle qui
empêche le mode escalade de battre à chaque frame sur une paroi réelle.
**Effet de bord traité, pas subi** : `WildlifeParams::maxSlope` passe de 0,90 à
0,80. Cette valeur n'a jamais eu de justification propre ; ce qu'elle porte est
un *rapport*, gardé par une assertion depuis la Phase 20 — aucun animal ne se
tient sur une pente grimpable, sans quoi on croiserait des cervidés en pleine
paroi. Le plafond devait descendre avec le seuil de paroi. L'effet réel sur le
jeu est proche de nul et c'est mesurable plutôt que supposé : les animaux sont
semés sur les zones boisées, or `ForestParams::maxSlope` vaut 0,6 — aucun animal
n'est jamais *placé* au-delà ; le seuil ne borne que l'errance.
L'assertion du test, elle, n'a pas changé d'une ligne : elle portait le rapport
et non les valeurs, donc elle a survécu au réglage. C'était exactement ce qu'on
lui demandait.
### Vérification sur le VRAI relief LiDAR
Pas seulement en synthétique — la leçon de la Phase 13 est explicite là-dessus.
Voie de référence de la Phase 14 : pied à **E 899900 / N 6435550** (x = +400,
z = −50 sur `LHD_0899_6436`), cap plein est, déjà connue comme une vraie
transition marche / paroi.
Profil de pente réellement mesuré sur la dalle (base de sondage 4 m) :
| x | 400 | 401 | 402 | 403 | 407 | 409 | 420 | 424 | 426 |
|---|---|---|---|---|---|---|---|---|---|
| pente | 57 % | 75 % | 89 % | 109 % | 119 % | 129 % | 100 % | 63 % | 42 % |
Résultat en jeu : **la marche progresse de 1,4 m puis s'arrête, sur du 81 %**.
Ce chiffre a été vérifié plutôt que cru — 1,4 m paraissait suspect. Le profil
ci-dessus le confirme : le pied de cette voie passe de 57 % à 89 % **en deux
mètres**. L'arrêt court est un fait du terrain, pas un artefact du test.
Et surtout : **depuis ce point d'arrêt exact, `Climber::tryStart()` accepte**.
La jonction est vérifiée là où elle se joue, sur du relief mesuré.
Bénéfice collatéral, mesuré : l'ascension de la voie de référence gagne
désormais **20,8 m** (contre ~19 m avant), parce qu'on s'engage plus bas — plus
proche des 21,4 m que l'outil de repérage annonce en ligne droite.
### Ce qui a été touché
| Fichier | Nature |
|---|---|
| `src/core/SlopeLimits.hpp` | **neuf** — les deux seuils, le filtre, header-only |
| `src/core/Camera.{hpp,cpp}` | le pas clavier passe par le filtre en mode `Walk` |
| `src/world/Climber.hpp` | `wallSlope` et `walkableSlope` lisent les constantes partagées |
| `src/world/Wildlife.hpp` | `maxSlope` 0,90 → 0,80 (voir ci-dessus) |
| `src/main.cpp` | journal sur **changement d'état** uniquement |
| `tests/logic_tests.cpp` | section `testWalkSlopeLimit()`, **+30 assertions** |
Header-only à dessein : ni `CMakeLists.txt` ni `tools/run_logic_tests.bat`
n'ont eu à changer de liste de sources.
**Le journal est volontairement avare** — une ligne sur *transition* seulement
(marchable ↔ trop raide, glisse ↔ tient debout), jamais par frame. Ce n'est pas
de l'économie de place : le harnais paie un coût par ligne de journal, et une
ligne par frame ferait échouer des scénarios entiers pour un jeu correct. C'est
exactement ce qui s'est produit en Phase 23.
### Tests
`tools\run_logic_tests.bat` : **3608 assertions, toutes passantes** (3578 avant
la phase, +30 neuves). Zéro régression sur les 42 sections existantes.
L'assertion qui compte le plus est celle qui balaie 300 pentes de 0 à 300 % et
vérifie qu'**aucune** n'est à la fois trop raide pour marcher et trop douce pour
grimper. C'est la seule chose ici qu'un réglage distrait pourrait casser sans
rien casser d'autre.
### Limites assumées
- La limite ne s'applique qu'à la **marche**. Le vol libre reste un mode
d'inspection sans contrainte, comme la collision l'est déjà depuis la Phase 6.
- **Pas d'indice visuel** de la limite : le joueur ralentit et glisse, mais rien
à l'écran ne dit « trop raide ». Un curseur ou une inclinaison de caméra
seraient l'étape suivante.
- La glissade **ne coûte rien** : ni énergie, ni dégât, ni perte de matériel.
C'est un renvoi en arrière, pas une sanction.
- Une **marche trop raide mais courte** (un ressaut de 2 m à 90 %) reste ni
marchable ni grimpable, parce que `minWallRise` exige 4 m de gain : c'est un
obstacle qu'on contourne. Assumé — et sans piège, la glissade garantissant
qu'on n'y reste jamais coincé.
---
## CHANTIER 2 — Flakiness du harnais — **FAIT, avec une correction du diagnostic**
### Le point 1 de la consigne était déjà livré
Le remplacement demandé — délégué .NET compilé au lieu d'un script-block
PowerShell par ligne de journal — **existe depuis la Phase 22**, avec sa mesure
(1833 ms contre 5 ms). Rien à refaire de ce côté.
Et c'est justement ce qui a masqué la suite : le harnais paraissait soldé.
### Ce que la dette restante était RÉELLEMENT
Trois exécutions de la suite ont donné le même échec **au détail près** sur les
scénarios A et C. Ce n'était donc **pas de la flakiness** : c'était un défaut
**déterministe**, classé « aléatoire » depuis des phases — ce qui explique
pourquoi élargir des délais ne l'a jamais corrigé, puisqu'aucun délai n'était
en cause.
Deux contrôles négatifs, dans les deux sens, écartent le chantier 1 :
| contrôle | résultat |
|---|---|
| limite de pente **entièrement neutralisée** (`kWalkMaxSlope` = 1000), rebuild | échec **identique** |
| exécution de référence du scénario A | le filtre de pente **ne s'est déclenché aucune fois**, et l'échec est identique |
Cause réelle, lue dans le journal brut du jeu :
[INFO] Ramassage : rien a portee de main. (x 24)
[INFO] Percussion impossible : il faut deux pierres, un percuteur...
[INFO] Abattage : aucun arbre dans la ligne de visee.
**Tout le scénario A tombait d'une seule cause : le joueur n'arrivait pas.**
« Percussions 0 » et « cible manquée » en étaient les conséquences, pas des
défauts distincts. `GoTo` naviguait **à l'estime** — tenir une touche pendant
`distance / 14 m/s` — puis *déclarait* le joueur arrivé sans rien vérifier.
L'erreur ne se corrigeait jamais : elle s'**accumulait** d'un `GoTo` au suivant.
### Le correctif, sans toucher au jeu
Contrainte respectée : aucune ligne du jeu modifiée pour ce chantier.
`src/main.cpp` journalise la position de la caméra **une fois par seconde, sans
condition**, depuis la Phase 15 — et le commentaire de cette ligne dit
explicitement que c'est pour que le harnais sache où le joueur a réellement
fini. Le harnais ne s'en servait pas. `GoTo` la lit désormais et corrige
(4 passes, tolérance 0,6 m), avec **repli exact sur l'ancien comportement** si
la ligne n'arrive pas.
Effet mesuré, scénario A :
| | avant | après |
|---|---|---|
| arbre visé | **manqué** | abattu |
| objets ramassés | **1** | 7–8 |
| percussions | **0** | 1 |
### Une limite du canal d'entrée, et ce qu'on en fait
La boucle fermée **plafonne à ~0,8 m** et n'y descend pas : `Hold` refuse tout
pas sous 0,28 m et `Start-Sleep` a une granularité de ~16 ms — une correction
fine est soit ignorée soit dépassée. Ce n'est pas un réglage à ajuster, c'est
une limite du pilotage par `PostMessage`.
Or la marge de visée du scénario C est plus fine que ce plafond, et ça s'est vu :
deux exécutions du **même binaire** ont donné **0,78 m (abattu)** et
**0,80 m (manqué)**. Une réussite qui tient à deux centimètres de résidu n'est
pas une réussite. Remède : `Fell-WithRetry`, un petit balayage latéral alterné —
exactement ce que le harnais fait déjà pour le même problème au ramassage
(`Vacuum`), au lieu d'exiger du canal d'entrée une précision qu'il n'a pas.
### Une régression de MOI, trouvée et corrigée
La première suite complète après le correctif de navigation a fait échouer le
scénario I : population de faune lue à 0, **150 relevés au lieu de 254**.
C'était mon journal du chantier 1. « Journaliser sur changement d'état » semble
déjà économe — un état qui **bat** autour d'un seuil produit pourtant une ligne
par frame. **494 lignes** sur la suite. C'est le défaut de la Phase 23,
reproduit malgré la leçon, parce que la règle paraissait bornée.
Limiteur de cadence ajouté (une seconde entre deux lignes). Résultat : **30
lignes** au lieu de 494, et le scénario I retrouve ses 216 relevés et ses 24
animaux.
### Diagnostics permanents ajoutés au harnais
- **Le journal brut du jeu est écrit sur disque** à chaque exécution
(`%TEMP% ercora_last_run.log`). C'est le manque qui a coûté cinq phases sur
la dette du vélo : le harnais imprimait ses *conclusions*, et quand l'une
d'elles était fausse, rien ne permettait de savoir ce que le jeu avait
réellement émis.
- **Report des déclenchements du filtre de pente**, pour que « ralenti par le
relief » et « dérive du pilotage » cessent d'être indiscernables.
### Le résultat sur plusieurs runs : le critère N'EST PAS tenu
Trois suites complètes après tous les correctifs :
| run | verdict | ce qui a lâché |
|---|---|---|
| 4 | **VERT** | — première suite verte de bout en bout du projet |
| 5 | **ÉCHEC** | scénario C : arbre manqué ; scénario I : **48 relevés au lieu de 216** |
| 6 | **VERT** | — |
Donc : **2 verts sur 3**, et le critère demandé — zéro faux-négatif sur
plusieurs runs consécutifs — **n'est pas atteint**. Il faut le dire tel quel
plutôt que de retenir le run 4.
Ce qui a néanmoins changé, et qui est solide :
- le défaut **déterministe** de navigation est corrigé, et il ne se reproduit
plus (le scénario A est « pilotage précis » dans les runs 4, 5 et 6, avec
7–8 objets ramassés) ;
- la première suite entièrement verte du projet existe, ce qui n'était jamais
arrivé (voir `NOTES-PHASE23.md`) ;
- ce qui reste est une **flakiness authentique**, cette fois : le run 5 a perdu
78 % de la télémétrie du scénario I, avec seulement 6 lignes de filtre de
pente — mon journal du chantier 1 est donc hors de cause, contrairement à la
régression trouvée plus haut.
### Un défaut de mon propre diagnostic, corrigé
Je n'ai **pas pu** remonter à la cause de l'échec du run 5 : le dump de journal
brut que j'avais ajouté écrivait toujours `vercora_last_run.log`, et le run 6 a
donc effacé la seule trace de l'échec.
Un journal de diagnostic qui ne survit pas à l'exécution suivante ne sert à
rien — précisément parce que les échecs de ce harnais sont ceux qu'on ne
reproduit pas à volonté. Le dump est désormais **horodaté**
(`vercora_run_AAAAMMJJ-HHMMSS.log`), avec une copie à nom fixe pour la
commodité. La prochaine occurrence sera diagnosticable.
### Ce qui reste ouvert
- **La flakiness résiduelle du scénario I** (télémétrie tronquée) et **du
scénario C** (visée). Piste à instruire en premier avec le journal horodaté :
savoir si le jeu a réellement émis moins de lignes, ou si le harnais en a
perdu — la distinction n'a jamais été tranchée pour ce symptôme.
- Les échecs « pas de sortie 20 s après WM_CLOSE » documentés en Phase 23 ne se
sont **pas reproduits** ici, mais aucune exécution n'a été conduite pour les
provoquer.
+189
Voir le fichier
@@ -0,0 +1,189 @@
# Phase 25 — Indice visuel adret / ubac
## Le manque
Depuis la Phase 23, l'écart adret/ubac est **calculé, mesuré et journalisé** —
14,7 °C contre 10,7 °C à midi sur la zone de référence — et **strictement
invisible à l'écran**. La Phase 23 l'avait notée elle-même comme sa limite
assumée : « pas de capture adret/ubac, et c'est une limite assumée : le jeu n'a
aucun indice VISUEL de température ».
## La piste retenue : teinte du terrain (piste 1)
Retenue sans hésitation, et le rapport impact / effort n'est pas la seule
raison : c'est la seule des trois pistes qui **réutilise la grandeur existante
telle quelle**.
`WeatherSystem::sampleAt` définit l'adret/ubac par l'écart entre le cosinus
d'incidence du point et celui qu'aurait du terrain **plat** au même instant. Or
`shaders/terrain.frag` dispose déjà des deux moitiés de ce calcul : la normale
du relief par fragment, et `ubo.sun.xyz` — la direction solaire **de Weather**,
celle que la Phase 23 a fait descendre jusqu'au rendu précisément pour qu'il n'y
ait qu'un seul soleil dans le jeu.
Il n'y avait donc **rien à recalculer**, seulement à consommer.
### Le partage des rôles, et pourquoi il est là
| | qui | quoi |
|---|---|---|
| hauteur du soleil, nébulosité | **CPU** (`main.cpp`) | appartiennent à la météo, passés dans `ubo.terrain.w` |
| cosinus d'incidence par fragment | **shader** | seule part qui a besoin de la normale |
Les deux règles portées par le CPU le sont délibérément : ce sont exactement
celles qu'un shader re-dériverait « à peu près », et qui divergeraient ensuite
de la température sans que rien ne le signale. C'est la contrainte « pas de
seconde source de calcul » prise au sérieux — la même exigence qui, en Phase 23,
avait fait sortir la température de `Needs`.
Le champ `terrain.w` était marqué « réservé » depuis la Phase 11. Il l'est resté
jusqu'ici : **aucun octet d'uniforme ajouté, aucune allocation.**
### Conséquence gratuite : la cohérence avec le cycle jour/nuit
Aucune règle horaire n'est écrite nulle part. Le soleil tourne, l'incidence de
chaque versant change avec lui ; il se couche, `terrain.w` tombe à zéro.
La condition « le soleil doit être levé » est celle de la Phase 23 — celle dont
l'absence rendait un versant sud plus chaud à 2 h du matin.
## Les paramètres visuels
| paramètre | valeur | où |
|---|---|---|
| teinte adret | `(1.14, 1.04, 0.88)` | `shaders/terrain.frag` |
| teinte ubac | `(0.86, 0.96, 1.12)` | idem |
| écart de référence | `0.35` | = `WeatherParams::aspectIncidenceReference` |
| intensité maîtresse | `1.0` | `kAspectTintIntensity`, `src/main.cpp` |
Deux propriétés voulues :
- **Symétrie exacte autour de 1**, canal par canal. Sur du terrain ni adret ni
ubac le signal vaut 0, donc le mélange rend le *milieu* des deux teintes : un
milieu qui ne serait pas `(1,1,1)` teinterait tout le plat du massif. Un
premier jeu de valeurs le faisait, d'un demi pour cent vers le chaud.
- **Modulation, jamais remplacement** : l'orthophoto porte tout le détail, elle
est seulement réchauffée ou refroidie.
### L'amplitude a été corrigée après mesure, pas devinée
Premier essai à ±7 % : à **13 h — l'heure où l'écart thermique est maximal —
93,5 % des pixels ne bougeaient pas d'un cran sur 255.** Un indice invisible
manque sa seule raison d'être. Amplitude portée à ±14 % (rouge) / ±12 % (bleu).
**Le signal, lui, n'a pas changé** : c'est toujours celui de la météo. Seule
l'amplitude d'affichage a été revue, et c'est un choix de rendu, légitimement
distinct du modèle physique.
## Vérification
### La vue : un belvédère, pas un point
Première tentative : un point choisi pour ses pentes. Résultat — une image
entièrement remplie par le versant sous les pieds, 0 % de ciel, aucun relief
lisible. **Savoir où sont les versants ne dit pas d'où on les voit.**
La recherche a donc été refaite avec un vrai calcul de **visibilité** (balayage
d'horizon le long de chaque rayon : un point n'est vu que si son élévation
dépasse celle de tout ce qui est plus proche). Belvédère retenu :
E 900000 / N 6436000, altitude 1950 m, --look=270,-24
108 points d'adret franc et 107 d'ubac franc VISIBLES, ciel sur 15 rayons/15
### Avant / après, mesuré
Témoin : **même binaire, même vue, `kAspectTintIntensity` à 0**. La mesure porte
sur la variation de « chaleur » `(R−B)` pixel à pixel.
| heure | réchauffés | refroidis | inchangés |
|---|---|---|---|
| 09 h | 3,2 % | **52,2 %** | 44,6 % |
| **13 h** | **20,4 %** | **29,0 %** | 50,6 % |
| 18 h | **45,8 %** | 6,0 % | 48,2 % |
| 22 h | 2,0 % | 0,0 % | 98,0 % |
Ce qu'on cherchait n'était pas « les images diffèrent » — un filtre global
donnerait ça aussi et ne prouverait rien. C'est que l'écart soit **bipolaire
dans la même image** : à 13 h, 20 % des pixels se réchauffent *pendant que*
29 % se refroidissent. C'est la signature d'un indice qui distingue deux
versants.
La rotation est cohérente avec le soleil : à 9 h, en regardant au nord, les
faces ouest sont à l'ombre — refroidies ; à 18 h les mêmes sont au soleil —
réchauffées.
### Plancher de bruit : la mesure qui rend les chiffres lisibles
Deux captures du **même** binaire, pour savoir ce que vaut une différence :
| | 13 h | 22 h |
|---|---|---|
| bruit (même binaire) | 0,6 % | 1,2 % |
| effet (avant/après) | **49,4 %** | 2,0 % |
À midi, l'effet est **80 fois le bruit**. À 22 h il est **dans** le bruit :
l'indice est donc réellement éteint la nuit, et le résidu de 2 % est l'herbe
animée — vérifié, pas supposé. Le journal du jeu le confirme de son côté :
`versant -2.1` à 13 h, `versant 0.0` à 22 h.
### Coût
| | témoin | avec l'indice |
|---|---|---|
| `drawFrame` | 672 µs | **665 µs** |
| orthophoto GPU | 48 Mo | 48 Mo |
| géométrie terrain GPU | 30 Mo | 30 Mo |
L'écart sur `drawFrame` est du bruit, et dans le sens d'un gain : autrement dit,
non mesurable. Attendu — quelques opérations ALU par fragment, aucune texture
supplémentaire, aucune allocation.
### Validation Vulkan
**Zéro message `[Validation]`** sur les deux séries de captures (8 lancements du
jeu, couches de validation actives).
## La divergence possible, rendue bruyante
`kAspectIncidenceReference` (0,35) est écrit **en dur dans le shader** : un
shader ne peut pas lire un paramètre C++. Si quelqu'un règle
`WeatherParams::aspectIncidenceReference` sans toucher au shader, l'indice
visuel cesserait d'être d'accord avec la température — exactement la double
source de vérité que la Phase 23 avait pris soin d'éviter.
On ne peut pas empêcher la divergence ; on peut refuser qu'elle soit
silencieuse. `main.cpp` compare les deux au démarrage et émet un `[WARN]`
explicite si elles ont cessé de s'accorder.
## Les pistes NON retenues
**Piste 2 — végétation différenciée par versant.** Écartée pour cette session,
et pas par manque de temps : l'équilibre de densité d'herbe est calibré depuis
la Phase 18 (124 touffes sur la vue de référence, un repère qui sert encore), et
la végétation n'a **aucune distinction d'espèces** — pas de résineux contre
feuillus, un seul type d'arbre. « Résineux en ubac, feuillus en adret » n'est
donc pas un réglage mais un **prérequis manquant**. À traiter avec le chantier 4
(placement des arbres), où la distinction d'espèces devrait de toute façon
apparaître.
**Piste 3 — température affichée dans l'interface.** Non nécessaire : elle était
le filet de sécurité si la piste 1 s'avérait risquée, et la piste 1 a tenu. À
noter que la température ambiante **est déjà** dans le titre de la fenêtre
(`chaud 99%`) et dans le journal des besoins.
## Limites assumées
- **L'indice n'est pas quantitatif.** Il dit « ce versant reçoit plus de soleil
que celui-là », pas « il fait 4 °C de plus ». Un joueur ne peut pas en lire une
température.
- **Le terrain seulement.** L'herbe et les arbres (shader `foliage`) ne sont pas
teintés : un versant densément boisé montrera donc l'indice sur le sol entre
les arbres, moins sur le couvert.
- **Pas d'ombres portées** (limite héritée de la Phase 23) : un versant à
l'ombre d'une crête est traité comme s'il voyait le soleil. L'indice suit
l'orientation de la surface, pas l'occultation par le relief.
- **L'amplitude est un réglage d'auteur**, pas une grandeur physique. Le seul
bouton est `kAspectTintIntensity` dans `src/main.cpp`, nommé pour être trouvé
sans lire le shader.
- **L'effet sature** au-delà de 0,35 d'écart d'incidence, comme la température :
deux versants très raides d'orientations opposées ne se distinguent plus
au-delà de ce seuil.
+365
Voir le fichier
@@ -0,0 +1,365 @@
# Phase 26 — Flakiness du scénario I, et espèces d'arbres par exposition
## TÂCHE 1 — La flakiness résiduelle du scénario I : REPRODUITE ET EXPLIQUÉE
### Ce que la Phase 25 laissait ouvert
Trois suites complètes, résultat vert / échec / vert. Le run en échec avait perdu
78 % de la télémétrie du scénario I. La cause n'avait pas pu être retrouvée : le
dump de diagnostic portait un nom fixe et avait été écrasé. La Phase 25 a
horodaté le dump pour que la prochaine occurrence soit traçable.
### Ce qui manquait ENCORE au dump, et qu'il a fallu ajouter
Le dump horodaté aurait survécu — mais il n'aurait toujours rien appris. Il
concaténait les **quatorze processus bout à bout, sans le moindre séparateur** :
aucune ligne du journal n'était rattachable à un scénario. On ne pouvait même pas
compter combien de lignes appartenaient au scénario I.
Ajouté ici, dans `Stop-Game` : un **en-tête par processus** portant le libellé,
l'heure de démarrage, la **durée mur**, le code de sortie et le nombre de lignes.
L'accumulation se fait dans `Stop-Game` lui-même et non en énumérant les `$runX`
à la fin — le scénario J recompose `$runJ` en concaténant ses trois processus, si
bien qu'une énumération des variables compterait J2 et J3 deux fois.
`$dumpLines` est construit **à part de `$all`** : aucune assertion du harnais ne
voit ces en-têtes, donc l'instrumentation ne peut pas changer un verdict.
### Le discriminateur, et pourquoi il tranche seul
La ligne `Faune :` et la ligne `Camera :` sont émises dans le **même bloc « une
fois par seconde »** de `src/main.cpp`. Mais `Camera :` est émise **sans aucune
condition** — ni mode éditeur, ni faune vivante, ni activité en cours. Comparer
les deux comptes sépare donc deux causes qu'aucune ne distingue seule :
* les deux comptes chutent ensemble → c'est **le tic lui-même** qui n'a pas
battu : le jeu n'a pas rendu d'images ;
* `Camera :` intact et `Faune :` effondré → c'est la **condition** de la ligne de
faune qui a sauté.
### La mesure
Échec reproduit **dès la suite 2**, et bien pire que celui de la Phase 25 :
[diag I] duree mur 276,3 s, tics 'Camera :' 3, releves faune 3
**Les deux s'effondrent ensemble.** Ce n'est donc ni un timeout, ni un tampon, ni
la condition de la ligne de faune, ni quoi que ce soit qui appartienne au
scénario I. Le jeu était vivant, sa fenêtre existait, son initialisation était
complète (~70 lignes) — et il ne rendait pas d'images.
### Ce que le tableau par processus a montré, et qui referme la question
| fenêtre d'horloge | ce qui tournait | état |
|---|---|---|
| jusqu'à **22:09:53** | suite 1 entière + suite 2 A/B/C | normal |
| **22:09:53 → 22:35:15** | suite 2 D→J3, **puis** suite 3 A→F | dégradé, codes de sortie −1 |
| à partir de **22:35:15** | suite 3 G1→J3 | normal, et identique à la suite 1 |
La dégradation est une **fenêtre continue d'horloge murale qui traverse la
frontière entre deux suites**. Elle frappe tous les processus lancés pendant
qu'elle dure, sans égard pour le scénario ; elle s'ouvre au milieu d'une suite et
se referme au milieu de la suivante.
Aucune propriété du scénario I ne peut produire cela — ni ses 240 s, ni sa
position dans la suite, ni un ordre d'exécution. Les deux pistes proposées au
départ sont donc écartées **par la mesure** : ce n'est pas la durée, et ce n'est
pas la place dans la suite.
Comparaison du même scénario, même binaire, à deux moments :
scenario I, run sain : 256,6 s de duree mur -> 254 tics (99 %)
scenario I, run degrade : 276,3 s de duree mur -> 3 tics ( 1 %)
Et la suite 3, une fois la fenêtre refermée, redonne **1349 lignes** au scénario I
là où la suite 1 en donnait 1347. Le jeu n'a jamais bougé.
### La cause matérielle, identifiée
Un processus `find.exe` de Git Bash, **orphelin** (son parent n'existe plus),
lancé à **18:04:59** — soit près de quatre heures avant le début de cette
session — balaie le disque entier :
"C:\Program Files\Git\usr\bin\find.exe" / -maxdepth 9 -type d -ipath *config/totochetools/horizons*
Au moment du constat il avait accumulé **20 334 secondes de CPU** (5,6 heures).
Sur cette machine le GPU est un **Intel UHD 770 intégré** (confirmé : le même GPU
est sélectionné dans les 14 processus des 3 suites, il n'y a pas de bascule de
GPU), qui partage sa bande passante mémoire avec le CPU. Un balayage de système
de fichiers saturant un cœur en continu est exactement ce qui affame un tel GPU.
S'y ajoutent, sur la même machine et pendant la même période, une **compilation
C++ complète** et un **second harnais Vulkan** lancés par une autre session.
### Le correctif : un TÉMOIN DE SANTÉ, pas un délai élargi
Le harnais ne savait pas distinguer deux choses qui n'ont rien à voir :
* « le jeu a régressé » → il faut chercher dans le jeu ;
* « la machine n'a pas pu rendre » → il n'y a **rien** à chercher dans le jeu.
Faute de les séparer, il déclarait ROUGE dans les deux cas. Ce projet a perdu
cinq phases sur exactement cette confusion (dette du vélo, Phases 17 à 22).
La mesure qui les sépare **existait déjà** : le nombre de lignes `Camera :`
rapporté à la durée mur du processus. Le harnais le calcule désormais pour chaque
run et, si un seul run tombe sous **50 %** du débit attendu, il conclut :
[NON CONCLUANT] ... exit 2
**Ce témoin ne rend rien vert.** Un run dégradé n'est pas déclaré réussi, il est
déclaré non concluant, avec un code de sortie qui lui est propre pour qu'aucune
automatisation ne le confonde avec un succès. On refuse de conclure sur une
mesure qui n'a pas eu lieu ; on ne prononce pas l'acquittement.
Le seuil de 50 % n'arbitre rien : les deux populations mesurées sont à **99 %** et
à **1 %**. N'importe quelle valeur entre les deux donnerait le même verdict.
### La vérification : 3 suites consécutives, machine au repos
Le `find` orphelin disparu et la charge globale retombée à 0 %, trois suites
complètes ont été enchaînées :
| suite | verdict | durée | scénario I |
|---|---|---|---|
| 1 | `[OK]` exit **0** | 14,2 min | 256,5 s → **254 tics / 254 relevés** |
| 2 | `[OK]` exit **0** | 14,2 min | 256,6 s → **254 tics / 254 relevés** |
| 3 | `[OK]` exit **0** | 14,2 min | 256,4 s → **254 tics / 254 relevés** |
Zéro message `[Validation]`, zéro ligne `[ERROR]`, et le témoin de santé conclut
« tous les processus ont rendu des images à cadence normale » dans les trois cas.
**Ce qui frappe, et qui est la vraie preuve** : la reproductibilité. **Onze des
quatorze processus rendent un nombre de lignes RIGOUREUSEMENT identique** d'une
suite à l'autre — scénario I à 1605 lignes les trois fois, scénario H à 1013.
Seuls le scénario A (430 / 442 / 436) et l'éditeur G1 (894 / 887 / 911) varient
de quelques lignes. Un harnais dont onze processus sur quatorze sont au relevé
près identiques n'est plus un harnais flaky.
Le critère « zéro faux-négatif sur plusieurs runs consécutifs », ouvert depuis la
Phase 25, est donc **atteint** — et il l'est sans qu'une seule ligne du jeu ait
été modifiée pour la fiabilité du harnais. Ce qui manquait était l'instrument, et
la machine.
À noter : les espèces de la Tâche 2 sont exercées par la suite complète (mesh
feuillu téléversé, « 10 résineux sur 16 arbres abattables » journalisé) — les
trois suites vertes valent donc aussi non-régression pour le chantier 4.
---
## TÂCHE 2 — Espèces d'arbres et placement par exposition
### L'architecture : une seule loi, trois consommateurs
`world/TreeSpecies.hpp` est le **seul** endroit qui décide d'une essence.
L'essence est une **fonction pure de la position monde et d'une graine** :
TreeSpecies treeSpeciesAt(worldX, worldZ, aspectExposure, params)
Elle n'est stockée nulle part comme vérité — `Forest` la mémorise dans chaque
arbre par commodité d'accès, `Vegetation` la met en cache avec sa cellule — mais
les deux la tirent du **même appel**. Ce qui est résineux à l'œil est donc
résineux à la saignée par construction, et non par accord entre deux tables
qu'il faudrait tenir à jour.
Le tirage porte sur la **position** et non sur un indice : un indice n'existe que
dans le système qui l'attribue, et les deux systèmes n'en ont pas de commun. La
position est quantifiée à 25 cm avant hachage — bien plus fin que l'espacement
minimal entre deux pieds (5,5 m), bien plus gros que le bruit de calcul.
### L'exposition : consommée, pas recalculée
Le signal d'adret/ubac de `WeatherSample::aspectC` dépend du **soleil courant** :
il tourne avec l'heure et s'éteint la nuit. Une essence ne peut pas changer entre
midi et minuit.
La formule a donc été **extraite** de `sampleAt` dans
`WeatherSystem::aspectSignal`, sans en changer une ligne de calcul, et
`WeatherSystem::aspectExposureAt` l'évalue **au soleil de midi**. Une seule
formule, deux instants d'évaluation. Preuve que l'extraction n'a rien changé :
les tests headless redonnent **14,7 °C d'adret contre 10,7 °C d'ubac, écart
4,0 °C** — les chiffres exacts documentés en Phase 23.
`Forest` et `Vegetation` ne connaissent pas `WeatherSystem` : elles voient
`AspectExposureSource`, une interface minuscule sur le modèle de
`GroundCoverSource` (Phase 17). Contrat total : source absente = exposition nulle
= part de résineux neutre partout, donc le comportement d'avant la phase.
La source est **paramètre du constructeur** de `Forest`, et non un simple setter :
le constructeur sème immédiatement, si bien qu'un setter aurait créé un ordre à
respecter, donc un piège silencieux du type dont ce projet a déjà payé le prix.
### La tendance, jamais la règle
part de resineux = coniferShareNeutral - aspectSwing x exposition
= 0,55 - 0,35 x exposition (bornee a [0,10 ; 0,92])
0,55 reprend **tel quel** l'ancien `ResinParams::coniferShare` : le réglage de la
Phase 22 n'est pas perdu, il devient le point neutre autour duquel l'exposition
fait pencher la balance. Les bornes dures ne mordent pas avec ces valeurs ; elles
sont là pour qu'un reréglage d'`aspectSwing` ne puisse pas, par inadvertance,
transformer la tendance en règle stricte.
### La présence n'a pas bougé, et c'est structurel
Dans `Vegetation::buildTreeCell`, l'appel à `treeSpeciesAt` est placé **après**
tous les filtres de présence — couvert LiDAR, pente, altitude, hauteur de
canopée. L'emplacement **est** déjà retenu quand l'essence est choisie.
L'exposition n'a donc aucun moyen d'ajouter ou de retirer un arbre. La contrainte
du chantier est tenue par la **structure** du code : déplacer cet appel de vingt
lignes vers le haut serait le seul moyen de la rompre.
**Et c'est vérifié par la mesure** (voir plus bas) : le nombre total d'arbres est
rigoureusement identique avec et sans le couplage.
### Les deux silhouettes
`TreeMesh.hpp` annonçait depuis la Phase 5 : « la variété de silhouette viendra de
plusieurs meshes distincts le jour où ce sera un sujet, pas d'un étirement ».
C'est ce jour-là.
Le conifère existant est conservé tel quel (tronc conique + deux cônes empilés,
**facetté**). Le feuillu ajoute un houppier **arrondi** : des anneaux empilés sur
un profil elliptique, **lissés** (normales radiales partagées). L'opposition ne
tient donc pas qu'au contour — les deux arbres n'accrochent pas la lumière de la
même façon. Teintes du feuillu plus claires et plus jaunes que le vert bleuté du
conifère, second indice de lecture après la silhouette.
**Le tronc est le même, et ce n'est pas un raccourci** : la souche interpole son
rayon de coupe sur la droite du tronc de l'arbre. Un second tronc aurait imposé
une seconde souche, et surtout la souche laissée par un feuillu abattu ne
coïnciderait plus avec le trait de coupe. **Une** souche sert les deux essences
parce que les deux partagent exactement le même tronc.
### La dette de la Phase 22, refermée
`world/Resin.hpp` écrivait : « un joueur ne peut pas VOIR quel arbre est résineux
avant d'essayer, puisque tous les arbres ont le même mesh ».
`ResinStand` **ne décide plus de rien**. Plus de graine d'essence, plus de part de
résineux, plus de hachage : `coniferShare` et `seed` ont quitté `ResinParams`.
`tap()` **reçoit** l'essence de l'arbre visé, lue dans `Tree::species` — celle-là
même dont la silhouette est dessinée à l'écran.
Faire lire à `ResinStand` la même fonction que le rendu aurait suffi à les faire
coïncider aujourd'hui ; le lui faire **donner** par l'appelant garantit qu'ils ne
peuvent pas diverger demain, parce qu'il n'y a plus de second calcul à maintenir.
La même exigence que la Phase 23 pour le soleil et la Phase 25 pour l'écart
d'incidence.
### Le rendu
Deux géométries distinctes = **deux appels de dessin instanciés** au lieu d'un.
C'est irréductible : l'instanciation tient UNE géométrie pour N instances. Les
mélanger demanderait une matrice par arbre, c'est-à-dire de défaire la Phase 11.
Le surcoût est d'**un appel de dessin par image**, pas d'un par arbre — le nombre
d'instances est inchangé.
`Vegetation::gatherTrees` a une surcharge à deux vecteurs ; la surcharge à un seul
vecteur appelle la première **avec le même vecteur passé deux fois**, ce qui rend
l'union exactement dans l'ordre d'avant la phase, sans copie et sans qu'il existe
une seconde version du parcours.
### Les deux témoins
| option | ce qu'elle neutralise | ce qu'elle sert à mesurer |
|---|---|---|
| `--no-species-aspect` | le **couplage au versant** seul (`aspectSwing = 0`) | l'effet revendiqué par cette phase |
| `--single-tree-species` | la **seconde essence** (100 % résineux, donc 1 appel) | le coût du second appel de dessin |
`--no-species-aspect` est délibérément étroit : éteindre les essences aurait
mélangé deux effets, « il y a deux formes d'arbres maintenant » et « leur
répartition suit le versant ». Il garde le même nombre d'arbres, la même
proportion globale et les deux silhouettes — seule la corrélation au versant
disparaît. Toute différence entre les deux captures ne peut donc venir que de ce
couplage, qui est exactement ce que cette phase prétend avoir ajouté.
### La vérification, mesurée
Zone de 25 km² (`vercora_zone_1m.vchm`, la seule qui porte une carte de couvert
LiDAR), vue plongeante sur le versant où l'on se tient.
| vue | avec couplage | témoin sans couplage | total d'arbres |
|---|---|---|---|
| **ubac** (exposition −0,75) | 3034 / 1522 = **66,6 %** de résineux | 2494 / 2062 = **54,7 %** | 4556 **/ 4556** |
| **adret** (exposition +0,20) | 810 / 723 = **52,8 %** | 840 / 693 = **54,8 %** | 1533 **/ 1533** |
Trois choses se lisent d'un coup :
1. **Le total est rigoureusement identique** dans chaque paire. La carte de
couvert LiDAR pilote toujours seule la présence — l'espèce n'ajoute ni ne
retire un arbre. Le point 3 du chantier est vérifié, pas supposé.
2. **Le témoin tombe sur 54,7 % et 54,8 %** dans les deux vues, c'est-à-dire sur
`coniferShareNeutral` (0,55). Le témoin fait ce qu'il annonce.
3. **L'écart est bipolaire** : +11,9 points de résineux en ubac, −2,0 points en
adret. Le signe est correct des deux côtés. L'amplitude plus faible en adret
suit l'exposition, qui n'y vaut que +0,20 contre −0,75 en ubac — les adrets de
cette zone sont réels mais peu marqués.
Une capture supplémentaire au belvédère de la Phase 25 (E 900000 / N 6436000,
`--look=270,-24`) donne 1985 / 866 avec couplage contre 1616 / 1235 au témoin,
pour un total identique de 2851 arbres.
La télémétrie qui porte ces chiffres est émise par le jeu une fois par seconde
(`Essences : N résineux et M feuillus à l'écran, exposition ici X`) : une capture
montre une différence, elle ne la **chiffre** pas.
### Validation Vulkan
**Zéro message `[Validation]`** sur toutes les captures et mesures (couches
actives, build Debug).
### Tests headless
`tools\run_logic_tests.bat` : **3607 vérifications passées**, dont la section
« Phase 22 / 26 : essences d'arbres et résine de pin » — déterminisme du tirage,
part observée conforme à la loi, les deux témoins (part nulle / part pleine), une
graine différente qui change réellement le tirage, et la bipolarité adret/ubac
sur la loi elle-même.
### Le coût : mesuré, et il n'y en a pas
Quatre paires de runs **entrelacés** (témoin, condition, témoin, condition…) sur
la même vue et le même binaire, machine au repos. Moyennes sur trois paires
exploitables :
| | 1 appel (témoin) | 2 appels | écart |
|---|---|---|---|
| images en 30 s | 3135 | 3168 | **+1,0 %** |
| `arbres` (semis CPU) | 1634,0 µs | 1633,4 µs | −0,0 % |
| **`herbe` (poste témoin)** | 4972,5 µs | 4977,3 µs | **+0,1 %** |
| `drawFrame` | 1950,2 µs | 1854,8 µs | −4,9 % |
| tampon d'instances | 522 Ko | 522 Ko | — |
| géométrie terrain GPU | 22 Mo | 22 Mo | — |
**Le poste témoin valide la mesure.** L'herbe ne dépend en rien des essences :
elle diffère de 0,1 %, donc la machine n'a pas dérivé entre les conditions. C'est
le contrôle qui manquait à la première tentative, et c'est lui qui autorise à
lire les autres lignes.
**Les deux écarts sont dans le bruit.** La dispersion à l'intérieur d'une même
condition vaut 0,8–0,9 % sur les images et **5,3–5,7 % sur `drawFrame`** : le
−4,9 % constaté est donc plus petit que le bruit du poste lui-même. Il n'y a pas
de surcoût mesurable, et il n'y a pas non plus de gain à revendiquer.
**Ce qui rend le résultat intéressant** : la condition à deux appels soumet
**45 % de triangles d'arbres en plus** —
1 appel : 4556 x 48 = 218 688 triangles
2 appels : 3034 x 48 + 1522 x 112 = 316 096 triangles
le feuillu ayant 112 triangles contre 48 au conifère. Quarante-cinq pour cent de
géométrie supplémentaire ne se voient pas dans le temps d'image : l'image n'est
pas limitée par le débit de sommets des arbres. C'est cohérent avec ce que la
Phase 19 avait établi — le frame attend ailleurs.
Côté mémoire, rien ne bouge : le tampon d'instances est identique (le nombre
d'instances l'est), et le feuillu ajoute **une** géométrie de 129 sommets /
112 triangles téléversée une seule fois.
### Ce qui reste ouvert
* La faune, les plantes à fibres et l'herbe ne sont pas touchées par les essences.
* Le shader `foliage` ne teinte toujours pas les arbres selon l'adret/ubac
(limite héritée de la Phase 25) : l'indice visuel de température reste sur le
terrain seul.
+327
Voir le fichier
@@ -0,0 +1,327 @@
# Phase 27 — Météo visible, micro-relief du sol, profil de performance
Règle de la phase : **aucune valeur ni mécanique météo inventée**. Tout effet
visuel ajouté est piloté par une grandeur que `WeatherSystem` calculait déjà,
ou par une donnée réelle du projet (orthophoto, heightmap LiDAR). Ce qui aurait
demandé une mécanique nouvelle est listé en fin de chantier 1 comme
**prérequis manquant**, et n'est pas implémenté.
Ordre de travail : chantier 1 (météo visible), chantier 3 (micro-relief),
chantier 2 (profilage), conformément à la priorité demandée.
---
## Outillage ajouté (préalable aux trois chantiers)
* **`--day=N`** (`src/main.cpp`) : jour de partie de départ. `--hour` seul ne
choisissait que l'heure du **jour 0**, qui ne contient **aucune
perturbation** : il était impossible de capturer la pluie. Le calendrier est
déterministe (seed fixe), donc `--day` + `--hour` + `--time-scale=0` épinglent
exactement un état météo.
* **`tools/shot_weather.ps1`** : captures épinglées (position, cadrage, jour,
heure, horloge gelée, `--lock-input`) avec **journal du jeu à côté de chaque
image** — nombre de `[Validation]` et ligne `Visuels meteo` relus pour chaque
capture. Une capture dont on ne sait pas quel temps il faisait ne prouve rien.
* **`tools/profile_phase27.ps1`** : mesure A/B **entrelacée**, poste témoin,
santé machine (voir chantier 2).
* **`--no-weather-visuals`**, **`--no-ground-detail`** : témoins **étroits**.
Chacun coupe l'ajout de la phase et lui seul (la météo continue de peser sur
les besoins et les activités ; le terrain garde son orthophoto).
* Bilan de fin de partie : poste `visuels meteo` (CPU) et ligne **`Cadence de
boucle (PHASE 27)`** — images / secondes de boucle réelles, sans dépendre du
titre de fenêtre (±15 %, leçon de la Phase 18).
### Instants de référence (calendrier déterministe, seed fixe)
Trouvés en balayant `synopticAt()` sur 30 jours puis sur un an, **pas** choisis
au hasard :
| instant | nébulosité | précipitation | usage |
|---|---|---|---|
| j12 13 h | 0,14 | 0 | grand beau |
| j0 13 h | 0,54 (0,61 local) | 0 | mi-couvert |
| j8 13 h | 0,95 (0,99 local) | 4,9 mm/h (9,2 local) | pluie franche |
| j8 22 h | 0,98 local | 8,6 mm/h local | pluie au crépuscule |
| j169 9 h 15 | 0,99 local | 9,2 mm/h local, **neige**, −3 °C | neige de jour |
L'écart synoptique/local vient du renforcement orographique et du gradient
altitudinal déjà modélisés (section 7 de `WeatherParams`) : la vue de l'alpage
est à ~1 480 m sur un versant au vent.
---
## CHANTIER 1 — Rendre la météo visible
### Constat avant
Un jour de pluie à 95 % de nébulosité se rendait **exactement** comme un jour
de grand beau : ciel bleu vif, soleil franc (captures `build/phase27/avant/`).
Au passage, un **commentaire mensonger** dans `sunLightFor()` affirmait depuis
la Phase 23 que l'ambiante était « écrasée par les nuages en plein jour » ; le
code n'a **jamais** lu la nébulosité. Corrigé.
### Architecture
Une seule fonction pure, **`weatherVisualsFor(sky, local, params)`**
(`world/Weather.hpp/.cpp`), est la traduction météo → image de tout le jeu.
Elle ne calcule **aucune** grandeur météo : elle lit l'état synoptique et
l'échantillon **local au joueur** que `main.cpp` calculait déjà une fois par
image, et part de `sunLightFor()`. Par ciel clair et sol sec, elle rend
`sunLightFor()` **au bit près** (testé).
### Traçabilité : quelle grandeur pilote quel effet
| effet visuel | grandeur Weather qui le pilote | coefficient d'affichage (PROVISOIRE, `WeatherParams` §6 ter) |
|---|---|---|
| soleil direct voilé | `WeatherSample::cloudCover` (local) | **aucun nouveau** : réutilise `cloudAspectDamping` (0,85), qui modélisait déjà « les nuages cachent le soleil » pour l'adret |
| ambiante diffuse renforcée, de jour seulement | `cloudCover` × part de jour (`daylight`) | `overcastAmbientGain` = 1,0 |
| ciel grisé (désaturé vers sa propre luminance, jour/nuit intact) | `cloudCover` | `overcastSkyDarkening` = 0,80 |
| pluie / neige à l'écran : densité et opacité | `precipitationMmPerHour` (local) / `precipitationMaxMmPerHour` | aucun (ratio de deux valeurs existantes) |
| neige plutôt que pluie | `snowing` (donc `temperatureC` local vs `snowThresholdC`) | — |
| inclinaison des traits | `windVector` (vent **local** : sondage amont, cols, abris) | `rainFallSpeedMps` 6,5 / `snowFallSpeedMps` 1,2 (vitesses terminales usuelles) |
| brouillard de distance | `precipitationMmPerHour` (local), `snowing` | `rainExtinctionPerKm` 0,25 × R^`0,63` (1/km), × `snowExtinctionMultiplier` 8 pour la neige |
| sol assombri | `wetness` (relecture de la pluie des 6 dernières heures, Phase 23) | `wetGroundDarkening` = 0,35 |
| couleur du brouillard | = couleur du ciel ci-dessus | — |
**Aucun effet n'existe sans sa grandeur.** C'est vérifié par
`testWeatherVisuals()` : ciel clair et sec ⇒ lumière de la Phase 23 au bit
près, brouillard nul, pluie nulle, sol non assombri ; et, sur **30 jours de jeu
à la minute**, pluie et brouillard à l'écran **exactement** quand la météo
calcule une précipitation, jamais sinon (0 écart sur 43 200 minutes).
### Cohérence temporelle (point 4 du cahier des charges)
Mesurée, pas supposée : sur 30 jours à la minute, le saut maximal d'une minute
à l'autre vaut 0,022 pour la couleur du ciel, 0,004 pour l'intensité de pluie,
6,5·10⁻⁵ /m pour le brouillard (montée d'une averse de neige, lisse). Les effets
suivent le calendrier synoptique comme le cycle jour/nuit, sans aléa propre.
**Une discontinuité, trouvée par le test et laissée telle quelle** : la bascule
**pluie ↔ neige** (j1 6 h 55 à 1 500 m : visibilité de 1,6 km à 13 km en une
minute). Elle vient du **modèle** — `snowing` est un booléen au seuil
`snowThresholdC` — et non du rendu. La lisser demanderait une phase mixte que
Weather ne modélise pas (voir prérequis). Le test isole ces minutes (2 bascules
sur 30 jours) et fait échouer **tout autre** saut.
### Rendu
* `UniformBufferObject` : quatre `vec4` en fin de bloc (`fog`, `precip`, `fall`,
`detail`), **neutres par défaut** — sans appel, l'image est celle de la
Phase 26.
* Brouillard : extinction de Beer-Lambert `exp(-σ d)`, **même fonction** dans
`terrain.frag`, `foliage.frag`, `cube.frag` (sinon les arbres ressortiraient
nets du voile). σ = 0 ⇒ couleur rendue inchangée.
* Pluie/neige : `precip.vert/.frag`, **un triangle plein écran** sans buffer de
sommets, trois couches de traits procéduraux, mélange alpha, sans profondeur.
La passe est **sautée entièrement** (aucun bind, aucun draw) quand
l'intensité vaut 0. Les traits sont collés à l'écran : ils ne passent pas
derrière un tronc — compromis assumé « effet d'écran simple ».
* Sol mouillé : `albedo *= 1 − precip.w` dans `terrain.frag`.
### Un effet mort trouvé par le journal des captures
Première série « après » : le journal affichait **`ambiante x1.00` sous 99 % de
nuages**. Le multiplicateur d'ambiante était écrêté à [0, 1] deux fois (dans
`weatherVisualsFor` et dans `Renderer::setSun`) ; or il vaut déjà 1 en plein
jour : le gain de ciel couvert ne s'appliquait **jamais**. Le test « monotone »
ne pouvait pas le voir (une constante ne décroît pas). Corrigé (borne à 4), et
un test exige désormais que l'effet **existe** (> ×1,5 sous ciel couvert).
### Vérification
* Tests headless : **3631 / 3631** (3607 + 24 nouveaux, `testWeatherVisuals`).
* Captures `build/phase27/planche_meteo.png` (témoin `--no-weather-visuals` à
gauche, Phase 27 à droite), 5 instants, **0 `[Validation]`** sur les 20
lancements Debug (avant, après, témoin, v1).
* Neutralité du témoin : témoin vs capture d'avant = 0,4 à 2,9 % de pixels
à plus de 8 niveaux (herbe animée) — le drapeau rend bien la Phase 26.
* Effet proportionné à la donnée : grand beau (nébulosité 0,14) = 3,5 % de
pixels changés ; mi-couvert 88 % ; pluie 94 %.
* Fausse alerte écartée par la mesure : le ciel « gris clair » de j8 22 h n'est
pas un bug — à 22 h fin mai c'est encore le crépuscule ; ciel témoin
(48, 56, 84), ciel Phase 27 (51, 51, 52) : même luminance, désaturée.
### Prérequis manquants — NON implémentés, faute de grandeur Weather
| effet envisagé | ce qui manque dans Weather |
|---|---|
| brume par temps sec, brume de vallée dans les cuvettes (la carte de piégeage d'air froid existe) | humidité relative / point de rosée : sans eux, rien ne dit **quand** l'air froid piégé condense |
| nuages accrochés au relief, plafond bas | altitude de la **base des nuages** : la nébulosité est une fraction de ciel, pas une hauteur |
| transition douce pluie ↔ neige (neige fondue) | une **phase mixte** de précipitation ; `snowing` est un booléen |
| sol **blanchi** par la neige | un **manteau neigeux** (accumulation / fonte) ; aujourd'hui une chute de neige mouille le sol (`wetness`) et le fonce, ce qui est ce que dit le modèle |
| nuages visibles, soleil voilé localement, éclaircies qui défilent | une nébulosité **spatialisée** (champ 2D advecté par le vent) ; la nébulosité est 0D + un renforcement orographique au point |
| éclairs / orage | aucune convection profonde modélisée |
---
## CHANTIER 3 — Micro-relief du sol vu de près
### Approche retenue
Texture de détail **procédurale** perturbant la **normale** (le grain réagit au
soleil de Weather) et, légèrement, l'albédo — pas de micro-déplacement
géométrique (il aurait fallu densifier les tuiles CDLOD proches : bien plus
cher et plus risqué pour le LOD).
* **Bande de fréquences** : de 0,61 m (= le texel de l'orthophoto, lu sur la
texture réellement chargée, `TextureData::metresPerTexel()`) jusqu'à ~5 mm,
en 7 octaves de rapport 2,2. Rien au-dessus du texel : le grain ne contredit
jamais la photo.
* **Amplitude pilotée par des données réelles** : contraste local de
l'orthophoto (photo nette contre sa version 2 mipmaps plus floue — éboulis
contrasté contre prairie lisse) et pente du relief LiDAR (1 − N.y). Plancher
50 %. **Le motif lui-même est un bruit** et ne représente aucun caillou réel ;
c'est dit dans le shader.
* **La normale perturbée ne sert qu'à l'éclairage** : l'indice adret/ubac garde
la normale du relief (il doit dire la même chose que la météo).
* **Deux fondus** : par distance (5 → 20 m) et **par octave selon l'empreinte
du pixel** (`fwidth`, Nyquist : plein poids ≥ 4 px, éteint à 2 px) — c'est ce
second fondu qui interdit le moiré en vue rasante. Les mipmaps de la texture
filtrent en plus le sous-pixel. Lectures en `textureGrad` avec dérivées
prises hors branche (boucle à sortie non uniforme).
### Paramètres finaux
| paramètre | valeur | où |
|---|---|---|
| force | 1,0 | `kGroundDetailStrength` (`main.cpp`) |
| fondu distance | 5 → 20 m | `kGroundDetailFadeStart/End` |
| motif de base | texel de l'ortho (0,610 m), 0,61 par défaut | `groundDetailPattern` |
| octaves / lacunarité | 7 / 2,2 | `terrain.frag` |
| pente max du grain | 1,3 × amplitude | `kDetailSlope` |
| couleur | ±30 % en crête, ±10 % typique | `kDetailAlbedo` = 0,30 |
| rugosité pleine | contraste photo 0,12 ou pente 0,35 | `kDetailFullContrast/Slope` |
| texture de bruit | 256², 32 cellules, RGBA8 + 9 mips (341 Ko) | `assets/DetailNoise.cpp`, binding 2, adressage REPEAT |
### Vérification
`build/phase27/planche_sol.png` (témoin `--no-ground-detail` à gauche).
Énergie haute fréquence (laplacien) mesurée sur les captures :
| vue | sol proche (moitié basse) | loin (tiers haut) |
|---|---|---|
| au ras du sol | 5,92 → **7,24 (+22 %)** | — |
| vue de marche | — | 3,01 → **3,01 (inchangé)** |
Le sol est visiblement grenu sous les pieds, et **rien** n'est ajouté au loin
(pas de moiré mesurable sur image fixe). **Limite** : des images fixes ne
prouvent pas l'absence de scintillement **en mouvement** ; le fondu de Nyquist
le prévient par construction, non vérifié en déplacement.
### Une première version rejetée PAR LA MESURE
La v1 calculait le bruit dans le shader. Première mesure de l'effet visuel :
énergie HF proche **inchangée** (5,92 → 5,91) — 4 octaves s'arrêtaient à 6 cm,
soit 15 pixels à 2 m : de l'ondulation, pas du grain ; et l'amplitude était
divisée deux fois (normalisation + moyenne des gradients). Corrigé à 7 octaves.
Puis son coût s'est révélé inacceptable → bruit en texture (chantier 2).
---
## CHANTIER 2 — Profilage et optimisation
### Protocole (`tools/profile_phase27.ps1`)
* Paires A/B **entrelacées** (AB, BA, AB…), B = témoin **étroit** de l'ajout
mesuré (`--no-weather-visuals`, `--no-ground-detail`, ou les deux = Phase 26).
* Métrique : `Cadence de boucle` (µs par image réelles) et les postes
`Cout par image (PHASE 19)`.
* **Santé machine par run** : charge totale échantillonnée pendant le run moins
le CPU de vercora. Plus d'un cœur entier ⇒ **NON CONCLUANT**, exclu des
médianes ; moins de 20 img/s ⇒ NON CONCLUANT (« n'a pas pu rendre »).
* Machine : i5-14600K, UHD 770 intégré, 1280×720.
**Deux défauts de l'outil trouvés en l'écrivant** : la 1re version du témoin de
santé sommait `TotalProcessorTime` sur une liste de processus qui change pendant
le run (« 318 910 % d'un cœur ») — remplacée par un échantillonnage de charge ;
et le bureau au repos (application Claude, webviews, Discord) consomme 25 à
130 % d'un cœur, d'où un seuil à 1 cœur, justifié dans le script. Beaucoup de
runs ont été écartés à ce titre : les tableaux ci-dessous n'utilisent que les
runs sains, et le signalent quand il n'en restait pas.
### Leçon de méthode : un poste CPU n'est pas un témoin sur GPU intégré
Sous la pluie, l'herbe (CPU) a été **systématiquement** plus lente en A qu'en B
(495 contre 374 µs, +32 %), tour après tour, **dans les deux ordres** — donc pas
une dérive de la machine. Par beau temps, où A et B chargent le GPU pareil :
écart 4 %. Sur un GPU **intégré**, CPU et GPU partagent le budget de puissance
du boîtier ; charger le GPU ralentit le CPU. Le témoin CPU est donc **couplé** à
toute modification GPU et ne peut pas la valider. Il reste valide quand la
condition ne change pas la charge GPU (beau temps : 4 % ; vue de marche finale :
2 %).
### Profil actuel (tout le contenu depuis la Phase 19), médianes
| config / vue | total | drawFrame | herbe | arbres | fibres | streaming |
|---|---:|---:|---:|---:|---:|---:|
| Release, vue fixe alpage, beau | 4 962 µs | 4 228 (**85 %**) | 408 | 253 | 17 | 14 |
| Release, survol 900 m/s (Phase 26) | 1 495 µs | 1 126 (75 %) | 1 | 241 | 10 | 82 |
| Debug, vue fixe alpage, beau | 7 838 µs | 2 099 (27 %) | **3 482 (44 %)** | 1 775 | 191 | 95 |
| Debug, survol 900 m/s (Phase 26) | 4 429 µs | 1 236 (28 %) | 9 | 1 987 | 124 | 939 |
* **Release est limité par le GPU** (75–85 % dans `drawFrame`) : optimiser les
postes CPU (herbe 0,4 ms, arbres 0,25 ms) ne rendrait **rien**, conformément
à la Phase 19. **Aucune optimisation CPU n'a donc été faite.**
* **Debug est limité par le CPU** (herbe 44 %) : le même changement GPU y est
invisible — la pluie y coûte −83 µs (bruit). Mesurer en Debug seul aurait
conclu « gratuit ». La leçon de la Phase 19 se vérifie encore.
* Les chiffres de survol ne sont pas comparables tels quels à ceux de l'audit
(378 img/s) : l'audit ne précisait ni jour, ni heure, ni drapeaux ; ici le
survol est épinglé à j8/j12 13 h.
### Coût des ajouts de la Phase 27 (Release, A − B)
| mesure | coût | statut |
|---|---:|---|
| beau temps, vue fixe (contrôle négatif météo) | −28 µs (0) | gratuit par temps sec |
| survol beau temps (shaders modifiés, rien d'actif) | +54 µs (+3,6 %) | surcoût fixe des shaders |
| **pluie, vue fixe** (passe plein écran + brouillard + sol mouillé) | **+608 µs (+12 %)** | **accepté** : seulement quand il pleut, ~180 img/s |
| survol sous la pluie | +684 µs | idem (≈ passe de pluie) |
| micro-relief v1, au ras du sol | **+1 683 µs (×1,94)** | **rejeté** |
| v1 + Nyquist resserré à 8 px | +1 490 µs | insuffisant |
| v1 sans aucune octave (bissection) | +330 µs | ⇒ ~200 µs **par octave** |
| v1 à 2 octaves (bissection) | +720 µs | confirme : ALU, pas un surcoût fixe |
| v1 avec hash flottant au lieu d'entier | ≈ inchangé | hypothèse réfutée |
| **v3 : bruit en texture**, au ras du sol | **≈ +900 µs** | −47 % |
| v3 sans la lecture floue d'ortho (bissection) | ≈ inchangé | lecture gratuite, conservée |
| v3, **vue de marche**, fondu 35 m | +623 µs (+15 %) | |
| **v3, vue de marche, fondu 20 m (final)** | **+480 µs (+11 %)** | **retenu**, témoin stable (2 %) |
(Les valeurs « ≈ » viennent de runs dont les A ont tous dépassé de peu le seuil
de santé, sans médiane formelle ; leur dispersion était de ±0,2 %.)
Seule optimisation livrée : **le micro-relief**, le seul poste nouveau mesuré
comme significatif — de +1 683 à ~+900 µs dans le pire cas, et +480 µs en vue de
marche. Trois hypothèses ont été **réfutées par la mesure** avant de trouver la
bonne (octaves fines, hash entier, lecture floue) ; aucune n'a été gardée « au
cas où ».
**Non fait, et pourquoi** : la passe de pluie (+608 µs) n'est active que
pendant les précipitations (~9 % du temps sur 30 jours de jeu) et le jeu y
reste vers 180 img/s ; l'alléger (moins de couches, demi-résolution) dégraderait
la lisibilité, qui est l'objectif du chantier 1. À reprendre si une cible plus
faible que l'UHD 770 est visée.
---
## Vérification globale
* Tests headless : **3636 / 3636** (3607 + 29 : `testWeatherVisuals`,
`testDetailNoise`).
* 0 `[Validation]` sur toutes les captures Debug de la phase et sur les runs
Debug de profilage.
* Suite `run_vulkan_check.ps1` (build Debug final, couches de validation) :
**verte au premier passage** — scénarios A à J3 (14 processus : gameplay,
collision, dalle LiDAR, parapente, vélo, escalade « sommet atteint : True »,
éditeur G1-G3, besoins, faune, récolte et fibres), **Messages [Validation] :
0**, fermeture propre. Un seul passage : la flakiness historique du harnais
(D2 de l'audit) n'a donc pas été re-mesurée ici.
## Où je me suis arrêté
Les trois chantiers sont livrés. Restent ouverts, sciemment :
* scintillement du micro-relief **en mouvement** : non vérifié (images fixes
seulement) ;
* passe de pluie à +608 µs : non optimisée (voir chantier 2) ;
* effets météo qui demanderaient une mécanique absente de Weather : listés
dans « Prérequis manquants », non implémentés, par règle.
+320
Voir le fichier
@@ -0,0 +1,320 @@
# Phase 28 — Conception de l'artisanat diégétique (document de conception, aucun code)
Rédigé le 2026-09-27, en session sans supervision. Toutes les références
`fichier:ligne` ont été relues dans l'état actuel du dépôt (après
`3faf930`, fin de Phase 27). Aucune ligne de code n'a été modifiée ; aucun
build n'a été lancé.
**Document de cadrage d'origine : introuvable.** Il n'existe aucun fichier de
cadrage dans le dépôt ; il n'est connu que par citations (`MEMORY.md:14`,
`MEMORY.md:1825`, `NOTES-PHASE22.md:106`, « les trois matières du document de
cadrage qui manquaient »). Les exemples « outils primitifs, ligatures en fibres,
poix (résine + cendres), manches en bois dense » viennent donc de la consigne
de la Phase 28, pas d'une relecture du cadrage.
---
## 1. Inventaire vérifié
### 1.1 Le modèle d'objet commun : `GroundItem` + `Ground` + `Inventory`
| Élément | Référence | Ce qu'il fait |
|---|---|---|
| `enum class GroundItemKind : uint8_t` | `src/world/GroundItem.hpp:13-28` | 8 valeurs : `Log, Branch, Stone, Flake, Clay, Sand, Resin, Fiber` |
| `kGroundItemKindCount = 8` | `GroundItem.hpp:30` | **Taille codée en dur** de l'inventaire — à incrémenter avec chaque nouveau type |
| `groundItemRestRadius`, `groundItemLabel*` | `GroundItem.hpp:34-46` | Rayon de repos et libellés FR (sing./indéfini/pluriel), un `switch` par type dans `Ground.cpp` |
| `struct GroundItem {position, yaw, roll, kind}` | `GroundItem.hpp:51-58` | Objet couché, mesh à dimensions absolues, jamais mis à l'échelle |
| `Ground::drop(kind, x, z, yaw, roll)` | `src/world/Ground.hpp:37` | Pose à la surface (le Ground calcule Y) |
| `Ground::scatterStones` | `Ground.hpp:43` | Semis initial des pierres |
| `Ground::findNearest(pos, reach, vTol=3)` | `Ground.hpp:53` | Portée **horizontale**, un seul objet, tous types confondus |
| `Ground::pickUp(index, kindOut)` | `Ground.hpp:58` | Retire l'objet du monde |
| `Ground::items()` | `Ground.hpp:60` | Accès en lecture au vecteur — suffit pour une requête « objets de tel type dans un rayon » |
| `Inventory::add / count / remove / summary` | `src/world/Inventory.hpp:20, 24, 31, 49` | Simples **compteurs** par `GroundItemKind`, `remove` atomique (refuse sans rien toucher) |
Il n'existe **aucun** geste « reposer au sol » depuis l'inventaire (grep de
`inventory.remove` dans `main.cpp` : seul le taillage consomme). Il n'y a **pas
de notion d'objet tenu** distincte de l'inventaire : « porter » = être compté
dans `Inventory`. Pas de masse, pas d'encombrement (`Inventory.hpp:1-17`,
commentaire d'en-tête : « le jour où le portage à dos sera un vrai sujet, c'est
cette classe qui grossira »).
### 1.2 Les matériaux
| Matériau | `GroundItemKind` | Récolte (touche) | Fichiers / fonctions |
|---|---|---|---|
| Bûche | `Log` | Abattage **E** (`kFellKey`, `main.cpp:185`) : `Forest::pickTree` puis `Forest::fell` (`main.cpp:3016-3043`, `Forest.hpp:136`). Débitage différé : `Forest::scheduleBucking` (`Forest.cpp:589`), 2 à 4 bûches selon la hauteur (`Forest.cpp:606`), déposées par `advancePendingDrops` → `ground_.drop` (`Forest.cpp:507`). `Habitat::recordFelling` inscrit la coupe (`main.cpp:3033`) |
| Branche | `Branch` | Même chaîne que la bûche (houppier), `Forest::scheduleBucking` |
| Pierre | `Stone` | Semée par `Ground::scatterStones` ; ramassage **R** (`main.cpp:3049-3062`) |
| Éclat | `Flake` | Taillage **C** (`kKnapKey`, `main.cpp:187`) : `knapStones` (`src/world/Knapping.cpp:32-60`) |
| Argile | `Clay` | Creuser **Y** (`kDigKey`, `main.cpp:260`) près d'un gisement `DepositKind::Clay` : `findMineralDeposits` / `nearestDeposit` (`src/world/Deposits.hpp:165, 180`), portée `kDigReach = 3,5 m` (`Deposits.hpp:175`) ; dépôt au sol `main.cpp:2343-2379` |
| Sable | `Sand` | Idem, gisement `DepositKind::Sand` (loin de l'eau) |
| Résine | `Resin` | Saigner **U** (`kResinKey`, `main.cpp:261`) : `ResinStand::tap(treeIndex, species, now)` (`src/world/Resin.hpp:102`) ; 600 s entre deux saignées, 3 par arbre ; dépôt au pied de l'arbre `main.cpp:2385-2421` |
| Fibres | `Fiber` | Arracher **I** (`kFiberKey`, `main.cpp:262`) : `FiberPlants::pullNearest` (`src/world/FiberPlants.hpp:208`), portée `kPullReach = 2,5 m` (`:163`), repousse 420 s (`:129`) ; `main.cpp:2429-2451` |
Règle commune posée en Phase 6 et répétée en Phase 22 (`Knapping.hpp:36-40`,
`GroundItem.hpp:18-23`, `main.cpp:2337-2342`) : **ce qui est produit tombe
d'abord au sol**, jamais directement dans l'inventaire.
### 1.3 Le pattern Knapping (le modèle à généraliser)
`knapStones(Inventory&, Ground&, playerPos, facing)` (`Knapping.hpp:43`,
`Knapping.cpp:32`) :
1. vérifie les ingrédients dans l'inventaire (`count(Stone) < 2`, `.cpp:34`) ;
2. projette le regard à l'horizontale, **teste la longueur avant de normaliser**
(`.cpp:41-43`) ;
3. consomme **un seul** ingrédient — le nucleus ; le percuteur est un **outil
non consommé** (`.cpp:47`, justification `.hpp:29-32`) ;
4. dépose le produit à 1,1 m devant le joueur (`kDropDistance`, `.cpp:14`,
`ground.drop` `.cpp:57`) ;
5. renvoie un `enum` de résultat + `knapResultMessage` (message FR journalisé).
Aucune table de recettes « volontairement » (`Knapping.hpp:26-27`).
`creuser` (`main.cpp:2343`) duplique à la main la même projection + dépôt à
1,1 m : c'est un **deuxième exemplaire** du même geste, déjà factorisable.
### 1.4 Systèmes qu'un objet fabriqué peut influencer
| Système | Point d'ancrage réel | État |
|---|---|---|
| **Needs — abri** | `NeedsContext::sheltered` (`src/world/Needs.hpp:126`) ; effet `shelterWarmthC = 5 °C` (`Needs.hpp:220`), et annule le refroidissement éolien (`Needs.cpp:184-191`) | **Aucun appelant** (`MEMORY.md:1278`) : `main.cpp:2276-2299` ne le remplit jamais |
| **Needs — température** | `NeedsContext::ambientTemperatureC` rempli depuis `WeatherSample::temperatureC` (`main.cpp:2284`) ; `NeedsParams::comfortTemperatureC`, `exertionWarmthCPerEffort` | Aucune source de chaleur locale n'existe |
| **Needs — soif** | `Needs::drink()` (`Needs.cpp:269`) remet la soif à 1 ; appelé seulement à `kDrinkReach` d'un point d'eau (`main.cpp:2313-2322`) | Pas de contenant : on ne boit qu'au point d'eau |
| **Needs — faim** | `Needs::eat(nutrition)` (`Needs.cpp:277`) | **Aucun appelant**, rien de comestible n'existe (`MEMORY.md:1274`) |
| **Needs — vitesse** | `Needs::movementFactor()` (`Needs.hpp:375`) module la marche | — |
| **Lumière / nuit** | `WeatherParams::nightAmbientFactor = 0,30` (`src/world/Weather.hpp:405`), `sunLightFor` (`Weather.hpp:933`) ; « à revoir avec le feu de camp » (`MEMORY.md:2214`) | **Aucune lumière ponctuelle** dans le renderer (grep `fire/feu/foyer` : zéro) |
| **Vitesse d'abattage** | `Forest::fell` est **instantané** (`main.cpp:3025`) ; seul le débitage a un délai (`PendingDrop::delay`, `Forest.hpp:163`) ; portée `kFellingReach = 40 m` (`main.cpp:170`) | **Il n'y a pas de vitesse d'abattage** ; et abattre ne demande aucun outil |
| **Vitesse de taillage** | `knapStones` est instantané | Pas de durée non plus |
| **Rendement** | `logCount = clamp(h/2,4, 2, 4)` (`Forest.cpp:606`) | Quantité modulable sans nouveau système |
| **Sauvegarde** | Aucune sauvegarde de partie. Seul `F5` écrit la scène de l'éditeur (`main.cpp:320`, `src/editor/SceneFile.cpp`). « Rien n'est sauvegardé » (`MEMORY.md:1957`, `NOTES-PHASE22.md` fin) | Inexistant |
| **Tests headless** | `tests/logic_tests.cpp` : `testPickup` (l.477), `testStoneKnapping` (l.652), `testNeeds` (l.5158), `testMineralDeposits` (l.6788), `testResin` (l.6999), `testFiberPlants` (l.7177) ; lancés par `tools\run_logic_tests.bat` | 3578 assertions (chiffre de la Phase 23) |
**Conséquence de conception majeure** : il n'existe ni feu, ni cendres, ni
vitesse d'abattage/taillage, ni sauvegarde. La « poix (résine + cendres) » du
brief suppose un **foyer** qui n'existe pas : le foyer doit donc être lui-même le
premier objet fabriqué, et c'est lui qui produira les cendres.
---
## 2. Les objets fabricables (8), et la priorité
Convention : **« posé »** = objet `Ground` à portée de l'ouvrage ; **« porté »**
= compté dans `Inventory` ; **« outil »** = requis mais non consommé (règle du
percuteur, `Knapping.hpp:29-32`).
### P1 — Foyer (`GroundItemKind::Hearth`, nouveau) — **prioritaire**
- **Ingrédients** : 3 pierres **posées** (consommées) + 2 branches **posées**
(consommées).
- **Interaction** : le joueur pose lui-même pierres et branches au sol, se place
au-dessus et fait le geste d'assemblage (touche d'artisanat, cf. §3.3). Pas
d'allumage séparé cette phase : le foyer est allumé à la construction avec
l'éclat comme outil (percussion pierre/éclat = étincelle, même geste que le
Knapping, **éclat porté, non consommé**).
- **Effet** : `NeedsContext::ambientTemperatureC += hearthWarmthC` (proposé
8 °C, décroissant linéairement jusqu'à 6 m) pendant la durée de combustion
(proposée 1 h de jeu, prolongée d'1 h par branche ou bûche posée dans le
foyer). Branché dans `main.cpp:2284`, **même calcul de température unique** :
on corrige l'ambiante locale, on ne crée pas une seconde formule.
Produit **1 cendre** (`GroundItemKind::Ash`, nouveau) à son extinction, posée
au centre.
- **Lien matière** : pierres = cercle de foyer, branches = combustible ; les
bûches (trop grosses pour allumer) servent seulement à l'entretien.
- **Lumière** : **pas cette phase** (le renderer n'a pas de lumière ponctuelle).
Décision documentée en §4.
### P2 — Ligature de fibres (`Cord`, nouveau) — **prioritaire**
- **Ingrédients** : 3 fibres **portées**, consommées.
- **Interaction** : torsion à la main, geste identique au Knapping (depuis
l'inventaire, produit déposé à 1,1 m devant). Aucun poste.
- **Effet** : aucun direct — c'est l'intermédiaire obligatoire de P3, P5 et P6.
Le justifier comme objet et non comme étape cachée est ce qui rend la chaîne
visible au sol.
- **Lien matière** : ortie et ronce sont des sources de fibres textiles réelles.
### P3 — Hache emmanchée (`Axe`, nouveau) — **prioritaire**
- **Ingrédients** : 1 éclat + 1 branche + 1 ligature, **posés ensemble** (outil
composite = assemblage au sol, pas en poche). Tous consommés.
- **Interaction** : assemblage au sol à la touche d'artisanat ; même dépôt que
le Knapping.
- **Effet** : l'abattage n'ayant pas de durée, deux effets réels possibles ;
retenu : **rendement** — `Forest::scheduleBucking` donne +1 bûche
(`clamp(…, 3, 5)` au lieu de `2, 4`, `Forest.cpp:606`) si une hache est portée.
Option non retenue : rendre `fell` impossible sans hache (voir §4, risque de
régression du scénario Vulkan A).
- **Lien matière** : éclat = tranchant, branche = manche, fibre = ligature.
### P4 — Poix (`Pitch`, nouveau) — **prioritaire (dernier des quatre)**
- **Ingrédients** : 2 résines + 1 cendre, **posées près d'un foyer allumé**.
- **Interaction** : le foyer est le **poste** : on pose résine et cendre à moins
de 2 m d'un foyer en combustion et on fait le geste d'artisanat. Refus
journalisé « il faut chauffer la résine » sinon.
- **Effet** : ingrédient de P5 et P6 (colle imperméable) ; remplace la ligature
seule dans la hache renforcée (voir P5).
- **Lien matière** : la poix de résine + charbon/cendre est la colle
préhistorique attestée.
### P5 — Hache renforcée (poix) — secondaire
- 1 hache + 1 poix, posées. Effet : +2 bûches au lieu de +1. Pas d'usure
cette phase, donc l'intérêt est modeste : secondaire.
### P6 — Abri de branches (`Shelter`, nouveau) — secondaire, fort impact
- **Ingrédients** : 4 bûches + 6 branches + 2 ligatures, posés.
- **Interaction** : assemblage au sol ; l'abri devient un objet **non
ramassable** du Ground (voir §3.4).
- **Effet** : `NeedsContext::sheltered = true` quand le joueur est à moins de
2,5 m d'un abri — premier appelant de ce champ (`Needs.hpp:126`), +5 °C et
vent annulé (`Needs.cpp:184-191`). C'est l'usage des bûches annoncé en
`MEMORY.md:1718`.
- Repoussé car il demande une collision (l'abri doit être solide) et un mesh.
### P7 — Pot d'argile cuite (`ClayPot`, nouveau) — secondaire
- **Ingrédients** : 2 argiles + 1 sable (dégraissant), façonnés au sol, puis
**cuits** en restant posés 10 min de jeu à côté d'un foyer allumé
(transformation `RawPot → ClayPot` pilotée par le temps, même horloge
`elapsedSeconds` que `ResinStand`).
- **Effet** : rempli au point d'eau (touche **T**, `main.cpp:2313`), il permet
un `Needs::drink()` hors de portée d'eau (une gorgée par remplissage).
- **Lien matière** : le sable est le dégraissant qui empêche l'argile de se
fendre à la cuisson.
### P8 — Couteau à éclat emmanché — rejeté pour cette phase
Éclat + branche + ligature. Aucun système existant qu'il influencerait (pas de
dépeçage, pas de nourriture) : **écarté** selon la règle « aucune mécanique
déconnectée ». Listé pour mémoire.
**Les 4 prioritaires cette session : Foyer (P1), Ligature (P2), Hache (P3),
Poix (P4).** P1 donne le premier effet réel sur Needs et produit la cendre ; P2
et P3 débloquent la chaîne outil ; P4 exerce le « poste » (foyer) et termine la
chaîne cendre du brief.
---
## 3. Architecture : un craft générique qui étend Knapping, pas un système parallèle
### 3.1 Principe
Un nouveau module `src/world/Crafting.hpp/.cpp`, **sans Vulkan**, calqué sur
`Knapping` : une fonction libre qui prend `Inventory&`, `Ground&`, la position et
le regard, et renvoie un résultat + message. `knapStones` devient la **recette
n°0** exprimée dans la table (le test `testStoneKnapping` doit rester vert sans
modification, garde-fou de non-régression). La touche **C** reste la touche
unique du geste de « façonner » : pas de nouvelle touche, pas de menu.
### 3.2 Structure d'une recette
```
struct Ingredient { GroundItemKind kind; uint8_t count; Source source; bool consumed; };
enum class Source : uint8_t { Carried, Placed, Either };
enum class Station : uint8_t { None, LitHearth };
struct Recipe {
const char* id; // "hearth", "cord", ... (stable, sert aux logs/tests)
std::array<Ingredient, 4> in; uint8_t inCount;
GroundItemKind out; uint8_t outCount;
Station station; // poste requis à portée
float stationReach; // 2 m
const char* successMessage; // FR, même rôle que knapResultMessage
};
inline constexpr std::array<Recipe, N> kRecipes = {...}; // constexpr, pas de fichier externe
```
Table **constexpr** dans le code : testable, sans parsing, cohérente avec la
philosophie « paramètres regroupés et documentés » (`WeatherParams`, `NeedsParams`).
### 3.3 Détection et déclenchement
`CraftResult craftAt(Inventory&, Ground&, const CraftWorld&, pos, facing)`
où `CraftWorld` expose les postes (foyers allumés = objets `Hearth` du Ground
avec combustion > 0).
1. Collecte des objets **posés** : nouvelle méthode
`Ground::indicesWithin(pos, reach=2,5 m, vTol)` — même critère horizontal
que `findNearest` (`Ground.hpp:53`), mais renvoie tous les indices.
2. **Sélection de la recette** : on parcourt la table dans l'ordre de
**priorité décroissante de complexité** (abri avant hache avant ligature avant
percussion), et on prend la première satisfaite. Déterministe ; l'ordre est
la seule règle, documentée. Le joueur choisit donc la recette **en
choisissant ce qu'il pose** — c'est le geste diégétique.
3. Refus : si aucune recette n'est satisfaite, message sur la recette « la plus
proche » (celle dont il manque le moins d'ingrédients) : « il manque une
ligature », sur le modèle du refus avec distance de `creuser`
(`main.cpp:2349-2353`).
### 3.4 Consommation et création
- Tout est vérifié **avant** tout retrait (atomicité, même discipline que
`Inventory::remove`, `Inventory.hpp:28-30`). Retraits Ground par indices triés
**décroissants** (sinon `pickUp` décale les indices).
- Produit : `ground.drop(out, …)` à 1,1 m devant (portée de `kDropDistance`
réutilisée) — ou, pour un produit d'assemblage au sol, au **barycentre** des
ingrédients consommés : l'objet naît là où on l'a construit.
- Objets fixes (`Hearth`, `Shelter`) : ajout de `groundItemIsPortable(kind)`
dans `GroundItem.hpp` ; `findNearest` les ignore pour le ramassage.
- État propre au foyer (combustion restante) : un `HearthSet` séparé (indice
d'objet → secondes restantes), sur le modèle de `ResinStand` qui garde « la
mémoire des arbres saignés » hors de la Forest. `GroundItem` reste un POD
sans état.
- Alimenter un foyer = poser une branche/bûche à moins de 1 m puis **C** : c'est
une recette `Branch(Placed) + Station LitHearth → rien` avec effet
`+1 h`. Pas de cas particulier.
### 3.5 Branchement des effets
- Chaleur : dans `main.cpp` à côté de `main.cpp:2284`,
`ambientTemperatureC += hearthSet.warmthAt(playerPosition)`. Fonction pure,
testable.
- Hache : `Forest::scheduleBucking` reçoit un `bonusLogs` (0 par défaut) —
défaut = comportement actuel au bit près.
- Abri (P6, plus tard) : `needsContext.sheltered = shelterNear(...)`.
### 3.6 Sauvegarde
Aucune sauvegarde de partie n'existe ; **la Phase 28 n'en crée pas** (décision
§4). Préparation : `Recipe::id` stables, et `HearthSet` exprimé en temps de
jeu, pour qu'un futur format texte (modèle `SceneFile`/`.vcsc`) puisse écrire
`Ground::items()` + l'état des foyers sans changer de structure.
### 3.7 Tests headless à prévoir (`tests/logic_tests.cpp`)
- `testCraftingRecipeTable` : unicité des `id`, sorties hors ingrédients, ordre
de priorité respecté.
- `testCraftingKnapUnchanged` : la recette n°0 reproduit exactement
`testStoneKnapping` (2 pierres, 1 consommée, éclat à 1,1 m, regard vertical
→ repli sans NaN).
- `testCraftingAtomicity` : ingrédient manquant ⇒ Inventory et Ground
**identiques** octet pour octet.
- `testCraftingPlacedVsCarried` : un ingrédient `Placed` hors portée (2,6 m) ne
compte pas ; un `Carried` au sol ne compte pas.
- `testCraftingIndexRemoval` : consommation de plusieurs objets Ground non
contigus sans décalage.
- `testHearth` : chaleur maximale au centre, nulle à 6 m, extinction ⇒ cendre
déposée, alimentation prolonge ; foyer non ramassable.
- `testPitchNeedsLitHearth` : refus sans foyer, refus foyer éteint, succès.
- `testAxeYield` : `bonusLogs = 0` ⇒ `logCount` identique à avant ;
`= 1` ⇒ 3..5.
- `testNeeds` inchangé (garde-fou : ambiante non corrigée hors foyer).
- Vulkan : un scénario K optionnel (pierres + branches semées au départ, **C**,
vérifier le foyer dans le journal) — non bloquant cette phase.
---
## 4. Décisions prises par défaut et risques
| Décision | Justification |
|---|---|
| Foyer créé en P1 alors que le brief cite seulement la poix | La poix exige des cendres ; rien n'en produit. Inventer des cendres sans feu serait une mécanique déconnectée |
| Pas de lumière du foyer | Le renderer n'a aucune lumière ponctuelle ; l'ajouter est un chantier de rendu (UBO, 3 shaders) hors conception d'artisanat. `nightAmbientFactor` reste inchangé |
| Allumage inclus dans l'assemblage (éclat outil) | Évite un second geste et un état « foyer éteint neuf » sans usage |
| Hache = rendement, pas condition d'abattage | L'abattage est instantané et sans outil ; le rendre conditionnel casserait le scénario Vulkan A et le mode démo |
| Même touche **C** pour tout le façonnage | Zéro menu : la recette se choisit par ce qu'on pose, pas par une liste |
| Recettes en table constexpr | Testable, sans fichier de données à charger |
| Pas de sauvegarde | Aucune n'existe dans le jeu ; en créer une est une phase à part entière |
| Pas d'usure des outils | Aucune notion d'usure dans le jeu (`MEMORY.md:774`) |
| Couteau écarté | Aucun système à influencer |
**Risques de régression**
- `kGroundItemKindCount` (`GroundItem.hpp:30`) et tous les `switch` de
`Ground.cpp` (libellés, rayons) et des meshes (`StoneMesh`, `TreeMesh`,
`HarvestMesh`) : chaque nouveau type doit y être ajouté, sinon mesh ou libellé
manquant. Un test doit itérer sur tous les types.
- `Inventory::summary()` s'allonge (titre de fenêtre) : afficher seulement les
compteurs non nuls.
- Réécrire `knapStones` via la table : risque sur `testStoneKnapping` et les
scénarios A/B → garder `knapStones` comme façade.
- `findNearest` modifié pour ignorer les objets fixes : risque sur `testPickup`.
- Chaleur du foyer ajoutée à l'ambiante : vérifier que `testNeeds` et le scénario
H ne voient aucun foyer (valeur par défaut 0).
- Mode démo (`main.cpp:3010-3014`) : le façonnage doit rester coupé comme le
taillage.
- Portage : objets « posés » requis ⇒ il faut un geste pour **reposer** un
objet porté (absent aujourd'hui). À ajouter en même temps (proposé : **R**
maintenu = poser le dernier type ramassé), sinon P1 et P3 sont injouables.
+274
Voir le fichier
@@ -0,0 +1,274 @@
# Phase 28 - Faconnage generique et diegetique (implementation, Agent 2/4)
Session sans supervision du 2026-09-27. Conception de reference :
`NOTES-PHASE28-DESIGN.md`. Sauvegarde des sources avant la phase :
`_Vercora_backups\avant-phase28-20260927-0403`.
**Resultats** : tests headless **3636 -> 3807** (+171), tous verts.
Build Debug OK. Lancement court du jeu : **0 `[Validation]`** au demarrage
(PID arrete explicitement). `run_vulkan_check.ps1` et mesures de performance
NON lances (role de l'Agent 4).
## Architecture reelle
- **`src/world/Crafting.hpp/.cpp`** (sans Vulkan) : generalisation de
`knapStones`.
- `kRecipes` : table `constexpr` de 8 recettes `{id, label, in[3], inCount,
hasOutput, out, station, effect, successMessage}`. Ingredient =
`{kind, count, source Carried|Placed, consumed}` (`consumed=false` = outil).
- `craftAt(inventory, ground, hearths, pos, facing, nowHours)` : collecte
les objets POSES portables a `kCraftReach = 2,5 m` (nouvelle
`Ground::indicesWithin`), les postes (foyer allume / eteint a
`kStationReach = 2 m` du joueur), puis execute la PREMIERE recette
satisfaite. Verification complete avant tout retrait ; retraits Ground par
indices decroissants ; produit au barycentre des ingredients poses
consommes, sinon a 1,1 m devant (meme projection/repli que knapStones).
- Refus : recette "la plus proche" = moins d'unites manquantes, puis plus
d'unites deja reunies, puis la plus simple (plus loin dans la table). Le
message liste ce qui manque ("a porter" / "a poser a moins de 2,5 m" /
"un foyer allume ... (il faut chauffer)"). Si la plus proche est la
percussion, le message historique `knapResultMessage(NotEnoughStones)`
est rendu mot pour mot.
- `HearthSet` : etat de combustion A PART du Ground (modele ResinStand).
Foyer identifie par sa POSITION (les indices Ground ne sont pas stables).
Temps = heures de JEU (`GameClock::totalHours`). `update()` eteint les
foyers echus et depose **une cendre** au centre. `relight`, `feed`,
`remainingHours`, `nearest`.
- `chooseKindToPutDown` / `putDown` : le geste "reposer".
- **`src/world/CraftMesh.hpp/.cpp`** : 5 meshes bas-poly generes en code
(ligature = anneau, hache = manche + lame + ligature, foyer = 3 pierres +
2 branches croisees + fond noirci, cendre = tas gris plat, poix = galette
brun-noir). Dimensions absolues, bas du mesh a -rayon (teste).
- `knapStones` (Knapping.cpp) **inchange** : facade testee ; la recette
`knap` en reproduit le resultat au bit pres (test dedie).
## Recettes (ordre = priorite)
| id | ingredients | poste | produit / effet |
|---|---|---|---|
| `hearth` | 3 pierres posees + 2 branches posees (consommees), eclat PORTE (outil) | - | Foyer (fixe) ALLUME, 1 h de jeu |
| `hearth_relight` | 2 branches posees + eclat porte (outil) | foyer eteint | foyer rallume 1 h |
| `axe` | eclat + branche + ligature, POSES | - | Hache (au sol, ramassable) |
| `pitch` | 2 resines + 1 cendre, POSEES | foyer allume | Poix |
| `cord` | 3 fibres PORTEES | - | Ligature a 1,1 m devant |
| `hearth_feed_log` | 1 buche posee | foyer allume | +1 h de combustion |
| `hearth_feed_branch` | 1 branche posee | foyer allume | +1 h de combustion |
| `knap` | 2 pierres portees (1 consommee, 1 outil) | - | Eclat (Phase 6) |
## Nouveaux `GroundItemKind` (ajoutes EN FIN d'enum)
`Cord, Axe, Hearth, Ash, Pitch` ; `kGroundItemKindCount` 8 -> **13**. Mis a
jour : rayons + 3 libelles (`Ground.cpp`), table `groundMeshes` (`main.cpp`),
test de la table de rendu (`testDrawListConstruction`), nouvelle fonction
`groundItemIsPortable` (faux pour `Hearth` seul) utilisee par `findNearest`.
`Inventory::summary()` : les 8 matieres toujours affichees (comportement et
test anterieurs), les objets faconnes seulement si leur compteur est non nul.
## Controles
- **C** : faconner (inchange pour la percussion : deux pierres en poche et
rien de pose autour => meme resultat, memes messages).
- **P** (nouveau) : reposer au sol, 0,9 m devant, le dernier type ramasse s'il
en reste, sinon la premiere nature portee. Decalage en spirale d'angle d'or
(0,25 m x sqrt(n)) pour ne pas superposer les objets. Coupe en mode demo,
en vol, a velo, en escalade et en editeur, comme C et R.
- Combustion des foyers avancee a chaque image si l'horloge avance (horloge
gelee => feu fige) ; extinction journalisee.
## Decisions (non specifiees, prises par defaut)
1. **Touche P et non "R maintenu"** (proposition du §4 de la conception) : le
ramassage se declenche a l'APPUI de R ; un maintien aurait d'abord ramasse
puis repose. P est a la meme position en AZERTY et QWERTY.
2. **Foyer eteint = reste en place** (objet fixe) et peut etre **rallume**
(recette `hearth_relight`) : sans cela le test "poix refusee foyer eteint"
n'aurait pas d'objet, et un cercle de pierres qui disparait serait
invisible pour le joueur. Chaque extinction laisse UNE cendre.
3. **Portee du poste mesuree depuis le joueur** (2 m), pas depuis les
ingredients. Plus simple a lire en jeu et a tester.
4. **Alimentation** : n'importe quelle branche/buche POSEE a 2,5 m du joueur
avec un foyer allume a 2 m (le "1 m du foyer" de la conception n'a pas ete
retenu : une seule regle de portee). Consequence documentee : une branche
isolee posee pres d'un feu est brulee au prochain C si aucune recette plus
complexe n'est satisfaite.
5. **Duree 1 h de jeu, +1 h par alimentation** (valeurs proposees par la
conception), dans `HearthParams`. Pas de plafond.
6. **Pas de lumiere ni de flamme** : un seul mesh de foyer, allume ou eteint
(le renderer n'a pas de lumiere ponctuelle, §4 de la conception).
7. **Pas de sauvegarde** (aucune n'existe). `Recipe::id` stables et temps en
heures de jeu pour la suite.
8. `CraftMesh.cpp` recopie un helper de facette plutot que de modifier
`HarvestMesh.cpp` (zero risque de regression sur les meshes Phase 22).
9. Aucun fichier de `data/` touche.
## Points d'accroche pour l'Agent 3 (NON branches)
- **Chaleur** : `HearthSet::warmthAt(pos)` (pure, testee : 8 C au centre,
lineaire jusqu'a 0 a 6 m, 0 si eteint ; `HearthParams::warmthC/warmthRadius`).
A ajouter dans `main.cpp` apres `needsContext.ambientTemperatureC =
localWeather.temperatureC;` : `+= hearths.warmthAt(playerPosition)`.
`hearths` est declare dans `main.cpp` a cote de `inventory`.
- **Hache** : `inventory.count(GroundItemKind::Axe) > 0` ; `Forest::scheduleBucking`
n'a PAS ete modifie (bonus de buches a ajouter, defaut 0).
- **Abri** : rien (recette P6 non implementee) ; `groundItemIsPortable` est
pret pour un futur `Shelter` fixe.
- Scenario Vulkan K (conception §3.7) non ecrit.
## Fichiers touches
Nouveaux : `src/world/Crafting.hpp`, `src/world/Crafting.cpp`,
`src/world/CraftMesh.hpp`, `src/world/CraftMesh.cpp`, `NOTES-PHASE28.md`.
Modifies : `src/world/GroundItem.hpp`, `src/world/Ground.hpp`,
`src/world/Ground.cpp`, `src/world/Inventory.hpp`, `src/main.cpp`,
`CMakeLists.txt`, `tools/run_logic_tests.bat`, `tests/logic_tests.cpp`,
`MEMORY.md`.
## Tests ajoutes (`tests/logic_tests.cpp`)
`testCraftingRecipeTable` (ids, ordre, recettes, rayons/libelles/meshes de
toutes les natures, resume), `testCraftingKnapUnchanged` (percussion = knapStones
au bit pres, message de refus historique, regard vertical sans NaN),
`testCraftingCord`, `testCraftingHearth` (construction, eclat conserve,
barycentre, non ramassable, combustion, extinction + cendre, rallumage,
alimentation, chaleur), `testCraftingAxe` (ingredients non contigus
entrelaces, refus octet pour octet, porte vs pose, portee 2,6 m),
`testPitchNeedsLitHearth` (sans foyer, foyer eteint, foyer trop loin,
succes et consommation exacte), `testPutDown`. `testStoneKnapping` et
`testNeeds` inchanges.
---
# Agent 3/4 - effets branches (2026-09-27)
**Resultats** : tests headless **3807 -> 3877** (+70), tous verts. Build Debug
OK (tests + jeu). Lancement court (25 s, PID arrete explicitement) :
**0 `[Validation]`**. `run_vulkan_check.ps1` et mesures NON lances (Agent 4).
## Effets branches (tous sur des systemes EXISTANTS)
| Objet | Branchement | Chiffres |
|---|---|---|
| Foyer allume | `main.cpp` (bloc besoins) : `needsContext.ambientTemperatureC += hearths.warmthAt(playerPosition)` juste apres l'ambiante meteo | +8 C au centre, lineaire -> 0 a 6 m, somme des foyers allumes, 0 si eteint |
| Hache | `forest->setBuckingBonusLogs(axeBonusLogs(inventory))` avant `forest->update` ; `Forest::scheduleBucking` ajoute les buches | +1 buche par arbre (3..5 au lieu de 2..4) |
| Hache renforcee (P5, NOUVELLE) | recette `pitched_axe` : hache + poix POSEES ; meme branchement | +2 buches (pas de cumul avec la hache : le meilleur outil) |
| Abri (P6, NOUVEAU) | recette `shelter` : 4 buches + 6 branches + 2 ligatures POSEES ; `needsContext.sheltered = ground && shelterNear(*ground, playerPosition)` (premier appelant) | abrite a <= 2,5 m horizontal, tolerance verticale 3 m ; effet Needs existant : +5 C ressentis et vent annule |
**Interaction ambiante / Needs verifiee dans le code** (`Needs.cpp:171-205`) :
l'ambiante recue devient `lastAmbientC_` (journal "ambiante"), puis refroidissement
eolien (`windChillC`, seulement < 10 C et vent > 4,8 km/h, annule si abrite),
+ effort, - epuisement, + 5 C si abrite, puis marge au confort (12 C). La chaleur
du foyer passe donc par la MEME formule que la meteo, aucune seconde formule.
Le foyer rechauffe l'air AVANT le vent (le vent mord moins sur un air plus chaud).
## Decisions
1. **Poix** : la conception prevoit P5 (hache + poix -> +2 buches). Implementee
comme recette + nouvelle nature `PitchedAxe` (mesh = hache + manchon de poix).
Sans hache, la poix reste un ingredient (aucun autre effet).
2. **Hache jamais requise pour abattre** : `fell()` inchange ; bonus 0 par
defaut ; les buches bonus sont tirees APRES les buches de base et avant les
branches, avec des tirages RNG seulement si bonus > 0 -> sans hache, suite
aleatoire et journal ("Debitage en cours : N buches") identiques.
3. **Bonus lu au moment du debitage** (fin de l'amortissement), pas au coup
d'abattage : c'est l'outil porte a ce moment qui compte.
4. Buches bonus rangees a 1 m sur le cote du tronc (alternance gauche/droite),
jamais au-dela de la hauteur de l'arbre.
5. **Ordre de la table** (10 recettes) : `shelter, hearth, hearth_relight,
pitched_axe, axe, pitch, cord, hearth_feed_log, hearth_feed_branch, knap`.
6. **Abri NON solide** : pas de collision ajoutee (la conception la jugeait
necessaire ; l'ajouter touchait le CollisionSolver compose -> risque de
regression refuse en session sans supervision). Le joueur traverse l'abri.
7. Abri FIXE (`groundItemIsPortable` faux), mesh appentis 2,1 x 1,8 x 1,2 m
(`kShelterRadius = 0,6`), pose au barycentre, yaw = regard du joueur.
8. Deux assertions anterieures mises a jour (volontairement) : 8 -> 10 recettes,
13 -> 15 natures ; table de rendu du test (`testDrawListConstruction`) completee.
9. Aucun fichier de `data/` touche.
## Tests ajoutes
`testHearthWarmthEffect` (0/1,5/3/6/20 m, Needs recoit 2+6 C, jauge plus
haute pres du feu, eteint = identique au froid, rallume, deux feux additionnes),
`testAxeYieldEffect` (bonus 0/1/2, `buckingLogCount`, abattage reel 12 m :
4/5/6 buches et toujours 4 branches, abattage sans hache OK), `testShelterEffect`
(refus atomique ligature manquante, construction, barycentre, non ramassable,
portee 2,4/2,6 m, survol, ressenti > +5 C, mesh), hache renforcee.
## Pas fini / pour l'Agent 4
- Scenario Vulkan K (feu / abri au clavier) non ecrit ; A..H non relances ici.
- Collision de l'abri ; lumiere du foyer (renderer sans lumiere ponctuelle).
- Pot d'argile (P7) non fait.
- Fichiers touches : `GroundItem.hpp`, `Ground.cpp`, `Crafting.hpp/.cpp`,
`CraftMesh.hpp/.cpp`, `Forest.hpp/.cpp`, `main.cpp`, `tests/logic_tests.cpp`.
---
# Verification (Agent 4/4) - 2026-09-27
Protocole : avant chaque etape lourde, `Get-Process` sur vercora, cmake,
ninja, cl, msbuild, cargo et rustc (aucun trouve a chaque fois). Une seule
execution a la fois (lecon de la Phase 26). Aucun processus tue. `data\`
n'a pas ete touche. Aucune modification de code (aucun bug de la Phase 28 trouve).
## Resultats MESURES
| Point | Resultat |
|---|---|
| Tests headless (`tools\run_logic_tests.bat`) | **3877 / 3877**, code de retour 0 |
| Avertissements `/W4` des tests | 1 seul : `main.cpp(1280) C4244` (double -> float, `ortho.metresPerTexel()`), **anterieur** : meme ligne en 1268 dans la sauvegarde (Phase 27). Zero dans les fichiers de la Phase 28 |
| Build jeu (`clean` puis `tools\build.bat` Debug) | OK, 82/82, **zero** `warning C` |
| Suite Vulkan complete, passage 1 | 0 `[Validation]`, 0 `[ERROR]`, 4 `[WARN]` (les memes qu'avant), fermeture propre partout ; A B D E F G1-3 H I J J3 OK ; **C : arbre MANQUE** -> `[ECHEC]` |
| Suite Vulkan complete, passage 2 | identique : 0 `[Validation]`, seul C echoue, meme cause |
| `run_vulkan_check.ps1 -Only C` | **OK** : arbre abattu, 6 objets ramasses, 0 `[Validation]` |
**Diagnostic de C (harnais, pas Phase 28)** : le jeu repond "aucun arbre dans la
ligne de visee". Arrivee de la navigation a 0,82 m puis 0,84 m de la cible
(echecs) contre 0,75 m (succes). Dans le journal brut, la camera diverge
DES LE PREMIER PAS entre la Phase 27 et maintenant (x = -5,05 contre -4,97),
avant toute logique neuve ; `pickTree`, `fell`, `Camera`, collision : zero
ligne modifiee (diff). C'est la limite du canal d'entree deja mesuree
(MEMORY, Phase 26 : ~0,8 m, 0,78 abattu / 0,80 manque). **Aucune execution
complete n'a donc ete verte de bout en bout** ; chaque scenario a ete vert
au moins une fois sur le binaire final.
## Performance (mesuree, Debug + validation, meme harnais)
Comparaison des 14 lignes `Cadence de boucle (PHASE 27)` du journal brut de
la suite de la Phase 27 (`%TEMP%\vercora_run_20260924-175538.log`) et du
passage 1 (`vercora_run_20260927-043937.log`), processus par processus (us/image) :
5760->5343, 5623->4759, 6395->5532, 6685->5992, 5848->5646, 4147->3976,
1852->1804, 1689->1632, 2113->2135 (+1 %), 2096->2092, 7127->6347,
7024->6101, 4788->4030, 7030->6913. **Aucune regression** : 13 sur 14
egaux ou plus rapides, un seul a +1 % (bruit). NON mesure : Release, A/B
entrelace (`profile_phase27.ps1`) - sans foyer ni abri le cout ajoute par
image est une boucle `shelterNear` sur les objets du sol et un
`warmthAt` sur une liste vide.
## Non-regression par relecture (diff sauvegarde -> actuel)
Fichiers modifies : `main.cpp`, `Forest.cpp/.hpp`, `Ground.cpp/.hpp`,
`GroundItem.hpp`, `Inventory.hpp`, `CMakeLists.txt`, `run_logic_tests.bat`,
`logic_tests.cpp` (+790, aucune ligne retiree) ; nouveaux `Crafting.*`,
`CraftMesh.*`. **Aucune ligne changee** dans Weather, Needs, Wildlife,
Habitat, Paraglider, Bike, Climber, CollisionSolver/Camera, StoneMesh, shaders.
- Taille de pierre : `kStoneRadius`/StoneMesh intouches ; ordre de l'enum 0..7 conserve.
- Abattage sans hache (A) : `fell` intouche ; `buckingLogCount(h,0)` = ancienne
formule ; boucle bonus sans tirage RNG si bonus 0 ; message "Debitage" identique
a bonus 0. Scenario A vert dans les deux passages (2 arbres, 8 ramassages, 1 percussion).
- Needs : `+ warmthAt` = +0 sans foyer ; `sheltered` passe de "jamais ecrit"
(defaut false) a `shelterNear` = false sans abri. Scenario H vert.
- Percussion : message de succes identique mot pour mot (harnais : "eclat
tranchant se detache" trouve). Seule difference de journal : la ligne
"Inventaire : ..." dit "un eclat est au sol" au lieu de "l'eclat est au sol".
- `findNearest` ignore les objets fixes (Hearth, Shelter seulement).
- Remarque cosmetique : le BOM UTF-8 de `main.cpp` a disparu ; ses seuls octets
non ASCII sont dans des commentaires (l. 899-900), sans effet sur le binaire.
- Comportement neuf a connaitre (voulu, non bug) : C avec 3 fibres en poche fait
une ligature AVANT la percussion ; une branche posee pres d'un feu allume est
brulee au prochain C.
## Pas fini (inchange)
Collision de l'abri (le joueur le traverse) ; pot d'argile (P7) ; lumiere du
foyer (pas de lumiere ponctuelle dans le renderer) ; scenario Vulkan K (feu/abri
au clavier) non ecrit ; flakiness de navigation du scenario C (harnais).
+153
Voir le fichier
@@ -0,0 +1,153 @@
# Phase 29 - Rochers, pierriers, buissons : donnees reelles (Agent 1/4)
Session sans supervision du 2026-09-27. Aucun fichier de `src\`, `shaders\`, `tests\`
ni de donnee existante modifie ; aucun build. Tout le derive est dans `data\phase29\`.
Scripts executes avec `py -3.14` (seul Python de la machine qui a laspy 2.7 + lazrs ;
le `python` par defaut, 3.10, ne l'a pas).
## 1. Donnees disponibles (VERIFIE)
| fichier | contenu |
|---|---|
| `data\lidar\*.copc.laz` (26) | nuages classes ; 25 dalles de la zone + `0907_6440` (hors zone) |
| `assets\terrain\vercora_zone_1m.vchm` | DTM 5001x5001, pas 1 m, origine E 899000 / N 6440000 (coin NO), 1029-2285 m |
| `assets\terrain\vercora_zone_canopy.vchm` | couvert 5 m 1001x1001 = (c3+c4+c5)/valides (tools/lidar_to_canopy.py) |
| `assets\terrain\vercora_zone_canopy_height.vchm` | z max classe 5 - z min sol, 5 m |
| `data\ortho\*.jpg` | ortho 0,5 m, dalles nommees par coin SO (validation independante) |
| **nouveau** `data\phase29\vercora_zone_lowveg.vchm` | **F3 = c3 / retours valides**, 5 m, meme emprise/convention que le couvert |
| **nouveau** `data\phase29\vercora_zone_lowveg_height.vchm` | z max classe 3 - z min sol (m), ecrete 0..10, 0 sans classe 3 |
| `data\phase29\class_counts_5m.npz` | comptes par classe (1,2,3,4,5,6,9,17,64...) par cellule 5 m, z3max, z3sum, gmin |
| `data\phase29\class_totals.csv` | comptes par dalle et par classe |
Scripts (lecture seule) : `data\phase29\rasterize_classes.py` (LAZ -> npz, ~2 min),
`probe_rocks.py [SMIN SMAX CMAX RMIN]` (sondage + PNG), `export_vchm.py`.
Coordonnees monde : `worldX = E - 901500`, `worldZ = 6437500 - N` (Heightmap.cpp l.240-255).
## 2. Classe 3 : EXISTE, DISTINCTE, EXPLOITABLE
Mesure (25 dalles, cf. class_totals.csv) : la classe 3 est presente dans 24 dalles sur 25,
de 0,5 M a 6,1 M points par dalle, avec des comptes indépendants des classes 4 et 5.
- Fraction F3 par cellule 5 m : p50 0,016 ; p75 0,065 ; p90 0,136 ; p99 0,31.
- corr(F3, F45) = **-0,19** : ce n'est PAS un doublon de la canopee (elle vit a cote).
- Hauteur z max c3 - sol : p10 1,1 / p50 2,5 / p90 4,5 m ; hauteur MOYENNE p50 1,5 m -> buissons.
- Densite classe 3 : moyenne 1,7 pt/m2 (p50 0,6 ; p90 4,9) sur ~33 pts/m2 totaux.
**Resolution utile : 5 m** (~40 pts c3/cellule la ou il y a du buisson). 2 m possible
mais bruite (≈3 pts/cellule en mediane) ; 1 m non.
- Deja rasterisee ? **Non separement** : elle est fondue dans le couvert (c3+c4+c5). Elle
l'est maintenant dans `vercora_zone_lowveg.vchm` (nouveau fichier).
- Limite mesuree : **dalle `0902_6438` quasi sans vegetation classee** (c3 = 988 pts,
c1 = 1,85 M) et c1 eleve dans 0901_6438, 0902_6439, 0903_6438/39/40 (~4-6 %). A l'ortho
ces dalles sont le plateau karstique clair, donc plausible, mais une sous-classification
n'est pas exclue (supposition). La classe 3 n'y creera simplement pas de buissons.
- F3 ne correle pas a la luminance ortho (0,03 ; F45 : -0,69) : a l'ortho un buisson ne se
distingue pas d'une pelouse. Validation par la hauteur, pas par la couleur.
Le proxy « lisiere » (F45 < 0,3 a <= 10 m d'une cellule F45 > 0,5, 11,5 % de la zone) a un
F3 moyen de 0,109 contre 0,046 sur la zone : il est coherent, mais **inutile** puisque la
classe 3 est la ; a garder seulement comme repli sur terrain sans carte.
### Critere BUISSON retenu
`F3 >= 0,10 ET F45 < 0,20` (F45 = couvert - F3, ou directement c4+c5).
= 10,5 % de la zone (2,62 km2). Variantes mesurees : F3 >= 0,05 -> 16,4 % ; >= 0,20 -> 3,5 %.
Densite recommandee : lineaire de F3 = 0,10 (rare) a 0,30 (~p99, plein). Taille : tirer
sous `lowveg_height` (p50 2,5 m), ecretee a 3 m pour rester des buissons. `F45 < 0,20`
evite de doubler les arbres deja semes par Vegetation (coverMin = 0,20).
Ce qui est suppose : l'espece (pin a crochets rampant / genevrier / aulne) n'est pas dans la donnee.
## 3. Rochers et pierriers
Seuils de reference du code : `kWalkComfortSlope = 0.60`, `kWalkMaxSlope = 0.84` =
`ClimberParams::wallSlope` (`src\core\SlopeLimits.hpp`) ; pente = `Climber::slopeAt`
(`src\world\Climber.cpp`), differences centrees demi-base `slopeSampleStep = 2 m`.
La sonde reproduit exactement cette pente sur le DTM 1 m.
### Critere PIERRIER retenu
`0,60 <= pente(base 4 m) < 0,84 ET couvert < 0,10 ET hors bati/eau`
- 0,84 : sous le seuil de paroi, par contrat (au-dessus c'est Climber).
- 0,60 : pente de marche confortable ; c'est aussi 31°, bas de l'angle de repos des eboulis
(31-40°). Sous 0,60, les zones nues sont majoritairement pelouses/pistes (mesure ci-dessous).
- couvert < 0,10 : sol nu au LiDAR (les parois de reference ont couvert ≈ 0).
- bati/eau : cellule 5 m avec >= 1 point classe 6, dilatee 10 m, ou classe 9 dilatee 5 m.
Effet mesure : **2 272 m2 seulement** retires (le bati est hors des pentes 0,6-0,84) ;
utile quand meme comme garde-fou (classe 6 : 0 a 266 k pts/dalle). Classe 9 : 230 pts, 1 dalle.
- **Rugosite ecartee comme filtre** : RMS du residu DTM - moyenne 5x5. Elle retirait 37 %
de la surface mais les rejetes sont AUSSI clairs a l'ortho (lum 166 vs 158) : un eboulis
fin est lisse a 1 m. A employer pour CHOISIR le mesh : rugosite >= 0,10 m -> gros blocs
(StoneMesh a l'echelle), < 0,10 -> pierraille fine (petits cailloux denses).
### Chiffres du sondage (probe_default.log)
Surface : **2,226 km2 (8,9 % de la zone)** ; dont rugueuse (>= 0,10 m) 1,395 km2.
Validation ortho (independante) : luminance moyenne **161** dans le masque contre 116 sur la
zone ; pixels clairs (> 140) **64 %** contre 32 %. Pelouse nue de reference : 113 ; paroi : 190.
Par tranche de pente, part NUE (couvert < 0,1) et luminance :
| pente | % zone | nu | lum nu |
|---|---|---|---|
| 0-0,30 | 20,4 | 6,9 | 152 |
| 0,30-0,45 | 25,2 | 6,8 | 150 |
| 0,45-0,60 | 22,4 | 7,6 | 154 |
| **0,60-0,70** | 11,3 | 5,0 | 164 |
| **0,70-0,84** | 8,2 | 3,9 | 157 |
| 0,84-1,00 | 4,2 | 2,1 | 156 |
| >= 1,00 | 8,4 | 5,9 | 161-181 |
Histogramme du masque rugueux (m2), altitude x pente [0,60 ;0,66 ;0,72 ;0,78 ;0,84[ :
| altitude | 0,60 | 0,66 | 0,72 | 0,78 | total | part de l'etage |
|---|---|---|---|---|---|---|
| 1000-1200 | 289 | 145 | 107 | 58 | 599 | 0,1 % |
| 1200-1400 | 907 | 657 | 528 | 362 | 2 454 | 0,1 % |
| 1400-1600 | 20 325 | 18 881 | 15 487 | 11 815 | 66 508 | 1,1 % |
| 1600-1800 | 100 764 | 117 042 | 109 416 | 90 904 | 418 126 | 6,5 % |
| 1800-2000 | 184 609 | 181 903 | 164 057 | 134 488 | 665 057 | 12,1 % |
| 2000-2300 | 68 000 | 65 836 | 58 462 | 50 084 | 242 382 | 14,4 % |
Coherence geographique (masque `data\phase29\mask_on_ortho_phase29.png`, 2 m/px) : rouge
sur les bandes calcaires claires et les pieds de barres ; **pas** sur le village (NO), les
pistes de ski en foret, le lac, ni les fonds de vallee boises. Le quart SE boise est vide.
12 echantillons (graine 29, masque rugueux) :
| E | N | worldX | worldZ | alt | pente | couvert | F3 | rug | RGB ortho | dalle |
|---|---|---|---|---|---|---|---|---|---|---|
| 903578 | 6438125 | 2078 | -625 | 1704 | 0,68 | 0,01 | 0,01 | 0,10 | 212,213,208 | 0903_6439 |
| 902390 | 6437021 | 890 | 479 | 1858 | 0,79 | 0 | 0 | 0,14 | 191,192,178 | 0902_6438 |
| 901790 | 6436949 | 290 | 551 | 1825 | 0,79 | 0 | 0 | 0,13 | 227,228,214 | 0901_6437 |
| 903452 | 6439601 | 1952 | -2101 | 1785 | 0,64 | 0 | 0 | 0,21 | 194,195,197 | 0903_6440 |
| 903491 | 6439343 | 1991 | -1843 | 1812 | 0,71 | 0 | 0 | 0,30 | 132,131,134 | 0903_6440 |
| 901751 | 6436832 | 251 | 668 | 1751 | 0,63 | 0 | 0 | 0,15 | 217,216,212 | 0901_6437 |
| 903608 | 6438770 | 2108 | -1270 | 1972 | 0,65 | 0 | 0 | 0,17 | 107,107,98 | 0903_6439 |
| 900086 | 6435551 | -1414 | 1949 | 1817 | 0,66 | 0 | 0 | 0,31 | 236,232,223 | 0900_6436 |
| 902588 | 6437228 | 1088 | 272 | 2050 | 0,71 | 0 | 0 | 0,58 | 85,83,82 | 0902_6438 |
| 900302 | 6435527 | -1198 | 1973 | 1681 | 0,83 | 0,01 | 0,01 | 0,18 | 186,181,165 | 0900_6436 |
| 903602 | 6438269 | 2102 | -769 | 1805 | 0,63 | 0 | 0 | 3,38 | 194,194,183 | 0903_6439 |
| 901802 | 6437189 | 302 | 311 | 2156 | 0,78 | 0 | 0 | 0,22 | 157,150,142 | 0901_6438 |
9/12 gris clair (calcaire), 3 sombres (ombre portee ou paroi : rug 3,38 = pied de barre).
## 4. Source exacte pour les agents 2 et 3
- Pente : `Climber::slopeAt`/`gradientAt` (`src\world\Climber.cpp` l.31-46), demi-base 2 m.
**Ne pas** reprendre `Vegetation::slopeAt` (`Vegetation.cpp` l.122, differences avant sur 1 m,
plus bruitee) : les seuils ci-dessus ont ete mesures avec la base de 4 m. Seuils :
`kWalkComfortSlope`, `kWalkMaxSlope` de `src\core\SlopeLimits.hpp`.
- Couvert : `Vegetation::coverAt` (`Vegetation.cpp` l.131) sur `vercora_zone_canopy.vchm`,
chargement dans `main.cpp` (`canopyPathFor`, l.498 ; chargement l.1329-1342).
- Classe 3 : `data\phase29\vercora_zone_lowveg.vchm` (+ `_height`), lisible par
`loadTerrainFile()` sans code neuf. A COPIER dans `assets\terrain\` sous le nom
`vercora_zone_canopy_lowveg.vchm` si l'on veut reutiliser `canopyPathFor(path, "_lowveg")`
(decision a prendre par l'agent 2 ; je ne touche pas a assets).
- Bati : non expose au jeu. Exclusion pratiquement sans effet (2 272 m2) : on peut s'en passer
en jeu ; sinon exporter `c6 > 0` depuis `class_counts_5m.npz`.
- Semis : meme schema que Vegetation (hachage par cellule, blocs 8x8, InstanceData 28 o) ;
meshes `stoneMeshData()` (`src\world\StoneMesh.hpp`), `treeMeshData/broadleaf` (`TreeMesh.hpp`).
## 5. Limites
- Mesure : pente sur DTM 1 m (le jeu lit aussi la 2 m au loin : pentes lissees, masque plus petit).
- Couvert 5 m echantillonne au plus proche dans la sonde ; le jeu interpole en bilineaire
(bords de masque decales de <= 2,5 m).
- Pierrier vs pelouse raide rase : non separables par le LiDAR seul (les deux sont c2). La
luminance ortho confirme la moyenne, pas chaque pixel (25 % de pixels verts dans le masque,
comme la zone). Supposition : une part des 0,60-0,70 est de la pelouse caillouteuse.
- Les rochers AU-DESSUS de 0,84 (pieds de parois, >= 1,0 : 5,9 % nu) sont hors critere par
consigne ; des blocs isoles y seraient aussi realistes.
- Dalles a classe 1 elevee (§2) : vegetation possiblement non classee.
- Rugosite : RMS 5x5 d'un DTM median 1 m, sensible aux artefacts de jointure (p99 2,8 m, Phase 7).
+347
Voir le fichier
@@ -0,0 +1,347 @@
# Phase 29 - Rochers, pierriers, buissons
Conception et donnees : `NOTES-PHASE29-DESIGN.md` (Agent 1).
# Agent 2/4 - Rochers et pierriers proceduraux (2026-09-27)
Session sans supervision. Sauvegarde des sources avant la phase :
`..\_Vercora_backups\avant-phase29-20260927-0513`.
## Fichiers
| fichier | role |
|---|---|
| `src/world/RockMesh.{hpp,cpp}` (nouveaux) | 3 meshes generes en code, echelle unite : `boulderMeshData` (gros bloc, 128 tri), `rockMeshData` (rocher moyen, 32 tri), `gravelMeshData` (plaque de 11 cailloux, 88 tri). Sphere subdivisee bosselee puis tronquee par des plans aleatoires (faces de fracture). En partie enterres sous l'origine (0,13-0,25 x echelle). |
| `src/world/Rocks.{hpp,cpp}` (nouveaux) | semis deterministe + LOD + collision (`CollisionSolver`) |
| `shaders/foliage.vert` | mode ROCHER quand `params.w < 0` : inclinaison selon la pente. Arbres/herbe/fibres (w >= 0) : chemin inchange. |
| `src/main.cpp` | creation apres les plantes a fibres, 3 meshes, 3 appels instancies, ajout au `worldSolver`, options `--no-rocks` (temoin) et `--no-rock-collision`, lignes de journal `Rochers (PHASE 29)`. La ligne `Cout par image (PHASE 19)` n'est PAS modifiee (les scripts la parsent). |
| `CMakeLists.txt`, `tools/run_logic_tests.bat` | ajout des 2 .cpp |
| `tests/logic_tests.cpp` | `testRockMeshes`, `testRockPlacement` (+53 verifications) |
| `tools/profile_phase29.ps1` (nouveau) | A/B entrelace `--no-rocks`, arret par PID exact, RAM |
Donnees : AUCUNE modifiee ni copiee. Le masque n'a besoin que du DTM et de
`vercora_zone_canopy.vchm`, deja charges par le jeu (`coverMap`). Les cartes
`lowveg` de l'Agent 1 ne servent qu'aux buissons (Agent 3).
## Critere (strictement celui de la conception)
- `kWalkComfortSlope (0,60) <= Climber::slopeAt < kWalkMaxSlope (0,84)` - appel
LITTERAL a `Climber::slopeAt` (base 4 m), jamais `Vegetation::slopeAt`.
- couvert LiDAR (`coverMap`, bilineaire) `< 0,10`.
- rugosite (definition exacte de `probe_rocks.py` : RMS 5x5 du residu DTM -
moyenne 5x5, 81 sondes) `>= 0,10 m` -> gros blocs + rochers ; `< 0,10` ->
pierraille. Blocs : rugosite au point ; pierraille : au centre de la cellule de 8 m.
- **Masque = filtre dur** ; le bruit ne fait que moduler la densite dedans.
- **Sans carte de couvert : zero rocher** (pas de repli pente seule).
- Bati/eau : NON applique (pas de carte en jeu ; effet mesure par l'Agent 1 :
2 272 m2 sur 25 km2). Chemins/activites : il n'existe AUCUN masque de
chemin dans le projet ; les parois d'escalade (>= 0,84) sont exclues par
construction. Rien d'autre a exclure.
- Mesure en jeu (ligne de journal) : **masque 8,4 % de la zone** (conception :
8,9 % sur DTM 1 m ; ecart = echantillonnage 1/9 des cellules + couvert bilineaire).
## Parametres (`RockParams`)
| | cellule | emplacements | taille (echelle, m) | portee far -> near |
|---|---|---|---|---|
| gros blocs | 32 m | 8 (1 / 128 m2 max) | 1,1-2,6 | 700 -> 350 m |
| rochers moyens | 32 m | 20 (1 / 51 m2 max) | 0,35-0,95 | 320 -> 140 m |
| pierraille (plaques) | 8 m | 12 (3 / 16 m2 max) | 0,7-1,5 | 70 -> 30 m |
- Taille tiree en loi carree (petits sujets majoritaires). Graine `20260927`.
- **Trainees** : bruit de valeur 2 octaves, anisotrope : 1/110 m le long de la
pente, 1/28 m en travers ; densite = rampe(bruit, 0,35, 0,65). Le repere de
pente est fixe **par tuile de 96 m** (direction lue au centre, base 32 m),
4 tuiles melangees. Premiere version (repere au point) REJETEE par le test
d'anisotropie : loin de l'origine, quelques degres d'ecart de direction
deplacaient le bruit de plusieurs periodes -> bruit blanc (mesure : variation
le long 64,7 vs en travers 23,0, soit l'inverse du but ; apres : 5,1 vs 20,3).
- Estimation zone (journal) : 1,85 gros blocs, 4,75 rochers, 46 plaques / ha de zone.
- LOD de densite : portee PAR EMPLACEMENT (comme les arbres) + retrecissement
sur les 18 derniers %. Semis par cellules, cache PAR BLOC de 8x8 cellules,
budget 3 blocs (4 pour la pierraille) par image, purge a 1,5 x portee.
- Inclinaison : `InstanceData` est plein (28 o) ; le gradient (x 0,85) est
quantifie 64x64 dans la partie ENTIERE de `variation`, la teinte dans sa
partie fractionnaire (`packRockVariation`). Rodrigues dans le shader.
## Collision : decision
**Gros blocs d'echelle >= 1,3 m seulement** bloquent (cylindre de rayon
0,425 x echelle), via le `CompositeCollisionSolver` existant, comme Forest et
la faune. Rochers moyens et pierraille : traversables (sinon un pierrier
deviendrait un labyrinthe impraticable a pied et a velo). Un corps dont les
pieds sont au-dessus du sommet - 0,40 m (parapente, joueur sur le bloc) passe.
Juge sur et simple : meme repoussement que `Forest::resolve`, aucun bloc sur
paroi (>= 0,84) par construction. Temoin : `--no-rock-collision`.
Verifie : scenarios Vulkan **E (velo) et F (escalade)** joues seuls
(`-Only 'E','F'` via `-Command` - via `-File` la liste arrive en une seule chaine
et RIEN n'est joue) : code 0, 0 `[Validation]`, fermeture propre. Leurs
controles detailles dependent du scenario C (non joue) : suite complete = Agent 4.
## Tests headless
`tools\run_logic_tests.bat` : **3930/3930** (3877 + 53). Couvre : meshes valides
et bas-poly, chaque critere du masque isole (plat, 0,50, 0,95, couvert 0,30,
bornes), sans carte -> vide, **0 rocher hors masque sur 10 819 semes** (relief a
bande de pente + couvert coupe en deux), pose au sol, blocs seulement sur
rugueux / pierraille seulement sur lisse, determinisme au bit, graine,
densite bornee, cellules vides ET pleines (trainees), anisotropie, LOD (portees,
eclaircissement avec la distance), pack/unpack, collision (detectee, resolue,
temoin, survol, composite, rien hors masque).
## Performance (Debug + validation, `tools\profile_phase29.ps1`, 3 tours A/B entrelaces, 20 s)
Charge verifiee avant (0-43 %) ; runs a > 1 coeur d'autres processus ecartes.
| vue | A (rochers) | B (`--no-rocks`) | A-B | RAM WS / pic |
|---|---|---|---|---|
| pierrier (903452, 6439601) | 334,8 img/s, 2 974 us | 346,6 img/s, 2 885 us | **+89 us/img (+3,1 %)** | 296/339 vs 295/338 Mo |
| alpage ref. Phase 27 (900500, 6439000) | 150,3 img/s, 6 653 us | 152,3 img/s, 6 568 us | **+85 us/img (+1,3 %)** | 291/358 vs 291/358 Mo |
Bruit : ecart min-max intra-condition 1-2 img/s. Semis rochers ~62-72 us/image.
Historique de l'optimisation (mesures) : cellule 16 m / 900 m -> **1 625 us** de
semis ; cellule 32 m / 700 m -> 402 us ; cache par bloc -> **~70 us**.
0 `[Validation]` sur les 12 runs.
## Limites
- Premier passage dans une zone : un bloc de 8x8 cellules est seme d'un coup
(jusqu'a ~1 800 tests de masque + rugosite) ; borne a 3+4 blocs par image,
mais a-coup possible, non mesure isolement.
- Pierraille : rugosite au centre de la cellule de 8 m (au point pour les blocs).
- Pas de bati/eau en jeu ; pas de rochers au-dessus de 0,84 (pieds de parois),
par consigne. Pierrier vs pelouse raide rase non separables (limite Agent 1).
- Le terrain lointain lu en 2 m peut lisser la pente : non concerne, le semis lit
le `heightmap` CPU 1 m.
- Collision : les blocs empiles/inclines sont des cylindres verticaux ; on ne
peut pas monter sur un bloc (pas de hauteur de sol modifiee).
- Rendu : les rochers suivent la touche G (vegetation) ; pas d'ombre portee.
# Agent 3/4 - Buissons et petits arbres (classe 3 LiDAR) (2026-09-27)
Session sans supervision ; toutes les decisions ci-dessous sont prises et justifiees ici.
## Fichiers
| fichier | role |
|---|---|
| `assets/terrain/vercora_zone_canopy_lowveg.vchm` (COPIE) | = `data/phase29/vercora_zone_lowveg.vchm` (F3), SHA-256 identique |
| `assets/terrain/vercora_zone_canopy_lowveg_height.vchm` (COPIE) | = `data/phase29/vercora_zone_lowveg_height.vchm` (h max c3 - sol) |
| `src/world/BushMesh.{hpp,cpp}` (nouveaux) | `shrubMeshData` (buisson 3 lobes, 106 tri), `smallTreeMeshData` (tronc + 2 cones, 44 tri) ; echelle unite = 1 m de HAUT, pied enterre de 0,08 |
| `src/world/Bushes.{hpp,cpp}` (nouveaux) | critere, semis deterministe, LOD, emprises d'arbres |
| `src/main.cpp` | chargement des 2 cartes, `--no-bushes` (temoin), 2 appels instancies, lignes `Buissons (PHASE 29)` |
| `CMakeLists.txt`, `tools/run_logic_tests.bat` | ajout des 2 .cpp |
| `tests/logic_tests.cpp` | `testBushMeshes`, `testBushPlacement` (+38) |
| `tools/profile_phase29.ps1` | + vue `buissons` (901160, 6436275) et `-Toggle` (option temoin de B, defaut `--no-rocks` : usage Agent 2 inchange) ; colonnes buissons |
| `shaders/foliage.vert` | **NON modifie** : les buissons prennent le chemin ARBRE (params.w = 0) |
**Donnees : schema du projet respecte.** Les cartes de terrain vivent dans
`assets\terrain\` et se trouvent par `canopyPathFor(terrain, suffixe)` ; les copies
portent donc les noms `_canopy_lowveg` / `_canopy_lowveg_height` (proposition de
l'Agent 1). Sources de `data\phase29\` non modifiees. `.gitignore` ignore deja
`assets/terrain/*.vchm`. Verifie avant : meme en-tete (emprise, pas 5 m) que le
couvert ; couvert >= F3 sauf 6 cellules sur 1 M (ecart < 0,03).
## Critere (celui de la conception, section 2)
`F3 >= 0,10 ET F45 = couvert - F3 < 0,20`, plus `couvert >= 0,10`.
- Pilote **uniquement** par F3 : la densite, la hauteur et le choix du mesh viennent
de la classe 3. Le couvert total ne sert qu'a EXCLURE (foret, et domaine rocher).
- `couvert >= 0,10` : le masque des Rochers exige couvert < 0,10, donc les deux semis
sont **disjoints par construction** (et les 6 cellules F3 > couvert sont ecartees).
Plus simple et plus sur que d'interroger Rocks.
- Arbres abattables (Forest) : aucun buisson dans le rayon de HOUPPIER
(`Tree::crownRadius`), emprises passees une fois au demarrage (grille de 32 m).
Arbres de decor (Vegetation) : NON verifies (semis prive, pas d'API) ; F45 < 0,20
les evite en grande partie (leur seuil : couvert >= 0,20). Limite assumee.
- Une des trois cartes absente -> ZERO buisson (pas de substitut). Terrain synthetique
et dalles `LHD_*` : aucun buisson.
## Parametres (`BushParams`)
- Cellule 8 m, 6 emplacements (<= 940 sujets/ha). Densite = 0,20 + 0,80 x rampe(F3,
0,10 -> 0,30) ; l'emplacement k n'est retenu que si k < densite x 6 (regle Rocks/Vegetation).
- Hauteur = clamp(h_max_c3 x U[0,35 ; 0,85], 0,5, 3,0) m. Moyenne du tirage 0,60 =
rapport mesure par l'Agent 1 entre hauteur moyenne (p50 1,5 m) et max (p50 2,5 m).
h_max < 0,3 m -> pas de sujet (pas de hauteur inventee). Ecretage 3 m : conception.
- Mesh par la HAUTEUR : >= 1,8 m -> petit arbre (jeune resineux), sinon buisson.
Dans le masque, h_max p50 = 3,35 m : les petits arbres dominent (mesure en jeu :
1 523 petits arbres pour 86 buissons visibles au coeur de la zone test). C'est la donnee.
- Portee par emplacement : buissons 150 -> 55 m, petits arbres 260 -> 100 m, fondu par
retrecissement sur les 18 derniers % (comme Rocks). Cache par bloc 8x8 cellules,
budget 4 blocs/image, purge a 1,5 x portee. Premier reglage 220/380 m : 276 us de
semis/image en Debug dans la zone dense -> ramene.
- Graine 20260928. Ondulation 4 cm (buisson), 0 (petit arbre) ; ni decoupe ni mode rocher.
- Journal en jeu : masque 9,7 % de la zone (donnee : 10,45 % ; echantillonnage 1/7 +
bilineaire), 21,7 buissons et 31,0 petits arbres par ha de zone, 16 emprises exclues.
## Adret / ubac : NON applique (decision)
Examine : buis (Buxus sempervirens) sur adrets calcaires chauds ; rhododendron
ferrugineux et aulne vert en ubac. Rejete pour ce jeu de donnees :
- le buis est une espece de l'etage collineen/montagnard inferieur ; la zone est a
1029-2285 m et le masque classe 3 est surtout en altitude (landes et pins a crochets
des Hauts-Plateaux) : l'appliquer par l'exposition seule le placerait hors de son etage ;
- le rhododendron ferrugineux est lie a un humus ACIDE (sur calcaire, seulement sous
les pins a crochets sur humus epais) : facteur edaphique, absent de nos donnees ;
- l'aulne vert est silicicole, marginal dans le Vercors calcaire.
Sources (connaissances generales, NON reverifiees en ligne pendant cette session) :
Ozenda, *La vegetation de la chaine alpine*, Masson 1985 ; Rameau et al., *Flore
forestiere francaise* t.1 (plaines et collines) et t.2 (montagnes), IDF 1989/1993.
Le LiDAR ne donne pas l'espece (conception, section 2). Donc : ni teinte ni espece
selon l'exposition ; la variation de teinte est l'alea par instance de foliage.vert.
## Collision : AUCUNE (decision)
Buissons et petits arbres se traversent : ce sont des ligneux bas et souples (landes,
fourres), qui ralentiraient plus qu'ils n'arretent ; les rendre bloquants ferait de
10 % de la zone un labyrinthe pour la marche, le velo et la faune, et Wildlife/activites
n'ont pas ete concus avec. Les petits arbres (<= 3 m) restent traversables pour la meme
raison. Le `worldSolver` n'est pas touche -> aucun effet sur la faune, l'artisanat, les
activites (Forest, Rocks, Vegetation : code non modifie).
## Tests headless
`tools\run_logic_tests.bat` : **3968/3968** (3930 + 38). Meshes (valides, 16-400 tri,
hauteur 1, pied enterre <= 0,08, emprise dans le rayon annonce) ; chaque critere isole ;
sans carte -> vide ; h = 0 -> vide ; **0 buisson hors critere sur 25 211** (champ en
rampe F3 x F45) et frontieres reproduites ; <= 6/cellule ; densite pleine a F3 0,30,
clairsemee a 0,11 ; hauteur dans [0,5 ; 3] sous 10 m et <= h carte sous 1,2 m ;
petit arbre ssi h >= 1,8 ; determinisme au bit, graine ; disjoint du masque Rocks
sur pierrier ; emprise d'arbre respectee ; gather (portee, fondu, echelle, LOD).
PIEGE rencontre : `C1041/C1090` sur `build-tests\logic_tests.pdb` quand build.bat et
les tests s'enchainent vite (mspdbsrv tient le PDB) ; supprimer le .pdb et relancer.
## Build et cout (Debug + validation, `profile_phase29.ps1 -Toggle --no-bushes`, 3 tours A/B entrelaces, 20 s)
Build Debug : 0 erreur, 0 avertissement. Charge avant : 0-2 % ; aucun autre vercora ni
build ; arret par PID. **0 `[Validation]` sur 12 runs** + fumee + capture.
| vue | A (buissons) | B (`--no-bushes`) | A-B | semis | RAM WS / pic |
|---|---|---|---|---|---|
| alpage ref. (900500, 6439000) | 148,3 img/s, 6 744 us | 151,3 img/s, 6 609 us | **+135 us (+2,0 %)** | 87 us, 41 + 92 | 299/367 vs 291/359 Mo |
| buissons (901160, 6436275, 90 % de masque a 100 m) | 151,8 img/s, 6 586 us | 159,6 img/s, 6 264 us | **+322 us (+5,1 %)** | 192 us, 86 + 1 523 | 299/368 vs 291/360 Mo |
RAM +8 Mo = les deux cartes 1001 x 1001 float. Capture : `build\phase29\buissons.png`.
`run_vulkan_check.ps1` NON lance (Agent 4).
## Limites
- Arbres de decor Vegetation non exclus (voir plus haut) ; recouvrement possible en lisiere.
- Dalle `0902_6438` peu classee : pas de buissons, par la donnee.
- Especes non identifiees (LiDAR) ; hauteur tiree, pas mesuree par sujet.
- Le cout Debug en zone dense (+0,32 ms) est surtout le parcours des instances ; pistes :
portee plus courte, ou tri des blocs par distance.
# Verification (Agent 4/4) (2026-09-27)
Session sans supervision. Avant chaque etape : aucun vercora/cmake/ninja/cl/msbuild/
cargo/rustc, charge CPU 3-26 %. Une seule chose a la fois. Arrets par PID (scripts).
`data\` non touche. Journaux et CSV : `build\phase29\agent4_*`.
## 1. Build Debug propre - VERT
`cmake --build build --clean-first` : 86/86, **0 avertissement**. Tests reconstruits
de zero (obj + pdb supprimes) : seul avertissement = `main.cpp(1297) C4244`, la MEME
ligne que `main.cpp(1280)` de la sauvegarde (Phase 27, decalee de 17 lignes par les
ajouts). Aucun avertissement dans Rocks/RockMesh/Bushes/BushMesh.
## 2. Tests headless - VERT
`tools\run_logic_tests.bat` : **SUCCES : 3968 verifications passees** (3968 attendues).
## 3. run_vulkan_check.ps1, suite complete - 0 `[Validation]`, seul C echoue (connu)
0 `[Validation]`, 0 `[ERROR]`, 4 `[WARN]` habituels, codes de sortie 0, fermetures propres.
| scenario | verdict |
|---|---|
| A gameplay synthetique | passe (2 abattus, 4 ramasses, percussion) |
| B chemin de collision | passe |
| C dalle LiDAR reelle | **ECHEC** : arbre "MANQUE", nav arrivee a 0,81 / 0,83 m |
| D parapente | passe |
| E velo | passe (en selle / pied a terre, 50 km/h) |
| F escalade | passe (sommet, 41,8 m) |
| G1-G3 editeur | passe (0,28 m avec scene contre 9,71 m temoin) |
| H besoins | passe |
| I faune | passe (24 animaux, fuite, frequentation 100 %) |
| J / J3 recolte, fibres zone | passe (repousse) |
Scenario C : Phase 28 = 0,82/0,84 m en suite complete ; ici 0,81/0,83 -> **pas pire**.
`-Only 'C'` (via `-Command`) x3 : echec (0,85/0,68 m), **passe** (0,73/0,90), **passe**
(0,75/0,90), 0 `[Validation]`. **La Phase 29 ne peut pas y jouer** : sur la dalle
`LHD_0907_6440`, le journal dit "aucune carte de couvert LiDAR, donc AUCUN rocher" et
"carte classe 3 ou couvert absent ... AUCUN buisson" (13 et 11 processus) ; `Rocks`
n'est ajoute au `worldSolver` que s'il est actif. A a I tournent sur des terrains sans
couvert : rochers et buissons n'y existent pas. Seul J3 (zone 25 km2) a rochers et
buissons actifs, et il passe. Rien corrige (rien a corriger).
## 4. Captures avant/apres - `build\phase29\captures\`
Meme binaire Debug, j12 13 h, temps gele, entree verrouillee ; avant = `--no-rocks --no-bushes`.
| paire | vue | pixels changes (seuil 30) |
|---|---|---|
| `belvedere_*` (+ `_zoom`) | E900000 N6436000 `--look=270,-24` (Phase 25) | 1,3 % |
| `pierrier_*` (+ `_apres_zoom`) | 903452,6439601 `--look=180,-15` | 0,3 % |
| `buissons_*` | 901160,6436275 `--look=0,-6` | non chiffre (lande nettement visible) |
| `buissons_sol_*` | idem `--look=-90,-15` (dans l'herbe) | 9,5 % |
Constats a l'oeil :
- Rochers : blocs POSES au sol (aucun flottant vu), sur ruptures de pente du versant,
aucun sur les replats de prairie. **Trainees NON visibles** a cette densite : les blocs
sont epars (77 blocs et 131 rochers dessines dans la vue de profil pierrier). La
coherence en trainees n'est donc prouvee que par le test d'anisotropie headless.
- Pierrier : le premier cadrage (`-90,-20`, face au versant) donne une image quasi
identique ; les vues 0 et 90 montrent la roche nue, sans rocher proche.
- Buissons : une lande de jeunes resineux comble la pente AU-DESSUS de la foret de
decor ; aucune intersection evidente avec les arbres de decor ni avec les arbres
Forest. Au belvedere, deux petits arbres apparaissent pres d'un feuillu de decor, en
avant de lui (profondeur non mesurable a l'oeil). Des petits arbres voisins
s'interpenetrent entre eux (jusqu'a 6 par cellule de 8 m, sans espacement), ce qui se
voit de pres.
## 5. Cout total rochers + buissons (A = normal, B = `--no-rocks --no-bushes`)
`profile_phase29.ps1 -Toggle "--no-rocks --no-bushes"`, 3 tours entrelaces, 20 s, medianes
des runs sains. Release : build separe `build-release\` (cmake Release + Ninja, 86/86),
meme script pointe sur l'exe Release (copie hors projet) ; pas de couche de validation.
| config / vue | A | B | A-B | RAM WS A/B |
|---|---|---|---|---|
| Debug alpage (ref. Phase 27) | 6 755 us (148,0 img/s) | 6 591 us (151,7) | **+164 us (+2,5 %)** | 299/291 Mo |
| Debug pierrier | 3 118 us (320,7) | 2 866 us (346,1) | **+252 us (+8,8 %)** | 304/295 |
| Debug buissons | 6 494 us (154,0) | 6 038 us (165,6) | **+456 us (+7,6 %)** | 299/290 |
| Release alpage | 4 954 us (201,5) | 4 830 us (204,1) | **+124 us (+2,6 %)** | 285/277 |
| Release pierrier | 1 748 us (571,1) | 1 679 us (595,7) | **+70 us (+4,2 %)** | 290/282 |
| Release buissons | 5 887 us (169,9) | 5 211 us (191,0) | **+676 us (+13 %)** | 285/277 |
Semis CPU (A) : rochers 62/72/127 us en Debug et 8/8/19 us en Release ; buissons
88/83/190 us en Debug. Ecart min-max intra-condition <= 3 img/s. 4 runs NON CONCLUANTS
(autres processus > 1 coeur) ecartes. 0 `[Validation]` sur les 18 runs Debug.
Situation : reference Phase 27 Release alpage = 4 962 us (201 img/s) ; Phase 29 mesuree
a 4 954 us -> **au niveau de la reference** (+124 us sur le temoin du jour). Pire cas
mesure (zone dense de petits arbres, Release) : 5,9 ms = 170 img/s ; le semis n'y pese
que ~19 us de rochers, c'est donc le dessin (~1 600 petits arbres, GPU). Reste tres
au-dessus de 60 img/s ; poste a surveiller : portee des petits arbres (260 m).
## 6. Non-regression par relecture - VERT
`diff -rq` de src et shaders contre `..\_Vercora_backups\avant-phase29-20260927-0513` :
fichiers existants modifies = **`src/main.cpp` et `shaders/foliage.vert` seulement** ;
nouveaux : Rocks, RockMesh, Bushes, BushMesh. Forest, Vegetation, Wildlife, Crafting,
Climber, Ground, Bike, Paraglider, Needs, collision : **identiques octet pour octet**.
- main.cpp : options `--no-rocks/--no-rock-collision/--no-bushes`, construction apres
les fibres, `worldSolver.add(rocks)` seulement si des rochers existent (voulu : les gros
blocs bloquent joueur ET faune, comme Forest), `forest->trees()` lu en const pour les
emprises, 5 appels instancies derriere la touche G, 2 lignes de bilan. Ligne
`Cout par image (PHASE 19)` inchangee.
- foliage.vert : pour `params.w >= 0` (arbres, herbe, fibres, buissons), `tilt` =
`mat3(1.0)` et `tintSeed` = `variation` -> meme position, meme normale, meme teinte ;
decoupe (w > 0) et `fragBladeSeed` inchanges. Le mode rocher n'agit que si w < 0.
## Ecart de documentation releve
Le journal actuel donne `masque pierrier 9,4 % ; 1,82 gros blocs, 4,66 rochers, 23,2
plaques / ha` (9,3 / 1,55 / 3,62 / 36,2 dans le processus J3, autre terrain de depart),
et non 8,4 % / 1,85 / 4,75 / 46 comme dans la section Agent 2 : `Rocks.cpp` date de
09:37, apres les mesures de l'Agent 2 (09:32). Les chiffres a jour sont ceux du journal.
## Non mesure
Scintillement et apparitions en mouvement ; a-coup du premier semis d'un bloc ; cout
sous la pluie ; vue de survol. Trainees de rochers a l'oeil (voir 4).
+200
Voir le fichier
@@ -0,0 +1,200 @@
# Vercora — Phase 6
Session du 2026-08-14. Comble les trous laissés par la Phase 5 (collision,
ramassage, transition de chute) et pose le premier maillon d'artisanat
(taillage de pierre par percussion).
> **Note de la Phase 7 (2026-08-16).** Ce document reste le compte rendu de la
> Phase 6 et n'a pas été récrit, mais deux choses y ont bougé depuis :
> `tools\dump_world.cpp` a été supprimé — c'est maintenant `vercora.exe
> --dump-world` — et `run_vulkan_check.ps1` compte trois scénarios, pas deux.
> Voir **NOTES-PHASE7.md**.
---
## État : compilé, exécuté, vérifié sous les couches de validation Vulkan
Mise à jour du **2026-08-15**, sur une nouvelle machine (64 Go de RAM). La dette
de la session précédente — « les couches de validation n'ont pas pu être
vérifiées, faute de SDK » — est **soldée**.
### Build
```bash
tools\build.bat
```
Configure et compile tout (47 cibles), sans rien télécharger : GLFW, GLM et
tinyobjloader sont réutilisés depuis `external/` via
`-DFETCHCONTENT_FULLY_DISCONNECTED=ON`.
### Vérification
```bash
tools\run_logic_tests.bat # 121 assertions de comportement, sans GPU
tools\run_vulkan_check.ps1 # le VRAI exécutable, sous validation layers
```
**Les deux passent.** `run_vulkan_check.ps1` lance le vrai `vercora.exe` en
Debug (donc `VERCORA_DEBUG`, donc `VK_LAYER_KHRONOS_validation` — le jeu logge
« Validation layers activees ») et pilote sa fenêtre par messages Win32.
Résultat : **0 message `[Validation]`, 0 `[ERROR]`, 0 `[WARN]`, codes de sortie
0/0, fermeture propre.** Couvert : init, rendu, abattage complet (chute →
amortissement → débitage progressif), ramassage des 4 natures d'objet,
percussion, collision contre tronc debout puis souche, 6 redimensionnements,
minimisation/restauration, et un vrai `WM_CLOSE` (pas un kill).
Le shim Vulkan maison (`tests/shim/`) a été supprimé : le harnais headless
compile désormais contre les vrais en-têtes du SDK, ce qui est plus strict.
`Pipeline.cpp`, seul fichier jamais vérifié la session précédente, compile.
### Particularités de cette machine
L'installation Visual Studio 18 est **partiellement corrompue** (1695 fichiers
sur 9692 examinés remplis de zéros binaires) : son CMake et son Ninja sont
inutilisables, et MSBuild fait échouer le générateur « Visual Studio ». Le
compilateur, lui, est intact. `tools\build.bat` utilise donc CMake et Ninja
**autonomes** (winget) avec le générateur Ninja, et vcvars64 de VS uniquement
pour l'environnement MSVC. Il préchauffe aussi `rc.exe`, dont le premier appel
échoue systématiquement (antivirus temps réel). Voir l'en-tête du script.
*Correctifs machine recommandés, à faire par l'utilisateur :* « Réparer » depuis
Visual Studio Installer, vérifier la santé du disque, et ajouter une exclusion
Defender sur le dossier du Windows Kit.
### Ce qui reste non vérifié
- **Le comportement de la collision sur le jeu réel.** Il est prouvé par les 121
assertions headless (marche simulée pas à pas, lecture directe des positions),
mais aucun observable externe ne permet de le confirmer sur l'exécutable : un
collider cylindrique *repousse* au lieu de bloquer, donc le joueur contourne le
tronc et se retrouve derrière lui que la collision marche ou non ; et la
déflexion latérale (0,66 u) est plus petite que la tolérance de visée (~1,4 u).
- **La jouabilité.** Rayon du joueur, portée de ramassage, durées de chute et de
débitage sont des valeurs raisonnées, validées comme *fonctionnelles* mais
jamais éprouvées manette en main.
---
## Ce qui a été fait
### 0. Préalable — `Vertex.hpp` ne dépend plus de Vulkan
`renderer/Vertex.hpp` incluait `<vulkan/vulkan.h>` pour deux fonctions statiques
de description du format de sommet. `MeshData` s'annonçait « indépendant de
Vulkan » tout en le tirant transitivement : **toute** la logique de jeu devenait
incompilable sans SDK.
Ces deux fonctions vivent désormais dans `renderer/VertexFormat.hpp`, inclus par
le seul `Pipeline.cpp` (`Vertex::getBindingDescription()` →
`vertexBindingDescription()`). C'est ce qui rend le harnais de tests possible —
et accessoirement ce que l'en-tête prétendait déjà faire.
### 1. Collision troncs et souches
- `core/CollisionSolver.hpp` : interface + `BodyCylinder`, dans le même esprit
que `HeightSampler` — `Camera` ne dépend pas de `world/`.
- `world/Forest` l'implémente : c'est elle qui sait où sont ses troncs.
- Joueur = cylindre vertical (r = 0,35 m). Obstacle = tronc sur toute sa hauteur
s'il est debout, souche seule sinon. **Le houppier ne bloque pas** : sa base
est à 35 % de la hauteur, on doit pouvoir marcher dessous.
- Résolution par **repoussement**, ce qui donne gratuitement le glissement le
long d'un tronc.
- ⚠ Piège corrigé en cours de route : le repoussement seul **fait passer** le
joueur à travers un passage plus étroit que lui (chaque obstacle le pousse à
son tour, la somme l'extrude de l'autre côté). D'où `moveBody()`, qui vérifie
le résultat avec `overlaps()` et refuse le déplacement s'il reste bloqué.
**`moveBody()` est le point d'entrée obligatoire ; `resolve()` seul ne suffit
pas.**
- La collision n'agit qu'en **mode marche**. Le vol libre reste un mode
d'inspection et traverse tout.
**Décisions prises seul :** la souche bloque (c'était demandé explicitement,
mais une souche de 0,3 m qui arrête net est discutable — un franchissement
automatique serait le prochain raffinement) ; un arbre *en cours de chute*
n'expose que sa souche, donc on peut traverser un tronc en vol pendant ~1,5 s.
### 2. Ramassage réel — touche `R`
- `world/Ground` : nouvelle classe propriétaire de tout ce qui traîne au sol.
`Forest` garde les arbres debout et la chute, et lui dépose son bois.
- `world/GroundItem.hpp` : `GroundItem` sort de `Tree.hpp`, et un enum
`GroundItemKind {Log, Branch, Stone, Flake}` remplace le booléen `isBranch`,
devenu intenable dès l'arrivée de la pierre.
- `world/Inventory.hpp` : compteurs simples, affichés **dans le titre de la
fenêtre** et les logs. Aucun menu.
- Portée 2,5 m, mesurée à l'horizontale.
### 3. Transition de chute améliorée
Nouvel état `TreeState::Settling` entre `Falling` et `Fallen` :
1. **Chute** — pendule inverse (inchangé).
2. **Amortissement (0,65 s)** — l'arbre **reste dessiné**, couché au sol, avec un
rebond amorti maintenu sous l'horizontale. C'est le cœur du correctif : en
Phase 5 l'arbre disparaissait à l'instant précis où il atteignait 90°.
3. **Débitage** — les bûches apparaissent **une par une, du pied vers la cime**
(0,16 s d'intervalle), puis les branches.
**Limite résiduelle assumée :** le tronc disparaît toujours d'un coup au début du
débitage. Le faire rétrécir progressivement demanderait une échelle **non
uniforme**, interdite par le contrat de `DrawItem` (`mat3(model)` sert de normal
matrix) — il faudrait un mesh par arbre. Piste pour plus tard : remplacer le
tronc par une file de bûches posées bout à bout sur son axe, puis les écarter une
à une.
### 4. Taille de pierre par percussion — touche `C`
- `world/StoneMesh` : galet (octaèdre subdivisé, bruité, facetté, aplati) et
éclat (face ventrale plate, face dorsale en arête). Générés **en code**.
- `world/Knapping` : `knapStones()`.
**Décisions prises seul :**
- **Deux pierres requises** — un percuteur et un nucleus. C'est la seule
« recette » du système, et il n'y a volontairement aucune table.
- **Une seule est consommée** (le nucleus). Le percuteur est l'outil, pas la
matière.
- **L'éclat tombe dans le monde**, devant le joueur, et doit être ramassé avec
`R`. Il ne va pas directement en inventaire : « zéro menu virtuel » veut que ce
qui est produit existe d'abord comme une chose posée quelque part.
- **6 pierres semées** : deux suffiraient au sens strict, mais obligeraient à
quadriller la carte pour trouver la seconde.
L'éclat ne sert encore à rien — c'était le périmètre demandé.
---
## Touches
| Touche | Action |
|---|---|
| clic droit + ZQSD | regarder / se déplacer |
| `F` | bascule marche / vol libre |
| `E` | abattre l'arbre visé |
| `R` | ramasser l'objet au sol le plus proche |
| `C` | percuter deux pierres |
(GLFW raisonne en positions physiques QWERTY : `E`, `R` et `C` tombent bien sur
les touches gravées d'un clavier AZERTY, contrairement à `W`/`A` → `Z`/`Q`.)
---
## Outils
| Script | Rôle |
|---|---|
| `tools\build.bat` | configure + compile (Debug par défaut, donc validation layers) |
| `tools\run_logic_tests.bat` | 121 assertions de comportement, sans GPU |
| `tools\run_vulkan_check.ps1` | lance le vrai jeu et traque les erreurs de validation |
| `tools\dump_world.cpp` | imprime le monde semé (positions + indices), sert au pilotage — *supprimé en Phase 7, remplacé par `vercora.exe --dump-world`* |
## Prochaines étapes suggérées
1. Essayer manette en main et régler : rayon du joueur, portée de ramassage,
durées d'amortissement et de débitage.
2. Franchissement automatique des souches plutôt que blocage net.
3. Rendre l'éclat utile (entaille d'abattage, gain de vitesse sur `E`).
4. Réparer l'installation Visual Studio, ce qui permettrait de revenir au
générateur Visual Studio si on y tient (rien ne l'impose : Ninja marche).
+404
Voir le fichier
@@ -0,0 +1,404 @@
# Vercora — Phase 7 : pipeline LiDAR HD réel, de bout en bout
Session du 2026-08-16, non supervisée. Objectif : valider la **chaîne technique**
complète, d'une vraie dalle IGN jusqu'au terrain sur lequel la caméra marche.
Ce n'est **pas** le choix de la zone finale du jeu, qui reste à définir.
Jusqu'ici le terrain était toujours synthétique (bruit fractal, Phase 4). Il ne
l'est plus : `vercora.exe` sans argument charge désormais une vraie dalle. Le
générateur procédural reste disponible (`vercora.exe terrain`) et sert toujours
de monde de référence aux tests — voir « Ce qui n'a pas changé » plus bas.
---
## État : vérifié, zéro erreur de validation Vulkan
```bash
tools\build.bat # compile
tools\run_logic_tests.bat # 169 assertions headless (121 avant la Phase 7)
tools\run_vulkan_check.ps1 # le VRAI exe, 3 scenarios, sous validation layers
```
**Les trois passent.** `run_vulkan_check.ps1` : 0 message `[Validation]`,
0 `[ERROR]`, 0 `[WARN]`, codes de sortie 0/0/0, fermeture propre sur les trois
scénarios — dont le nouveau **scénario C**, qui joue sur la dalle réelle
(2 000 000 de triangles) : chargement, marche sur le relief mesuré, abattage,
ramassage, vol libre, 6 redimensionnements, minimisation/restauration, `WM_CLOSE`.
Non-régression : les scénarios A et B tournent toujours sur le terrain
synthétique, avec exactement la même couverture qu'en Phase 6.
---
## 1. La dalle utilisée
| | |
|---|---|
| Nom | `LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz` |
| Emprise | Lambert 93, X 907000–908000, Y 6439000–6440000 (1 km × 1 km) |
| WGS84 (centre) | **45,0236 N — 5,6349 E** |
| Lieu | **Le Gua, Isère (38450)** — bordure orientale du Vercors |
| Bloc / mission | `PM`, mission `21LHD6PM`, acquisition du 06 au 13/08/2021 |
| Classement | `ST_AUTO_MANUEL_POST_EXP` (auto Avineon + reprise manuelle IGN) |
| Points | 28 739 937, format LAS 1.4 point format 6 |
| Taille | **175 350 922 octets (167,2 Mo)** |
| Licence | Etalab 2.0 (open data) |
URL de téléchargement :
```
https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz
```
**Comment on la trouve** — et c'est le point non évident. `geoservices.ign.fr`
redirige vers `cartes.gouv.fr`, une application web dont les liens ne
s'extraient pas d'une page. L'index des dalles est en revanche exposé en **WFS**,
et chaque tuile y porte son URL de téléchargement :
```bash
curl "https://data.geopf.fr/wfs/ows?SERVICE=WFS&VERSION=2.0.0&REQUEST=GetFeature&TYPENAMES=IGNF_NUAGES-DE-POINTS-LIDAR-HD:dalle&COUNT=3&OUTPUTFORMAT=application/json&SRSNAME=EPSG:2154&BBOX=908000,6440000,913000,6445000,EPSG:2154"
```
La propriété `url` de chaque *feature* est le lien direct ; `metadata` donne le
nombre de points, les dates d'acquisition et le procédé de classement. Le service
limite à 1 requête/seconde. L'ancienne forme
`storage.sbg.cloud.ovh.net/.../ppk-lidar/...`, encore citée un peu partout, n'est
plus la source de référence.
**Pourquoi cette dalle.** Zone de couverture confirmée (livrée dès 2021), et
surtout un relief qui met le pipeline à l'épreuve plutôt que de le flatter :
**562 m de dénivelé sur 1 km²** (420 → 982 m), donc de vraies falaises, et
**67 % de végétation haute**, donc de vrais trous de données sous le couvert. Un
plateau agricole aurait tout fait passer sans rien prouver.
Espace disque vérifié avant téléchargement : 294 Go libres sur C:.
---
## 2. L'outil de conversion — `tools/lidar_to_heightmap.py`
```bash
python -m pip install "laspy[lazrs]" numpy
python tools/lidar_to_heightmap.py data/lidar/LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz -o assets/terrain/LHD_0907_6440_1m.vchm --cell 1.0
```
Options : `--cell`, `--stat median|mean|min`, `--classes`, `--no-despike`,
`--zero-base`, `--report-only`. L'en-tête du script documente tout.
**laspy + lazrs plutôt que PDAL.** PDAL est bien le standard du domaine, mais sur
Windows il ne se livre en pratique que par conda, absent de cette machine.
laspy 2.7 avec le backend lazrs (l'implémentation Rust de LASzip) lit exactement
le même LAZ 1.4 classifié, s'installe en une commande pip — y compris sur le
Python 3.14 de cette machine, ce qui n'allait pas de soi — et tout le reste du
travail est du numpy de toute façon. Le format de sortie ne dépend pas du lecteur :
PDAL produirait le même fichier.
**Pourquoi un outil séparé du moteur.** Un `.laz` est un nuage compressé et non
trié ; en tirer une grille demande un décodeur LASzip, un tri, une agrégation,
un bouchage de trous et un filtrage — 3,6 s et 167 Mo de lecture, pour un
résultat toujours identique. C'est de la *préparation*, pas du chargement. Le jeu
lit 4 Mo de float déjà propres. Même frontière que les shaders, compilés en
SPIR-V par le build et non en GLSL à l'exécution.
### Résultats de la conversion
| | 1 m (**retenu**) | 2 m |
|---|---|---|
| Échantillons | 1001 × 1001 | 501 × 501 |
| Fichier `.vchm` | **4 008 124 o (3,82 Mo)** | 1 004 124 o (0,96 Mo) |
| Points sol par cellule (médiane) | 7 | 20 |
| Cellules sans aucun point | **21,58 %** | 6,64 % |
| Rayon du plus gros trou | 6 cellules (6 m) | 3 cellules (6 m) |
| Pics corrigés | 13 (0,0013 %) | 5 (0,0020 %) |
| Sommets / triangles | 1 002 001 / 2 000 000 | 251 001 / 500 000 |
| FPS (GTX 960, Debug) | **848** | 1876 |
| Pic mémoire du processus | **185 Mo** | 102 Mo |
| Durée de conversion | 3,6 s | 3,2 s |
**Le 1 m est retenu**, pour trois raisons : la densité de points sol (7,10 pts/m²)
le supporte réellement — descendre à 20 cm inventerait du détail que la donnée
n'a pas ; 848 FPS sur une GTX 960 de 2015 laisse une marge considérable ; et
185 Mo de pic mémoire sont sans commune mesure avec les 64 Go disponibles. Le 2 m
reste généré et utilisable (`vercora.exe chemin\vers\..._2m.vchm`) comme repli
pour une machine plus modeste ou pour une future carte multi-dalles.
### Le format `.vchm`
En-tête de 120 octets petit-boutiste puis `samplesZ * samplesX` float32.
Définition complète en tête de `tools/lidar_to_heightmap.py`, redite dans
`src/assets/TerrainFile.hpp`. Les altitudes restent **absolues (IGN69)** et le
géoréférencement (coin nord-ouest en Lambert 93 + code EPSG) est conservé dans
l'en-tête : le fichier reste raccordable à ses voisins.
---
## 3. Intégration dans le moteur
`TerrainMesh`, les shaders et la caméra n'ont **pas été touchés**. C'était tout
l'intérêt d'avoir fait passer le terrain par `Heightmap` dès la Phase 4, et ça
s'est vérifié : la classe a simplement reçu un second constructeur qui adopte une
grille déjà construite.
- `src/assets/TerrainFile.{hpp,cpp}` — lecture et validation du `.vchm`.
- `src/assets/Heightmap.{hpp,cpp}` — constructeur « grille toute faite »,
`GeoReference`, `toProjected()`, validation factorisée dans `finalize()`.
- `src/main.cpp` — sélection de la scène, repli sur le procédural.
### Scènes disponibles
```
vercora.exe -> dalle LiDAR reelle (defaut)
vercora.exe terrain -> terrain synthetique (Phase 4)
vercora.exe chemin\dalle.vchm -> une autre heightmap reelle
vercora.exe cube -> cube code en dur (Phase 1)
vercora.exe modele.obj -> mesh charge depuis un fichier
```
Si la dalle par défaut est absente (elle n'est pas versionnée), le jeu **se replie
sur le terrain synthétique** avec un message expliquant comment la produire. Un
chemin donné *explicitement* qui n'existe pas est en revanche une erreur : obtenir
du bruit fractal à la place de la dalle demandée sans s'en apercevoir serait pire
que planter.
---
## 4. Les problèmes rencontrés avec les vraies données
### 4.1 Trous — 21,6 % des cellules au pas de 1 m
Cause : 67 % de végétation haute. Sous un couvert dense, aucun écho ne redescend
jusqu'au sol. Le plus gros trou fait **6 cellules de rayon**.
Traitement : dilatation itérative — chaque passe remplit une cellule vide par la
moyenne de ses voisines déjà connues, jusqu'à ce qu'il n'en reste aucune. Le
nombre de passes est journalisé et vaut exactement le rayon du plus gros trou :
c'est le diagnostic le plus parlant sur la qualité d'une dalle. Aucun `NaN` ne
doit atteindre le GPU — il produirait un triangle dégénéré et un terrain
clignotant, sans le moindre message d'erreur. `Heightmap::finalize()` refuse donc
aussi toute valeur non finie, en seconde barrière.
### 4.2 Valeurs aberrantes — 13 cellules sur 1 002 001
La médiane par nœud absorbe déjà le bruit ponctuel. Le risque résiduel est la
cellule dont *tous* les points sont faux. Le filtre doit donc être sévère envers
un pic isolé et **indulgent envers une falaise**, car cette dalle en a de vraies.
D'où un double seuil : il faut dépasser **à la fois** 5 m d'écart absolu **et**
6 × la dispersion locale (MAD du voisinage 3×3). Sur un versant raide la
dispersion locale est grande et le filtre se désactive de lui-même ; sur un
replat elle est proche de zéro et le moindre pic ressort. Résultat : 13 cellules
touchées, écart maximal 25,2 m — des blunders francs, pas du relief.
### 4.3 Coordonnées Lambert 93 — recentrage obligatoire
Les coordonnées IGN valent ~907 000 en X et ~6 440 000 en Y. À 6,4 millions,
l'écart entre deux `float32` consécutifs vaut déjà **0,5 m** : porter ces valeurs
dans les sommets ferait trembler la géométrie et ruinerait le depth buffer.
Le terrain est donc **recentré sur l'origine du monde** (ce que `Heightmap`
faisait déjà), et le géoréférencement est conservé **en `double`, à côté de la
grille**, jamais dans les sommets. `Heightmap::toProjected()` refait le chemin
inverse ; le jeu journalise au démarrage la position Lambert 93 du point de
départ (E 907500, N 6439500, altitude 605,38 m), ce qui permet de retrouver
l'endroit sur une carte à partir d'un simple log de partie.
### 4.4 Le piège de l'orientation — le relief en miroir
Le moteur est en repère main droite avec Y vers le haut, donc X ∧ Y = Z. En
posant X = Est, on obtient **Z = Est ∧ Haut = −Nord** : le nord est en −Z. Les
lignes du `.vchm` sont donc rangées **du nord vers le sud**.
Se tromper de sens produit un terrain parfaitement plausible — même dénivelé,
mêmes pentes, même histogramme — mais **retourné**, et d'autant plus indétectable
qu'il n'y a pas encore d'orthophoto à plaquer dessus. C'est le genre d'erreur
qu'on découvre trois phases plus tard.
D'où `tools/check_terrain_file.py`, qui relit le `.vchm` et le confronte au nuage
brut sans rien partager avec le convertisseur :
```bash
python tools/check_terrain_file.py assets/terrain/LHD_0907_6440_1m.vchm data/lidar/LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz
```
Résultat sur les deux résolutions :
```
lecture DIRECTE : ecart moyen 0.0000 m, max 0.0000 m
si les lignes etaient inversees (nord/sud) : ecart moyen 64.3 m
si les colonnes etaient inversees (est/ouest): ecart moyen 221.1 m
```
C'est le **contraste** qui fait la preuve, pas la valeur absolue.
### 4.5 Deux erreurs réellement commises, et attrapées par ce contrôle
1. **Arrondi bancaire.** `np.rint` arrondit les ex æquo vers l'entier *pair* : un
point tombant pile sur la frontière entre deux nœuds partait à gauche ou à
droite selon la **parité** de l'indice. Les coordonnées LAZ étant quantifiées
au centimètre, ces ex æquo sont fréquents. Remplacé par `floor(t + 0.5)`.
2. **Intervalle inversé sur l'axe nord.** En arrondissant directement
`(y_max − y)`, le sens de l'intervalle semi-ouvert s'inversait avec le signe :
`[c−½, c+½[` sur l'axe est, mais `]c−½, c+½]` sur l'axe nord. Deux dalles
voisines raccordées le long d'une frontière est-ouest se seraient disputé leur
ligne commune. Le renversement nord-sud se fait désormais **après** l'arrondi,
sur l'indice entier.
Aucune des deux n'était visible à l'écran : elles ne déplaçaient qu'une poignée
de points sur une dalle isolée. Elles auraient explosé au premier assemblage
multi-dalles.
### 4.6 Le relief casse la visée horizontale — et donc le script de test
Symptôme : le scénario C échouait à abattre l'arbre visé, alors que le jeu
fonctionnait parfaitement.
`Forest::pickTree` lance un rayon **horizontal** depuis l'œil (la souris ne peut
pas être pilotée par messages Win32 — voir l'en-tête de `run_vulkan_check.ps1`),
et vérifie que le point touché est entre le pied et la cime. Sur le terrain
synthétique, assez lisse, un arbre à 9 m au nord est toujours dans l'axe : **les
16 arbres sur 16 sont abattables**. Sur le relief mesuré, un arbre en contrebas
passe entièrement sous le rayon et un arbre en amont entièrement au-dessus :
**seuls 6 sur 16 le sont**.
Plutôt que de réimplémenter ce raisonnement en PowerShell, `vercora.exe
--dump-world` interroge la **vraie** fonction de visée du jeu, avec la vraie
heightmap, pour chaque recul plausible, et émet des lignes
`AIM <indice> <camX> <camZ> <recul>`. Le script vise le plus proche des arbres
*réellement* abattables. Ce n'est pas une estimation : c'est la réponse de
`Forest::pickTree`.
C'est un vrai constat de gameplay, pas seulement un problème de test : **sur du
relief réel, on ne peut abattre qu'un tiers des arbres sans pouvoir viser en
hauteur.** Le pitch de la caméra existe pourtant — c'est le script qui ne peut
pas s'en servir. À confirmer manette en main.
### 4.7 `dump_world` replié dans le jeu — et Smart App Control
`tools/dump_world.cpp` et `tools/build_dump_world.bat` sont **supprimés**. Le dump
est désormais un mode du jeu :
```
vercora.exe --dump-world # dalle par defaut
vercora.exe --dump-world terrain # terrain synthetique
vercora.exe --dump-world chemin\dalle.vchm # une autre dalle
```
Deux raisons, dans cet ordre d'importance :
1. **La duplication était un piège.** `dump_world.cpp` *recopiait* la construction
du monde de `main.cpp` en comptant sur le fait que les deux resteraient dans le
même ordre — le semis étant déterministe, un ordre différent aurait donné un
monde différent, et le script aurait visé à côté sans que rien ne le signale.
Le dump traverse maintenant exactement le code du jeu, par construction.
2. **Smart App Control est actif sur cette machine** (`VerifiedAndReputablePolicyState = 1`).
Il a bloqué à l'exécution le `dump_world.exe` fraîchement recompilé —
« Une stratégie de contrôle d'application a bloqué ce fichier » — alors que le
binaire *précédent*, issu des mêmes sources, tournait. Le verdict porte sur
l'empreinte du fichier : il est donc imprévisible pour tout binaire non signé
nouvellement produit. Recopier le fichier sous un autre nom ne change rien, et
attendre 2 minutes non plus. `vercora.exe` et `logic_tests.exe` passent, eux.
*Rien n'a été désactivé* : SAC est un réglage de sécurité de la machine. Si le
problème réapparaît sur un autre binaire, c'est à l'utilisateur de décider
(Sécurité Windows → Contrôle d'application intelligent). Une raison de plus de
n'avoir qu'un seul exécutable. À classer avec les autres particularités de
cette machine (VS corrompu, `rc.exe` bloqué au premier appel), cf.
NOTES-PHASE6.md.
### 4.8 Ordre des opérations dans le pilotage
Première version du scénario C : promenade de 30 m dans les quatre directions
« pour exercer le relief », *puis* abattage. Le trajet traversait le semis
d'arbres, chaque tronc déviait la caméra de quelques dizaines de centimètres, et
la position à l'estime n'était plus bonne. Corrigé : **viser d'abord depuis
l'origine** — la seule position connue exactement — **se promener ensuite**,
quand la dérive n'a plus d'importance. C'est exactement la leçon que l'en-tête du
scénario B documentait déjà.
---
## 5. Vérification
### Tests headless — 169 assertions (121 avant)
`TerrainFile.cpp` et `TerrainMesh.cpp` ne dépendent ni de Vulkan ni de GLFW : ils
sont désormais **compilés et liés** dans l'exécutable de test (`TerrainMesh.cpp`
n'était que vérifié syntaxiquement). Le nouveau bloc couvre :
- écriture puis relecture d'un `.vchm` construit octet par octet dans le test,
avec une grille **asymétrique sur les deux axes** (sans quoi une inversion
passerait inaperçue) ;
- résolution, pas, emprise déduite, bornes, label, `heightAt` aux nœuds et en
milieu de cellule ;
- `toProjected` aux quatre coins, y compris la règle des signes opposés (aller à
l'est **augmente** l'abscisse projetée, aller au sud **diminue** l'ordonnée) ;
- `terrainMeshData` sur la grille chargée : un sommet par échantillon, altitudes
identiques ;
- **refus** d'un fichier à magie fausse, version inconnue, grille non carrée, pas
nul, grille d'un seul échantillon, fichier tronqué, altitude `NaN`, fichier
absent ;
- la **vraie dalle** si elle est présente (bloc ignoré sinon) : 1001², pas de 1 m,
EPSG 2154, dénivelé > 500 m, et surtout `heightAt(0,0) == 605,38 m` — valeur
relevée indépendamment sur le nuage brut par `check_terrain_file.py`.
### Vulkan réel — 3 scénarios
| | Scénario A | Scénario B | Scénario C |
|---|---|---|---|
| Terrain | synthétique | synthétique | **dalle LiDAR** |
| Couvre | gameplay complet, resize, minimisation | collision tronc puis souche | 2 M triangles, marche sur relief mesuré, abattage, ramassage, vol libre, 6 resize, minimisation |
| Résultat | 0 validation, sortie 0 | 0 validation, sortie 0 | 0 validation, sortie 0 |
---
## Ce qui n'a pas changé
- **Le terrain synthétique reste le monde de référence des tests.** Semis
déterministe, positions connues d'avance, arbres tous abattables : c'est ce qui
rend les scénarios A et B décisifs. Il n'est pas près d'être supprimé.
- **Les arbres et les pierres restent procéduraux.** La classification LiDAR
contient bien la végétation (67 % de la dalle), mais en extraire des arbres
individuels — segmentation de houppiers — est un sujet à part entière.
- **`TerrainMesh`, les shaders, `Camera`, `Forest`, `Ground` : aucune
modification.** `Camera.hpp` n'a reçu qu'une constante nommée
(`kDefaultEyeHeight`), pour que le dump puisse prédire ce que voit le joueur.
## Outils
| Script | Rôle |
|---|---|
| `tools\build.bat` | configure + compile (Debug par défaut, donc validation layers) |
| `tools\run_logic_tests.bat` | 169 assertions de comportement, sans GPU |
| `tools\run_vulkan_check.ps1` | lance le vrai jeu (3 scénarios) et traque les erreurs de validation |
| `tools\lidar_to_heightmap.py` | dalle `.laz` IGN → heightmap `.vchm` |
| `tools\check_terrain_file.py` | confronte un `.vchm` au nuage brut (détecte le miroir) |
| `vercora.exe --dump-world` | imprime le monde semé et les reculs de tir (remplace `tools\dump_world.cpp`) |
## Limites assumées
- **Grilles carrées uniquement.** `Heightmap` et `TerrainMesh` n'exposent qu'une
résolution. Une dalle IGN étant un carré de 1 km, ça ne coûte rien aujourd'hui ;
ça devra tomber au premier assemblage multi-dalles. Un fichier rectangulaire est
**refusé avec un message explicite**, pas chargé de travers.
- **Une seule dalle à la fois**, chargée entièrement en mémoire. Pas de streaming,
pas de LOD, pas de pavage.
- **Pas de texture.** Le terrain est coloré par altitude et par pente, comme en
Phase 4. Les UV du maillage sont prêts pour une orthophoto (`data.geopf.fr`
diffuse la BD ORTHO sur la même emprise).
- **Le nord est en −Z**, ce qui est correct mais peu intuitif. À garder en tête au
moment de plaquer la première orthophoto.
## Prochaines étapes suggérées
1. **Essayer manette en main** — notamment la remarque 4.6 : est-ce que viser en
hauteur suffit à rendre tous les arbres abattables sur du vrai relief ?
2. **Orthophoto BD ORTHO** sur la même emprise, plaquée via les UV existants.
C'est le premier vrai contrôle visuel de l'orientation.
3. **Assemblage multi-dalles** : supporter les grilles rectangulaires, raccorder
les bords (les nœuds de bord sont déjà partagés par construction), et décider
d'une origine monde commune.
4. **Exploiter la classification** : la classe 5 (végétation haute) donne une
carte de densité de forêt, de quoi semer les arbres là où il y en a vraiment.
5. **Choisir la zone du jeu.** Le pipeline est prêt ; n'importe quelle dalle de
France se charge maintenant en deux commandes.
+366
Voir le fichier
@@ -0,0 +1,366 @@
# Vercora — Phase 9 : la vraie zone de jeu, 25 dalles assemblées en un terrain
Session du 2026-08-20/21. Objectif : passer de la dalle unique de validation
(Phase 7) à la **zone de jeu réelle** choisie avec l'utilisateur et son père —
25 dalles LiDAR HD, grille 5 × 5 km, Lambert 93 X 899–903 / Y 6436–6440.
C'est la session où se jouait ce que les deux bugs d'arrondi de la Phase 7
(arrondi bancaire, intervalle semi-ouvert inversé sur l'axe nord) auraient cassé
**en silence**. Ils avaient été corrigés mais jamais éprouvés en conditions
réelles. Ils le sont maintenant : **les 8 frontières intérieures sont vérifiées
contre les nuages bruts, alignement prouvé par contraste ×14,5.**
> **Numérotation.** La consigne de session parlait de « Phase 8 ». La Phase 8
> existe déjà dans `MEMORY.md` (visée sur relief + base du parapente, même
> journée) : cette session est donc numérotée **Phase 9** partout, y compris dans
> l'en-tête des nouveaux outils.
---
## Résultat en une page
| | |
|---|---|
| Dalles téléchargées | **25 / 25**, 4,99 Go, **73 s** (~85 Mo/s) |
| Conversion 1 m | 25 × 1001×1001, ~6 s/dalle, ~2,5 min au total |
| Terrain assemblé 1 m | **5001 × 5001**, 95,4 Mo, 5000 × 5000 m, dénivelé **1256 m** (1028,8 → 2285,2 m) |
| Continuité aux frontières | **conforme sur les 8 frontières** (détail plus bas) |
| Chargé dans le moteur | oui — 25 M sommets, 50 M triangles, **0 erreur de validation** |
| Jouable à 1 m ? | **non — 12 FPS.** Le 2 m (46 FPS) est le repli utilisable |
| Verdict | **le streaming par tuiles devient nécessaire maintenant**, cf. §6 |
---
## 1. Téléchargement — `tools/fetch_dalles.py` (nouveau)
Le manifeste annoncé à la racine sous le nom `vercora_dalles.json` n'y était
pas : il se trouvait dans `Downloads` sous le nom **`metadonnees.json`** (avec un
doublon `metadonnees(1).json`, strictement identique — même MD5). Contenu
conforme à l'annonce : 25 entrées, grille 5 × 5 complète, 925 974 185 points.
Copié à la racine sous le nom attendu.
```bash
python tools/fetch_dalles.py vercora_dalles.json -o data/lidar --dry-run
python tools/fetch_dalles.py vercora_dalles.json -o data/lidar
```
Le script fait d'abord **25 requêtes HEAD** pour connaître la taille réelle du
lot *avant* d'écrire quoi que ce soit (4,99 Go), la compare à l'espace libre
(281,6 Go) avec une marge, puis télécharge. Reprise par `Range` sur fichier
partiel, 4 tentatives avec attente croissante, vérification de la taille finale
**et** de la signature `LASF` — un HTML d'erreur enregistré sous un nom en `.laz`
passerait sinon inaperçu jusqu'à la conversion. Bilan final nommant les échecs.
**Résultat : 25/25, aucune reprise, aucun échec.** 73 s en deux lots (4 puis 21).
> **À noter pour l'utilisateur** : le téléchargement par navigateur lancé en
> parallèle tournait à ~1,5 Mo/s, contre ~85 Mo/s pour le script — soit plus
> d'une heure contre une minute pour le même lot.
## 2. Conversion — `tools/lidar_to_heightmap.py` (une option ajoutée)
Résolution **1 m, inchangée depuis la Phase 7**, et pour les mêmes raisons (la
densité de points sol la supporte). Un jeu 2 m est produit **en plus**, pas à la
place — voir §5.
Une seule modification, mais elle est structurante pour l'assemblage :
**`--bounds-from-name`.** L'emprise de la grille était déduite de
`header.mins/maxs`, c'est-à-dire de l'étendue des **points**, arrondie au mètre.
Sur les 25 dalles ça tombe juste — mais ce n'est pas garanti : une dalle dont les
échos s'arrêtent 30 cm avant le bord (bord de mission, plan d'eau, trou de vol)
aurait donné 1000 échantillons au lieu de 1001. Elle aurait alors été **refusée
comme non carrée**, ou pire, se serait raccordée **décalée d'un mètre**. L'option
impose l'emprise **nominale** lue dans le nom de la dalle, qui est celle que
l'IGN garantit. Utilisée pour les 25.
Résultats : **25 dalles, toutes en 1001 × 1001**, ~6 s chacune. Les trous varient
énormément d'une dalle à l'autre — de **0,26 %** (0901_6438) à **47,3 %**
(0901_6436, sous couvert dense) — et sont bouchés par dilatation comme en Phase 7.
> **Un piège rencontré, et qui vaut d'être noté.** La première passe de
> conversion en a silencieusement sauté 3 : le motif shell `LHD_FXX_09*` ne
> correspond pas aux dalles de la colonne **X = 899**, dont le nom commence par
> `LHD_FXX_0899` — donc par `08`, pas `09`. Erreur de ma part, pas de l'outil.
> Elle n'a pas pu aller plus loin parce que **`assemble_terrain.py` refuse une
> grille incomplète** (`--allow-gaps` est explicite) : le filet a joué son rôle.
## 3. Assemblage — `tools/assemble_terrain.py` (nouveau)
```bash
python tools/assemble_terrain.py assets/terrain/LHD_09*_1m.vchm \
-o assets/terrain/vercora_zone_1m.vchm --label vercora_zone_5x5_1m
```
Chaque dalle est placée par son **géoréférencement** (`originEast`/`originNorth`
de son en-tête), jamais par son nom ni son ordre sur la ligne de commande. Une
origine qui ne tombe pas sur le réseau au pas courant est refusée.
### Le nœud partagé — le point non évident
Les échantillons sont sur les **nœuds** : une dalle de 1 km au pas de 1 m fait
1001 échantillons, de X=899000 à X=900000 **inclus**. La voisine commence à
X=900000, inclus elle aussi. **La colonne est donc dans les deux fichiers.**
5 dalles alignées font **5 × 1001 − 4 = 5001** échantillons, pas 5005. Une
concaténation naïve aurait produit 5005 colonnes : terrain 4 m trop large et tout
ce qui est à l'est d'une jointure décalé — la « duplication de ligne/colonne à la
jointure » à ne pas commettre. Le script le signale explicitement dans sa sortie.
Mais les deux valeurs partagées **ne sont pas identiques**, et c'est normal : le
nœud X=900000 agrège les points de [899999,5 ; 900000,5[. La dalle ouest n'en
voit que la moitié gauche, la dalle est que la moitié droite. **L'écart entre les
deux mesure directement la cohérence du raccord.** La valeur retenue est leur
moyenne.
### Écart entre les deux versions d'un nœud partagé (40 040 nœuds, 1 m)
| | |
|---|---|
| Médiane | **0,170 m** |
| Moyenne | 0,359 m |
| p99 | 2,78 m |
| > 10 m | 73 nœuds (0,18 %) |
| > 50 m | 15 nœuds (0,037 %) |
| Maximum | **79,23 m** |
Les 79 m ont été **cherchés et expliqués**, pas laissés de côté. Le pire nœud est
à E 903844 / N 6439000 : 1728,66 m selon la dalle nord, 1807,89 m selon la dalle
sud. Vérification dans les nuages bruts : les deux dalles **ont** des points là
(28 et 22 dans la cellule), et dans une fenêtre de 10 × 10 m autour, les
altitudes sol vont de **1682 à 1827 m** — une paroi quasi verticale.
La corrélation est nette sur l'ensemble :
| Écart au nœud partagé | Nœuds | Relief local médian (amplitude sur 5 m) |
|---|---|---|
| ≤ 0,5 m | 34 569 | **1,62 m** |
| 0,5 – 2 m | 4 742 | 2,31 m |
| 2 – 10 m | 656 | 2,41 m |
| 10 – 50 m | 58 | **34,13 m** |
| > 50 m | 15 | **59,71 m** |
**Ce n'est pas un défaut d'assemblage mais la limite d'une heightmap 2,5D sur une
falaise** : sur une paroi verticale, « l'altitude du sol en (x, y) » n'a pas de
valeur unique, et la médiane d'une cellule de 1 m² y est instable par nature. 79 %
des nœuds à plus de 10 m d'écart sont sur du relief à plus de 20 m d'amplitude
sur 5 m. À garder en tête le jour où la collision devra gérer ces parois.
## 4. Vérification des frontières — `tools/check_seams.py` (nouveau)
`tools/check_terrain_file.py` est resté **inchangé** : deux arguments positionnels
et des sondes nommées en dur, taillés pour une dalle isolée. Le pendant
multi-dalles est un outil frère, qui applique le **même principe** — relire le
`.vchm` produit et le confronter aux points sol **bruts**, sans rien partager avec
le producteur, pour qu'une erreur d'indexation ne puisse pas se compenser.
```bash
python tools/check_seams.py assets/terrain/vercora_zone_1m.vchm data/lidar/*.laz
```
1 676 sondes (1 592 réparties tous les 25 m le long des 8 frontières, 100 témoins
loin de toute jointure), dont **1 360 exploitables** — les 316 autres sont
rejetées faute de points sol, sous couvert dense.
### Résultat (terrain 1 m, 25 dalles)
```
lecture jointures: median max | temoins: median max
direct 0.020m 80.840m 0.000m 0.080m <- lecture reelle
est +1 0.300m 42.605m 0.290m 3.430m
ouest -1 0.300m 85.420m 0.305m 2.105m
sud +1 0.290m 77.540m 0.260m 1.885m
nord -1 0.295m 86.930m 0.280m 1.595m
```
**C'est le contraste qui fait la preuve**, comme pour le test nord/sud de la
Phase 7 : la lecture directe vaut **0,020 m** contre **0,290 m** pour le meilleur
décalage d'un nœud, soit **×14,5**. Un assemblage décalé d'une colonne resterait
plausible sur du relief doux ; il ne peut pas produire ce contraste.
Détail des 8 frontières — aucune ne se distingue :
| Frontière | Sondes | Médiane | Max |
|---|---|---|---|
| H N6436000 | 109 | 0,030 m | 12,49 m |
| H N6437000 | 167 | 0,025 m | 11,66 m |
| H N6438000 | 171 | 0,020 m | 0,53 m |
| H N6439000 | 175 | 0,017 m | 12,72 m |
| V E900000 | 175 | 0,022 m | 1,87 m |
| V E901000 | 164 | 0,015 m | 0,27 m |
| V E902000 | 152 | 0,017 m | **80,84 m** |
| V E903000 | 160 | 0,020 m | 0,39 m |
Les maxima isolés sont les falaises du §3 (mêmes nœuds, même cause). **Les
médianes, elles, sont toutes ≤ 0,030 m**, et les témoins en plein milieu de dalle
sont à 0,000 m : le raccord n'est pas moins fidèle que le reste du terrain.
### Deuxième contrôle, indépendant, dans `assemble_terrain.py`
Mesure faite sur le **produit fini**, sans rien savoir des dalles d'origine : le
long d'une jointure, la différence entre deux colonnes voisines doit ressembler à
celle observée partout ailleurs. Un décalage la rendrait anormalement **grande**,
une colonne dupliquée anormalement **petite** (deux colonnes identiques = pente
nulle). Les deux défauts sont donc attrapés.
```
reference : pente mediane est-ouest 0.300 m/m, nord-sud 0.265 m/m
jointure verticale x=1000 : 0.393 / 0.397 x=2000 : 0.253 / 0.250
x=3000 : 0.270 / 0.267 x=4000 : 0.318 / 0.315
jointure horizontale z=1000 : 0.235 / 0.235 z=2000 : 0.250 / 0.248
z=3000 : 0.388 / 0.390 z=4000 : 0.403 / 0.398
OK - aucune jointure ne se distingue du relief environnant.
```
### Système de coordonnées
Inchangé et conforme à la Phase 7 : le `.vchm` garde son géoréférencement en
`double` dans l'en-tête (coin nord-ouest **E 899000 / N 6440000**, EPSG:2154) et
des altitudes **absolues IGN69** ; c'est le moteur qui **recentre le terrain sur
l'origine du monde** au chargement. Les sommets ne portent donc jamais de
coordonnées Lambert 93 — à 6,4 millions, l'écart entre deux `float32` vaut déjà
0,5 m. Sur 5 km, le monde va de −2500 à +2500 en X et en Z, et les anciennes
frontières de dalles tombent à ±500 et ±1500 m.
## 5. Chargement dans le moteur et performances
Mesures reproductibles via **`tools/measure_terrain.ps1`** (nouveau) : FPS lu dans
le titre de la fenêtre, mémoire par `PeakWorkingSet64`. **Rien n'a été ajouté au
moteur pour mesurer** — c'est exactement le binaire qui tourne en vrai.
> **Le GPU a changé depuis la Phase 7.** Cette machine n'a plus de GTX 960 : elle
> tourne sur l'**Intel UHD 770** intégrée (confirmé par l'utilisateur, ce n'est
> pas un défaut de détection). Les 848 FPS de la Phase 7 ne sont donc **pas**
> comparables aux chiffres ci-dessous. La dalle de Phase 7 a été **re-mesurée**
> sur ce GPU pour servir de repère honnête. i5-14600K, 64 Go de RAM, build
> **Debug avec couches de validation**, comme en Phase 7.
| Scène | Sommets | Triangles | FPS | Pic RAM | Chargement |
|---|---:|---:|---:|---:|---:|
| Procédural (Phase 4) | 16 384 | 32 258 | **1381** | 108 Mo | 0,2 s |
| 1 dalle 1 m (Phase 7) | 1 002 001 | 2 000 000 | **247** | 302 Mo | 0,6 s |
| 2 × 2 dalles 1 m (4 km²) | 4 004 001 | 8 000 000 | **67** | 805 Mo | 1,8 s |
| **5 × 5 dalles 2 m (25 km²)** | 6 255 001 | 12 500 000 | **46** | 1 083 Mo | 2,8 s |
| **5 × 5 dalles 1 m (25 km²)** | 25 010 001 | 50 000 000 | **12** | **4 014 Mo** | 10,2 s |
**Zéro message `[Validation]`, zéro `[ERROR]`/`[WARN]`, code de sortie 0 sur les
cinq scènes.** Le terrain de 25 km² à 1 m *charge et fonctionne* — il n'est
simplement pas jouable.
### Déplacement sur toute la zone — `tools/traverse_terrain.ps1` (nouveau)
La caméra marche 5,6 km en franchissant les anciennes frontières à ±500 m et
±1500 m sur les deux axes, avec relevé du FPS **en cours de route** : un accroc à
une jointure se verrait comme une chute localisée, pas dans une moyenne.
| Terrain | FPS moyen | min | max | Validation | Sortie |
|---|---|---|---|---|---|
| 5 × 5 à 2 m | 46–47 | 43 | 47 | 0 | propre |
| 5 × 5 à 1 m | 12 | 9 | 12 | 0 | propre |
**Aucune chute localisée au franchissement d'une frontière**, aucune chute à
travers le sol, aucun blocage, fermeture propre. Le FPS est le même au milieu
d'une ancienne dalle et à cheval sur une jointure.
*Limite assumée, la même qu'en Phase 7/8 : la souris ne peut pas être pilotée
(GLFW lit le curseur système), donc la caméra ne tourne pas de tout le test et la
position n'est connue qu'à l'estime. Le test prouve qu'on traverse sans incident ;
il ne mesure pas où l'on arrive.*
### Non-régression
- **Terrain procédural** (`vercora.exe terrain`) : 1381 FPS, intact.
- **Dalle unique de la Phase 7** (`vercora.exe assets\terrain\LHD_0907_6440_1m.vchm`) :
247 FPS, intacte. Elle **reste la scène par défaut** — voir §6.
- **185 assertions headless** (`tools\run_logic_tests.bat`) : toutes passent.
- **`tools\run_vulkan_check.ps1`**, 4 scénarios : voir le tableau de `MEMORY.md`.
## 6. Le verdict qu'il faut entendre : le streaming devient nécessaire
Le facteur limitant n'est **pas** la mémoire (4 Go sur une machine qui en a 64,
et le GPU intégré puise dans la RAM système) ni le disque (5,2 Go sur 281 Go
libres) ni la conversion (2,5 min pour 25 dalles). C'est le **débit géométrique**.
Le moteur envoie **un seul maillage, en entier, à chaque image**, sans LOD ni
culling par morceaux. Le coût est donc proportionnel à la surface, et il l'est
très proprement : 247 → 67 → 12 FPS pour 1 → 4 → 25 km² à 1 m. Or **le joueur ne
voit à aucun moment plus d'un très petit pourcentage** de ces 50 M de triangles.
**Réponse à la question posée : oui, un système de streaming par tuiles devient
nécessaire maintenant, et non plus tard.** À l'échelle de la Phase 7 tout passait
en force ; à 25 km² ce n'est plus vrai, et la donnée finale est là pour rester.
Sans découpage, chaque agrandissement futur de la zone divisera encore le FPS.
Ce qui est *déjà* acquis pour ça : les 25 heightmaps individuelles sont
conservées (`assets/terrain/LHD_<X>_<Y>_1m.vchm`), le géoréférencement de chacune
est exact, et l'assemblage est prouvé cohérent. **Le découpage en tuiles n'aura
donc rien à redécouper** — il consommera directement les dalles existantes.
Ce qui manque côté moteur, par ordre d'importance : charger/décharger des
morceaux de terrain selon la position de la caméra ; un LOD par distance (une
tuile lointaine n'a pas besoin du pas de 1 m) ; un frustum culling par tuile. La
contrainte « grilles carrées uniquement » de `TerrainFile` devra aussi tomber,
puisqu'elle n'a survécu ici que parce que 5 × 5 est carré.
### En attendant : le 2 m est le repli utilisable
`assets/terrain/vercora_zone_2m.vchm` (2501 × 2501, 25 Mo) couvre la **même zone
de 25 km²** à **46 FPS** et 1 Go — soit 4× moins de triangles pour un pas qui
reste très fin à l'échelle d'une montagne. La Phase 7 avait déjà généré le 2 m en
prévoyant exactement ce cas (« pour une future carte multi-dalles »).
**Ce n'est pas un substitut au 1 m** : le fichier 1 m est produit, vérifié et
livré, et c'est lui qui alimentera le streaming. C'est un repli pour continuer à
travailler sur la vraie zone d'ici là.
## 7. Ce qui n'a pas été fait / vérifié — à dire franchement
- **La scène par défaut n'a pas été changée.** `vercora.exe` sans argument charge
toujours la dalle de Phase 7. Faire de la zone 25 km² le défaut alors qu'elle
tourne à 12 FPS aurait donné l'impression d'une régression du moteur ; le choix
du défaut revient à l'utilisateur, une fois le streaming décidé. Les deux
terrains assemblés se chargent par chemin explicite.
- **Aucun test headless n'a été ajouté** pour l'assemblage : la vérification est
entièrement en Python (`assemble_terrain.py` + `check_seams.py`), pas dans les
185 assertions C++. Un test C++ qui chargerait `vercora_zone_1m.vchm` supposerait
un fichier de 95 Mo non versionné.
- **Aucun scénario n'a été ajouté à `run_vulkan_check.ps1`** pour la zone
assemblée : le pilotage par PostMessage est calibré en distance/temps à
vitesse 14 m/s, et à 12 FPS le jeu consomme les touches trop grossièrement pour
que le tir sur cible reste fiable. `traverse_terrain.ps1` couvre le
déplacement ; l'abattage/ramassage sur la nouvelle zone reste à vérifier.
- **Rien n'a été vérifié à la manette / à l'œil.** L'orientation du relief est
prouvée par la donnée (contraste ×14,5), pas par un contrôle visuel : il n'y a
toujours pas d'orthophoto plaquée. C'est toujours la recommandation n°2 de la
Phase 7.
- **Les falaises du §3** ne sont pas traitées, seulement caractérisées.
- **`--bounds-from-name` n'a pas été éprouvée sur une dalle réellement tronquée**,
puisque les 25 tombaient juste. C'est un filet, pas une correction constatée.
## 8. Où sont les choses
| Chemin | Quoi |
|---|---|
| `vercora_dalles.json` | manifeste des 25 dalles (copié depuis `Downloads/metadonnees.json`) |
| `data/lidar/*.copc.laz` | 25 dalles brutes, **5,2 Go** (avec celle de Phase 7) — non versionnées |
| `assets/terrain/LHD_<X>_<Y>_1m.vchm` | 25 heightmaps individuelles, 3,82 Mo chacune |
| `assets/terrain/LHD_<X>_<Y>_2m.vchm` | idem au pas de 2 m |
| `assets/terrain/vercora_zone_1m.vchm` | **terrain assemblé 5001², 95,4 Mo** |
| `assets/terrain/vercora_zone_2m.vchm` | terrain assemblé 2501², 25 Mo (repli jouable) |
| `assets/terrain/test_2x2_1m.vchm` | bloc de validation 2 × 2, gardé comme cas de test |
Nouveaux outils : `tools/fetch_dalles.py`, `tools/assemble_terrain.py`,
`tools/check_seams.py`, `tools/measure_terrain.ps1`, `tools/traverse_terrain.ps1`.
Modifié : `tools/lidar_to_heightmap.py` (option `--bounds-from-name`).
**Aucun fichier de `src/` n'a été modifié dans cette session.**
## Prochaines étapes suggérées
1. **Streaming par tuiles + LOD** (§6) — le vrai sujet de la prochaine session.
2. **Orthophoto BD ORTHO** sur l'emprise E 899000–904000 / N 6435000–6440000 :
premier contrôle *visuel* de l'orientation, toujours en attente depuis la
Phase 7.
3. Décider de la **scène par défaut** une fois le streaming en place.
4. Exploiter la classification (classe 5) pour semer les arbres là où il y en a
vraiment — la variation de couvert entre dalles (0,26 % à 47,3 % de trous) est
une carte de forêt gratuite.
+31
Voir le fichier
@@ -0,0 +1,31 @@
# assets/editor — modèles placables par l'éditeur (Phase 15)
Tout fichier `.obj` déposé ici est ajouté au catalogue de l'éditeur au prochain
démarrage du jeu. Aucune inscription nulle part : le dossier est scanné, c'est
tout.
- **Identifiant** = le nom du fichier sans extension, ramené en minuscules ASCII
(les espaces et les accents deviennent `_`). C'est cet identifiant qui est
écrit dans les fichiers de scène `assets/scenes/*.vcsc` : **le renommer casse
les objets déjà posés**.
- **Ordre du catalogue** : les modèles générés en code viennent en premier, puis
les fichiers **triés par nom**. Les touches `1`..`9` de l'éditeur désignent
des rangs dans cette liste, d'où le tri — sans lui, la même touche poserait un
modèle différent d'une exécution à l'autre.
- **Ancrage** : le loader recentre le modèle en X et Z sur sa boîte englobante et
pose son point le plus bas à `y = 0`. Un `.obj` dont l'origine est n'importe où
se pose donc quand même exactement au point visé. La documentation complète de
la convention est dans `src/editor/EditorAssets.hpp`.
- **Unités** : mètres. Un modèle exporté en centimètres sera 100 fois trop grand ;
le catalogue le signale au chargement (`dimension suspecte`) mais le charge
quand même — l'échelle se corrige objet par objet dans l'éditeur.
- **Collision** : déduite automatiquement de la boîte englobante (cylindre
vertical *contenant*). Un objet à intérieur — un abri, une arche — sera plein.
Le remède immédiat est de le poser *traversable* (touche `K`).
`octaedre.obj` est là comme témoin : c'est le seul asset du catalogue qui vienne
d'un fichier, donc le seul qui prouve que ce chemin fonctionne dans une partie
réelle.
**glTF (`.gltf` / `.glb`) n'est pas encore supporté** — voir `NOTES-PHASE15.md`.
Le seul endroit à étendre est `AssetCatalog::supportedExtensions()`.
+28
Voir le fichier
@@ -0,0 +1,28 @@
# Vercora - asset de test Phase 3 : octaedre a facettes plates
# 6 positions / 8 normales distinctes / 8 triangles
# Chaque position est reutilisee avec plusieurs normales : teste la
# deduplication du loader sur le triplet (position, uv, normale).
# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main
o OctahedronFlat
v 1.000000 0.000000 0.000000
v -1.000000 0.000000 0.000000
v 0.000000 1.000000 0.000000
v 0.000000 -1.000000 0.000000
v 0.000000 0.000000 1.000000
v 0.000000 0.000000 -1.000000
vn 0.577350 0.577350 0.577350
vn -0.577350 0.577350 0.577350
vn -0.577350 -0.577350 0.577350
vn 0.577350 -0.577350 0.577350
vn 0.577350 0.577350 -0.577350
vn -0.577350 0.577350 -0.577350
vn -0.577350 -0.577350 -0.577350
vn 0.577350 -0.577350 -0.577350
f 1//1 3//1 5//1
f 3//2 2//2 5//2
f 2//3 4//3 5//3
f 4//4 1//4 5//4
f 3//5 1//5 6//5
f 2//6 3//6 6//6
f 4//7 2//7 6//7
f 1//8 4//8 6//8
+210
Voir le fichier
@@ -0,0 +1,210 @@
# Vercora - asset de test Phase 3 : icosphere (1 subdivision)
# 42 sommets, 80 triangles, normales lissees + UV spheriques
# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main
o Icosphere
v -0.525731 0.850651 0.000000
v 0.525731 0.850651 0.000000
v -0.525731 -0.850651 0.000000
v 0.525731 -0.850651 0.000000
v 0.000000 -0.525731 0.850651
v 0.000000 0.525731 0.850651
v 0.000000 -0.525731 -0.850651
v 0.000000 0.525731 -0.850651
v 0.850651 0.000000 -0.525731
v 0.850651 0.000000 0.525731
v -0.850651 0.000000 -0.525731
v -0.850651 0.000000 0.525731
v -0.809017 0.500000 0.309017
v -0.500000 0.309017 0.809017
v -0.309017 0.809017 0.500000
v 0.309017 0.809017 0.500000
v 0.000000 1.000000 0.000000
v 0.309017 0.809017 -0.500000
v -0.309017 0.809017 -0.500000
v -0.500000 0.309017 -0.809017
v -0.809017 0.500000 -0.309017
v -1.000000 0.000000 0.000000
v 0.500000 0.309017 0.809017
v 0.809017 0.500000 0.309017
v -0.500000 -0.309017 0.809017
v 0.000000 0.000000 1.000000
v -0.809017 -0.500000 -0.309017
v -0.809017 -0.500000 0.309017
v 0.000000 0.000000 -1.000000
v -0.500000 -0.309017 -0.809017
v 0.809017 0.500000 -0.309017
v 0.500000 0.309017 -0.809017
v 0.809017 -0.500000 0.309017
v 0.500000 -0.309017 0.809017
v 0.309017 -0.809017 0.500000
v -0.309017 -0.809017 0.500000
v 0.000000 -1.000000 0.000000
v -0.309017 -0.809017 -0.500000
v 0.309017 -0.809017 -0.500000
v 0.500000 -0.309017 -0.809017
v 0.809017 -0.500000 -0.309017
v 1.000000 0.000000 0.000000
vn -0.525731 0.850651 0.000000
vn 0.525731 0.850651 0.000000
vn -0.525731 -0.850651 0.000000
vn 0.525731 -0.850651 0.000000
vn 0.000000 -0.525731 0.850651
vn 0.000000 0.525731 0.850651
vn 0.000000 -0.525731 -0.850651
vn 0.000000 0.525731 -0.850651
vn 0.850651 0.000000 -0.525731
vn 0.850651 0.000000 0.525731
vn -0.850651 0.000000 -0.525731
vn -0.850651 0.000000 0.525731
vn -0.809017 0.500000 0.309017
vn -0.500000 0.309017 0.809017
vn -0.309017 0.809017 0.500000
vn 0.309017 0.809017 0.500000
vn 0.000000 1.000000 0.000000
vn 0.309017 0.809017 -0.500000
vn -0.309017 0.809017 -0.500000
vn -0.500000 0.309017 -0.809017
vn -0.809017 0.500000 -0.309017
vn -1.000000 0.000000 0.000000
vn 0.500000 0.309017 0.809017
vn 0.809017 0.500000 0.309017
vn -0.500000 -0.309017 0.809017
vn 0.000000 0.000000 1.000000
vn -0.809017 -0.500000 -0.309017
vn -0.809017 -0.500000 0.309017
vn 0.000000 0.000000 -1.000000
vn -0.500000 -0.309017 -0.809017
vn 0.809017 0.500000 -0.309017
vn 0.500000 0.309017 -0.809017
vn 0.809017 -0.500000 0.309017
vn 0.500000 -0.309017 0.809017
vn 0.309017 -0.809017 0.500000
vn -0.309017 -0.809017 0.500000
vn 0.000000 -1.000000 0.000000
vn -0.309017 -0.809017 -0.500000
vn 0.309017 -0.809017 -0.500000
vn 0.500000 -0.309017 -0.809017
vn 0.809017 -0.500000 -0.309017
vn 1.000000 0.000000 0.000000
vt 1.000000 0.176208
vt 0.500000 0.176208
vt 1.000000 0.823792
vt 0.500000 0.823792
vt 0.750000 0.676208
vt 0.750000 0.323792
vt 0.250000 0.676208
vt 0.250000 0.323792
vt 0.411896 0.500000
vt 0.588104 0.500000
vt 0.088104 0.500000
vt 0.911896 0.500000
vt 0.941930 0.333333
vt 0.838104 0.400000
vt 0.838104 0.200000
vt 0.661896 0.200000
vt 0.500000 0.000000
vt 0.338104 0.200000
vt 0.161896 0.200000
vt 0.161896 0.400000
vt 0.058070 0.333333
vt 1.000000 0.500000
vt 0.661896 0.400000
vt 0.558070 0.333333
vt 0.838104 0.600000
vt 0.750000 0.500000
vt 0.058070 0.666667
vt 0.941930 0.666667
vt 0.250000 0.500000
vt 0.161896 0.600000
vt 0.441930 0.333333
vt 0.338104 0.400000
vt 0.558070 0.666667
vt 0.661896 0.600000
vt 0.661896 0.800000
vt 0.838104 0.800000
vt 0.500000 1.000000
vt 0.161896 0.800000
vt 0.338104 0.800000
vt 0.338104 0.600000
vt 0.441930 0.666667
vt 0.500000 0.500000
f 1/1/1 13/13/13 15/15/15
f 12/12/12 14/14/14 13/13/13
f 6/6/6 15/15/15 14/14/14
f 13/13/13 14/14/14 15/15/15
f 1/1/1 15/15/15 17/17/17
f 6/6/6 16/16/16 15/15/15
f 2/2/2 17/17/17 16/16/16
f 15/15/15 16/16/16 17/17/17
f 1/1/1 17/17/17 19/19/19
f 2/2/2 18/18/18 17/17/17
f 8/8/8 19/19/19 18/18/18
f 17/17/17 18/18/18 19/19/19
f 1/1/1 19/19/19 21/21/21
f 8/8/8 20/20/20 19/19/19
f 11/11/11 21/21/21 20/20/20
f 19/19/19 20/20/20 21/21/21
f 1/1/1 21/21/21 13/13/13
f 11/11/11 22/22/22 21/21/21
f 12/12/12 13/13/13 22/22/22
f 21/21/21 22/22/22 13/13/13
f 2/2/2 16/16/16 24/24/24
f 6/6/6 23/23/23 16/16/16
f 10/10/10 24/24/24 23/23/23
f 16/16/16 23/23/23 24/24/24
f 6/6/6 14/14/14 26/26/26
f 12/12/12 25/25/25 14/14/14
f 5/5/5 26/26/26 25/25/25
f 14/14/14 25/25/25 26/26/26
f 12/12/12 22/22/22 28/28/28
f 11/11/11 27/27/27 22/22/22
f 3/3/3 28/28/28 27/27/27
f 22/22/22 27/27/27 28/28/28
f 11/11/11 20/20/20 30/30/30
f 8/8/8 29/29/29 20/20/20
f 7/7/7 30/30/30 29/29/29
f 20/20/20 29/29/29 30/30/30
f 8/8/8 18/18/18 32/32/32
f 2/2/2 31/31/31 18/18/18
f 9/9/9 32/32/32 31/31/31
f 18/18/18 31/31/31 32/32/32
f 4/4/4 33/33/33 35/35/35
f 10/10/10 34/34/34 33/33/33
f 5/5/5 35/35/35 34/34/34
f 33/33/33 34/34/34 35/35/35
f 4/4/4 35/35/35 37/37/37
f 5/5/5 36/36/36 35/35/35
f 3/3/3 37/37/37 36/36/36
f 35/35/35 36/36/36 37/37/37
f 4/4/4 37/37/37 39/39/39
f 3/3/3 38/38/38 37/37/37
f 7/7/7 39/39/39 38/38/38
f 37/37/37 38/38/38 39/39/39
f 4/4/4 39/39/39 41/41/41
f 7/7/7 40/40/40 39/39/39
f 9/9/9 41/41/41 40/40/40
f 39/39/39 40/40/40 41/41/41
f 4/4/4 41/41/41 33/33/33
f 9/9/9 42/42/42 41/41/41
f 10/10/10 33/33/33 42/42/42
f 41/41/41 42/42/42 33/33/33
f 5/5/5 34/34/34 26/26/26
f 10/10/10 23/23/23 34/34/34
f 6/6/6 26/26/26 23/23/23
f 34/34/34 23/23/23 26/26/26
f 3/3/3 36/36/36 28/28/28
f 5/5/5 25/25/25 36/36/36
f 12/12/12 28/28/28 25/25/25
f 36/36/36 25/25/25 28/28/28
f 7/7/7 38/38/38 30/30/30
f 3/3/3 27/27/27 38/38/38
f 11/11/11 30/30/30 27/27/27
f 38/38/38 27/27/27 30/30/30
f 9/9/9 40/40/40 32/32/32
f 7/7/7 29/29/29 40/40/40
f 8/8/8 32/32/32 29/29/29
f 40/40/40 29/29/29 32/32/32
f 10/10/10 42/42/42 24/24/24
f 9/9/9 31/31/31 42/42/42
f 2/2/2 24/24/24 31/31/31
f 42/42/42 31/31/31 24/24/24
+28
Voir le fichier
@@ -0,0 +1,28 @@
# Vercora - asset de test Phase 3 : octaedre a facettes plates
# 6 positions / 8 normales distinctes / 8 triangles
# Chaque position est reutilisee avec plusieurs normales : teste la
# deduplication du loader sur le triplet (position, uv, normale).
# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main
o OctahedronFlat
v 1.000000 0.000000 0.000000
v -1.000000 0.000000 0.000000
v 0.000000 1.000000 0.000000
v 0.000000 -1.000000 0.000000
v 0.000000 0.000000 1.000000
v 0.000000 0.000000 -1.000000
vn 0.577350 0.577350 0.577350
vn -0.577350 0.577350 0.577350
vn -0.577350 -0.577350 0.577350
vn 0.577350 -0.577350 0.577350
vn 0.577350 0.577350 -0.577350
vn -0.577350 0.577350 -0.577350
vn -0.577350 -0.577350 -0.577350
vn 0.577350 -0.577350 -0.577350
f 1//1 3//1 5//1
f 3//2 2//2 5//2
f 2//3 4//3 5//3
f 4//4 1//4 5//4
f 3//5 1//5 6//5
f 2//6 3//6 6//6
f 4//7 2//7 6//7
f 1//8 4//8 6//8
+23
Voir le fichier
@@ -0,0 +1,23 @@
# Vercora scene v1 - scene de DEMONSTRATION de la Phase 15.
#
# Ecrite A LA MAIN, et c'est volontaire : le format est un format texte, il doit
# donc etre editable sans lancer le jeu. Cette scene est ce qui le prouve, et
# elle sert de reference visuelle a tools/shot_editor.ps1.
#
# Emprise : dalle LHD_0907_6440_1m.vchm. Le point de vue de reference est
# --start=907500,6439500 --look=-90,-8
# c'est-a-dire regard plein NORD, legerement plongeant : les objets ci-dessous
# sont alignes devant lui, du plus proche au plus lointain.
#
# object <asset> <est> <nord> <dz> <cap deg> <echelle> <solide>
version 1
terrain LHD_0907_6440_1m.vchm
crs 2154
object poteau 907499.000 6439503.500 0.000 -20.000 1.0000 1
object cairn 907503.500 6439505.000 0.000 0.000 1.0000 1
object rocher 907495.500 6439506.500 0.000 0.000 1.0000 1
object bloc 907507.000 6439509.000 0.000 35.000 1.0000 1
object octaedre 907492.000 6439510.000 1.200 0.000 1.5000 1
object abri 907501.000 6439513.000 0.000 15.000 1.0000 0
object rocher 907509.500 6439515.000 0.000 90.000 2.2000 1
object cairn 907494.000 6439517.000 0.000 0.000 0.7000 1
+24
Voir le fichier
@@ -0,0 +1,24 @@
# Vercora - scene de CONTROLE de la Phase 15, sur la zone de jeu de 25 km2.
#
# Elle demontre la propriete centrale du format : les coordonnees sont projetees
# (Lambert 93) et les altitudes RELATIVES au terrain, donc la meme scene se
# recharge au meme endroit du massif quelle que soit l'emprise ou la resolution
# chargee. Verifie a l'image sur vercora_zone_1m.vchm ET vercora_zone_2m.vchm :
# memes objets, memes positions a l'ecran, seul le relief fin differe.
#
# Elle ne porte VOLONTAIREMENT pas le nom d'auto-chargement (vercora_zone.vcsc) :
# la zone de jeu par defaut reste vierge, cette scene ne se charge qu'a la
# demande.
#
# vercora.exe assets errain ercora_zone_1m.vchm ^
# --scene=assets\scenes\demo_zone25.vcsc ^
# --start=901500,6438500 --look=-90,-10
version 1
terrain vercora_zone_1m.vchm
crs 2154
object poteau 901499.000 6438504.000 0.000 0.000 1.0000 1
object cairn 901503.000 6438508.000 0.000 0.000 1.0000 1
object rocher 901495.500 6438512.000 0.000 0.000 1.0000 1
object bloc 901506.000 6438516.000 0.000 35.000 1.0000 1
object abri 901498.000 6438522.000 0.000 15.000 1.0000 0
object octaedre 901509.000 6438526.000 1.200 0.000 1.5000 1
Fichier binaire non affiché.
+45
Voir le fichier
@@ -0,0 +1,45 @@
Vulkan SDK : C:\VulkanSDK\1.4.357.0
-- Including Win32 support
.\tools\build.bat : CMake Warning (deprecated) at external/glm-src/CMakeLists.txt:1 (cmake_minimum_required):
Au caractère Ligne:1 : 348
+ ... theog\Documents\_CODE\_Vercora"; .\tools\build.bat Debug 2>&1 | Tee-O ...
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo : NotSpecified: (CMake Warning (...imum_required)::String) [], RemoteException
+ FullyQualifiedErrorId : NativeCommandError
Compatibility with CMake < 3.10 will be removed from a future version of
CMake.
Update the VERSION argument <min> value. Or, use the <min>...<max> syntax
to tell CMake that the project requires at least <min> but has been updated
to work with policies introduced by <max> or earlier.
This warning is for project developers. Use -Wno-author or -Wno-deprecated
to suppress it.
CMake Warning (deprecated) at external/glm-src/CMakeLists.txt:2 (cmake_policy):
Compatibility with CMake < 3.10 will be removed from a future version of
CMake.
Update the VERSION argument <min> value. Or, use the <min>...<max> syntax
to tell CMake that the project requires at least <min> but has been updated
to work with policies introduced by <max> or earlier.
This warning is for project developers. Use -Wno-author or -Wno-deprecated
to suppress it.
-- GLM: Version 1.0.1
-- GLM: Build with C++ features auto detection
-- Configuring done (0.5s)
-- Generating done (0.1s)
-- Build files have been written to: C:/Users/theog/Documents/_CODE/_Vercora/build
[1/4] Building CXX object CMakeFiles\vercora.dir\src\renderer\Pipeline.cpp.obj
[2/4] Building CXX object CMakeFiles\vercora.dir\src\core\Paths.cpp.obj
[3/4] Building CXX object CMakeFiles\vercora.dir\src\main.cpp.obj
[4/4] Linking CXX executable vercora.exe
FAILED: [code=4294967295] vercora.exe
C:\WINDOWS\system32\cmd.exe /C "cd . && "C:\Program Files\CMake\bin\cmake.exe" -E vs_link_exe --msvc-ver=1951 --intdir=CMakeFiles\vercora.dir --rc="C:\Program Files (x86)\Windows Kits\10\bin\10.0.26100.0\x64\rc.exe" --mt="C:\Program Files (x86)\Windows Kits\10\bin\10.0.26100.0\x64\mt.exe" --manifests -- "C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\bin\Hostx64\x64\link.exe" /nologo CMakeFiles\vercora.dir\src\main.cpp.obj CMakeFiles\vercora.dir\src\core\Window.cpp.obj CMakeFiles\vercora.dir\src\core\Camera.cpp.obj CMakeFiles\vercora.dir\src\core\Paths.cpp.obj CMakeFiles\vercora.dir\src\assets\ObjLoader.cpp.obj CMakeFiles\vercora.dir\src\assets\Heightmap.cpp.obj CMakeFiles\vercora.dir\src\assets\TerrainFile.cpp.obj CMakeFiles\vercora.dir\src\assets\TextureFile.cpp.obj CMakeFiles\vercora.dir\src\world\TreeMesh.cpp.obj CMakeFiles\vercora.dir\src\world\StoneMesh.cpp.obj CMakeFiles\vercora.dir\src\world\Tree.cpp.obj CMakeFiles\vercora.dir\src\world\Ground.cpp.obj CMakeFiles\vercora.dir\src\world\Knapping.cpp.obj CMakeFiles\vercora.dir\src\world\Forest.cpp.obj CMakeFiles\vercora.dir\src\world\Habitat.cpp.obj CMakeFiles\vercora.dir\src\world\Wildlife.cpp.obj CMakeFiles\vercora.dir\src\world\AnimalMesh.cpp.obj CMakeFiles\vercora.dir\src\world\Vegetation.cpp.obj CMakeFiles\vercora.dir\src\world\GrassMesh.cpp.obj CMakeFiles\vercora.dir\src\world\Paraglider.cpp.obj CMakeFiles\vercora.dir\src\world\Bike.cpp.obj CMakeFiles\vercora.dir\src\world\Climber.cpp.obj CMakeFiles\vercora.dir\src\world\Needs.cpp.obj CMakeFiles\vercora.dir\src\world\WaterSource.cpp.obj CMakeFiles\vercora.dir\src\world\TerrainQuadtree.cpp.obj CMakeFiles\vercora.dir\src\editor\EditorAssets.cpp.obj CMakeFiles\vercora.dir\src\editor\AssetCatalog.cpp.obj CMakeFiles\vercora.dir\src\editor\EditorScene.cpp.obj CMakeFiles\vercora.dir\src\editor\EditorController.cpp.obj CMakeFiles\vercora.dir\src\editor\SceneFile.cpp.obj CMakeFiles\vercora.dir\src\renderer\VulkanContext.cpp.obj CMakeFiles\vercora.dir\src\renderer\VulkanBuffer.cpp.obj CMakeFiles\vercora.dir\src\renderer\Mesh.cpp.obj CMakeFiles\vercora.dir\src\renderer\TerrainMesh.cpp.obj CMakeFiles\vercora.dir\src\renderer\TerrainNodeMesh.cpp.obj CMakeFiles\vercora.dir\src\renderer\TerrainStreamer.cpp.obj CMakeFiles\vercora.dir\src\renderer\SwapChain.cpp.obj CMakeFiles\vercora.dir\src\renderer\Pipeline.cpp.obj CMakeFiles\vercora.dir\src\renderer\Renderer.cpp.obj CMakeFiles\vercora.dir\src\renderer\Texture.cpp.obj /out:vercora.exe /implib:vercora.lib /pdb:vercora.pdb /version:0.0 /machine:x64 /debug /INCREMENTAL /subsystem:console C:\VulkanSDK\1.4.357.0\Lib\vulkan-1.lib C:\Users\theog\Documents\_CODE\_Vercora\external\glfw-build\src\glfw3.lib C:\Users\theog\Documents\_CODE\_Vercora\external\glm-build\glm\glm.lib kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib && cd ."
LINK Pass 1: command "C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\bin\Hostx64\x64\link.exe /nologo CMakeFiles\vercora.dir\src\main.cpp.obj CMakeFiles\vercora.dir\src\core\Window.cpp.obj CMakeFiles\vercora.dir\src\core\Camera.cpp.obj CMakeFiles\vercora.dir\src\core\Paths.cpp.obj CMakeFiles\vercora.dir\src\assets\ObjLoader.cpp.obj CMakeFiles\vercora.dir\src\assets\Heightmap.cpp.obj CMakeFiles\vercora.dir\src\assets\TerrainFile.cpp.obj CMakeFiles\vercora.dir\src\assets\TextureFile.cpp.obj CMakeFiles\vercora.dir\src\world\TreeMesh.cpp.obj CMakeFiles\vercora.dir\src\world\StoneMesh.cpp.obj CMakeFiles\vercora.dir\src\world\Tree.cpp.obj CMakeFiles\vercora.dir\src\world\Ground.cpp.obj CMakeFiles\vercora.dir\src\world\Knapping.cpp.obj CMakeFiles\vercora.dir\src\world\Forest.cpp.obj CMakeFiles\vercora.dir\src\world\Habitat.cpp.obj CMakeFiles\vercora.dir\src\world\Wildlife.cpp.obj CMakeFiles\vercora.dir\src\world\AnimalMesh.cpp.obj CMakeFiles\vercora.dir\src\world\Vegetation.cpp.obj CMakeFiles\vercora.dir\src\world\GrassMesh.cpp.obj CMakeFiles\vercora.dir\src\world\Paraglider.cpp.obj CMakeFiles\vercora.dir\src\world\Bike.cpp.obj CMakeFiles\vercora.dir\src\world\Climber.cpp.obj CMakeFiles\vercora.dir\src\world\Needs.cpp.obj CMakeFiles\vercora.dir\src\world\WaterSource.cpp.obj CMakeFiles\vercora.dir\src\world\TerrainQuadtree.cpp.obj CMakeFiles\vercora.dir\src\editor\EditorAssets.cpp.obj CMakeFiles\vercora.dir\src\editor\AssetCatalog.cpp.obj CMakeFiles\vercora.dir\src\editor\EditorScene.cpp.obj CMakeFiles\vercora.dir\src\editor\EditorController.cpp.obj CMakeFiles\vercora.dir\src\editor\SceneFile.cpp.obj CMakeFiles\vercora.dir\src\renderer\VulkanContext.cpp.obj CMakeFiles\vercora.dir\src\renderer\VulkanBuffer.cpp.obj CMakeFiles\vercora.dir\src\renderer\Mesh.cpp.obj CMakeFiles\vercora.dir\src\renderer\TerrainMesh.cpp.obj CMakeFiles\vercora.dir\src\renderer\TerrainNodeMesh.cpp.obj CMakeFiles\vercora.dir\src\renderer\TerrainStreamer.cpp.obj CMakeFiles\vercora.dir\src\renderer\SwapChain.cpp.obj CMakeFiles\vercora.dir\src\renderer\Pipeline.cpp.obj CMakeFiles\vercora.dir\src\renderer\Renderer.cpp.obj CMakeFiles\vercora.dir\src\renderer\Texture.cpp.obj /out:vercora.exe /implib:vercora.lib /pdb:vercora.pdb /version:0.0 /machine:x64 /debug /INCREMENTAL /subsystem:console C:\VulkanSDK\1.4.357.0\Lib\vulkan-1.lib C:\Users\theog\Documents\_CODE\_Vercora\external\glfw-build\src\glfw3.lib C:\Users\theog\Documents\_CODE\_Vercora\external\glm-build\glm\glm.lib kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /MANIFEST /MANIFESTFILE:CMakeFiles\vercora.dir/intermediate.manifest CMakeFiles\vercora.dir/manifest.res" failed (exit code 1168) with the following output:
LINK : fatal error LNK1168: impossible d'ouvrir vercora.exe pour écrire
ninja: build stopped: subcommand failed.
[OK] Build Debug termine : C:\Users\theog\Documents\_CODE\_Vercora\tools\..\build\vercora.exe
+4
Voir le fichier
@@ -0,0 +1,4 @@
@echo off
cd /d "%~dp0"
echo Lancement de Vercora (zone 25 km2, activites completes : escalade, velo, parapente, faune, meteo)...
start "" "build\vercora.exe" assets\terrain\vercora_zone_1m.vchm
+4
Voir le fichier
@@ -0,0 +1,4 @@
@echo off
cd /d "%~dp0"
echo Lancement de Vercora Release (zone 25 km2, activites completes : escalade, velo, parapente, faune, meteo)...
start "" "build-release\vercora.exe" assets\terrain\vercora_zone_1m.vchm
+121
Voir le fichier
@@ -0,0 +1,121 @@
#version 450
// Meme bloc uniforme que le vertex shader : on n'y lit que viewPos, mais un bloc
// uniforme se declare a l'identique dans les deux etages (meme binding, meme
// layout). Cote C++, le descriptor set layout doit donc exposer ce binding au
// stage FRAGMENT en plus du stage VERTEX.
layout(binding = 0) uniform UniformBufferObject {
mat4 view;
mat4 proj;
vec3 viewPos;
vec4 terrain;
// PHASE 23 : cycle jour/nuit. xyz = direction VERS la lumiere, w = intensite
// directe dans [0, 1]. Voir renderer/UniformBufferObject.hpp.
vec4 sun;
// rgb = couleur de la lumiere, a = MULTIPLICATEUR de l'ambiante ci-dessous.
vec4 sunColor;
// PHASE 27 : meteo visible et micro-relief. Voir
// renderer/UniformBufferObject.hpp pour le sens de chaque composante.
vec4 fog; // rgb = couleur, a = extinction en 1/m (0 = aucun brouillard)
vec4 precip; // x = intensite, y = neige, z = temps, w = assombrissement sol mouille
vec4 fall; // xyz = vitesse de chute en monde (m/s)
vec4 detail; // micro-relief : x = force, y/z = fondu (m), w = motif (m)
} ubo;
layout(location = 0) in vec3 fragColor;
layout(location = 1) in vec3 fragNormal;
layout(location = 2) in vec3 fragWorldPos;
// PHASE 15 : teinte de temoin de l'editeur. x = force (0 = aucune), yzw =
// couleur. Voir le commentaire du push constant dans cube.vert.
layout(location = 3) in vec4 fragTint;
layout(location = 0) out vec4 outColor;
// --- Lumiere directionnelle, fixe en dur pour la Phase 2 ---
// Direction de PROPAGATION de la lumiere (celle vers laquelle elle voyage) :
// venant d'en haut, legerement de la gauche et de l'avant. Une directionnelle
// n'a pas de position : tous les rayons sont paralleles, comme le soleil.
// PHASE 23 : la direction et la couleur de la lumiere ne sont plus des
// constantes. Elles viennent de l'UBO, donc de la position solaire calculee
// par world/Weather.hpp a partir de l'heure de jeu. Il n'y a qu'UN soleil
// dans le jeu, et c'est celui-la.
const float kAmbientStrength = 0.15; // evite que les faces a l'ombre soient noires
const float kSpecularStrength = 0.35;
const float kShininess = 32.0; // plus grand = tache speculaire plus petite
// --- PHASE 27 : brouillard de distance ------------------------------------
// Loi d'extinction exponentielle (Beer-Lambert) : la part de la couleur de la
// surface qui atteint l'oeil vaut exp(-sigma * d). sigma = ubo.fog.a vient de
// weatherVisualsFor(), qui le tire de la PRECIPITATION LOCALE calculee par la
// meteo ; il vaut exactement zero par temps sec, et alors cette fonction rend
// la couleur inchangee au bit pres. La couleur du voile est celle du ciel.
// MEME fonction dans terrain.frag, foliage.frag et cube.frag : un arbre et le
// sol sur lequel il pousse doivent disparaitre dans la brume ensemble.
vec3 applyFog(vec3 color, vec3 worldPos) {
float sigma = ubo.fog.a;
if (sigma <= 0.0) {
return color;
}
float d = length(ubo.viewPos - worldPos);
return mix(ubo.fog.rgb, color, exp(-sigma * d));
}
void main() {
// Les varyings sont interpoles entre sommets : leur longueur n'est plus
// garantie, d'ou le normalize().
vec3 N = normalize(fragNormal);
vec3 L = normalize(ubo.sun.xyz); // surface -> lumiere
vec3 V = normalize(ubo.viewPos - fragWorldPos); // surface -> observateur
// Blinn-Phong : on utilise le "half vector" entre L et V plutot que le
// vecteur reflechi de Phong. Moins cher (pas de reflect()) et sans la
// coupure abrupte de Phong quand l'angle depasse 90 degres.
vec3 H = normalize(L + V);
// Lambert : l'intensite depend du cosinus de l'angle normale/lumiere.
// max(..., 0) : une face qui tourne le dos a la lumiere ne recoit rien
// (sans ca, le produit scalaire negatif retirerait de la lumiere).
float diffuse = max(dot(N, L), 0.0);
// Pas de reflet speculaire sur une face non eclairee.
float specular = diffuse > 0.0
? kSpecularStrength * pow(max(dot(N, H), 0.0), kShininess)
: 0.0;
// L'ambiant et le diffus teintent la couleur de la face ; le speculaire est
// un reflet de la lumiere elle-meme, il s'ajoute donc sans etre teinte.
// PHASE 23 : l'intensite directe et le multiplicateur d'ambiante viennent du
// cycle jour/nuit. En plein jour, sun.w = 1 et sunColor.a = 1 : l'expression
// ci-dessous est alors mot pour mot celle de la Phase 2.
vec3 kLightColor = ubo.sunColor.rgb;
float ambient = kAmbientStrength * ubo.sunColor.a;
diffuse *= ubo.sun.w;
specular *= ubo.sun.w;
vec3 lit = fragColor * kLightColor * (ambient + diffuse)
+ kLightColor * specular;
// --- Teinte de temoin (PHASE 15) ---------------------------------------
// L'editeur doit distinguer d'un coup d'oeil trois etats du MEME modele :
// l'objet pose, le fantome qui suit la visee, et l'objet selectionne.
//
// Une teinte plutot qu'une TRANSPARENCE, ce qui serait pourtant le rendu
// habituel d'un fantome : le melange alpha impose de trier les objets par
// profondeur a chaque image, ou d'accepter des artefacts. C'est le choix que
// le projet a deja fait deux fois - la vegetation de la Phase 11 fond ses
// arbres par RETRECISSEMENT et non par transparence, et l'herbe est faite de
// quads opaques - pour la meme raison. Une teinte forte plus un ambiant
// releve donne un objet parfaitement identifiable, opaque, sans tri, sans
// second pipeline et sans etat de blending.
//
// Force nulle (tout le reste du jeu) : la branche n'est meme pas prise, le
// rendu est bit a bit celui d'avant la Phase 15.
if (fragTint.x > 0.0) {
vec3 tinted = fragTint.yzw * kLightColor * (0.55 + 0.45 * diffuse)
+ kLightColor * specular;
lit = mix(lit, tinted, clamp(fragTint.x, 0.0, 1.0));
}
outColor = vec4(applyFog(lit, fragWorldPos), 1.0);
}
+63
Voir le fichier
@@ -0,0 +1,63 @@
#version 450
// Uniform Buffer Object : ce qui est constant sur toute la frame (matrices View
// et Projection, position camera).
layout(binding = 0) uniform UniformBufferObject {
mat4 view;
mat4 proj;
vec3 viewPos;
} ubo;
// Push constant : la transformation propre a l'objet en cours de dessin. Elle
// change a chaque draw d'une meme frame, contrairement au contenu de l'UBO.
//
// `params` a une signification PROPRE A CHAQUE MATERIAU - c'est le meme bloc de
// push constants pour tous, mais chaque paire de shaders l'interprete a sa
// facon (bande de geomorphing pour le terrain en Phase 10, ondulation pour la
// vegetation en Phase 11). Pour le materiau Object, il etait inutilise jusqu'a
// la Phase 15, qui s'en sert pour la TEINTE DE TEMOIN de l'editeur :
// params.x = force de la teinte, 0 = aucune (le cas de tout le jeu normal)
// params.yzw = couleur de la teinte
// Un zero laisse donc le rendu strictement inchange, ce qui etait la condition
// pour ne pas toucher au pipeline ni ajouter un materiau.
layout(push_constant) uniform PushConstants {
mat4 model;
vec4 params;
} pc;
// Attributs de sommet (voir Vertex.hpp cote C++).
layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 2) in vec3 inNormal;
// UV lu par le loader .obj (Phase 3) mais pas encore consomme : declare ici pour
// que l'attribut fourni par le vertex buffer corresponde a une entree du shader.
// Rien ne l'utilise tant qu'il n'y a pas de texturing.
layout(location = 3) in vec2 inUV;
// Vers le fragment shader. Tout est exprime en espace MONDE : c'est l'espace le
// plus simple pour l'eclairage ici, puisque la lumiere est definie en monde.
layout(location = 0) out vec3 fragColor;
layout(location = 1) out vec3 fragNormal;
layout(location = 2) out vec3 fragWorldPos;
layout(location = 3) out vec4 fragTint;
void main() {
vec4 worldPos = pc.model * vec4(inPosition, 1.0);
gl_Position = ubo.proj * ubo.view * worldPos;
fragColor = inColor;
fragWorldPos = worldPos.xyz;
fragTint = pc.params;
// Normal matrix : la regle generale est transpose(inverse(M)). Ici la model
// matrix est une ROTATION eventuellement suivie d'une echelle UNIFORME
// (contrat documente sur DrawItem). Une rotation est orthogonale, donc
// transpose(inverse(M)) se simplifie en M ; une echelle uniforme ne fait que
// changer la LONGUEUR de la normale, ce que le normalize() du fragment
// shader absorbe. mat3(model) suffit donc, et evite une inversion de matrice
// par sommet.
// A revoir des qu'un objet aura une mise a l'echelle NON UNIFORME : il
// faudra alors calculer la vraie normal matrix cote CPU et la pousser en
// plus (le push constant a encore 64 octets de marge sur les 128 garantis).
fragNormal = mat3(pc.model) * inNormal;
}
+170
Voir le fichier
@@ -0,0 +1,170 @@
#version 450
// PHASE 11 : eclairage de la vegetation instanciee.
//
// Volontairement proche de cube.frag (meme lumiere, meme Blinn-Phong) : la
// vegetation doit s'eclairer comme le reste du monde, sinon les arbres de decor
// se detachent des arbres abattables de Forest, qui passent, eux, par le
// materiau Object.
layout(binding = 0) uniform UniformBufferObject {
mat4 view;
mat4 proj;
vec3 viewPos;
vec4 terrain;
// PHASE 23 : cycle jour/nuit. xyz = direction VERS la lumiere, w = intensite
// directe dans [0, 1]. Voir renderer/UniformBufferObject.hpp.
vec4 sun;
// rgb = couleur de la lumiere, a = MULTIPLICATEUR de l'ambiante ci-dessous.
vec4 sunColor;
// PHASE 27 : meteo visible et micro-relief. Voir
// renderer/UniformBufferObject.hpp pour le sens de chaque composante.
vec4 fog; // rgb = couleur, a = extinction en 1/m (0 = aucun brouillard)
vec4 precip; // x = intensite, y = neige, z = temps, w = assombrissement sol mouille
vec4 fall; // xyz = vitesse de chute en monde (m/s)
vec4 detail; // micro-relief : x = force, y/z = fondu (m), w = motif (m)
} ubo;
layout(location = 0) in vec3 fragTint;
layout(location = 1) in vec3 fragNormal;
layout(location = 2) in vec3 fragWorldPos;
// PHASE 18 : de quoi decouper le quad en brins (voir foliage.vert).
layout(location = 3) in vec2 fragUV;
layout(location = 4) in float fragBladeSeed;
layout(location = 5) in float fragCutout;
layout(location = 0) out vec4 outColor;
// --- PHASE 18 : decoupe alpha des brins d'herbe -----------------------------
//
// POURQUOI UN MASQUE CALCULE ET NON UNE TEXTURE. Une planche de brins en RGBA
// serait la solution d'atelier habituelle ; elle demanderait un second
// echantillonneur, donc un binding de descriptor de plus sur CE pipeline
// seulement, un asset a produire et a charger, et son filtrage mipmap ferait
// FONDRE les brins fins en une bouillie grise a quelques metres (le probleme
// classique du masque alpha mipmape). Le masque analytique n'a aucun de ces
// couts, tient en une quinzaine de lignes, et sa finesse ne depend d'aucune
// resolution.
//
// POURQUOI `discard` ET NON DU MELANGE ALPHA. Le melange imposerait de trier
// les touffes en profondeur a chaque image - des dizaines de milliers d'objets,
// depuis une camera qui bouge - et une seconde passe de rendu. Le test alpha,
// lui, laisse le tampon de profondeur faire son travail : l'ordre de dessin
// reste sans importance, exactement comme avant la Phase 18. C'est ce qui rend
// cette amelioration presque gratuite. Sa contrepartie est un bord FRANC, sans
// demi-teinte ; c'est ce que compense l'effacement progressif de la decoupe
// avec la distance calcule dans le vertex shader.
const float kBladesPerQuad = 4.0;
// Renvoie true si le fragment tombe DANS un brin.
bool insideBlade(vec2 uv, float seed, float strength) {
const float height = clamp(uv.y, 0.0, 1.0);
// Le quad est partage en kBladesPerQuad bandes ; chaque bande porte un brin.
const float scaled = uv.x * kBladesPerQuad;
const float index = floor(scaled);
const float local = scaled - index;
// Alea propre a CE brin de CETTE touffe. Hachage trigonometrique : sans
// texture ni table, et suffisant pour ce qu'on lui demande (decorreler des
// brins voisins, pas resister a une analyse statistique).
const float random = fract(sin(index * 12.9898 + seed * 78.233 + 1.7) * 43758.5453);
// 1. Tous les brins ne montent pas a la meme hauteur. C'est CE detail qui
// distingue une touffe d'un peigne : une touffe reelle a un profil
// irregulier.
const float tip = mix(0.55, 1.0, random);
if (height > tip) {
return false;
}
// 2. Largeur du brin : pleine au pied, effilee a sa propre pointe. Le carre
// donne un profil de lame, pas de triangle.
const float alongBlade = height / tip;
// 0,40 et non 0,50 : les brins d'une meme bande ne se TOUCHENT pas au pied.
// Avec 0,50 ils se rejoignaient a la base et la touffe redevenait, sur son
// premier tiers, l'aplat opaque que la decoupe devait supprimer - c'est
// exactement ce que montrait la premiere capture.
const float halfWidth = 0.40 * (1.0 - 0.88 * alongBlade * alongBlade);
// 3. Le brin s'ecarte de l'axe de sa bande en montant : les brins d'une
// meme touffe s'ouvrent en gerbe au lieu de rester paralleles.
const float lean = (random - 0.5) * 0.9;
const float centre = 0.5 + lean * alongBlade * alongBlade * 0.5;
// 4. `strength` referme la decoupe avec la distance : a 0 la bande est
// pleine d'un bord a l'autre et le quad redevient celui de la Phase 11.
const float width = mix(0.5, halfWidth, strength);
return abs(local - centre) <= width;
}
// PHASE 23 : la direction et la couleur de la lumiere ne sont plus des
// constantes. Elles viennent de l'UBO, donc de la position solaire calculee
// par world/Weather.hpp a partir de l'heure de jeu. Il n'y a qu'UN soleil
// dans le jeu, et c'est celui-la.
const float kAmbientStrength = 0.24; // plus haut que le cube : le feuillage a
// l'ombre ne doit pas virer au noir
const float kSpecularStrength = 0.04; // vegetation : mate
const float kShininess = 12.0;
// --- PHASE 27 : brouillard de distance ------------------------------------
// Loi d'extinction exponentielle (Beer-Lambert) : la part de la couleur de la
// surface qui atteint l'oeil vaut exp(-sigma * d). sigma = ubo.fog.a vient de
// weatherVisualsFor(), qui le tire de la PRECIPITATION LOCALE calculee par la
// meteo ; il vaut exactement zero par temps sec, et alors cette fonction rend
// la couleur inchangee au bit pres. La couleur du voile est celle du ciel.
// MEME fonction dans terrain.frag, foliage.frag et cube.frag : un arbre et le
// sol sur lequel il pousse doivent disparaitre dans la brume ensemble.
vec3 applyFog(vec3 color, vec3 worldPos) {
float sigma = ubo.fog.a;
if (sigma <= 0.0) {
return color;
}
float d = length(ubo.viewPos - worldPos);
return mix(ubo.fog.rgb, color, exp(-sigma * d));
}
void main() {
// Test alpha AVANT tout calcul d'eclairage : un fragment rejete ne doit
// rien couter de plus qu'un branchement.
if (fragCutout > 0.0 && !insideBlade(fragUV, fragBladeSeed, fragCutout)) {
discard;
}
vec3 N = normalize(fragNormal);
// Le rendu se fait sans culling de faces (voir Pipeline.cpp), ce qui est
// indispensable aux quads croises de l'herbe : sans cela la moitie des
// brins serait invisible selon l'angle. Consequence : une face vue de dos
// presente une normale qui pointe a l'oppose de l'observateur et
// s'assombrirait completement. On la RETOURNE vers l'observateur - c'est le
// traitement standard d'une geometrie a double face, et il n'a aucun effet
// sur les troncs et houppiers, dont on ne voit jamais l'interieur.
if (dot(N, ubo.viewPos - fragWorldPos) < 0.0) {
N = -N;
}
vec3 L = normalize(ubo.sun.xyz);
vec3 V = normalize(ubo.viewPos - fragWorldPos);
vec3 H = normalize(L + V);
float diffuse = max(dot(N, L), 0.0);
float specular = diffuse > 0.0
? kSpecularStrength * pow(max(dot(N, H), 0.0), kShininess)
: 0.0;
// PHASE 23 : l'intensite directe et le multiplicateur d'ambiante viennent du
// cycle jour/nuit. En plein jour, sun.w = 1 et sunColor.a = 1 : l'expression
// ci-dessous est alors mot pour mot celle de la Phase 2.
vec3 kLightColor = ubo.sunColor.rgb;
float ambient = kAmbientStrength * ubo.sunColor.a;
diffuse *= ubo.sun.w;
specular *= ubo.sun.w;
vec3 lit = fragTint * kLightColor * (ambient + diffuse)
+ kLightColor * specular;
outColor = vec4(applyFog(lit, fragWorldPos), 1.0);
}
+162
Voir le fichier
@@ -0,0 +1,162 @@
#version 450
// PHASE 11 : vegetation INSTANCIEE (arbres de decor et touffes d'herbe).
//
// Une geometrie, un appel de dessin, N instances. Chaque instance lit sa
// transformation dans le binding 1, cadence par instance et non par sommet (voir
// renderer/InstanceData.hpp et renderer/VertexFormat.hpp).
layout(binding = 0) uniform UniformBufferObject {
mat4 view;
mat4 proj;
vec3 viewPos;
vec4 terrain;
} ubo;
// x = amplitude d'ondulation en metres (0 pour un arbre : un tronc ne plie pas),
// y = temps en secondes, z = distance de rendu, w = reserve.
layout(push_constant) uniform PushConstants {
mat4 model;
vec4 params;
} pc;
// --- Attributs de SOMMET (binding 0, cadence par sommet) --------------------
layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 2) in vec3 inNormal;
layout(location = 3) in vec2 inUV;
// --- Attributs d'INSTANCE (binding 1, cadence par instance) -----------------
layout(location = 6) in vec3 inInstancePosition;
layout(location = 7) in vec2 inScaleYaw; // x = echelle uniforme, y = lacet
layout(location = 8) in vec2 inVariationFade; // x = alea [0,1], y = attenuation
layout(location = 0) out vec3 fragTint;
layout(location = 1) out vec3 fragNormal;
layout(location = 2) out vec3 fragWorldPos;
// PHASE 18 : ce qu'il faut au fragment shader pour DECOUPER le quad en brins.
//
// fragUV : les memes UV que le maillage (x en travers du quad, y du pied a
// la pointe). Le masque de brins est dessine dans cet espace.
// fragBladeSeed : l'alea de l'instance, transmis tel quel. Deux touffes
// voisines n'ont donc pas leurs brins au meme endroit ; sans lui,
// le meme decoupage se repeterait a l'identique sur tout le pre.
// fragCutout : FORCE de la decoupe, entre 0 et 1, calculee ICI parce que la
// distance a la camera y est deja connue. 1 = brins decoupes,
// 0 = quad plein (le comportement d'avant la Phase 18).
//
// POURQUOI LA DECOUPE S'EFFACE AVEC LA DISTANCE. Un brin fait quelques pixels a
// 15 m et moins d'un pixel a 30 : le decouper produit alors un scintillement -
// le pixel tombe tantot dans un brin, tantot entre deux, et l'image bouge des
// que la camera bouge. Sans MSAA (rasterizationSamples = 1, voir Pipeline.cpp)
// il n'y a aucun filtrage pour l'absorber. On ELARGIT donc les brins jusqu'a
// refermer le quad quand la touffe s'eloigne : de pres on voit des brins, de
// loin une silhouette pleine, et entre les deux la transition est continue.
layout(location = 3) out vec2 fragUV;
layout(location = 4) out float fragBladeSeed;
layout(location = 5) out float fragCutout;
// Distances, en metres, entre lesquelles la decoupe des brins se referme.
// Reglees sur la portee de l'herbe (34 m, voir world/Vegetation.hpp) : la
// decoupe est entiere sur le premier tiers, la ou on distingue reellement un
// brin, et le quad est de nouveau plein bien avant que la touffe ne disparaisse.
const float kCutoutFullRange = 7.0;
const float kCutoutNoneRange = 17.0;
void main() {
const float scale = inScaleYaw.x;
const float yaw = inScaleYaw.y;
const float variation = inVariationFade.x;
const float fade = inVariationFade.y;
// ATTENUATION PAR RETRECISSEMENT, et non par transparence. Une instance qui
// rapetisse jusqu'a zero disparait sans melange alpha, donc sans imposer de
// tri en profondeur ni de seconde passe de rendu. C'est ce qui rend le fondu
// de l'herbe gratuit, alors qu'une disparition en transparence couterait bien
// plus cher que l'herbe elle-meme. La contrepartie est visible de pres si la
// bande de fondu est trop courte : les touffes ont l'air de pousser quand on
// avance. C'est pourquoi la bande est large (voir world/Vegetation.hpp).
const float effectiveScale = scale * fade;
// Rotation autour de Y reconstituee depuis le lacet : 6 flottants par
// instance suffisent, la matrice 4x4 n'a pas a voyager (voir InstanceData.hpp).
const float s = sin(yaw);
const float c = cos(yaw);
const mat3 rotation = mat3( c, 0.0, -s,
0.0, 1.0, 0.0,
s, 0.0, c);
vec3 local = inPosition * effectiveScale;
// --- Ondulation ---------------------------------------------------------
// Ne s'applique qu'a l'herbe (amplitude nulle pour un arbre). Le
// deplacement croit avec inUV.y, qui vaut 0 au pied du brin et 1 a sa
// pointe : le pied reste donc PLANTE dans le sol, ce qu'un deplacement
// uniforme de l'instance ne donnerait pas. La variation dephase chaque
// touffe, sans quoi tout le pre ondulerait a l'unisson comme un seul objet.
if (pc.params.x > 0.0) {
const float phase = pc.params.y * 1.7 + variation * 6.2831853;
const float bend = pc.params.x * inUV.y * inUV.y * sin(phase);
local.x += bend;
local.z += bend * 0.6;
}
// --- PHASE 29 : mode ROCHER (params.w < 0) --------------------------------
// Un bloc d'eboulis s'incline avec la pente, ce que la rotation en lacet
// seule ne sait pas faire. InstanceData etant plein (28 o), le gradient du
// sol est ENCODE dans la partie entiere de `variation` (64 x 64 niveaux dans
// [-1, 1], voir world/Rocks.hpp packRockVariation) et la teinte dans sa
// partie fractionnaire. La rotation amene l'axe Y du mesh sur la normale
// n = normalize(-gx, 1, -gz) (formule de Rodrigues). Arbres, herbe et
// plantes a fibres poussent w >= 0 : leur chemin est strictement inchange.
float tintSeed = variation;
mat3 tilt = mat3(1.0);
if (pc.params.w < 0.0) {
const float packedIndex = floor(variation);
tintSeed = variation - packedIndex;
const float qx = floor(packedIndex / 64.0);
const float qz = packedIndex - qx * 64.0;
const vec2 g = vec2(qx, qz) / 63.0 * 2.0 - 1.0;
const vec3 n = normalize(vec3(-g.x, 1.0, -g.y));
const vec3 axis = vec3(n.z, 0.0, -n.x); // cross((0,1,0), n)
const float sine = length(axis);
if (sine > 1e-4) {
const vec3 k = axis / sine;
const float cosine = n.y;
const mat3 K = mat3(0.0, k.z, -k.y,
-k.z, 0.0, k.x,
k.y, -k.x, 0.0);
tilt = mat3(cosine) + sine * K + (1.0 - cosine) * outerProduct(k, k);
}
}
const vec3 worldPos = inInstancePosition + tilt * (rotation * local);
gl_Position = ubo.proj * ubo.view * vec4(worldPos, 1.0);
fragWorldPos = worldPos;
// L'echelle etant UNIFORME, la rotation seule suffit a transporter la
// normale : pas d'inverse transpose a calculer (voir DrawItem.hpp).
fragNormal = tilt * (rotation * inNormal);
// Variation de teinte par instance : sans elle, dix mille arbres du meme
// vert forment un aplat qui trahit immediatement la copie. Le facteur reste
// resserre autour de 1 pour que ce soit une nuance, pas un arc-en-ciel.
fragTint = inColor * (0.82 + 0.30 * tintSeed);
// --- Decoupe en brins (PHASE 18) ---------------------------------------
// params.w porte la force demandee par l'appelant : 0 pour un arbre (un
// houppier n'a pas a etre troue), > 0 pour l'herbe. C'est le meme bloc de
// push constants pour tous les materiaux, et w y etait justement reserve
// (voir renderer/DrawItem.hpp).
fragUV = inUV;
fragBladeSeed = variation;
if (pc.params.w > 0.0) {
const float distance = length(ubo.viewPos - worldPos);
fragCutout = pc.params.w * (1.0 - smoothstep(kCutoutFullRange, kCutoutNoneRange,
distance));
} else {
fragCutout = 0.0;
}
}
+132
Voir le fichier
@@ -0,0 +1,132 @@
#version 450
// ===========================================================================
// PHASE 27 - Pluie et neige a l'ecran
// ===========================================================================
// L'objectif est la LISIBILITE, pas le photorealisme : le joueur doit voir
// qu'il pleut ou qu'il neige, et a quel point. Un seul triangle plein ecran,
// trois couches de traits procéduraux, aucune texture, aucun buffer de
// particules.
//
// TOUT CE QUI VARIE vient de la meteo, via weatherVisualsFor() :
// precip.x intensite = precipitation LOCALE / precipitationMaxMmPerHour.
// Elle regle la DENSITE des traits (proportion de cellules qui
// portent une goutte) et leur opacite.
// precip.y neige ou pluie = WeatherSample::snowing, donc la temperature
// locale comparee a snowThresholdC.
// fall.xyz vitesse de chute en monde : le VENT LOCAL (sondage amont, cols,
// abris) plus une vitesse terminale de goutte ou de flocon.
// Projetee dans le repere de la camera, elle donne l'INCLINAISON
// des traits : la pluie se couche dans le sens ou le vent souffle
// reellement a cet endroit, et se redresse a l'abri.
// La luminosite des traits suit la lumiere du cycle jour/nuit (sun, sunColor),
// pour qu'une pluie nocturne ne brille pas plus que le paysage.
//
// Ce que ce n'est PAS : des particules en monde. Les traits sont colles a
// l'ecran ; ils ne se cachent pas derriere un tronc et ne se rapprochent pas
// quand on avance. C'est le compromis assume de "particules basiques ou effet
// d'ecran", au cout d'une seule passe.
// ===========================================================================
layout(binding = 0) uniform UniformBufferObject {
mat4 view;
mat4 proj;
vec3 viewPos;
vec4 terrain;
vec4 sun;
vec4 sunColor;
vec4 fog;
vec4 precip;
vec4 fall;
vec4 detail;
} ubo;
layout(location = 0) in vec2 fragScreenUV;
layout(location = 0) out vec4 outColor;
float hash21(vec2 p) {
p = fract(p * vec2(123.34, 456.21));
p += dot(p, p + 45.32);
return fract(p.x * p.y);
}
// Une couche de precipitation. cells = nombre de cellules sur la HAUTEUR de
// l'ecran (plus il y en a, plus la couche parait lointaine) ; screenSpeed =
// hauteurs d'ecran parcourues par seconde.
float layerAlpha(vec2 q, float cells, float screenSpeed, float layerSeed,
float density, bool snow, float t) {
vec2 g = q * cells;
// Chaque colonne a sa propre phase : sans ca, toutes les gouttes d'une
// rangee tomberaient alignees comme un rideau.
float column = floor(g.x);
g.y -= t * screenSpeed * cells + hash21(vec2(column, layerSeed)) * 17.0;
vec2 cell = floor(g);
vec2 f = fract(g);
float h = hash21(cell + layerSeed * 31.7);
if (h > density) {
return 0.0;
}
float x0 = 0.2 + 0.6 * fract(h * 7.13);
if (snow) {
// Flocon : un disque flou qui oscille lateralement.
float wobble = 0.15 * sin(t * 1.7 + h * 40.0);
vec2 d = f - vec2(x0 + wobble, 0.5);
return 1.0 - smoothstep(0.06, 0.16, length(d));
}
// Goutte : un trait fin et long dans le sens de la chute.
float across = 1.0 - smoothstep(0.015, 0.045, abs(f.x - x0));
float along = smoothstep(0.0, 0.15, f.y) * (1.0 - smoothstep(0.55, 0.75, f.y));
return across * along;
}
void main() {
float intensity = clamp(ubo.precip.x, 0.0, 1.0);
if (intensity <= 0.0) {
discard; // ne devrait pas arriver : la passe est sautee cote CPU
}
bool snow = ubo.precip.y > 0.5;
float t = ubo.precip.z;
// --- Direction de chute a l'ecran ---------------------------------------
// Vitesse monde -> repere camera. En Vulkan l'axe Y de l'ecran descend,
// d'ou le signe. Quand la chute est presque dans l'axe de la vue (regard a
// la verticale), la direction degeneree retombe sur "vers le bas".
vec3 v = mat3(ubo.view) * ubo.fall.xyz;
vec2 screenDir = vec2(v.x, -v.y);
screenDir = length(screenDir) > 1e-3 ? normalize(screenDir) : vec2(0.0, 1.0);
// Coordonnees ecran isotropes (le pixel est carre), puis rotation qui
// amene la direction de chute sur +Y.
float aspect = abs(ubo.proj[1][1] / ubo.proj[0][0]);
vec2 p = vec2(fragScreenUV.x * aspect, fragScreenUV.y);
vec2 q = vec2(screenDir.y * p.x - screenDir.x * p.y,
screenDir.x * p.x + screenDir.y * p.y);
// --- Trois couches -------------------------------------------------------
// La densite suit l'intensite : une bruine ne montre que quelques traits,
// une averse en montre beaucoup. Le plancher de 0,15 garde une faible
// precipitation VISIBLE - sinon 0,3 mm/h serait mesure et invisible, ce qui
// est exactement le defaut que cette phase corrige.
float density = mix(0.15, 0.85, intensity);
float alpha;
if (snow) {
alpha = layerAlpha(q, 9.0, 0.16, 1.0, density, true, t)
+ layerAlpha(q, 16.0, 0.11, 2.0, density, true, t) * 0.7
+ layerAlpha(q, 28.0, 0.07, 3.0, density, true, t) * 0.45;
} else {
alpha = layerAlpha(q, 7.0, 1.6, 1.0, density, false, t)
+ layerAlpha(q, 13.0, 1.2, 2.0, density, false, t) * 0.7
+ layerAlpha(q, 22.0, 0.9, 3.0, density, false, t) * 0.45;
}
// --- Teinte ---------------------------------------------------------------
// Eclairee comme le paysage : ambiante et directe du cycle jour/nuit.
float light = clamp(0.45 * ubo.sunColor.a + 0.55 * ubo.sun.w, 0.0, 1.0);
vec3 base = snow ? vec3(0.97, 0.98, 1.0) : vec3(0.78, 0.82, 0.88);
vec3 color = base * mix(ubo.sunColor.rgb, vec3(1.0), 0.5) * (0.25 + 0.75 * light);
float opacity = snow ? mix(0.55, 0.9, intensity) : mix(0.22, 0.45, intensity);
outColor = vec4(color, clamp(alpha, 0.0, 1.0) * opacity);
}
+16
Voir le fichier
@@ -0,0 +1,16 @@
#version 450
// PHASE 27 - Passe plein ecran de precipitation.
//
// Aucun buffer de sommets : un seul triangle qui deborde de l'ecran, fabrique a
// partir de gl_VertexIndex (0, 1, 2). C'est la facon la moins chere de couvrir
// tous les pixels - pas de diagonale partagee entre deux triangles, donc pas de
// pixels ombres deux fois le long de cette diagonale.
layout(location = 0) out vec2 fragScreenUV; // 0,0 en haut a gauche, 1,1 en bas a droite
void main() {
vec2 uv = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
fragScreenUV = uv;
gl_Position = vec4(uv * 2.0 - 1.0, 0.0, 1.0);
}
+385
Voir le fichier
@@ -0,0 +1,385 @@
#version 450
layout(binding = 0) uniform UniformBufferObject {
mat4 view;
mat4 proj;
vec3 viewPos;
// x = altitude min, y = altitude max, z = dosage orthophoto,
// w = force de l'indice adret/ubac (PHASE 25, voir plus bas)
vec4 terrain;
// PHASE 23 : cycle jour/nuit. xyz = direction VERS la lumiere, w = intensite
// directe dans [0, 1]. Voir renderer/UniformBufferObject.hpp.
vec4 sun;
// rgb = couleur de la lumiere, a = MULTIPLICATEUR de l'ambiante ci-dessous.
vec4 sunColor;
// PHASE 27 : meteo visible et micro-relief. Voir
// renderer/UniformBufferObject.hpp pour le sens de chaque composante.
vec4 fog; // rgb = couleur, a = extinction en 1/m (0 = aucun brouillard)
vec4 precip; // x = intensite, y = neige, z = temps, w = assombrissement sol mouille
vec4 fall; // xyz = vitesse de chute en monde (m/s)
vec4 detail; // micro-relief : x = force, y/z = fondu (m), w = motif (m)
} ubo;
// PHASE 11 : orthophoto BD ORTHO drapee sur le relief. Toujours reliee a une
// image valide - un texel blanc quand aucune photo n'est chargee - donc
// echantillonnable sans condition. C'est ubo.terrain.z qui decide si le resultat
// compte, et il vaut zero dans ce cas.
layout(binding = 1) uniform sampler2D orthoTexture;
layout(location = 0) in vec3 fragTint;
layout(location = 1) in vec3 fragNormal;
layout(location = 2) in vec3 fragWorldPos;
layout(location = 3) in vec2 fragUV;
layout(location = 0) out vec4 outColor;
// --- Lumiere directionnelle, identique a celle de la Phase 2 ---------------
// PHASE 23 : la direction et la couleur de la lumiere ne sont plus des
// constantes. Elles viennent de l'UBO, donc de la position solaire calculee
// par world/Weather.hpp a partir de l'heure de jeu. Il n'y a qu'UN soleil
// dans le jeu, et c'est celui-la.
const float kAmbientStrength = 0.18;
const float kSpecularStrength = 0.06; // roche/herbe : quasi mat, contrairement au cube
const float kShininess = 16.0;
// --- Etagement par altitude ------------------------------------------------
// Trois teintes suffisent a rendre le relief lisible sans texturing : c'est le
// but de cette phase (valider que la geometrie et les normales sont correctes),
// pas de faire joli.
const vec3 kLowColor = vec3(0.22, 0.32, 0.17); // alpage
const vec3 kMidColor = vec3(0.45, 0.42, 0.34); // roche / eboulis
const vec3 kHighColor = vec3(0.93, 0.95, 0.98); // neve
const vec3 kCliffColor = vec3(0.34, 0.31, 0.29); // falaise (roche nue)
// --- PHASE 25 : indice visuel adret / ubac ---------------------------------
// L'ecart adret/ubac existait depuis la Phase 23 - mesure, journalise, et
// invisible : 14,7 C contre 10,7 C a midi sans que RIEN a l'ecran ne le montre.
//
// CE SHADER NE CALCULE PAS UNE DEUXIEME EXPOSITION SOLAIRE. Il reprend
// exactement la grandeur de WeatherSystem::sampleAt - l'ecart entre le cosinus
// d'incidence du point et celui qu'aurait du terrain PLAT au meme instant -
// avec la MEME direction solaire, celle de ubo.sun.xyz, qui vient de
// world/Weather.hpp. Il n'y a qu'un soleil dans ce jeu, et c'est celui de la
// meteo.
//
// Le partage des roles est le suivant, et il est deliberé :
// - ce shader fait ce que lui seul peut faire : le cosinus d'incidence PAR
// FRAGMENT, a partir de la normale du relief ;
// - le CPU (main.cpp) porte tout le reste - hauteur du soleil, nebulosite -
// dans ubo.terrain.w, parce que ces deux regles appartiennent a la meteo et
// n'ont pas a etre re-derivees ici, ou elles pourraient diverger.
//
// Consequence directe : l'effet suit le cycle jour/nuit tout seul. Le soleil
// tourne, l'incidence de chaque versant change avec lui ; il se couche, et
// ubo.terrain.w tombe a zero. Aucune regle horaire n'est ecrite nulle part.
// Ecart de cosinus d'incidence qui vaut un effet COMPLET.
// DOIT rester egal a WeatherParams::aspectIncidenceReference (0,35). main.cpp
// verifie cette egalite au demarrage et previent si elle est rompue : un shader
// ne peut pas lire un parametre C++, donc la seule protection possible est de
// rendre la divergence BRUYANTE plutot que silencieuse.
const float kAspectIncidenceReference = 0.35;
// Les deux teintes, en MULTIPLICATEUR d'albedo.
//
// ELLES SONT EXACTEMENT SYMETRIQUES autour de 1, canal par canal
// ((1,14 + 0,86) / 2 = 1, etc.), et ce n'est pas de l'esthetique : sur du
// terrain qui n'est ni adret ni ubac le signal vaut 0, donc le melange rend le
// MILIEU des deux teintes. Un milieu qui ne serait pas (1,1,1) teinterait tout
// le plat du massif - un premier jeu de valeurs le faisait, d'un demi pour cent
// vers le chaud.
//
// AMPLITUDE : +/- 14 % sur le rouge, +/- 12 % sur le bleu, au signal PLEIN.
// La premiere version montait a 7 % et c'etait mesurablement trop peu : a 13 h,
// l'heure ou l'ecart thermique est maximal, 93,5 % des pixels ne bougeaient pas
// d'un cran sur 255 - donc un indice invisible, ce qui lui faisait manquer sa
// seule raison d'etre. Le signal, lui, n'a pas change : c'est toujours celui de
// la meteo. Seule l'AMPLITUDE D'AFFICHAGE a ete revue, et c'est un choix de
// rendu, legitimement distinct du modele physique.
//
// Le plein signal demande |incidence - incidence a plat| >= 0,35, donc un
// versant franchement oriente : sur du relief ordinaire l'effet reste bien en
// dessous de ces bornes.
const vec3 kAdretTint = vec3(1.14, 1.04, 0.88); // versant au soleil : plus dore
const vec3 kUbacTint = vec3(0.86, 0.96, 1.12); // versant a l'ombre : plus bleute
// --- PHASE 27 : brouillard de distance ------------------------------------
// Loi d'extinction exponentielle (Beer-Lambert) : la part de la couleur de la
// surface qui atteint l'oeil vaut exp(-sigma * d). sigma = ubo.fog.a vient de
// weatherVisualsFor(), qui le tire de la PRECIPITATION LOCALE calculee par la
// meteo ; il vaut exactement zero par temps sec, et alors cette fonction rend
// la couleur inchangee au bit pres. La couleur du voile est celle du ciel.
// MEME fonction dans terrain.frag, foliage.frag et cube.frag : un arbre et le
// sol sur lequel il pousse doivent disparaitre dans la brume ensemble.
vec3 applyFog(vec3 color, vec3 worldPos) {
float sigma = ubo.fog.a;
if (sigma <= 0.0) {
return color;
}
float d = length(ubo.viewPos - worldPos);
return mix(ubo.fog.rgb, color, exp(-sigma * d));
}
// ===========================================================================
// PHASE 27 - MICRO-RELIEF DU SOL VU DE PRES (chantier 3)
// ===========================================================================
// LE PROBLEME : l'orthophoto a 0,61 m/texel, vue a pied, est agrandie jusqu'a
// ce qu'un texel couvre des dizaines de pixels. Le filtrage bilineaire en fait
// un aplat flou - le sol sous les pieds n'a aucun grain.
//
// CE QUI EST AJOUTE : de l'information dans la SEULE bande de frequences que la
// photo ne porte pas, celle qui est plus fine que son texel. Les longueurs
// d'onde du motif partent de ubo.detail.w (le texel de l'orthophoto, passe par
// main.cpp) et descendent par octaves ; rien au-dessus du texel, donc rien qui
// contredise la photo.
//
// CE QUI EST REEL ET CE QUI NE L'EST PAS, sans detour : le MOTIF est un bruit,
// il ne represente aucun caillou reel. Mais son AMPLITUDE, elle, est pilotee
// par deux donnees reelles du projet :
// - le CONTRASTE LOCAL de l'orthophoto (ecart entre la photo et sa version
// deux niveaux de mipmap plus floue) : un eboulis photographie est
// contraste, une prairie rase est lisse, et le grain ajoute suit ;
// - la PENTE du relief LiDAR : un versant raide est de la roche, plus rugueuse
// qu'un replat.
//
// DEUX FONDUS, et c'est ce qui le garde compatible avec le LOD :
// 1. par distance (ubo.detail.y -> ubo.detail.z) : l'effet n'existe qu'a
// portee de marche, et le cout est nul au-dela (branche sautee) ;
// 2. par OCTAVE, sur l'empreinte du pixel au sol (fwidth) : une octave dont
// la longueur d'onde tombe sous deux pixels est eteinte AVANT de
// scintiller. C'est la regle de Nyquist appliquee au motif, et c'est elle
// qui interdit le moire en vue rasante - la ou le fondu par distance seul
// echouerait.
//
// La normale perturbee ne sert QU'A l'eclairage : l'indice adret/ubac garde la
// normale du relief, parce qu'il doit dire la meme chose que la meteo, qui ne
// connait pas ce motif.
// PHASE 27, binding 2 : bruit de valeur PERIODIQUE precalcule (voir
// assets/DetailNoise.hpp). r = valeur, gb = derivees par unite de cellule,
// codees sur [-1,5 ; +1,5]. 32 cellules sur la largeur de la texture.
//
// HISTORIQUE MESURE, pour ne pas y revenir : la premiere version calculait ce
// bruit dans le shader (4 hash + interpolation par octave). +1 490 us par
// image au ras du sol en Release sur l'UHD 770, ~200 us PAR OCTAVE (bissection :
// 0 octave +330 us, 2 octaves +720 us) ; passer d'un hash entier a un hash
// flottant n'y changeait rien. C'etait l'arithmetique elle-meme. Une lecture
// de texture la remplace, et les mipmaps apportent en prime le filtrage des
// grains sous-pixel.
layout(binding = 2) uniform sampler2D detailNoise;
const float kDetailNoiseCells = 32.0;
const float kDetailNoiseSlopeRange = 1.5; // = kDetailNoiseSlopeRange (C++)
// textureGrad et non texture : l'appel vit dans une boucle a sortie NON
// uniforme (break de Nyquist) et une branche de distance, ou les derivees
// implicites sont indefinies. Les derivees d'ecran de la position sont prises
// hors branche par l'appelant, puis mises a l'echelle de l'octave.
vec3 valueNoiseD(vec2 x, vec2 dxdx, vec2 dxdy) {
vec3 t = textureGrad(detailNoise, x / kDetailNoiseCells,
dxdx / kDetailNoiseCells, dxdy / kDetailNoiseCells).rgb;
return vec3(t.r, (t.gb * 2.0 - 1.0) * kDetailNoiseSlopeRange);
}
// Octaves du motif : longueur d'onde de base, puis divisee par 2,2 a chaque
// octave (un rapport non entier evite que les octaves s'alignent en grille).
// SEPT octaves, donc de 0,61 m jusqu'a 5 mm. La premiere version en avait 4
// (finesse 6 cm) et la mesure l'a condamnee : a 2 m du regard, 6 cm couvrent
// encore une quinzaine de pixels, et l'energie haute frequence du sol proche
// n'avait PAS bouge (5,92 contre 5,91) - de l'ondulation, pas du grain. Les
// octaves fines ne coutent que de pres : le fondu de Nyquist les eteint des
// qu'elles passent sous deux pixels, et la boucle les saute alors.
const int kDetailOctaves = 7;
const float kDetailLacunarity = 2.2;
// Pente du relief MACRO (1 - N.y) qui vaut une rugosite complete : 0,35, le
// debut des versants ou la tuile passe deja a la teinte de falaise.
const float kDetailFullSlope = 0.35;
// Contraste local de l'orthophoto (distance RGB entre photo nette et floue) qui
// vaut une rugosite complete : 0,12, soit ~30 niveaux sur 255.
const float kDetailFullContrast = 0.12;
// Pente maximale du micro-relief, sans unite (derivee de hauteur par metre, a
// force 1). 0,6 : assez pour que chaque grain accroche la lumiere rasante,
// pas assez pour retourner une normale.
const float kDetailSlope = 1.3;
// Amplitude de couleur a force 1 : au plus +/- 30 % autour de la photo sur
// les pics du motif, +/- 10 % typiquement.
const float kDetailAlbedo = 0.30;
void main() {
vec3 N = normalize(fragNormal);
// Altitude ramenee dans [0,1] sur la plage reelle du terrain. Le max(...)
// protege du cas degenere "terrain parfaitement plat" (division par zero).
float span = max(ubo.terrain.y - ubo.terrain.x, 1e-4);
float altitude = clamp((fragWorldPos.y - ubo.terrain.x) / span, 0.0, 1.0);
// Degrade en deux segments : bas -> milieu, puis milieu -> haut.
// smoothstep plutot que mix lineaire : les transitions de teinte ne
// dessinent pas de bande nette a l'endroit du raccord.
vec3 albedo = altitude < 0.5
? mix(kLowColor, kMidColor, smoothstep(0.0, 0.5, altitude))
: mix(kMidColor, kHighColor, smoothstep(0.5, 1.0, altitude));
// Pente : N.y vaut 1 a plat et tend vers 0 sur une paroi verticale. Une
// pente forte ne retient ni terre ni neige -> roche nue. C'est ce terme qui
// rend les versants raides immediatement visibles, donc qui valide que les
// normales sont bien calculees.
float slope = 1.0 - clamp(N.y, 0.0, 1.0);
albedo = mix(albedo, kCliffColor, smoothstep(0.25, 0.6, slope));
// --- Orthophoto ---------------------------------------------------------
// L'UV couvre EXACTEMENT l'emprise du terrain (0,0 = coin nord-ouest). Le
// niveau de mipmap est choisi par le materiel a partir des derivees de
// fragUV : c'est ce qui evite le fourmillement en vue lointaine, ou un texel
// de 0,61 m se projette bien en dessous du pixel.
//
// La photo remplace l'albedo mais PAS l'eclairage : le Blinn-Phong ci-dessous
// continue de s'appliquer avec la normale du relief. Une orthophoto est prise
// a la verticale par temps clair, donc deja a peu pres uniformement eclairee ;
// la relancer dans le modele d'eclairage est ce qui redonne du volume aux
// versants, qu'une photo plaquee telle quelle aplatit completement.
vec3 ortho = texture(orthoTexture, fragUV).rgb;
albedo = mix(albedo, ortho, clamp(ubo.terrain.z, 0.0, 1.0));
// --- PHASE 27 : sol mouille --------------------------------------------
// Pilote par WeatherSample::wetness (relecture de la pluie des dernieres
// heures, Phase 23) via weatherVisualsFor() : ubo.precip.w vaut
// wetGroundDarkening * wetness, donc exactement 0 sur un sol sec. Le sol
// fonce apres l'averse et SECHE avec le modele, sans aucune regle ici.
albedo *= 1.0 - clamp(ubo.precip.w, 0.0, 1.0);
// fragTint vaut (1,1,1) pour le terrain synthetique : reserve a une future
// classification par sommet (sol / vegetation / bati venant du LiDAR).
albedo *= fragTint;
vec3 L = normalize(ubo.sun.xyz);
// --- PHASE 27 : micro-relief (voir l'en-tete du bloc au-dessus de main) --
vec3 Nlit = N;
float detailStrength = clamp(ubo.detail.x, 0.0, 1.0);
float viewDistance = length(ubo.viewPos - fragWorldPos);
float distanceFade = detailStrength > 0.0
? 1.0 - smoothstep(ubo.detail.y, ubo.detail.z, viewDistance)
: 0.0;
// Derivees d'ecran calculees HORS de la branche : fwidth() et le choix du
// mipmap exigent un flot de controle uniforme dans le quad de pixels.
vec2 footprint = fwidth(fragWorldPos.xz);
vec2 posDx = dFdx(fragWorldPos.xz);
vec2 posDy = dFdy(fragWorldPos.xz);
float orthoLod = textureQueryLod(orthoTexture, fragUV).x;
if (distanceFade > 0.0) {
// Rugosite pilotee par les donnees : contraste local de la photo et
// pente LiDAR. Plancher de 0,5 : meme une prairie lisse a du grain,
// sinon le sol le plus courant du jeu resterait l'aplat a corriger.
vec3 orthoBlur = textureLod(orthoTexture, fragUV, orthoLod + 2.0).rgb;
float photoContrast = length(ortho - orthoBlur) * clamp(ubo.terrain.z, 0.0, 1.0);
float roughness = clamp(max(photoContrast / kDetailFullContrast,
slope / kDetailFullSlope), 0.0, 1.0);
float amplitude = detailStrength * distanceFade * mix(0.5, 1.0, roughness);
// Empreinte d'un pixel au sol, en metres (le plus grand des deux axes :
// en vue rasante, c'est l'axe de profondeur qui s'etire).
float pixelMeters = max(footprint.x, footprint.y);
float wavelength = max(ubo.detail.w, 0.01);
float height = 0.0;
vec2 gradient = vec2(0.0);
for (int o = 0; o < kDetailOctaves; ++o) {
// Nyquist : plein poids tant que la longueur d'onde couvre au moins
// 4 pixels, eteint a 2 pixels. (Resserre a 8 -> 4 pendant la
// chasse au cout, puis RETABLI : depuis que le bruit est une
// texture mipmappee, une octave ne coute qu'une lecture et les
// mipmaps filtrent deja le sous-pixel. La coupure a 8 px ne faisait
// plus que retirer le grain fin.) HISTORIQUE : la premiere
// version (4 -> 2 pixels) faisait tourner les 7 octaves sur tout le
// sol proche et coutait +1 683 us par image au ras du sol (x1,94 sur
// l'image entiere, Release) - pour des octaves de 5 et 11 mm qui
// tombaient a 2-4 pixels, donc invisibles ou scintillantes.
float nyquist = 1.0 - smoothstep(0.25, 0.5, pixelMeters / wavelength);
// Les longueurs d'onde decroissent : une octave eteinte eteint
// toutes les suivantes, inutile de continuer la boucle.
if (nyquist <= 0.0) {
break;
}
// Poids de hauteur proportionnel a la longueur d'onde : la PENTE de
// chaque octave est alors comparable (n' / lambda * lambda), d'ou un
// sol grenu a toutes les echelles plutot qu'ondule.
float octaveWeight = wavelength / max(ubo.detail.w, 0.01);
if (nyquist > 0.0) {
// Decalage propre a chaque octave : sans lui, toutes les octaves
// partageraient l'origine de la texture periodique.
vec3 n = valueNoiseD(fragWorldPos.xz / wavelength + float(o) * vec2(7.31, 3.17),
posDx / wavelength, posDy / wavelength);
height += nyquist * octaveWeight * (n.x - 0.5);
gradient += nyquist * n.yz; // = octaveWeight * lambda0 * (n'/lambda)
}
wavelength /= kDetailLacunarity;
}
// Pas de normalisation par la somme des poids ni par le nombre
// d'octaves : la premiere version faisait les deux, et divisait ainsi
// l'effet par ~7 avant meme d'appliquer sa force. La hauteur reste dans
// [-0,9, 0,9] environ (somme geometrique des poids), la pente par
// octave est comparable a toutes les echelles.
height = clamp(height, -1.0, 1.0);
gradient *= 0.5;
// Normale : la surface y = h(x, z) a pour normale (-dh/dx, 1, -dh/dz).
// On incline la normale du relief de ce gradient (approximation exacte
// a plat, bonne jusqu'aux pentes de falaise).
Nlit = normalize(N + amplitude * kDetailSlope * vec3(-gradient.x, 0.0, -gradient.y));
// Couleur : modulation autour de la photo, jamais remplacement.
albedo *= 1.0 + amplitude * kDetailAlbedo * height;
}
// --- PHASE 25 : adret / ubac -------------------------------------------
// MODULATION de l'albedo (donc de l'orthophoto), jamais un remplacement :
// la photo continue de porter tout le detail, elle est seulement rechauffee
// ou refroidie.
//
// Pourquoi ca ne fait PAS double emploi avec le diffus de Blinn-Phong, qui
// assombrit deja les versants a l'ombre : l'eclairage joue sur la
// LUMINOSITE, cet indice joue sur la TEINTE. Un ubac faiblement eclaire et
// un adret vu de loin dans la brume peuvent avoir la meme luminosite ; la
// difference d'exposition, elle, reste lisible dans la couleur. C'est aussi
// ce qui rend l'indice perceptible sur une orthophoto, qui est prise a la
// verticale par temps clair et arrive donc deja "a plat".
float aspectStrength = clamp(ubo.terrain.w, 0.0, 1.0);
if (aspectStrength > 0.0) {
// Les deux cosinus sont ecretes a zero, exactement comme dans
// WeatherSystem::sampleAt : une surface qui tourne le dos au soleil ne
// recoit pas un rayonnement negatif, elle n'en recoit pas.
float incidence = max(dot(N, L), 0.0);
float flatIncidence = max(L.y, 0.0);
float aspectSignal = clamp((incidence - flatIncidence) / kAspectIncidenceReference,
-1.0, 1.0);
// -1 -> ubac franc, 0 -> ni l'un ni l'autre, +1 -> adret franc.
vec3 tint = mix(kUbacTint, kAdretTint, 0.5 + 0.5 * aspectSignal);
albedo *= mix(vec3(1.0), tint, aspectStrength);
}
// --- Blinn-Phong, identique a la Phase 2 -------------------------------
vec3 V = normalize(ubo.viewPos - fragWorldPos);
vec3 H = normalize(L + V);
// PHASE 27 : Nlit = normale du relief + micro-relief de pres (egale a N
// partout ailleurs). L'indice adret/ubac ci-dessus garde N.
float diffuse = max(dot(Nlit, L), 0.0);
float specular = diffuse > 0.0
? kSpecularStrength * pow(max(dot(Nlit, H), 0.0), kShininess)
: 0.0;
// PHASE 23 : l'intensite directe et le multiplicateur d'ambiante viennent du
// cycle jour/nuit. En plein jour, sun.w = 1 et sunColor.a = 1 : l'expression
// ci-dessous est alors mot pour mot celle de la Phase 2.
vec3 kLightColor = ubo.sunColor.rgb;
float ambient = kAmbientStrength * ubo.sunColor.a;
diffuse *= ubo.sun.w;
specular *= ubo.sun.w;
vec3 lit = albedo * kLightColor * (ambient + diffuse)
+ kLightColor * specular;
outColor = vec4(applyFog(lit, fragWorldPos), 1.0);
}
+91
Voir le fichier
@@ -0,0 +1,91 @@
#version 450
// Meme bloc uniforme que les shaders du cube, avec un membre supplementaire en
// fin de bloc (terrain). Cote C++ il n'y a qu'une seule struct
// UniformBufferObject : les shaders du cube declarent simplement une version
// tronquee du bloc, ce qui est legal (la plage du descriptor peut etre plus
// grande que le bloc declare, jamais l'inverse).
layout(binding = 0) uniform UniformBufferObject {
mat4 view;
mat4 proj;
vec3 viewPos;
// x = altitude minimale du terrain, y = altitude maximale, zw = reserve.
// Passe par l'UBO plutot que code en dur : la coloration reste correcte
// quels que soient les parametres de generation (et demain, les vraies
// altitudes LiDAR, qui seront en metres NGF et pas du tout dans [0,16]).
vec4 terrain;
} ubo;
// Meme push constant que cube.vert : les deux pipelines partagent la meme
// signature de layout, ce qui permet au Renderer de pousser la model matrix de
// la meme facon quel que soit le materiau.
// params.x = debut de la bande de geomorphing, params.y = fin, en metres depuis
// la camera. Bande vide (y <= x) = pas de morphing : c'est le cas du terrain
// dessine d'un seul bloc (option --no-lod).
layout(push_constant) uniform PushConstants {
mat4 model;
vec4 params;
} pc;
layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 2) in vec3 inNormal;
// UV du sommet sur TOUT le terrain (0,0 au coin nord-ouest, 1,1 au sud-est),
// et non sur la tuile de quadtree : c'est ce qui rend la coordonnee continue
// d'une tuile a l'autre et independante du niveau de detail. Voir
// TerrainNodeMesh.cpp. PHASE 11 : desormais consomme, pour l'orthophoto.
layout(location = 3) in vec2 inUV;
// PHASE 10 - cible de geomorphing : position et normale de ce sommet dans la
// grille du niveau de detail SUPERIEUR (voir renderer/TerrainNodeMesh.hpp).
layout(location = 4) in vec3 inMorphPos;
layout(location = 5) in vec3 inMorphNormal;
layout(location = 0) out vec3 fragTint;
layout(location = 1) out vec3 fragNormal;
layout(location = 2) out vec3 fragWorldPos;
layout(location = 3) out vec2 fragUV;
void main() {
// --- Geomorphing (CDLOD) ------------------------------------------------
// La distance est mesuree sur la position NON MORPHEE : c'est ce qui garantit
// qu'un sommet partage par deux tuiles voisines obtient le meme facteur des
// deux cotes, donc que le bord reste soude. Prendre la position morphee
// rendrait le calcul recursif et instable.
//
// Le terrain etant genere directement en espace monde avec une model matrix
// identite, inPosition EST deja la position monde ; le pc.model ci-dessous
// reste applique pour ne rien casser si un jour une tuile etait transformee.
float morphSpan = pc.params.y - pc.params.x;
float morph = 0.0;
if (morphSpan > 0.0) {
float distance = length(ubo.viewPos - inPosition);
morph = clamp((distance - pc.params.x) / morphSpan, 0.0, 1.0);
}
vec3 position = mix(inPosition, inMorphPos, morph);
vec3 normal = mix(inNormal, inMorphNormal, morph);
vec4 worldPos = pc.model * vec4(position, 1.0);
gl_Position = ubo.proj * ubo.view * worldPos;
fragWorldPos = worldPos.xyz;
fragTint = inColor;
// L'UV n'est PAS morphe. Il est deja une fonction affine de la position dans
// la grille du terrain entier, donc la cible de morphing d'un sommet - qui
// est un autre noeud de cette meme grille - a naturellement l'UV de sa
// propre position. Interpoler entre les deux decalerait la photo par rapport
// au relief pendant la transition de niveau, exactement ce qu'on cherche a
// eviter. Le leger glissement de la texture qu'on pourrait attendre pendant
// un morph est en realite le comportement CORRECT : la surface se deforme,
// la photo reste accrochee a ses coordonnees geographiques.
fragUV = inUV;
// Le terrain est genere DIRECTEMENT en espace monde et son DrawItem porte la
// matrice IDENTITE : mat3(model) est donc exact ici sans discussion. Il
// redeviendrait faux si on appliquait au terrain une echelle verticale
// differente de l'horizontale - dans ce cas il faudrait transposer l'inverse
// cote CPU. Voir TerrainMesh.cpp.
fragNormal = mat3(pc.model) * normal;
}
+9
Voir le fichier
@@ -0,0 +1,9 @@
#version 450
// Couleur interpolee recue du vertex shader.
layout(location = 0) in vec3 fragColor;
layout(location = 0) out vec4 outColor;
void main() {
outColor = vec4(fragColor, 1.0);
}
+22
Voir le fichier
@@ -0,0 +1,22 @@
#version 450
// Triangle "en dur" dans le shader : positions et couleurs codees, pas de
// vertex buffer pour la Phase 0. gl_VertexIndex va de 0 a 2.
layout(location = 0) out vec3 fragColor;
vec2 positions[3] = vec2[](
vec2( 0.0, -0.5),
vec2( 0.5, 0.5),
vec2(-0.5, 0.5)
);
vec3 colors[3] = vec3[](
vec3(1.0, 0.0, 0.0),
vec3(0.0, 1.0, 0.0),
vec3(0.0, 0.0, 1.0)
);
void main() {
gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
fragColor = colors[gl_VertexIndex];
}
+113
Voir le fichier
@@ -0,0 +1,113 @@
#include "assets/DetailNoise.hpp"
#include <algorithm>
#include <cmath>
#include <stdexcept>
#include <vector>
namespace vercora {
namespace {
float latticeValue(uint32_t x, uint32_t y, uint32_t seed) {
uint32_t h = x * 0x8da6b343u ^ y * 0xd8163841u ^ seed * 0xcb1ab31fu;
h ^= h >> 13;
h *= 0x5bd1e995u;
h ^= h >> 15;
return static_cast<float>(h & 0x00ffffffu) / 16777215.0f;
}
unsigned char toByte(float v) {
return static_cast<unsigned char>(std::clamp(std::lround(v * 255.0f), 0L, 255L));
}
} // namespace
TextureData makeDetailNoiseTexture(uint32_t size, uint32_t cells, uint32_t seed) {
if (size == 0 || cells == 0 || size % cells != 0 || (size & (size - 1)) != 0) {
throw std::invalid_argument(
"makeDetailNoiseTexture : size doit etre une puissance de deux multiple de cells.");
}
// --- Niveau 0 : bruit de valeur periodique et ses derivees --------------
const uint32_t texelsPerCell = size / cells;
std::vector<float> level(static_cast<size_t>(size) * size * 4);
for (uint32_t y = 0; y < size; ++y) {
for (uint32_t x = 0; x < size; ++x) {
// Centre du texel, en unites de cellule.
const float u = (static_cast<float>(x) + 0.5f) / static_cast<float>(texelsPerCell);
const float v = (static_cast<float>(y) + 0.5f) / static_cast<float>(texelsPerCell);
const uint32_t i = static_cast<uint32_t>(std::floor(u));
const uint32_t j = static_cast<uint32_t>(std::floor(v));
const float fx = u - static_cast<float>(i);
const float fy = v - static_cast<float>(j);
// Raccord periodique : la cellule "cells" est la cellule 0.
const uint32_t i0 = i % cells, i1 = (i + 1) % cells;
const uint32_t j0 = j % cells, j1 = (j + 1) % cells;
const float a = latticeValue(i0, j0, seed);
const float b = latticeValue(i1, j0, seed);
const float c = latticeValue(i0, j1, seed);
const float d = latticeValue(i1, j1, seed);
const float sx = fx * fx * (3.0f - 2.0f * fx);
const float sy = fy * fy * (3.0f - 2.0f * fy);
const float dsx = 6.0f * fx * (1.0f - fx);
const float dsy = 6.0f * fy * (1.0f - fy);
const float k = a - b - c + d;
const float value = a + (b - a) * sx + (c - a) * sy + k * sx * sy;
const float du = dsx * ((b - a) + k * sy);
const float dv = dsy * ((c - a) + k * sx);
float* px = &level[(static_cast<size_t>(y) * size + x) * 4];
px[0] = value;
px[1] = 0.5f + 0.5f * du / kDetailNoiseSlopeRange;
px[2] = 0.5f + 0.5f * dv / kDetailNoiseSlopeRange;
px[3] = 1.0f;
}
}
// --- Chaine de mipmaps par moyenne 2x2 ------------------------------------
TextureData data;
data.width = size;
data.height = size;
data.format = TextureFormat::RGBA8;
data.label = "bruit de detail du sol (Phase 27)";
data.epsg = 0; // non georeferencee
uint32_t w = size;
std::vector<float> current = std::move(level);
for (;;) {
TextureMipLevel mip;
mip.width = w;
mip.height = w;
mip.offset = data.pixels.size();
mip.size = static_cast<uint64_t>(w) * w * 4;
data.mips.push_back(mip);
for (float f : current) {
data.pixels.push_back(toByte(f));
}
if (w == 1) {
break;
}
const uint32_t half = w / 2;
std::vector<float> next(static_cast<size_t>(half) * half * 4);
for (uint32_t y = 0; y < half; ++y) {
for (uint32_t x = 0; x < half; ++x) {
for (uint32_t ch = 0; ch < 4; ++ch) {
const auto at = [&](uint32_t xx, uint32_t yy) {
return current[(static_cast<size_t>(yy) * w + xx) * 4 + ch];
};
next[(static_cast<size_t>(y) * half + x) * 4 + ch] =
0.25f * (at(2 * x, 2 * y) + at(2 * x + 1, 2 * y) +
at(2 * x, 2 * y + 1) + at(2 * x + 1, 2 * y + 1));
}
}
}
current = std::move(next);
w = half;
}
return data;
}
} // namespace vercora
+37
Voir le fichier
@@ -0,0 +1,37 @@
#pragma once
#include "assets/TextureFile.hpp"
#include <cstdint>
namespace vercora {
// ===========================================================================
// PHASE 27 - Texture de bruit pour le micro-relief du sol
// ===========================================================================
// POURQUOI UNE TEXTURE et non un bruit calcule dans le shader : la premiere
// version calculait un bruit de valeur a derivees analytiques PAR PIXEL. La
// mesure (Release, UHD 770, vue au ras du sol, conditions entrelacees) a donne
// +1 490 us par image, dont ~200 us PAR OCTAVE : du calcul pur, confirme par
// bissection (sans octave : +330 us ; 2 octaves : +720 us). Changer le hash
// n'y changeait rien. Une lecture de texture par octave remplace les quatre
// hash et l'interpolation.
//
// CE QUE CONTIENT LA TEXTURE : un bruit de valeur 2D PERIODIQUE (il se raccorde
// bord a bord, pour etre echantillonne en repetition), sur une grille de
// `cells` x `cells` cellules, et ses derivees analytiques :
// R = valeur dans [0, 1]
// G = d(valeur)/du, B = d(valeur)/dv, par unite de CELLULE, codees de
// [-kDetailNoiseSlopeRange, +kDetailNoiseSlopeRange] vers [0, 255]
// A = 255
// Les mipmaps sont des moyennes 2x2 : moyenner des derivees ATTENUE le relief
// des niveaux lointains, ce qui est exactement le comportement voulu (un grain
// sous-pixel doit s'effacer, pas scintiller).
//
// Fonction PURE et deterministe : aucune dependance Vulkan, testable headless.
inline constexpr float kDetailNoiseSlopeRange = 1.5f;
TextureData makeDetailNoiseTexture(uint32_t size = 256, uint32_t cells = 32,
uint32_t seed = 0x6D1C0u);
} // namespace vercora
+297
Voir le fichier
@@ -0,0 +1,297 @@
#include "assets/Heightmap.hpp"
#include "core/Logger.hpp"
#include <algorithm>
#include <cmath>
#include <limits>
#include <stdexcept>
namespace vercora {
namespace {
// --- Bruit de valeur (value noise) --------------------------------------
// Choix : bruit de VALEUR plutot que Perlin/Simplex. Il ne demande aucune
// table de permutation ni gradients pre-calcules (donc zero etat, zero
// allocation, et un resultat identique sur toutes les plateformes), et une
// fois empile en fBm il est visuellement indiscernable de Perlin a cette
// echelle. Le cout par echantillon est plus eleve que Perlin, mais on genere
// 16384 points UNE fois au demarrage : c'est sans importance.
// Hash entier -> [0,1). Melange multiplicatif + decalages facon "integer
// finalizer" (meme famille que murmur3) : deux entrees voisines donnent des
// sorties decorrelees, ce qui est tout ce qu'on demande a un bruit de valeur.
float hash01(int64_t x, int64_t z, uint32_t seed) {
uint32_t h = seed;
h ^= static_cast<uint32_t>(static_cast<uint64_t>(x)) * 0x9E3779B1u;
h ^= static_cast<uint32_t>(static_cast<uint64_t>(z)) * 0x85EBCA77u;
h ^= h >> 15; h *= 0x2C1B3C6Du;
h ^= h >> 12; h *= 0x297A2D39u;
h ^= h >> 15;
// 24 bits suffisent largement et tiennent exactement dans la mantisse d'un
// float (pas d'arrondi, donc resultat parfaitement reproductible).
return static_cast<float>(h & 0x00FFFFFFu) / static_cast<float>(0x01000000u);
}
// Courbe de Hermite : derivee nulle aux extremites, donc pas de cassure de
// pente visible aux frontieres des cellules du bruit (une interpolation
// lineaire donnerait un relief en facettes losangees, tres reconnaissable).
float smoothCurve(float t) {
return t * t * (3.0f - 2.0f * t);
}
float lerp(float a, float b, float t) {
return a + (b - a) * t;
}
float valueNoise(float x, float z, uint32_t seed) {
const float fx = std::floor(x);
const float fz = std::floor(z);
const int64_t ix = static_cast<int64_t>(fx);
const int64_t iz = static_cast<int64_t>(fz);
const float tx = smoothCurve(x - fx);
const float tz = smoothCurve(z - fz);
const float n00 = hash01(ix, iz, seed);
const float n10 = hash01(ix + 1, iz, seed);
const float n01 = hash01(ix, iz + 1, seed);
const float n11 = hash01(ix + 1, iz + 1, seed);
return lerp(lerp(n00, n10, tx), lerp(n01, n11, tx), tz);
}
// fBm : somme d'octaves de frequence doublee et d'amplitude halvee.
// Renvoie une valeur dans [0,1] (division par la somme des amplitudes).
//
// 'ridged' transforme chaque octave en 1 - |2n - 1| : la valeur culmine la ou
// le bruit passait par sa moyenne, ce qui remplace les dômes arrondis par des
// LIGNES de crete continues, avec une derivee discontinue au sommet (arete
// vive). C'est la recette classique pour un relief de montagne, et c'est ce qui
// cree les versants raides dont le fragment shader a besoin pour montrer sa
// coloration par pente.
float fbm(float x, float z, const Heightmap::Params& params, bool ridged) {
float sum = 0.0f;
float normalization = 0.0f;
float amplitude = 1.0f;
float frequency = params.baseFrequency;
for (uint32_t octave = 0; octave < params.octaves; ++octave) {
// Graine decalee par octave : sans ca, toutes les octaves seraient la
// meme image a des echelles differentes et leurs maxima s'aligneraient.
// Le decalage differe aussi entre les deux variantes, pour que les
// cretes ne tombent pas systematiquement sur les sommets du fBm doux.
const uint32_t octaveSeed =
params.seed + octave * 7919u + (ridged ? 104729u : 0u);
float n = valueNoise(x * frequency, z * frequency, octaveSeed);
if (ridged) {
n = 1.0f - std::fabs(2.0f * n - 1.0f);
}
sum += amplitude * n;
normalization += amplitude;
amplitude *= 0.5f;
frequency *= 2.0f;
}
return normalization > 0.0f ? sum / normalization : 0.0f;
}
} // namespace
Heightmap::Heightmap(const Params& params) : params_(params) {
if (params_.resolution < 2) {
throw std::runtime_error(
"Heightmap : resolution de " + std::to_string(params_.resolution) +
" echantillons, il en faut au moins 2 pour former une surface.");
}
if (!(params_.worldSize > 0.0f) || !(params_.amplitude >= 0.0f)) {
throw std::runtime_error(
"Heightmap : worldSize doit etre > 0 et amplitude >= 0.");
}
if (params_.octaves == 0) {
throw std::runtime_error("Heightmap : il faut au moins une octave de bruit.");
}
const uint32_t res = params_.resolution;
// resolution-1 cellules couvrent worldSize -> pas de la grille.
spacing_ = params_.worldSize / static_cast<float>(res - 1);
halfSize_ = params_.worldSize * 0.5f;
heights_.resize(static_cast<std::size_t>(res) * res);
for (uint32_t iz = 0; iz < res; ++iz) {
// Coordonnees normalisees [0,1] : la frequence du bruit est ainsi
// exprimee en "motifs sur toute la largeur", independamment de la
// resolution. Changer resolution affine donc le maillage SANS changer
// la forme du relief - pratique pour comparer deux resolutions.
const float v = static_cast<float>(iz) / static_cast<float>(res - 1);
for (uint32_t ix = 0; ix < res; ++ix) {
const float u = static_cast<float>(ix) / static_cast<float>(res - 1);
// Deux reliefs superposes puis melanges : le fBm doux donne les
// grandes ondulations et les fonds de vallee, le ridged donne les
// aretes. std::pow sur une base garantie >= 0 : pas de NaN possible.
const float smooth = std::pow(fbm(u, v, params_, /*ridged=*/false),
params_.reliefExponent);
const float ridge = fbm(u, v, params_, /*ridged=*/true);
// Elevation au carre : accentue les cretes et aplatit le bas des
// versants, ce qui evite le relief "en toile de tente" uniforme.
const float shaped = lerp(smooth, ridge * ridge,
std::clamp(params_.ridgeWeight, 0.0f, 1.0f));
heights_[static_cast<std::size_t>(iz) * res + ix] =
shaped * params_.amplitude;
}
}
label_ = "terrain synthetique " + std::to_string(res) + "x" + std::to_string(res);
finalize();
logInfo("Heightmap synthetique generee : " + std::to_string(res) + "x" +
std::to_string(res) + " echantillons sur " +
std::to_string(params_.worldSize) + " unites (pas de " +
std::to_string(spacing_) + "), altitudes " +
std::to_string(minHeight_) + " a " + std::to_string(maxHeight_) + ".");
}
Heightmap::Heightmap(std::vector<float> heights, uint32_t resolution,
float spacing, std::string label, const GeoReference& geo)
: heights_(std::move(heights)), label_(std::move(label)), geo_(geo) {
if (resolution < 2) {
throw std::runtime_error(
"Heightmap : grille de " + std::to_string(resolution) +
" echantillons par cote, il en faut au moins 2 pour former une surface.");
}
if (!std::isfinite(spacing) || spacing <= 0.0f) {
throw std::runtime_error(
"Heightmap : pas de grille invalide (" + std::to_string(spacing) + ").");
}
const std::size_t expected =
static_cast<std::size_t>(resolution) * static_cast<std::size_t>(resolution);
if (heights_.size() != expected) {
throw std::runtime_error(
"Heightmap : " + std::to_string(heights_.size()) + " altitudes fournies "
"pour une grille " + std::to_string(resolution) + "x" +
std::to_string(resolution) + " qui en attend " + std::to_string(expected) + ".");
}
params_.resolution = resolution;
// La taille monde DECOULE du pas et du nombre d'echantillons : pour une
// grille mesuree c'est le pas qui est la donnee (1 m sur la dalle LiDAR),
// pas l'emprise. L'ordre est donc inverse de celui du generateur procedural,
// ou l'on impose l'emprise et ou le pas s'en deduit.
params_.worldSize = spacing * static_cast<float>(resolution - 1);
spacing_ = spacing;
halfSize_ = params_.worldSize * 0.5f;
finalize();
}
void Heightmap::finalize() {
minHeight_ = std::numeric_limits<float>::max();
maxHeight_ = std::numeric_limits<float>::lowest();
for (std::size_t i = 0; i < heights_.size(); ++i) {
const float height = heights_[i];
// Un seul NaN suffit a produire un triangle degenere et un terrain qui
// clignote, sans le moindre message d'erreur. On refuse ici plutot que
// de le decouvrir a l'ecran : c'est le risque numero un avec des donnees
// mesurees, ou une cellule sans aucun point de retour est frequente.
if (!std::isfinite(height)) {
const uint32_t res = params_.resolution;
throw std::runtime_error(
"Heightmap : altitude non finie (NaN ou infini) a l'echantillon (" +
std::to_string(i % res) + ", " + std::to_string(i / res) + ").");
}
minHeight_ = std::min(minHeight_, height);
maxHeight_ = std::max(maxHeight_, height);
}
}
float Heightmap::at(int64_t ix, int64_t iz) const {
const int64_t last = static_cast<int64_t>(params_.resolution) - 1;
const int64_t cx = std::clamp(ix, static_cast<int64_t>(0), last);
const int64_t cz = std::clamp(iz, static_cast<int64_t>(0), last);
return heights_[static_cast<std::size_t>(cz) * params_.resolution +
static_cast<std::size_t>(cx)];
}
float Heightmap::worldCoord(uint32_t index) const {
return -halfSize_ + static_cast<float>(index) * spacing_;
}
std::string Heightmap::describe() const {
return label_;
}
void Heightmap::toProjected(float worldX, float worldZ,
double* east, double* north) const {
// Inverse de worldCoord() : worldX = -halfSize + ix * spacing, donc la
// distance a l'echantillon 0 vaut worldX + halfSize.
//
// Le signe differe entre les deux axes et ce n'est pas une faute de frappe :
// ix croissant va vers l'EST (meme sens que la coordonnee projetee), tandis
// que iz croissant va vers le SUD, c'est-a-dire dans le sens DECROISSANT du
// nord. Voir l'orientation documentee dans Heightmap.hpp.
if (east) { *east = geo_.originEast + static_cast<double>(worldX + halfSize_); }
if (north) { *north = geo_.originNorth - static_cast<double>(worldZ + halfSize_); }
}
void Heightmap::fromProjected(double east, double north,
float* worldX, float* worldZ) const {
// Inversion terme a terme de toProjected ci-dessus. La soustraction se fait
// en DOUBLE avant la conversion en float, et c'est le point qui compte : un
// Lambert 93 vaut ~6,4 millions en nord, ou l'ecart entre deux float
// consecutifs atteint deja 0,5 m. Convertir d'abord puis soustraire
// perdrait un demi-metre sur chaque objet pose.
if (worldX) {
*worldX = static_cast<float>(east - geo_.originEast) - halfSize_;
}
if (worldZ) {
*worldZ = static_cast<float>(geo_.originNorth - north) - halfSize_;
}
}
float Heightmap::heightAt(float worldX, float worldZ) const {
const float last = static_cast<float>(params_.resolution - 1);
// Passage en coordonnees de grille (unite = un echantillon), ecretees sur
// le domaine : au-dela du bord, on prolonge la hauteur du bord.
// std::clamp sur des NaN renverrait NaN ; on s'en protege en amont plutot
// que de propager une position de camera invalide.
const float gx = std::isfinite(worldX)
? std::clamp((worldX + halfSize_) / spacing_, 0.0f, last) : 0.0f;
const float gz = std::isfinite(worldZ)
? std::clamp((worldZ + halfSize_) / spacing_, 0.0f, last) : 0.0f;
const float fx = std::floor(gx);
const float fz = std::floor(gz);
const int64_t ix = static_cast<int64_t>(fx);
const int64_t iz = static_cast<int64_t>(fz);
// Position dans la cellule, dans [0,1].
const float tx = gx - fx;
const float tz = gz - fz;
const float h00 = at(ix, iz);
const float h10 = at(ix + 1, iz);
const float h01 = at(ix, iz + 1);
const float h11 = at(ix + 1, iz + 1);
// TerrainMesh coupe chaque cellule le long de la diagonale h00-h11.
// Interpoler bilineairement ici donnerait une hauteur legerement au-dessus
// ou en dessous des triangles reellement affiches ; on reproduit donc le
// decoupage exact, ce qui colle la camera pile sur la surface visible.
if (tz > tx) {
// Triangle (h00, h01, h11) : affine, exact aux trois sommets.
return h00 + (h01 - h00) * tz + (h11 - h01) * tx;
}
// Triangle (h00, h10, h11).
return h00 + (h10 - h00) * tx + (h11 - h10) * tz;
}
} // namespace vercora
+192
Voir le fichier
@@ -0,0 +1,192 @@
#pragma once
#include "core/HeightSampler.hpp"
#include <cstdint>
#include <string>
#include <vector>
namespace vercora {
// Reference geographique d'une grille d'altitudes.
//
// PHASE 7 : c'est la trace de la provenance des donnees. Le moteur travaille en
// coordonnees LOCALES (terrain centre sur l'origine, cf. plus bas) parce qu'un
// Lambert 93 brut - de l'ordre de 907 000 m en X et 6 440 000 m en Y - depasse
// largement la precision d'un float32 : a 6,4 millions, l'ecart entre deux
// float consecutifs vaut deja 0,5 m, ce qui ferait trembler la geometrie et
// ruinerait le depth buffer. Le georeferencement est donc CONSERVE ici en
// double, a cote de la grille, plutot que porte par les sommets.
struct GeoReference {
// Coordonnees projetees de l'echantillon (ix = 0, iz = 0), c'est-a-dire le
// coin NORD-OUEST de la grille (voir l'orientation ci-dessous).
double originEast = 0.0;
double originNorth = 0.0;
// Code EPSG de la projection. 2154 = Lambert 93 (metropole). 0 = grille
// sans reference geographique, ce qui est le cas du terrain synthetique.
uint32_t epsg = 0;
// true si les altitudes sont les altitudes ABSOLUES mesurees (IGN69 pour la
// metropole), false si elles ont ete ramenees a une base nulle.
bool absoluteAltitude = false;
bool isGeoreferenced() const { return epsg != 0; }
};
// Grille reguliere d'altitudes.
//
// DEUX PROVENANCES, une seule classe :
// - bruit procedural genere en memoire (Phase 4), par le constructeur Params ;
// - dalle LiDAR HD reelle chargee depuis un fichier .vchm (Phase 7), par
// assets/TerrainFile.hpp, qui passe par le constructeur "grille toute
// faite" ci-dessous.
// TerrainMesh, les shaders, la camera et la foret ne voient AUCUNE difference :
// c'etait tout l'interet de passer par cette classe des la Phase 4 plutot que
// de generer le mesh directement, et c'est ce qui a rendu la Phase 7 possible
// sans toucher au rendu.
//
// Le terrain est CENTRE sur l'origine XZ : x et z varient dans
// [-worldSize/2, +worldSize/2]. Y est l'altitude (repere du moteur : Y up).
//
// ORIENTATION (n'a de sens que pour une grille georeferencee) : ix croissant va
// vers l'EST, iz croissant va vers le SUD. Le moteur etant en repere main droite
// avec Y vers le haut, X ^ Y = Z ; en posant X = Est on obtient
// Z = Est ^ Haut = -Nord. Le nord est donc en -Z, et ranger les lignes du nord
// vers le sud est la seule facon d'afficher le relief sans le mettre en MIROIR.
class Heightmap : public HeightSampler {
public:
struct Params {
// Echantillons par cote. 128x128 = 16384 hauteurs = 64 Ko de float :
// volontairement modeste (contrainte RAM de la machine de dev).
uint32_t resolution = 128;
// Cote du terrain en unites monde.
float worldSize = 100.0f;
// Denivele total vise entre le point le plus bas et le plus haut.
float amplitude = 30.0f;
// Graine du bruit : deux Heightmap de meme graine sont identiques bit a
// bit, ce qui rend les tests reproductibles.
uint32_t seed = 20260724u;
// Nombre d'octaves du fBm : chacune ajoute un detail deux fois plus fin
// et deux fois moins haut. Au-dela de ~6, le detail passe sous la taille
// d'une cellule de la grille et n'est plus representable.
uint32_t octaves = 5;
// Nombre de "grandes formes" du relief sur toute la largeur du terrain.
float baseFrequency = 3.0f;
// Exposant applique au bruit normalise avant mise a l'echelle. > 1
// creuse les vallees et garde les sommets pointus (relief plus lisible
// qu'un bruit brut, qui donne une houle uniforme).
float reliefExponent = 1.4f;
// Dosage entre relief doux (0 : collines arrondies, fBm classique) et
// relief de cretes (1 : bruit "ridged", aretes marquees et versants
// raides). Une valeur elevee produit de vraies pentes fortes, seule
// facon d'exercer la coloration par pente du shader - et accessoirement
// plus proche de ce que donneront les falaises du Vercors.
float ridgeWeight = 0.6f;
};
// Genere immediatement la grille par bruit fractal. Lance
// std::runtime_error si les parametres ne peuvent pas produire une surface
// (resolution < 2, taille <= 0, ...).
explicit Heightmap(const Params& params = {});
// Adopte une grille DEJA CONSTRUITE, sans rien generer : c'est par ici
// qu'entrent les donnees LiDAR (voir assets/TerrainFile.hpp).
// heights : resolution*resolution altitudes, indexees [iz * res + ix],
// lignes du nord vers le sud pour une grille georeferencee.
// spacing : distance monde entre deux echantillons voisins, en metres.
// label : ce que renverra describe(), affiche dans le titre.
// Lance std::runtime_error si la grille n'est pas exploitable (taille
// incoherente, pas nul ou negatif, valeur non finie). La validation est
// faite ICI et non chez l'appelant : toute autre source de donnees future
// en beneficiera sans avoir a y penser.
Heightmap(std::vector<float> heights, uint32_t resolution, float spacing,
std::string label, const GeoReference& geo = {});
uint32_t resolution() const { return params_.resolution; }
float worldSize() const { return params_.worldSize; }
// Provenance geographique. epsg == 0 pour le terrain synthetique.
const GeoReference& geo() const { return geo_; }
// Coordonnees projetees (Lambert 93 pour une dalle IGN) d'un point du monde
// moteur. Inverse exact du recentrage applique au chargement : c'est le seul
// endroit qui documente le lien entre les deux reperes, et il est verifie
// par les tests headless.
// N'a de sens que si geo().isGeoreferenced() ; renvoie sinon les
// coordonnees locales telles quelles.
void toProjected(float worldX, float worldZ,
double* east, double* north) const;
// PHASE 15 : l'INVERSE de toProjected, des coordonnees projetees vers le
// repere du moteur.
//
// Cette formule existait deja, recopiee a la main dans main.cpp pour
// l'option --start de la Phase 11, et l'editeur en avait besoin une
// troisieme fois (le fichier de scene stocke des coordonnees projetees).
// Deux copies d'une convention d'axes dont une seule serait corrigee le jour
// ou elle changerait, c'est exactement le genre de piege que le commentaire
// de toProjected ci-dessus decrit : la conversion vit desormais ICI, dans
// les deux sens, a cote de l'orientation qu'elle applique.
//
// AUCUN ecretage : un point hors emprise rend des coordonnees hors emprise,
// a charge de l'appelant de decider ce qu'il en fait (main.cpp refuse un
// --start dehors, l'editeur signale un objet dehors et le garde).
void fromProjected(double east, double north,
float* worldX, float* worldZ) const;
// Distance monde entre deux echantillons voisins.
float spacing() const { return spacing_; }
// Bornes reelles des altitudes generees (et non l'amplitude demandee) :
// le shader s'en sert pour normaliser sa coloration par altitude.
float minHeight() const { return minHeight_; }
float maxHeight() const { return maxHeight_; }
// Altitude d'un echantillon de la grille. Les indices sont ecretes dans
// [0, resolution-1] : appeler avec ix = -1 renvoie la colonne 0.
float at(int64_t ix, int64_t iz) const;
// Position monde d'un echantillon (le long de X pour ix, de Z pour iz).
float worldCoord(uint32_t index) const;
// Nom lisible, repris dans MeshData et le titre de la fenetre.
std::string describe() const;
// --- HeightSampler ---
// Interpolation AFFINE sur le triangle qui contient (worldX, worldZ), avec
// la meme diagonale de decoupe que TerrainMesh : la valeur renvoyee est
// donc exactement l'altitude de la surface affichee, pas une approximation.
// Hors domaine, les coordonnees sont ecretees sur le bord.
float heightAt(float worldX, float worldZ) const override;
private:
// Facteurs communs aux deux constructeurs : derive spacing_/halfSize_ de la
// resolution, puis balaye la grille pour en tirer minHeight_/maxHeight_ en
// refusant toute valeur non finie.
void finalize();
Params params_;
std::vector<float> heights_; // resolution * resolution, indexe [iz * res + ix]
// Ce que renvoie describe(). Porte par une chaine plutot que reconstruit a
// la demande : une grille chargee n'a pas de "parametres de bruit" a decrire,
// seulement le nom de sa dalle d'origine.
std::string label_;
GeoReference geo_{};
float spacing_ = 0.0f;
float halfSize_ = 0.0f;
float minHeight_ = 0.0f;
float maxHeight_ = 0.0f;
};
} // namespace vercora
+294
Voir le fichier
@@ -0,0 +1,294 @@
#include "assets/ObjLoader.hpp"
#include "core/Logger.hpp"
// tinyobjloader est header-only : l'implementation doit etre compilee dans
// EXACTEMENT une unite de traduction, celle-ci.
#define TINYOBJLOADER_IMPLEMENTATION
#include <tiny_obj_loader.h>
#include <cmath>
#include <cstdint>
#include <filesystem>
#include <limits>
#include <stdexcept>
#include <string>
#include <unordered_map>
namespace vercora {
namespace {
// Cle de deduplication : un sommet .obj est un TRIPLET d'indices independants
// (position / UV / normale). Deux faces ne partagent un sommet de vertex buffer
// que si les trois coincident : deux faces qui partagent une position mais ont
// des normales differentes (arete vive) doivent rester deux sommets distincts.
struct AttribKey {
int position = -1;
int uv = -1;
int normal = -1;
bool operator==(const AttribKey& other) const = default;
};
struct AttribKeyHash {
std::size_t operator()(const AttribKey& key) const noexcept {
// Melange multiplicatif simple (constante du nombre d'or 64 bits) :
// suffisant ici, les indices sont petits et bien repartis.
constexpr std::uint64_t kMix = 0x9E3779B97F4A7C15ull;
std::uint64_t h = static_cast<std::uint32_t>(key.position);
h = (h + static_cast<std::uint32_t>(key.uv)) * kMix;
h = (h + static_cast<std::uint32_t>(key.normal)) * kMix;
return static_cast<std::size_t>(h);
}
};
// Supprime les retours a la ligne finaux des messages de tinyobjloader, qui
// sinon cassent le formatage du logger.
std::string trimTrailingNewlines(std::string text) {
while (!text.empty() && (text.back() == '\n' || text.back() == '\r')) {
text.pop_back();
}
return text;
}
} // namespace
MeshData loadObjMesh(const std::string& path) {
namespace fs = std::filesystem;
// --- 1. Verifications de fichier, avant meme d'invoquer le parseur -------
// On veut un message qui distingue "chemin faux" de "contenu invalide".
std::error_code ec;
const fs::path filePath(path);
if (!fs::exists(filePath, ec) || ec) {
throw std::runtime_error(
"Fichier .obj introuvable : \"" + path + "\" (chemin absolu teste : " +
fs::absolute(filePath, ec).string() + ").");
}
if (!fs::is_regular_file(filePath, ec) || ec) {
throw std::runtime_error(
"Le chemin \"" + path + "\" existe mais n'est pas un fichier.");
}
if (fs::file_size(filePath, ec) == 0 || ec) {
throw std::runtime_error("Fichier .obj vide : \"" + path + "\".");
}
// --- 2. Parsing ---------------------------------------------------------
tinyobj::attrib_t attrib;
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials;
std::string warn;
std::string err;
// mtl_basedir = dossier du .obj, pour qu'un eventuel materiau reference
// soit cherche a cote du fichier et non dans le repertoire courant.
const std::string baseDir = filePath.parent_path().string();
// triangulate = true : les quads et n-gones sont decoupes en triangles, le
// seul type de primitive que le pipeline accepte (TRIANGLE_LIST).
const bool ok = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err,
path.c_str(),
baseDir.empty() ? nullptr : baseDir.c_str(),
/*triangulate=*/true);
if (!warn.empty()) {
// Typiquement un .mtl manquant : non bloquant, on n'utilise pas encore
// les materiaux.
logWarn("tinyobjloader (" + filePath.filename().string() + ") : " +
trimTrailingNewlines(warn));
}
if (!ok) {
throw std::runtime_error("Fichier .obj invalide : \"" + path + "\" - " +
trimTrailingNewlines(err.empty() ? "erreur inconnue" : err));
}
if (shapes.empty() || attrib.vertices.empty()) {
throw std::runtime_error(
"Fichier .obj lu mais sans geometrie exploitable : \"" + path +
"\" (aucune face ou aucun sommet).");
}
// --- 3. Construction du MeshData ---------------------------------------
const std::size_t positionCount = attrib.vertices.size() / 3;
const std::size_t normalCount = attrib.normals.size() / 3;
const std::size_t uvCount = attrib.texcoords.size() / 2;
// attrib.colors est rempli par tinyobjloader (blanc par defaut) et a la
// meme taille que attrib.vertices ; on se protege quand meme.
const bool hasColors = attrib.colors.size() == attrib.vertices.size();
MeshData mesh;
mesh.name = filePath.filename().string();
std::unordered_map<AttribKey, uint32_t, AttribKeyHash> uniqueVertices;
std::size_t verticesWithoutNormal = 0;
bool anyUv = false;
for (const tinyobj::shape_t& shape : shapes) {
for (const tinyobj::index_t& idx : shape.mesh.indices) {
if (idx.vertex_index < 0 ||
static_cast<std::size_t>(idx.vertex_index) >= positionCount) {
throw std::runtime_error(
"Fichier .obj invalide : \"" + path + "\" - index de position " +
std::to_string(idx.vertex_index) + " hors des " +
std::to_string(positionCount) + " positions declarees.");
}
// Un indice de normale/UV present mais hors limites est une erreur ;
// absent (-1) est un cas legitime, traite plus bas.
if (idx.normal_index >= 0 &&
static_cast<std::size_t>(idx.normal_index) >= normalCount) {
throw std::runtime_error(
"Fichier .obj invalide : \"" + path + "\" - index de normale " +
std::to_string(idx.normal_index) + " hors limites.");
}
if (idx.texcoord_index >= 0 &&
static_cast<std::size_t>(idx.texcoord_index) >= uvCount) {
throw std::runtime_error(
"Fichier .obj invalide : \"" + path + "\" - index d'UV " +
std::to_string(idx.texcoord_index) + " hors limites.");
}
const AttribKey key{ idx.vertex_index, idx.texcoord_index, idx.normal_index };
const auto [it, inserted] =
uniqueVertices.try_emplace(key, static_cast<uint32_t>(mesh.vertices.size()));
if (inserted) {
Vertex vertex{};
const std::size_t v = static_cast<std::size_t>(idx.vertex_index) * 3;
vertex.pos = { attrib.vertices[v + 0],
attrib.vertices[v + 1],
attrib.vertices[v + 2] };
vertex.color = hasColors ? glm::vec3{ attrib.colors[v + 0],
attrib.colors[v + 1],
attrib.colors[v + 2] }
: glm::vec3{ 1.0f, 1.0f, 1.0f };
if (idx.normal_index >= 0) {
const std::size_t n = static_cast<std::size_t>(idx.normal_index) * 3;
vertex.normal = { attrib.normals[n + 0],
attrib.normals[n + 1],
attrib.normals[n + 2] };
} else {
// Marqueur : normale a calculer une fois toutes les faces
// connues (etape 4).
vertex.normal = { 0.0f, 0.0f, 0.0f };
++verticesWithoutNormal;
}
if (idx.texcoord_index >= 0) {
const std::size_t t = static_cast<std::size_t>(idx.texcoord_index) * 2;
// .obj a l'origine des UV en bas a gauche, Vulkan en haut a
// gauche : on inverse V des maintenant pour que la donnee
// stockee soit deja dans la convention du moteur.
vertex.uv = { attrib.texcoords[t + 0],
1.0f - attrib.texcoords[t + 1] };
anyUv = true;
}
mesh.vertices.push_back(vertex);
}
mesh.indices.push_back(it->second);
}
}
if (mesh.indices.empty()) {
throw std::runtime_error(
"Fichier .obj sans face exploitable : \"" + path + "\".");
}
if (mesh.indices.size() % 3 != 0) {
// Ne devrait pas arriver avec triangulate=true, mais mieux vaut le dire
// que de laisser passer une geometrie tronquee.
throw std::runtime_error(
"Fichier .obj : la triangulation a produit " +
std::to_string(mesh.indices.size()) +
" index, ce qui n'est pas un multiple de 3 (\"" + path + "\").");
}
// --- 4. Normales manquantes : moyenne des faces adjacentes --------------
// Un .obj sans 'vn' est courant. Sans normale, le shader Blinn-Phong de la
// Phase 2 rendrait l'objet uniformement noir (produit scalaire nul), donc on
// les reconstruit. Les sommets ayant deja une normale ne sont pas touches.
if (verticesWithoutNormal > 0) {
for (std::size_t i = 0; i + 2 < mesh.indices.size(); i += 3) {
Vertex& a = mesh.vertices[mesh.indices[i + 0]];
Vertex& b = mesh.vertices[mesh.indices[i + 1]];
Vertex& c = mesh.vertices[mesh.indices[i + 2]];
// Normale geometrique de la face. L'enroulement du .obj etant
// anti-horaire par convention, ce produit vectoriel pointe vers
// l'exterieur.
const glm::vec3 faceNormal = glm::cross(b.pos - a.pos, c.pos - a.pos);
for (Vertex* vertex : { &a, &b, &c }) {
if (vertex->normal == glm::vec3(0.0f)) {
// Non normalise volontairement : la longueur du produit
// vectoriel vaut le double de l'aire du triangle, ce qui
// pondere la moyenne par l'aire (les grandes faces pesent
// plus, resultat plus lisse).
vertex->normal += faceNormal;
}
}
}
// Normalisation finale, une seule fois par sommet.
for (Vertex& vertex : mesh.vertices) {
const float lengthSquared = glm::dot(vertex.normal, vertex.normal);
if (lengthSquared > 1e-12f) {
vertex.normal /= std::sqrt(lengthSquared);
} else {
// Sommet isole ou faces degenerees : valeur par defaut plutot
// qu'une division par zero (qui donnerait des NaN a l'ecran).
vertex.normal = { 0.0f, 1.0f, 0.0f };
}
}
}
// --- 5. Controle de coherence geometrique -------------------------------
// tinyobjloader est tres permissif : un token non numerique ("v abc def")
// est lu comme 0.0 sans erreur, et un tel fichier produirait une geometrie
// degeneree, invisible a l'ecran, sans aucun message. On mesure donc la
// boite englobante : elle sert de garde-fou ET d'information utile (echelle
// du modele, indispensable pour cadrer la camera sur du terrain plus tard).
glm::vec3 minBounds(std::numeric_limits<float>::max());
glm::vec3 maxBounds(std::numeric_limits<float>::lowest());
for (const Vertex& vertex : mesh.vertices) {
for (int axis = 0; axis < 3; ++axis) {
if (!std::isfinite(vertex.pos[axis])) {
throw std::runtime_error(
"Fichier .obj invalide : \"" + path +
"\" - coordonnee non finie (NaN ou infini) dans les positions.");
}
}
minBounds = glm::min(minBounds, vertex.pos);
maxBounds = glm::max(maxBounds, vertex.pos);
}
const glm::vec3 extent = maxBounds - minBounds;
if (glm::dot(extent, extent) <= 0.0f) {
throw std::runtime_error(
"Fichier .obj sans geometrie visible : \"" + path +
"\" - tous les sommets sont confondus (boite englobante de taille "
"nulle). Fichier probablement mal forme : tinyobjloader lit toute "
"valeur non numerique comme 0.");
}
logInfo("Boite englobante de " + mesh.name + " : " +
std::to_string(extent.x) + " x " + std::to_string(extent.y) + " x " +
std::to_string(extent.z) + ".");
logInfo("Charge " + mesh.name + " : " + std::to_string(mesh.vertices.size()) +
" sommets uniques, " + std::to_string(mesh.triangleCount()) + " triangles" +
(anyUv ? ", UV lus" : ", pas d'UV") +
(verticesWithoutNormal > 0
? ", " + std::to_string(verticesWithoutNormal) + " normales generees"
: ", normales lues") +
".");
return mesh;
}
} // namespace vercora
+28
Voir le fichier
@@ -0,0 +1,28 @@
#pragma once
#include "renderer/MeshData.hpp"
#include <string>
namespace vercora {
// Charge un fichier Wavefront .obj en geometrie CPU (MeshData), prete a etre
// envoyee au GPU par la classe Mesh.
//
// Ce que fait le loader :
// - triangule les faces (un .obj peut contenir des quads ou des n-gones) ;
// - lit positions, normales et UV quand ils sont presents ;
// - genere des normales lissees pour les sommets qui n'en ont pas, sinon
// l'eclairage de la Phase 2 produirait un objet totalement noir ;
// - deduplique les sommets sur le triplet (position, UV, normale) pour ne pas
// exploser inutilement la taille du vertex buffer.
//
// Aucune ressource Vulkan n'est touchee ici : appeler cette fonction AVANT
// d'initialiser le GPU permet d'echouer proprement sur un fichier manquant ou
// invalide sans avoir rien alloue.
//
// Lance std::runtime_error avec un message explicite si le fichier est
// introuvable, illisible, mal forme, ou ne contient aucune geometrie.
MeshData loadObjMesh(const std::string& path);
} // namespace vercora
+176
Voir le fichier
@@ -0,0 +1,176 @@
#include "assets/TerrainFile.hpp"
#include "core/Logger.hpp"
#include <bit>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <fstream>
#include <stdexcept>
#include <vector>
namespace vercora {
namespace {
constexpr std::size_t kHeaderSize = 120;
constexpr std::size_t kLabelSize = 64;
constexpr uint32_t kExpectedVersion = 1;
constexpr uint32_t kFlagAbsoluteAltitude = 1u << 0;
// Garde-fou contre un en-tete corrompu. Sans lui, un champ "samplesX" errone
// demanderait une allocation absurde AVANT qu'on ait pu constater que le fichier
// est trop court pour la contenir. 16384 echantillons par cote, c'est deja
// 268 millions de sommets : bien au-dela de ce qu'on chargera jamais d'un bloc.
constexpr uint32_t kMaxResolution = 16384;
// Le format est petit-boutiste, comme toutes les machines visees (x86-64,
// ARM64). Plutot que d'ecrire un echangeur d'octets qui ne serait jamais
// exerce - donc jamais teste, donc probablement faux - on refuse a la
// compilation les plateformes gros-boutistes.
static_assert(std::endian::native == std::endian::little,
"Le format .vchm est petit-boutiste ; portage requis sur une "
"plateforme gros-boutiste.");
static_assert(sizeof(float) == 4 && sizeof(double) == 8,
"Le format .vchm suppose des float IEEE 754 de 4 et 8 octets.");
// Lecture d'un champ a un offset FIXE du tampon d'en-tete. On ne surimpose pas
// une struct C++ : son agencement dependrait du padding decide par le
// compilateur, alors que le format, lui, est fige par l'outil Python.
template <typename T>
T readField(const unsigned char* header, std::size_t offset) {
T value{};
std::memcpy(&value, header + offset, sizeof(T));
return value;
}
} // namespace
Heightmap loadTerrainFile(const std::string& path) {
std::ifstream file(path, std::ios::binary);
if (!file) {
throw std::runtime_error("Terrain : fichier introuvable ou illisible : " + path);
}
unsigned char header[kHeaderSize];
if (!file.read(reinterpret_cast<char*>(header), kHeaderSize)) {
throw std::runtime_error(
"Terrain : " + path + " fait moins de " + std::to_string(kHeaderSize) +
" octets, ce n'est pas un fichier .vchm.");
}
if (std::memcmp(header, "VCHM", 4) != 0) {
throw std::runtime_error(
"Terrain : " + path + " ne commence pas par la magie \"VCHM\". "
"Fichier d'un autre type, ou produit par un autre outil ?");
}
const uint32_t version = readField<uint32_t>(header, 4);
if (version != kExpectedVersion) {
throw std::runtime_error(
"Terrain : " + path + " est en version " + std::to_string(version) +
", ce moteur lit la version " + std::to_string(kExpectedVersion) +
". Regenerer avec tools/lidar_to_heightmap.py.");
}
const uint32_t samplesX = readField<uint32_t>(header, 8);
const uint32_t samplesZ = readField<uint32_t>(header, 12);
const float spacing = readField<float>(header, 16);
const double originE = readField<double>(header, 24);
const double originN = readField<double>(header, 32);
const float headerMin = readField<float>(header, 40);
const float headerMax = readField<float>(header, 44);
const uint32_t epsg = readField<uint32_t>(header, 48);
const uint32_t flags = readField<uint32_t>(header, 52);
if (samplesX != samplesZ) {
throw std::runtime_error(
"Terrain : " + path + " est une grille " + std::to_string(samplesX) + "x" +
std::to_string(samplesZ) + ". Seules les grilles CARREES sont "
"supportees pour l'instant (Heightmap n'expose qu'une resolution).");
}
if (samplesX < 2 || samplesX > kMaxResolution) {
throw std::runtime_error(
"Terrain : " + path + " annonce " + std::to_string(samplesX) +
" echantillons par cote, hors des bornes acceptees [2, " +
std::to_string(kMaxResolution) + "].");
}
const std::size_t count =
static_cast<std::size_t>(samplesX) * static_cast<std::size_t>(samplesZ);
// Le fichier doit faire EXACTEMENT la taille annoncee par son en-tete. Trop
// court, on lirait des zeros silencieusement (terrain plat par endroits) ;
// trop long, l'en-tete ment sur son contenu. Dans les deux cas mieux vaut
// refuser que jouer sur un terrain a moitie faux.
file.seekg(0, std::ios::end);
const std::streamoff fileSize = file.tellg();
const std::streamoff expected =
static_cast<std::streamoff>(kHeaderSize + count * sizeof(float));
if (fileSize != expected) {
throw std::runtime_error(
"Terrain : " + path + " fait " + std::to_string(fileSize) +
" octets, alors que son en-tete (" + std::to_string(samplesX) + "x" +
std::to_string(samplesZ) + " echantillons) en decrit " +
std::to_string(expected) + ". Fichier tronque ou en-tete corrompu.");
}
std::vector<float> heights(count);
file.seekg(static_cast<std::streamoff>(kHeaderSize), std::ios::beg);
if (!file.read(reinterpret_cast<char*>(heights.data()),
static_cast<std::streamsize>(count * sizeof(float)))) {
throw std::runtime_error("Terrain : lecture interrompue dans " + path + ".");
}
// Le label du fichier n'est pas garanti termine par un zero s'il occupe les
// 64 octets : on borne explicitement plutot que de faire confiance.
const char* labelBytes = reinterpret_cast<const char*>(header + 56);
std::size_t labelLength = 0;
while (labelLength < kLabelSize && labelBytes[labelLength] != '\0') { ++labelLength; }
std::string label(labelBytes, labelLength);
if (label.empty()) { label = "dalle sans nom"; }
GeoReference geo;
geo.originEast = originE;
geo.originNorth = originN;
geo.epsg = epsg;
geo.absoluteAltitude = (flags & kFlagAbsoluteAltitude) != 0;
// Le constructeur valide le reste : taille coherente, pas > 0, et surtout
// aucune altitude non finie.
Heightmap heightmap(std::move(heights), samplesX, spacing, label, geo);
// Les bornes de l'en-tete sont redondantes avec les donnees. Les comparer
// est un controle d'integrite gratuit : un ecart signale un fichier modifie
// apres coup, ou un outil de generation qui a diverge du format.
const float tolerance = 0.01f; // les altitudes LiDAR sont au centimetre
if (std::abs(headerMin - heightmap.minHeight()) > tolerance ||
std::abs(headerMax - heightmap.maxHeight()) > tolerance) {
logWarn("Terrain : les bornes de l'en-tete (" + std::to_string(headerMin) +
" .. " + std::to_string(headerMax) + ") ne correspondent pas aux "
"altitudes lues (" + std::to_string(heightmap.minHeight()) + " .. " +
std::to_string(heightmap.maxHeight()) + "). Fichier suspect.");
}
logInfo("Terrain reel charge : " + label + ", " + std::to_string(samplesX) + "x" +
std::to_string(samplesZ) + " echantillons au pas de " +
std::to_string(spacing) + " m, emprise " +
std::to_string(heightmap.worldSize()) + " m, altitudes " +
std::to_string(heightmap.minHeight()) + " a " +
std::to_string(heightmap.maxHeight()) + " m" +
(geo.absoluteAltitude ? " (IGN69)" : " (base ramenee a zero)") + ".");
if (geo.isGeoreferenced()) {
// Le coin nord-ouest de la dalle est le seul point dont on connaisse la
// coordonnee projetee sans calcul : le journaliser permet de retrouver
// la dalle sur une carte a partir d'un simple log de partie.
logInfo(" georeference EPSG:" + std::to_string(geo.epsg) +
", coin nord-ouest E " + std::to_string(geo.originEast) +
" N " + std::to_string(geo.originNorth) +
" ; le centre de la dalle est a l'origine du monde.");
}
return heightmap;
}
} // namespace vercora
+50
Voir le fichier
@@ -0,0 +1,50 @@
#pragma once
#include "assets/Heightmap.hpp"
#include <string>
namespace vercora {
// Chargement d'une heightmap .vchm ("Vercora HeightMap") produite hors ligne par
// tools/lidar_to_heightmap.py a partir d'une dalle LiDAR HD de l'IGN.
//
// POURQUOI UN FORMAT MAISON plutot que lire le .laz directement. Un .laz est un
// nuage de points COMPRESSE et non trie : en extraire une grille demande un
// decodeur LASzip, puis un tri, une agregation par cellule, un bouchage des
// trous et un filtrage des valeurs aberrantes - environ 3,5 s et 170 Mo de
// lecture pour la dalle de test, pour un resultat toujours identique. C'est du
// travail de PREPARATION, pas de chargement. Le jeu, lui, lit 4 Mo de float
// deja propres et les envoie au maillage. La frontiere est la meme que celle des
// shaders, compiles en SPIR-V par le build et non en GLSL a l'execution.
//
// FORMAT (petit-boutiste, en-tete de 120 octets, puis les altitudes) - la
// definition de reference, avec les justifications, est en tete de
// tools/lidar_to_heightmap.py :
//
// 0 "VCHM" magie
// 4 uint32 version = 1
// 8 uint32 samplesX echantillons d'ouest en est
// 12 uint32 samplesZ echantillons du nord vers le sud
// 16 float32 spacing metres entre deux echantillons
// 20 uint32 reserve
// 24 float64 originEast Lambert 93 X de l'echantillon ix = 0
// 32 float64 originNorth Lambert 93 Y de l'echantillon iz = 0
// 40 float32 minHeight \ redondants avec les donnees : sert de
// 44 float32 maxHeight / controle de coherence, pas de source
// 48 uint32 epsg
// 52 uint32 flags bit 0 : altitudes absolues (IGN69)
// 56 char[64] label
// 120 float32 heights[samplesZ * samplesX]
//
// LIMITE ASSUMEE : seules les grilles CARREES sont acceptees, parce que
// Heightmap et TerrainMesh n'exposent qu'une seule resolution. Une dalle IGN
// etant un carre de 1 km, la contrainte ne coute rien aujourd'hui ; elle devra
// tomber le jour ou l'on assemblera plusieurs dalles en un rectangle. Un fichier
// non carre est refuse avec un message explicite plutot que charge de travers.
//
// Lance std::runtime_error avec un message exploitable si le fichier est
// absent, tronque, d'une autre version, ou incoherent.
Heightmap loadTerrainFile(const std::string& path);
} // namespace vercora
+167
Voir le fichier
@@ -0,0 +1,167 @@
#include "assets/TextureFile.hpp"
#include "core/Logger.hpp"
#include <bit>
#include <cstring>
#include <fstream>
#include <stdexcept>
namespace vercora {
namespace {
constexpr std::size_t kHeaderSize = 128;
constexpr std::size_t kLabelSize = 64;
constexpr uint32_t kExpectedVersion = 1;
// Meme garde-fou que .vchm : un en-tete corrompu ne doit pas pouvoir demander
// une allocation absurde avant qu'on ait pu constater que le fichier est trop
// court. 32768 est deja le double de la limite materielle usuelle
// (maxImageDimension2D = 16384 sur les GPU de bureau actuels).
constexpr uint32_t kMaxDimension = 32768;
// Une chaine de mipmaps ne peut pas depasser log2(taille max) + 1 niveaux.
constexpr uint32_t kMaxMipLevels = 16;
static_assert(std::endian::native == std::endian::little,
"Le format .vcto est petit-boutiste ; portage requis sur une "
"plateforme gros-boutiste.");
template <typename T>
T readField(const unsigned char* header, std::size_t offset) {
T value{};
std::memcpy(&value, header + offset, sizeof(T));
return value;
}
} // namespace
uint64_t textureLevelSize(TextureFormat format, uint32_t width, uint32_t height) {
if (format == TextureFormat::BC1) {
// Blocs de 4x4 texels sur 8 octets. Les dimensions non multiples de 4
// (les tout derniers niveaux : 2x2, 1x1) occupent un bloc entier : c'est
// ce que fait l'outil et ce qu'attend le materiel.
const uint64_t blocksX = (width + 3u) / 4u;
const uint64_t blocksY = (height + 3u) / 4u;
return blocksX * blocksY * 8u;
}
return static_cast<uint64_t>(width) * height * 4u;
}
double TextureData::metresPerTexel() const {
if (width == 0 || height == 0) {
return 0.0;
}
const double perX = (eastMax - eastMin) / static_cast<double>(width);
const double perY = (northMax - northMin) / static_cast<double>(height);
return 0.5 * (perX + perY);
}
TextureData loadTextureFile(const std::string& path) {
std::ifstream file(path, std::ios::binary);
if (!file) {
throw std::runtime_error("Texture : fichier introuvable ou illisible : " + path);
}
unsigned char header[kHeaderSize];
if (!file.read(reinterpret_cast<char*>(header), kHeaderSize)) {
throw std::runtime_error(
"Texture : " + path + " fait moins de " + std::to_string(kHeaderSize) +
" octets, ce n'est pas un fichier .vcto.");
}
if (std::memcmp(header, "VCTO", 4) != 0) {
throw std::runtime_error(
"Texture : " + path + " ne commence pas par la magie \"VCTO\". "
"Fichier d'un autre type, ou produit par un autre outil ?");
}
const uint32_t version = readField<uint32_t>(header, 4);
if (version != kExpectedVersion) {
throw std::runtime_error(
"Texture : " + path + " est en version " + std::to_string(version) +
", ce moteur lit la version " + std::to_string(kExpectedVersion) +
". Regenerer avec tools/make_ortho_texture.py.");
}
TextureData texture;
texture.width = readField<uint32_t>(header, 8);
texture.height = readField<uint32_t>(header, 12);
const uint32_t mipLevels = readField<uint32_t>(header, 16);
const uint32_t rawFormat = readField<uint32_t>(header, 20);
texture.eastMin = readField<double>(header, 24);
texture.northMin = readField<double>(header, 32);
texture.eastMax = readField<double>(header, 40);
texture.northMax = readField<double>(header, 48);
texture.epsg = readField<uint32_t>(header, 56);
char label[kLabelSize + 1] = {};
std::memcpy(label, header + 64, kLabelSize);
texture.label = label;
if (texture.width == 0 || texture.height == 0 ||
texture.width > kMaxDimension || texture.height > kMaxDimension) {
throw std::runtime_error(
"Texture : " + path + " annonce des dimensions inexploitables (" +
std::to_string(texture.width) + "x" + std::to_string(texture.height) + ").");
}
if (mipLevels == 0 || mipLevels > kMaxMipLevels) {
throw std::runtime_error(
"Texture : " + path + " annonce " + std::to_string(mipLevels) +
" niveaux de mipmap, ce qui est impossible.");
}
if (rawFormat > static_cast<uint32_t>(TextureFormat::BC1)) {
throw std::runtime_error(
"Texture : " + path + " utilise le format inconnu " +
std::to_string(rawFormat) + ".");
}
if (texture.eastMax <= texture.eastMin || texture.northMax <= texture.northMin) {
throw std::runtime_error(
"Texture : " + path + " porte une emprise vide ou inversee.");
}
texture.format = static_cast<TextureFormat>(rawFormat);
// Les niveaux sont deduits, pas lus : la seule chose qui vient du fichier est
// leur NOMBRE. Un decompte incoherent se traduira par une taille totale qui
// ne correspond pas au fichier, donc par un refus juste en dessous.
uint64_t total = 0;
texture.mips.reserve(mipLevels);
for (uint32_t level = 0; level < mipLevels; ++level) {
TextureMipLevel mip;
mip.width = texture.width >> level;
mip.height = texture.height >> level;
if (mip.width == 0) mip.width = 1;
if (mip.height == 0) mip.height = 1;
mip.offset = total;
mip.size = textureLevelSize(texture.format, mip.width, mip.height);
total += mip.size;
texture.mips.push_back(mip);
}
file.seekg(0, std::ios::end);
const std::streamoff fileSize = file.tellg();
const uint64_t expected = static_cast<uint64_t>(kHeaderSize) + total;
if (fileSize < 0 || static_cast<uint64_t>(fileSize) != expected) {
throw std::runtime_error(
"Texture : " + path + " fait " + std::to_string(fileSize) +
" octets, alors que son en-tete en decrit " + std::to_string(expected) +
". Fichier tronque ou en-tete incoherent.");
}
file.seekg(static_cast<std::streamoff>(kHeaderSize), std::ios::beg);
texture.pixels.resize(static_cast<std::size_t>(total));
if (!file.read(reinterpret_cast<char*>(texture.pixels.data()),
static_cast<std::streamsize>(total))) {
throw std::runtime_error("Texture : lecture interrompue dans " + path + ".");
}
logInfo("Texture : " + texture.label + " " + std::to_string(texture.width) + "x" +
std::to_string(texture.height) + ", " + std::to_string(mipLevels) +
" mipmaps, " +
(texture.format == TextureFormat::BC1 ? std::string("BC1") : std::string("RGBA8")) +
", " + std::to_string(total / (1024 * 1024)) + " Mo.");
return texture;
}
} // namespace vercora
+73
Voir le fichier
@@ -0,0 +1,73 @@
#pragma once
#include <cstdint>
#include <string>
#include <vector>
namespace vercora {
// Encodage des texels d'une texture .vcto. Les valeurs sont celles ECRITES dans
// le fichier par tools/make_ortho_texture.py : ne jamais les reordonner.
enum class TextureFormat : uint32_t {
RGBA8 = 0, // 4 octets par texel, non compresse
BC1 = 1, // blocs de 4x4 texels sur 8 octets (RGB, 6:1)
};
// Un niveau de mipmap : ou le trouver dans le bloc d'octets, et quelle taille il
// fait. Les offsets sont calcules au chargement plutot que stockes : le fichier
// les range consecutivement, et une taille deduite ne peut pas contredire les
// donnees (alors qu'une table lue pourrait).
struct TextureMipLevel {
uint32_t width = 0;
uint32_t height = 0;
uint64_t offset = 0; // depuis le debut de pixels
uint64_t size = 0; // en octets
};
// Texture chargee depuis un .vcto, cote CPU uniquement : aucune dependance
// Vulkan, comme Heightmap. C'est ce qui permet de la tester sans GPU.
//
// PHASE 11. Le terrain LiDAR ne porte que des altitudes ; la couleur vient
// d'ailleurs. Ce fichier est le pendant exact de TerrainFile.hpp pour la photo
// aerienne : un format maison, produit hors ligne, que le jeu se contente de
// relire. La justification detaillee du format (et pourquoi les mipmaps sont
// precalculees : on ne peut pas filtrer des blocs BC1 sur le GPU) est en tete de
// tools/make_ortho_texture.py.
struct TextureData {
uint32_t width = 0;
uint32_t height = 0;
TextureFormat format = TextureFormat::RGBA8;
std::vector<TextureMipLevel> mips;
std::vector<unsigned char> pixels;
// Emprise Lambert 93 COUVERTE par l'image, bord a bord. C'est ce qui permet
// de verifier qu'une texture correspond bien au terrain charge au lieu de
// l'appliquer de travers en silence.
double eastMin = 0.0;
double northMin = 0.0;
double eastMax = 0.0;
double northMax = 0.0;
uint32_t epsg = 0;
std::string label;
bool empty() const { return pixels.empty(); }
// Metres de terrain par texel du niveau 0, moyenne des deux axes. Sert au
// journal de demarrage : c'est le chiffre qui dit si la texture est a la
// hauteur du niveau de detail du terrain.
double metresPerTexel() const;
};
// Charge un .vcto. Lance std::runtime_error avec un message exploitable si le
// fichier est absent, tronque, d'une autre version, ou incoherent (nombre de
// niveaux impossible, taille de charge utile ne correspondant pas aux niveaux
// annonces, ...).
TextureData loadTextureFile(const std::string& path);
// Nombre d'octets d'un niveau de mipmap pour un format donne. Expose parce que
// c'est la seule formule qui lie les deux formats a leur taille, et que le
// chargeur ET les tests s'en servent.
uint64_t textureLevelSize(TextureFormat format, uint32_t width, uint32_t height);
} // namespace vercora
+247
Voir le fichier
@@ -0,0 +1,247 @@
#include "core/Camera.hpp"
#include "core/CollisionSolver.hpp"
#include "core/HeightSampler.hpp"
#include "core/SlopeLimits.hpp"
#include "core/Logger.hpp"
#include "core/Window.hpp" // apporte aussi les constantes GLFW_*
#include <glm/gtc/matrix_transform.hpp>
#include <algorithm>
#include <cmath>
namespace vercora {
Camera::Camera(glm::vec3 position, float yawDegrees, float pitchDegrees)
: position_(position), yaw_(yawDegrees), pitch_(pitchDegrees) {
updateVectors();
}
void Camera::setMode(CameraMode mode) {
if (mode == CameraMode::Walk && heightSampler_ == nullptr) {
logWarn("Mode marche indisponible : aucun terrain n'est charge.");
return;
}
mode_ = mode;
if (mode_ == CameraMode::Walk) {
// Poser la camera tout de suite : sinon elle resterait a son altitude de
// vol jusqu'a la premiere frame, ce qui donnerait un saut visible.
snapToTerrain();
}
switch (mode_) {
case CameraMode::Walk:
logInfo("Camera : mode MARCHE (la camera suit le relief).");
break;
case CameraMode::Free:
logInfo("Camera : mode LIBRE (vol).");
break;
case CameraMode::Glide:
logInfo("Camera : mode PARAPENTE (vue a la troisieme personne).");
break;
case CameraMode::Ride:
logInfo("Camera : mode VELO (vue a la troisieme personne).");
break;
case CameraMode::Climb:
logInfo("Camera : mode ESCALADE (premiere personne, regard libre).");
break;
}
}
void Camera::setChasePose(const glm::vec3& eye, const glm::vec3& lookAtPoint) {
position_ = eye;
front_ = glm::normalize(lookAtPoint - eye);
right_ = glm::normalize(glm::cross(front_, worldUp_));
up_ = glm::normalize(glm::cross(right_, front_));
yaw_ = glm::degrees(std::atan2(front_.z, front_.x));
pitch_ = glm::degrees(std::asin(std::clamp(front_.y, -1.0f, 1.0f)));
}
void Camera::snapToTerrain() {
if (heightSampler_ == nullptr) {
return;
}
position_.y = heightSampler_->heightAt(position_.x, position_.z) + eyeHeight_;
}
void Camera::resolveCollisions(const glm::vec3& previousPosition) {
if (collisionSolver_ == nullptr) {
return;
}
BodyCylinder body;
body.position = position_;
body.radius = bodyRadius_;
// position_ est la hauteur d'OEIL : les pieds sont une hauteur d'oeil plus
// bas, la tete juste au-dessus des yeux. Cette bande est ce qui permet a une
// souche basse de bloquer les jambes sans qu'on ait a la traiter a part.
body.feetY = position_.y - eyeHeight_;
body.headY = position_.y + 0.15f;
// moveBody et non resolve directement : c'est lui qui refuse le deplacement
// quand aucune position libre n'existe, au lieu de laisser le joueur etre
// extrude au travers d'un passage plus etroit que lui (voir CollisionSolver).
const glm::vec3 corrected = moveBody(*collisionSolver_, body, previousPosition);
// Seul l'horizontal est repris : la verticale appartient au terrain, et la
// reprendre ici ferait lutter la collision contre snapToTerrain.
position_.x = corrected.x;
position_.z = corrected.z;
}
void Camera::setOrientation(float yawDegrees, float pitchDegrees) {
yaw_ = yawDegrees;
pitch_ = std::clamp(pitchDegrees, -89.0f, 89.0f);
updateVectors();
}
void Camera::update(const Window& window, float deltaTime) {
if (!inputEnabled_) {
// Camera verrouillee : ni clavier ni souris. La position et
// l'orientation restent celles fixees par l'appelant. Voir
// setInputEnabled().
return;
}
if (mode_ == CameraMode::Glide || mode_ == CameraMode::Ride) {
// L'activite est pilotee de l'exterieur (world/Paraglider,
// world/Bike) : ni le clavier ni la souris n'agissent ici, y compris la
// touche F. C'est delibere - voir le commentaire de setChasePose() - et
// ca evite qu'une bascule Free/Walk parasite ne s'active en plein vol
// ou en pleine descente.
return;
}
// PHASE 14. L'escalade a un contrat MIXTE, et c'est le seul mode qui en a
// un : la POSITION appartient a world/Climber (imposee par setPosition() une
// fois par frame), l'ORIENTATION reste au joueur.
//
// Pourquoi la souris continue d'agir alors qu'elle est coupee en vol et a
// velo : en escalade, les commandes sont RELATIVES A LA PAROI et non au
// regard - monter suit la ligne de plus grande pente, traverser suit la
// ligne de niveau, toutes deux imposees par le terrain. Le regard n'a donc
// plus aucune influence sur le deplacement, et il redevient libre sans rien
// casser. C'est meme necessaire : accroche a une face, on doit pouvoir lever
// les yeux pour lire la suite de la voie et regarder en bas pour juger la
// hauteur, sans que ca deplace le grimpeur d'un centimetre.
//
// Concretement : on saute la bascule F et tout le deplacement clavier (que
// main.cpp consomme pour grimper), on garde le bloc souris tout en bas.
const bool orientationOnly = (mode_ == CameraMode::Climb);
if (!orientationOnly) {
// --- Bascule de mode (front descendant sur F) ---
const bool toggleDown = window.isKeyPressed(GLFW_KEY_F);
if (toggleDown && !toggleKeyWasDown_ && !modeLocked_) {
setMode(mode_ == CameraMode::Free ? CameraMode::Walk : CameraMode::Free);
}
toggleKeyWasDown_ = toggleDown;
// --- Clavier : deplacement ---
const float velocity = moveSpeed_ * deltaTime;
if (mode_ == CameraMode::Walk) {
// Position d'avant le pas. La collision en a besoin comme position de
// repli : c'est la derniere dont on sait qu'elle etait libre.
const glm::vec3 previousPosition = position_;
// Direction du regard projetee sur le plan horizontal : regarder le ciel
// ne doit pas faire reculer, ni ralentir la marche.
// pitch_ est ecrete a +/-89 degres, la composante horizontale ne peut
// donc jamais etre nulle : normalize() est sur.
const glm::vec3 flatFront = glm::normalize(glm::vec3(front_.x, 0.0f, front_.z));
// Le pas DEMANDE par le clavier. Il n'est plus applique directement :
// depuis la Phase 24 il passe par le filtre de pente (voir plus bas).
// right_ est deja horizontal par construction (cross(front, worldUp)).
glm::vec3 desiredStep(0.0f);
if (window.isKeyPressed(GLFW_KEY_W)) desiredStep += flatFront * velocity;
if (window.isKeyPressed(GLFW_KEY_S)) desiredStep -= flatFront * velocity;
if (window.isKeyPressed(GLFW_KEY_A)) desiredStep -= right_ * velocity;
if (window.isKeyPressed(GLFW_KEY_D)) desiredStep += right_ * velocity;
// Espace/shift volontairement ignores : c'est le terrain qui decide de Y.
// PHASE 24 : la pente limite la marche. Le filtre rend la position
// horizontale retenue - pas a vitesse pleine sous kWalkComfortSlope,
// ralenti au-dela, nul a kWalkMaxSlope, plus une glissade vers l'aval
// si le joueur se trouve sur du terrain ou il ne tient pas debout.
// Voir core/SlopeLimits.hpp pour le choix des seuils et, surtout,
// pour la raison qui les lie a ClimberParams::wallSlope.
//
// Le filtre a besoin du terrain : sans HeightSampler il n'y a de
// toute facon pas de mode Walk (setMode le refuse), mais update()
// peut etre atteint avec un sampler retire entre-temps.
if (heightSampler_ != nullptr) {
lastWalkStep_ = resolveWalkStep(*heightSampler_, position_, desiredStep,
deltaTime, walkSlopeParams_);
position_ = lastWalkStep_.position;
} else {
position_ += desiredStep;
}
// ORDRE IMPORTANT : on corrige d'abord la position horizontale contre
// les obstacles, on repose ENSUITE la camera sur le terrain. L'inverse
// laisserait la camera a l'altitude de l'endroit ou elle voulait aller
// et non de celui ou elle a fini, ce qui se voit immediatement quand on
// longe un tronc sur une pente.
resolveCollisions(previousPosition);
snapToTerrain();
} else {
if (window.isKeyPressed(GLFW_KEY_W)) position_ += front_ * velocity; // Z (AZERTY)
if (window.isKeyPressed(GLFW_KEY_S)) position_ -= front_ * velocity; // S
if (window.isKeyPressed(GLFW_KEY_A)) position_ -= right_ * velocity; // Q (AZERTY)
if (window.isKeyPressed(GLFW_KEY_D)) position_ += right_ * velocity; // D
if (window.isKeyPressed(GLFW_KEY_SPACE)) position_ += worldUp_ * velocity;
if (window.isKeyPressed(GLFW_KEY_LEFT_SHIFT)) position_ -= worldUp_ * velocity;
}
}
// --- Souris : rotation seulement si clic droit maintenu ---
if (window.isMouseButtonPressed(GLFW_MOUSE_BUTTON_RIGHT)) {
double x = 0.0;
double y = 0.0;
window.getCursorPos(x, y);
if (!rotating_) {
// Premier frame du drag : on initialise sans "saut" de camera.
rotating_ = true;
lastX_ = x;
lastY_ = y;
}
const double dx = x - lastX_;
const double dy = lastY_ - y; // ecran : Y vers le bas -> on inverse
lastX_ = x;
lastY_ = y;
yaw_ += static_cast<float>(dx) * mouseSensitivity_;
pitch_ += static_cast<float>(dy) * mouseSensitivity_;
pitch_ = std::clamp(pitch_, -89.0f, 89.0f); // evite le retournement
updateVectors();
} else {
rotating_ = false;
}
}
glm::mat4 Camera::viewMatrix() const {
return glm::lookAt(position_, position_ + front_, up_);
}
void Camera::updateVectors() {
const float yawRad = glm::radians(yaw_);
const float pitchRad = glm::radians(pitch_);
glm::vec3 front;
front.x = std::cos(yawRad) * std::cos(pitchRad);
front.y = std::sin(pitchRad);
front.z = std::sin(yawRad) * std::cos(pitchRad);
front_ = glm::normalize(front);
right_ = glm::normalize(glm::cross(front_, worldUp_));
up_ = glm::normalize(glm::cross(right_, front_));
}
} // namespace vercora
+217
Voir le fichier
@@ -0,0 +1,217 @@
#pragma once
#include "core/SlopeLimits.hpp"
#include <glm/glm.hpp>
namespace vercora {
class Window;
class HeightSampler;
class CollisionSolver;
// Quatre modes :
//
// - Free (Phase 1) : "fly camera". ZQSD dans la direction du regard,
// espace/shift pour monter/descendre. C'est le mode d'inspection d'un objet,
// bascule avec Walk par la touche F.
// - Walk (Phase 4) : la camera colle au terrain. ZQSD deplace uniquement dans
// le plan horizontal, et Y est impose par le terrain sous les pieds, plus
// une hauteur d'oeil fixe. Espace/shift sont sans effet (pas encore de saut).
// - Glide (Phase 8) : vol en parapente. La camera ne se pilote plus toute
// seule ici - voir world/Paraglider, qui possede la position et le cap du
// pilote - elle se contente d'afficher une vue chase-cam derriere lui via
// setChasePose(), appelee une fois par frame par l'appelant. update() est
// alors un no-op : ni clavier ni souris n'agissent sur la camera pendant le
// vol, cf. la remarque sur la lisibilite dans setChasePose().
// - Climb (Phase 14) : escalade. Le seul mode a la PREMIERE personne pilote de
// l'exterieur, et donc un contrat different des deux precedents : la POSITION
// vient de world/Climber (via setPosition(), appelee une fois par frame),
// mais l'ORIENTATION reste au joueur - la souris continue de fonctionner.
// Voir le commentaire de update() pour la raison, qui est de gameplay et non
// de commodite.
// - Ride (Phase 13) : sortie a velo. EXACTEMENT le meme contrat que Glide -
// la camera est passive et recoit sa pose de l'exterieur (world/Bike) - mais
// c'est un mode distinct et non un alias, pour deux raisons : les journaux
// doivent dire lequel des deux est actif, et une activite future pourra
// vouloir un cadrage different sans toucher a l'autre. Le choix de la
// troisieme personne est le meme que pour le parapente : la lisibilite du
// mouvement, ici l'assiette du velo sur le relief.
//
// Le mode Walk n'est disponible que si un HeightSampler a ete fourni ; sinon la
// bascule est refusee avec un message, plutot que de laisser la camera dans un
// etat ou elle ne peut plus bouger verticalement.
//
// Note clavier : on interroge les tokens GLFW W/A/S/D. Sur un clavier AZERTY
// francais, ces tokens correspondent PHYSIQUEMENT aux touches Z/Q/S/D (GLFW
// raisonne en positions physiques facon QWERTY US). Donc ZQSD "sous les doigts".
enum class CameraMode { Free, Walk, Glide, Ride, Climb };
// Hauteur des yeux au-dessus du sol en mode marche, en unites monde (= metres).
//
// Nommee ici plutot que codee en dur dans Camera : le code qui doit PREDIRE ce
// que verra le joueur - le mode --dump-world de main.cpp, qui cherche depuis
// quel recul un arbre est reellement visible - en a besoin sans avoir de Camera
// sous la main, l'oeil n'existant pas encore au moment ou il calcule.
inline constexpr float kDefaultEyeHeight = 1.7f;
class Camera {
public:
explicit Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 3.0f),
float yawDegrees = -90.0f,
float pitchDegrees = 0.0f);
// A appeler une fois par frame. deltaTime en secondes.
void update(const Window& window, float deltaTime);
glm::mat4 viewMatrix() const;
glm::vec3 position() const { return position_; }
// Direction du regard, normalisee. C'est l'origine et la direction du rayon
// de visee du joueur (Phase 5 : designer l'arbre a abattre).
glm::vec3 front() const { return front_; }
// Terrain sur lequel marcher. Le pointeur n'est PAS possede : il doit rester
// valide aussi longtemps que la camera. nullptr desactive le mode Walk.
void setHeightSampler(const HeightSampler* sampler) { heightSampler_ = sampler; }
// Obstacles que la camera ne doit pas traverser. Le pointeur n'est PAS
// possede : il doit rester valide aussi longtemps que la camera. nullptr
// (le defaut) = on traverse tout, exactement comme avant la Phase 6.
//
// La collision n'agit QU'EN MODE MARCHE. Le vol libre reste un mode
// d'inspection : pouvoir traverser un tronc pour aller regarder une souche
// de pres y est une fonctionnalite, pas un defaut.
void setCollisionSolver(const CollisionSolver* solver) { collisionSolver_ = solver; }
// Bascule refusee (et signalee) vers Walk sans HeightSampler.
void setMode(CameraMode mode);
CameraMode mode() const { return mode_; }
// Deplace la camera de force a une position donnee, sans toucher a son
// orientation. Sert au retour d'atterrissage du parapente : le pilote se
// pose loin d'ou la camera se trouvait (elle suivait en chase-cam), il faut
// donc la ramener sur lui avant de rebasculer en mode Walk.
void setPosition(const glm::vec3& position) { position_ = position; }
// Pose imposee depuis l'exterieur en mode Glide : eye = ou placer l'oeil de
// la camera, lookAtPoint = ce qu'elle regarde (le pilote). Recalcule aussi
// yaw_/pitch_ a partir du regard obtenu, sans quoi sortir du vol ferait
// sauter la camera a l'orientation d'avant le decollage - souvent tres
// differente - au lieu de continuer dans a peu pres la direction du vol.
void setChasePose(const glm::vec3& eye, const glm::vec3& lookAtPoint);
// Demi-largeur du joueur, en unites monde. Sert au test de collision.
void setBodyRadius(float radius) { bodyRadius_ = radius; }
float bodyRadius() const { return bodyRadius_; }
// Vitesse de deplacement en unites/seconde. Un terrain de 100 unites de cote
// ne se parcourt pas a la meme vitesse qu'un cube d'une unite d'arete.
void setMoveSpeed(float unitsPerSecond) { moveSpeed_ = unitsPerSecond; }
// PHASE 15 : le mode editeur vole beaucoup plus vite que la marche et doit
// rendre EXACTEMENT sa vitesse a la camera en sortant, sans supposer laquelle
// c'etait (elle differe entre une scene de terrain et un objet isole).
float moveSpeed() const { return moveSpeed_; }
// PHASE 11. Coupe TOUTE lecture du clavier et de la souris par la camera.
//
// Raison d'etre : le jeu lit le clavier et la souris SYSTEME (GLFW ne voit
// pas les messages postes, cf. l'en-tete de run_vulkan_check.ps1).
// Une capture automatisee lancee pendant que la machine sert a autre chose
// se fait donc bouger la camera par la vraie souris - constate directement :
// deux executions du meme script ont donne yaw -90 et yaw -50, donc deux
// cadrages differents, ce qui rend toute comparaison avant/apres sans
// valeur. Verrouiller l'entree rend la vue entierement determinee par
// --start et --look.
void setInputEnabled(bool enabled) { inputEnabled_ = enabled; }
bool inputEnabled() const { return inputEnabled_; }
// PHASE 15. Interdit a la touche F de basculer Free <-> Walk.
//
// Le mode EDITEUR exige une camera de vol libre : ni gravite, ni collision,
// pour survoler les 25 km2. C'est exactement ce que fait deja
// CameraMode::Free - resolveCollisions() et snapToTerrain() ne sont appeles
// qu'en mode Walk - il ne manquait donc rien, sauf la garantie que le mode
// ne change pas sous les pieds de l'editeur des qu'une touche traine.
//
// Un verrou plutot qu'une valeur d'enum "Editor" de plus : la camera d'edition
// n'a AUCUN comportement propre, elle est un vol libre. Lui inventer un mode
// ajouterait une branche a traiter dans chaque switch de ce fichier et dans
// main.cpp, pour un comportement identique a un cas existant.
void setModeLocked(bool locked) { modeLocked_ = locked; }
bool modeLocked() const { return modeLocked_; }
// PHASE 24. Reglage de la limite de pente franchissable a pied, et dernier
// resultat du filtre. Voir core/SlopeLimits.hpp.
//
// Le resultat est expose parce qu'il est la SEULE facon de constater apres
// coup pourquoi le joueur n'avancait plus : sans lui, "je pousse la touche
// et il ne se passe rien" est indiscernable d'une touche perdue par le
// harnais - un diagnostic que ce projet a deja paye plusieurs fois.
void setWalkSlopeParams(const WalkSlopeParams& params) { walkSlopeParams_ = params; }
const WalkSlopeParams& walkSlopeParams() const { return walkSlopeParams_; }
const WalkStepResult& lastWalkStep() const { return lastWalkStep_; }
// Oriente la camera directement, en degres.
void setOrientation(float yawDegrees, float pitchDegrees);
// Orientation courante, en degres. Exposee pour le journal de diagnostic :
// c'est la seule facon de constater apres coup qu'une capture automatisee
// ne cadrait pas ce qu'on croyait.
float yawDegrees() const { return yaw_; }
float pitchDegrees() const { return pitch_; }
private:
void updateVectors();
// Applique la contrainte du mode Walk : Y = terrain + hauteur d'oeil.
void snapToTerrain();
// Repousse la camera hors des obstacles, a l'horizontale uniquement.
// previousPosition = position d'avant le pas, utilisee comme repli quand
// aucune position libre n'existe.
void resolveCollisions(const glm::vec3& previousPosition);
glm::vec3 position_;
glm::vec3 front_;
glm::vec3 up_;
glm::vec3 right_;
glm::vec3 worldUp_ = glm::vec3(0.0f, 1.0f, 0.0f);
bool inputEnabled_ = true;
bool modeLocked_ = false;
float yaw_; // degres
float pitch_; // degres
float moveSpeed_ = 3.0f; // unites/seconde
float mouseSensitivity_ = 0.1f; // degres/pixel
// Hauteur des yeux au-dessus du sol en mode Walk. La convention 1 unite =
// 1 metre n'est plus une hypothese depuis la Phase 7 : le terrain vient de
// donnees LiDAR dont les coordonnees sont en metres.
float eyeHeight_ = kDefaultEyeHeight;
// Demi-largeur du corps du joueur. 0.35 unite = 0.35 m : un peu plus qu'une
// demi-largeur d'epaules, ce qui evite de raser les troncs a les frotter.
float bodyRadius_ = 0.35f;
WalkSlopeParams walkSlopeParams_{};
WalkStepResult lastWalkStep_{};
CameraMode mode_ = CameraMode::Free;
const HeightSampler* heightSampler_ = nullptr; // non possede
const CollisionSolver* collisionSolver_ = nullptr; // non possede
// Front descendant de la touche de bascule : sans ca, maintenir F une demi
// seconde ferait basculer le mode a chaque frame.
bool toggleKeyWasDown_ = false;
// Etat du drag souris (clic droit).
bool rotating_ = false;
double lastX_ = 0.0;
double lastY_ = 0.0;
};
} // namespace vercora
+94
Voir le fichier
@@ -0,0 +1,94 @@
#pragma once
#include <glm/glm.hpp>
namespace vercora {
// Le corps du joueur, modelise par un CYLINDRE VERTICAL.
//
// Un cylindre et non une capsule ou un mesh : les seuls obstacles de cette phase
// sont des troncs et des souches, eux-memes cylindriques et verticaux. Le test
// se reduit donc a un probleme de cercles dans le plan XZ plus un recouvrement
// d'intervalles en Y - quelques lignes, aucun cout mesurable, et une precision
// tres suffisante tant que rien n'est en surplomb.
struct BodyCylinder {
// Position de l'OEIL (c'est ce que manipule la camera), en monde. Seuls X et
// Z sont corriges par la resolution : la verticale reste le domaine du
// terrain (voir Camera::snapToTerrain).
glm::vec3 position{0.0f};
// Demi-largeur du joueur.
float radius = 0.35f;
// Bande verticale occupee par le corps. Un obstacle qui n'y mord pas ne
// bloque pas : c'est ce qui permettra plus tard de passer sous une branche
// haute, et c'est deja ce qui distingue un tronc entier d'une souche basse.
float feetY = 0.0f;
float headY = 0.0f;
};
// Ce que la camera a besoin de savoir du monde pour ne pas le traverser.
//
// Meme intention que HeightSampler juste a cote : core/Camera ne doit dependre
// NI de world/Forest, ni de ce qui peuplera le monde demain (rochers, batis,
// couche LiDAR classifiee). La camera consomme ce contrat, l'implementation vit
// du cote des donnees - ici world/Forest, qui connait ses troncs et ses souches.
class CollisionSolver {
public:
virtual ~CollisionSolver() = default;
// Renvoie la position corrigee : identique a body.position si le joueur ne
// chevauche aucun obstacle, repoussee juste en dehors sinon.
//
// Contrat : la fonction est TOTALE et ne deplace jamais le joueur qu'a
// l'horizontale. Une implementation qui n'a rien a dire renvoie la position
// telle quelle. Corriger par repoussement (et non en annulant le
// deplacement) est ce qui donne gratuitement le glissement le long d'un
// obstacle : on longe un tronc au lieu de s'y coller net.
//
// Le repoussement ne garantit PAS a lui seul une position libre : entre deux
// obstacles plus rapproches que la largeur du joueur, il n'en existe pas. Le
// resultat doit donc etre verifie par overlaps() - c'est ce que fait
// moveBody() ci-dessous, et c'est par la que doit passer tout appelant.
virtual glm::vec3 resolve(const BodyCylinder& body) const = 0;
// Le corps chevauche-t-il un obstacle a cette position ?
virtual bool overlaps(const BodyCylinder& body) const = 0;
};
// Deplace un corps d'une position CONNUE LIBRE vers une position desiree, en
// respectant les obstacles. C'est le point d'entree unique de la collision : la
// camera et les tests passent tous les deux par ici, donc ils exercent
// exactement la meme logique.
//
// Pourquoi le repli sur la position precedente : le repoussement seul peut
// FAIRE PASSER le joueur au travers d'un passage plus etroit que lui. Chaque
// obstacle le repousse tour a tour, et la somme de ces poussees a une composante
// le long du passage : le joueur se retrouve extrude de l'autre cote, alors
// qu'il n'aurait jamais du pouvoir s'y engager. Verifier le resultat et refuser
// le deplacement quand il reste bloque supprime ce cas, et c'est la seule facon
// simple de le garantir avec un solveur par repoussement.
inline glm::vec3 moveBody(const CollisionSolver& solver, const BodyCylinder& desired,
const glm::vec3& previousPosition) {
const glm::vec3 pushed = solver.resolve(desired);
BodyCylinder probe = desired;
probe.position = pushed;
if (!solver.overlaps(probe)) {
return pushed;
}
// Le repoussement n'a pas trouve de place. On reste ou on etait, si tant est
// que ce soit encore libre.
probe.position = { previousPosition.x, desired.position.y, previousPosition.z };
if (!solver.overlaps(probe)) {
return probe.position;
}
// Meme l'ancienne position est occupee - typiquement un arbre plante sur le
// joueur, ou un obstacle apparu autour de lui. Le repoussement reste alors
// le moins mauvais choix : il l'ecarte au lieu de le laisser enfonce.
return pushed;
}
} // namespace vercora
+73
Voir le fichier
@@ -0,0 +1,73 @@
#pragma once
#include "core/CollisionSolver.hpp"
#include <vector>
namespace vercora {
// ---------------------------------------------------------------------------
// PHASE 15 : plusieurs sources d'obstacles, un seul solveur.
// ---------------------------------------------------------------------------
// Jusqu'ici le monde n'avait qu'UNE source d'obstacles - `world/Forest`, qui
// connait ses troncs et ses souches - et `Camera::setCollisionSolver` prenait
// donc un pointeur unique. L'editeur en ajoute une seconde (les objets poses),
// et il n'y a aucune raison de faire de la Forest le proprietaire de rochers
// qu'elle n'a pas semes.
//
// D'ou ce composite : il implemente le meme contrat `CollisionSolver` et le
// delegue a une liste. La camera, le velo et le grimpeur continuent de ne voir
// qu'un seul solveur - AUCUN des trois n'a ete modifie pour la Phase 15, et
// c'est precisement ce que l'interface de la Phase 6 permettait.
//
// SEMANTIQUE DE `resolve` : les repoussements sont CHAINES, pas moyennes. Le
// resultat du premier solveur devient la position soumise au deuxieme, et ainsi
// de suite. C'est le comportement correct pour un solveur par repoussement -
// sortir d'un tronc peut faire entrer dans un rocher, et il faut alors sortir du
// rocher aussi - et ca reste conforme au contrat : la fonction est totale, et un
// solveur qui n'a rien a dire rend la position telle quelle.
//
// Ce chainage ne garantit pas a lui seul une position libre (deux obstacles plus
// rapproches que le joueur n'en laissent aucune), mais ce n'etait deja pas le
// cas d'un solveur seul : c'est `moveBody()` qui verifie le resultat par
// `overlaps()` et refuse le deplacement le cas echeant. Rien ne change de ce
// cote, le composite repond simplement "oui" des qu'UN de ses membres chevauche.
//
// Les solveurs ne sont PAS possedes : ils doivent vivre plus longtemps que le
// composite. Un pointeur nul est ignore, ce qui evite a l'appelant de tester
// l'existence de chaque source avant de l'ajouter (la Forest n'existe pas sur
// une scene sans terrain, l'editeur pas encore charge, etc.).
class CompositeCollisionSolver : public CollisionSolver {
public:
void add(const CollisionSolver* solver) {
if (solver != nullptr) {
solvers_.push_back(solver);
}
}
void clear() { solvers_.clear(); }
std::size_t size() const { return solvers_.size(); }
glm::vec3 resolve(const BodyCylinder& body) const override {
BodyCylinder probe = body;
for (const CollisionSolver* solver : solvers_) {
probe.position = solver->resolve(probe);
}
return probe.position;
}
bool overlaps(const BodyCylinder& body) const override {
for (const CollisionSolver* solver : solvers_) {
if (solver->overlaps(body)) {
return true;
}
}
return false;
}
private:
std::vector<const CollisionSolver*> solvers_; // non possedes
};
} // namespace vercora
+45
Voir le fichier
@@ -0,0 +1,45 @@
#pragma once
namespace vercora {
// Compteur de FPS moyen sur une fenetre glissante d'un intervalle fixe.
//
// Pourquoi ne pas afficher 1/deltaTime a chaque frame : la valeur instantanee
// saute dans tous les sens (illisible), et changer le titre de la fenetre est un
// appel systeme qu'on ne veut pas payer 300 fois par seconde. On moyenne donc sur
// ~1 seconde et on ne signale une nouvelle valeur qu'a ce rythme.
class FpsCounter {
public:
explicit FpsCounter(float updateIntervalSeconds = 1.0f)
: updateInterval_(updateIntervalSeconds) {}
// A appeler une fois par frame, avec le meme deltaTime que la camera.
// Renvoie true quand une nouvelle valeur vient d'etre calculee (donc environ
// une fois par intervalle) : c'est le moment de rafraichir l'affichage.
bool update(float deltaTime) {
accumulatedTime_ += deltaTime;
++frameCount_;
if (accumulatedTime_ < updateInterval_) {
return false;
}
// Division sure : accumulatedTime_ >= updateInterval_ > 0 a ce point.
fps_ = static_cast<float>(frameCount_) / accumulatedTime_;
accumulatedTime_ = 0.0f;
frameCount_ = 0;
return true;
}
// Derniere valeur calculee (0 tant que le premier intervalle n'est pas ecoule).
float fps() const { return fps_; }
private:
float updateInterval_;
float accumulatedTime_ = 0.0f;
int frameCount_ = 0;
float fps_ = 0.0f;
};
} // namespace vercora
+95
Voir le fichier
@@ -0,0 +1,95 @@
#pragma once
#include <glm/glm.hpp>
#include <array>
namespace vercora {
// Les six plans du tronc de vision de la camera, extraits d'une matrice
// view-projection, plus le test "cette boite est-elle potentiellement visible".
//
// PHASE 10. Header-only et ne dependant que de GLM, comme HeightSampler : le
// culling doit pouvoir etre teste SANS GPU ni Vulkan (tests/logic_tests.cpp), et
// il n'a besoin de rien d'autre qu'une matrice.
//
// Methode : Gribb-Hartmann. Un point p est a l'interieur du volume de clipping
// si -w <= x <= w (idem y) et 0 <= z <= w apres transformation. Chacune de ces
// six inegalites, reecrite en fonction de p en espace MONDE, est exactement un
// plan dont les coefficients sont une combinaison de LIGNES de la matrice.
// (0 <= z et non -w <= z : GLM_FORCE_DEPTH_ZERO_TO_ONE est actif - convention
// Vulkan - et prendre la convention OpenGL ici donnerait un plan proche FAUX,
// deux fois trop loin devant la camera.)
//
// Attention aux conventions GLM : m[c][r], donc la ligne i vaut
// (m[0][i], m[1][i], m[2][i], m[3][i]) et non m[i].
struct Frustum {
// Chaque plan est (nx, ny, nz, d) avec la normale dirigee vers l'INTERIEUR :
// dot(n, p) + d >= 0 <=> p est du bon cote.
std::array<glm::vec4, 6> planes{};
static Frustum fromViewProjection(const glm::mat4& viewProj) {
const glm::vec4 row0(viewProj[0][0], viewProj[1][0], viewProj[2][0], viewProj[3][0]);
const glm::vec4 row1(viewProj[0][1], viewProj[1][1], viewProj[2][1], viewProj[3][1]);
const glm::vec4 row2(viewProj[0][2], viewProj[1][2], viewProj[2][2], viewProj[3][2]);
const glm::vec4 row3(viewProj[0][3], viewProj[1][3], viewProj[2][3], viewProj[3][3]);
Frustum frustum;
frustum.planes[0] = row3 + row0; // gauche : x >= -w
frustum.planes[1] = row3 - row0; // droite : x <= w
frustum.planes[2] = row3 + row1; // bas : y >= -w
frustum.planes[3] = row3 - row1; // haut : y <= w
frustum.planes[4] = row2; // proche : z >= 0 (convention Vulkan)
frustum.planes[5] = row3 - row2; // lointain: z <= w
for (glm::vec4& plane : frustum.planes) {
const float length = glm::length(glm::vec3(plane));
// Une matrice degeneree (projection non initialisee) donnerait une
// normale nulle : on laisse le plan tel quel plutot que de diviser
// par zero. Le test ci-dessous devient alors permissif, ce qui est
// le bon repli - on prefere dessiner en trop que faire disparaitre
// le terrain.
if (length > 1e-8f) {
plane /= length;
}
}
return frustum;
}
// Test CONSERVATEUR boite-alignee / tronc de vision : renvoie false
// seulement si la boite est entierement du mauvais cote d'un des plans.
//
// Conservateur dans le bon sens : une boite tout juste hors champ peut etre
// declaree visible (on dessine pour rien, c'est benin), mais une boite
// visible n'est JAMAIS declaree invisible - ce serait un trou dans le
// terrain. Le cas classique "boite hors champ mais dans le mauvais cote
// d'aucun plan a elle seule" (coin du tronc) est accepte volontairement :
// le corriger demanderait un test plus couteux pour un gain nul a notre
// nombre de noeuds.
bool intersectsAABB(const glm::vec3& boxMin, const glm::vec3& boxMax) const {
for (const glm::vec4& plane : planes) {
// Sommet "positif" : celui de la boite le plus avance dans la
// direction de la normale. Si LUI est derriere le plan, les huit
// le sont.
const glm::vec3 positive(plane.x >= 0.0f ? boxMax.x : boxMin.x,
plane.y >= 0.0f ? boxMax.y : boxMin.y,
plane.z >= 0.0f ? boxMax.z : boxMin.z);
if (glm::dot(glm::vec3(plane), positive) + plane.w < 0.0f) {
return false;
}
}
return true;
}
};
// Distance du point au pave aligne le plus proche (0 si le point est dedans).
// Sert a la selection de LOD : c'est le "a quelle distance suis-je de ce
// morceau de terrain", et non la distance a son centre - laquelle donnerait un
// niveau de detail trop grossier pour une grande tuile dont on rase le bord.
inline float distanceToAABB(const glm::vec3& point,
const glm::vec3& boxMin, const glm::vec3& boxMax) {
const glm::vec3 clamped = glm::clamp(point, boxMin, boxMax);
return glm::length(point - clamped);
}
} // namespace vercora
+23
Voir le fichier
@@ -0,0 +1,23 @@
#pragma once
namespace vercora {
// Ce que la camera a besoin de savoir d'un terrain pour "marcher" dessus :
// une hauteur en fonction d'une position horizontale, rien de plus.
//
// L'interface existe pour que core/Camera ne depende PAS de assets/Heightmap
// (ni, demain, du futur terrain LiDAR streame par tuiles) : la camera consomme
// ce contrat, l'implementation vit du cote des donnees.
class HeightSampler {
public:
virtual ~HeightSampler() = default;
// Altitude (Y monde) de la surface a la position horizontale (worldX, worldZ).
// Contrat : la fonction est TOTALE - hors du domaine couvert par les donnees,
// l'implementation doit renvoyer la hauteur du point valide le plus proche
// plutot que d'echouer. Une camera ne doit jamais tomber dans le vide parce
// qu'elle a depasse le bord d'une tuile.
virtual float heightAt(float worldX, float worldZ) const = 0;
};
} // namespace vercora
+28
Voir le fichier
@@ -0,0 +1,28 @@
#pragma once
#include <iostream>
#include <string>
#include <string_view>
namespace vercora {
// Logger minimaliste pour la Phase 0. On garde ca volontairement simple :
// pas de dependance externe, sortie sur stdout/stderr.
enum class LogLevel { Info, Warn, Error };
inline void log(LogLevel level, std::string_view message) {
const char* prefix = "[INFO] ";
std::ostream* out = &std::cout;
switch (level) {
case LogLevel::Info: prefix = "[INFO] "; out = &std::cout; break;
case LogLevel::Warn: prefix = "[WARN] "; out = &std::cerr; break;
case LogLevel::Error: prefix = "[ERROR] "; out = &std::cerr; break;
}
(*out) << prefix << message << std::endl;
}
inline void logInfo(std::string_view msg) { log(LogLevel::Info, msg); }
inline void logWarn(std::string_view msg) { log(LogLevel::Warn, msg); }
inline void logError(std::string_view msg) { log(LogLevel::Error, msg); }
} // namespace vercora
+83
Voir le fichier
@@ -0,0 +1,83 @@
#include "core/Paths.hpp"
#include <filesystem>
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
#else
# include <unistd.h>
#endif
namespace vercora {
namespace {
// Chemin complet de l'executable, ou chaine vide si indisponible.
std::string readExePath() {
#ifdef _WIN32
// MAX_PATH ne suffit pas toujours (chemins longs actives) : on agrandit
// tant que l'API dit que le tampon est trop petit. GetModuleFileNameW ne
// termine PAS par zero en cas de troncature avant Windows 10, d'ou le test
// sur la taille plutot que sur le contenu.
std::wstring buffer(MAX_PATH, L'\0');
for (;;) {
const DWORD written = ::GetModuleFileNameW(nullptr, buffer.data(),
static_cast<DWORD>(buffer.size()));
if (written == 0) {
return {};
}
if (written < buffer.size()) {
buffer.resize(written);
return std::filesystem::path(buffer).string();
}
if (buffer.size() > 65536) {
return {}; // garde-fou : quelque chose ne va pas, on abandonne.
}
buffer.resize(buffer.size() * 2);
}
#else
std::error_code error;
const std::filesystem::path self =
std::filesystem::read_symlink("/proc/self/exe", error);
return error ? std::string{} : self.string();
#endif
}
// Applique la regle documentee dans Paths.hpp : le sous-dossier `name` a cote de
// l'executable s'il existe, sinon `fallback` (la macro CMake).
std::string resolveDataDir(const char* name, const char* fallback) {
const std::string& exe = exeDir();
if (!exe.empty()) {
const std::filesystem::path candidate = std::filesystem::path(exe) / name;
std::error_code error;
if (std::filesystem::is_directory(candidate, error)) {
return candidate.string();
}
}
return fallback;
}
} // namespace
const std::string& exeDir() {
static const std::string cached = [] {
const std::string path = readExePath();
if (path.empty()) {
return std::string{};
}
return std::filesystem::path(path).parent_path().string();
}();
return cached;
}
const std::string& assetsDir() {
static const std::string cached = resolveDataDir("assets", ASSETS_DIR);
return cached;
}
const std::string& shadersDir() {
static const std::string cached = resolveDataDir("shaders", SHADERS_OUTPUT_DIR);
return cached;
}
} // namespace vercora
+39
Voir le fichier
@@ -0,0 +1,39 @@
#pragma once
#include <string>
namespace vercora {
// ---------------------------------------------------------------------------
// Ou l'executable trouve ses donnees (PHASE 21)
// ---------------------------------------------------------------------------
// Jusqu'ici, deux macros definies par CMake - ASSETS_DIR et SHADERS_OUTPUT_DIR -
// portaient des chemins ABSOLUS vers l'arborescence de developpement. C'est
// exactement ce qu'il fallait pour developper (l'executable trouve ses assets
// depuis n'importe quel repertoire courant) et exactement ce qui rend le binaire
// INDISTRIBUABLE : sur une autre machine, ces chemins ne designent rien.
//
// La regle appliquee ici, dans cet ordre :
// 1. le dossier a COTE DE L'EXECUTABLE, s'il existe -> cas du package ;
// 2. sinon la macro CMake -> cas du developpement, comportement inchange.
//
// Les deux cas coexistent donc sans commutateur : un vercora.exe compile ici et
// lance depuis build\ continue de lire assets\ a la racine du depot, et le meme
// binaire copie dans un dossier qui contient assets\ lit celui-la. C'est ce qui
// permet de TESTER le package sans build special (voir NOTES-PHASE21.md).
//
// Les chemins sont resolus une fois et memorises : la resolution appelle le
// systeme et touche le disque, et elle est interrogee a chaque chargement de
// dalle.
// Dossier de l'executable en cours, sans separateur final. Chaine vide si le
// systeme refuse de le donner - les appelants retombent alors sur la macro.
const std::string& exeDir();
// Dossier des donnees ("assets"), sans separateur final.
const std::string& assetsDir();
// Dossier des shaders SPIR-V compiles ("shaders"), sans separateur final.
const std::string& shadersDir();
} // namespace vercora
+229
Voir le fichier
@@ -0,0 +1,229 @@
#pragma once
#include "core/HeightSampler.hpp"
#include <glm/glm.hpp>
#include <algorithm>
#include <cmath>
namespace vercora {
// ===========================================================================
// PHASE 24 - LES DEUX SEUILS DE PENTE DU JEU, EN UN SEUL ENDROIT.
// ===========================================================================
//
// Jusqu'ici la marche (core/Camera, mode Walk) n'avait AUCUNE limite de pente :
// un versant a 90 %, voire une paroi a 300 %, se montait debout a 14 m/s. Ce
// n'etait pas seulement irrealiste, ca rendait l'escalade FACULTATIVE - une
// activite entiere que rien n'obligeait jamais a employer, puisque la marche
// passait partout.
//
// Les valeurs sont en RISE PAR METRE HORIZONTAL, la meme unite que
// ClimberParams et BikeParams (1,00 = 45 degres = 100 %).
//
// --- kWalkComfortSlope : 0,60 (31 degres) ----------------------------------
//
// Pente au-dela de laquelle on ne marche plus a pleine vitesse. Ce n'est PAS
// une valeur neuve : c'est exactement ClimberParams::walkableSlope, deja
// justifiee en Phase 14 comme "la pente au-dela de laquelle un sentier de
// montagne ne se fait plus debout de facon soutenue", et deja employee par
// tools/find_climb_walls.py pour juger si une paroi a un pied abordable. Les
// trois DOIVENT rester d'accord, d'ou la constante partagee.
//
// --- kWalkMaxSlope : 0,84 (40 degres) --------------------------------------
//
// Pente au-dela de laquelle on ne progresse plus du tout debout. La consigne
// etait de choisir entre le seuil de marche libre (0,60) et le seuil de paroi
// de Climber (1,00) ; voici pourquoi 0,84 et pas autre chose :
//
// 1. C'est la BORNE HAUTE DE L'ANGLE DE REPOS des materiaux meubles (35 a 40
// degres, soit 70 a 84 %), la meme grandeur physique que la Phase 14
// invoquait deja pour placer wallSlope. Au-dessus, un versant de ce massif
// ne retient ni terre ni eboulis : il n'y a plus de sol sous les pieds,
// seulement du rocher. C'est litteralement la pente maximale a laquelle il
// existe encore quelque chose sur quoi se tenir.
// 2. Ca laisse INTACTE la randonnee raide. Un sentier de montagne soutenu vit
// entre 0,30 et 0,60 ; les raidillons ponctuels montent a 0,70 - 0,80.
// Tout ca continue de passer, ralenti mais franchissable. Ce qui est
// refuse commence la ou un randonneur reel met les mains.
// 3. Ca ne ferme pas le terrain. La distribution des pentes de la zone de jeu
// (25 millions d'echantillons, tools/find_climb_walls.py) donne p75 =
// 65,7 % et p90 = 92,4 % : le seuil tombe entre les deux, et interdit donc
// de l'ordre de 13 % du massif a la marche - assez pour que le relief
// compte, pas assez pour qu'on soit constamment arrete.
//
// --- LE POINT LE PLUS IMPORTANT : PAS DE TROU ENTRE LES DEUX ACTIVITES -----
//
// ClimberParams::wallSlope vaut kWalkMaxSlope, la MEME constante, et ce n'est
// pas une coincidence de reglage : c'est le contrat. Si le seuil d'entree en
// escalade etait plus haut que la limite de marche - ce qu'il etait, 1,00
// contre 0,84 - il existerait une bande de pentes ou le joueur ne pourrait NI
// marcher NI grimper. Sur cette zone de jeu la bande [0,84 ; 1,00[ represente
// environ 5 % du massif : ce n'est pas un cas theorique, c'est un versant sur
// vingt. Faire des deux seuils une seule constante rend ce trou impossible a
// reintroduire par un reglage distrait.
//
// L'hysteresis de SORTIE d'escalade reste, elle, a kWalkComfortSlope (0,60),
// strictement en dessous : c'est elle qui empeche le mode escalade de battre a
// chaque frame sur une paroi reelle, qui oscille autour de son seuil.
inline constexpr float kWalkComfortSlope = 0.60f;
inline constexpr float kWalkMaxSlope = 0.84f;
struct WalkSlopeParams {
float comfortSlope = kWalkComfortSlope;
float maxSlope = kWalkMaxSlope;
// Demi-base des differences finies centrees, en m : la pente est lue sur
// 2 x sampleStep. MEME VALEUR ET MEME RAISON que BikeParams (Phase 13) et
// ClimberParams (Phase 14) : au pas de 1 m de la heightmap, le bruit
// decimetrique d'un DTM LiDAR fabrique 8 % de micro-sections en
// contre-pente et, ici, fabriquerait des murs invisibles en pleine prairie.
float sampleStep = 2.0f;
// Vitesse de glissade, en m/s PAR UNITE DE PENTE EN EXCES au-dela de
// maxSlope. A 100 % de pente l'exces vaut 0,16, donc 0,48 m/s : on decolle
// doucement. A 200 % il vaut 1,16, donc 3,5 m/s : on devale.
float slideSpeed = 3.0f;
// Plafond de la glissade, en m/s. Sans lui, une paroi a 3000 % - il y en a
// sur cette dalle, max mesure 5018 % - ejecterait le joueur a 150 m/s.
float slideSpeedMax = 6.0f;
};
// Gradient du terrain en (worldX, worldZ), par differences finies CENTREES.
// Pointe vers la MONTEE. Symetrique, donc le meme versant a la meme pente
// qu'on l'aborde par la gauche ou par la droite.
inline glm::vec2 walkTerrainGradient(const HeightSampler& terrain, float worldX,
float worldZ, float sampleStep) {
const float s = sampleStep;
const float hxPlus = terrain.heightAt(worldX + s, worldZ);
const float hxMinus = terrain.heightAt(worldX - s, worldZ);
const float hzPlus = terrain.heightAt(worldX, worldZ + s);
const float hzMinus = terrain.heightAt(worldX, worldZ - s);
return glm::vec2((hxPlus - hxMinus) / (2.0f * s), (hzPlus - hzMinus) / (2.0f * s));
}
// Norme de la pente en (worldX, worldZ), en rise par metre horizontal.
inline float walkTerrainSlope(const HeightSampler& terrain, float worldX,
float worldZ, float sampleStep) {
const glm::vec2 g = walkTerrainGradient(terrain, worldX, worldZ, sampleStep);
return std::sqrt(g.x * g.x + g.y * g.y);
}
// Fraction de la vitesse de marche encore disponible sur une pente donnee :
// 1 jusqu'a comfortSlope, puis DECROISSANCE LINEAIRE jusqu'a 0 a maxSlope.
//
// Pourquoi une rampe et non un mur : un blocage sec a 0,84 serait exactement le
// "mur invisible incomprehensible" qu'il fallait eviter. Avec la rampe, le
// joueur SENT le terrain se durcir bien avant d'etre arrete - a 0,72, soit a
// mi-chemin, il n'avance deja plus qu'a moitie - et l'arret, quand il vient,
// est la fin d'un mouvement continu au lieu d'un evenement.
inline float walkSpeedFactor(float slope, const WalkSlopeParams& params) {
if (slope <= params.comfortSlope) {
return 1.0f;
}
if (slope >= params.maxSlope) {
return 0.0f;
}
const float span = params.maxSlope - params.comfortSlope;
if (span <= 0.0f) {
return 0.0f; // reglage degenere : on prefere refuser que diviser par zero
}
return 1.0f - (slope - params.comfortSlope) / span;
}
// Resultat d'un pas de marche filtre par la pente. Tout est HORIZONTAL : la
// verticale appartient au terrain (Camera::snapToTerrain), et la reprendre ici
// ferait lutter deux regles l'une contre l'autre.
struct WalkStepResult {
glm::vec3 position{0.0f}; // position horizontale retenue (y inchange)
float slopeUnderFoot = 0.0f; // pente au point de DEPART
float slopeAhead = 0.0f; // pente au point VISE
float speedFactor = 1.0f; // fraction de vitesse accordee au pas
bool sliding = false; // le joueur ne tient plus debout et devale
};
// Filtre un pas de marche par la pente du terrain.
//
// from : position horizontale de depart (y ignore et rendu tel quel)
// desiredStep : le pas que le clavier demandait, deja multiplie par dt
// deltaTime : necessaire a la glissade, qui est une VITESSE et non un pas
//
// TROIS REGLES, dans cet ordre :
//
// 1. La vitesse accordee est celle de la pente AU POINT VISE, pas au point de
// depart. C'est ce qui fait qu'on s'arrete AU PIED d'une paroi au lieu d'y
// entrer d'abord puis d'y etre coince : le pas qui mettrait le joueur sur
// du trop raide est refuse tant qu'il est encore sur du marchable.
// 2. Seule la composante VERS L'AMONT est facturee. Redescendre est toujours
// accorde, a pleine vitesse. Sans cette dissymetrie, un joueur pose sur du
// trop raide serait fige - le "blocage brutal frustrant" - au lieu de
// pouvoir simplement revenir sur ses pas.
// 3. Au-dela de maxSlope sous les pieds, le joueur GLISSE vers l'aval, a une
// vitesse proportionnelle a l'exces de pente. C'est la regle qui garantit
// qu'aucune position du monde n'est un piege : ou qu'on le depose, le
// joueur finit par redescendre tout seul jusqu'a du terrain marchable.
inline WalkStepResult resolveWalkStep(const HeightSampler& terrain,
const glm::vec3& from,
const glm::vec3& desiredStep, float deltaTime,
const WalkSlopeParams& params) {
constexpr float kEpsilon = 1e-6f;
WalkStepResult result;
result.position = from;
const glm::vec2 gradient =
walkTerrainGradient(terrain, from.x, from.z, params.sampleStep);
result.slopeUnderFoot = std::sqrt(gradient.x * gradient.x + gradient.y * gradient.y);
// Direction de la plus grande pente, vers le HAUT, dans le plan horizontal.
glm::vec3 uphill(0.0f);
if (result.slopeUnderFoot > kEpsilon) {
uphill = glm::vec3(gradient.x / result.slopeUnderFoot, 0.0f,
gradient.y / result.slopeUnderFoot);
}
glm::vec3 step(desiredStep.x, 0.0f, desiredStep.z);
const float stepLength = std::sqrt(step.x * step.x + step.z * step.z);
if (stepLength > kEpsilon) {
const glm::vec3 target = from + step;
result.slopeAhead =
walkTerrainSlope(terrain, target.x, target.z, params.sampleStep);
result.speedFactor = walkSpeedFactor(result.slopeAhead, params);
// Decomposition amont / lateral. Note : quand le terrain est
// strictement plat, uphill est nul, donc `along` l'est aussi et tout le
// pas part dans `lateral` - qui est alors accorde en entier puisque
// speedFactor vaut 1. Le cas degenere se traite donc tout seul.
const float along = step.x * uphill.x + step.z * uphill.z;
const glm::vec3 lateral = step - uphill * along;
// La composante amont est facturee ; la composante aval passe entiere.
const float allowedAlong = (along > 0.0f) ? along * result.speedFactor : along;
// Le lateral est facture lui aussi : traverser une pente a 80 % en
// devers est aussi difficile que la monter, et laisser le lateral libre
// permettrait de gagner de la hauteur en zigzag a pleine vitesse, ce qui
// annulerait la limite qu'on vient de poser.
result.position = from + uphill * allowedAlong + lateral * result.speedFactor;
} else {
result.slopeAhead = result.slopeUnderFoot;
result.speedFactor = walkSpeedFactor(result.slopeUnderFoot, params);
}
// --- Glissade ------------------------------------------------------------
if (result.slopeUnderFoot > params.maxSlope && result.slopeUnderFoot > kEpsilon &&
deltaTime > 0.0f) {
result.sliding = true;
const float excess = result.slopeUnderFoot - params.maxSlope;
const float speed = std::min(params.slideSpeed * excess, params.slideSpeedMax);
result.position -= uphill * (speed * deltaTime);
}
result.position.y = from.y;
return result;
}
} // namespace vercora
+169
Voir le fichier
@@ -0,0 +1,169 @@
#pragma once
#include "core/HeightSampler.hpp"
#include <glm/glm.hpp>
#include <algorithm>
#include <cmath>
namespace vercora {
// ---------------------------------------------------------------------------
// PHASE 15 : intersection d'un rayon avec la SURFACE du terrain.
// ---------------------------------------------------------------------------
// Ce que la Phase 5 avait deja, et pourquoi ca ne suffisait pas ici :
// `Forest::pickTree` intersecte un rayon avec des CYLINDRES (les troncs), ce qui
// est un probleme analytique a solution fermee. La surface du terrain, elle,
// n'est pas une primitive : c'est une grille bilineaire de plusieurs millions de
// cellules. Il n'y a pas de formule, on MARCHE le long du rayon.
//
// L'editeur en a besoin pour la raison la plus directe qui soit : "poser l'objet
// a la position exacte visee" veut dire savoir OU le regard rencontre le sol.
// C'est aussi ce qui manquait a toute idee de curseur monde (marqueur de voie,
// mesure de distance, previsualisation d'abattage) - d'ou le placement dans
// core/ a cote de HeightSampler, et non dans editor/ : la fonction ne connait
// que le contrat d'echantillonnage, elle est reutilisable telle quelle.
//
// ALGORITHME. Marche a pas CROISSANT puis dichotomie :
//
// 1. on avance le long du rayon en surveillant le signe de
// `hauteurDuRayon - hauteurDuTerrain` ;
// 2. des que le signe s'inverse, la surface a ete traversee entre le pas
// precedent et le pas courant : 24 iterations de dichotomie ramenent
// l'incertitude a maxDistance / 2^24, soit moins d'un dixieme de millimetre
// sur 1 km.
//
// Le pas CROIT avec la distance (geometriquement, jusqu'a un plafond) pour une
// raison de cout : pres de l'oeil il faut de la finesse - un pas de 8 m
// traverserait un rocher entier sans le voir - alors qu'a 400 m un pas de 8 m ne
// represente que quelques pixels a l'ecran. Un pas constant assez fin pour le
// proche couterait des milliers d'echantillons par frame ; celui-ci en demande
// ~150 pour 400 m, soit une poignee de microsecondes.
//
// LIMITE ASSUMEE, a connaitre avant de s'en servir ailleurs : une marche a pas
// fini peut ENJAMBER une arete plus fine que le pas courant (une crete
// rocheuse vue de loin et par-dessus). Le rayon ressort alors "sous" le relief
// et l'intersection trouvee est plus loin qu'elle ne devrait. Pour l'usage
// editeur ce n'est pas genant - on vise ce qu'on voit, donc de pres - et le
// remede exact (parcours cellule par cellule facon DDA sur la grille) exigerait
// de connaitre la grille elle-meme, donc de renoncer a l'interface
// HeightSampler. C'est le compromis retenu.
//
// SECOND POINT IMPORTANT : `HeightSampler::heightAt` est TOTALE par contrat -
// hors des donnees elle renvoie la hauteur du bord le plus proche. Un rayon qui
// part vers l'exterieur "toucherait" donc une etagere plate infinie. D'ou
// `halfExtent` : au-dela de cette demi-emprise horizontale, le rayon est
// considere comme sorti du monde et ne touche RIEN. Passer 0 desactive le
// controle (terrain sans bord connu).
struct TerrainRayHit {
// true si le rayon rencontre la surface dans les limites demandees.
bool hit = false;
// Point d'intersection en coordonnees monde.
glm::vec3 position{0.0f};
// Distance parcourue depuis l'origine du rayon, en unites monde (= metres).
float distance = 0.0f;
};
// Normale approchee de la surface en (worldX, worldZ), par differences CENTREES
// sur une base de `sampleStep` metres de part et d'autre.
//
// La base par defaut est de 2 m (donc 4 m d'un bord a l'autre) et ce n'est pas
// un chiffre en l'air : c'est celle que la Phase 13 a du adopter pour le velo,
// apres avoir mesure qu'au pas de 1 m - le pas de la heightmap - le bruit
// decimetrique d'un DTM LiDAR fait lire 8 % d'une VRAIE descente en contre-pente.
// Une normale calculee sur 1 m serait tout aussi bruitee, et un objet pose
// dessus tressauterait d'un metre a l'autre sans raison visible.
inline glm::vec3 terrainNormalAt(const HeightSampler& terrain, float worldX, float worldZ,
float sampleStep = 2.0f) {
const float dydx = (terrain.heightAt(worldX + sampleStep, worldZ) -
terrain.heightAt(worldX - sampleStep, worldZ)) /
(2.0f * sampleStep);
const float dydz = (terrain.heightAt(worldX, worldZ + sampleStep) -
terrain.heightAt(worldX, worldZ - sampleStep)) /
(2.0f * sampleStep);
// La surface est le graphe y = h(x, z) ; sa normale sortante est
// (-dh/dx, 1, -dh/dz), normalisee.
return glm::normalize(glm::vec3(-dydx, 1.0f, -dydz));
}
// Intersection rayon / surface. `direction` doit etre normalisee.
inline TerrainRayHit raycastTerrain(const HeightSampler& terrain,
const glm::vec3& origin,
const glm::vec3& direction,
float maxDistance,
float halfExtent = 0.0f,
float firstStep = 0.5f,
float maxStep = 8.0f,
float stepGrowth = 1.02f) {
TerrainRayHit result;
if (!(maxDistance > 0.0f)) {
return result;
}
const auto outside = [&](const glm::vec3& p) {
return halfExtent > 0.0f &&
(std::abs(p.x) > halfExtent || std::abs(p.z) > halfExtent);
};
// Signe de depart. Si l'oeil est DEJA sous la surface (on est dans le
// relief - ca arrive en mode vol libre ou apres un repli de collision), on
// ne peut pas raisonner par changement de signe : le premier point est deja
// "dedans". On rend alors le point de depart projete sur la surface, ce qui
// est le comportement utile - l'objet se pose la ou on est.
const float startClearance = origin.y - terrain.heightAt(origin.x, origin.z);
if (startClearance <= 0.0f && !outside(origin)) {
result.hit = true;
result.position = { origin.x, terrain.heightAt(origin.x, origin.z), origin.z };
result.distance = 0.0f;
return result;
}
float previousT = 0.0f;
float step = std::max(firstStep, 1e-3f);
for (float t = 0.0f; t < maxDistance;) {
t = std::min(t + step, maxDistance);
step = std::min(step * stepGrowth, maxStep);
const glm::vec3 point = origin + direction * t;
if (outside(point)) {
// Sorti de l'emprise : tout ce qui suit est hors donnees. On
// n'accroche PAS l'etagere plate que renverrait heightAt.
return result;
}
const float clearance = point.y - terrain.heightAt(point.x, point.z);
if (clearance <= 0.0f) {
// Traversee entre previousT (au-dessus) et t (au-dessous).
float low = previousT;
float high = t;
for (int i = 0; i < 24; ++i) {
const float mid = 0.5f * (low + high);
const glm::vec3 probe = origin + direction * mid;
if (probe.y - terrain.heightAt(probe.x, probe.z) > 0.0f) {
low = mid;
} else {
high = mid;
}
}
result.hit = true;
result.distance = high;
const glm::vec3 point3 = origin + direction * high;
// On REPOSE le point sur la surface plutot que de garder le point
// du rayon : la dichotomie s'arrete a un cheveu au-dessous, et un
// objet pose la s'enfoncerait visiblement d'autant.
result.position = { point3.x, terrain.heightAt(point3.x, point3.z), point3.z };
return result;
}
previousT = t;
}
return result;
}
} // namespace vercora
+95
Voir le fichier
@@ -0,0 +1,95 @@
#include "core/Window.hpp"
#include <stdexcept>
namespace vercora {
Window::Window(int width, int height, std::string title) {
if (glfwInit() != GLFW_TRUE) {
throw std::runtime_error("Echec de l'initialisation de GLFW.");
}
// Pas de contexte OpenGL : on gere le rendu nous-memes via Vulkan.
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
window_ = glfwCreateWindow(width, height, title.c_str(), nullptr, nullptr);
if (window_ == nullptr) {
glfwTerminate();
throw std::runtime_error("Echec de la creation de la fenetre GLFW.");
}
// Permet de retrouver l'instance Window depuis le callback C de GLFW.
glfwSetWindowUserPointer(window_, this);
glfwSetFramebufferSizeCallback(window_, framebufferResizeCallback);
glfwSetScrollCallback(window_, scrollCallback);
}
Window::~Window() {
if (window_ != nullptr) {
glfwDestroyWindow(window_);
}
glfwTerminate();
}
bool Window::shouldClose() const {
return glfwWindowShouldClose(window_) == GLFW_TRUE;
}
void Window::pollEvents() const {
glfwPollEvents();
}
void Window::waitEvents() const {
glfwWaitEvents();
}
void Window::setTitle(const std::string& title) const {
glfwSetWindowTitle(window_, title.c_str());
}
VkSurfaceKHR Window::createSurface(VkInstance instance) const {
VkSurfaceKHR surface = VK_NULL_HANDLE;
if (glfwCreateWindowSurface(instance, window_, nullptr, &surface) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation de la surface Vulkan.");
}
return surface;
}
void Window::getFramebufferSize(int& width, int& height) const {
glfwGetFramebufferSize(window_, &width, &height);
}
bool Window::isKeyPressed(int key) const {
return glfwGetKey(window_, key) == GLFW_PRESS;
}
bool Window::isMouseButtonPressed(int button) const {
return glfwGetMouseButton(window_, button) == GLFW_PRESS;
}
void Window::getCursorPos(double& x, double& y) const {
glfwGetCursorPos(window_, &x, &y);
}
double Window::consumeScroll() {
const double accumulated = scrollAccumulator_;
scrollAccumulator_ = 0.0;
return accumulated;
}
void Window::framebufferResizeCallback(GLFWwindow* window, int /*width*/, int /*height*/) {
auto* self = static_cast<Window*>(glfwGetWindowUserPointer(window));
if (self != nullptr) {
self->framebufferResized_ = true;
}
}
void Window::scrollCallback(GLFWwindow* window, double /*xOffset*/, double yOffset) {
auto* self = static_cast<Window*>(glfwGetWindowUserPointer(window));
if (self != nullptr) {
self->scrollAccumulator_ += yOffset;
}
}
} // namespace vercora
+69
Voir le fichier
@@ -0,0 +1,69 @@
#pragma once
// GLFW_INCLUDE_VULKAN est defini par CMake : GLFW tire alors les headers Vulkan.
#include <GLFW/glfw3.h>
#include <string>
namespace vercora {
// Encapsule la fenetre GLFW et l'init/terminate de la bibliotheque.
// Cross-platform : aucune API Win32/X11 directe n'est utilisee ici.
class Window {
public:
Window(int width, int height, std::string title);
~Window();
Window(const Window&) = delete;
Window& operator=(const Window&) = delete;
bool shouldClose() const;
void pollEvents() const;
// Bloque tant que la fenetre est minimisee (taille 0). Utilise lors du resize.
void waitEvents() const;
// Change le titre affiche (utilise pour le compteur de FPS).
void setTitle(const std::string& title) const;
// Cree la surface Vulkan associee a cette fenetre (VK_KHR_surface).
VkSurfaceKHR createSurface(VkInstance instance) const;
// Taille reelle du framebuffer en pixels (peut differer de la taille logique
// sur ecrans HiDPI).
void getFramebufferSize(int& width, int& height) const;
bool wasResized() const { return framebufferResized_; }
void resetResizedFlag() { framebufferResized_ = false; }
// --- Entrees (utilisees par la camera) ---
// 'key' / 'button' sont des constantes GLFW (GLFW_KEY_*, GLFW_MOUSE_BUTTON_*).
bool isKeyPressed(int key) const;
bool isMouseButtonPressed(int button) const;
void getCursorPos(double& x, double& y) const;
// PHASE 15. Crans de molette accumules depuis le dernier appel, puis remis a
// zero. Positif = vers l'avant.
//
// ACCUMULE et non lu a la demande, parce que la molette est le seul peripherique
// du jeu qui n'a pas d'etat : GLFW n'offre aucun `glfwGetScroll()` equivalent a
// `glfwGetKey()`, il n'y a que des EVENEMENTS. Un cran survenu entre deux images
// serait donc simplement perdu si on ne le retenait pas.
//
// La lecture est destructive (d'ou "consume") : deux appelants dans la meme image
// se voleraient les crans l'un a l'autre. Il n'y en a qu'un, l'editeur, et c'est
// volontaire - la molette n'a aucun role dans le jeu normal.
double consumeScroll();
GLFWwindow* handle() const { return window_; }
private:
static void framebufferResizeCallback(GLFWwindow* window, int width, int height);
static void scrollCallback(GLFWwindow* window, double xOffset, double yOffset);
GLFWwindow* window_ = nullptr;
bool framebufferResized_ = false;
double scrollAccumulator_ = 0.0;
};
} // namespace vercora
+240
Voir le fichier
@@ -0,0 +1,240 @@
#include "editor/AssetCatalog.hpp"
#include "assets/ObjLoader.hpp"
#include "core/Logger.hpp"
#include "editor/EditorAssets.hpp"
#include <algorithm>
#include <cctype>
#include <cmath>
#include <exception>
#include <filesystem>
#include <limits>
#include <sstream>
namespace vercora {
namespace {
// Garde-fous de taille, en unites monde (= metres). Un modele hors de ces bornes
// n'est pas refuse - il peut etre volontaire - mais il est SIGNALE.
//
// Raison d'etre : la premiere cause d'un asset "invisible" ou "gigantesque" a
// l'import est une unite differente (un .obj exporte en centimetres est 100 fois
// trop grand, un .obj en pouces 39 fois). Sans ce message, le symptome observe
// est "j'ai pose un rocher et je ne le vois pas", et on va chercher le defaut
// dans le placement ou le rendu, jamais dans le fichier.
constexpr float kSuspiciouslySmall = 0.05f;
constexpr float kSuspiciouslyLarge = 200.0f;
std::string toLowerAscii(std::string text) {
for (char& c : text) {
c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
}
return text;
}
} // namespace
std::string sanitizeAssetId(const std::string& raw) {
std::string result;
result.reserve(raw.size());
for (const unsigned char c : raw) {
if (std::isalnum(c) != 0) {
result.push_back(static_cast<char>(std::tolower(c)));
} else if (c == '_' || c == '-' || c == '.') {
result.push_back(static_cast<char>(c));
} else {
result.push_back('_');
}
}
if (result.empty()) {
result = "asset";
}
return result;
}
void normalizeAssetMesh(MeshData& mesh) {
if (mesh.vertices.empty()) {
return;
}
glm::vec3 minCorner(std::numeric_limits<float>::max());
glm::vec3 maxCorner(std::numeric_limits<float>::lowest());
for (const Vertex& vertex : mesh.vertices) {
minCorner = glm::min(minCorner, vertex.pos);
maxCorner = glm::max(maxCorner, vertex.pos);
}
// X et Z : centre sur la boite. Y : pied a zero, PAS centre - c'est toute la
// convention d'ancrage (voir editor/EditorAssets.hpp).
const glm::vec3 shift(-0.5f * (minCorner.x + maxCorner.x),
-minCorner.y,
-0.5f * (minCorner.z + maxCorner.z));
if (glm::length(shift) < 1e-6f) {
return; // deja aligne : ne pas toucher aux valeurs, meme d'un ulp
}
for (Vertex& vertex : mesh.vertices) {
vertex.pos += shift;
// morphPos n'est PAS decale : il ne concerne que les tuiles du quadtree
// (Phase 10) et vaut zero sur toute autre geometrie, ou il est ignore
// parce que la bande de morphing du DrawItem est vide.
}
}
void computeAssetBounds(AssetEntry& entry) {
entry.collisionRadius = 0.0f;
entry.height = 0.0f;
entry.halfExtentX = 0.0f;
entry.halfExtentZ = 0.0f;
if (entry.mesh.vertices.empty()) {
return;
}
glm::vec3 minCorner(std::numeric_limits<float>::max());
glm::vec3 maxCorner(std::numeric_limits<float>::lowest());
for (const Vertex& vertex : entry.mesh.vertices) {
minCorner = glm::min(minCorner, vertex.pos);
maxCorner = glm::max(maxCorner, vertex.pos);
}
entry.halfExtentX = std::max(std::abs(minCorner.x), std::abs(maxCorner.x));
entry.halfExtentZ = std::max(std::abs(minCorner.z), std::abs(maxCorner.z));
entry.height = maxCorner.y - std::min(0.0f, minCorner.y);
// Cylindre CONTENANT : le rayon est la demi-diagonale horizontale, sans quoi
// les coins de la boite depasseraient et l'objet se traverserait en biais.
entry.collisionRadius = std::sqrt(entry.halfExtentX * entry.halfExtentX +
entry.halfExtentZ * entry.halfExtentZ);
}
const std::vector<std::string>& AssetCatalog::supportedExtensions() {
// PHASE 15 : Wavefront .obj uniquement, par le loader deja en place depuis la
// Phase 3. Le glTF (.gltf / .glb) est l'ajout evident pour une bibliotheque
// d'assets libres de droits - voir la limite documentee dans
// NOTES-PHASE15.md. Cette liste est le SEUL endroit a etendre le jour ou un
// second loader existe.
static const std::vector<std::string> extensions = { ".obj" };
return extensions;
}
bool AssetCatalog::addEntry(AssetEntry entry) {
if (entry.mesh.empty()) {
logWarn("Catalogue : asset \"" + entry.id + "\" sans geometrie, ignore.");
return false;
}
if (indexOf(entry.id) >= 0) {
logWarn("Catalogue : identifiant \"" + entry.id +
"\" deja pris, ce modele est ignore" +
(entry.sourcePath.empty() ? "" : " (" + entry.sourcePath + ")") +
". Renommer le fichier suffit a le reintegrer.");
return false;
}
computeAssetBounds(entry);
const float footprint = 2.0f * std::max(entry.halfExtentX, entry.halfExtentZ);
const float largest = std::max(footprint, entry.height);
if (largest < kSuspiciouslySmall || largest > kSuspiciouslyLarge) {
logWarn("Catalogue : \"" + entry.id + "\" mesure " +
std::to_string(largest) +
" m dans sa plus grande dimension. Unites du fichier suspectes "
"(centimetres ? pouces ?). Il reste placable, l'echelle se "
"corrige objet par objet.");
}
entries_.push_back(std::move(entry));
return true;
}
void AssetCatalog::addBuiltins() {
for (const BuiltinAsset& builtin : builtinEditorAssets()) {
AssetEntry entry;
entry.id = builtin.id;
entry.description = builtin.description + " [genere en code]";
entry.mesh = builtin.build();
// Pas de normalizeAssetMesh ici, volontairement : les builtins
// respectent deja la convention d'ancrage par construction, et un test
// headless le verifie. Les normaliser quand meme masquerait une derive
// de leur generateur au lieu de la faire echouer.
addEntry(std::move(entry));
}
}
uint32_t AssetCatalog::scanDirectory(const std::string& directory) {
namespace fs = std::filesystem;
std::error_code ec;
if (!fs::exists(directory, ec) || !fs::is_directory(directory, ec)) {
logInfo("Catalogue : aucun dossier d'assets a " + directory +
" (seuls les modeles generes en code sont disponibles). "
"Y deposer des .obj suffit a les voir apparaitre au prochain "
"demarrage de l'editeur.");
return 0;
}
// Collecte puis TRI par nom : voir la note d'en-tete sur les touches 1..9.
std::vector<fs::path> files;
for (const fs::directory_entry& item : fs::directory_iterator(directory, ec)) {
if (ec) {
break;
}
if (!item.is_regular_file(ec) || ec) {
continue;
}
const std::string extension = toLowerAscii(item.path().extension().string());
const auto& supported = supportedExtensions();
if (std::find(supported.begin(), supported.end(), extension) != supported.end()) {
files.push_back(item.path());
}
}
std::sort(files.begin(), files.end());
uint32_t added = 0;
for (const fs::path& file : files) {
AssetEntry entry;
entry.id = sanitizeAssetId(file.stem().string());
entry.sourcePath = file.string();
try {
entry.mesh = loadObjMesh(file.string());
} catch (const std::exception& error) {
// Un modele casse ne prive pas l'editeur des autres.
logWarn("Catalogue : \"" + file.filename().string() +
"\" illisible, ignore. " + error.what());
continue;
}
normalizeAssetMesh(entry.mesh);
entry.description = file.filename().string();
if (addEntry(std::move(entry))) {
++added;
}
}
logInfo("Catalogue : " + std::to_string(added) + " modele(s) charge(s) depuis " +
directory + " sur " + std::to_string(files.size()) + " fichier(s) reconnu(s).");
return added;
}
int AssetCatalog::indexOf(const std::string& id) const {
for (std::size_t i = 0; i < entries_.size(); ++i) {
if (entries_[i].id == id) {
return static_cast<int>(i);
}
}
return -1;
}
std::string AssetCatalog::listing(int selected) const {
std::ostringstream out;
out << "Catalogue d'assets (" << entries_.size() << ") :";
for (std::size_t i = 0; i < entries_.size(); ++i) {
const AssetEntry& entry = entries_[i];
out << "\n " << (static_cast<int>(i) == selected ? "> " : " ")
<< (i + 1) << ". " << entry.id
<< " [" << entry.description << "]"
<< " h=" << entry.height << " m, r=" << entry.collisionRadius << " m";
}
if (entries_.empty()) {
out << "\n (vide)";
}
return out.str();
}
} // namespace vercora
+143
Voir le fichier
@@ -0,0 +1,143 @@
#pragma once
#include "renderer/DrawItem.hpp" // MeshHandle / kInvalidMesh
#include "renderer/MeshData.hpp"
#include <cstdint>
#include <string>
#include <vector>
namespace vercora {
// ---------------------------------------------------------------------------
// PHASE 15 : le catalogue des modeles placables.
// ---------------------------------------------------------------------------
// Deux provenances, un seul type :
// - les assets GENERES EN CODE (editor/EditorAssets.hpp), toujours presents ;
// - les fichiers trouves dans un dossier scanne au demarrage de l'editeur
// (assets/editor/ par defaut).
// Rien en aval ne distingue les deux : c'est le meme principe qu'en Phase 7,
// ou une heightmap procedurale et une dalle LiDAR entrent toutes deux par
// `Heightmap` et ou plus rien ensuite ne sait laquelle est laquelle.
//
// Le catalogue ne connait PAS Vulkan. Il produit des `MeshData` ; c'est
// l'appelant qui les enregistre aupres du Renderer et redepose la poignee
// obtenue dans `meshHandle`. C'est ce qui permet de tester tout le catalogue -
// scan, normalisation, empreintes de collision, doublons - sans GPU.
// Une entree du catalogue.
struct AssetEntry {
// Identifiant ecrit dans le fichier de scene. Sans espace ni accent (voir
// sanitizeAssetId). Unique dans un catalogue.
std::string id;
// Libelle lisible, affiche dans la liste. Jamais serialise.
std::string description;
// Chemin du fichier d'origine, vide pour un asset genere en code. Sert au
// journal et au diagnostic ("d'ou vient ce modele ?").
std::string sourcePath;
// Geometrie cote CPU, DEJA normalisee (voir normalizeAssetMesh).
MeshData mesh;
// --- Empreinte de collision, a l'echelle 1 ------------------------------
// Deduite de la boite englobante du mesh, et non decrite a la main : un
// fichier telecharge n'apporte aucune information de collision, et exiger
// une fiche par asset rendrait le catalogue inutilisable pour son but
// premier (poser vite des choses pour voir).
//
// `collisionRadius` est la demi-diagonale horizontale de la boite, donc le
// rayon du plus petit cylindre vertical qui CONTIENT l'objet. Volontairement
// le contenant et non l'inscrit : un obstacle un peu trop gros se contourne,
// un obstacle trop petit se traverse par les coins - et traverser un rocher
// est bien plus visible que le raser d'un demi-metre.
float collisionRadius = 0.0f;
// Hauteur totale (le mesh part de y = 0 par convention).
float height = 0.0f;
// Demi-etendues horizontales de la boite englobante. Exposees pour le
// journal et pour les tests : c'est la seule facon de verifier qu'un mesh
// charge a bien ete recentre.
float halfExtentX = 0.0f;
float halfExtentZ = 0.0f;
// Poignee de geometrie, remplie par l'appelant APRES `Renderer::addMesh`.
// kInvalidMesh tant que le catalogue n'a pas ete televerse (et toujours,
// dans les tests headless).
MeshHandle meshHandle = kInvalidMesh;
};
// Rend un identifiant utilisable dans le fichier de scene : minuscules ASCII,
// chiffres, '_', '-' et '.' conserves ; tout le reste devient '_'. Une chaine
// vide devient "asset".
//
// Necessaire parce que le format de scene est a champs separes par des espaces :
// un asset nomme "gros rocher.obj" produirait une ligne a un champ de trop, et
// le fichier ne se relirait pas. Normaliser a l'entree plutot que citer les
// champs garde le format lisible et diffable a l'oeil.
std::string sanitizeAssetId(const std::string& raw);
// Realigne un mesh sur la convention d'ancrage des assets d'editeur :
// centre en X et Z sur sa boite englobante, pied a y = 0.
//
// Appliquee a TOUT mesh charge depuis un fichier, jamais aux builtins (qui la
// respectent deja par construction, et le test le verifie). Un .obj pris dans
// une bibliotheque libre a son origine ou l'auteur l'a laissee : au centre du
// volume, dans un coin, ou a plusieurs dizaines de metres si la scene d'origine
// en contenait plusieurs. Sans ce recentrage, "poser au point vise" poserait
// l'objet a cote du point vise, d'un ecart different pour chaque modele.
void normalizeAssetMesh(MeshData& mesh);
// Renseigne collisionRadius / height / halfExtent* depuis la geometrie.
void computeAssetBounds(AssetEntry& entry);
class AssetCatalog {
public:
// Ajoute les assets generes en code. A appeler en premier : ils ont priorite
// en cas de collision d'identifiant avec un fichier (voir scanDirectory).
void addBuiltins();
// Scanne un dossier (non recursif) et ajoute un asset par fichier reconnu.
// Renvoie le nombre d'assets REELLEMENT ajoutes.
//
// - Un dossier absent n'est pas une erreur : l'editeur doit demarrer sur une
// installation qui n'a que les builtins. Le chemin attendu est journalise,
// pour qu'on sache ou deposer des modeles.
// - Les fichiers sont tries par NOM avant traitement. Pas par gout de
// l'ordre : les touches 1..9 de l'editeur designent des rangs dans cette
// liste, et `std::filesystem::directory_iterator` ne garantit aucun ordre.
// Sans le tri, la meme touche pourrait poser un modele different d'une
// execution a l'autre.
// - Un fichier illisible ou vide est SIGNALE et saute, il n'interrompt pas
// le scan : un modele casse ne doit pas priver l'editeur des autres.
uint32_t scanDirectory(const std::string& directory);
// Extensions reconnues par scanDirectory, en minuscules et avec le point.
static const std::vector<std::string>& supportedExtensions();
const std::vector<AssetEntry>& entries() const { return entries_; }
std::vector<AssetEntry>& entries() { return entries_; }
std::size_t size() const { return entries_.size(); }
bool empty() const { return entries_.empty(); }
// Indice de l'asset d'identifiant `id`, ou -1.
int indexOf(const std::string& id) const;
// Liste texte multi-lignes, prete a etre journalisee. C'est L'INTERFACE du
// catalogue pour cette session : la consigne demandait explicitement une
// liste texte plutot qu'un navigateur graphique, l'editeur etant a usage
// developpeur. `selected` marque l'entree courante d'un chevron.
std::string listing(int selected = -1) const;
private:
// Ajoute une entree en refusant les identifiants deja pris. Renvoie false
// (et journalise) sur doublon ou geometrie vide.
bool addEntry(AssetEntry entry);
std::vector<AssetEntry> entries_;
};
} // namespace vercora
+348
Voir le fichier
@@ -0,0 +1,348 @@
#include "editor/EditorAssets.hpp"
#include <glm/glm.hpp>
#include <array>
#include <cmath>
#include <cstdint>
#include <map>
#include <utility>
#include <vector>
namespace vercora {
namespace {
// Teintes de sommet. Le materiau Object (cube.vert/frag) prend la couleur du
// sommet telle quelle : pas de texture, pas de materiau, une seule voie de
// rendu partagee avec le cube, les arbres et les pierres.
const glm::vec3 kRockGrey {0.46f, 0.45f, 0.43f}; // calcaire, comme les galets
const glm::vec3 kRockDark {0.33f, 0.33f, 0.32f}; // faces d'ombre / socle
const glm::vec3 kRockLight {0.60f, 0.59f, 0.55f}; // faces fraiches
const glm::vec3 kWoodColor {0.42f, 0.30f, 0.18f};
const glm::vec3 kSignColor {0.78f, 0.68f, 0.30f}; // plaque de balisage
// --- Petit atelier de geometrie facettee ------------------------------------
// Les meshes de cette session sont tous facettes (une normale par triangle) :
// une silhouette bas-poly en normales lissees ressemble a un galet de plage,
// alors que du rocher casse a des aretes franches. Meme raisonnement qu'en
// Phase 6 (world/StoneMesh.cpp) - le code est repris ici plutot que partage,
// parce que le rendre commun demanderait de sortir un "MeshBuilder" que rien
// d'autre ne reclame encore.
void appendFacet(MeshData& mesh, const glm::vec3& a, const glm::vec3& b,
const glm::vec3& c, const glm::vec3& color) {
const glm::vec3 rawNormal = glm::cross(b - a, c - a);
const float length = glm::length(rawNormal);
if (length < 1e-9f) {
return; // triangle degenere : pas de normale, rien a dessiner
}
const glm::vec3 normal = rawNormal / length;
const auto base = static_cast<uint32_t>(mesh.vertices.size());
for (const glm::vec3& position : { a, b, c }) {
Vertex vertex{};
vertex.pos = position;
vertex.color = color;
vertex.normal = normal;
mesh.vertices.push_back(vertex);
}
mesh.indices.insert(mesh.indices.end(), { base, base + 1, base + 2 });
}
// Quad facette, decoupe en deux triangles partageant la meme normale.
void appendQuad(MeshData& mesh, const glm::vec3& a, const glm::vec3& b,
const glm::vec3& c, const glm::vec3& d, const glm::vec3& color) {
appendFacet(mesh, a, b, c, color);
appendFacet(mesh, a, c, d, color);
}
// Boite alignee sur les axes, puis tournee de `yawRadians` autour de Y et
// translatee. Les six faces sont facettees, donc la boite reste lisible meme
// posee de travers.
//
// `center` est le CENTRE de la boite (y compris verticalement) : c'est ce qui
// rend l'empilement du cairn lisible a ecrire (chaque pierre connait la hauteur
// de celle d'en dessous).
void appendBox(MeshData& mesh, const glm::vec3& center, const glm::vec3& halfSize,
float yawRadians, const glm::vec3& color,
const glm::vec3& topColor) {
const float c = std::cos(yawRadians);
const float s = std::sin(yawRadians);
const auto place = [&](float x, float y, float z) {
return center + glm::vec3(c * x - s * z, y, s * x + c * z);
};
const float hx = halfSize.x;
const float hy = halfSize.y;
const float hz = halfSize.z;
const glm::vec3 p000 = place(-hx, -hy, -hz);
const glm::vec3 p100 = place(+hx, -hy, -hz);
const glm::vec3 p110 = place(+hx, +hy, -hz);
const glm::vec3 p010 = place(-hx, +hy, -hz);
const glm::vec3 p001 = place(-hx, -hy, +hz);
const glm::vec3 p101 = place(+hx, -hy, +hz);
const glm::vec3 p111 = place(+hx, +hy, +hz);
const glm::vec3 p011 = place(-hx, +hy, +hz);
appendQuad(mesh, p001, p101, p111, p011, color); // +Z
appendQuad(mesh, p100, p000, p010, p110, color); // -Z
appendQuad(mesh, p101, p100, p110, p111, color); // +X
appendQuad(mesh, p000, p001, p011, p010, color); // -X
appendQuad(mesh, p011, p111, p110, p010, topColor); // +Y
appendQuad(mesh, p000, p100, p101, p001, kRockDark); // -Y
}
// --- Bruit deterministe -----------------------------------------------------
// Les deformations des rochers sont tirees d'un HACHAGE de l'indice de sommet,
// et non d'un generateur a etat.
//
// Ce n'est pas de la coquetterie : c'est la lecon de la Phase 11 (semis de la
// vegetation). Un `mt19937` rend une suite qui depend de l'ORDRE des appels ;
// deux constructions du meme mesh dans un ordre different donneraient deux
// geometries differentes. Un hachage rend chaque sommet independant de tous les
// autres, donc `editorBoulderMeshData()` produit exactement la meme geometrie a
// chaque appel, dans n'importe quel contexte. Ca compte ici parce que la
// COLLISION est deduite de la boite englobante du mesh : un mesh qui varierait
// donnerait une empreinte de collision qui varie, et une scene sauvegardee ne
// se rechargerait pas a l'identique.
float hashUnit(uint32_t value, uint32_t salt) {
uint32_t h = value * 0x9E3779B9u + salt * 0x85EBCA6Bu;
h ^= h >> 15;
h *= 0x2545F491u;
h ^= h >> 13;
h *= 0xC2B2AE35u;
h ^= h >> 16;
// [0, 1) en divisant par 2^32.
return static_cast<float>(h) * (1.0f / 4294967296.0f);
}
// --- Sphere subdivisee (base des rochers) -----------------------------------
using EdgeKey = std::pair<uint32_t, uint32_t>;
uint32_t midpointIndex(std::vector<glm::vec3>& points, std::map<EdgeKey, uint32_t>& cache,
uint32_t a, uint32_t b) {
const EdgeKey key = (a < b) ? EdgeKey{ a, b } : EdgeKey{ b, a };
const auto found = cache.find(key);
if (found != cache.end()) {
return found->second;
}
// Milieu REPROJETE sur la sphere : sans ca les subdivisions successives
// rabattraient le volume vers l'octaedre de depart.
points.push_back(glm::normalize(points[a] + points[b]));
const auto index = static_cast<uint32_t>(points.size() - 1);
cache.emplace(key, index);
return index;
}
// Octaedre subdivise `subdivisions` fois, sommets deformes par hachage, aplati
// et pose sur y = 0.
//
// Le bruit porte sur les sommets UNIQUES, AVANT le decoupage en triangles
// facettes : bruiter chaque triangle separement dechirerait le volume (deux
// triangles voisins ne partageraient plus leur arete) et on verrait a travers
// le rocher. Meme piege qu'en Phase 6.
MeshData buildBoulder(uint32_t subdivisions, uint32_t salt, float radius,
float flatten, float roughness, const glm::vec3& color,
const char* name) {
std::vector<glm::vec3> points = {
{ 1.0f, 0.0f, 0.0f }, { -1.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f }, { 0.0f, -1.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f }, { 0.0f, 0.0f, -1.0f },
};
std::vector<std::array<uint32_t, 3>> faces = {
{0, 2, 4}, {2, 1, 4}, {1, 3, 4}, {3, 0, 4},
{2, 0, 5}, {1, 2, 5}, {3, 1, 5}, {0, 3, 5},
};
for (uint32_t pass = 0; pass < subdivisions; ++pass) {
std::map<EdgeKey, uint32_t> cache;
std::vector<std::array<uint32_t, 3>> next;
next.reserve(faces.size() * 4);
for (const auto& face : faces) {
const uint32_t ab = midpointIndex(points, cache, face[0], face[1]);
const uint32_t bc = midpointIndex(points, cache, face[1], face[2]);
const uint32_t ca = midpointIndex(points, cache, face[2], face[0]);
next.push_back({ face[0], ab, ca });
next.push_back({ face[1], bc, ab });
next.push_back({ face[2], ca, bc });
next.push_back({ ab, bc, ca });
}
faces.swap(next);
}
// Deformation + aplatissement.
for (uint32_t i = 0; i < points.size(); ++i) {
const float jitter = 1.0f + roughness * (hashUnit(i, salt) - 0.5f) * 2.0f;
points[i] *= radius * jitter;
points[i].y *= flatten;
}
// On pose le volume sur y = 0 : le point le plus bas devient exactement 0.
float minY = points.front().y;
for (const glm::vec3& p : points) {
minY = std::min(minY, p.y);
}
for (glm::vec3& p : points) {
p.y -= minY;
}
MeshData mesh;
mesh.name = name;
mesh.vertices.reserve(faces.size() * 3);
mesh.indices.reserve(faces.size() * 3);
for (const auto& face : faces) {
// Une teinte par face, legerement variee : sans ca un rocher facette de
// couleur uniforme se lit comme une seule masse, et les aretes que le
// facettage vient de creer ne se voient qu'a contre-jour.
const float shade = 0.85f + 0.30f * hashUnit(face[0] * 7919u + face[1], salt + 17u);
appendFacet(mesh, points[face[0]], points[face[1]], points[face[2]],
color * shade);
}
return mesh;
}
const std::vector<BuiltinAsset> kBuiltins = {
{ "rocher", "rocher arrondi, 1,8 m", &editorBoulderMeshData },
{ "bloc", "dalle basculee anguleuse, 3,2 m", &editorSlabMeshData },
{ "cairn", "cairn de sentier, 1,3 m", &editorCairnMeshData },
{ "abri", "abri de pierre a deux pentes, 3,4 m", &editorShelterMeshData },
{ "poteau", "poteau de balisage avec plaque, 2,1 m", &editorMarkerPostMeshData },
};
} // namespace
const std::vector<BuiltinAsset>& builtinEditorAssets() { return kBuiltins; }
MeshData editorBoulderMeshData() {
// 2 subdivisions = 128 faces : assez pour que la silhouette soit ronde,
// assez peu pour rester dans l'esprit bas-poly du reste du projet.
return buildBoulder(2, 20260822u, 0.95f, 0.78f, 0.26f, kRockGrey,
"rocher (asset d'editeur genere, Phase 15)");
}
MeshData editorSlabMeshData() {
// Une dalle basculee : trois boites imbriquees de tailles decroissantes,
// inclinees differemment. Volontairement construite de primitives et non
// bruitee, pour que sa silhouette soit ANGULEUSE la ou celle du rocher est
// arrondie - les deux assets doivent se distinguer d'un coup d'oeil dans une
// scene de test, sinon on ne sait plus lequel on vient de poser.
MeshData mesh;
mesh.name = "bloc (asset d'editeur genere, Phase 15)";
appendBox(mesh, { 0.0f, 0.35f, 0.0f }, { 1.10f, 0.35f, 0.85f },
0.0f, kRockDark, kRockGrey);
appendBox(mesh, { 0.10f, 1.20f, -0.05f }, { 0.85f, 0.60f, 0.62f },
0.42f, kRockGrey, kRockLight);
appendBox(mesh, { -0.15f, 2.35f, 0.10f }, { 0.55f, 0.62f, 0.42f },
-0.65f, kRockGrey, kRockLight);
return mesh;
}
MeshData editorCairnMeshData() {
MeshData mesh;
mesh.name = "cairn (asset d'editeur genere, Phase 15)";
// Quatre pierres empilees, chacune un peu plus petite et tournee autrement.
// Les hauteurs sont cumulees a la main : chaque centre est pose sur le
// sommet du bloc precedent, sans recouvrement, sinon la pile "fond" les unes
// dans les autres et ne se lit plus comme un empilement.
struct Stone { float halfX, halfY, halfZ, yaw; };
constexpr std::array<Stone, 4> stones = { {
{ 0.42f, 0.16f, 0.36f, 0.00f },
{ 0.34f, 0.14f, 0.30f, 0.70f },
{ 0.26f, 0.13f, 0.23f, -0.55f },
{ 0.17f, 0.11f, 0.15f, 1.15f },
} };
float y = 0.0f;
uint32_t index = 0;
for (const Stone& stone : stones) {
const float shade = 0.88f + 0.24f * hashUnit(index, 4242u);
appendBox(mesh, { 0.0f, y + stone.halfY, 0.0f },
{ stone.halfX, stone.halfY, stone.halfZ }, stone.yaw,
kRockGrey * shade, kRockLight * shade);
y += 2.0f * stone.halfY;
++index;
}
return mesh;
}
MeshData editorShelterMeshData() {
MeshData mesh;
mesh.name = "abri (asset d'editeur genere, Phase 15)";
constexpr float halfWidth = 1.70f; // le long de X
constexpr float halfDepth = 1.30f; // le long de Z
constexpr float wallHeight = 1.55f;
constexpr float ridgeHeight = 2.60f;
constexpr float thickness = 0.22f;
constexpr float doorHalfWidth = 0.42f;
constexpr float doorHeight = 1.30f;
// Murs pignons (le long de Z, aux deux extremites en X), pleins.
for (const float sx : { -1.0f, 1.0f }) {
appendBox(mesh, { sx * (halfWidth - 0.5f * thickness), 0.5f * wallHeight, 0.0f },
{ 0.5f * thickness, 0.5f * wallHeight, halfDepth },
0.0f, kRockGrey, kRockLight);
}
// Mur arriere plein (-Z).
appendBox(mesh, { 0.0f, 0.5f * wallHeight, -(halfDepth - 0.5f * thickness) },
{ halfWidth - thickness, 0.5f * wallHeight, 0.5f * thickness },
0.0f, kRockGrey, kRockLight);
// Mur avant (+Z) PERCE d'une porte : deux jambages plus un linteau.
const float jambWidth = 0.5f * ((halfWidth - thickness) * 2.0f - 2.0f * doorHalfWidth);
for (const float sx : { -1.0f, 1.0f }) {
const float centerX = sx * (doorHalfWidth + 0.5f * jambWidth);
appendBox(mesh, { centerX, 0.5f * wallHeight, halfDepth - 0.5f * thickness },
{ 0.5f * jambWidth, 0.5f * wallHeight, 0.5f * thickness },
0.0f, kRockGrey, kRockLight);
}
appendBox(mesh,
{ 0.0f, 0.5f * (doorHeight + wallHeight), halfDepth - 0.5f * thickness },
{ doorHalfWidth, 0.5f * (wallHeight - doorHeight), 0.5f * thickness },
0.0f, kRockDark, kRockGrey);
// Toit a deux pentes : deux quads inclines plus les deux tympans
// triangulaires qui bouchent les pignons. Le faitage court le long de X.
const float eaveZ = halfDepth + 0.18f; // debord de toit
const float roofX = halfWidth + 0.12f;
const glm::vec3 roofColor = kRockDark * 1.15f;
appendQuad(mesh,
{ -roofX, wallHeight, eaveZ }, { roofX, wallHeight, eaveZ },
{ roofX, ridgeHeight, 0.0f }, { -roofX, ridgeHeight, 0.0f }, roofColor);
appendQuad(mesh,
{ roofX, wallHeight, -eaveZ }, { -roofX, wallHeight, -eaveZ },
{ -roofX, ridgeHeight, 0.0f }, { roofX, ridgeHeight, 0.0f }, roofColor);
for (const float sx : { -1.0f, 1.0f }) {
const float x = sx * (halfWidth - 0.5f * thickness);
appendFacet(mesh, { x, wallHeight, -halfDepth }, { x, wallHeight, halfDepth },
{ x, ridgeHeight, 0.0f },
sx > 0.0f ? kRockLight : kRockGrey);
}
return mesh;
}
MeshData editorMarkerPostMeshData() {
MeshData mesh;
mesh.name = "poteau (asset d'editeur genere, Phase 15)";
constexpr float postHeight = 1.90f;
constexpr float postHalf = 0.045f; // 9 cm de cote : volontairement mince
// Socle de pierre, pour que le poteau ne semble pas planter dans le vide.
appendBox(mesh, { 0.0f, 0.06f, 0.0f }, { 0.20f, 0.06f, 0.20f },
0.0f, kRockDark, kRockGrey);
// Le mat.
appendBox(mesh, { 0.0f, 0.12f + 0.5f * postHeight, 0.0f },
{ postHalf, 0.5f * postHeight, postHalf }, 0.0f, kWoodColor,
kWoodColor * 1.2f);
// La plaque, en haut, decalee sur +X comme un panneau directionnel.
appendBox(mesh, { 0.24f, 0.12f + postHeight - 0.16f, 0.0f },
{ 0.24f, 0.11f, 0.012f }, 0.0f, kSignColor, kSignColor);
return mesh;
}
} // namespace vercora
+111
Voir le fichier
@@ -0,0 +1,111 @@
#pragma once
#include "renderer/MeshData.hpp"
#include <cstdint>
#include <string>
#include <vector>
namespace vercora {
// ---------------------------------------------------------------------------
// PHASE 15 : le premier lot d'assets de l'editeur, genere EN CODE.
// ---------------------------------------------------------------------------
// Meme parti pris que l'arbre (Phase 5), la pierre (Phase 6) et la touffe
// d'herbe (Phase 11) : aucun fichier, aucun telechargement, aucune licence a
// verifier. Le but de cette session n'est pas d'habiller le jeu mais de VALIDER
// LE PIPELINE de placement de bout en bout - catalogue, fantome, pose, collision,
// sauvegarde, rechargement. Pour ca il faut des objets qui existent tout de
// suite et dont on connait les dimensions exactes.
//
// Les vrais assets telecharges viendront par le meme chemin, sans rien changer :
// `AssetCatalog` traite un builtin et un fichier de la meme facon des lors que
// tous deux produisent un `MeshData` (voir editor/AssetCatalog.hpp).
//
// --- CONVENTION D'ANCRAGE, valable pour TOUS les assets d'editeur -----------
// Elle differe de celle de l'arbre, et pour une raison precise.
//
// * L'arbre (world/TreeMesh.hpp) est genere "unite" : hauteur exactement 1.0,
// et une instance se met a l'echelle de sa vraie hauteur. C'etait la bonne
// convention la-bas parce que la Forest fait VARIER la taille des arbres et
// qu'un mesh unite evite une echelle non uniforme.
//
// * Un asset d'editeur, lui, a une taille REELLE et intentionnelle : un abri
// de 3 m est un abri de 3 m. Le facteur d'echelle de l'editeur est un
// REGLAGE (1,0 par defaut), pas une mise a l'echelle obligatoire. Poser un
// objet sans y toucher doit donner l'objet a sa taille.
//
// Donc, pour tout asset d'editeur - genere ici ou charge depuis un fichier :
// - dimensions ABSOLUES, en unites monde (= metres) ;
// - PIED a y = 0 : le mesh occupe y >= 0, son point d'ancrage est le sol ;
// - ANCRAGE HORIZONTAL a l'origine : (x, z) = (0, 0) est le point qui se posera
// exactement sous le reticule.
// C'est ce qui rend le placement trivial : la matrice modele d'un objet pose est
// translate(pointVise) * rotateY(cap) * scale(echelle uniforme)
// c'est-a-dire exactement le contrat de `DrawItem` (rotation puis echelle
// UNIFORME, donc mat3(model) reste une normal matrix valide).
//
// --- ANCRAGE N'EST PAS CENTRAGE, et la nuance est deliberee ----------------
// Un asset GENERE ICI choisit son point d'ancrage. Il est presque toujours au
// milieu du volume, mais pas toujours, et c'est voulu : le poteau de balisage a
// son MAT a l'origine, sa plaque debordant vers +X. Poser un panneau, c'est
// planter le mat au point vise - pas y placer le milieu de l'ensemble
// mat + panneau, qui n'existe nulle part physiquement. La meme remarque vaudra
// pour un arbre penche, une porte, une passerelle.
//
// Un asset CHARGE DEPUIS UN FICHIER, lui, ne dit rien de son intention : son
// origine est la ou l'auteur l'a laissee, parfois a plusieurs dizaines de metres
// si la scene d'origine contenait plusieurs objets. Faute de mieux,
// `AssetCatalog::normalizeAssetMesh` le RECENTRE de force sur sa boite
// englobante. C'est le defaut le moins mauvais, pas une regle generale - un
// modele importe dont on voudrait un autre ancrage se corrige aujourd'hui en
// deplacant ses sommets dans un modeleur.
//
// La propriete que TOUS respectent, et que le test headless verifie, est plus
// faible et plus utile : l'ancrage tombe DANS l'empreinte horizontale de
// l'objet, pas a cote. Un objet pose entoure donc toujours le point vise.
// Un asset genere en code : son identifiant de catalogue et sa geometrie.
// L'identifiant est ce qui est ECRIT DANS LE FICHIER DE SCENE : il ne doit
// contenir ni espace ni caractere accentue, et ne doit jamais changer une fois
// des objets poses (ce serait casser les scenes existantes).
struct BuiltinAsset {
std::string id;
std::string description;
MeshData (*build)();
};
// Le catalogue des builtins, dans l'ordre ou ils apparaissent dans la liste.
const std::vector<BuiltinAsset>& builtinEditorAssets();
// --- Les geometries ---------------------------------------------------------
// Rocher arrondi de ~1,8 m, facette. C'est le "rocher" de la consigne : le cas
// d'usage evident du placement a la main (un bloc erratique sur une croupe) et
// le premier objet dont la collision doit se comporter comme un tronc.
MeshData editorBoulderMeshData();
// Bloc anguleux de ~3,2 m : une dalle basculee, faces planes et aretes vives.
// Present a cote du rocher parce que les deux exercent des choses differentes -
// le rocher est large et bas (empreinte de collision genereuse), le bloc est
// haut et etroit (il faut le contourner).
MeshData editorSlabMeshData();
// Cairn : quatre pierres empilees en decroissant, ~1,3 m. Le repere de sentier
// classique. Sert surtout de test d'ECHELLE : c'est un petit objet, donc celui
// sur lequel un decalage vertical d'un decimetre se voit tout de suite.
MeshData editorCairnMeshData();
// Abri de pierre a toit a deux pentes, 3,4 x 2,6 x 2,6 m. Le seul asset a
// INTERIEUR : il a une porte, donc il exerce le cas ou la collision par cylindre
// englobant est FAUSSE (on ne peut pas y entrer). C'est volontaire - voir la
// limite documentee dans NOTES-PHASE15.md.
MeshData editorShelterMeshData();
// Poteau de balisage de 2,1 m avec sa plaque. Volontairement FIN : c'est l'asset
// de mesure de l'editeur. Un objet mince pose au point vise montre a l'oeil, au
// centimetre pres, ou le rayon a touche le sol - ce qu'un rocher d'un metre de
// large ne peut pas montrer.
MeshData editorMarkerPostMeshData();
} // namespace vercora
+443
Voir le fichier
@@ -0,0 +1,443 @@
#include "editor/EditorController.hpp"
#include "core/HeightSampler.hpp"
#include "core/Logger.hpp"
#include "core/TerrainRay.hpp"
#include "editor/AssetCatalog.hpp"
#include "editor/EditorScene.hpp"
#include <algorithm>
#include <cmath>
#include <sstream>
namespace vercora {
EditorController::EditorController(const AssetCatalog& catalog, EditorScene& scene,
const EditorControllerParams& params)
: catalog_(catalog), scene_(scene), params_(params) {
if (!catalog_.empty()) {
brushIndex_ = 0;
}
}
void EditorController::selectBrush(int index) {
if (catalog_.empty()) {
brushIndex_ = -1;
return;
}
const int count = static_cast<int>(catalog_.size());
// Modulo POSITIF : reculer depuis le premier asset doit ramener au dernier,
// et l'operateur % du C++ rendrait un indice negatif.
brushIndex_ = ((index % count) + count) % count;
page_ = brushIndex_ / kPageSize;
statusChanged_ = true;
}
void EditorController::applyAdjustments(const EditorInput& input, PlacedObject& target,
float* liftOut) const {
const float divider = input.holdFineStep ? std::max(1.0f, params_.fineStepDivider)
: 1.0f;
const float dt = input.deltaTime;
const float rotate = (input.holdRotateRight ? 1.0f : 0.0f) -
(input.holdRotateLeft ? 1.0f : 0.0f);
if (rotate != 0.0f) {
target.yawDegrees += rotate * params_.rotateDegreesPerSecond * dt / divider;
// Repli dans [-180, 180] : la valeur part dans le fichier de scene, et
// un cap de 3 240 degres y serait juste illisible.
while (target.yawDegrees > 180.0f) { target.yawDegrees -= 360.0f; }
while (target.yawDegrees < -180.0f) { target.yawDegrees += 360.0f; }
}
const float scaleInput = (input.holdScaleUp ? 1.0f : 0.0f) -
(input.holdScaleDown ? 1.0f : 0.0f);
if (scaleInput != 0.0f) {
// Reglage MULTIPLICATIF et non additif : passer de 0,2 a 0,3 et de 10 a
// 15 sont le meme geste a l'oeil, alors qu'un pas additif rendrait le
// premier impossible a doser et le second interminable.
const float rate = std::pow(params_.scalePerSecond, scaleInput * dt / divider);
target.scale = std::clamp(target.scale * rate, params_.minScale, params_.maxScale);
}
if (liftOut != nullptr) {
const float lift = (input.holdRaise ? 1.0f : 0.0f) -
(input.holdLower ? 1.0f : 0.0f);
if (lift != 0.0f) {
*liftOut = std::clamp(
*liftOut + lift * params_.liftMetresPerSecond * dt / divider,
params_.minLift, params_.maxLift);
}
}
}
void EditorController::update(const EditorInput& input, const HeightSampler& terrain,
float halfExtent) {
hasPreview_ = false;
// --- Catalogue ----------------------------------------------------------
if (input.nextAssetPressed) { selectBrush(brushIndex_ + 1); }
if (input.prevAssetPressed) { selectBrush(brushIndex_ - 1); }
if (input.quickPick >= 0) {
const int index = page_ * kPageSize + input.quickPick;
if (index < static_cast<int>(catalog_.size())) {
selectBrush(index);
} else {
logInfo("Editeur : rien au rang " + std::to_string(input.quickPick + 1) +
" de la page " + std::to_string(page_ + 1) + ".");
}
}
if (input.listPressed) { listRequested_ = true; }
if (input.savePressed) { saveRequested_ = true; }
if (input.reloadPressed) { reloadRequested_ = true; }
if (input.undoPressed) {
// Une annulation pendant une saisie serait ambigue (annule-t-on la
// saisie ou l'action d'avant ?). On repose d'abord, sans rien empiler :
// l'objet retourne exactement d'ou il vient.
if (grabbedId_ != kNoPlacedObject) {
grabbedId_ = kNoPlacedObject;
logInfo("Editeur : saisie abandonnee avant l'annulation.");
}
const std::string label = scene_.lastActionLabel();
if (scene_.undo()) {
logInfo("Editeur : annule (" + label + "). Reste " +
std::to_string(scene_.undoDepth()) + " annulation(s), " +
std::to_string(scene_.size()) + " objet(s).");
if (scene_.find(selectedId_) == nullptr) {
selectedId_ = kNoPlacedObject;
}
} else {
logInfo("Editeur : rien a annuler.");
}
statusChanged_ = true;
}
if (input.cancelPressed) {
if (grabbedId_ != kNoPlacedObject) {
grabbedId_ = kNoPlacedObject;
logInfo("Editeur : saisie abandonnee, l'objet reste ou il etait.");
} else if (selectedId_ != kNoPlacedObject) {
selectedId_ = kNoPlacedObject;
logInfo("Editeur : selection abandonnee.");
}
statusChanged_ = true;
}
// --- Visee --------------------------------------------------------------
const glm::vec3 direction = glm::length(input.forward) > 1e-6f
? glm::normalize(input.forward)
: glm::vec3(0.0f, 0.0f, -1.0f);
const TerrainRayHit aim =
raycastTerrain(terrain, input.eye, direction, params_.aimReach, halfExtent);
// --- Selection ----------------------------------------------------------
if (input.pickPressed && grabbedId_ == kNoPlacedObject) {
// La portee de selection s'arrete AU TERRAIN quand celui-ci est touche :
// sans ca, viser le sol au pied d'un rocher selectionnerait un objet
// situe derriere la colline. `aimReach` sinon.
const float reach = aim.hit ? aim.distance + 1.0f : params_.aimReach;
const uint32_t picked = scene_.pick(input.eye, direction, reach);
if (picked != kNoPlacedObject) {
selectedId_ = picked;
const PlacedObject* object = scene_.find(picked);
logInfo("Editeur : selection de l'objet " + std::to_string(picked) + " (" +
(object ? object->asset : std::string("?")) + ").");
} else {
selectedId_ = kNoPlacedObject;
logInfo("Editeur : aucun objet dans la ligne de visee, selection videe.");
}
statusChanged_ = true;
}
// --- Cycle parmi les objets poses (F3/F4) --------------------------------
// Meme garde que la selection a la visee : pas pendant une saisie, sinon on
// changerait l'objet EN MAIN sous les pieds du joueur. Contrairement a
// pickPressed, celle-ci ne regarde jamais le terrain - c'est tout son
// interet : retrouver un objet pose hors du champ de visee actuel sans
// revenir dessus a la souris.
if ((input.cycleNextPressed || input.cyclePrevPressed) &&
grabbedId_ == kNoPlacedObject) {
const auto& objects = scene_.objects();
if (objects.empty()) {
selectedId_ = kNoPlacedObject;
logInfo("Editeur : aucun objet pose a selectionner.");
} else {
const int count = static_cast<int>(objects.size());
const int current = scene_.indexOf(selectedId_);
const int base = (current >= 0) ? current : 0;
// Rien de selectionne + "suivant" pointe sur le premier objet ;
// rien de selectionne + "precedent" sur le dernier - le meme choix
// que selectBrush(-1) depuis l'indice 0.
const int step = (current < 0) ? (input.cyclePrevPressed ? -1 : 0)
: (input.cycleNextPressed ? 1 : -1);
const int index = ((base + step) % count + count) % count;
selectedId_ = objects[static_cast<std::size_t>(index)].id;
logInfo("Editeur : selection de l'objet " + std::to_string(selectedId_) +
" (" + objects[static_cast<std::size_t>(index)].asset +
") [F3/F4].");
}
statusChanged_ = true;
}
// --- Saisie : DEBUT seulement -------------------------------------------
//
// La REPOSE est traitee plus bas, APRES le calcul de la previsualisation de
// cette image. Les deux etaient ensemble ici au depart, et c'etait un
// defaut : reposer a la touche de saisie ecrivait la previsualisation de
// l'image PRECEDENTE, alors que reposer au clic - traite plus bas -
// ecrivait celle de l'image courante. Deux gestes censes faire la meme
// chose n'avaient donc pas exactement le meme resultat.
bool grabStartedThisFrame = false;
if (input.grabPressed && grabbedId_ == kNoPlacedObject) {
if (selectedId_ != kNoPlacedObject) {
const PlacedObject* object = scene_.find(selectedId_);
if (object != nullptr) {
grabbedId_ = selectedId_;
grabState_ = *object;
grabLift_ = object->position.y -
terrain.heightAt(object->position.x, object->position.z);
grabStartedThisFrame = true;
logInfo("Editeur : objet " + std::to_string(grabbedId_) +
" en main, il suit la visee.");
statusChanged_ = true;
}
} else {
logInfo("Editeur : rien de selectionne a saisir.");
}
}
// --- Reglages : saisie > selection > pinceau ----------------------------
if (grabbedId_ != kNoPlacedObject) {
// Les reglages portent sur `grabState_`, une COPIE : l'objet stocke dans
// la scene ne bouge pas tant qu'il est en main. C'est ce qui garantit
// que l'unique annulation empilee a la repose retienne bien l'etat
// d'avant la saisie, rotation comprise.
applyAdjustments(input, grabState_, &grabLift_);
if (input.toggleSolidPressed) {
grabState_.solid = !grabState_.solid;
logInfo(std::string("Editeur : objet en main rendu ") +
(grabState_.solid ? "SOLIDE." : "TRAVERSABLE."));
statusChanged_ = true;
}
} else if (selectedId_ != kNoPlacedObject) {
const PlacedObject* current = scene_.find(selectedId_);
if (current == nullptr) {
selectedId_ = kNoPlacedObject;
} else {
PlacedObject updated = *current;
float lift = updated.position.y -
terrain.heightAt(updated.position.x, updated.position.z);
const float beforeYaw = updated.yawDegrees;
const float beforeScale = updated.scale;
const float beforeLift = lift;
applyAdjustments(input, updated, &lift);
bool changed = (updated.yawDegrees != beforeYaw) ||
(updated.scale != beforeScale) || (lift != beforeLift);
if (input.toggleSolidPressed) {
updated.solid = !updated.solid;
changed = true;
logInfo(std::string("Editeur : objet ") + std::to_string(selectedId_) +
(updated.solid ? " rendu SOLIDE." : " rendu TRAVERSABLE."));
}
if (changed) {
updated.position.y =
terrain.heightAt(updated.position.x, updated.position.z) + lift;
scene_.transform(selectedId_, updated, input.now);
statusChanged_ = true;
}
}
} else {
PlacedObject brush;
brush.yawDegrees = brushYaw_;
brush.scale = brushScale_;
const float beforeYaw = brushYaw_;
const float beforeScale = brushScale_;
const float beforeLift = brushLift_;
applyAdjustments(input, brush, &brushLift_);
brushYaw_ = brush.yawDegrees;
brushScale_ = brush.scale;
if (input.toggleSolidPressed) {
brushSolid_ = !brushSolid_;
logInfo(std::string("Editeur : le pinceau posera des objets ") +
(brushSolid_ ? "SOLIDES." : "TRAVERSABLES."));
statusChanged_ = true;
}
if (brushYaw_ != beforeYaw || brushScale_ != beforeScale ||
brushLift_ != beforeLift) {
statusChanged_ = true;
}
}
// --- Previsualisation ---------------------------------------------------
if (grabbedId_ != kNoPlacedObject) {
preview_ = grabState_;
preview_.id = grabbedId_;
if (aim.hit) {
preview_.position.x = aim.position.x;
preview_.position.z = aim.position.z;
}
preview_.position.y =
terrain.heightAt(preview_.position.x, preview_.position.z) + grabLift_;
hasPreview_ = true;
} else if (aim.hit && brushIndex_ >= 0) {
preview_ = PlacedObject{};
preview_.id = kNoPlacedObject;
preview_.asset = catalog_.entries()[static_cast<std::size_t>(brushIndex_)].id;
preview_.position = { aim.position.x,
aim.position.y + brushLift_,
aim.position.z };
preview_.yawDegrees = brushYaw_;
preview_.scale = brushScale_;
preview_.solid = brushSolid_;
hasPreview_ = true;
}
// --- Repose et pose -----------------------------------------------------
// Un objet en main se repose AUSSI BIEN a la touche de saisie qu'a celle de
// pose : c'est le geste naturel dans les deux cas, et ca evite d'avoir a se
// souvenir laquelle des deux termine un deplacement. Les deux passent
// desormais par le meme code et ecrivent la MEME previsualisation, celle de
// l'image courante, calculee juste au-dessus.
const bool dropRequested = grabbedId_ != kNoPlacedObject &&
((input.grabPressed && !grabStartedThisFrame) ||
input.placePressed);
if (dropRequested) {
const uint32_t id = grabbedId_;
grabbedId_ = kNoPlacedObject;
PlacedObject dropped = preview_;
dropped.id = id;
// UNE seule ecriture dans la scene pour tout le deplacement, donc UNE
// seule annulation - dont le `before` est l'etat d'avant la saisie,
// puisque rien n'a touche l'objet stocke entre-temps.
scene_.transform(id, dropped, input.now);
logInfo("Editeur : objet " + std::to_string(id) + " repose.");
statusChanged_ = true;
} else if (input.placePressed) {
if (!hasPreview_) {
logInfo("Editeur : la visee ne touche pas le terrain, rien a poser.");
} else if (brushIndex_ < 0) {
logInfo("Editeur : catalogue vide, rien a poser.");
} else {
const uint32_t id = scene_.place(preview_);
// L'objet pose n'est VOLONTAIREMENT PAS selectionne.
//
// C'etait le cas dans la premiere version, par analogie avec les
// editeurs 3D, et un essai sous Vulkan a montre que c'etait le
// mauvais choix ici : les reglages visent la selection en priorite
// (SAISIE > SELECTION > PINCEAU), donc poser un objet detournait
// silencieusement les fleches de rotation du PINCEAU vers l'objet
// qu'on venait de poser. Regler le pinceau puis poser dix blocs
// alignes - le geste le plus courant de l'outil - devenait
// impossible sans deselectionner entre chaque.
//
// Pour retoucher ce qu'on vient de poser, il suffit de le viser et
// d'appuyer sur la touche de selection.
logInfo("Editeur : pose de \"" + preview_.asset + "\" (objet " +
std::to_string(id) + ") a " + std::to_string(aim.distance) +
" m, cap " + std::to_string(preview_.yawDegrees) +
" deg, echelle " + std::to_string(preview_.scale) +
(preview_.solid ? ", solide." : ", traversable."));
statusChanged_ = true;
}
}
// --- Suppression --------------------------------------------------------
if (input.deletePressed) {
if (grabbedId_ != kNoPlacedObject) {
grabbedId_ = kNoPlacedObject; // on repose avant de supprimer
}
if (selectedId_ == kNoPlacedObject) {
logInfo("Editeur : rien de selectionne a supprimer.");
} else {
const PlacedObject* object = scene_.find(selectedId_);
const std::string asset = object ? object->asset : std::string("?");
if (scene_.erase(selectedId_)) {
logInfo("Editeur : objet " + std::to_string(selectedId_) + " (" + asset +
") supprime. Reste " + std::to_string(scene_.size()) +
" objet(s).");
}
selectedId_ = kNoPlacedObject;
statusChanged_ = true;
}
}
}
bool EditorController::consumeSaveRequest() {
const bool requested = saveRequested_;
saveRequested_ = false;
return requested;
}
bool EditorController::consumeReloadRequest() {
const bool requested = reloadRequested_;
reloadRequested_ = false;
return requested;
}
bool EditorController::consumeListRequest() {
const bool requested = listRequested_;
listRequested_ = false;
return requested;
}
bool EditorController::consumeStatusChanged() {
const std::string current = statusLine();
const bool changed = statusChanged_ || (current != lastStatus_);
statusChanged_ = false;
lastStatus_ = current;
return changed;
}
void EditorController::resetInteraction() {
grabbedId_ = kNoPlacedObject;
selectedId_ = kNoPlacedObject;
hasPreview_ = false;
statusChanged_ = true;
}
std::string EditorController::statusLine() const {
std::ostringstream out;
out << "Editeur : pinceau ";
if (brushIndex_ >= 0) {
out << '[' << (brushIndex_ + 1) << '/' << catalog_.size() << "] "
<< catalog_.entries()[static_cast<std::size_t>(brushIndex_)].id;
} else {
out << "(catalogue vide)";
}
out << ", cap " << brushYaw_ << " deg, echelle " << brushScale_
<< ", dz " << brushLift_ << " m, "
<< (brushSolid_ ? "solide" : "traversable");
// La ligne d'etat doit montrer CE QUE LES REGLAGES VONT TOUCHER, et non
// seulement le pinceau. Sans ca, tourner un objet selectionne affichait
// "cap 0 deg" - celui du pinceau, inchange - pendant que l'objet tournait :
// on ne pouvait pas lire a l'ecran ce qu'on etait en train de regler.
const auto describe = [&out](const PlacedObject& object) {
out << " (" << object.asset << ", cap " << object.yawDegrees
<< " deg, echelle " << object.scale << ", "
<< (object.solid ? "solide" : "traversable") << ')';
};
if (grabbedId_ != kNoPlacedObject) {
out << " | EN MAIN : objet " << grabbedId_;
describe(grabState_);
} else if (selectedId_ != kNoPlacedObject) {
out << " | selection : objet " << selectedId_;
const PlacedObject* selected = scene_.find(selectedId_);
if (selected != nullptr) {
describe(*selected);
}
} else {
out << " | aucune selection";
}
out << " | " << scene_.size() << " objet(s), " << scene_.solidCount()
<< " solide(s), " << scene_.undoDepth() << " annulation(s)";
return out.str();
}
} // namespace vercora
+250
Voir le fichier
@@ -0,0 +1,250 @@
#pragma once
#include "editor/PlacedObject.hpp"
#include <cstdint>
#include <string>
namespace vercora {
class AssetCatalog;
class EditorScene;
class HeightSampler;
// ---------------------------------------------------------------------------
// PHASE 15 : la machine a etats de l'editeur.
// ---------------------------------------------------------------------------
// Elle tient tout ce qui distingue "une liste d'objets" (EditorScene) d'un
// OUTIL : quel asset est arme, ou tombe la visee, quel objet est selectionne,
// est-on en train d'en deplacer un.
//
// --- POURQUOI ELLE NE LIT PAS LE CLAVIER ------------------------------------
// Elle recoit un `EditorInput` deja depouille par l'appelant. Trois raisons, la
// derniere etant la vraie :
// 1. elle ne depend alors ni de GLFW ni de Window, donc elle est EXECUTEE dans
// les tests headless - toute la logique de placement, de selection et de
// saisie est couverte sans GPU ni fenetre ;
// 2. les touches restent decrites en un seul endroit, dans main.cpp, a cote de
// celles du jeu ;
// 3. le harnais automatise (tools/run_vulkan_check.ps1) ne peut PAS piloter la
// souris - GLFW lit le curseur systeme, pas les messages postes. Un
// controleur qui lirait lui-meme les entrees serait donc intestable
// autrement qu'a la main. En le nourrissant d'une structure, un scenario
// scripte peut lui soumettre exactement la meme sequence qu'un joueur.
//
// --- LE PINCEAU, LA SELECTION ET LA SAISIE ----------------------------------
// Trois etats coexistent, et l'ordre dans lequel les commandes de reglage
// (rotation, echelle, hauteur) les visent est fixe et documente :
//
// SAISIE > SELECTION > PINCEAU
//
// * SAISIE : un objet deja pose a ete "decroche" (touche de saisie). Il suit
// la visee jusqu'a ce qu'on le repose. Tant qu'il est en main, la scene
// n'est PAS modifiee - c'est seulement en le reposant qu'une unique action
// annulable est empilee. Sans ca, deplacer un rocher de trente metres
// empilerait une annulation par image.
// * SELECTION : un objet pose, designe par la visee. Les reglages
// l'atteignent directement, et les retouches successives sont regroupees en
// une seule annulation (voir EditorScene).
// * PINCEAU : l'asset arme et SES reglages (cap, echelle, hauteur, solidite).
// Ils sont CONSERVES d'une pose a l'autre, ce qui est le comportement utile
// quand on aligne une serie de blocs : on regle une fois, on pose dix fois.
//
// --- LE FANTOME -------------------------------------------------------------
// L'objet previsualise avant la pose. Sa geometrie est celle de l'asset arme, sa
// position est le point ou le regard rencontre le terrain (core/TerrainRay.hpp),
// et il n'existe que quand la visee touche effectivement le sol dans l'emprise -
// viser le ciel ne pose rien et ne montre rien, plutot que de poser a une
// distance arbitraire.
// Ce que l'appelant doit fournir a chaque image.
//
// Les champs `...Pressed` sont des FRONTS DESCENDANTS deja resolus (la touche
// vient d'etre enfoncee) ; les champs `hold...` sont l'etat courant de la
// touche, parce que ces reglages-la sont continus - on maintient la fleche pour
// tourner, on ne la tapote pas quinze fois.
struct EditorInput {
float deltaTime = 0.0f;
// Temps courant en secondes, croissant. Sert au regroupement des
// annulations (voir EditorScene::transform).
float now = 0.0f;
// Rayon de visee : oeil et direction NORMALISEE du regard. C'est le meme
// rayon que celui de l'abattage (main.cpp appelle Forest::pickTree avec
// camera.position() et camera.front()), donc le reticule de l'editeur est
// exactement celui du jeu.
glm::vec3 eye{0.0f};
glm::vec3 forward{0.0f, 0.0f, -1.0f};
// --- Fronts -------------------------------------------------------------
bool placePressed = false; // poser l'objet arme / reposer l'objet saisi
bool pickPressed = false; // selectionner l'objet vise
bool deletePressed = false; // supprimer la selection
bool grabPressed = false; // saisir / reposer la selection
bool cancelPressed = false; // annuler la saisie en cours, deselectionner
bool nextAssetPressed = false; // asset suivant du catalogue
bool prevAssetPressed = false; // asset precedent
bool toggleSolidPressed = false; // solide <-> traversable
bool undoPressed = false;
bool savePressed = false;
bool reloadPressed = false;
bool listPressed = false; // reafficher catalogue + inventaire
// Selectionne l'objet POSE suivant / precedent (ordre de la scene), sans
// passer par la visee. Ajoute apres la Phase 15 : sans gizmo ni reticule
// permanent, retrouver un objet pose loin du regard courant n'avait qu'une
// voie, revenir dessus a la souris. Ignore si un objet est en main, comme
// pickPressed (voir EditorController::update).
bool cycleNextPressed = false;
bool cyclePrevPressed = false;
// Rang 1..9 demande au clavier, -1 si aucune. Converti en indice de
// catalogue par l'appelant ? NON : c'est fait ici, parce que le rang depend
// de la PAGE courante, qui est un etat du controleur.
int quickPick = -1;
// --- Etats maintenus ----------------------------------------------------
bool holdRotateLeft = false;
bool holdRotateRight = false;
bool holdScaleUp = false;
bool holdScaleDown = false;
bool holdRaise = false;
bool holdLower = false;
// Pas fin : divise les vitesses de reglage ci-dessous. Sur la touche de
// modification, pour poser au centimetre quand ca compte.
bool holdFineStep = false;
};
// Reglages de l'outil. Regroupes pour qu'un scenario de test puisse les fixer
// sans toucher au code.
struct EditorControllerParams {
// Portee de la visee, en metres. 400 m : de quoi poser un rocher sur la
// croupe d'en face depuis un promontoire, sans que le pas de marche du
// raycast (voir core/TerrainRay.hpp) devienne grossier au point de rater
// ce qu'on regarde.
float aimReach = 400.0f;
// Vitesses de reglage, par seconde de touche maintenue.
float rotateDegreesPerSecond = 90.0f;
float scalePerSecond = 1.8f; // facteur multiplicatif par seconde
float liftMetresPerSecond = 0.6f;
// Diviseur applique aux trois vitesses avec la touche de pas fin.
float fineStepDivider = 8.0f;
// Bornes d'echelle. Un objet a 0,01 est invisible et un objet a 100 masque
// tout l'ecran : dans les deux cas on ne peut plus le retrouver pour
// corriger, ce qui est la seule vraie raison de borner.
float minScale = 0.05f;
float maxScale = 40.0f;
// Bornes du decalage vertical par rapport au terrain, en metres.
float minLift = -20.0f;
float maxLift = 60.0f;
};
class EditorController {
public:
// Ni le catalogue ni la scene ne sont possedes : tous deux doivent vivre
// plus longtemps que le controleur.
EditorController(const AssetCatalog& catalog, EditorScene& scene,
const EditorControllerParams& params = {});
// Une image d'editeur. `halfExtent` est la demi-emprise horizontale du
// terrain : au-dela, la visee ne touche rien (voir raycastTerrain).
void update(const EditorInput& input, const HeightSampler& terrain,
float halfExtent);
// --- Ce que l'appelant doit dessiner ------------------------------------
// Y a-t-il un objet a previsualiser (fantome de pose, ou objet saisi) ?
bool hasPreview() const { return hasPreview_; }
// La previsualisation, prete a etre transformee en DrawItem. Son `id` vaut
// celui de l'objet saisi, ou kNoPlacedObject pour un fantome de pose.
const PlacedObject& preview() const { return preview_; }
// Objet dont le dessin NORMAL doit etre saute cette image, parce qu'il est
// en cours de deplacement et deja dessine par la previsualisation.
// kNoPlacedObject si aucun.
uint32_t hiddenObjectId() const { return grabbedId_; }
uint32_t selection() const { return selectedId_; }
bool grabbing() const { return grabbedId_ != kNoPlacedObject; }
// Indice du pinceau dans le catalogue, ou -1 si le catalogue est vide.
int brushIndex() const { return brushIndex_; }
// --- Requetes a traiter par l'appelant ----------------------------------
// Le controleur ne fait AUCUNE entree/sortie : sauvegarder demande un chemin
// et le georeferencement du terrain, qui ne le regardent pas. Il se contente
// de lever un drapeau, que l'appelant consomme.
bool consumeSaveRequest();
bool consumeReloadRequest();
bool consumeListRequest();
// --- Journal ------------------------------------------------------------
// Ligne d'etat compacte : pinceau, reglages, selection, nombre d'objets.
std::string statusLine() const;
// A-t-elle change depuis le dernier appel a consumeStatusChanged() ?
// Sert a n'ecrire dans le journal que quand quelque chose bouge : l'editeur
// tourne a plusieurs centaines d'images par seconde, une ligne par image
// rendrait toute autre trace illisible.
bool consumeStatusChanged();
// Force l'affichage du prochain etat (apres un rechargement de fichier).
void markStatusChanged() { statusChanged_ = true; }
// Remet la selection et la saisie a zero. Appele en sortant du mode editeur :
// laisser un objet "en main" pendant une partie normale le figerait sur le
// reticule pour toujours.
void resetInteraction();
// Rang du pinceau dans la page courante et taille de page, pour l'aide.
static constexpr int kPageSize = 9;
int page() const { return page_; }
private:
void selectBrush(int index);
void applyAdjustments(const EditorInput& input, PlacedObject& target,
float* liftOut) const;
const AssetCatalog& catalog_;
EditorScene& scene_;
EditorControllerParams params_;
// --- Pinceau ------------------------------------------------------------
int brushIndex_ = -1;
int page_ = 0;
float brushYaw_ = 0.0f;
float brushScale_ = 1.0f;
float brushLift_ = 0.0f; // decalage vertical par rapport au terrain
bool brushSolid_ = true;
// --- Selection et saisie ------------------------------------------------
uint32_t selectedId_ = kNoPlacedObject;
uint32_t grabbedId_ = kNoPlacedObject;
// Etat de TRAVAIL pendant la saisie : c'est lui que les reglages modifient
// et lui qui est previsualise. L'etat d'AVANT la saisie n'est volontairement
// pas recopie ici - il reste dans la scene, intacte tant que l'objet est en
// main, et c'est elle qui le retiendra comme `before` de l'unique action
// annulable empilee au moment de reposer.
PlacedObject grabState_;
// Decalage vertical de l'objet saisi, reevalue par rapport au terrain sous
// sa nouvelle position a chaque image.
float grabLift_ = 0.0f;
// --- Sortie -------------------------------------------------------------
bool hasPreview_ = false;
PlacedObject preview_;
bool saveRequested_ = false;
bool reloadRequested_ = false;
bool listRequested_ = false;
bool statusChanged_ = true;
std::string lastStatus_;
};
} // namespace vercora
+319
Voir le fichier
@@ -0,0 +1,319 @@
#include "editor/EditorScene.hpp"
#include "editor/AssetCatalog.hpp"
#include <algorithm>
#include <cmath>
namespace vercora {
const PlacedObject* EditorScene::find(uint32_t id) const {
const int index = indexOf(id);
return index < 0 ? nullptr : &objects_[static_cast<std::size_t>(index)];
}
int EditorScene::indexOf(uint32_t id) const {
if (id == kNoPlacedObject) {
return -1;
}
for (std::size_t i = 0; i < objects_.size(); ++i) {
if (objects_[i].id == id) {
return static_cast<int>(i);
}
}
return -1;
}
void EditorScene::pushAction(Action action) {
undoStack_.push_back(std::move(action));
if (undoStack_.size() > kMaxUndoDepth) {
// On jette la PLUS ANCIENNE, pas la plus recente : une pile bornee doit
// continuer d'annuler ce qu'on vient de faire.
undoStack_.erase(undoStack_.begin());
}
}
uint32_t EditorScene::place(PlacedObject object) {
object.id = nextId_++;
const uint32_t id = object.id;
Action action;
action.kind = ActionKind::Place;
action.before = object; // sert au libelle, pas a la restauration
action.index = objects_.size();
pushAction(std::move(action));
objects_.push_back(std::move(object));
return id;
}
bool EditorScene::erase(uint32_t id) {
const int index = indexOf(id);
if (index < 0) {
return false;
}
const auto position = static_cast<std::size_t>(index);
Action action;
action.kind = ActionKind::Erase;
action.before = objects_[position];
action.index = position;
pushAction(std::move(action));
objects_.erase(objects_.begin() + index);
return true;
}
bool EditorScene::transform(uint32_t id, const PlacedObject& updated, float now) {
const int index = indexOf(id);
if (index < 0) {
return false;
}
PlacedObject& target = objects_[static_cast<std::size_t>(index)];
// Regroupement : si la derniere action est deja une transformation du MEME
// objet, assez recente, on ne l'empile pas une seconde fois - on prolonge la
// precedente, dont le `before` reste l'etat d'avant la manipulation
// complete. Voir l'en-tete du header.
const bool grouped = !undoStack_.empty() &&
undoStack_.back().kind == ActionKind::Transform &&
undoStack_.back().before.id == id &&
(now - undoStack_.back().lastTouch) <= transformGroupSeconds_;
if (grouped) {
undoStack_.back().lastTouch = now;
} else {
Action action;
action.kind = ActionKind::Transform;
action.before = target;
action.index = static_cast<std::size_t>(index);
action.lastTouch = now;
pushAction(std::move(action));
}
// L'identite et l'asset NE CHANGENT JAMAIS par cette voie : `updated` est
// fourni par l'appelant, qui a pu le construire a partir d'une copie
// maladroite. Les reimposer ici rend l'invariant impossible a violer depuis
// l'exterieur.
const std::string asset = target.asset;
target = updated;
target.id = id;
target.asset = asset;
if (!(target.scale > 0.0f) || !std::isfinite(target.scale)) {
target.scale = 1.0f;
}
return true;
}
bool EditorScene::undo() {
if (undoStack_.empty()) {
return false;
}
const Action action = undoStack_.back();
undoStack_.pop_back();
switch (action.kind) {
case ActionKind::Place: {
const int index = indexOf(action.before.id);
if (index >= 0) {
objects_.erase(objects_.begin() + index);
}
return true;
}
case ActionKind::Erase: {
// Reinsertion a sa place d'origine. L'indice peut avoir depasse la
// taille courante si d'autres suppressions ont eu lieu depuis ; on
// ecrete plutot que de refuser l'annulation.
const std::size_t index = std::min(action.index, objects_.size());
objects_.insert(objects_.begin() + static_cast<std::ptrdiff_t>(index),
action.before);
return true;
}
case ActionKind::Transform: {
const int index = indexOf(action.before.id);
if (index < 0) {
// L'objet a ete supprime depuis. Rien a restaurer : la
// suppression, elle, a sa propre entree plus bas dans la pile.
return true;
}
objects_[static_cast<std::size_t>(index)] = action.before;
return true;
}
}
return false;
}
std::string EditorScene::lastActionLabel() const {
if (undoStack_.empty()) {
return {};
}
const Action& action = undoStack_.back();
const std::string& asset = action.before.asset;
switch (action.kind) {
case ActionKind::Place: return "pose de \"" + asset + "\"";
case ActionKind::Erase: return "suppression de \"" + asset + "\"";
case ActionKind::Transform: return "reglage de \"" + asset + "\"";
}
return {};
}
void EditorScene::replaceAll(std::vector<PlacedObject> objects) {
objects_ = std::move(objects);
undoStack_.clear();
// Renumerotation complete : les identifiants sont une notion de SESSION, le
// fichier n'en porte pas (voir SceneFile.hpp). Repartir de 1 garantit qu'ils
// sont uniques et croissants dans l'ordre du fichier, donc lisibles.
nextId_ = 1;
for (PlacedObject& object : objects_) {
object.id = nextId_++;
}
}
bool EditorScene::footprint(const PlacedObject& object, float* radius,
float* height) const {
if (catalog_ == nullptr) {
return false;
}
const int index = catalog_->indexOf(object.asset);
if (index < 0) {
return false;
}
const AssetEntry& entry = catalog_->entries()[static_cast<std::size_t>(index)];
if (!(entry.collisionRadius > 0.0f) || !(entry.height > 0.0f)) {
return false;
}
if (radius) { *radius = entry.collisionRadius * object.scale; }
if (height) { *height = entry.height * object.scale; }
return true;
}
uint32_t EditorScene::pick(const glm::vec3& origin, const glm::vec3& direction,
float maxDistance) const {
uint32_t closestId = kNoPlacedObject;
float closestT = maxDistance;
for (const PlacedObject& object : objects_) {
float radius = 0.0f;
float height = 0.0f;
if (!footprint(object, &radius, &height)) {
// Asset inconnu : l'objet n'est pas dessine non plus (voir main.cpp),
// il ne serait pas honnete de le rendre selectionnable a l'aveugle.
continue;
}
// La VISEE est plus genereuse que la collision : on veut pouvoir
// reprendre un poteau de 9 cm de large a dix metres sans devoir poser le
// curseur au pixel. 0,35 m, c'est le rayon du corps du joueur - donc
// "gros comme un joueur", ce qui reste discriminant entre deux objets
// voisins.
const float pickRadius = std::max(radius, 0.35f);
const glm::vec2 d2(direction.x, direction.z);
const glm::vec2 o2(origin.x - object.position.x, origin.z - object.position.z);
const float a = glm::dot(d2, d2);
if (a < 1e-6f) {
continue; // rayon quasi vertical : voir Forest::pickTree
}
const float b = 2.0f * glm::dot(o2, d2);
const float c = glm::dot(o2, o2) - pickRadius * pickRadius;
const float discriminant = b * b - 4.0f * a * c;
if (discriminant < 0.0f) {
continue;
}
const float sqrtDisc = std::sqrt(discriminant);
const float roots[2] = { (-b - sqrtDisc) / (2.0f * a),
(-b + sqrtDisc) / (2.0f * a) };
for (const float t : roots) {
if (t <= 0.05f || t >= closestT) {
continue;
}
const float y = origin.y + direction.y * t;
if (y < object.position.y || y > object.position.y + height) {
continue;
}
closestT = t;
closestId = object.id;
break;
}
}
return closestId;
}
glm::vec3 EditorScene::resolve(const BodyCylinder& body) const {
glm::vec3 position = body.position;
for (const PlacedObject& object : objects_) {
if (!object.solid) {
continue;
}
float radius = 0.0f;
float height = 0.0f;
if (!footprint(object, &radius, &height)) {
continue;
}
// Recouvrement vertical : un objet entierement sous les pieds ou
// au-dessus de la tete ne bloque pas. Meme regle que pour les souches
// depuis la Phase 6.
if (object.position.y + height < body.feetY || object.position.y > body.headY) {
continue;
}
const float minDistance = radius + body.radius;
const glm::vec2 offset(position.x - object.position.x,
position.z - object.position.z);
const float distanceSquared = glm::dot(offset, offset);
if (distanceSquared >= minDistance * minDistance) {
continue;
}
const float distance = std::sqrt(distanceSquared);
// Exactement au centre : aucune direction de repoussement n'existe. On
// en choisit une arbitraire mais DETERMINISTE (+X), sinon la position
// rendue dependrait du bruit numerique.
const glm::vec2 push = (distance > 1e-4f) ? offset / distance
: glm::vec2(1.0f, 0.0f);
position.x = object.position.x + push.x * minDistance;
position.z = object.position.z + push.y * minDistance;
}
return position;
}
bool EditorScene::overlaps(const BodyCylinder& body) const {
for (const PlacedObject& object : objects_) {
if (!object.solid) {
continue;
}
float radius = 0.0f;
float height = 0.0f;
if (!footprint(object, &radius, &height)) {
continue;
}
if (object.position.y + height < body.feetY || object.position.y > body.headY) {
continue;
}
const float minDistance = radius + body.radius;
const glm::vec2 offset(body.position.x - object.position.x,
body.position.z - object.position.z);
// Marge d'un dixieme de millimetre : resolve() repousse EXACTEMENT a
// minDistance, et un test strict sur la meme valeur rendrait "encore
// dedans" a cause de l'arrondi flottant - donc moveBody() refuserait
// tout deplacement le long d'un rocher au lieu de laisser glisser.
if (glm::dot(offset, offset) < (minDistance - 1e-4f) * (minDistance - 1e-4f)) {
return true;
}
}
return false;
}
std::size_t EditorScene::solidCount() const {
std::size_t count = 0;
for (const PlacedObject& object : objects_) {
if (object.solid) {
++count;
}
}
return count;
}
} // namespace vercora
+165
Voir le fichier
@@ -0,0 +1,165 @@
#pragma once
#include "core/CollisionSolver.hpp"
#include "editor/PlacedObject.hpp"
#include <cstdint>
#include <string>
#include <vector>
namespace vercora {
class AssetCatalog;
// (kNoPlacedObject est declare dans editor/PlacedObject.hpp, avec le champ id
// qu'il qualifie.)
// ---------------------------------------------------------------------------
// PHASE 15 : la scene editable.
// ---------------------------------------------------------------------------
// Trois responsabilites, et pas une de plus :
// 1. detenir la liste des objets poses et leurs identites stables ;
// 2. repondre aux questions du monde a leur sujet - visee (pick) et COLLISION
// (elle implemente CollisionSolver, comme la Forest depuis la Phase 6) ;
// 3. tenir la pile d'ANNULATION.
//
// Ce qu'elle ne fait PAS : lire le clavier (c'est EditorController), toucher a
// Vulkan (c'est main.cpp qui traduit en DrawItem), ou lire/ecrire un fichier
// (c'est SceneFile). Cette classe ne depend que de GLM, donc elle est EXECUTEE
// dans les tests headless - annulation, collision et visee comprises.
//
// --- COLLISION : le meme contrat que la Forest ------------------------------
// Chaque objet SOLIDE est un cylindre vertical, de rayon `collisionRadius x
// echelle` (rayon du cylindre CONTENANT l'asset, voir AssetCatalog) et de
// hauteur `height x echelle` au-dessus de son point d'ancrage.
//
// Ce cylindre est un PROXY assume. Il est exact pour un rocher ou un cairn -
// c'est-a-dire pour ce que l'editeur sert d'abord a poser - et il est FAUX pour
// tout objet a interieur : l'abri de pierre a une porte, mais son cylindre est
// plein, donc on ne peut pas y entrer. D'ou le drapeau `solid` par objet
// (PlacedObject::solid) : le remede immediat est de le poser traversable. La
// vraie reponse - une collision par volume ou par maillage - est un chantier a
// part, documente comme limite dans NOTES-PHASE15.md.
//
// --- ANNULATION -------------------------------------------------------------
// Pile d'actions INVERSIBLES, LIFO, profondeur bornee. Trois natures d'action :
// pose, suppression, transformation. Chacune retient de quoi revenir en arriere
// (l'etat AVANT) et l'indice ou l'objet se trouvait, ce qui permet a une
// suppression annulee de reprendre sa place dans la liste plutot que d'atterrir
// a la fin - l'ordre de la liste est ce que voit l'utilisateur.
//
// Les retouches de transformation SUCCESSIVES sur le meme objet sont
// REGROUPEES tant qu'elles s'enchainent a moins de `transformGroupSeconds` l'une
// de l'autre. Sans ce regroupement, tourner un rocher d'un quart de tour au pas
// de 15 degres empilerait six annulations, et "annuler" ne rendrait jamais
// l'etat d'avant la manipulation - ce qui est pourtant la seule chose qu'on
// veut. Le temps est FOURNI par l'appelant plutot que lu d'une horloge : c'est
// ce qui rend le regroupement testable.
class EditorScene : public CollisionSolver {
public:
// Le catalogue n'est PAS possede et peut etre nul : sans lui la scene reste
// parfaitement utilisable, seule la collision devient inerte (on ne connait
// plus les dimensions des assets). C'est le cas des tests qui n'exercent que
// la pile d'annulation.
explicit EditorScene(const AssetCatalog* catalog = nullptr) : catalog_(catalog) {}
void setCatalog(const AssetCatalog* catalog) { catalog_ = catalog; }
const AssetCatalog* catalog() const { return catalog_; }
// --- Contenu ------------------------------------------------------------
const std::vector<PlacedObject>& objects() const { return objects_; }
std::size_t size() const { return objects_.size(); }
bool empty() const { return objects_.empty(); }
const PlacedObject* find(uint32_t id) const;
// Indice dans objects(), ou -1.
int indexOf(uint32_t id) const;
// --- Edition ------------------------------------------------------------
// Pose un objet et renvoie son identifiant. L'identifiant du parametre est
// ignore : c'est la scene qui les attribue.
uint32_t place(PlacedObject object);
// Supprime un objet. Renvoie false si l'identifiant n'existe pas.
bool erase(uint32_t id);
// Remplace la transformation d'un objet (position / cap / echelle / solidite ;
// l'asset, lui, n'est jamais modifie - changer d'asset, c'est poser un autre
// objet). `now` est un temps en secondes, croissant, servant au regroupement
// des retouches successives.
bool transform(uint32_t id, const PlacedObject& updated, float now);
// --- Annulation ---------------------------------------------------------
// Annule la derniere action. Renvoie false si la pile est vide.
bool undo();
std::size_t undoDepth() const { return undoStack_.size(); }
// Libelle de la derniere action annulable, pour le journal ("pose d'un
// rocher", ...). Vide si la pile est vide.
std::string lastActionLabel() const;
// --- Chargement en bloc -------------------------------------------------
// Remplace tout le contenu et VIDE la pile d'annulation. Annuler par-dessus
// un chargement de fichier n'aurait aucun sens defini : la pile decrit des
// actions sur un contenu qui vient de disparaitre.
void replaceAll(std::vector<PlacedObject> objects);
void clear() { replaceAll({}); }
// --- Interrogation ------------------------------------------------------
// Premier objet touche par le rayon (cylindre englobant), ou kNoPlacedObject.
// Meme construction que Forest::pickTree, y compris le test des DEUX racines
// du cylindre pour que viser depuis l'interieur fonctionne.
uint32_t pick(const glm::vec3& origin, const glm::vec3& direction,
float maxDistance) const;
// --- CollisionSolver ----------------------------------------------------
glm::vec3 resolve(const BodyCylinder& body) const override;
bool overlaps(const BodyCylinder& body) const override;
// Nombre d'objets solides. Journalise au chargement : c'est le seul moyen de
// constater qu'une scene est entierement traversable par megarde.
std::size_t solidCount() const;
// Fenetre de regroupement des retouches de transformation, en secondes.
void setTransformGroupSeconds(float seconds) { transformGroupSeconds_ = seconds; }
float transformGroupSeconds() const { return transformGroupSeconds_; }
// Profondeur maximale de la pile d'annulation. Bornee parce qu'un editeur
// ouvert une heure accumulerait sinon des milliers d'etats ; 128 couvre
// largement une session de retouche.
static constexpr std::size_t kMaxUndoDepth = 128;
private:
enum class ActionKind { Place, Erase, Transform };
struct Action {
ActionKind kind = ActionKind::Place;
// Etat AVANT l'action, pour Erase et Transform. Pour Place, seul `id`
// compte (l'objet a annuler est celui qui vient d'etre cree).
PlacedObject before;
// Indice qu'occupait l'objet, pour qu'une suppression annulee reprenne
// sa place au lieu de sauter en fin de liste.
std::size_t index = 0;
// Horodatage de la derniere retouche, pour le regroupement.
float lastTouch = 0.0f;
};
void pushAction(Action action);
// Rayon et hauteur EFFECTIFS d'un objet (dimensions de l'asset x echelle).
// Renvoie false si le catalogue est absent ou l'asset introuvable - un objet
// dont on ne connait pas les dimensions ne peut pas bloquer le joueur, et le
// faire bloquer "au cas ou" avec des dimensions inventees serait pire.
bool footprint(const PlacedObject& object, float* radius, float* height) const;
const AssetCatalog* catalog_ = nullptr; // non possede
std::vector<PlacedObject> objects_;
std::vector<Action> undoStack_;
uint32_t nextId_ = 1;
float transformGroupSeconds_ = 0.75f;
};
} // namespace vercora
+83
Voir le fichier
@@ -0,0 +1,83 @@
#pragma once
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <cstdint>
#include <string>
namespace vercora {
// Identifiant "aucun objet". Les identifiants reels commencent a 1, ce qui rend
// zero utilisable comme absence sans valeur sentinelle a part.
//
// Declare ICI et non dans EditorScene.hpp, ou il vivait d'abord : c'est une
// valeur de PlacedObject::id, donc elle appartient au meme en-tete que le champ
// qu'elle qualifie. Le controleur, qui manipule des identifiants sans avoir
// besoin de la scene, ne doit pas avoir a inclure celle-ci pour ca.
inline constexpr uint32_t kNoPlacedObject = 0;
// ---------------------------------------------------------------------------
// PHASE 15 : un objet pose par l'editeur.
// ---------------------------------------------------------------------------
// C'est l'unite de la scene editable, et c'est exactement ce qui est serialise
// dans le fichier de scene (voir editor/SceneFile.hpp). Volontairement PLAT et
// sans pointeur : l'objet designe son asset par son IDENTIFIANT texte, pas par
// un indice de catalogue ni par un MeshHandle.
//
// Pourquoi cet indirection par nom, alors qu'un indice serait plus rapide : un
// indice de catalogue depend de l'ORDRE de scan du dossier d'assets, donc du
// systeme de fichiers. Ajouter un .obj dans assets/editor/ deplacerait tous les
// objets deja poses vers un autre modele, en silence. Le nom, lui, survit a
// l'ajout, au retrait et au renommage de tout le reste - et quand l'asset
// manque vraiment, on peut le DIRE au lieu d'afficher n'importe quoi (voir
// EditorScene::resolve).
//
// TRANSFORMATION AUTORISEE : translation, rotation autour de Y, echelle
// UNIFORME. Pas de rotation libre, pas d'echelle non uniforme. Ce n'est pas une
// limitation de l'editeur mais le contrat de `DrawItem` : le vertex shader
// utilise `mat3(model)` comme normal matrix, ce qui n'est exact que pour une
// rotation suivie d'une echelle uniforme. Autoriser plus imposerait de calculer
// et de pousser une vraie normal matrix - possible (il reste 48 octets de push
// constant) mais hors scope de cette session.
struct PlacedObject {
// Identite STABLE, attribuee par EditorScene et jamais reutilisee dans une
// session. La selection, la suppression et l'annulation raisonnent la-dessus
// et non sur un indice de tableau, qui bouge des qu'un objet est supprime au
// milieu de la liste.
uint32_t id = 0;
// Identifiant de catalogue de l'asset (ex. "rocher"). Voir plus haut.
std::string asset;
// Position monde du point d'ANCRAGE, c'est-a-dire du pied de l'objet (les
// assets d'editeur ont leur origine au sol - voir editor/EditorAssets.hpp).
glm::vec3 position{0.0f};
// Rotation autour de l'axe vertical, en degres, dans le repere main droite
// du moteur (Y vers le haut). 0 = l'asset tel qu'il a ete cree.
float yawDegrees = 0.0f;
// Echelle UNIFORME. 1 = taille reelle de l'asset.
float scale = 1.0f;
// L'objet bloque-t-il le joueur ? Voir EditorScene, qui implemente
// CollisionSolver : un objet solide est un cylindre vertical de plus dans le
// monde, au meme titre qu'un tronc.
//
// Reglable par objet et non par asset : le meme rocher peut etre un obstacle
// sur un sentier et un simple decor a flanc de falaise, la ou le joueur ne
// passera jamais. Et surtout, un asset dont l'empreinte cylindrique est
// fausse (l'abri, qui a un interieur) doit pouvoir etre pose sans bloquer.
bool solid = true;
// Matrice modele. translate * rotateY * scale : rotation suivie d'une
// echelle uniforme, donc conforme au contrat de DrawItem.
glm::mat4 modelMatrix() const {
glm::mat4 model = glm::translate(glm::mat4(1.0f), position);
model = glm::rotate(model, glm::radians(yawDegrees), glm::vec3(0.0f, 1.0f, 0.0f));
return glm::scale(model, glm::vec3(scale));
}
};
} // namespace vercora
+288
Voir le fichier
@@ -0,0 +1,288 @@
#include "editor/SceneFile.hpp"
#include "assets/Heightmap.hpp"
#include "core/Logger.hpp"
#include <cmath>
#include <cstdio>
#include <exception>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <locale>
#include <sstream>
namespace vercora {
namespace {
constexpr uint32_t kFormatVersion = 1;
// Retire le commentaire (tout ce qui suit '#') et les blancs de bord.
std::string stripComment(const std::string& line) {
const std::size_t hash = line.find('#');
std::string body = (hash == std::string::npos) ? line : line.substr(0, hash);
const std::size_t first = body.find_first_not_of(" \t\r\n");
if (first == std::string::npos) {
return {};
}
const std::size_t last = body.find_last_not_of(" \t\r\n");
return body.substr(first, last - first + 1);
}
// Flux de lecture en locale CLASSIQUE.
//
// Ce n'est pas de la precaution gratuite : dans une locale francaise, le
// separateur decimal est la VIRGULE, et un `907512.250` se relirait alors comme
// 907512 - l'objet se retrouverait a 25 cm de la, sans le moindre message. Le
// jeu ne change jamais de locale aujourd'hui, mais un fichier de donnees doit
// se relire a l'identique quoi qu'il arrive autour.
void useClassicLocale(std::ios_base& stream) { stream.imbue(std::locale::classic()); }
} // namespace
SceneLoadResult loadSceneFile(const std::string& path, const Heightmap& terrain) {
SceneLoadResult result;
std::error_code ec;
if (!std::filesystem::exists(path, ec) || ec) {
return result; // fileExisted reste false : ce n'est pas une erreur
}
result.fileExisted = true;
std::ifstream file(path);
if (!file) {
result.error = "fichier illisible";
return result;
}
useClassicLocale(file);
const float halfSize = 0.5f * terrain.worldSize();
bool headerSeen = false;
uint32_t lineNumber = 0;
std::string line;
while (std::getline(file, line)) {
++lineNumber;
const std::string body = stripComment(line);
if (body.empty()) {
continue;
}
std::istringstream fields(body);
useClassicLocale(fields);
std::string directive;
fields >> directive;
if (directive == "version") {
uint32_t version = 0;
if (!(fields >> version)) {
result.error = "ligne " + std::to_string(lineNumber) +
" : version illisible";
return result;
}
result.version = version;
headerSeen = true;
if (version > kFormatVersion) {
// On CONTINUE : les directives inconnues sont ignorees une a
// une, donc un fichier plus recent se lit partiellement au lieu
// d'etre refuse en bloc. C'est le comportement utile pour un
// outil dont le format bougera encore.
logWarn("Scene : le fichier est en version " + std::to_string(version) +
", cet executable connait la " + std::to_string(kFormatVersion) +
". Lecture au mieux, les champs inconnus seront perdus a "
"la prochaine sauvegarde.");
}
continue;
}
if (!headerSeen) {
result.error = "ligne " + std::to_string(lineNumber) +
" : la directive \"version\" doit venir en premier";
return result;
}
if (directive == "terrain") {
fields >> result.terrainLabel;
continue;
}
if (directive == "crs") {
fields >> result.epsg;
continue;
}
if (directive == "object") {
std::string asset;
double first = 0.0;
double second = 0.0;
float dz = 0.0f;
float yaw = 0.0f;
float scale = 1.0f;
int solid = 1;
if (!(fields >> asset >> first >> second >> dz >> yaw >> scale >> solid)) {
++result.skippedObjects;
logWarn("Scene : ligne " + std::to_string(lineNumber) +
" mal formee, objet ignore : " + body);
continue;
}
if (!std::isfinite(dz) || !std::isfinite(yaw) || !std::isfinite(scale) ||
!(scale > 0.0f)) {
++result.skippedObjects;
logWarn("Scene : ligne " + std::to_string(lineNumber) +
" : valeurs hors domaine (echelle nulle ou negative ?), "
"objet ignore.");
continue;
}
PlacedObject object;
object.asset = asset;
object.yawDegrees = yaw;
object.scale = scale;
object.solid = (solid != 0);
if (result.epsg != 0) {
// Coordonnees projetees : c'est Heightmap qui detient la
// convention d'axes, dans les deux sens (voir fromProjected).
terrain.fromProjected(first, second, &object.position.x,
&object.position.z);
} else {
object.position.x = static_cast<float>(first);
object.position.z = static_cast<float>(second);
}
if (std::abs(object.position.x) > halfSize ||
std::abs(object.position.z) > halfSize) {
++result.outsideExtent;
}
// Altitude ABSOLUE recalculee ici : c'est le seul endroit ou le dz
// du fichier redevient un Y monde (voir l'en-tete du header).
object.position.y =
terrain.heightAt(object.position.x, object.position.z) + dz;
result.objects.push_back(std::move(object));
continue;
}
++result.unknownDirectives;
logWarn("Scene : directive inconnue ligne " + std::to_string(lineNumber) +
", ignoree : " + directive);
}
if (!headerSeen) {
result.error = "aucune directive \"version\" : ce n'est pas un fichier .vcsc";
return result;
}
result.ok = true;
return result;
}
bool saveSceneFile(const std::string& path, const std::vector<PlacedObject>& objects,
const Heightmap& terrain, const std::string& terrainLabel) {
namespace fs = std::filesystem;
std::error_code ec;
const fs::path target(path);
if (target.has_parent_path()) {
fs::create_directories(target.parent_path(), ec);
if (ec) {
logError("Scene : impossible de creer " + target.parent_path().string() +
" (" + ec.message() + ").");
return false;
}
}
// Ecriture dans un temporaire puis renommage : voir l'en-tete du header.
fs::path temporary = target;
temporary += ".tmp";
{
std::ofstream file(temporary, std::ios::binary | std::ios::trunc);
if (!file) {
logError("Scene : impossible d'ecrire " + temporary.string() + ".");
return false;
}
useClassicLocale(file);
const bool georeferenced = terrain.geo().isGeoreferenced();
std::ostringstream out;
useClassicLocale(out);
out << "# Vercora scene v" << kFormatVersion
<< " - genere par l'editeur (Phase 15).\n"
"# Format documente dans src/editor/SceneFile.hpp et NOTES-PHASE15.md.\n"
"# object <asset> "
<< (georeferenced ? "<est> <nord>" : "<x> <z>")
<< " <dz> <cap deg> <echelle> <solide>\n";
out << "version " << kFormatVersion << "\n";
out << "terrain " << (terrainLabel.empty() ? std::string("inconnu") : terrainLabel)
<< "\n";
out << "crs " << (georeferenced ? terrain.geo().epsg : 0u) << "\n";
out << std::fixed;
for (const PlacedObject& object : objects) {
double first = 0.0;
double second = 0.0;
if (georeferenced) {
terrain.toProjected(object.position.x, object.position.z, &first, &second);
} else {
first = object.position.x;
second = object.position.z;
}
// dz : l'altitude REDEVIENT relative au terrain sous l'objet. Un
// aller-retour save/load sur le meme terrain est donc l'identite -
// c'est ce que verifie le test headless de round-trip.
const float dz = object.position.y -
terrain.heightAt(object.position.x, object.position.z);
out << "object " << object.asset << ' '
<< std::setprecision(3) << first << ' ' << second << ' '
<< dz << ' '
<< std::setprecision(3) << object.yawDegrees << ' '
<< std::setprecision(4) << object.scale << ' '
<< (object.solid ? 1 : 0) << '\n';
}
file << out.str();
if (!file) {
logError("Scene : ecriture interrompue dans " + temporary.string() + ".");
return false;
}
}
fs::rename(temporary, target, ec);
if (ec) {
// rename echoue sur certains systemes quand la cible existe deja.
fs::remove(target, ec);
fs::rename(temporary, target, ec);
if (ec) {
logError("Scene : impossible de remplacer " + target.string() + " (" +
ec.message() + ").");
return false;
}
}
return true;
}
std::string scenePathFor(const std::string& terrainPath,
const std::string& scenesDirectory) {
std::filesystem::path source(terrainPath);
std::string stem = source.stem().string();
// Meme regle que orthoPathFor dans main.cpp : le suffixe de resolution ne
// fait pas partie de l'identite du lieu.
for (const char* suffix : { "_1m", "_2m", "_5m" }) {
const std::string tail(suffix);
if (stem.size() > tail.size() &&
stem.compare(stem.size() - tail.size(), tail.size(), tail) == 0) {
stem.resize(stem.size() - tail.size());
break;
}
}
if (stem.empty()) {
stem = "scene";
}
return (std::filesystem::path(scenesDirectory) / (stem + ".vcsc")).string();
}
} // namespace vercora
+140
Voir le fichier
@@ -0,0 +1,140 @@
#pragma once
#include "editor/PlacedObject.hpp"
#include <cstdint>
#include <string>
#include <vector>
namespace vercora {
class Heightmap;
// ---------------------------------------------------------------------------
// PHASE 15 : le format de scene .vcsc (Vercora SCene).
// ---------------------------------------------------------------------------
// Fichier TEXTE, une directive par ligne, champs separes par des espaces,
// commentaires apres '#'. Encodage ASCII. Fins de ligne LF ecrites, LF et CRLF
// acceptees en lecture.
//
// # Vercora scene v1
// version 1
// terrain vercora_zone_1m.vchm
// crs 2154
// object rocher 907512.250 6440337.750 0.000 135.000 1.400 1
// object cairn 907518.900 6440341.100 0.000 0.000 1.000 1
//
// Directives :
// version <n> obligatoire, en premier. 1 pour cette session.
// terrain <nom> INFORMATIF : le nom du terrain sur lequel la scene a ete
// composee. Sert au diagnostic, jamais a refuser un
// chargement - la meme zone existe au pas de 1 m et de 2 m,
// et une scene doit passer de l'un a l'autre (c'est meme la
// raison d'etre du georeferencement ci-dessous).
// crs <epsg> 2154 = Lambert 93 : les objets portent des coordonnees
// PROJETEES. 0 = terrain sans reference geographique (le
// terrain synthetique) : coordonnees LOCALES du moteur.
// object ... un objet pose. Sept champs, dans cet ordre :
// 1. identifiant d'asset (voir editor/AssetCatalog.hpp)
// 2. est (m) ou x local si crs 0
// 3. nord (m) ou z local si crs 0
// 4. dz (m) altitude RELATIVE au terrain (voir plus bas)
// 5. cap (degres) rotation autour de la verticale
// 6. echelle (facteur uniforme, 1 = taille reelle)
// 7. solide (1 = bloque le joueur, 0 = traversable)
//
// --- POURQUOI DES COORDONNEES PROJETEES ET NON LOCALES ----------------------
// Le repere du moteur est CENTRE sur le terrain charge : (0, 0) est le milieu de
// l'emprise. Une position locale ne veut donc rien dire sans savoir QUELLE
// emprise etait chargee. Cette zone existe deja sous quatre emprises differentes
// (la dalle de Phase 7, la zone de 25 km2, ses versions a 1 m et a 2 m) et
// d'autres decoupages viendront. Enregistrer du Lambert 93 rend la scene
// independante de tout ca : un rocher pose sur la dalle isolee se retrouve au
// meme endroit du massif quand on charge la zone entiere.
//
// --- POURQUOI UNE ALTITUDE RELATIVE ET NON ABSOLUE --------------------------
// Meme raisonnement, applique a la verticale. La surface au pas de 2 m n'est pas
// exactement celle au pas de 1 m (c'est le meme relief re-echantillonne, pas le
// meme maillage), et le repli sur l'ancetre du quadtree peut afficher une tuile
// plus grossiere pendant une frame. Une altitude ABSOLUE ferait donc flotter ou
// enterrer chaque objet a la moindre variation. `dz` est l'ecart au terrain
// SOUS l'objet : un dz nul veut dire "pose au sol", et ca reste vrai partout.
// L'altitude absolue se recalcule au chargement par heightAt(x, z) + dz.
//
// --- CE QUE LE FORMAT NE STOCKE PAS, ET POURQUOI ----------------------------
// * L'IDENTIFIANT d'objet : il est attribue a la volee au chargement. C'est
// une identite de SESSION (selection, annulation), pas une propriete de la
// scene. La stocker rendrait tout deplacement de ligne visible dans un diff
// sans rien apporter.
// * La GEOMETRIE : la scene ne contient que des references d'assets. Un
// fichier de scene fait quelques centaines d'octets et se relit a l'oeil.
//
// --- ROBUSTESSE -------------------------------------------------------------
// Une directive inconnue est IGNOREE avec un avertissement plutot que de faire
// echouer le chargement : c'est ce qui permettra a une version ulterieure
// d'ajouter des champs sans qu'un fichier plus recent devienne illisible. Une
// ligne `object` mal formee est comptee et sautee - perdre un objet vaut mieux
// que perdre la scene.
// Ce que rend un chargement.
struct SceneLoadResult {
// Le fichier existe-t-il ? Un fichier absent n'est PAS une erreur : c'est le
// cas normal du premier lancement, et le jeu doit demarrer sans scene.
bool fileExisted = false;
// Le fichier a-t-il ete lu jusqu'au bout avec un en-tete valide ?
bool ok = false;
std::vector<PlacedObject> objects;
// Lignes `object` refusees (champs manquants, nombre illisible).
uint32_t skippedObjects = 0;
// Directives inconnues rencontrees.
uint32_t unknownDirectives = 0;
// Objets tombant hors de l'emprise du terrain charge. Ils sont CONSERVES
// (la scene peut avoir ete composee sur une emprise plus large), mais
// comptes : c'est le premier symptome d'une scene associee au mauvais
// terrain.
uint32_t outsideExtent = 0;
// Ce que disait l'en-tete.
std::string terrainLabel;
uint32_t version = 0;
uint32_t epsg = 0;
// Message d'echec, vide si ok.
std::string error;
};
// Charge une scene. `terrain` fournit a la fois le georeferencement (pour
// convertir les coordonnees projetees) et la surface (pour recalculer les
// altitudes absolues depuis les dz).
//
// Ne LANCE PAS : toute defaillance ressort dans le resultat. Un editeur qui
// refuse de demarrer parce qu'une ligne est fautive serait le pire des
// comportements pour un outil dont le fichier s'edite aussi a la main.
SceneLoadResult loadSceneFile(const std::string& path, const Heightmap& terrain);
// Ecrit une scene. Cree les dossiers parents si besoin.
// `terrainLabel` est recopie tel quel dans la directive `terrain`.
// Renvoie false et journalise en cas d'echec d'ecriture.
//
// L'ecriture passe par un fichier TEMPORAIRE renomme a la fin : une coupure au
// milieu d'un `save` laisserait sinon un fichier tronque a la place de la scene,
// c'est-a-dire detruirait le travail qu'on etait en train de sauvegarder.
bool saveSceneFile(const std::string& path, const std::vector<PlacedObject>& objects,
const Heightmap& terrain, const std::string& terrainLabel);
// Chemin de scene associe PAR CONVENTION a un terrain :
// assets/terrain/vercora_zone_1m.vchm -> assets/scenes/vercora_zone.vcsc
// Le suffixe de resolution est retire, exactement comme pour l'orthophoto
// (main.cpp, orthoPathFor) et pour la meme raison : 1 m et 2 m sont deux
// echantillonnages du MEME endroit, ils partagent donc leur scene.
//
// `scenesDirectory` est le dossier ou ranger les scenes (assets/scenes/).
std::string scenePathFor(const std::string& terrainPath,
const std::string& scenesDirectory);
} // namespace vercora
+3971
Voir le fichier
Diff désactivé car ce fichier est trop long. Voir la Diff
+82
Voir le fichier
@@ -0,0 +1,82 @@
#pragma once
#include "renderer/MeshData.hpp"
#include "renderer/Vertex.hpp"
#include <cstdint>
#include <vector>
namespace vercora {
// Geometrie du cube, codee en dur (Phase 1).
// 24 sommets = 4 par face, pour avoir une couleur ET une normale propres a
// chaque face (des sommets partages ne pourraient pas porter 6 normales).
// Cube centre sur l'origine, arete de 1 (coordonnees +/-0.5).
//
// Convention d'enroulement : chaque quad est defini dans l'ordre anti-horaire
// vu de l'exterieur. Le culling est desactive (voir Pipeline), donc l'ordre
// n'est pas critique ici, mais il reste correct pour activer le back-face
// culling plus tard.
inline const std::vector<Vertex> kCubeVertices = {
// Face +Z (avant) - rouge normale (0,0,1)
{{-0.5f, -0.5f, 0.5f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
{{ 0.5f, -0.5f, 0.5f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
{{ 0.5f, 0.5f, 0.5f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
{{-0.5f, 0.5f, 0.5f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
// Face -Z (arriere) - vert normale (0,0,-1)
{{ 0.5f, -0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
{{-0.5f, -0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
{{-0.5f, 0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
{{ 0.5f, 0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
// Face +X (droite) - bleu normale (1,0,0)
{{ 0.5f, -0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f, 0.0f}},
{{ 0.5f, -0.5f, -0.5f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f, 0.0f}},
{{ 0.5f, 0.5f, -0.5f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f, 0.0f}},
{{ 0.5f, 0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f, 0.0f}},
// Face -X (gauche) - jaune normale (-1,0,0)
{{-0.5f, -0.5f, -0.5f}, {1.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
{{-0.5f, -0.5f, 0.5f}, {1.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
{{-0.5f, 0.5f, 0.5f}, {1.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
{{-0.5f, 0.5f, -0.5f}, {1.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
// Face +Y (haut) - magenta normale (0,1,0)
{{-0.5f, 0.5f, 0.5f}, {1.0f, 0.0f, 1.0f}, {0.0f, 1.0f, 0.0f}},
{{ 0.5f, 0.5f, 0.5f}, {1.0f, 0.0f, 1.0f}, {0.0f, 1.0f, 0.0f}},
{{ 0.5f, 0.5f, -0.5f}, {1.0f, 0.0f, 1.0f}, {0.0f, 1.0f, 0.0f}},
{{-0.5f, 0.5f, -0.5f}, {1.0f, 0.0f, 1.0f}, {0.0f, 1.0f, 0.0f}},
// Face -Y (bas) - cyan normale (0,-1,0)
{{-0.5f, -0.5f, -0.5f}, {0.0f, 1.0f, 1.0f}, {0.0f, -1.0f, 0.0f}},
{{ 0.5f, -0.5f, -0.5f}, {0.0f, 1.0f, 1.0f}, {0.0f, -1.0f, 0.0f}},
{{ 0.5f, -0.5f, 0.5f}, {0.0f, 1.0f, 1.0f}, {0.0f, -1.0f, 0.0f}},
{{-0.5f, -0.5f, 0.5f}, {0.0f, 1.0f, 1.0f}, {0.0f, -1.0f, 0.0f}},
};
// 2 triangles par face : (0,1,2) et (2,3,0), decales de 4 par face.
inline const std::vector<uint32_t> kCubeIndices = {
0, 1, 2, 2, 3, 0, // +Z
4, 5, 6, 6, 7, 4, // -Z
8, 9, 10, 10, 11, 8, // +X
12, 13, 14, 14, 15, 12, // -X
16, 17, 18, 18, 19, 16, // +Y
20, 21, 22, 22, 23, 20, // -Y
};
// Emballe le cube en dur dans le meme MeshData que celui produit par le loader
// .obj (Phase 3). Le cube reste ainsi utilisable tel quel comme geometrie de
// repli / de reference : meme chemin de code, meme classe Mesh, aucune
// duplication du cote GPU.
// Les sommets du cube ne portent pas d'UV : le membre Vertex::uv garde sa valeur
// par defaut (0,0), ce qui est sans effet tant qu'aucun shader ne l'utilise.
inline MeshData cubeMeshData() {
MeshData data;
data.name = "cube (geometrie en dur, Phase 1)";
data.vertices = kCubeVertices;
data.indices = kCubeIndices;
return data;
}
} // namespace vercora
+118
Voir le fichier
@@ -0,0 +1,118 @@
#pragma once
#include "renderer/InstanceData.hpp"
#include <glm/glm.hpp>
#include <cstdint>
namespace vercora {
// Identifie une geometrie enregistree aupres du Renderer (Renderer::addMesh).
// C'est un simple indice : le Renderer possede les Mesh, l'appelant ne manipule
// que des poignees, ce qui evite d'exposer Vulkan au code de gameplay.
using MeshHandle = uint32_t;
inline constexpr MeshHandle kInvalidMesh = static_cast<MeshHandle>(-1);
// Quel couple de shaders utiliser pour dessiner un objet.
// Volontairement un enum ferme et non un ShaderSet libre : le Renderer cree UN
// pipeline par valeur, et trie les draws par materiau pour limiter les
// changements de pipeline. Ajouter un materiau = ajouter une valeur ici et sa
// paire de shaders dans kMaterialShaders.
enum class Material : uint32_t {
// Couleur de sommet + Blinn-Phong (Phase 2). Cube, meshes .obj, arbres.
Object = 0,
// Coloration par altitude et par pente (Phase 4). Reserve au terrain.
Terrain = 1,
// PHASE 11. Vegetation INSTANCIEE : arbres de decor et touffes d'herbe.
// Un seul materiau pour les deux, et non deux : ils partagent exactement le
// meme besoin (une geometrie, N transformations reduites, un eclairage
// Blinn-Phong). Ce qui les distingue - l'ondulation, la teinte, la portee -
// tient dans le maillage et dans les push constants, pas dans le pipeline.
Foliage = 2,
};
inline constexpr uint32_t kMaterialCount = 3;
// Une instance a dessiner : une geometrie, une transformation, un materiau.
//
// La model matrix voyage par PUSH CONSTANT (et non plus par l'UBO comme en
// Phases 1 a 4) : elle change d'un objet a l'autre a l'interieur d'une meme
// frame, alors que l'UBO est ecrit une seule fois par frame. 64 octets, donc
// tres en dessous des 128 garantis par la spec Vulkan pour maxPushConstantsSize.
//
// CONTRAINTE : la partie lineaire de `model` doit rester une rotation
// eventuellement suivie d'une echelle UNIFORME. Le vertex shader utilise
// mat3(model) comme normal matrix, ce qui n'est exact que dans ce cas (une
// echelle uniforme ne change que la longueur de la normale, absorbee par le
// normalize() du fragment shader). Une echelle non uniforme imposerait de
// calculer transpose(inverse(mat3(model))) cote CPU et de la pousser en plus.
struct DrawItem {
MeshHandle mesh = kInvalidMesh;
glm::mat4 model{1.0f};
Material material = Material::Object;
// Parametres libres pousses au vertex shader a cote de la model matrix.
//
// ATTENTION : leur signification depend du MATERIAU. C'est le meme bloc de
// push constants pour tous les pipelines - c'est ce qui permet a un seul
// pipeline layout de les servir tous - mais chaque paire de shaders
// l'interprete a sa facon. Deux conventions coexistent aujourd'hui :
//
// Material::Terrain (PHASE 10, shaders/terrain.vert)
// x = debut de la bande de geomorphing, y = fin, en unites monde
// (metres) mesurees depuis la camera ; zw reserves.
// Une bande VIDE (y <= x, le defaut) desactive le morphing. C'est ce qui
// permet a toute geometrie qui n'est pas une tuile de quadtree - cube,
// arbres, terrain d'un seul bloc en --no-lod - de traverser le meme
// pipeline sans rien changer.
//
// Material::Object (PHASE 15, shaders/cube.vert et cube.frag)
// x = force de la teinte de temoin de l'editeur, 0 = aucune ;
// yzw = couleur de cette teinte.
// Sert a distinguer le fantome de pose et l'objet selectionne du meme
// modele pose normalement, SANS transparence donc sans tri en
// profondeur. Une force nulle - le cas de tous les DrawItem du jeu -
// laisse le rendu strictement identique a celui d'avant la Phase 15.
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
};
// Ce que le Renderer pousse REELLEMENT en push constant, dans cet ordre.
// Duplique volontairement les deux membres correspondants de DrawItem : ce type
// decrit le bloc `push_constant` des shaders (donc un layout impose de
// l'exterieur), la ou DrawItem decrit une intention de rendu cote gameplay. Les
// melanger obligerait a garder `mesh` et `material` - inutiles au GPU - dans un
// budget de push constants qui ne fait que 128 octets garantis.
//
// 80 octets : toujours tres en dessous des 128 garantis par la spec Vulkan pour
// maxPushConstantsSize.
struct DrawItemPush {
glm::mat4 model{1.0f};
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
};
// ---------------------------------------------------------------------------
// PHASE 11 : dessin INSTANCIE
// ---------------------------------------------------------------------------
// Une geometrie dessinee N fois en un seul appel, chaque exemplaire lisant sa
// transformation dans un tableau d'InstanceData (voir InstanceData.hpp).
//
// Les instances ne sont PAS possedees ici : le pointeur doit rester valide
// jusqu'au retour de drawFrame, qui les recopie dans un buffer de la frame. Ce
// choix evite une allocation par frame et par especes de vegetation, alors que
// l'appelant, lui, produit deja ses instances dans un vecteur qu'il reutilise.
struct InstancedDrawItem {
MeshHandle mesh = kInvalidMesh;
const InstanceData* instances = nullptr;
uint32_t count = 0;
Material material = Material::Foliage;
// Pousses au vertex shader comme pour un DrawItem.
// PHASE 11 : x = amplitude d'ondulation en metres (0 pour un arbre),
// y = temps en secondes, z = distance de rendu (pour information du shader),
// w = reserve.
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
};
} // namespace vercora
+66
Voir le fichier
@@ -0,0 +1,66 @@
#pragma once
#include <glm/glm.hpp>
namespace vercora {
// Une instance de vegetation : ce qui distingue un arbre (ou une touffe d'herbe)
// de tous les autres, envoye au GPU dans un buffer a part.
//
// PHASE 11. Jusqu'ici chaque objet du monde etait un DrawItem, donc UN appel de
// dessin et une matrice poussee en push constant. C'est parfait pour quelques
// dizaines d'arbres abattables ; ca ne l'est plus du tout pour les dizaines de
// milliers d'arbres et les centaines de milliers de touffes d'herbe que demande
// une zone de 25 km2. Un appel de dessin par touffe couterait, a lui seul, bien
// plus cher que tout le terrain.
//
// D'ou l'instanciation : UNE geometrie, UN appel de dessin, N instances lues
// dans un second binding de sommets cadence par instance
// (VK_VERTEX_INPUT_RATE_INSTANCE) au lieu de par sommet.
//
// POURQUOI PAS UNE MATRICE 4x4 PAR INSTANCE (64 octets). Une instance de
// vegetation ne subit qu'une rotation autour de Y, une echelle uniforme et une
// translation : sept flottants suffisent a la decrire (les deux derniers etant
// des variations d'aspect), contre seize pour la matrice generale. Sur 300 000
// touffes, la difference est de 11 Mo par frame ecrits sur un bus partage avec
// le CPU. La matrice est reconstituee dans le vertex shader, ou elle ne coute
// que quelques instructions.
//
// 28 octets : glm::vec3 s'aligne sur 4 comme un float, donc la struct est
// exactement la somme de ses membres, sans remplissage. Cette taille EST le
// stride du binding d'instances, d'ou l'assertion en fin de fichier.
struct InstanceData {
// Pied de l'instance, en espace monde (le terrain est genere en espace monde
// avec une model matrix identite, cf. TerrainMesh.cpp).
glm::vec3 position{0.0f};
// Echelle UNIFORME. Non uniforme serait possible mais obligerait le vertex
// shader a corriger la normale par l'inverse transpose, pour un gain visuel
// nul sur de la vegetation.
float scale = 1.0f;
// Rotation autour de Y, en radians. Le sinus et le cosinus sont calcules
// dans le vertex shader : les precalculer ici couterait 4 octets de plus par
// instance pour economiser deux instructions par sommet, ce qui est le
// mauvais cote du compromis quand le poste limitant est la bande passante.
float yaw = 0.0f;
// Aleas propres a l'instance, dans [0,1] : sert a varier la teinte et, pour
// l'herbe, a dephaser l'ondulation afin que deux touffes voisines ne bougent
// pas a l'unisson.
float variation = 0.0f;
// Attenuation de distance, dans [0,1] : 1 en pleine visibilite, tendant vers
// 0 a la limite de rendu. Le vertex shader s'en sert pour RETRECIR l'instance
// plutot que pour la rendre transparente - une instance qui rapetisse
// disparait sans avoir besoin de melange alpha, donc sans imposer de tri en
// profondeur ni de seconde passe. C'est ce qui rend le fondu de l'herbe
// gratuit.
float fade = 1.0f;
};
static_assert(sizeof(InstanceData) == 28,
"InstanceData doit rester compact et sans remplissage : sa taille "
"est le stride du binding d'instances decrit dans VertexFormat.hpp.");
} // namespace vercora
+118
Voir le fichier
@@ -0,0 +1,118 @@
#include "renderer/Mesh.hpp"
#include "core/Logger.hpp"
#include "renderer/MeshData.hpp"
#include "renderer/VulkanBuffer.hpp"
#include "renderer/VulkanContext.hpp"
#include <stdexcept>
#include <string>
namespace vercora {
Mesh::Mesh(VulkanContext& context,
BufferUploader& uploader,
const MeshData& data,
bool log) {
// --- Validation AVANT toute allocation Vulkan ---------------------------
// Un index hors limites ne produit pas d'erreur a la creation du buffer :
// il se manifesterait au draw, sous forme de lecture hors du vertex buffer
// (comportement indefini cote GPU). Mieux vaut refuser ici, avec un message
// qui dit quoi.
if (data.vertices.empty()) {
throw std::runtime_error("Mesh vide : aucun sommet (" + data.name + ").");
}
if (data.indices.empty()) {
throw std::runtime_error("Mesh vide : aucun index (" + data.name + ").");
}
if (data.indices.size() % 3 != 0) {
throw std::runtime_error(
"Mesh non triangule : " + std::to_string(data.indices.size()) +
" index, ce qui n'est pas un multiple de 3 (" + data.name + ").");
}
const auto vertexCount = static_cast<uint32_t>(data.vertices.size());
for (uint32_t index : data.indices) {
if (index >= vertexCount) {
throw std::runtime_error(
"Index hors limites dans le mesh : " + std::to_string(index) +
" pour " + std::to_string(vertexCount) + " sommets (" + data.name + ").");
}
}
vertexCount_ = vertexCount;
indexCount_ = static_cast<uint32_t>(data.indices.size());
// --- Upload GPU ---------------------------------------------------------
vertexBuffer_ = createDeviceLocalBuffer(
context, uploader,
data.vertices.data(),
sizeof(data.vertices[0]) * data.vertices.size(),
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
indexBuffer_ = createDeviceLocalBuffer(
context, uploader,
data.indices.data(),
sizeof(data.indices[0]) * data.indices.size(),
VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
if (log) {
logInfo("Mesh charge sur le GPU : " + data.name + " - " +
std::to_string(vertexCount_) + " sommets, " +
std::to_string(indexCount_ / 3) + " triangles.");
}
}
Mesh::~Mesh() = default; // les buffers se detruisent avec leurs unique_ptr
std::unique_ptr<VulkanBuffer> Mesh::createDeviceLocalBuffer(
VulkanContext& context,
BufferUploader& uploader,
const void* data,
VkDeviceSize size,
VkBufferUsageFlags usage) {
// 1. Staging host-visible : accessible au CPU, on y ecrit la geometrie.
auto staging = std::make_unique<VulkanBuffer>(
context, size,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
staging->writeToBuffer(data, size);
// 2. Buffer final device-local : rapide pour le GPU, non mappable.
auto buffer = std::make_unique<VulkanBuffer>(
context, size,
VK_BUFFER_USAGE_TRANSFER_DST_BIT | usage,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
// 3. PHASE 12 : la copie est CONFIEE, pas attendue. Le staging part avec
// elle - il doit survivre jusqu'a l'execution de la frame qui portera la
// commande de copie, ce qui n'est plus une duree connue ici. C'est tout
// le changement : avant, cette ligne bloquait le thread jusqu'a ce que le
// GPU ait vide sa queue.
uploader.enqueueCopy(std::move(staging), buffer->handle());
return buffer;
}
void Mesh::bind(VkCommandBuffer commandBuffer) const {
const VkBuffer buffers[] = { vertexBuffer_->handle() };
const VkDeviceSize offsets[] = { 0 };
vkCmdBindVertexBuffers(commandBuffer, 0, 1, buffers, offsets);
// uint32 : suffisant pour de gros meshes, indispensable pour du terrain
// LiDAR plus tard (uint16 plafonnerait a 65536 sommets).
vkCmdBindIndexBuffer(commandBuffer, indexBuffer_->handle(), 0, VK_INDEX_TYPE_UINT32);
}
void Mesh::draw(VkCommandBuffer commandBuffer) const {
vkCmdDrawIndexed(commandBuffer, indexCount_, 1, 0, 0, 0);
}
void Mesh::drawInstanced(VkCommandBuffer commandBuffer, uint32_t instanceCount) const {
if (instanceCount == 0) {
return; // un draw a zero instance est legal mais inutile
}
vkCmdDrawIndexed(commandBuffer, indexCount_, instanceCount, 0, 0, 0);
}
} // namespace vercora
+81
Voir le fichier
@@ -0,0 +1,81 @@
#pragma once
#include <vulkan/vulkan.h>
#include <cstdint>
#include <memory>
namespace vercora {
class VulkanContext;
class VulkanBuffer;
class BufferUploader;
struct MeshData;
// Un mesh pret a etre dessine : vertex buffer + index buffer device-local et
// leurs compteurs. Interchangeable par construction : le Renderer ne sait pas
// d'ou vient la geometrie (fichier .obj, cube code en dur, terrain genere plus
// tard), il recoit un Mesh et l'affiche.
//
// L'upload passe par VulkanBuffer (staging host-visible -> device-local), le
// meme chemin que la Phase 1, factorise ici en une seule fonction.
//
// PHASE 12 : cet upload n'ATTEND PLUS le GPU. La copie est confiee a un
// BufferUploader (le Renderer), qui l'enregistre en tete du command buffer de la
// frame suivante ; le constructeur revient des que la geometrie a ete recopiee
// dans un buffer staging, sans aucune synchronisation. Consequence a garder en
// tete : les buffers du Mesh ne contiennent la geometrie qu'a partir de
// l'execution de cette frame - c'est-a-dire avant tout draw qui pourrait les
// lire, puisque la copie est enregistree AVANT le render pass et separee de lui
// par une barriere.
class Mesh {
public:
// `uploader` recoit les copies staging -> device-local. Il doit vivre plus
// longtemps que la frame en cours (en pratique c'est le Renderer lui-meme).
// Lance std::runtime_error si la geometrie est vide ou incoherente.
// `log` a false pour les geometries creees en masse (les tuiles du quadtree
// de la Phase 10) : une ligne de journal par tuile noierait toute autre
// information et couterait plus cher que l'upload lui-meme.
Mesh(VulkanContext& context,
BufferUploader& uploader,
const MeshData& data,
bool log = true);
~Mesh();
Mesh(const Mesh&) = delete;
Mesh& operator=(const Mesh&) = delete;
// Lie les buffers du mesh au command buffer courant.
void bind(VkCommandBuffer commandBuffer) const;
// Emet le draw indexe. A appeler apres bind() et apres avoir lie les
// descriptor sets / le pipeline.
void draw(VkCommandBuffer commandBuffer) const;
// PHASE 11 : meme dessin, repete `instanceCount` fois. Les instances lisent
// leurs attributs dans le binding 1, que l'appelant doit avoir lie (le Mesh
// ne connait que sa propre geometrie, pas le buffer d'instances, qui vit
// dans le Renderer et change a chaque frame).
void drawInstanced(VkCommandBuffer commandBuffer, uint32_t instanceCount) const;
uint32_t vertexCount() const { return vertexCount_; }
uint32_t indexCount() const { return indexCount_; }
private:
// Cree un buffer device-local et CONFIE a l'uploader la copie depuis un
// staging temporaire. Commun au vertex buffer et a l'index buffer.
static std::unique_ptr<VulkanBuffer> createDeviceLocalBuffer(
VulkanContext& context,
BufferUploader& uploader,
const void* data,
VkDeviceSize size,
VkBufferUsageFlags usage);
std::unique_ptr<VulkanBuffer> vertexBuffer_;
std::unique_ptr<VulkanBuffer> indexBuffer_;
uint32_t vertexCount_ = 0;
uint32_t indexCount_ = 0;
};
} // namespace vercora
+33
Voir le fichier
@@ -0,0 +1,33 @@
#pragma once
#include "renderer/Vertex.hpp"
#include <cstdint>
#include <string>
#include <vector>
namespace vercora {
// Geometrie cote CPU, independante de Vulkan : ce que produit un loader
// (ObjLoader) ou un generateur (CubeMesh), et ce que consomme la classe Mesh
// pour remplir ses buffers GPU.
//
// Separer ce type de Mesh permet de valider/inspecter/transformer la geometrie
// AVANT de toucher au GPU (et donc de refuser un fichier invalide sans avoir
// alloue quoi que ce soit cote Vulkan).
struct MeshData {
std::vector<Vertex> vertices;
std::vector<uint32_t> indices;
// Nom lisible (fichier source ou libelle) : sert aux logs et au titre de
// la fenetre, pas au rendu.
std::string name;
bool empty() const { return vertices.empty() || indices.empty(); }
uint32_t triangleCount() const {
return static_cast<uint32_t>(indices.size() / 3);
}
};
} // namespace vercora
+249
Voir le fichier
@@ -0,0 +1,249 @@
#include "renderer/Pipeline.hpp"
#include "core/Logger.hpp"
#include "core/Paths.hpp"
#include "renderer/DrawItem.hpp"
#include "renderer/VertexFormat.hpp"
#include <glm/glm.hpp>
#include <array>
#include <fstream>
#include <stdexcept>
#include <vector>
namespace vercora {
Pipeline::Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayout descriptorSetLayout,
const ShaderSet& shaders)
: device_(device) {
// PHASE 21 : le dossier shaders\ a cote de l'executable s'il existe (cas du
// package distribue), sinon SHADERS_OUTPUT_DIR defini par CMake (cas du
// developpement). Voir core/Paths.hpp.
const std::string shaderDir = shadersDir() + "/";
const std::vector<char> vertCode = readFile(shaderDir + shaders.vertexSpv);
const std::vector<char> fragCode = readFile(shaderDir + shaders.fragmentSpv);
VkShaderModule vertModule = createShaderModule(vertCode);
VkShaderModule fragModule = createShaderModule(fragCode);
VkPipelineShaderStageCreateInfo vertStage{};
vertStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vertStage.stage = VK_SHADER_STAGE_VERTEX_BIT;
vertStage.module = vertModule;
vertStage.pName = "main";
VkPipelineShaderStageCreateInfo fragStage{};
fragStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
fragStage.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
fragStage.module = fragModule;
fragStage.pName = "main";
const std::array<VkPipelineShaderStageCreateInfo, 2> stages = { vertStage, fragStage };
// Vertex input : un binding entrelace, et autant d'attributs que le vertex
// shader en consomme reellement - quatre (pos, color, normal, uv) pour les
// objets, six pour le terrain, dont la cible de geomorphing. Le STRIDE, lui,
// reste toujours sizeof(Vertex) : le format de sommet cote C++ est unique.
const auto bindingDescription = vertexBindingDescription();
const auto attributeDescriptions = vertexAttributeDescriptions();
const uint32_t attributeCount = shaders.usesMorphAttributes
? static_cast<uint32_t>(attributeDescriptions.size())
: 4u;
// PHASE 11 : un materiau instancie decrit DEUX bindings (sommets et
// instances) et concatene leurs attributs. Les tableaux sont construits ici
// meme pour que leur duree de vie couvre l'appel a vkCreateGraphicsPipelines.
const auto instanceBinding = instanceBindingDescription();
const auto instanceAttributes = instanceAttributeDescriptions();
std::vector<VkVertexInputBindingDescription> bindings{ bindingDescription };
std::vector<VkVertexInputAttributeDescription> attributes(
attributeDescriptions.begin(), attributeDescriptions.begin() + attributeCount);
// PHASE 27 : une passe plein ecran ne lit AUCUN buffer de sommets.
if (shaders.fullscreenOverlay) {
bindings.clear();
attributes.clear();
}
if (shaders.usesInstancing) {
bindings.push_back(instanceBinding);
attributes.insert(attributes.end(),
instanceAttributes.begin(), instanceAttributes.end());
}
VkPipelineVertexInputStateCreateInfo vertexInput{};
vertexInput.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInput.vertexBindingDescriptionCount = static_cast<uint32_t>(bindings.size());
vertexInput.pVertexBindingDescriptions = bindings.data();
vertexInput.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributes.size());
vertexInput.pVertexAttributeDescriptions = attributes.data();
VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
inputAssembly.primitiveRestartEnable = VK_FALSE;
// Viewport/scissor dynamiques : leur contenu est fixe au moment du rendu.
VkPipelineViewportStateCreateInfo viewportState{};
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewportState.viewportCount = 1;
viewportState.scissorCount = 1;
VkPipelineRasterizationStateCreateInfo rasterizer{};
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rasterizer.depthClampEnable = VK_FALSE;
rasterizer.rasterizerDiscardEnable = VK_FALSE;
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
rasterizer.lineWidth = 1.0f;
rasterizer.cullMode = VK_CULL_MODE_NONE; // pas de culling : triangle toujours visible
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
rasterizer.depthBiasEnable = VK_FALSE;
VkPipelineMultisampleStateCreateInfo multisampling{};
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
multisampling.sampleShadingEnable = VK_FALSE;
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
VkPipelineColorBlendAttachmentState colorBlendAttachment{};
colorBlendAttachment.colorWriteMask =
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
colorBlendAttachment.blendEnable = VK_FALSE;
if (shaders.fullscreenOverlay) {
// Melange "over" classique : la precipitation se pose sur l'image.
colorBlendAttachment.blendEnable = VK_TRUE;
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
}
VkPipelineColorBlendStateCreateInfo colorBlending{};
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
colorBlending.logicOpEnable = VK_FALSE;
colorBlending.attachmentCount = 1;
colorBlending.pAttachments = &colorBlendAttachment;
// Depth testing : on garde le fragment le plus proche (compareOp LESS) et on
// ecrit sa profondeur. Indispensable pour un rendu 3D correct.
VkPipelineDepthStencilStateCreateInfo depthStencil{};
depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
depthStencil.depthTestEnable = VK_TRUE;
depthStencil.depthWriteEnable = VK_TRUE;
depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
if (shaders.fullscreenOverlay) {
depthStencil.depthTestEnable = VK_FALSE;
depthStencil.depthWriteEnable = VK_FALSE;
}
depthStencil.depthBoundsTestEnable = VK_FALSE;
depthStencil.stencilTestEnable = VK_FALSE;
const std::array<VkDynamicState, 2> dynamicStates = {
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR
};
VkPipelineDynamicStateCreateInfo dynamicState{};
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
dynamicState.pDynamicStates = dynamicStates.data();
// Un descriptor set (l'UBO : view/proj/viewPos/terrain, constant sur la
// frame) + un push constant (la model matrix, propre a chaque objet dessine).
//
// Push constant plutot qu'un second UBO ou un offset dynamique : depuis la
// Phase 5 une frame dessine plusieurs objets (terrain, arbres, souches,
// buches) et chacun a sa propre transformation. 80 octets depuis la Phase 10
// (la bande de geomorphing de la tuile s'y ajoute) : toujours largement dans
// les 128 que la spec Vulkan garantit sur toute implementation.
// Stage VERTEX uniquement : le fragment shader n'en a pas besoin (il
// travaille sur des varyings deja en espace monde).
VkPushConstantRange modelRange{};
modelRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
modelRange.offset = 0;
// La plage couvre model + params (voir DrawItemPush). Elle est la MEME pour
// les deux materiaux, meme si cube.vert n'utilise pas params : une plage
// identique garde les deux pipeline layouts compatibles, ce dont depend le
// fait de ne relier le descriptor set qu'une fois par materiau.
modelRange.size = static_cast<uint32_t>(sizeof(DrawItemPush));
VkPipelineLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
layoutInfo.setLayoutCount = 1;
layoutInfo.pSetLayouts = &descriptorSetLayout;
layoutInfo.pushConstantRangeCount = 1;
layoutInfo.pPushConstantRanges = &modelRange;
if (vkCreatePipelineLayout(device_, &layoutInfo, nullptr, &pipelineLayout_) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation du pipeline layout.");
}
VkGraphicsPipelineCreateInfo pipelineInfo{};
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipelineInfo.stageCount = static_cast<uint32_t>(stages.size());
pipelineInfo.pStages = stages.data();
pipelineInfo.pVertexInputState = &vertexInput;
pipelineInfo.pInputAssemblyState = &inputAssembly;
pipelineInfo.pViewportState = &viewportState;
pipelineInfo.pRasterizationState = &rasterizer;
pipelineInfo.pMultisampleState = &multisampling;
pipelineInfo.pDepthStencilState = &depthStencil;
pipelineInfo.pColorBlendState = &colorBlending;
pipelineInfo.pDynamicState = &dynamicState;
pipelineInfo.layout = pipelineLayout_;
pipelineInfo.renderPass = renderPass;
pipelineInfo.subpass = 0;
if (vkCreateGraphicsPipelines(device_, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr,
&graphicsPipeline_) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation du pipeline graphique.");
}
// Les modules ne sont plus necessaires une fois le pipeline construit.
vkDestroyShaderModule(device_, fragModule, nullptr);
vkDestroyShaderModule(device_, vertModule, nullptr);
logInfo("Pipeline graphique cree (" + shaders.vertexSpv + " + " +
shaders.fragmentSpv + ").");
}
Pipeline::~Pipeline() {
if (graphicsPipeline_ != VK_NULL_HANDLE) {
vkDestroyPipeline(device_, graphicsPipeline_, nullptr);
}
if (pipelineLayout_ != VK_NULL_HANDLE) {
vkDestroyPipelineLayout(device_, pipelineLayout_, nullptr);
}
}
VkShaderModule Pipeline::createShaderModule(const std::vector<char>& code) const {
VkShaderModuleCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = code.size();
createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());
VkShaderModule module = VK_NULL_HANDLE;
if (vkCreateShaderModule(device_, &createInfo, nullptr, &module) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation d'un shader module.");
}
return module;
}
std::vector<char> Pipeline::readFile(const std::string& path) {
// ate : on se place a la fin pour connaitre la taille directement.
std::ifstream file(path, std::ios::ate | std::ios::binary);
if (!file.is_open()) {
throw std::runtime_error("Impossible d'ouvrir le fichier shader : " + path);
}
const size_t fileSize = static_cast<size_t>(file.tellg());
std::vector<char> buffer(fileSize);
file.seekg(0);
file.read(buffer.data(), static_cast<std::streamsize>(fileSize));
file.close();
return buffer;
}
} // namespace vercora
+84
Voir le fichier
@@ -0,0 +1,84 @@
#pragma once
#include <vulkan/vulkan.h>
#include <string>
#include <vector>
namespace vercora {
// Paire de shaders a charger, designee par le NOM des fichiers .spv produits
// par CMake dans SHADERS_OUTPUT_DIR (et non par un chemin complet : le
// repertoire est une affaire de build, pas d'appelant).
struct ShaderSet {
std::string vertexSpv;
std::string fragmentSpv;
// true si le vertex shader consomme les attributs de geomorphing
// (locations 4 et 5, voir Vertex.hpp). Seul terrain.vert le fait.
//
// Ce drapeau n'est pas une optimisation mais une CORRECTION : declarer dans
// le vertex input un attribut qu'aucun shader ne lit fait emettre aux
// couches de validation "Vertex attribute at location 4 not consumed by
// vertex shader", et le contrat du projet est zero message de validation. Le
// format de sommet reste unique cote C++ ; c'est seulement sa DESCRIPTION au
// pipeline qui est tronquee pour les materiaux qui n'en lisent qu'une partie
// (ce que Vulkan autorise : un binding peut avoir un stride plus grand que
// la somme des attributs decrits).
bool usesMorphAttributes = false;
// PHASE 11. true si le pipeline doit decrire le second binding de sommets,
// cadence par instance (voir VertexFormat.hpp). Meme raisonnement que
// usesMorphAttributes : c'est une CORRECTION, pas une optimisation. Decrire
// un binding d'instances a un pipeline non instancie obligerait a lier un
// buffer d'instances avant de dessiner un cube, et ne pas le decrire a un
// pipeline instancie ferait echouer la validation sur les locations 6 a 8.
bool usesInstancing = false;
// PHASE 27 : passe PLEIN ECRAN. Aucune entree de sommet (le vertex shader
// fabrique un triangle couvrant a partir de gl_VertexIndex), pas de test
// ni d'ecriture de profondeur, melange par alpha.
bool fullscreenOverlay = false;
};
// Shaders de la Phase 2 : couleur par sommet + Blinn-Phong. Utilises par le
// cube en dur et par les meshes .obj.
inline const ShaderSet kObjectShaders{ "cube.vert.spv", "cube.frag.spv" };
// Shaders de la Phase 4 : coloration par altitude et par pente + Blinn-Phong.
inline const ShaderSet kTerrainShaders{ "terrain.vert.spv", "terrain.frag.spv", true };
// Shaders de la Phase 11 : vegetation instanciee (arbres de decor et herbe).
// Ne lit PAS les attributs de geomorphing, mais lit le binding d'instances.
inline const ShaderSet kFoliageShaders{ "foliage.vert.spv", "foliage.frag.spv",
false, true };
// PHASE 27 : pluie et neige a l'ecran. Voir shaders/precip.frag.
inline const ShaderSet kPrecipitationShaders{ "precip.vert.spv", "precip.frag.spv",
false, false, true };
// Charge les shaders SPIR-V et construit le pipeline graphique.
// Viewport et scissor sont dynamiques : le pipeline n'a donc PAS besoin d'etre
// recree au resize (on les fixe dans le command buffer).
class Pipeline {
public:
Pipeline(VkDevice device, VkRenderPass renderPass, VkDescriptorSetLayout descriptorSetLayout,
const ShaderSet& shaders);
~Pipeline();
Pipeline(const Pipeline&) = delete;
Pipeline& operator=(const Pipeline&) = delete;
VkPipeline handle() const { return graphicsPipeline_; }
VkPipelineLayout layout() const { return pipelineLayout_; }
private:
VkShaderModule createShaderModule(const std::vector<char>& code) const;
static std::vector<char> readFile(const std::string& path);
VkDevice device_ = VK_NULL_HANDLE;
VkPipelineLayout pipelineLayout_ = VK_NULL_HANDLE;
VkPipeline graphicsPipeline_ = VK_NULL_HANDLE;
};
} // namespace vercora
+1002
Voir le fichier
Diff désactivé car ce fichier est trop long. Voir la Diff
+408
Voir le fichier
@@ -0,0 +1,408 @@
#pragma once
#include "renderer/DrawItem.hpp"
#include "renderer/Pipeline.hpp" // pour ShaderSet
#include "renderer/VulkanBuffer.hpp" // pour BufferUploader
#include <glm/glm.hpp>
#include <vulkan/vulkan.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <memory>
#include <vector>
namespace vercora {
class VulkanContext;
class Window;
class SwapChain;
class Camera;
class Mesh;
class Texture;
struct MeshData;
struct TextureData;
// Ce que le Renderer doit savoir de la scene, en plus de sa geometrie.
// Regroupe ici plutot qu'en parametres separes : la liste s'allongera (soleil,
// brouillard, ...) et un struct nomme reste lisible sur l'appel.
struct RenderOptions {
// Altitudes min/max du terrain, transmises au fragment shader pour sa
// coloration. Ignore par les shaders d'objet.
glm::vec2 heightRange{0.0f, 1.0f};
// Couleur d'effacement de l'attache couleur. Par defaut le bleu nuit des
// phases precedentes, qui fait ressortir un objet isole ; un terrain, lui,
// a besoin d'un ciel pour que la ligne d'horizon soit lisible.
glm::vec3 clearColor{0.01f, 0.01f, 0.03f};
// Plans de la projection perspective. Le terrain est bien plus etendu qu'un
// objet isole : son far plane doit suivre, sinon l'horizon est tronque.
float nearPlane = 0.1f;
float farPlane = 100.0f;
// PHASE 11. Dosage entre coloration PROCEDURALE (0 : altitude + pente, le
// rendu des Phases 4 a 10) et ORTHOPHOTO (1 : la photo aerienne reelle).
// Un dosage plutot qu'un booleen : la bascule sert au debug et aux captures
// avant/apres, et une valeur intermediaire montre d'un coup d'oeil si les
// deux se recouvrent bien. Sans texture chargee, la valeur est ignoree (le
// binding pointe alors sur un texel blanc).
float orthoMix = 0.0f;
};
// Orchestre le rendu : geometries enregistrees, UBO/descriptors, command
// pool/buffers, synchronisation, et la boucle drawFrame. Possede la SwapChain
// et les Pipeline. Gere le resize (swapchain + depth buffer ensemble).
//
// Depuis la Phase 5, le Renderer dessine PLUSIEURS objets par frame :
// 1. l'appelant enregistre ses geometries une fois pour toutes (addMesh) et
// garde les MeshHandle retournes ;
// 2. a chaque frame il fournit la liste des DrawItem a dessiner.
// La geometrie (couteuse : upload GPU) est donc dissociee des instances
// (jetables : une matrice). Un meme mesh d'arbre sert ainsi a tous les arbres.
//
// PHASE 12 : le Renderer est aussi le BufferUploader du moteur. Les copies
// staging -> device-local demandees par les Mesh ne sont plus attendues : elles
// sont accumulees puis enregistrees en tete du command buffer de la frame
// suivante, avant le render pass, suivies d'UNE barriere transfert -> vertex
// input. Voir enqueueCopy et NOTES-PHASE12.md.
class Renderer : public BufferUploader {
public:
Renderer(VulkanContext& context, Window& window,
const RenderOptions& options = {});
~Renderer();
Renderer(const Renderer&) = delete;
Renderer& operator=(const Renderer&) = delete;
// Envoie une geometrie sur le GPU et renvoie sa poignee. La geometrie est
// fournie deja construite (fichier .obj, cube en dur, terrain ou arbre
// genere) : le Renderer ne fait aucune I/O disque ni aucune generation.
// Lance std::runtime_error si la geometrie est vide ou incoherente.
// `log` a false pour les geometries creees en masse (les tuiles du
// quadtree, plusieurs par seconde) : une ligne de journal par tuile noierait
// toute autre information.
MeshHandle addMesh(const MeshData& meshData, bool log = true);
// Libere une geometrie et rend sa poignee reutilisable. Indispensable depuis
// la Phase 10 : le streaming par tuiles cree et detruit des maillages en
// permanence, alors que jusque-la une geometrie enregistree vivait aussi
// longtemps que le Renderer.
//
// La destruction est DIFFEREE de kMaxFramesInFlight + 1 frames : le GPU peut
// encore etre en train de lire les buffers d'une frame deja soumise, et les
// detruire tout de suite serait une erreur de validation immediate (voire un
// crash du driver). Detruire au bout de ce delai est correct sans avoir a
// suivre quelle frame a reference quel mesh.
void removeMesh(MeshHandle handle);
// Matrice de projection de la frame a venir. Exposee parce que le frustum
// culling se decide AVANT le rendu, cote appelant (voir core/Frustum.hpp) :
// c'est le Renderer qui connait l'aspect de la swapchain et les plans
// near/far, donc lui qui doit fournir la matrice - la recalculer ailleurs
// reviendrait a dupliquer une convention (l'inversion de l'axe Y de GLM)
// qu'une seule des deux copies penserait a mettre a jour.
glm::mat4 projectionMatrix() const;
// PHASE 11. Envoie l'orthophoto sur le GPU et la relie aux descriptor sets.
// A appeler avant la premiere frame (elle attend la fin des transferts).
// Sans appel, le binding de texture reste sur un texel blanc et seule la
// coloration procedurale est visible.
void setTerrainTexture(const TextureData& data);
// Bascule coloration procedurale <-> orthophoto (voir RenderOptions).
// Sans effet visible si aucune texture n'a ete chargee.
void setOrthoMix(float mix);
float orthoMix() const { return options_.orthoMix; }
// PHASE 23 - CYCLE JOUR/NUIT.
//
// Regle la lumiere directionnelle pour les images suivantes. Appele une fois
// par image depuis main.cpp, a partir de la position solaire calculee par
// world/Weather.hpp - le renderer ne connait ni l'heure, ni la meteo, il
// recoit une lumiere deja faite. C'est la meme separation que pour tout le
// reste du projet : le monde calcule, le renderer dessine.
//
// direction : du fragment VERS la lumiere, unitaire, en repere monde
// intensity : intensite de la lumiere DIRECTE, dans [0, 1] (0 = nuit)
// color : couleur de la lumiere
// ambient : MULTIPLICATEUR de l'ambiante propre a chaque shader, dans
// [0, 1]. Voir renderer/UniformBufferObject.hpp pour la raison
// d'un multiplicateur plutot que d'une valeur absolue.
//
// Une direction nulle ou non finie est IGNOREE (l'ancienne est conservee) :
// un cas degenere ne doit pas eteindre l'image.
void setSun(const glm::vec3& direction, float intensity, const glm::vec3& color,
float ambient);
// Couleur d'effacement, c'est-a-dire le CIEL. Reglee par image avec la
// lumiere (voir SunLight::skyColor) : sans elle, la nuit tombait sur le
// relief mais pas sur le fond, et une capture de 3 h du matin montrait des
// sapins noirs sur un ciel de midi.
void setClearColor(const glm::vec3& color) {
options_.clearColor = glm::clamp(color, glm::vec3(0.0f), glm::vec3(1.0f));
}
// PHASE 27 : METEO VISIBLE. Parametres produits par weatherVisualsFor()
// (world/Weather.hpp) - le renderer ne sait rien de la meteo, il recoit des
// nombres, comme pour setSun(). Valeurs neutres par defaut : sans appel,
// l'image est celle de la Phase 26.
//
// fogColor / fogDensityPerMeter : brouillard de distance, dans les trois
// shaders d'objets (sinon les arbres ressortiraient nets du voile)
// precipitation (0..1), snow : passe plein ecran de pluie ou de neige,
// sautee entierement quand precipitation vaut 0 (cout nul par beau)
// fallVelocity : vitesse de chute en monde, m/s, vent local compris
// groundDarkening : assombrissement du sol mouille, terrain seulement
// timeSeconds : horloge d'animation de la chute
void setWeatherVisuals(const glm::vec3& fogColor, float fogDensityPerMeter,
float precipitation, bool snow, const glm::vec3& fallVelocity,
float groundDarkening, float timeSeconds);
// PHASE 27, chantier 3 : micro-relief du sol vu de pres. strength = 0
// desactive. fadeStart / fadeEnd en metres depuis la camera ; patternMeters
// = taille du motif le plus grossier. Voir shaders/terrain.frag.
void setGroundDetail(float strength, float fadeStart, float fadeEnd, float patternMeters);
// Vrai si la passe de precipitation sera enregistree a la prochaine image.
bool precipitationPassActive() const { return precip_.x > 0.0f; }
// La lumiere courante, pour le journal et les captures.
const glm::vec4& sun() const { return sun_; }
const glm::vec4& sunColor() const { return sunColor_; }
// PHASE 25 : FORCE DE L'INDICE VISUEL ADRET / UBAC, dans [0, 1].
//
// Ce scalaire porte TOUT ce qui, dans l'ecart adret/ubac, ne depend pas de
// la geometrie locale : la hauteur du soleil et la nebulosite. Il est
// calcule cote CPU par main.cpp, a partir des memes grandeurs et des memes
// parametres que WeatherSystem::sampleAt - et c'est deliberement lui qui
// les porte, pour qu'aucune de ces deux regles ne soit re-derivee dans un
// shader ou elle pourrait diverger de la meteo.
//
// Le shader n'ajoute que ce que lui seul peut faire : le cosinus
// d'incidence par fragment, a partir de la normale et de la MEME direction
// solaire que l'eclairage (ubo.sun.xyz). Voir shaders/terrain.frag.
//
// 0 = aucun effet, et c'est le defaut : sans appel a setAspectTint(), le
// rendu est exactement celui d'avant la Phase 25.
void setAspectTint(float strength) {
aspectTint_ = std::isfinite(strength) ? std::clamp(strength, 0.0f, 1.0f) : 0.0f;
}
float aspectTint() const { return aspectTint_; }
// true si une vraie orthophoto est reliee (et non le texel blanc de repli).
bool hasTerrainTexture() const { return terrainTexture_ != nullptr; }
// Nombre de geometries actuellement vivantes. Sert aux logs de diagnostic du
// streaming.
uint32_t liveMeshCount() const { return liveMeshCount_; }
// Rend et presente une frame : la vue vient de la camera, le contenu de la
// liste d'objets. La liste n'est PAS conservee au-dela de l'appel.
void drawFrame(const Camera& camera, const std::vector<DrawItem>& items);
// PHASE 11. Meme frame, avec en plus de la geometrie INSTANCIEE (vegetation).
// Les tableaux d'instances designes par les InstancedDrawItem sont recopies
// dans un buffer de la frame pendant l'appel ; ils n'ont pas a survivre au
// retour.
void drawFrame(const Camera& camera, const std::vector<DrawItem>& items,
const std::vector<InstancedDrawItem>& instanced);
// Instances reellement soumises a la derniere frame, tous materiaux
// confondus. Sert au journal de diagnostic.
uint32_t lastInstanceCount() const { return lastInstanceCount_; }
// A appeler avant destruction pour que le GPU termine son travail en cours.
void waitIdle() const;
// --- BufferUploader -----------------------------------------------------
// Accumule une copie staging -> device-local. Elle sera enregistree en tete
// du prochain command buffer de frame, AVANT vkCmdBeginRenderPass, et
// separee des draws par une barriere memoire. Rien n'est soumis ici, rien
// n'est attendu : c'est la levee du "verrou n 1" de la Phase 10.
//
// Consequence pour l'appelant : la geometrie n'est lisible par le GPU qu'a
// partir de la frame suivante - ce qui est exactement le moment ou elle
// servira, puisque le seul chemin qui l'appelle (addMesh) est suivi d'un
// drawFrame.
//
// `destination` est une poignee NUE : elle doit rester valide jusqu'a
// l'enregistrement, c'est-a-dire jusqu'au prochain drawFrame. C'est
// garanti par construction - le seul appelant est addMesh, et removeMesh
// DIFFERE la destruction des buffers de kMaxFramesInFlight + 1 frames.
void enqueueCopy(std::unique_ptr<VulkanBuffer> staging,
VkBuffer destination) override;
// Octets de staging en attente d'enregistrement + en attente d'execution.
// Sert au journal de diagnostic du streaming.
std::size_t stagingBytesInFlight() const { return stagingBytesInFlight_; }
// Plafond de staging vivant simultanement. Au-dela, enqueueCopy bascule sur
// une soumission SYNCHRONE (voir flushCopiesNow) plutot que de laisser la
// memoire enfler.
//
// Pourquoi ce plafond existe : differer les copies veut dire garder les
// buffers staging trois frames de plus au lieu de les liberer aussitot. Pour
// le streaming c'est negligeable (64 tuiles ~ 25 Mo). Pour le chemin
// --no-lod, qui televerse la zone de 25 km2 en UN SEUL maillage, le staging
// pese 3,4 Go a lui tout seul : sans plafond, le pic memoire de ce chemin
// passait de 5,6 a 6,9 Go, soit une regression de 23 % sur une mesure de la
// Phase 10. 128 Mo laisse passer tout le streaming et n'attrape que les
// televersements geants, qui sont par nature hors du chemin critique (ils
// ont lieu avant la premiere frame).
static constexpr VkDeviceSize kMaxPendingStagingBytes = 128ull * 1024 * 1024;
private:
// Lumiere directionnelle courante. Initialisee aux valeurs de la Phase 2 :
// sans appel a setSun(), le rendu est exactement celui d'avant la Phase 23.
float aspectTint_ = 0.0f; // PHASE 25, voir setAspectTint()
glm::vec4 sun_{0.3244f, 0.8111f, 0.4867f, 1.0f};
glm::vec4 sunColor_{1.0f, 0.97f, 0.90f, 1.0f};
// PHASE 27 - voir setWeatherVisuals() / setGroundDetail() et le detail des
// champs dans renderer/UniformBufferObject.hpp.
glm::vec4 fog_{0.52f, 0.66f, 0.82f, 0.0f};
glm::vec4 precip_{0.0f, 0.0f, 0.0f, 0.0f};
glm::vec4 fall_{0.0f, -6.5f, 0.0f, 0.0f};
glm::vec4 detail_{0.0f, 0.0f, 1.0f, 1.0f};
static constexpr int kMaxFramesInFlight = 2;
void createCommandPool();
void createCommandBuffers();
void createFrameSyncObjects();
void createImageSyncObjects();
void destroyImageSyncObjects();
// Ressources de rendu.
void createUniformBuffers();
void createDescriptorSetLayout();
void createDescriptorPool();
void createDescriptorSets();
// (Re)ecrit le binding 1 de tous les descriptor sets vers la texture
// actuellement retenue. Appele a la creation (texel blanc) puis a chaque
// setTerrainTexture.
void writeTextureDescriptors();
void updateUniformBuffer(uint32_t frameIndex, const Camera& camera);
void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex,
const std::vector<DrawItem>& items,
const std::vector<InstancedDrawItem>& instanced);
// Enregistre toutes les copies en attente puis UNE barriere, dans un
// command buffer deja commence et AVANT tout render pass.
void recordPendingCopies(VkCommandBuffer commandBuffer);
// Soumet immediatement les copies en attente et ATTEND le GPU, puis libere
// leur staging. Chemin de secours uniquement (voir kMaxPendingStagingBytes) :
// il bloque, ce que tout le reste de la Phase 12 s'emploie a eviter.
void flushCopiesNow();
// Recopie toutes les instances de la frame dans le buffer de la
// frame-in-flight courante, en agrandissant celui-ci si besoin, et remplit
// instanceOffsets_ (un offset par InstancedDrawItem, dans l'ordre).
void uploadInstances(const std::vector<InstancedDrawItem>& instanced);
void recreateSwapChain();
VulkanContext& context_;
Window& window_;
RenderOptions options_;
std::unique_ptr<SwapChain> swapChain_;
// Un pipeline par materiau, indexe par la valeur de l'enum Material. Tous
// partagent le meme descriptor set layout et le meme push constant range :
// seuls les shaders different.
std::array<std::unique_ptr<Pipeline>, kMaterialCount> pipelines_;
// PHASE 27 : passe PLEIN ECRAN de precipitation. Hors de la table par
// materiau : elle ne dessine aucun DrawItem, un seul triangle couvrant.
std::unique_ptr<Pipeline> precipitationPipeline_;
VkCommandPool commandPool_ = VK_NULL_HANDLE;
std::vector<VkCommandBuffer> commandBuffers_; // un par frame-in-flight
// Geometries enregistrees (buffers device-local), indexees par MeshHandle.
// Les Mesh sont possedes ici et vivent aussi longtemps que le Renderer :
// les DrawItem d'une frame ne portent que des poignees, jamais de pointeur.
std::vector<std::unique_ptr<Mesh>> meshes_;
// Emplacements de meshes_ liberes par removeMesh, reutilisables par addMesh.
// Sans cette liste, meshes_ grandirait indefiniment au fil du streaming.
std::vector<MeshHandle> freeMeshSlots_;
// Meshes retires mais pas encore detruits (voir removeMesh). Le compteur est
// decremente a chaque frame ; a zero, le unique_ptr est relache.
struct RetiredMesh {
std::unique_ptr<Mesh> mesh;
int framesRemaining = 0;
};
std::vector<RetiredMesh> retiredMeshes_;
uint32_t liveMeshCount_ = 0;
// PHASE 12 : copies demandees mais pas encore enregistrees dans un command
// buffer. Videe a chaque recordCommandBuffer.
struct PendingCopy {
std::unique_ptr<VulkanBuffer> staging;
VkBuffer destination = VK_NULL_HANDLE;
VkDeviceSize size = 0;
};
std::vector<PendingCopy> pendingCopies_;
// Buffers staging dont la copie EST enregistree et soumise, mais dont on ne
// sait pas encore si le GPU l'a executee. Meme mecanisme de vieillissement
// que retiredMeshes_ : detruire un staging encore lu par une frame en vol
// serait une erreur de validation immediate.
struct RetiredStaging {
std::unique_ptr<VulkanBuffer> staging;
int framesRemaining = 0;
};
std::vector<RetiredStaging> retiredStaging_;
std::size_t stagingBytesInFlight_ = 0;
// UBO : un buffer host-visible mappe en permanence, par frame-in-flight.
std::vector<std::unique_ptr<VulkanBuffer>> uniformBuffers_;
// Descriptors.
VkDescriptorSetLayout descriptorSetLayout_ = VK_NULL_HANDLE;
VkDescriptorPool descriptorPool_ = VK_NULL_HANDLE;
std::vector<VkDescriptorSet> descriptorSets_; // un par frame-in-flight
// Texture du terrain (binding 1). `whiteTexture_` existe toujours : c'est
// elle qui occupe le binding tant qu'aucune orthophoto n'est chargee, ce qui
// evite d'avoir deux layouts de descriptor set et deux jeux de pipelines
// selon la presence d'une photo.
std::unique_ptr<Texture> whiteTexture_;
std::unique_ptr<Texture> terrainTexture_;
// PHASE 27 : bruit periodique du micro-relief (binding 2). Genere au
// demarrage par makeDetailNoiseTexture, 256x256 RGBA8 + mipmaps, 341 Ko.
std::unique_ptr<Texture> detailTexture_;
// PHASE 11 : buffer d'instances par frame-in-flight, host-visible et mappe
// en permanence, comme l'UBO. Reecrit a chaque frame parce que son contenu
// change a chaque frame (le joueur bouge, donc l'ensemble des arbres
// visibles change) : un buffer device-local imposerait un staging et une
// copie par frame pour une donnee qui ne sert qu'une fois.
//
// Il GRANDIT a la demande et ne retrecit jamais : le pic de vegetation
// visible est atteint en quelques secondes de jeu, et liberer pour
// reallouer ensuite ne ferait qu'ajouter des a-coups.
std::vector<std::unique_ptr<VulkanBuffer>> instanceBuffers_;
std::vector<VkDeviceSize> instanceOffsets_; // un par InstancedDrawItem de la frame
uint32_t lastInstanceCount_ = 0;
// Synchronisation.
std::vector<VkSemaphore> imageAvailableSemaphores_; // par frame-in-flight
std::vector<VkSemaphore> renderFinishedSemaphores_; // par image de swapchain
std::vector<VkFence> inFlightFences_; // par frame-in-flight
std::vector<VkFence> imagesInFlight_; // suivi : quelle fence occupe l'image
uint32_t currentFrame_ = 0;
};
} // namespace vercora
+393
Voir le fichier
@@ -0,0 +1,393 @@
#include "renderer/SwapChain.hpp"
#include "core/Logger.hpp"
#include "core/Window.hpp"
#include "renderer/VulkanContext.hpp"
#include <algorithm>
#include <array>
#include <cstdint>
#include <limits>
#include <stdexcept>
namespace vercora {
namespace {
// Nom lisible d'un present mode, pour le log de demarrage.
const char* presentModeName(VkPresentModeKHR mode) {
switch (mode) {
case VK_PRESENT_MODE_IMMEDIATE_KHR: return "IMMEDIATE (V-Sync off, tearing possible)";
case VK_PRESENT_MODE_MAILBOX_KHR: return "MAILBOX (triple buffering, V-Sync on)";
case VK_PRESENT_MODE_FIFO_KHR: return "FIFO (V-Sync on, FPS plafonnes)";
case VK_PRESENT_MODE_FIFO_RELAXED_KHR: return "FIFO_RELAXED";
default: return "inconnu";
}
}
} // namespace
SwapChain::SwapChain(VulkanContext& context, Window& window)
: context_(context), window_(window) {
// Le format de profondeur est fixe une fois pour toutes (il ne depend pas de
// la taille) : le render pass, cree une seule fois, s'y refere.
depthFormat_ = context_.findDepthFormat();
createSwapChain();
createImageViews();
createRenderPass();
createDepthResources();
createFramebuffers();
}
SwapChain::~SwapChain() {
cleanupSizeDependent();
if (renderPass_ != VK_NULL_HANDLE) {
vkDestroyRenderPass(context_.device(), renderPass_, nullptr);
}
}
void SwapChain::recreate() {
cleanupSizeDependent();
createSwapChain();
createImageViews();
createDepthResources();
createFramebuffers();
}
void SwapChain::cleanupSizeDependent() {
VkDevice device = context_.device();
// Depth buffer (dependant de la taille).
if (depthImageView_ != VK_NULL_HANDLE) {
vkDestroyImageView(device, depthImageView_, nullptr);
depthImageView_ = VK_NULL_HANDLE;
}
if (depthImage_ != VK_NULL_HANDLE) {
vkDestroyImage(device, depthImage_, nullptr);
depthImage_ = VK_NULL_HANDLE;
}
if (depthImageMemory_ != VK_NULL_HANDLE) {
vkFreeMemory(device, depthImageMemory_, nullptr);
depthImageMemory_ = VK_NULL_HANDLE;
}
for (VkFramebuffer fb : framebuffers_) {
vkDestroyFramebuffer(device, fb, nullptr);
}
framebuffers_.clear();
for (VkImageView view : imageViews_) {
vkDestroyImageView(device, view, nullptr);
}
imageViews_.clear();
if (swapChain_ != VK_NULL_HANDLE) {
vkDestroySwapchainKHR(device, swapChain_, nullptr);
swapChain_ = VK_NULL_HANDLE;
}
images_.clear();
}
// ---------------------------------------------------------------------------
// Choix des parametres de la swapchain
// ---------------------------------------------------------------------------
VkSurfaceFormatKHR SwapChain::chooseSurfaceFormat(
const std::vector<VkSurfaceFormatKHR>& formats) const {
for (const auto& format : formats) {
if (format.format == VK_FORMAT_B8G8R8A8_SRGB &&
format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
return format;
}
}
return formats.front();
}
VkPresentModeKHR SwapChain::choosePresentMode(
const std::vector<VkPresentModeKHR>& modes) const {
// Phase 2 : on veut mesurer les FPS reels du moteur, donc pas de V-Sync.
// Ordre de preference :
// IMMEDIATE : presente sans attendre le rafraichissement ecran. FPS non
// plafonnes (ce qu'on veut ici), au prix d'un tearing possible.
// MAILBOX : triple buffering, faible latence mais toujours cale sur
// l'ecran -> FPS plafonnes au taux de rafraichissement.
// FIFO : seul mode dont Vulkan garantit la presence. Fallback ultime.
// A rebasculer sur MAILBOX/FIFO quand le jeu sera jouable : le tearing n'est
// acceptable que pour du profilage.
for (VkPresentModeKHR wanted : { VK_PRESENT_MODE_IMMEDIATE_KHR,
VK_PRESENT_MODE_MAILBOX_KHR }) {
if (std::find(modes.begin(), modes.end(), wanted) != modes.end()) {
return wanted;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D SwapChain::chooseExtent(const VkSurfaceCapabilitiesKHR& capabilities) const {
if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {
return capabilities.currentExtent;
}
int width = 0;
int height = 0;
window_.getFramebufferSize(width, height);
VkExtent2D actual{ static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actual.width = std::clamp(actual.width,
capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
actual.height = std::clamp(actual.height,
capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
return actual;
}
// ---------------------------------------------------------------------------
// Swapchain
// ---------------------------------------------------------------------------
void SwapChain::createSwapChain() {
const SwapChainSupportDetails support = context_.querySwapChainSupport();
const VkSurfaceFormatKHR surfaceFormat = chooseSurfaceFormat(support.formats);
const VkPresentModeKHR presentMode = choosePresentMode(support.presentModes);
const VkExtent2D extent = chooseExtent(support.capabilities);
// createSwapChain() est aussi appelee a chaque resize : on ne log que si le
// mode change reellement, pour ne pas spammer la console pendant un drag.
if (presentMode != presentMode_) {
logInfo(std::string("Present mode retenu : ") + presentModeName(presentMode));
presentMode_ = presentMode;
}
// On demande une image de plus que le minimum pour eviter d'attendre le driver.
uint32_t imageCount = support.capabilities.minImageCount + 1;
if (support.capabilities.maxImageCount > 0 &&
imageCount > support.capabilities.maxImageCount) {
imageCount = support.capabilities.maxImageCount;
}
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = context_.surface();
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
const QueueFamilyIndices& indices = context_.queueFamilies();
const uint32_t queueFamilyIndices[] = {
indices.graphicsFamily.value(),
indices.presentFamily.value()
};
if (indices.graphicsFamily != indices.presentFamily) {
// Familles distinctes : partage concurrent (plus simple, un peu moins rapide).
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
} else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = support.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = VK_NULL_HANDLE;
if (vkCreateSwapchainKHR(context_.device(), &createInfo, nullptr, &swapChain_) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation de la swapchain.");
}
// Recupere les images effectivement creees (peut differer de imageCount demande).
vkGetSwapchainImagesKHR(context_.device(), swapChain_, &imageCount, nullptr);
images_.resize(imageCount);
vkGetSwapchainImagesKHR(context_.device(), swapChain_, &imageCount, images_.data());
imageFormat_ = surfaceFormat.format;
extent_ = extent;
}
void SwapChain::createImageViews() {
imageViews_.resize(images_.size());
for (size_t i = 0; i < images_.size(); ++i) {
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = images_[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = imageFormat_;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
if (vkCreateImageView(context_.device(), &createInfo, nullptr, &imageViews_[i]) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation d'une image view.");
}
}
}
void SwapChain::createRenderPass() {
// Attache 0 : couleur.
VkAttachmentDescription colorAttachment{};
colorAttachment.format = imageFormat_;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; // efface a chaque frame
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; // conserve pour la presentation
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorRef{};
colorRef.attachment = 0;
colorRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
// Attache 1 : profondeur. Pas besoin de la conserver (storeOp DONT_CARE).
VkAttachmentDescription depthAttachment{};
depthAttachment.format = depthFormat_;
depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkAttachmentReference depthRef{};
depthRef.attachment = 1;
depthRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorRef;
subpass.pDepthStencilAttachment = &depthRef;
// Dependance : synchronise couleur ET profondeur avec l'exterieur du subpass.
//
// PHASE 12, CORRECTION. srcAccessMask valait 0, ce qui n'ordonne QUE
// l'execution, pas les ecritures entre elles. Or il n'y a qu'UN SEUL buffer
// de profondeur pour les deux frames-in-flight : le clear de la frame N+1
// (une ecriture, au vkCmdBeginRenderPass) court alors sans dependance
// contre le storeOp de la frame N (une ecriture aussi). La validation de
// SYNCHRONISATION - qui n'etait activee dans aucune phase precedente -
// signale exactement ca : "WRITE_AFTER_WRITE hazard, vkCmdBeginRenderPass
// ... previously written ... by the attachment storeOp".
//
// Le defaut est ANTERIEUR au transfert asynchrone : il se reproduit sur la
// scene `cube` et avec --no-lod, donc sans le moindre upload en vol. Il est
// corrige ici parce qu'un message d'erreur permanent dans le journal de
// synchronisation rendrait invisible un VRAI probleme de transfert.
//
// La forme correcte nomme les ecritures de la frame precedente cote source.
// L'ecriture du storeOp de profondeur a lieu au stage LATE_FRAGMENT_TESTS,
// celle de la couleur au stage COLOR_ATTACHMENT_OUTPUT.
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask =
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
dependency.srcAccessMask =
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
dependency.dstStageMask =
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
dependency.dstAccessMask =
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
const std::array<VkAttachmentDescription, 2> attachments = { colorAttachment, depthAttachment };
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
renderPassInfo.pAttachments = attachments.data();
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(context_.device(), &renderPassInfo, nullptr, &renderPass_) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation du render pass.");
}
}
void SwapChain::createDepthResources() {
VkImageCreateInfo imageInfo{};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageInfo.imageType = VK_IMAGE_TYPE_2D;
imageInfo.extent.width = extent_.width;
imageInfo.extent.height = extent_.height;
imageInfo.extent.depth = 1;
imageInfo.mipLevels = 1;
imageInfo.arrayLayers = 1;
imageInfo.format = depthFormat_;
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
VkDevice device = context_.device();
if (vkCreateImage(device, &imageInfo, nullptr, &depthImage_) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation de l'image de profondeur.");
}
VkMemoryRequirements memRequirements{};
vkGetImageMemoryRequirements(device, depthImage_, &memRequirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = context_.findMemoryType(
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
if (vkAllocateMemory(device, &allocInfo, nullptr, &depthImageMemory_) != VK_SUCCESS) {
throw std::runtime_error("Echec de l'allocation memoire de profondeur.");
}
vkBindImageMemory(device, depthImage_, depthImageMemory_, 0);
VkImageViewCreateInfo viewInfo{};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
viewInfo.image = depthImage_;
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
viewInfo.format = depthFormat_;
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
viewInfo.subresourceRange.baseMipLevel = 0;
viewInfo.subresourceRange.levelCount = 1;
viewInfo.subresourceRange.baseArrayLayer = 0;
viewInfo.subresourceRange.layerCount = 1;
if (vkCreateImageView(device, &viewInfo, nullptr, &depthImageView_) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation de la vue de profondeur.");
}
}
void SwapChain::createFramebuffers() {
framebuffers_.resize(imageViews_.size());
for (size_t i = 0; i < imageViews_.size(); ++i) {
// Ordre = ordre des attaches du render pass : couleur puis profondeur.
std::array<VkImageView, 2> attachments = { imageViews_[i], depthImageView_ };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass_;
framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
framebufferInfo.pAttachments = attachments.data();
framebufferInfo.width = extent_.width;
framebufferInfo.height = extent_.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(context_.device(), &framebufferInfo, nullptr, &framebuffers_[i]) != VK_SUCCESS) {
throw std::runtime_error("Echec de la creation d'un framebuffer.");
}
}
}
} // namespace vercora
+77
Voir le fichier
@@ -0,0 +1,77 @@
#pragma once
#include <vulkan/vulkan.h>
#include <vector>
namespace vercora {
class VulkanContext;
class Window;
// Encapsule la swapchain et tout ce qui en depend directement :
// image views, render pass et framebuffers. Concue pour etre recreee au resize.
// Le render pass, lui, est conserve entre deux recreations (son format ne change
// pas), ce qui evite d'invalider le pipeline graphique.
class SwapChain {
public:
SwapChain(VulkanContext& context, Window& window);
~SwapChain();
SwapChain(const SwapChain&) = delete;
SwapChain& operator=(const SwapChain&) = delete;
// Detruit les ressources dependant de la taille et les reconstruit.
void recreate();
VkRenderPass renderPass() const { return renderPass_; }
VkExtent2D extent() const { return extent_; }
VkFormat imageFormat() const { return imageFormat_; }
VkFormat depthFormat() const { return depthFormat_; }
VkSwapchainKHR handle() const { return swapChain_; }
// Mode de presentation effectivement retenu (depend du support GPU/driver).
VkPresentModeKHR presentMode() const { return presentMode_; }
uint32_t imageCount() const { return static_cast<uint32_t>(images_.size()); }
VkFramebuffer framebuffer(uint32_t index) const { return framebuffers_[index]; }
private:
void createSwapChain();
void createImageViews();
void createRenderPass();
void createDepthResources();
void createFramebuffers();
// Detruit uniquement les ressources dependant de la taille (pas le render pass).
void cleanupSizeDependent();
VkSurfaceFormatKHR chooseSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& formats) const;
VkPresentModeKHR choosePresentMode(const std::vector<VkPresentModeKHR>& modes) const;
VkExtent2D chooseExtent(const VkSurfaceCapabilitiesKHR& capabilities) const;
VulkanContext& context_;
Window& window_;
VkSwapchainKHR swapChain_ = VK_NULL_HANDLE;
VkFormat imageFormat_ = VK_FORMAT_UNDEFINED;
VkExtent2D extent_{};
// MAX_ENUM = "pas encore choisi", pour que le premier choix soit toujours logge.
VkPresentModeKHR presentMode_ = VK_PRESENT_MODE_MAX_ENUM_KHR;
std::vector<VkImage> images_;
std::vector<VkImageView> imageViews_;
std::vector<VkFramebuffer> framebuffers_;
// Depth buffer : une seule image partagee (le rendu d'une frame est serialise
// par le render pass). Recree en meme temps que la swapchain au resize.
VkFormat depthFormat_ = VK_FORMAT_UNDEFINED;
VkImage depthImage_ = VK_NULL_HANDLE;
VkDeviceMemory depthImageMemory_ = VK_NULL_HANDLE;
VkImageView depthImageView_ = VK_NULL_HANDLE;
VkRenderPass renderPass_ = VK_NULL_HANDLE;
};
} // namespace vercora
+148
Voir le fichier
@@ -0,0 +1,148 @@
#include "renderer/TerrainMesh.hpp"
#include "assets/Heightmap.hpp"
#include "core/Logger.hpp"
#include <cmath>
#include <cstdint>
#include <stdexcept>
namespace vercora {
MeshData terrainMeshData(const Heightmap& heightmap) {
const uint32_t res = heightmap.resolution();
if (res < 2) {
throw std::runtime_error(
"TerrainMesh : une grille de " + std::to_string(res) +
" echantillons par cote ne forme aucune cellule.");
}
const uint32_t cells = res - 1;
const float spacing = heightmap.spacing();
MeshData mesh;
mesh.name = heightmap.describe();
mesh.vertices.reserve(static_cast<std::size_t>(res) * res);
mesh.indices.reserve(static_cast<std::size_t>(cells) * cells * 6);
// --- 1. Sommets ---------------------------------------------------------
// Un sommet par echantillon, PARTAGE entre les triangles voisins : c'est ce
// partage qui rend le terrain lisse (normales moyennees implicitement) et
// qui divise par ~6 la taille du vertex buffer par rapport a des triangles
// independants. L'inverse du cube, dont chaque face voulait ses propres
// normales pour garder des aretes vives.
//
// Les positions sont en espace MONDE des maintenant : la model matrix reste
// l'IDENTITE pour le terrain (voir RenderOptions::spinModel). C'est un choix
// assume pour cette phase - il evite la question de la normal matrix, qui se
// poserait des qu'on appliquerait au terrain un facteur d'echelle vertical
// different de l'horizontal (dans ce cas mat3(model) est FAUX : il faudrait
// transpose(inverse(mat3(model))), calcule cote CPU et passe par l'UBO).
// Toute mise a l'echelle du relief se fait donc dans la Heightmap, en amont.
for (uint32_t iz = 0; iz < res; ++iz) {
for (uint32_t ix = 0; ix < res; ++ix) {
Vertex vertex{};
vertex.pos = { heightmap.worldCoord(ix),
heightmap.at(ix, iz),
heightmap.worldCoord(iz) };
// Teinte neutre : le fragment shader du terrain colore par altitude
// et par pente, cette valeur ne fait que le multiplier. Elle reste
// disponible pour, plus tard, marquer des zones (classification
// LiDAR : sol / vegetation / bati) sans toucher au shader.
vertex.color = { 1.0f, 1.0f, 1.0f };
// Normale analytique de la surface y = h(x,z) : le vecteur normal
// vaut (-dh/dx, 1, -dh/dz). Les derivees sont estimees par
// difference CENTREE sur les deux voisins (plus precis et plus
// symetrique qu'un produit vectoriel sur une seule face).
// Sur les bords, at() ecrete les indices : la difference devient
// unilaterale, d'ou le pas reel (xp - xm) au denominateur plutot
// qu'un 2 en dur - sinon les normales du bord seraient deux fois
// trop plates.
const int64_t xm = (ix > 0) ? ix - 1 : ix;
const int64_t xp = (ix + 1 < res) ? ix + 1 : ix;
const int64_t zm = (iz > 0) ? iz - 1 : iz;
const int64_t zp = (iz + 1 < res) ? iz + 1 : iz;
const float dhdx = (heightmap.at(xp, iz) - heightmap.at(xm, iz)) /
(static_cast<float>(xp - xm) * spacing);
const float dhdz = (heightmap.at(ix, zp) - heightmap.at(ix, zm)) /
(static_cast<float>(zp - zm) * spacing);
vertex.normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
// UV sur tout le terrain. Pas encore consomme (pas de texturing),
// mais c'est le repere naturel pour y plaquer une orthophoto le jour
// ou les vraies donnees arriveront.
vertex.uv = { static_cast<float>(ix) / static_cast<float>(cells),
static_cast<float>(iz) / static_cast<float>(cells) };
mesh.vertices.push_back(vertex);
}
}
// --- 2. Indices ---------------------------------------------------------
// Chaque cellule donne deux triangles, coupes le long de la diagonale
// v00-v11. Heightmap::heightAt reproduit EXACTEMENT ce decoupage pour que
// la camera marche sur la surface reellement affichee : changer la diagonale
// ici oblige a la changer la-bas aussi.
//
// Enroulement anti-horaire vu de dessus (+Y), coherent avec la convention
// des .obj de la Phase 3. Le culling est desactive dans Pipeline, donc c'est
// sans effet visible aujourd'hui, mais ca rend le back-face culling
// activable sans retoucher la geometrie.
for (uint32_t iz = 0; iz < cells; ++iz) {
for (uint32_t ix = 0; ix < cells; ++ix) {
const uint32_t v00 = iz * res + ix;
const uint32_t v10 = v00 + 1;
const uint32_t v01 = v00 + res;
const uint32_t v11 = v01 + 1;
mesh.indices.push_back(v00);
mesh.indices.push_back(v01);
mesh.indices.push_back(v11);
mesh.indices.push_back(v00);
mesh.indices.push_back(v11);
mesh.indices.push_back(v10);
}
}
// --- 3. Controle de coherence ------------------------------------------
// Meme esprit que les gardes-fous du loader .obj (Phase 3) : on refuse de
// pousser vers le GPU une geometrie qu'on sait cassee, plutot que d'afficher
// une fenetre vide sans explication. Ici le generateur est deterministe,
// donc ces tests attrapent une erreur de code (indexation, resolution), pas
// une donnee douteuse - ils resteront pertinents quand la grille viendra du
// LiDAR.
if (mesh.indices.size() % 3 != 0) {
throw std::runtime_error("TerrainMesh : nombre d'index non multiple de 3.");
}
for (uint32_t index : mesh.indices) {
if (index >= mesh.vertices.size()) {
throw std::runtime_error(
"TerrainMesh : index " + std::to_string(index) + " hors des " +
std::to_string(mesh.vertices.size()) + " sommets generes.");
}
}
for (const Vertex& vertex : mesh.vertices) {
if (!std::isfinite(vertex.pos.x) || !std::isfinite(vertex.pos.y) ||
!std::isfinite(vertex.pos.z) || !std::isfinite(vertex.normal.y)) {
throw std::runtime_error(
"TerrainMesh : coordonnee ou normale non finie (NaN/infini) "
"produite par la heightmap.");
}
}
logInfo("Maillage terrain genere : " + std::to_string(mesh.vertices.size()) +
" sommets, " + std::to_string(mesh.triangleCount()) + " triangles, "
"emprise " + std::to_string(heightmap.worldSize()) + " x " +
std::to_string(heightmap.maxHeight() - heightmap.minHeight()) + " x " +
std::to_string(heightmap.worldSize()) + ".");
return mesh;
}
} // namespace vercora
+23
Voir le fichier
@@ -0,0 +1,23 @@
#pragma once
#include "renderer/MeshData.hpp"
namespace vercora {
class Heightmap;
// Convertit une grille d'altitudes en geometrie indexee, dans le meme MeshData
// que le cube en dur (CubeMesh) et que le loader .obj (ObjLoader) : la classe
// Mesh, les buffers Vulkan et le Renderer ne voient aucune difference.
//
// Positions en espace MONDE directement (voir le commentaire sur la model
// matrix dans TerrainMesh.cpp), normales calculees par differences finies sur
// les voisins, UV normalises sur [0,1]^2, couleur laissee a blanc : la
// coloration du terrain est calculee par le fragment shader a partir de
// l'altitude et de la pente, la couleur de sommet ne sert que de teinte
// (neutre ici).
//
// Lance std::runtime_error si la grille ne peut pas produire un maillage sain.
MeshData terrainMeshData(const Heightmap& heightmap);
} // namespace vercora
+199
Voir le fichier
@@ -0,0 +1,199 @@
#include "renderer/TerrainNodeMesh.hpp"
#include "assets/Heightmap.hpp"
#include "world/TerrainQuadtree.hpp"
#include <algorithm>
#include <cmath>
#include <stdexcept>
#include <string>
#include <vector>
namespace vercora {
namespace {
// Position monde + normale d'un point de grille, echantillonne au pas `stride`.
//
// La normale est calculee par difference centree SUR LE PAS DU NOEUD et non sur
// le pas de la donnee : une tuile lointaine doit avoir les normales de la
// surface qu'elle dessine reellement, sinon son eclairage serait bruite par un
// relief que sa geometrie ne represente pas. C'est aussi ce qui rend le
// morphing des normales coherent - a morph = 1, la normale d'un sommet est
// exactement celle que le parent lui donnerait.
struct GridSample {
glm::vec3 position;
glm::vec3 normal;
};
GridSample sampleGrid(const Heightmap& heightmap, uint32_t cells,
uint32_t gx, uint32_t gz, uint32_t stride) {
const float spacing = heightmap.spacing();
const int64_t xm = (gx >= stride) ? static_cast<int64_t>(gx) - stride : gx;
const int64_t xp = (gx + stride <= cells) ? static_cast<int64_t>(gx) + stride : gx;
const int64_t zm = (gz >= stride) ? static_cast<int64_t>(gz) - stride : gz;
const int64_t zp = (gz + stride <= cells) ? static_cast<int64_t>(gz) + stride : gz;
// Sur le bord, la difference devient unilaterale : le pas reel (xp - xm) au
// denominateur, et non un 2*stride en dur, sinon les normales du bord
// seraient deux fois trop plates. Meme raisonnement que TerrainMesh.
const float dx = static_cast<float>(xp - xm) * spacing;
const float dz = static_cast<float>(zp - zm) * spacing;
GridSample sample;
sample.position = { heightmap.worldCoord(gx),
heightmap.at(gx, gz),
heightmap.worldCoord(gz) };
const float dhdx = (dx > 0.0f)
? (heightmap.at(xp, gz) - heightmap.at(xm, gz)) / dx : 0.0f;
const float dhdz = (dz > 0.0f)
? (heightmap.at(gx, zp) - heightmap.at(gx, zm)) / dz : 0.0f;
sample.normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz));
return sample;
}
} // namespace
std::vector<uint32_t> terrainNodeIndices(uint32_t nodeCells) {
if (nodeCells < 1) {
throw std::runtime_error("TerrainNodeMesh : nodeCells nul.");
}
const uint32_t verts = nodeCells + 1;
std::vector<uint32_t> indices;
indices.reserve(static_cast<std::size_t>(nodeCells) * nodeCells * 6);
// Meme decoupe en diagonale v00-v11 et meme enroulement que TerrainMesh :
// Heightmap::heightAt reproduit cette diagonale pour que la camera marche
// sur la surface reellement affichee (a la pleine resolution, c'est-a-dire
// au niveau 0, celui qui entoure le joueur).
for (uint32_t j = 0; j < nodeCells; ++j) {
for (uint32_t i = 0; i < nodeCells; ++i) {
const uint32_t v00 = j * verts + i;
const uint32_t v10 = v00 + 1;
const uint32_t v01 = v00 + verts;
const uint32_t v11 = v01 + 1;
indices.push_back(v00);
indices.push_back(v01);
indices.push_back(v11);
indices.push_back(v00);
indices.push_back(v11);
indices.push_back(v10);
}
}
return indices;
}
MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& quadtree,
uint32_t nodeIndex, bool withIndices,
bool reuseParentGrid) {
if (nodeIndex >= quadtree.nodeCount()) {
throw std::runtime_error("TerrainNodeMesh : indice de noeud hors limites.");
}
const TerrainQuadtree::Node& node = quadtree.node(nodeIndex);
const uint32_t nodeCells = quadtree.nodeCells();
const uint32_t verts = nodeCells + 1;
const uint32_t cells = heightmap.resolution() - 1;
const uint32_t stride = node.stride;
// --- PHASE 18 : la grille du PARENT, echantillonnee une seule fois ------
// Le morphing a besoin, pour chaque sommet, du point que le noeud PARENT
// produirait au meme endroit. Ce point ne depend que des indices locaux
// ARRONDIS a un multiple de deux : les quatre sommets d'un bloc 2x2 partagent
// donc exactement la meme cible. La version d'avant la Phase 18 la
// recalculait pour chacun des quatre - soit trois echantillonnages sur
// quatre jetes, et un echantillonnage coute cinq lectures de la heightmap
// plus une normalisation.
//
// Le profilage (TerrainStreamer::buildProfile) chiffrait la geometrie a
// 1858 us/tuile, dont la moitie environ pour ces cibles. La grille
// grossiere ci-dessous fait 33x33 la ou la tuile en fait 65x65 : quatre fois
// moins d'echantillons, et un resultat BIT A BIT identique - c'est la meme
// fonction appelee avec les memes arguments, simplement moins souvent.
const uint32_t parentVerts = (verts + 1u) / 2u;
std::vector<GridSample> parentGrid;
if (reuseParentGrid) {
parentGrid.resize(static_cast<std::size_t>(parentVerts) * parentVerts);
}
for (uint32_t pj = 0; reuseParentGrid && pj < parentVerts; ++pj) {
for (uint32_t pi = 0; pi < parentVerts; ++pi) {
// L'ecretage est applique APRES l'arrondi, pour que deux tuiles
// voisines qui butent sur le meme bord y arrivent a la meme valeur.
const uint32_t mx = std::min(node.ix0 + (pi * 2u) * stride, cells);
const uint32_t mz = std::min(node.iz0 + (pj * 2u) * stride, cells);
// Pas DOUBLE : c'est litteralement ce que le parent produirait.
parentGrid[static_cast<std::size_t>(pj) * parentVerts + pi] =
sampleGrid(heightmap, cells, mx, mz, stride * 2u);
}
}
MeshData mesh;
mesh.name = "tuile L" + std::to_string(static_cast<int>(node.level)) + " (" +
std::to_string(node.ix0) + "," + std::to_string(node.iz0) + ")";
mesh.vertices.resize(static_cast<std::size_t>(verts) * verts);
for (uint32_t j = 0; j < verts; ++j) {
for (uint32_t i = 0; i < verts; ++i) {
// Indices de grille du sommet, ECRETES sur le bord du terrain.
const uint32_t gx = std::min(node.ix0 + i * stride, cells);
const uint32_t gz = std::min(node.iz0 + j * stride, cells);
const GridSample here = sampleGrid(heightmap, cells, gx, gz, stride);
// Cible de morphing : indices LOCAUX arrondis vers le bas a un
// multiple de deux, ce qui donne la grille du niveau superieur -
// lue dans parentGrid, deja calculee ci-dessus.
const GridSample parentSample = reuseParentGrid
? GridSample{}
: sampleGrid(heightmap, cells,
std::min(node.ix0 + (i & ~1u) * stride, cells),
std::min(node.iz0 + (j & ~1u) * stride, cells), stride * 2u);
const GridSample& parent = reuseParentGrid
? parentGrid[static_cast<std::size_t>(j / 2u) * parentVerts + (i / 2u)]
: parentSample;
Vertex& vertex = mesh.vertices[static_cast<std::size_t>(j) * verts + i];
vertex.pos = here.position;
vertex.normal = here.normal;
vertex.morphPos = parent.position;
vertex.morphNormal = parent.normal;
// Teinte neutre : le fragment shader colore par altitude et par
// pente. Reserve a une future classification LiDAR par sommet.
vertex.color = { 1.0f, 1.0f, 1.0f };
// UV sur TOUT le terrain (et non sur la tuile) : c'est le repere
// naturel d'une future orthophoto, et il doit rester continu d'une
// tuile a l'autre.
vertex.uv = { static_cast<float>(gx) / static_cast<float>(cells),
static_cast<float>(gz) / static_cast<float>(cells) };
}
}
if (withIndices) {
mesh.indices = terrainNodeIndices(nodeCells);
}
// Controle de coherence, meme esprit que TerrainMesh : on refuse de pousser
// vers le GPU une geometrie qu'on sait cassee. Le generateur etant
// deterministe, ce test attrape une erreur de CODE (indexation, pas de
// parcours), pas une donnee douteuse.
for (const Vertex& vertex : mesh.vertices) {
if (!std::isfinite(vertex.pos.x) || !std::isfinite(vertex.pos.y) ||
!std::isfinite(vertex.pos.z) || !std::isfinite(vertex.normal.y) ||
!std::isfinite(vertex.morphPos.y)) {
throw std::runtime_error(
"TerrainNodeMesh : coordonnee ou normale non finie (NaN/infini) "
"produite par la heightmap.");
}
}
return mesh;
}
} // namespace vercora
Affichage de 100 fichiers sur 200. Ce diff contient trop de modifications pour tout afficher. Voir plus