Premier commit
Cette révision appartient à :
révision
84a72fe30c
200 fichiers modifiés
+61602
Aucun fichier ne correspond à votre recherche
@@ -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/
|
||||||
@@ -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
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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`.
|
||||||
@@ -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.
|
||||||
@@ -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).
|
||||||
@@ -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).
|
||||||
@@ -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.
|
||||||
@@ -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)
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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).
|
||||||
@@ -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).
|
||||||
@@ -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).
|
||||||
@@ -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).
|
||||||
@@ -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.
|
||||||
@@ -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.
|
||||||
@@ -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()`.
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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 errainercora_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é.
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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);
|
||||||
|
}
|
||||||
@@ -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;
|
||||||
|
}
|
||||||
@@ -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);
|
||||||
|
}
|
||||||
@@ -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;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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);
|
||||||
|
}
|
||||||
@@ -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);
|
||||||
|
}
|
||||||
@@ -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);
|
||||||
|
}
|
||||||
@@ -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;
|
||||||
|
}
|
||||||
@@ -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);
|
||||||
|
}
|
||||||
@@ -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];
|
||||||
|
}
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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
Référencer dans un nouveau ticket
Bloquer un utilisateur