commit 84a72fe30c4bd8a2741dde62e47f07a1c1054a3a Author: Théo Gastinel <264859180+gastinelt@users.noreply.github.com> Date: Sun Oct 11 01:54:18 2026 +0200 Premier commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ab20bb0 --- /dev/null +++ b/.gitignore @@ -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/ diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..27c4db5 --- /dev/null +++ b/CMakeLists.txt @@ -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 + $<$: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") diff --git a/MEMORY.md b/MEMORY.md new file mode 100644 index 0000000..e221516 --- /dev/null +++ b/MEMORY.md @@ -0,0 +1,2652 @@ +# Vercora — MEMORY.md + +Point d'entree rapide sur l'etat du projet. Pour le detail d'une phase donnee, +voir `NOTES-PHASE6.md`, `NOTES-PHASE7.md`, `NOTES-PHASE9.md`, `NOTES-PHASE10.md`, +`NOTES-PHASE11.md`, `NOTES-PHASE12.md`, `NOTES-PHASE-VELO.md`, +`NOTES-PHASE-ESCALADE.md`, `NOTES-PHASE15.md`, `NOTES-PHASE16.md`, +`NOTES-PHASE17.md`, `NOTES-PHASE18.md`, `NOTES-PHASE19.md`, +`NOTES-PHASE20.md` et `NOTES-PHASE21.md` ; ce fichier est +un resume vivant, mis a jour a la fin de chaque session, pas un journal complet. + +## Ce qu'est Vercora + +Jeu d'exploration de montagne solo, moteur maison C++20/Vulkan, cross-platform +Windows/Linux (GLFW + CMake). **LES QUATRE ACTIVITES DU CADRAGE ONT DESORMAIS UNE +BASE** : marche/abattage/taillage (fonctionnelles), parapente (Phase 8), velo +(Phase 13) et **escalade (Phase 14)**. Aucune n'est finie - chacune est un modele +simplifie, chiffre et teste - mais plus aucune n'est vide. + +**Depuis la Phase 15, le projet a aussi un OUTIL** : un editeur de niveau interne +(touche F2) qui pose des objets sur le relief. Ce qu'il pose fait partie du +MONDE - une partie normale les charge, les dessine et s'y cogne. Suite du +2026-08-23 : **F3/F4 selectionnent l'objet pose suivant/precedent SANS viser** +(detail plus bas, section Phase 15). + +## Etat verifie (2026-08-26, fin de Phase 20) + +- **GPU DE CETTE MACHINE : Intel UHD 770 integree.** Il n'y a plus de GTX 960 + (confirme par l'utilisateur, ce n'est pas un defaut de detection). Tous les FPS + releves avant la Phase 9 - dont les 848 FPS de la Phase 7 - ont ete mesures sur + la GTX et ne sont PAS comparables aux chiffres actuels. Repere re-mesure sur le + GPU actuel : la dalle unique de Phase 7 tourne a **247 FPS**. i5-14600K, + 64 Go de RAM, mesures en Debug avec couches de validation. +- **Build** : `tools\build.bat` (CMake + Ninja autonomes, cl.exe de VS 18 - voir + l'en-tete du script pour la corruption partielle de VS sur cette machine). +- **Tests headless** : `tools\run_logic_tests.bat` - **3578 assertions** (chiffre + de la Phase 23 ; il etait annonce a 935 en Phase 20, chiffre deja perime + ensuite), sans GPU + ni Vulkan (terrain, foret/abattage, ramassage, taillage, parapente, quadtree / + selection de LOD / frustum culling, format de texture .vcto, semis d'arbres et + d'herbe, format d'instance, chaine de peres du quadtree et invariants du repli + sur l'ancetre, la physique du velo depuis la Phase 13, celle de l'escalade + depuis la Phase 14, et **tout l'editeur sauf le dessin depuis la Phase 15** - + catalogue, raycast terrain, scene, annulation, collision, format .vcsc, + machine a etats, et **les quatre jauges de besoins plus la detection des + points d'eau depuis la Phase 16** - 129 assertions a elles seules, et + **l'empreinte environnementale depuis la Phase 17** - memoire du milieu, faune + et degradation du sol, 97 assertions, et le **SYSTEME METEO depuis la + Phase 23** - determinisme et independance du chemin, les deux couches, le + sondage amont du vent, la carte de piegeage d'air froid, le cycle jour/nuit et + les effets sur les quatre activites). +- **Vulkan reel** : `tools\run_vulkan_check.ps1` - **9 scenarios** (A gameplay + synthetique, B collision, C dalle LiDAR reelle, D vol en parapente, E sortie a + velo sur un versant mesure, F escalade sur une paroi mesuree, **G editeur de + niveau en trois processus - edition, relecture en jeu normal, et TEMOIN sans + la scene**, **H besoins primaires : depart sur un point d'eau detecte par le + jeu lui-meme, deux touches T qui exercent le test de portee dans les DEUX + sens, puis 160 s de marche et 60 s d'immobilite - la forme doit descendre PUIS + remonter**, **I empreinte environnementale : faune semee sur relief mesure, + 240 s de presence continue, la zone proche doit se VIDER**), sous couches de + validation. Zero `[Validation]`, zero + `[ERROR]`/`[WARN]` a chaque run reussi. + **`-Only `** (Phase 15) ne joue qu'une partie des scenarios, pour + iterer sans payer les quinze minutes de la suite complete ; un scenario non joue + est IGNORE, pas valide, donc un run de reference se fait sans `-Only`. + **Flakiness connue** : les scenarios A/B pilotes par PostMessage + (scancodes, pas de vraie souris) echouent parfois sur un detail de timing + (cible d'abattage manquee de peu, ou WM_CLOSE lent a etre traite) - c'est une + variance d'automatisation deja documentee dans le script (antivirus/ + ordonnancement), PAS un defaut du jeu. Reste correle : re-executer suffit. + Le scenario D (parapente), lui, a reussi 3 fois sur 3 lors de son ajout. +- **Validation de SYNCHRONISATION** (Phase 12, nouvelle) : les couches standard + ne verifient PAS les dependances memoire - elles etaient a zero message y + compris avec une synchronisation fausse. Pour tout changement de synchro GPU, + relancer avec `set VK_LAYER_VALIDATE_SYNC=1`, et faire le CONTROLE NEGATIF + (retirer la barriere, verifier que l'outil crie). C'est ce qui a mis au jour un + defaut de dependance de subpass anterieur a la Phase 12. +- **Le jeu lit le clavier et la souris SYSTEME.** Toute manipulation de la + machine pendant une capture ou une mesure automatisee deplace la camera. Depuis + la Phase 11, `--lock-input` (passe PAR DEFAUT par `screenshot_scene.ps1`) fige + entierement la camera, et `--start=est,nord` / `--look=yaw,pitch` determinent la + vue. Sans ce verrou, deux captures du meme script differaient sur 65 % de leurs + pixels. **PRECISION DE LA PHASE 12** : `--lock-input` seul ne suffit PAS a + garantir le cadrage - trois captures de la meme scene ont donne 38,2 / 38,3 / + 32,9 % de ciel, donc trois vues differentes. **Pour toute comparaison d'image, + epingler aussi `--look`** ; on retombe alors dans le bruit (une soixantaine de + pixels sur 921 600 entre deux runs identiques). +- **PRECISION DE LA PHASE 15, et c'est un piege a part** : `--lock-input` ne + verrouillait que la CAMERA. L'editeur, lui, lisait la souris directement, et + une execution complete du harnais a pose **9 objets pour 3 touches envoyees** - + les clics REELS de l'utilisateur atterrissant dans la fenetre du jeu, qui prend + le focus a chaque nouveau processus. La nuance GLFW qui rendait ca invisible : + la POSITION du curseur vient de `GetCursorPos()` (un WM_MOUSEMOVE poste n'a + aucun effet, limite connue), mais **l'ETAT DES BOUTONS est mis en cache depuis + les messages de fenetre** - donc les clics passent la ou le curseur ne passe + pas. Corrige : `--lock-input` coupe aussi la pose au clic. Controle negatif, + 3 clics postes -> **3 objets avant, 0 apres**. Le CLAVIER reste vivant (touche + INSER), sans quoi aucun scenario ne pourrait piloter l'editeur. +- Terrain LiDAR reel (dalle Le Gua/Isere, 1001x1001, 562 m de denivele) chargee + et fonctionnelle par defaut ; terrain synthetique reste le monde de reference + des tests (semis deterministe). + +## Phase 8 (2026-08-20) : visee sur relief + base du parapente + +### Correction de la visee d'arbre (pas un bug de gameplay) + +Le vrai souci de la Phase 7 ("6 arbres sur 16 abattables sur relief reel") +n'etait **pas** dans le jeu : `Forest::pickTree` (src/world/Forest.cpp) a +toujours fait une intersection rayon 3D correcte, et le gameplay reel +(`main.cpp`, appel a `forest->pickTree(camera.position(), camera.front(), ...)`) +vise deja avec le pitch de la camera inclus (`Camera::front()` a une composante +Y des que `pitch_ != 0`). Le rayon HORIZONTAL etait confine au harnais de test +`--dump-world` (`dumpWorld()` dans `main.cpp`), necessaire parce que +`run_vulkan_check.ps1` ne peut pas piloter la souris (GLFW lit le curseur +SYSTEME, pas les messages postes - voir l'en-tete du script). + +Corrige : `dumpWorld()` vise maintenant le tronc de chaque arbre (mi-hauteur) +avec un rayon pitch-inclus (`normalize(cible - oeil)`), et journalise le pitch +requis + la categorie (au-dessus/en-dessous/au-niveau). **16 arbres sur 16 +sont abattables sur la dalle LiDAR reelle** des que le pitch est utilise - +confirme par `vercora.exe --dump-world` (voir aussi le terrain synthetique, +16/16 egalement, avec les 3 categories representees). Une seconde ligne +`AIMLEVEL` (rayon horizontal, comme avant) reste emise pour le tir REELLEMENT +joue par le script, puisque celui-ci ne peut physiquement pas incliner la +camera pendant un run. + +### Parapente : premiere session de physique + +Nouveau : `src/world/Paraglider.{hpp,cpp}` - modele de vol volontairement +simplifie (pas d'aerodynamique, pas de vent/thermiques - viendront avec la +meteo) : +- vitesse de croisiere ~38 km/h, taux de chute 1,25 m/s en air calme ; +- virage a vitesse angulaire constante (25 deg/s), donc rayon de virage fini, + pas une rotation instantanee ; +- frein (touche S en vol) : reponse EXPONENTIELLE (constante de temps 0,5 s) + vers une vitesse plus faible et un taux de chute legerement plus fort - pas + un interrupteur ; +- atterrissage detecte des que l'altitude rejoint `terrain.heightAt(x,z) + + eyeHeight`, position collee exactement au sol. + +Integration dans `main.cpp` : touche **V** decolle (uniquement en mode Free, +au moins 5 m au-dessus du terrain sous les pieds) ou force un atterrissage si +deja en vol (filet de securite). Pendant le vol, A/D tournent, S freine ; +`Forest::update` continue de tourner (une chute d'arbre en cours ne se fige +pas parce qu'on decolle) mais E/R/C sont desactives. Un cube fait office de +marqueur visuel du pilote (pas de vrai mesh d'aile pour cette session). + +Camera : nouveau mode `CameraMode::Glide` (src/core/Camera.hpp/cpp) - la +camera ne pilote plus rien elle-meme en vol, elle affiche une vue chase-cam +(troisieme personne, derriere et au-dessus du pilote) via la nouvelle methode +`Camera::setChasePose(eye, lookAt)`, qui recalcule aussi yaw_/pitch_ pour que +le retour en marche apres atterrissage ne fasse pas sauter l'orientation. + +Verifie : 16 nouvelles assertions headless (`tests/logic_tests.cpp`, section +"Phase 8") + scenario D de `run_vulkan_check.ps1` (decollage, virage, frein, +atterrissage NATUREL contre le relief LiDAR reel, resize, fermeture propre) - +zero erreur de validation, 3 executions sur 3 reussies. + +### Hors scope, assume (a reprendre plus tard) + +- Pas de vent/thermiques/ascendances (systeme meteo a venir). +- Pas de collision avec les arbres pendant le vol. +- Pas de gestion de crash/dommages : un atterrissage brutal se comporte comme + un atterrissage normal. +- Pas de vrai mesh d'aile/pilote ni de course d'elan au decollage. +- Le marqueur cube n'a pas d'animation ni d'inclinaison en virage (visuel + minimal, purement pour la lisibilite du test). + +## Phase 9 (2026-08-21) : la vraie zone de jeu, 25 dalles assemblees + +Detail complet dans `NOTES-PHASE9.md`. (La consigne de session parlait de +"Phase 8" ; ce numero etait deja pris par la session parapente ci-dessus, d'ou +Phase 9.) + +**La zone de jeu est choisie et assemblee** : grille 5 x 5 km, Lambert 93 +X 899-903 / Y 6436-6440, massif d'altitude (1028,8 a 2285,2 m, **1256 m de +denivele**). C'est la session qui a mis a l'epreuve les deux bugs d'arrondi +corriges en Phase 7 mais jamais eprouves en multi-dalles. + +### Chiffres + +| | | +|---|---| +| Telechargement | 25/25 dalles, **4,99 Go en 73 s** (~85 Mo/s), 0 echec | +| Sur disque | `data/lidar` **5,2 Go**, `assets/terrain` 271 Mo | +| Conversion | ~6 s/dalle, ~2,5 min au total, toutes en 1001 x 1001 au pas de 1 m | +| Terrain assemble 1 m | **5001 x 5001**, 95,4 Mo (et non 5005 : bords PARTAGES) | +| Terrain assemble 2 m | 2501 x 2501, 25 Mo | + +### Continuite aux frontieres : VERIFIEE, conforme + +Deux controles independants, sur les **8 frontieres interieures**, pas seulement +a l'oeil : + +1. `tools/check_seams.py` (nouveau) confronte le terrain assemble aux **nuages + bruts**, 1 360 sondes exploitables. Lecture directe **0,020 m** d'ecart median + contre **0,290 m** pour le meilleur decalage d'un noeud, soit **x14,5** : c'est + ce CONTRASTE qui prouve l'alignement. Les 8 frontieres ont une mediane + <= 0,030 m ; les temoins en plein milieu de dalle sont a 0,000 m. +2. `tools/assemble_terrain.py` mesure la pente aux jointures sur le produit fini : + aucune ne se distingue du relief environnant (un decalage la rendrait trop + grande, une colonne dupliquee trop faible). + +Ecart entre les deux versions d'un noeud partage (40 040 noeuds) : mediane +**0,170 m**, p99 2,78 m, max 79,23 m. **Les valeurs extremes sont sur des parois +verticales** (relief local median de 34 a 60 m d'amplitude sur 5 m, contre 1,6 m +pour les noeuds concordants) : c'est la limite d'une heightmap 2,5D sur une +falaise, pas un defaut d'assemblage. Verifie point par point sur le pire noeud. + +### Performances - LE POINT IMPORTANT + +| Scene | Triangles | FPS | Pic RAM | +|---|---:|---:|---:| +| Procedural | 32 258 | 1381 | 108 Mo | +| 1 dalle 1 m (Phase 7) | 2 000 000 | 247 | 302 Mo | +| 2 x 2 dalles 1 m | 8 000 000 | 67 | 805 Mo | +| **5 x 5 dalles 2 m (25 km2)** | 12 500 000 | **46** | 1 083 Mo | +| **5 x 5 dalles 1 m (25 km2)** | 50 000 000 | **12** | 4 014 Mo | + +Zero erreur de validation Vulkan sur les cinq scenes. Le 25 km2 a 1 m **charge et +fonctionne, mais n'est pas jouable**. La camera traverse 5,6 km en franchissant +les anciennes frontieres sans aucune chute de FPS localisee, sans blocage, sans +chute a travers le sol (`tools/traverse_terrain.ps1`). + +**=> LE STREAMING PAR TUILES DEVIENT NECESSAIRE MAINTENANT, pas plus tard.** Le +facteur limitant n'est ni la RAM (4 Go sur 64), ni le disque, ni la conversion : +c'est que le moteur envoie **un seul maillage entier a chaque image**, sans LOD ni +culling, alors que le joueur n'en voit qu'une fraction infime. Le cout est +proportionnel a la surface (247 -> 67 -> 12 FPS pour 1 -> 4 -> 25 km2). Les 25 +heightmaps individuelles sont conservees et leur georeferencement est exact : le +decoupage en tuiles n'aura rien a redecouper. + +En attendant, **`assets/terrain/vercora_zone_2m.vchm` est le repli utilisable** : +meme zone de 25 km2, 46 FPS, 1 Go. Ce n'est pas un substitut au 1 m, qui est +produit, verifie et livre. + +### Non-regression : complete + +Terrain procedural (1381 FPS) et dalle unique de Phase 7 (247 FPS) intacts et +toujours disponibles ; **185 assertions headless** passent ; +**`run_vulkan_check.ps1` : 4 scenarios sur 4, zero validation, du premier coup**. +`vercora.exe` sans argument charge **toujours la dalle de Phase 7** : la zone +25 km2 se charge par chemin explicite, le choix du defaut revient a +l'utilisateur une fois le streaming en place. + +**Aucun fichier de `src/` n'a ete modifie en Phase 9.** + +## Phase 10 (2026-08-21) : quadtree, LOD continu (CDLOD) et frustum culling + +Detail complet dans `NOTES-PHASE10.md`. C'est la reponse au verdict de la +Phase 9 : le moteur envoyait UN SEUL maillage entier par image, sans LOD ni +culling, d'ou un cout proportionnel a la surface du terrain. + +### Le resultat + +Meme zone, meme position de camera, meme binaire, Debug avec couches de +validation, Intel UHD 770. + +| Scene | Phase 9 (bloc unique) | **Phase 10 (LOD)** | +|---|---:|---:| +| **25 km2 au pas de 1 m** | 12 FPS / 4 014 Mo | **487 FPS / 246 Mo** | +| **25 km2 au pas de 2 m** | 46 FPS / 1 083 Mo | **601 FPS / 166 Mo** | +| 1 dalle 1 m (Phase 7) | 247 FPS / 302 Mo | **847 FPS / 141 Mo** | +| Procedural (Phase 4) | 1 381 FPS / 108 Mo | 1 244 FPS / 106 Mo | + +Sur la zone 1 m : **50 000 000 -> 548 864 triangles soumis** (1,1 %), chargement +**10,4 s -> 0,5 s**. Zero message `[Validation]` sur les quatre scenes. +Controle visuel automatise (`tools\screenshot_scene.ps1`) : la vue avec LOD est +identique a la vue sans LOD, ce qui ecarte l'hypothese "excellents FPS parce que +le culling est casse". + +### Comment le quadtree est structure + +Nouveaux fichiers : `src/core/Frustum.hpp`, `src/world/TerrainQuadtree.{hpp,cpp}`, +`src/renderer/TerrainNodeMesh.{hpp,cpp}`, `src/renderer/TerrainStreamer.{hpp,cpp}`. +Les trois premiers ne dependent que de GLM et sont **executes** dans les tests +headless ; seul le streamer touche a Vulkan. + +**Chaque noeud est toujours maille avec le meme nombre de sommets** (65 x 65, +8 192 triangles). Ce qui change avec le niveau, c'est le PAS d'echantillonnage : +niveau L = pas 2^L, couvre 64 x 2^L cellules. Un noeud de niveau L coute donc le +meme prix GPU qu'une feuille en couvrant 4^L fois plus de terrain. La racine est +le plus petit niveau couvrant toute la grille (zone 1 m : niveaux 0..7, 8 380 +noeuds). + +Deux details qui comptent : les bornes verticales d'une feuille sont calculees a +la PLEINE resolution (une boite trop petite ferait disparaitre du terrain au +culling), et les indices sont ECRETES sur le bord du terrain (5 000 n'est pas +multiple de 64 ; sans ecretage la racine produirait une "etagere" plate de 3,2 km +au-dela des donnees). + +### Comment les LOD sont selectionnes + +`range[L] = 3 x tailleMonde(tuile L)`, donc DOUBLE a chaque niveau (au pas de +1 m : L0 <= 192 m ... L7 <= 24 576 m). Descente depuis la racine : hors frustum -> +abandon de tout le sous-arbre ; niveau 0 ou distance >= range[L-1] -> le noeud est +dessine ; sinon on descend dans les 4 fils. La distance est celle a la BOITE du +noeud, pas a son centre. + +**Geomorphing** : chaque sommet porte aussi sa position/normale dans la grille du +niveau superieur (attributs de sommet 4 et 5, obtenus en arrondissant les indices +LOCAUX a un multiple de 2). Le vertex shader interpole selon la distance du +sommet, dans la bande `[0,70 ; 0,95] x range[L]` poussee par push constant. +Ca supprime le popping ET les fissures : au-dela de range[L] une tuile L est +entierement morphee sur la grille L+1, ou sa voisine L+1 est encore a morph = 0. +**C'est pourquoi morphStartRatio doit rester > 0,5** (le constructeur refuse le +contraire). La distance est prise sur la position NON morphee, pour que deux +tuiles voisines s'accordent sur un sommet partage. + +### Decouplage rendu / collision : verifie, rien n'a change cote physique + +La `Heightmap` pleine resolution reste la source UNIQUE de `heightAt()` : +`Camera`, `Forest`, `Ground`, `Paraglider` la consomment inchangee. Le quadtree ne +detient que des BORNES, pas d'altitudes. Verifie par un test headless dedie +(`heightAt()` identique au bit pres selon que le quadtree vient d'etre selectionne +de tres loin ou au contact) et par `run_vulkan_check.ps1` : **4 scenarios sur 4, +du premier coup**, 2 abattages, 3 debitages, 8 ramassages, 1 percussion, collision +tronc/souche, vol de parapente avec atterrissage naturel. Au contact du joueur les +tuiles sont de niveau 0, donc la surface affichee y est aussi celle de la donnee. + +### Ce qui reste a ameliorer (par ordre d'importance) + +1. ~~**Transfert asynchrone.**~~ **LEVE EN PHASE 12.** Le `vkQueueWaitIdle` par + upload a disparu du chemin de streaming, le budget est passe de 4 a 64 tuiles + par frame. +2. **Index buffer partage.** La topologie est identique pour toutes les tuiles + (teste), mais chacune a encore son propre index buffer : 98 Ko et une + allocation Vulkan gaspilles par tuile. +3. **Alleger le sommet.** Il est passe de 44 a 68 octets pour porter le + geomorphing. Consequence honnete : le chemin `--no-lod` a REGRESSE (zone 1 m : + 12 -> 9 FPS, 4,0 -> 5,6 Go) et le terrain procedural perd 10 % (1 381 -> + 1 244 FPS). Le chemin reel, lui, n'a jamais 25 M de sommets en vol. Piste : + n'encoder que le DELTA de morphing, ou reprendre `color`/`uv` inutilises. +4. ~~Pas de repli sur l'ancetre quand une tuile n'est pas encore construite.~~ + **LEVE EN PHASE 12** (repli + sommet du quadtree epingle). +5. Pas de streaming DISQUE : la heightmap entiere (95 Mo) reste chargee d'un bloc. +6. Les parametres du quadtree ne sont pas reglables en ligne de commande. +7. Aucun test automatique ne cherche une fissure dans l'IMAGE rendue. + +### Traversee en mouvement : 20 km, zero validation + +`traverse_terrain.ps1` sur la zone 25 km2 au pas de 1 m, 20 km parcourus (2,5 km +par branche, aller-retour sur les deux axes, en sortant deux fois de l'emprise) : +FPS moyen de 459 a 725 selon la branche, **minimum instantane 146 FPS** - soit +douze fois le chiffre MOYEN de la Phase 9 a l'arret. Zero `[Validation]`, aucune +chute localisee aux anciennes frontieres de dalles, aucune chute a travers le sol. + +**Un incident non elucide** : sur ce run de 20 km, le jeu n'est pas sorti dans les +30 s apres `WM_CLOSE` (tue par le script). Enquete : une traversee de 3,2 km sort +proprement, et une sonde chronometrant la fermeture apres 0 s / 60 s / 180 s de +marche continue (jusqu'a 130 tuiles residentes) donne **0,1 s dans les trois cas**. +Le temps de sortie ne depend donc PAS du nombre de tuiles residentes ; rien ne +rattache l'incident au streaming, et ca ressemble a la flakiness `PostMessage` +deja connue. Mais 30 s reste beaucoup, et ce n'est pas reproduit : **a re-tenter +au prochain run long**, pas classe. + +### Non-regression + +**223 assertions headless** (185 avant, +38 pour la Phase 10) ; +**`run_vulkan_check.ps1` : 4/4, zero validation, du premier coup** ; terrain +procedural et dalle de Phase 7 intacts et plus rapides qu'avant ; scenes non +terrain intactes (`vercora.exe cube` a 3 403 FPS, zero validation - le materiau +`Object` ne se voit decrire que 4 attributs de sommet, cf. `ShaderSet:: +usesMorphAttributes`) ; `--dump-world` retrouve 16 arbres visables sur 16. +`vercora.exe` sans argument charge **toujours la dalle de Phase 7** ; toute scene +de terrain passe desormais par le quadtree, sauf avec l'option **`--no-lod`**, qui +reproduit le comportement de la Phase 9 pour la comparaison. + +## Phase 11 (2026-08-21) : orthophoto, arbres a l'echelle, herbe + +Detail complet dans `NOTES-PHASE11.md`. Le terrain LiDAR ne portait QUE de la +geometrie : cette session lui donne une couleur reelle et l'habille. + +### Le resultat + +| Scene, position de depart par defaut | FPS median | Pic RAM | +|---|---:|---:| +| Zone 25 km2 a 1 m, chemin Phase 10 (`--no-ortho --no-vegetation`) | 514 | 240 Mo | +| **Zone 25 km2 a 1 m, Phase 11 complete** | **271** | **332 Mo** | + +Cout brique par brique, meme vue : terrain seul 658 FPS -> +orthophoto 637 -> ++arbres 466 -> +herbe 283. **L'orthophoto coute 3 % de FPS et 101 Mo** : c'est de +loin le meilleur rapport de la session. Zero `[Validation]` partout. + +### Orthophoto + +BD ORTHO IGN par le WMS de la Geoplateforme (couche `HR.ORTHOIMAGERY.ORTHOPHOTOS`, +licence Etalab), meme portail que le LiDAR. **25 tuiles, 23,8 Mo en 101 s.** + +- **L'emprise est LUE dans l'en-tete du .vchm**, jamais recopiee a la main. +- **Le serveur ne parle que WMS 1.3.0, et l'ordre des axes en EPSG:2154 est + EST,NORD** - tranche par l'experience : l'ordre inverse renvoie une image + BLANCHE UNIFORME. Rejoue a chaque execution (`--self-test`). +- Les UV du terrain etaient DEJA en coordonnees du terrain entier depuis la + Phase 10 : rien a changer cote maillage, et `gz = 0` correspond au nord donc a + `v = 0` - **aucun retournement necessaire**. +- Format maison **`.vcto`** : 8192 x 8192, **0,61 m/texel**, BC1, 14 mipmaps + PRECALCULEES (on ne peut pas filtrer des blocs BC1 sur le GPU), 44,7 Mo au lieu + de 357 Mo en RGBA8. Encodeur numpy maison, **PSNR 33,2 dB**. +- `samplerAnisotropy` activee (optionnelle en Vulkan, abandonnee proprement si + absente) : indispensable pour un plan regarde en rasant. +- Binding 1 declare pour TOUS les materiaux, occupe par une texture 1x1 blanche + tant qu'aucune photo n'est chargee. Repli procedural conserve : touche **O**, + ou `--no-ortho`. +- `orthoMatchesTerrain()` REFUSE une texture dont l'emprise ne correspond pas au + terrain charge, a 0,5 m pres. + +### Arbres : la classification LiDAR est exploitable, et excellente + +`tools/lidar_to_canopy.py` depouille les 25 dalles en **150 s** et produit deux +cartes au pas de 5 m, **au format .vchm** (une grille de flottants georeferencee +n'a pas a contenir des altitudes) : le **couvert** (part des retours de classes +3/4/5, dit OU semer) et la **hauteur de canopee** (dit QUELLE TAILLE). + +**Validation croisee decisive**, contre l'orthophoto qui est une source +totalement independante : correlation couvert / luminance de **-0,729** ; +cellules a couvert > 0,70 -> RVB (67,75,72) vert sombre ; cellules nues -> +(162,162,153) gris clair. Cela valide d'un coup le georeferencement des DEUX +jeux de donnees. + +`world/Vegetation` a cote de `world/Forest`, **deux systemes et non un** : +`Forest` garde ses 16 arbres abattables a etat, `Vegetation` produit des dizaines +de milliers d'arbres de decor sans etat. **Rien n'est stocke pour les 25 km2** : +le semis est une fonction deterministe de la cellule, par HACHAGE et non par un +generateur a etat - un `mt19937` dependrait de l'ordre d'appel, donc du chemin +parcouru (teste). Densite obtenue : **59 arbres/ha** sur toute la zone. + +**Niveau de detail de densite** : chaque emplacement de cellule a sa PROPRE +portee (1100 m pour le premier, 320 m pour le dernier), donc la foret +s'eclaircit arbre par arbre au lieu de sauter par bosquets. Le fondu se fait par +RETRECISSEMENT, pas par transparence : aucun tri en profondeur necessaire. + +**Instanciation GPU ajoutee au moteur** (elle n'existait pas) : binding de +sommets 1 cadence par instance, `InstanceData` de **28 octets**, materiau +`Foliage` partage par les arbres et l'herbe, buffer par frame-in-flight qui +grandit a la demande. + +### La mesure qui a change le code + +Les arbres coutaient bien plus que leur geometrie. Experience discriminante : +camera vers le CIEL, donc presque aucun arbre dessine mais le meme balayage. +**1946 FPS sans vegetation contre 351 avec** : **2,3 ms par image de balayage +PUR**. Le cout etait la boucle qui visitait ~8400 cellules par image, y compris +derriere le joueur. + +Correctif : **culling par blocs de 8x8 cellules** (16x16 pour l'herbe), plus la +suppression d'un `heightAt()` calcule deux fois par touffe. Balayage 2,3 ms -> +0,11 ms ; scene complete 193 -> 283 FPS. **Verifie NON DESTRUCTIF** (le piege des +"excellents FPS parce que le culling est casse") : comptes d'instances +identiques au chiffre pres, et 98 pixels differents sur 879 360. + +### Herbe : un essai, etat honnete + +Bruit de valeur a deux octaves (longueur d'onde 14 m) pour GROUPER les touffes, +taille et densite pilotees par l'altitude (0,30 m en bas, 0,11 m en haut ; dense +sous 1750 m, absente au-dessus de 2250 m), portee courte (34 m, fondu des 14 m), +instanciation GPU. La donnee LiDAR distingue le pre du sous-bois et du lapiaz. + +**Ce qui ne convainc pas** : avec 2158 touffes dans une vue de prairie, cela se +lit comme un **semis de touffes espacees, pas comme un tapis** - il en faudrait +4 a 5 fois plus. Chaque touffe est un eventail de 3 quads OPAQUES sans texture ni +decoupe alpha (choix qui evite tout melange alpha, donc tout tri en profondeur, +mais qui plafonne le realisme). A noter : ce massif est majoritairement forestier +et rocheux, la prairie ouverte sous 1500 m n'y represente que **0,4 %** des +cellules - l'herbe y a structurellement peu de terrain. + +### Non-regression + +**268 assertions headless** (223 avant, +45) ; **`run_vulkan_check.ps1` : 4/4 du +premier coup**, zero validation, 2 abattages / 3 debitages / 8 ramassages / +1 percussion / vol de parapente. `--dump-world` intact. + +Terrain procedural et dalle de Phase 7 : le chemin Phase 10 est **intact et meme +plus rapide** (1348 et 884 FPS avec `--no-vegetation`, contre 1244 et 847 en +Phase 10). Leur baisse en Phase 11 complete (258 et 212 FPS) est le COUT de la +vegetation, qui y est semee par un substitut par pente et altitude faute de carte +LiDAR - pas une regression. + +### Options et touches ajoutees + +`--no-ortho`, `--ortho=chemin.vcto`, `--no-vegetation`, `--no-grass`, +`--start=est,nord`, `--look=yaw,pitch`, `--lock-input`. +Touches **O** (orthophoto / procedural) et **G** (tout / arbres seuls / rien). + +### Ce qui reste a ameliorer (par ordre d'importance) + +1. **Texture de detail de pres** : a 0,61 m/texel l'orthophoto est molle sous les + pieds (un texel couvre ~150 pixels d'ecran a 3 m). C'est le defaut visuel le + plus visible. +2. **Densifier l'herbe et lui donner une decoupe alpha** (`discard` plutot que + melange, pour eviter le tri). +3. **Promotion d'un arbre de decor en arbre abattable** a l'approche : seuls les + 16 arbres de `Forest`, semes autour de l'origine, sont abattables. Un joueur + qui marche 200 m est dans une foret entierement decorative. +4. **Collision avec les arbres de decor** : ils se traversent. +5. Ombres portees (les arbres flottent visuellement sur le sol). + +## Phase 12 (2026-08-21) : transferts de tuiles asynchrones et repli sur l'ancetre + +Detail complet dans `NOTES-PHASE12.md`. C'est la levee du **verrou n 1** pose par +la Phase 10 : `VulkanBuffer::copyFrom` faisait un `vkQueueWaitIdle` par upload de +tuile, d'ou un budget de 4 tuiles par frame et un TROU la ou une tuile n'etait pas +prete. + +### Le GPU de cette machine n'a PAS de queue de transfert dediee + +Journalise a chaque demarrage : `Familles de queues : 2 - [0] x1 graphics compute +transfer sparse [1] x2`. La famille 1 est une famille video, sans bit transfert. +La branche "queue dediee" ne s'applique donc pas ici, et elle n'a **pas** ete +ecrite : elle imposerait un transfert de propriete de famille de queue +(release/acquire) qu'aucun test de cette machine ne pourrait exercer. La detection +existe et est journalisee (`QueueFamilyIndices::dedicatedTransferFamily`). + +### L'architecture retenue + +Les copies staging -> device-local ne sont plus attendues : `Mesh` les confie a un +**`BufferUploader`** (interface dans `VulkanBuffer.hpp`, implementee par le +`Renderer`), qui les accumule et les enregistre **en tete du command buffer de la +frame**, avant `vkCmdBeginRenderPass`, suivies d'**UNE** `VkMemoryBarrier` +`TRANSFER_WRITE -> VERTEX_ATTRIBUTE_READ | INDEX_READ` +(`TRANSFER -> VERTEX_INPUT`). + +Une seule soumission par frame, aucune attente CPU, dependance memoire +**explicite et verifiable**, et la tuile est lisible **des cette frame** - il n'y +a donc aucune latence de transfert a masquer. + +Les buffers staging survivent via le meme compte a rebours que `retiredMeshes_` +de la Phase 10 (`kMaxFramesInFlight + 1` vieillissements). + +**Un seul `vkQueueWaitIdle` subsiste**, dans `Renderer::flushCopiesNow`, atteint +uniquement quand le staging vivant depasse **128 Mo** : c'est le garde-fou du +chemin `--no-lod`, dont le maillage unique de 3,4 Go faisait autrement passer le +pic memoire de 5,6 a 6,9 Go. **0 declenchement** sur tout le streaming. + +### La verification qui compte : controle NEGATIF + +Un journal propre ne prouve rien si l'outil ne regarde pas au bon endroit. La +barriere a donc ete retiree volontairement : + +| Barriere | Validation de synchronisation | +|---|---| +| **retiree** | **10 x `READ_AFTER_WRITE hazard ... reads index VkBuffer ... written by vkCmdCopyBuffer`** | +| en place | **0** | + +Au passage, la validation de synchronisation a revele un defaut **anterieur** : la +dependance de subpass de `SwapChain` avait `srcAccessMask = 0`, alors qu'il n'y a +qu'UN buffer de profondeur pour deux frames-in-flight - WRITE_AFTER_WRITE entre le +clear de la frame N+1 et le storeOp de la frame N. Reproduit sur la scene `cube`, +donc sans aucun upload. Corrige. + +### Le repli sur l'ancetre, et pourquoi il ne suffisait pas + +Une tuile pas encore construite n'est plus un trou : on remonte sa chaine de peres +(nouveau `Node::parent`) jusqu'a une tuile residente. Le repli **remplace** le +sous-arbre au lieu de s'y superposer, sinon deux surfaces de niveaux differents se +disputeraient le z-buffer. + +**Le repli seul ne suffisait pas**, et c'est une mesure qui l'a montre. Un +diagnostic sur les tuiles restees non couvertes a donne : niveaux 3, 4 et 5, dont +les ancetres de niveau 6 et 7 n'avaient **jamais ete dessines** - 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. + +D'ou le **sommet du quadtree epingle** : les 3 niveaux les plus grossiers sont +construits au demarrage et jamais evincees (**14 tuiles, 5 Mo** sur la zone de +25 km2). Tout noeud selectionne est alors soit epingle, soit descendant d'un +epingle : **un trou devient structurellement impossible**, et le compteur +`uncoveredNodes()` reste mesure a chaque frame pour le prouver. + +Une hypothese intermediaire - "le LRU evince les ancetres", corrigee par une +eviction biaisee par niveau - a ete **testee, mesuree marginale (25 -> 23 frames) +et retiree**. + +### Les trous : mesures + +Zone 25 km2 a 1 m, survol scripte (`--flythrough`), meme binaire, seules les +options changent. A **60 m/s** (six fois un parapente) meme les reglages Phase 10 +ne produisent aucun trou : il a fallu monter en vitesse pour que la comparaison +prouve quelque chose. + +| Vitesse | Budget | Repli | Sommet epingle | Frames a trou | +|---:|---:|:---:|:---:|---:| +| 300 m/s | 4 | non | non | 21 / 6 750 | +| 900 m/s | 4 | non | non | 112 / 4 780 | +| 900 m/s | 1 | non | non | 1 973 / 4 798 | +| 900 m/s | 4 | oui | non | 25 / 4 739 | +| **900 m/s** | **1** | **oui** | **oui** | **0 / 4 748** | +| **900 m/s** | **64 (defaut)** | **oui** | **oui** | **0 / 4 063** | + +A 900 m/s avec 1 tuile/frame, le repli est sollicite sur **1 969 frames sur +4 748** et ne manque jamais sa cible. + +**Vol en parapente REEL** (physique du jeu, decollage, 12 virages, atterrissage +naturel contre le relief) sur la zone de 25 km2, sous validation de +synchronisation : **0 trou sur 25 501 frames**, 0 hazard, 0 `[Validation]`. + +### FPS/RAM : le FPS n'a pas bouge, et c'est normal + +| Scene, a l'arret | Avant | Apres | RAM avant | RAM apres | +|---|---:|---:|---:|---:| +| Zone 25 km2 a 1 m | 312 | 292 | 332,2 Mo | 332,3 Mo | +| Dalle de Phase 7 | 218 | 216 | 128,8 Mo | 151,2 Mo | +| Terrain procedural | 267 | 263 | 106,9 Mo | 109,9 Mo | +| Zone 1 m `--no-lod` | 9 | 9 | 5 600 Mo | 5 637 Mo | + +**Les ecarts de FPS sont du bruit**, et un temoin le prouve sur le MEME binaire : +a l'arret aucun transfert n'a lieu, donc les reglages de streaming ne peuvent +rien changer - reglages Phase 10 **285 FPS** contre reglages Phase 12 **292 FPS**, +et sous survol a 60 m/s **422** contre **418**. Cinq runs consecutifs de la meme +configuration donnent 278/280/292/293/295 : le bruit de cette machine vaut ~5 %. +Le verrou leve ne se manifestait pas en FPS moyen mais en **trous visuels**. + +La RAM, elle, a bouge et c'est explicable : +22,4 Mo sur la dalle de Phase 7 +(21 tuiles epinglees + les staging qui coexistent au lieu de se succeder), zone +25 km2 inchangee, `--no-lod` +0,7 % grace au garde-fou. + +### Controle visuel + +Avec la vue EPINGLEE (`--look`), zone 25 km2, vegetation coupee : reglages Phase 12 +contre reglages Phase 10 = **45 pixels differents sur 921 600**, soit MOINS que le +temoin de la meme configuration relancee deux fois (60 pixels). Meme nombre de +tuiles dessinees (66/66) et de triangles (540 672). + +**Piege a connaitre** : sans `--look`, trois captures de la meme scene ont donne +38,2 / 38,3 / 32,9 % de ciel, donc trois cadrages differents, et une comparaison +pixel a pixel sans valeur (2,4 % d'ecart, pur artefact). `--lock-input` seul n'a +pas suffi. **Pour toute comparaison d'image, epingler `--look`.** + +### Options ajoutees + +`--tile-budget=N` (defaut 64 ; 4 = plafond Phase 10), `--no-tile-fallback` +(comportement Phase 10), `--flythrough=V[,H]` (survol scripte a V m/s, H m +au-dessus du relief, virage de 90 deg au bord). + +### Non-regression + +**280 assertions headless** (268 avant, +12) ; **`run_vulkan_check.ps1` : 4/4 du +premier coup**, zero validation ; **traversee de 20 km** sur la zone 25 km2, zero +validation, code de sortie 0 (et **l'incident de sortie lente de la Phase 10 ne +s'est pas reproduit** - toujours pas explique, toujours pas reproduit) ; +`--dump-world` 16 AIM sur 16 ; `cube`, `icosphere.obj`, `--no-lod`, procedural, +dalle de Phase 7 intacts. Le decouplage +rendu/collision de la Phase 10 n'est pas touche : le repli ne concerne que ce qui +est DESSINE. + +### Ce qui reste a ameliorer + +1. **Le maillage d'une tuile reste synchrone sur le thread de rendu** (~385 Ko a + produire par tuile). C'est desormais LE cout du streaming : le prochain verrou + est un thread de maillage, plus le transfert. +2. La branche "queue de transfert dediee" n'est pas ecrite (voir plus haut). +3. Le repli degrade la resolution sur toute l'emprise de l'ancetre, pas seulement + sur la tuile manquante : une L4 manquante fait basculer ~2 km de terrain en L5 + le temps d'une frame ou deux. Compromis assume. +4. Une fissure fine reste possible au bord d'un ancetre de repli, et **aucun test + automatique ne cherche une fissure dans l'IMAGE** (limite ouverte depuis la + Phase 10). +5. Le cadrage de `screenshot_scene.ps1` n'est pas reproductible sans `--look`, + malgre `--lock-input` : a comprendre. + +## Phase 13 (2026-08-22) : physique du velo + +Detail complet dans `NOTES-PHASE-VELO.md`. Troisieme activite, meme intention que +le parapente : un modele simplifie mais chiffre et testable. + +Nouveau : `src/world/Bike.{hpp,cpp}`. Comme `Paraglider`, la classe ne connait ni +Vulkan ni la `Camera` ; elle consomme `core/HeightSampler` (altitude et pente) et +`core/CollisionSolver` (obstacles), donc elle est **executee** dans les tests +headless. + +### Le modele en une ligne + +Somme d'accelerations integree a chaque pas - pesanteur le long de la pente, +pedalage decroissant avec la vitesse, frein manuel, resistances - donc **aucun +changement instantane de vitesse**. La verticale n'est jamais une variable +d'etat : `position.y` est relue de `heightAt()` a chaque pas, le velo ne decolle +donc pas d'une bosse par construction. + +| pente | pedalage a fond | roue libre | +|---:|---:|---:| +| plat | 16,9 km/h | 0 | +| +10 % | 10,0 km/h | 0 | +| +25 % | **cale** | 0 | +| -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 | + +**Pente maximale franchissable : 23,6 %** ; au-dela le velo cale et **ne recule +pas**. Braquage a rayon fini et CROISSANT avec la vitesse (`R = v²/4,0`, soit 25 m +a 10 m/s, 6,3 m a 5 m/s), plafonne a 140 deg/s a l'arret pour pouvoir replacer la +machine. Collision : **`moveBody()`, le meme point d'entree que le joueur a +pied** - rien n'est reecrit ; un choc coute simplement de la vitesse. + +### Touche B, camera Ride + +**B** enfourche le velo depuis la MARCHE et en descend. Choisie parce qu'elle +occupe la meme position physique en AZERTY et en QWERTY (contrairement a W/A qui +donnent Z/Q) et qu'elle est voisine de V, le parapente. En selle : **Z** pedale, +**S** freine, **Q/D** tournent ; E/R/C sont desactives, comme en vol. + +Nouveau `CameraMode::Ride` - meme contrat que `Glide` (camera passive, +`setChasePose()`), mais un mode distinct pour que les journaux disent lequel est +actif. Une contrainte que le parapente n'avait pas : **garde au sol minimale de +1,2 m pour l'oeil**, sinon en descente la camera recule dans la pente et passe +sous la surface. + +### LES DEUX DEFAUTS QUE SEUL LE RELIEF REEL A REVELES + +Aucun des deux n'etait visible sur un plan incline synthetique. + +1. **`slopeSampleStep` a 1 m (le pas de la heightmap) ne marche pas.** Sur un + versant reel qui descend a 26,7 %, les differences finies a +/-1 m donnent + **8 % de micro-sections en CONTRE-pente, avec des pics a +22 %** - au-dela du + franchissable, donc le velo s'immobilisait definitivement en pleine descente. + A +/-2 m (base de 4 m) : 1,6 % et un pic a +1,1 %, **pente moyenne inchangee** + (-26,9 % contre -26,8 %). Justification physique : 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. +2. **Un seuil d'arret applique inconditionnellement empeche tout DEMARRAGE.** + `kSpeedEpsilon` (2 cm/s) ecretait la vitesse apres chaque integration, donc + toute acceleration inferieure a 1,2 m/s² a 60 images/s etait annulee a chaque + frame : le velo restait cloue a 0 km/h des 10 % de montee et ne pouvait meme + pas descendre une pente de 10 % en roue libre. C'est un seuil d'**arret** : il + ne s'applique plus que si le bilan des accelerations est negatif. + +### Scenario E : ce qu'il a fallu pour qu'il prouve quelque chose + +Le harnais ne sait pas tourner la camera, donc le velo part forcement au cap +initial : lance n'importe ou il roulerait sur du plat et le run serait **vert +sans rien montrer**. Quatre versions ont ete necessaires ; les trois premieres +ont echoue, et la troisieme sur une **erreur de raisonnement** qui merite d'etre +retenue : *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, comme le fait `Bike`) sur toute la dalle, et prend un point +qui offre les deux : `--start=907875,6439450`, **montee cap 220 deg** (+14,8 % +sur 90 m, pire section +16,8 %, donc aucune section infranchissable) et +**descente cap 40 deg** (-25,0 % sur 170 m). La montee se fait en premier, la +descente gagne ainsi l'elan du denivele grimpe. Le **demi-tour est ASSERVI** sur +le cap que le jeu journalise (courtes rafales, frein tire), pas minute : le temps +vu par le jeu n'est pas celui du `Start-Sleep`. + +Resultat, **deux runs consecutifs quasi identiques** : 50,0 km/h au pic en +descente (31,4 de moyenne sur 39 releves), montee a 5,4 km/h de moyenne sur +**20 releves en mouvement contre 2 calages**, 4,4 m d'altitude reellement gagnes +en pedalant, **96,9 m de denivele suivi**, pentes locales jusqu'a -71 % sans +divergence ni NaN, zero `[Validation]`. + +### Ce qui reste a ameliorer + +1. **La pente franchissable de 23,6 % est basse pour ce massif.** En dessous le + velo monte proprement (20 releves en mouvement contre 2 calages sur le versant + a +14,8 % du scenario E) ; au-dessus il s'immobilise net, et les versants + depouilles ont des devers moyens de 25 a 29 %. Une premiere version du + scenario, posee sur un versant a 27 %, donnait 41 calages contre 3 releves en + mouvement. Le modele suppose qu'on ZIGZAGUE (il lit la pente le long du cap, + donc traverser en biais reduit reellement l'effort). Avant de toucher a + `pedalAcceleration`, **decider si monter droit dans un versant a 27 % doit + etre possible** - a pied non plus, ca ne l'est pas. +2. **La vitesse limite theorique n'est presque jamais atteinte sur du relief + MESURE** : un vrai versant est fait de terrasses. C'est un resultat, pas un + defaut. +3. Marqueur = cube (mais oriente correctement en cap/tangage/roulis, ce qui rend + l'assiette lisible a l'ecran). Vrai mesh a venir avec l'habillage. +4. Pas de suspension ni de derapage : le `dragCoefficient` groupe tout, ce qui en + fait le parametre le plus arbitraire du modele. +5. La collision ne concerne toujours que les 16 arbres de `Forest` - le velo rend + cette limite de la Phase 11 plus voyante, puisqu'on couvre du terrain vite. +6. Aucun controle d'IMAGE sur la vue a la troisieme personne du velo. + +### Hors scope, assume + +Pas de degats ni de chute, pas d'usure, pas de velo ramassable ou fabricable. + +### Non-regression + +**334 assertions headless** (280 avant, +54) ; **`run_vulkan_check.ps1` : 5/5, +deux runs consecutifs**, zero validation ; scenarios A a D inchanges et verts. +Aucun chemin de rendu touche (le marqueur est un `DrawItem` de plus sur le +materiau `Object` existant). `Camera` : une valeur d'enum ajoutee (`Ride`) et +deux branches qui la traitent comme `Glide`, rien d'autre. Scenes annexes +relancees une a une (`cube`, procedural, dalle de Phase 7 en `--no-lod`, zone +25 km2 a 1 m) : **toutes a 0 validation / 0 erreur / fermeture propre** ; +`--dump-world` retrouve **16 AIM sur 16**. + +## Phase 14 (2026-08-22) : physique de l'escalade + +Detail complet dans `NOTES-PHASE-ESCALADE.md`. **Quatrieme et derniere activite +du cadrage** : aucune des quatre n'est vide desormais. + +Nouveau : `src/world/Climber.{hpp,cpp}` et `tools/find_climb_walls.py`. Comme +`Paraglider` et `Bike`, la classe ne connait ni Vulkan ni la `Camera` ; elle +consomme `core/HeightSampler` (surface et pente) et `core/CollisionSolver` +(obstacles), donc elle est **executee** dans les tests headless. + +**Aucun chemin de rendu n'est touche** - pas un `DrawItem` de plus. C'est la +seule des quatre activites dans ce cas : elle est a la premiere personne, il n'y +a meme pas de marqueur a dessiner. La synchronisation GPU n'ayant pas bouge, la +validation de synchronisation n'avait rien de nouveau a regarder. + +### Le seuil de paroi : 100 % (45 deg), et c'est un CHOIX + +`tools/find_climb_walls.py` (nouveau) a depouille la zone de jeu entiere +(24 970 009 echantillons, base de 4 m comme le velo) : + +| | p50 | p75 | p90 | p95 | p99 | max | +|---|---:|---:|---:|---:|---:|---:| +| pente | 47,7 % | 65,7 % | 92,4 % | 129,4 % | 342,5 % | 5018,2 % | + +**Ce massif est raide partout - la pente MEDIANE vaut 47,7 % - et la +distribution est un CONTINUUM sans aucune bimodalite.** Il n'existe donc AUCUN +creux ou poser le seuil : c'est une decision de conception, pas une mesure, et +il faut le presenter ainsi. Les trois arguments retenus : 45 deg est la borne +basse conventionnelle du terrain d'escalade ; c'est nettement au-dessus de +l'angle de repos des materiaux meubles (35-40 deg), donc une face a 45 deg dans +ce massif est du rocher nu ; et ca retient **8,4 %** de la zone - assez pour que +grimper serve, assez rare pour que marcher reste le defaut (a 70 % on en +retiendrait 20,7 %, tout versant deviendrait une paroi). + +**Hysteresis obligatoire** : on entre a 100 %, on ressort a 60 %. Sans cet ecart, +une paroi reelle - qui oscille autour de son seuil d'un metre a l'autre - ferait +clignoter le mode a chaque image. + +### Le modele, en une phrase + +Le grimpeur reste **exactement sur la surface** et s'y deplace le long de deux +tangentes : ligne de plus grande pente (monter/desescalader) et ligne de niveau +(traverser). Meme invariant que le velo - *la verticale n'est jamais une variable +d'etat* - et c'est ce qui rend l'escalade compatible avec une heightmap **sans +rien ajouter au moteur**. + +La projection `L / sqrt(1 + pente^2)` produit toute seule le comportement voulu, +sans aucun cas particulier : sur une paroi a 87 deg, un metre parcouru le long de +la surface donne **0,999 m d'altitude et 0,050 m a l'horizontale**. + +Vitesses : 1,0 m/s en ascension (14 fois plus lent que la marche du moteur), +0,6 m/s en traversee. Collision : `moveBody()`, le meme point d'entree unique que +le joueur a pied et le velo. + +### DEUX PIEGES QUE SEUL LE RELIEF REEL A REVELES + +1. **Un seuil de pente ne suffit pas a trouver une paroi.** Sur du relief mesure, + le joueur qui s'approche s'accroche au PREMIER point raide a portee, qui est + souvent un ressaut isole de deux metres devant la paroi : l'escalade se + terminait par un "SOMMET" apres **0,3 m gagnes en 1,2 s**. La base de 4 m + elimine le bruit decimetrique mais pas un accident de terrain REEL. D'ou + `wallRise()` : simuler 6 m de progression et exiger 4 m de gain, c'est-a-dire + demander *"grimper ici mene-t-il quelque part ?"* plutot que *"est-ce raide + ici ?"*. +2. **LA MEME ERREUR DE RAISONNEMENT QU'EN PHASE 13.** Le premier test sur relief + reel visait le centre d'une paroi et l'abordait plein est. Or **cette paroi + DESCEND vers l'est** : le test approchait par le SOMMET et le grimpeur + remontait correctement les 3,9 m qu'il venait de descendre. *Savoir qu'il y a + de la pente quelque part ne dit pas PAR OU l'aborder.* D'ou le mode + `--routes` de l'outil, qui evalue le relief **le long de chaque cap** depuis + un pied marchable - exactement ce qu'avait fallu faire pour le scenario velo. + +Corollaire a retenir : **le grimpeur suit la ligne de plus grande pente, qui +s'incurve ; l'outil mesure le long d'un cap FIXE.** Les deux divergent (19,5 m +reellement gagnes contre 21,4 m projetes). Ne jamais recopier le chiffre de +l'outil dans une assertion. + +### La jauge d'energie + +Une seule jauge dans [0, 1], isolee. **Les couts sont PAR METRE, pas par +seconde** : monter 40 m coute pareil vite ou lentement (comportement correct), et +la jauge devient independante du nombre d'images par seconde. + +| montee | descente | horizontal | suspendu | recuperation (AU SOL seulement) | +|---:|---:|---:|---:|---:| +| 0,016 /m | 0,005 /m | 0,005 /m | 0,004 /s | 0,05 /s | + +Descendre coute 3 fois moins cher que monter : **choix de JEU, pas de physique** - +sans porte de sortie, s'engager trop haut ne laisserait que la chute. + +**Le chiffre qui donne son sens a l'activite** : une jauge pleine vaut **61,5 m** +d'ascension (mesure sur paroi a 87 deg). Les parois abordables de la zone font +30 a 44 m -> elles passent. Les grandes falaises font **250 a 276 m** -> hors de +portee. Ce n'est pas un reglage rate, c'est la limite qui fait exister l'activite. + +### Trois sorties, une seule reinitialisation de position + +`ToppedOut` (on reste OU L'ON EST - toute la recompense), `Released` et +`Exhausted` (retour au pied). Les deux dernieres partagent **exactement le meme +code** : lacher une paroi, c'est se retrouver au pied, qu'on l'ait decide ou non. +Le point de repli est la position AU MOMENT DE L'ENGAGEMENT, dont on sait qu'elle +etait marchable et libre - la calculer apres coup serait chercher une position +libre sans garantie d'en trouver une. Aucun degat (hors scope). + +Le sommet est teste **AVANT** l'epuisement : poser la main sur la vire avec sa +derniere goutte d'energie, c'est topper, pas tomber. Fige par test. + +Confirmation du sommet sur **DEUX** points (l'accroche et 3 m plus loin) : un +seul point sortirait du mode escalade sur la moindre dalle horizontale au milieu +d'une face, donc EN PLEIN VIDE. Une vire de 1 m ne stoppe pas, une vire de 6 m +si - et c'est correct, 6 m de terrain marchable, on y tient debout. + +### Camera : premiere personne, regard LIBRE + +Nouveau `CameraMode::Climb`, **contrat MIXTE, le seul du projet** : la position +vient de `Climber` (comme `Glide`/`Ride`), mais **l'orientation reste au joueur** - +la souris marche, alors qu'elle est coupee en vol et a velo. + +Pourquoi c'est coherent et pas une exception : **les commandes de l'escalade sont +relatives a la PAROI, pas au regard** (monter suit la ligne de plus grande pente, +traverser la ligne de niveau, toutes deux imposees par le terrain). Le regard n'a +donc aucune influence sur le deplacement, et il redevient libre sans rien casser - +c'est meme necessaire pour lire la suite de la voie et juger la hauteur. + +Premiere personne parce que l'information utile est la surface devant le visage +(un avatar la masquerait), et parce qu'une 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 avait deja du rustiner ce probleme +(`kRideChaseMinClearance`) sur du terrain bien plus doux. + +**L'oeil n'a PAS la convention des trois autres activites** : le grimpeur est +CONTRE la surface, l'oeil est donc a `accroche + normale sortante x 0,6 m + 0,3 m` +et non a 1,7 m au-dessus du sol. Le decalage se fait vers l'AVAL, ce qui garantit +que l'oeil est hors du relief - verifie sur 200 pas et sur l'ascension LiDAR reelle. + +### Touche X, et la rangee des activites + +**X** s'engage / lache (puis Z monter, S desescalader, Q/D traverser). Meme +raisonnement que le B du velo : X occupe la MEME position physique en AZERTY et en +QWERTY. Les quatre activites et les deux actions d'outillage forment desormais une +rangee contigue sous la main gauche : **X** escalade, **C** percussion, +**V** parapente, **B** velo. + +### Scenario F : ce qu'il a fallu + +Le harnais ne peut pas tourner la camera, 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). Retenu : **E 907616 / N 6439312**. + +A noter : **le scenario F n'a RIEN a asservir**, la ou le scenario E avait exige +un asservissement de cap (`Turn-BikeTo`). C'est une consequence directe du choix +de commandes relatives a la paroi. + +Resultat : engagement, montee, traversee des deux cotes, desescalade, **lachage**, +repos, **re-engagement**, **SOMMET a 41,6 m** avec **14 % de jauge restante**, +75 releves de telemetrie, zero validation. + +**La CHUTE par epuisement n'est PAS exercee sous Vulkan** : elle demanderait une +paroi de plus de 62 m et il n'en existe pas d'abordable plein nord sur cette +dalle. Couverte par les tests headless jusqu'a la position de repli exacte. + +### Reproductibilite : l'escalade est deterministe, le velo ne l'est pas + +Deux runs consecutifs, meme binaire : le scenario F rend **41,6 m / 14 % de jauge +/ 75 releves** les DEUX fois, quand le scenario E varie de 50,0 a 44,1 km/h et de +96,8 a 67,7 m de denivele suivi. Raison : le velo INTEGRE une vitesse, donc le +moindre decalage de timing du harnais s'accumule en distance et change le terrain +rencontre ; l'escalade n'a aucune quantite de mouvement (la vitesse est imposee) +et ses commandes sont relatives a la paroi, donc un decalage de timing ne change +que la duree, jamais le chemin. Les assertions du scenario F peuvent donc etre +serrees sans devenir instables. + +### Non-regression : complete + +**425 assertions headless** (334 avant, +91) ; **`run_vulkan_check.ps1` : 6/6, du +premier coup, deux runs consecutifs**, zero validation ; scenarios A a E inchanges +et verts ; scenes annexes relancees une a une (`cube`, 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**. `Camera` : une valeur d'enum ajoutee et +un booleen `orientationOnly` dans `update()`, sans duplication du bloc souris. + +### Ce qui reste a ameliorer + +1. **Les grandes falaises sont inaccessibles, et pas d'abord a cause de + l'energie** : les six meilleures par denivele (250 a 276 m) ont **0 a 2 % de + pied marchable**. On ne peut litteralement pas les atteindre a pied. Les + debloquer demande des RELAIS *et* un moyen d'approche - ce qui pointe vers une + interaction parapente/escalade qui n'existe pas. +2. **Aucune difficulte locale** : une paroi a 105 % se grimpe comme une a 2000 %. + Faire dependre vitesse et cout de la pente locale serait l'amelioration a cout + nul, bien avant un vrai systeme de prises. +3. Le seuil de 100 % est un choix : a revoir en premier si l'escalade se revele + trop presente ou trop rare a l'usage. +4. La desescalade n'a aucun risque, ce qui affaiblit la tension de la jauge. +5. **Rien ne relie l'escalade a la marche en dehors de la touche X** : la marche + n'a toujours AUCUNE limite de pente, donc un versant a 90 % se monte encore a + pied. Tant que ce sera vrai, l'escalade restera facultative. +6. Aucun controle d'IMAGE sur la vue en escalade. + +## Phase 15 (2026-08-23) : editeur de niveau interne + +Detail complet dans `NOTES-PHASE15.md`. Premier OUTIL du projet, par opposition +aux quatorze phases precedentes qui construisaient le jeu. Usage developpeur : +aucune interface graphique, le catalogue est une liste texte dans le journal. + +**Le point qui compte** : ce qui est pose fait partie du MONDE, pas de l'outil. +Une partie normale - sans `--editor` - charge la scene, la dessine et s'y cogne. + +### Nouveau : src/editor/ (5 unites) + 2 en-tetes dans core/ + +`EditorAssets` (5 modeles generes en code), `AssetCatalog` (builtins + scan de +`assets/editor/`), `PlacedObject`, `EditorScene` (liste + visee + collision + +annulation), `EditorController` (machine a etats), `SceneFile` (format `.vcsc`). +Plus `core/TerrainRay.hpp` (rayon / surface) et `core/CompositeCollisionSolver.hpp`. + +**Aucun ne connait Vulkan** : tout l'editeur SAUF LE DESSIN est execute dans les +tests headless. Meme decoupage que les quatre activites. + +`EditorController` ne lit pas le clavier - il recoit un `EditorInput` deja +depouille par `main.cpp`. La vraie raison n'est pas la proprete : le harnais +automatise ne peut PAS piloter la souris (GLFW lit le curseur systeme), donc un +controleur qui lirait lui-meme les entrees ne serait testable qu'a la main. + +### La collision : l'interface de la Phase 6 sert enfin a quelque chose + +Le monde n'avait qu'UNE source d'obstacles (`Forest`). `CompositeCollisionSolver` +implemente le meme contrat et le delegue a une liste, repoussements CHAINES. +**Ni `Camera`, ni `Bike`, ni `Climber` n'ont ete modifies** : seul l'objet qu'on +leur passe a change. + +Empreinte = cylindre vertical CONTENANT, deduite de la boite englobante du mesh +(un obstacle trop gros se contourne, un obstacle trop petit se traverse par les +coins). Drapeau `solide` par OBJET, parce que le cylindre est faux des qu'un +asset a un interieur - l'abri a une porte, mais son cylindre est plein. + +### LA MESURE : collision prouvee par TEMOIN NEGATIF, et chiffre PREDIT + +Trois processus, meme binaire, meme depart, meme duree de touche maintenue ; +seule la presence de la scene change. + +| | distance parcourue vers le nord | +|---|---:| +| avec un rocher pose devant | **0,69 m** | +| temoin, `--no-scene` | **21,17 m** | + +Et le chiffre etait PREVISIBLE : rocher pose a 2,51 m, rayon de collision +1,47 m, rayon du corps 0,35 m -> arret attendu a 2,51 - 1,82 = **0,69 m**. C'est +ce qui separe "ca a l'air de bloquer" de "ca bloque la ou le modele le dit". + +### Le format `.vcsc` : deux decisions, une seule intention + +Fichier TEXTE, une directive par ligne (`version` / `terrain` / `crs` / `object`), +range dans `assets/scenes/` - donc VERSIONNE, contrairement a `data/`. + +1. **Coordonnees PROJETEES (Lambert 93), pas locales.** Le repere du moteur est + centre sur le terrain CHARGE : une position locale ne veut rien dire sans + savoir quelle emprise l'etait. Cette zone existe deja sous quatre emprises. +2. **Altitude RELATIVE au terrain (`dz`), pas absolue.** La surface a 2 m n'est + pas celle a 1 m, et le repli sur l'ancetre (Phase 12) peut afficher une tuile + plus grossiere une image durant. `dz = 0` = "pose au sol", vrai partout. + +=> une scene composee sur la dalle isolee se recharge au bon endroit du massif +sur la zone de 25 km2. **Verifie par test** : rechargee au pas de 2 m, les objets +restent au sol au demi-centimetre pres et celui qui etait souleve de 2,5 m garde +ses 2,5 m. + +Robustesse : directive inconnue ignoree (pas fatale), ligne `object` fautive +comptee et sautee, ecriture par temporaire renomme, locale C forcee (en locale +francaise `907512.250` se relirait `907512`). + +`assets/scenes/demo_phase15.vcsc` est ECRITE A LA MAIN : c'est ce qui prouve que +le format est editable sans lancer le jeu. + +### Le fantome est TEINTE, pas transparent + +Trois etats du meme maillage (pose / fantome / selectionne) se distinguent par +une teinte poussee en push constant (`params.x` = force, `yzw` = couleur), lue +par `shaders/cube.frag`. Pas de melange alpha : il imposerait un tri en +profondeur. **Meme choix qu'en Phase 11** (les arbres fondent par +retrecissement, l'herbe est opaque). **Force nulle = rendu bit a bit identique a +l'avant-Phase 15**, la branche n'est meme pas prise - c'est ce qui autorisait a +toucher au shader du materiau `Object`. + +### CE QUE L'ESSAI SOUS VULKAN A CORRIGE + +La pose SELECTIONNAIT l'objet pose, par analogie avec les editeurs 3D. Les +reglages visant la selection en priorite (SAISIE > SELECTION > PINCEAU), poser un +objet detournait donc silencieusement les fleches du PINCEAU vers l'objet pose : +"regler une fois, poser dix blocs alignes" - le geste le plus courant de l'outil - +devenait impossible sans deselectionner entre chaque. **La pose ne selectionne +plus**, fige par test. + +Au passage, la ligne d'etat n'affichait que le cap du PINCEAU : tourner un objet +selectionne affichait `cap 0 deg` pendant qu'il tournait. Elle decrit desormais +la cible reelle des reglages. + +### Ancrage n'est pas centrage + +Convention des assets : dimensions ABSOLUES en metres, pied a `y = 0`, ancrage +horizontal a l'origine. Mais pas forcement au centre de la boite : le poteau de +balisage a son MAT a l'origine, sa plaque debordant. Planter un panneau, c'est +planter le mat au point vise. + +Un asset charge d'un FICHIER ne dit rien de son intention -> `normalizeAssetMesh` +le recentre de force sur sa boite. Defaut le moins mauvais, pas regle generale. +La propriete que tous respectent (et que le test verifie) est plus faible : +**l'ancrage tombe DANS l'empreinte horizontale**, jamais a cote. + +*(Le premier test exigeait un centrage exact et a echoue sur 3 assets sur 5. +C'est la convention qui etait fausse, pas la geometrie.)* + +Le bruit des rochers est un HACHAGE de l'indice de sommet, pas un `mt19937` - +meme lecon qu'en Phase 11. Ca compte ici parce que la COLLISION est deduite de la +boite englobante : un mesh qui varierait donnerait une collision qui varie. + +### Touches + +**F2** entre/sort. Le mode est EXCLUSIF (aucune touche de jeu n'est lue, et +reciproquement), ce qui autorise a reprendre des lettres deja prises. A chaque +bascule, TOUS les fronts descendants sont resynchronises - sinon entrer avec `E` +enfonce selectionnerait, en sortir avec `E` enfonce abattrait un arbre. + +Vol ZQSD + espace/maj, molette = vitesse (2 a 600 m/s). **Clic gauche ou INSER** +pose, `E` selectionne, `G` saisit/repose, `SUPPR` supprime, `ECHAP` abandonne, +`TAB`/`PAGE` parcourent le catalogue, `1..9` rang direct, fleches = cap et +echelle, `DEBUT`/`FIN` = hauteur, `K` solide/traversable, `CTRL` pas fin, +`RETOUR ARRIERE` annule, `F5` sauve, `F9` recharge, `L` liste. + +Touches choisies parmi celles qui occupent la MEME position physique en AZERTY et +en QWERTY (fleches, pave de navigation, fonctions, chiffres) ; seules lettres +utilisees : `E`, `G`, `K`. + +`INSER` double le clic gauche parce que le harnais ne pilote que le clavier : +sans elle, la pose serait la seule fonction de l'editeur qu'aucun test ne +pourrait exercer sous Vulkan. + +### Options ajoutees + +`--editor`, `--scene=chemin.vcsc`, `--no-scene`, `--editor-assets=rep`. +**`--no-scene` reproduit exactement le comportement d'avant la Phase 15** : c'est +le temoin de toute mesure avant/apres. + +### Ce qui reste a ameliorer (par ordre d'importance) + +1. **glTF : NON FAIT.** `AssetCatalog::supportedExtensions()` ne connait que + `.obj`. Un loader glTF honnete (JSON + conteneur `.glb` + accesseurs + + hierarchie de noeuds) fait 600 a 800 lignes : une session a part, dont le + risque etait reel alors que la consigne exigeait zero validation et une + non-regression complete. Choix assume de livrer l'editeur COMPLET. Cout : les + bibliotheques libres distribuent surtout du glTF, il faut convertir avant. + **`supportedExtensions()` est le seul point d'extension** - ancrage, + collision, catalogue, placement et serialisation sont deja agnostiques. +2. **Collision par cylindre englobant** : fausse pour tout objet a interieur. +3. **Aucun frustum culling sur les objets poses** : un `DrawItem` par objet et + par image. Sans consequence a l'echelle d'une scene d'editeur, `Frustum` + existe deja et se brancherait en quelques lignes. +4. Catalogue fige au demarrage (deposer un `.obj` demande de relancer). +5. Pas de sauvegarde automatique : `F5` est explicite, sortir du mode n'ecrit rien. +6. Aucune aide au placement : ni grille, ni magnetisme, ni alignement sur la + normale du terrain (`terrainNormalAt()` est pourtant deja ecrit et teste). +7. Pas de rotation libre ni d'echelle non uniforme (contrat de `DrawItem` : + `mat3(model)` comme normal matrix). +8. Pas de selection multiple ni de copier-coller. +9. Les objets poses n'interagissent avec rien (pas d'abattage, pas d'ombre), et + l'editeur ne peut pas toucher aux arbres de `Forest` ni aux pierres de `Ground`. +10. Rien ne previent qu'on empile deux objets au meme endroit. + +### Suite du 2026-08-23 : selection au clavier sans viser (F3/F4) + +Detail complet dans `NOTES-PHASE15.md` section 12. Verification prealable que +la session tenait toujours : build propre, 650/650 assertions headless, puis +`run_vulkan_check.ps1` complet - zero validation, scenario G vert ; seul le +scenario F a echoue sur la fermeture propre, rejoue seul aussitot apres il +passe (flakiness `PostMessage` deja connue, pas une regression). + +Choix motive parmi les trois pistes proposees (annulation deja livree, glTF, +ergonomie) : le glTF reste la plus grosse limite documentee, mais c'est +justement pourquoi la session initiale l'avait ecarte - 600-800 lignes neuves, +un risque reel face a l'exigence de zero regression, et le choix assume de +livrer un editeur COMPLET plutot qu'un editeur et un loader a moitie. Le +retenter dans une suite courte aurait repris ce risque sans le temps de le +tester aussi rigoureusement que le reste. L'ergonomie clavier, elle, correspond +a une lacune precise et deja nommee (§9) : `pickPressed` (touche E) exige que +la visee touche l'objet, donc retrouver un objet pose hors du champ courant +n'avait qu'une voie, y revenir a la souris. + +**F3** (suivant) / **F4** (precedent) parcourent desormais la liste des objets +poses independamment de la visee, avec la meme garde que la selection visee +(ignore pendant qu'un objet est en main). 9 assertions headless de plus +(650 -> **659**), et le harnais Vulkan (`run_vulkan_check.ps1`, scenario G1) +envoie desormais F3/F4 par `PostMessage` et EXIGE exactement 3 selections +journalisees pour les 3 touches envoyees - un front descendant perdu ferait +donc echouer le run. Aucun fichier de rendu touche. + +## Phase 16 (2026-08-24) : besoins primaires du joueur + +Detail complet dans **NOTES-PHASE16.md**. Resume de ce qu'il faut savoir sans +ouvrir ce fichier. + +### Quatre jauges, aucune ne tue + +`src/world/Needs.hpp/.cpp` - faim, soif, fatigue, temperature, dans [0, 1], +**1 = tout va bien pour les quatre** (d'ou le libelle "forme" a l'affichage : +"fatigue 100 %" se lirait a l'envers). Meme moule que Paraglider/Bike/Climber : +ni Vulkan, ni GLFW, ni Camera. La classe recoit un pas de temps et un CONTEXTE +(activite, altitude, heure, exposition du versant) et rend des jauges et des +COEFFICIENTS ; c'est `main.cpp` qui applique. + +**Les taux sont en SECONDES REELLES**, pas en heures simulees - c'est le point +le plus facile a confondre. Depuis des jauges pleines, en marchant sans arret : +forme vide en 1 h 30, soif en 1 h 05, faim en 2 h 06. A l'arret : forme +**remonte** (pleine en 20 min), soif 2 h 30, faim 4 h. A cinq minutes, tout est +encore au-dessus de 90 %. + +Une seule table d'effort commande tout (marche = 1) : **repos 0 / marche 1 / +velo 1,8 / escalade 4 / parapente 0,3**. L'escalade fatigue donc exactement +quatre fois plus vite que la marche. Elle a deja sa jauge courte +(`Climber::stamina`) ; la fatigue est l'ENVELOPPE LONGUE - elle n'interdit pas +une paroi, elle interdit d'en enchainer dix. + +**Le repos 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. + +### La temperature relie enfin le relief a l'etat du joueur + +`ambiante = 15 C - 6,5 C/km d'altitude + cycle diurne (+/-8 C, max a 15 h) ++ 4 C d'adret pondere par le soleil`. Sur la dalle chargee (420 -> 982 m), ca +fait **3,7 C d'ecart permanent entre le fond de vallee et la crete**, et 16 C +entre 3 h et 15 h : marcher de nuit coute a peu pres autant que marcher 2400 m +plus haut. Le ressenti ajoute la chaleur de l'effort, retire le vent du vol +(-6 C) et l'epuisement (-3 C a forme nulle). + +**L'adret/ubac est CALCULE, pas devine** (`terrainExposure`) : +Z va vers le +SUD (convention `Heightmap::toProjected`), donc un versant qui descend vers +Z +est un adret. Lu sur une base de **4 m**, meme valeur et meme raison que +`BikeParams::slopeSampleStep`, et **pondere par la pente** - sur du plat il n'y a +ni adret ni ubac, sans quoi une plaine bruitee donnerait des expositions +extremes et aleatoires d'un metre a l'autre. + +### Les consequences sont appliquees aux ENTREES, pas dans les modeles + +Un SEUL coefficient (`Needs::movementFactor`, produit de quatre penalites, +plancher a **0,35**) multiplie trois choses dans `main.cpp` : la vitesse de +marche, la commande de pedalage, la commande de montee en paroi (desescalade +comprise - sinon on monterait epuise et on redescendrait gratis). + +`Bike`, `Climber` et `Paraglider` **n'ont pas ete touches**, et c'est +volontaire : ils ecretent deja leurs entrees dans [0, 1], donc une commande +plus faible y produit exactement ce qu'on veut (moins d'acceleration, vitesse +d'equilibre plus basse, pente franchissable plus faible) sans risquer une +regression sur une physique testee depuis deux phases. Les tests ne verifient +pas le coefficient mais l'EFFET : distance parcourue a velo en une minute, +hauteur gagnee en 20 s d'escalade, avec et sans penalite. + +Plancher a 0,35 : au plus mal, le joueur avance encore a plus du tiers de sa +vitesse. Le produit brut des quatre penalites vaudrait 0,175 - une assertion +verifie que le plancher MORD vraiment et n'est pas decoratif. + +### Points d'eau : la seule regeneration reelle (touche T) + +`src/world/WaterSource.hpp/.cpp`. Le jeu n'a PAS d'eau ; cette fonction cherche +seulement **ou il serait credible de boire**, dans la forme du terrain : les +points a la fois peu pentus et concaves. Balaye une fois au chargement. + +**Trois reglages ont du etre corriges apres mesure sur la dalle reelle, ou la +premiere version rendait ZERO point** : + +1. **ce massif est raide** - au pas de 50 m, seuls 10 points sur 361 passent + sous 10 % de pente. Seuil porte a **15 %** ; +2. **le pas de balayage etait trop grossier** - le rayon utile d'un creux vaut + une vingtaine de metres, un pas de 50 m passe a cote. Ramene a **20 m** ; +3. **quatre sondes ne distinguent pas un talweg d'un col.** Un talweg a deux + sondes hautes (les versants) et deux basses (amont/aval) : exiger 3 sur 4 ne + retient que les cuvettes fermees, qui n'existent pas ici ; accepter 2 sur 4 + laisse passer les COLS, qui ont la meme signature et ou il n'y a rien a boire. + D'ou **HUIT directions, 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. + +Resultat sur la dalle du Gua : **2 points d'eau**, le premier en monde +(-75, 285) = E 907425 / N 6439215. Portee pour boire : **4 m** horizontaux. +C'est cette heuristique qui disparaitra le jour ou le reseau hydrographique IGN +sera charge, pas ses appelants. + +### Ce qui n'existe PAS, et qu'il faut savoir + +- **De quoi manger.** `Needs::eat()` est ecrit et teste mais **n'a aucun + appelant** : le jeu ne produit rien de comestible. C'est pour ca que la faim + est de loin le besoin le plus lent. C'est le trou beant du systeme. +- **Un abri.** `NeedsContext::sheltered` existe et est teste, sans appelant non + plus. +- **Le cycle jour/nuit RENDU.** `GameClock` (facteur 12 : une session d'une + heure traverse douze heures de jeu) ne pilote que la temperature. Le soleil des + shaders reste une direction fixe : **il fait toujours jour a l'ecran** alors + que la temperature, elle, tombe la nuit. Incoherence assumee. +- Le mode EDITEUR **gele les quatre jauges** (outil de developpement). + +### Affichage + +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 +detail (ambiante, ressenti, coefficient de deplacement) va dans le journal - +c'est cette ligne que depouille le scenario H. + +### Deux pieges du harnais, notes parce qu'ils se reproduiront + +- le scenario attendait `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 %). + +## Phase 17 (2026-08-25) : premiere empreinte environnementale + +Detail complet dans **NOTES-PHASE17.md**. Resume de ce qu'il faut savoir sans +ouvrir ce fichier. + +### Le monde garde une trace, et ne le dit jamais + +Trois briques neuves, aucune modification de comportement ailleurs : + +| Fichier | Role | +|---|---| +| `src/world/Habitat.hpp/.cpp` | la memoire locale : deux compteurs par cellule de 32 m | +| `src/world/Wildlife.hpp/.cpp` | la faune : semis par tirage-rejet, deux etats, fuite | +| `src/world/AnimalMesh.hpp/.cpp` | le cervide bas-poly, genere en code | +| `src/world/GroundCover.hpp` | l'interface par laquelle l'herbe interroge l'etat du sol | + +`Forest` n'a PAS ete touchee : c'est `main.cpp` qui inscrit l'abattage dans le +milieu apres un `fell()` reussi. L'abattage est une mecanique de la Phase 5, +l'empreinte qu'il laisse est une lecture de la Phase 17. + +### Deux memoires, jamais une seule + +**Frequentation** : monte avec la presence (ponderee par le BRUIT de +l'activite), saturee en 60 s de marche sur place, oubliee en 4 min. +**Deforestation** : un cran par arbre, 3 arbres saturent une cellule, 15 min +pour se resorber. Un derangement CESSE quand on part, un prelevement NON. + +Le bruit n'est PAS l'effort de la Phase 16 : **repos 0,25 / marche 1 / velo 2 / +escalade 0,6 / parapente 0,15**. L'escalade est l'effort MAXIMAL du joueur et +l'une des activites qui derange le MOINS. + +La grille est CREUSE et oublieuse : seules les cellules touchees existent, et +une cellule revenue a neuf est effacee (meme principe que le cache de cellules +de `Vegetation`). + +### Consequences, toutes observables en jouant + +- au-dela de 0,55 de frequentation, la faune presente PART ; elle ne revient que + sous 0,35 (hysteresis deliberee, sinon les animaux clignotent sur le seuil) ; +- au-dela de 0,40 de deforestation, plus aucune reapparition ; +- le sol se DENUDE : la densite d'herbe de `Vegetation::gatherGrass` est + multipliee par le couvert rendu par l'`Habitat` (jusqu'a 0,15 au pire). Au pied + d'une coupe saturee, plus de la moitie de l'herbe disparait ; elle revient + integralement en 20 min. + +**Le shader terrain n'a PAS ete touche.** Passer les compteurs au GPU aurait +demande un binding, une texture a re-televerser et donc un chantier de +synchronisation Vulkan a part entiere. Faire disparaitre l'herbe donne le meme +signal pour zero objet Vulkan neuf. Contrepartie : **la ou il n'y a pas d'herbe +(lapiaz, au-dessus de 2250 m), une coupe ne se voit pas.** + +### DEUX RAYONS REGLES SEPAREMENT QUI NE SE RECOUVRAIENT PAS + +La lecon de la session, et elle est generale. `noiseRadius` valait 45 m, +`spawnRadiusMin` valait 90 m. Chacun defendable seul. Ensemble : **aucun animal +ne se trouvait jamais dans le rayon derange**. Run mesure : 24 animaux au depart, +24 apres deux minutes de presence, frequentation a 100 %, ZERO fuite. Le code +etait juste, les tests headless verts, le resultat en jeu nul. + +Corrige : `noiseRadius` = 120 m et `spawnRadiusMin` = 55 m (a 90 m, un cervide +de 1,3 m est un point : la faune existait sans qu'on puisse la regarder). Apres +correction : 4 animaux a portee de vue au depart, 1 apres quatre minutes. + +**Il faut que `noiseRadius` depasse `spawnRadiusMin`**, sans quoi la deuxieme +mecanique de la phase n'existe pas. Aucun test unitaire ne l'aurait dit : chaque +constante est correcte de son cote. + +### Le defaut qui rendait la memoire muette + +Premier essai : rien ne montait, `trackedCellCount` a zero. Au premier pas de +temps une cellule ne contient que 0,0003, soit MOINS que l'epsilon d'oubli +(1e-3) : `update` l'effacait a l'image meme ou `notePresence` venait de la creer. +Corrige : une cellule OCCUPEE n'est ni oubliee ni decrue tant que le joueur y est. + +### La bonne metrique n'est pas la population + +L'effectif total ne bouge pas quand une zone se vide : les animaux s'ECARTENT +puis d'autres apparaissent plus loin. Ce qui se vide, et ce qu'un joueur voit, +c'est le VOISINAGE - d'ou `Wildlife::countWithin`, et le scenario I qui la +depouille. Attendre zero serait faux : la ponderation en `1 - (d/r)^2` tend vers +zero au bord du rayon, donc un residu d'un ou deux animaux a la limite est le +comportement CORRECT du modele. + +### Deux effets de bord sur le harnais, a connaitre + +**`--no-wildlife`** est ajoute au jeu : il coupe la faune ET la memoire du +milieu, et rend le comportement d'avant la phase. TEMOIN, au meme titre que +`--no-vegetation` - il a servi des cette session. + +1. **Le scenario F (escalade) n'avait aucune marge.** La faune coute 6 % de FPS + (301 contre 320, mesure avec le temoin). La trajectoire du grimpeur depend du + pas de temps - sa commande est projetee sur la ligne de plus grande pente + LOCALE a chaque image - donc 6 % de FPS suffisent a changer le chemin suivi + sur la paroi. Le scenario laissait 18 s de marge sur une montee de 57 s : + **echeance portee de 75 s a 140 s**, cote harnais, pas cote jeu. +2. **Le scenario E (velo) echoue sur son "pied a terre" final, et ce n'est PAS + du a la Phase 17** : rejoue deux fois avec `--no-wildlife`, il echoue + pareil. La touche B finale n'emet aucune ligne, et la sonde montre le velo + encore lance a 31 km/h alors que le scenario vient de freiner 5 s - la + descente scriptee ne finit plus ou elle a ete reglee. **Non corrige** : hors + perimetre, et le corriger a l'aveugle aurait ete plus risque que le signaler. + +### Ce que la faune n'a pas + +Aucune IA (deux etats, fuite en ligne droite opposee au joueur), ~~aucune +collision dans aucun sens~~ - **la collision JOUEUR -> ANIMAL a ete ajoutee en +Phase 20** ; le sens ANIMAL -> MONDE reste absent, et volontairement (voir plus +bas) -, aucune persistance, une seule espece, aucun lien avec +l'heure du jour ni avec les besoins du joueur. La Phase 17 construit la BOUCLE, +pas un bestiaire. Et rien n'est sauvegarde : la memoire du milieu meurt avec le +processus. + +## Phase 18 (2026-08-25) : un vrai tapis d'herbe, et le profilage de la tuile + +Detail complet : `NOTES-PHASE18.md`. Deux chantiers independants. + +### Tache 1 - l'herbe + +**Decoupe alpha par masque CALCULE**, pas par texture. `shaders/foliage.frag` +decoupe 4 brins par quad (12 par touffe) a partir des seuls UV et de l'alea +d'instance, et `discard` le reste. Le quad n'est plus le brin : il est la +PLANCHE dans laquelle on decoupe, d'ou son elargissement (demi-largeur au pied +0,26 -> 0,42, a la pointe 0,06 -> 0,30). + +Trois raisons de ne pas prendre une texture RGBA : un binding de descriptor de +plus sur ce seul pipeline, un asset a produire, et surtout le filtrage mipmap +qui FAIT FONDRE des brins fins en bouillie grise a quelques metres. + +`discard` et non melange alpha : le melange imposerait de trier 20 000 touffes +en profondeur a chaque image et une seconde passe. Contrepartie, un bord franc +sans MSAA (`rasterizationSamples = 1`) - compense en EFFACANT la decoupe avec la +distance (brins elargis jusqu'a refermer le quad entre 7 m et 17 m), sinon +l'herbe lointaine scintille. + +**Zero pipeline, zero descriptor, zero binding ajoute** : la force de decoupe +passe par `params.w`, RESERVE dans le bloc de push constants depuis la Phase 11. + +**Densite : `grassSlots` 24 -> 56.** Choisi CONTRE l'autre chemin possible +(baisser les seuils de selection), qui aurait mis de l'herbe la ou il n'y en a +pas - rocher, futaie dense, versants nus selon le LiDAR. Aucun seuil de +repartition n'a bouge : la carte de la Phase 11 est litteralement la meme, seul +son REMPLISSAGE change. 8 867 -> 20 098 touffes sur la vue d'alpage. + +### Tache 2 - la construction d'une tuile + +`TerrainStreamer::buildProfile()` chronometre trois postes separes. Premier +relevé, survol a 900 m/s : geometrie 1 858 us/tuile (66 %), **indices +636 us (23 %)**, televersement GPU 307 us (11 %). + +Deux optimisations EXACTES (maillage identique, seul le travail change) : +topologie construite une fois et recopiee, et cibles de morphing regroupees par +bloc 2x2 (grille 33x33 au lieu de 65x65 echantillons de parent). + +**2 609 -> 1 512 us par tuile (-42 %), +20 % de frames, 0 frame a trou avant +comme apres.** Temoin `--no-tile-cache`, deux passages par colonne, ecart entre +passages sous 0,5 %. + +### Chiffres + +| Vue | Avant | Apres | +|---|---:|---:| +| Reference Phase 11 (E 901500 N 6436600, yaw 100, pitch -7) | 271 FPS / 332,4 Mo | **293 FPS / 332,7 Mo** | +| Alpage (E 900500 N 6439000, yaw 100, pitch -7) | 137 FPS / 338,5 Mo, 8 867 touffes | **122 FPS / 340,2 Mo, 20 098 touffes** | + +**Tests headless : 896 assertions** (885 avant, +11). Zero `[Validation]` +partout. Nouvelles options temoins : `--no-grass-cutout`, `--no-tile-cache`. + +### Les trois lecons a retenir + +1. **LA VUE DE REFERENCE D'UNE PHASE NE VAUT QUE POUR CE QU'ELLE CONTIENT.** La + vue de la Phase 11, reprise pour mesurer l'herbe, n'a que **124 touffes** : + tout changement du semis s'y perd dans le bruit. Il a fallu sonder cinq + positions pour trouver un alpage reellement herbeux. Meme piege que « savoir + ou il y a de la pente ne dit pas par ou l'aborder ». +2. **LA DECOUPE ALPHA COUTE ZERO FPS ; C'EST LE NOMBRE D'INSTANCES QUI COUTE.** + 95 FPS avec la decoupe, 95 FPS sans (temoin `--no-grass-cutout`, meme + binaire, meme vue). Le fragment shader n'etait pas le facteur limitant. Tout + le cout de la densite etait CPU : supprimer l'appel a `heightAt()` par touffe + au profit de quatre par CELLULE a rendu 95 -> 118 FPS **sans changer un + pixel**. +3. **LE DEUXIEME POSTE DE COUT D'UNE TUILE ETAIT UNE BOUCLE D'INDICES + REDONDANTE.** 636 us/tuile, soit 23 % - deux fois le televersement GPU qui + avait mobilise toute la Phase 12. L'en-tete de `TerrainNodeMesh.hpp` disait + depuis la Phase 10 que la topologie etait « calculee une fois et recopiee » ; + le code, lui, la reconstruisait a chaque tuile. **Un commentaire n'est pas + une mesure.** + +### Deux points rouges du harnais, non causes par cette phase + +- Scenario E (velo), « pied a terre » : echec **deja documente en Phase 17**, + non corrige (hors perimetre). Ni cause ni aggrave ici. +- Scenario I (faune), « animaux a portee de vue » : rouge au premier passage, + **vert au rejeu isole ET au passage final**. Le critere compte des releves sur + 240 s, donc depend du FPS : c'est du bruit, pas une regression. Le harnais + gagnerait a rendre E et I insensibles au debit d'images. + +Harnais joue DEUX FOIS en entier cette session : 0 `[Validation]`, 0 `[ERROR]`, +fermeture propre et code 0 pour les onze processus, les deux fois. + +### Ce qui n'est pas fait + +Parallelisation multi-thread de `terrainNodeMeshData` (83 % du cout restant, et +la fonction est deja PURE - `Renderer::addMesh` n'est simplement pas sur pour +plusieurs threads) ; buffer d'indices GPU partage (~48 Mo recuperables) ; +teinte du terrain sous l'herbe (le sol entre les touffes reste l'orthophoto +grise, et c'est ce qui plafonne encore le tapis de tres pres). + +## Phase 19 (2026-08-26) : le profil de la Phase 18 etait un profil de Debug + +Detail complet dans **NOTES-PHASE19.md**. *(Section ecrite le 2026-08-26 au +debut de la Phase 20 : la session de la Phase 19 s'etait arretee apres avoir +redige ses NOTES, sans reporter le resume ici. Les NOTES, elles, sont +completes - harnais joue deux fois en entier.)* + +### Le resultat principal annule les deux taches prevues + +La mesure qui fondait la parallelisation du maillage de tuiles avait ete relevee +en **Debug** et ne tient pas en **Release**. En Release une tuile ne coute plus +140 us de geometrie (contre 1 344 en Debug) : le poste dominant devient le +**televersement** (63 %), et le frame entier n'est pas limite par le CPU. + +**La lecon, et elle est generale : un profil de Debug n'est pas un profil de +Release.** Comme toutes les mesures du projet sont en Debug - la seule +configuration avec les couches de validation - rien ne pouvait le signaler. + +- `Renderer::addMesh` **n'a pas ete rendu thread-safe** : les deux points + dangereux (`commandPool_`, `graphicsQueue_` dans `flushCopiesNow`) ne sont + atteints que si le staging en vol depasse 128 Mo, donc **jamais pendant le + streaming**. La partie risquee aurait ete exactement celle qu'aucun test + n'aurait pu exercer. Aucun appel Vulkan ne change de thread. +- Le maillage CPU, lui, est parallelisable sans toucher au Renderer + (`terrainNodeMeshData` est PURE) : `--tile-threads=N`, **defaut 1** + (sequentiel, le reglage que la mesure designe en Release). Le chemin parallele + est garde comme outillage (2,4x et +14 % d'images en Debug) et comme TEMOIN. +- **Tache 2 : rien n'a ete optimise, a dessein.** Le frame est limite par le GPU + (81 % de l'image passee a attendre dans `drawFrame`, verifie par ABLATION et + non affirme). Supprimer entierement `gatherTrees` et `gatherGrass` ne rendrait + rien. Ce que la phase livre est le **profileur permanent** (`Cout par image`, + cinq postes CPU, non conditionnel) et `tools\profile_tiles.ps1`. +- Verifie : **902 assertions** headless (+6), zero `[Validation]`, + `VK_LAYER_VALIDATE_SYNC=1` sur les deux chemins avec son **controle negatif** + (barriere retiree -> la couche crie immediatement). Harnais joue deux fois en + entier, 11 processus, un seul point rouge : le scenario E (velo, "pied a + terre"), **anterieur a la phase** et documente depuis la Phase 17. + +## Phase 20 (2026-08-26) : la collision cesse d'etre une affaire d'arbres + +Detail complet dans **NOTES-PHASE20.md**. + +### L'inventaire a reduit la consigne a UNE lacune + +La consigne demandait d'etendre la collision "a tous les objets du monde qui +n'en ont pas encore". Etat reel trouve dans le code, avant d'ecrire une ligne : + +| Categorie | Etat trouve | Decision | +|---|---|---| +| Arbres, souches (`Forest`) | collision depuis la Phase 6 | inchange | +| Objets d'editeur (`EditorScene`) | collision depuis la **Phase 15**, drapeau `solid` **par instance** (touche K, serialise en `.vcsc`) | inchange | +| **Faune (`Wildlife`)** | **aucune collision** | **corrige** | +| Objets au sol (`Ground`) | aucune collision | **laisse ainsi, delibere** | + +Deux points a retenir. D'abord, **la decision "flag solide" que la consigne +proposait de prendre etait deja prise en Phase 15**, et dans le sens le plus fin +des deux (par instance, pas par asset). Ensuite, **l'architecture ne demandait +aucune generalisation** : `CollisionSolver` + `moveBody()` (Phase 6) et +`CompositeCollisionSolver` (Phase 15) suffisaient. Brancher la faune est **une +ligne** dans `main.cpp`, et cette ligne couvre **les trois activites au sol** - +ni `Camera`, ni `Bike`, ni `Climber` n'ont ete modifies. Deuxieme fois que +l'interface de la Phase 6 tient sa promesse. + +### Ce qui a ete ecrit + +`Wildlife` implemente `CollisionSolver`. Cylindre vertical, rayon **0,65 m** = +demi-longueur du mesh de cervide, x `Animal::scale` ; geometrie **copiee de +`Forest::resolve`**, pas reinventee. Le lien mesh/collision est tenu par un +**`static_assert`** : le jour ou le cervide changera de taille, ca echoue a la +COMPILATION au lieu de le rendre traversable par le flanc. + +### LA MESURE : temoin negatif et chiffre predit + +Nouveau temoin **`--no-animal-collision`** : la faune reste VISIBLE et redevient +traversable. `--no-wildlife` ne pouvait pas jouer ce role - supprimer les +animaux ne montre pas qu'on traverse celui qui est la. + +| Marche de 20 m droit sur un cervide | approche la plus proche | parcouru | +|---|---:|---:| +| Temoin `--no-animal-collision` | **0,0010 m** (le centre) | **20,00 m** | +| Avec collision | **1,0418 m** | 13,20 m | + +**1,0418 m est le chiffre PREDIT** (0,65 x echelle + 0,35 de demi-largeur du +joueur), atteint au millimetre pres. + +**Le test attendait d'abord un ARRET NET a 8,96 m, et il avait tort.** Un +obstacle convexe ISOLE se **contourne** : la poussee frontale n'est jamais +parfaitement frontale a l'arrondi pres, et la composante laterale accumulee fait +glisser autour - c'est le comportement voulu du solveur par repoussement +(`CollisionSolver.hpp`). La grandeur que le modele predit n'est pas la distance +d'arret, c'est le **rayon de contact**. *Un chiffre attendu qui ne sort pas +n'est pas forcement un bug : il faut d'abord savoir lequel, du code ou de +l'attente, decrit le modele.* + +### Toutes les activites, verifiees une par une + +- **Marche** : mesuree ci-dessus. +- **Velo** : mesure a part, et c'est le cas qui compte - le velo roule a 30 km/h, + soit la vitesse de FUITE de l'animal (8 m/s). **C'est la seule activite qui + peut rattraper un cervide.** A pied on ne l'approche jamais, il part a 30 m. +- **Escalade** : concernee au PIED de la paroi, jamais dessus, et pour une raison + de MODELE : `WildlifeParams::maxSlope` (0,90) < `ClimberParams::wallSlope` + (1,00), donc **aucun animal ne peut se tenir sur une pente grimpable**. Meme + genre de rapport entre deux constantes reglees separement que la lecon de la + Phase 17, sauf qu'ici il est bon - une assertion le fige. +- **Parapente** : hors perimetre, inchange, **coherent avec la Phase 8** qui + documente deja l'absence de collision en vol. A l'atterrissage le joueur + repasse en `Walk` et retrouve tout. + +### DECISION : les objets au sol ne bloquent pas + +Buches, branches, pierres et eclats restent traversables. Trois raisons, et +c'est une decision documentee, pas un oubli : ce sont des cibles de RAMASSAGE +(`findNearest` exige de s'en approcher) ; le plus haut - la pierre - culmine a +**0,40 m**, sous le genou, et le moteur n'a pas de step-up ; et un debitage en +depose **3 a 4 autour du joueur**, ce qui pourrait l'emmurer dans le bois qu'il +vient de produire. Un test fige la decision au lieu de la laisser au +commentaire. Ce qui la rendrait fausse : un objet au sol nettement plus gros - +il faudrait alors un drapeau par NATURE d'objet, pas un collider pour toute la +categorie. + +### Ce qui reste faux, volontairement + +**Un animal traverse toujours les troncs, les rochers et ses congeneres.** +Corollaire du "aucune IA" de la Phase 17 : la fuite est une ligne droite sans +evitement, donc un animal qui buterait resterait COLLE a l'obstacle. Un cervide +encastre dans un arbre serait plus laid que le probleme resolu. Le cylindre +reste aussi trop genereux **de face** (0,65 m pour 0,42 m de large) : un +cylindre ne peut pas etre juste dans les deux sens. + +### Verification + +**935 assertions** headless (902 avant, **+33**), zero avertissement `/W4`. +Aucun objet Vulkan, aucun thread, aucune barriere touches - d'ou **pas de +`VK_LAYER_VALIDATE_SYNC`** cette fois, et c'est justifie plutot qu'omis (le +chemin de televersement des tuiles est rigoureusement inchange). + +**Pas de scenario Vulkan dedie** : le harnais ne pilote que le clavier et la +faune est semee ALEATOIREMENT autour du joueur, donc un scenario reproductible +demanderait une entree de debogage dans `Wildlife`. La preuve de collision est +headless et deterministe - ce qui est aussi le seul endroit ou le temoin negatif +est rigoureux. Le harnais complet a servi a la NON-REGRESSION. + +**Harnais joue en entier** : **zero `[Validation]`, zero `[ERROR]`** sur 5 510 +lignes, 4 `[WARN]` benins habituels. Non-regression confirmee, et la ligne qui +compte pour cette phase : **l'editeur (scenario G) rend exactement le meme +chiffre qu'en Phase 15 - 0,28 m avec la scene contre 21,03 m sans**. Ajouter une +source au composite n'a rien change aux deux autres. Faune (I) : 4 animaux a +portee -> 1. Besoins (H), escalade (F), parapente (D), dalle reelle (C) : verts. + +Deux points rouges, aucun imputable a la phase : +1. **Scenario E (velo), "pied a terre" `False`** : echec ANTERIEUR, documente + depuis la Phase 17, hors perimetre. +2. **Scenario B, code -1** : celui-la ne pouvait PAS etre classe sans verifier, + parce que le scenario B EST le chemin de collision. **Rejoue seul : vert** + (code 0, fermeture propre, "tronc debout PUIS souche pousses"). Flakiness + `PostMessage` deja documentee. Pas une regression. + +## Prochaines etapes suggerees + +0. **glTF dans le catalogue d'assets** - la seule chose demandee en Phase 15 qui + n'ait pas ete livree, et desormais le goulot de tout habillage : les + bibliotheques libres de droits distribuent surtout du glTF, il faut convertir + a la main avant de deposer dans `assets/editor/`. + `AssetCatalog::supportedExtensions()` est le SEUL point d'extension - ancrage, + collision, catalogue, placement et serialisation sont deja agnostiques du + format. Compter un analyseur JSON, le conteneur `.glb`, les accesseurs et + l'aplatissement de la hierarchie de noeuds. +0bis. **Paralleliser la construction des tuiles** (Phase 18) : c'est 83 % du + cout d'une tuile apres les optimisations exactes de cette phase, et + `terrainNodeMeshData` est deja PURE. Le seul obstacle est + `Renderer::addMesh`, qui doit rester sur le thread de rendu. +1. **Texture de detail de pres** pour completer l'orthophoto (voir Phase 11), + et **teinter le terrain sous l'herbe** (Phase 18). +2. **Promotion decor -> abattable** et **collision avec les arbres de decor** : + sans elles, la foret des 25 km2 reste un fond de scene. +3. ~~Transfert asynchrone des tuiles de terrain.~~ **FAIT EN PHASE 12.** Le + verrou suivant est le **maillage CPU d'une tuile**, toujours synchrone sur le + thread de rendu : un thread de maillage dedie est la suite logique. +4. **Index buffer partage** entre toutes les tuiles, et **sommet allege** (delta + de morphing plutot que position complete) : deux economies faciles, chiffrees + dans NOTES-PHASE10.md. Le partage de l'index buffer economiserait aussi + 98 Ko par tuile epinglee. +5. **Decider de la scene par defaut** : `vercora.exe` sans argument charge + toujours la dalle de Phase 7, alors que la zone 25 km2 est desormais habillee + et jouable (271 FPS). +6. **Densifier l'herbe** (decoupe alpha) - explicitement laisse en l'etat. +7. Habillage visuel du parapente (mesh d'aile, inclinaison en virage) **et du + velo** (mesh de VTT a la place du cube). +7bis. **Trancher la question de la pente franchissable a velo** (voir Phase 13) : + 23,6 % rend le massif largement non-montable en ligne droite. +8. Vent/thermiques une fois le systeme meteo pose. **La Phase 16 a pose la + premiere brique de ce systeme** : temperature ambiante fonction de l'altitude, + de l'heure et de l'exposition du versant (`ambientTemperature`). Le vent n'en + fait pas partie. +8bis. ~~**Escalade** : la quatrieme activite, seule encore non commencee.~~ + **FAITE EN PHASE 14.** Les quatre activites du cadrage ont desormais une base. + Les suites les plus utiles sont, dans l'ordre : faire dependre la vitesse et le + cout d'escalade de la PENTE LOCALE (amelioration a cout nul, avant tout systeme + de prises), et **donner une limite de pente a la MARCHE** - sans elle un + versant a 90 % se monte encore a pied et l'escalade reste facultative. +8ter. **Une interaction entre activites**, la premiere du projet : les grandes + falaises (250 a 276 m) ont 0 a 2 % de pied marchable, on ne peut pas les + atteindre a pied. Le parapente est le moyen d'approche evident - mais il faut + aussi des RELAIS pour reprendre de l'energie a mi-paroi. +8quater. **DONNER DE QUOI MANGER** (Phase 16). C'est desormais la premiere + priorite de gameplay : le joueur a une jauge de faim que rien au monde ne peut + remplir. Cueillette, chasse, ou simples reserves de depart - c'est une + decision de cadrage, pas une decision technique. Dans la foulee : un ABRI + (qui donnerait un sens a `NeedsContext::sheltered` et un usage aux buches) et + le SOMMEIL (le repos refait la forme, mais rien ne distingue une pause d'une + nuit). +8quinquies. **Rendre le cycle jour/nuit.** L'horloge existe depuis la Phase 16 et + fait tomber la temperature la nuit, mais le soleil des shaders reste une + direction fixe : il fait toujours jour a l'ecran. C'est la seule incoherence + VISIBLE introduite par la Phase 16. +9. Ombres portees. (Les objets poses par l'editeur les rendent plus voyantes + encore que la vegetation : un rocher de deux metres sans ombre flotte.) +10. **Suites de l'editeur**, par ordre d'utilite (detail dans NOTES-PHASE15.md) : + collision par volumes composes plutot que par cylindre englobant, frustum + culling sur les objets poses, alignement sur la normale du terrain + (`terrainNormalAt()` est deja ecrit et teste), et selection multiple. + ~~Selectionner sans viser.~~ **FAIT LE 2026-08-23** (touches F3/F4, voir + plus haut) - mais un vrai reticule et des gizmos 3D restent a faire (§9). + +## PHASE 21 (2026-08-27) — build demo + packaging distribuable + +**Objectif atteint** : un `.exe` envoyable a quelqu'un sans environnement de +dev. Detail complet dans `NOTES-PHASE21.md`. Resume : + +- **`--demo`** (flag runtime, pas de macro de compilation) : coupe faune, + besoins, velo/parapente/escalade, artisanat interactif (abattage/ramassage/ + percussion) et l'editeur. Garde marche, vol libre (F), LOD/streaming du + terrain 25 km², orthophoto, vegetation procedurale, FPS. Charge par defaut + `vercora_zone_1m.vchm` (toute la zone) au lieu de la dalle unique de dev. +- **Chemins codes en dur elimines** : nouveau `src/core/Paths.hpp/.cpp` + (`assetsDir()`, `shadersDir()`) prefere le dossier a cote de l'executable + s'il existe, sinon retombe sur les macros CMake (`ASSETS_DIR`, + `SHADERS_OUTPUT_DIR`) - donc AUCUN changement pour le developpement + courant. C'est ce qui rend le binaire copiable ailleurs. +- **Build Release confirme sans validation layers** (`VERCORA_DEBUG` non + definie hors Debug, deja le cas avant cette phase - juste verifie). +- **Dependances runtime** : `vulkan-1.dll` vient du pilote GPU (absent du SDK + Vulkan, non fourni dans le package) ; `MSVCP140.dll`/`VCRUNTIME140.dll`/ + `VCRUNTIME140_1.dll` (VC++ Redistributable) sont fournies dans le package, + copiees depuis `VC\Redist\MSVC\...` de Visual Studio. +- **Package final** (`dist/VercoraDemo/`) : **140 Mo** au total (dalle 1 m + 95 Mo + orthophoto 43 Mo + exe/DLL/shaders ~1 Mo). Trop gros pour un email + standard (limite Gmail 25 Mo) -> **necessite un service de transfert** + (WeTransfer, lien Drive/OneDrive, etc.). Alternative plus legere possible : + substituer `vercora_zone_2m.vchm` (24 Mo) -> package ~68 Mo, deja gere par + le code en repli automatique. +- **Teste** : build Debug intact (0 erreur de validation sur le scenario A du + harnais Vulkan), build Release compile et tourne, **lance et tourne + correctement copie sur un lecteur different (E:)** - preuve que plus rien + ne depend du chemin du depot de developpement. +- **Ce qui n'a PAS pu etre verifie** (pas de machine tierce reelle) : GPU/ + pilotes de l'ami, reaction de SmartScreen chez lui (l'exe n'est pas signe), + Windows 10/11 cote lui. Voir "§7" de `NOTES-PHASE21.md` pour la liste exacte + a demander de verifier. + +## PHASE 22 (2026-08-27) — trois matieres recoltables, et la dette du velo enfin comprise + +Detail complet : `NOTES-PHASE22.md`. Deux chantiers independants. + +### Tache 2 — la dette du velo : LE JEU N'A JAMAIS EU DE DEFAUT + +**C'est le harnais qui regardait trop tot.** Le scenario E echouait sur son +« pied a terre » depuis la Phase 17 ; cinq phases l'ont reporte. La cause est +maintenant mesuree, et elle n'est pas dans `Bike.cpp` : + +`Start-Game` capturait la sortie du jeu avec `Register-ObjectEvent -Action`, +c'est-a-dire **un script-block PowerShell execute PAR LIGNE de journal**. Ces +blocs ne tournent que quand le runspace est disponible ; or les scenarios passent +leur temps dans des `Start-Sleep`. Les evenements s'empilent, et le tampon que +`Wait-ForLog` interroge est **EN RETARD** sur ce que le jeu a ecrit. **Le retard +CROIT avec la duree du scenario.** + +Temoin decisif — meme binaire, meme dalle, meme instant de lecture, seul le +collecteur change : + +| collecteur | « en selle » | « pied a terre » | +|---|---|---| +| `Register-ObjectEvent -Action` | 1 833 ms | **jamais vu en 3 s** (9,6 s reels) | +| delegue .NET compile | 5 ms | 0 ms | + +La ligne `[INFO] Velo : pied a terre.` **etait dans le journal du jeu** (ligne +490 sur 520) a chaque run depuis la Phase 17, suivie de « Fermeture propre. » et +d'un code de sortie 0. Verifie aussi par trois reproductions hors harnais : +enfourcher + 40 s de pedalage (3/3), + 14 rafales de demi-tour (3/3), et **la fin +exacte du scenario E — elan, 32 s de descente, freinage, pied a terre — 3/3 +propres** (cap impose par `--look=40,0` au lieu d'etre asservi). + +**Correctif** : le collecteur est un delegue .NET compile (`VercoraLogSink`, +`Add-Type`), qui se branche lui-meme (PowerShell 5.1 ne convertit pas une +`PSMethod` en `DataReceivedEventHandler`). `ToString()` surcharge => **aucun +appelant touche**. **Aucune ligne du jeu modifiee.** + +**Nota qui vaut pour tout le harnais** : « en selle » consommait deja **61 % de +son budget de 3 s**. Le defaut menacait TOUS les `Wait-ForLog`, pas seulement +celui du velo ; le scenario E etait juste le plus long, donc le premier a +franchir le seuil. Elargir le delai aurait masque cela au lieu de le resoudre. + +**Confirmation non cherchee** : le second demi-tour du velo converge desormais en +**3 rafales au lieu de 9** — `Turn-BikeTo` s'asservit sur un cap qui n'est plus +perime. Meme cause, deuxieme preuve. + +**Fausse piste a retenir** : le premier run de diagnostic montrait le jeu mourant +a ~30 s (sortie `-1`), puis a 105 s, puis survivant 280 s. C'etait un +**processus `vercora.exe` orphelin** d'une mesure precedente qui se disputait le +GPU. **Verifier qu'aucun processus de jeu ne survit AVANT de conclure quoi que ce +soit d'une mesure de stabilite ou de performance.** + +### Tache 1 — argile, sable, resine, plantes a fibres + +Les trois matieres du document de cadrage qui manquaient. Toutes arrivent **par +le sol**, comme l'eclat de percussion de la Phase 6 : l'objet tombe aux pieds du +joueur et doit etre ramasse (`R`). Rien ne tombe dans l'inventaire. + +**`world/Deposits` — argile et sable. LE PLACEMENT EST UN PROXY, PAS UNE CARTE.** +Le LiDAR ne porte AUCUNE information de nature de terrain (ni lithologie, ni +granulometrie, ni formations superficielles) : distinguer une vraie argile d'un +vrai sable y est **strictement impossible**. La regle codee est morphologique : +un **creux** (memes huit sondes que `WaterSource`) + un **versant amont** de 3 m +minimum — c'est ce second critere, et non la concavite, qui ecarte les replats de +crete. Partage **argile a moins de 120 m d'un point d'eau detecte, sable +sinon** ; **sans point d'eau connu, tout est du sable**. Seuils plus permissifs +que ceux de l'eau (pente 22 % contre 15 %, concavite 0,6 m contre 1,0 m, 4 sondes +sur 8 contre 5) : *l'eau doit stagner pour qu'on y boive, un sediment n'a qu'a +s'etre depose*. **Sur la dalle de reference : 18 gisements, 2 d'argile et 16 de +sable — et les deux argiles tombent exactement sur les deux points d'eau de la +Phase 16.** Touche `Y`, portee 3,5 m. + +**`world/Resin` — resine, recoltee SANS abattre.** Le jeu n'a aucune notion +d'essence d'arbre : mesh unique, et la carte de canopee donne une hauteur et un +couvert, pas une classification feuillu/resineux. D'ou un **marquage +DETERMINISTE** par hachage (55 % de resineux), recalcule et jamais stocke. On +vise le meme arbre, par le **meme** `Forest::pickTree` — mais rien n'est abattu, +rien n'est debite, et l'`Habitat` n'enregistre **aucune coupe**. Redonne au bout +de 600 s, epuise apres 3 entailles. Touche `U`. +**DETTE PRINCIPALE : un joueur ne peut pas VOIR quel arbre est un resineux** — +tous ont le meme mesh. Une silhouette distincte est le prolongement naturel, non +fait. + +**`world/FiberPlants` — ronces et orties.** Deux voies combinees par un +**MAXIMUM** (pas une somme : une coupe en pleine lisiere ne doit pas porter deux +fois plus de ronces) : +1. **la lisiere**, lue dans la carte de couvert LiDAR, avec un **toit + triangulaire** sur la bande (maximum au milieu, nul aux deux bords) — un + creneau ferait porter des ronces a tout un versant clairseme, ce qui est une + lande et non une lisiere ; +2. **le sol recemment ouvert**, via une nouvelle interface `world/Clearing.hpp` + (`ClearingSource`) implementee par `Habitat`. **Une zone ou le joueur a abattu + des arbres se met a porter des ronces.** C'est la **PREMIERE fois dans ce + projet qu'une action du joueur FAIT APPARAITRE quelque chose au lieu de le + retirer** — la Phase 17 avait construit « je coupe, le milieu s'appauvrit », + celle-ci lui donne son revers. + +Deux interfaces et non une : `groundCover` demande « reste-t-il du couvert ? » et +**rarefie** l'herbe, `clearing` demande « a-t-on ouvert ? » et **fait pousser** +les ronces. Le jour ou l'usure par pietinement degradera le couvert, elle fera +baisser l'une sans ouvrir l'autre — un sentier tasse ne fait pas pousser +d'orties. +**Sans carte de couvert, la voie 1 est entierement muette**, et c'est voulu : on +n'invente pas une lisiere par un substitut de pente. Temoin naturel — un monde +sans carte ne porte QUE les plantes que le joueur a fait pousser. +Semis **deterministe par cellule** (rien de stocke sur 25 km2) ; seules les +plantes **arrachees** sont memorisees, le temps de leur repousse (420 s), apres +quoi la meme plante revient **a la meme place et a la meme taille**. Touche `I`, +portee 2,5 m. + +**Les touches** : une rangee contigue, `E abattre / R ramasser / T boire / +Y creuser / U saigner / I arracher`. Pas une coquetterie : la rangee 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, donc **tout +ce qui suit le Z/W occupe la meme position physique**, et GLFW raisonne en +positions physiques. + +**`world/HarvestMesh`** : quatre meshes d'objets au sol + un mesh de plante sur +pied, generes en code. Quatre silhouettes et non un mesh recolore — en « zero +menu virtuel », toute la lisibilite repose sur la forme. + +### Verifications + +**Headless : 1 095 verifications** (935 avant, soit **+160**), toutes les +anciennes toujours vertes (`Forest`, `Knapping`, `Habitat`, `Bike`, `Climber`, +editeur, besoins, faune). Temoins negatifs partout. + +**TROIS TESTS AVAIENT TORT, PAS LE CODE**, et c'est la mesure qui l'a montre : +- le **pied d'une bosse** etait ecrit comme un controle negatif. Mesure : deux + gisements a 160 m du centre, 8,1 m de concavite, 26,8 m de versant au-dessus. + C'est la definition d'un cone de dejection, l'endroit le plus credible d'un + relief pour trouver du sediment. Devenu un controle **positif** ; +- le temoin de `minUpslope` plafonnait la cuvette a 40 m : le detecteur retenait + alors trois points sur un anneau a 60 m, ou le flanc fournit 5,5 m d'amont. + **Une cuvette n'est « sans amont » qu'a son CENTRE, pas partout** ; +- l'assertion de demi-hauteur exigeait l'egalite sur des meshes **bruites** : + elle testait le tirage aleatoire, pas le contrat. + +Un test **existant** a fait son travail : il a signale que les quatre nouvelles +natures manquaient dans la table mesh-par-nature. Ces `switch` ont un `return` +par defaut — le compilateur, lui, n'aurait rien dit. + +**Vulkan : DIX scenarios (A a J), QUATORZE processus.** Zero `[Validation]`, zero +`[ERROR]`, codes de sortie nuls, fermeture propre partout, **et « pied a terre : +True »**. **Scenario J ajoute, en TROIS processus** : (1-2) le script relit les gisements +que LE JEU a journalises, s'y rend par `--start`, creuse, ramasse, puis s'eloigne +de 30 m et recreuse — le refus a distance est le controle negatif, sans lequel on +ne distinguerait pas « la portee marche » de « la touche produit toujours quelque +chose » ; (3) les PLANTES A FIBRES sur la **zone de 25 km2**, la seule qui ait +une carte de couvert. **Le point de depart a ete trouve PAR MESURE** (balayage de +la zone au pas de 50 m avec la fonction de semis elle-meme : 1 656 cellules +candidates, meilleure a monde (1450, -1750), alt 1777 m, couvert 0,240). **Le +point de depart par DEFAUT de la zone est a 1947 m, au-dessus de la limite des +arbres : zero plante, zero herbe — un scenario pose la aurait ete VERT SANS RIEN +EXERCER.** Chaine verifiee : 295 plantes semees -> arrachage -> 294 et « 1 en +repousse » (et non disparue) -> ramassage du fagot. + +**Cout mesure du semis** (zone 25 km2, 10 486 images) : plantes a fibres +**185,9 us/image**, contre herbe 828,2, `drawFrame` 838,5 et arbres 1 278,3. Le +moins cher des trois semis, d'un facteur quatre. + +### Un critere du harnais qui se contredisait (scenario I, faune) + +La suite est passee rouge UNE fois sur « animaux a portee de vue » : 2 au dernier +releve, la ou le seuil n'en tolerait qu'1. **Verifie avant de toucher au code — +une regression serait reproductible** : MEME binaire, scenario I en suite +complete -> 2 ; en isolation, trois fois -> 1, 1, 1. C'est du bruit lie a la +CHARGE DE LA MACHINE (le scenario compte des releves sur 240 s, et les tentatives +d'apparition suivent le FPS). Deja consigne en Phase 18 : « rouge au premier +passage, vert au rejeu isole ET au passage final [...] c'est du bruit ». + +Surtout, **le critere contredisait sa propre documentation** : le commentaire qui +le precede dit depuis la Phase 17 qu'un residu « d'un ou DEUX animaux » est +correct (ponderation `1 - (d/r)^2`, qui tend vers zero au bord du rayon), et le +seuil n'en tolerait qu'un. Plancher porte de 1 a 2 — **mise en accord du seuil +avec le modele, pas assouplissement de confort** : l'assertion exige toujours de +partir de >= 3 et de finir a 2 au plus. La vraie correction (rendre E et I +insensibles au FPS) reste a faire. + +### Ce qui n'est pas fait + +Aucun **usage fonctionnel** des quatre matieres (recoltables, rien ne s'en +fabrique — c'etait le perimetre demande). Les **resineux n'ont pas de silhouette +propre**. **La resine n'est pas exercee sous Vulkan** : elle demande de VISER un +arbre, or le harnais ne sait pas tourner la camera et l'unique position de tir de +la dalle est deja consommee par le scenario C. (Les plantes a fibres, elles, le +sont depuis le scenario J3.) Rien n'est +**sauvegarde** : entailles et plantes arrachees meurent avec le processus. Une +seule espece de plante a fibres (mesh unique, seule l'echelle varie). + +--- + +## PHASE 23 (2026-08-27) — systeme meteo deterministe, et le jour se met enfin a tomber + +Fichiers neufs : `src/world/Weather.hpp` / `.cpp`, `NOTES-PHASE23.md`, +`tools/shot_daynight.ps1`. + +### AVERTISSEMENT EN TETE, parce qu'il conditionne la lecture de tout le reste + +**Aucune valeur numerique de ce systeme n'a ete validee par un climatologue.** +Ce sont des ordres de grandeur plausibles. Le code separe donc strictement : + +- **les mecanismes** — implementes serieusement, testes, independants des + chiffres ; +- **les valeurs** — TOUTES dans une seule struct, `WeatherParams`, chacune + commentee avec ce qu'elle fait, sa valeur provisoire et d'ou elle sort. Les + recalibrer se fait en ouvrant un seul fichier. + +Deux exceptions non provisoires et sourcables : le **refroidissement eolien** +(formule JAG/TI, Environnement Canada / NWS depuis 2001) et la **declinaison +solaire** (Cooper, 1969). Une troisieme est un fait : la latitude, 45,0 degres, +parce que la dalle est en Isere. + +`NOTES-PHASE23.md` liste par ordre de doute les sept valeurs qui demandent une +vraie relecture externe. La plus arbitraire est +`precipitationCloudThreshold = 0,72`, qui fixe a elle seule la frequence des +precipitations. + +Les tests 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**. + +### L'architecture : une fonction d'etat PURE + +Aucun etat cache, aucune integration dependante du pas de temps. Pour un point +`(x, y, z)` et un instant `t`, le module rend l'etat meteo exact. + +- En jeu : deux joueurs au meme endroit au meme instant vivent exactement les + memes conditions, quel que soit le chemin, la duree, le nombre d'images par + seconde ou les pauses. +- En test : on saute directement a `t = 137 h` sans simuler les 137 heures. + C'est ce qui rend la couverture de cette phase possible. + +Contraste avec `Needs` (Phase 16), qui INTEGRE : les jauges ont une memoire, +c'est leur role, et rien n'a change de ce cote. + +**Couche 1, synoptique (0D)** — saison et cycle diurne a deux harmoniques, +perturbations par bruit de gradient 1D, position solaire, vent de reference, +nebulosite, precipitation. Ne connait aucune position. **0,38 us**. + +**Couche 2, spatialisation (3D)** — gradient altitudinal, adret/ubac par produit +scalaire, inversion de fond de cuvette, vent local par sondage amont, ridge +lift, subsidence, turbulence, thermiques, orographie, mouillure. **4,0 us**. + +**Seed FIXE par defaut**, derivable d'une graine de partie par le constructeur. +Delibere : la zone de jeu est unique et faite a la main, rien d'autre dans +Vercora n'est reseede par partie, et un calendrier fixe est ce qui rend deux +captures du meme instant comparables (lecon de la Phase 12). + +### 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, pas d'en ajouter. + +Ont quitte `NeedsParams` pour `WeatherParams` : `seaLevelMeanTemperatureC`, +`lapseRateCPerKm`, `diurnalAmplitudeC`, `diurnalPeakHour`, `exposureBonusC`. +Ont quitte `Needs.cpp` pour `Weather.cpp` : `ambientTemperature()`, +`daylightFactor()`, `terrainExposure()`. A ete **supprime** : +`paraglideWindChillC`. + +`NeedsContext` porte desormais `ambientTemperatureC` et `windSpeedMps` au lieu +de `altitudeMeters` / `timeOfDayHours` / `exposure`. **Needs ne calcule plus +aucune ambiante** : il en recoit une et n'y ajoute que ce qui concerne le corps +du joueur — effort, fatigue, abri, vent subi. Tant que les deux calculs +coexistaient, rien n'empechait qu'un reglage n'en corrige qu'un. + +Ce n'est pas un renommage : la nouvelle ambiante connait en plus la saison, la +masse d'air, 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 ; +c'est maintenant le sinus de l'elevation solaire reelle, donc les journees +s'allongent avec la saison. + +**Le refroidissement eolien remplace le forfait de -6 degres reserve au vol.** +La marche en crete par vent fort refroidit desormais elle aussi. Hors du domaine +de validite publie (T > 10 degres ou vent < 4,8 km/h), la fonction rend la +temperature INCHANGEE plutot qu'une extrapolation : au-dessus de 10 degres la +formule brute rendrait un vent *rechauffant*. + +### L'adret/ubac par produit scalaire, et ce qu'il produit de mieux + +On compare le cosinus d'incidence du point a celui qu'aurait du terrain PLAT au +meme instant. Le comportement en sort tout seul : + +- **a midi**, un versant sud ne gagne presque rien (il est deja perpendiculaire + au rayonnement) alors qu'un versant nord perd beaucoup ; +- **au petit matin**, c'est le versant **est** qui prend le maximum — un modele + purement nord/sud ne pouvait pas le produire. + +Mesure a midi, 1000 m, pente 60 % : adret 14,7 C, ubac 10,7 C. + +### GameClock compte maintenant le temps TOTAL + +`hours()` est inchange (heure locale dans [0, 24)) ; `totalHours()` est le +compteur monotone. Le systeme meteo en a besoin : une perturbation dure +plusieurs jours, elle ne peut pas etre indexee par une heure qui reboucle. +`setHours()` recale sur le jour courant au lieu de remettre a zero — regler +l'heure a la main deplace dans la journee, pas dans le calendrier meteo. + +### QUATRE DEFAUTS TROUVES PAR LES TESTS + +Ce sont les seules parties du travail dont on sache qu'elles ne sont pas +seulement plausibles. + +**(a) Un fBm n'atteint jamais ses bornes theoriques.** Sans gain, la nebulosite +restait entre 0,20 et 0,70 sur trente jours simules : **jamais de grand beau**, +donc jamais de nuit claire, donc **tout le mecanisme d'inversion restait mort**, +et 13 heures de pluie sur 720. Corrige par `frontNoiseGain = 2,2` + ecretage. +Apres : 61 h de pluie, 63 h de grand beau. Le test qui l'a trouve exige qu'un +mois de jeu contienne des journees claires ET des journees de pluie — c'est le +controle negatif d'un modele qui a l'air de marcher tout en etant quasi +constant. **Le meme doute vaut pour le bruit de valeur de `Heightmap.cpp` et +`Vegetation.cpp`, jamais mesure de cette facon.** + +**(b) Un versant sud plus chaud de 2,9 degres a 2 h DU MATIN.** Le produit +scalaire continuait de se calculer avec le soleil sous l'horizon, ou la +reference "terrain plat" tombe a zero et AMPLIFIE l'ecart au lieu de l'eteindre. +Une formule geometrique reste definie hors de son domaine physique ; le zero +attendu ne sort pas des maths, il faut le poser. Corrige par +`aspectFullDaylightSin`. **C'est le controle negatif de NUIT qui l'a trouve, pas +le test positif de midi, qui passait.** + +**(c) La moyenne des sondages amont effacait l'abri.** Un point 250 m sous le +vent d'une crete de 200 m — un abri franc — obtenait un signal d'exposition de +**-0,05** : la sonde proche voyait bien la crete, mais la plaine des sondes a +750 m et 2000 m ramenait la moyenne au niveau du point. La regle correcte tient +en une phrase : **etre abrite, c'est avoir du relief au-dessus de soi dans AU +MOINS UNE echelle ; etre expose, c'est dominer TOUTES les echelles.** Donc un +`max` d'un cote et un `min` de l'autre, jamais une moyenne. Une moyenne suppose +les echelles interchangeables ; elles ne le sont pas. + +**(d) La turbulence de sillage se mesurait sur le mauvais vent.** Elle etait +calculee sur le vent LOCAL, qui est justement faible sous le vent : un sillage +etait d'autant plus calme qu'il etait plus abrite, l'inverse exact de la +realite. Ce qui agite un sillage est le flux qui vient de decoller de la crete, +lequel a la vitesse AMONT. + +### Et une cinquieme fois ou le test avait tort + +Le test d'inversion employait d'abord une cuvette de 400 m de creux pour 500 m +de rayon. Il echouait — mais le modele avait raison : a 400 m de denivele, le +seul gradient adiabatique rend le fond 2,6 degres PLUS CHAUD que le rebord, et +l'inversion, correctement calculee, ne suffisait pas tout a fait a renverser ce +handicap. Le relief etait invraisemblable : 400 m de creux pour 500 m de rayon +est une falaise circulaire, pas une combe. Ramene a 150 m, le test passe +largement. Voir la note memoire sur l'hypothese "le test a tort" — 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. + +### Le sondage amont : 7 lectures de heightmap, et ce qu'on en tire + +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. + +Le **Venturi** est detecte par les deux sondes laterales, mais **il faut une +ponderation 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. + +Mesures sur le relief de test (crete nord-sud de 400 m avec col, vent d'ouest) : + +| Point | Vent | Facteur de relief | +|---|---|---| +| Col | 14,2 m/s | x 2,01 | +| Crete pleine | — | x 1,80 | +| Plateau au vent | 6,4 m/s | x 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, et plus que la crete pleine **a vent +de reference egal** — l'effet d'entonnoir est bien distingue de l'effet +d'altitude. + +### La carte de piegeage d'air froid + +Precalculee UNE FOIS au chargement, 128 x 128 sur les 5 km (cellules de 39 m, +la bonne echelle pour une cuvette), 393 216 lectures de heightmap payees une +seule fois. Lecture au runtime : une bilineaire. + +Elle mesure l'**ENFERMEMENT**, pas l'altitude : huit directions a trois rayons +(120 / 350 / 900 m), on compte combien de ces 24 sondes sont plus hautes. Un +versant a mi-hauteur et un fond de vallee peuvent etre a la meme altitude, et +seul le second piege l'air froid. Meme lecon que la Phase 22 sur le relief. + +Controle negatif, 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 exige TROIS conditions simultanees (creux ferme, nuit, ciel clair et +calme) et le test verifie qu'elle **renverse le signe du gradient** — le fond, +150 m plus bas, doit etre plus FROID. Mesure : fond 2,1 C, plateau 3,6 C. + +Sans carte reliee, l'inversion vaut zero partout et le reste fonctionne : repli +explicite et teste, pas une panne. + +### LE CYCLE JOUR/NUIT VISUEL — l'incoherence de la Phase 16 est corrigee + +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 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, et un test le verifie explicitement +(`dot(light.direction, sky.sunDirection) == 1`). + +Chemin : `SynopticState` -> `sunLightFor()` -> `Renderer::setSun()` -> +`UniformBufferObject::sun` / `sunColor` -> les trois shaders de fragment, ou +`kLightDirection` et `kLightColor` etaient des constantes en dur depuis la +Phase 2. + +**Deux details qui evitent des regressions de rendu :** + +- `sunColor.a` est un **MULTIPLICATEUR** de l'ambiante, pas une valeur absolue. + Les trois shaders ont des ambiantes differentes et justifiees (0,15 cube / + 0,18 terrain / 0,24 feuillage, qui laisse passer la lumiere) : les remplacer + par une valeur unique aurait ete une regression deguisee en correction. +- Les valeurs **par defaut** de l'UBO et du Renderer reproduisent exactement + l'ancien eclairage. Un rendu qui n'appelle pas `setSun()` est pixel pour pixel + celui de la Phase 22. + +**LE CIEL 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 directionnelle venue d'en dessous eclaire le relief par le bas, defaut +visuel classique d'un cycle bacle. Test : `direction.y >= 0` a toute heure. + +**`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 la moitie du temps n'est pas jouable tant qu'aucune source de lumiere +portable n'existe. A revoir avec le feu de camp. + +### Deux options de ligne de commande, pour la meme raison que `--look` + +`--hour=` epingle l'instant de jeu, `--time-scale=0` **GELE l'horloge**. +C'est le pendant exact de `--lock-input` pour le TEMPS : sans elles, le cycle +jour/nuit rendait toute capture non reproductible, puisque les secondes de mise +en place deplacaient le soleil. `tools\shot_daynight.ps1` s'en sert pour +produire une serie d'images de la meme vue a des heures differentes. + +### Effets gameplay : branches sur l'existant, jamais en 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. + +**Paraglider** — nouvelle struct `AirState` (vent, vertical, turbulence), +volontairement NUE et non un `WeatherSample` : Paraglider ne doit pas plus +dependre de la meteo qu'il ne depend de Vulkan (meme separation que +`HeightSampler`). +- `speed_` est une vitesse **AIR** ; la vitesse sol est cette vitesse plus le + vent. 30 s a 6 m/s : **495 m vent arriere, 315 m en air calme, 135 m vent de + face**, sans aucune regle particuliere. +- Dans une ascendance plus forte que le taux de chute, la somme est positive et + l'aile MONTE : la definition du vol thermique sort de l'addition. 30 s : + 1462 m en air calme, 1553 m dans 3 m/s. +- Turbulence : deux sinusoides de periodes **incommensurables**, pas un tirage + aleatoire — le vol reste deterministe donc rejouable, et deux periodes sans + rapport simple ne se resynchronisent jamais, donc le chahut ne degenere pas en + balancement regulier, qui est ce qui trahit une turbulence fabriquee. Ni + fermeture ni decrochage : l'aile perd du cap et de la finesse, elle ne tombe + pas. + +**Climber** — adherence dans [0, 1] tiree de l'humidite par +`Climber::gripForWetness()` (methode de la classe, pour qu'il n'y ait qu'UNE +traduction humidite -> adherence dans le jeu). L'effet est **double, et c'est le +point** : la vitesse baisse ET le cout par metre monte (jusqu'a x 1,8). Sans le +second terme, un modele qui ne ferait que ralentir laisserait la jauge dire le +contraire — moins de metres, donc moins d'energie, 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**. Plancher d'adherence a 0,05 pour qu'une paroi ruisselante +reste grimpable au lieu de devenir une impasse ou le joueur serait bloque. + +**Bike** — fait, en version minimale : une seule grandeur (humidite) et deux +coefficients branches sur des termes existants, **sans ajouter le moindre +etat**. Roulement +45 %, freinage -30 % sur sol detrempe. Mesure : equilibre a +plat 16,9 -> 15,9 km/h ; une demi-seconde de frein enleve 11,7 -> 8,8 km/h. +**Pas touche : l'adherence en VIRAGE** — le rayon de braquage est un equilibre +deja verifie par les tests de la Phase 13, y toucher sans mesure serait un pari. + +### La mouillure du sol : RELUE, pas accumulee + +Le seul endroit qui pourrait sembler avoir une memoire n'en a pas : +`groundWetness()` remonte le temps dans la fonction synoptique — qui est pure — +au lieu d'accumuler par image. Huit echantillons sur six heures de jeu, decrus +exponentiellement, on garde le plus mouille. Testee : un joueur trouve la meme +mouillure au meme endroit au meme instant, qu'il ait mis dix minutes ou deux +heures a venir. + +### Cout + +| | Cout | +|---|---| +| Evaluation complete (couche 1 + 2, 7 sondages, mouillure) | **4,0 us** | +| Couche synoptique seule | **0,38 us** | +| Carte de piegeage 128 x 128 | 393 216 `heightAt()`, **une fois au chargement** | + +**Une seule** evaluation par image, au point du joueur — soit 0,024 % d'une +image de 16,7 ms. Le repere de la Phase 19 tient : le frame est domine par le +GPU (81 % dans `drawFrame` en Release), et la meteo n'avait aucune chance de +changer ca. Le test de cout porte un seuil TRES large (50 us) et volontairement : +il protege contre un facteur mille — un sondage devenu une recherche, une carte +recalculee par image — pas contre 20 %, que le bruit de mesure de cette machine +ne distingue pas (lecon de la Phase 17). + +### Verification + +- **Tests headless** : **3578 assertions**, toutes passantes. Deux sections + neuves, `testWeather()` et `testWeatherGameplay()`. +- **Vulkan reel** : **cinq executions completes** de la suite. **Zero + `[Validation]` et zero `[ERROR]` dans les cinq** ; 4 `[WARN]`, les memes + qu'avant. **Chaque scenario a passe ses assertions de gameplay** sur le binaire + final. Aucune execution n'a ete verte de bout en bout : les echecs residuels + sont tous du cote du harnais, frappent un scenario different a chaque fois, et + sont detailles juste en dessous. +- **Visuel** : `tools\shot_daynight.ps1`, six captures de la MEME vue a + 3 / 6,5 / 9 / 13 / 18 / 21 h, horloge gelee et cadrage epingle. La lumiere + tourne d'est en ouest, l'intensite suit, le ciel passe du bleu de midi au bleu + nuit. Le detecteur de ciel du script le chiffre tout seul : **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. +- **Pas de capture adret/ubac**, et c'est une limite assumee : le jeu n'a aucun + indice VISUEL de temperature. L'ecart est mesure par les tests (14,7 C contre + 10,7 C a midi), pas montre. Un indice visuel est note comme amelioration + future. + +### LE HARNAIS VULKAN : une regression a moi, et une flakiness enfin mesuree + +**(a) Ma regression.** La premiere version journalisait DEUX LIGNES DE METEO PAR +SECONDE. Le harnais paie un script-block PowerShell PAR LIGNE de journal et son +retard CROIT avec le volume (dette ouverte en Phase 17, comprise en Phase 22). +Le scenario H, le plus long, a echoue et n'a collecte que **87 releves sur 220**. +Le jeu etait correct. + +La cadence a ete resserree DEUX FOIS, et la valeur intermediaire est la lecon : + +| Cadence | Lignes ajoutees au scenario H | Releves collectes | +|---|---|---| +| 2 / seconde | ~440 | **87** - echec | +| 2 / 10 s | ~44 | 235 puis **181** - echec marginal | +| **1 / 30 s** | **~7** | **236 / 240** | + +La version a 10 s 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.** + +**(b) La flakiness, desormais MESUREE et non supposee.** 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), sans jamais aucun `[Validation]` ni +`[ERROR]`. **Le jeu se ferme en 0,1 / 0,1 / 0,1 / 0,2 seconde** sur quatre essais +chronometres par `CloseMainWindow()` + `WaitForExit`. Un "pas de sortie apres +20 s" est donc un echec de LIVRAISON du message par le harnais, jamais un blocage +du jeu. Meme famille que la variance A/B/G deja documentee (`PostMessage`, +scancodes, pas de vraie souris) : les runs qui echouent montrent d'ailleurs des +assertions de gameplay a False EN AMONT - pas de decollage, pas d'entree en mode +editeur - donc des touches perdues, pas une fermeture ratee. + +### Limites assumees + +Pas de vraie ombre pluviometrique sous le vent (seulement l'absence de +renforcement) ; pas de nature de sol pour le velo (le LiDAR n'en porte aucune, +limite deja etablie en Phase 22) ; pas d'adherence en virage ; ni fermeture ni +decrochage en parapente ; `snowing` calcule et journalise mais **sans aucun +effet** gameplay ni visuel ; **aucune precipitation visible** — il pleut dans les +chiffres, pas a l'ecran ; pas d'ombres portees ; pas d'etoiles ni de lune ; l'ondulation de +l'herbe (Phase 18) est toujours pilotee par un temps qui defile et non par le +vent local, alors que celui-ci est desormais disponible en tout point ; modele +solaire sans equation du temps ni refraction (au plus une quinzaine de minutes +d'erreur sur le lever et le coucher, invisible dans une horloge acceleree douze +fois). + + +--- + +## PHASE 24 (2026-08-27) - coherence marche/escalade, et une fausse flakiness + +Voir `NOTES-PHASE24.md` pour le detail complet. + +### Chantier 1 : la marche a enfin une limite de pente + +Jusqu'ici `Camera` en mode `Walk` n'avait AUCUNE limite : un versant a 90 %, +voire une paroi a 300 %, se montait debout a 14 m/s. Le vrai probleme n'etait pas +le realisme, c'etait que **l'escalade devenait facultative** - une activite +entiere que rien n'obligeait jamais a employer. + +`src/core/SlopeLimits.hpp` (neuf, header-only) porte deux seuils PARTAGES : + +- `kWalkComfortSlope` = **0,60** (31 deg) - fin de la pleine vitesse. Ce n'est + pas une valeur neuve : c'est `ClimberParams::walkableSlope`, deja justifiee en + Phase 14. Les trois lecteurs lisent desormais la meme constante. +- `kWalkMaxSlope` = **0,84** (40 deg) - plus aucune progression debout. C'est la + borne haute de l'angle de repos des materiaux meubles, la grandeur que la + Phase 14 invoquait deja pour placer `wallSlope`. Vitesse accordee : 100 % a + 60 %, 50 % a 72 %, 17 % a 80 %, 0 % a 84 %. La randonnee raide passe intacte. + +Trois regles au-dela : rampe progressive (pas de mur sec), **redescendre est +toujours accorde a pleine vitesse** (sans quoi un joueur pose sur du trop raide +serait fige), et **glissade** vers l'aval (0,48 m/s a 100 % de pente, plafonnee +a 6 m/s). La glissade est la garantie de fond : aucune position n'est un piege. + +**LE VRAI BUG DE COHERENCE, et sa correction structurelle.** L'escalade ne +s'engageait qu'a 1,00 : une limite de marche a 0,84 aurait ouvert une bande +[0,84 ; 1,00[ - environ **5 % du massif** - ou l'on ne pouvait NI marcher NI +grimper. `ClimberParams::wallSlope` vaut desormais `kWalkMaxSlope`, **la meme +constante** : il n'y a plus deux nombres a faire diverger. La part grimpable de +la zone passe de 8,4 % a ~13 %. `WildlifeParams::maxSlope` descend de 0,90 a +0,80 pour garder le rapport "aucun animal sur une pente grimpable". + +Verifie sur le relief LiDAR reel (voie de reference E 899900 / N 6435550) : la +marche progresse de 1,4 m puis s'arrete sur du 81 %, et `Climber::tryStart()` +accepte **depuis ce point exact**. Le 1,4 m paraissait suspect : le profil +mesure montre 57 % -> 89 % en deux metres. C'est le terrain, pas le test. + +Tests : **3608 assertions** (3578 avant, +30 neuves), zero regression. + +### Chantier 2 : ce n'etait pas de la flakiness + +Le delegue .NET compile demande par la consigne **existait deja** (Phase 22) - +et c'est ce qui a masque la suite. Trois executions ont donne le meme echec au +detail pres sur les scenarios A et C : **defaut DETERMINISTE**, classe +"aleatoire" depuis des phases, d'ou l'inefficacite d'elargir des delais. + +Deux controles negatifs ecartent le chantier 1 : limite de pente entierement +neutralisee -> echec identique ; et dans l'execution de reference le filtre ne +s'est **declenche aucune fois**. + +Cause reelle : `GoTo` naviguait **a l'estime** et declarait le joueur arrive +sans rien verifier ; l'erreur s'accumulait d'un `GoTo` au suivant. Tout le +scenario A tombait d'une seule cause. Correctif **sans toucher au jeu** : +`main.cpp` journalise la position de la camera une fois par seconde depuis la +Phase 15 - le harnais ne s'en servait pas. Boucle fermee, tolerance 0,6 m. +Scenario A : arbre abattu au lieu de manque, **7-8 objets ramasses au lieu de +1**, percussion 1 au lieu de 0. + +Limite du canal d'entree, mesuree : la boucle **plafonne a ~0,8 m** (`Hold` +refuse tout pas sous 0,28 m, `Start-Sleep` granularite ~16 ms). Deux executions +du meme binaire ont donne 0,78 m (abattu) et 0,80 m (manque) - d'ou +`Fell-WithRetry`, un balayage lateral, comme `Vacuum` le fait deja au ramassage. + +**Une regression de la phase, trouvee et corrigee** : le journal "sur changement +d'etat" du chantier 1 CHATTE quand le joueur longe le seuil - 494 lignes, et le +scenario I perdait 40 % de sa telemetrie. Limiteur de cadence (1 s) : 30 lignes, +scenario I retabli. Un etat qui BAT n'est pas un evenement. + +Diagnostics permanents ajoutes : le **journal brut du jeu ecrit sur disque** a +chaque execution (HORODATE - le premier jet ecrasait le precedent, et le run 6 a +efface la seule trace de l'echec du run 5), et un report des declenchements du +filtre de pente. + +**RESULTAT SUR PLUSIEURS SUITES COMPLETES, et il faut le dire tel quel :** +run 4 **VERT** (la premiere suite verte de bout en bout du projet), run 5 +**ECHEC** (scenario C : arbre manque ; scenario I : 48 releves au lieu de 216), +run 6 **VERT**. Donc **2 verts sur 3** : le critere "zero faux-negatif sur +plusieurs runs consecutifs" **n'est PAS atteint**. Le defaut DETERMINISTE, lui, +est bien corrige - le scenario A est "pilotage precis" dans les trois runs. +Ce qui reste est une flakiness authentique, et le journal horodate est ce qui +permettra de la trancher a la prochaine occurrence. + +--- + +## PHASE 25 (2026-08-27) - l'adret/ubac devient VISIBLE + +Voir `NOTES-PHASE25.md` pour le detail complet. + +L'ecart adret/ubac etait calcule et journalise depuis la Phase 23 (14,7 C contre +10,7 C a midi) et **strictement invisible a l'ecran** - limite que la Phase 23 +avait notee elle-meme. + +**Piste retenue : teinte du terrain**, parce que c'est la seule des trois qui +reutilise la grandeur existante telle quelle. `shaders/terrain.frag` avait deja +les deux moities du calcul de `WeatherSystem::sampleAt` : la normale par fragment +et `ubo.sun.xyz`, la direction solaire de Weather descendue jusqu'au rendu en +Phase 23. **Rien a recalculer, seulement a consommer.** + +Partage des roles : le CPU porte dans `ubo.terrain.w` ce qui appartient a la +meteo (hauteur du soleil, nebulosite) ; le shader ne fait que le cosinus +d'incidence par fragment. `terrain.w` etait "reserve" depuis la Phase 11 : +**aucun octet d'uniforme ajoute, aucune allocation**. + +Consequence gratuite : la coherence avec le cycle jour/nuit ne demande AUCUNE +regle horaire. Le soleil tourne, l'incidence suit ; il se couche, l'effet +s'eteint. + +**Parametres** : teinte adret `(1.14, 1.04, 0.88)`, ubac `(0.86, 0.96, 1.12)`, +exactement symetriques autour de 1 (sinon tout le plat du massif serait teinte), +ecart de reference 0,35 = `WeatherParams::aspectIncidenceReference`, intensite +maitresse `kAspectTintIntensity` = 1,0 dans `src/main.cpp`. + +**L'amplitude a ete corrigee apres mesure** : a +/- 7 %, 93,5 % des pixels ne +bougeaient pas d'un cran sur 255 a 13 h - donc un indice invisible. Le SIGNAL +reste celui de la meteo ; seule l'amplitude d'AFFICHAGE a change. + +**Verification.** Belvedere trouve par un vrai calcul de VISIBILITE (la premiere +tentative, qui ne comptait que les pentes presentes dans le cone, a donne un +aplat a 0 % de ciel) : **E 900000 / N 6436000, alt 1950 m, `--look=270,-24`**, +108 points d'adret et 107 d'ubac VISIBLES. + +| heure | rechauffes | refroidis | inchanges | +|---|---|---|---| +| 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 % | + +Le critere n'est pas "les images different" - un filtre global donnerait ca +aussi - mais la **bipolarite dans la meme image**. Plancher de bruit mesure en +capturant deux fois le MEME binaire : 0,6 % a 13 h, 1,2 % a 22 h. L'effet est +donc **80 fois le bruit a midi**, et **dans le bruit a 22 h** - reellement eteint +la nuit, le residu etant l'herbe animee. + +**Cout** : `drawFrame` 665 us contre 672 us au temoin (bruit, et dans le sens +d'un gain) ; memoire GPU strictement identique. **Zero `[Validation]`** sur les +huit lancements de capture. + +Pistes NON retenues : la **vegetation differenciee par versant** demande une +distinction d'especes qui **n'existe pas** (un seul type d'arbre) - c'est un +prerequis manquant, pas un reglage, a traiter avec le chantier 4 ; l'**affichage +de la temperature** etait le filet de securite, inutile puisque la piste 1 a +tenu (et la temperature est deja dans le titre de la fenetre). + +Limites assumees : indice **non quantitatif** ; **terrain seulement** (l'herbe et +les arbres ne sont pas teintes) ; **pas d'ombres portees** (herite de la Phase +23) - un versant a l'ombre d'une crete est traite comme s'il voyait le soleil ; +l'effet **sature** au-dela de 0,35 d'ecart d'incidence, exactement comme la +temperature. + +## PHASE 27 (2026-09-24) - meteo visible, micro-relief du sol, profil de performance + +Detail complet : `NOTES-PHASE27.md`. Tests 3636/3636, 0 `[Validation]`. + +**Meteo visible** : une seule fonction pure, `weatherVisualsFor(sky, local, +params)` (world/Weather), traduit en image ce que Weather calculait deja, au +point du joueur. **Tracabilite** (aucune mecanique inventee) : +- soleil direct voile <- `cloudCover` local, loi `cloudAspectDamping` (reutilisee, + la meme que l'adret) ; ambiante diffuse x(1 + 1,0 x nuages x jour) ; ciel + desature vers sa luminance x0,80 <- `cloudCover` ; +- pluie/neige plein ecran (densite, opacite) <- `precipitationMmPerHour` local / + `precipitationMaxMmPerHour` ; neige <- `snowing` (temperature) ; inclinaison + <- `windVector` local + vitesse terminale 6,5 / 1,2 m/s ; +- brouillard exp(-sigma d), sigma = 0,25 R^0,63 /km (x8 en neige) <- + precipitation locale ; **nul sans precipitation** ; couleur = ciel ; +- sol fonce x(1 - 0,35 x `wetness`). +Coefficients d'affichage PROVISOIRES regroupes dans `WeatherParams` section +6 ter. Ciel clair + sol sec = lumiere de la Phase 23 AU BIT PRES (teste). +Prerequis manquants documentes, non implementes : humidite/point de rosee +(brume de vallee), base des nuages, phase mixte pluie/neige (la bascule est un +saut du modele, isole par le test), manteau neigeux, nebulosite spatialisee. + +**Micro-relief** : bruit en TEXTURE (256 px, 32 cellules, mips, binding 2) +perturbant la normale + l'albedo, 7 octaves de 0,61 m (texel ortho) a 5 mm, +amplitude pilotee par le contraste local de l'ortho et la pente LiDAR, fondu +5 -> 20 m + fondu de Nyquist par octave. HF du sol proche +22 %, lointain +inchange. Non verifie EN MOUVEMENT (scintillement). + +**Outils** : `--day=N`, `--no-weather-visuals`, `--no-ground-detail` (temoins +etroits), `tools/shot_weather.ps1` (captures + journal par image), +`tools/profile_phase27.ps1` (A/B entrelaces, sante machine), ligne +`Cadence de boucle (PHASE 27)` en fin de partie. + +**Performance (Release, UHD 770)** : toujours GPU-bound (drawFrame 75-85 %) ; +Debug CPU-bound (herbe 44 %). Pluie +608 us (accepte, seulement quand il +pleut) ; micro-relief v1 +1 683 us rejete, bissection -> ~200 us PAR OCTAVE +d'arithmetique ; v3 texture +480 us en vue de marche. **Un poste CPU n'est pas +un temoin valide pour un changement GPU sur GPU integre** (budget de puissance +partage : herbe +32 % des que le GPU charge plus). + +## PHASE 28 (2026-09-27) - faconnage generique (Agent 2 : Foyer, Ligature, Hache, Poix) + +Detail complet : `NOTES-PHASE28.md` (conception : `NOTES-PHASE28-DESIGN.md`). +Tests **3807/3807** (3636 avant), 0 `[Validation]` au demarrage. + +- `world/Crafting` : table `constexpr kRecipes` (8 recettes), `craftAt` sur la + touche **C** (premiere recette satisfaite ; ingredients PORTES ou POSES a + 2,5 m ; poste = foyer a 2 m ; tout verifie avant retrait ; produit au sol). + La percussion est la derniere recette ; `knapStones` reste, inchange. +- `HearthSet` : combustion en heures de JEU, 1 h (+1 h par branche/buche + posee), extinction => 1 cendre ; foyer fixe (`groundItemIsPortable`), + rallumable. +- Nouveaux `GroundItemKind` en fin d'enum : Cord, Axe, Hearth, Ash, Pitch + (`kGroundItemKindCount` = 13), meshes `world/CraftMesh`. +- **P** = reposer au sol (dernier type ramasse). Coupe en demo/vol/velo/escalade. +- (Agent 2) effets non branches -> faits par l'Agent 3 ci-dessous : `HearthSet::warmthAt` pret pour + `ambientTemperatureC` ; hache = `inventory.count(Axe)` pour le rendement. +- **Agent 3 (effets branches)** : tests **3877/3877** (3807 avant), 0 `[Validation]`. + Foyer : `ambientTemperatureC += hearths.warmthAt(pos)` (+8 C centre -> 0 a 6 m). + Hache : `Forest::setBuckingBonusLogs(axeBonusLogs(inventory))` +1 buche ; + hache renforcee (`pitched_axe` = hache + poix posees, `PitchedAxe`) +2. + Abri (`shelter` = 4 buches + 6 branches + 2 ligatures posees, `Shelter` fixe) : + `needsContext.sheltered = shelterNear(...)` a 2,5 m (+5 C, vent annule). + 10 recettes, `kGroundItemKindCount` = 15. Abattage jamais conditionne. + NON fait : collision de l'abri, scenario Vulkan K, pot (P7). Voir NOTES-PHASE28.md. +- **Agent 4 (verification, 2026-09-27)** - detail : `NOTES-PHASE28.md` fin. + MESURE : headless **3877/3877** ; build Debug propre 82/82, **0 avertissement** + (le seul `/W4` des tests, `main.cpp` C4244 l.1280, date de la Phase 27) ; + `run_vulkan_check.ps1` complet x2 : **0 `[Validation]`, 0 `[ERROR]`**, 4 `[WARN]` + habituels, tout vert SAUF C (arbre "MANQUE" : navigation arrivee a 0,82/0,84 m, + limite connue ~0,8 m du harnais) ; `-Only C` ensuite : **vert**. Aucun passage + complet vert de bout en bout. Cadence Debug par processus vs journal brut de la + Phase 27 : 13/14 egaux ou plus rapides, 1 a +1 % -> pas de regression (Release + NON mesure). Relecture du diff vs sauvegarde : Weather/Needs/faune/collision/ + activites/pierre intouches ; aucun bug trouve, aucun code modifie. +- **Recettes retenues (10, ordre = priorite)** : shelter (4 buches+6 branches+ + 2 ligatures posees -> abri fixe, sheltered), hearth (3 pierres+2 branches posees, + eclat porte outil -> foyer allume), hearth_relight, pitched_axe (hache+poix -> + +2 buches), axe (eclat+branche+ligature posees -> +1 buche), pitch (2 resines+ + 1 cendre, foyer allume), cord (3 fibres portees), hearth_feed_log/branch (+1 h), + knap (Phase 6, au bit pres). Justification : chaque objet branche un systeme + EXISTANT (Needs ambiante/sheltered, rendement Forest) ; le foyer existe parce que + la poix exige de la cendre ; couteau ecarte (rien a influencer). +- **Architecture** : `world/Crafting` sans Vulkan, table `constexpr kRecipes`, + `craftAt` = premiere recette satisfaite (porte = Inventory, pose = Ground a + 2,5 m, poste = foyer a 2 m), verification avant retrait, produit au sol ; + `HearthSet` hors Ground, heures de jeu ; touches C (faconner) et P (reposer). +- **Pas fini** : collision de l'abri, pot d'argile (P7), lumiere du foyer, + scenario Vulkan K, fiabilite de navigation du scenario C. + +## PHASE 29 (2026-09-27) - Agent 2 : rochers et pierriers (detail : NOTES-PHASE29.md) + +- `src/world/Rocks.{hpp,cpp}` + `RockMesh.{hpp,cpp}` : semis deterministe sous le + masque de NOTES-PHASE29-DESIGN.md (Climber::slopeAt 0,60-0,84, couvert < 0,10), + rugosite >= 0,10 m -> gros blocs/rochers, sinon pierraille. Sans carte de + couvert : ZERO rocher. Masque en jeu : 8,4 % de la zone. +- Rendu instancie (Material::Foliage), mode rocher de `foliage.vert` si + `params.w < 0` : gradient encode dans la partie entiere de `variation`. +- Collision : gros blocs >= 1,3 m seulement ; `--no-rocks`, `--no-rock-collision`. +- Tests **3930/3930** (+53). Cout Debug : +85-89 us/image, RAM +1 Mo, 0 `[Validation]`. +- `tools\profile_phase29.ps1` : A/B entrelace, arret par PID exact (profile_phase27 + tue PAR NOM, a eviter). PIEGE : `run_vulkan_check.ps1 -Only E,F` via `-File` ne + joue RIEN ; passer par `-Command "& .\tools\run_vulkan_check.ps1 -Only 'E','F'"`. + +## PHASE 29 (2026-09-27) - Agent 3 : buissons et petits arbres (detail : NOTES-PHASE29.md) + +- Cartes classe 3 COPIEES dans `assets\terrain\vercora_zone_canopy_lowveg.vchm` et + `_canopy_lowveg_height.vchm` (schema `canopyPathFor(path, "_lowveg")`), sources intactes. +- `src/world/Bushes.{hpp,cpp}` + `BushMesh.{hpp,cpp}` : critere F3 >= 0,10 ET couvert-F3 < 0,20 + ET couvert >= 0,10 (=> disjoint des Rochers par construction) ; hors houppier des arbres + Forest ; densite lineaire en F3, hauteur = h max c3 x U[0,35;0,85] bornee 0,5-3 m ; + >= 1,8 m -> petit arbre. Une carte absente -> ZERO buisson. +- Rendu : chemin ARBRE de `foliage.vert` (w = 0), shader NON modifie ; `--no-bushes` temoin. +- Adret/ubac NON applique (buis hors etage, rhododendron = sol acide, aulne vert silicicole). +- Collision : aucune (traversables). Tests **3968/3968** (+38). +- Cout Debug : alpage +135 us/img (+2,0 %), zone dense +322 us (+5,1 %), RAM +8 Mo, 0 `[Validation]`. +- `profile_phase29.ps1 -View buissons -Toggle --no-bushes` (defaut inchange). + +## PHASE 29 (2026-09-27) - Agent 4 : verification (detail : NOTES-PHASE29.md fin) + +- MESURE : build Debug clean 86/86, 0 avertissement (seul C4244 main.cpp l.1297 = l.1280 + Phase 27 decalee) ; headless **3968/3968** ; `run_vulkan_check.ps1` complet : + **0 `[Validation]`**, tout vert SAUF C (0,81/0,83 m, comme en Phase 28) ; `-Only 'C'` x3 : + 1 echec, 2 verts. Sur les dalles LHD (scenarios A a I) : ZERO rocher/buisson (pas de couvert), + donc la Phase 29 ne peut pas y jouer ; J3 (zone) les a et passe. +- Placement : rochers = Climber::slopeAt 0,60-0,84 ET couvert < 0,10 ; rugosite >= 0,10 m + -> blocs, sinon pierraille ; trainees = bruit anisotrope 110 m / 28 m. Buissons = F3 >= 0,10 + ET couvert-F3 < 0,20 ET couvert >= 0,10 (disjoints des rochers), hors houppier Forest. +- Densite : blocs 8 / 1024 m2, rochers 20 / 1024 m2, pierraille 12 plaques / 64 m2 ; + buissons 6 / cellule de 8 m. Journal actuel : masque rochers 9,4 %, 1,82 blocs, 4,66 + rochers, 23,2 plaques / ha (les 8,4 % / 46 de l'Agent 2 precedent une retouche de Rocks.cpp) ; + buissons 9,7 %, 21,7 buissons + 31,0 petits arbres / ha. +- Cout TOTAL (A contre `--no-rocks --no-bushes`, 3 tours entrelaces) : Debug alpage +164 us + (+2,5 %), pierrier +252 (+8,8 %), buissons +456 (+7,6 %) ; **Release** (`build-release\` + separe) alpage +124 us (+2,6 %) = 4 954 us, au niveau de la ref. Phase 27 (4 962) ; + pierrier +70 us ; zone dense de petits arbres **+676 us (+13 %)**, 170 img/s, GPU-bound. + RAM +8-9 Mo. +- Limites : trainees NON visibles a l'oeil (blocs epars) ; petits arbres voisins + s'interpenetrent ; arbres de decor Vegetation non exclus ; rien de mesure en mouvement. +- Relecture : seuls main.cpp et foliage.vert modifies ; Forest/Vegetation/faune/ + artisanat/collision/activites identiques octet pour octet ; chemin w >= 0 du shader inchange. +- Outil : `build-release\` existe desormais (profil Release hors du `build\` Debug). diff --git a/NOTES-AUDIT-GLOBAL.md b/NOTES-AUDIT-GLOBAL.md new file mode 100644 index 0000000..19837a0 --- /dev/null +++ b/NOTES-AUDIT-GLOBAL.md @@ -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. diff --git a/NOTES-PHASE-ESCALADE.md b/NOTES-PHASE-ESCALADE.md new file mode 100644 index 0000000..b4e1c8a --- /dev/null +++ b/NOTES-PHASE-ESCALADE.md @@ -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. diff --git a/NOTES-PHASE-VELO.md b/NOTES-PHASE-VELO.md new file mode 100644 index 0000000..baca39a --- /dev/null +++ b/NOTES-PHASE-VELO.md @@ -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. diff --git a/NOTES-PHASE10.md b/NOTES-PHASE10.md new file mode 100644 index 0000000..7da376e --- /dev/null +++ b/NOTES-PHASE10.md @@ -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. diff --git a/NOTES-PHASE11.md b/NOTES-PHASE11.md new file mode 100644 index 0000000..959e9d9 --- /dev/null +++ b/NOTES-PHASE11.md @@ -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. diff --git a/NOTES-PHASE12.md b/NOTES-PHASE12.md new file mode 100644 index 0000000..8e8a53a --- /dev/null +++ b/NOTES-PHASE12.md @@ -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. diff --git a/NOTES-PHASE15.md b/NOTES-PHASE15.md new file mode 100644 index 0000000..c9f478e --- /dev/null +++ b/NOTES-PHASE15.md @@ -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 ` | obligatoire, **en premier**. 1 pour cette session. | +| `terrain ` | **informatif** : ne sert jamais à refuser un chargement. | +| `crs ` | `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/.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. diff --git a/NOTES-PHASE16.md b/NOTES-PHASE16.md new file mode 100644 index 0000000..3e98e69 --- /dev/null +++ b/NOTES-PHASE16.md @@ -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`. diff --git a/NOTES-PHASE17.md b/NOTES-PHASE17.md new file mode 100644 index 0000000..2cfda38 --- /dev/null +++ b/NOTES-PHASE17.md @@ -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. diff --git a/NOTES-PHASE18.md b/NOTES-PHASE18.md new file mode 100644 index 0000000..dd52e2d --- /dev/null +++ b/NOTES-PHASE18.md @@ -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). diff --git a/NOTES-PHASE19.md b/NOTES-PHASE19.md new file mode 100644 index 0000000..a3d34f0 --- /dev/null +++ b/NOTES-PHASE19.md @@ -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). diff --git a/NOTES-PHASE20.md b/NOTES-PHASE20.md new file mode 100644 index 0000000..0ed3d33 --- /dev/null +++ b/NOTES-PHASE20.md @@ -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. diff --git a/NOTES-PHASE21.md b/NOTES-PHASE21.md new file mode 100644 index 0000000..cbe747a --- /dev/null +++ b/NOTES-PHASE21.md @@ -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 + `$<$: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) diff --git a/NOTES-PHASE22.md b/NOTES-PHASE22.md new file mode 100644 index 0000000..5a7f389 --- /dev/null +++ b/NOTES-PHASE22.md @@ -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. diff --git a/NOTES-PHASE23.md b/NOTES-PHASE23.md new file mode 100644 index 0000000..d31ca8b --- /dev/null +++ b/NOTES-PHASE23.md @@ -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. diff --git a/NOTES-PHASE24.md b/NOTES-PHASE24.md new file mode 100644 index 0000000..2b9b642 --- /dev/null +++ b/NOTES-PHASE24.md @@ -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. diff --git a/NOTES-PHASE25.md b/NOTES-PHASE25.md new file mode 100644 index 0000000..5a02f9a --- /dev/null +++ b/NOTES-PHASE25.md @@ -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. diff --git a/NOTES-PHASE26.md b/NOTES-PHASE26.md new file mode 100644 index 0000000..e1e944c --- /dev/null +++ b/NOTES-PHASE26.md @@ -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. diff --git a/NOTES-PHASE27.md b/NOTES-PHASE27.md new file mode 100644 index 0000000..5bc3559 --- /dev/null +++ b/NOTES-PHASE27.md @@ -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. diff --git a/NOTES-PHASE28-DESIGN.md b/NOTES-PHASE28-DESIGN.md new file mode 100644 index 0000000..7688dbd --- /dev/null +++ b/NOTES-PHASE28-DESIGN.md @@ -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 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 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. diff --git a/NOTES-PHASE28.md b/NOTES-PHASE28.md new file mode 100644 index 0000000..31d9849 --- /dev/null +++ b/NOTES-PHASE28.md @@ -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). diff --git a/NOTES-PHASE29-DESIGN.md b/NOTES-PHASE29-DESIGN.md new file mode 100644 index 0000000..78dae1b --- /dev/null +++ b/NOTES-PHASE29-DESIGN.md @@ -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). diff --git a/NOTES-PHASE29.md b/NOTES-PHASE29.md new file mode 100644 index 0000000..b421ead --- /dev/null +++ b/NOTES-PHASE29.md @@ -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). diff --git a/NOTES-PHASE6.md b/NOTES-PHASE6.md new file mode 100644 index 0000000..435979b --- /dev/null +++ b/NOTES-PHASE6.md @@ -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 `` 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). diff --git a/NOTES-PHASE7.md b/NOTES-PHASE7.md new file mode 100644 index 0000000..5880d62 --- /dev/null +++ b/NOTES-PHASE7.md @@ -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 `. 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. diff --git a/NOTES-PHASE9.md b/NOTES-PHASE9.md new file mode 100644 index 0000000..5847ee2 --- /dev/null +++ b/NOTES-PHASE9.md @@ -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___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___1m.vchm` | 25 heightmaps individuelles, 3,82 Mo chacune | +| `assets/terrain/LHD___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. diff --git a/assets/editor/README.md b/assets/editor/README.md new file mode 100644 index 0000000..f5b65c9 --- /dev/null +++ b/assets/editor/README.md @@ -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()`. diff --git a/assets/editor/octaedre.obj b/assets/editor/octaedre.obj new file mode 100644 index 0000000..25af61d --- /dev/null +++ b/assets/editor/octaedre.obj @@ -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 diff --git a/assets/icosphere.obj b/assets/icosphere.obj new file mode 100644 index 0000000..a09958e --- /dev/null +++ b/assets/icosphere.obj @@ -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 diff --git a/assets/octahedron.obj b/assets/octahedron.obj new file mode 100644 index 0000000..25af61d --- /dev/null +++ b/assets/octahedron.obj @@ -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 diff --git a/assets/scenes/demo_phase15.vcsc b/assets/scenes/demo_phase15.vcsc new file mode 100644 index 0000000..01ad8f2 --- /dev/null +++ b/assets/scenes/demo_phase15.vcsc @@ -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 +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 diff --git a/assets/scenes/demo_zone25.vcsc b/assets/scenes/demo_zone25.vcsc new file mode 100644 index 0000000..8464039 --- /dev/null +++ b/assets/scenes/demo_zone25.vcsc @@ -0,0 +1,24 @@ +# Vercora - scene de CONTROLE de la Phase 15, sur la zone de jeu de 25 km2. +# +# Elle demontre la propriete centrale du format : les coordonnees sont projetees +# (Lambert 93) et les altitudes RELATIVES au terrain, donc la meme scene se +# recharge au meme endroit du massif quelle que soit l'emprise ou la resolution +# chargee. Verifie a l'image sur vercora_zone_1m.vchm ET vercora_zone_2m.vchm : +# memes objets, memes positions a l'ecran, seul le relief fin differe. +# +# Elle ne porte VOLONTAIREMENT pas le nom d'auto-chargement (vercora_zone.vcsc) : +# la zone de jeu par defaut reste vierge, cette scene ne se charge qu'a la +# demande. +# +# vercora.exe assets errain ercora_zone_1m.vchm ^ +# --scene=assets\scenes\demo_zone25.vcsc ^ +# --start=901500,6438500 --look=-90,-10 +version 1 +terrain vercora_zone_1m.vchm +crs 2154 +object poteau 901499.000 6438504.000 0.000 0.000 1.0000 1 +object cairn 901503.000 6438508.000 0.000 0.000 1.0000 1 +object rocher 901495.500 6438512.000 0.000 0.000 1.0000 1 +object bloc 901506.000 6438516.000 0.000 35.000 1.0000 1 +object abri 901498.000 6438522.000 0.000 15.000 1.0000 0 +object octaedre 901509.000 6438526.000 1.200 0.000 1.5000 1 diff --git a/assets/terrain/vercora_zone_ortho.vcto b/assets/terrain/vercora_zone_ortho.vcto new file mode 100644 index 0000000..dfeb987 Binary files /dev/null and b/assets/terrain/vercora_zone_ortho.vcto differ diff --git a/build_log.txt b/build_log.txt new file mode 100644 index 0000000..efd5647 --- /dev/null +++ b/build_log.txt @@ -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 value. Or, use the ... syntax + to tell CMake that the project requires at least but has been updated + to work with policies introduced by 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 value. Or, use the ... syntax + to tell CMake that the project requires at least but has been updated + to work with policies introduced by 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 diff --git a/run_demo.bat b/run_demo.bat new file mode 100644 index 0000000..befdd92 --- /dev/null +++ b/run_demo.bat @@ -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 diff --git a/run_release.bat b/run_release.bat new file mode 100644 index 0000000..63233a4 --- /dev/null +++ b/run_release.bat @@ -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 diff --git a/shaders/cube.frag b/shaders/cube.frag new file mode 100644 index 0000000..1c276bd --- /dev/null +++ b/shaders/cube.frag @@ -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); +} diff --git a/shaders/cube.vert b/shaders/cube.vert new file mode 100644 index 0000000..4066f01 --- /dev/null +++ b/shaders/cube.vert @@ -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; +} diff --git a/shaders/foliage.frag b/shaders/foliage.frag new file mode 100644 index 0000000..2cc3071 --- /dev/null +++ b/shaders/foliage.frag @@ -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); +} diff --git a/shaders/foliage.vert b/shaders/foliage.vert new file mode 100644 index 0000000..b203eb2 --- /dev/null +++ b/shaders/foliage.vert @@ -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; + } +} diff --git a/shaders/precip.frag b/shaders/precip.frag new file mode 100644 index 0000000..af8f23b --- /dev/null +++ b/shaders/precip.frag @@ -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); +} diff --git a/shaders/precip.vert b/shaders/precip.vert new file mode 100644 index 0000000..b58fb9b --- /dev/null +++ b/shaders/precip.vert @@ -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); +} diff --git a/shaders/terrain.frag b/shaders/terrain.frag new file mode 100644 index 0000000..7417fa1 --- /dev/null +++ b/shaders/terrain.frag @@ -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); +} diff --git a/shaders/terrain.vert b/shaders/terrain.vert new file mode 100644 index 0000000..7f2f968 --- /dev/null +++ b/shaders/terrain.vert @@ -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; +} diff --git a/shaders/triangle.frag b/shaders/triangle.frag new file mode 100644 index 0000000..bb8c479 --- /dev/null +++ b/shaders/triangle.frag @@ -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); +} diff --git a/shaders/triangle.vert b/shaders/triangle.vert new file mode 100644 index 0000000..69af785 --- /dev/null +++ b/shaders/triangle.vert @@ -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]; +} diff --git a/src/assets/DetailNoise.cpp b/src/assets/DetailNoise.cpp new file mode 100644 index 0000000..ae90caa --- /dev/null +++ b/src/assets/DetailNoise.cpp @@ -0,0 +1,113 @@ +#include "assets/DetailNoise.hpp" + +#include +#include +#include +#include + +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(h & 0x00ffffffu) / 16777215.0f; +} + +unsigned char toByte(float v) { + return static_cast(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 level(static_cast(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(x) + 0.5f) / static_cast(texelsPerCell); + const float v = (static_cast(y) + 0.5f) / static_cast(texelsPerCell); + const uint32_t i = static_cast(std::floor(u)); + const uint32_t j = static_cast(std::floor(v)); + const float fx = u - static_cast(i); + const float fy = v - static_cast(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(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 current = std::move(level); + for (;;) { + TextureMipLevel mip; + mip.width = w; + mip.height = w; + mip.offset = data.pixels.size(); + mip.size = static_cast(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 next(static_cast(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(yy) * w + xx) * 4 + ch]; + }; + next[(static_cast(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 diff --git a/src/assets/DetailNoise.hpp b/src/assets/DetailNoise.hpp new file mode 100644 index 0000000..6ebe132 --- /dev/null +++ b/src/assets/DetailNoise.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include "assets/TextureFile.hpp" + +#include + +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 diff --git a/src/assets/Heightmap.cpp b/src/assets/Heightmap.cpp new file mode 100644 index 0000000..d091c75 --- /dev/null +++ b/src/assets/Heightmap.cpp @@ -0,0 +1,297 @@ +#include "assets/Heightmap.hpp" + +#include "core/Logger.hpp" + +#include +#include +#include +#include + +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(static_cast(x)) * 0x9E3779B1u; + h ^= static_cast(static_cast(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(h & 0x00FFFFFFu) / static_cast(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(fx); + const int64_t iz = static_cast(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(res - 1); + halfSize_ = params_.worldSize * 0.5f; + + heights_.resize(static_cast(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(iz) / static_cast(res - 1); + + for (uint32_t ix = 0; ix < res; ++ix) { + const float u = static_cast(ix) / static_cast(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(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 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(resolution) * static_cast(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(resolution - 1); + spacing_ = spacing; + halfSize_ = params_.worldSize * 0.5f; + + finalize(); +} + +void Heightmap::finalize() { + minHeight_ = std::numeric_limits::max(); + maxHeight_ = std::numeric_limits::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(params_.resolution) - 1; + const int64_t cx = std::clamp(ix, static_cast(0), last); + const int64_t cz = std::clamp(iz, static_cast(0), last); + return heights_[static_cast(cz) * params_.resolution + + static_cast(cx)]; +} + +float Heightmap::worldCoord(uint32_t index) const { + return -halfSize_ + static_cast(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(worldX + halfSize_); } + if (north) { *north = geo_.originNorth - static_cast(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(east - geo_.originEast) - halfSize_; + } + if (worldZ) { + *worldZ = static_cast(geo_.originNorth - north) - halfSize_; + } +} + +float Heightmap::heightAt(float worldX, float worldZ) const { + const float last = static_cast(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(fx); + const int64_t iz = static_cast(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 diff --git a/src/assets/Heightmap.hpp b/src/assets/Heightmap.hpp new file mode 100644 index 0000000..787dd21 --- /dev/null +++ b/src/assets/Heightmap.hpp @@ -0,0 +1,192 @@ +#pragma once + +#include "core/HeightSampler.hpp" + +#include +#include +#include + +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 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 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 diff --git a/src/assets/ObjLoader.cpp b/src/assets/ObjLoader.cpp new file mode 100644 index 0000000..bef10e8 --- /dev/null +++ b/src/assets/ObjLoader.cpp @@ -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 + +#include +#include +#include +#include +#include +#include +#include + +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(key.position); + h = (h + static_cast(key.uv)) * kMix; + h = (h + static_cast(key.normal)) * kMix; + return static_cast(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 shapes; + std::vector 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 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(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(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(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(mesh.vertices.size())); + + if (inserted) { + Vertex vertex{}; + const std::size_t v = static_cast(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(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(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::max()); + glm::vec3 maxBounds(std::numeric_limits::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 diff --git a/src/assets/ObjLoader.hpp b/src/assets/ObjLoader.hpp new file mode 100644 index 0000000..85e0348 --- /dev/null +++ b/src/assets/ObjLoader.hpp @@ -0,0 +1,28 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +#include + +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 diff --git a/src/assets/TerrainFile.cpp b/src/assets/TerrainFile.cpp new file mode 100644 index 0000000..eeaca7f --- /dev/null +++ b/src/assets/TerrainFile.cpp @@ -0,0 +1,176 @@ +#include "assets/TerrainFile.hpp" + +#include "core/Logger.hpp" + +#include +#include +#include +#include +#include +#include +#include + +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 +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(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(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(header, 8); + const uint32_t samplesZ = readField(header, 12); + const float spacing = readField(header, 16); + const double originE = readField(header, 24); + const double originN = readField(header, 32); + const float headerMin = readField(header, 40); + const float headerMax = readField(header, 44); + const uint32_t epsg = readField(header, 48); + const uint32_t flags = readField(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(samplesX) * static_cast(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(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 heights(count); + file.seekg(static_cast(kHeaderSize), std::ios::beg); + if (!file.read(reinterpret_cast(heights.data()), + static_cast(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(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 diff --git a/src/assets/TerrainFile.hpp b/src/assets/TerrainFile.hpp new file mode 100644 index 0000000..76cdd24 --- /dev/null +++ b/src/assets/TerrainFile.hpp @@ -0,0 +1,50 @@ +#pragma once + +#include "assets/Heightmap.hpp" + +#include + +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 diff --git a/src/assets/TextureFile.cpp b/src/assets/TextureFile.cpp new file mode 100644 index 0000000..09b6faa --- /dev/null +++ b/src/assets/TextureFile.cpp @@ -0,0 +1,167 @@ +#include "assets/TextureFile.hpp" + +#include "core/Logger.hpp" + +#include +#include +#include +#include + +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 +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(width) * height * 4u; +} + +double TextureData::metresPerTexel() const { + if (width == 0 || height == 0) { + return 0.0; + } + const double perX = (eastMax - eastMin) / static_cast(width); + const double perY = (northMax - northMin) / static_cast(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(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(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(header, 8); + texture.height = readField(header, 12); + const uint32_t mipLevels = readField(header, 16); + const uint32_t rawFormat = readField(header, 20); + texture.eastMin = readField(header, 24); + texture.northMin = readField(header, 32); + texture.eastMax = readField(header, 40); + texture.northMax = readField(header, 48); + texture.epsg = readField(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(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(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(kHeaderSize) + total; + if (fileSize < 0 || static_cast(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(kHeaderSize), std::ios::beg); + texture.pixels.resize(static_cast(total)); + if (!file.read(reinterpret_cast(texture.pixels.data()), + static_cast(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 diff --git a/src/assets/TextureFile.hpp b/src/assets/TextureFile.hpp new file mode 100644 index 0000000..56cd911 --- /dev/null +++ b/src/assets/TextureFile.hpp @@ -0,0 +1,73 @@ +#pragma once + +#include +#include +#include + +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 mips; + std::vector 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 diff --git a/src/core/Camera.cpp b/src/core/Camera.cpp new file mode 100644 index 0000000..f098b88 --- /dev/null +++ b/src/core/Camera.cpp @@ -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 + +#include +#include + +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(dx) * mouseSensitivity_; + pitch_ += static_cast(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 diff --git a/src/core/Camera.hpp b/src/core/Camera.hpp new file mode 100644 index 0000000..cc10cd7 --- /dev/null +++ b/src/core/Camera.hpp @@ -0,0 +1,217 @@ +#pragma once + +#include "core/SlopeLimits.hpp" + +#include + +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 diff --git a/src/core/CollisionSolver.hpp b/src/core/CollisionSolver.hpp new file mode 100644 index 0000000..df96dac --- /dev/null +++ b/src/core/CollisionSolver.hpp @@ -0,0 +1,94 @@ +#pragma once + +#include + +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 diff --git a/src/core/CompositeCollisionSolver.hpp b/src/core/CompositeCollisionSolver.hpp new file mode 100644 index 0000000..549b2d2 --- /dev/null +++ b/src/core/CompositeCollisionSolver.hpp @@ -0,0 +1,73 @@ +#pragma once + +#include "core/CollisionSolver.hpp" + +#include + +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 solvers_; // non possedes +}; + +} // namespace vercora diff --git a/src/core/FpsCounter.hpp b/src/core/FpsCounter.hpp new file mode 100644 index 0000000..8b583c5 --- /dev/null +++ b/src/core/FpsCounter.hpp @@ -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(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 diff --git a/src/core/Frustum.hpp b/src/core/Frustum.hpp new file mode 100644 index 0000000..bf2b006 --- /dev/null +++ b/src/core/Frustum.hpp @@ -0,0 +1,95 @@ +#pragma once + +#include + +#include + +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 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 diff --git a/src/core/HeightSampler.hpp b/src/core/HeightSampler.hpp new file mode 100644 index 0000000..8357519 --- /dev/null +++ b/src/core/HeightSampler.hpp @@ -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 diff --git a/src/core/Logger.hpp b/src/core/Logger.hpp new file mode 100644 index 0000000..2fae5e3 --- /dev/null +++ b/src/core/Logger.hpp @@ -0,0 +1,28 @@ +#pragma once + +#include +#include +#include + +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 diff --git a/src/core/Paths.cpp b/src/core/Paths.cpp new file mode 100644 index 0000000..eb7947e --- /dev/null +++ b/src/core/Paths.cpp @@ -0,0 +1,83 @@ +#include "core/Paths.hpp" + +#include + +#ifdef _WIN32 +# define WIN32_LEAN_AND_MEAN +# include +#else +# include +#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(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 diff --git a/src/core/Paths.hpp b/src/core/Paths.hpp new file mode 100644 index 0000000..c82f7cb --- /dev/null +++ b/src/core/Paths.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include + +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 diff --git a/src/core/SlopeLimits.hpp b/src/core/SlopeLimits.hpp new file mode 100644 index 0000000..c9ecf8f --- /dev/null +++ b/src/core/SlopeLimits.hpp @@ -0,0 +1,229 @@ +#pragma once + +#include "core/HeightSampler.hpp" + +#include + +#include +#include + +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 diff --git a/src/core/TerrainRay.hpp b/src/core/TerrainRay.hpp new file mode 100644 index 0000000..dacc155 --- /dev/null +++ b/src/core/TerrainRay.hpp @@ -0,0 +1,169 @@ +#pragma once + +#include "core/HeightSampler.hpp" + +#include + +#include +#include + +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 diff --git a/src/core/Window.cpp b/src/core/Window.cpp new file mode 100644 index 0000000..9643f29 --- /dev/null +++ b/src/core/Window.cpp @@ -0,0 +1,95 @@ +#include "core/Window.hpp" + +#include + +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(glfwGetWindowUserPointer(window)); + if (self != nullptr) { + self->framebufferResized_ = true; + } +} + +void Window::scrollCallback(GLFWwindow* window, double /*xOffset*/, double yOffset) { + auto* self = static_cast(glfwGetWindowUserPointer(window)); + if (self != nullptr) { + self->scrollAccumulator_ += yOffset; + } +} + +} // namespace vercora diff --git a/src/core/Window.hpp b/src/core/Window.hpp new file mode 100644 index 0000000..65cdab3 --- /dev/null +++ b/src/core/Window.hpp @@ -0,0 +1,69 @@ +#pragma once + +// GLFW_INCLUDE_VULKAN est defini par CMake : GLFW tire alors les headers Vulkan. +#include + +#include + +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 diff --git a/src/editor/AssetCatalog.cpp b/src/editor/AssetCatalog.cpp new file mode 100644 index 0000000..27d1e96 --- /dev/null +++ b/src/editor/AssetCatalog.cpp @@ -0,0 +1,240 @@ +#include "editor/AssetCatalog.hpp" + +#include "assets/ObjLoader.hpp" +#include "core/Logger.hpp" +#include "editor/EditorAssets.hpp" + +#include +#include +#include +#include +#include +#include +#include + +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(std::tolower(static_cast(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(std::tolower(c))); + } else if (c == '_' || c == '-' || c == '.') { + result.push_back(static_cast(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::max()); + glm::vec3 maxCorner(std::numeric_limits::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::max()); + glm::vec3 maxCorner(std::numeric_limits::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& 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 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 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(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(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 diff --git a/src/editor/AssetCatalog.hpp b/src/editor/AssetCatalog.hpp new file mode 100644 index 0000000..235c959 --- /dev/null +++ b/src/editor/AssetCatalog.hpp @@ -0,0 +1,143 @@ +#pragma once + +#include "renderer/DrawItem.hpp" // MeshHandle / kInvalidMesh +#include "renderer/MeshData.hpp" + +#include +#include +#include + +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& supportedExtensions(); + + const std::vector& entries() const { return entries_; } + std::vector& 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 entries_; +}; + +} // namespace vercora diff --git a/src/editor/EditorAssets.cpp b/src/editor/EditorAssets.cpp new file mode 100644 index 0000000..5f61706 --- /dev/null +++ b/src/editor/EditorAssets.cpp @@ -0,0 +1,348 @@ +#include "editor/EditorAssets.hpp" + +#include + +#include +#include +#include +#include +#include +#include + +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(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(h) * (1.0f / 4294967296.0f); +} + +// --- Sphere subdivisee (base des rochers) ----------------------------------- +using EdgeKey = std::pair; + +uint32_t midpointIndex(std::vector& points, std::map& 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(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 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> 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 cache; + std::vector> 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 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& 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 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 diff --git a/src/editor/EditorAssets.hpp b/src/editor/EditorAssets.hpp new file mode 100644 index 0000000..421d8b5 --- /dev/null +++ b/src/editor/EditorAssets.hpp @@ -0,0 +1,111 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +#include +#include +#include + +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& 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 diff --git a/src/editor/EditorController.cpp b/src/editor/EditorController.cpp new file mode 100644 index 0000000..48f4239 --- /dev/null +++ b/src/editor/EditorController.cpp @@ -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 +#include +#include + +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(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(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(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(index)].id; + logInfo("Editeur : selection de l'objet " + std::to_string(selectedId_) + + " (" + objects[static_cast(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(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(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 diff --git a/src/editor/EditorController.hpp b/src/editor/EditorController.hpp new file mode 100644 index 0000000..3de4703 --- /dev/null +++ b/src/editor/EditorController.hpp @@ -0,0 +1,250 @@ +#pragma once + +#include "editor/PlacedObject.hpp" + +#include +#include + +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 diff --git a/src/editor/EditorScene.cpp b/src/editor/EditorScene.cpp new file mode 100644 index 0000000..6f48ffb --- /dev/null +++ b/src/editor/EditorScene.cpp @@ -0,0 +1,319 @@ +#include "editor/EditorScene.hpp" + +#include "editor/AssetCatalog.hpp" + +#include +#include + +namespace vercora { + +const PlacedObject* EditorScene::find(uint32_t id) const { + const int index = indexOf(id); + return index < 0 ? nullptr : &objects_[static_cast(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(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(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(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(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(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(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 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(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 diff --git a/src/editor/EditorScene.hpp b/src/editor/EditorScene.hpp new file mode 100644 index 0000000..64cf158 --- /dev/null +++ b/src/editor/EditorScene.hpp @@ -0,0 +1,165 @@ +#pragma once + +#include "core/CollisionSolver.hpp" +#include "editor/PlacedObject.hpp" + +#include +#include +#include + +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& 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 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 objects_; + std::vector undoStack_; + uint32_t nextId_ = 1; + float transformGroupSeconds_ = 0.75f; +}; + +} // namespace vercora diff --git a/src/editor/PlacedObject.hpp b/src/editor/PlacedObject.hpp new file mode 100644 index 0000000..3e5d120 --- /dev/null +++ b/src/editor/PlacedObject.hpp @@ -0,0 +1,83 @@ +#pragma once + +#include +#include + +#include +#include + +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 diff --git a/src/editor/SceneFile.cpp b/src/editor/SceneFile.cpp new file mode 100644 index 0000000..16f3c39 --- /dev/null +++ b/src/editor/SceneFile.cpp @@ -0,0 +1,288 @@ +#include "editor/SceneFile.hpp" + +#include "assets/Heightmap.hpp" +#include "core/Logger.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +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(first); + object.position.z = static_cast(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& 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 " + << (georeferenced ? " " : " ") + << " \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 diff --git a/src/editor/SceneFile.hpp b/src/editor/SceneFile.hpp new file mode 100644 index 0000000..037b206 --- /dev/null +++ b/src/editor/SceneFile.hpp @@ -0,0 +1,140 @@ +#pragma once + +#include "editor/PlacedObject.hpp" + +#include +#include +#include + +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 obligatoire, en premier. 1 pour cette session. +// terrain 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 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 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& 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 diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..59e562e --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,3971 @@ +#include "assets/Heightmap.hpp" +#include "assets/ObjLoader.hpp" +#include "assets/TerrainFile.hpp" +#include "assets/TextureFile.hpp" +#include "core/Camera.hpp" +#include "core/Frustum.hpp" +#include "core/FpsCounter.hpp" +#include "core/Logger.hpp" +#include "core/CompositeCollisionSolver.hpp" +#include "core/Window.hpp" +#include "editor/AssetCatalog.hpp" +#include "editor/EditorController.hpp" +#include "core/Paths.hpp" +#include "editor/EditorScene.hpp" +#include "editor/PlacedObject.hpp" +#include "editor/SceneFile.hpp" +#include "renderer/CubeMesh.hpp" +#include "renderer/DrawItem.hpp" +#include "renderer/MeshData.hpp" +#include "renderer/Renderer.hpp" +#include "renderer/TerrainMesh.hpp" +#include "renderer/TerrainStreamer.hpp" +#include "renderer/VulkanContext.hpp" +#include "world/AnimalMesh.hpp" +#include "world/Forest.hpp" +#include "world/Habitat.hpp" +#include "world/GrassMesh.hpp" +#include "world/Ground.hpp" +#include "world/GroundItem.hpp" +#include "world/Inventory.hpp" +#include "world/Knapping.hpp" +#include "world/Crafting.hpp" +#include "world/CraftMesh.hpp" +#include "world/Bike.hpp" +#include "world/Climber.hpp" +#include "world/Needs.hpp" +#include "world/Weather.hpp" +#include "world/WaterSource.hpp" +#include "world/Deposits.hpp" +#include "world/FiberPlants.hpp" +#include "world/RockMesh.hpp" +#include "world/Rocks.hpp" +#include "world/BushMesh.hpp" +#include "world/Bushes.hpp" +#include "world/HarvestMesh.hpp" +#include "world/Resin.hpp" +#include "world/Paraglider.hpp" +#include "world/StoneMesh.hpp" +#include "world/Tree.hpp" +#include "world/TreeMesh.hpp" +#include "world/Vegetation.hpp" +#include "world/Wildlife.hpp" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace vercora; + +namespace { + +// --------------------------------------------------------------------------- +// Scene affichee : le seul endroit a changer pour tester autre chose. +// --------------------------------------------------------------------------- +// Sans argument, on affiche la dalle LiDAR HD REELLE (Phase 7), peuplee des +// arbres de la Phase 5 et des pierres de la Phase 6. Les scenes des phases +// precedentes restent accessibles sans recompiler : +// vercora.exe -> dalle LiDAR reelle (defaut) +// vercora.exe terrain -> terrain synthetique (Phase 4) +// vercora.exe chemin\vers\dalle.vchm -> une autre heightmap reelle +// vercora.exe cube -> cube code en dur (Phase 1) +// vercora.exe chemin\vers\modele.obj -> mesh charge depuis un fichier +// +// Plus un mode outil, qui n'ouvre aucune fenetre (voir dumpWorld plus bas) : +// vercora.exe --dump-world [scene] -> imprime le monde seme, puis sort +// +// Plus une option de comparaison, ajoutee en Phase 10 : +// vercora.exe [scene] --no-lod -> terrain d'un SEUL bloc, sans +// quadtree, LOD ni culling : le +// comportement exact de la Phase 9. +// Elle n'existe que pour mesurer l'avant/apres sur la meme scene et la meme +// position de camera. Sans elle, toute scene de terrain passe par le quadtree. +// +// Plus trois options de la Phase 12, autour du streaming des tuiles : +// vercora.exe [scene] --no-tile-fallback -> pas de repli sur l'ancetre : une +// tuile pas encore construite +// laisse un TROU (comportement de +// la Phase 10). +// vercora.exe [scene] --tile-budget=N -> N tuiles construites au plus par +// frame (defaut 64 ; 4 reproduit +// le plafond de la Phase 10). +// vercora.exe [scene] --tile-threads=N -> degre de parallelisme du MAILLAGE +// CPU des tuiles, thread de rendu +// compris (defaut 4). 1 remet ce +// maillage entierement sequentiel, +// c'est-a-dire dans l'etat d'avant +// la Phase 19 : c'est le TEMOIN de +// la parallelisation. Aucun appel +// Vulkan ne change de thread quelle +// que soit la valeur. +// vercora.exe [scene] --flythrough=V[,H] -> survol SCRIPTE : la camera avance +// toute seule a V m/s, H metres +// au-dessus du relief (defaut 120), +// et tourne de 90 deg en arrivant +// au bord de l'emprise. +// Les trois servent au meme controle : reproduire, mesurer et comparer le cas +// qui produisait des trous a l'horizon en deplacement rapide, sans recompiler +// entre les deux moities de la comparaison. +// +// Plus quatre options de la Phase 15, autour de l'EDITEUR DE NIVEAU : +// vercora.exe [scene] --editor -> demarre directement en mode +// edition (sinon la touche F2) +// vercora.exe [scene] --scene=chemin.vcsc -> fichier de scene explicite, au +// lieu de la convention +// assets/scenes/.vcsc +// vercora.exe [scene] --no-scene -> ni catalogue, ni objets poses, +// ni mode editeur : le +// comportement exact d'avant la +// Phase 15, garde pour la +// comparaison et la mesure +// vercora.exe [scene] --editor-assets=rep -> dossier de modeles a scanner, +// au lieu de assets/editor +// Le mode editeur est un outil de DEVELOPPEMENT : il n'a pas d'interface +// graphique, sa liste d'assets et son etat s'affichent dans le journal. Les +// objets poses, eux, font partie du monde et sont affiches et solides dans le +// jeu normal - c'est justement le point. +// +// Le terrain synthetique n'est PAS supprime, et pour deux raisons distinctes : +// il reste la scene de reference des tests (monde deterministe, arbres a +// positions connues, cf. dumpWorld plus bas), et il sert de repli si le +// fichier de dalle est absent - le depot ne versionne pas les 4 Mo de la +// heightmap, encore moins les 167 Mo du .laz d'origine. +// +// ASSETS_DIR est defini par CMake et pointe sur le dossier assets/ a la racine +// du projet : l'executable trouve donc ses assets quel que soit le repertoire +// courant depuis lequel on le lance. +constexpr const char* kProceduralKeyword = "terrain"; +constexpr const char* kBuiltinCubeKeyword = "cube"; + +// Dalle chargee par defaut. Produite par : +// 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 +// Voir NOTES-PHASE7.md pour la provenance de la dalle et le detail du choix de +// resolution. +// PHASE 21 : le prefixe n'est plus la macro ASSETS_DIR mais assetsDir(), qui +// prefere le dossier assets\ pose a cote de l'executable quand il existe. Sur +// cette machine, rien ne change ; dans le package distribue, tout en depend. +// Voir core/Paths.hpp. +const std::string kDefaultTerrainFile = assetsDir() + "/terrain/LHD_0907_6440_1m.vchm"; + +// PHASE 21 : la dalle chargee par defaut EN MODE DEMO (--demo). La demo montre +// la zone de 25 km2 - c'est tout son propos - alors que le defaut de +// developpement reste la dalle unique de la Phase 7, qui charge en une seconde. +// Produite par tools/assemble_terrain.py, voir NOTES-PHASE9.md. +const std::string kDemoTerrainFile = assetsDir() + "/terrain/vercora_zone_1m.vchm"; + +// Repli du mode demo si la dalle 1 m est absente du package : meme zone, pas de +// 2 m, quatre fois plus legere (25 Mo contre 100). Voir NOTES-PHASE21.md. +const std::string kDemoTerrainFallback = assetsDir() + "/terrain/vercora_zone_2m.vchm"; + +// Portee de la visee, en unites monde (= metres). Au-dela, on considere que le +// joueur ne peut pas atteindre l'arbre avec un outil a main. +constexpr float kFellingReach = 40.0f; + +// Portee du ramassage, mesuree a l'horizontale. Un peu plus qu'un bras tendu : +// il faut pouvoir attraper une buche sans se placer au centimetre pres. +constexpr float kPickupReach = 2.5f; + +// Nombre de pierres semees. Il en faut DEUX pour percuter, mais n'en semer que +// deux obligerait a quadriller la carte pour trouver la seconde. Six laisse une +// chance raisonnable d'en croiser deux en explorant, sans transformer la +// montagne en carriere. +constexpr uint32_t kStoneCount = 6; + +// Touches d'action. GLFW raisonne en POSITIONS PHYSIQUES facon QWERTY US : sur +// un clavier AZERTY francais, ces trois tokens tombent bien sur les touches +// gravees E, R et C (contrairement a W/A qui, eux, donnent Z/Q - voir Camera). +constexpr int kFellKey = GLFW_KEY_E; // abattre l'arbre vise +constexpr int kPickupKey = GLFW_KEY_R; // ramasser l'objet au sol le plus proche +constexpr int kKnapKey = GLFW_KEY_C; // percuter deux pierres ; PHASE 28 : faconner (toutes recettes) +// PHASE 28. Reposer au sol un objet porte (le dernier ramasse s'il en reste). +// P comme "poser" ; P occupe la MEME position physique en AZERTY et en QWERTY +// (rangee du haut ...-O-P), comme E/R/T/Y/U/I. "R maintenu", propose par le +// document de conception, aurait heurte le ramassage, declenche a l'APPUI. +constexpr int kPutDownKey = GLFW_KEY_P; +constexpr int kParaglideKey = GLFW_KEY_V; // decoller/atterrir en parapente + +// PHASE 13. Monter sur le velo / en descendre. +// +// Choix de la touche : B comme "bike"/"velo", et surtout B est l'une des rares +// lettres qui occupe la MEME position physique en AZERTY et en QWERTY (rangee du +// bas : W-X-C-V-B en AZERTY, Z-X-C-V-B en QWERTY). Le token GLFW_KEY_B tombe +// donc sur la touche gravee B des deux cotes, sans le decalage qui touche W/A - +// voir la note clavier de core/Camera.hpp. Elle est aussi juste a cote de V, la +// touche du parapente : les deux activites montees se declenchent du meme doigt. +constexpr int kBikeKey = GLFW_KEY_B; // enfourcher le velo / en descendre + +// PHASE 14. S'engager sur une paroi / lacher. +// +// Meme raisonnement que pour B : X occupe la MEME position physique en AZERTY et +// en QWERTY (rangee du bas W-X-C-V-B / Z-X-C-V-B), donc le token GLFW_KEY_X +// tombe sur la touche gravee X des deux cotes. Les quatre activites et les deux +// actions d'outillage occupent ainsi une seule rangee contigue sous la main +// gauche : X escalade, C percussion, V parapente, B velo. +// PHASE 25. Intensite MAITRESSE de l'indice visuel adret/ubac, dans [0, 1]. +// +// 1,0 = les teintes de shaders/terrain.frag sont appliquees en plein, ce qui +// represente au plus 7 % par canal et environ 13 % d'ecart total entre un adret +// et un ubac vus cote a cote. C'est le reglage retenu : en dessous, l'indice +// cesse d'etre perceptible sur une orthophoto, ce qui lui ferait manquer sa +// seule raison d'etre. +// +// Nommee ici plutot qu'ecrite en dur dans l'appel : c'est le seul bouton a +// tourner si l'effet devait etre juge trop marque, et il doit se trouver sans +// lire le shader. +constexpr float kAspectTintIntensity = 1.0f; + +// PHASE 27, chantier 3 : micro-relief du sol vu de pres. Voir shaders/ +// terrain.frag et NOTES-PHASE27.md. Force a 1 = pentes de grain de 0,6 et +// couleur +/- 18 % sur le sol le plus rugueux (plancher de 35 % sur le sol +// lisse). Le motif de base est le texel de l'orthophoto quand il est connu, +// 0,61 m sinon. +constexpr float kGroundDetailStrength = 1.0f; +constexpr float kGroundDetailFadeStart = 5.0f; +constexpr float kGroundDetailFadeEnd = 20.0f; +constexpr float kGroundDetailDefaultPattern = 0.61f; + +// Valeur de WeatherParams::aspectIncidenceReference que shaders/terrain.frag +// code en dur (kAspectIncidenceReference). Un shader ne peut pas lire un +// parametre C++ : la seule protection contre une divergence est de la rendre +// BRUYANTE. Verifiee une fois au demarrage. +constexpr float kShaderAspectIncidenceReference = 0.35f; + +constexpr int kClimbKey = GLFW_KEY_X; // s'engager sur une paroi / lacher + +// PHASE 16. Boire au point d'eau le plus proche. +// +// Meme raisonnement de clavier que pour B et X : la rangee du haut est +// A-Z-E-R-T-Y en AZERTY et Q-W-E-R-T-Y en QWERTY, donc E, R, T et Y y occupent +// la MEME position physique des deux cotes. Le token GLFW_KEY_T tombe sur la +// touche gravee T partout, et elle est voisine de R (ramasser) : les deux +// gestes qui consomment le monde sont sous le meme doigt. +constexpr int kDrinkKey = GLFW_KEY_T; // boire au point d'eau + +// PHASE 22. Les trois gestes de recolte ajoutes par cette phase. +// +// MEME raisonnement de clavier que pour B, X et T, et il finit de se payer ici : +// la rangee 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, donc TOUT ce qui suit le Z/W y occupe la meme position physique. Les +// six gestes du joueur SUR LE MONDE tiennent donc desormais dans une seule +// rangee contigue, dans l'ordre ou on les apprend : +// +// E abattre R ramasser T boire Y creuser U saigner I arracher +// +// Ce n'est pas une coquetterie : c'est ce qui evite d'aller chercher des lettres +// decalees entre les deux dispositions (le piege qui avait fait croire pendant +// tout un run que le jeu ignorait W - voir la note clavier de core/Camera.hpp). +constexpr int kDigKey = GLFW_KEY_Y; // creuser un gisement d'argile ou de sable +constexpr int kResinKey = GLFW_KEY_U; // saigner le resineux vise, SANS l'abattre +constexpr int kFiberKey = GLFW_KEY_I; // arracher la plante a fibres a ses pieds + +// Vitesse de marche de reference, en m/s. Nommee depuis la Phase 16 parce que +// la vitesse effective en est desormais une FRACTION (voir Needs::movementFactor) +// et qu'elle est reappliquee a chaque image : la valeur de reference ne peut +// donc plus vivre en dur dans l'appel a setMoveSpeed. +constexpr float kWalkSpeed = 14.0f; + +// En dessous de cette vitesse horizontale (m/s), un joueur A PIED est considere +// immobile, donc AU REPOS - le seul etat qui refait la forme. Elle est lue sur +// le deplacement reel de la camera entre deux images et non sur les touches : +// un joueur qui pousse contre un rocher tient sa touche mais n'avance pas, et +// il ne doit pas recuperer pour autant. 0,20 m/s, soit 1,4 % de kWalkSpeed : +// assez bas pour qu'un arret soit franc, assez haut pour absorber le residu +// numerique d'une camera collee a un obstacle. +constexpr float kRestSpeedThreshold = 0.20f; +constexpr int kOrthoKey = GLFW_KEY_O; // orthophoto <-> coloration procedurale +constexpr int kVegetationKey = GLFW_KEY_G; // vegetation de decor : tout / arbres / rien + +// --------------------------------------------------------------------------- +// PHASE 15 : les touches du MODE EDITEUR +// --------------------------------------------------------------------------- +// Elles ne sont lues QUE dans ce mode, et le mode desactive en retour toutes les +// touches de jeu (abattage, ramassage, percussion, les quatre activites, la +// bascule de vegetation). Les deux jeux de touches ne se marchent donc jamais +// dessus, ce qui laisse le champ libre pour reprendre ici des lettres deja +// prises ailleurs - E designe un arbre a abattre en jeu et selectionne un objet +// en edition, sans ambiguite possible. +// +// CHOIX DES TOUCHES. Le jeu doit rester utilisable en AZERTY comme en QWERTY, et +// GLFW raisonne en positions physiques facon QWERTY US (voir la note clavier de +// core/Camera.hpp). Les touches de reglage sont donc prises parmi celles qui +// occupent la MEME position physique sur les deux dispositions : les fleches, +// le pave de navigation (Inser/Suppr/Debut/Fin/Page), la rangee de fonctions, +// Tab, Retour arriere, Echap et la rangee des chiffres. Les seules lettres +// utilisees - E, G, K - sont a la meme place sur les deux. +constexpr int kEditorToggleKey = GLFW_KEY_F2; // entrer / sortir du mode edition + +// Equivalent CLAVIER du clic gauche : poser l'objet arme / reposer l'objet en +// main. Deux raisons, la seconde etant decisive : +// - a l'usage, on regle le cap et l'echelle aux fleches puis on pose, sans +// avoir a ramener la main sur la souris ; +// - le harnais automatise ne peut piloter que le CLAVIER. Il pilote la fenetre +// par PostMessage, or GLFW lit la position du curseur avec GetCursorPos(), +// c'est-a-dire la souris SYSTEME - un WM_MOUSEMOVE poste n'a aucun effet +// (voir l'en-tete de tools/run_vulkan_check.ps1). Sans cette touche, la pose +// d'objet serait la seule fonction de l'editeur qu'aucun test ne pourrait +// exercer sous Vulkan. +constexpr int kEditorPlaceKey = GLFW_KEY_INSERT; // poser (equivalent du clic) +constexpr int kEditorPickKey = GLFW_KEY_E; // selectionner l'objet vise +constexpr int kEditorGrabKey = GLFW_KEY_G; // saisir / reposer +constexpr int kEditorSolidKey = GLFW_KEY_K; // solide <-> traversable +constexpr int kEditorDeleteKey = GLFW_KEY_DELETE; // supprimer la selection +constexpr int kEditorCancelKey = GLFW_KEY_ESCAPE; // abandonner saisie/selection +constexpr int kEditorNextKey = GLFW_KEY_TAB; // asset suivant +constexpr int kEditorNextKey2 = GLFW_KEY_PAGE_DOWN; // idem, sous la main droite +constexpr int kEditorPrevKey = GLFW_KEY_PAGE_UP; // asset precedent +constexpr int kEditorUndoKey = GLFW_KEY_BACKSPACE; // annuler la derniere action +constexpr int kEditorSaveKey = GLFW_KEY_F5; // ecrire le fichier de scene +constexpr int kEditorReloadKey = GLFW_KEY_F9; // relire le fichier de scene +constexpr int kEditorListKey = GLFW_KEY_L; // reafficher catalogue + etat +constexpr int kEditorFineKey = GLFW_KEY_LEFT_CONTROL; // pas fin sur les reglages + +// Selectionner l'objet POSE suivant/precedent sans viser (ergonomie ajoutee +// apres la session initiale de la Phase 15, voir NOTES-PHASE15.md ss13). +// F3/F4 : libres, memes touches physiques en AZERTY et QWERTY (rangee de +// fonctions), et adjacentes a F2/F5 deja pris par l'editeur. +constexpr int kEditorCycleNextKey = GLFW_KEY_F3; +constexpr int kEditorCyclePrevKey = GLFW_KEY_F4; + +// Vitesse de vol du mode editeur, en m/s, et ses bornes. +// +// 60 m/s par defaut : la zone fait 5 km de cote, donc une traversee complete +// prend ~83 s - assez rapide pour aller voir l'autre versant, assez lent pour +// poser quelque chose sans depasser. La molette la multiplie ou la divise, ce +// qui est le seul reglage vraiment necessaire : on alterne sans arret entre +// survol de reconnaissance et placement au metre pres. +constexpr float kEditorFlySpeed = 60.0f; +constexpr float kEditorFlySpeedMin = 2.0f; +constexpr float kEditorFlySpeedMax = 600.0f; +constexpr float kEditorFlySpeedStep = 1.25f; // par cran de molette + +// Teintes de temoin, au format attendu par DrawItem::params pour le materiau +// Object : (force, rouge, vert, bleu). Voir shaders/cube.frag. +// +// Cyan pour le fantome, ambre pour la selection : deux couleurs qu'aucun asset +// de cette session ne porte (ils sont tous gris, bruns ou ocres) et que le +// terrain ne porte pas non plus. Une teinte verte se serait confondue avec la +// vegetation, une teinte grise avec le rocher. +const glm::vec4 kGhostTint{0.55f, 0.25f, 0.85f, 0.95f}; +const glm::vec4 kSelectionTint{0.55f, 1.00f, 0.62f, 0.15f}; + +// Dossier scanne au demarrage de l'editeur, et dossier ou sont rangees les +// scenes. Tous deux sous assets/, donc VERSIONNES (contrairement a data/, que le +// .gitignore exclut) : une scene composee a la main est du contenu, au meme +// titre qu'un modele - la perdre couterait le temps de la refaire, alors qu'une +// heightmap se regenere en quatre secondes depuis le .laz. +const std::string kEditorAssetsDir = assetsDir() + "/editor"; +const std::string kScenesDir = assetsDir() + "/scenes"; + +// Hauteur minimale au-dessus du terrain pour pouvoir decoller (unites monde = +// metres), verifiee EN MODE LIBRE. Sans ce seuil, "decoller" depuis un sol plat +// n'aurait aucun sens ; l'exiger evite aussi un vol qui commence deja pose (la +// toute premiere frame de checkLanding le terminerait aussitot). +constexpr float kMinLaunchHeightAboveTerrain = 5.0f; + +// Distance et hauteur de la camera derriere le pilote en vol (chase-cam), en +// unites monde. Assez loin pour voir le pilote ET le relief qui vient, assez +// pres pour rester une vue a la troisieme personne lisible et non un plan large. +constexpr float kGlideChaseDistance = 6.0f; +constexpr float kGlideChaseHeight = 2.2f; + +// PHASE 13. Meme chose pour le velo, en plus rapproche : le parapente se lit a +// l'echelle du relief traverse, le velo se lit a l'echelle du sentier - il faut +// voir ou passent les roues et comment la machine s'incline, pas un panorama. +constexpr float kRideChaseDistance = 5.0f; +constexpr float kRideChaseHeight = 2.0f; + +// Garde au sol MINIMALE de la camera de poursuite du velo, en unites monde. +// +// Necessaire et pas seulement cosmetique : en descente, l'oeil recule DANS la +// pente qu'on vient de devaler, et sans ce plancher il se retrouve sous la +// surface - on voit alors l'interieur du terrain. Le parapente n'a pas ce +// probleme (il est en l'air), c'est pour ca que la contrainte n'existe qu'ici. +constexpr float kRideChaseMinClearance = 1.2f; + +// Front descendant d'une touche. +// +// Toutes les actions du jeu en ont besoin, et pour la meme raison : sans lui, +// maintenir la touche une demi-seconde declencherait l'action a chaque frame - +// soit une soixantaine d'abattages, ou l'inventaire vide d'un coup. La Phase 5 +// gerait ca avec un booleen nomme a la main par action ; les regrouper ici evite +// d'en oublier un au prochain ajout. +class KeyEdge { +public: + bool justPressed(const Window& window, int key) { + return justPressed(window.isKeyPressed(key)); + } + + // PHASE 15 : meme mecanique sur un etat DEJA LU. Le clic gauche de l'editeur + // en a besoin (il vient de isMouseButtonPressed, pas de isKeyPressed), et il + // en a besoin pour exactement la meme raison que les touches : sans front + // descendant, maintenir le bouton une demi-seconde poserait une soixantaine + // de rochers empiles au meme endroit - et soixante annulations a defaire. + bool justPressed(bool down) { + const bool edge = down && !wasDown_; + wasDown_ = down; + return edge; + } + +private: + bool wasDown_ = false; +}; + +// --------------------------------------------------------------------------- +// PHASE 14 : fin d'une escalade +// --------------------------------------------------------------------------- +// Les trois sorties d'escalade (sommet, lachage, epuisement) se produisent a +// DEUX endroits du code - la touche X pour le lachage volontaire, Climber::update +// pour les deux autres - mais elles ont exactement les memes suites : reposer le +// joueur et revenir en marche. Les regrouper ici est ce qui garantit qu'on ne +// puisse pas reparer l'une en oubliant l'autre. +// +// Climber a deja place son point d'accroche a la bonne position avant de rendre +// la main : au sommet pour ToppedOut, au pied de la paroi pour Released et +// Exhausted. Il n'y a donc PAS de choix de position a refaire ici - une seule +// reinitialisation existe, dans world/Climber, et c'est elle que les tests +// headless verifient. +// +// On passe par anchor() et non par position() : anchor() est le point SUR la +// surface, alors que position() est l'oeil du grimpeur, decale de la paroi. +// Camera::setMode(Walk) reposera la camera a la bonne hauteur d'oeil tout seul +// (snapToTerrain), donc seuls X et Z comptent vraiment. +void handleClimbExit(ClimbExit exit, const Climber& climber, Camera& camera) { + if (exit == ClimbExit::None) { + return; + } + + camera.setPosition(climber.anchor()); + camera.setMode(CameraMode::Walk); + + switch (exit) { + case ClimbExit::ToppedOut: + logInfo("Escalade : SOMMET atteint, " + + std::to_string(climber.heightGained()) + + " m gagnes. Energie restante " + + std::to_string(100.0f * climber.stamina()) + " %."); + break; + case ClimbExit::Released: + logInfo("Escalade : lachee volontairement, retour au pied de la paroi. " + "Energie restante " + + std::to_string(100.0f * climber.stamina()) + " %."); + break; + case ClimbExit::Exhausted: + logInfo("Escalade : CHUTE, energie epuisee. Retour au pied de la " + "paroi (aucun degat : hors scope de cette session)."); + break; + case ClimbExit::None: + break; + } +} + +// --------------------------------------------------------------------------- +// PHASE 11 : orthophoto +// --------------------------------------------------------------------------- +// Chemin .vcto associe par CONVENTION a un terrain .vchm : +// assets/terrain/vercora_zone_1m.vchm -> assets/terrain/vercora_zone_ortho.vcto +// Le suffixe de resolution est retire, parce qu'une meme zone photographiee une +// fois sert au terrain a 1 m comme a celui a 2 m : ce sont deux echantillonnages +// du meme relief, pas deux endroits. +std::string orthoPathFor(const std::string& terrainPath) { + std::string stem = terrainPath; + const std::size_t dot = stem.rfind('.'); + if (dot != std::string::npos) { + stem.resize(dot); + } + for (const char* suffix : { "_1m", "_2m", "_5m" }) { + const std::size_t length = std::strlen(suffix); + if (stem.size() > length && stem.compare(stem.size() - length, length, suffix) == 0) { + stem.resize(stem.size() - length); + break; + } + } + return stem + "_ortho.vcto"; +} + +// Meme convention pour les cartes de vegetation produites par +// tools/lidar_to_canopy.py : +// assets/terrain/vercora_zone_1m.vchm -> ..._canopy.vchm et ..._canopy_height.vchm +std::string canopyPathFor(const std::string& terrainPath, const std::string& suffix) { + std::string path = orthoPathFor(terrainPath); + // orthoPathFor a deja retire l'extension et le suffixe de resolution ; il ne + // reste qu'a remplacer sa terminaison. + const std::string tail = "_ortho.vcto"; + path.resize(path.size() - tail.size()); + return path + "_canopy" + suffix + ".vchm"; +} + +// Refuse une texture qui ne recouvre pas EXACTEMENT le terrain charge. +// +// C'est le controle qui manquait a la Phase 7 : sans lui, associer par megarde +// la photo d'une zone a le relief d'une autre produit un rendu parfaitement +// plausible - des couleurs de montagne sur de la montagne - que rien ne +// signale. La tolerance est d'un demi-metre, soit moins d'un texel : les deux +// emprises viennent du meme en-tete .vchm, elles doivent coincider au bit pres +// ou presque. +bool orthoMatchesTerrain(const TextureData& texture, const Heightmap& heightmap) { + if (texture.epsg != heightmap.geo().epsg) { + logWarn("Orthophoto : projection " + std::to_string(texture.epsg) + + " contre " + std::to_string(heightmap.geo().epsg) + + " pour le terrain. Texture ignoree."); + return false; + } + + const double spacing = static_cast(heightmap.spacing()); + const double span = (heightmap.resolution() - 1) * spacing; + const double eastMin = heightmap.geo().originEast; + const double northMax = heightmap.geo().originNorth; + + const double tolerance = 0.5; + const bool ok = + std::abs(texture.eastMin - eastMin) < tolerance && + std::abs(texture.eastMax - (eastMin + span)) < tolerance && + std::abs(texture.northMax - northMax) < tolerance && + std::abs(texture.northMin - (northMax - span)) < tolerance; + + if (!ok) { + logWarn("Orthophoto : emprise E " + std::to_string(texture.eastMin) + ".." + + std::to_string(texture.eastMax) + " N " + std::to_string(texture.northMin) + + ".." + std::to_string(texture.northMax) + + ", alors que le terrain couvre E " + std::to_string(eastMin) + ".." + + std::to_string(eastMin + span) + " N " + std::to_string(northMax - span) + + ".." + std::to_string(northMax) + ". Texture ignoree."); + } + return ok; +} + +// Choisit et construit le terrain a partir de l'argument de ligne de commande. +// Renvoie nullptr si l'argument ne designe pas une scene de terrain (cube, .obj). +// +// Le REPLI sur le terrain synthetique n'est fait que pour la dalle par DEFAUT. +// Un chemin donne explicitement qui n'existe pas est une erreur, pas une +// occasion de silencieusement afficher autre chose : demander une dalle precise +// et obtenir du bruit fractal sans s'en apercevoir serait le pire des deux +// mondes. +std::unique_ptr makeTerrain(const std::string& sceneArgument, + bool useDefaultTerrain, bool demoMode) { + if (sceneArgument == kProceduralKeyword) { + logInfo("Terrain : generateur procedural (Phase 4), demande explicitement."); + return std::make_unique(); + } + + if (useDefaultTerrain) { + // PHASE 21 : la demo montre la zone de 25 km2 (c'est tout son propos), + // pas la dalle unique de developpement. Repli en cascade sur la version + // 2 m si la 1 m est absente du package (voir NOTES-PHASE21.md) - les + // deux couvrent la meme emprise, seule la resolution differe. + if (demoMode) { + if (std::filesystem::exists(kDemoTerrainFile)) { + return std::make_unique(loadTerrainFile(kDemoTerrainFile)); + } + if (std::filesystem::exists(kDemoTerrainFallback)) { + logWarn("Terrain : dalle demo 1 m absente, repli sur la 2 m (" + + kDemoTerrainFallback + ")."); + return std::make_unique(loadTerrainFile(kDemoTerrainFallback)); + } + logWarn("Terrain : ni " + kDemoTerrainFile + " ni " + kDemoTerrainFallback + + " ne sont presents. Repli sur le terrain synthetique."); + return std::make_unique(); + } + if (!std::filesystem::exists(kDefaultTerrainFile)) { + logWarn(std::string("Terrain : dalle LiDAR absente (") + kDefaultTerrainFile + + "). Repli sur le terrain synthetique. Pour la produire :"); + logWarn(" python tools/lidar_to_heightmap.py " + "data/lidar/.copc.laz -o " + std::string(kDefaultTerrainFile) + + " --cell 1.0"); + return std::make_unique(); + } + return std::make_unique(loadTerrainFile(kDefaultTerrainFile)); + } + + if (sceneArgument.size() > 5 && + sceneArgument.compare(sceneArgument.size() - 5, 5, ".vchm") == 0) { + return std::make_unique(loadTerrainFile(sceneArgument)); + } + + return nullptr; +} + +// --------------------------------------------------------------------------- +// Mode --dump-world : imprime le monde seme, puis sort. Aucune fenetre, aucun +// Vulkan. +// --------------------------------------------------------------------------- +// Sert au pilotage de tools\run_vulkan_check.ps1 : piloter le jeu a l'aveugle ne +// prouve rien - on appuie sur E sans jamais viser un arbre, sur R sans rien +// avoir sous la main. En connaissant le monde, le script vise de vraies cibles. +// +// C'ETAIT un programme separe (tools\dump_world.cpp) jusqu'a la Phase 7, qui +// RECOPIAIT la construction du monde de main.cpp en comptant sur le fait que les +// deux resteraient dans le meme ordre - le semis etant deterministe, un ordre +// different aurait donne un monde different, et le script aurait vise a cote +// sans que rien ne le signale. Le replier ici supprime cette duplication : le +// dump traverse EXACTEMENT le code du jeu, par construction. +// +// (Le declencheur immediat etait plus terre a terre : Smart App Control, actif +// sur cette machine, bloque a l'execution les binaires non signes fraichement +// compiles, verdict par empreinte et donc imprevisible. vercora.exe, lui, passe. +// Une raison de moins d'avoir un second executable.) +// +// Format, une ligne par objet : +// KIND x z distance capHorizontaleDegres +// puis, pour chaque arbre reellement abattable au cap initial : +// AIM indice camX camZ recul +void dumpWorld(const Heightmap& heightmap, const Forest& forest, const Ground& ground) { + struct Entry { + std::string kind; + float x = 0.0f; + float z = 0.0f; + float distance = 0.0f; + float bearing = 0.0f; + }; + std::vector entries; + + // L'INDICE est celui que le jeu journalise ("Abattage de l'arbre 8") : c'est + // ce qui permet de verifier apres coup qu'on a bien abattu l'arbre VISE, et + // donc que le pilotage de la camera est precis. + for (std::size_t i = 0; i < forest.trees().size(); ++i) { + entries.push_back({ "TREE" + std::to_string(i), + forest.trees()[i].base.x, forest.trees()[i].base.z }); + } + for (const GroundItem& item : ground.items()) { + entries.push_back({ groundItemLabel(item.kind), item.position.x, item.position.z }); + } + + for (Entry& entry : entries) { + entry.distance = std::sqrt(entry.x * entry.x + entry.z * entry.z); + // Convention de Camera::updateVectors : front = (cos(yaw), *, sin(yaw)), + // yaw en degres. Pour regarder un point depuis l'origine il faut donc + // yaw = atan2(z, x). + entry.bearing = glm::degrees(std::atan2(entry.z, entry.x)); + } + std::sort(entries.begin(), entries.end(), + [](const Entry& a, const Entry& b) { return a.distance < b.distance; }); + + for (const Entry& entry : entries) { + std::printf("%s %.3f %.3f %.3f %.3f\n", entry.kind.c_str(), entry.x, entry.z, + entry.distance, entry.bearing); + } + + // --- Reculs d'ou un arbre est REELLEMENT visible ------------------------ + // Corrige en Phase 8. Le dump visait auparavant avec un rayon HORIZONTAL au + // cap initial (front = (0, 0, -1), pitch nul) : sur le terrain synthetique, + // assez lisse pour qu'un arbre a 9 m au sud reste toujours dans l'axe, ca + // donnait 16 arbres abattables sur 16. Sur le relief mesure, un arbre en + // contrebas passait entierement sous ce rayon et un arbre en amont + // entierement au-dessus : 6 sur 16 seulement, alors que le jeu, lui, vise + // avec camera.front() qui inclut le pitch (Camera::updateVectors, front.y = + // sin(pitch)) - voir main.cpp, la boucle de gameplay qui appelle pickTree. + // Ce n'etait donc pas un bug de visee, seulement un rayon de TEST trop + // simple pour representer ce qu'un joueur fait reellement en inclinant la + // camera vers le haut ou le bas. + // + // Le dump vise maintenant le TRONC de l'arbre (mi-hauteur) depuis l'oeil, + // direction = normalize(cible - oeil) : c'est exactement le rayon qu'un + // joueur obtient en pointant la souris sur l'arbre, pitch inclus. Le pitch + // requis est journalise pour distinguer les trois cas demandes (arbre + // au-dessus, en dessous, au meme niveau que l'oeil). + for (std::size_t i = 0; i < forest.trees().size(); ++i) { + const Tree& tree = forest.trees()[i]; + const glm::vec3 aimPoint = tree.base + glm::vec3(0.0f, tree.height * 0.5f, 0.0f); + + // Le recul doit rester assez grand pour ne pas etre DANS le houppier, et + // assez petit pour que la derive du pilotage a l'estime reste sous la + // tolerance de visee. + for (float standoff = 6.0f; standoff <= 16.0f; standoff += 0.5f) { + const float camX = tree.base.x; + const float camZ = tree.base.z + standoff; // plein sud de l'arbre + const glm::vec3 eye(camX, + heightmap.heightAt(camX, camZ) + kDefaultEyeHeight, + camZ); + const glm::vec3 toAim = aimPoint - eye; + const float horizontal = std::sqrt(toAim.x * toAim.x + toAim.z * toAim.z); + const float pitchDeg = glm::degrees(std::atan2(toAim.y, horizontal)); + + // Meme limite que Camera::update (std::clamp(pitch_, -89, 89)) : un + // pitch que le joueur ne peut pas physiquement atteindre ne compte + // pas comme "visable". + if (std::abs(pitchDeg) > 89.0f) { + continue; + } + + const glm::vec3 direction = glm::normalize(toAim); + if (forest.pickTree(eye, direction, kFellingReach) == static_cast(i)) { + const char* elevation = pitchDeg > 2.0f ? "au-dessus" + : pitchDeg < -2.0f ? "en-dessous" + : "au-niveau"; + std::printf("AIM %zu %.3f %.3f %.3f %.2f %s\n", i, camX, camZ, standoff, + pitchDeg, elevation); + break; + } + } + } + + // --- Reculs abattables au pitch NUL, pour le tir reellement joue ----------- + // run_vulkan_check.ps1 ne peut pas incliner la camera pendant qu'il pilote le + // vrai jeu : GLFW lit le curseur SYSTEME (glfwGetCursorPos -> GetCursorPos) + // et non les messages postes, donc faire tourner la camera exigerait de + // deplacer reellement le pointeur - voler la souris a l'utilisateur pendant + // le test. Le pitch en jeu reste donc a 0 tout du long du scenario C. Le + // script a besoin d'au moins une cible que ce rayon horizontal touche + // reellement, faute de quoi il ne peut prouver l'abattage lui-meme (meme si + // pickTree, verifie ci-dessus, sait viser en hauteur). + for (std::size_t i = 0; i < forest.trees().size(); ++i) { + const Tree& tree = forest.trees()[i]; + for (float standoff = 6.0f; standoff <= 16.0f; standoff += 0.5f) { + const float camX = tree.base.x; + const float camZ = tree.base.z + standoff; + const glm::vec3 eye(camX, + heightmap.heightAt(camX, camZ) + kDefaultEyeHeight, + camZ); + if (forest.pickTree(eye, glm::vec3(0.0f, 0.0f, -1.0f), kFellingReach) == + static_cast(i)) { + std::printf("AIMLEVEL %zu %.3f %.3f %.3f\n", i, camX, camZ, standoff); + break; + } + } + } +} + +} // namespace + +int main(int argc, char** argv) { + try { + // --dump-world doit venir en PREMIER, la scene eventuelle juste apres : + // vercora.exe --dump-world -> dalle par defaut + // vercora.exe --dump-world terrain -> terrain synthetique + // vercora.exe --dump-world chemin\x.vchm -> une autre dalle + // Les options commencent par "--" et peuvent etre placees n'importe ou ; + // le premier argument restant designe la scene. Un simple balayage + // suffit : il y a deux options en tout, et une vraie bibliotheque + // d'analyse d'arguments serait plus de code que le reste du fichier. + bool dumpWorldOnly = false; + // PHASE 21 : mode DEMO, pense pour un .exe envoye a quelqu'un qui n'a ni + // le depot ni l'environnement de developpement (voir NOTES-PHASE21.md). + // C'est un DRAPEAU DE LANCEMENT et non une configuration de compilation : + // le binaire distribue est EXACTEMENT celui qu'on utilise pour + // developper, en Release plutot qu'en Debug. Un flag runtime plutot + // qu'une macro parce que la demo ne retranche aucun code, seulement de + // l'INITIALISATION - la meme raison qui fait deja exister --no-wildlife + // et --no-scene : une deuxieme configuration de build a maintenir en + // parallele aurait un cout permanent pour un besoin ponctuel. + // + // Ce que --demo coupe, et pourquoi : + // - la faune (Wildlife/Habitat) et les besoins (Needs) : deux systemes + // de simulation qui tournent en continu sans rien ajouter a + // "se deplacer et regarder le terrain" ; + // - velo, parapente, escalade : trois activites montees, hors sujet ; + // - abattage, ramassage, percussion : l'interaction avec les arbres et + // les pierres reste du RENDU et de la COLLISION (la foret n'est pas + // retiree), seule la boucle d'artisanat est coupee ; + // - le mode editeur : c'est un outil de developpement, pas du contenu + // a montrer. + // Restent : marche, vol libre (F), collision terrain/arbres, FPS. + bool demoMode = false; + bool useLod = true; + bool useOrtho = true; + bool useVegetation = true; + bool useGrass = true; + // PHASE 18 : temoin de la DECOUPE ALPHA des brins d'herbe. Rend les + // quads opaques de la Phase 11 sans rien changer d'autre - ni la + // densite, ni le maillage, ni le chemin de rendu - ce qui est la seule + // facon de mesurer ce que la decoupe coute a elle seule. + bool useGrassCutout = true; + // PHASE 18 : temoin de l'accelaration de la construction de tuile. + // Meme role que --no-grass-cutout : mesurer un changement sur le MEME + // binaire et la meme trajectoire, la seule comparaison qui ait du sens. + bool cacheTileWork = true; + // PHASE 19 : 0 = laisser le defaut du TerrainStreamer (4). 1 remet le + // maillage des tuiles entierement sequentiel, c'est-a-dire dans l'etat + // d'avant la phase - TEMOIN de mesure, au meme titre que + // --no-tile-cache. + uint32_t tileThreads = 0; + // PHASE 17 : --no-wildlife coupe la faune ET la memoire du milieu. Meme + // role que --no-vegetation : c'est un TEMOIN. Sans lui, on ne peut pas + // attribuer un ecart de FPS - ou un ecart de comportement dans un + // scenario automatise - a ce qui a ete ajoute cette phase plutot qu'a + // autre chose. La lecon du scenario G de la Phase 15 vaut ici aussi : + // une mesure sans temoin ne prouve rien. + bool speciesFollowAspect = true; // PHASE 26, voir --no-species-aspect + bool singleTreeSpecies = false; // PHASE 26, voir --single-tree-species + bool useWildlife = true; + // PHASE 20 : --no-animal-collision garde la faune VISIBLE mais la rend + // traversable, c'est-a-dire le comportement exact d'avant cette phase. + // C'est le temoin qui compte pour la mesure de collision : --no-wildlife + // supprime les animaux, donc il ne peut pas montrer qu'on traverse celui + // qui est la. Meme role que --no-scene pour l'editeur en Phase 15. + bool animalCollision = true; + // PHASE 29 : rochers et pierriers. --no-rocks = TEMOIN de cout (le monde + // d'avant la Phase 29) ; --no-rock-collision garde les rochers visibles + // mais traversables, comme --no-animal-collision pour la faune. + bool useRocks = true; + bool rockCollision = true; + // PHASE 29 (Agent 3) : buissons (classe 3 LiDAR). --no-bushes = temoin. + bool useBushes = true; + // --start=E,N : point de depart en Lambert 93. PHASE 11. La camera + // demarrait toujours au CENTRE du terrain, ce qui tombe sur du lapiaz nu + // au milieu de cette zone : impossible d'aller regarder une foret ou une + // prairie sans piloter la souris a la main, donc impossible d'en faire + // une capture automatisee reproductible. + std::string startArgument; + + // PHASE 23 : heure de jeu de depart et vitesse de l'horloge. + // + // POURQUOI CES DEUX OPTIONS EXISTENT : parce que le cycle jour/nuit rend + // toute capture d'ecran dependante de l'instant, et que le projet a + // deja appris deux fois ce que coute une capture non reproductible + // (Phase 12 : trois captures de la meme scene differaient sur 5 % de + // ciel faute de --look epingle). --hour fixe le moment, --time-scale=0 + // GELE l'horloge pour que la duree de mise en place de la capture ne + // deplace pas le soleil. Les deux ensemble sont ce qui rend deux + // captures a la meme heure comparables au pixel pres. + // + // -1 = non demande, on garde les valeurs par defaut de GameClock. + float startHourArgument = -1.0f; + // PHASE 27 : jour de partie de depart. --hour seul ne choisissait que + // l'heure du JOUR 0, donc jamais une perturbation : impossible de + // capturer la pluie. --day epingle le jour du calendrier meteo, qui est + // deterministe (seed fixe), exactement comme --hour epingle l'heure. + int startDayArgument = 0; + float timeScaleArgument = -1.0f; + // --look=yaw,pitch en degres, et --lock-input pour geler la camera. + // Les deux vont ensemble : sans le verrou, la souris systeme peut + // reorienter la camera pendant une capture (voir Camera::setInputEnabled). + std::string lookArgument; + bool lockInput = false; + // PHASE 27 : TEMOIN ETROIT de la meteo visible. Il ne coupe QUE la + // traduction meteo -> image (ciel grise, soleil voile, brouillard, + // pluie/neige, sol mouille) : la meteo continue d'etre calculee et de + // peser sur les besoins et les activites exactement comme avant. Deux + // captures ou deux mesures avec et sans ce drapeau ne different donc que + // par ce que la Phase 27 a ajoute a l'ecran. + bool weatherVisuals = true; + // PHASE 27, chantier 3 : TEMOIN ETROIT du micro-relief. Coupe le grain + // de sol et lui seul. + bool groundDetail = true; + // Taille du motif de base : le texel de l'orthophoto reellement chargee. + float groundDetailPattern = kGroundDetailDefaultPattern; + std::string orthoArgument; // --ortho=chemin.vcto, sinon la convention + // PHASE 12 : streaming des tuiles. Voir l'en-tete de ce fichier. + bool tileFallback = true; + uint32_t tileBudget = 0; // 0 = laisser le defaut du TerrainStreamer + float flythroughSpeed = 0.0f; // 0 = pas de survol scripte + float flythroughAltitude = 120.0f; + // PHASE 15 : editeur de niveau. + // --editor demarre directement en mode edition (sinon F2) + // --scene=chemin fichier de scene explicite (sinon la convention) + // --no-scene ne charge ni n'ecrit aucun objet pose + // --editor-assets=rep dossier de modeles a scanner (sinon assets/editor) + bool startInEditor = false; + bool useScene = true; + std::string sceneFileArgument; + std::string editorAssetsArgument; + std::string sceneArgument; + for (int i = 1; i < argc; ++i) { + const std::string argument = argv[i]; + if (argument == "--dump-world") { + dumpWorldOnly = true; + } else if (argument == "--demo") { + demoMode = true; + } else if (argument == "--no-lod") { + useLod = false; + } else if (argument == "--no-ortho") { + useOrtho = false; + } else if (argument == "--no-vegetation") { + useVegetation = false; + } else if (argument == "--no-grass") { + useGrass = false; + } else if (argument == "--no-grass-cutout") { + useGrassCutout = false; + } else if (argument == "--single-tree-species") { + // PHASE 26 : TEMOIN DE COUT, et lui seul. + // + // Force 100 % de resineux, donc un vecteur de feuillus VIDE, donc + // UN SEUL appel de dessin instancie pour les arbres - exactement + // la situation d'avant cette phase. C'est le seul moyen de + // mesurer ce que coute le second appel sans changer de binaire, + // de vue, ni de nombre d'instances : le total d'arbres soumis est + // rigoureusement le meme, seule leur repartition entre un et deux + // appels change. + // + // A ne pas confondre avec --no-species-aspect, qui garde les deux + // appels et ne debranche que le couplage au versant. + singleTreeSpecies = true; + } else if (argument == "--no-species-aspect") { + // PHASE 26 : LE TEMOIN du chantier 4. + // + // Il n'eteint PAS les essences - ce serait un temoin trop large, + // qui melangerait deux effets : « il y a deux formes d'arbres + // maintenant » et « leur repartition suit le versant ». Il annule + // seulement le COUPLAGE A L'EXPOSITION (aspectSwing = 0). + // + // Consequence : meme nombre d'arbres, meme proportion globale de + // resineux, memes deux silhouettes - mais reparties au hasard au + // lieu de suivre l'adret et l'ubac. Toute difference entre les + // deux captures ne peut donc venir que de ce couplage, qui est + // exactement ce que cette phase pretend avoir ajoute. + speciesFollowAspect = false; + } else if (argument == "--no-wildlife") { + useWildlife = false; + } else if (argument == "--no-animal-collision") { + animalCollision = false; + } else if (argument == "--no-rocks") { + useRocks = false; + } else if (argument == "--no-rock-collision") { + rockCollision = false; + } else if (argument == "--no-bushes") { + useBushes = false; + } else if (argument == "--lock-input") { + lockInput = true; + } else if (argument == "--no-weather-visuals") { + weatherVisuals = false; + } else if (argument == "--no-ground-detail") { + groundDetail = false; + } else if (argument == "--editor") { + startInEditor = true; + } else if (argument == "--no-scene") { + useScene = false; + } else if (argument.rfind("--scene=", 0) == 0) { + sceneFileArgument = argument.substr(std::strlen("--scene=")); + } else if (argument.rfind("--editor-assets=", 0) == 0) { + editorAssetsArgument = argument.substr(std::strlen("--editor-assets=")); + } else if (argument == "--no-tile-cache") { + // PHASE 18 : temoin de la mise en cache du travail de tuile. + cacheTileWork = false; + } else if (argument.rfind("--tile-threads=", 0) == 0) { + try { + const long value = + std::stol(argument.substr(std::strlen("--tile-threads="))); + if (value < 1 || value > 64) { + logWarn("--tile-threads doit valoir entre 1 et 64. Ignore."); + } else { + tileThreads = static_cast(value); + } + } catch (const std::exception&) { + logWarn("--tile-threads : nombre illisible. Ignore : " + argument); + } + } else if (argument == "--no-tile-fallback") { + tileFallback = false; + } else if (argument.rfind("--tile-budget=", 0) == 0) { + try { + const long value = + std::stol(argument.substr(std::strlen("--tile-budget="))); + if (value < 1) { + logWarn("--tile-budget doit valoir au moins 1. Ignore."); + } else { + tileBudget = static_cast(value); + } + } catch (const std::exception&) { + logWarn("--tile-budget : nombre illisible. Ignore : " + argument); + } + } else if (argument.rfind("--flythrough=", 0) == 0) { + const std::string value = argument.substr(std::strlen("--flythrough=")); + const std::size_t comma = value.find(','); + try { + flythroughSpeed = std::stof(value.substr(0, comma)); + if (comma != std::string::npos) { + flythroughAltitude = std::stof(value.substr(comma + 1)); + } + if (!(flythroughSpeed > 0.0f)) { + logWarn("--flythrough : vitesse nulle ou negative. Ignore."); + flythroughSpeed = 0.0f; + } + } catch (const std::exception&) { + logWarn("--flythrough attend \"vitesse[,altitude]\" en m/s et m. " + "Ignore : " + argument); + flythroughSpeed = 0.0f; + } + } else if (argument.rfind("--look=", 0) == 0) { + lookArgument = argument.substr(std::strlen("--look=")); + } else if (argument.rfind("--start=", 0) == 0) { + startArgument = argument.substr(std::strlen("--start=")); + } else if (argument.rfind("--hour=", 0) == 0) { + try { + const float value = std::stof(argument.substr(std::strlen("--hour="))); + if (value < 0.0f || value >= 24.0f) { + logWarn("--hour attend une heure dans [0, 24). Ignore : " + argument); + } else { + startHourArgument = value; + } + } catch (const std::exception&) { + logWarn("--hour : heure illisible. Ignore : " + argument); + } + } else if (argument.rfind("--day=", 0) == 0) { + try { + const int value = std::stoi(argument.substr(std::strlen("--day="))); + if (value < 0 || value > 3650) { + logWarn("--day attend un jour de partie dans [0, 3650]. Ignore : " + + argument); + } else { + startDayArgument = value; + } + } catch (const std::exception&) { + logWarn("--day : jour illisible. Ignore : " + argument); + } + } else if (argument.rfind("--time-scale=", 0) == 0) { + try { + const float value = + std::stof(argument.substr(std::strlen("--time-scale="))); + if (value < 0.0f) { + logWarn("--time-scale doit etre positif ou nul (0 = horloge " + "gelee). Ignore : " + argument); + } else { + timeScaleArgument = value; + } + } catch (const std::exception&) { + logWarn("--time-scale : nombre illisible. Ignore : " + argument); + } + } else if (argument.rfind("--ortho=", 0) == 0) { + orthoArgument = argument.substr(std::strlen("--ortho=")); + } else if (argument.rfind("--", 0) == 0) { + logWarn("Option inconnue, ignoree : " + argument); + } else if (sceneArgument.empty()) { + sceneArgument = argument; + } + } + const bool useDefaultTerrain = sceneArgument.empty(); + + // PHASE 21 : demo AUTO-DETECTEE quand la dalle de DEVELOPPEMENT est + // absente mais qu'une dalle de zone existe. Sans ca, double-cliquer sur + // le vercora.exe d'un package distribue (voir NOTES-PHASE21.md) sans + // argument retombait sur kDefaultTerrainFile, absent du package -> repli + // sur le terrain SYNTHETIQUE 128x128, silencieusement : la personne qui + // recoit la demo n'a aucune ligne de commande a taper, elle double-clique + // et doit voir la vraie zone. Un chemin de scene EXPLICITE (sceneArgument + // non vide) ou --demo deja tape ne sont pas affectes par cette detection. + if (!demoMode && useDefaultTerrain && !std::filesystem::exists(kDefaultTerrainFile) && + (std::filesystem::exists(kDemoTerrainFile) || + std::filesystem::exists(kDemoTerrainFallback))) { + demoMode = true; + } + + // PHASE 21 : --demo coupe la faune, les besoins, les trois activites + // montees, l'artisanat interactif et l'editeur - voir le commentaire de + // la declaration de demoMode plus haut pour le detail et la raison de + // chaque coupure. Applique ICI, juste apres le parsing et avant toute + // construction du monde, pour que le reste du fichier n'ait plus a + // savoir QUE ces flags ont ete forces - seulement que useWildlife vaut + // false, exactement comme si --no-wildlife --no-scene avaient ete tapes. + if (demoMode) { + useWildlife = false; + useScene = false; + startInEditor = false; + logInfo("Mode DEMO : faune, besoins, velo/parapente/escalade, " + "artisanat et editeur desactives. Marche, vol libre (F) et " + "compteur FPS seulement."); + } + + // ------------------------------------------------------------------ + // 1. Monde cote CPU d'abord : on echoue vite et clairement, sans avoir + // ouvert de fenetre ni initialise Vulkan. + // ------------------------------------------------------------------ + // Depuis la Phase 7 le relief peut venir d'une vraie dalle LiDAR HD ; les + // arbres et les pierres, eux, restent semes de facon procedurale (la + // classification LiDAR contient bien la vegetation, mais en tirer des + // arbres individuels est un autre sujet). + std::unique_ptr heightmap = makeTerrain(sceneArgument, useDefaultTerrain, demoMode); + + // PHASE 21 : chemin de la dalle REELLEMENT chargee par makeTerrain (et + // non plus systematiquement kDefaultTerrainFile) : le mode demo peut y + // avoir substitue vercora_zone_1m/2m.vchm. Sert de base a l'orthophoto + // (convention de nom, voir orthoPathFor) et au nom de fichier de scene - + // les deux doivent designer la MEME dalle que celle affichee, ou + // l'orthophoto chargee ne recouvrirait pas le terrain (orthoMatchesTerrain + // la rejetterait) et le fichier de scene se romprait au premier F9. + const std::string resolvedTerrainFile = !useDefaultTerrain ? sceneArgument + : demoMode + ? (std::filesystem::exists(kDemoTerrainFile) ? kDemoTerrainFile + : kDemoTerrainFallback) + : kDefaultTerrainFile; + const bool terrainScene = (heightmap != nullptr); + + // PHASE 26 : LES reglages d'essence, en UN exemplaire. Pousses a la fois + // dans la Forest (arbres abattables) et dans la Vegetation (decor) pour + // qu'il soit impossible que les deux systemes appliquent des lois + // differentes au meme versant. + TreeSpeciesParams kTreeSpecies{}; + if (singleTreeSpecies) { + kTreeSpecies.coniferShareNeutral = 1.0f; + kTreeSpecies.coniferShareMin = 1.0f; + kTreeSpecies.coniferShareMax = 1.0f; + kTreeSpecies.aspectSwing = 0.0f; + logInfo("TEMOIN --single-tree-species : une seule essence, donc UN SEUL " + "appel de dessin instancie pour les arbres (etat d'avant la " + "Phase 26). Sert a mesurer le cout du second appel."); + } + if (!speciesFollowAspect) { + kTreeSpecies.aspectSwing = 0.0f; + logInfo("TEMOIN --no-species-aspect : les essences ne suivent plus le " + "versant (aspectSwing = 0). Meme nombre d'arbres et meme part " + "de resineux, mais reparties au hasard."); + } + + // --- METEO, declaree AVANT le monde (PHASE 26) ---------------------- + // Deterministe et SANS ETAT (voir world/Weather.hpp) : il n'y a rien a + // faire avancer d'une image a l'autre, on l'INTERROGE. Le seed est celui + // par defaut, donc FIXE. + // + // POURQUOI ICI ET PLUS BAS COMME AVANT. La Phase 26 fait dependre + // l'ESSENCE de chaque arbre de l'exposition adret/ubac, laquelle vient de + // ce systeme ; or la Forest seme ses arbres dans son constructeur. Le + // soleil doit donc exister avant le monde. C'est un simple deplacement de + // declaration : l'objet est sans etat, rien ne depend de l'instant ou il + // est construit. + WeatherSystem weather; + + // Adaptateur : donne a la Forest et a la Vegetation l'exposition + // adret/ubac SANS leur faire connaitre WeatherSystem. Meme patron que + // GroundCoverSource (Phase 17) - une interface minuscule, une + // implementation qui delegue, et deux systemes qui restent testables + // sans monter toute la meteo. + // + // Il ne CALCULE rien : il transmet. Le calcul est celui de la Phase 23, + // evalue au soleil de midi (voir WeatherSystem::aspectExposureAt). + class WeatherAspectExposure final : public AspectExposureSource { + public: + WeatherAspectExposure(const WeatherSystem& weather, const HeightSampler* terrain) + : weather_(weather), terrain_(terrain) {} + float aspectExposureAt(float worldX, float worldZ) const override { + // Y est indifferent : aspectExposureAt ne lit que la NORMALE du + // relief en (x, z). On passe 0 plutot que de sonder l'altitude + // pour rien. + return weather_.aspectExposureAt(glm::vec3(worldX, 0.0f, worldZ), terrain_); + } + private: + const WeatherSystem& weather_; + const HeightSampler* terrain_ = nullptr; + }; + const WeatherAspectExposure aspectExposure(weather, heightmap.get()); + + std::unique_ptr ground; + std::unique_ptr forest; + + // PHASE 15 : le monde a desormais DEUX sources d'obstacles - les troncs + // et souches de la Forest (Phase 6) et les objets solides poses par + // l'editeur. La camera, le velo et le grimpeur continuent de ne voir + // qu'un seul CollisionSolver : celui-ci les additionne. + // + // Aucune des trois classes n'a ete modifiee pour ca. C'est exactement ce + // que l'interface de la Phase 6 permettait, et la premiere fois qu'on + // s'en sert. + CompositeCollisionSolver worldSolver; + + MeshData sceneMesh; + RenderOptions renderOptions; + + Inventory inventory; + + // PHASE 28 : etat de combustion des foyers (world/Crafting), tenu hors du + // Ground, et nature du dernier objet ramasse (ce que P repose d'abord). + HearthSet hearths; + GroundItemKind lastPickedKind = GroundItemKind::Stone; + + if (terrainScene) { + // Le maillage d'un seul bloc n'est construit que si on en a + // reellement besoin : + // - jamais en --dump-world (des millions de triangles batis pour + // etre jetes aussitot) ; + // - jamais avec le quadtree, qui maille tuile par tuile a la + // demande. C'est le premier poste d'economie de RAM de la + // Phase 10 : sur la zone de 25 km2 au pas de 1 m, ce seul appel + // produisait 25 M de sommets et 50 M de triangles cote CPU, + // recopies ensuite sur le GPU. + if (!dumpWorldOnly && !useLod) { + sceneMesh = terrainMeshData(*heightmap); + } + + renderOptions.heightRange = { heightmap->minHeight(), heightmap->maxHeight() }; + // Voir loin : le terrain fait worldSize d'un bord a l'autre, et on le + // regarde en diagonale depuis le sol. + renderOptions.farPlane = 3.0f * heightmap->worldSize(); + // Ciel diurne : sans lui, l'horizon se confond avec le fond noir et + // on ne voit plus ou s'arrete le relief. + renderOptions.clearColor = { 0.52f, 0.66f, 0.82f }; + + const float extent = 0.5f * heightmap->worldSize(); + + // Le sol est cree AVANT la foret : c'est lui qui recevra les buches + // et les branches produites par les abattages. + ground = std::make_unique(*heightmap); + // PHASE 26 : l'exposition adret/ubac est passee au CONSTRUCTEUR, seul + // moment ou elle sert - c'est lui qui seme, donc lui qui decide des + // essences. Sur le terrain synthetique elle est plate, donc neutre. + forest = std::make_unique(*heightmap, *ground, extent, ForestParams{}, + &aspectExposure, kTreeSpecies); + worldSolver.add(forest.get()); + // PHASE 26 : la composition des arbres ABATTABLES. C'est aussi le + // nombre d'arbres qui donneront de la resine - les deux ne peuvent + // plus differer, ils lisent le meme champ. + logInfo("Essences : " + std::to_string(forest->coniferCount()) + " resineux sur " + + std::to_string(forest->trees().size()) + + " arbres abattables (les resineux seuls donnent de la resine, " + "et se reconnaissent a leur silhouette conique)."); + + // Le nombre d'arbres SEMES est journalise depuis la Phase 7 : sur du + // relief reel, le filtre de pente (ForestParams::maxSlope) en rejette + // une partie, ce qui est normal mais doit rester visible. Un semis a + // zero arbre serait le premier symptome d'un terrain trop raide pour + // le gameplay - une information qu'un terrain synthetique bien lisse + // ne pouvait pas donner. + logInfo("Arbres semes : " + std::to_string(forest->treeCount()) + + " (le relief refuse les pentes fortes)."); + + const uint32_t stones = ground->scatterStones(kStoneCount, 26.0f, 5.0f, extent); + logInfo("Pierres semees : " + std::to_string(stones) + " sur " + + std::to_string(kStoneCount) + " demandees."); + } else if (sceneArgument == kBuiltinCubeKeyword) { + logInfo("Geometrie : cube code en dur (Phase 1)."); + sceneMesh = cubeMeshData(); + } else { + sceneMesh = loadObjMesh(sceneArgument); + } + + if (dumpWorldOnly) { + if (forest && ground) { + dumpWorld(*heightmap, *forest, *ground); + } else { + logWarn("--dump-world : cette scene n'a ni foret ni objets au sol."); + } + return EXIT_SUCCESS; + } + + // Le maillage n'a pas toujours de nom a ce stade (avec le quadtree il + // n'existe pas encore), d'ou le repli sur le libelle de la heightmap. + const std::string sceneName = !sceneMesh.name.empty() + ? sceneMesh.name + : (heightmap ? heightmap->describe() : std::string("scene")); + // PHASE 21 : en mode demo, le titre se limite a "Vercora - DEMO" - pas + // de nom de scene technique (illisible pour quelqu'un hors du projet), + // pas de suffixe LOD. Le detail complet reste le titre de developpement. + const std::string kBaseTitle = demoMode + ? std::string("Vercora - DEMO") + : "Vercora - Phase 10 - " + sceneName + + (terrainScene && useLod ? " - LOD" : ""); + + // ------------------------------------------------------------------ + // 2. Ordre d'initialisation : fenetre -> contexte Vulkan -> renderer. + // ------------------------------------------------------------------ + Window window(1280, 720, kBaseTitle); + VulkanContext context(window); + Renderer renderer(context, window, renderOptions); + + // Enregistrement des geometries : une seule fois, quel que soit le + // nombre d'instances qui les utiliseront ensuite. + // Avec le quadtree, il n'y a pas de geometrie de scene unique : chaque + // tuile est enregistree et liberee par le TerrainStreamer. + const MeshHandle sceneMeshHandle = + sceneMesh.empty() ? kInvalidMesh : renderer.addMesh(sceneMesh); + + // ------------------------------------------------------------------ + // 2 bis. Orthophoto (Phase 11). Chargee APRES le Renderer, qui possede + // le command pool servant au transfert. Toute defaillance est + // NON FATALE : sans photo le terrain reprend sa coloration + // procedurale par altitude et par pente, ce qui reste un monde + // jouable. La seule chose interdite est de draper en silence une + // photo qui ne correspond pas (voir orthoMatchesTerrain). + // ------------------------------------------------------------------ + if (terrainScene && useOrtho && heightmap->geo().isGeoreferenced()) { + const std::string terrainPath = + resolvedTerrainFile; + const std::string orthoPath = + orthoArgument.empty() ? orthoPathFor(terrainPath) : orthoArgument; + + if (!std::filesystem::exists(orthoPath)) { + logInfo("Orthophoto : aucune texture pour ce terrain (" + orthoPath + + " absent). Coloration procedurale. Pour la produire :"); + logInfo(" python tools/fetch_ortho.py " + terrainPath + " -o data/ortho"); + logInfo(" python tools/make_ortho_texture.py " + terrainPath + + " -i data/ortho -o " + orthoPath); + } else { + try { + const TextureData ortho = loadTextureFile(orthoPath); + if (orthoMatchesTerrain(ortho, *heightmap)) { + renderer.setTerrainTexture(ortho); + renderer.setOrthoMix(1.0f); + groundDetailPattern = ortho.metresPerTexel(); + logInfo("Orthophoto : " + + std::to_string(ortho.metresPerTexel()) + + " m/texel pour un terrain au pas de " + + std::to_string(heightmap->spacing()) + + " m. Touche O pour basculer vers la coloration " + "procedurale."); + } + } catch (const std::exception& error) { + logWarn(std::string("Orthophoto : ") + error.what() + + " Coloration procedurale conservee."); + } + } + } else if (terrainScene && !useOrtho) { + logInfo("Orthophoto desactivee (--no-ortho) : coloration procedurale."); + } + + std::unique_ptr terrainStreamer; + if (terrainScene && useLod) { + TerrainStreamer::Params streamerParams; + streamerParams.ancestorFallback = tileFallback; + streamerParams.cacheTileWork = cacheTileWork; + if (tileThreads > 0) { + streamerParams.meshThreads = tileThreads; + } + if (tileBudget > 0) { + streamerParams.maxUploadsPerFrame = tileBudget; + } + if (!tileFallback) { + logInfo("Repli sur l'ancetre DESACTIVE (--no-tile-fallback) : une " + "tuile pas encore construite laissera un trou, comme en " + "Phase 10. Garde pour la comparaison."); + } + terrainStreamer = + std::make_unique(*heightmap, renderer, streamerParams); + } else if (terrainScene) { + logInfo("Terrain dessine d'un seul bloc (--no-lod) : ni quadtree, ni " + "niveau de detail, ni frustum culling. C'est le comportement " + "de la Phase 9, garde pour la comparaison."); + } + + // ------------------------------------------------------------------ + // 2 ter. Vegetation de decor (Phase 11). Les deux cartes LiDAR sont + // optionnelles : sans elles, Vegetation retombe sur un substitut + // par pente et altitude (voir world/Vegetation.cpp). Leur absence + // n'est donc PAS une erreur - c'est le cas normal du terrain + // synthetique et des dalles sans carte produite. + // ------------------------------------------------------------------ + std::unique_ptr coverMap; + std::unique_ptr canopyHeightMap; + std::unique_ptr vegetation; + + // --- PHASE 17 : empreinte environnementale ------------------------ + // L'Habitat existe TOUJOURS, meme sans terrain : ce n'est qu'une grille + // de compteurs, il n'a besoin de rien. La faune, elle, a besoin d'un + // relief sous les sabots, comme les quatre activites du joueur. + Habitat habitat; + std::unique_ptr wildlife; + + if (terrainScene && useVegetation) { + const std::string terrainPath = + resolvedTerrainFile; + const std::string coverPath = canopyPathFor(terrainPath, ""); + const std::string heightPath = canopyPathFor(terrainPath, "_height"); + + for (auto* slot : { &coverMap, &canopyHeightMap }) { + const std::string& path = (slot == &coverMap) ? coverPath : heightPath; + if (!std::filesystem::exists(path)) { + continue; + } + try { + *slot = std::make_unique(loadTerrainFile(path)); + } catch (const std::exception& error) { + logWarn(std::string("Carte de vegetation : ") + error.what()); + } + } + + if (coverMap) { + logInfo("Vegetation : carte de couvert LiDAR chargee (" + coverPath + ")."); + } else { + logInfo("Vegetation : pas de carte de couvert (" + coverPath + + " absent). Semis de substitut par pente et altitude. " + "Pour la produire : python tools/lidar_to_canopy.py data/lidar " + "-o " + coverPath + " --extent " + terrainPath); + } + + VegetationParams vegetationParams; + if (!useGrassCutout) { + vegetationParams.grassCutout = 0.0f; + } + vegetationParams.species = kTreeSpecies; // PHASE 26 : la meme loi que la Forest + vegetation = std::make_unique( + *heightmap, coverMap.get(), canopyHeightMap.get(), + 0.5f * heightmap->worldSize(), vegetationParams); + + // PHASE 17 : l'herbe consulte desormais l'etat du sol. Branche ICI + // et nulle part ailleurs - c'est le seul point de contact entre le + // decor et la memoire du milieu. Non branche sous --no-wildlife : + // le temoin doit etre le comportement d'AVANT la phase, pas + // "presque". + if (useWildlife) { + vegetation->setGroundCover(&habitat); + } + + // PHASE 26 : l'exposition adret/ubac, qui decide de l'ESSENCE des + // arbres de decor - et d'elle seule. La PRESENCE d'un arbre reste + // pilotee par la carte de couvert LiDAR de la Phase 11, exactement + // comme avant : voir le commentaire de buildTreeCell, ou l'essence + // est choisie APRES tous les filtres de presence. + vegetation->setAspectExposure(&aspectExposure); + + logInfo("Vegetation : densite estimee " + + std::to_string(vegetation->estimateTreeDensityPerHectare()) + + " arbres/ha sur toute la zone. Touche G pour basculer " + "tout / arbres seuls / rien."); + } + + // --- PHASE 17 : la faune ------------------------------------------- + // Cree APRES la vegetation parce qu'elle lit la MEME carte de couvert + // LiDAR pour savoir ou est le bois. Elle peut etre nulle (terrain sans + // carte) : la faune se place alors partout ou la pente le permet, voir + // WildlifeParams::coverWithoutMap. + // + // Independante de --no-vegetation : couper le decor est un reglage + // d'affichage pour mesurer des FPS, ce n'est pas une raison de vider le + // monde de ses animaux. + if (terrainScene && useWildlife) { + WildlifeParams wildlifeParams; + wildlifeParams.solid = animalCollision; + wildlife = std::make_unique(*heightmap, coverMap.get(), + 0.5f * heightmap->worldSize(), + wildlifeParams); + + // PHASE 20 : troisieme source d'obstacles du monde, apres les + // troncs de la Forest (Phase 6) et les objets poses par l'editeur + // (Phase 15). Une seule ligne, et elle suffit pour LES TROIS + // activites qui se deplacent au sol : la marche, le velo et + // l'escalade recoivent tous le meme `worldSolver`, aucune des trois + // classes n'a ete touchee. C'est le meme argument qu'en Phase 15, + // et c'est la deuxieme fois qu'il tient. + worldSolver.add(wildlife.get()); + logInfo(std::string("Faune : collision ") + + (animalCollision ? "ACTIVE (Phase 20), rayon " + + std::to_string(wildlifeParams.colliderRadius) + + " m par animal." + : "DESACTIVEE (--no-animal-collision) : " + "c'est le comportement d'avant la Phase 20, " + "garde comme temoin.")); + } else if (terrainScene) { + logInfo("Faune et memoire du milieu DESACTIVEES (--no-wildlife) : " + "c'est le comportement d'avant la Phase 17, garde comme temoin."); + } + + MeshHandle treeMeshHandle = kInvalidMesh; + MeshHandle stumpMeshHandle = kInvalidMesh; + MeshHandle avatarMeshHandle = kInvalidMesh; // marqueur visuel du joueur en activite + MeshHandle broadleafMeshHandle = kInvalidMesh; // PHASE 26 + MeshHandle sceneryTreeMeshHandle = kInvalidMesh; + MeshHandle sceneryBroadleafMeshHandle = kInvalidMesh; // PHASE 26 + MeshHandle grassMeshHandle = kInvalidMesh; + MeshHandle fiberMeshHandle = kInvalidMesh; // PHASE 22 + MeshHandle animalMeshHandle = kInvalidMesh; // PHASE 17 + + // Un mesh par nature d'objet au sol, indexe par GroundItemKind : la + // boucle de rendu se reduit alors a une indexation, sans cascade de if. + std::array groundMeshes{}; + groundMeshes.fill(kInvalidMesh); + + if (terrainScene) { + treeMeshHandle = renderer.addMesh(treeMeshData(kTreeProportions)); + // PHASE 26 : la seconde silhouette. MEMES proportions, donc meme + // tronc, donc LA MEME SOUCHE convient aux deux essences - c'est ce + // qui evite un second mesh de souche et garantit que le trait de + // coupe coincide quelle que soit l'essence abattue. + broadleafMeshHandle = renderer.addMesh(broadleafTreeMeshData(kTreeProportions)); + stumpMeshHandle = renderer.addMesh(stumpMeshData(kTreeProportions)); + + groundMeshes[static_cast(GroundItemKind::Log)] = + renderer.addMesh(logMeshData()); + groundMeshes[static_cast(GroundItemKind::Branch)] = + renderer.addMesh(branchMeshData()); + groundMeshes[static_cast(GroundItemKind::Stone)] = + renderer.addMesh(stoneMeshData()); + groundMeshes[static_cast(GroundItemKind::Flake)] = + renderer.addMesh(flakeMeshData()); + // PHASE 22 : les quatre matieres du document de cadrage qui + // manquaient. Elles passent par la MEME table indexee par + // GroundItemKind, donc par le meme unique point de rendu plus bas - + // aucune cascade de if n'a ete ajoutee pour elles. + groundMeshes[static_cast(GroundItemKind::Clay)] = + renderer.addMesh(clayLumpMeshData()); + groundMeshes[static_cast(GroundItemKind::Sand)] = + renderer.addMesh(sandPileMeshData()); + groundMeshes[static_cast(GroundItemKind::Resin)] = + renderer.addMesh(resinBlobMeshData()); + groundMeshes[static_cast(GroundItemKind::Fiber)] = + renderer.addMesh(fiberBundleMeshData()); + // PHASE 28 : objets faconnes, meme table, meme point de rendu. + groundMeshes[static_cast(GroundItemKind::Cord)] = + renderer.addMesh(cordMeshData()); + groundMeshes[static_cast(GroundItemKind::Axe)] = + renderer.addMesh(axeMeshData()); + groundMeshes[static_cast(GroundItemKind::Hearth)] = + renderer.addMesh(hearthMeshData()); + groundMeshes[static_cast(GroundItemKind::Ash)] = + renderer.addMesh(ashMeshData()); + groundMeshes[static_cast(GroundItemKind::Pitch)] = + renderer.addMesh(pitchMeshData()); + groundMeshes[static_cast(GroundItemKind::PitchedAxe)] = + renderer.addMesh(pitchedAxeMeshData()); + groundMeshes[static_cast(GroundItemKind::Shelter)] = + renderer.addMesh(shelterMeshData()); + + // Marqueur du joueur pendant une activite a la troisieme personne + // (parapente depuis la Phase 8, velo depuis la Phase 13) : sans lui, + // la vue chase-cam montrerait le relief mais rien qui indique ou est + // le joueur - le point meme d'une camera a la troisieme personne. Un + // cube fait l'affaire ; les vrais meshs d'aile et de velo viendront + // avec l'habillage visuel, hors scope des deux sessions de physique. + avatarMeshHandle = renderer.addMesh(cubeMeshData()); + + // PHASE 17 : une seule geometrie de cervide pour toute la faune, + // instanciee par un DrawItem et une matrice comme les arbres + // abattables. Voir world/AnimalMesh.hpp pour la convention. + animalMeshHandle = renderer.addMesh(animalMeshData()); + + if (vegetation) { + // L'arbre de DECOR reutilise exactement le mesh des arbres + // abattables : meme silhouette, donc aucune couture visible + // entre les deux systemes. Seule la voie de rendu differe + // (instanciee au lieu d'un DrawItem par arbre). + sceneryTreeMeshHandle = treeMeshHandle; + sceneryBroadleafMeshHandle = broadleafMeshHandle; + grassMeshHandle = renderer.addMesh(grassTuftMeshData()); + // PHASE 22 : la plante a fibres SUR PIED. Meme voie de rendu + // instanciee que l'herbe, meme materiau, meme mesh unite. + fiberMeshHandle = renderer.addMesh(fiberPlantMeshData()); + } + } + + // ------------------------------------------------------------------ + // 2 quater. EDITEUR DE NIVEAU (PHASE 15). + // ------------------------------------------------------------------ + // Le catalogue et la scene sont montes MEME HORS MODE EDITEUR, et c'est + // le point important : le jeu normal doit afficher les objets poses. Le + // mode edition n'ajoute que les commandes ; ce qui a ete pose est du + // contenu du monde, pas un artefact d'outil. + // + // Ordre : APRES le Renderer, parce que chaque geometrie du catalogue est + // televersee des maintenant (une seule fois, quel que soit le nombre + // d'objets qui l'utiliseront - c'est le decouplage geometrie/instances de + // la Phase 5). Et AVANT la camera, qui doit recevoir un solveur de + // collision deja complet. + AssetCatalog editorCatalog; + EditorScene editorScene; + // Resolution asset -> geometrie, par HACHAGE et non par balayage du + // catalogue : la liste de dessin est reconstruite a chaque image, et un + // AssetCatalog::indexOf() par objet et par image serait une comparaison + // de chaines par asset et par objet - negligeable a dix objets, plus du + // tout a plusieurs milliers. + std::unordered_map assetByName; + std::string scenePath; + std::string sceneTerrainLabel; + + if (terrainScene && useScene) { + editorCatalog.addBuiltins(); + editorCatalog.scanDirectory(editorAssetsArgument.empty() + ? std::string(kEditorAssetsDir) + : editorAssetsArgument); + + for (AssetEntry& entry : editorCatalog.entries()) { + // log a false : une ligne par asset noierait le reste, on + // journalise un resume juste apres. + entry.meshHandle = renderer.addMesh(entry.mesh, false); + } + for (const AssetEntry& entry : editorCatalog.entries()) { + assetByName.emplace(entry.id, &entry); + } + logInfo("Editeur : " + std::to_string(editorCatalog.size()) + + " asset(s) au catalogue, geometries televersees."); + + editorScene.setCatalog(&editorCatalog); + worldSolver.add(&editorScene); + + const std::string terrainPath = + resolvedTerrainFile; + sceneTerrainLabel = std::filesystem::path(terrainPath).filename().string(); + scenePath = sceneFileArgument.empty() + ? scenePathFor(terrainPath, kScenesDir) + : sceneFileArgument; + } else if (startInEditor) { + // Demander l'editeur et ne pas l'obtenir doit se DIRE. Les deux cas + // ou il n'existe pas sont legitimes - on peut vouloir mesurer une + // scene sans lui, ou regarder un .obj isole - mais rester muet + // laisserait croire a une touche F2 qui ne repond pas. + logWarn(terrainScene + ? "--editor ignore : --no-scene coupe l'editeur et les objets poses." + : "--editor ignore : l'editeur a besoin d'une scene de terrain " + "(il pose des objets SUR le relief)."); + } + + // Chargement (ou rechargement a la touche F9) de la scene depuis le + // disque. Ecrit comme une lambda parce que les deux appelants - le + // demarrage et la touche - doivent faire EXACTEMENT la meme chose, y + // compris le controle des assets manquants ; les separer serait le moyen + // sur d'en corriger un seul le jour ou ca changera. + const auto loadScene = [&]() { + if (scenePath.empty() || heightmap == nullptr) { + return; + } + const SceneLoadResult result = loadSceneFile(scenePath, *heightmap); + if (!result.fileExisted) { + logInfo("Scene : aucun fichier a " + scenePath + + " (monde sans objets poses). Il sera cree par la touche F5 " + "depuis le mode editeur (F2)."); + editorScene.clear(); + return; + } + if (!result.ok) { + logWarn("Scene : " + scenePath + " illisible (" + result.error + + "). Aucun objet charge, le fichier n'est PAS ecrase tant " + "qu'on ne sauvegarde pas."); + return; + } + + editorScene.replaceAll(result.objects); + + // Assets manquants : signales UNE fois, par nom, avec le compte. + // C'est le seul defaut de scene qu'on ne peut pas voir a l'ecran - + // un objet dont le modele n'existe plus n'est simplement pas + // dessine, ce qui ressemble a "je n'avais rien pose la". + std::unordered_map missing; + for (const PlacedObject& object : editorScene.objects()) { + if (assetByName.find(object.asset) == assetByName.end()) { + ++missing[object.asset]; + } + } + for (const auto& [name, count] : missing) { + logWarn("Scene : " + std::to_string(count) + " objet(s) referencent " + "l'asset \"" + name + "\", absent du catalogue. Ils sont " + "conserves dans le fichier mais ni dessines ni solides."); + } + + logInfo("Scene : " + std::to_string(editorScene.size()) + " objet(s) charges " + "depuis " + scenePath + " (" + std::to_string(editorScene.solidCount()) + + " solide(s), terrain d'origine \"" + result.terrainLabel + "\", EPSG:" + + std::to_string(result.epsg) + ")."); + if (result.skippedObjects > 0) { + logWarn("Scene : " + std::to_string(result.skippedObjects) + + " ligne(s) d'objet mal formees, sautees."); + } + if (result.outsideExtent > 0) { + logWarn("Scene : " + std::to_string(result.outsideExtent) + + " objet(s) hors de l'emprise du terrain charge. Scene " + "composee sur une autre emprise ?"); + } + }; + loadScene(); + + // ------------------------------------------------------------------ + // 3. Camera. Sur le terrain : au centre, en mode marche (le Y exact est + // impose par setMode). Sur un objet : en recul, comme en Phase 1. + // ------------------------------------------------------------------ + Camera camera(terrainScene ? glm::vec3(0.0f, 0.0f, 0.0f) + : glm::vec3(0.0f, 0.0f, 3.0f)); + + if (terrainScene) { + camera.setHeightSampler(heightmap.get()); + // Le solveur composite plutot que la Forest directement (PHASE 15) : + // il contient la Forest - qui sait ou sont les troncs et les souches - + // ET la scene d'editeur, qui sait ou sont les rochers poses. + camera.setCollisionSolver(&worldSolver); + camera.setMoveSpeed(kWalkSpeed); + camera.setMode(CameraMode::Walk); + + if (!startArgument.empty()) { + if (!heightmap->geo().isGeoreferenced()) { + logWarn("--start ignore : ce terrain n'est pas georeference."); + } else { + const std::size_t comma = startArgument.find(','); + if (comma == std::string::npos) { + logWarn("--start attend \"est,nord\" en Lambert 93, par exemple " + "--start=901315,6435855. Ignore : " + startArgument); + } else { + try { + const double east = std::stod(startArgument.substr(0, comma)); + const double north = std::stod(startArgument.substr(comma + 1)); + // Inverse de Heightmap::toProjected : le terrain est + // centre sur l'origine, l'est croit avec X et le nord + // DECROIT avec Z (voir Heightmap.hpp). + const float worldX = + static_cast(east - heightmap->geo().originEast) - + 0.5f * heightmap->worldSize(); + const float worldZ = + static_cast(heightmap->geo().originNorth - north) - + 0.5f * heightmap->worldSize(); + const float half = 0.5f * heightmap->worldSize(); + if (std::abs(worldX) > half || std::abs(worldZ) > half) { + logWarn("--start est hors de l'emprise du terrain. Ignore."); + } else { + camera.setPosition({ worldX, 0.0f, worldZ }); + camera.setMode(CameraMode::Walk); // recolle au sol + } + } catch (const std::exception&) { + logWarn("--start : coordonnees illisibles. Ignore : " + + startArgument); + } + } + } + } + + if (!lookArgument.empty()) { + const std::size_t comma = lookArgument.find(','); + if (comma == std::string::npos) { + logWarn("--look attend \"yaw,pitch\" en degres. Ignore : " + lookArgument); + } else { + try { + camera.setOrientation(std::stof(lookArgument.substr(0, comma)), + std::stof(lookArgument.substr(comma + 1))); + } catch (const std::exception&) { + logWarn("--look : angles illisibles. Ignore : " + lookArgument); + } + } + } + + if (flythroughSpeed > 0.0f) { + // Le survol pilote la position lui-meme : la camera doit etre en + // mode libre (sinon elle se recolle au sol a chaque frame) et ne + // doit pas recevoir le clavier ni la souris, sans quoi la + // trajectoire ne serait plus reproductible d'un run a l'autre. + camera.setMode(CameraMode::Free); + camera.setInputEnabled(false); + logInfo("Survol scripte (--flythrough) : " + + std::to_string(flythroughSpeed) + " m/s a " + + std::to_string(flythroughAltitude) + + " m au-dessus du relief, virage de 90 deg au bord de " + "l'emprise. Clavier et souris ignores."); + } + + if (lockInput) { + camera.setInputEnabled(false); + logInfo("Camera VERROUILLEE (--lock-input) : ni clavier ni souris. " + "La vue est entierement determinee par --start et --look. " + "La pose au CLIC de l'editeur est coupee elle aussi - un " + "clic reel de l'utilisateur poserait sinon un objet " + "pendant une mesure automatisee (utiliser INSER)."); + } + + if (heightmap->geo().isGeoreferenced()) { + // Le point de depart, exprime dans la projection d'origine : de + // quoi retrouver l'endroit sur une carte et confronter le relief + // affiche a la realite. C'est le seul controle possible du bon + // sens des axes sans orthophoto - un terrain en miroir donnerait + // ici des coordonnees parfaitement plausibles mais un versant du + // mauvais cote. + double east = 0.0, north = 0.0; + heightmap->toProjected(camera.position().x, camera.position().z, + &east, &north); + logInfo("Position de depart : E " + std::to_string(east) + " N " + + std::to_string(north) + " (EPSG:" + + std::to_string(heightmap->geo().epsg) + "), altitude " + + std::to_string(camera.position().y) + " m."); + } + } + + FpsCounter fpsCounter; + + // Le vol n'existe que sur une scene de terrain : decoller suppose un + // relief sous les pieds pour mesurer la hauteur de depart et detecter + // l'atterrissage. + Paraglider paraglider; + KeyEdge paraglideKey; + + // PHASE 13 : le velo. Meme conditions d'existence que le parapente - il + // lui faut un relief sous les roues pour avoir une pente et une + // altitude. Les parametres par defaut sont ceux documentes dans + // world/Bike.hpp ; seule la hauteur d'oeil est reprise de la camera, + // pour que descendre de velo ne fasse pas sauter le point de vue. + BikeParams bikeParams; + bikeParams.eyeHeight = kDefaultEyeHeight; + Bike bike(bikeParams); + KeyEdge bikeKey; + + // PHASE 14 : l'escalade. Comme les deux precedentes, elle n'existe que + // sur une scene de terrain - il lui faut une surface dont lire la pente. + // Tous les parametres sont ceux documentes dans world/Climber.hpp ; + // aucun n'est repris de la camera, parce que l'escalade n'a justement + // PAS de hauteur d'oeil au-dessus du sol (voir Climber::position()). + Climber climber; + KeyEdge climbKey; + + // --- PHASE 16 : les besoins primaires ----------------------------- + // + // Contrairement aux quatre activites, les besoins existent AUSSI sur une + // scene d'objet isole : ils ne demandent au monde qu'une altitude et une + // heure. Ce qui exige un relief, c'est la temperature liee au versant et + // la recherche des points d'eau - les deux sont gardees par `heightmap` + // plus bas, pas par l'existence des jauges. + Needs needs; + + // PHASE 23 : l'horloge prend l'heure et l'echelle demandees en ligne de + // commande. GameClock refuse une echelle nulle (elle la ramene a 1), ce + // qui est le bon comportement pour un jeu ; pour GELER l'horloge d'une + // capture, on ne touche donc pas a l'echelle, on cesse simplement de + // l'avancer - voir clockFrozen plus bas. + const bool clockFrozen = (timeScaleArgument == 0.0f); + GameClock clock(startHourArgument >= 0.0f ? startHourArgument : 9.0f, + timeScaleArgument > 0.0f ? timeScaleArgument : 12.0f); + if (startDayArgument > 0) { + // L'horloge n'expose que advance() pour avancer le compteur TOTAL : + // on s'en sert plutot que d'ajouter une porte derobee. Le calcul est + // exact a la precision du float (au pire quelques secondes de jeu + // sur dix ans). + clock.advance(static_cast(startDayArgument) * 24.0f * 3600.0f / + clock.scale()); + } + if (startHourArgument >= 0.0f || timeScaleArgument >= 0.0f || startDayArgument > 0) { + logInfo(std::string("Horloge : depart au jour ") + + std::to_string(clock.day()) + " a " + clock.clockText() + + (clockFrozen ? ", GELEE (--time-scale=0)." + : ", facteur " + std::to_string(clock.scale()) + ".")); + } + + // --- PHASE 23 : le systeme meteo -------------------------------- + // + // Deterministe et SANS ETAT (voir world/Weather.hpp) : il n'y a rien a + // faire avancer d'une image a l'autre, on l'INTERROGE. Le seul etat du + // monde meteo est l'heure de jeu, et elle vit deja dans `clock`. + // + // Le seed est celui par defaut, donc FIXE : la zone de jeu est unique et + // fabriquee a la main, rien d'autre dans Vercora n'est reseede par + // partie, et un calendrier meteo fixe est ce qui rend deux captures du + // meme instant comparables (voir la lecon de la Phase 12 sur --look). + // PHASE 26 : la declaration a REMONTE avant la construction du monde + // (voir plus haut). L'ordre importe desormais : la Forest decide de + // l'essence de chaque arbre au moment ou elle le plante, donc elle a + // besoin que le soleil existe avant elle. Rien d'autre n'a change - le + // systeme est sans etat, le construire plus tot ne coute rien. + + // PHASE 25 : le shader terrain code en dur l'ecart de reference de + // l'adret/ubac, faute de pouvoir lire un parametre C++. Si quelqu'un + // regle la meteo sans toucher au shader, l'indice VISUEL cesse d'etre + // d'accord avec la TEMPERATURE - exactement le genre de double source de + // verite que la Phase 23 a pris soin d'eviter. On ne peut pas empecher + // la divergence ; on peut refuser qu'elle soit silencieuse. + if (std::abs(weather.params().aspectIncidenceReference - + kShaderAspectIncidenceReference) > 1e-4f) { + logWarn("Adret/ubac : WeatherParams::aspectIncidenceReference vaut " + + std::to_string(weather.params().aspectIncidenceReference) + + " alors que shaders/terrain.frag code " + + std::to_string(kShaderAspectIncidenceReference) + + ". L'indice visuel et la temperature ne diront plus la meme " + "chose : mettre les deux d'accord."); + } + ColdAirTrapMap coldAirTraps; + + // Etat meteo de l'image courante. Calcule UNE FOIS par image, au point du + // joueur, et relu par tout ce qui en a besoin - les besoins, les quatre + // activites, la lumiere. Une seule evaluation par image : recalculer + // dans chaque activite serait a la fois du gaspillage et le retour du + // probleme que cette phase corrige (plusieurs sources de verite). + SynopticState skyState = weather.synopticAt(clock.totalHours()); + WeatherSample localWeather; + float lastWeatherVisualsLog = -1.0f; // PHASE 27, journal borne par le temps + KeyEdge drinkKey; + KeyEdge digKey; // PHASE 22 + KeyEdge resinKey; // PHASE 22 + KeyEdge fiberKey; // PHASE 22 + + // Position de la camera a l'image precedente : sert a distinguer un + // joueur qui MARCHE d'un joueur qui s'est arrete (voir + // kRestSpeedThreshold). Initialisee a la position de depart pour que la + // toute premiere image ne compte pas comme un deplacement de 500 m. + glm::vec3 previousPlayerPosition = camera.position(); + + // Points d'eau : detectes UNE FOIS au chargement, jamais recalcules - + // le relief ne bouge pas. Le balayage coute quelques milliers d'appels a + // heightAt (voir world/WaterSource.hpp pour la methode et ses limites). + std::vector waterSources; + if (heightmap) { + const float half = 0.5f * heightmap->worldSize(); + waterSources = findWaterSources(*heightmap, -half, half, -half, half); + logInfo("Points d'eau : " + std::to_string(waterSources.size()) + + " creux retenus sur " + std::to_string(heightmap->worldSize()) + + " m d'emprise. Touche T pour boire quand on est a moins de " + + std::to_string(kDrinkReach) + " m de l'un d'eux."); + for (std::size_t i = 0; i < waterSources.size() && i < 5; ++i) { + logInfo(" point d'eau " + std::to_string(i + 1) + " : " + + std::to_string(waterSources[i].position.x) + " " + + std::to_string(waterSources[i].position.y) + " " + + std::to_string(waterSources[i].position.z) + + " (creux de " + std::to_string(waterSources[i].depth) + " m)"); + } + if (waterSources.empty()) { + logWarn("Points d'eau : aucun creux ne passe les criteres sur ce " + "relief. La soif ne sera pas etanchable ici - voir " + "world/WaterSource.hpp (WaterSurveyParams)."); + } + } + + // --- PHASE 23 : carte de piegeage d'air froid ----------------------- + // Precalculee UNE FOIS au chargement, exactement comme les points d'eau + // ci-dessus et pour la meme raison - le relief ne bouge pas. C'est + // l'exigence de cout du cahier des charges : l'inversion de fond de + // cuvette demande de savoir quels points sont ENFERMES par du relief plus + // haut, ce qui est une question sur la topographie et pas sur l'instant. + // + // 128 x 128 sur les 25 km2 de la zone de jeu = des cellules de 39 m, la + // bonne echelle pour une cuvette (une cuvette de 39 m n'en est pas une), + // pour 393 216 lectures de heightmap payees une seule fois. + if (heightmap) { + const float half = 0.5f * heightmap->worldSize(); + coldAirTraps = ColdAirTrapMap(*heightmap, half, 128); + weather.setTrapMap(&coldAirTraps); + logInfo("Meteo : carte de piegeage d'air froid 128x128 sur " + + std::to_string(heightmap->worldSize()) + + " m (index moyen " + std::to_string(coldAirTraps.meanValue()) + + ", maximum " + std::to_string(coldAirTraps.maxValue()) + ")."); + logInfo("Meteo : " + weather.synopticAt(clock.totalHours()).describe()); + } else { + logInfo("Meteo : aucun relief charge - pas de carte de piegeage, donc " + "aucune inversion de fond de cuvette. Le reste du systeme " + "meteo fonctionne normalement."); + } + + // --- PHASE 22 : les gisements d'argile et de sable ------------------ + // Detectes UNE FOIS au chargement, comme les points d'eau et pour la + // meme raison : le relief ne bouge pas. Ils sont cherches APRES l'eau, + // et ce n'est pas un detail d'ordonnancement - c'est la liste des points + // d'eau qui decide lesquels sont de l'argile et lesquels sont du sable + // (voir world/Deposits.hpp). + // + // A LIRE AVANT DE S'Y FIER : ce placement est un PROXY MORPHOLOGIQUE et + // non une carte geologique. Le LiDAR ne porte aucune information de + // nature de terrain ; ces gisements sont places la ou ils seraient + // PLAUSIBLES, pas la ou ils sont. + std::vector deposits; + if (heightmap) { + const float half = 0.5f * heightmap->worldSize(); + deposits = findMineralDeposits(*heightmap, -half, half, -half, half, + waterSources); + std::size_t clayCount = 0; + for (const MineralDeposit& deposit : deposits) { + if (deposit.kind == DepositKind::Clay) { + ++clayCount; + } + } + logInfo("Gisements : " + std::to_string(deposits.size()) + + " retenus (" + std::to_string(clayCount) + " d'argile, " + + std::to_string(deposits.size() - clayCount) + " de sable). " + "Touche Y pour creuser a moins de " + + std::to_string(kDigReach) + " m. PLACEMENT PAR PROXY " + "MORPHOLOGIQUE (creux + versant amont, argile pres de l'eau) " + "- ce n'est PAS une carte geologique, voir " + "world/Deposits.hpp."); + for (std::size_t i = 0; i < deposits.size() && i < 5; ++i) { + logInfo(std::string(" gisement ") + std::to_string(i + 1) + " : " + + depositLabel(deposits[i].kind) + " en " + + std::to_string(deposits[i].position.x) + " " + + std::to_string(deposits[i].position.y) + " " + + std::to_string(deposits[i].position.z) + + " (creux " + std::to_string(deposits[i].depth) + + " m, amont " + std::to_string(deposits[i].upslope) + " m)"); + } + } + + // --- PHASE 22 : le marquage des resineux --------------------------- + // Aucune donnee ne dit qu'un arbre est un resineux (ni le mesh, ni la + // carte de canopee) : c'est une convention DETERMINISTE, recalculee et + // jamais stockee. Voir world/Resin.hpp pour la limite assumee. + ResinStand resinStand; + + // --- PHASE 22 : les plantes a fibres ------------------------------- + // Branchees sur l'Habitat par ClearingSource : une zone ou le joueur a + // abattu des arbres se met a porter des ronces. C'est la premiere fois + // dans ce projet qu'une action du joueur FAIT APPARAITRE quelque chose + // au lieu de le retirer. + std::unique_ptr fiberPlants; + if (terrainScene && heightmap) { + fiberPlants = std::make_unique( + *heightmap, coverMap.get(), 0.5f * heightmap->worldSize()); + fiberPlants->setClearingSource(&habitat); + logInfo(std::string("Plantes a fibres : semis actif") + + (coverMap ? " (lisiere LiDAR + sol ouvert par le joueur)" + : " (sol ouvert par le joueur SEULEMENT : aucune " + "carte de couvert, donc aucune lisiere connue)") + + ". Touche I pour en arracher une a moins de " + + std::to_string(kPullReach) + " m."); + } + + // --- PHASE 29 : rochers et pierriers -------------------------------- + // Semes UNIQUEMENT sous le masque de NOTES-PHASE29-DESIGN.md (pente + // Climber 0,60-0,84, couvert LiDAR < 0,10). Sans carte de couvert, + // Rocks est vide : aucun rocher sans donnee reelle. + std::unique_ptr rocks; + MeshHandle boulderMeshHandle = kInvalidMesh; + MeshHandle rockMeshHandle = kInvalidMesh; + MeshHandle gravelMeshHandle = kInvalidMesh; + if (terrainScene && heightmap && useRocks) { + RockParams rockParams; + rockParams.collide = rockCollision; + rocks = std::make_unique(*heightmap, coverMap.get(), + 0.5f * heightmap->worldSize(), rockParams); + if (rocks->enabled()) { + boulderMeshHandle = renderer.addMesh(boulderMeshData()); + rockMeshHandle = renderer.addMesh(rockMeshData()); + gravelMeshHandle = renderer.addMesh(gravelMeshData()); + worldSolver.add(rocks.get()); + const Rocks::Stats rs = rocks->estimate(); + char line[320]; + std::snprintf(line, sizeof(line), + "Rochers (PHASE 29) : masque pierrier %.1f %% de la zone ; " + "%.2f gros blocs, %.2f rochers, %.1f plaques de pierraille " + "par ha de zone ; collision des gros blocs %s.", + 100.0 * rs.maskFraction, rs.bouldersPerHa, rs.stonesPerHa, + rs.gravelPerHa, + rockCollision ? "ACTIVE" : "DESACTIVEE (--no-rock-collision)"); + logInfo(line); + } else { + logInfo("Rochers (PHASE 29) : aucune carte de couvert LiDAR, donc AUCUN " + "rocher (pas de semis sans donnee reelle)."); + } + } else if (terrainScene && !useRocks) { + logInfo("Rochers DESACTIVES (--no-rocks) : monde d'avant la Phase 29, temoin."); + } + + // --- PHASE 29 (Agent 3) : buissons et petits arbres ----------------- + // Pilotes par la classe 3 LiDAR seule (NOTES-PHASE29-DESIGN.md s.2) : + // assets/terrain/_canopy_lowveg.vchm (F3) et + // _canopy_lowveg_height.vchm (h max classe 3), meme convention de + // nommage que les cartes de couvert (canopyPathFor). Le couvert (deja + // charge) ne sert qu'a EXCLURE. Une carte absente -> aucun buisson. + std::unique_ptr lowVegMap; + std::unique_ptr lowVegHeightMap; + std::unique_ptr bushes; + MeshHandle shrubMeshHandle = kInvalidMesh; + MeshHandle smallTreeMeshHandle = kInvalidMesh; + if (terrainScene && heightmap && useBushes) { + const std::string lowVegPath = canopyPathFor(resolvedTerrainFile, "_lowveg"); + const std::string lowVegHeightPath = canopyPathFor(resolvedTerrainFile, "_lowveg_height"); + for (auto* slot : { &lowVegMap, &lowVegHeightMap }) { + const std::string& path = (slot == &lowVegMap) ? lowVegPath : lowVegHeightPath; + if (!std::filesystem::exists(path)) { continue; } + try { + *slot = std::make_unique(loadTerrainFile(path)); + } catch (const std::exception& error) { + logWarn(std::string("Carte de vegetation basse : ") + error.what()); + } + } + bushes = std::make_unique(*heightmap, lowVegMap.get(), lowVegHeightMap.get(), + coverMap.get(), 0.5f * heightmap->worldSize()); + if (bushes->enabled()) { + if (forest) { + std::vector footprints; + footprints.reserve(forest->trees().size()); + for (const Tree& tree : forest->trees()) { + footprints.emplace_back(tree.base.x, tree.base.z, tree.crownRadius()); + } + bushes->setTreeFootprints(std::move(footprints)); + } + shrubMeshHandle = renderer.addMesh(shrubMeshData()); + smallTreeMeshHandle = renderer.addMesh(smallTreeMeshData()); + const Bushes::Stats bs = bushes->estimate(); + char line[320]; + std::snprintf(line, sizeof(line), + "Buissons (PHASE 29) : masque classe 3 %.1f %% de la zone ; " + "%.1f buissons et %.1f petits arbres par ha de zone ; " + "traversables ; %zu emprises d'arbres exclues.", + 100.0 * bs.maskFraction, bs.shrubsPerHa, bs.smallTreesPerHa, + forest ? forest->trees().size() : std::size_t{0}); + logInfo(line); + } else { + logInfo("Buissons (PHASE 29) : carte classe 3 ou couvert absent (" + lowVegPath + + "), donc AUCUN buisson (pas de semis sans donnee reelle)."); + } + } else if (terrainScene && !useBushes) { + logInfo("Buissons DESACTIVES (--no-bushes) : temoin."); + } + + // --- PHASE 17 : premier peuplement ---------------------------------- + // Peupler AVANT la premiere image, sinon le joueur voit le monde se + // remplir sous ses yeux pendant les premieres secondes - ce qui montre + // la mecanique au lieu du monde. C'est la meme raison qui fait que le + // semis d'arbres est fait au constructeur de Forest. + if (wildlife) { + wildlife->populate(camera.position(), habitat); + logInfo("Faune : " + std::to_string(wildlife->animalCount()) + + " animaux au depart dans un rayon de " + + std::to_string(wildlife->params().spawnRadiusMax) + + " m (le couvert et la pente refusent le reste)."); + if (wildlife->animalCount() == 0) { + logWarn("Faune : aucun animal place. Terrain trop raide ou couvert " + "LiDAR trop faible autour du depart - voir " + "WildlifeParams::minCover et maxSlope."); + } + } + + logInfo("Initialisation terminee. Clic droit maintenu + ZQSD pour bouger" + + std::string(terrainScene + ? ", F pour basculer marche/vol libre, E pour abattre l'arbre" + " vise, R pour ramasser, P pour reposer au sol, C pour faconner" + " (percuter deux pierres, ou assembler ce qui est pose), V pour" + " decoller en parapente depuis le mode vol libre (en hauteur)," + " B pour enfourcher le velo depuis la marche (puis Z pedaler," + " S freiner, Q/D tourner), X pour s'engager sur une paroi" + " grimpable depuis la marche (puis Z/S monter et descendre," + " Q/D traverser), T pour boire a un point d'eau," + " F2 pour le MODE EDITEUR." + : ", espace/shift pour monter/descendre.")); + + // Reutilisee a chaque frame : la liste des objets varie en contenu mais + // pas en ordre de grandeur, donc on garde sa capacite d'une frame a + // l'autre au lieu de reallouer 60 fois par seconde. + std::vector drawItems; + + // Reutilises d'une frame a l'autre : leur capacite se stabilise apres + // quelques images, donc plus aucune allocation en regime etabli. + std::vector instancedItems; + std::vector treeInstances; // resineux (PHASE 26) + std::vector broadleafInstances; // feuillus (PHASE 26) + std::vector grassInstances; + std::vector fiberInstances; // PHASE 22 + std::vector boulderInstances; // PHASE 29 + std::vector stoneInstances; // PHASE 29 + std::vector gravelInstances; // PHASE 29 + std::vector shrubInstances; // PHASE 29 (Agent 3) + std::vector smallTreeInstances; // PHASE 29 (Agent 3) + + // Trois etats plutot qu'un booleen : pouvoir isoler les arbres de + // l'herbe est ce qui permet d'attribuer un cout de FPS a l'un ou a + // l'autre pendant une mesure, et de faire des captures comparables. + enum class VegetationMode { All, TreesOnly, None }; + VegetationMode vegetationMode = VegetationMode::All; + + const auto startTime = std::chrono::steady_clock::now(); + double lastTime = glfwGetTime(); + + KeyEdge fellKey; + KeyEdge orthoKey; + KeyEdge vegetationKey; + KeyEdge pickupKey; + KeyEdge knapKey; + KeyEdge putDownKey; // PHASE 28 + + // --- PHASE 15 : etat du mode editeur ---------------------------- + EditorController editorController(editorCatalog, editorScene); + bool editorMode = false; + // --editor : la bascule est demandee comme si F2 avait ete presse a la + // premiere image, plutot que dupliquee ici. C'est ce qui garantit que + // demarrer en edition passe par EXACTEMENT le meme chemin que d'y entrer + // en cours de partie - donc que les deux ne peuvent pas diverger. + bool editorToggleRequested = startInEditor; + float editorFlySpeed = kEditorFlySpeed; + // Ce qu'on rend a la sortie du mode edition. La camera d'edition est un + // vol libre rapide ; retrouver la marche - et la vitesse de marche - + // exactement comme on les avait laissees est ce qui permet d'aller + // retoucher un rocher en pleine partie sans perdre sa position. + CameraMode editorPreviousMode = CameraMode::Walk; + float editorPreviousSpeed = 14.0f; + + // PHASE 24 : dernier etat JOURNALISE du filtre de pente de la marche. + // Sert uniquement a n'ecrire une ligne que sur transition - voir le bloc + // qui suit camera.update(). + bool walkBlockedWasLogged = false; + bool walkSlidingWasLogged = false; + // Instant de la derniere ligne emise par ce bloc. Voir le limiteur de + // cadence qui suit camera.update() : un etat qui BAT n'est pas un + // evenement, et ne doit pas se payer en lignes de journal. + double walkLogLastTime = -1000.0; + + KeyEdge editorToggleKey; + KeyEdge editorPlaceButton; + KeyEdge editorPlaceKey; + KeyEdge editorPickKey; + KeyEdge editorGrabKey; + KeyEdge editorDeleteKey; + KeyEdge editorCancelKey; + KeyEdge editorNextKey; + KeyEdge editorNextKey2; + KeyEdge editorPrevKey; + KeyEdge editorSolidKey; + KeyEdge editorUndoKey; + KeyEdge editorSaveKey; + KeyEdge editorReloadKey; + KeyEdge editorListKey; + KeyEdge editorCycleNextKey; + KeyEdge editorCyclePrevKey; + std::array editorQuickKeys{}; + + const std::string kEditorHelp = + "Editeur (F2 pour sortir) : ZQSD + espace/maj-gauche pour voler, " + "molette = vitesse de vol, clic droit = regarder. " + "Clic gauche ou INSER = poser au point vise, E = selectionner " + "l'objet vise, " + "G = saisir/reposer, SUPPR = supprimer, ECHAP = annuler la saisie. " + "TAB ou PAGE_SUIV / PAGE_PREC = asset suivant/precedent, 1..9 = rang " + "direct. Fleches gauche/droite = tourner, haut/bas = echelle, " + "DEBUT/FIN = monter/descendre par rapport au sol, K = solide <-> " + "traversable, CTRL gauche = pas fin. F3/F4 = objet pose suivant/" + "precedent (sans viser). RETOUR ARRIERE = annuler, " + "F5 = sauvegarder, F9 = recharger, L = reafficher le catalogue."; + + // Resynchronise TOUS les fronts descendants, jeu et editeur confondus. + // + // Appelee a chaque bascule de mode, et pour un defaut precis : chaque + // KeyEdge ne se met a jour que lorsqu'on l'interroge, or le jeu + // n'interroge pas les touches d'editeur et reciproquement. Une touche + // maintenue pendant la bascule apparaitrait donc comme un front + // descendant a la premiere image du nouveau mode - entrer en edition + // avec E enfonce selectionnerait un objet, en sortir avec E enfonce + // abattrait un arbre. Les interroger tous une fois au moment de la + // bascule fixe leur etat sur la realite du clavier. + const auto syncAllKeyEdges = [&]() { + fellKey.justPressed(window, kFellKey); + pickupKey.justPressed(window, kPickupKey); + knapKey.justPressed(window, kKnapKey); + putDownKey.justPressed(window, kPutDownKey); + paraglideKey.justPressed(window, kParaglideKey); + bikeKey.justPressed(window, kBikeKey); + climbKey.justPressed(window, kClimbKey); + drinkKey.justPressed(window, kDrinkKey); + digKey.justPressed(window, kDigKey); + resinKey.justPressed(window, kResinKey); + fiberKey.justPressed(window, kFiberKey); + vegetationKey.justPressed(window, kVegetationKey); + orthoKey.justPressed(window, kOrthoKey); + + editorPlaceButton.justPressed( + window.isMouseButtonPressed(GLFW_MOUSE_BUTTON_LEFT)); + editorPlaceKey.justPressed(window, kEditorPlaceKey); + editorPickKey.justPressed(window, kEditorPickKey); + editorGrabKey.justPressed(window, kEditorGrabKey); + editorDeleteKey.justPressed(window, kEditorDeleteKey); + editorCancelKey.justPressed(window, kEditorCancelKey); + editorNextKey.justPressed(window, kEditorNextKey); + editorNextKey2.justPressed(window, kEditorNextKey2); + editorPrevKey.justPressed(window, kEditorPrevKey); + editorSolidKey.justPressed(window, kEditorSolidKey); + editorUndoKey.justPressed(window, kEditorUndoKey); + editorSaveKey.justPressed(window, kEditorSaveKey); + editorReloadKey.justPressed(window, kEditorReloadKey); + editorListKey.justPressed(window, kEditorListKey); + editorCycleNextKey.justPressed(window, kEditorCycleNextKey); + editorCyclePrevKey.justPressed(window, kEditorCyclePrevKey); + for (int i = 0; i < static_cast(editorQuickKeys.size()); ++i) { + editorQuickKeys[static_cast(i)].justPressed( + window, GLFW_KEY_1 + i); + } + }; + + // Le titre porte le compteur d'inventaire : c'est le seul retour visuel + // du ramassage a ce stade, conformement a la philosophie "zero menu". + // On ne le reecrit que quand quelque chose change, un appel systeme par + // frame pour rien etant inutile. + std::string inventoryText = inventory.summary(); + bool titleDirty = true; + long displayedFps = 0; + + // --- PHASE 19 : ou passe le temps CPU d'une image ? ----------------- + // Meme demarche que TerrainStreamer::buildProfile en Phase 18, appliquee + // cette fois a l'IMAGE entiere : la Phase 18 avait montre que le poste + // qu'on croit couteux ne l'est pas, et que le poste couteux n'est pas + // celui qu'on regarde. Rien ici n'est optimise avant d'avoir ete mesure. + // + // Le chronometre est pris SANS condition : un profilage qu'on active a + // la demande finit par mesurer un binaire different de celui qui tourne. + // Le cout est de quelques dizaines de nanosecondes par borne, contre des + // centaines de microsecondes par poste. + struct FrameProfile { + uint64_t frames = 0; + uint64_t streamingMicros = 0; // terrainStreamer->appendDrawItems + uint64_t treesMicros = 0; // Vegetation::gatherTrees + uint64_t grassMicros = 0; // Vegetation::gatherGrass + uint64_t fiberMicros = 0; // FiberPlants::gather (PHASE 22) + uint64_t rocksMicros = 0; // Rocks::gather (PHASE 29) + uint64_t bushesMicros = 0; // Bushes::gather (PHASE 29, Agent 3) + uint64_t drawMicros = 0; // Renderer::drawFrame + uint64_t frustumMicros = 0; // projection * vue + extraction des plans + // PHASE 27 : la traduction meteo -> image (weatherVisualsFor et + // les appels au renderer). Mesuree pour pouvoir AFFIRMER son cout + // CPU au lieu de le supposer negligeable. + uint64_t weatherVisualsMicros = 0; + } frameProfile; + using ProfileClock = std::chrono::steady_clock; + const auto profileMicros = [](ProfileClock::time_point a, + ProfileClock::time_point b) { + return static_cast( + std::chrono::duration_cast(b - a).count()); + }; + + // PHASE 27 : duree reelle de la boucle, pour que le bilan donne une + // cadence (images / secondes de boucle) sans dependre du titre de la + // fenetre, dont la Phase 18 a montre qu'il varie de ~15 % entre deux + // runs identiques. Chargement exclu : il precede la boucle. + const auto loopStart = ProfileClock::now(); + while (!window.shouldClose()) { + window.pollEvents(); + + const double now = glfwGetTime(); + const float deltaTime = static_cast(now - lastTime); + lastTime = now; + + // Temps ecoule depuis le demarrage, pousse aux shaders de vegetation + // pour l'ondulation de l'herbe. glfwGetTime part de zero au + // demarrage, donc la valeur reste petite et n'use pas la precision + // d'un float, contrairement a une horloge absolue. + const float elapsedSeconds = static_cast(now); + + // --- Bascule du MODE EDITEUR (PHASE 15) ------------------------ + // Traitee AVANT camera.update : entrer en edition change le mode et + // la vitesse de la camera, et on veut que ce soit effectif des cette + // image plutot qu'a la suivante. + // + // Le front descendant est lu dans une variable AVANT le test, et non + // dans la condition : place a droite d'un `||`, il serait + // court-circuite l'image ou --editor declenche la bascule, et l'etat + // de la touche F2 ne serait plus tenu a jour. + const bool editorToggleEdge = + editorToggleKey.justPressed(window, kEditorToggleKey); + if (terrainScene && useScene && (editorToggleEdge || editorToggleRequested)) { + editorToggleRequested = false; + if (!editorMode && + (paraglider.flying() || bike.riding() || climber.climbing())) { + // Refus plutot que sortie d'office de l'activite : l'editeur + // reprend la camera, et une activite en cours continuerait de + // lui imposer sa pose a chaque image. Les deux se battraient. + logInfo("Editeur : pas pendant une activite. Terminer le vol, " + "la descente ou l'escalade d'abord."); + } else if (!editorMode) { + editorMode = true; + editorPreviousMode = camera.mode(); + editorPreviousSpeed = camera.moveSpeed(); + camera.setMode(CameraMode::Free); + camera.setMoveSpeed(editorFlySpeed); + // Sans ce verrou, la touche F - encore lue par la camera - + // reposerait l'editeur au sol en mode marche. + camera.setModeLocked(true); + editorController.markStatusChanged(); + logInfo("=== MODE EDITEUR ==="); + logInfo(kEditorHelp); + logInfo(editorCatalog.listing(editorController.brushIndex())); + titleDirty = true; + syncAllKeyEdges(); + } else { + editorMode = false; + editorController.resetInteraction(); + camera.setModeLocked(false); + camera.setMoveSpeed(editorPreviousSpeed); + camera.setMode(editorPreviousMode); + logInfo("=== retour au JEU. Les objets poses restent affiches " + "et solides ; ils ne sont sur le DISQUE que si F5 a ete " + "presse en mode editeur. ==="); + titleDirty = true; + syncAllKeyEdges(); + } + } + + // =============================================================== + // PHASE 16 : besoins primaires + // =============================================================== + // Place AVANT camera.update, et c'est le point qui compte : la + // penalite de fatigue agit en reglant la vitesse de la camera, or + // camera.update deplace le joueur avec la vitesse courante. Calculee + // apres, la penalite ne mordrait qu'a l'image suivante - un decalage + // invisible a l'oeil, mais qui rendrait toute mesure fausse d'une + // image. + // + // Le MODE EDITEUR gele tout : c'est un outil de developpement, on y + // survole 25 km2 en vol libre, et voir la fatigue tomber pendant + // qu'on pose des rochers n'aurait aucun sens. Les jauges reprennent + // exactement ou elles en etaient en sortant (F2). + if (!editorMode) { + if (!clockFrozen) { + clock.advance(deltaTime); + } + + // Ou est REELLEMENT le joueur : chaque activite a sa propre + // position, la camera ne suit qu'en chase-cam pour deux d'entre + // elles. Prendre camera.position() sans distinguer donnerait + // l'altitude de l'oeil qui suit le parapente, pas celle du + // pilote. + glm::vec3 playerPosition = camera.position(); + Activity activity = Activity::Walk; + if (paraglider.flying()) { + playerPosition = paraglider.position(); + activity = Activity::Paraglide; + } else if (bike.riding()) { + playerPosition = bike.position(); + activity = Activity::Bike; + } else if (climber.climbing()) { + playerPosition = climber.anchor(); + activity = Activity::Climb; + } else { + // A pied : marche ou repos, selon qu'on a bouge ou non + // depuis l'image precedente. Le mode vol libre (F) compte + // comme du repos - ce n'est pas une facon de se deplacer + // dans le monde, c'est un mode d'inspection. + const glm::vec3 step = playerPosition - previousPlayerPosition; + const float horizontal = + std::sqrt(step.x * step.x + step.z * step.z); + const bool moving = + camera.mode() == CameraMode::Walk && deltaTime > 0.0f && + horizontal / deltaTime > kRestSpeedThreshold; + activity = moving ? Activity::Walk : Activity::Rest; + } + previousPlayerPosition = camera.position(); + + // --- PHASE 23 : la meteo de cette image ------------------ + // UNE seule evaluation par image, au point ou est reellement le + // joueur. Tout ce qui suit - les jauges, les quatre activites, + // la lumiere - relit CE resultat. C'est la traduction directe de + // "une seule source de verite" : deux appels a sampleAt() dans + // la meme image seraient deja deux occasions de diverger, en + // plus d'un cout paye deux fois. + skyState = weather.synopticAt(clock.totalHours()); + localWeather = weather.sampleAt(playerPosition, skyState, heightmap.get()); + + // PHASE 21 : en mode DEMO, les besoins n'existent pas - ni la + // jauge, ni son effet sur la vitesse de marche, ni l'action de + // boire. La vitesse reste donc la reference constante kWalkSpeed + // au lieu d'etre modulee par needs.movementFactor(). + if (!demoMode) { + NeedsContext needsContext; + needsContext.activity = activity; + + // PHASE 23 : l'ambiante n'est plus calculee par Needs. Elle + // vient du systeme meteo, qui tient compte de l'altitude, de + // l'heure, de la saison, de la masse d'air, du versant et de + // l'inversion de fond de cuvette. Un seul calcul de + // temperature dans tout le jeu. + needsContext.ambientTemperatureC = localWeather.temperatureC; + + // PHASE 28 (Agent 3) : chaleur des foyers ALLUMES. On corrige + // l'ambiante LOCALE au lieu d'ecrire une seconde formule : + // Needs la traite ensuite comme n'importe quelle ambiante + // (vent, effort, abri, marge au confort). 8 degres au centre, + // lineaire jusqu'a 0 a 6 m (HearthParams). Sans foyer : + 0, + // exactement l'ambiante meteo d'avant (scenario H intact). + needsContext.ambientTemperatureC += hearths.warmthAt(playerPosition); + + // PHASE 28 (Agent 3) : premier appelant de sheltered. Un abri + // pose a moins de 2,5 m : +5 degres et vent annule (Needs.cpp). + needsContext.sheltered = ground && shelterNear(*ground, playerPosition); + + // Vent RELATIF : au vent du lieu s'ajoute la vitesse propre + // du joueur quand elle compte. En parapente et a velo on + // fabrique son propre vent, et c'est ce qui refroidit - c'est + // le mecanisme reel derriere le forfait de -6 degres que la + // Phase 16 reservait au vol. + float relativeWind = localWeather.windMps; + if (paraglider.flying()) { + relativeWind += ParagliderParams{}.cruiseSpeed; + } else if (bike.riding()) { + relativeWind += bike.speed(); + } + needsContext.windSpeedMps = relativeWind; + + needs.update(deltaTime, needsContext); + + // LA consequence, appliquee en un seul endroit pour les + // quatre activites : la marche ici, le pedalage et la montee + // en paroi plus bas (les deux multiplient leur commande par + // ce meme coefficient). Reappliquee a chaque image parce que + // le coefficient bouge en continu. + camera.setMoveSpeed(kWalkSpeed * needs.movementFactor()); + + // --- Boire ------------------------------------------- + // Uniquement a pied et a portee d'un point d'eau detecte sur + // le relief. Le refus est journalise avec la distance : sans + // elle, "trop loin" ne dit pas s'il faut faire deux pas ou + // deux kilometres. + if (drinkKey.justPressed(window, kDrinkKey)) { + float distance = 0.0f; + const WaterSource* source = + nearestWaterSource(waterSources, playerPosition, &distance); + if (source == nullptr) { + logInfo("Boire : aucun point d'eau connu sur ce terrain."); + } else if (distance > kDrinkReach) { + logInfo("Boire : le point d'eau le plus proche est a " + + std::to_string(distance) + " m (il faut etre a " + + std::to_string(kDrinkReach) + " m)."); + } else if (needs.drink()) { + logInfo("Boire : soif etanchee au point d'eau (" + + std::to_string(distance) + " m). " + + needs.statusLine()); + } else { + logInfo("Boire : pas soif."); + } + } + + // --- PHASE 22 : creuser un gisement ------------------ + // Meme forme exactement que "boire" juste au-dessus : une + // portee horizontale, un refus JOURNALISE AVEC LA DISTANCE + // (sans elle, "trop loin" ne dit pas s'il faut faire deux + // pas ou deux kilometres), et rien qui ressemble a un menu. + // + // La matiere tombe AU SOL devant le joueur et non dans son + // inventaire : c'est la regle posee en Phase 6 par l'eclat + // de percussion, et elle vaut pour les trois matieres de + // cette phase. Ce qui est produit doit d'abord EXISTER + // quelque part. + if (digKey.justPressed(window, kDigKey)) { + float distance = 0.0f; + const MineralDeposit* deposit = + nearestDeposit(deposits, playerPosition, &distance); + if (deposit == nullptr) { + logInfo("Creuser : aucun gisement connu sur ce terrain."); + } else if (distance > kDigReach) { + logInfo(std::string("Creuser : le gisement de ") + + depositLabel(deposit->kind) + " le plus proche " + "est a " + std::to_string(distance) + + " m (il faut etre a " + std::to_string(kDigReach) + + " m)."); + } else if (ground) { + const GroundItemKind kind = + (deposit->kind == DepositKind::Clay) + ? GroundItemKind::Clay + : GroundItemKind::Sand; + const glm::vec3 facing = camera.front(); + glm::vec3 flat(facing.x, 0.0f, facing.z); + const float flatLength = + std::sqrt(flat.x * flat.x + flat.z * flat.z); + // Meme precaution qu'au taillage de pierre : on teste + // AVANT de normaliser. Normaliser un vecteur nul + // propagerait des NaN jusque dans la position de + // l'objet, qui disparaitrait du monde sans un mot. + flat = (flatLength > 1e-4f) ? flat / flatLength + : glm::vec3(1.0f, 0.0f, 0.0f); + ground->drop(kind, playerPosition.x + flat.x * 1.1f, + playerPosition.z + flat.z * 1.1f, + std::atan2(-flat.z, flat.x), 0.0f); + logInfo(std::string("Creuser : ") + + groundItemLabelIndefinite(kind) + + " se detache du gisement et tombe a vos pieds."); + } + } + + // --- PHASE 22 : saigner un resineux ------------------ + // La difference avec l'abattage (touche E) est le point de + // toute la mecanique, et elle est visible ici : on VISE le + // meme arbre, par le MEME Forest::pickTree et avec la meme + // portee - mais rien n'est abattu, rien n'est debite, et + // l'Habitat n'enregistre aucune coupe. L'arbre reste debout. + if (resinKey.justPressed(window, kResinKey)) { + if (!forest) { + logInfo("Resine : aucun arbre dans ce monde."); + } else { + const int target = forest->pickTree( + camera.position(), camera.front(), kFellingReach); + // PHASE 26 : l'essence vient de L'ARBRE VISE, celle-la + // meme dont la silhouette est dessinee a l'ecran. Un + // arbre conique donne de la resine, un arbre a + // houppier rond n'en donne pas, et le joueur le voit + // AVANT d'appuyer - c'est la dette de la Phase 22 qui + // se referme ici, au point d'usage. + const TreeSpecies aimedSpecies = + (target >= 0) + ? forest->trees()[static_cast(target)].species + : TreeSpecies::Broadleaf; + const ResinResult result = + resinStand.tap(target, aimedSpecies, elapsedSeconds); + logInfo(resinResultMessage(result)); + if (result == ResinResult::StillDry && target >= 0) { + const float wait = + resinStand.secondsUntilFlow(target, elapsedSeconds); + logInfo(" entailles deja faites : " + + std::to_string(resinStand.tapCount(target)) + + (wait > 0.0f + ? ", il faut encore " + + std::to_string(wait) + " s" + : ", arbre epuise")); + } + if (result == ResinResult::Success && ground) { + const glm::vec3 base = forest->trees()[ + static_cast(target)].base; + ground->drop(GroundItemKind::Resin, base.x, base.z, + 0.0f, 0.0f); + } + } + } + + // --- PHASE 22 : arracher une plante a fibres --------- + // La seule des trois qui RETIRE quelque chose du monde : la + // plante disparait du semis et met sept minutes a repousser, + // a la meme place et a la meme taille (le semis est une + // fonction deterministe de la cellule, donc rien ne se + // perd). Les gisements et les arbres, eux, restent. + if (fiberKey.justPressed(window, kFiberKey)) { + if (!fiberPlants) { + logInfo("Fibres : aucun semis de plantes sur ce terrain."); + } else { + FiberPlant pulled; + if (fiberPlants->pullNearest(playerPosition, kPullReach, + &pulled)) { + if (ground) { + ground->drop(GroundItemKind::Fiber, + pulled.position.x, pulled.position.z, + pulled.yaw, 0.0f); + } + logInfo("Fibres : la tige cede, un fagot tombe a vos " + "pieds. La plante repoussera ici meme."); + } else { + logInfo("Fibres : aucune plante a fibres a portee " + "(il faut etre a " + std::to_string(kPullReach) + + " m). Elles poussent en lisiere de foret et sur " + "les coupes."); + } + } + } + } else { + camera.setMoveSpeed(kWalkSpeed); + // Fronts tenus a jour a vide : sans ca, revenir a la marche en + // tenant l'une de ces touches declencherait le geste au + // premier relachement. + drinkKey.justPressed(window, kDrinkKey); + digKey.justPressed(window, kDigKey); + resinKey.justPressed(window, kResinKey); + fiberKey.justPressed(window, kFiberKey); + } + + // =========================================================== + // PHASE 17 : empreinte environnementale + // =========================================================== + // Trois lignes, et tout le systeme est la. Elles sont placees + // DANS le bloc des besoins parce qu'elles ont besoin d'exactement + // les memes deux grandeurs, deja calculees juste au-dessus : ou + // est REELLEMENT le joueur (et non ou est la camera, qui suit en + // chase-cam pendant deux activites) et CE QU'IL FAIT. + // + // Les recalculer ici les ferait diverger le jour ou une + // cinquieme activite arrivera. Consequence assumee : comme les + // besoins, l'empreinte est GELEE en mode editeur - survoler + // 25 km2 en vol libre pour poser des rochers ne doit pas + // effrayer la faune de toute la vallee. + if (useWildlife) { + habitat.notePresence(playerPosition, deltaTime, + activityNoise(activity)); + habitat.update(deltaTime); + if (wildlife) { + wildlife->update(deltaTime, playerPosition, habitat); + } + } + + // PHASE 22 : la repousse des plantes arrachees. Volontairement + // HORS du bloc `useWildlife` ci-dessus : --no-wildlife est le + // temoin de la faune, pas une raison pour qu'une ronce cesse de + // repousser. Elle est en revanche dans le bloc des besoins, + // donc GELEE en mode editeur, pour la meme raison qu'eux. + if (fiberPlants) { + fiberPlants->update(deltaTime); + } + + // Le titre n'est PAS marque sale ici. Il l'est deja une fois + // par seconde par le compteur de FPS, et les jauges y sont + // affichees en pourcentages ENTIERS : les rafraichir soixante + // fois par seconde ferait soixante appels systeme pour montrer + // le meme texte. + } else { + // Le front descendant de la touche est tenu a jour a vide, comme + // toutes les touches de jeu pendant l'edition (voir + // syncAllKeyEdges) : sans ca, sortir de l'editeur en tenant T + // ferait boire au premier relachement. + drinkKey.justPressed(window, kDrinkKey); + digKey.justPressed(window, kDigKey); + resinKey.justPressed(window, kResinKey); + fiberKey.justPressed(window, kFiberKey); + } + + camera.update(window, deltaTime); + + // --- PHASE 24 : la pente a-t-elle arrete le marcheur ? ----------- + // Journalise UNIQUEMENT les CHANGEMENTS d'etat (marchable <-> trop + // raide, glisse <-> tient debout). Ce n'est pas de l'economie de + // place : le harnais de verification paie un cout par ligne de + // journal et son retard croit avec le volume - une ligne par frame + // ferait echouer des scenarios entiers pour un jeu correct, ce qui + // s'est deja produit en Phase 23. Deux ou trois lignes par approche + // de paroi suffisent a dire ce qui s'est passe. + if (camera.mode() == CameraMode::Walk) { + const WalkStepResult& walkStep = camera.lastWalkStep(); + const bool blocked = walkStep.speedFactor <= 0.0f; + + // LIMITEUR DE CADENCE, et ce n'est pas du confort. + // + // "Journaliser sur changement d'etat" ne suffit PAS : un joueur + // qui longe du terrain juste au seuil bascule d'un cote a + // l'autre a chaque frame, et chaque bascule est un changement + // d'etat legitime. Premiere mesure sur la suite complete : 494 + // lignes, et le scenario I a perdu 40 % de sa telemetrie (150 + // releves au lieu de 254). + // + // C'est le meme defaut qu'en Phase 23, une cadence de journal + // qui fait echouer un scenario pour un jeu parfaitement + // correct - et il s'est reproduit ici parce que "sur + // changement" SEMBLE deja econome. Un etat qui BAT n'est pas un + // evenement. + // + // Une seconde entre deux lignes : assez pour qu'une vraie + // approche de paroi laisse une trace lisible, assez pour qu'un + // battement a 60 Hz coute au plus une ligne par seconde. + constexpr double kWalkLogMinInterval = 1.0; + const bool walkLogAllowed = + (now - walkLogLastTime) >= kWalkLogMinInterval; + + if (blocked != walkBlockedWasLogged && walkLogAllowed) { + walkLogLastTime = now; + walkBlockedWasLogged = blocked; + logInfo(std::string("Marche : ") + + (blocked ? "pente trop raide, progression arretee (" + : "pente de nouveau franchissable (") + + std::to_string(100.0f * walkStep.slopeAhead) + + " % devant, limite " + + std::to_string(100.0f * camera.walkSlopeParams().maxSlope) + + " %)."); + } + if (walkStep.sliding != walkSlidingWasLogged && walkLogAllowed) { + walkLogLastTime = now; + walkSlidingWasLogged = walkStep.sliding; + logInfo(std::string("Marche : ") + + (walkStep.sliding ? "le joueur GLISSE vers l'aval (" + : "le joueur retrouve son appui (") + + std::to_string(100.0f * walkStep.slopeUnderFoot) + + " % sous les pieds)."); + } + } + + // --- Survol scripte (PHASE 12) ---------------------------------- + // Reproduit le scenario qui a motive le chantier : traverser la zone + // de 25 km2 assez vite pour que le streaming n'ait pas le temps de + // suivre. Scripte plutot que pilote au clavier parce que le harnais + // de test ne peut pas commander la souris (voir run_vulkan_check.ps1) + // et parce qu'une trajectoire reproductible est la condition pour + // comparer deux runs. + if (flythroughSpeed > 0.0f && heightmap) { + glm::vec3 position = camera.position(); + const glm::vec3 front = camera.front(); + glm::vec3 heading(front.x, 0.0f, front.z); + const float headingLength = glm::length(heading); + // Camera exactement verticale : cap indefini, on garde l'axe X. + heading = (headingLength > 1e-4f) ? heading / headingLength + : glm::vec3(1.0f, 0.0f, 0.0f); + + position += heading * flythroughSpeed * deltaTime; + + // Virage de 90 degres a l'approche du bord : la camera reste dans + // l'emprise indefiniment, donc la duree du test ne depend plus de + // la taille du terrain. La marge evite de tourner PILE sur le + // bord, ou la moitie du champ de vision serait hors donnees. + const float limit = 0.5f * heightmap->worldSize() - 250.0f; + if (std::abs(position.x) > limit || std::abs(position.z) > limit) { + position.x = std::clamp(position.x, -limit, limit); + position.z = std::clamp(position.z, -limit, limit); + camera.setOrientation(camera.yawDegrees() + 90.0f, + camera.pitchDegrees()); + } + + position.y = heightmap->heightAt(position.x, position.z) + + flythroughAltitude; + camera.setPosition(position); + } + + // --- MODE EDITEUR : entrees, placement, previsualisation -------- + // Tout le mode tient dans ce bloc, et il est EXCLUSIF : tant qu'il + // est actif, aucune touche de jeu n'est lue (voir les gardes + // !editorMode ci-dessous). C'est ce qui autorise le mode edition a + // reprendre des lettres deja prises par le jeu. + if (editorMode && heightmap) { + // Molette : vitesse de vol. Multiplicative, comme le reglage + // d'echelle de l'editeur et pour la meme raison - le rapport + // entre 5 et 10 m/s est le meme geste que celui entre 200 et + // 400, alors qu'un pas additif rendrait l'un des deux inutile. + const double scroll = window.consumeScroll(); + if (scroll != 0.0) { + editorFlySpeed = std::clamp( + editorFlySpeed * + std::pow(kEditorFlySpeedStep, static_cast(scroll)), + kEditorFlySpeedMin, kEditorFlySpeedMax); + camera.setMoveSpeed(editorFlySpeed); + logInfo("Editeur : vitesse de vol " + + std::to_string(editorFlySpeed) + " m/s."); + } + + EditorInput editorInput; + editorInput.deltaTime = deltaTime; + editorInput.now = elapsedSeconds; + // MEME rayon que la visee d'arbre du jeu (Forest::pickTree est + // appele plus bas avec ces deux memes valeurs) : le reticule de + // l'editeur est donc exactement celui du joueur. + editorInput.eye = camera.position(); + editorInput.forward = camera.front(); + + // --- LA SOURIS EST COUPEE PAR --lock-input ----------------- + // + // Defaut REEL, constate pendant la mise au point du scenario G : + // une execution complete du harnais a pose NEUF objets pour trois + // touches envoyees, et le scenario joue seul en posait trois. La + // difference n'etait ni le code, ni le timing - c'est que la + // suite dure huit minutes, que chaque processus prend le focus en + // demarrant, et que les clics REELS de l'utilisateur atterrissent + // alors dans la fenetre du jeu. + // + // C'est exactement le probleme de la Phase 11, qui avait donne + // --lock-input : "le jeu lit le clavier et la souris SYSTEME". + // Sauf que ce verrou-la ne couvrait que la CAMERA, l'editeur + // n'existant pas encore. Reproduit a la demande : trois + // WM_LBUTTONDOWN postes dans une fenetre lancee avec + // --lock-input posent trois objets. + // + // Nuance importante sur GLFW : la position du curseur vient de + // GetCursorPos(), donc un WM_MOUSEMOVE poste n'a aucun effet - + // c'est la limite deja documentee. Mais l'ETAT DES BOUTONS, lui, + // est mis en cache depuis les messages de fenetre. Les boutons + // sont donc atteignables la ou le curseur ne l'est pas, ce qui + // est precisement ce qui rendait ce defaut invisible. + // + // On ne coupe QUE la souris, et pas tout : le clavier doit rester + // vivant pour qu'un scenario puisse piloter l'editeur camera + // figee. C'est la raison d'etre de la touche INSER. + // Le front descendant est calcule DANS TOUS LES CAS et seul son + // RESULTAT est filtre : un `&&` court-circuite, et laisser + // l'etat du bouton non tenu a jour reintroduirait un front + // parasite le jour ou le verrou deviendrait basculable. + const bool clickEdge = editorPlaceButton.justPressed( + window.isMouseButtonPressed(GLFW_MOUSE_BUTTON_LEFT)); + const bool placeByClick = clickEdge && !lockInput; + const bool placeByKey = + editorPlaceKey.justPressed(window, kEditorPlaceKey); + editorInput.placePressed = placeByClick || placeByKey; + editorInput.pickPressed = + editorPickKey.justPressed(window, kEditorPickKey); + editorInput.grabPressed = + editorGrabKey.justPressed(window, kEditorGrabKey); + editorInput.deletePressed = + editorDeleteKey.justPressed(window, kEditorDeleteKey); + editorInput.cancelPressed = + editorCancelKey.justPressed(window, kEditorCancelKey); + // Les deux touches "asset suivant" sont interrogees AVANT d'etre + // combinees : un || court-circuiterait la seconde et son front + // descendant ne serait plus tenu a jour. + const bool nextA = editorNextKey.justPressed(window, kEditorNextKey); + const bool nextB = editorNextKey2.justPressed(window, kEditorNextKey2); + editorInput.nextAssetPressed = nextA || nextB; + editorInput.prevAssetPressed = + editorPrevKey.justPressed(window, kEditorPrevKey); + editorInput.toggleSolidPressed = + editorSolidKey.justPressed(window, kEditorSolidKey); + editorInput.undoPressed = + editorUndoKey.justPressed(window, kEditorUndoKey); + editorInput.savePressed = + editorSaveKey.justPressed(window, kEditorSaveKey); + editorInput.reloadPressed = + editorReloadKey.justPressed(window, kEditorReloadKey); + editorInput.listPressed = + editorListKey.justPressed(window, kEditorListKey); + editorInput.cycleNextPressed = + editorCycleNextKey.justPressed(window, kEditorCycleNextKey); + editorInput.cyclePrevPressed = + editorCyclePrevKey.justPressed(window, kEditorCyclePrevKey); + for (int i = 0; i < static_cast(editorQuickKeys.size()); ++i) { + if (editorQuickKeys[static_cast(i)].justPressed( + window, GLFW_KEY_1 + i)) { + editorInput.quickPick = i; + } + } + + editorInput.holdRotateLeft = window.isKeyPressed(GLFW_KEY_LEFT); + editorInput.holdRotateRight = window.isKeyPressed(GLFW_KEY_RIGHT); + editorInput.holdScaleUp = window.isKeyPressed(GLFW_KEY_UP); + editorInput.holdScaleDown = window.isKeyPressed(GLFW_KEY_DOWN); + editorInput.holdRaise = window.isKeyPressed(GLFW_KEY_HOME); + editorInput.holdLower = window.isKeyPressed(GLFW_KEY_END); + editorInput.holdFineStep = window.isKeyPressed(kEditorFineKey); + + editorController.update(editorInput, *heightmap, + 0.5f * heightmap->worldSize()); + + // Le controleur ne fait aucune entree/sortie : il leve des + // drapeaux, on les traite ici ou le chemin de scene et le + // georeferencement sont connus. + if (editorController.consumeListRequest()) { + logInfo(editorCatalog.listing(editorController.brushIndex())); + } + if (editorController.consumeSaveRequest()) { + if (scenePath.empty()) { + logWarn("Scene : aucun chemin de sauvegarde (--no-scene ?)."); + } else if (saveSceneFile(scenePath, editorScene.objects(), + *heightmap, sceneTerrainLabel)) { + logInfo("Scene : " + std::to_string(editorScene.size()) + + " objet(s) ecrits dans " + scenePath + "."); + } + } + if (editorController.consumeReloadRequest()) { + logInfo("Scene : rechargement demande (F9). Les modifications " + "non sauvegardees sont perdues."); + loadScene(); + editorController.resetInteraction(); + } + if (editorController.consumeStatusChanged()) { + logInfo(editorController.statusLine()); + } + + // Les fronts descendants du JEU sont tenus a jour a vide : voir + // syncAllKeyEdges pour la raison, qui vaut aussi image par image + // et pas seulement au moment de la bascule. + fellKey.justPressed(window, kFellKey); + pickupKey.justPressed(window, kPickupKey); + knapKey.justPressed(window, kKnapKey); + putDownKey.justPressed(window, kPutDownKey); + paraglideKey.justPressed(window, kParaglideKey); + bikeKey.justPressed(window, kBikeKey); + climbKey.justPressed(window, kClimbKey); + vegetationKey.justPressed(window, kVegetationKey); + } + + // --- Parapente : decollage/atterrissage, vol, camera chase-cam --- + // PHASE 21 : hors sujet en mode demo (voir demoMode plus haut). + if (!editorMode && !demoMode && heightmap && + paraglideKey.justPressed(window, kParaglideKey) && + !bike.riding() && !climber.climbing()) { + if (paraglider.flying()) { + // Filet de securite : abandon volontaire du vol, pose + // immediate a l'endroit courant. Utile si le relief ne + // finit jamais par rejoindre l'altitude de vol (grand + // plateau, ou vol lance au-dessus d'un gouffre). + paraglider.abort(); + camera.setPosition(glm::vec3(paraglider.position().x, + paraglider.position().y, + paraglider.position().z)); + camera.setMode(CameraMode::Walk); + logInfo("Parapente : vol interrompu (atterrissage force)."); + } else if (camera.mode() == CameraMode::Free) { + const float groundY = heightmap->heightAt(camera.position().x, + camera.position().z); + const float aboveGround = camera.position().y - groundY; + if (aboveGround >= kMinLaunchHeightAboveTerrain) { + const float headingDeg = + glm::degrees(std::atan2(camera.front().z, camera.front().x)); + paraglider.launch(camera.position(), headingDeg); + camera.setMode(CameraMode::Glide); + logInfo("Decollage en parapente, cap " + + std::to_string(headingDeg) + " degres."); + } else { + logInfo("Parapente : pas assez de hauteur pour decoller (" + + std::to_string(aboveGround) + " m au-dessus du sol, il en " + "faut " + std::to_string(kMinLaunchHeightAboveTerrain) + ")."); + } + } else { + logInfo("Parapente : decolle depuis le mode vol libre (F), en hauteur."); + } + } + + if (paraglider.flying()) { + const float turnInput = (window.isKeyPressed(GLFW_KEY_D) ? 1.0f : 0.0f) - + (window.isKeyPressed(GLFW_KEY_A) ? 1.0f : 0.0f); + const float brakeInput = window.isKeyPressed(GLFW_KEY_S) ? 1.0f : 0.0f; + // PHASE 23 : l'aile vole DANS une masse d'air. Le vent la fait + // deriver, les ascendances la font monter, la turbulence de + // sillage la chahute. L'air est celui deja echantillonne pour + // cette image, au point du pilote. + AirState air; + air.wind = localWeather.windVector; + air.vertical = localWeather.verticalMps; + air.turbulence = localWeather.turbulence; + paraglider.update(deltaTime, turnInput, brakeInput, air); + + if (heightmap && paraglider.checkLanding(*heightmap, kDefaultEyeHeight)) { + camera.setPosition(paraglider.position()); + camera.setMode(CameraMode::Walk); + logInfo("Parapente : atterrissage."); + } else { + // Chase-cam : l'oeil recule derriere le pilote le long de son + // cap et se souleve un peu, en visant le pilote lui-meme - + // c'est ce qui donne une vue a la troisieme personne lisible + // du mouvement (voir Camera::setChasePose). + const glm::vec3 back = -paraglider.forward(); + const glm::vec3 eye = paraglider.position() + + back * kGlideChaseDistance + + glm::vec3(0.0f, kGlideChaseHeight, 0.0f); + camera.setChasePose(eye, paraglider.position()); + } + } + + // --- Velo : monter/descendre, rouler, camera de poursuite (PHASE 13) + // + // Meme decoupage que le parapente juste au-dessus, et volontairement : + // une touche a front descendant pour entrer/sortir de l'activite, la + // physique dans world/, la camera pilotee depuis ici. Ce qui change + // est que le velo n'a pas de condition d'altitude - on l'enfourche la + // ou on marche - et qu'il ne se termine jamais tout seul : il n'y a + // pas d'equivalent de l'atterrissage, c'est le joueur qui descend. + if (!editorMode && !demoMode && heightmap && bikeKey.justPressed(window, kBikeKey) && + !paraglider.flying() && !climber.climbing()) { + if (bike.riding()) { + bike.dismount(); + camera.setPosition(bike.position()); + camera.setMode(CameraMode::Walk); + logInfo("Velo : pied a terre."); + } else if (camera.mode() == CameraMode::Walk) { + // Cap de depart = la direction du regard projetee a + // l'horizontale, comme au decollage en parapente : on part + // dans la direction ou on regardait, pas vers +X. + const float headingDeg = + glm::degrees(std::atan2(camera.front().z, camera.front().x)); + bike.mount(camera.position(), headingDeg, *heightmap); + camera.setMode(CameraMode::Ride); + logInfo("Velo : en selle, cap " + std::to_string(headingDeg) + + " degres. Z pedaler, S freiner, Q/D tourner, B pour " + "descendre."); + } else { + logInfo("Velo : on enfourche depuis la MARCHE (touche F pour y " + "revenir)."); + } + } + + if (bike.riding()) { + const float steerInput = (window.isKeyPressed(GLFW_KEY_D) ? 1.0f : 0.0f) - + (window.isKeyPressed(GLFW_KEY_A) ? 1.0f : 0.0f); + // PHASE 16 : la commande de pedalage est MULTIPLIEE par le + // coefficient des besoins. 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. + const float pedalInput = + (window.isKeyPressed(GLFW_KEY_W) ? 1.0f : 0.0f) * + needs.movementFactor(); + const float brakeInput = window.isKeyPressed(GLFW_KEY_S) ? 1.0f : 0.0f; + + // Le solveur composite est passe tel quel : c'est EXACTEMENT + // le meme objet que celui de camera.setCollisionSolver() plus + // haut, donc le velo bute sur les memes troncs, les memes souches + // et - depuis la Phase 15 - les memes rochers poses que le joueur + // a pied, par le meme moveBody(). + // PHASE 23 : etat du sol. La mouillure vient de la pluie des + // dernieres heures de jeu, RELUE dans la fonction meteo (elle + // n'est pas accumulee - voir WeatherSystem::groundWetness). + bike.update(deltaTime, steerInput, pedalInput, brakeInput, + *heightmap, &worldSolver, localWeather.wetness); + + // Camera de poursuite : l'oeil recule derriere le velo le long de + // son cap et se souleve, en visant le velo. Meme construction que + // la chase-cam du parapente, a une contrainte pres : on refuse de + // laisser l'oeil passer sous la surface (voir + // kRideChaseMinClearance). + const glm::vec3 back = -bike.forward(); + glm::vec3 eye = bike.position() + back * kRideChaseDistance + + glm::vec3(0.0f, kRideChaseHeight, 0.0f); + const float minEyeY = heightmap->heightAt(eye.x, eye.z) + + kRideChaseMinClearance; + eye.y = std::max(eye.y, minEyeY); + camera.setChasePose(eye, bike.position()); + } + + // --- Escalade : engagement, progression, sortie (PHASE 14) ------ + // + // Meme decoupage que le parapente et le velo : une touche a front + // descendant pour entrer/sortir, la physique dans world/, la camera + // pilotee depuis ici. Deux choses la distinguent : + // - l'engagement peut ECHOUER (il faut une paroi a portee), donc + // Climber::tryStart renvoie un booleen la ou mount() ne pouvait + // pas refuser ; + // - l'escalade se termine toute seule de TROIS facons distinctes, + // la ou le velo ne se terminait jamais et le parapente d'une + // seule (l'atterrissage). + if (!editorMode && !demoMode && heightmap && climbKey.justPressed(window, kClimbKey) && + !paraglider.flying() && !bike.riding()) { + if (climber.climbing()) { + handleClimbExit(climber.release(), climber, camera); + } else if (camera.mode() == CameraMode::Walk) { + if (climber.tryStart(*heightmap, camera.position(), + camera.front())) { + camera.setMode(CameraMode::Climb); + logInfo("Escalade : engage sur la paroi (pente " + + std::to_string(100.0f * climber.slopeAt( + *heightmap, climber.anchor().x, + climber.anchor().z)) + + " %), energie " + + std::to_string(100.0f * climber.stamina()) + + " %. Z monter, S descendre, Q/D traverser, X " + "pour lacher."); + } else if (climber.stamina() < Climber::minStaminaToStart()) { + logInfo("Escalade : trop epuise pour s'engager (energie " + + std::to_string(100.0f * climber.stamina()) + + " %, il en faut " + + std::to_string(100.0f * Climber::minStaminaToStart()) + + " %)."); + } else { + logInfo("Escalade : aucune paroi grimpable a portee " + "(il faut une pente d'au moins " + + std::to_string(100.0f * climber.params().wallSlope) + + " % a moins de " + + std::to_string(climber.params().reach) + + " m devant soi)."); + } + } else { + logInfo("Escalade : on s'engage depuis la MARCHE (touche F pour " + "y revenir)."); + } + } + + if (climber.climbing()) { + // Commandes RELATIVES A LA PAROI, pas au regard : Z/S suivent la + // ligne de plus grande pente, Q/D la ligne de niveau. C'est ce + // qui permet a la souris de rester libre en mode Climb (voir + // Camera::update). + // PHASE 16 : meme multiplication que pour le pedalage, et la + // desescalade est ralentie AUSSI (le coefficient s'applique a la + // commande entiere, signe compris). C'est voulu : redescendre + // une paroi epuise autant que la monter, et une desescalade qui + // resterait a pleine vitesse serait la faille evidente du + // systeme - on monterait vite fait, on redescendrait gratis. + const float climbInput = + ((window.isKeyPressed(GLFW_KEY_W) ? 1.0f : 0.0f) - + (window.isKeyPressed(GLFW_KEY_S) ? 1.0f : 0.0f)) * + needs.movementFactor(); + const float traverseInput = (window.isKeyPressed(GLFW_KEY_D) ? 1.0f : 0.0f) - + (window.isKeyPressed(GLFW_KEY_A) ? 1.0f : 0.0f); + + // Le solveur composite est passe tel quel : le grimpeur bute + // sur les memes obstacles que le joueur a pied et que le velo - + // troncs, souches et objets poses - par le meme moveBody(). Rien + // n'est reecrit. + // PHASE 23 : adherence de la paroi. Une paroi mouillee se + // grimpe plus lentement ET coute plus cher au metre - les deux, + // parce que ralentir seul ferait paradoxalement DEPENSER moins + // d'energie sur une paroi difficile. + const ClimbExit exit = + climber.update(deltaTime, climbInput, traverseInput, *heightmap, + &worldSolver, + climber.gripForWetness(localWeather.wetness)); + if (exit == ClimbExit::None) { + // Premiere personne : la camera EST le grimpeur. On n'impose + // que la position - l'orientation reste au joueur, c'est tout + // l'interet du mode Climb. + camera.setPosition(climber.position()); + } else { + handleClimbExit(exit, climber, camera); + } + } else { + // Recuperation : uniquement au sol, jamais en paroi. C'est ce qui + // fait de la jauge une contrainte de trajet et pas un compteur. + climber.restOnGround(deltaTime); + } + + // --- Bascule de la vegetation de decor -------------------------- + if (!editorMode && vegetation && + vegetationKey.justPressed(window, kVegetationKey)) { + vegetationMode = vegetationMode == VegetationMode::All + ? VegetationMode::TreesOnly + : (vegetationMode == VegetationMode::TreesOnly ? VegetationMode::None + : VegetationMode::All); + logInfo(vegetationMode == VegetationMode::All + ? "Vegetation : arbres et herbe." + : (vegetationMode == VegetationMode::TreesOnly + ? "Vegetation : arbres seuls." + : "Vegetation : aucune.")); + } + + // --- Bascule orthophoto / coloration procedurale ---------------- + // Disponible meme en vol : c'est un reglage d'affichage, pas une + // action de jeu. + if (orthoKey.justPressed(window, kOrthoKey) && renderer.hasTerrainTexture()) { + const float next = renderer.orthoMix() > 0.5f ? 0.0f : 1.0f; + renderer.setOrthoMix(next); + logInfo(next > 0.5f ? "Affichage : orthophoto." + : "Affichage : coloration procedurale (altitude/pente)."); + } + + // PHASE 21 : abattage/ramassage/percussion coupes en mode demo - + // l'artisanat n'est pas interactif, mais foret et sol restent en + // place, visibles et solides (voir demoMode plus haut). + if (!editorMode && !demoMode && forest && ground && !paraglider.flying() && + !bike.riding() && !climber.climbing()) { + // --- Abattage ------------------------------------------- + if (fellKey.justPressed(window, kFellKey)) { + const int target = forest->pickTree(camera.position(), camera.front(), + kFellingReach); + if (target == kNoTree) { + logInfo("Abattage : aucun arbre dans la ligne de visee."); + } else { + Clearance clearance; + const glm::vec3 stump = + forest->trees()[static_cast(target)].base; + forest->fell(target, &clearance); + + // PHASE 17 : la coupe est INSCRITE dans le milieu, au + // pied de l'arbre et non a la position du joueur - on + // peut abattre a trente metres, et c'est l'arbre qui + // manque, pas le bucheron. + // + // Rien n'est dit au joueur. La consequence se voit sur + // place, plus tard : le sol s'y denude et la faune n'y + // revient pas (voir NOTES-PHASE17.md). + habitat.recordFelling(stump); + + logInfo("Abattage de l'arbre " + std::to_string(target) + + " : chute vers (" + + std::to_string(clearance.direction.x) + ", " + + std::to_string(clearance.direction.z) + "), " + + std::to_string(clearance.distance) + + " unites degagees, obstacle le plus proche : " + + clearance.obstacle + + (clearance.cramped ? " [ZONE ETROITE]" : "")); + } + } + + // --- Ramassage ------------------------------------------ + if (pickupKey.justPressed(window, kPickupKey)) { + const int target = ground->findNearest(camera.position(), kPickupReach); + if (target == kNoGroundItem) { + logInfo("Ramassage : rien a portee de main."); + } else { + GroundItemKind picked = GroundItemKind::Log; + ground->pickUp(target, &picked); + inventory.add(picked); + lastPickedKind = picked; + inventoryText = inventory.summary(); + titleDirty = true; + logInfo(std::string("Ramasse : ") + + groundItemLabelIndefinite(picked) + + ". Inventaire : " + inventoryText); + } + } + + // --- Taillage de pierre par percussion ------------------- + // PHASE 28 : la meme touche C devient le geste generique de + // FACONNAGE (world/Crafting). La percussion y est la derniere + // recette de la table : avec deux pierres en poche et rien de + // pose autour, le comportement et les messages sont ceux de la + // Phase 6, mot pour mot. + if (knapKey.justPressed(window, kKnapKey)) { + const CraftOutcome outcome = + craftAt(inventory, *ground, hearths, camera.position(), + camera.front(), clock.totalHours()); + logInfo(outcome.message); + if (outcome.result == CraftResult::Success) { + inventoryText = inventory.summary(); + titleDirty = true; + const Recipe& done = kRecipes[static_cast(outcome.recipe)]; + if (done.hasOutput) { + logInfo("Inventaire : " + inventoryText + " (" + + groundItemLabelIndefinite(done.out) + + (groundItemIsPortable(done.out) + ? " est au sol, R pour le ramasser)." + : " est construit ici, il ne se deplace pas).")); + } else { + logInfo("Inventaire : " + inventoryText + "."); + } + const int nearHearth = + hearths.nearest(camera.position(), kStationReach, true); + if (nearHearth >= 0) { + logInfo(" foyer allume, combustion restante : " + + std::to_string(hearths.remainingHours( + nearHearth, clock.totalHours())) + + " h de jeu."); + } + } + } + + // --- PHASE 28 : reposer un objet porte (P) ------------------ + if (putDownKey.justPressed(window, kPutDownKey)) { + GroundItemKind kind = GroundItemKind::Stone; + if (!chooseKindToPutDown(inventory, lastPickedKind, &kind)) { + logInfo("Poser : vous ne portez rien."); + } else if (putDown(inventory, *ground, kind, camera.position(), + camera.front())) { + inventoryText = inventory.summary(); + titleDirty = true; + logInfo(std::string("Pose : ") + groundItemLabelIndefinite(kind) + + ". Inventaire : " + inventoryText); + } + } + } + + // Independant du vol : une chute d'arbre ou un debitage en cours ne + // doit pas se figer parce que le joueur a decolle entre-temps. + if (forest) { + // PHASE 28 (Agent 3) : la hache (ou la hache renforcee) PORTEE + // donne des buches en plus au prochain debitage. Jamais une + // condition d'abattage. 0 en mode demo (inventaire vide). + forest->setBuckingBonusLogs(axeBonusLogs(inventory)); + forest->update(deltaTime); + } + + // PHASE 28 : combustion des foyers, en heures de JEU (horloge gelee => + // feu fige, comme la meteo). Un foyer qui s'eteint laisse une cendre. + if (ground && !hearths.hearths().empty()) { + const int out = hearths.update(clock.totalHours(), *ground); + if (out > 0) { + logInfo("Foyer : le feu s'eteint, il ne reste qu'un peu de cendre " + "au milieu des pierres."); + } + } + + if (fpsCounter.update(deltaTime)) { + displayedFps = std::lround(fpsCounter.fps()); + titleDirty = true; + + // Une ligne de streaming par seconde, au meme rythme que le + // compteur de FPS : de quoi lire apres coup combien de tuiles ont + // ete reellement dessinees pour ces images-la, sans noyer la + // sortie. C'est la mesure qui dit si le LOD travaille. + if (terrainStreamer) { + logInfo(terrainStreamer->statsLine()); + } + // Orientation de la camera, une fois par seconde. PHASE 11 : + // ajoute parce que deux captures automatisees lancees avec les + // MEMES arguments ne cadraient pas la meme chose. Sans cette + // trace, impossible de dire si la camera demarre differemment ou + // si elle derive pendant la pose. + // PHASE 15 : la POSITION s'ajoute au cap. Le harnais automatise + // pilote le joueur a l'estime (il compte les millisecondes de + // touche maintenue) et n'avait donc aucun moyen de constater ou + // le joueur avait REELLEMENT fini - or c'est exactement ce qu'il + // faut savoir pour prouver qu'un rocher pose l'a arrete. Sans + // cette trace, un test de collision ne peut que verifier qu'il + // ne s'est rien passe de mal, pas que quelque chose a bloque. + logInfo("Camera : yaw " + std::to_string(camera.yawDegrees()) + + " pitch " + std::to_string(camera.pitchDegrees()) + + " position " + std::to_string(camera.position().x) + " " + + std::to_string(camera.position().y) + " " + + std::to_string(camera.position().z)); + // PHASE 13. Une ligne de velo par seconde tant qu'on roule. + // C'est la SEULE facon pour le harnais automatise de constater + // que la physique a bien tourne sur le VRAI relief : la vitesse + // et la pente sous les roues ne se devinent pas depuis + // l'exterieur, et un velo bloque a 0 km/h donnerait par ailleurs + // un run parfaitement vert. + if (climber.climbing() && heightmap) { + // PHASE 14. Journal periodique de l'escalade. Les memes + // grandeurs que le velo, plus les deux qui n'existent qu'ici : + // l'energie (qui decide de la fin) et l'altitude gagnee (qui + // dit si l'escalade a servi a quelque chose). C'est cette + // ligne que le scenario F de run_vulkan_check.ps1 depouille. + logInfo("Escalade : energie " + + std::to_string(100.0f * climber.stamina()) + + " %, pente " + + std::to_string(100.0f * climber.slopeAt( + *heightmap, climber.anchor().x, climber.anchor().z)) + + " %, altitude " + std::to_string(climber.anchor().y) + + " m, gain " + std::to_string(climber.heightGained()) + + " m."); + } + + if (bike.riding() && heightmap) { + logInfo("Velo : " + std::to_string(bike.speedKmh()) + + " km/h, pente " + + std::to_string(100.0f * bike.slopeAlongHeading(*heightmap)) + + " %, cap " + std::to_string(bike.headingDegrees()) + + " deg, assiette " + std::to_string(bike.pitchDegrees()) + + "/" + std::to_string(bike.rollDegrees()) + " deg, altitude " + + std::to_string(bike.position().y) + " m."); + } + // PHASE 16. Une ligne de besoins par seconde. C'est la seule + // trace exploitable par le harnais Vulkan : le titre de la + // fenetre ne se depouille pas depuis un script, et les jauges + // bougent trop lentement pour qu'une capture d'image dise quoi + // que ce soit. + if (!editorMode) { + // PHASE 23. UNE ligne de meteo toutes les TRENTE SECONDES, et + // non une par seconde comme les jauges juste en dessous. + // + // LA CADENCE EST UN CHOIX SUBI, ET IL FAUT DIRE POURQUOI : + // le harnais Vulkan paie un script-block PowerShell PAR + // LIGNE DE JOURNAL, et son retard CROIT avec le volume (voir + // l'en-tete de tools/run_vulkan_check.ps1, dette ouverte en + // Phase 17 et comprise en Phase 22). Une premiere version de + // cette phase journalisait les deux lignes chaque seconde, + // donc TRIPLAIT le debit de journal : le scenario H a echoue + // sur "pas de sortie 20 s apres WM_CLOSE" et n'a collecte + // que 87 releves la ou il en attendait 220. Le jeu etait + // correct, c'est le collecteur qui n'arrivait plus a suivre. + // + // La cadence a ete resserree DEUX FOIS. Une premiere baisse + // a dix secondes et deux lignes a suffi a faire repasser le + // scenario H, mais de justesse : un run ulterieur n'a collecte + // que 181 releves sur 220 secondes au lieu de 235, et la + // recuperation de la jauge - qui se lit dans les DERNIERS + // releves - est passee a la trappe. A trente secondes et une + // seule ligne, la Phase 23 ajoute sept lignes a un scenario + // qui en produit plus de deux cents : le volume de journal + // redevient celui d'avant. + // + // Trente secondes suffisent largement au depouillement : la + // meteo bouge a l'echelle de l'heure de jeu, pas de la + // seconde reelle. + // + // Les deux couches restent lisibles SEPAREMENT dans la ligne, + // de part et d'autre du separateur - la synoptique dit le + // temps qu'il fait sur le massif, la locale dit ce que le + // relief en fait la ou est le joueur, et c'est justement + // l'ecart entre les deux qui doit se voir. + static int weatherLogTick = 0; + if (weatherLogTick % 30 == 0) { + logInfo(skyState.describe() + " | " + localWeather.describe()); + } + ++weatherLogTick; + + logInfo(needs.statusLine()); + } + // PHASE 17. Une ligne d'empreinte par seconde, au meme titre + // que celle des besoins et pour la meme raison : c'est la SEULE + // trace depouillable par le harnais Vulkan. Rien de tout ceci + // n'apparait a l'ecran - ni titre, ni pop-up - conformement au + // "pas de message moralisateur". Le journal est un instrument de + // mesure, pas une interface de jeu. + if (!editorMode && wildlife) { + logInfo("Faune : " + std::to_string(wildlife->animalCount()) + + " animaux dont " + std::to_string(wildlife->fleeingCount()) + + " en fuite, " + + std::to_string(wildlife->countWithin( + camera.position(), habitat.params().noiseRadius)) + + " a moins de " + + std::to_string(habitat.params().noiseRadius) + " m (" + std::to_string(wildlife->spawnCount()) + + " apparitions, " + std::to_string(wildlife->despawnCount()) + + " disparitions). Milieu : frequentation ici " + + std::to_string(100.0f * habitat.disturbanceAt( + camera.position().x, camera.position().z)) + + " %, deforestation ici " + + std::to_string(100.0f * habitat.loggingAt( + camera.position().x, camera.position().z)) + + " % (" + std::to_string(habitat.treesFelledAt( + camera.position().x, camera.position().z)) + + " arbres), couvert au sol " + + std::to_string(100.0f * habitat.groundCover( + camera.position().x, camera.position().z)) + + " %, " + std::to_string(habitat.trackedCellCount()) + + " cellules memorisees, pointes " + + std::to_string(100.0f * habitat.peakDisturbance()) + "/" + + std::to_string(100.0f * habitat.peakLogging()) + " %."); + } + if (vegetation) { + // PHASE 26 : la COMPOSITION du peuplement, une fois par + // seconde. C'est la seule trace depouillable qui dise si + // l'essence suit reellement le versant : une capture montre + // une difference, elle ne la CHIFFRE pas. + logInfo("Essences : " + std::to_string(vegetation->lastConiferCount()) + + " resineux et " + std::to_string(vegetation->lastBroadleafCount()) + + " feuillus a l'ecran, exposition ici " + + std::to_string(aspectExposure.aspectExposureAt( + camera.position().x, camera.position().z)) + "."); + logInfo("Vegetation : " + std::to_string(vegetation->lastTreeCount()) + + " arbres et " + std::to_string(vegetation->lastGrassCount()) + + " touffes soumis, " + + std::to_string(vegetation->cachedCellCount()) + + " cellules d'arbres en cache." + + // PHASE 22 : le compte de plantes a fibres est + // journalise ICI et non a part, parce que c'est le + // SEUL chiffre qui dise si le semis produit + // reellement quelque chose - un `gather` qui coute + // du temps et ne rend rien se lit sinon comme un + // semis qui marche. + (fiberPlants + ? " Plantes a fibres : " + + std::to_string(fiberPlants->lastPlantCount()) + + " soumises, " + + std::to_string(fiberPlants->pulledPlantCount()) + + " arrachee(s) en repousse." + : std::string())); + } + } + + if (titleDirty) { + // Le mode editeur se voit dans le TITRE. C'est le seul retour + // permanent a l'ecran : le reste de l'etat de l'outil passe par + // le journal, et rien dans la vue elle-meme ne distingue une + // camera de vol libre d'edition d'un simple mode vol libre. + // PHASE 21 : en mode demo, le titre se reduit a son minimum - + // ni inventaire (l'artisanat est coupe), ni jauges (les besoins + // sont coupes), ni horloge. Juste de quoi confirmer que c'est la + // demo et lire le FPS, qui est tout le retour utile ici. + std::string title = (editorMode ? "[EDITEUR] " : "") + kBaseTitle + + " - " + std::to_string(displayedFps) + " FPS"; + if (!demoMode) { + if (terrainScene) { + title += " - " + inventoryText; + } + // PHASE 16 : les quatre jauges et l'heure. C'est l'affichage + // minimal demande - le jeu n'a toujours aucune interface + // graphique, et la barre de titre reste le seul retour + // permanent a l'ecran, comme pour l'inventaire depuis la + // Phase 6. + title += " - " + needs.summary() + " - " + clock.clockText(); + } + window.setTitle(title); + titleDirty = false; + } + + // --- Construction de la liste d'objets a dessiner ---------------- + drawItems.clear(); + + if (terrainScene) { + if (terrainStreamer) { + // --- Terrain par quadtree (Phase 10) -------------------- + // Le tronc de vision est reconstruit CHAQUE frame a partir + // de la projection du Renderer (qui connait l'aspect courant + // de la swapchain) et de la vue de la camera. Le streamer + // s'en sert pour ecarter les tuiles hors champ, choisir un + // niveau de detail par distance, et construire ce qui manque + // sous budget. + const auto tf0 = ProfileClock::now(); + const glm::mat4 viewProjection = + renderer.projectionMatrix() * camera.viewMatrix(); + const Frustum frustum = Frustum::fromViewProjection(viewProjection); + const auto tf1 = ProfileClock::now(); + terrainStreamer->appendDrawItems(camera.position(), frustum, drawItems); + const auto tf2 = ProfileClock::now(); + frameProfile.frustumMicros += profileMicros(tf0, tf1); + frameProfile.streamingMicros += profileMicros(tf1, tf2); + } else if (sceneMeshHandle != kInvalidMesh) { + // Terrain d'un seul bloc : sommets deja en coordonnees monde + // -> matrice identite, et pas de bande de morphing. + drawItems.push_back({ sceneMeshHandle, glm::mat4(1.0f), + Material::Terrain }); + } + + for (const Tree& tree : forest->trees()) { + if (tree.state != TreeState::Standing) { + // Des que l'arbre est coupe, sa souche apparait : c'est + // elle qui marque le trait de coupe pendant la chute. + drawItems.push_back({ stumpMeshHandle, tree.stumpMatrix(), + Material::Object }); + } + // L'arbre reste dessine pendant Settling : il est couche au + // sol, en train de s'immobiliser, et ne disparait qu'au + // moment ou il se debite. + if (tree.state != TreeState::Fallen) { + // PHASE 26 : la silhouette suit l'essence. C'est ce qui + // rend la resine LISIBLE - le joueur voit un cone ou un + // houppier rond avant d'appuyer, au lieu de le decouvrir + // en essayant (dette de la Phase 22). + const MeshHandle mesh = + (tree.species == TreeSpecies::Conifer) ? treeMeshHandle + : broadleafMeshHandle; + drawItems.push_back({ mesh, tree.modelMatrix(), + Material::Object }); + } + } + + for (const GroundItem& item : ground->items()) { + const MeshHandle mesh = groundMeshes[static_cast(item.kind)]; + if (mesh != kInvalidMesh) { + drawItems.push_back({ mesh, item.modelMatrix(), Material::Object }); + } + } + + // --- Objets poses par l'editeur (PHASE 15) ----------------- + // Dessines DANS LES DEUX MODES, et c'est le point : ce qui a ete + // pose fait partie du monde, pas de l'outil. Le mode edition + // n'ajoute que les deux teintes de temoin - selection et fantome. + // + // Un DrawItem par objet, sans frustum culling : le culling de la + // Phase 10 vit dans le quadtree du terrain et celui de la + // Phase 11 dans la vegetation instanciee, aucun des deux ne + // s'applique ici. Assume pour cette session - une scene + // d'editeur compte des dizaines d'objets, pas des dizaines de + // milliers - et note comme limite dans NOTES-PHASE15.md. + { + const uint32_t hiddenId = + editorMode ? editorController.hiddenObjectId() : kNoPlacedObject; + const uint32_t selectedId = + editorMode ? editorController.selection() : kNoPlacedObject; + + for (const PlacedObject& object : editorScene.objects()) { + if (object.id == hiddenId) { + continue; // en main : dessine par la previsualisation + } + const auto found = assetByName.find(object.asset); + if (found == assetByName.end() || + found->second->meshHandle == kInvalidMesh) { + continue; // asset absent, deja signale au chargement + } + DrawItem item{ found->second->meshHandle, object.modelMatrix(), + Material::Object }; + if (object.id == selectedId) { + item.params = kSelectionTint; + } + drawItems.push_back(item); + } + + if (editorMode && editorController.hasPreview()) { + const PlacedObject& ghost = editorController.preview(); + const auto found = assetByName.find(ghost.asset); + if (found != assetByName.end() && + found->second->meshHandle != kInvalidMesh) { + drawItems.push_back({ found->second->meshHandle, + ghost.modelMatrix(), + Material::Object, kGhostTint }); + } + } + } + + // --- Faune (PHASE 17) -------------------------------------- + // Un DrawItem par animal, comme les arbres abattables et les + // objets poses : ils se comptent en dizaines, pas en dizaines de + // milliers, donc la voie instanciee de la Phase 11 serait du + // travail pour rien. Aucun frustum culling non plus, meme + // raisonnement et meme limite assumee que pour les objets poses. + if (wildlife && animalMeshHandle != kInvalidMesh) { + for (const Animal& animal : wildlife->animals()) { + drawItems.push_back({ animalMeshHandle, animal.modelMatrix(), + Material::Object }); + } + } + + if (paraglider.flying() && avatarMeshHandle != kInvalidMesh) { + // Marqueur du pilote : voir le commentaire de avatarMeshHandle + // plus haut. Oriente sur le cap de vol, aplati un peu pour ne + // pas ressembler a une caisse qui tombe du ciel. + glm::mat4 model = + glm::translate(glm::mat4(1.0f), paraglider.position()); + model = glm::rotate(model, glm::radians(-paraglider.headingDegrees()), + glm::vec3(0.0f, 1.0f, 0.0f)); + model = glm::scale(model, glm::vec3(0.5f, 0.3f, 0.8f)); + drawItems.push_back({ avatarMeshHandle, model, Material::Object }); + } + + if (bike.riding() && avatarMeshHandle != kInvalidMesh) { + // Marqueur du cycliste. Contrairement au parapente, on prend + // la peine d'orienter le marqueur CORRECTEMENT sur le cap : + // c'est le seul moyen de LIRE a l'ecran l'assiette calculee + // par Bike (tangage sur la pente, roulis en devers et en + // virage), donc de verifier a l'oeil ce que disent les tests. + // + // Convention : une rotation de theta autour de +Y envoie le + // +Z local sur (sin theta, cos theta) dans le plan (x, z). On + // veut y envoyer le cap (cos h, sin h), d'ou theta = 90 - h. + glm::mat4 model = glm::translate(glm::mat4(1.0f), bike.position()); + model = glm::rotate(model, glm::radians(90.0f - bike.headingDegrees()), + glm::vec3(0.0f, 1.0f, 0.0f)); + // Le +Z local etant maintenant l'avant, le tangage tourne + // autour du X local, et le roulis autour du Z local. + model = glm::rotate(model, glm::radians(-bike.pitchDegrees()), + glm::vec3(1.0f, 0.0f, 0.0f)); + model = glm::rotate(model, glm::radians(bike.rollDegrees()), + glm::vec3(0.0f, 0.0f, 1.0f)); + // Etroit, bas et long : une silhouette de deux-roues plutot + // qu'un cube, ce qui rend le cap et l'assiette lisibles. + model = glm::scale(model, glm::vec3(0.35f, 0.5f, 1.4f)); + drawItems.push_back({ avatarMeshHandle, model, Material::Object }); + } + } else { + // Objet isole des Phases 1 a 3 : rotation animee autour d'un axe + // incline. Rotation PURE, donc mat3(model) reste une normal + // matrix valide (voir cube.vert). + const float elapsed = std::chrono::duration( + std::chrono::steady_clock::now() - startTime).count(); + const glm::mat4 spin = + glm::rotate(glm::mat4(1.0f), elapsed * glm::radians(45.0f), + glm::normalize(glm::vec3(0.3f, 1.0f, 0.0f))); + if (sceneMeshHandle != kInvalidMesh) { + drawItems.push_back({ sceneMeshHandle, spin, Material::Object }); + } + } + + // --- Vegetation de decor instanciee (Phase 11) ------------------ + instancedItems.clear(); + if (vegetation && vegetationMode != VegetationMode::None) { + const auto tv0 = ProfileClock::now(); + const glm::mat4 viewProjection = + renderer.projectionMatrix() * camera.viewMatrix(); + const Frustum frustum = Frustum::fromViewProjection(viewProjection); + const auto tv1 = ProfileClock::now(); + + // PHASE 26 : le semis rend les deux essences SEPAREMENT. Deux + // geometries distinctes = deux appels de dessin instancies, et + // c'est irreductible : l'instanciation, par definition, tient UNE + // geometrie pour N instances. Les melanger demanderait une + // matrice par arbre, c'est-a-dire de defaire la Phase 11. + // + // Le surcout est d'UN appel de dessin par image, pas d'un par + // arbre : le nombre d'instances, lui, est inchange. + vegetation->gatherTrees(camera.position(), frustum, + treeInstances, broadleafInstances); + const auto tv2 = ProfileClock::now(); + frameProfile.frustumMicros += profileMicros(tv0, tv1); + frameProfile.treesMicros += profileMicros(tv1, tv2); + + const auto pushTrees = [&](const std::vector& instances, + MeshHandle mesh) { + if (instances.empty() || mesh == kInvalidMesh) { return; } + InstancedDrawItem item; + item.mesh = mesh; + item.instances = instances.data(); + item.count = static_cast(instances.size()); + item.material = Material::Foliage; + // Amplitude d'ondulation NULLE : un tronc ne plie pas. + item.params = { 0.0f, elapsedSeconds, 0.0f, 0.0f }; + instancedItems.push_back(item); + }; + pushTrees(treeInstances, sceneryTreeMeshHandle); + pushTrees(broadleafInstances, sceneryBroadleafMeshHandle); + + if (useGrass && vegetationMode == VegetationMode::All && + grassMeshHandle != kInvalidMesh) { + const auto tg0 = ProfileClock::now(); + vegetation->gatherGrass(camera.position(), frustum, grassInstances); + frameProfile.grassMicros += profileMicros(tg0, ProfileClock::now()); + if (!grassInstances.empty()) { + InstancedDrawItem item; + item.mesh = grassMeshHandle; + item.instances = grassInstances.data(); + item.count = static_cast(grassInstances.size()); + item.material = Material::Foliage; + // w = force de la decoupe alpha (PHASE 18). C'est le + // seul materiau qui s'en sert : un arbre pousse 0 et + // traverse le meme pipeline, inchange. + item.params = { vegetation->params().grassSway, + elapsedSeconds, 0.0f, + vegetation->params().grassCutout }; + instancedItems.push_back(item); + } + } + + // PHASE 22 : les plantes a fibres. Meme voie de rendu que + // l'herbe - une geometrie, un appel de dessin, N instances - + // et donc rien de nouveau cote Renderer. Elles suivent la + // bascule de vegetation (touche G) comme le reste du decor. + if (vegetationMode == VegetationMode::All && fiberPlants && + fiberMeshHandle != kInvalidMesh) { + // Chronometre au meme titre que l'herbe et les arbres : un + // poste de semis qu'on n'aurait pas mesure serait le seul du + // frame dans ce cas, et c'est exactement comme ca qu'on se + // retrouve a optimiser le mauvais (voir NOTES-PHASE19.md). + const auto tf0 = ProfileClock::now(); + fiberPlants->gather(camera.position(), frustum, fiberInstances); + frameProfile.fiberMicros += profileMicros(tf0, ProfileClock::now()); + if (!fiberInstances.empty()) { + InstancedDrawItem item; + item.mesh = fiberMeshHandle; + item.instances = fiberInstances.data(); + item.count = static_cast(fiberInstances.size()); + item.material = Material::Foliage; + // Ondulation plus faible que l'herbe : une tige ligneuse + // de ronce plie moins qu'un brin. Decoupe alpha NULLE + // (w = 0) : la silhouette est portee par la geometrie, + // pas par un masque - ces plantes sont peu nombreuses, + // le budget de sommets n'est pas le sujet. + item.params = { 0.35f * vegetation->params().grassSway, + elapsedSeconds, 0.0f, 0.0f }; + instancedItems.push_back(item); + } + } + } + + // --- PHASE 29 : rochers et pierriers, instancies --------------- + // Meme voie que les arbres : trois geometries, trois appels de + // dessin, N instances. params.w = -1 active le mode ROCHER de + // foliage.vert (inclinaison selon la pente, voir Rocks.hpp) ; ni + // ondulation ni decoupe. Suit la bascule de vegetation (touche G). + if (rocks && rocks->enabled() && vegetationMode != VegetationMode::None) { + const auto tr0 = ProfileClock::now(); + const Frustum rockFrustum = Frustum::fromViewProjection( + renderer.projectionMatrix() * camera.viewMatrix()); + rocks->gather(camera.position(), rockFrustum, boulderInstances, + stoneInstances, gravelInstances); + frameProfile.rocksMicros += profileMicros(tr0, ProfileClock::now()); + const auto pushRocks = [&](const std::vector& instances, + MeshHandle mesh) { + if (instances.empty() || mesh == kInvalidMesh) { return; } + InstancedDrawItem item; + item.mesh = mesh; + item.instances = instances.data(); + item.count = static_cast(instances.size()); + item.material = Material::Foliage; + item.params = { 0.0f, elapsedSeconds, 0.0f, -1.0f }; + instancedItems.push_back(item); + }; + pushRocks(boulderInstances, boulderMeshHandle); + pushRocks(stoneInstances, rockMeshHandle); + pushRocks(gravelInstances, gravelMeshHandle); + } + + // --- PHASE 29 (Agent 3) : buissons et petits arbres, instancies -- + // Chemin ARBRE de foliage.vert (params.w = 0 : ni decoupe ni mode + // rocher), avec une ondulation tres faible (x) comme les plantes a + // fibres : un buisson bouge un peu au vent, pas comme l'herbe. + if (bushes && bushes->enabled() && vegetationMode != VegetationMode::None) { + const auto tb0 = ProfileClock::now(); + const Frustum bushFrustum = Frustum::fromViewProjection( + renderer.projectionMatrix() * camera.viewMatrix()); + bushes->gather(camera.position(), bushFrustum, shrubInstances, smallTreeInstances); + frameProfile.bushesMicros += profileMicros(tb0, ProfileClock::now()); + const auto pushBushes = [&](const std::vector& instances, + MeshHandle mesh, float sway) { + if (instances.empty() || mesh == kInvalidMesh) { return; } + InstancedDrawItem item; + item.mesh = mesh; + item.instances = instances.data(); + item.count = static_cast(instances.size()); + item.material = Material::Foliage; + item.params = { sway, elapsedSeconds, 0.0f, 0.0f }; + instancedItems.push_back(item); + }; + pushBushes(shrubInstances, shrubMeshHandle, 0.04f); + pushBushes(smallTreeInstances, smallTreeMeshHandle, 0.0f); + } + + // =============================================================== + // PHASE 23 : CYCLE JOUR/NUIT VISUEL + // =============================================================== + // C'est la correction de l'incoherence assumee en Phase 16 : le jeu + // simulait une horloge acceleree douze fois, et l'image n'en montrait + // rien - la lumiere directionnelle etait une constante ecrite en dur + // dans les shaders depuis la Phase 2. + // + // La lumiere vient de la MEME position solaire que l'adret/ubac et + // les thermiques (voir sunLightFor). Il n'y a donc pas deux soleils + // qui pourraient diverger, ce qui est la meme exigence que celle qui + // a fait sortir la temperature de Needs. + // + // Appele meme en mode EDITEUR : l'horloge y est gelee, donc la + // lumiere l'est aussi - une scene d'edition eclairee de facon stable + // est ce qu'on veut d'un outil. + { + // =========================================================== + // PHASE 27 : METEO VISIBLE + // =========================================================== + // weatherVisualsFor() part de la MEME lumiere que sunLightFor() + // et la corrige de ce que la meteo a DEJA calcule pour cette + // image, au point du joueur : nebulosite locale, precipitation + // locale, neige, vent local, mouillure. Elle n'invente rien - + // par ciel clair et sol sec, elle rend sunLightFor() au bit pres + // (verifie par testWeatherVisuals). + // + // --no-weather-visuals revient exactement a la Phase 26. + const auto tw0 = ProfileClock::now(); + WeatherVisuals visuals; + if (weatherVisuals) { + visuals = weatherVisualsFor(skyState, localWeather, weather.params()); + } else { + visuals.light = sunLightFor(skyState, weather.params()); + visuals.fogColor = visuals.light.skyColor; + } + const SunLight& light = visuals.light; + renderer.setSun(light.direction, light.intensity, light.color, + light.ambient); + renderer.setClearColor(light.skyColor); + // PHASE 27, chantier 3 : micro-relief. Motif de base = le TEXEL + // de l'orthophoto (0,61 m sur la zone) : le grain ajoute ne + // commence qu'en dessous de ce que la photo sait porter. Fondu + // de 6 a 35 m : la portee du regard d'un marcheur sur le sol a + // ses pieds ; au-dela, l'orthophoto seule a assez de pixels. Le + // fondu PAR OCTAVE (Nyquist) du shader protege en plus contre le + // moire, quelle que soit la distance. + renderer.setGroundDetail(groundDetail ? kGroundDetailStrength : 0.0f, + kGroundDetailFadeStart, kGroundDetailFadeEnd, + groundDetailPattern); + renderer.setWeatherVisuals(visuals.fogColor, visuals.fogDensityPerMeter, + visuals.precipitation, visuals.snow, + visuals.fallVelocity, visuals.groundDarkening, + elapsedSeconds); + frameProfile.weatherVisualsMicros += profileMicros(tw0, ProfileClock::now()); + + // Journal BORNE PAR LE TEMPS (lecon de la Phase 24 : "sur + // changement d'etat" oscille autour d'un seuil). Une ligne a la + // premiere image, puis une par minute reelle au plus - de quoi + // relire, pour chaque capture, le temps qu'il faisait. + if (elapsedSeconds - lastWeatherVisualsLog >= 60.0f || + lastWeatherVisualsLog < 0.0f) { + lastWeatherVisualsLog = elapsedSeconds; + const float visibilityKm = + visuals.fogDensityPerMeter > 0.0f + ? 3.912f / (visuals.fogDensityPerMeter * 1000.0f) + : -1.0f; + char line[320]; + std::snprintf(line, sizeof(line), + "Visuels meteo%s : nuages locaux %.2f, precipitation " + "%.2f mm/h (%s, ecran %.2f), mouillure %.2f, soleil " + "direct %.2f, ambiante x%.2f, visibilite %s", + weatherVisuals ? "" : " (DESACTIVES, --no-weather-visuals)", + localWeather.cloudCover, + localWeather.precipitationMmPerHour, + localWeather.snowing ? "neige" : "pluie", + visuals.precipitation, localWeather.wetness, + light.intensity, light.ambient, + visibilityKm > 0.0f + ? (std::to_string(visibilityKm).substr(0, 5) + " km").c_str() + : "illimitee"); + logInfo(line); + } + + // =========================================================== + // PHASE 25 : force de l'indice visuel ADRET / UBAC + // =========================================================== + // L'ecart adret/ubac etait mesure depuis la Phase 23 (14,7 C + // contre 10,7 C a midi) et parfaitement INVISIBLE a l'ecran. + // + // Ce scalaire porte les deux facteurs de l'ecart qui ne + // dependent PAS de la geometrie locale, et il les calcule avec + // les MEMES parametres que WeatherSystem::sampleAt : + // + // - la hauteur du soleil. Le soleil doit etre leve, et + // l'effet s'eteint progressivement quand il rase + // l'horizon. C'est la condition qui, en Phase 23, avait + // manque et rendait un versant sud plus chaud a 2 h du + // matin ; elle ne sera pas oubliee ici ; + // - la nebulosite. Sous un ciel couvert il n'y a pas de + // rayonnement direct, donc pas d'adret - ni thermique, ni + // visuel. + // + // Le cosinus d'incidence par fragment, lui, reste au shader : + // c'est la seule part qui a besoin de la normale du relief. + const WeatherParams& wp = weather.params(); + const float aspectSunStrength = + std::clamp(skyState.daylight / + std::max(1e-3f, wp.aspectFullDaylightSin), + 0.0f, 1.0f); + const float aspectCloudDamping = + std::max(0.0f, 1.0f - wp.cloudAspectDamping * skyState.cloudCover); + renderer.setAspectTint(kAspectTintIntensity * aspectSunStrength * + aspectCloudDamping); + } + + const auto td0 = ProfileClock::now(); + renderer.drawFrame(camera, drawItems, instancedItems); + frameProfile.drawMicros += profileMicros(td0, ProfileClock::now()); + ++frameProfile.frames; + } + + // S'assurer que le GPU a fini avant de detruire quoi que ce soit. + renderer.waitIdle(); + + if (frameProfile.frames > 0) { + const auto per = [&](uint64_t total) { + const double value = static_cast(total) / + static_cast(frameProfile.frames); + return std::to_string(static_cast(value * 10.0 + 0.5) / 10.0); + }; + logInfo("Cout par image (PHASE 19) : " + + std::to_string(frameProfile.frames) + " images - streaming terrain " + + per(frameProfile.streamingMicros) + " us, arbres " + + per(frameProfile.treesMicros) + " us, herbe " + + per(frameProfile.grassMicros) + " us, plantes a fibres " + + per(frameProfile.fiberMicros) + " us, tronc de vision " + + per(frameProfile.frustumMicros) + " us, drawFrame " + + per(frameProfile.drawMicros) + " us, visuels meteo " + + per(frameProfile.weatherVisualsMicros) + " us."); + const double loopSeconds = + std::chrono::duration(ProfileClock::now() - loopStart).count(); + if (loopSeconds > 0.0) { + char line[200]; + std::snprintf(line, sizeof(line), + "Cadence de boucle (PHASE 27) : %llu images en %.2f s, soit " + "%.1f images/s, %.1f us par image.", + static_cast(frameProfile.frames), + loopSeconds, + static_cast(frameProfile.frames) / loopSeconds, + 1e6 * loopSeconds / static_cast(frameProfile.frames)); + logInfo(line); + } + if (rocks && rocks->enabled()) { + logInfo("Rochers (PHASE 29) : semis " + per(frameProfile.rocksMicros) + + " us par image ; derniere image " + + std::to_string(rocks->lastBoulderCount()) + " gros blocs, " + + std::to_string(rocks->lastStoneCount()) + " rochers, " + + std::to_string(rocks->lastGravelCount()) + + " plaques de pierraille."); + } + if (bushes && bushes->enabled()) { + logInfo("Buissons (PHASE 29) : semis " + per(frameProfile.bushesMicros) + + " us par image ; derniere image " + + std::to_string(bushes->lastShrubCount()) + " buissons, " + + std::to_string(bushes->lastSmallTreeCount()) + " petits arbres."); + } + } + logInfo("Fermeture propre."); + } catch (const std::exception& e) { + logError(std::string("Exception fatale : ") + e.what()); + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/src/renderer/CubeMesh.hpp b/src/renderer/CubeMesh.hpp new file mode 100644 index 0000000..de939d1 --- /dev/null +++ b/src/renderer/CubeMesh.hpp @@ -0,0 +1,82 @@ +#pragma once + +#include "renderer/MeshData.hpp" +#include "renderer/Vertex.hpp" + +#include +#include + +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 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 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 diff --git a/src/renderer/DrawItem.hpp b/src/renderer/DrawItem.hpp new file mode 100644 index 0000000..cda27a3 --- /dev/null +++ b/src/renderer/DrawItem.hpp @@ -0,0 +1,118 @@ +#pragma once + +#include "renderer/InstanceData.hpp" + +#include + +#include + +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(-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 diff --git a/src/renderer/InstanceData.hpp b/src/renderer/InstanceData.hpp new file mode 100644 index 0000000..494a7da --- /dev/null +++ b/src/renderer/InstanceData.hpp @@ -0,0 +1,66 @@ +#pragma once + +#include + +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 diff --git a/src/renderer/Mesh.cpp b/src/renderer/Mesh.cpp new file mode 100644 index 0000000..d33f665 --- /dev/null +++ b/src/renderer/Mesh.cpp @@ -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 +#include + +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(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(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 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( + 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( + 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 diff --git a/src/renderer/Mesh.hpp b/src/renderer/Mesh.hpp new file mode 100644 index 0000000..5b3482c --- /dev/null +++ b/src/renderer/Mesh.hpp @@ -0,0 +1,81 @@ +#pragma once + +#include + +#include +#include + +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 createDeviceLocalBuffer( + VulkanContext& context, + BufferUploader& uploader, + const void* data, + VkDeviceSize size, + VkBufferUsageFlags usage); + + std::unique_ptr vertexBuffer_; + std::unique_ptr indexBuffer_; + + uint32_t vertexCount_ = 0; + uint32_t indexCount_ = 0; +}; + +} // namespace vercora diff --git a/src/renderer/MeshData.hpp b/src/renderer/MeshData.hpp new file mode 100644 index 0000000..e16920a --- /dev/null +++ b/src/renderer/MeshData.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include "renderer/Vertex.hpp" + +#include +#include +#include + +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 vertices; + std::vector 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(indices.size() / 3); + } +}; + +} // namespace vercora diff --git a/src/renderer/Pipeline.cpp b/src/renderer/Pipeline.cpp new file mode 100644 index 0000000..e7649c8 --- /dev/null +++ b/src/renderer/Pipeline.cpp @@ -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 + +#include +#include +#include +#include + +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 vertCode = readFile(shaderDir + shaders.vertexSpv); + const std::vector 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 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(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 bindings{ bindingDescription }; + std::vector 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(bindings.size()); + vertexInput.pVertexBindingDescriptions = bindings.data(); + vertexInput.vertexAttributeDescriptionCount = static_cast(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 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(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(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(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& code) const { + VkShaderModuleCreateInfo createInfo{}; + createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + createInfo.codeSize = code.size(); + createInfo.pCode = reinterpret_cast(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 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(file.tellg()); + std::vector buffer(fileSize); + file.seekg(0); + file.read(buffer.data(), static_cast(fileSize)); + file.close(); + return buffer; +} + +} // namespace vercora diff --git a/src/renderer/Pipeline.hpp b/src/renderer/Pipeline.hpp new file mode 100644 index 0000000..d6f2b39 --- /dev/null +++ b/src/renderer/Pipeline.hpp @@ -0,0 +1,84 @@ +#pragma once + +#include + +#include +#include + +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& code) const; + static std::vector readFile(const std::string& path); + + VkDevice device_ = VK_NULL_HANDLE; + VkPipelineLayout pipelineLayout_ = VK_NULL_HANDLE; + VkPipeline graphicsPipeline_ = VK_NULL_HANDLE; +}; + +} // namespace vercora diff --git a/src/renderer/Renderer.cpp b/src/renderer/Renderer.cpp new file mode 100644 index 0000000..308de99 --- /dev/null +++ b/src/renderer/Renderer.cpp @@ -0,0 +1,1002 @@ +#include "renderer/Renderer.hpp" + +#include "assets/DetailNoise.hpp" + +#include "core/Camera.hpp" +#include "core/Logger.hpp" +#include "core/Window.hpp" +#include "renderer/Mesh.hpp" +#include "renderer/MeshData.hpp" +#include "renderer/Pipeline.hpp" +#include "renderer/SwapChain.hpp" +#include "renderer/Texture.hpp" +#include "renderer/UniformBufferObject.hpp" +#include "renderer/VulkanBuffer.hpp" +#include "renderer/VulkanContext.hpp" + +#include + +#include +#include +#include +#include + +namespace vercora { + +namespace { + +// Paire de shaders associee a chaque materiau. L'ordre suit celui de l'enum +// Material : c'est ce tableau qui fait le lien entre le vocabulaire du gameplay +// ("cet objet est du terrain") et celui du rendu ("ces .spv"). +const ShaderSet& shadersFor(Material material) { + switch (material) { + case Material::Terrain: return kTerrainShaders; + case Material::Foliage: return kFoliageShaders; + case Material::Object: break; + } + return kObjectShaders; +} + +} // namespace + +Renderer::Renderer(VulkanContext& context, Window& window, + const RenderOptions& options) + : context_(context), window_(window), options_(options) { + swapChain_ = std::make_unique(context_, window_); + + createCommandPool(); // requis avant les buffers (transferts staging) + + createDescriptorSetLayout(); + + // Un pipeline par materiau, cree une fois pour toutes : changer de pipeline + // pendant l'enregistrement d'un command buffer est bon marche, en creer un + // ne l'est pas. Ils ne dependent pas de l'extent (viewport/scissor + // dynamiques), donc le resize ne les recree pas non plus. + for (uint32_t i = 0; i < kMaterialCount; ++i) { + pipelines_[i] = std::make_unique( + context_.device(), swapChain_->renderPass(), descriptorSetLayout_, + shadersFor(static_cast(i))); + } + precipitationPipeline_ = std::make_unique( + context_.device(), swapChain_->renderPass(), descriptorSetLayout_, + kPrecipitationShaders); + + createUniformBuffers(); + createDescriptorPool(); + + // Doit exister avant l'ecriture des descriptor sets : c'est elle qui occupe + // le binding 1 tant qu'aucune orthophoto n'est chargee. + whiteTexture_ = std::make_unique(context_, commandPool_, + context_.graphicsQueue(), + Texture::whitePixelData()); + detailTexture_ = std::make_unique(context_, commandPool_, + context_.graphicsQueue(), + makeDetailNoiseTexture(), true); + + createDescriptorSets(); + + // Un emplacement de buffer d'instances par frame-in-flight ; les buffers + // eux-memes sont alloues a la premiere frame qui en a besoin, avec la taille + // qu'il faut. Une scene sans vegetation n'alloue donc rien. + instanceBuffers_.resize(kMaxFramesInFlight); + + createCommandBuffers(); + createFrameSyncObjects(); + createImageSyncObjects(); +} + +Renderer::~Renderer() { + VkDevice device = context_.device(); + + for (VkSemaphore s : imageAvailableSemaphores_) { + vkDestroySemaphore(device, s, nullptr); + } + for (VkFence f : inFlightFences_) { + vkDestroyFence(device, f, nullptr); + } + destroyImageSyncObjects(); + + if (descriptorPool_ != VK_NULL_HANDLE) { + vkDestroyDescriptorPool(device, descriptorPool_, nullptr); + } + if (descriptorSetLayout_ != VK_NULL_HANDLE) { + vkDestroyDescriptorSetLayout(device, descriptorSetLayout_, nullptr); + } + + if (commandPool_ != VK_NULL_HANDLE) { + // Detruire le pool libere aussi les command buffers alloues dessus. + vkDestroyCommandPool(device, commandPool_, nullptr); + } + + // uniformBuffers_, meshes_, pipelines_, swapChain_ : detruits automatiquement + // (unique_ptr) apres ce corps, device encore valide. +} + +void Renderer::waitIdle() const { + vkDeviceWaitIdle(context_.device()); +} + +MeshHandle Renderer::addMesh(const MeshData& meshData, bool log) { + // Le Mesh valide les donnees et leve une exception si elles sont + // incoherentes, avant toute allocation durable. Construit AVANT de toucher + // aux tableaux : si la construction echoue, aucun emplacement n'a ete + // consomme. + auto mesh = std::make_unique(context_, *this, meshData, log); + ++liveMeshCount_; + + if (!freeMeshSlots_.empty()) { + const MeshHandle handle = freeMeshSlots_.back(); + freeMeshSlots_.pop_back(); + meshes_[handle] = std::move(mesh); + return handle; + } + + meshes_.push_back(std::move(mesh)); + return static_cast(meshes_.size() - 1); +} + +void Renderer::removeMesh(MeshHandle handle) { + if (handle >= meshes_.size() || !meshes_[handle]) { + return; // deja libere, ou poignee invalide : ne rien faire est sans risque + } + // Le mesh sort de la table tout de suite (sa poignee redevient disponible) + // mais ses buffers Vulkan survivent le temps que les frames deja soumises + // aient fini de les lire. Voir le commentaire de declaration. + retiredMeshes_.push_back({ std::move(meshes_[handle]), kMaxFramesInFlight + 1 }); + freeMeshSlots_.push_back(handle); + --liveMeshCount_; +} + +glm::mat4 Renderer::projectionMatrix() const { + const VkExtent2D extent = swapChain_->extent(); + // Une hauteur nulle est possible pendant une minimisation : on evite la + // division par zero, la matrice obtenue n'etant de toute facon pas utilisee + // (aucune frame n'est presentee dans cet etat). + const float height = (extent.height > 0) ? static_cast(extent.height) : 1.0f; + const float aspect = static_cast(extent.width) / height; + + glm::mat4 proj = glm::perspective(glm::radians(60.0f), aspect, + options_.nearPlane, options_.farPlane); + // GLM a ete concu pour OpenGL (Y clip inverse par rapport a Vulkan) : on + // reinverse l'axe Y de la projection. + proj[1][1] *= -1.0f; + return proj; +} + +// --------------------------------------------------------------------------- +// Command pool / buffers +// --------------------------------------------------------------------------- +void Renderer::createCommandPool() { + VkCommandPoolCreateInfo poolInfo{}; + poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + // RESET_COMMAND_BUFFER : on reenregistre chaque buffer a chaque frame. + poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + poolInfo.queueFamilyIndex = context_.queueFamilies().graphicsFamily.value(); + + if (vkCreateCommandPool(context_.device(), &poolInfo, nullptr, &commandPool_) != VK_SUCCESS) { + throw std::runtime_error("Echec de la creation du command pool."); + } +} + +void Renderer::createCommandBuffers() { + commandBuffers_.resize(kMaxFramesInFlight); + + VkCommandBufferAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.commandPool = commandPool_; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandBufferCount = static_cast(commandBuffers_.size()); + + if (vkAllocateCommandBuffers(context_.device(), &allocInfo, commandBuffers_.data()) != VK_SUCCESS) { + throw std::runtime_error("Echec de l'allocation des command buffers."); + } +} + +// --------------------------------------------------------------------------- +// UBO + descriptors +// --------------------------------------------------------------------------- +void Renderer::createUniformBuffers() { + const VkDeviceSize bufferSize = sizeof(UniformBufferObject); + uniformBuffers_.resize(kMaxFramesInFlight); + + for (int i = 0; i < kMaxFramesInFlight; ++i) { + // Host-visible + coherent, mappe en permanence : mis a jour chaque frame. + uniformBuffers_[i] = std::make_unique( + context_, bufferSize, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + uniformBuffers_[i]->map(); + } +} + +void Renderer::createDescriptorSetLayout() { + VkDescriptorSetLayoutBinding uboBinding{}; + uboBinding.binding = 0; + uboBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + uboBinding.descriptorCount = 1; + // Lu par le vertex shader (matrices MVP) ET par le fragment shader (viewPos, + // pour le speculaire). Oublier FRAGMENT_BIT ici declenche une erreur de + // validation des que le fragment shader accede au binding. + uboBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; + uboBinding.pImmutableSamplers = nullptr; + + // PHASE 11, binding 1 : orthophoto du terrain. Declare pour TOUS les + // materiaux, y compris ceux qui ne l'echantillonnent pas (cube, arbres) : un + // descriptor present dans le set mais non lu par un shader est parfaitement + // legal, alors qu'avoir deux layouts differents obligerait a deux jeux de + // pipelines et deux pools. Le binding pointe toujours sur une image valide - + // un texel blanc tant qu'aucune photo n'est chargee. + VkDescriptorSetLayoutBinding textureBinding{}; + textureBinding.binding = 1; + textureBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + textureBinding.descriptorCount = 1; + textureBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + textureBinding.pImmutableSamplers = nullptr; + + // PHASE 27, binding 2 : bruit periodique du micro-relief du sol. Toujours + // relie (cree avant les descriptor sets), lu par terrain.frag seulement. + VkDescriptorSetLayoutBinding detailBinding = textureBinding; + detailBinding.binding = 2; + + const std::array bindings{ uboBinding, textureBinding, + detailBinding }; + + VkDescriptorSetLayoutCreateInfo layoutInfo{}; + layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + layoutInfo.bindingCount = static_cast(bindings.size()); + layoutInfo.pBindings = bindings.data(); + + if (vkCreateDescriptorSetLayout(context_.device(), &layoutInfo, nullptr, + &descriptorSetLayout_) != VK_SUCCESS) { + throw std::runtime_error("Echec de la creation du descriptor set layout."); + } +} + +void Renderer::createDescriptorPool() { + std::array poolSizes{}; + poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + poolSizes[0].descriptorCount = static_cast(kMaxFramesInFlight); + poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + // Deux images par set depuis la Phase 27 : orthophoto et bruit de detail. + poolSizes[1].descriptorCount = static_cast(2 * kMaxFramesInFlight); + + VkDescriptorPoolCreateInfo poolInfo{}; + poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + poolInfo.poolSizeCount = static_cast(poolSizes.size()); + poolInfo.pPoolSizes = poolSizes.data(); + poolInfo.maxSets = static_cast(kMaxFramesInFlight); + + if (vkCreateDescriptorPool(context_.device(), &poolInfo, nullptr, &descriptorPool_) != VK_SUCCESS) { + throw std::runtime_error("Echec de la creation du descriptor pool."); + } +} + +void Renderer::createDescriptorSets() { + std::vector layouts(kMaxFramesInFlight, descriptorSetLayout_); + + VkDescriptorSetAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + allocInfo.descriptorPool = descriptorPool_; + allocInfo.descriptorSetCount = static_cast(kMaxFramesInFlight); + allocInfo.pSetLayouts = layouts.data(); + + descriptorSets_.resize(kMaxFramesInFlight); + if (vkAllocateDescriptorSets(context_.device(), &allocInfo, descriptorSets_.data()) != VK_SUCCESS) { + throw std::runtime_error("Echec de l'allocation des descriptor sets."); + } + + // Chaque set pointe vers l'uniform buffer de sa frame-in-flight. + for (int i = 0; i < kMaxFramesInFlight; ++i) { + VkDescriptorBufferInfo bufferInfo{}; + bufferInfo.buffer = uniformBuffers_[i]->handle(); + bufferInfo.offset = 0; + bufferInfo.range = sizeof(UniformBufferObject); + + VkWriteDescriptorSet write{}; + write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + write.dstSet = descriptorSets_[i]; + write.dstBinding = 0; + write.dstArrayElement = 0; + write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + write.descriptorCount = 1; + write.pBufferInfo = &bufferInfo; + + vkUpdateDescriptorSets(context_.device(), 1, &write, 0, nullptr); + } + + writeTextureDescriptors(); +} + +void Renderer::writeTextureDescriptors() { + // La texture de terrain si elle existe, le texel blanc sinon. Le binding + // n'est JAMAIS laisse vide : un descriptor non ecrit auquel un shader accede + // est une erreur de validation, et selon le driver un plantage. + const Texture& texture = terrainTexture_ ? *terrainTexture_ : *whiteTexture_; + + VkDescriptorImageInfo imageInfo{}; + imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + imageInfo.imageView = texture.view(); + imageInfo.sampler = texture.sampler(); + + for (int i = 0; i < kMaxFramesInFlight; ++i) { + VkWriteDescriptorSet write{}; + write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + write.dstSet = descriptorSets_[i]; + write.dstBinding = 1; + write.dstArrayElement = 0; + write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + write.descriptorCount = 1; + write.pImageInfo = &imageInfo; + + vkUpdateDescriptorSets(context_.device(), 1, &write, 0, nullptr); + + // PHASE 27 : bruit de detail, binding 2. Reecrit ici avec le reste pour + // qu'aucun chemin ne laisse le binding vide. + VkDescriptorImageInfo detailInfo{}; + detailInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + detailInfo.imageView = detailTexture_->view(); + detailInfo.sampler = detailTexture_->sampler(); + VkWriteDescriptorSet detailWrite = write; + detailWrite.dstBinding = 2; + detailWrite.pImageInfo = &detailInfo; + vkUpdateDescriptorSets(context_.device(), 1, &detailWrite, 0, nullptr); + } +} + +void Renderer::setTerrainTexture(const TextureData& data) { + // Le GPU peut encore lire l'ancienne texture : on attend avant de la + // remplacer. Sans consequence, l'appel ayant lieu a l'initialisation. + waitIdle(); + + terrainTexture_ = std::make_unique(context_, commandPool_, + context_.graphicsQueue(), data); + writeTextureDescriptors(); + + logInfo("Orthophoto reliee au terrain : " + std::to_string(data.width) + "x" + + std::to_string(data.height) + ", " + + std::to_string(terrainTexture_->deviceSize() / (1024 * 1024)) + + " Mo sur le GPU."); +} + +void Renderer::setOrthoMix(float mix) { + options_.orthoMix = std::clamp(mix, 0.0f, 1.0f); +} + +void Renderer::setSun(const glm::vec3& direction, float intensity, const glm::vec3& color, + float ambient) { + const float length = glm::length(direction); + if (std::isfinite(length) && length > 1e-4f) { + const glm::vec3 unit = direction / length; + sun_ = glm::vec4(unit, std::clamp(intensity, 0.0f, 1.0f)); + } else { + // Direction degeneree : on garde l'ancienne et on ne met a jour que + // l'intensite. Eteindre l'image serait une reaction disproportionnee a + // une entree douteuse. + sun_.w = std::clamp(intensity, 0.0f, 1.0f); + } + + // PHASE 27 : le multiplicateur d'ambiante peut depasser 1 (ciel couvert : + // la lumiere diffuse remplace le direct, voir weatherVisualsFor). Borne + // haute a 4, garde-fou contre une valeur absurde, et non plus 1 - qui + // avait silencieusement annule tout l'effet a la premiere capture. + sunColor_ = glm::vec4(glm::clamp(color, glm::vec3(0.0f), glm::vec3(1.0f)), + std::isfinite(ambient) ? std::clamp(ambient, 0.0f, 4.0f) : 1.0f); +} + +void Renderer::setWeatherVisuals(const glm::vec3& fogColor, float fogDensityPerMeter, + float precipitation, bool snow, + const glm::vec3& fallVelocity, float groundDarkening, + float timeSeconds) { + // Toute entree non finie est ramenee au NEUTRE (pas de brouillard, pas de + // pluie) : une valeur douteuse ne doit ni noircir ni blanchir l'image. + const auto finiteOr = [](float v, float fallback) { + return std::isfinite(v) ? v : fallback; + }; + fog_ = glm::vec4(glm::clamp(fogColor, glm::vec3(0.0f), glm::vec3(1.0f)), + std::max(0.0f, finiteOr(fogDensityPerMeter, 0.0f))); + precip_ = glm::vec4(std::clamp(finiteOr(precipitation, 0.0f), 0.0f, 1.0f), + snow ? 1.0f : 0.0f, + finiteOr(timeSeconds, 0.0f), + std::clamp(finiteOr(groundDarkening, 0.0f), 0.0f, 1.0f)); + const bool fallOk = std::isfinite(fallVelocity.x) && std::isfinite(fallVelocity.y) && + std::isfinite(fallVelocity.z); + fall_ = glm::vec4(fallOk ? fallVelocity : glm::vec3(0.0f, -6.5f, 0.0f), 0.0f); +} + +void Renderer::setGroundDetail(float strength, float fadeStart, float fadeEnd, + float patternMeters) { + const float start = std::isfinite(fadeStart) ? std::max(0.0f, fadeStart) : 0.0f; + const float end = std::isfinite(fadeEnd) ? std::max(start + 0.01f, fadeEnd) : start + 1.0f; + detail_ = glm::vec4(std::isfinite(strength) ? std::clamp(strength, 0.0f, 1.0f) : 0.0f, + start, end, + std::isfinite(patternMeters) ? std::max(0.01f, patternMeters) : 1.0f); +} + +void Renderer::updateUniformBuffer(uint32_t frameIndex, const Camera& camera) { + UniformBufferObject ubo{}; + + // La model matrix n'est plus ici : elle est propre a chaque objet et part + // par push constant au moment de son draw (voir recordCommandBuffer). + ubo.view = camera.viewMatrix(); + // Position de la camera : utilisee par le fragment shader pour le speculaire. + ubo.viewPos = camera.position(); + // z = dosage orthophoto. Force a zero tant qu'aucune texture n'est reliee : + // le binding porte alors un texel blanc, et laisser passer un dosage non nul + // afficherait un terrain uniformement blanc au lieu du repli procedural. + const float mix = terrainTexture_ ? options_.orthoMix : 0.0f; + // w = force de l'indice adret/ubac (PHASE 25). Le champ etait marque + // "reserve" depuis la Phase 11 ; il l'est resté jusqu'ici. + ubo.terrain = glm::vec4(options_.heightRange.x, options_.heightRange.y, mix, aspectTint_); + + // Exactement la matrice que projectionMatrix() a rendue a l'appelant pour + // son frustum culling : une seule definition, donc aucun risque que le + // culling et le rendu ne voient pas le meme tronc de vision. + ubo.proj = projectionMatrix(); + + // PHASE 23 : la lumiere du cycle jour/nuit. Une seule ecriture par image, + // dans le bloc qui portait deja tout ce qui est constant sur la frame. + ubo.sun = sun_; + ubo.sunColor = sunColor_; + ubo.fog = fog_; + ubo.precip = precip_; + ubo.fall = fall_; + ubo.detail = detail_; + + std::memcpy(uniformBuffers_[frameIndex]->mapped(), &ubo, sizeof(ubo)); +} + +// --------------------------------------------------------------------------- +// Synchronisation +// --------------------------------------------------------------------------- +void Renderer::createFrameSyncObjects() { + imageAvailableSemaphores_.resize(kMaxFramesInFlight); + inFlightFences_.resize(kMaxFramesInFlight); + + VkSemaphoreCreateInfo semaphoreInfo{}; + semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + + VkFenceCreateInfo fenceInfo{}; + fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + // Cree signalee pour que la premiere frame n'attende pas indefiniment. + fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; + + VkDevice device = context_.device(); + for (int i = 0; i < kMaxFramesInFlight; ++i) { + if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores_[i]) != VK_SUCCESS || + vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences_[i]) != VK_SUCCESS) { + throw std::runtime_error("Echec de la creation des objets de synchro (frame)."); + } + } +} + +void Renderer::createImageSyncObjects() { + // Un semaphore "renderFinished" par image de swapchain : evite qu'un semaphore + // soit reutilise alors qu'une presentation precedente ne l'a pas encore attendu. + const uint32_t count = swapChain_->imageCount(); + renderFinishedSemaphores_.resize(count); + + VkSemaphoreCreateInfo semaphoreInfo{}; + semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + + for (uint32_t i = 0; i < count; ++i) { + if (vkCreateSemaphore(context_.device(), &semaphoreInfo, nullptr, + &renderFinishedSemaphores_[i]) != VK_SUCCESS) { + throw std::runtime_error("Echec de la creation des objets de synchro (image)."); + } + } + + // Aucune image n'est occupee au demarrage. + imagesInFlight_.assign(count, VK_NULL_HANDLE); +} + +void Renderer::destroyImageSyncObjects() { + for (VkSemaphore s : renderFinishedSemaphores_) { + vkDestroySemaphore(context_.device(), s, nullptr); + } + renderFinishedSemaphores_.clear(); + imagesInFlight_.clear(); +} + +// --------------------------------------------------------------------------- +// Transferts asynchrones (PHASE 12) +// --------------------------------------------------------------------------- +// Rappel du probleme (Phase 10) : chaque tuile de terrain televersee faisait un +// vkQueueWaitIdle, c'est-a-dire vidait la queue graphique. Quatre tuiles par +// frame suffisaient a manger le budget d'image, d'ou le plafond artificiel +// maxUploadsPerFrame = 4 et les trous a l'horizon en deplacement rapide. +// +// Ce GPU (Intel UHD 770) n'expose AUCUNE famille de transfert dediee : famille 0 +// graphics/compute/transfer, famille 1 video sans bit transfert (journalise au +// demarrage par VulkanContext). Les transferts partagent donc forcement la queue +// graphique, et une "soumission asynchrone separee sur la meme queue" n'y +// gagnerait rien de plus que ce qui suit, tout en ajoutant une soumission et une +// fence par frame. +// +// Choix retenu : les copies sont enregistrees DANS le command buffer de la +// frame, en tete, avant vkCmdBeginRenderPass, suivies d'une seule barriere +// memoire transfert -> vertex input. Proprietes : +// - aucune attente CPU nulle part sur le chemin critique ; +// - une seule soumission par frame, comme avant ; +// - la dependance memoire est EXPLICITE et verifiable par la validation de +// synchronisation, au lieu de reposer sur un vidage de queue ; +// - aucun transfert de propriete de famille de queue a ecrire (meme famille), +// donc pas de code de synchronisation impossible a eprouver ici ; +// - la tuile est lisible DES CETTE FRAME : le repli sur l'ancetre ne sert donc +// qu'aux tuiles pas encore CONSTRUITES (budget), pas a une latence de +// transfert. +void Renderer::enqueueCopy(std::unique_ptr staging, VkBuffer destination) { + if (!staging || destination == VK_NULL_HANDLE) { + return; + } + PendingCopy copy; + copy.size = staging->size(); + copy.destination = destination; + copy.staging = std::move(staging); + stagingBytesInFlight_ += static_cast(copy.size); + pendingCopies_.push_back(std::move(copy)); + + // Garde-fou memoire : un televersement geant (le maillage d'un bloc entier + // sur le chemin --no-lod) ne doit pas garder des gigaoctets de staging le + // temps de trois frames. Voir kMaxPendingStagingBytes. + if (stagingBytesInFlight_ > kMaxPendingStagingBytes) { + flushCopiesNow(); + } +} + +void Renderer::flushCopiesNow() { + if (pendingCopies_.empty()) { + return; + } + VkDevice device = context_.device(); + + VkCommandBufferAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandPool = commandPool_; + allocInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer = VK_NULL_HANDLE; + if (vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer) != VK_SUCCESS) { + return; // les copies restent en attente : elles partiront avec la frame + } + + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + vkBeginCommandBuffer(commandBuffer, &beginInfo); + + for (const PendingCopy& copy : pendingCopies_) { + VkBufferCopy region{}; + region.size = copy.size; + vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination, + 1, ®ion); + } + vkEndCommandBuffer(commandBuffer); + + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + + vkQueueSubmit(context_.graphicsQueue(), 1, &submitInfo, VK_NULL_HANDLE); + // Le seul vkQueueWaitIdle qui subsiste sur un upload de geometrie, et il + // n'est atteint que par un maillage de plus de 128 Mo, donc jamais par une + // tuile de streaming. Meme forme que VulkanBuffer::copyFrom. + vkQueueWaitIdle(context_.graphicsQueue()); + + vkFreeCommandBuffers(device, commandPool_, 1, &commandBuffer); + + std::size_t freed = 0; + for (const PendingCopy& copy : pendingCopies_) { + freed += static_cast(copy.size); + } + stagingBytesInFlight_ -= freed; + pendingCopies_.clear(); // detruit les staging : le GPU a fini de les lire + + logInfo("Transfert synchrone de secours : " + + std::to_string(freed / (1024 * 1024)) + + " Mo de staging depassaient le plafond, copie attendue puis liberee."); +} + +void Renderer::recordPendingCopies(VkCommandBuffer commandBuffer) { + if (pendingCopies_.empty()) { + return; + } + + for (PendingCopy& copy : pendingCopies_) { + VkBufferCopy region{}; + region.size = copy.size; + vkCmdCopyBuffer(commandBuffer, copy.staging->handle(), copy.destination, + 1, ®ion); + // Le staging passe en attente de fin d'execution. Meme delai que les + // meshes retires : kMaxFramesInFlight + 1 vieillissements, ce qui + // garantit que la frame qui porte cette copie est terminee. + retiredStaging_.push_back({ std::move(copy.staging), kMaxFramesInFlight + 1 }); + } + pendingCopies_.clear(); + + // UNE barriere pour toutes les copies : elles ecrivent toutes des buffers de + // geometrie, et elles sont toutes lues au meme endroit (l'assemblage des + // sommets). Une barriere par buffer serait exact aussi, mais ferait N + // barrieres pour une seule dependance reelle. + // + // VK_ACCESS_INDEX_READ_BIT autant que VERTEX_ATTRIBUTE_READ : un Mesh + // televerse ses sommets ET ses indices. + VkMemoryBarrier barrier{}; + barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; + barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + barrier.dstAccessMask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT | VK_ACCESS_INDEX_READ_BIT; + + vkCmdPipelineBarrier(commandBuffer, + VK_PIPELINE_STAGE_TRANSFER_BIT, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, + 0, + 1, &barrier, + 0, nullptr, + 0, nullptr); +} + +// --------------------------------------------------------------------------- +// Enregistrement des commandes +// --------------------------------------------------------------------------- +void Renderer::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex, + const std::vector& items, + const std::vector& instanced) { + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + + if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) { + throw std::runtime_error("Echec du debut d'enregistrement du command buffer."); + } + + // PHASE 12 : transferts d'abord, HORS du render pass. Un vkCmdCopyBuffer est + // interdit a l'interieur d'un render pass, et la barriere doit de toute + // facon precede tout draw qui lirait la geometrie fraichement copiee. + recordPendingCopies(commandBuffer); + + // Deux valeurs de clear : couleur (attache 0) et profondeur (attache 1). + std::array clearValues{}; + clearValues[0].color = { { options_.clearColor.r, + options_.clearColor.g, + options_.clearColor.b, 1.0f } }; + clearValues[1].depthStencil = { 1.0f, 0 }; // 1.0 = plan lointain + + VkRenderPassBeginInfo renderPassInfo{}; + renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + renderPassInfo.renderPass = swapChain_->renderPass(); + renderPassInfo.framebuffer = swapChain_->framebuffer(imageIndex); + renderPassInfo.renderArea.offset = { 0, 0 }; + renderPassInfo.renderArea.extent = swapChain_->extent(); + renderPassInfo.clearValueCount = static_cast(clearValues.size()); + renderPassInfo.pClearValues = clearValues.data(); + + vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE); + + // Viewport et scissor dynamiques : adaptes a l'extent courant. Fixes une + // seule fois : ils font partie de l'etat du command buffer, pas du pipeline. + const VkExtent2D extent = swapChain_->extent(); + VkViewport viewport{}; + viewport.x = 0.0f; + viewport.y = 0.0f; + viewport.width = static_cast(extent.width); + viewport.height = static_cast(extent.height); + viewport.minDepth = 0.0f; + viewport.maxDepth = 1.0f; + vkCmdSetViewport(commandBuffer, 0, 1, &viewport); + + VkRect2D scissor{}; + scissor.offset = { 0, 0 }; + scissor.extent = extent; + vkCmdSetScissor(commandBuffer, 0, 1, &scissor); + + // Un passage par materiau plutot qu'un parcours dans l'ordre d'arrivee : + // les objets d'un meme materiau sont dessines a la suite, donc le pipeline + // n'est lie qu'une fois par materiau reellement utilise (au plus deux fois + // par frame ici). Avec quelques dizaines d'objets, ce tri "par balayage" + // coute moins cher qu'un vrai tri, et evite de copier la liste. + for (uint32_t m = 0; m < kMaterialCount; ++m) { + const Material material = static_cast(m); + bool pipelineBound = false; + + for (const DrawItem& item : items) { + if (item.material != material) { + continue; + } + if (item.mesh >= meshes_.size() || !meshes_[item.mesh]) { + // Poignee invalide, ou emplacement libere par removeMesh depuis + // que la liste a ete construite : on ignore l'objet plutot que + // de laisser le driver lire hors du tableau (ou de dereferencer + // un pointeur nul). Signaler serait bruyant a 60 Hz. + continue; + } + + if (!pipelineBound) { + vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + pipelines_[m]->handle()); + // Descriptor set (UBO) de la frame-in-flight courante. Relie + // apres chaque changement de pipeline : les layouts des deux + // pipelines sont identiques donc compatibles, mais s'appuyer + // sur cette compatibilite serait fragile au moindre ajout. + vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + pipelines_[m]->layout(), 0, 1, + &descriptorSets_[currentFrame_], 0, nullptr); + pipelineBound = true; + } + + // Transformation et parametres propres a cet objet. Les deux sont + // pousses d'un seul coup : ils sont contigus dans DrawItemPush, + // dont le layout reproduit exactement le bloc push_constant des + // shaders (voir DrawItem.hpp). + const DrawItemPush push{ item.model, item.params }; + vkCmdPushConstants(commandBuffer, pipelines_[m]->layout(), + VK_SHADER_STAGE_VERTEX_BIT, 0, + static_cast(sizeof(DrawItemPush)), &push); + + const Mesh& mesh = *meshes_[item.mesh]; + mesh.bind(commandBuffer); + mesh.draw(commandBuffer); + } + + // --- Geometrie INSTANCIEE du meme materiau (Phase 11) --------------- + // Dans le meme passage par materiau que ci-dessus, pour que le pipeline + // ne soit lie qu'une fois, y compris quand un materiau porte a la fois + // des objets simples et des instances. + for (std::size_t index = 0; index < instanced.size(); ++index) { + const InstancedDrawItem& item = instanced[index]; + if (item.material != material || item.count == 0) { + continue; + } + if (item.mesh >= meshes_.size() || !meshes_[item.mesh]) { + continue; + } + + if (!pipelineBound) { + vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + pipelines_[m]->handle()); + vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + pipelines_[m]->layout(), 0, 1, + &descriptorSets_[currentFrame_], 0, nullptr); + pipelineBound = true; + } + + const DrawItemPush push{ glm::mat4(1.0f), item.params }; + vkCmdPushConstants(commandBuffer, pipelines_[m]->layout(), + VK_SHADER_STAGE_VERTEX_BIT, 0, + static_cast(sizeof(DrawItemPush)), &push); + + const Mesh& mesh = *meshes_[item.mesh]; + mesh.bind(commandBuffer); + + // Binding 1 : la tranche du buffer d'instances qui appartient a cet + // objet. L'offset a ete calcule par uploadInstances, dans le meme + // ordre que cette liste. + const VkBuffer instanceBuffer = instanceBuffers_[currentFrame_]->handle(); + const VkDeviceSize offset = instanceOffsets_[index]; + vkCmdBindVertexBuffers(commandBuffer, 1, 1, &instanceBuffer, &offset); + + mesh.drawInstanced(commandBuffer, item.count); + } + } + + // --- PHASE 27 : precipitation, en DERNIER -------------------------------- + // Apres toute la geometrie, un triangle plein ecran melange par alpha, sans + // test ni ecriture de profondeur. SAUTEE ENTIEREMENT par temps sec : pas de + // pipeline lie, pas de draw, donc un cout rigoureusement nul les jours sans + // precipitation. + if (precip_.x > 0.0f) { + vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + precipitationPipeline_->handle()); + vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + precipitationPipeline_->layout(), 0, 1, + &descriptorSets_[currentFrame_], 0, nullptr); + vkCmdDraw(commandBuffer, 3, 1, 0, 0); + } + + vkCmdEndRenderPass(commandBuffer); + + if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) { + throw std::runtime_error("Echec de la fin d'enregistrement du command buffer."); + } +} + +// --------------------------------------------------------------------------- +// Boucle de rendu +// --------------------------------------------------------------------------- +void Renderer::uploadInstances(const std::vector& instanced) { + instanceOffsets_.assign(instanced.size(), 0); + lastInstanceCount_ = 0; + + VkDeviceSize total = 0; + for (const InstancedDrawItem& item : instanced) { + if (item.instances == nullptr || item.count == 0) { + continue; + } + total += static_cast(item.count) * sizeof(InstanceData); + lastInstanceCount_ += item.count; + } + if (total == 0) { + return; + } + + std::unique_ptr& buffer = instanceBuffers_[currentFrame_]; + if (!buffer || buffer->size() < total) { + // Agrandissement avec de la marge (x1,5) : la vegetation visible varie + // continuement, et reallouer a chaque poignee d'instances de plus + // couterait une allocation Vulkan par frame. + // + // Remplacer le buffer ICI est sans risque : drawFrame a deja attendu la + // fence de cette frame-in-flight, donc plus aucune commande soumise ne + // lit l'ancien buffer. + const VkDeviceSize capacity = std::max( + static_cast(static_cast(total) * 1.5), + 64u * 1024u); + buffer = std::make_unique( + context_, capacity, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + buffer->map(); + logInfo("Instances : buffer porte a " + + std::to_string(capacity / 1024) + " Ko (frame " + + std::to_string(currentFrame_) + ")."); + } + + auto* destination = static_cast(buffer->mapped()); + VkDeviceSize offset = 0; + for (std::size_t index = 0; index < instanced.size(); ++index) { + const InstancedDrawItem& item = instanced[index]; + if (item.instances == nullptr || item.count == 0) { + continue; + } + const VkDeviceSize bytes = static_cast(item.count) * sizeof(InstanceData); + std::memcpy(destination + offset, item.instances, static_cast(bytes)); + instanceOffsets_[index] = offset; + offset += bytes; + } +} + +void Renderer::drawFrame(const Camera& camera, const std::vector& items) { + static const std::vector kNone; + drawFrame(camera, items, kNone); +} + +void Renderer::drawFrame(const Camera& camera, const std::vector& items, + const std::vector& instanced) { + VkDevice device = context_.device(); + + // 1. Attendre que la frame-in-flight courante soit libre. + vkWaitForFences(device, 1, &inFlightFences_[currentFrame_], VK_TRUE, UINT64_MAX); + + // Vieillissement des meshes retires (Phase 10, streaming par tuiles) : place + // ICI, apres l'attente de la fence, donc a un instant ou l'on sait qu'une + // frame de plus est reellement terminee. Un compteur atteint zero => plus + // aucune frame en vol ne peut referencer ces buffers, ils sont detruits. + for (std::size_t i = retiredMeshes_.size(); i-- > 0;) { + if (--retiredMeshes_[i].framesRemaining <= 0) { + if (i + 1 != retiredMeshes_.size()) { + retiredMeshes_[i] = std::move(retiredMeshes_.back()); + } + retiredMeshes_.pop_back(); + } + } + + // PHASE 12 : meme vieillissement pour les buffers staging dont la copie a + // ete soumise. A zero, la frame qui portait la copie est forcement terminee, + // donc plus personne ne lit le staging : il peut partir. + for (std::size_t i = retiredStaging_.size(); i-- > 0;) { + if (--retiredStaging_[i].framesRemaining <= 0) { + stagingBytesInFlight_ -= static_cast( + retiredStaging_[i].staging->size()); + if (i + 1 != retiredStaging_.size()) { + retiredStaging_[i] = std::move(retiredStaging_.back()); + } + retiredStaging_.pop_back(); + } + } + + // 1 bis. Recopier les instances de la frame. Place ICI, apres l'attente de + // la fence, parce que le buffer d'instances de cette frame-in-flight peut + // alors etre reecrit (ou remplace par un plus grand) sans qu'aucune commande + // en vol ne le lise. + uploadInstances(instanced); + + // 2. Acquerir la prochaine image. + uint32_t imageIndex = 0; + VkResult result = vkAcquireNextImageKHR( + device, swapChain_->handle(), UINT64_MAX, + imageAvailableSemaphores_[currentFrame_], VK_NULL_HANDLE, &imageIndex); + + if (result == VK_ERROR_OUT_OF_DATE_KHR) { + recreateSwapChain(); + return; // on repart proprement a la frame suivante. + } + if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) { + throw std::runtime_error("Echec de l'acquisition d'une image de swapchain."); + } + + // Si une frame precedente utilise encore cette image, attendre sa fence. + if (imagesInFlight_[imageIndex] != VK_NULL_HANDLE) { + vkWaitForFences(device, 1, &imagesInFlight_[imageIndex], VK_TRUE, UINT64_MAX); + } + imagesInFlight_[imageIndex] = inFlightFences_[currentFrame_]; + + // Mise a jour de l'UBO de cette frame (matrices MVP a partir de la camera). + updateUniformBuffer(currentFrame_, camera); + + // 3. Enregistrer les commandes. + vkResetCommandBuffer(commandBuffers_[currentFrame_], 0); + recordCommandBuffer(commandBuffers_[currentFrame_], imageIndex, items, instanced); + + // 4. Soumettre a la graphics queue. + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + + const VkSemaphore waitSemaphores[] = { imageAvailableSemaphores_[currentFrame_] }; + const VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT }; + submitInfo.waitSemaphoreCount = 1; + submitInfo.pWaitSemaphores = waitSemaphores; + submitInfo.pWaitDstStageMask = waitStages; + + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffers_[currentFrame_]; + + // Signale le semaphore associe a l'image (et non a la frame-in-flight). + const VkSemaphore signalSemaphores[] = { renderFinishedSemaphores_[imageIndex] }; + submitInfo.signalSemaphoreCount = 1; + submitInfo.pSignalSemaphores = signalSemaphores; + + // Reset de la fence juste avant la soumission qui va la re-signaler. + vkResetFences(device, 1, &inFlightFences_[currentFrame_]); + + if (vkQueueSubmit(context_.graphicsQueue(), 1, &submitInfo, + inFlightFences_[currentFrame_]) != VK_SUCCESS) { + throw std::runtime_error("Echec de la soumission du command buffer."); + } + + // 5. Presenter. + VkPresentInfoKHR presentInfo{}; + presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; + presentInfo.waitSemaphoreCount = 1; + presentInfo.pWaitSemaphores = signalSemaphores; + + const VkSwapchainKHR swapChains[] = { swapChain_->handle() }; + presentInfo.swapchainCount = 1; + presentInfo.pSwapchains = swapChains; + presentInfo.pImageIndices = &imageIndex; + + result = vkQueuePresentKHR(context_.presentQueue(), &presentInfo); + + if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || + window_.wasResized()) { + window_.resetResizedFlag(); + recreateSwapChain(); + } else if (result != VK_SUCCESS) { + throw std::runtime_error("Echec de la presentation d'une image."); + } + + currentFrame_ = (currentFrame_ + 1) % kMaxFramesInFlight; +} + +// --------------------------------------------------------------------------- +// Resize : swapchain ET depth buffer recrees ensemble (le depth vit dans SwapChain) +// --------------------------------------------------------------------------- +void Renderer::recreateSwapChain() { + // Si la fenetre est minimisee (taille 0), on attend qu'elle reprenne une taille. + int width = 0; + int height = 0; + window_.getFramebufferSize(width, height); + while (width == 0 || height == 0) { + window_.getFramebufferSize(width, height); + window_.waitEvents(); + } + + // Attendre que le GPU n'utilise plus les ressources qu'on va recreer. + vkDeviceWaitIdle(context_.device()); + + swapChain_->recreate(); + + // Le nombre d'images peut changer : on recree les objets de synchro par image. + destroyImageSyncObjects(); + createImageSyncObjects(); +} + +} // namespace vercora diff --git a/src/renderer/Renderer.hpp b/src/renderer/Renderer.hpp new file mode 100644 index 0000000..922cc7a --- /dev/null +++ b/src/renderer/Renderer.hpp @@ -0,0 +1,408 @@ +#pragma once + +#include "renderer/DrawItem.hpp" +#include "renderer/Pipeline.hpp" // pour ShaderSet +#include "renderer/VulkanBuffer.hpp" // pour BufferUploader + +#include +#include + +#include +#include +#include +#include +#include + +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& 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& items, + const std::vector& 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 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& items, + const std::vector& 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& instanced); + void recreateSwapChain(); + + VulkanContext& context_; + Window& window_; + RenderOptions options_; + + std::unique_ptr 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, 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 precipitationPipeline_; + + VkCommandPool commandPool_ = VK_NULL_HANDLE; + std::vector 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> meshes_; + + // Emplacements de meshes_ liberes par removeMesh, reutilisables par addMesh. + // Sans cette liste, meshes_ grandirait indefiniment au fil du streaming. + std::vector 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; + int framesRemaining = 0; + }; + std::vector 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 staging; + VkBuffer destination = VK_NULL_HANDLE; + VkDeviceSize size = 0; + }; + std::vector 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 staging; + int framesRemaining = 0; + }; + std::vector retiredStaging_; + + std::size_t stagingBytesInFlight_ = 0; + + // UBO : un buffer host-visible mappe en permanence, par frame-in-flight. + std::vector> uniformBuffers_; + + // Descriptors. + VkDescriptorSetLayout descriptorSetLayout_ = VK_NULL_HANDLE; + VkDescriptorPool descriptorPool_ = VK_NULL_HANDLE; + std::vector 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 whiteTexture_; + std::unique_ptr terrainTexture_; + // PHASE 27 : bruit periodique du micro-relief (binding 2). Genere au + // demarrage par makeDetailNoiseTexture, 256x256 RGBA8 + mipmaps, 341 Ko. + std::unique_ptr 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> instanceBuffers_; + std::vector instanceOffsets_; // un par InstancedDrawItem de la frame + + uint32_t lastInstanceCount_ = 0; + + // Synchronisation. + std::vector imageAvailableSemaphores_; // par frame-in-flight + std::vector renderFinishedSemaphores_; // par image de swapchain + std::vector inFlightFences_; // par frame-in-flight + std::vector imagesInFlight_; // suivi : quelle fence occupe l'image + + uint32_t currentFrame_ = 0; +}; + +} // namespace vercora diff --git a/src/renderer/SwapChain.cpp b/src/renderer/SwapChain.cpp new file mode 100644 index 0000000..eec6a33 --- /dev/null +++ b/src/renderer/SwapChain.cpp @@ -0,0 +1,393 @@ +#include "renderer/SwapChain.hpp" + +#include "core/Logger.hpp" +#include "core/Window.hpp" +#include "renderer/VulkanContext.hpp" + +#include +#include +#include +#include +#include + +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& 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& 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::max()) { + return capabilities.currentExtent; + } + int width = 0; + int height = 0; + window_.getFramebufferSize(width, height); + + VkExtent2D actual{ static_cast(width), static_cast(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 attachments = { colorAttachment, depthAttachment }; + + VkRenderPassCreateInfo renderPassInfo{}; + renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + renderPassInfo.attachmentCount = static_cast(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 attachments = { imageViews_[i], depthImageView_ }; + + VkFramebufferCreateInfo framebufferInfo{}; + framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + framebufferInfo.renderPass = renderPass_; + framebufferInfo.attachmentCount = static_cast(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 diff --git a/src/renderer/SwapChain.hpp b/src/renderer/SwapChain.hpp new file mode 100644 index 0000000..81e190d --- /dev/null +++ b/src/renderer/SwapChain.hpp @@ -0,0 +1,77 @@ +#pragma once + +#include + +#include + +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(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& formats) const; + VkPresentModeKHR choosePresentMode(const std::vector& 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 images_; + std::vector imageViews_; + std::vector 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 diff --git a/src/renderer/TerrainMesh.cpp b/src/renderer/TerrainMesh.cpp new file mode 100644 index 0000000..9fc398c --- /dev/null +++ b/src/renderer/TerrainMesh.cpp @@ -0,0 +1,148 @@ +#include "renderer/TerrainMesh.hpp" + +#include "assets/Heightmap.hpp" +#include "core/Logger.hpp" + +#include +#include +#include + +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(res) * res); + mesh.indices.reserve(static_cast(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(xp - xm) * spacing); + const float dhdz = (heightmap.at(ix, zp) - heightmap.at(ix, zm)) / + (static_cast(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(ix) / static_cast(cells), + static_cast(iz) / static_cast(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 diff --git a/src/renderer/TerrainMesh.hpp b/src/renderer/TerrainMesh.hpp new file mode 100644 index 0000000..4ba978d --- /dev/null +++ b/src/renderer/TerrainMesh.hpp @@ -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 diff --git a/src/renderer/TerrainNodeMesh.cpp b/src/renderer/TerrainNodeMesh.cpp new file mode 100644 index 0000000..6ebe4c8 --- /dev/null +++ b/src/renderer/TerrainNodeMesh.cpp @@ -0,0 +1,199 @@ +#include "renderer/TerrainNodeMesh.hpp" + +#include "assets/Heightmap.hpp" +#include "world/TerrainQuadtree.hpp" + +#include +#include +#include +#include +#include + +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(gx) - stride : gx; + const int64_t xp = (gx + stride <= cells) ? static_cast(gx) + stride : gx; + const int64_t zm = (gz >= stride) ? static_cast(gz) - stride : gz; + const int64_t zp = (gz + stride <= cells) ? static_cast(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(xp - xm) * spacing; + const float dz = static_cast(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 terrainNodeIndices(uint32_t nodeCells) { + if (nodeCells < 1) { + throw std::runtime_error("TerrainNodeMesh : nodeCells nul."); + } + const uint32_t verts = nodeCells + 1; + + std::vector indices; + indices.reserve(static_cast(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 parentGrid; + if (reuseParentGrid) { + parentGrid.resize(static_cast(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(pj) * parentVerts + pi] = + sampleGrid(heightmap, cells, mx, mz, stride * 2u); + } + } + + MeshData mesh; + mesh.name = "tuile L" + std::to_string(static_cast(node.level)) + " (" + + std::to_string(node.ix0) + "," + std::to_string(node.iz0) + ")"; + mesh.vertices.resize(static_cast(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(j / 2u) * parentVerts + (i / 2u)] + : parentSample; + + Vertex& vertex = mesh.vertices[static_cast(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(gx) / static_cast(cells), + static_cast(gz) / static_cast(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 diff --git a/src/renderer/TerrainNodeMesh.hpp b/src/renderer/TerrainNodeMesh.hpp new file mode 100644 index 0000000..8244232 --- /dev/null +++ b/src/renderer/TerrainNodeMesh.hpp @@ -0,0 +1,66 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +#include +#include + +namespace vercora { + +class Heightmap; +class TerrainQuadtree; + +// Maillage d'UN noeud de quadtree (Phase 10). +// +// Le pendant "par tuile" de renderer/TerrainMesh.hpp, qui lui maille la grille +// ENTIERE en un seul bloc. Les deux coexistent volontairement : TerrainMesh +// reste le chemin de reference (option --no-lod du jeu), ce qui permet de +// comparer avant/apres sur exactement la meme scene. +// +// Ce que le maillage d'un noeud a de particulier : +// +// - Il echantillonne la grille au PAS DU NOEUD (node.stride), pas au pas de la +// donnee. Un noeud de niveau 3 lit un point sur huit : meme nombre de +// sommets qu'une feuille, huit fois plus de terrain couvert. +// +// - Les indices de grille sont ECRETES sur le bord du terrain. Un noeud qui +// depasse ne produit donc pas une "etagere" plate au-dela des donnees, mais +// des triangles degeneres (sommets confondus) que le rasterizer ignore. +// +// - Chaque sommet porte sa CIBLE DE GEOMORPHING : sa position et sa normale +// dans la grille du niveau superieur, obtenues en arrondissant ses indices +// LOCAUX vers le bas a un multiple de deux (c'est exactement la grille que +// dessinerait le noeud parent). Un sommet d'indice local pair est deja sur +// cette grille et ne bouge pas ; un sommet impair vient se confondre avec son +// voisin pair. A morph = 1, la tuile a donc EXACTEMENT la forme de son +// parent, ce qui est la condition pour que le raccord avec une tuile voisine +// plus grossiere soit sans fissure. +// +// - Les indices (la topologie) sont IDENTIQUES pour tous les noeuds de tous les +// niveaux : c'est toujours la meme grille reguliere de nodeCells x nodeCells +// cellules. Ils sont donc calcules une fois et recopies (voir +// terrainNodeIndices). +// +// `withIndices` = false laisse `indices` VIDE ; c'est a l'appelant de poser la +// topologie. PHASE 18 : elle est identique pour toutes les tuiles de tous les +// niveaux (la remarque etait deja dans cet en-tete depuis la Phase 10, mais le +// code la reconstruisait quand meme a chaque tuile), et TerrainStreamer en +// garde desormais UN exemplaire qu'il recopie. Le defaut reste `true` pour que +// tout autre appelant - les tests headless notamment - obtienne un maillage +// complet et utilisable tel quel. +// +// Lance std::runtime_error si le noeud ne peut pas produire un maillage sain. +// `reuseParentGrid` = false recalcule la cible de morphing SOMMET PAR SOMMET, +// c'est-a-dire quatre fois par bloc 2x2 : c'est le comportement d'avant la +// Phase 18, conserve comme TEMOIN de mesure (option de jeu --no-tile-cache). +// Le resultat est identique - c'est la meme fonction avec les memes arguments - +// seul le nombre d'appels change, ce que verifie tests\logic_tests.cpp. +MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& quadtree, + uint32_t nodeIndex, bool withIndices = true, + bool reuseParentGrid = true); + +// Topologie commune a tous les noeuds : deux triangles par cellule, meme +// diagonale que TerrainMesh. Calculee une fois par appelant et reutilisee. +std::vector terrainNodeIndices(uint32_t nodeCells); + +} // namespace vercora diff --git a/src/renderer/TerrainStreamer.cpp b/src/renderer/TerrainStreamer.cpp new file mode 100644 index 0000000..fa8384c --- /dev/null +++ b/src/renderer/TerrainStreamer.cpp @@ -0,0 +1,618 @@ +#include "renderer/TerrainStreamer.hpp" + +#include "assets/Heightmap.hpp" +#include "core/Logger.hpp" +#include "renderer/MeshData.hpp" +#include "renderer/Renderer.hpp" +#include "renderer/TerrainNodeMesh.hpp" + +#include +#include +#include +#include +#include + +namespace vercora { + +TerrainStreamer::TerrainStreamer(const Heightmap& heightmap, Renderer& renderer, + const Params& params) + : heightmap_(heightmap), renderer_(renderer), params_(params), + quadtree_(heightmap, params.quadtree) { + logInfo(quadtree_.describe()); + + const std::size_t bytesPerNode = static_cast(quadtree_.nodeCells() + 1) * + (quadtree_.nodeCells() + 1) * sizeof(Vertex) + + static_cast(quadtree_.trianglesPerNode()) * + 3 * sizeof(uint32_t); + logInfo("Streaming terrain : au plus " + std::to_string(params_.maxResidentNodes) + + " tuiles residentes (" + + std::to_string(params_.maxResidentNodes * bytesPerNode / (1024 * 1024)) + + " Mo de geometrie GPU), " + std::to_string(params_.maxUploadsPerFrame) + + " construites par frame."); + + pinTopLevels(); +} + +void TerrainStreamer::pinTopLevels() { + if (params_.pinnedTopLevels == 0) { + logInfo("Sommet du quadtree NON epingle : un trou redevient possible si " + "une tuile grossiere n'est pas prete a temps."); + return; + } + + // Niveau le plus fin a epingler. La soustraction est faite en entier signe : + // sur un terrain minuscule, rootLevel peut etre inferieur au nombre de + // niveaux demandes, et on epingle alors simplement tout l'arbre. + const int lowest = std::max(0, static_cast(quadtree_.rootLevel()) - + static_cast(params_.pinnedTopLevels) + 1); + + const std::size_t bytesPerNode = + static_cast(quadtree_.nodeCells() + 1) * + (quadtree_.nodeCells() + 1) * sizeof(Vertex) + + static_cast(quadtree_.trianglesPerNode()) * 3 * sizeof(uint32_t); + + for (uint32_t index = 0; index < quadtree_.nodeCount(); ++index) { + if (static_cast(quadtree_.node(index).level) < lowest) { + continue; + } + const MeshHandle mesh = buildNode(index); + if (mesh == kInvalidMesh) { + continue; // buildNode a deja journalise ; le repli sera juste moins bon + } + ResidentNode node; + node.mesh = mesh; + node.bytes = bytesPerNode; + node.pinned = true; + // Jamais rajeunie ensuite : elle n'est de toute facon pas evincable. + node.lastUsedFrame = 0; + resident_.emplace(index, node); + residentBytes_ += bytesPerNode; + ++pinnedCount_; + } + + logInfo("Sommet du quadtree epingle : " + std::to_string(pinnedCount_) + + " tuiles de niveau " + std::to_string(lowest) + " a " + + std::to_string(static_cast(quadtree_.rootLevel())) + " (" + + std::to_string(pinnedCount_ * bytesPerNode / (1024 * 1024)) + + " Mo), jamais evincees. C'est ce qui rend le repli sur l'ancetre " + "toujours disponible."); +} + +TerrainStreamer::~TerrainStreamer() { + // Les tuiles sont rendues au Renderer, qui differe leur destruction reelle. + // Le Renderer attend le GPU avant de se detruire lui-meme, donc l'ordre est + // sur quel que soit celui des deux qui part en premier. + for (const auto& entry : resident_) { + renderer_.removeMesh(entry.second.mesh); + } + logInfo("Streaming terrain : pics de la session - " + std::to_string(peakSelected_) + + " tuiles selectionnees, " + std::to_string(peakResident_) + + " residentes, " + std::to_string(peakResidentBytes_ / (1024 * 1024)) + + " Mo de geometrie GPU, au plus " + std::to_string(peakBuiltPerFrame_) + + " construites en une frame."); + logInfo(holeReport()); + logInfo(buildProfile()); +} + +const std::vector& TerrainStreamer::sharedIndices() const { + // La topologie d'une tuile - 24 576 indices pour 64x64 cellules - est + // IDENTIQUE pour toutes les tuiles de tous les niveaux. L'en-tete de + // TerrainNodeMesh.hpp le disait depuis la Phase 10 (« calcules une fois et + // recopies ») mais le code, lui, les reconstruisait a chaque tuile. + // + // Le profilage de la Phase 18 a chiffre ce travail redondant a + // 636 us/tuile, soit 23 % du cout total de construction - devant le + // televersement GPU (307 us), qui avait pourtant mobilise toute la Phase 12. + // C'est le genre de poste qu'on ne trouve qu'en mesurant : personne + // n'aurait parie sur la boucle d'indices. + // + // Construite a la premiere tuile puis simplement RECOPIEE dans le MeshData. + // Ne pas la recopier du tout - partager un unique buffer d'indices GPU entre + // toutes les tuiles - economiserait en plus 96 Ko par tuile residente, mais + // demanderait de dissocier sommets et indices dans Renderer::addMesh : c'est + // un chantier de renderer, pas de streaming (voir NOTES-PHASE18.md). + if (indexTemplate_.empty() || !params_.cacheTileWork) { + indexTemplate_ = terrainNodeIndices(quadtree_.nodeCells()); + } + return indexTemplate_; +} + +namespace { + +// Duree en microsecondes entre deux points d'horloge. steady_clock, et non +// system_clock : une mesure de duree ne doit pas dependre d'un ajustement +// d'horloge. Le cout du chronometre lui-meme (quelques dizaines de +// nanosecondes) est negligeable devant une tuile, qui se compte en centaines de +// microsecondes. +using Clock = std::chrono::steady_clock; + +uint64_t microsBetween(Clock::time_point a, Clock::time_point b) { + return static_cast( + std::chrono::duration_cast(b - a).count()); +} + +// PHASE 19. En deca de ce nombre de tuiles, le lot est maille en sequence sur +// le thread appelant, quel que soit meshThreads. Le REGIME ETABLI (une ou deux +// tuiles par image, la marche a pied) reste ainsi sur le chemin de code exact +// d'avant la Phase 19, threads compris. +// +// Ce seuil n'a d'effet que si l'on a demande des threads (--tile-threads=N) ; +// par defaut le maillage est entierement sequentiel. Voir le commentaire de +// Params::meshThreads pour la mesure qui a conduit a ce defaut. +constexpr std::size_t kParallelBatchThreshold = 3; + +} // namespace + +bool TerrainStreamer::wantsParallel(std::size_t count) const { + return params_.meshThreads > 1 && count >= kParallelBatchThreshold; +} + +void TerrainStreamer::meshBatch(const std::vector& nodes) { + batchMeshes_.clear(); + batchErrors_.clear(); + batchMeshes_.resize(nodes.size()); + batchErrors_.resize(nodes.size()); + if (nodes.empty()) { + return; + } + + // Le corps d'un travailleur. Il ne touche QUE batchMeshes_[k] et + // batchErrors_[k] pour k dans [begin, end) - des elements deja alloues, donc + // ni le vecteur ni sa capacite ne bougent pendant l'execution. Tout le reste + // de ce qu'il lit (heightmap_, quadtree_, params_) est const pour la duree + // de la session. + // + // Le chronometrage par tuile est fait ICI, mais il n'est PAS accumule dans + // geometryMicros_ depuis un thread : chaque tuile depose sa duree dans son + // propre element d'un vecteur local, somme apres la jonction. Un `+=` sur + // un membre depuis plusieurs threads serait exactement la course que cette + // fonction s'emploie a ne pas avoir - et une course sur un compteur de + // MESURE serait la pire de toutes, puisqu'elle fausserait le chiffre cense + // prouver que le changement est bon. + std::vector perTileMicros(nodes.size(), 0); + + const auto worker = [&](std::size_t begin, std::size_t end) { + for (std::size_t k = begin; k < end; ++k) { + const auto t0 = Clock::now(); + try { + batchMeshes_[k] = terrainNodeMeshData(heightmap_, quadtree_, nodes[k], + false, params_.cacheTileWork); + } catch (const std::exception& e) { + // Une exception ne doit JAMAIS traverser la frontiere d'un + // std::thread : elle appellerait std::terminate. Elle est donc + // capturee ici et rendue a l'appelant comme une donnee. + batchErrors_[k] = e.what(); + batchMeshes_[k] = MeshData{}; + } catch (...) { + batchErrors_[k] = "exception inconnue"; + batchMeshes_[k] = MeshData{}; + } + perTileMicros[k] = microsBetween(t0, Clock::now()); + } + }; + + const auto wall0 = Clock::now(); + + const uint32_t wanted = std::max(1u, params_.meshThreads); + if (nodes.size() < kParallelBatchThreshold || wanted == 1) { + worker(0, nodes.size()); + } else { + // Decoupage en tranches CONTIGUES et disjointes. Une tuile coute + // toujours la meme chose - 65 x 65 sommets, quel que soit son niveau - + // donc un decoupage statique equilibre naturellement la charge : pas + // besoin d'une file de travail, qui demanderait un verrou. + const std::size_t total = nodes.size(); + const std::size_t slices = + std::min(static_cast(wanted), total); + std::vector threads; + threads.reserve(slices - 1); + + const auto sliceBegin = [total, slices](std::size_t s) { + return (total * s) / slices; + }; + // Le thread APPELANT prend la premiere tranche : creer `slices` threads + // pour ensuite attendre sans rien faire gacherait un coeur entier. + for (std::size_t s = 1; s < slices; ++s) { + threads.emplace_back(worker, sliceBegin(s), sliceBegin(s + 1)); + } + worker(sliceBegin(0), sliceBegin(1)); + for (std::thread& t : threads) { + t.join(); + } + ++parallelBatches_; + } + + meshWallMicros_ += microsBetween(wall0, Clock::now()); + for (uint64_t micros : perTileMicros) { + geometryMicros_ += micros; + } +} + +MeshHandle TerrainStreamer::uploadNode(uint32_t nodeIndex, MeshData& data) { + try { + const auto t1 = Clock::now(); + // Les indices sont poses ICI et non dans terrainNodeMeshData, pour que + // les deux postes soient chronometres separement (voir buildProfile). + data.indices = sharedIndices(); + const auto t2 = Clock::now(); + // log = false : plusieurs tuiles par frame, une ligne chacune rendrait la + // sortie inexploitable (et couterait plus que l'upload). + const MeshHandle mesh = renderer_.addMesh(data, false); + const auto t3 = Clock::now(); + + ++builtNodes_; + indicesMicros_ += microsBetween(t1, t2); + uploadMicros_ += microsBetween(t2, t3); + return mesh; + } catch (const std::exception& e) { + // Une tuile qu'on ne sait pas construire ne doit pas arreter le jeu : + // elle sera simplement absente, et le message dit laquelle. Le cas + // realiste est un manque de memoire GPU, pas une donnee invalide. + logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) + + " non televersee (" + e.what() + ")."); + return kInvalidMesh; + } +} + +MeshHandle TerrainStreamer::buildNode(uint32_t nodeIndex) { + // Chemin SEQUENTIEL : maille une tuile puis la televerse, sans jamais garder + // plus d'un MeshData en vie. C'est le chemin du sommet epingle (construit + // avant la premiere frame) et, depuis que le defaut est meshThreads = 1, + // celui de la construction courante. + // + // Ne pas passer par meshBatch ici n'est pas une duplication gratuite : + // meshBatch dimensionne un vecteur de MeshData pour TOUT le lot, ce qui fait + // vivre jusqu'a 53 tuiles simultanement (~15 Mo) la ou ce chemin-ci n'en + // tient qu'une. Mesure : le pic memoire du processus montait de 5,6 Mo quand + // tout passait par le lot. Le chemin par defaut retrouve ainsi exactement le + // profil memoire d'avant la Phase 19. + const auto t0 = Clock::now(); + try { + scratchMesh_ = terrainNodeMeshData(heightmap_, quadtree_, nodeIndex, false, + params_.cacheTileWork); + } catch (const std::exception& e) { + geometryMicros_ += microsBetween(t0, Clock::now()); + logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) + + " non maillee (" + e.what() + ")."); + return kInvalidMesh; + } + const uint64_t micros = microsBetween(t0, Clock::now()); + geometryMicros_ += micros; + meshWallMicros_ += micros; + return uploadNode(nodeIndex, scratchMesh_); +} + +bool TerrainStreamer::evictOne() { + uint32_t victim = 0; + uint64_t oldest = std::numeric_limits::max(); + bool found = false; + + for (const auto& entry : resident_) { + // Jamais une tuile deja utilisee dans la frame courante : l'evincer + // reviendrait a la reconstruire immediatement (thrashing pur). + if (entry.second.lastUsedFrame >= frameCounter_) { + continue; + } + // PHASE 12 : le sommet epingle n'est jamais candidat. Il est la + // precisement pour les frames ou tout le reste manque. + if (entry.second.pinned) { + continue; + } + + if (entry.second.lastUsedFrame < oldest) { + oldest = entry.second.lastUsedFrame; + victim = entry.first; + found = true; + } + } + + if (!found) { + return false; + } + + const auto it = resident_.find(victim); + renderer_.removeMesh(it->second.mesh); + residentBytes_ -= it->second.bytes; + resident_.erase(it); + return true; +} + +int32_t TerrainStreamer::residentAncestor(uint32_t nodeIndex) const { + // Remontee STRICTE : on part du pere, jamais du noeud lui-meme. La chaine + // fait au plus rootLevel_ maillons (8 sur la zone de 25 km2 au pas de 1 m), + // donc cette boucle est bornee et courte. + int32_t current = quadtree_.parentIndex(nodeIndex); + while (current >= 0) { + if (resident_.find(static_cast(current)) != resident_.end()) { + return current; + } + current = quadtree_.parentIndex(static_cast(current)); + } + return -1; +} + +bool TerrainStreamer::coveredByFallback(uint32_t nodeIndex) const { + int32_t current = quadtree_.parentIndex(nodeIndex); + while (current >= 0) { + if (fallbackAncestors_.count(static_cast(current)) != 0) { + return true; + } + current = quadtree_.parentIndex(static_cast(current)); + } + return false; +} + +void TerrainStreamer::appendDrawItems(const glm::vec3& cameraPosition, + const Frustum& frustum, + std::vector& out) { + ++frameCounter_; + + quadtree_.select(cameraPosition, frustum, selection_); + selectedCount_ = static_cast(selection_.size()); + drawnCount_ = 0; + pendingCount_ = 0; + fallbackCount_ = 0; + uncoveredCount_ = 0; + + const std::size_t bytesPerNode = + static_cast(quadtree_.nodeCells() + 1) * + (quadtree_.nodeCells() + 1) * sizeof(Vertex) + + static_cast(quadtree_.trianglesPerNode()) * 3 * sizeof(uint32_t); + + const bool priming = (frameCounter_ <= params_.primingFrames); + uint32_t uploadsLeft = priming ? std::numeric_limits::max() + : params_.maxUploadsPerFrame; + + // --- 1a. Recensement : QUELLES tuiles construire cette frame ------------ + // selection_ est deja triee du plus proche au plus lointain : le lot retient + // donc les tuiles sous les pieds du joueur en premier quand le budget est + // serre. + // + // PHASE 19 : cette passe ne fait plus que RECENSER. Elle etait auparavant + // fusionnee avec le maillage et le televersement ; les separer est ce qui + // permet de mailler tout le lot d'un coup, donc en parallele. + uint32_t builtThisFrame = 0; + batchNodes_.clear(); + for (const TerrainQuadtree::SelectedNode& selected : selection_) { + auto it = resident_.find(selected.nodeIndex); + if (it != resident_.end()) { + // Marquee utilisee MEME si le repli finit par la remplacer cette + // frame (voir passe 3) : sans cela le LRU evincerait une tuile que + // la selection redemande, ce qui la ferait reconstruire aussitot. + it->second.lastUsedFrame = frameCounter_; + continue; + } + + ++pendingCount_; + + if (uploadsLeft == 0) { + continue; // servie a une frame suivante ; le repli la couvre en attendant + } + // Le budget est decompte a l'INSCRIPTION et non plus a la reussite. + // Difference observable seulement quand une tuile echoue a se construire + // (en pratique : plus de memoire GPU) : cette frame-la en sert une de + // moins, et la tuile part a la frame suivante. Le repli sur l'ancetre la + // couvre entre-temps, donc cela ne peut pas faire de trou. + if (uploadsLeft != std::numeric_limits::max()) { + --uploadsLeft; + } + batchNodes_.push_back(selected.nodeIndex); + } + + // --- 1b/1c. Maillage puis televersement --------------------------------- + // Deux chemins, et le choix se fait sur la TAILLE DU LOT : + // + // - lot parallelisable : tout le lot est maille d'abord (meshBatch, aucun + // appel Vulkan, plusieurs threads), puis televerse en sequence ; + // - sinon : chaque tuile est maillee et televersee a la suite, sans jamais + // garder plus d'un MeshData en vie. C'est le chemin par DEFAUT, et il + // est identique a celui d'avant la Phase 19, cout memoire compris. + // + // Dans les deux cas les addMesh ont lieu sur le thread de rendu, en + // sequence, et dans l'ordre de selection - donc du plus proche au plus + // lointain. + + // Suivi du plus gros lot : il doit compter les DEUX chemins, sinon le bilan + // afficherait « plus gros lot 0 tuiles » sur le chemin par defaut. + peakBatchSize_ = std::max(peakBatchSize_, + static_cast(batchNodes_.size())); + + const bool parallel = wantsParallel(batchNodes_.size()); + if (parallel) { + meshBatch(batchNodes_); + } + + for (std::size_t k = 0; k < batchNodes_.size(); ++k) { + const uint32_t nodeIndex = batchNodes_[k]; + if (parallel && !batchErrors_[k].empty()) { + logWarn("Streaming terrain : tuile " + std::to_string(nodeIndex) + + " non maillee (" + batchErrors_[k] + ")."); + continue; + } + // Faire de la place AVANT de televerser, sinon le pic de residence + // depasserait le plafond le temps d'un upload. (Le maillage, lui, + // n'alloue rien sur le GPU : c'est bien l'upload qui doit etre couvert.) + while (resident_.size() >= params_.maxResidentNodes) { + if (!evictOne()) { + break; // tout est utilise cette frame : on laisse deborder + } + } + + const MeshHandle mesh = parallel ? uploadNode(nodeIndex, batchMeshes_[k]) + : buildNode(nodeIndex); + if (mesh == kInvalidMesh) { + continue; + } + ++builtThisFrame; + + ResidentNode node; + node.mesh = mesh; + node.bytes = bytesPerNode; + node.lastUsedFrame = frameCounter_; + resident_.emplace(nodeIndex, node); + residentBytes_ += bytesPerNode; + --pendingCount_; // finalement servie dans la frame meme + } + + // Le lot ne doit pas garder ses maillages en vie jusqu'a la frame suivante : + // ce sont ~287 Ko par tuile. + if (parallel) { + batchMeshes_.clear(); + batchMeshes_.shrink_to_fit(); + } + + // --- 2. Choix des ancetres de repli (PHASE 12) -------------------------- + // Rien a faire dans le cas courant : en regime etabli toute la selection est + // residente, l'ensemble reste vide et les passes suivantes ne coutent rien. + fallbackAncestors_.clear(); + + if (pendingCount_ > 0) { + for (const TerrainQuadtree::SelectedNode& selected : selection_) { + if (resident_.find(selected.nodeIndex) != resident_.end()) { + continue; + } + if (!params_.ancestorFallback) { + ++uncoveredCount_; // comportement Phase 10 : la tuile est un trou + continue; + } + const int32_t ancestor = residentAncestor(selected.nodeIndex); + if (ancestor >= 0) { + fallbackAncestors_.insert(static_cast(ancestor)); + } else { + // Aucun ancetre resident : la surface n'est reellement couverte + // par rien. C'est le seul cas qui produit encore un trou. + ++uncoveredCount_; + } + } + } + + // --- 3. Emission --------------------------------------------------------- + const bool hasFallback = !fallbackAncestors_.empty(); + + auto emit = [&](const TerrainQuadtree::SelectedNode& node, MeshHandle mesh) { + DrawItem item; + item.mesh = mesh; + // Les sommets d'une tuile sont deja en coordonnees monde, comme ceux du + // terrain d'un seul bloc : matrice identite. + item.model = glm::mat4(1.0f); + item.material = Material::Terrain; + item.params = glm::vec4(node.morphStart, node.morphEnd, 0.0f, 0.0f); + out.push_back(item); + ++drawnCount_; + }; + + // 3a. Les ancetres de repli eux-memes, une seule fois chacun, et seulement + // les plus HAUTS : si un ancetre de repli est lui-meme sous un autre + // ancetre de repli, le second couvre deja le premier. + fallbackCount_ = 0; + if (hasFallback) { + for (uint32_t ancestor : fallbackAncestors_) { + if (coveredByFallback(ancestor)) { + continue; + } + const auto it = resident_.find(ancestor); + if (it == resident_.end()) { + continue; // ne peut pas arriver : il a ete retenu parce qu'il l'etait + } + it->second.lastUsedFrame = frameCounter_; + emit(quadtree_.describeNode(ancestor, cameraPosition), it->second.mesh); + ++fallbackCount_; + } + } + + // 3b. Les tuiles selectionnees residentes, SAUF celles qu'un ancetre de + // repli recouvre deja - deux surfaces superposees se disputeraient le + // z-buffer. + for (const TerrainQuadtree::SelectedNode& selected : selection_) { + const auto it = resident_.find(selected.nodeIndex); + if (it == resident_.end()) { + continue; // pas encore construite : couverte par un repli, ou trou + } + if (hasFallback && coveredByFallback(selected.nodeIndex)) { + continue; + } + emit(selected, it->second.mesh); + } + + peakSelected_ = std::max(peakSelected_, selectedCount_); + peakResident_ = std::max(peakResident_, static_cast(resident_.size())); + peakResidentBytes_ = std::max(peakResidentBytes_, residentBytes_); + peakUncovered_ = std::max(peakUncovered_, uncoveredCount_); + peakFallback_ = std::max(peakFallback_, fallbackCount_); + peakBuiltPerFrame_ = std::max(peakBuiltPerFrame_, builtThisFrame); + ++frameCount_; + if (uncoveredCount_ > 0) { ++framesWithHoles_; } + if (fallbackCount_ > 0) { ++framesWithFallback_; } +} + +std::string TerrainStreamer::statsLine() const { + std::string text = + "Terrain LOD : " + std::to_string(drawnCount_) + " tuiles dessinees sur " + + std::to_string(selectedCount_) + " selectionnees (" + + std::to_string(drawnTriangles()) + " triangles), " + + std::to_string(resident_.size()) + " residentes, " + + std::to_string(residentBytes_ / (1024 * 1024)) + " Mo de geometrie GPU."; + if (pendingCount_ > 0 || fallbackCount_ > 0 || uncoveredCount_ > 0) { + text += " En attente " + std::to_string(pendingCount_) + ", repli sur " + + std::to_string(fallbackCount_) + " ancetre(s), " + + std::to_string(uncoveredCount_) + " non couverte(s)."; + } + return text; +} + +std::string TerrainStreamer::holeReport() const { + if (frameCount_ == 0) { + return "Trous de streaming : aucune frame mesuree."; + } + std::string text = + "Trous de streaming : " + std::to_string(framesWithHoles_) + " frame(s) sur " + + std::to_string(frameCount_) + " avec au moins une tuile NON COUVERTE (pic " + + std::to_string(peakUncovered_) + " tuiles) ; repli sur ancetre utilise dans " + + std::to_string(framesWithFallback_) + " frame(s) (pic " + + std::to_string(peakFallback_) + " ancetres)."; + if (!params_.ancestorFallback) { + text += " [repli DESACTIVE : --no-tile-fallback]"; + } + return text; +} + +std::string TerrainStreamer::buildProfile() const { + if (builtNodes_ == 0) { + return "Construction de tuiles : aucune tuile construite."; + } + const auto per = [this](uint64_t total) { + // Moyenne en microsecondes par tuile, arrondie au dixieme. + const double value = static_cast(total) / static_cast(builtNodes_); + return std::to_string(static_cast(value * 10.0 + 0.5) / 10.0); + }; + const uint64_t total = geometryMicros_ + indicesMicros_ + uploadMicros_; + std::string text = + "Construction de tuiles : " + std::to_string(builtNodes_) + " tuiles, " + + std::to_string(total / 1000) + " ms au total - geometrie " + + std::to_string(geometryMicros_ / 1000) + " ms (" + per(geometryMicros_) + + " us/tuile), indices " + std::to_string(indicesMicros_ / 1000) + " ms (" + + per(indicesMicros_) + " us/tuile), televersement " + + std::to_string(uploadMicros_ / 1000) + " ms (" + per(uploadMicros_) + + " us/tuile)."; + + // PHASE 19. Le chiffre precedent est le TRAVAIL par tuile ; il ne doit PAS + // baisser avec la parallelisation, puisque c'est la meme fonction qui fait + // le meme calcul. Ce qui doit baisser, c'est le temps que le thread de rendu + // passe BLOQUE dessus - donc le temps de mur. Publier les deux est la seule + // facon honnete de presenter un gain de parallelisme : un seul des deux + // chiffres laisserait croire soit qu'il n'y a pas de gain, soit que le + // travail a diminue. + text += " Maillage parallele : " + std::to_string(meshWallMicros_ / 1000) + + " ms de temps de mur pour " + std::to_string(geometryMicros_ / 1000) + + " ms de travail (facteur " + + std::to_string(meshWallMicros_ > 0 + ? static_cast(static_cast(geometryMicros_) * 100.0 / + static_cast(meshWallMicros_) + 0.5) / 100.0 + : 0.0) + + "), " + std::to_string(parallelBatches_) + " lot(s) sur threads, plus gros lot " + + std::to_string(peakBatchSize_) + " tuiles, " + + std::to_string(std::max(1u, params_.meshThreads)) + " thread(s) demandes."; + return text; +} + +} // namespace vercora diff --git a/src/renderer/TerrainStreamer.hpp b/src/renderer/TerrainStreamer.hpp new file mode 100644 index 0000000..9035a09 --- /dev/null +++ b/src/renderer/TerrainStreamer.hpp @@ -0,0 +1,356 @@ +#pragma once + +#include "core/Frustum.hpp" +#include "renderer/DrawItem.hpp" +#include "renderer/MeshData.hpp" +#include "world/TerrainQuadtree.hpp" + +#include + +#include +#include +#include +#include +#include + +namespace vercora { + +class Heightmap; +class Renderer; + +// Fait le lien entre le quadtree (qui decide QUOI dessiner) et le Renderer (qui +// possede les geometries GPU) : cache de tuiles residentes, construction a la +// demande sous budget, eviction LRU, production de la liste de DrawItem. +// +// PHASE 10. Le point important est la GESTION DE LA RESIDENCE. Le quadtree +// complet de la zone de 25 km2 au pas de 1 m compte ~8300 noeuds ; les mailler +// tous couterait plus cher que le maillage d'un seul bloc de la Phase 9. Seules +// les tuiles reellement selectionnees sont donc construites, et elles sont +// gardees tant que la place le permet. +// +// Trois garde-fous, dans cet ordre d'importance : +// +// 1. BUDGET PAR FRAME (maxUploadsPerFrame). PHASE 12 : ce 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 est passe de 4 a 64 pour cette raison. Les tuiles au-dela du +// budget sont servies dans les frames suivantes, les plus PROCHES d'abord. +// +// 2. PLAFOND DE RESIDENCE (maxResidentNodes). Chaque tuile consomme deux +// allocations Vulkan (vertex + index), et vkAllocateMemory est plafonne par +// maxMemoryAllocationCount (typiquement 4096). Le plafond garde une marge +// confortable en plus de borner la RAM. +// +// 3. EVICTION LRU, jamais sur une tuile utilisee dans la frame courante, ni +// sur une tuile du sommet epingle (point 4). +// +// 4. REPLI SUR L'ANCETRE (PHASE 12). Une tuile selectionnee mais pas encore +// construite n'est plus laissee en trou : on remonte sa chaine de peres +// 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 tout le sous-arbre, il ne s'y superpose pas : les autres +// tuiles selectionnees situees sous l'ancetre retenu sont retirees de la +// frame, meme si elles etaient residentes. Sans cela deux surfaces de +// niveaux differents se recouvriraient et se disputeraient le z-buffer, ce +// qui remplacerait 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. +// +// Pourquoi un ancetre est-il resident ? En partie parce qu'on l'a dessine +// il y a peu (en s'approchant d'une zone on la voit d'abord en L5, puis L4, +// puis L3...), mais cette raison-la ne suffit PAS, et c'est une mesure qui +// l'a montre : les tuiles restees non couvertes lors d'un survol a 900 m/s +// etaient de niveau 3, 4 et 5, et leurs ancetres de niveau 6 et 7 n'avaient +// JAMAIS ete dessines - 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. +// +// D'ou le SOMMET EPINGLE (params_.pinnedTopLevels) : les tuiles des +// quelques niveaux les plus grossiers sont construites au demarrage et ne +// sont jamais evincees. Elles sont peu nombreuses (1 + 4 + 16 = 21 tuiles +// pour trois niveaux, ~8 Mo) et elles rendent le repli STRUCTURELLEMENT +// toujours disponible : tout noeud selectionne est soit epingle lui-meme, +// soit descendant d'un noeud epingle. uncoveredNodes() ne peut alors plus +// valoir autre chose que zero - et il reste mesure pour le prouver. +class TerrainStreamer { +public: + struct Params { + TerrainQuadtree::Params quadtree{}; + + // Tuiles construites au maximum par frame. + // + // PHASE 10 : 4, parce que chaque tuile coutait deux vkQueueWaitIdle. + // PHASE 12 : 64, une fois ce verrou leve. Ce qui reste est du travail + // CPU (maillage + memcpy vers le staging), qui ne vide plus la queue + // graphique. Le budget existe encore pour deux raisons : lisser les + // a-coups d'une teleportation ou d'un demi-tour brutal, et borner le + // staging vivant simultanement (64 tuiles ~ 25 Mo). + uint32_t maxUploadsPerFrame = 64; + + // Plafond de tuiles gardees sur le GPU. 512 tuiles = 1024 allocations + // Vulkan et ~200 Mo au format de sommet de la Phase 10. + uint32_t maxResidentNodes = 512; + + // Frames pendant lesquelles le budget par frame est LEVE, au demarrage : + // le temps de construire la vue initiale d'un coup plutot que de montrer + // un terrain qui se remplit par morceaux pendant deux secondes. + uint32_t primingFrames = 1; + + // PHASE 12. Nombre de niveaux les plus grossiers dont TOUTES les tuiles + // sont construites au demarrage et jamais evincees, racine comprise. + // 3 -> racine + deux niveaux en dessous, soit au plus 1 + 4 + 16 = 21 + // tuiles (~8 Mo). C'est ce qui garantit qu'un ancetre resident existe + // toujours, donc qu'un trou est impossible. 0 desactive l'epinglage. + uint32_t pinnedTopLevels = 3; + + // PHASE 12. Repli sur l'ancetre resident quand une tuile manque. + // Desactivable pour mesurer l'avant/apres sur le MEME binaire, comme + // --no-lod le fait pour le quadtree entier (option --no-tile-fallback). + bool ancestorFallback = true; + + // PHASE 18. false remet la construction d'une tuile dans l'etat + // d'avant la phase : topologie reconstruite a chaque tuile et cible de + // morphing recalculee sommet par sommet. TEMOIN de mesure - le + // maillage produit est identique, seul le travail depense change + // (option de jeu --no-tile-cache). + bool cacheTileWork = true; + + // PHASE 19. Degre de parallelisme du MAILLAGE CPU des tuiles, thread + // appelant compris. 1 = tout sequentiel, c'est-a-dire exactement le + // comportement d'avant la Phase 19 (temoin --tile-threads=1). + // + // Ce qui est parallelise, et ce qui ne l'est PAS : + // + // - terrainNodeMeshData est PURE : elle ne lit que la heightmap et le + // quadtree, tous deux const et immuables pendant toute la session, + // et elle ecrit dans un MeshData qui lui appartient. Deux appels sur + // deux tuiles differentes ne partagent STRICTEMENT rien. C'est elle, + // et elle seule, qui part sur les threads ; + // + // - Renderer::addMesh reste sur le THREAD DE RENDU, appele en sequence + // et dans le meme ordre qu'avant. Aucun appel Vulkan ne change de + // thread dans cette phase. Voir NOTES-PHASE19.md pour le detail de + // ce qui empecherait addMesh d'etre appele depuis plusieurs threads, + // et pourquoi la Phase 19 n'y a pas touche. + // + // POURQUOI LE DEFAUT EST 1, ET NON 4 - c'est le resultat le plus + // important de la Phase 19, et il contredit la piste ouverte par la + // Phase 18 : + // + // La Phase 18 a mesure que la geometrie faisait 83 % du cout d'une + // tuile et a designe la parallelisation comme le gain suivant. Ce + // chiffre a ete releve en DEBUG, la seule configuration ou tournent + // les couches de validation et donc toutes les mesures du projet. En + // RELEASE, le meme releve donne un tout autre partage : + // + // Debug : geometrie 1344 us/tuile, indices 16, televersement 250 + // Release : geometrie 140 us/tuile, indices 15, televersement 262 + // + // La geometrie est 9,6 fois moins chere une fois optimisee ; ce n'est + // plus elle le poste dominant d'une tuile, c'est le TELEVERSEMENT + // (63 %). Paralleliser la geometrie revenait donc a decouper le petit + // morceau. + // + // Mesure directe, survol a 900 m/s, meme binaire Release, deux + // passages chacun (option --tile-threads) : + // 1 thread : 819 / 811 ms de temps de mur, 32206 / 32327 images + // 4 threads : 1227 / 870 ms de temps de mur, 29776 / 32104 images + // La creation des threads (environ 3900 sur le survol) coute plus que + // le travail qu'elle repartit, parce qu'une tuile Release ne dure que + // 140 us. Le parallelisme est neutre au mieux, perdant au pire. + // + // Le chemin parallele est CONSERVE, teste et documente, parce qu'il + // reste un gain net la ou une tuile est chere : en Debug il donne un + // facteur 2,4 a 2,6 et +14 % d'images, ce qui accelere reellement les + // campagnes de mesure et de validation du projet. Il redeviendra + // interessant en Release le jour ou une tuile coutera plus cher (format + // de sommet plus lourd, pas LiDAR plus fin). D'ici la, le defaut est + // celui que la mesure designe. + // + // Une valeur superieure a 1 n'ouvre AUCUN nouveau chemin Vulkan : voir + // meshBatch. Le risque de ce reglage est donc un risque de performance, + // pas un risque de correction. + uint32_t meshThreads = 1; + }; + + // Ni la Heightmap ni le Renderer ne sont possedes ; les deux doivent vivre + // plus longtemps que le streamer. + TerrainStreamer(const Heightmap& heightmap, Renderer& renderer, + const Params& params = {}); + ~TerrainStreamer(); + + TerrainStreamer(const TerrainStreamer&) = delete; + TerrainStreamer& operator=(const TerrainStreamer&) = delete; + + // Selectionne, construit ce qui manque (sous budget) et AJOUTE les DrawItem + // des tuiles dessinables a `out`. `out` n'est pas vide au prealable : le + // terrain n'est qu'une partie de la scene. + void appendDrawItems(const glm::vec3& cameraPosition, const Frustum& frustum, + std::vector& out); + + const TerrainQuadtree& quadtree() const { return quadtree_; } + + // --- Statistiques de la derniere frame, pour les logs et la mesure ------- + uint32_t selectedNodes() const { return selectedCount_; } + uint32_t drawnNodes() const { return drawnCount_; } + // Tuiles selectionnees qui n'etaient pas encore construites a cette frame. + uint32_t pendingNodes() const { return pendingCount_; } + // Tuiles d'ancetre dessinees a la place d'un sous-arbre incomplet (PHASE 12). + uint32_t fallbackNodes() const { return fallbackCount_; } + // LE chiffre qui compte : tuiles selectionnees que RIEN ne couvre, ni + // elles-memes ni un ancetre. C'est la mesure objective d'un trou visuel. + uint32_t uncoveredNodes() const { return uncoveredCount_; } + uint32_t residentNodes() const { return static_cast(resident_.size()); } + uint32_t drawnTriangles() const { + return drawnCount_ * quadtree_.trianglesPerNode(); + } + // Octets de geometrie residente sur le GPU (sommets + indices). + std::size_t residentBytes() const { return residentBytes_; } + + // Ligne de statistiques lisible, journalisee periodiquement. + std::string statsLine() const; + + // PHASE 18. Bilan du COUT de construction d'une tuile, journalise a la + // destruction. Separe volontairement en trois postes, parce que la Phase 12 + // a conclu que le maillage CPU etait devenu le goulot sans jamais le mesurer + // poste par poste : + // + // - GEOMETRIE : terrainNodeMeshData, c'est-a-dire l'echantillonnage de la + // heightmap et le calcul des normales et des cibles de + // morphing ; + // - INDICES : la topologie de la tuile, identique pour TOUTES les + // tuiles de tous les niveaux ; + // - TELEVERSEMENT : Renderer::addMesh, donc le chemin GPU deja traite en + // Phase 12. + // + // Sans cette separation, "la construction CPU coute X ms" ne dit pas quoi + // optimiser - et la reponse s'est revelee contre-intuitive (voir + // NOTES-PHASE18.md). + std::string buildProfile() const; + + // PHASE 12. Bilan des trous sur toute la session, journalise a la + // destruction : c'est le critere de reussite du chantier. + std::string holeReport() const; + +private: + struct ResidentNode { + MeshHandle mesh = kInvalidMesh; + uint64_t lastUsedFrame = 0; + std::size_t bytes = 0; + // PHASE 12 : tuile du sommet epingle, jamais candidate a l'eviction. + bool pinned = false; + }; + + // PHASE 19. Maille les tuiles `nodes` dans `batchMeshes_`, en parallele + // au-dela de deux tuiles. AUCUN appel Vulkan : c'est toute la raison pour + // laquelle cette etape peut quitter le thread de rendu sans rien changer a + // la synchronisation du moteur. + // + // Chaque thread ecrit dans des ELEMENTS DISJOINTS de vecteurs deja + // dimensionnes : il n'y a ni verrou, ni file, ni compteur partage - donc + // aucun etat sur lequel une course serait possible. Une tuile qui echoue + // depose son message dans `batchErrors_[k]`, jamais dans un journal (les + // fonctions de journalisation ne sont pas prevues pour plusieurs threads) : + // c'est l'appelant qui journalise, apres la jonction. + void meshBatch(const std::vector& nodes); + + // true si un lot de `count` tuiles vaut la peine de partir sur des threads. + bool wantsParallel(std::size_t count) const; + + // Pose la topologie commune puis televerse. SEQUENTIEL, thread de rendu. + // Renvoie kInvalidMesh en cas d'echec (la tuile est alors simplement + // sautee : un trou d'une frame vaut mieux qu'un arret du jeu). + MeshHandle uploadNode(uint32_t nodeIndex, MeshData& data); + + // Maille ET televerse une tuile, en sequence, sans jamais garder plus d'un + // MeshData en vie. Chemin par DEFAUT depuis que meshThreads vaut 1, et + // chemin du sommet epingle. + MeshHandle buildNode(uint32_t nodeIndex); + + // PHASE 18 : la topologie d'une tuile, commune a toutes. + const std::vector& sharedIndices() const; + + // Libere la tuile la moins recemment utilisee qui n'a pas servi dans la + // frame courante. Renvoie false s'il n'y a rien a liberer. + bool evictOne(); + + // PHASE 12. Construit et epingle les tuiles des params_.pinnedTopLevels + // niveaux les plus grossiers. Appele une fois, a la construction. + void pinTopLevels(); + + // PHASE 12. Premier ancetre STRICT de `nodeIndex` qui soit resident, ou -1. + int32_t residentAncestor(uint32_t nodeIndex) const; + + // PHASE 12. true si un ancetre STRICT de `nodeIndex` figure parmi les + // ancetres de repli retenus cette frame (donc si le noeud est deja couvert). + bool coveredByFallback(uint32_t nodeIndex) const; + + const Heightmap& heightmap_; + Renderer& renderer_; + Params params_; + + TerrainQuadtree quadtree_; + + // Tuiles residentes, indexees par indice de noeud du quadtree. + std::unordered_map resident_; + + // Reutilisee d'une frame a l'autre pour ne pas reallouer 60 fois par seconde. + std::vector selection_; + + // PHASE 12. Ancetres retenus pour le repli a cette frame. Membre, et non + // variable locale, uniquement pour garder sa capacite d'une frame a l'autre. + std::unordered_set fallbackAncestors_; + + uint64_t frameCounter_ = 0; + std::size_t residentBytes_ = 0; + + uint32_t selectedCount_ = 0; + uint32_t drawnCount_ = 0; + uint32_t pendingCount_ = 0; + uint32_t fallbackCount_ = 0; + uint32_t uncoveredCount_ = 0; + uint32_t peakSelected_ = 0; + uint32_t peakResident_ = 0; + std::size_t peakResidentBytes_ = 0; + + // Bilan de session (PHASE 12). + uint64_t frameCount_ = 0; + uint64_t framesWithHoles_ = 0; // frames comptant au moins un noeud non couvert + uint64_t framesWithFallback_ = 0; // frames ayant utilise au moins un repli + uint32_t peakUncovered_ = 0; + uint32_t peakFallback_ = 0; + uint32_t peakBuiltPerFrame_ = 0; + + // PHASE 18 : la topologie commune, construite a la premiere tuile. + // `mutable` parce que sharedIndices() est const : c'est un cache, il ne + // change rien a l'etat observable du streamer. + mutable std::vector indexTemplate_; + + // PHASE 18 : profilage de la construction, en microsecondes cumulees. + uint64_t builtNodes_ = 0; + uint64_t geometryMicros_ = 0; + uint64_t indicesMicros_ = 0; + uint64_t uploadMicros_ = 0; + uint32_t pinnedCount_ = 0; + + // PHASE 19 : lot de tuiles a mailler cette frame. Membres, et non variables + // locales, uniquement pour garder leur capacite d'une frame a l'autre - + // meme raison que selection_ et fallbackAncestors_. + std::vector batchNodes_; + std::vector batchMeshes_; // rempli seulement sur le chemin parallele + std::vector batchErrors_; + + // Maillage de travail du chemin sequentiel. Membre pour garder sa capacite + // d'une tuile a l'autre ; il n'en vit jamais qu'un. + MeshData scratchMesh_; + + // PHASE 19 : temps de MUR de l'etape de maillage, a comparer a + // geometryMicros_ qui reste, lui, la somme du travail par tuile. Les deux + // sont necessaires pour une mesure honnete : le travail par tuile ne doit + // PAS changer (la fonction est la meme), seul le temps ecoule doit baisser. + uint64_t meshWallMicros_ = 0; + uint64_t parallelBatches_ = 0; // lots reellement partis sur des threads + uint32_t peakBatchSize_ = 0; +}; + +} // namespace vercora diff --git a/src/renderer/Texture.cpp b/src/renderer/Texture.cpp new file mode 100644 index 0000000..86a210f --- /dev/null +++ b/src/renderer/Texture.cpp @@ -0,0 +1,303 @@ +#include "renderer/Texture.hpp" + +#include "core/Logger.hpp" +#include "renderer/VulkanBuffer.hpp" +#include "renderer/VulkanContext.hpp" + +#include +#include +#include +#include +#include + +namespace vercora { +namespace { + +VkFormat toVkFormat(TextureFormat format) { + switch (format) { + case TextureFormat::BC1: + // ..._UNORM_BLOCK et non _SRGB_BLOCK : la swapchain de ce moteur est + // en UNORM et l'eclairage est calcule tel quel depuis la Phase 2. + // Prendre une variante sRGB ici ferait subir a la seule orthophoto + // une conversion que rien d'autre dans le pipeline n'applique, donc + // la rendrait plus claire que les couleurs de sommet voisines. + return VK_FORMAT_BC1_RGB_UNORM_BLOCK; + case TextureFormat::RGBA8: + break; + } + return VK_FORMAT_R8G8B8A8_UNORM; +} + +// Barriere de transition de layout couvrant TOUTE la chaine de mipmaps. Les +// niveaux sont copies d'un bloc, donc il n'y a jamais besoin de transitionner un +// niveau isolement (ce que ferait une generation de mipmaps par blit). +void transitionLayout(VkCommandBuffer commandBuffer, VkImage image, uint32_t mipLevels, + VkImageLayout oldLayout, VkImageLayout newLayout, + VkAccessFlags srcAccess, VkAccessFlags dstAccess, + VkPipelineStageFlags srcStage, VkPipelineStageFlags dstStage) { + VkImageMemoryBarrier barrier{}; + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.oldLayout = oldLayout; + barrier.newLayout = newLayout; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = image; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = mipLevels; + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = 1; + barrier.srcAccessMask = srcAccess; + barrier.dstAccessMask = dstAccess; + + vkCmdPipelineBarrier(commandBuffer, srcStage, dstStage, 0, + 0, nullptr, 0, nullptr, 1, &barrier); +} + +} // namespace + +TextureData Texture::whitePixelData() { + TextureData data; + data.width = 1; + data.height = 1; + data.format = TextureFormat::RGBA8; + data.pixels = { 255, 255, 255, 255 }; + data.mips.push_back({ 1, 1, 0, 4 }); + data.label = "blanc 1x1"; + // Emprise volontairement degeneree : cette texture n'est PAS georeferencee, + // et personne ne doit croire qu'elle recouvre quoi que ce soit. + data.epsg = 0; + return data; +} + +Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue, + const TextureData& data, bool repeat) + : context_(context) { + if (data.pixels.empty() || data.mips.empty()) { + throw std::runtime_error("Texture : donnees vides."); + } + + const VkFormat format = toVkFormat(data.format); + + // Verification AVANT toute allocation : sur un GPU sans textureCompressionBC, + // creer l'image echouerait de toute facon, mais avec un message du driver + // au lieu d'une explication. Le repli existe et il est nomme. + VkFormatProperties properties{}; + vkGetPhysicalDeviceFormatProperties(context_.physicalDevice(), format, &properties); + if (!(properties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { + throw std::runtime_error( + "Texture : ce GPU ne sait pas echantillonner le format demande" + + std::string(data.format == TextureFormat::BC1 + ? " (BC1). Regenerer la texture avec " + "tools/make_ortho_texture.py --format rgba." + : ".")); + } + + const uint32_t mipLevels = static_cast(data.mips.size()); + createImage(data.width, data.height, mipLevels, format); + uploadAndTransition(commandPool, queue, data); + createView(format, mipLevels); + createSampler(mipLevels, repeat); +} + +Texture::~Texture() { + VkDevice device = context_.device(); + if (sampler_ != VK_NULL_HANDLE) { + vkDestroySampler(device, sampler_, nullptr); + } + if (view_ != VK_NULL_HANDLE) { + vkDestroyImageView(device, view_, nullptr); + } + if (image_ != VK_NULL_HANDLE) { + vkDestroyImage(device, image_, nullptr); + } + if (memory_ != VK_NULL_HANDLE) { + vkFreeMemory(device, memory_, nullptr); + } +} + +void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels, + VkFormat format) { + VkImageCreateInfo imageInfo{}; + imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + imageInfo.imageType = VK_IMAGE_TYPE_2D; + imageInfo.extent = { width, height, 1 }; + imageInfo.mipLevels = mipLevels; + imageInfo.arrayLayers = 1; + imageInfo.format = format; + imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL; + imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; + imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + imageInfo.samples = VK_SAMPLE_COUNT_1_BIT; + + VkDevice device = context_.device(); + if (vkCreateImage(device, &imageInfo, nullptr, &image_) != VK_SUCCESS) { + throw std::runtime_error("Texture : echec de la creation de l'image."); + } + + VkMemoryRequirements requirements{}; + vkGetImageMemoryRequirements(device, image_, &requirements); + + VkMemoryAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocInfo.allocationSize = requirements.size; + allocInfo.memoryTypeIndex = context_.findMemoryType( + requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + + if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) { + throw std::runtime_error("Texture : echec de l'allocation memoire de l'image."); + } + vkBindImageMemory(device, image_, memory_, 0); + deviceSize_ = requirements.size; +} + +void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue, + const TextureData& data) { + VkDevice device = context_.device(); + const VkDeviceSize total = static_cast(data.pixels.size()); + + // Un seul buffer de staging pour toute la chaine : les niveaux sont deja + // contigus dans le fichier, donc les offsets de copie sont ceux du .vcto. + VulkanBuffer staging(context_, total, + VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + staging.writeToBuffer(data.pixels.data(), total); + staging.unmap(); + + VkCommandBufferAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandPool = commandPool; + allocInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer = VK_NULL_HANDLE; + vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer); + + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + vkBeginCommandBuffer(commandBuffer, &beginInfo); + + const uint32_t mipLevels = static_cast(data.mips.size()); + + transitionLayout(commandBuffer, image_, mipLevels, + VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 0, VK_ACCESS_TRANSFER_WRITE_BIT, + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); + + std::vector regions; + regions.reserve(mipLevels); + for (uint32_t level = 0; level < mipLevels; ++level) { + const TextureMipLevel& mip = data.mips[level]; + VkBufferImageCopy region{}; + region.bufferOffset = mip.offset; + // 0 = "serre sur l'extent de l'image". Indispensable pour un format + // compresse, ou bufferRowLength se compterait en TEXELS et non en blocs : + // le calculer a la main serait une occasion d'erreur gratuite. + region.bufferRowLength = 0; + region.bufferImageHeight = 0; + region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + region.imageSubresource.mipLevel = level; + region.imageSubresource.baseArrayLayer = 0; + region.imageSubresource.layerCount = 1; + region.imageOffset = { 0, 0, 0 }; + region.imageExtent = { mip.width, mip.height, 1 }; + regions.push_back(region); + } + + vkCmdCopyBufferToImage(commandBuffer, staging.handle(), image_, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + static_cast(regions.size()), regions.data()); + + transitionLayout(commandBuffer, image_, mipLevels, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); + + vkEndCommandBuffer(commandBuffer); + + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE); + // Transfert unique a l'initialisation : attendre est simple et sans + // consequence sur la boucle de rendu, qui n'a pas encore demarre. + vkQueueWaitIdle(queue); + + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); +} + +void Texture::createView(VkFormat format, uint32_t mipLevels) { + VkImageViewCreateInfo viewInfo{}; + viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + viewInfo.image = image_; + viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; + viewInfo.format = format; + viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + viewInfo.subresourceRange.baseMipLevel = 0; + viewInfo.subresourceRange.levelCount = mipLevels; + viewInfo.subresourceRange.baseArrayLayer = 0; + viewInfo.subresourceRange.layerCount = 1; + + if (vkCreateImageView(context_.device(), &viewInfo, nullptr, &view_) != VK_SUCCESS) { + throw std::runtime_error("Texture : echec de la creation de la vue d'image."); + } +} + +void Texture::createSampler(uint32_t mipLevels, bool repeat) { + VkPhysicalDeviceProperties deviceProperties{}; + vkGetPhysicalDeviceProperties(context_.physicalDevice(), &deviceProperties); + + VkPhysicalDeviceFeatures features{}; + vkGetPhysicalDeviceFeatures(context_.physicalDevice(), &features); + + VkSamplerCreateInfo samplerInfo{}; + samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + samplerInfo.magFilter = VK_FILTER_LINEAR; + samplerInfo.minFilter = VK_FILTER_LINEAR; + // CLAMP_TO_EDGE et non REPEAT : la texture recouvre EXACTEMENT l'emprise du + // terrain. En repetition, un sommet legerement hors bornes (l'ecretage de la + // heightmap en produit) irait chercher la couleur du bord oppose, soit + // plusieurs kilometres plus loin. + samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + if (repeat) { + // PHASE 27 : texture periodique (bruit de detail), echantillonnee bien + // au-dela de [0, 1] - la repetition est ici le comportement voulu. + samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT; + } + + // L'anisotropie n'est demandee que si la feature a ete ACTIVEE sur le device + // logique (voir VulkanContext::createLogicalDevice). La demander sans + // l'avoir activee est une erreur de validation immediate. + if (context_.anisotropyEnabled()) { + samplerInfo.anisotropyEnable = VK_TRUE; + samplerInfo.maxAnisotropy = deviceProperties.limits.maxSamplerAnisotropy; + } else { + samplerInfo.anisotropyEnable = VK_FALSE; + samplerInfo.maxAnisotropy = 1.0f; + } + + samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK; + samplerInfo.unnormalizedCoordinates = VK_FALSE; + samplerInfo.compareEnable = VK_FALSE; + samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS; + samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; + samplerInfo.mipLodBias = 0.0f; + samplerInfo.minLod = 0.0f; + samplerInfo.maxLod = static_cast(mipLevels); + + if (vkCreateSampler(context_.device(), &samplerInfo, nullptr, &sampler_) != VK_SUCCESS) { + throw std::runtime_error("Texture : echec de la creation de l'echantillonneur."); + } +} + +} // namespace vercora diff --git a/src/renderer/Texture.hpp b/src/renderer/Texture.hpp new file mode 100644 index 0000000..4bc55a3 --- /dev/null +++ b/src/renderer/Texture.hpp @@ -0,0 +1,83 @@ +#pragma once + +// TextureData est inclus (et non declare en avant) parce que whitePixelData() +// le renvoie par valeur. L'en-tete reste sans cout : assets/TextureFile.hpp ne +// depend pas de Vulkan. +#include "assets/TextureFile.hpp" + +#include + +#include + +namespace vercora { + +class VulkanContext; + +// Une texture 2D sur le GPU : image, memoire, vue et echantillonneur, avec sa +// chaine de mipmaps DEJA CALCULEE cote CPU. +// +// PHASE 11. Premiere texture du moteur : jusqu'ici tout etait colore par +// sommet ou calcule dans le fragment shader. +// +// POURQUOI LES MIPMAPS NE SONT PAS GENEREES ICI. Le chemin classique +// (vkCmdBlitImage en cascade depuis le niveau 0) ne fonctionne QUE sur un format +// non compresse : on ne sait pas filtrer des blocs BC1. Comme la texture +// d'orthophoto est compressee - c'est ce qui la fait tenir en 45 Mo au lieu de +// 357 - les niveaux arrivent tout faits dans le .vcto et cette classe se contente +// d'un vkCmdCopyBufferToImage par niveau. Le code est plus court que la version +// qui blitte, pas plus long. +// +// L'ANISOTROPIE compte particulierement ici : le terrain est un plan regarde en +// rasant depuis la hauteur d'oeil, exactement le cas ou un filtrage trilineaire +// seul rend une bouillie au-dela de quelques dizaines de metres. Elle est +// demandee au maximum permis par le GPU, et silencieusement abandonnee si la +// feature n'est pas disponible (le rendu reste correct, seulement plus flou de +// loin). +class Texture { +public: + // Envoie `data` sur le GPU. Lance std::runtime_error si le format n'est pas + // supporte par le GPU (BC1 sur un materiel sans textureCompressionBC) ou si + // une ressource Vulkan ne peut pas etre creee. + // repeat : adressage en REPETITION (PHASE 27, texture de bruit de detail, + // qui se raccorde bord a bord). Par defaut CLAMP_TO_EDGE, le bon choix pour + // l'orthophoto - voir createSampler. + Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue, + const TextureData& data, bool repeat = false); + ~Texture(); + + Texture(const Texture&) = delete; + Texture& operator=(const Texture&) = delete; + + VkImageView view() const { return view_; } + VkSampler sampler() const { return sampler_; } + + // Octets reellement alloues sur le GPU pour l'image (mipmaps comprises). + VkDeviceSize deviceSize() const { return deviceSize_; } + + // Donnees d'une texture 1x1 blanche opaque, a passer au constructeur. + // + // Le descriptor set du Renderer declare toujours son binding de texture ; le + // laisser non ecrit serait une erreur de validation des qu'un shader du set + // y accede. Plutot que de multiplier les layouts et les pipelines selon + // qu'une orthophoto est chargee ou non, on relie toujours QUELQUE CHOSE, et + // c'est un facteur neutre (blanc) quand il n'y a pas de photo. Renvoyer des + // donnees CPU plutot qu'une Texture construite evite d'avoir a rendre cette + // classe deplacable pour un seul cas d'usage. + static TextureData whitePixelData(); + +private: + void createImage(uint32_t width, uint32_t height, uint32_t mipLevels, VkFormat format); + void uploadAndTransition(VkCommandPool commandPool, VkQueue queue, + const TextureData& data); + void createView(VkFormat format, uint32_t mipLevels); + void createSampler(uint32_t mipLevels, bool repeat); + + VulkanContext& context_; + VkImage image_ = VK_NULL_HANDLE; + VkDeviceMemory memory_ = VK_NULL_HANDLE; + VkImageView view_ = VK_NULL_HANDLE; + VkSampler sampler_ = VK_NULL_HANDLE; + VkDeviceSize deviceSize_ = 0; +}; + +} // namespace vercora diff --git a/src/renderer/UniformBufferObject.hpp b/src/renderer/UniformBufferObject.hpp new file mode 100644 index 0000000..9f129bf --- /dev/null +++ b/src/renderer/UniformBufferObject.hpp @@ -0,0 +1,90 @@ +#pragma once + +#include + +namespace vercora { + +// Donnees uniformes passees aux shaders (binding = 0). +// alignas(16) : les mat4 doivent etre alignees sur 16 octets selon les regles +// std140/std430 de GLSL, sinon le layout C++ ne correspond pas au shader. +// Idem pour un vec3, qui s'aligne sur 16 (et non 12) en std140. +// +// Offsets resultants, identiques cote C++ et cote GLSL : +// view 0 | proj 64 | viewPos 128 | terrain 144 | sun 160 | sunColor 176 +// +// Ce bloc ne contient QUE ce qui est constant sur toute la frame. Depuis la +// Phase 5, la model matrix n'en fait plus partie : une frame dessine plusieurs +// objets (terrain, arbres, souches, buches) et chacun pousse la sienne par push +// constant au moment de son draw (voir DrawItem.hpp et Pipeline.cpp). +struct UniformBufferObject { + alignas(16) glm::mat4 view; + alignas(16) glm::mat4 proj; + + // Position de la camera en espace monde. Necessaire au fragment shader pour + // le terme speculaire (vecteur surface -> observateur). + alignas(16) glm::vec3 viewPos; + + // Parametres du terrain : x = altitude minimale, y = altitude maximale, + // zw reserves. Le fragment shader du terrain s'en sert pour normaliser sa + // coloration par altitude. + // + // Un vec4 (et non un vec2) volontairement : son alignement std140 est 16, + // exactement celui d'alignas(16) cote C++, donc aucune ambiguite de layout. + // Les shaders du cube ne declarent pas ce membre et ignorent donc les 16 + // derniers octets du buffer : legal, la plage d'un descriptor peut depasser + // la taille du bloc declare par un shader (l'inverse ne l'est pas). + alignas(16) glm::vec4 terrain{0.0f, 1.0f, 0.0f, 0.0f}; + + // PHASE 23 - CYCLE JOUR/NUIT. + // + // Jusqu'ici la lumiere directionnelle etait la constante + // vec3(-0.4, -1.0, -0.6) ecrite en dur dans les TROIS shaders de fragment, + // depuis la Phase 2. Le jeu simulait pourtant une horloge acceleree douze + // fois depuis la Phase 16 : une session d'une heure traversait une tombee de + // nuit dont l'image ne montrait rien. C'est l'incoherence notee dans + // NOTES-PHASE16.md, et ces deux vec4 la corrigent. + // + // Les valeurs par defaut ci-dessous REPRODUISENT EXACTEMENT l'ancien + // eclairage - direction normalisee de (0.4, 1.0, 0.6), pleine intensite, + // meme teinte, ambiante inchangee. Un rendu qui n'appellerait pas + // Renderer::setSun() est donc pixel pour pixel celui de la Phase 22, ce qui + // rend la non-regression verifiable. + // + // sun.xyz direction du fragment VERS la lumiere, unitaire, en monde + // sun.w intensite de la lumiere directe, dans [0, 1] + // sunColor.rgb couleur de la lumiere + // sunColor.a MULTIPLICATEUR de l'ambiante propre a chaque shader (dans + // [0, 4] depuis la Phase 27 : > 1 sous un ciel couvert). Un + // multiplicateur, parce que les trois shaders ont des + // ambiantes differentes et justifiees (0,15 / 0,18 / 0,24) : + // les remplacer par une valeur unique aurait ete une + // regression de rendu deguisee en correction de cycle. + alignas(16) glm::vec4 sun{0.3244f, 0.8111f, 0.4867f, 1.0f}; + alignas(16) glm::vec4 sunColor{1.0f, 0.97f, 0.90f, 1.0f}; + + // PHASE 27 - METEO VISIBLE. Offsets 192 / 208 / 224 / 240. + // + // Toutes ces valeurs sont produites par weatherVisualsFor() (world/ + // Weather.hpp), qui ne fait que TRADUIRE des grandeurs deja calculees par + // WeatherSystem. Les defauts ci-dessous sont NEUTRES : sans appel a + // Renderer::setWeatherVisuals(), aucun brouillard, aucune pluie, aucun + // assombrissement - l'image est exactement celle de la Phase 26. + // + // fog.rgb couleur du brouillard (= couleur du ciel) + // fog.a coefficient d'extinction, en 1/m (0 = aucun brouillard) + // precip.x intensite de precipitation a l'ecran, dans [0, 1] + // precip.y 1 = neige, 0 = pluie + // precip.z temps ecoule en secondes (animation de la chute) + // precip.w assombrissement du sol par la mouillure, dans [0, 1] + // fall.xyz vitesse de chute apparente en monde, m/s (vent local compris) + // fall.w reserve + // detail micro-relief du sol (PHASE 27, chantier 3) : + // x = force (0 = desactive), y = debut du fondu, z = fin du + // fondu (metres depuis la camera), w = echelle du motif (m) + alignas(16) glm::vec4 fog{0.52f, 0.66f, 0.82f, 0.0f}; + alignas(16) glm::vec4 precip{0.0f, 0.0f, 0.0f, 0.0f}; + alignas(16) glm::vec4 fall{0.0f, -6.5f, 0.0f, 0.0f}; + alignas(16) glm::vec4 detail{0.0f, 0.0f, 1.0f, 1.0f}; +}; + +} // namespace vercora diff --git a/src/renderer/Vertex.hpp b/src/renderer/Vertex.hpp new file mode 100644 index 0000000..6c12cf7 --- /dev/null +++ b/src/renderer/Vertex.hpp @@ -0,0 +1,50 @@ +#pragma once + +#include + +namespace vercora { + +// Un sommet : position, couleur, normale, coordonnee de texture, plus la cible +// de geomorphing ajoutee en Phase 10. +// +// L'UV n'est pas encore utilise par les shaders (pas de texturing avant une +// phase ulterieure) mais il est stocke des maintenant : le loader .obj de la +// Phase 3 le lit quand le fichier le fournit, et changer le format de sommet +// plus tard obligerait a retoucher pipeline + shaders + tous les meshes. +// Valeur par defaut (0,0) : la geometrie codee en dur (CubeMesh) ne definit pas +// d'UV, l'initialisation par agregat laisse donc ce membre a zero de facon +// deterministe plutot que non initialise. +// +// PHASE 10 - morphPos / morphNormal : ou ce sommet doit ALLER quand la tuile de +// terrain qui le porte passe au niveau de detail superieur (voir +// renderer/TerrainNodeMesh.hpp). Le vertex shader du terrain interpole entre +// (pos, normal) et (morphPos, morphNormal) selon la distance a la camera, ce qui +// supprime le "popping" au changement de LOD ET les fissures entre tuiles +// voisines de niveaux differents. +// +// Ces deux membres coutent 24 octets sur TOUS les sommets, y compris ceux du +// cube et des arbres qui ne s'en servent pas. C'est assume : un second format de +// sommet imposerait un second binding, un second pipeline layout et un second +// jeu de shaders, pour economiser quelques kilo-octets sur des meshes minuscules. +// Sur le terrain, ou le volume est reel, le quadtree fait par ailleurs baisser la +// quantite de geometrie residente d'un ordre de grandeur - largement de quoi +// payer ces 24 octets. +// +// Valeur par defaut nulle : sans effet, car le shader ne morphe que lorsque la +// bande [morphStart, morphEnd] poussee par le DrawItem est non vide, ce qui n'est +// le cas que pour les tuiles du quadtree. +// +// Ce header ne connait PAS Vulkan : c'est de la donnee pure. La description du +// format a l'attention du pipeline vit dans renderer/VertexFormat.hpp, qui est +// le seul fichier a inclure pour ce sujet. Voir l'explication +// detaillee la-bas. +struct Vertex { + glm::vec3 pos; + glm::vec3 color; + glm::vec3 normal; + glm::vec2 uv{0.0f, 0.0f}; + glm::vec3 morphPos{0.0f, 0.0f, 0.0f}; + glm::vec3 morphNormal{0.0f, 0.0f, 0.0f}; +}; + +} // namespace vercora diff --git a/src/renderer/VertexFormat.hpp b/src/renderer/VertexFormat.hpp new file mode 100644 index 0000000..1a6116a --- /dev/null +++ b/src/renderer/VertexFormat.hpp @@ -0,0 +1,136 @@ +#pragma once + +#include "renderer/InstanceData.hpp" +#include "renderer/Vertex.hpp" + +#include + +#include +#include + +namespace vercora { + +// Description VULKAN du sommet : comment le lire dans le buffer, et quel attribut +// alimente quel location(...) du vertex shader. +// +// Volontairement separee de Vertex.hpp. Vertex/MeshData se presentent comme de la +// geometrie "cote CPU, independante de Vulkan", mais tant que ces deux fonctions +// vivaient dans la struct, le simple fait d'inclure MeshData.hpp tirait +// : toute la logique de jeu (world/, core/) devenait donc +// incompilable sans le SDK Vulkan installe, alors qu'elle ne depend que de GLM. +// Ce fichier est le SEUL endroit du dossier renderer/ ou le format de sommet +// rencontre Vulkan, et seul Pipeline.cpp en a besoin. +// +// Consequence concrete : la logique de jeu se compile et se teste sans GPU (voir +// tests/logic_tests.cpp), y compris sur une machine ou le SDK n'est pas installe. + +// Un seul binding, sommets entrelaces. +inline VkVertexInputBindingDescription vertexBindingDescription() { + VkVertexInputBindingDescription binding{}; + binding.binding = 0; + binding.stride = sizeof(Vertex); + binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + return binding; +} + +// Mapping des attributs vers les location(...) du vertex shader. +// +// Six attributs depuis la Phase 10 : les deux derniers portent la cible de +// geomorphing du terrain (voir Vertex.hpp) et ne sont decrits qu'aux pipelines +// dont le vertex shader les lit reellement. +// `includeMorph` a false pour un vertex shader qui ne lit pas les locations 4/5 +// (cube.vert) : les decrire quand meme declencherait un avertissement de +// validation. Voir ShaderSet::usesMorphAttributes. +inline std::array vertexAttributeDescriptions() { + std::array attrs{}; + + attrs[0].binding = 0; + attrs[0].location = 0; + attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT; + attrs[0].offset = offsetof(Vertex, pos); + + attrs[1].binding = 0; + attrs[1].location = 1; + attrs[1].format = VK_FORMAT_R32G32B32_SFLOAT; + attrs[1].offset = offsetof(Vertex, color); + + attrs[2].binding = 0; + attrs[2].location = 2; + attrs[2].format = VK_FORMAT_R32G32B32_SFLOAT; + attrs[2].offset = offsetof(Vertex, normal); + + // Deux composantes seulement -> format R32G32. + attrs[3].binding = 0; + attrs[3].location = 3; + attrs[3].format = VK_FORMAT_R32G32_SFLOAT; + attrs[3].offset = offsetof(Vertex, uv); + + // Position et normale du meme sommet dans la grille du niveau de detail + // SUPERIEUR (plus grossier). Nulles sur toute geometrie qui n'est pas une + // tuile de quadtree : sans effet, le shader ne morphe que si la bande de + // morphing poussee par le DrawItem est non vide. + attrs[4].binding = 0; + attrs[4].location = 4; + attrs[4].format = VK_FORMAT_R32G32B32_SFLOAT; + attrs[4].offset = offsetof(Vertex, morphPos); + + attrs[5].binding = 0; + attrs[5].location = 5; + attrs[5].format = VK_FORMAT_R32G32B32_SFLOAT; + attrs[5].offset = offsetof(Vertex, morphNormal); + + return attrs; +} + +// --------------------------------------------------------------------------- +// PHASE 11 : binding d'INSTANCES (binding 1) +// --------------------------------------------------------------------------- +// Second flux de sommets, cadence par INSTANCE et non par sommet. Le pipeline +// n'en est decrit que pour les materiaux instancies (ShaderSet::usesInstancing) : +// declarer un binding qu'aucun shader ne lit ferait echouer la validation, et +// surtout obligerait a lier un buffer d'instances au moment de dessiner un cube. + +inline VkVertexInputBindingDescription instanceBindingDescription() { + VkVertexInputBindingDescription binding{}; + binding.binding = 1; + binding.stride = sizeof(InstanceData); + binding.inputRate = VK_VERTEX_INPUT_RATE_INSTANCE; + return binding; +} + +// Locations 6 a 8 : les locations 0 a 5 appartiennent au sommet (voir plus haut), +// et un pipeline instancie decrit les deux flux dans le meme espace de numeros. +// Les trois flottants scalaires (scale, yaw, variation, fade) sont regroupes en +// deux attributs plutot qu'en quatre : moins d'attributs a decrire, et le shader +// les lit comme des vec2, ce qui se lit aussi bien. +inline std::array instanceAttributeDescriptions() { + std::array attrs{}; + + attrs[0].binding = 1; + attrs[0].location = 6; + attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT; + attrs[0].offset = offsetof(InstanceData, position); + + // scale et yaw sont contigus dans la struct : un seul vec2 les porte. + attrs[1].binding = 1; + attrs[1].location = 7; + attrs[1].format = VK_FORMAT_R32G32_SFLOAT; + attrs[1].offset = offsetof(InstanceData, scale); + + // variation et fade, contigus de la meme facon. + attrs[2].binding = 1; + attrs[2].location = 8; + attrs[2].format = VK_FORMAT_R32G32_SFLOAT; + attrs[2].offset = offsetof(InstanceData, variation); + + return attrs; +} + +// Verifications que les regroupements ci-dessus supposent. Sans elles, un ajout +// de membre dans InstanceData decalerait silencieusement yaw ou fade. +static_assert(offsetof(InstanceData, yaw) == offsetof(InstanceData, scale) + sizeof(float), + "scale et yaw doivent rester contigus : ils sont lus comme un vec2."); +static_assert(offsetof(InstanceData, fade) == offsetof(InstanceData, variation) + sizeof(float), + "variation et fade doivent rester contigus : ils sont lus comme un vec2."); + +} // namespace vercora diff --git a/src/renderer/VulkanBuffer.cpp b/src/renderer/VulkanBuffer.cpp new file mode 100644 index 0000000..0efebe8 --- /dev/null +++ b/src/renderer/VulkanBuffer.cpp @@ -0,0 +1,110 @@ +#include "renderer/VulkanBuffer.hpp" + +#include "renderer/VulkanContext.hpp" + +#include +#include + +namespace vercora { + +VulkanBuffer::VulkanBuffer(VulkanContext& context, + VkDeviceSize size, + VkBufferUsageFlags usage, + VkMemoryPropertyFlags properties) + : context_(context), size_(size) { + VkDevice device = context_.device(); + + VkBufferCreateInfo bufferInfo{}; + bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + bufferInfo.size = size_; + bufferInfo.usage = usage; + bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + + if (vkCreateBuffer(device, &bufferInfo, nullptr, &buffer_) != VK_SUCCESS) { + throw std::runtime_error("Echec de la creation d'un buffer."); + } + + VkMemoryRequirements memRequirements{}; + vkGetBufferMemoryRequirements(device, buffer_, &memRequirements); + + VkMemoryAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocInfo.allocationSize = memRequirements.size; + allocInfo.memoryTypeIndex = + context_.findMemoryType(memRequirements.memoryTypeBits, properties); + + if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) { + throw std::runtime_error("Echec de l'allocation memoire d'un buffer."); + } + + vkBindBufferMemory(device, buffer_, memory_, 0); +} + +VulkanBuffer::~VulkanBuffer() { + VkDevice device = context_.device(); + if (mapped_ != nullptr) { + vkUnmapMemory(device, memory_); + mapped_ = nullptr; + } + if (buffer_ != VK_NULL_HANDLE) { + vkDestroyBuffer(device, buffer_, nullptr); + } + if (memory_ != VK_NULL_HANDLE) { + vkFreeMemory(device, memory_, nullptr); + } +} + +void VulkanBuffer::map() { + if (mapped_ == nullptr) { + vkMapMemory(context_.device(), memory_, 0, size_, 0, &mapped_); + } +} + +void VulkanBuffer::unmap() { + if (mapped_ != nullptr) { + vkUnmapMemory(context_.device(), memory_); + mapped_ = nullptr; + } +} + +void VulkanBuffer::writeToBuffer(const void* data, VkDeviceSize dataSize) { + map(); + std::memcpy(mapped_, data, static_cast(dataSize)); +} + +void VulkanBuffer::copyFrom(const VulkanBuffer& src, VkCommandPool commandPool, VkQueue queue) { + VkDevice device = context_.device(); + + // Command buffer a usage unique pour le transfert. + VkCommandBufferAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandPool = commandPool; + allocInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer = VK_NULL_HANDLE; + vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer); + + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + vkBeginCommandBuffer(commandBuffer, &beginInfo); + + VkBufferCopy copyRegion{}; + copyRegion.size = src.size(); + vkCmdCopyBuffer(commandBuffer, src.handle(), buffer_, 1, ©Region); + + vkEndCommandBuffer(commandBuffer); + + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + + vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE); + vkQueueWaitIdle(queue); // simple et suffisant pour un transfert ponctuel a l'init. + + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); +} + +} // namespace vercora diff --git a/src/renderer/VulkanBuffer.hpp b/src/renderer/VulkanBuffer.hpp new file mode 100644 index 0000000..4880b97 --- /dev/null +++ b/src/renderer/VulkanBuffer.hpp @@ -0,0 +1,83 @@ +#pragma once + +#include + +#include + +namespace vercora { + +class VulkanContext; +class VulkanBuffer; + +// PHASE 12. Destinataire d'une copie staging -> device-local qui ne veut PAS +// attendre le GPU. +// +// Jusqu'ici tout upload passait par VulkanBuffer::copyFrom, qui soumet un +// command buffer jetable puis fait un vkQueueWaitIdle : une synchronisation +// complete avec le GPU, a chaque tuile de terrain. C'etait le "verrou n 1" +// identifie en Phase 10, celui qui imposait un budget de 4 tuiles construites +// par frame. +// +// L'implementation reelle est le Renderer : il accumule les copies demandees et +// les enregistre en tete du command buffer de la frame suivante, suivies d'UNE +// barriere transfert -> vertex input. Le buffer staging lui est CEDE, parce que +// sa duree de vie ne se termine plus au retour de l'appel mais a la fin de la +// frame qui aura execute la copie. +// +// L'interface existe pour que Mesh n'ait pas a connaitre le Renderer (qui, lui, +// possede des Mesh : la dependance inverse serait circulaire). +class BufferUploader { +public: + virtual ~BufferUploader() = default; + + // Enregistre une copie de `staging` (integralite de sa taille) vers + // `destination`. Prend possession de `staging`, qui sera detruit quand la + // frame ayant execute la copie sera terminee. + virtual void enqueueCopy(std::unique_ptr staging, + VkBuffer destination) = 0; +}; + +// Buffer Vulkan reutilisable : creation, allocation memoire, bind, map, +// ecriture et copie (staging). Evite de dupliquer le code d'allocation partout. +class VulkanBuffer { +public: + VulkanBuffer(VulkanContext& context, + VkDeviceSize size, + VkBufferUsageFlags usage, + VkMemoryPropertyFlags properties); + ~VulkanBuffer(); + + VulkanBuffer(const VulkanBuffer&) = delete; + VulkanBuffer& operator=(const VulkanBuffer&) = delete; + + VkBuffer handle() const { return buffer_; } + VkDeviceSize size() const { return size_; } + + // Mappe la memoire de facon persistante (buffers host-visible uniquement). + void map(); + void unmap(); + void* mapped() const { return mapped_; } + + // Copie 'dataSize' octets depuis 'data' vers la memoire mappee. + void writeToBuffer(const void* data, VkDeviceSize dataSize); + + // Copie GPU->GPU depuis 'src' vers ce buffer via un command buffer jetable, + // SUIVIE D'UN vkQueueWaitIdle : l'appel ne revient qu'une fois la copie + // reellement terminee. + // + // PHASE 12 - a n'utiliser que HORS du chemin critique de rendu, c'est-a-dire + // avant la premiere frame (orthophoto, textures). Pour tout ce qui est + // televerse pendant que le jeu tourne - les tuiles du streaming - passer par + // un BufferUploader : le vkQueueWaitIdle ci-dessous est exactement ce qui + // plafonnait le streaming a 4 tuiles par frame. + void copyFrom(const VulkanBuffer& src, VkCommandPool commandPool, VkQueue queue); + +private: + VulkanContext& context_; + VkDeviceSize size_ = 0; + VkBuffer buffer_ = VK_NULL_HANDLE; + VkDeviceMemory memory_ = VK_NULL_HANDLE; + void* mapped_ = nullptr; +}; + +} // namespace vercora diff --git a/src/renderer/VulkanContext.cpp b/src/renderer/VulkanContext.cpp new file mode 100644 index 0000000..d20b36f --- /dev/null +++ b/src/renderer/VulkanContext.cpp @@ -0,0 +1,462 @@ +#include "renderer/VulkanContext.hpp" + +#include "core/Logger.hpp" +#include "core/Window.hpp" + +#include +#include +#include +#include + +namespace vercora { + +namespace { + +// Validation layers actives uniquement en Debug (voir VERCORA_DEBUG). +#ifdef VERCORA_DEBUG +constexpr bool kEnableValidationLayers = true; +#else +constexpr bool kEnableValidationLayers = false; +#endif + +const std::vector kValidationLayers = { + "VK_LAYER_KHRONOS_validation" +}; + +const std::vector kDeviceExtensions = { + VK_KHR_SWAPCHAIN_EXTENSION_NAME +}; + +// Callback appele par les validation layers. Route les messages vers notre logger. +VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback( + VkDebugUtilsMessageSeverityFlagBitsEXT severity, + VkDebugUtilsMessageTypeFlagsEXT /*type*/, + const VkDebugUtilsMessengerCallbackDataEXT* callbackData, + void* /*userData*/) { + + if (severity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) { + logError(std::string("[Validation] ") + callbackData->pMessage); + } else if (severity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) { + logWarn(std::string("[Validation] ") + callbackData->pMessage); + } else { + logInfo(std::string("[Validation] ") + callbackData->pMessage); + } + return VK_FALSE; +} + +// vkCreate/DestroyDebugUtilsMessengerEXT ne sont pas charges statiquement : +// il faut passer par vkGetInstanceProcAddr. +VkResult createDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* createInfo, + const VkAllocationCallbacks* allocator, + VkDebugUtilsMessengerEXT* messenger) { + auto func = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT")); + if (func != nullptr) { + return func(instance, createInfo, allocator, messenger); + } + return VK_ERROR_EXTENSION_NOT_PRESENT; +} + +void destroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* allocator) { + auto func = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT")); + if (func != nullptr) { + func(instance, messenger, allocator); + } +} + +void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& info) { + info = {}; + info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + info.messageSeverity = + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + info.messageType = + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; + info.pfnUserCallback = debugCallback; +} + +} // namespace + +VulkanContext::VulkanContext(Window& window) { + createInstance(); + setupDebugMessenger(); + createSurface(window); + pickPhysicalDevice(); + createLogicalDevice(); +} + +VulkanContext::~VulkanContext() { + if (device_ != VK_NULL_HANDLE) { + vkDestroyDevice(device_, nullptr); + } + if (surface_ != VK_NULL_HANDLE) { + vkDestroySurfaceKHR(instance_, surface_, nullptr); + } + if (kEnableValidationLayers && debugMessenger_ != VK_NULL_HANDLE) { + destroyDebugUtilsMessengerEXT(instance_, debugMessenger_, nullptr); + } + if (instance_ != VK_NULL_HANDLE) { + vkDestroyInstance(instance_, nullptr); + } +} + +// --------------------------------------------------------------------------- +// Instance +// --------------------------------------------------------------------------- +void VulkanContext::createInstance() { + if (kEnableValidationLayers && !checkValidationLayerSupport()) { + throw std::runtime_error("Validation layers demandees mais indisponibles."); + } + + VkApplicationInfo appInfo{}; + appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + appInfo.pApplicationName = "Vercora"; + appInfo.applicationVersion = VK_MAKE_VERSION(0, 1, 0); + appInfo.pEngineName = "Vercora Engine"; + appInfo.engineVersion = VK_MAKE_VERSION(0, 1, 0); + appInfo.apiVersion = VK_API_VERSION_1_2; + + VkInstanceCreateInfo createInfo{}; + createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + createInfo.pApplicationInfo = &appInfo; + + const auto extensions = getRequiredInstanceExtensions(); + createInfo.enabledExtensionCount = static_cast(extensions.size()); + createInfo.ppEnabledExtensionNames = extensions.data(); + + // Ce debug messenger "temporaire" couvre la creation/destruction de l'instance + // elle-meme (avant/apres le messenger principal). + VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{}; + if (kEnableValidationLayers) { + createInfo.enabledLayerCount = static_cast(kValidationLayers.size()); + createInfo.ppEnabledLayerNames = kValidationLayers.data(); + populateDebugMessengerCreateInfo(debugCreateInfo); + createInfo.pNext = &debugCreateInfo; + } else { + createInfo.enabledLayerCount = 0; + } + + if (vkCreateInstance(&createInfo, nullptr, &instance_) != VK_SUCCESS) { + throw std::runtime_error("Echec de la creation de l'instance Vulkan."); + } + logInfo("Instance Vulkan creee."); +} + +std::vector VulkanContext::getRequiredInstanceExtensions() const { + // GLFW indique les extensions necessaires au fenetrage (surface + plateforme). + uint32_t glfwExtensionCount = 0; + const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); + + std::vector extensions(glfwExtensions, glfwExtensions + glfwExtensionCount); + + if (kEnableValidationLayers) { + extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); + } + return extensions; +} + +bool VulkanContext::checkValidationLayerSupport() const { + uint32_t layerCount = 0; + vkEnumerateInstanceLayerProperties(&layerCount, nullptr); + std::vector available(layerCount); + vkEnumerateInstanceLayerProperties(&layerCount, available.data()); + + for (const char* wanted : kValidationLayers) { + bool found = false; + for (const auto& props : available) { + if (std::strcmp(wanted, props.layerName) == 0) { + found = true; + break; + } + } + if (!found) { + return false; + } + } + return true; +} + +// --------------------------------------------------------------------------- +// Debug messenger +// --------------------------------------------------------------------------- +void VulkanContext::setupDebugMessenger() { + if (!kEnableValidationLayers) { + return; + } + VkDebugUtilsMessengerCreateInfoEXT createInfo{}; + populateDebugMessengerCreateInfo(createInfo); + if (createDebugUtilsMessengerEXT(instance_, &createInfo, nullptr, &debugMessenger_) != VK_SUCCESS) { + throw std::runtime_error("Echec de la mise en place du debug messenger."); + } + logInfo("Validation layers activees."); +} + +// --------------------------------------------------------------------------- +// Surface +// --------------------------------------------------------------------------- +void VulkanContext::createSurface(Window& window) { + surface_ = window.createSurface(instance_); +} + +// --------------------------------------------------------------------------- +// Selection du GPU physique +// --------------------------------------------------------------------------- +void VulkanContext::pickPhysicalDevice() { + uint32_t deviceCount = 0; + vkEnumeratePhysicalDevices(instance_, &deviceCount, nullptr); + if (deviceCount == 0) { + throw std::runtime_error("Aucun GPU compatible Vulkan trouve."); + } + std::vector devices(deviceCount); + vkEnumeratePhysicalDevices(instance_, &deviceCount, devices.data()); + + for (const auto& device : devices) { + if (isDeviceSuitable(device)) { + physicalDevice_ = device; + queueIndices_ = findQueueFamilies(device); + break; + } + } + + if (physicalDevice_ == VK_NULL_HANDLE) { + throw std::runtime_error("Aucun GPU ne remplit les criteres requis."); + } + + VkPhysicalDeviceProperties props{}; + vkGetPhysicalDeviceProperties(physicalDevice_, &props); + logInfo(std::string("GPU selectionne : ") + props.deviceName); +} + +bool VulkanContext::isDeviceSuitable(VkPhysicalDevice device) const { + const QueueFamilyIndices indices = findQueueFamilies(device); + const bool extensionsSupported = checkDeviceExtensionSupport(device); + + bool swapChainAdequate = false; + if (extensionsSupported) { + const SwapChainSupportDetails support = querySwapChainSupport(device); + swapChainAdequate = !support.formats.empty() && !support.presentModes.empty(); + } + + return indices.isComplete() && extensionsSupported && swapChainAdequate; +} + +bool VulkanContext::checkDeviceExtensionSupport(VkPhysicalDevice device) const { + uint32_t extensionCount = 0; + vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr); + std::vector available(extensionCount); + vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, available.data()); + + std::set required(kDeviceExtensions.begin(), kDeviceExtensions.end()); + for (const auto& ext : available) { + required.erase(ext.extensionName); + } + return required.empty(); +} + +QueueFamilyIndices VulkanContext::findQueueFamilies(VkPhysicalDevice device) const { + QueueFamilyIndices indices; + + uint32_t queueFamilyCount = 0; + vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr); + std::vector families(queueFamilyCount); + vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, families.data()); + + // PHASE 12 : le balayage va desormais jusqu'au bout (et non plus jusqu'a + // isComplete()), parce qu'une famille de transfert dediee est generalement + // DERRIERE la famille graphique dans la liste. Il y a moins d'une dizaine de + // familles sur n'importe quel GPU : le cout est nul et c'est fait une fois. + for (uint32_t i = 0; i < queueFamilyCount; ++i) { + const VkQueueFlags flags = families[i].queueFlags; + + if ((flags & VK_QUEUE_GRAPHICS_BIT) && !indices.graphicsFamily.has_value()) { + indices.graphicsFamily = i; + } + VkBool32 presentSupport = VK_FALSE; + vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface_, &presentSupport); + if (presentSupport == VK_TRUE && !indices.presentFamily.has_value()) { + indices.presentFamily = i; + } + // Dediee = sait transferer, ne sait PAS faire de graphique. Le bit + // TRANSFER est implicite pour une famille graphique ou compute, d'ou le + // test sur les deux autres bits plutot que sur le seul bit TRANSFER. + if ((flags & VK_QUEUE_TRANSFER_BIT) && !(flags & VK_QUEUE_GRAPHICS_BIT) && + !indices.dedicatedTransferFamily.has_value()) { + indices.dedicatedTransferFamily = i; + } + } + return indices; +} + +// --------------------------------------------------------------------------- +// Device logique + queues +// --------------------------------------------------------------------------- +void VulkanContext::createLogicalDevice() { + // graphics et present peuvent pointer sur la meme famille -> set pour dedup. + std::set uniqueFamilies = { + queueIndices_.graphicsFamily.value(), + queueIndices_.presentFamily.value() + }; + + std::vector queueCreateInfos; + const float queuePriority = 1.0f; + for (uint32_t family : uniqueFamilies) { + VkDeviceQueueCreateInfo queueInfo{}; + queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queueInfo.queueFamilyIndex = family; + queueInfo.queueCount = 1; + queueInfo.pQueuePriorities = &queuePriority; + queueCreateInfos.push_back(queueInfo); + } + + // PHASE 11 : samplerAnisotropy pour l'orthophoto. Le terrain est un plan + // regarde en rasant depuis la hauteur d'oeil - le cas ou un filtrage + // trilineaire seul rend une bouillie au-dela de quelques dizaines de metres. + // La feature est OPTIONNELLE en Vulkan : on l'active si le GPU la propose et + // on s'en passe sinon, plutot que d'en faire un critere de selection du GPU. + // La demander sans qu'elle soit supportee ferait echouer la creation du + // device, et l'utiliser sans l'avoir activee est une erreur de validation. + VkPhysicalDeviceFeatures supported{}; + vkGetPhysicalDeviceFeatures(physicalDevice_, &supported); + + VkPhysicalDeviceFeatures deviceFeatures{}; + anisotropyEnabled_ = (supported.samplerAnisotropy == VK_TRUE); + deviceFeatures.samplerAnisotropy = anisotropyEnabled_ ? VK_TRUE : VK_FALSE; + if (!anisotropyEnabled_) { + logWarn("Ce GPU ne propose pas samplerAnisotropy : le terrain texture " + "sera plus flou en vue rasante."); + } + + VkDeviceCreateInfo createInfo{}; + createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + createInfo.queueCreateInfoCount = static_cast(queueCreateInfos.size()); + createInfo.pQueueCreateInfos = queueCreateInfos.data(); + createInfo.pEnabledFeatures = &deviceFeatures; + createInfo.enabledExtensionCount = static_cast(kDeviceExtensions.size()); + createInfo.ppEnabledExtensionNames = kDeviceExtensions.data(); + + // Les layers de device sont depreciees depuis Vulkan 1.0 : les validation + // layers recentes exigent enabledLayerCount == 0. Seules les layers d'instance + // comptent (voir createInstance). On laisse donc ce champ a 0. + createInfo.enabledLayerCount = 0; + + if (vkCreateDevice(physicalDevice_, &createInfo, nullptr, &device_) != VK_SUCCESS) { + throw std::runtime_error("Echec de la creation du device logique."); + } + + vkGetDeviceQueue(device_, queueIndices_.graphicsFamily.value(), 0, &graphicsQueue_); + vkGetDeviceQueue(device_, queueIndices_.presentFamily.value(), 0, &presentQueue_); + logInfo("Device logique et queues cree(e)s."); + + // PHASE 12 : inventaire des familles de queues. Journalise parce que c'est + // l'information qui DECIDE de l'architecture de transfert (voir + // QueueFamilyIndices::dedicatedTransferFamily et NOTES-PHASE12.md) : sans + // cette ligne, relire le choix six mois plus tard obligerait a le refaire. + { + uint32_t count = 0; + vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &count, nullptr); + std::vector families(count); + vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &count, families.data()); + + std::string text = "Familles de queues : " + std::to_string(count) + " -"; + for (uint32_t i = 0; i < count; ++i) { + text += " [" + std::to_string(i) + "] x" + + std::to_string(families[i].queueCount); + const VkQueueFlags flags = families[i].queueFlags; + if (flags & VK_QUEUE_GRAPHICS_BIT) text += " graphics"; + if (flags & VK_QUEUE_COMPUTE_BIT) text += " compute"; + if (flags & VK_QUEUE_TRANSFER_BIT) text += " transfer"; + if (flags & VK_QUEUE_SPARSE_BINDING_BIT) text += " sparse"; + } + logInfo(text); + + if (queueIndices_.dedicatedTransferFamily.has_value()) { + logInfo("Famille de transfert dediee disponible (indice " + + std::to_string(queueIndices_.dedicatedTransferFamily.value()) + + "), NON utilisee : les transferts de tuiles sont enregistres " + "dans le command buffer de la frame (voir NOTES-PHASE12.md)."); + } else { + logInfo("Aucune famille de transfert dediee sur ce GPU : les " + "transferts partagent forcement la queue graphique."); + } + } +} + +// --------------------------------------------------------------------------- +// Support swapchain +// --------------------------------------------------------------------------- +SwapChainSupportDetails VulkanContext::querySwapChainSupport() const { + return querySwapChainSupport(physicalDevice_); +} + +uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const { + VkPhysicalDeviceMemoryProperties memProperties{}; + vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memProperties); + + for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) { + const bool typeOk = (typeFilter & (1u << i)) != 0; + const bool propsOk = + (memProperties.memoryTypes[i].propertyFlags & properties) == properties; + if (typeOk && propsOk) { + return i; + } + } + throw std::runtime_error("Aucun type de memoire adapte trouve."); +} + +VkFormat VulkanContext::findSupportedFormat(const std::vector& candidates, + VkImageTiling tiling, + VkFormatFeatureFlags features) const { + for (VkFormat format : candidates) { + VkFormatProperties props{}; + vkGetPhysicalDeviceFormatProperties(physicalDevice_, format, &props); + + if (tiling == VK_IMAGE_TILING_LINEAR && + (props.linearTilingFeatures & features) == features) { + return format; + } + if (tiling == VK_IMAGE_TILING_OPTIMAL && + (props.optimalTilingFeatures & features) == features) { + return format; + } + } + throw std::runtime_error("Aucun format supporte trouve parmi les candidats."); +} + +VkFormat VulkanContext::findDepthFormat() const { + return findSupportedFormat( + { VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT }, + VK_IMAGE_TILING_OPTIMAL, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT); +} + +SwapChainSupportDetails VulkanContext::querySwapChainSupport(VkPhysicalDevice device) const { + SwapChainSupportDetails details; + + vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface_, &details.capabilities); + + uint32_t formatCount = 0; + vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface_, &formatCount, nullptr); + if (formatCount != 0) { + details.formats.resize(formatCount); + vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface_, &formatCount, details.formats.data()); + } + + uint32_t presentModeCount = 0; + vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface_, &presentModeCount, nullptr); + if (presentModeCount != 0) { + details.presentModes.resize(presentModeCount); + vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface_, &presentModeCount, details.presentModes.data()); + } + + return details; +} + +} // namespace vercora diff --git a/src/renderer/VulkanContext.hpp b/src/renderer/VulkanContext.hpp new file mode 100644 index 0000000..2561e78 --- /dev/null +++ b/src/renderer/VulkanContext.hpp @@ -0,0 +1,115 @@ +#pragma once + +#include + +#include +#include + +namespace vercora { + +class Window; + +// Indices des familles de queues dont on a besoin. +struct QueueFamilyIndices { + std::optional graphicsFamily; + std::optional presentFamily; + + // PHASE 12. Famille de transfert DEDIEE, c'est-a-dire une famille qui expose + // VK_QUEUE_TRANSFER_BIT sans VK_QUEUE_GRAPHICS_BIT. Renseignee seulement si + // le GPU en propose une : elle est OPTIONNELLE en Vulkan, et beaucoup de GPU + // integres n'exposent qu'une seule famille universelle. + // + // Elle n'est PAS utilisee pour les transferts du streaming (voir la note + // d'architecture dans NOTES-PHASE12.md et Renderer::enqueueCopy) : elle est + // detectee et journalisee parce que c'est cette detection qui justifie le + // choix fait, et parce qu'un futur portage sur GPU discret voudra la + // relire. Utiliser une famille differente pour ecrire un buffer puis le lire + // au rendu impose un TRANSFERT DE PROPRIETE de famille (barriere de release + // puis d'acquire) : du code qu'on ne peut pas eprouver sur une machine qui + // n'a qu'une famille, donc du code qu'on n'ecrit pas. + std::optional dedicatedTransferFamily; + + bool isComplete() const { + return graphicsFamily.has_value() && presentFamily.has_value(); + } +}; + +// Capacites de la surface pour la construction de la swapchain. +struct SwapChainSupportDetails { + VkSurfaceCapabilitiesKHR capabilities{}; + std::vector formats; + std::vector presentModes; +}; + +// Regroupe l'etat "global" Vulkan qui ne change pas au resize : +// instance, debug messenger, surface, GPU physique, device logique, queues. +class VulkanContext { +public: + explicit VulkanContext(Window& window); + ~VulkanContext(); + + VulkanContext(const VulkanContext&) = delete; + VulkanContext& operator=(const VulkanContext&) = delete; + + VkInstance instance() const { return instance_; } + VkSurfaceKHR surface() const { return surface_; } + VkPhysicalDevice physicalDevice() const { return physicalDevice_; } + VkDevice device() const { return device_; } + VkQueue graphicsQueue() const { return graphicsQueue_; } + VkQueue presentQueue() const { return presentQueue_; } + + const QueueFamilyIndices& queueFamilies() const { return queueIndices_; } + + // PHASE 11. true si samplerAnisotropy a ete ACTIVEE sur le device logique. + // Un echantillonneur ne peut demander l'anisotropie que dans ce cas : la + // demander sans l'avoir activee est une erreur de validation immediate. La + // feature est optionnelle en Vulkan, donc le moteur s'en passe si le GPU ne + // la propose pas (le terrain est alors plus flou en vue rasante, rien de + // plus). + bool anisotropyEnabled() const { return anisotropyEnabled_; } + + // (Re)interroge le support swapchain du GPU choisi. Appele au (re)build de + // la swapchain, car les capacites (extent courant) peuvent avoir change. + SwapChainSupportDetails querySwapChainSupport() const; + + // Trouve un type de memoire satisfaisant a la fois un filtre (bits issus des + // memory requirements) et un jeu de proprietes (host-visible, device-local...). + uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const; + + // Premier format de la liste supporte par le GPU pour un tiling/feature donne. + VkFormat findSupportedFormat(const std::vector& candidates, + VkImageTiling tiling, + VkFormatFeatureFlags features) const; + + // Format de profondeur retenu (D32 de preference, avec fallbacks). + VkFormat findDepthFormat() const; + +private: + void createInstance(); + void setupDebugMessenger(); + void createSurface(Window& window); + void pickPhysicalDevice(); + void createLogicalDevice(); + + bool isDeviceSuitable(VkPhysicalDevice device) const; + bool checkDeviceExtensionSupport(VkPhysicalDevice device) const; + QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) const; + SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) const; + + std::vector getRequiredInstanceExtensions() const; + bool checkValidationLayerSupport() const; + + VkInstance instance_ = VK_NULL_HANDLE; + VkDebugUtilsMessengerEXT debugMessenger_ = VK_NULL_HANDLE; + VkSurfaceKHR surface_ = VK_NULL_HANDLE; + VkPhysicalDevice physicalDevice_ = VK_NULL_HANDLE; + VkDevice device_ = VK_NULL_HANDLE; + VkQueue graphicsQueue_ = VK_NULL_HANDLE; + VkQueue presentQueue_ = VK_NULL_HANDLE; + + QueueFamilyIndices queueIndices_; + + bool anisotropyEnabled_ = false; +}; + +} // namespace vercora diff --git a/src/world/AnimalMesh.cpp b/src/world/AnimalMesh.cpp new file mode 100644 index 0000000..54f0569 --- /dev/null +++ b/src/world/AnimalMesh.cpp @@ -0,0 +1,177 @@ +#include "world/AnimalMesh.hpp" + +#include + +#include +#include + +namespace vercora { +namespace { + +// Teintes de sommet, comme pour la pierre et l'arbre : le materiau Object +// (cube.vert/frag) les utilise telles quelles, il n'y a pas de texture. +const glm::vec3 kCoatColor {0.42f, 0.31f, 0.20f}; // pelage fauve +const glm::vec3 kBellyColor{0.58f, 0.48f, 0.36f}; // ventre et croupe, plus clairs +const glm::vec3 kLegColor {0.30f, 0.22f, 0.15f}; // pattes, plus sombres +const glm::vec3 kHeadColor {0.36f, 0.27f, 0.18f}; + +// Meme fonction que StoneMesh::appendFacet : trois sommets qui appartiennent au +// triangle, une seule normale, donc une arete franche. +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 : sa normale n'existe pas + } + const glm::vec3 normal = rawNormal / length; + + const auto base = static_cast(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 }); +} + +// Une boite quelconque decrite par ses deux coins opposes, en 12 triangles +// facettes. L'ordre des sommets de chaque face est choisi pour que la normale +// calculee par appendFacet sorte du volume (sens trigonometrique vu de +// l'exterieur) : une face a l'envers serait eclairee par derriere et +// apparaitrait noire. +// +// Une boite suffit pour toutes les parties du corps : ce qui rend l'animal +// lisible a trente metres est sa SILHOUETTE (encolure inclinee, pattes fines, +// corps allonge), pas le nombre de facettes de son flanc. +void appendBox(MeshData& mesh, const glm::vec3& min, const glm::vec3& max, + const glm::vec3& color) { + const glm::vec3 p000{min.x, min.y, min.z}; + const glm::vec3 p100{max.x, min.y, min.z}; + const glm::vec3 p110{max.x, max.y, min.z}; + const glm::vec3 p010{min.x, max.y, min.z}; + const glm::vec3 p001{min.x, min.y, max.z}; + const glm::vec3 p101{max.x, min.y, max.z}; + const glm::vec3 p111{max.x, max.y, max.z}; + const glm::vec3 p011{min.x, max.y, max.z}; + + // -Z et +Z + appendFacet(mesh, p000, p110, p100, color); + appendFacet(mesh, p000, p010, p110, color); + appendFacet(mesh, p001, p101, p111, color); + appendFacet(mesh, p001, p111, p011, color); + // -X et +X + appendFacet(mesh, p000, p001, p011, color); + appendFacet(mesh, p000, p011, p010, color); + appendFacet(mesh, p100, p111, p101, color); + appendFacet(mesh, p100, p110, p111, color); + // -Y et +Y + appendFacet(mesh, p000, p100, p101, color); + appendFacet(mesh, p000, p101, p001, color); + appendFacet(mesh, p010, p011, p111, color); + appendFacet(mesh, p010, p111, p110, color); +} + +// Une boite INCLINEE, decrite par deux sections rectangulaires successives le +// long d'un segment. C'est ce qui donne l'encolure : une boite droite y +// dessinerait une marche d'escalier entre le corps et la tete. +void appendTaperedLink(MeshData& mesh, const glm::vec3& from, float fromHalfWidth, + float fromHalfHeight, const glm::vec3& to, float toHalfWidth, + float toHalfHeight, const glm::vec3& color) { + // Les sections restent verticales (leur normale n'est pas l'axe du + // segment) : approximation assumee, invisible sur un tronc de cone de + // 30 cm, et elle evite d'avoir a construire un repere orthonorme complet. + const auto section = [](const glm::vec3& centre, float halfWidth, float halfHeight) { + return std::array{ + glm::vec3{centre.x, centre.y - halfHeight, centre.z - halfWidth}, + glm::vec3{centre.x, centre.y - halfHeight, centre.z + halfWidth}, + glm::vec3{centre.x, centre.y + halfHeight, centre.z + halfWidth}, + glm::vec3{centre.x, centre.y + halfHeight, centre.z - halfWidth}, + }; + }; + + const auto a = section(from, fromHalfWidth, fromHalfHeight); + const auto b = section(to, toHalfWidth, toHalfHeight); + + for (int i = 0; i < 4; ++i) { + const int j = (i + 1) % 4; + appendFacet(mesh, a[static_cast(i)], b[static_cast(i)], + b[static_cast(j)], color); + appendFacet(mesh, a[static_cast(i)], b[static_cast(j)], + a[static_cast(j)], color); + } + // Bouchons : sans eux, on voit l'interieur du volume par les deux bouts. + appendFacet(mesh, a[0], a[2], a[1], color); + appendFacet(mesh, a[0], a[3], a[2], color); + appendFacet(mesh, b[0], b[1], b[2], color); + appendFacet(mesh, b[0], b[2], b[3], color); +} + +} // namespace + +MeshData animalMeshData() { + MeshData mesh; + mesh.name = "cervide synthetique (Phase 17)"; + + // Repere : +X vers l'avant (museau), +Y vers le haut, y = 0 aux sabots. + // Toutes les cotes sont en metres et tiennent dans l'enveloppe annoncee par + // kAnimalLength / kAnimalHeight / kAnimalWidth. + constexpr float kLegHeight = 0.46f; // hauteur du ventre + constexpr float kBodyTop = 0.78f; // ligne du dos + constexpr float kHalfWidth = 0.5f * kAnimalWidth; + constexpr float kLegHalf = 0.045f; // demi-section d'une patte + + // --- Corps : de la croupe (x negatif) au poitrail -------------------- + appendBox(mesh, { -0.62f, kLegHeight, -kHalfWidth }, + { 0.24f, kBodyTop, kHalfWidth }, kCoatColor); + // Ventre plus clair, en tranche mince sous le corps : c'est ce contraste + // qui empeche le corps de se lire comme une simple caisse. + appendBox(mesh, { -0.60f, kLegHeight - 0.03f, -kHalfWidth + 0.04f }, + { 0.22f, kLegHeight + 0.06f, kHalfWidth - 0.04f }, kBellyColor); + + // --- Encolure : du poitrail vers l'avant et le haut ------------------ + appendTaperedLink(mesh, { 0.20f, 0.70f, 0.0f }, 0.10f, 0.11f, + { 0.46f, 0.92f, 0.0f }, 0.07f, 0.07f, kCoatColor); + + // --- Tete : petite boite allongee, museau vers +X -------------------- + appendBox(mesh, { 0.40f, 0.86f, -0.065f }, + { 0.68f, 1.02f, 0.065f }, kHeadColor); + // Oreilles : deux ecailles plates de part et d'autre du crane. Trois + // triangles chacune, et elles font enormement pour la lisibilite de + // l'espece a distance. + for (const float side : { -1.0f, 1.0f }) { + const glm::vec3 root{ 0.46f, 1.00f, side * 0.06f }; + const glm::vec3 tip { 0.42f, kAnimalHeight, side * 0.15f }; + const glm::vec3 back{ 0.52f, 1.00f, side * 0.06f }; + appendFacet(mesh, root, tip, back, kHeadColor); + appendFacet(mesh, root, back, tip, kHeadColor); // dos de l'oreille + } + + // --- Quatre pattes ---------------------------------------------------- + // Anterieures sous le poitrail, posterieures sous la croupe, ecartees de + // part et d'autre de l'axe. Une patte est une boite verticale mince : a + // cette echelle, un membre articule ne se verrait pas. + for (const float x : { 0.10f, -0.48f }) { + for (const float side : { -1.0f, 1.0f }) { + const float z = side * (kHalfWidth - 0.07f); + appendBox(mesh, { x - kLegHalf, 0.0f, z - kLegHalf }, + { x + kLegHalf, kLegHeight + 0.02f, z + kLegHalf }, + kLegColor); + } + } + + // --- Queue : courte, claire, dressee --------------------------------- + // Le miroir blanc du chevreuil. C'est le detail qui rend une FUITE lisible : + // c'est la tache qu'on voit s'eloigner. + // Elle s'arrete NET avant le museau en valeur absolue (0,66 contre 0,68) : + // c'est ce qui permet de dire, en lisant les seuls sommets, de quel cote + // l'animal regarde - et c'est ce que verifie le test de convention. + appendBox(mesh, { -0.66f, kBodyTop - 0.14f, -0.05f }, + { -0.56f, kBodyTop + 0.02f, 0.05f }, kBellyColor); + + return mesh; +} + +} // namespace vercora diff --git a/src/world/AnimalMesh.hpp b/src/world/AnimalMesh.hpp new file mode 100644 index 0000000..40dc32d --- /dev/null +++ b/src/world/AnimalMesh.hpp @@ -0,0 +1,45 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +namespace vercora { + +// Geometrie synthetique bas-poly de la faune (Phase 17), generee EN CODE comme +// l'arbre, la souche, le galet et l'eclat : aucun fichier, aucun +// telechargement. +// +// --- Convention ------------------------------------------------------------ +// Dimensions ABSOLUES (comme la pierre et la buche, pas comme l'arbre) : un +// chevreuil fait la meme taille partout. Le mesh est pose PIEDS AU SOL (y = 0 +// au bas des sabots) et regarde vers +X. +// +// Une instance se place donc par +// translate(pieds) * rotateY(-cap) * scale(facteur) +// ou le facteur est une echelle UNIFORME proche de 1 (voir Animal::scale) : la +// rotation suivie d'une echelle uniforme laisse mat3(model) valide comme normal +// matrix, exactement comme pour l'arbre. +// +// Le -cap vient de la convention deja posee par le velo : une rotation de theta +// autour de +Y envoie le +X local sur (cos theta, -sin theta) dans le plan +// (x, z) ; pour l'envoyer sur le cap (cos h, sin h), il faut theta = -h. +// +// --- Pourquoi un seul mesh ------------------------------------------------- +// Une seule silhouette de quadrupede pour toute la faune de cette session. Ce +// n'est pas un choix esthetique, c'est le perimetre annonce : la Phase 17 +// construit la BOUCLE (presence -> derangement -> absence), pas un bestiaire. +// Plusieurs especes se feront en ajoutant des meshes et un champ d'espece a +// Animal, sans toucher a la logique. + +// Un cervide bas-poly : corps, encolure, tete, quatre pattes, queue. Facette +// (une normale par triangle) comme le galet - a cette densite de triangles, des +// normales lissees rendraient la silhouette molle. +MeshData animalMeshData(); + +// Dimensions en unites monde, exposees parce que le placement et la fuite en +// ont besoin (hauteur d'oeil de l'animal, distance de securite, portee de +// visee eventuelle plus tard). +inline constexpr float kAnimalLength = 1.30f; // museau -> croupe +inline constexpr float kAnimalHeight = 1.05f; // sabots -> sommet de la tete +inline constexpr float kAnimalWidth = 0.42f; + +} // namespace vercora diff --git a/src/world/Bike.cpp b/src/world/Bike.cpp new file mode 100644 index 0000000..90cdc7d --- /dev/null +++ b/src/world/Bike.cpp @@ -0,0 +1,219 @@ +#include "world/Bike.hpp" + +#include "core/CollisionSolver.hpp" +#include "core/HeightSampler.hpp" + +#include +#include + +namespace vercora { + +namespace { + +// Pesanteur, en m/s^2. Le reste du jeu travaille en metres depuis la Phase 7 +// (donnees LiDAR), la valeur reelle a donc un sens ici. +constexpr float kGravity = 9.81f; + +// En dessous de cette vitesse, un velo qui RALENTIT est considere a l'arret : on +// annule la vitesse au lieu de laisser un residu qui ferait deriver la position +// d'un millimetre par seconde indefiniment. +// +// Le "qui ralentit" n'est pas un detail : applique inconditionnellement, ce +// seuil empeche tout DEMARRAGE dont l'acceleration est inferieure a +// kSpeedEpsilon / dt (1,2 m/s^2 a 60 images/s). Constate directement - le velo +// restait cloue a 0 km/h des 10 % de montee, et ne pouvait pas non plus se +// laisser descendre une pente de 10 % en roue libre, alors que le bilan des +// accelerations etait franchement positif dans les deux cas. +constexpr float kSpeedEpsilon = 0.02f; + +} // namespace + +Bike::Bike(const BikeParams& params) : params_(params) {} + +glm::vec3 Bike::forward() const { + const float rad = glm::radians(heading_); + return glm::vec3(std::cos(rad), 0.0f, std::sin(rad)); +} + +glm::vec3 Bike::right() const { + // cross(forward, worldUp) avec forward = (cos, 0, sin) : (-sin, 0, cos). + const float rad = glm::radians(heading_); + return glm::vec3(-std::sin(rad), 0.0f, std::cos(rad)); +} + +glm::vec2 Bike::terrainGradient(const HeightSampler& terrain) const { + const float s = params_.slopeSampleStep; + // Differences finies CENTREES : deux fois plus precises qu'une difference + // avant pour le meme nombre de points, et surtout SYMETRIQUES - une + // difference avant donnerait une pente differente selon le sens de marche + // sur le meme sentier, ce qui se sentirait a l'aller-retour. + const float hxPlus = terrain.heightAt(position_.x + s, position_.z); + const float hxMinus = terrain.heightAt(position_.x - s, position_.z); + const float hzPlus = terrain.heightAt(position_.x, position_.z + s); + const float hzMinus = terrain.heightAt(position_.x, position_.z - s); + return glm::vec2((hxPlus - hxMinus) / (2.0f * s), (hzPlus - hzMinus) / (2.0f * s)); +} + +float Bike::slopeAlongHeading(const HeightSampler& terrain) const { + const glm::vec2 gradient = terrainGradient(terrain); + const glm::vec3 f = forward(); + return gradient.x * f.x + gradient.y * f.z; +} + +void Bike::mount(const glm::vec3& position, float headingDegrees, + const HeightSampler& terrain) { + position_ = position; + heading_ = headingDegrees; + // Contact permanent : la verticale n'est jamais une variable d'etat du velo, + // elle est TOUJOURS relue du terrain. C'est vrai des la premiere frame, sans + // quoi enfourcher le velo depuis une camera en vol libre le ferait apparaitre + // suspendu. + position_.y = terrain.heightAt(position_.x, position_.z) + params_.eyeHeight; + speed_ = 0.0f; // pas de demarrage lance : on part a l'arret + pitch_ = 0.0f; + roll_ = 0.0f; + riding_ = true; +} + +void Bike::update(float deltaTime, float steerInput, float pedalInput, float brakeInput, + const HeightSampler& terrain, const CollisionSolver* obstacles, + float wetness) { + if (!riding_ || deltaTime <= 0.0f) { + return; + } + + steerInput = std::clamp(steerInput, -1.0f, 1.0f); + pedalInput = std::clamp(pedalInput, 0.0f, 1.0f); + brakeInput = std::clamp(brakeInput, 0.0f, 1.0f); + + // PHASE 23 : etat du sol. Deux coefficients, aucun etat ajoute - voir + // BikeParams::wetRollingGain pour ce que ce modele fait et ne fait pas. + const float wet = std::isfinite(wetness) ? std::clamp(wetness, 0.0f, 1.0f) : 0.0f; + + // ----------------------------------------------------------------------- + // 1. Direction. Rayon de braquage fini, et qui GRANDIT avec la vitesse. + // ----------------------------------------------------------------------- + // La vitesse angulaire tenable est celle qui n'excede pas l'adherence : + // a_lat = omega * v <= maxLateralAccel => omega <= maxLateralAccel / v + // Elle est donc INVERSEMENT proportionnelle a la vitesse : a 10 m/s le velo + // ne tourne qu'a 23 deg/s (rayon 25 m), a 5 m/s a 46 deg/s (rayon 6,3 m). + // Le plafond maxTurnRateDegPerSec ne mord qu'a tres basse vitesse, ou la + // formule diverge - c'est la manoeuvre pieds a terre, pas un virage. + const float gripTurnRate = params_.maxLateralAccel / std::max(speed_, 1e-3f); + const float turnRate = std::min(gripTurnRate, + glm::radians(params_.maxTurnRateDegPerSec)); + const float yawRate = steerInput * turnRate; // rad/s, > 0 = a droite + heading_ += glm::degrees(yawRate) * deltaTime; + + // ----------------------------------------------------------------------- + // 2. Dynamique longitudinale. Somme d'accelerations, INTEGREE : aucun terme + // n'agit sur la vitesse instantanement, ni le pedalage ni le frein. + // ----------------------------------------------------------------------- + const float slopeTan = slopeAlongHeading(terrain); + // La composante de la pesanteur le long de la pente vaut g * sin(theta), pas + // g * tan(theta) : sur une paroi LiDAR a 300 % la difference est un facteur + // trois, et tan() divergerait. sin = tan / sqrt(1 + tan^2). + const float slopeSin = slopeTan / std::sqrt(1.0f + slopeTan * slopeTan); + const float gravityAccel = -kGravity * slopeSin; // < 0 en montee + + float accel = gravityAccel; + + if (brakeInput > 0.0f) { + // Freiner et pedaler en meme temps n'a pas de sens : le frein l'emporte. + accel -= params_.brakeDeceleration * (1.0f - params_.wetBrakingLoss * wet) * brakeInput; + } else { + const float pedalFade = + std::max(0.0f, 1.0f - speed_ / params_.pedalSpeedLimit); + accel += params_.pedalAcceleration * pedalInput * pedalFade; + } + + // Resistances : toujours opposees au mouvement. Elles s'appliquent aussi a + // l'arret, et c'est ce qui empeche le velo de se mettre a rouler seul sur + // une pente insuffisante (l'ecretage a zero juste apres s'en charge). + accel -= params_.rollingResistance * (1.0f + params_.wetRollingGain * wet) + + params_.dragCoefficient * speed_ * speed_; + + speed_ += accel * deltaTime; + speed_ = std::clamp(speed_, 0.0f, params_.maxSpeed); + // Seuil d'ARRET, pas seuil de mouvement : on ne l'applique que si le bilan + // des accelerations est negatif, sinon il tuerait le demarrage (voir + // kSpeedEpsilon). + if (speed_ < kSpeedEpsilon && accel <= 0.0f) { + speed_ = 0.0f; + } + + // ----------------------------------------------------------------------- + // 3. Deplacement horizontal, puis OBSTACLES, puis contact avec le sol. + // Meme ordre que Camera::update en mode marche, et pour la meme raison : + // l'inverse laisserait le velo a l'altitude de l'endroit ou il VOULAIT + // aller et non de celui ou il a fini. + // ----------------------------------------------------------------------- + const glm::vec3 previousPosition = position_; + const glm::vec3 step = forward() * speed_ * deltaTime; + position_ += step; + + if (obstacles != nullptr) { + BodyCylinder body; + body.position = position_; + body.radius = params_.bodyRadius; + // Meme bande verticale que le joueur a pied (Camera::resolveCollisions) : + // c'est ce qui fait qu'une souche basse arrete le velo comme elle arrete + // les jambes, sans avoir a la traiter a part. + body.feetY = position_.y - params_.eyeHeight; + body.headY = position_.y + 0.15f; + + // moveBody() et non resolve() : c'est le point d'entree UNIQUE de la + // collision du projet, celui que la camera et les tests empruntent deja. + // Rien n'est reecrit ici. + const glm::vec3 corrected = moveBody(*obstacles, body, previousPosition); + position_.x = corrected.x; + position_.z = corrected.z; + + // Le choc coute de la vitesse, proportionnellement a ce que l'obstacle a + // mange du pas. 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. + const float desired = std::sqrt(step.x * step.x + step.z * step.z); + if (desired > 1e-4f) { + const float dx = position_.x - previousPosition.x; + const float dz = position_.z - previousPosition.z; + const float actual = std::sqrt(dx * dx + dz * dz); + speed_ *= std::clamp(actual / desired, 0.0f, 1.0f); + if (speed_ < kSpeedEpsilon) { + speed_ = 0.0f; + } + } + } + + // Contact PERMANENT avec la surface : la verticale n'est pas integree, elle + // est imposee. Un velo ne decolle pas d'une bosse dans ce modele. + position_.y = terrain.heightAt(position_.x, position_.z) + params_.eyeHeight; + + // ----------------------------------------------------------------------- + // 4. Assiette VISUELLE. N'entre dans aucun calcul physique. + // ----------------------------------------------------------------------- + const glm::vec2 gradient = terrainGradient(terrain); + const glm::vec3 f = forward(); + const glm::vec3 r = right(); + + // Tangage : le nez suit la pente le long du cap. atan d'une tangente. + const float alongTan = gradient.x * f.x + gradient.y * f.z; + pitch_ = glm::degrees(std::atan(alongTan)); + + // Roulis, deux causes qui s'ajoutent : + // - le DEVERS : si le sol monte a droite, le velo penche a gauche, donc + // un roulis negatif (positif = penche a droite, cf. l'en-tete) ; + // - le VIRAGE : le cycliste s'incline vers l'interieur de l'angle + // d'equilibre atan(a_lat / g), exactement comme un vrai deux-roues. + const float crossTan = gradient.x * r.x + gradient.y * r.z; + const float bankFromSlope = -glm::degrees(std::atan(crossTan)); + const float lateralAccel = yawRate * speed_; // > 0 = vers la droite + const float bankFromTurn = glm::degrees(std::atan(lateralAccel / kGravity)); + + roll_ = std::clamp(bankFromSlope + bankFromTurn, + -params_.maxVisualTiltDegrees, params_.maxVisualTiltDegrees); + pitch_ = std::clamp(pitch_, -params_.maxVisualTiltDegrees, + params_.maxVisualTiltDegrees); +} + +} // namespace vercora diff --git a/src/world/Bike.hpp b/src/world/Bike.hpp new file mode 100644 index 0000000..91640f2 --- /dev/null +++ b/src/world/Bike.hpp @@ -0,0 +1,287 @@ +#pragma once + +#include + +namespace vercora { + +class HeightSampler; +class CollisionSolver; + +// Modele de VTT simplifie (Phase 13), dans le meme esprit que world/Paraglider : +// pas une simulation de dynamique du vehicule - pas de suspension, pas de +// transfert de charge, pas de rapport de vitesses, pas d'adherence variable - +// juste de quoi rouler, monter, descendre, tourner et freiner de facon credible. +// +// Le modele longitudinal tient en une somme d'accelerations, integree a chaque +// pas de temps (donc AUCUN changement instantane de vitesse) : +// +// a = a_gravite(pente) + a_pedalage(vitesse) - a_frein - a_resistances(vitesse) +// +// Chaque terme est justifie et chiffre ci-dessous. Les vitesses d'equilibre qui +// en decoulent sont dans NOTES-PHASE-VELO.md et VERIFIEES par les tests +// headless (tests/logic_tests.cpp, section Phase 13) : c'est la que se lit le +// comportement reellement obtenu, pas seulement celui vise. +struct BikeParams { + // --- Motricite ----------------------------------------------------------- + + // Acceleration disponible au pedalage a l'arret, en m/s^2. 2,6 m/s^2 sur un + // VTT charge (~95 kg avec le cycliste) correspond a ~250 W au demarrage, + // c'est-a-dire un cycliste ordinaire en danseuse, pas un sprinter. + // + // C'est ce terme, confronte a la pesanteur, qui fixe la PENTE MAXIMALE + // FRANCHISSABLE : le velo cale des que g*sin(theta) depasse + // pedalAcceleration - rollingResistance, soit **23,6 % de pente**. Au-dela + // il faut zigzaguer (le modele lit la pente LE LONG DU CAP, pas la pente + // maximale : traverser en biais reduit reellement l'effort) ou mettre pied a + // terre. C'est voulu - un sentier a 25 % se monte a pied - mais c'est le + // parametre a revoir en premier si la zone de jeu se revele trop verrouillee. + float pedalAcceleration = 2.6f; + + // Vitesse a laquelle le pedalage ne pousse plus du tout, en m/s. Le terme de + // poussee est pedalAcceleration * (1 - v / pedalSpeedLimit) : c'est la facon + // la plus simple de representer qu'a haute vitesse la cadence s'emballe et + // que le cycliste ne developpe plus d'effort utile. 6,5 m/s = 23,4 km/h. + // + // Ce n'est PAS la vitesse de pointe sur le plat : les resistances ci-dessous + // en retirent encore, et l'equilibre reel tombe vers 4,6 m/s (16,6 km/h). + float pedalSpeedLimit = 6.5f; + + // --- Resistances --------------------------------------------------------- + + // Resistance au roulement, en m/s^2 (constante, independante de la vitesse). + // 0,35 m/s^2 correspond a un coefficient de ~0,036 : un pneu large a basse + // pression sur un chemin de terre, soit cinq a dix fois une roue de route + // sur bitume. C'est ce terme qui empeche le velo de descendre tout seul une + // pente tres faible. + float rollingResistance = 0.35f; + + // Terme quadratique, en 1/m : la deceleration vaut dragCoefficient * v^2. + // + // ATTENTION, c'est un terme GROUPE et non la seule trainee aerodynamique. + // L'aero pure d'un cycliste redresse vaut ~0,004 /m ; on prend 0,014, soit + // trois fois plus, pour representer d'un seul coup ce que ce modele ne + // simule pas : sol irregulier, pompage de la suspension, et surtout le fait + // qu'un vrai vetetiste ne laisse pas filer sa machine sur un sentier. + // + // C'est ce coefficient qui FIXE les vitesses de pointe en descente, et c'est + // pour ca qu'il est le parametre le plus arbitraire du modele. A 20 % de + // pente il donne 10,6 m/s (38 km/h), a 30 % 13,3 m/s (48 km/h) : la + // fourchette VTT visee. + float dragCoefficient = 0.014f; + + // --- Freinage ------------------------------------------------------------ + + // Deceleration au frein a fond, en m/s^2. 6,0 m/s^2 ~ 0,61 g : c'est a peu + // pres la limite avant le passage par-dessus le guidon sur un VTT, et bien + // au-dela de ce que le terme de resistance seul peut faire. Le freinage + // demande est PROGRESSIF (brakeInput dans [0, 1]). + float brakeDeceleration = 6.0f; + + // --- PHASE 23 : etat du sol --------------------------------------------- + // + // Un sol detrempe roule plus mal et freine moins bien. C'est un modele + // DELIBEREMENT MINIMAL - une seule grandeur, l'humidite dans [0, 1], et deux + // coefficients - et le cahier des charges laissait le choix entre ca et le + // reporter a plus tard. Il est fait parce qu'il ne demande aucune donnee + // nouvelle (WeatherSample::wetness existe deja) et parce qu'il se branche sur + // des termes qui existent deja dans l'equation du mouvement, sans y ajouter + // le moindre etat. + // + // CE QU'IL NE FAIT PAS, et c'est note comme amelioration future dans + // NOTES-PHASE23.md : aucune nature de sol (terre, roche, herbe - le LiDAR + // n'en porte aucune, voir la limite deja etablie en Phase 22 pour les + // gisements), aucune boue qui se formerait et secherait par endroits, 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). + // + // VALEURS PROVISOIRES. + + // Surcout de resistance au roulement sur sol detrempe, en fraction. 0,45 : + // une piste boueuse coute la moitie de resistance en plus qu'une piste + // seche. + float wetRollingGain = 0.45f; + + // Perte de freinage sur sol detrempe, en fraction. 0,30 : on freine 30 % moins + // fort, ce qui est la partie qui SE SENT en descente. + float wetBrakingLoss = 0.30f; + + // --- Plafond ------------------------------------------------------------- + + // Vitesse maximale absolue, en m/s. 13,9 m/s = 50,0 km/h, le haut de la + // fourchette demandee. Ce n'est PAS le regulateur habituel du modele : les + // resistances y parviennent seules jusqu'a ~32 % de pente. Au-dela, ce + // plafond prend le relais plutot que de laisser la vitesse diverger sur une + // paroi LiDAR (la zone de jeu a des pentes locales bien pires que 32 %). + float maxSpeed = 13.9f; + + // --- Direction ----------------------------------------------------------- + + // Acceleration laterale maximale en virage, en m/s^2. 4,0 m/s^2 ~ 0,41 g : + // l'adherence d'un pneu large sur terre seche, franchement en dessous de ce + // que tient un pneu de route sur bitume. + // + // C'est ce qui donne un RAYON DE BRAQUAGE COHERENT : le rayon stabilise vaut + // R = v^2 / maxLateralAccel, donc 6,3 m a 5 m/s et 25 m a 10 m/s. La vitesse + // angulaire correspondante est maxLateralAccel / v, donc elle DIMINUE quand + // la vitesse monte - impossible de pivoter sur place a pleine vitesse. + float maxLateralAccel = 4.0f; + + // Plafond de vitesse angulaire, en degres/seconde. Necessaire parce que la + // formule ci-dessus diverge a l'arret (R = 0). 140 deg/s est la vitesse a + // laquelle un cycliste presque immobile peut replacer sa machine avec les + // pieds - c'est ce qui evite de rester coince nez dans une pente trop raide. + float maxTurnRateDegPerSec = 140.0f; + + // --- Geometrie ----------------------------------------------------------- + + // Demi-largeur du velo pour la COLLISION, en unites monde. 0,45 m contre + // 0,35 m pour le joueur a pied (Camera::bodyRadius_) : un guidon est plus + // large que des epaules. Volontairement en dessous de la demi-largeur reelle + // d'un guidon (~0,37 m) plus la roue : on ne cherche pas a accrocher un + // tronc du bout du cintre, on cherche a ne pas le traverser. + float bodyRadius = 0.45f; + + // Hauteur de l'oeil au-dessus du sol une fois en selle, en unites monde. + // Meme valeur que la marche (kDefaultEyeHeight) : assis sur une selle de + // VTT, les yeux sont a peu pres a la meme hauteur que debout. La valeur + // vient de l'appelant pour que world/ ne dependent pas de core/Camera.hpp. + float eyeHeight = 1.7f; + + // Demi-base des differences finies centrees utilisees pour mesurer la pente + // locale, en metres. La pente est donc lue sur 2 x slopeSampleStep. + // + // 1,0 m - le pas de la heightmap - PARAIT le choix evident et ne marche pas. + // Mesure faite sur un versant reel de la dalle LHD_0907_6440 (200 m plein + // nord depuis E 907172 / N 6439790, qui descend de 26,7 % en moyenne) : + // + // 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 (le reglage retenu, differences a +/-2 m) + // 4 m | 14,0 % | 1,6 % | +1,1 % + // + // A 1 m, une descente franche presente donc 8 % de micro-sections montantes + // a plus de 20 % : de quoi CALER le velo (la pente maximale franchissable + // est de 23,6 %) au beau milieu d'un devers qui descend. Constate en jeu : + // le velo s'immobilisait definitivement sur un versant a -27 %. + // + // 2,0 m (base de 4 m) ramene ces sections 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, d'ou l'arret ici. + float slopeSampleStep = 2.0f; + + // Inclinaison visuelle maximale, en degres, dans les deux axes. Sert + // uniquement d'ecretage d'affichage : une paroi LiDAR verticale donnerait + // sinon un marqueur couche a plat. + float maxVisualTiltDegrees = 45.0f; +}; + +// Position, cap, vitesse et assiette d'une sortie a velo. +// +// Comme Paraglider, cette classe ne connait NI Vulkan NI la Camera : elle +// produit une position, un cap et deux angles d'assiette, et c'est l'appelant +// (main.cpp) qui en tire une pose de camera a la troisieme personne via +// Camera::setChasePose(). +// +// Deux differences de fond avec le parapente, toutes deux voulues : +// - le velo est TOUJOURS en contact avec le sol : sa position verticale n'est +// pas integree, elle est IMPOSEE par heightAt() a chaque pas. Il n'y a donc +// ni saut, ni chute, ni decollage sur une bosse ; +// - le velo respecte les OBSTACLES, via le meme core/CollisionSolver et la meme +// fonction moveBody() que le joueur a pied. Aucune logique de collision n'est +// reecrite ici. +class Bike { +public: + explicit Bike(const BikeParams& params = {}); + + const BikeParams& params() const { return params_; } + + // Enfourche le velo a la position et au cap donnes (degres, convention + // Camera : 0 = +X, 90 = +Z). La position est immediatement recollee au + // terrain, donc l'appelant n'a pas a fournir un Y correct : seuls X et Z + // comptent. La vitesse part de zero - pas de demarrage lance. + void mount(const glm::vec3& position, float headingDegrees, + const HeightSampler& terrain); + + // Descend de velo. Ne deplace pas la position : c'est a l'appelant d'y + // reposer le joueur (voir main.cpp), exactement comme pour Paraglider. + void dismount() { riding_ = false; } + + // Fait avancer la simulation d'un pas de temps. + // + // steerInput dans [-1, 1] : -1 = a gauche, +1 = a droite + // pedalInput dans [0, 1] : effort de pedalage + // brakeInput dans [0, 1] : freinage manuel. PRIORITAIRE sur le pedalage + // (on ne pedale pas en freinant). + // terrain : impose l'altitude ET fournit la pente. Obligatoire. + // obstacles : arbres et souches. nullptr = on traverse tout, comme la + // camera sans solveur. + // + // Les entrees sont ecretees en interne : l'appelant peut passer des valeurs + // brutes de touches (0/1) sans y penser, comme Paraglider::update. + // + // PHASE 23 - wetness : humidite du sol dans [0, 1] (0 = sec), tiree de + // WeatherSample::wetness. Valeur par defaut 0 : tous les appelants ecrits + // avant la Phase 23 - dont les tests de la Phase 13, qui verifient des + // vitesses d'equilibre au centieme - decrivent exactement la meme physique. + void update(float deltaTime, float steerInput, float pedalInput, float brakeInput, + const HeightSampler& terrain, const CollisionSolver* obstacles, + float wetness = 0.0f); + + bool riding() const { return riding_; } + const glm::vec3& position() const { return position_; } + float headingDegrees() const { return heading_; } + + // Vitesse le long du sol, en m/s (toujours >= 0 : ce modele ne recule pas). + float speed() const { return speed_; } + + // Vitesse en km/h - la seule unite dans laquelle une vitesse de velo se lit, + // et donc celle des journaux et des tests. + float speedKmh() const { return speed_ * 3.6f; } + + // Assiette VISUELLE, en degres. Ne retroagit sur rien : c'est l'inclinaison + // du marqueur, pas un etat physique. + // pitch > 0 : nez leve, le velo monte ; + // roll > 0 : le velo penche sur la DROITE du cycliste. + // Le roulis somme deux causes : la pente en travers (le velo epouse le + // devers) et l'inclinaison en virage (angle d'equilibre atan(a_lat / g)). + float pitchDegrees() const { return pitch_; } + float rollDegrees() const { return roll_; } + + // Direction horizontale unitaire du cap courant. Meme convention que + // Paraglider::forward(). + glm::vec3 forward() const; + + // Direction horizontale unitaire a la droite du cycliste. Meme construction + // que Camera::right_ (cross(front, worldUp)). + glm::vec3 right() const; + + // Pente le long du cap, en RISE PAR METRE HORIZONTAL (donc une tangente : + // 0,20 = 20 % = 11,3 degres). Positive en montee. Exposee parce que c'est + // l'entree qui explique toute la dynamique longitudinale, et qu'un test qui + // ne pourrait pas la lire devrait la redemontrer a l'envers. + float slopeAlongHeading(const HeightSampler& terrain) const; + +private: + // Gradient de la surface au point courant, par differences finies centrees. + // .x = dh/dx, .y = dh/dz (rise par metre horizontal). + glm::vec2 terrainGradient(const HeightSampler& terrain) const; + + BikeParams params_; + + glm::vec3 position_{0.0f}; // hauteur d'OEIL, comme Camera::position_ + float heading_ = 0.0f; // degres, convention Camera : 0 = +X, 90 = +Z + + float speed_ = 0.0f; // m/s, toujours >= 0 + + float pitch_ = 0.0f; // degres, visuel seulement + float roll_ = 0.0f; // degres, visuel seulement + + bool riding_ = false; +}; + +} // namespace vercora diff --git a/src/world/BushMesh.cpp b/src/world/BushMesh.cpp new file mode 100644 index 0000000..3fbd4b0 --- /dev/null +++ b/src/world/BushMesh.cpp @@ -0,0 +1,140 @@ +#include "world/BushMesh.hpp" + +#include + +#include +#include +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; + +// Couleurs : feuillage vert moyen un peu jaune pour le buisson (feuillus bas, +// genevrier), vert sombre pour le jeune resineux ; bois brun gris. +const glm::vec3 kShrubLeaves{0.27f, 0.37f, 0.17f}; +const glm::vec3 kConiferLeaves{0.15f, 0.29f, 0.14f}; +const glm::vec3 kWood{0.33f, 0.26f, 0.19f}; + +void appendFacet(MeshData& mesh, const glm::vec3& a, const glm::vec3& b, const glm::vec3& c, + const glm::vec3& color) { + const glm::vec3 raw = glm::cross(b - a, c - a); + const float length = glm::length(raw); + if (length < 1e-9f) { return; } + const glm::vec3 normal = raw / length; + const auto base = static_cast(mesh.vertices.size()); + for (const glm::vec3& p : { a, b, c }) { + Vertex v{}; + v.pos = p; + v.color = color; + v.normal = normal; + v.uv = { 0.5f, glm::clamp(p.y, 0.0f, 1.0f) }; + mesh.vertices.push_back(v); + } + mesh.indices.insert(mesh.indices.end(), { base, base + 1, base + 2 }); +} + +float hashUnit(uint32_t v) { + v ^= v >> 16; v *= 0x7feb352du; + v ^= v >> 15; v *= 0x846ca68bu; + v ^= v >> 16; + return static_cast(v >> 8) * (1.0f / 16777216.0f); +} + +// Octaedre subdivise une fois (32 faces), bossele de +/- 7 %, puis etire en +// ellipsoide de rayons `radii` autour de `center`. Faces vers l'exterieur. +void appendLobe(MeshData& mesh, const glm::vec3& center, const glm::vec3& radii, uint32_t seed, + const glm::vec3& color) { + std::vector p = { { 1, 0, 0 }, { -1, 0, 0 }, { 0, 1, 0 }, + { 0, -1, 0 }, { 0, 0, 1 }, { 0, 0, -1 } }; + const std::array, 8> octa = { { {0, 2, 4}, {2, 1, 4}, {1, 3, 4}, {3, 0, 4}, + {2, 0, 5}, {1, 2, 5}, {3, 1, 5}, {0, 3, 5} } }; + std::vector> faces; + auto mid = [&](uint32_t a, uint32_t b) { + const glm::vec3 m = glm::normalize(p[a] + p[b]); + for (uint32_t i = 6; i < p.size(); ++i) { + if (glm::length(p[i] - m) < 1e-5f) { return i; } + } + p.push_back(m); + return static_cast(p.size() - 1); + }; + for (const auto& f : octa) { + const uint32_t ab = mid(f[0], f[1]), bc = mid(f[1], f[2]), ca = mid(f[2], f[0]); + faces.push_back({ f[0], ab, ca }); + faces.push_back({ ab, f[1], bc }); + faces.push_back({ ca, bc, f[2] }); + faces.push_back({ ab, bc, ca }); + } + std::vector q(p.size()); + for (std::size_t i = 0; i < p.size(); ++i) { + const float bump = 0.93f + 0.14f * hashUnit(seed * 131u + static_cast(i) * 7919u); + q[i] = center + p[i] * radii * bump; + } + for (const auto& f : faces) { + appendFacet(mesh, q[f[0]], q[f[1]], q[f[2]], color); + } +} + +// Prisme (sides faces laterales) d'axe Y, de y0 a y1, rayons r0 -> r1. +void appendPrism(MeshData& mesh, float y0, float y1, float r0, float r1, int sides, + const glm::vec3& color) { + for (int i = 0; i < sides; ++i) { + const float a0 = kTwoPi * static_cast(i) / static_cast(sides); + const float a1 = kTwoPi * static_cast(i + 1) / static_cast(sides); + const glm::vec3 b0(r0 * std::cos(a0), y0, r0 * std::sin(a0)); + const glm::vec3 b1(r0 * std::cos(a1), y0, r0 * std::sin(a1)); + const glm::vec3 t0(r1 * std::cos(a0), y1, r1 * std::sin(a0)); + const glm::vec3 t1(r1 * std::cos(a1), y1, r1 * std::sin(a1)); + appendFacet(mesh, b0, t0, t1, color); + appendFacet(mesh, b0, t1, b1, color); + } +} + +// Cone ouvert (base + pointe), `sides` faces, avec son disque de base. +void appendCone(MeshData& mesh, float yBase, float yApex, float radius, float phase, int sides, + const glm::vec3& color) { + const glm::vec3 apex(0.0f, yApex, 0.0f); + const glm::vec3 centre(0.0f, yBase, 0.0f); + for (int i = 0; i < sides; ++i) { + const float a0 = phase + kTwoPi * static_cast(i) / static_cast(sides); + const float a1 = phase + kTwoPi * static_cast(i + 1) / static_cast(sides); + const glm::vec3 b0(radius * std::cos(a0), yBase, radius * std::sin(a0)); + const glm::vec3 b1(radius * std::cos(a1), yBase, radius * std::sin(a1)); + appendFacet(mesh, b0, apex, b1, color); // flanc, vers l'exterieur + appendFacet(mesh, b0, b1, centre, color); // dessous, vers le bas + } +} + +} // namespace + +MeshData shrubMeshData() { + MeshData mesh; + mesh.name = "buisson (phase 29)"; + // Souche courte, enterree de kBushBuriedDepth. + appendPrism(mesh, -kBushBuriedDepth, 0.30f, 0.06f, 0.04f, 5, kWood); + // Trois lobes : un central et deux lateraux plus bas. + appendLobe(mesh, { 0.00f, 0.52f, 0.00f }, { 0.46f, 0.44f, 0.46f }, 1u, kShrubLeaves); + appendLobe(mesh, { 0.24f, 0.36f, 0.12f }, { 0.34f, 0.31f, 0.34f }, 2u, kShrubLeaves * 0.92f); + appendLobe(mesh, { -0.20f, 0.35f, -0.18f }, { 0.32f, 0.30f, 0.32f }, 3u, kShrubLeaves * 1.06f); + // Normalisation : sommet exactement a 1 (l'echelle de l'instance = hauteur). + float top = 0.0f; + for (const Vertex& v : mesh.vertices) { top = std::max(top, v.pos.y); } + for (Vertex& v : mesh.vertices) { + if (v.pos.y > 0.0f) { v.pos.y /= top; } + } + return mesh; +} + +MeshData smallTreeMeshData() { + MeshData mesh; + mesh.name = "petit arbre (phase 29)"; + appendPrism(mesh, -kBushBuriedDepth, 0.30f, 0.055f, 0.04f, 6, kWood); + appendCone(mesh, 0.16f, 0.74f, 0.40f, 0.0f, 8, kConiferLeaves); + appendCone(mesh, 0.50f, 1.00f, 0.27f, 0.39f, 8, kConiferLeaves * 1.08f); + return mesh; +} + +} // namespace vercora diff --git a/src/world/BushMesh.hpp b/src/world/BushMesh.hpp new file mode 100644 index 0000000..a7ee9a2 --- /dev/null +++ b/src/world/BushMesh.hpp @@ -0,0 +1,28 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +namespace vercora { + +// PHASE 29 (Agent 3) : geometries des BUISSONS et PETITS ARBRES, generees en +// code (aucun fichier externe), a l'ECHELLE UNITE : hauteur totale 1 au-dessus +// de l'origine, qui est le pied pose sur le terrain. L'instance porte une +// echelle uniforme = la HAUTEUR du sujet en metres, tiree sous la carte de +// hauteur de la classe 3 LiDAR (voir world/Bushes.hpp). +// +// Deux variantes, choisies par la HAUTEUR (donnee), pas par l'exposition : +// - buisson arrondi : trois lobes bosseles aplatis sur une souche courte, +// plus large que haut (emprise ~1,3 x la hauteur) ; +// - petit arbre : tronc court + deux cones decales, silhouette de jeune +// resineux (pin a crochets / epicea juvenile de lisiere) - c'est la +// vegetation ligneuse qui depasse ~1,8 m hors couvert forestier. +MeshData shrubMeshData(); +MeshData smallTreeMeshData(); + +// Rayon d'emprise horizontale a l'echelle 1 (x hauteur en metres). +inline constexpr float kShrubFootprintRadius = 0.68f; +inline constexpr float kSmallTreeFootprintRadius = 0.40f; +// Partie enterree sous l'origine (x echelle) : pas de pied qui flotte en pente. +inline constexpr float kBushBuriedDepth = 0.08f; + +} // namespace vercora diff --git a/src/world/Bushes.cpp b/src/world/Bushes.cpp new file mode 100644 index 0000000..e960a5b --- /dev/null +++ b/src/world/Bushes.cpp @@ -0,0 +1,267 @@ +#include "world/Bushes.hpp" + +#include "core/Frustum.hpp" +#include "core/HeightSampler.hpp" +#include "world/BushMesh.hpp" + +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; +constexpr float kEdgeMargin = 10.0f; +constexpr float kTreeGridCell = 32.0f; + +// Memes primitives que Rocks.cpp / Vegetation.cpp (hachage sans etat). +uint32_t mix32(uint32_t v) { + v ^= v >> 16; v *= 0x7feb352du; + v ^= v >> 15; v *= 0x846ca68bu; + v ^= v >> 16; + return v; +} +uint32_t cellHash(int32_t cx, int32_t cz, uint32_t seed, uint32_t stream) { + uint32_t h = seed; + h = mix32(h ^ static_cast(cx) * 0x9E3779B1u); + h = mix32(h ^ static_cast(cz) * 0x85EBCA77u); + h = mix32(h ^ (stream * 0xC2B2AE3Du)); + return h; +} +float unitFloat(uint32_t h) { return static_cast(h >> 8) * (1.0f / 16777216.0f); } +float ramp(float v, float a, float b) { + if (b <= a) { return v >= b ? 1.0f : 0.0f; } + return std::clamp((v - a) / (b - a), 0.0f, 1.0f); +} + +} // namespace + +Bushes::Bushes(const HeightSampler& terrain, const HeightSampler* lowVeg, + const HeightSampler* lowVegHeight, const HeightSampler* cover, float terrainExtent, + const BushParams& params) + : terrain_(terrain), lowVeg_(lowVeg), lowVegHeight_(lowVegHeight), cover_(cover), + terrainExtent_(terrainExtent), params_(params) { + if (params_.cell <= 0.0f || params_.slots == 0) { + throw std::runtime_error("Bushes : cellule ou emplacements nuls."); + } + if (params_.heightMin <= 0.0f || params_.heightMin > params_.heightMax) { + throw std::runtime_error("Bushes : bornes de hauteur incoherentes."); + } + if (params_.lowVegMin >= params_.lowVegFull) { + throw std::runtime_error("Bushes : lowVegMin doit rester sous lowVegFull."); + } + if (params_.shrubDistanceNear > params_.shrubDistanceFar || + params_.treeDistanceNear > params_.treeDistanceFar) { + throw std::runtime_error("Bushes : portee proche au-dela de la portee lointaine."); + } +} + +void Bushes::setTreeFootprints(std::vector footprints) { + treeGrid_.clear(); + treeGridMaxRadius_ = 0.0f; + for (const glm::vec3& f : footprints) { + const Key k{ static_cast(std::floor(f.x / kTreeGridCell)), + static_cast(std::floor(f.y / kTreeGridCell)) }; + treeGrid_[k].push_back(f); + treeGridMaxRadius_ = std::max(treeGridMaxRadius_, f.z); + } + cache_.clear(); +} + +bool Bushes::inTreeFootprint(float x, float z) const { + if (treeGrid_.empty()) { return false; } + const float r = treeGridMaxRadius_; + const auto x0 = static_cast(std::floor((x - r) / kTreeGridCell)); + const auto x1 = static_cast(std::floor((x + r) / kTreeGridCell)); + const auto z0 = static_cast(std::floor((z - r) / kTreeGridCell)); + const auto z1 = static_cast(std::floor((z + r) / kTreeGridCell)); + for (int32_t cz = z0; cz <= z1; ++cz) { + for (int32_t cx = x0; cx <= x1; ++cx) { + const auto it = treeGrid_.find(Key{ cx, cz }); + if (it == treeGrid_.end()) { continue; } + for (const glm::vec3& f : it->second) { + const float dx = x - f.x, dz = z - f.y; + if (dx * dx + dz * dz < f.z * f.z) { return true; } + } + } + } + return false; +} + +float Bushes::coverAt(float x, float z) const { + return std::clamp(cover_->heightAt(x, z), 0.0f, 1.0f); +} +float Bushes::lowVegAt(float x, float z) const { + return std::clamp(lowVeg_->heightAt(x, z), 0.0f, 1.0f); +} + +bool Bushes::maskAt(float worldX, float worldZ) const { + if (!enabled()) { return false; } + const float usable = terrainExtent_ - kEdgeMargin; + if (std::abs(worldX) > usable || std::abs(worldZ) > usable) { return false; } + const float f3 = lowVegAt(worldX, worldZ); + if (f3 < params_.lowVegMin) { return false; } + const float cover = coverAt(worldX, worldZ); + if (cover < params_.rockCoverMax) { return false; } // domaine des rochers + return cover - f3 < params_.highVegMax; +} + +float Bushes::densityAt(float worldX, float worldZ) const { + if (!maskAt(worldX, worldZ)) { return 0.0f; } + const float t = ramp(lowVegAt(worldX, worldZ), params_.lowVegMin, params_.lowVegFull); + return params_.minDensity + (1.0f - params_.minDensity) * t; +} + +std::vector Bushes::cellBushes(int32_t cx, int32_t cz) const { + std::vector out; + if (!enabled()) { return out; } + const float size = params_.cell; + const float baseX = static_cast(cx) * size; + const float baseZ = static_cast(cz) * size; + for (uint32_t slot = 0; slot < params_.slots; ++slot) { + const uint32_t stream = slot * 6u + 40u; + const float x = baseX + unitFloat(cellHash(cx, cz, params_.seed, stream)) * size; + const float z = baseZ + unitFloat(cellHash(cx, cz, params_.seed, stream + 1u)) * size; + // 1. Filtre dur + densite : l'emplacement `slot` n'est retenu que si la + // densite locale lui laisse la place (meme regle que Rocks/Vegetation). + const float density = densityAt(x, z); + if (density <= 0.0f || static_cast(slot) >= density * static_cast(params_.slots)) { + continue; + } + // 2. Hauteur tiree SOUS la hauteur max de classe 3 de la cellule 5 m. + const float hMap = lowVegHeight_->heightAt(x, z); + if (!(hMap >= params_.heightMapMin)) { continue; } // pas de hauteur mesuree + const float draw = glm::mix(params_.heightDrawMin, params_.heightDrawMax, + unitFloat(cellHash(cx, cz, params_.seed, stream + 2u))); + const float height = std::clamp(hMap * draw, params_.heightMin, params_.heightMax); + // 3. Pas dans l'emprise d'un arbre existant. + if (inTreeFootprint(x, z)) { continue; } + BushInstance b; + b.kind = height >= params_.smallTreeFrom ? BushKind::SmallTree : BushKind::Shrub; + b.position = { x, terrain_.heightAt(x, z), z }; + b.height = height; + b.yaw = unitFloat(cellHash(cx, cz, params_.seed, stream + 3u)) * kTwoPi; + b.tint = unitFloat(cellHash(cx, cz, params_.seed, stream + 4u)); + const float t = params_.slots > 1 + ? static_cast(slot) / static_cast(params_.slots - 1) + : 0.0f; + b.maxDistance = b.kind == BushKind::SmallTree + ? glm::mix(params_.treeDistanceFar, params_.treeDistanceNear, t) + : glm::mix(params_.shrubDistanceFar, params_.shrubDistanceNear, t); + out.push_back(b); + } + return out; +} + +Bushes::Block Bushes::buildBlock(int32_t bx, int32_t bz) const { + Block block; + bool first = true; + for (int32_t j = 0; j < kBlockCells; ++j) { + for (int32_t i = 0; i < kBlockCells; ++i) { + for (const BushInstance& b : cellBushes(bx * kBlockCells + i, bz * kBlockCells + j)) { + const float r = kShrubFootprintRadius * b.height; + const glm::vec3 lo(b.position.x - r, b.position.y - kBushBuriedDepth * b.height, b.position.z - r); + const glm::vec3 hi(b.position.x + r, b.position.y + b.height, b.position.z + r); + block.boxMin = first ? lo : glm::min(block.boxMin, lo); + block.boxMax = first ? hi : glm::max(block.boxMax, hi); + first = false; + block.bushes.push_back(b); + } + } + } + return block; +} + +void Bushes::gather(const glm::vec3& eye, const Frustum& frustum, std::vector& shrubs, + std::vector& smallTrees) { + shrubs.clear(); + smallTrees.clear(); + if (enabled()) { + const float reach = std::max(params_.shrubDistanceFar, params_.treeDistanceFar); + const float blockSize = static_cast(kBlockCells) * params_.cell; + const auto bx0 = static_cast(std::floor((eye.x - reach) / blockSize)); + const auto bx1 = static_cast(std::floor((eye.x + reach) / blockSize)); + const auto bz0 = static_cast(std::floor((eye.z - reach) / blockSize)); + const auto bz1 = static_cast(std::floor((eye.z + reach) / blockSize)); + uint32_t built = 0; + for (int32_t bz = bz0; bz <= bz1; ++bz) { + for (int32_t bx = bx0; bx <= bx1; ++bx) { + const float mx = static_cast(bx) * blockSize; + const float mz = static_cast(bz) * blockSize; + const float dx = eye.x - std::clamp(eye.x, mx, mx + blockSize); + const float dz = eye.z - std::clamp(eye.z, mz, mz + blockSize); + if (dx * dx + dz * dz > reach * reach) { continue; } + auto found = cache_.find(Key{ bx, bz }); + if (found == cache_.end()) { + float lo = terrain_.heightAt(mx + 0.5f * blockSize, mz + 0.5f * blockSize); + float hi = lo; + for (int c = 0; c < 4; ++c) { + const float h = terrain_.heightAt(mx + ((c & 1) ? blockSize : 0.0f), + mz + ((c & 2) ? blockSize : 0.0f)); + lo = std::min(lo, h); + hi = std::max(hi, h); + } + if (!frustum.intersectsAABB({ mx, lo - 60.0f, mz }, + { mx + blockSize, hi + 60.0f, mz + blockSize })) { + continue; + } + if (built >= params_.blockBudget) { continue; } + ++built; + found = cache_.emplace(Key{ bx, bz }, buildBlock(bx, bz)).first; + } + const Block& block = found->second; + if (block.bushes.empty() || !frustum.intersectsAABB(block.boxMin, block.boxMax)) { + continue; + } + for (const BushInstance& b : block.bushes) { + const glm::vec3 d = eye - b.position; + const float d2 = glm::dot(d, d); + if (d2 >= b.maxDistance * b.maxDistance) { continue; } + InstanceData inst; + inst.position = b.position; + inst.scale = b.height; + inst.yaw = b.yaw; + inst.variation = b.tint; + inst.fade = 1.0f - ramp(std::sqrt(d2), 0.82f * b.maxDistance, b.maxDistance); + (b.kind == BushKind::SmallTree ? smallTrees : shrubs).push_back(inst); + } + } + } + const float keep = 1.5f * reach + blockSize; + for (auto it = cache_.begin(); it != cache_.end();) { + const float cx = (static_cast(it->first.x) + 0.5f) * blockSize; + const float cz = (static_cast(it->first.z) + 0.5f) * blockSize; + const float ex = eye.x - cx, ez = eye.z - cz; + it = (ex * ex + ez * ez > keep * keep) ? cache_.erase(it) : std::next(it); + } + } + lastShrubs_ = static_cast(shrubs.size()); + lastTrees_ = static_cast(smallTrees.size()); +} + +Bushes::Stats Bushes::estimate(uint32_t step) const { + Stats stats; + if (!enabled()) { return stats; } + step = std::max(step, 1u); + const float cell = params_.cell; + const auto half = static_cast((terrainExtent_ - kEdgeMargin) / cell) - 1; + uint64_t cells = 0, masked = 0, shrubs = 0, trees = 0; + for (int32_t cz = -half; cz <= half; cz += static_cast(step)) { + for (int32_t cx = -half; cx <= half; cx += static_cast(step)) { + ++cells; + masked += maskAt((static_cast(cx) + 0.5f) * cell, (static_cast(cz) + 0.5f) * cell) ? 1 : 0; + for (const BushInstance& b : cellBushes(cx, cz)) { + (b.kind == BushKind::SmallTree ? trees : shrubs) += 1; + } + } + } + if (cells == 0) { return stats; } + const double ha = static_cast(cells) * cell * cell / 10000.0; + stats.maskFraction = static_cast(masked) / static_cast(cells); + stats.shrubsPerHa = static_cast(shrubs) / ha; + stats.smallTreesPerHa = static_cast(trees) / ha; + return stats; +} + +} // namespace vercora diff --git a/src/world/Bushes.hpp b/src/world/Bushes.hpp new file mode 100644 index 0000000..b42dc7c --- /dev/null +++ b/src/world/Bushes.hpp @@ -0,0 +1,146 @@ +#pragma once + +#include "renderer/InstanceData.hpp" + +#include + +#include +#include +#include + +namespace vercora { + +class HeightSampler; +struct Frustum; + +// PHASE 29 (Agent 3) : buissons et petits arbres, pilotes UNIQUEMENT par la +// classe 3 LiDAR (vegetation basse) rasterisee par l'Agent 1 au pas de 5 m +// (NOTES-PHASE29-DESIGN.md, section 2) : +// +// BUISSON = F3 >= 0,10 ET F45 = couvert - F3 < 0,20 +// F3 = retours classe 3 / retours valides (vercora_zone_canopy_lowveg.vchm) +// couvert = (c3 + c4 + c5) / valides (vercora_zone_canopy.vchm, deja charge) +// +// La carte des grands arbres (couvert) ne sert QU'A exclure : elle ne cree +// aucun buisson (pas de double emploi du meme signal). Densite : lineaire en F3 +// de 0,10 (rare) a 0,30 (~p99, plein). Hauteur : tiree SOUS la hauteur max de +// la classe 3 de la cellule (`_lowveg_height`), bornee a [heightMin, heightMax]. +// +// Exclusions : +// - rochers (Rocks, Agent 2) : leur masque exige couvert < 0,10 ; on exige ici +// couvert >= 0,10, donc les deux semis sont DISJOINTS par construction (la +// donnee a 6 cellules sur 1 M ou F3 depasse le couvert de < 0,03 : ce test +// les ecarte aussi) ; +// - arbres abattables de la Forest : emprise du houppier (setTreeFootprints). +// Les arbres de decor de Vegetation ne sont pas consultes (semis prive) ; +// F45 < 0,20 les evite deja en grande partie (leur seuil coverMin = 0,20). +// +// Sans l'une des trois cartes : AUCUN buisson (aucun substitut). +// Collision : AUCUNE, les buissons se traversent (voir NOTES-PHASE29.md). +struct BushParams { + float lowVegMin = 0.10f; // F3 minimal + float lowVegFull = 0.30f; // F3 a densite pleine + float highVegMax = 0.20f; // F45 maximal + float rockCoverMax = 0.10f; // couvert sous lequel Rocks peut semer -> exclu ici + float minDensity = 0.20f; // part des emplacements retenue a F3 = lowVegMin + + float cell = 8.0f; + uint32_t slots = 6; // au plus 6 sujets / 64 m2 (1 / 10,7 m2) + + float heightMin = 0.5f, heightMax = 3.0f; // m + float heightMapMin = 0.3f; // h classe 3 de la cellule sous ce seuil : pas de sujet + // Fraction de h max tiree : [0,35 ; 0,85], moyenne 0,60 = rapport mesure par + // l'Agent 1 entre hauteur MOYENNE (p50 1,5 m) et MAX (p50 2,5 m) de la classe 3. + float heightDrawMin = 0.35f, heightDrawMax = 0.85f; + float smallTreeFrom = 1.8f; // hauteur a partir de laquelle c'est un petit arbre + + // Portees : un premier reglage 220/380 m coutait 276 us de semis par image + // (Debug) au coeur d'une zone de buissons ; ramene a 150/260 m. + float shrubDistanceFar = 150.0f, shrubDistanceNear = 55.0f; + float treeDistanceFar = 260.0f, treeDistanceNear = 100.0f; + + uint32_t seed = 20260928u; + uint32_t blockBudget = 4; // blocs de 8x8 cellules engendres au plus par appel +}; + +enum class BushKind : uint8_t { Shrub = 0, SmallTree = 1 }; + +struct BushInstance { + glm::vec3 position{0.0f}; + float height = 1.0f; // = echelle du mesh (unite = 1 m de haut) + float yaw = 0.0f; + float tint = 0.0f; + float maxDistance = 0.0f; + BushKind kind = BushKind::Shrub; +}; + +class Bushes { +public: + // lowVeg = F3, lowVegHeight = h max classe 3 - sol (m), cover = couvert total. + // Toutes non possedees ; une seule nulle -> aucun buisson. + Bushes(const HeightSampler& terrain, const HeightSampler* lowVeg, + const HeightSampler* lowVegHeight, const HeightSampler* cover, float terrainExtent, + const BushParams& params = {}); + + bool enabled() const { return lowVeg_ && lowVegHeight_ && cover_; } + + // Emprises (x, z, rayon) des arbres existants : aucun buisson dedans. + // A appeler avant le premier gather (vide le cache). + void setTreeFootprints(std::vector footprints); + + void gather(const glm::vec3& eye, const Frustum& frustum, std::vector& shrubs, + std::vector& smallTrees); + + // --- Critere et semis exposes (tests, diagnostic) ------------------------ + bool maskAt(float worldX, float worldZ) const; + float densityAt(float worldX, float worldZ) const; // [0,1], 0 hors masque + std::vector cellBushes(int32_t cx, int32_t cz) const; + + struct Stats { + double maskFraction = 0.0; + double shrubsPerHa = 0.0; // par ha de ZONE + double smallTreesPerHa = 0.0; + }; + Stats estimate(uint32_t step = 7) const; + + uint32_t lastShrubCount() const { return lastShrubs_; } + uint32_t lastSmallTreeCount() const { return lastTrees_; } + const BushParams& params() const { return params_; } + +private: + struct Key { + int32_t x = 0, z = 0; + bool operator==(const Key& o) const { return x == o.x && z == o.z; } + }; + struct KeyHash { + std::size_t operator()(const Key& k) const { + return (static_cast(static_cast(k.x)) * 0x9E3779B1ull) ^ + (static_cast(static_cast(k.z)) * 0x85EBCA77ull); + } + }; + struct Block { + std::vector bushes; + glm::vec3 boxMin{0.0f}, boxMax{0.0f}; + }; + static constexpr int32_t kBlockCells = 8; + Block buildBlock(int32_t bx, int32_t bz) const; + bool inTreeFootprint(float x, float z) const; + float coverAt(float x, float z) const; + float lowVegAt(float x, float z) const; + + const HeightSampler& terrain_; + const HeightSampler* lowVeg_ = nullptr; + const HeightSampler* lowVegHeight_ = nullptr; + const HeightSampler* cover_ = nullptr; + float terrainExtent_ = 0.0f; + BushParams params_; + + // Emprises d'arbres rangees par case de 32 m. + std::unordered_map, KeyHash> treeGrid_; + float treeGridMaxRadius_ = 0.0f; + + std::unordered_map cache_; + uint32_t lastShrubs_ = 0, lastTrees_ = 0; +}; + +} // namespace vercora diff --git a/src/world/Clearing.hpp b/src/world/Clearing.hpp new file mode 100644 index 0000000..6b22232 --- /dev/null +++ b/src/world/Clearing.hpp @@ -0,0 +1,37 @@ +#pragma once + +namespace vercora { + +// =========================================================================== +// PHASE 22 : ce que le semis des PLANTES A FIBRES a besoin de savoir du milieu. +// =========================================================================== +// Une seule question, posee en coordonnees monde : ce sol a-t-il ete OUVERT ? +// 0 = intact, 1 = entierement degage. +// +// C'est le pendant EXACT de world/GroundCover.hpp, et l'interface existe pour +// la meme raison : world/FiberPlants ne doit PAS dependre de world/Habitat. Le +// semis consomme ce contrat et ne sait rien de ce qui le calcule. +// +// MAIS CE N'EST PAS LA MEME QUESTION, ET C'EST TOUT L'INTERET D'AVOIR DEUX +// INTERFACES PLUTOT QU'UNE. `groundCover` demande "reste-t-il du couvert ici ?" +// et sert a RARÉFIER l'herbe ; `clearing` demande "a-t-on ouvert ici ?" et sert +// a FAIRE POUSSER les ronces. Les deux se lisent aujourd'hui dans le meme +// compteur de deforestation d'Habitat, mais elles n'y liront pas toujours la +// meme chose : le jour ou l'usure des sols par pietinement degradera le couvert +// (annonce en Phase 17 et toujours pas fait), elle fera baisser groundCover sans +// ouvrir quoi que ce soit - un sentier tasse ne fait pas pousser d'orties. Les +// fusionner maintenant obligerait a les separer a ce moment-la. +// +// Contrat : la fonction est TOTALE - partout ou aucune ouverture n'est +// enregistree, elle doit rendre 0, pas echouer. Un monde sans Habitat branche +// se comporte donc comme un monde jamais coupe, et les plantes a fibres n'y +// poussent que par le critere de LISIERE (voir FiberPlants.hpp). +class ClearingSource { +public: + virtual ~ClearingSource() = default; + + // Part de sol ouvert en (worldX, worldZ), dans [0, 1]. + virtual float clearing(float worldX, float worldZ) const = 0; +}; + +} // namespace vercora diff --git a/src/world/Climber.cpp b/src/world/Climber.cpp new file mode 100644 index 0000000..6943906 --- /dev/null +++ b/src/world/Climber.cpp @@ -0,0 +1,335 @@ +#include "world/Climber.hpp" + +#include "core/CollisionSolver.hpp" +#include "core/HeightSampler.hpp" + +#include +#include + +namespace vercora { + +namespace { + +// Nombre de sondes reparties sur params.reach pour trouver la paroi. Sept sondes +// sur 2 m = une tous les 33 cm, largement plus fin que la base de 4 m sur +// laquelle la pente est lue : sonder plus fin ne revelerait rien de nouveau. +constexpr int kReachProbes = 7; + +// Distance a laquelle on verifie que le terrain reste marchable pour declarer un +// sommet, en m. Voir Climber::hasToppedOut. +constexpr float kTopOutConfirmDistance = 3.0f; + +// En dessous de cette longueur, un pas est considere nul : on ne normalise pas +// un vecteur de longueur nulle et on ne facture pas d'energie pour du bruit de +// virgule flottante. +constexpr float kMinStep = 1e-5f; + +} // namespace + +Climber::Climber(const ClimberParams& params) : params_(params) {} + +glm::vec2 Climber::gradientAt(const HeightSampler& terrain, float worldX, + float worldZ) const { + const float s = params_.slopeSampleStep; + // Differences CENTREES, comme Bike::terrainGradient : symetriques, donc la + // meme paroi a la meme pente qu'on l'aborde par la gauche ou par la droite. + 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)); +} + +float Climber::slopeAt(const HeightSampler& terrain, float worldX, float worldZ) const { + const glm::vec2 g = gradientAt(terrain, worldX, worldZ); + return std::sqrt(g.x * g.x + g.y * g.y); +} + +glm::vec3 Climber::wallFacing(const HeightSampler& terrain) const { + const glm::vec2 g = gradientAt(terrain, anchor_.x, anchor_.z); + const float length = std::sqrt(g.x * g.x + g.y * g.y); + if (length < kMinStep) { + // Surface strictement plate : la ligne de plus grande pente n'existe + // pas. Ne peut pas arriver en paroi (on n'y entre qu'au-dessus de + // wallSlope), mais la fonction est publique donc elle doit repondre. + return glm::vec3(0.0f); + } + // Le gradient pointe vers la montee : c'est la direction dans laquelle le + // grimpeur fait face. + return glm::vec3(g.x / length, 0.0f, g.y / length); +} + +void Climber::snapAnchor(const HeightSampler& terrain) { + anchor_.y = terrain.heightAt(anchor_.x, anchor_.z); +} + +glm::vec3 Climber::position() const { + // L'oeil est decale vers l'AVAL (outward_) et un peu vers le haut. Le + // decalage aval garantit que l'oeil est hors du relief : la surface y est + // plus basse qu'a l'accroche, puisqu'on descend la ligne de plus grande + // pente. + return anchor_ + outward_ * params_.wallOffset + + glm::vec3(0.0f, params_.eyeRise, 0.0f); +} + +float Climber::wallRise(const HeightSampler& terrain, float worldX, + float worldZ) const { + // On suit la ligne de plus grande pente exactement comme le fait update(), + // par petits pas, en reevaluant le gradient a chaque fois : une paroi reelle + // tourne, et un pas unique en ligne droite sortirait de la face. + constexpr int kSteps = 12; + const float stepLength = params_.minWallRun / static_cast(kSteps); + + float x = worldX; + float z = worldZ; + const float startY = terrain.heightAt(x, z); + + for (int i = 0; i < kSteps; ++i) { + const glm::vec2 g = gradientAt(terrain, x, z); + const float slope = std::sqrt(g.x * g.x + g.y * g.y); + if (slope < kMinStep) { + break; // plat : plus rien a gagner, on s'arrete la + } + // Meme projection que le deplacement reel : avancer stepLength LE LONG DE + // LA SURFACE ne consomme que stepLength / sqrt(1 + pente^2) a + // l'horizontale. + const float horizontal = stepLength / std::sqrt(1.0f + slope * slope); + x += (g.x / slope) * horizontal; + z += (g.y / slope) * horizontal; + } + + return terrain.heightAt(x, z) - startY; +} + +bool Climber::tryStart(const HeightSampler& terrain, const glm::vec3& eyePosition, + const glm::vec3& lookDirection) { + if (climbing_ || stamina_ < minStaminaToStart()) { + return false; + } + + // Seule la projection horizontale du regard compte : lever les yeux vers le + // haut de la falaise ne doit pas raccourcir la portee au sol. + glm::vec3 flat(lookDirection.x, 0.0f, lookDirection.z); + const float flatLength = std::sqrt(flat.x * flat.x + flat.z * flat.z); + if (flatLength < kMinStep) { + return false; // regard strictement vertical : aucune direction au sol + } + flat /= flatLength; + + for (int i = 0; i <= kReachProbes; ++i) { + const float distance = + params_.reach * static_cast(i) / static_cast(kReachProbes); + const float px = eyePosition.x + flat.x * distance; + const float pz = eyePosition.z + flat.z * distance; + if (!isWall(terrain, px, pz)) { + continue; + } + + // Raide ne suffit pas : il faut que grimper la MENE quelque part. Sans + // ce controle, on s'accroche au premier ressaut de deux metres devant la + // paroi et l'escalade se termine par un "sommet" trois secondes plus + // tard - constate sur la paroi de reference LiDAR, voir minWallRun. + if (wallRise(terrain, px, pz) < params_.minWallRise) { + continue; + } + + // Le point de repli d'une chute est la position du joueur AU MOMENT DE + // L'ENGAGEMENT, et non le pied de la paroi calcule apres coup : c'est + // par construction du terrain ou il se tenait debout la frame d'avant, + // donc du terrain ou l'on peut le reposer sans risque. Le calculer + // autrement, ce serait chercher une position libre sans garantie d'en + // trouver une. + // + // Stocke SUR LA SURFACE et non a hauteur d'oeil : groundAnchor_ et + // anchor_ doivent etre dans le meme repere, sans quoi heightGained() + // annoncerait 1,7 m de moins que la realite. L'appelant qui repose le + // joueur y ajoutera sa hauteur d'oeil (Camera::setMode le fait tout + // seul via snapToTerrain). + groundAnchor_ = glm::vec3(eyePosition.x, + terrain.heightAt(eyePosition.x, eyePosition.z), + eyePosition.z); + + anchor_ = glm::vec3(px, 0.0f, pz); + snapAnchor(terrain); + outward_ = -wallFacing(terrain); + climbing_ = true; + return true; + } + + return false; +} + +bool Climber::hasToppedOut(const HeightSampler& terrain) const { + if (slopeAt(terrain, anchor_.x, anchor_.z) >= params_.walkableSlope) { + return false; + } + // Confirmation 3 m plus loin dans la pente. Sans elle, la moindre dalle + // horizontale au milieu de la face terminerait l'escalade en plein vide. + const glm::vec3 facing = wallFacing(terrain); + if (facing == glm::vec3(0.0f)) { + // Plat parfait dans toutes les directions : c'est un sommet, et il n'y a + // pas de direction dans laquelle confirmer. + return true; + } + const float cx = anchor_.x + facing.x * kTopOutConfirmDistance; + const float cz = anchor_.z + facing.z * kTopOutConfirmDistance; + return slopeAt(terrain, cx, cz) < params_.walkableSlope; +} + +ClimbExit Climber::release() { + if (!climbing_) { + return ClimbExit::None; + } + climbing_ = false; + // Retour au pied. La position de repli est celle de l'engagement, dont on + // sait qu'elle etait libre et marchable. + anchor_ = groundAnchor_; + return ClimbExit::Released; +} + +void Climber::restOnGround(float deltaTime) { + if (climbing_ || deltaTime <= 0.0f) { + return; + } + stamina_ = std::min(1.0f, stamina_ + params_.staminaRecoveryPerSecond * deltaTime); +} + +float Climber::gripForWetness(float wetness) const { + const float wet = std::isfinite(wetness) ? std::clamp(wetness, 0.0f, 1.0f) : 0.0f; + const float wetGrip = std::clamp(params_.wetGrip, 0.05f, 1.0f); + return 1.0f + (wetGrip - 1.0f) * wet; +} + +ClimbExit Climber::update(float deltaTime, float climbInput, float traverseInput, + const HeightSampler& terrain, + const CollisionSolver* obstacles, float grip) { + if (!climbing_ || deltaTime <= 0.0f) { + return ClimbExit::None; + } + + climbInput = std::clamp(climbInput, -1.0f, 1.0f); + traverseInput = std::clamp(traverseInput, -1.0f, 1.0f); + + // PHASE 23 : adherence. Le plancher a 0,05 n'est pas cosmetique - il garantit + // qu'une paroi ruisselante reste GRIMPABLE, tres lentement et tres chere, + // plutot que de devenir une impasse ou le joueur resterait bloque en paroi + // sans pouvoir ni monter ni redescendre. + grip = std::isfinite(grip) ? std::clamp(grip, 0.05f, 1.0f) : 1.0f; + + // Le surcout suit l'INVERSE de l'adherence : a grip 1 il vaut 1, et il monte + // jusqu'a wetStaminaGain quand l'adherence tombe a sa valeur mouillee. Le + // rapporter a params_.wetGrip plutot qu'a zero est ce qui garde les deux + // constantes d'accord entre elles - regler l'une sans l'autre ne peut pas + // produire un surcout absurde. + const float wetGrip = std::clamp(params_.wetGrip, 0.05f, 1.0f); + const float slipperiness = wetGrip < 1.0f + ? std::clamp((1.0f - grip) / (1.0f - wetGrip), 0.0f, 1.0f) + : 0.0f; + const float staminaScale = 1.0f + (params_.wetStaminaGain - 1.0f) * slipperiness; + + const glm::vec2 gradient = gradientAt(terrain, anchor_.x, anchor_.z); + const float slope = std::sqrt(gradient.x * gradient.x + gradient.y * gradient.y); + + glm::vec3 facing(0.0f); + if (slope >= kMinStep) { + facing = glm::vec3(gradient.x / slope, 0.0f, gradient.y / slope); + } + outward_ = -facing; + + // ----------------------------------------------------------------------- + // 1. Deplacement LE LONG DE LA SURFACE. + // ----------------------------------------------------------------------- + // Monter/descendre suit la ligne de plus grande pente. Avancer d'une + // longueur L le long de la surface consomme L / sqrt(1 + pente^2) de + // deplacement HORIZONTAL - c'est cette projection qui fait qu'une paroi + // quasi verticale se monte quasi verticalement, sans aucun cas particulier. + glm::vec3 horizontalStep(0.0f); + if (facing != glm::vec3(0.0f) && climbInput != 0.0f) { + const float alongSurface = params_.climbSpeed * grip * climbInput * deltaTime; + const float horizontal = alongSurface / std::sqrt(1.0f + slope * slope); + horizontalStep += facing * horizontal; + } + + // Traverser suit la LIGNE DE NIVEAU : perpendiculaire au gradient dans le + // plan XZ. Meme construction que Camera::right_ / Bike::right() + // (cross(front, worldUp)), donc +1 est bien la droite du grimpeur face a la + // paroi. Une ligne de niveau etant horizontale par definition, il n'y a pas + // de projection a faire ici. + if (facing != glm::vec3(0.0f) && traverseInput != 0.0f) { + const glm::vec3 right(-facing.z, 0.0f, facing.x); + horizontalStep += right * (params_.traverseSpeed * grip * traverseInput * deltaTime); + } + + const glm::vec3 previousAnchor = anchor_; + anchor_.x += horizontalStep.x; + anchor_.z += horizontalStep.z; + + // ----------------------------------------------------------------------- + // 2. Obstacles, par le point d'entree UNIQUE du projet. + // ----------------------------------------------------------------------- + if (obstacles != nullptr) { + BodyCylinder body; + body.position = anchor_; + body.radius = params_.bodyRadius; + // Bande CENTREE sur l'accroche, et non partant des pieds comme a la + // marche : en paroi le corps est etendu le long de la surface, le point + // d'accroche est a peu pres a mi-corps. + body.feetY = anchor_.y - params_.bodyHalfHeight; + body.headY = anchor_.y + params_.bodyHalfHeight; + + const glm::vec3 corrected = moveBody(*obstacles, body, previousAnchor); + anchor_.x = corrected.x; + anchor_.z = corrected.z; + } + + // Contact PERMANENT avec la surface, meme invariant que le velo : la + // verticale n'est pas integree, elle est relue. + snapAnchor(terrain); + + // ----------------------------------------------------------------------- + // 3. Energie. Facturee sur le deplacement REELLEMENT obtenu (donc apres les + // obstacles) : buter contre un tronc ne doit pas couter comme si on avait + // grimpe. + // ----------------------------------------------------------------------- + const float dx = anchor_.x - previousAnchor.x; + const float dz = anchor_.z - previousAnchor.z; + const float dHorizontal = std::sqrt(dx * dx + dz * dz); + const float dAltitude = anchor_.y - previousAnchor.y; + + if (dHorizontal < kMinStep && std::abs(dAltitude) < kMinStep) { + // Suspendu sans bouger : le seul cout au temps du modele. + // Rester suspendu a une paroi mouillee coute plus cher : on serre. + stamina_ -= params_.staminaHangPerSecond * staminaScale * deltaTime; + } else { + stamina_ -= dHorizontal * params_.staminaPerMeterLateral * staminaScale; + stamina_ -= (dAltitude > 0.0f + ? dAltitude * params_.staminaPerMeterUp + : -dAltitude * params_.staminaPerMeterDown) * + staminaScale; + } + stamina_ = std::clamp(stamina_, 0.0f, 1.0f); + + // ----------------------------------------------------------------------- + // 4. Conditions de sortie. L'ORDRE COMPTE : le sommet est teste AVANT + // l'epuisement. Un grimpeur qui pose la main sur la vire avec sa derniere + // goutte d'energie a topppe, il n'est pas tombe - et c'est la seule + // lecture qui ne frustre pas. + // ----------------------------------------------------------------------- + if (hasToppedOut(terrain)) { + climbing_ = false; + return ClimbExit::ToppedOut; + } + + if (stamina_ <= 0.0f) { + climbing_ = false; + // Chute : reinitialisation PROPRE de la position, pas de degats (hors + // scope de cette session). On revient au point d'engagement, dont on + // sait qu'il etait marchable et libre. + anchor_ = groundAnchor_; + return ClimbExit::Exhausted; + } + + return ClimbExit::None; +} + +} // namespace vercora diff --git a/src/world/Climber.hpp b/src/world/Climber.hpp new file mode 100644 index 0000000..cb3b52f --- /dev/null +++ b/src/world/Climber.hpp @@ -0,0 +1,466 @@ +#pragma once + +#include "core/SlopeLimits.hpp" + +#include + +namespace vercora { + +class HeightSampler; +class CollisionSolver; + +// Modele d'ESCALADE simplifie (Phase 14), dans le meme esprit que +// world/Paraglider et world/Bike : pas une simulation de grimpe - pas de prises +// individuelles, pas de materiel, pas d'adherence variable, pas de meteo - juste +// de quoi s'engager sur une vraie paroi du terrain LiDAR, y monter, y traverser, +// en redescendre ou en tomber quand l'energie manque. +// +// LA DIFFERENCE DE FOND AVEC LES TROIS AUTRES ACTIVITES tient en une phrase : +// marcher, rouler et voler se font AU-DESSUS de la surface, grimper se fait +// CONTRE elle. Ce que ca change concretement est detaille sur position() plus +// bas - le grimpeur n'a pas de "hauteur d'oeil au-dessus du sol". +// +// Ce que ce modele NE fait PAS, et qui est assume pour cette session : +// - aucune prise individuelle : une paroi assez raide est grimpable +// ENTIEREMENT, il n'y a pas de "bon" ou de "mauvais" endroit sur la face ; +// - aucun SURPLOMB : une heightmap 2,5D ne peut pas en representer (limite +// deja documentee en Phase 9 sur les noeuds partages des falaises) ; +// - aucun degat, aucune corde, aucun point d'assurage. +struct ClimberParams { + // --- Detection de paroi -------------------------------------------------- + + // Pente a partir de laquelle une zone est une PAROI et non un versant raide, + // en RISE PAR METRE HORIZONTAL (1,00 = 45 degres = 100 %). + // + // CE SEUIL EST UN CHOIX DE CONCEPTION, PAS UNE DECOUVERTE. La distribution + // des pentes de la zone de jeu, mesuree par tools/find_climb_walls.py sur + // les 25 millions d'echantillons du terrain assemble, est un CONTINUUM sans + // aucune bimodalite - il n'existe pas de "creux" ou poser le seuil : + // + // p50 47,7 % p75 65,7 % p90 92,4 % + // p95 129,4 % p99 342,5 % max 5018,2 % + // + // Trois arguments ont fixe la valeur a 1,00 : + // + // 1. 45 degres 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 degres, soit 70 a 84 %). Une face a 45 degres 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. Il retient 8,4 % de la zone de jeu. 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 que sur les grandes falaises inabordables. + // + // PHASE 24 - CE SEUIL A ETE ABAISSE A 0,84 (kWalkMaxSlope), ET LA RAISON + // N'EST PAS UN REGLAGE MAIS UNE COHERENCE. + // + // La Phase 24 a donne a la marche une limite de pente (0,84, l'angle de + // repos des materiaux meubles - voir core/SlopeLimits.hpp). Tant que + // l'escalade ne s'engageait qu'a partir de 1,00, il existait une bande + // [0,84 ; 1,00[ - environ 5 % du massif, soit un versant sur vingt - ou le + // joueur ne pouvait NI marcher NI grimper. C'etait le vrai defaut de + // coherence entre les deux activites, et un seuil de plus ne l'aurait pas + // corrige : deux nombres regles separement finissent toujours par diverger. + // + // La correction est donc structurelle : ce seuil EST la limite de marche, + // la meme constante, et il ne peut plus exister de trou entre les deux. + // + // Ce que ca change pour les trois arguments ci-dessus : le (1) devient 40 + // degres au lieu de 45 - toujours au-dessus de l'angle de repos, donc + // toujours du rocher nu, l'argument (2) tient inchange ; le (3) passe de + // 8,4 % a environ 13 % de la zone de jeu, ce qui reste tres loin des 20,7 % + // que la Phase 14 jugeait excessifs. + // + // tools/find_climb_walls.py, lui, continue de chercher a 1,00 : c'est un + // outil de REPERAGE hors ligne, et une paroi a 45 degres reste une + // meilleure voie de reference qu'une a 40. Il rend desormais un + // sous-ensemble de ce qui est grimpable en jeu, ce qui est le bon sens de + // l'ecart - jamais l'inverse. + float wallSlope = kWalkMaxSlope; + + // Pente sous laquelle on remarche, meme rise par metre. STRICTEMENT plus + // basse que wallSlope, et c'est tout l'interet : les deux seuils forment une + // HYSTERESIS. + // + // Sans elle, une paroi reelle - qui oscille autour de son seuil d'un metre a + // l'autre - ferait entrer et sortir du mode escalade a chaque frame. Avec + // elle, il faut vraiment atteindre du terrain marchable pour sortir. + // + // 0,60 (31 degres) est la pente au-dela de laquelle un sentier de montagne + // ne se fait plus debout de facon soutenue ; c'est aussi la valeur que + // tools/find_climb_walls.py emploie pour juger si une paroi a un pied + // abordable, et les deux DOIVENT rester d'accord. + // PHASE 24 : la valeur est passee dans core/SlopeLimits.hpp + // (kWalkComfortSlope) pour que la marche et l'escalade lisent le MEME + // nombre. Elle n'a pas change : 0,60. + float walkableSlope = kWalkComfortSlope; + + // Demi-base des differences finies centrees qui mesurent la pente, en m. La + // pente est donc lue sur 2 x slopeSampleStep. + // + // Meme valeur et MEME RAISON qu'en Phase 13 (BikeParams::slopeSampleStep) : + // 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 plat, donc un joueur qui entre en escalade sur un caillou. + // Une base de 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. + float slopeSampleStep = 2.0f; + + // Portee de la prise de contact, en m, mesuree a l'horizontale devant le + // joueur. Un peu moins que la portee de ramassage (kPickupReach = 2,5 m) : + // on s'engage sur une paroi qu'on touche, pas sur une qu'on voit. + float reach = 2.0f; + + // Longueur de surface sondee vers le haut pour confirmer qu'un point est une + // vraie paroi, en m, et gain d'altitude minimal exige sur cette longueur. + // + // POURQUOI CES DEUX PARAMETRES EXISTENT : parce que le seuil de pente seul ne + // suffit pas sur du relief mesure, et ce n'est pas une supposition - c'est un + // echec observe. Le premier essai n'exigeait qu'un point au-dessus de + // wallSlope ; sur la paroi de reference LiDAR (E 899850 / N 6435230), le + // joueur qui s'approchait s'accrochait au PREMIER point raide rencontre, qui + // etait un ressaut isole de quelques decimetres devant la paroi, et + // l'escalade se terminait par un "sommet" apres 0,3 m gagnes en 1,2 s. + // + // La base de 4 m (slopeSampleStep) 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 ces + // deux valeurs demandent. + // + // Les valeurs sont accordees sur wallSlope et non choisies au hasard : a 45 + // degres pile, 6 m parcourus sur la surface font gagner 4,24 m. Un point tout + // juste au seuil passe donc de justesse, et tout ce qui s'aplatit avant est + // rejete. + float minWallRun = 6.0f; + float minWallRise = 4.0f; + + // --- Deplacement --------------------------------------------------------- + + // Vitesse d'ascension/descente LE LONG DE LA SURFACE, en m/s. + // + // 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 (14 m/s, soit ~10 fois + // une marche reelle), choisie pour que traverser 25 km2 ne prenne pas une + // soiree. Ce qui compte pour la consigne "plus lent que la marche" est le + // RAPPORT, et il est de 14 : on grimpe quatorze fois moins vite qu'on ne + // marche. Sur la paroi de reference (61 degres) ca donne 0,87 m/s de gain + // d'altitude, soit 44 m en 50 s. + float climbSpeed = 1.0f; + + // Vitesse de traversee laterale, en m/s. Plus lente que l'ascension parce + // qu'une traversee l'est reellement : on deplace un appui a la fois sans + // jamais pouvoir se reposer sur les jambes comme en montee. + float traverseSpeed = 0.6f; + + // Distance a laquelle l'oeil se tient de la surface, en m. Purement une + // question de cadrage : colle a la paroi, la camera aurait le rocher dans + // son plan proche. 0,6 m ~ une longueur d'avant-bras, ce qui donne la vue + // qu'a reellement un grimpeur, nez a une prise. + float wallOffset = 0.6f; + + // Elevation de l'oeil au-dessus du point d'accroche, en m. PETITE, et c'est + // le point : sur une paroi, le grimpeur est ETENDU LE LONG de la surface, il + // n'est pas debout dessus. Les 1,7 m de la marche n'ont aucun sens ici - ils + // placeraient l'oeil bien au-dessus des mains. + float eyeRise = 0.3f; + + // --- Energie ------------------------------------------------------------- + // + // Une seule jauge dans [0, 1], volontairement isolee : la consigne de + // session demande ce parametre seul, pas un systeme de besoins primaires. + // Les couts sont exprimes PAR METRE et non par seconde partout ou un travail + // physique est en jeu - monter 40 m coute la meme chose qu'on le fasse vite + // ou lentement, ce qui est le comportement correct et evite en prime de + // rendre la jauge dependante du nombre d'images par seconde. + + // Cout par metre d'altitude GAGNEE. 0,016 /m => une jauge pleine vaut + // 62,5 m de paroi strictement verticale. + // + // C'est ce chiffre qui fixe ce que l'escalade permet dans ce massif, et le + // resultat est interessant : les parois de reference abordables font 30 a + // 44 m, donc elles passent ; les grandes falaises du massif font 250 a 276 m + // (mesurees par find_climb_walls.py), donc elles sont 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, ou une paroi de + // 270 m se fait en plusieurs longueurs avec des relais. + float staminaPerMeterUp = 0.016f; + + // Cout par metre d'altitude PERDUE en desescalade. Trois fois moins cher que + // la montee. Physiquement une desescalade fatigue presque autant ; le choix + // est un choix de JEU, et il est delibere : 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. + float staminaPerMeterDown = 0.005f; + + // Cout par metre parcouru a l'HORIZONTALE (traversee, et la composante + // horizontale d'une montee en paroi non verticale). Meme ordre que la + // desescalade : on ne lutte pas contre la pesanteur. + float staminaPerMeterLateral = 0.005f; + + // Cout par SECONDE quand on est accroche sans bouger. Le seul cout au temps + // du modele, et il en faut un : sans lui, rester suspendu serait un repos + // gratuit, et la jauge cesserait de limiter quoi que ce soit. 0,004 /s => + // 250 s (4 min) suspendu immobile, ce qui est genereux mais fini. + float staminaHangPerSecond = 0.004f; + + // Recuperation par seconde, une fois REVENU AU SOL. 0,05 /s => 20 s de repos + // pour une jauge vide. La recuperation ne se fait jamais en paroi : c'est ce + // qui force a topper ou a redescendre, donc ce qui fait de la jauge une + // contrainte de trajet et pas seulement un compteur. + float staminaRecoveryPerSecond = 0.05f; + + // Demi-largeur du grimpeur pour la COLLISION, en m. Meme valeur que le + // joueur a pied (Camera::bodyRadius_) : c'est le meme corps. + float bodyRadius = 0.35f; + + // --- PHASE 23 : adherence de la paroi ------------------------------- + // + // L'humidite locale (WeatherSample::wetness) change la facon dont le rocher + // tient sous les mains et les pieds. L'effet est MESURE et porte sur la + // physique existante - la vitesse de progression et le cout energetique - + // et non sur un booleen "ca glisse" qui n'aurait aucune traduction dans le + // modele. C'est la demande explicite du cahier des charges de la phase. + // + // VALEURS PROVISOIRES, comme celles de WeatherParams. Elles vivent ici parce + // qu'elles decrivent la REPONSE DU GRIMPEUR a une paroi mouillee, pas + // l'atmosphere. + + // Adherence d'une paroi RUISSELANTE, dans ]0, 1]. 0,45 : sur du rocher + // trempe on grimpe a peu pres deux fois moins vite, ce qui est l'ordre de + // grandeur reel - un calcaire mouille est franchement savonneux, un granite + // beaucoup moins, et le modele ne connait pas la nature de la roche (voir la + // limite deja notee en Phase 22 sur les gisements : le LiDAR ne porte aucune + // information de materiau). + float wetGrip = 0.45f; + + // Cout energetique d'une paroi de grip minimal, en multiple du cout sec. + // 1,8 : lutter contre le glissement fatigue, on serre les prises. Le cout + // varie donc DANS LE MEME SENS que le temps passe, ce qui est ce qui rend + // une paroi mouillee reellement plus dure a monter et pas seulement plus + // lente. + float wetStaminaGain = 1.8f; + + // Demi-hauteur du corps le long de la paroi, en m. Le grimpeur est etendu + // sur la surface, son corps occupe donc une bande CENTREE sur le point + // d'accroche, et non une bande qui part des pieds comme a la marche. + float bodyHalfHeight = 0.9f; +}; + +// Comment se termine une session d'escalade. Une valeur par sortie DISTINCTE, +// et non un simple booleen, parce que les trois n'ont pas les memes suites : +// seul le sommet laisse le joueur la ou il est arrive. +enum class ClimbExit { + None, // toujours en paroi + ToppedOut, // sommet atteint : on reste sur place, en marche + Released, // lachage volontaire : retour au pied + Exhausted, // jauge vide : chute, retour au pied +}; + +// Position, energie et etat d'une escalade en cours. +// +// Comme Paraglider et Bike, cette classe ne connait NI Vulkan NI la Camera. Elle +// consomme core/HeightSampler (la surface et sa pente) et core/CollisionSolver +// (les obstacles), donc elle est EXECUTEE dans les tests headless. +// +// LE MODELE DE DEPLACEMENT, 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/descendre) et la ligne de niveau (traverser). +// +// Ce choix est le meme invariant que celui du velo ("la verticale n'est jamais +// une variable d'etat, position.y est relue de heightAt() a chaque pas"), et il +// 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. Sur une paroi a 87 degres - il y en a de vraies dans la zone +// de jeu, voir NOTES-PHASE-ESCALADE.md - avancer d'un metre le long de la +// surface fait gagner 0,999 m d'altitude et 0,05 m a l'horizontale : la montee +// est donc quasi verticale, sans qu'aucun cas particulier n'ait ete ecrit. +// +// La limite honnete de ce modele est celle de la 2,5D : un SURPLOMB n'existe +// pas. Une paroi qui deverse est representee par la heightmap comme une paroi +// tres raide mais positive, et se grimpe comme telle. +class Climber { +public: + explicit Climber(const ClimberParams& params = {}); + + const ClimberParams& params() const { return params_; } + + // --- Detection de paroi (utilisable sans etre en escalade) --------------- + + // Pente locale de la surface (magnitude du gradient, rise par metre) en + // (worldX, worldZ). Lue sur une base de 2 x slopeSampleStep. + float slopeAt(const HeightSampler& terrain, float worldX, float worldZ) const; + + // Cette position est-elle sur une paroi grimpable ? + bool isWall(const HeightSampler& terrain, float worldX, float worldZ) const { + return slopeAt(terrain, worldX, worldZ) >= params_.wallSlope; + } + + // Cherche une paroi devant le joueur et s'y engage. + // + // eyePosition : position de l'oeil du joueur a pied (Camera::position()). + // lookDirection : direction du regard ; seule sa projection horizontale + // compte, regarder le ciel ne doit pas changer la cible. + // + // Sonde la surface a intervalles reguliers de 0 a params.reach devant le + // joueur et s'accroche au PREMIER point dont la pente atteint wallSlope. + // Sonder plusieurs distances et non la seule portee maximale est ce qui + // permet de s'engager qu'on soit colle a la paroi ou a deux metres. + // + // Un point n'est retenu que s'il est une paroi ET si grimper depuis lui fait + // reellement gagner de la hauteur (voir minWallRun / minWallRise) : sans + // cette seconde condition, on s'accroche au premier ressaut venu. + // + // Renvoie false et ne change RIEN si aucune paroi n'est a portee, ou si la + // jauge est deja trop basse pour s'engager (voir minStaminaToStart()). + // L'appelant peut donc appeler sans verifier quoi que ce soit d'abord. + bool tryStart(const HeightSampler& terrain, const glm::vec3& eyePosition, + const glm::vec3& lookDirection); + + // --- Escalade en cours --------------------------------------------------- + + // Fait avancer l'escalade d'un pas de temps. + // + // climbInput dans [-1, 1] : +1 monte, -1 desescalade + // traverseInput dans [-1, 1] : +1 vers la DROITE du grimpeur face a la + // paroi, -1 vers la gauche + // terrain : impose la surface suivie ET fournit la pente. Obligatoire. + // obstacles : troncs et souches. nullptr = on traverse tout. + // + // Les entrees sont ecretees en interne, comme Bike::update. + // + // Renvoie la facon dont l'escalade s'est terminee PENDANT ce pas, ou + // ClimbExit::None si elle continue. Quand la valeur n'est pas None, climbing() + // est repasse a false et position() est deja la position finale : sommet pour + // ToppedOut, pied de paroi pour Released et Exhausted. + // + // PHASE 23 - grip : adherence de la paroi dans [0, 1], 1 = rocher sec. + // L'appelant la tire de l'humidite locale (voir gripForWetness). Elle + // RALENTIT la progression et RENCHERIT chaque metre gagne. Sa valeur par + // defaut est 1 : tous les appelants ecrits avant la Phase 23 - dont les + // tests de la Phase 14 - decrivent exactement la meme escalade. + ClimbExit update(float deltaTime, float climbInput, float traverseInput, + const HeightSampler& terrain, const CollisionSolver* obstacles, + float grip = 1.0f); + + // Adherence correspondant a une humidite dans [0, 1]. Interpolation lineaire + // entre 1 (sec) et params.wetGrip (ruisselant). + // + // Exposee comme une fonction de la CLASSE et non laissee a l'appelant pour + // qu'il n'y ait qu'une seule traduction humidite -> adherence dans le jeu : + // main.cpp et les tests doivent employer la meme, sinon le comportement + // teste n'est pas celui qui est joue. + float gripForWetness(float wetness) const; + + // Lachage volontaire. Meme issue qu'une chute d'epuisement - retour au pied + // de la paroi - et c'est voulu : lacher une paroi, c'est descendre au pied, + // qu'on l'ait decide ou non. Une seule reinitialisation de position a ecrire, + // donc une seule a verifier. + // + // Sans effet (et renvoie None) si on n'est pas en escalade. + ClimbExit release(); + + // Recuperation au sol. A appeler a chaque frame QUAND ON NE GRIMPE PAS ; + // sans effet pendant une escalade, l'appelant n'a donc pas a s'en soucier. + void restOnGround(float deltaTime); + + bool climbing() const { return climbing_; } + + // Position de l'OEIL, en monde. + // + // ATTENTION, la convention n'est PAS celle des trois autres activites. A + // pied, a velo et en parapente, position() est l'oeil place a eyeHeight + // AU-DESSUS de la surface. En escalade, le grimpeur est CONTRE la surface : + // l'oeil est le point d'accroche decale de wallOffset vers l'exterieur de la + // paroi (le long de la descente) et de eyeRise vers le haut. C'est la seule + // facon d'obtenir la vue reelle d'un grimpeur, et c'est aussi ce qui + // 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. + glm::vec3 position() const; + + // Point d'accroche : le point exactement SUR la surface. C'est l'etat reel + // du grimpeur ; position() n'en est qu'une vue. Expose parce que c'est lui + // qu'un test doit confronter a heightAt(), et lui qui devient la position du + // joueur au sommet. + const glm::vec3& anchor() const { return anchor_; } + + // Point ou le joueur s'est engage sur la paroi - du terrain marchable, par + // construction. C'est la position de repli d'une chute ou d'un lachage. + const glm::vec3& groundAnchor() const { return groundAnchor_; } + + // Jauge d'energie dans [0, 1]. 1 = frais, 0 = chute. + float stamina() const { return stamina_; } + + // Energie minimale pour S'ENGAGER sur une paroi. Un seuil d'entree distinct + // de zero evite le cas absurde ou le joueur s'accroche avec 1 % de jauge et + // retombe dans la seconde ; il laisse de quoi monter puis redescendre. + static constexpr float minStaminaToStart() { return 0.15f; } + + // Altitude gagnee depuis l'engagement, en m. Negative si on est descendu + // sous son point de depart. Sert au journal et aux tests : c'est la mesure + // qui dit si une escalade a reellement servi a quelque chose. + float heightGained() const { return anchor_.y - groundAnchor_.y; } + + // Direction horizontale unitaire vers l'INTERIEUR de la paroi (la ligne de + // plus grande pente, vers le haut). C'est la direction dans laquelle le + // grimpeur fait face. Renvoie (0,0,0) sur une surface strictement plate, ou + // elle n'est pas definie - cas qui ne peut pas se produire en paroi. + glm::vec3 wallFacing(const HeightSampler& terrain) const; + + // Normale horizontale sortante de la paroi : -wallFacing(). C'est vers la + // que l'oeil est decale, et c'est la direction dans laquelle on tombe. + glm::vec3 wallOutward(const HeightSampler& terrain) const { + return -wallFacing(terrain); + } + +private: + // Gradient de la surface, differences finies centrees. .x = dh/dx, + // .y = dh/dz. Meme construction que Bike::terrainGradient. + glm::vec2 gradientAt(const HeightSampler& terrain, float worldX, float worldZ) const; + + // Le grimpeur a-t-il atteint du terrain ou l'on tient debout ? + // + // DEUX points sont testes, 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, donc y terminer + // l'escalade est le comportement correct et non un pis-aller. + bool hasToppedOut(const HeightSampler& terrain) const; + + // Gain d'altitude qu'on obtiendrait en grimpant minWallRun metres de surface + // depuis (worldX, worldZ), en suivant la ligne de plus grande pente comme le + // fait update(). C'est la mesure qui distingue une paroi d'un ressaut isole : + // elle repond a "grimper ici mene-t-il quelque part ?" plutot qu'a "est-ce + // raide ici ?", qui est la question a laquelle un seuil de pente repond deja + // et qui ne suffit pas. + float wallRise(const HeightSampler& terrain, float worldX, float worldZ) const; + + // Recolle le point d'accroche sur la surface. Appele apres tout deplacement + // horizontal, comme Bike le fait de position_.y. + void snapAnchor(const HeightSampler& terrain); + + ClimberParams params_; + + glm::vec3 anchor_{0.0f}; // point SUR la surface + glm::vec3 groundAnchor_{0.0f}; // pied de paroi, position de repli + + float stamina_ = 1.0f; + bool climbing_ = false; + + // Cache de la normale sortante du dernier pas. position() est const et ne + // recoit pas de terrain : elle ne peut donc pas recalculer le gradient. Le + // cacher ici est ce qui permet a l'appelant de lire la pose de la camera + // sans avoir a repasser le terrain. + glm::vec3 outward_{1.0f, 0.0f, 0.0f}; +}; + +} // namespace vercora diff --git a/src/world/CraftMesh.cpp b/src/world/CraftMesh.cpp new file mode 100644 index 0000000..03d20e1 --- /dev/null +++ b/src/world/CraftMesh.cpp @@ -0,0 +1,303 @@ +#include "world/CraftMesh.hpp" + +#include + +#include +#include +#include +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; + +// Teintes de sommet (materiau Object, couleur au sommet, comme HarvestMesh). +const glm::vec3 kCordColor {0.55f, 0.50f, 0.32f}; // fibre sechee, paille +const glm::vec3 kHandleColor {0.52f, 0.40f, 0.26f}; // bois ecorce +const glm::vec3 kBladeColor {0.38f, 0.38f, 0.40f}; // silex, meme famille que l'eclat +const glm::vec3 kStoneColor {0.50f, 0.49f, 0.46f}; // pierres du cercle +const glm::vec3 kStickColor {0.36f, 0.26f, 0.17f}; // petit bois +const glm::vec3 kCharColor {0.10f, 0.09f, 0.08f}; // fond noirci du foyer +const glm::vec3 kAshColor {0.58f, 0.57f, 0.55f}; // cendre gris clair +const glm::vec3 kPitchColor {0.12f, 0.08f, 0.05f}; // poix brun-noir + +// Facette orientee VERS L'EXTERIEUR d'un point interieur donne : tous les +// volumes de ce fichier sont convexes par morceaux, ce qui suffit a garantir +// des normales sortantes sans se fier a l'ordre d'enumeration des sommets. +void facetOut(MeshData& mesh, glm::vec3 a, glm::vec3 b, glm::vec3 c, + const glm::vec3& inside, const glm::vec3& color) { + glm::vec3 rawNormal = glm::cross(b - a, c - a); + const float length = glm::length(rawNormal); + if (length < 1e-9f) { + return; // triangle degenere : aucune normale, rien a dessiner + } + const glm::vec3 centroid = (a + b + c) / 3.0f; + if (glm::dot(rawNormal, centroid - inside) < 0.0f) { + std::swap(b, c); + rawNormal = -rawNormal; + } + const glm::vec3 normal = rawNormal / length; + + const auto base = static_cast(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 }); +} + +// Pave de demi-dimensions `half`, tourne de `yaw` autour de Y (meme convention +// que GroundItem : +X tourne vers (cos, 0, -sin)). +void appendBox(MeshData& mesh, const glm::vec3& center, const glm::vec3& half, + float yaw, const glm::vec3& color) { + const float c = std::cos(yaw); + const float s = std::sin(yaw); + std::array p{}; + for (int i = 0; i < 8; ++i) { + const glm::vec3 local{ (i & 1) ? half.x : -half.x, + (i & 2) ? half.y : -half.y, + (i & 4) ? half.z : -half.z }; + p[static_cast(i)] = + center + glm::vec3(c * local.x + s * local.z, local.y, -s * local.x + c * local.z); + } + // Six faces, deux triangles chacune (indices des coins : bit0 = x, bit1 = y, + // bit2 = z). + const int faces[6][4] = { + {0, 2, 6, 4}, {1, 3, 7, 5}, // -X, +X + {0, 1, 5, 4}, {2, 3, 7, 6}, // -Y, +Y + {0, 1, 3, 2}, {4, 5, 7, 6}, // -Z, +Z + }; + for (const auto& f : faces) { + facetOut(mesh, p[f[0]], p[f[1]], p[f[2]], center, color); + facetOut(mesh, p[f[0]], p[f[2]], p[f[3]], center, color); + } +} + +// Motte bruitee : octaedre subdivise une fois, sommets UNIQUES bruites (meme +// construction que le galet et la motte d'argile, pour la meme raison : +// bruiter les triangles independamment ouvrirait le volume). +void appendLump(MeshData& mesh, const glm::vec3& center, const glm::vec3& half, + uint32_t seed, float minBump, const glm::vec3& color) { + std::vector 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 }, + }; + const std::array, 8> 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}, + } }; + // Subdivision sans cache d'aretes : les milieux sont recalcules a + // l'identique (meme formule, memes operandes), donc les sommets partages + // coincident exactement et le volume reste ferme ; le bruit, lui, est tire + // par POSITION (hash), pas par ordre de creation, pour la meme raison. + std::vector> tris; + for (const auto& f : faces) { + const glm::vec3 a = points[f[0]], b = points[f[1]], c = points[f[2]]; + const glm::vec3 ab = glm::normalize(a + b); + const glm::vec3 bc = glm::normalize(b + c); + const glm::vec3 ca = glm::normalize(c + a); + tris.push_back({ a, ab, ca }); + tris.push_back({ ab, b, bc }); + tris.push_back({ ca, bc, c }); + tris.push_back({ ab, bc, ca }); + } + const auto bumpAt = [&](const glm::vec3& v) { + const auto q = [](float x) { return static_cast(std::lround(x * 1000.0f) + 5000); }; + std::mt19937 rng(seed ^ (q(v.x) * 73856093u) ^ (q(v.y) * 19349663u) ^ (q(v.z) * 83492791u)); + return std::uniform_real_distribution(minBump, 1.0f)(rng); + }; + for (const auto& t : tris) { + std::array w{}; + for (int k = 0; k < 3; ++k) { + const glm::vec3 v = t[static_cast(k)] * bumpAt(t[static_cast(k)]); + w[static_cast(k)] = center + v * half; + } + facetOut(mesh, w[0], w[1], w[2], center, color); + } +} + +// Cone tres surbaisse (meme forme que le tas de sable de la Phase 22). +void appendMound(MeshData& mesh, float halfHeight, float width, uint32_t seed, + const glm::vec3& color) { + constexpr int kSides = 10; + const glm::vec3 apex{ 0.0f, halfHeight, 0.0f }; + const glm::vec3 baseCenter{ 0.0f, -halfHeight, 0.0f }; + std::mt19937 rng(seed); + std::uniform_real_distribution wobble(0.80f, 1.0f); + std::vector rim; + for (int i = 0; i < kSides; ++i) { + const float angle = kTwoPi * static_cast(i) / static_cast(kSides); + const float r = width * wobble(rng); + rim.push_back({ r * std::cos(angle), -halfHeight, r * std::sin(angle) }); + } + const glm::vec3 inside{ 0.0f, -0.5f * halfHeight, 0.0f }; + for (int i = 0; i < kSides; ++i) { + const glm::vec3& a = rim[static_cast(i)]; + const glm::vec3& b = rim[static_cast((i + 1) % kSides)]; + facetOut(mesh, apex, a, b, inside, color); + // Base fermee (vue de dessous depuis un talus), orientee vers le bas. + facetOut(mesh, baseCenter, b, a, 0.5f * apex, color); + } +} + +// PHASE 28 (Agent 3). Poutre de section carree (demi-cote t) de a a b, dans +// n'importe quelle direction (appendBox ne sait tourner qu'autour de Y). +void appendBeam(MeshData& mesh, const glm::vec3& a, const glm::vec3& b, float t, + const glm::vec3& color) { + const glm::vec3 axis = b - a; + const float length = glm::length(axis); + if (length < 1e-6f) { + return; + } + const glm::vec3 d = axis / length; + const glm::vec3 helper = (std::abs(d.y) < 0.9f) ? glm::vec3(0.0f, 1.0f, 0.0f) + : glm::vec3(1.0f, 0.0f, 0.0f); + const glm::vec3 u = glm::normalize(glm::cross(d, helper)) * t; + const glm::vec3 v = glm::normalize(glm::cross(d, u)) * t; + std::array p{}; + for (int i = 0; i < 8; ++i) { + p[static_cast(i)] = ((i & 1) ? b : a) + ((i & 2) ? u : -u) + ((i & 4) ? v : -v); + } + const glm::vec3 center = 0.5f * (a + b); + const int faces[6][4] = { + {0, 2, 6, 4}, {1, 3, 7, 5}, {0, 1, 5, 4}, {2, 3, 7, 6}, {0, 1, 3, 2}, {4, 5, 7, 6}, + }; + for (const auto& f : faces) { + facetOut(mesh, p[f[0]], p[f[1]], p[f[2]], center, color); + facetOut(mesh, p[f[0]], p[f[2]], p[f[3]], center, color); + } +} + +} // namespace + +MeshData cordMeshData() { + MeshData mesh; + mesh.name = "ligature (Phase 28)"; + // Anneau de huit troncons : un echeveau enroule, pose a plat. + constexpr int kSegments = 8; + const float ringRadius = kCordWidth - kCordRadius; + const float segmentHalf = ringRadius * std::sin(0.5f * kTwoPi / kSegments) + 0.004f; + for (int i = 0; i < kSegments; ++i) { + const float angle = kTwoPi * (static_cast(i) + 0.5f) / static_cast(kSegments); + const glm::vec3 center{ ringRadius * std::cos(angle), 0.0f, -ringRadius * std::sin(angle) }; + // Tangente a l'anneau : yaw = angle + 90 degres. + appendBox(mesh, center, { segmentHalf, kCordRadius, 0.8f * kCordRadius }, + angle + 0.25f * kTwoPi, kCordColor); + } + return mesh; +} + +MeshData axeMeshData() { + MeshData mesh; + mesh.name = "hache emmanchee (Phase 28)"; + const float handleHalf = 0.018f; + const float bindExtra = 0.006f; // surepaisseur de la ligature + // Manche le long de +X, sureleve de la surepaisseur de la ligature : c'est + // elle, la plus epaisse, qui touche le sol. + const float handleY = -kAxeRadius + handleHalf + bindExtra; + appendBox(mesh, { 0.0f, handleY, 0.0f }, + { 0.5f * kAxeLength, handleHalf, handleHalf }, 0.0f, kHandleColor); + // Lame : eclat aplati pres du bout +X, deborde d'un cote du manche. + const float bladeX = 0.5f * kAxeLength - 0.05f; + appendLump(mesh, { bladeX, 0.0f, 0.035f }, { 0.045f, kAxeRadius, 0.06f }, + 0xA7E5u, 0.85f, kBladeColor); + // Ligature : un manchon un peu plus epais que le manche, juste derriere. + appendBox(mesh, { bladeX - 0.05f, handleY, 0.0f }, + { 0.02f, handleHalf + bindExtra, handleHalf + bindExtra }, 0.0f, kCordColor); + return mesh; +} + +MeshData hearthMeshData() { + MeshData mesh; + mesh.name = "foyer (Phase 28)"; + // Fond noirci : un disque tres fin au ras du sol. + appendBox(mesh, { 0.0f, -kHearthRadius + 0.004f, 0.0f }, + { 0.22f, 0.004f, 0.22f }, 0.0f, kCharColor); + // Les TROIS pierres consommees par la recette, en triangle. + const float stoneHalf = 0.11f; + const float ringRadius = kHearthWidth - stoneHalf; + for (int i = 0; i < 3; ++i) { + const float angle = kTwoPi * static_cast(i) / 3.0f; + appendLump(mesh, + { ringRadius * std::cos(angle), 0.0f, ringRadius * std::sin(angle) }, + { stoneHalf, kHearthRadius, stoneHalf }, 0x4EA27u + static_cast(i), + 0.78f, kStoneColor); + } + // Les DEUX branches consommees, croisees au centre. + const float stickHalf = 0.022f; + appendBox(mesh, { 0.0f, -kHearthRadius + 0.008f + stickHalf, 0.0f }, + { 0.24f, stickHalf, stickHalf }, 0.5f, kStickColor); + appendBox(mesh, { 0.0f, -kHearthRadius + 0.008f + 3.0f * stickHalf, 0.0f }, + { 0.24f, stickHalf, stickHalf }, -0.5f, kStickColor); + return mesh; +} + +MeshData ashMeshData() { + MeshData mesh; + mesh.name = "cendre (Phase 28)"; + appendMound(mesh, kAshRadius, kAshWidth, 0xA54u, kAshColor); + return mesh; +} + +MeshData pitchMeshData() { + MeshData mesh; + mesh.name = "poix (Phase 28)"; + appendLump(mesh, { 0.0f, 0.0f, 0.0f }, { kPitchWidth, kPitchRadius, kPitchWidth }, + 0x917C4u, 0.90f, kPitchColor); + return mesh; +} + +MeshData pitchedAxeMeshData() { + MeshData mesh = axeMeshData(); + mesh.name = "hache renforcee (Phase 28)"; + // Manchon de poix par-dessus la ligature : un peu plus long, meme + // epaisseur maximale (la lame reste l'element le plus epais : kAxeRadius). + const float handleHalf = 0.018f; + const float bindExtra = 0.006f; + const float handleY = -kAxeRadius + handleHalf + bindExtra; + const float bladeX = 0.5f * kAxeLength - 0.05f; + appendBox(mesh, { bladeX - 0.05f, handleY, 0.0f }, + { 0.032f, handleHalf + bindExtra, handleHalf + bindExtra + 0.002f }, + 0.0f, kPitchColor); + return mesh; +} + +MeshData shelterMeshData() { + MeshData mesh; + mesh.name = "abri de branches (Phase 28)"; + const float bottom = -kShelterRadius; + const float ridgeY = kShelterRadius - 0.06f; + const float frontZ = -kShelterHalfDepth + 0.10f; + const float backZ = kShelterHalfDepth - 0.10f; + const float logHalf = 0.06f; + // Deux montants (buches) a l'avant, du sol a la faitiere. + for (const float x : { -0.85f, 0.85f }) { + appendBeam(mesh, { x, bottom, frontZ }, { x, ridgeY, frontZ }, logHalf, kHandleColor); + } + // Faitiere (buche) posee en travers des montants. + appendBeam(mesh, { -kShelterHalfWidth + logHalf, ridgeY, frontZ }, + { kShelterHalfWidth - logHalf, ridgeY, frontZ }, logHalf, kHandleColor); + // Buche de base a l'arriere, au pied des branches. + appendBeam(mesh, { -0.95f, bottom + logHalf, backZ }, { 0.95f, bottom + logHalf, backZ }, + logHalf, kHandleColor); + // Six branches inclinees de la faitiere a la buche de base. + for (int i = 0; i < 6; ++i) { + const float x = -0.80f + 0.32f * static_cast(i); + appendBeam(mesh, { x, ridgeY - 0.02f, frontZ + 0.08f }, + { x, bottom + 2.0f * logHalf + 0.03f, backZ - 0.02f }, 0.03f, kStickColor); + } + // Deux ligatures aux noeuds montant/faitiere. + for (const float x : { -0.85f, 0.85f }) { + appendBox(mesh, { x, ridgeY - 0.10f, frontZ }, { logHalf + 0.012f, 0.03f, logHalf + 0.012f }, + 0.0f, kCordColor); + } + return mesh; +} + +} // namespace vercora diff --git a/src/world/CraftMesh.hpp b/src/world/CraftMesh.hpp new file mode 100644 index 0000000..b39fde9 --- /dev/null +++ b/src/world/CraftMesh.hpp @@ -0,0 +1,64 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +namespace vercora { + +// =========================================================================== +// PHASE 28 : les geometries des objets FACONNES (world/Crafting). +// =========================================================================== +// Meme contrat que world/HarvestMesh.hpp et world/StoneMesh.hpp, dont ce fichier +// est le prolongement : genere EN CODE, dimensions ABSOLUES (aucune echelle a +// l'instance), mesh centre sur l'origine y compris verticalement, objets +// couches le long de +X (meme convention de yaw que la buche et l'eclat). +// +// Ce sont des geometries de LISIBILITE bas-poly, pas des modeles finis : chaque +// objet doit se reconnaitre a sa silhouette, puisque le jeu n'a aucune liste +// d'inventaire a l'ecran (philosophie "zero menu"). +// +// Le foyer n'a qu'UN mesh, qu'il soit allume ou eteint : le renderer n'a ni +// lumiere ponctuelle ni particules (NOTES-PHASE28-DESIGN.md §4). L'etat de +// combustion vit dans world/Crafting (HearthSet) et se lit dans le journal. + +// Ligature : un echeveau de fibres torsadees, anneau plat pose au sol. +MeshData cordMeshData(); + +// Hache emmanchee : un manche (branche ecorcee) le long de +X, un eclat en +// lame a son extremite, et la ligature qui les tient. +MeshData axeMeshData(); + +// Foyer : trois pierres en cercle autour de deux branches croisees. +MeshData hearthMeshData(); + +// Cendre : un petit tas gris, tres plat. +MeshData ashMeshData(); + +// Poix : une galette sombre et luisante, plus plate que la perle de resine. +MeshData pitchMeshData(); + +// PHASE 28 (Agent 3). Hache renforcee : la hache, dont la ligature est noyee +// dans un manchon de poix brun-noir (meme encombrement que la hache). +MeshData pitchedAxeMeshData(); + +// PHASE 28 (Agent 3). Abri en appentis : deux montants (buches), une faitiere +// (buche) et une buche de base, six branches inclinees de la faitiere au sol, +// deux ligatures aux noeuds. Le SEUL objet de la famille qui n'est pas a +// l'echelle de la main : il n'est pas ramassable (groundItemIsPortable). +MeshData shelterMeshData(); + +// --- Dimensions en unites monde (les "rayons" sont des DEMI-HAUTEURS) -------- +inline constexpr float kCordRadius = 0.020f; // demi-epaisseur de l'echeveau +inline constexpr float kCordWidth = 0.075f; // rayon exterieur de l'anneau +inline constexpr float kAxeRadius = 0.030f; // demi-epaisseur de la lame couchee +inline constexpr float kAxeLength = 0.50f; // longueur totale du manche +inline constexpr float kHearthRadius = 0.110f; // demi-hauteur du cercle de pierres +inline constexpr float kHearthWidth = 0.40f; // rayon du cercle de pierres +inline constexpr float kAshRadius = 0.020f; // demi-hauteur du tas de cendre +inline constexpr float kAshWidth = 0.13f; +inline constexpr float kPitchRadius = 0.022f; // demi-hauteur de la galette +inline constexpr float kPitchWidth = 0.05f; +inline constexpr float kShelterRadius = 0.60f; // demi-hauteur de l'abri (1,2 m de haut) +inline constexpr float kShelterHalfWidth = 1.05f; // demi-largeur (le long de +X) +inline constexpr float kShelterHalfDepth = 0.90f; // demi-profondeur (le long de Z) + +} // namespace vercora diff --git a/src/world/Crafting.cpp b/src/world/Crafting.cpp new file mode 100644 index 0000000..4a2afc1 --- /dev/null +++ b/src/world/Crafting.cpp @@ -0,0 +1,365 @@ +#include "world/Crafting.hpp" + +#include "world/Ground.hpp" +#include "world/Inventory.hpp" +#include "world/Knapping.hpp" + +#include +#include +#include +#include + +namespace vercora { +namespace { + +constexpr glm::vec3 kFallbackFacing{ 1.0f, 0.0f, 0.0f }; + +// Meme projection que knapStones : longueur testee AVANT de normaliser. +glm::vec3 flatFacing(const glm::vec3& facing) { + glm::vec3 flat(facing.x, 0.0f, facing.z); + const float flatLength = std::sqrt(flat.x * flat.x + flat.z * flat.z); + return (flatLength > 1e-4f) ? flat / flatLength : kFallbackFacing; +} + +float horizontalDistanceSq(const glm::vec3& a, const glm::vec3& b) { + const float dx = a.x - b.x; + const float dz = a.z - b.z; + return dx * dx + dz * dz; +} + +// Besoin agrege d'une recette : total par nature et par source (deux lignes de +// la meme nature, comme le nucleus et le percuteur, s'additionnent). +struct Need { + std::array carried{}; + std::array placed{}; +}; + +Need needOf(const Recipe& recipe) { + Need need; + for (uint8_t i = 0; i < recipe.inCount; ++i) { + const CraftIngredient& ing = recipe.in[i]; + auto& table = (ing.source == CraftSource::Carried) ? need.carried : need.placed; + table[static_cast(ing.kind)] += ing.count; + } + return need; +} + +std::string plural(GroundItemKind kind, int n) { + return (n > 1) ? std::to_string(n) + " " + groundItemLabelPlural(kind) + : std::string(groundItemLabelIndefinite(kind)); +} + +} // namespace + +int axeBonusLogs(const Inventory& inventory) { + if (inventory.count(GroundItemKind::PitchedAxe) > 0) { + return kPitchedAxeBonusLogs; + } + return inventory.count(GroundItemKind::Axe) > 0 ? kAxeBonusLogs : 0; +} + +bool shelterNear(const Ground& ground, const glm::vec3& position) { + // Boucle directe, nature testee EN PREMIER : appelee a chaque image, elle ne + // doit rien couter quand aucun abri n'existe (cas de tous les scenarios + // anterieurs). + const float reachSq = kShelterReach * kShelterReach; + for (const GroundItem& item : ground.items()) { + if (item.kind != GroundItemKind::Shelter) { + continue; + } + if (std::abs(item.position.y - position.y) > kShelterVerticalTolerance) { + continue; + } + if (horizontalDistanceSq(item.position, position) <= reachSq) { + return true; + } + } + return false; +} + +int findRecipe(const char* id) { + for (std::size_t i = 0; i < kRecipes.size(); ++i) { + if (std::strcmp(kRecipes[i].id, id) == 0) { + return static_cast(i); + } + } + return -1; +} + +// --------------------------------------------------------------------------- +// HearthSet +// --------------------------------------------------------------------------- +void HearthSet::addLit(const glm::vec3& position, float nowHours) { + HearthState state; + state.position = position; + state.lit = true; + state.burnsUntilHours = nowHours + params_.burnHours; + hearths_.push_back(state); +} + +int HearthSet::nearest(const glm::vec3& position, float reach, bool wantLit) const { + int best = -1; + float bestSq = reach * reach; + for (std::size_t i = 0; i < hearths_.size(); ++i) { + if (hearths_[i].lit != wantLit) { + continue; + } + const float d = horizontalDistanceSq(hearths_[i].position, position); + if (d <= bestSq) { + bestSq = d; + best = static_cast(i); + } + } + return best; +} + +void HearthSet::relight(int index, float nowHours) { + if (index < 0 || static_cast(index) >= hearths_.size()) { + return; + } + HearthState& h = hearths_[static_cast(index)]; + h.lit = true; + h.burnsUntilHours = nowHours + params_.burnHours; +} + +void HearthSet::feed(int index) { + if (index < 0 || static_cast(index) >= hearths_.size()) { + return; + } + HearthState& h = hearths_[static_cast(index)]; + if (h.lit) { + h.burnsUntilHours += params_.feedHours; + } +} + +int HearthSet::update(float nowHours, Ground& ground) { + int extinguished = 0; + for (HearthState& h : hearths_) { + if (h.lit && nowHours >= h.burnsUntilHours) { + h.lit = false; + // La cendre se pose au CENTRE du foyer. Le foyer n'etant pas + // ramassable (findNearest l'ignore), c'est bien elle que R attrape. + ground.drop(GroundItemKind::Ash, h.position.x, h.position.z, 0.0f, 0.0f); + ++extinguished; + } + } + return extinguished; +} + +float HearthSet::remainingHours(int index, float nowHours) const { + if (index < 0 || static_cast(index) >= hearths_.size()) { + return 0.0f; + } + const HearthState& h = hearths_[static_cast(index)]; + return h.lit ? std::max(0.0f, h.burnsUntilHours - nowHours) : 0.0f; +} + +float HearthSet::warmthAt(const glm::vec3& position) const { + if (params_.warmthRadius <= 0.0f) { + return 0.0f; + } + float total = 0.0f; + for (const HearthState& h : hearths_) { + if (!h.lit) { + continue; + } + const float d = std::sqrt(horizontalDistanceSq(h.position, position)); + total += params_.warmthC * std::max(0.0f, 1.0f - d / params_.warmthRadius); + } + return total; +} + +// --------------------------------------------------------------------------- +// craftAt +// --------------------------------------------------------------------------- +CraftOutcome craftAt(Inventory& inventory, Ground& ground, HearthSet& hearths, + const glm::vec3& playerPosition, const glm::vec3& facing, + float nowHours) { + // 1. Ce qui est POSE a portee, par nature (les objets fixes n'en sont pas). + std::array, kGroundItemKindCount> placedByKind; + for (const int index : ground.indicesWithin(playerPosition, kCraftReach)) { + const GroundItem& item = ground.items()[static_cast(index)]; + if (groundItemIsPortable(item.kind)) { + placedByKind[static_cast(item.kind)].push_back(index); + } + } + // Les plus proches d'abord : c'est eux qui seront consommes. + for (auto& list : placedByKind) { + std::sort(list.begin(), list.end(), [&](int a, int b) { + const float da = horizontalDistanceSq(ground.items()[static_cast(a)].position, playerPosition); + const float db = horizontalDistanceSq(ground.items()[static_cast(b)].position, playerPosition); + return (da != db) ? da < db : a < b; + }); + } + + const int litHearth = hearths.nearest(playerPosition, kStationReach, true); + const int coldHearth = hearths.nearest(playerPosition, kStationReach, false); + + // 2. Premiere recette satisfaite ; sinon, la plus proche (moins d'unites + // manquantes ; a egalite, celle dont le joueur a DEJA reuni le plus + // d'unites ; a egalite encore, la plus SIMPLE, donc la plus loin dans la + // table - c'est ce qui rend, les mains vides, le refus historique de la + // percussion). + int chosen = -1; + int closest = -1; + int closestMissing = 1 << 30; + int closestSatisfied = -1; + for (std::size_t r = 0; r < kRecipes.size(); ++r) { + const Recipe& recipe = kRecipes[r]; + const Need need = needOf(recipe); + int missing = 0; + int satisfied = 0; + for (uint32_t k = 0; k < kGroundItemKindCount; ++k) { + const auto kind = static_cast(k); + const int carried = inventory.count(kind); + const int placed = static_cast(placedByKind[k].size()); + missing += std::max(0, need.carried[k] - carried); + missing += std::max(0, need.placed[k] - placed); + satisfied += std::min(need.carried[k], carried) + std::min(need.placed[k], placed); + } + if (recipe.station == CraftStation::LitHearth && litHearth < 0) ++missing; + if (recipe.station == CraftStation::ColdHearth && coldHearth < 0) ++missing; + if (missing == 0) { + chosen = static_cast(r); + break; + } + if (missing < closestMissing || + (missing == closestMissing && satisfied >= closestSatisfied)) { + closestMissing = missing; + closestSatisfied = satisfied; + closest = static_cast(r); + } + } + + CraftOutcome outcome; + if (chosen < 0) { + outcome.result = CraftResult::MissingIngredients; + outcome.recipe = closest; + const Recipe& recipe = kRecipes[static_cast(closest)]; + // La percussion garde MOT POUR MOT son message historique (Phase 6). + if (std::strcmp(recipe.id, "knap") == 0) { + outcome.message = knapResultMessage(KnapResult::NotEnoughStones); + return outcome; + } + const Need need = needOf(recipe); + std::string list; + const auto append = [&](const std::string& part) { + list += list.empty() ? part : ", " + part; + }; + for (uint32_t k = 0; k < kGroundItemKindCount; ++k) { + const auto kind = static_cast(k); + const int c = need.carried[k] - inventory.count(kind); + if (c > 0) append(plural(kind, c) + " (a porter)"); + const int p = need.placed[k] - static_cast(placedByKind[k].size()); + if (p > 0) append(plural(kind, p) + " (a poser a moins de 2,5 m)"); + } + if (recipe.station == CraftStation::LitHearth && litHearth < 0) { + append("un foyer allume a moins de 2 m (il faut chauffer)"); + } + if (recipe.station == CraftStation::ColdHearth && coldHearth < 0) { + append("un foyer eteint a moins de 2 m"); + } + outcome.message = std::string("Faconner (") + recipe.label + ") : il manque " + + list + "."; + return outcome; + } + + // 3. Execution. Tout a ete verifie : a partir d'ici plus aucun refus. + const Recipe& recipe = kRecipes[static_cast(chosen)]; + std::vector toRemove; + glm::vec3 barycenter(0.0f); + for (uint8_t i = 0; i < recipe.inCount; ++i) { + const CraftIngredient& ing = recipe.in[i]; + if (!ing.consumed) { + continue; + } + if (ing.source == CraftSource::Carried) { + inventory.remove(ing.kind, ing.count); + } else { + auto& list = placedByKind[static_cast(ing.kind)]; + for (uint8_t n = 0; n < ing.count; ++n) { + const int index = list.front(); + list.erase(list.begin()); + toRemove.push_back(index); + barycenter += ground.items()[static_cast(index)].position; + } + } + } + if (!toRemove.empty()) { + barycenter /= static_cast(toRemove.size()); + } + // Indices DECROISSANTS : pickUp echange avec le dernier, un ordre croissant + // deplacerait un objet a consommer sous un indice deja traite. + std::sort(toRemove.begin(), toRemove.end(), std::greater()); + for (const int index : toRemove) { + ground.pickUp(index); + } + + const glm::vec3 flat = flatFacing(facing); + if (recipe.hasOutput) { + float x = playerPosition.x + flat.x * kCraftDropDistance; + float z = playerPosition.z + flat.z * kCraftDropDistance; + if (!toRemove.empty()) { + x = barycenter.x; + z = barycenter.z; + } + ground.drop(recipe.out, x, z, std::atan2(-flat.z, flat.x), 0.0f); + if (recipe.effect == CraftEffect::LightNewHearth) { + hearths.addLit(ground.items().back().position, nowHours); + } + } + if (recipe.effect == CraftEffect::RelightHearth) { + hearths.relight(coldHearth, nowHours); + } else if (recipe.effect == CraftEffect::FeedHearth) { + hearths.feed(litHearth); + } + + outcome.result = CraftResult::Success; + outcome.recipe = chosen; + outcome.message = recipe.successMessage; + return outcome; +} + +// --------------------------------------------------------------------------- +// Reposer +// --------------------------------------------------------------------------- +bool chooseKindToPutDown(const Inventory& inventory, GroundItemKind preferred, + GroundItemKind* kindOut) { + if (inventory.count(preferred) > 0 && groundItemIsPortable(preferred)) { + if (kindOut != nullptr) *kindOut = preferred; + return true; + } + for (uint32_t k = 0; k < kGroundItemKindCount; ++k) { + const auto kind = static_cast(k); + if (inventory.count(kind) > 0 && groundItemIsPortable(kind)) { + if (kindOut != nullptr) *kindOut = kind; + return true; + } + } + return false; +} + +bool putDown(Inventory& inventory, Ground& ground, GroundItemKind kind, + const glm::vec3& playerPosition, const glm::vec3& facing) { + if (!groundItemIsPortable(kind) || inventory.count(kind) <= 0) { + return false; + } + const glm::vec3 flat = flatFacing(facing); + const glm::vec3 spot{ playerPosition.x + flat.x * kPutDownDistance, playerPosition.y, + playerPosition.z + flat.z * kPutDownDistance }; + // Decalage en spirale de Vogel (angle d'or) selon le nombre d'objets deja + // poses pres du point : n = 0 -> au point exact, puis 0,25 m x sqrt(n). + constexpr float kGoldenAngle = 2.39996323f; + constexpr float kSpacing = 0.25f; + const int n = static_cast(ground.indicesWithin(spot, 0.6f).size()); + const float radius = kSpacing * std::sqrt(static_cast(n)); + const float angle = kGoldenAngle * static_cast(n); + const float x = spot.x + radius * std::cos(angle); + const float z = spot.z + radius * std::sin(angle); + + inventory.remove(kind, 1); + ground.drop(kind, x, z, std::atan2(-flat.z, flat.x), 0.0f); + return true; +} + +} // namespace vercora diff --git a/src/world/Crafting.hpp b/src/world/Crafting.hpp new file mode 100644 index 0000000..9854256 --- /dev/null +++ b/src/world/Crafting.hpp @@ -0,0 +1,276 @@ +#pragma once + +#include "world/GroundItem.hpp" + +#include + +#include +#include +#include +#include + +namespace vercora { + +class Ground; +class Inventory; + +// =========================================================================== +// PHASE 28 : le FACONNAGE generique et diegetique. +// =========================================================================== +// Generalisation directe de world/Knapping (knapStones), sans Vulkan, sans +// menu, sans fichier de donnees. Une seule touche (C, celle de la percussion) : +// le joueur choisit la recette EN CHOISISSANT CE QU'IL POSE autour de lui. +// +// - Un ingredient est soit PORTE (compte dans Inventory), soit POSE (objet du +// Ground a moins de kCraftReach du joueur, a l'horizontale, meme critere que +// le ramassage). Un ingredient porte qui traine au sol ne compte pas, et +// inversement : c'est la difference entre "tordre des fibres dans ses mains" +// et "assembler une hache sur une souche". +// - Un ingredient peut etre un OUTIL : requis, non consomme (regle du +// percuteur, Knapping.hpp). +// - Une recette peut exiger un POSTE : un foyer allume (ou froid, pour le +// rallumer) a moins de kStationReach du joueur. +// - La table est parcourue dans l'ordre (complexite decroissante) ; la +// PREMIERE recette satisfaite est executee. Aucune autre regle. +// - Tout est verifie AVANT le moindre retrait : un refus ne touche ni a +// l'inventaire ni au sol (meme discipline qu'Inventory::remove). +// - Le produit nait AU SOL : au barycentre des ingredients poses consommes +// (l'objet nait la ou on l'a assemble), ou a 1,1 m devant le joueur si la +// recette ne consomme que du porte (meme depot que la percussion). +// +// knapStones (Knapping.cpp) reste en place, INCHANGE, comme facade testee +// (testStoneKnapping) ; la recette "knap" ci-dessous en reproduit exactement le +// resultat, ce que verifie testCraftingKnapUnchanged. + +enum class CraftSource : uint8_t { Carried, Placed }; + +enum class CraftStation : uint8_t { + None, + LitHearth, // un foyer EN COMBUSTION a portee + ColdHearth, // un foyer ETEINT a portee (pour le rallumer) +}; + +// Effet sur un foyer, en plus (ou a la place) d'un produit. +enum class CraftEffect : uint8_t { + None, + LightNewHearth, // le produit (Hearth) nait allume : l'eclat porte fait l'etincelle + RelightHearth, // le foyer froid a portee repart pour une duree de combustion + FeedHearth, // le foyer allume a portee brule plus longtemps +}; + +struct CraftIngredient { + GroundItemKind kind = GroundItemKind::Stone; + uint8_t count = 0; + CraftSource source = CraftSource::Carried; + bool consumed = true; // false = outil (requis, non consomme) +}; + +struct Recipe { + const char* id; // stable : journal, tests, future sauvegarde + const char* label; // francais, pour les messages ("un foyer") + std::array in; + uint8_t inCount; + bool hasOutput; + GroundItemKind out; + CraftStation station; + CraftEffect effect; + const char* successMessage; // francais, pret a journaliser +}; + +// Portee des objets POSES comptes par une recette : la meme que le ramassage +// (kPickupReach de main.cpp, 2,5 m) - ce qu'on peut ramasser, on peut +// l'assembler. +inline constexpr float kCraftReach = 2.5f; +// Portee d'un POSTE (foyer), mesuree depuis le joueur (NOTES-PHASE28-DESIGN §2 P4). +inline constexpr float kStationReach = 2.0f; +// Distance du depot devant le joueur : celle de la percussion (Knapping.cpp). +inline constexpr float kCraftDropDistance = 1.1f; + +// La table. Ordre = priorite (complexite decroissante). Voir NOTES-PHASE28.md. +inline constexpr std::array kRecipes = { { + // PHASE 28 (Agent 3), conception P6 : l'abri, la plus grosse recette, EN + // TETE (complexite decroissante). Objet FIXE : effet NeedsContext::sheltered. + { "shelter", "un abri", + { { { GroundItemKind::Log, 4, CraftSource::Placed, true }, + { GroundItemKind::Branch, 6, CraftSource::Placed, true }, + { GroundItemKind::Cord, 2, CraftSource::Placed, true } } }, + 3, true, GroundItemKind::Shelter, CraftStation::None, CraftEffect::None, + "Abri : deux buches en montants, une en faitiere, une a la base ; les branches " + "couchees contre la faitiere, les ligatures serrees aux noeuds." }, + { "hearth", "un foyer", + { { { GroundItemKind::Stone, 3, CraftSource::Placed, true }, + { GroundItemKind::Branch, 2, CraftSource::Placed, true }, + { GroundItemKind::Flake, 1, CraftSource::Carried, false } } }, + 3, true, GroundItemKind::Hearth, CraftStation::None, CraftEffect::LightNewHearth, + "Foyer : les pierres en cercle, le petit bois croise ; l'eclat frappe la pierre, " + "le feu prend." }, + { "hearth_relight", "rallumer le foyer", + { { { GroundItemKind::Branch, 2, CraftSource::Placed, true }, + { GroundItemKind::Flake, 1, CraftSource::Carried, false }, + {} } }, + 2, false, GroundItemKind::Hearth, CraftStation::ColdHearth, CraftEffect::RelightHearth, + "Foyer : du petit bois neuf, une etincelle, le feu repart." }, + // PHASE 28 (Agent 3), conception P5 : hache + poix, posees. Avant "axe" : + // plus complexe (elle consomme une hache). + { "pitched_axe", "une hache renforcee", + { { { GroundItemKind::Axe, 1, CraftSource::Placed, true }, + { GroundItemKind::Pitch, 1, CraftSource::Placed, true }, + {} } }, + 2, true, GroundItemKind::PitchedAxe, CraftStation::None, CraftEffect::None, + "Hache renforcee : la poix noie la ligature et colle l'eclat au manche." }, + { "axe", "une hache", + { { { GroundItemKind::Flake, 1, CraftSource::Placed, true }, + { GroundItemKind::Branch, 1, CraftSource::Placed, true }, + { GroundItemKind::Cord, 1, CraftSource::Placed, true } } }, + 3, true, GroundItemKind::Axe, CraftStation::None, CraftEffect::None, + "Hache : l'eclat est cale dans la fente de la branche et serre par la ligature." }, + { "pitch", "de la poix", + { { { GroundItemKind::Resin, 2, CraftSource::Placed, true }, + { GroundItemKind::Ash, 1, CraftSource::Placed, true }, + {} } }, + 2, true, GroundItemKind::Pitch, CraftStation::LitHearth, CraftEffect::None, + "Poix : la resine fond pres du feu, la cendre s'y melange ; une colle sombre fige." }, + { "cord", "une ligature", + { { { GroundItemKind::Fiber, 3, CraftSource::Carried, true }, {}, {} } }, + 1, true, GroundItemKind::Cord, CraftStation::None, CraftEffect::None, + "Ligature : trois tiges torsadees ensemble donnent un lien solide, pose a vos pieds." }, + { "hearth_feed_log", "alimenter le foyer", + { { { GroundItemKind::Log, 1, CraftSource::Placed, true }, {}, {} } }, + 1, false, GroundItemKind::Hearth, CraftStation::LitHearth, CraftEffect::FeedHearth, + "Foyer : la buche est posee sur les braises, le feu durera plus longtemps." }, + { "hearth_feed_branch", "alimenter le foyer", + { { { GroundItemKind::Branch, 1, CraftSource::Placed, true }, {}, {} } }, + 1, false, GroundItemKind::Hearth, CraftStation::LitHearth, CraftEffect::FeedHearth, + "Foyer : la branche est jetee au feu, il durera plus longtemps." }, + // Recette "numero 0" historique (Phase 6), placee EN DERNIER : c'est la plus simple. + { "knap", "un eclat", + { { { GroundItemKind::Stone, 1, CraftSource::Carried, true }, // nucleus + { GroundItemKind::Stone, 1, CraftSource::Carried, false }, // percuteur + {} } }, + 2, true, GroundItemKind::Flake, CraftStation::None, CraftEffect::None, + "Percussion : un eclat tranchant se detache et tombe a vos pieds." }, +} }; + +// --------------------------------------------------------------------------- +// PHASE 28 (Agent 3) : les EFFETS des objets faconnes, en fonctions pures. +// --------------------------------------------------------------------------- +// Rendement de la hache (conception P3/P5) : buches SUPPLEMENTAIRES par arbre +// debite, lues par Forest::scheduleBucking via Forest::setBuckingBonusLogs. +// La hache n'est PAS une condition d'abattage (scenario Vulkan A intact). +inline constexpr int kAxeBonusLogs = 1; +inline constexpr int kPitchedAxeBonusLogs = 2; +// Hache renforcee portee -> 2 ; sinon hache portee -> 1 ; sinon 0. Pas de +// cumul : on abat avec UN outil, le meilleur. +int axeBonusLogs(const Inventory& inventory); + +// Abri (conception P6) : le joueur est abrite a moins de kShelterReach +// (horizontal) d'un abri pose, avec la meme tolerance verticale que le +// ramassage (3 m) - un parapente qui survole l'abri n'est pas abrite. +inline constexpr float kShelterReach = 2.5f; +inline constexpr float kShelterVerticalTolerance = 3.0f; +bool shelterNear(const Ground& ground, const glm::vec3& position); + +// Indice d'une recette par son id, ou -1. +int findRecipe(const char* id); + +// --------------------------------------------------------------------------- +// Foyers : l'etat de combustion, tenu A PART du Ground (qui reste un sac de +// POD sans etat), sur le modele de ResinStand qui garde la memoire des arbres +// saignes hors de la Forest. Un foyer est identifie par sa POSITION : les +// indices du Ground ne sont pas stables (pickUp echange avec le dernier), un +// foyer, lui, ne bouge jamais. +// +// Le temps est celui du JEU (GameClock::totalHours), pas le temps reel : un +// feu dure une heure de jeu, que l'horloge soit acceleree ou gelee. +// --------------------------------------------------------------------------- +struct HearthParams { + float burnHours = 1.0f; // duree d'un allumage (proposition du document) + float feedHours = 1.0f; // gagne par branche ou buche ajoutee + // --- POINTS D'ACCROCHE (Agent 3), NON BRANCHES en Phase 28 -------------- + // Chaleur au centre et rayon ou elle s'annule (decroissance lineaire), + // proposes par NOTES-PHASE28-DESIGN §2 P1. Rien ne lit warmthAt dans + // main.cpp a ce stade. + float warmthC = 8.0f; + float warmthRadius = 6.0f; +}; + +struct HearthState { + glm::vec3 position{0.0f}; // celle de l'objet Hearth du Ground + bool lit = false; + float burnsUntilHours = 0.0f; // heure de jeu d'extinction (si lit) +}; + +class HearthSet { +public: + explicit HearthSet(const HearthParams& params = {}) : params_(params) {} + + // Enregistre un foyer neuf, ALLUME a nowHours. + void addLit(const glm::vec3& position, float nowHours); + + // Foyer le plus proche (horizontal) a portee, allume ou non selon wantLit ; + // -1 si aucun. + int nearest(const glm::vec3& position, float reach, bool wantLit) const; + + void relight(int index, float nowHours); + void feed(int index); + + // Fait avancer les combustions : tout foyer allume dont l'heure est passee + // s'eteint et laisse UNE cendre au sol, a son centre. Renvoie le nombre de + // foyers eteints a cet appel. + int update(float nowHours, Ground& ground); + + // Heures de combustion restantes (0 si eteint ou indice invalide). + float remainingHours(int index, float nowHours) const; + + // POINT D'ACCROCHE pour l'Agent 3 (chaleur -> NeedsContext::ambientTemperatureC). + // Somme des foyers allumes, chacun warmthC au centre, 0 a warmthRadius. + // Fonction pure ; NON appelee par le jeu en Phase 28. + float warmthAt(const glm::vec3& position) const; + + const std::vector& hearths() const { return hearths_; } + const HearthParams& params() const { return params_; } + +private: + HearthParams params_; + std::vector hearths_; +}; + +// --------------------------------------------------------------------------- +// Le geste +// --------------------------------------------------------------------------- +enum class CraftResult { + Success, + MissingIngredients, // aucune recette satisfaite ; le message dit ce qui manque +}; + +struct CraftOutcome { + CraftResult result = CraftResult::MissingIngredients; + int recipe = -1; // recette executee, ou la plus proche en cas de refus + std::string message; // francais, pret a journaliser +}; + +// facing : direction du regard (projetee et normalisee ici, avec repli si +// verticale, exactement comme knapStones). nowHours : GameClock::totalHours. +CraftOutcome craftAt(Inventory& inventory, Ground& ground, HearthSet& hearths, + const glm::vec3& playerPosition, const glm::vec3& facing, + float nowHours); + +// --------------------------------------------------------------------------- +// Reposer un objet porte (PHASE 28) : le geste manquant sans lequel le foyer +// et la hache - assembles AU SOL - seraient injouables. +// --------------------------------------------------------------------------- +// Nature a reposer : `preferred` (le dernier objet ramasse) si le joueur en +// porte encore, sinon la premiere nature portee dans l'ordre de l'enum. false +// si l'inventaire est vide. +bool chooseKindToPutDown(const Inventory& inventory, GroundItemKind preferred, + GroundItemKind* kindOut); + +// Pose un exemplaire de `kind` a kPutDownDistance devant le joueur. Si des +// objets y sont deja, le point est decale en spirale (angle d'or) pour que les +// pierres d'un futur foyer ne se superposent pas exactement. false (et rien ne +// change) si le joueur n'en porte pas ou si l'objet n'est pas portable. +inline constexpr float kPutDownDistance = 0.9f; +bool putDown(Inventory& inventory, Ground& ground, GroundItemKind kind, + const glm::vec3& playerPosition, const glm::vec3& facing); + +} // namespace vercora diff --git a/src/world/Deposits.cpp b/src/world/Deposits.cpp new file mode 100644 index 0000000..15c797f --- /dev/null +++ b/src/world/Deposits.cpp @@ -0,0 +1,197 @@ +#include "world/Deposits.hpp" + +#include "core/HeightSampler.hpp" + +#include +#include +#include + +namespace vercora { + +namespace { + +// Les HUIT memes directions de sonde que world/WaterSource.cpp. Recopiees et non +// partagees : les deux fichiers ne doivent dependre que du HeightSampler, et +// sortir huit constantes dans un en-tete commun creerait une dependance entre +// deux detecteurs qui n'ont aucune raison d'evoluer ensemble. +constexpr float kDiagonal = 0.70710678f; // 1/sqrt(2) +constexpr std::size_t kProbeCount = 8; +const glm::vec2 kProbeDirections[kProbeCount] = { + { 1.0f, 0.0f}, {-1.0f, 0.0f}, {0.0f, 1.0f}, {0.0f, -1.0f}, + { kDiagonal, kDiagonal}, { kDiagonal, -kDiagonal}, + {-kDiagonal, kDiagonal}, {-kDiagonal, -kDiagonal}, +}; + +float localSlope(const HeightSampler& terrain, float x, float z, float step) { + const float s = step > 0.0f ? step : 2.0f; + const float dhdx = (terrain.heightAt(x + s, z) - terrain.heightAt(x - s, z)) / (2.0f * s); + const float dhdz = (terrain.heightAt(x, z + s) - terrain.heightAt(x, z - s)) / (2.0f * s); + return std::sqrt(dhdx * dhdx + dhdz * dhdz); +} + +// Distance horizontale au point d'eau le plus proche. Rend l'infini quand la +// liste est vide : tout est alors classe sable, ce qui est le comportement +// annonce dans l'en-tete - sans eau connue, on n'affirme rien sur l'argile. +float distanceToWater(const std::vector& sources, float x, float z) { + float best = std::numeric_limits::infinity(); + for (const WaterSource& source : sources) { + const float dx = source.position.x - x; + const float dz = source.position.z - z; + const float d2 = dx * dx + dz * dz; + if (d2 < best) { + best = d2; + } + } + return std::isinf(best) ? best : std::sqrt(best); +} + +} // namespace + +const char* depositLabel(DepositKind kind) { + switch (kind) { + case DepositKind::Clay: return "argile"; + case DepositKind::Sand: return "sable"; + } + return "gisement"; +} + +std::vector findMineralDeposits(const HeightSampler& terrain, + float minX, float maxX, + float minZ, float maxZ, + const std::vector& waterSources, + const DepositSurveyParams& params) { + std::vector found; + + const float step = params.scanStep > 0.0f ? params.scanStep : 20.0f; + const float probe = params.probeDistance > 0.0f ? params.probeDistance : 25.0f; + if (!(maxX > minX) || !(maxZ > minZ)) { + return found; + } + + // On rentre d'une portee de sonde, MEME RAISON qu'au detecteur de points + // d'eau : heightAt est TOTALE et prolonge la hauteur du bord au-dela des + // donnees, ce qui fabriquerait de fausses cuvettes tout le long du + // perimetre. + const float x0 = minX + probe; + const float x1 = maxX - probe; + const float z0 = minZ + probe; + const float z1 = maxZ - probe; + if (!(x1 > x0) || !(z1 > z0)) { + return found; + } + + std::vector candidates; + + for (float z = z0; z <= z1; z += step) { + for (float x = x0; x <= x1; x += step) { + if (localSlope(terrain, x, z, params.slopeSampleStep) > params.maxSlope) { + continue; + } + + const float h = terrain.heightAt(x, z); + + int rising = 0; + float sum = 0.0f; + float highest = 0.0f; // denivele de la sonde la PLUS haute + for (const glm::vec2& direction : kProbeDirections) { + const float rise = + terrain.heightAt(x + direction.x * probe, z + direction.y * probe) - h; + sum += rise; + if (rise >= params.minDepth) { + ++rising; + } + if (rise > highest) { + highest = rise; + } + } + if (rising < params.risingProbesRequired) { + continue; + } + + const float depth = sum / static_cast(kProbeCount); + if (depth < params.minDepth) { + continue; + } + + // LE critere qui distingue ce detecteur de celui des points d'eau : + // il faut un versant AU-DESSUS. Un creux sans amont ne recoit aucun + // sediment, et c'est ce test - pas la concavite - qui elimine les + // replats de crete. + if (highest < params.minUpslope) { + continue; + } + + const float water = distanceToWater(waterSources, x, z); + + MineralDeposit deposit; + deposit.position = glm::vec3(x, h, z); + deposit.kind = (water <= params.clayWaterRadius) ? DepositKind::Clay + : DepositKind::Sand; + deposit.depth = depth; + deposit.upslope = highest; + deposit.waterDistance = water; + candidates.push_back(deposit); + } + } + + // Du plus creux au moins creux, avec depart aux coordonnees a egalite : + // MEME TRI que findWaterSources, et pour la meme raison - sans le second + // critere, deux points aussi creux l'un que l'autre pourraient sortir dans + // un ordre dependant de l'implementation du tri, et le resultat cesserait + // d'etre reproductible d'un run a l'autre. + std::sort(candidates.begin(), candidates.end(), + [](const MineralDeposit& a, const MineralDeposit& b) { + if (a.depth != b.depth) { + return a.depth > b.depth; + } + if (a.position.x != b.position.x) { + return a.position.x < b.position.x; + } + return a.position.z < b.position.z; + }); + + const float separation2 = params.minSeparation * params.minSeparation; + for (const MineralDeposit& candidate : candidates) { + if (found.size() >= params.maxDeposits) { + break; + } + bool tooClose = false; + for (const MineralDeposit& kept : found) { + const float dx = kept.position.x - candidate.position.x; + const float dz = kept.position.z - candidate.position.z; + if (dx * dx + dz * dz < separation2) { + tooClose = true; + break; + } + } + if (!tooClose) { + found.push_back(candidate); + } + } + + return found; +} + +const MineralDeposit* nearestDeposit(const std::vector& deposits, + const glm::vec3& position, + float* outDistance) { + const MineralDeposit* best = nullptr; + float bestDistance2 = 0.0f; + + for (const MineralDeposit& deposit : deposits) { + const float dx = deposit.position.x - position.x; + const float dz = deposit.position.z - position.z; + const float d2 = dx * dx + dz * dz; + if (best == nullptr || d2 < bestDistance2) { + best = &deposit; + bestDistance2 = d2; + } + } + + if (outDistance) { + *outDistance = best ? std::sqrt(bestDistance2) : 0.0f; + } + return best; +} + +} // namespace vercora diff --git a/src/world/Deposits.hpp b/src/world/Deposits.hpp new file mode 100644 index 0000000..71154a3 --- /dev/null +++ b/src/world/Deposits.hpp @@ -0,0 +1,184 @@ +#pragma once + +#include "world/WaterSource.hpp" + +#include + +#include +#include +#include + +namespace vercora { + +class HeightSampler; + +// =========================================================================== +// PHASE 22 : les gisements d'ARGILE et de SABLE. +// =========================================================================== +// +// AVERTISSEMENT, ET IL EST LE COEUR DE CE FICHIER : CE PLACEMENT N'EST PAS +// GEOLOGIQUE. Le LiDAR ne porte AUCUNE information de nature de terrain - ni +// lithologie, ni granulometrie, ni carte des formations superficielles. Il +// donne une SURFACE, et rien d'autre. Il est donc strictement impossible de +// distinguer, a partir de ces donnees, un vrai gisement d'argile d'un vrai +// gisement de sable, ou de l'un ou l'autre d'un banc de calcaire. +// +// Ce que fait ce fichier est un PROXY MORPHOLOGIQUE : il place les gisements +// la ou, dans un massif de ce type, ils seraient PLAUSIBLES. C'est une +// vraisemblance, pas une mesure, et rien ici ne doit etre lu comme une carte. +// Le jour ou les formations superficielles du BRGM seront chargees, c'est +// cette fonction qui disparaitra, pas ses appelants - exactement le sort +// annonce pour findWaterSources quand l'IGN fournira le reseau +// hydrographique. +// +// LA REGLE DU PROXY, ET POURQUOI ELLE. Les deux matieres sont des SEDIMENTS +// FINS : elles ne se forment pas la ou elles sont arrachees, elles se deposent +// la ou l'eau ralentit et les abandonne. Deux conditions morphologiques +// suivent, et ce sont exactement celles que ce fichier teste : +// +// 1. UN CREUX. Meme critere de concavite que world/WaterSource - huit sondes +// de pourtour, dont un nombre minimal doit etre plus haut - et pour la +// meme raison : c'est la seule forme, sur un relief mesure, ou quelque +// chose peut s'accumuler au lieu d'etre emporte. Le code de detection est +// volontairement le MEME que celui des points d'eau, aux seuils pres. +// +// 2. UN VERSANT AU-DESSUS. La matiere doit VENIR de quelque part : un creux +// au milieu d'un plateau ne recoit rien. On mesure donc le denivele amont +// (`upslope`), c'est-a-dire de combien le pourtour domine le point. +// +// CE QUI SEPARE L'ARGILE DU SABLE. Une seule variable, et elle est assumee : la +// PROXIMITE D'UN POINT D'EAU deja detecte par le jeu (Phase 16). +// +// argile - a moins de clayWaterRadius d'un point d'eau. L'argile est la +// fraction la PLUS FINE : elle ne se depose que la ou l'eau stagne +// vraiment, c'est-a-dire au fond des cuvettes et des talwegs que le +// detecteur de la Phase 16 retient deja. +// sable - au-dela. Plus grossier, il se depose plus haut et plus tot, au +// debouche des pentes, sans avoir besoin d'eau stagnante. +// +// Ce partage est GROSSIER et il est faux par endroits, comme l'heuristique des +// points d'eau dont il herite : une argile de versant existe, un sable de fond +// de mare aussi. Il est retenu parce qu'il est VERIFIABLE (les tests headless le +// confrontent a un relief construit expres), bon marche (un balayage unique au +// chargement), et parce qu'il donne au joueur une regle qu'il peut APPRENDRE en +// jouant - "l'argile est pres de l'eau, le sable en amont" - au lieu d'un semis +// aleatoire qu'aucune observation ne recompense. +// +// Ne connait ni Vulkan, ni le rendu : il produit des positions et des natures. +// Entierement testable sans GPU. +// =========================================================================== + +enum class DepositKind : uint8_t { + Clay, // argile : creux PRES d'un point d'eau + Sand, // sable : creux LOIN d'un point d'eau +}; + +// Libelle francais au singulier, pour les journaux. +const char* depositLabel(DepositKind kind); + +// Un gisement affleurant, ou le joueur peut creuser. +struct MineralDeposit { + glm::vec3 position{0.0f}; // sur la surface : y = heightAt(x, z) + DepositKind kind = DepositKind::Sand; + + // Concavite apparente en m (elevation moyenne du pourtour au-dessus du + // point). Sert a classer les candidats du plus creux au moins creux, donc a + // garder les meilleurs quand il y en a trop. + float depth = 0.0f; + + // Denivele AMONT en m : de combien la plus haute des huit sondes domine le + // point. C'est la mesure de "il y a un versant au-dessus qui alimente ce + // creux". Un creux sans amont ne recoit rien et n'est pas retenu. + float upslope = 0.0f; + + // Distance horizontale au point d'eau le plus proche, en m, au moment du + // balayage. Vaut l'infini quand aucun point d'eau n'a ete fourni - et dans + // ce cas TOUT est classe sable, ce qui est le comportement voulu : sans + // eau connue, on ne peut rien affirmer sur l'argile. + float waterDistance = 0.0f; +}; + +struct DepositSurveyParams { + // Pas du balayage, en m. 20 m, MEME VALEUR ET MEME RAISON que + // WaterSurveyParams::scanStep : le rayon utile d'un creux sur ce relief vaut + // une vingtaine de metres, et un pas plus large passe simplement a cote. + float scanStep = 20.0f; + + // Rayon des sondes de pourtour, en m. + float probeDistance = 25.0f; + + // Demi-base de la lecture de pente, en m. 2,0, donc une base de 4 m : meme + // valeur et MEME RAISON que BikeParams::slopeSampleStep et que + // WaterSurveyParams::slopeSampleStep - au pas de 1 m, le bruit + // decimetrique du LiDAR fait lire des pentes qui n'existent pas. + float slopeSampleStep = 2.0f; + + // Pente locale maximale admise. 0,22 - donc PLUS PERMISSIF que les 0,15 des + // points d'eau, et c'est voulu : l'eau doit stagner pour qu'on y boive, un + // sediment n'a qu'a s'etre depose. Un cone de dejection au debouche d'un + // ravin est nettement plus pentu qu'une mare, et l'exclure viderait la + // moitie des emplacements credibles de ce massif (qui, rappel de la Phase + // 16, est raide : 562 m de denivele sur 1 km). + float maxSlope = 0.22f; + + // Concavite moyenne minimale, en m, pour que le point compte comme un creux. + // 0,6 m sur 25 m de rayon, soit 2,4 % - plus bas que le 1,0 m des points + // d'eau, meme raison que ci-dessus : on cherche un endroit ou la matiere se + // pose, pas un endroit ou l'eau reste. + float minDepth = 0.6f; + + // Nombre de sondes du pourtour (sur HUIT) qui doivent etre plus hautes d'au + // moins minDepth. 4 sur 8 et non 5 : le seuil de 5 des points d'eau existe + // pour ECARTER LES COLS, ou il n'y a rien a boire. Ici un col n'est pas + // absurde - un replat de col recoit bel et bien des depots - et le critere + // qui compte a la place est le denivele amont (minUpslope), qu'un col + // franchit sans peine mais qu'un sommet ne franchit pas. + int risingProbesRequired = 4; + + // Denivele amont minimal, en m : la plus haute sonde doit dominer le point + // d'au moins ca. 3,0 m sur 25 m de rayon. C'est ce seuil, et non la + // concavite, qui elimine les replats de crete - un creux de sommet est + // concave mais n'a rien au-dessus de lui. + float minUpslope = 3.0f; + + // Distance a un point d'eau en dessous de laquelle un creux est classe + // ARGILE, en m. 120 m : de l'ordre de la separation des points d'eau + // (150 m), donc un creux appartient au plus a un point d'eau, et les deux + // matieres ne se superposent jamais au meme endroit. + float clayWaterRadius = 120.0f; + + // Distance minimale entre deux gisements retenus, en m. 90 m : plus serre + // que les 150 m des points d'eau parce qu'il y a DEUX matieres a placer et + // qu'un joueur doit pouvoir en trouver sans traverser la carte. + float minSeparation = 90.0f; + + // Garde-fou : au-dela, on ne garde que les plus creux. + std::size_t maxDeposits = 64; +}; + +// Balaie le rectangle [minX, maxX] x [minZ, maxZ] (coordonnees monde, en m) et +// rend les gisements retenus, du plus creux au moins creux. +// +// `waterSources` est la liste deja produite par findWaterSources : elle sert +// UNIQUEMENT a classer argile/sable. Une liste vide est licite et rend alors +// tout en sable (voir MineralDeposit::waterDistance). +std::vector findMineralDeposits(const HeightSampler& terrain, + float minX, float maxX, + float minZ, float maxZ, + const std::vector& waterSources, + const DepositSurveyParams& params = {}); + +// Portee pour creuser, en m, mesuree a l'HORIZONTALE. 3,5 m : entre le +// ramassage d'objet (2,5 m) et la portee de boisson (4,0 m). Un gisement est une +// ZONE, comme un point d'eau, mais on doit s'en approcher plus pres pour y +// mettre les mains que pour y tremper une gourde. +inline constexpr float kDigReach = 3.5f; + +// Gisement le plus proche d'une position, a l'horizontale. Renvoie nullptr si la +// liste est vide. outDistance, s'il est fourni, recoit la distance horizontale +// au gisement rendu. +const MineralDeposit* nearestDeposit(const std::vector& deposits, + const glm::vec3& position, + float* outDistance = nullptr); + +} // namespace vercora diff --git a/src/world/FiberPlants.cpp b/src/world/FiberPlants.cpp new file mode 100644 index 0000000..396a501 --- /dev/null +++ b/src/world/FiberPlants.cpp @@ -0,0 +1,322 @@ +#include "world/FiberPlants.hpp" + +#include "core/Frustum.hpp" +#include "core/HeightSampler.hpp" + +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; + +// Rampe lineaire ecretee : 0 sous `from`, 1 au-dessus de `to`. Meme fonction que +// celle de Vegetation.cpp, recopiee pour la meme raison qu'appendFacet dans +// HarvestMesh.cpp - quatre lignes sans etat ne justifient pas une dependance. +float ramp(float value, float from, float to) { + if (to <= from) { + return (value >= to) ? 1.0f : 0.0f; + } + return std::clamp((value - from) / (to - from), 0.0f, 1.0f); +} + +// Melange 32 bits (finalisateur de MurmurHash3), le meme que world/Resin.cpp. +// Sans etat : le semis d'une cellule ne construit pas de generateur. +uint32_t mix32(uint32_t value) { + value ^= value >> 16; + value *= 0x85EBCA6Bu; + value ^= value >> 13; + value *= 0xC2B2AE35u; + value ^= value >> 16; + return value; +} + +// Aleas d'un emplacement, dans [0, 1). `channel` separe des tirages qui doivent +// etre INDEPENDANTS : sans lui, la position et la taille d'une plante seraient +// correlees et toutes les grandes plantes se retrouveraient du meme cote de +// leur cellule. +float slotRandom(uint32_t seed, int32_t cellX, int32_t cellZ, uint32_t slot, + uint32_t channel) { + uint32_t h = mix32(seed ^ 0x9E3779B9u); + h = mix32(h ^ static_cast(cellX)); + h = mix32(h ^ static_cast(cellZ)); + h = mix32(h ^ (slot * 0x27D4EB2Fu)); + h = mix32(h ^ (channel * 0x165667B1u)); + return static_cast(static_cast(h) / 4294967296.0); +} + +} // namespace + +FiberPlants::FiberPlants(const HeightSampler& terrain, const HeightSampler* cover, + float terrainExtent, const FiberPlantParams& params) + : terrain_(terrain), cover_(cover), terrainExtent_(terrainExtent), params_(params) {} + +float FiberPlants::slopeAt(float worldX, float worldZ) const { + // MEME definition que Vegetation::slopeAt : les deux filtres doivent parler + // de la meme grandeur, sans quoi comparer une densite de ronces a une + // densite d'arbres n'aurait aucun sens. + const float h = terrain_.heightAt(worldX, worldZ); + const float dx = terrain_.heightAt(worldX + 1.0f, worldZ) - h; + const float dz = terrain_.heightAt(worldX, worldZ + 1.0f) - h; + return std::sqrt(dx * dx + dz * dz); +} + +float FiberPlants::coverAt(float worldX, float worldZ) const { + if (cover_ == nullptr) { + // Voir l'en-tete : sans carte de couvert, on ne sait pas ou est la + // lisiere et on ne l'invente pas. -1 est la valeur sentinelle qui dit + // "inconnu" et que edgeDensityAt traduit en densite nulle. + return -1.0f; + } + return std::clamp(cover_->heightAt(worldX, worldZ), 0.0f, 1.0f); +} + +float FiberPlants::edgeDensityAt(float worldX, float worldZ) const { + const float cover = coverAt(worldX, worldZ); + if (cover < 0.0f) { + return 0.0f; // pas de carte : pas de lisiere connue + } + const float open = params_.coverOpen; + const float closed = params_.coverClosed; + if (!(closed > open)) { + return 0.0f; + } + if (cover <= open || cover >= closed) { + return 0.0f; + } + // TOIT TRIANGULAIRE sur la bande : maximum en son milieu, zero a ses deux + // bords. C'est ce qui fait de ce critere une BORDURE et non un simple + // intervalle - avec un creneau, une immense zone de couvert intermediaire + // (un versant clairseme entier) porterait des ronces partout, ce qui n'est + // pas une lisiere mais une lande. + const float middle = 0.5f * (open + closed); + const float half = 0.5f * (closed - open); + return std::clamp(1.0f - std::fabs(cover - middle) / half, 0.0f, 1.0f); +} + +float FiberPlants::clearingDensityAt(float worldX, float worldZ) const { + if (clearing_ == nullptr) { + return 0.0f; + } + const float opened = clearing_->clearing(worldX, worldZ); + return ramp(opened, params_.clearingBegin, params_.clearingFull); +} + +float FiberPlants::densityAt(float worldX, float worldZ) const { + // MAXIMUM et non somme : une coupe faite en pleine lisiere ne doit pas + // porter deux fois plus de ronces qu'ailleurs (voir l'en-tete). + float density = std::max(edgeDensityAt(worldX, worldZ), + clearingDensityAt(worldX, worldZ)); + if (density <= 0.0f) { + return 0.0f; + } + + // Filtres de terrain, appliques APRES : ils ne choisissent pas ou pousser, + // ils interdisent. Une paroi n'est pas une lisiere meme si son couvert le + // laisse croire. + if (slopeAt(worldX, worldZ) > params_.maxSlope) { + return 0.0f; + } + if (terrain_.heightAt(worldX, worldZ) > params_.maxAltitude) { + return 0.0f; + } + return density; +} + +void FiberPlants::update(float deltaTime) { + if (deltaTime <= 0.0f) { + return; + } + for (auto it = pulled_.begin(); it != pulled_.end();) { + it->second -= deltaTime; + if (it->second <= 0.0f) { + it = pulled_.erase(it); // repoussee : elle sort de la memoire + } else { + ++it; + } + } +} + +bool FiberPlants::isStanding(const FiberPlantId& id) const { + return pulled_.find(id) == pulled_.end(); +} + +void FiberPlants::buildCell(int32_t cellX, int32_t cellZ, + std::vector& out) const { + const float cell = params_.cell; + const float baseX = static_cast(cellX) * cell; + const float baseZ = static_cast(cellZ) * cell; + + // La densite est lue UNE FOIS au centre de la cellule et non par + // emplacement : c'est quatre fois moins d'appels a la carte de couvert et au + // terrain, et la cellule fait 4 m - la lisiere ne bouge pas a l'interieur. + const float density = densityAt(baseX + 0.5f * cell, baseZ + 0.5f * cell); + if (density <= 0.0f) { + return; + } + + const float usable = std::max(0.0f, terrainExtent_ - 2.0f); + const uint32_t slots = params_.slots; + + for (uint32_t slot = 0; slot < slots; ++slot) { + // Chaque emplacement a son propre tirage d'existence, compare a la + // densite : la cellule se remplit donc PROGRESSIVEMENT quand la densite + // monte, au lieu d'apparaitre d'un bloc. C'est le meme principe que les + // portees individuelles des emplacements d'arbres (Vegetation). + if (slotRandom(params_.seed, cellX, cellZ, slot, 0) >= density) { + continue; + } + + const FiberPlantId id{cellX, cellZ, slot}; + if (!isStanding(id)) { + continue; // arrachee, en cours de repousse + } + + const float x = baseX + cell * slotRandom(params_.seed, cellX, cellZ, slot, 1); + const float z = baseZ + cell * slotRandom(params_.seed, cellX, cellZ, slot, 2); + if (usable > 0.0f && (std::fabs(x) > usable || std::fabs(z) > usable)) { + continue; // hors des donnees de terrain + } + + const float t = slotRandom(params_.seed, cellX, cellZ, slot, 3); + + FiberPlant plant; + plant.id = id; + plant.position = glm::vec3(x, terrain_.heightAt(x, z), z); + plant.size = params_.sizeMin + t * (params_.sizeMax - params_.sizeMin); + plant.yaw = kTwoPi * slotRandom(params_.seed, cellX, cellZ, slot, 4); + plant.variation = slotRandom(params_.seed, cellX, cellZ, slot, 5); + out.push_back(plant); + } +} + +std::vector FiberPlants::plantsNear(const glm::vec3& position, + float reach) const { + std::vector found; + if (reach <= 0.0f) { + return found; + } + + const float cell = params_.cell; + const int32_t cx0 = static_cast(std::floor((position.x - reach) / cell)); + const int32_t cx1 = static_cast(std::floor((position.x + reach) / cell)); + const int32_t cz0 = static_cast(std::floor((position.z - reach) / cell)); + const int32_t cz1 = static_cast(std::floor((position.z + reach) / cell)); + + std::vector cellPlants; + const float reach2 = reach * reach; + for (int32_t cz = cz0; cz <= cz1; ++cz) { + for (int32_t cx = cx0; cx <= cx1; ++cx) { + cellPlants.clear(); + buildCell(cx, cz, cellPlants); + for (const FiberPlant& plant : cellPlants) { + // Portee HORIZONTALE seulement, comme Ground::findNearest : une + // plante en contrebas d'un talus reste attrapable. + const float dx = plant.position.x - position.x; + const float dz = plant.position.z - position.z; + if (dx * dx + dz * dz <= reach2) { + found.push_back(plant); + } + } + } + } + return found; +} + +bool FiberPlants::pullNearest(const glm::vec3& position, float reach, + FiberPlant* pulled) { + const std::vector near = plantsNear(position, reach); + + const FiberPlant* best = nullptr; + float bestDistance2 = 0.0f; + for (const FiberPlant& plant : near) { + const float dx = plant.position.x - position.x; + const float dz = plant.position.z - position.z; + const float d2 = dx * dx + dz * dz; + if (best == nullptr || d2 < bestDistance2) { + best = &plant; + bestDistance2 = d2; + } + } + if (best == nullptr) { + return false; + } + + if (pulled != nullptr) { + *pulled = *best; + } + pulled_[best->id] = params_.regrowthDelay; + return true; +} + +void FiberPlants::gather(const glm::vec3& eye, const Frustum& frustum, + std::vector& out) const { + out.clear(); + + const float cell = params_.cell; + const float reach = params_.distanceFar; + + const int32_t cx0 = static_cast(std::floor((eye.x - reach) / cell)); + const int32_t cx1 = static_cast(std::floor((eye.x + reach) / cell)); + const int32_t cz0 = static_cast(std::floor((eye.z - reach) / cell)); + const int32_t cz1 = static_cast(std::floor((eye.z + reach) / cell)); + + const float fadeSpan = std::max(1e-3f, params_.distanceFar - params_.distanceNear); + + std::vector cellPlants; + for (int32_t cz = cz0; cz <= cz1; ++cz) { + for (int32_t cx = cx0; cx <= cx1; ++cx) { + const float baseX = static_cast(cx) * cell; + const float baseZ = static_cast(cz) * cell; + + // Rejet par DISTANCE d'abord (un carre de distance, pas de frustum a + // evaluer), puis par frustum. La cellule fait 4 m : un culling par + // blocs comme celui de l'herbe n'apporterait presque rien sur une + // portee de 46 m, qui ne couvre qu'une centaine de cellules. + const float nearestX = std::clamp(eye.x, baseX, baseX + cell); + const float nearestZ = std::clamp(eye.z, baseZ, baseZ + cell); + const float ddx = eye.x - nearestX; + const float ddz = eye.z - nearestZ; + if (ddx * ddx + ddz * ddz > reach * reach) { + continue; + } + + const float cellY = terrain_.heightAt(baseX + 0.5f * cell, baseZ + 0.5f * cell); + // Marge verticale large : la sonde centrale ne voit pas le relief de + // toute la cellule, et ces plantes sont basses - mieux vaut ne jamais + // les ecarter a tort. + if (!frustum.intersectsAABB({ baseX, cellY - 20.0f, baseZ }, + { baseX + cell, cellY + 20.0f, baseZ + cell })) { + continue; + } + + cellPlants.clear(); + buildCell(cx, cz, cellPlants); + for (const FiberPlant& plant : cellPlants) { + const float dx = plant.position.x - eye.x; + const float dz = plant.position.z - eye.z; + const float distance = std::sqrt(dx * dx + dz * dz); + if (distance > reach) { + continue; + } + + InstanceData instance; + instance.position = plant.position; + instance.scale = plant.size; + instance.yaw = plant.yaw; + instance.variation = plant.variation; + // Meme fondu que l'herbe : l'instance RETRECIT au lieu de + // devenir transparente, ce qui evite tout melange alpha et donc + // tout tri en profondeur. + instance.fade = + std::clamp((params_.distanceFar - distance) / fadeSpan, 0.0f, 1.0f); + out.push_back(instance); + } + } + } + + lastPlantCount_ = static_cast(out.size()); +} + +} // namespace vercora diff --git a/src/world/FiberPlants.hpp b/src/world/FiberPlants.hpp new file mode 100644 index 0000000..e5ff943 --- /dev/null +++ b/src/world/FiberPlants.hpp @@ -0,0 +1,257 @@ +#pragma once + +#include "renderer/InstanceData.hpp" +#include "world/Clearing.hpp" + +#include + +#include +#include +#include + +namespace vercora { + +class HeightSampler; +struct Frustum; + +// =========================================================================== +// PHASE 22 : les PLANTES A FIBRES (ronces, orties). +// =========================================================================== +// Ce sont des plantes de RUDERALIE : elles ne poussent pas dans la futaie +// fermee, elles poussent la ou la lumiere arrive au sol et ou personne ne les +// concurrence. Le document de cadrage dit "clairieres, zones perturbees", et +// c'est litteralement le critere code ici, par DEUX voies independantes qui +// s'additionnent : +// +// 1. LA LISIERE, lue dans la carte de couvert LiDAR. Ni la futaie dense +// (l'ombre les tue) ni l'alpage nu (rien ne les abrite) : la BANDE DE +// TRANSITION entre les deux. C'est une bordure, donc une forme que la +// carte de couvert donne gratuitement - il suffit de retenir les cellules +// dont le couvert tombe entre deux seuils. Rien de nouveau n'est charge : +// c'est la MEME carte que celle qui decide ou poussent les arbres de decor +// (voir Vegetation::coverAt), lue avec d'autres seuils. +// +// 2. LE SOL RECEMMENT OUVERT, lu dans world/Clearing.hpp - en pratique le +// compteur de deforestation de world/Habitat. Une zone ou le joueur a +// abattu des arbres se met a porter des ronces. C'est la coherence que le +// cahier des charges suggerait et elle est exploitee ici PARCE QU'ELLE EST +// VRAIE : la recolonisation d'une coupe par les ronces est le fait le plus +// banal de la sylviculture temperee. Elle a en prime une vertu de jeu que +// rien d'autre dans le projet n'avait : c'est la PREMIERE fois qu'une +// action du joueur FAIT APPARAITRE 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. +// +// La densite retenue est le MAXIMUM des deux et non leur somme : une coupe faite +// en pleine lisiere ne doit pas porter deux fois plus de ronces qu'ailleurs. +// +// LES LIMITES, EN CLAIR. Le couvert LiDAR ne distingue pas une vraie lisiere +// d'un simple trou dans le couvert (un affleurement rocheux au milieu des +// arbres passe le test). Et rien ne distingue une ronce d'une ortie : le mesh +// est unique, seule l'echelle varie. Ce sont des limites assumees, du meme +// ordre que celles de world/Deposits.hpp et de world/Resin.hpp. +// +// ARCHITECTURE : le semis est une FONCTION DETERMINISTE de la cellule, comme +// celui de world/Vegetation - engendrer la cellule (17, -42) donne toujours les +// memes plantes, quelle que soit la facon dont on y est arrive, et il n'y a +// donc RIEN a stocker pour les 25 km2. Seules les plantes ARRACHEES sont +// memorisees, dans une table creuse, et seulement le temps de leur repousse : +// meme principe que la grille creuse de world/Habitat. +// +// Ne connait RIEN de Vulkan : produit des InstanceData, c'est main.cpp qui les +// remet au Renderer. Testable sans GPU. +// =========================================================================== + +struct FiberPlantParams { + // Cote d'une cellule de semis, en m. 4 m : entre la cellule d'herbe (1 m) et + // celle des arbres (24 m). Une tache de ronces fait quelques metres, pas + // quelques decimetres. + float cell = 4.0f; + + // Emplacements engendres par cellule. Le nombre REELLEMENT retenu depend de + // la densite locale (voir plus bas). 3 sur 4 m de cote = au plus une plante + // pour 5,3 m2 au maximum de densite : un roncier est dense, mais il reste + // franchissable a pied. + uint32_t slots = 3; + + // Portee de rendu, en m, et debut du fondu. Court, comme l'herbe : ces + // plantes sont basses et c'est le poste d'instances le plus cher apres + // elle. + float distanceFar = 46.0f; + float distanceNear = 22.0f; + + // --- Voie 1 : la LISIERE ------------------------------------------------- + // Bande de couvert retenue. En dessous de coverOpen c'est de l'alpage nu, au + // dessus de coverClosed c'est de la futaie fermee ; la densite est maximale + // au MILIEU de la bande et retombe a zero a ses deux bords. + // + // Les bornes encadrent volontairement VegetationParams::coverMin (0,20), qui + // est le seuil a partir duquel une cellule commence a porter des arbres de + // decor : la lisiere est, par construction, l'endroit ou les arbres + // apparaissent. Les deux fichiers parlent donc bien de la meme frontiere. + float coverOpen = 0.06f; + float coverClosed = 0.42f; + + // --- Voie 2 : le SOL OUVERT --------------------------------------------- + // Ouverture (ClearingSource) en dessous de laquelle rien ne recolonise, et + // au-dessus de laquelle la recolonisation est maximale. + // + // 0,30 correspond a UN SEUL arbre abattu dans la cellule d'Habitat + // (HabitatParams::loggingPerTree vaut 0,34). C'est plus bas que le seuil qui + // fait fuir la faune (0,40) et que celui qui denude le sol (0,25 a 1,00), et + // c'est voulu : couper un arbre isole ne vide pas la zone de ses animaux, + // mais il ouvre bel et bien une trouee de lumiere, et c'est tout ce qu'il + // faut a une ronce. + float clearingBegin = 0.30f; + float clearingFull = 0.85f; + + // --- Filtres de terrain -------------------------------------------------- + // Pente maximale (tangente) portant des plantes a fibres. 1,0 (45 degres) : + // plus severe que l'herbe (1,3) - un roncier a besoin d'un peu de sol, pas + // seulement d'une fissure. + float maxSlope = 1.0f; + + // Altitude, en m, au-dessus de laquelle ces plantes disparaissent. 1900 m : + // c'est l'ordre de grandeur de la limite des arbres sur ce massif (voir + // VegetationParams::grassAltitudeLush et son commentaire). Ronces et orties + // sont des plantes de l'etage montagnard ; au-dessus, il n'y a plus de + // lisiere puisqu'il n'y a plus de foret. + float maxAltitude = 1900.0f; + + // Taille d'une plante, en m, aux deux bouts de la variation d'instance. + float sizeMin = 0.45f; + float sizeMax = 0.95f; + + // --- Recolte ------------------------------------------------------------- + // Delai de repousse d'une plante arrachee, en secondes de jeu. 420 s = sept + // minutes. Entre la resine (600 s) et rien du tout : une ronce repousse vite, + // c'est meme sa definition. + float regrowthDelay = 420.0f; + + // --- Commun -------------------------------------------------------------- + // Deux FiberPlants de meme graine sont identiques. Distincte de celle de + // Vegetation : changer l'une ne doit pas rebattre l'autre. + uint32_t seed = 20260822u; +}; + +// Une plante identifiee de facon STABLE : sa cellule et son emplacement dans la +// cellule. C'est ce couple, et non un indice dans un vecteur, qui sert de cle a +// la memoire des plantes arrachees - un indice de vecteur n'aurait aucun sens +// pour un semis qui n'est jamais stocke. +struct FiberPlantId { + int32_t cellX = 0; + int32_t cellZ = 0; + uint32_t slot = 0; + + bool operator==(const FiberPlantId& other) const { + return cellX == other.cellX && cellZ == other.cellZ && slot == other.slot; + } +}; + +// Une plante sur pied, telle que le semis la rend. +struct FiberPlant { + FiberPlantId id; + glm::vec3 position{0.0f}; // pied, sur la surface + float size = 0.0f; // hauteur en m + float yaw = 0.0f; + float variation = 0.0f; +}; + +// Portee d'arrachage, en m, a l'HORIZONTALE. 2,5 m : exactement celle du +// ramassage d'objet au sol, parce que c'est le meme geste - on se penche et on +// prend. +inline constexpr float kPullReach = 2.5f; + +class FiberPlants { +public: + // `terrain` fournit altitude et pente ; `cover` est la carte de couvert + // LiDAR (celle de tools/lidar_to_canopy.py, echantillonnee en coordonnees + // MONDE comme le terrain). Aucun des deux n'est possede et tous deux doivent + // vivre plus longtemps. + // + // `cover` peut etre NUL : la voie "lisiere" est alors entierement + // desactivee, et seule la voie "sol ouvert" produit des plantes. C'est le + // comportement voulu et non un repli degrade - sans carte de couvert, on ne + // sait tout simplement pas ou est la lisiere, et l'inventer par un + // substitut de pente donnerait des ronces sur des criteres qui n'ont rien a + // voir avec la lumiere. Un TEMOIN naturel, en prime : un monde sans carte de + // couvert ne porte QUE les plantes que le joueur a fait pousser. + // + // `terrainExtent` = demi-cote du terrain, pour ne pas semer hors des donnees. + FiberPlants(const HeightSampler& terrain, const HeightSampler* cover, + float terrainExtent, const FiberPlantParams& params = {}); + + // Branche le semis sur l'etat du milieu (world/Habitat en pratique). Nul par + // defaut, et une FiberPlants sans source se comporte comme un monde jamais + // coupe - le contrat TOTAL de ClearingSource garantit qu'il n'y a pas de cas + // particulier a ecrire ici. + // La source n'est PAS possedee et doit vivre plus longtemps. + void setClearingSource(const ClearingSource* source) { clearing_ = source; } + const ClearingSource* clearingSource() const { return clearing_; } + + // Fait avancer l'horloge de repousse et OUBLIE les plantes revenues. A + // appeler une fois par image, comme Habitat::update. + void update(float deltaTime); + + // Remplit `out` (vide d'abord) des plantes visibles depuis `eye`. + void gather(const glm::vec3& eye, const Frustum& frustum, + std::vector& out) const; + + // Plantes SUR PIED a moins de `reach` (a l'horizontale) de `position`, + // engendrees a la demande. Sert a l'arrachage et aux tests ; ne met rien en + // cache. + std::vector plantsNear(const glm::vec3& position, float reach) const; + + // Arrache la plante sur pied la plus proche, dans la portee donnee. Rend + // true et remplit `pulled` (s'il n'est pas nul) quand une plante a bien ete + // arrachee. La plante disparait du semis jusqu'a sa repousse. + bool pullNearest(const glm::vec3& position, float reach, FiberPlant* pulled = nullptr); + + // Cette plante est-elle encore sur pied ? (false pendant sa repousse) + bool isStanding(const FiberPlantId& id) const; + + // --- Diagnostic --------------------------------------------------------- + std::size_t pulledPlantCount() const { return pulled_.size(); } + uint32_t lastPlantCount() const { return lastPlantCount_; } + + // Densite locale retenue en un point, dans [0, 1], et les deux voies qui la + // composent. Expose parce que c'est le SEUL chiffre qui dit laquelle des + // deux a decide - un test qui ne pourrait pas les lire devrait redemontrer + // le semis a l'envers pour distinguer une lisiere d'une coupe. + float densityAt(float worldX, float worldZ) const; + float edgeDensityAt(float worldX, float worldZ) const; + float clearingDensityAt(float worldX, float worldZ) const; + + const FiberPlantParams& params() const { return params_; } + +private: + struct IdHash { + std::size_t operator()(const FiberPlantId& id) const { + // Meme melange que Vegetation::CellKeyHash et Habitat::CellKeyHash : + // les moities occupent des bits distincts. + return (static_cast(static_cast(id.cellX)) * 0x9E3779B1ull) + ^ (static_cast(static_cast(id.cellZ)) * 0x85EBCA77ull) + ^ (static_cast(id.slot) * 0x27D4EB2Full); + } + }; + + // Engendre les plantes SUR PIED d'une cellule (les arrachees sont omises). + void buildCell(int32_t cellX, int32_t cellZ, std::vector& out) const; + + float slopeAt(float worldX, float worldZ) const; + float coverAt(float worldX, float worldZ) const; + + const HeightSampler& terrain_; + const HeightSampler* cover_ = nullptr; + const ClearingSource* clearing_ = nullptr; + float terrainExtent_ = 0.0f; + FiberPlantParams params_; + + // Plantes arrachees : secondes de repousse restantes. Creuse, et videe des + // qu'une plante est revenue. + std::unordered_map pulled_; + + mutable uint32_t lastPlantCount_ = 0; +}; + +} // namespace vercora diff --git a/src/world/Forest.cpp b/src/world/Forest.cpp new file mode 100644 index 0000000..b9e83d6 --- /dev/null +++ b/src/world/Forest.cpp @@ -0,0 +1,688 @@ +#include "world/Forest.hpp" + +#include "core/HeightSampler.hpp" +#include "core/Logger.hpp" +#include "world/Ground.hpp" +#include "world/TreeMesh.hpp" + +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kPi = 3.14159265359f; +constexpr float kHalfPi = 1.57079632679f; + +// Nombre de rayons lances a l'horizontale pour chercher la zone degagee. +// 24 rayons = un tous les 15 degres : assez fin pour trouver une trouee entre +// deux arbres voisins, assez grossier pour rester negligeable en cout (on +// l'appelle une fois par abattage, pas une fois par frame). +constexpr int kClearanceRayCount = 24; + +// Pas d'echantillonnage du relief le long d'un rayon, en unites monde. +constexpr float kTerrainStep = 1.0f; + +// On ignore le relief tout pres du pied : sur une pente, le sol juste derriere +// l'arbre est forcement plus haut que son pied sans que ca gene sa chute. +constexpr float kTerrainProbeStart = 2.0f; + +// Acceleration de la pesanteur. 1 unite monde = 1 m (convention posee par la +// hauteur d'oeil de la camera), donc la vraie valeur a un sens ici. +constexpr float kGravity = 9.81f; + +// Un pas de temps aberrant (fenetre deplacee, point d'arret dans le debugger) +// ne doit pas faire exploser l'integration : au-dela, on avance au ralenti +// plutot que de telescoper l'arbre a travers le sol. +constexpr float kMaxStep = 0.05f; + +// --- Amortissement apres l'impact (etat Settling) -------------------------- +// Duree pendant laquelle l'arbre reste dessine, COUCHE au sol, avant de se +// debiter. C'est le temps qu'il faut pour lire "l'arbre est tombe la" ; en +// dessous de ~0.4 s on ne voit toujours rien, au-dela d'une seconde l'attente +// devient perceptible. +constexpr float kSettleDuration = 0.65f; + +// Rebond : l'arbre remonte legerement puis se repose, en s'amortissant. On reste +// TOUJOURS sous l'horizontale (l'angle est retranche a pi/2), sans quoi le tronc +// s'enfoncerait dans le terrain a chaque oscillation. +constexpr float kSettleAmplitude = 0.055f; // rad, ~3 degres au premier rebond +constexpr float kSettlePulsation = 15.0f; // rad/s +constexpr float kSettleDamping = 7.0f; // 1/s + +// --- Debitage (passage a Fallen) ------------------------------------------- +// Intervalle entre deux pieces de bois. Le tronc se debite du pied vers la cime, +// puis les branches suivent : l'oeil suit une vague de fragmentation le long de +// l'arbre au lieu de voir tout le bois surgir d'un coup. +constexpr float kBuckingInterval = 0.16f; + +// Nombre de passes de resolution des collisions (voir resolve()). +// +// La resolution est SEQUENTIELLE : chaque obstacle repousse le joueur a son +// tour. C'est ce qui donne le glissement le long d'un tronc, mais quand +// plusieurs obstacles se chevauchent, sortir du premier peut replonger dans le +// second - il faut alors plusieurs passes pour converger. Quatre suffisent +// largement a la densite de foret visee ici ; les passes s'arretent des qu'une +// d'elles ne touche plus rien, donc le cas courant (aucun obstacle) n'en coute +// qu'une. +// +// Limite assumee : deux troncs plus rapproches que la largeur du joueur forment +// un passage geometriquement infranchissable. La resolution le traite en le +// repoussant d'un cote ou de l'autre sans jamais diverger ni produire de NaN, +// mais elle ne garantit pas de trouver l'echappatoire laterale. En pratique le +// joueur ne peut pas s'y retrouver enferme : il est arrete par le premier tronc +// bien avant d'atteindre l'entre-deux (c'est ce que verifie le test de marche +// dans tests/logic_tests.cpp). +constexpr int kCollisionPasses = 4; + +// Produit vectoriel 2D (composante Y) entre deux vecteurs du plan XZ. Son signe +// donne le cote, sa valeur absolue la distance a la droite quand b est unitaire. +float cross2D(const glm::vec3& a, const glm::vec3& b) { + return a.x * b.z - a.z * b.x; +} + +// Vecteur horizontal unitaire perpendiculaire a d (lui-meme horizontal). +glm::vec3 horizontalPerp(const glm::vec3& d) { + return glm::vec3(d.z, 0.0f, -d.x); +} + +// Le volume de collision de cet arbre mord-il la tranche verticale occupee par +// le corps ? C'est ce test qui distingue un tronc entier d'une souche : la +// souche d'un arbre de 7 m culmine a ~0.3 m, donc elle n'accroche que les pieds, +// alors que le tronc debout barre toute la hauteur du joueur. +// +// Un arbre EN TRAIN DE TOMBER n'expose deja plus que le volume de sa souche +// (voir Tree::colliderTopY) : son tronc est en l'air, quelque part au-dessus du +// joueur ou a cote de lui. Le suivre pendant la bascule demanderait un obstacle +// mobile - c'est hors sujet a ce stade, et la fenetre d'une seconde et demie ou +// on pourrait traverser un tronc en vol est un defaut acceptable. +bool blocksBody(const Tree& tree, const BodyCylinder& body) { + return body.feetY <= tree.colliderTopY() && body.headY >= tree.base.y; +} + +} // namespace + +// --------------------------------------------------------------------------- +// Construction : semis des arbres +// --------------------------------------------------------------------------- +Forest::Forest(const HeightSampler& terrain, Ground& ground, float terrainExtent, + const ForestParams& params, + const AspectExposureSource* aspectExposure, + const TreeSpeciesParams& speciesParams) + : terrain_(terrain), ground_(ground), terrainExtent_(terrainExtent), + params_(params), rng_(params.seed) { + // Renseignes AVANT le semis qui suit : plantTree les lit pour chaque arbre. + aspectExposure_ = aspectExposure; + speciesParams_ = speciesParams; + if (params_.minHeight <= 0.0f || params_.maxHeight < params_.minHeight) { + throw std::runtime_error("Forest : bornes de hauteur d'arbre incoherentes."); + } + if (params_.areaRadius <= params_.minDistanceFromStart) { + throw std::runtime_error( + "Forest : la zone de semis est vide (areaRadius <= minDistanceFromStart)."); + } + + // Semis par tirage-rejet : on tire une position au hasard et on la garde si + // elle passe les deux filtres (pente praticable, espacement suffisant). + // Plus simple qu'un echantillonnage de Poisson et parfaitement suffisant + // pour quelques dizaines d'arbres ; la limite d'essais garantit qu'on sort + // meme si les contraintes sont trop serrees pour la surface disponible. + std::uniform_real_distribution angleDist(0.0f, 2.0f * kPi); + std::uniform_real_distribution unitDist(0.0f, 1.0f); + std::uniform_real_distribution heightDist(params_.minHeight, params_.maxHeight); + + // Marge par rapport au bord du terrain : un arbre pile sur le bord tomberait + // hors des donnees, ou heightAt ne renvoie plus que la valeur ecretee. + const float usableExtent = std::max(0.0f, terrainExtent_ - 3.0f); + + const uint32_t maxAttempts = params_.treeCount * 60u; + trees_.reserve(params_.treeCount); + + for (uint32_t attempt = 0; attempt < maxAttempts && trees_.size() < params_.treeCount; + ++attempt) { + // Racine carree sur le rayon : sans elle, le tirage se concentre au + // centre du disque (la surface d'une couronne croit avec le rayon). + const float r0 = params_.minDistanceFromStart; + const float r1 = params_.areaRadius; + const float u = unitDist(rng_); + const float radius = std::sqrt(r0 * r0 + u * (r1 * r1 - r0 * r0)); + const float angle = angleDist(rng_); + + const float x = radius * std::cos(angle); + const float z = radius * std::sin(angle); + + if (std::abs(x) > usableExtent || std::abs(z) > usableExtent) { + continue; + } + if (slopeAt(x, z) > params_.maxSlope) { + continue; + } + + bool tooClose = false; + for (const Tree& other : trees_) { + const float dx = other.base.x - x; + const float dz = other.base.z - z; + if (dx * dx + dz * dz < params_.minSpacing * params_.minSpacing) { + tooClose = true; + break; + } + } + if (tooClose) { + continue; + } + + // Les deux tirages sont nommes AVANT l'appel, et non passes directement + // en arguments : l'ordre d'evaluation des arguments d'un appel n'est pas + // specifie en C++, donc les ecrire dans l'appel laisserait le compilateur + // decider laquelle des deux valeurs du generateur devient la hauteur et + // laquelle devient l'orientation. La foret cesserait d'etre reproductible + // d'un compilateur a l'autre, ce qui est precisement la garantie que + // ForestParams::seed est cense offrir. + const float height = heightDist(rng_); + const float yaw = angleDist(rng_); + plantTree(x, z, height, yaw); + } + + logInfo("Foret : " + std::to_string(trees_.size()) + " arbres semes sur " + + std::to_string(params_.treeCount) + " demandes (rejet par pente ou espacement)."); +} + +int Forest::plantTree(float worldX, float worldZ, float height, float yaw) { + if (height <= 0.0f) { + throw std::runtime_error("Forest : hauteur d'arbre nulle ou negative."); + } + + Tree tree; + tree.base = { worldX, terrain_.heightAt(worldX, worldZ), worldZ }; + tree.height = height; + tree.yaw = yaw; + // PHASE 26 : l'essence, decidee par le MEME appel que le semis de decor. Un + // arbre abattable et un arbre de decor plantes au meme endroit sont donc de + // la meme essence - la fonction ne depend que de la position et de la graine. + // Source d'exposition nulle (cas des tests et du terrain synthetique) : la + // part de resineux vaut alors la valeur neutre partout. + tree.species = treeSpeciesAt(worldX, worldZ, aspectExposure_, speciesParams_); + trees_.push_back(tree); + return static_cast(trees_.size()) - 1; +} + +std::size_t Forest::coniferCount() const { + std::size_t count = 0; + for (const Tree& tree : trees_) { + if (tree.species == TreeSpecies::Conifer) { ++count; } + } + return count; +} + +float Forest::slopeAt(float worldX, float worldZ) const { + // Difference centree, comme les normales de TerrainMesh. L'ecart est + // volontairement large (0.5 unite) : on veut la pente a l'echelle du pied + // d'un arbre, pas la micro-rugosite d'une cellule de la grille. + constexpr float kProbe = 0.5f; + const float dhdx = (terrain_.heightAt(worldX + kProbe, worldZ) - + terrain_.heightAt(worldX - kProbe, worldZ)) / (2.0f * kProbe); + const float dhdz = (terrain_.heightAt(worldX, worldZ + kProbe) - + terrain_.heightAt(worldX, worldZ - kProbe)) / (2.0f * kProbe); + return std::sqrt(dhdx * dhdx + dhdz * dhdz); +} + +// --------------------------------------------------------------------------- +// Visee : rayon du joueur -> arbre +// --------------------------------------------------------------------------- +int Forest::pickTree(const glm::vec3& origin, const glm::vec3& direction, + float maxDistance) const { + int closestIndex = kNoTree; + float closestT = maxDistance; + + for (std::size_t i = 0; i < trees_.size(); ++i) { + const Tree& tree = trees_[i]; + if (tree.state != TreeState::Standing) { + continue; + } + + // Volume de visee : un cylindre vertical englobant, de rayon celui du + // houppier, sur toute la hauteur de l'arbre. C'est un PROXY assume et + // non la geometrie exacte - tester le tronc reel rendrait la visee + // penible a 30 m, et rien dans le gameplay ne depend de savoir si le + // joueur a touche une branche ou le tronc. + const float pickRadius = tree.crownRadius() * 0.9f; + + // Intersection rayon / cylindre : le probleme se resout dans le plan XZ + // (le cylindre y est un cercle), la coordonnee Y ne servant ensuite qu'a + // verifier que le point touche est bien entre le pied et la cime. + const glm::vec2 d2(direction.x, direction.z); + const glm::vec2 o2(origin.x - tree.base.x, origin.z - tree.base.z); + + const float a = glm::dot(d2, d2); + if (a < 1e-6f) { + // Rayon quasi vertical : il ne peut toucher un tronc que si la + // camera est deja dedans, cas sans interet. + continue; + } + + 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); + // Les deux racines : entree puis sortie du cylindre. On teste les deux, + // pour que viser depuis l'interieur d'un houppier fonctionne aussi. + 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 < tree.base.y || y > tree.base.y + tree.height) { + continue; + } + closestT = t; + closestIndex = static_cast(i); + break; + } + } + + return closestIndex; +} + +// --------------------------------------------------------------------------- +// Zone degagee : ou l'arbre peut-il tomber ? +// --------------------------------------------------------------------------- +Clearance Forest::evaluateClearance(int treeIndex) const { + Clearance result; + if (treeIndex < 0 || static_cast(treeIndex) >= trees_.size()) { + return result; + } + + const Tree& tree = trees_[static_cast(treeIndex)]; + + // Ce qu'il faut de place pour coucher l'arbre entier : sa hauteur. + const float needed = tree.height; + + // Demi-largeur du couloir balaye par le houppier pendant la chute. On ne + // simule pas le volume exact : un couloir de largeur constante suffit a + // repondre a la seule question qui compte ici ("y a-t-il un tronc sur la + // trajectoire ?"). + const float swath = tree.crownRadius() * 0.8f; + + // Un relief qui monte de plus de ca sur le trajet arrete la chute : l'arbre + // s'appuierait sur la pente au lieu de se coucher. + const float uphillTolerance = std::max(1.0f, tree.height * 0.18f); + + struct RayResult { + glm::vec3 direction; + float freeDistance; + float score; + const char* obstacle; + }; + std::vector rays; + rays.reserve(kClearanceRayCount); + + for (int k = 0; k < kClearanceRayCount; ++k) { + const float angle = 2.0f * kPi * static_cast(k) / + static_cast(kClearanceRayCount); + const glm::vec3 dir(std::cos(angle), 0.0f, std::sin(angle)); + + float freeDistance = needed; + const char* obstacle = "aucun"; + + // --- Obstacle 1 : les autres arbres encore debout ------------------- + // Test analytique plutot qu'un echantillonnage le long du rayon : la + // distance d'un pied d'arbre a la demi-droite se lit directement dans + // la projection (le long) et le produit vectoriel 2D (le travers). + for (std::size_t j = 0; j < trees_.size(); ++j) { + if (static_cast(j) == treeIndex || trees_[j].state != TreeState::Standing) { + continue; + } + const glm::vec3 toOther = trees_[j].base - tree.base; + const float along = toOther.x * dir.x + toOther.z * dir.z; + if (along <= 0.0f || along > freeDistance) { + continue; // derriere, ou plus loin que ce qui nous interesse + } + const float lateral = std::abs(cross2D(toOther, dir)); + if (lateral < swath + trees_[j].crownRadius() * 0.7f) { + freeDistance = std::max(0.0f, along - trees_[j].trunkRadius()); + obstacle = "arbre voisin"; + } + } + + // --- Obstacle 2 : le relief qui monte ------------------------------- + for (float s = kTerrainProbeStart; s <= freeDistance; s += kTerrainStep) { + const float h = terrain_.heightAt(tree.base.x + dir.x * s, + tree.base.z + dir.z * s); + if (h - tree.base.y > uphillTolerance) { + freeDistance = s; + obstacle = "relief montant"; + break; + } + } + + // --- Score ---------------------------------------------------------- + // D'abord la place disponible, c'est le critere qui compte. A place + // egale, un bonus pour la pente descendante : c'est la ou un bucheron + // ferait effectivement tomber l'arbre, et ca departage naturellement + // les directions en terrain ouvert (sans ce terme, toutes les + // directions d'une clairiere sont ex aequo). + const float endH = terrain_.heightAt(tree.base.x + dir.x * freeDistance, + tree.base.z + dir.z * freeDistance); + const float drop = std::clamp(tree.base.y - endH, 0.0f, 6.0f); + const float score = freeDistance + 0.35f * drop; + + rays.push_back({ dir, freeDistance, score, obstacle }); + } + + // Meilleur score, puis tirage au sort parmi les quasi ex aequo : deux + // abattages dans la meme clairiere ne donnent pas mecaniquement la meme + // direction, sans pour autant sacrifier le choix de la zone la plus degagee. + float bestScore = rays.front().score; + for (const RayResult& ray : rays) { + bestScore = std::max(bestScore, ray.score); + } + + std::vector candidates; + for (const RayResult& ray : rays) { + if (ray.score >= bestScore - 0.5f) { + candidates.push_back(&ray); + } + } + + std::uniform_int_distribution pick(0, static_cast(candidates.size()) - 1); + const RayResult& chosen = *candidates[static_cast(pick(rng_))]; + + result.direction = chosen.direction; + result.distance = chosen.freeDistance; + result.obstacle = chosen.obstacle; + result.cramped = chosen.freeDistance < needed * 0.9f; + return result; +} + +// --------------------------------------------------------------------------- +// Abattage et chute +// --------------------------------------------------------------------------- +bool Forest::fell(int treeIndex, Clearance* clearanceOut) { + if (treeIndex < 0 || static_cast(treeIndex) >= trees_.size()) { + return false; + } + Tree& tree = trees_[static_cast(treeIndex)]; + if (tree.state != TreeState::Standing) { + return false; + } + + const Clearance clearance = evaluateClearance(treeIndex); + if (clearanceOut != nullptr) { + *clearanceOut = clearance; + } + + tree.fallDirection = clearance.direction; + tree.state = TreeState::Falling; + + // Conditions initiales = le coup d'epaule du bucheron sur un arbre deja + // entaille. Elles ne sont pas cosmetiques : le couple de gravite vaut + // sin(angle), donc un arbre parfaitement vertical et immobile ne tomberait + // JAMAIS. Il faut donc un ecart initial non nul. + // + // Le choix de la vitesse initiale, lui, est un choix de jeu. Avec un simple + // ecart et une vitesse nulle, la solution est en cosh(t/tau) : mesure sur + // cette scene, l'arbre mettait ~3 s a tomber dont les deux premieres + // secondes visuellement immobiles, ce qui se lit comme un bug. Une vitesse + // initiale ajoute un terme en sinh(t/tau) qui rend la bascule visible des + // la premiere demi-seconde, pour une chute complete en ~1,4 s - sans rien + // changer a l'equation du mouvement, qui reste celle du pendule. + tree.fallAngle = 0.10f; // rad, ~6 degres : l'arbre "part" sur son entaille + tree.fallRate = 0.45f; // rad/s + return true; +} + +void Forest::update(float deltaTime) { + const float dt = std::clamp(deltaTime, 0.0f, kMaxStep); + if (dt <= 0.0f) { + return; + } + + for (Tree& tree : trees_) { + if (tree.state == TreeState::Falling) { + // Pendule inverse : barre homogene de longueur L pivotant autour de + // son pied. Son moment d'inertie vaut mL²/3 et le couple de la + // gravite (mgL/2)sin(a), d'ou une acceleration angulaire + // (3g/2L)sin(a). Consequence physique correcte et bien visible : un + // grand arbre tombe plus LENTEMENT qu'un petit, parce que L est au + // denominateur. + const float angularAccel = (3.0f * kGravity / (2.0f * tree.height)) * + std::sin(tree.fallAngle); + tree.fallRate += angularAccel * dt; + tree.fallAngle += tree.fallRate * dt; + + if (tree.fallAngle >= kHalfPi) { + // Impact. L'arbre ne disparait PAS ici (c'etait le defaut de la + // Phase 5) : il se pose et reste visible le temps de s'amortir. + tree.fallAngle = kHalfPi; + tree.fallRate = 0.0f; + tree.settleTime = 0.0f; + tree.state = TreeState::Settling; + logInfo("Arbre a terre."); + } + continue; + } + + if (tree.state == TreeState::Settling) { + tree.settleTime += dt; + + // Oscillation amortie SOUS l'horizontale : la cime rebondit d'un + // poil et retombe. La valeur absolue du sinus evite que l'arbre + // repasse au-dessus de pi/2, ce qui l'enfoncerait dans le terrain. + const float decay = std::exp(-kSettleDamping * tree.settleTime); + const float swing = std::abs(std::sin(kSettlePulsation * tree.settleTime)); + tree.fallAngle = kHalfPi - kSettleAmplitude * decay * swing; + + if (tree.settleTime >= kSettleDuration) { + tree.fallAngle = kHalfPi; + tree.state = TreeState::Fallen; + scheduleBucking(tree); + } + } + } + + advancePendingDrops(dt); +} + +void Forest::advancePendingDrops(float deltaTime) { + if (pendingDrops_.empty()) { + return; + } + + // Parcours en place, en preservant l'ordre : les pieces ont ete programmees + // du pied vers la cime, et c'est dans cet ordre qu'elles doivent apparaitre. + std::size_t keep = 0; + for (std::size_t i = 0; i < pendingDrops_.size(); ++i) { + PendingDrop drop = pendingDrops_[i]; + drop.delay -= deltaTime; + + if (drop.delay <= 0.0f) { + ground_.drop(drop.kind, drop.worldX, drop.worldZ, drop.yaw, drop.roll); + } else { + pendingDrops_[keep] = drop; + ++keep; + } + } + pendingDrops_.resize(keep); +} + +// --------------------------------------------------------------------------- +// Collision : le joueur ne traverse ni les troncs debout ni les souches +// --------------------------------------------------------------------------- +bool Forest::overlaps(const BodyCylinder& body) const { + for (const Tree& tree : trees_) { + if (!blocksBody(tree, body)) { + continue; + } + + const float reach = tree.colliderRadius() + body.radius; + const float dx = body.position.x - tree.base.x; + const float dz = body.position.z - tree.base.z; + + // Marge de tolerance : resolve() repousse le joueur EXACTEMENT au + // contact, et l'arrondi flottant peut alors laisser la distance un + // cheveu sous le seuil. Sans cette marge, overlaps() contredirait + // resolve() sur sa propre sortie et le joueur serait declare bloque + // partout ou il longe un tronc. + constexpr float kContactEpsilon = 1e-3f; + if (dx * dx + dz * dz < (reach - kContactEpsilon) * (reach - kContactEpsilon)) { + return true; + } + } + return false; +} + +glm::vec3 Forest::resolve(const BodyCylinder& body) const { + glm::vec3 corrected = body.position; + + for (int pass = 0; pass < kCollisionPasses; ++pass) { + bool touched = false; + + for (const Tree& tree : trees_) { + if (!blocksBody(tree, body)) { + continue; + } + + const float reach = tree.colliderRadius() + body.radius; + const float dx = corrected.x - tree.base.x; + const float dz = corrected.z - tree.base.z; + const float distanceSq = dx * dx + dz * dz; + + if (distanceSq >= reach * reach) { + continue; + } + + const float distance = std::sqrt(distanceSq); + // Cas degenere : le joueur est exactement sur l'axe du tronc (par + // exemple parce qu'un arbre vient d'etre plante sous ses pieds). Il + // n'y a alors pas de direction de repoussement privilegiee ; on en + // choisit une arbitraire mais DETERMINISTE, plutot que de diviser + // par zero et de propager un NaN dans la position de la camera. + const glm::vec2 outward = (distance > 1e-4f) + ? glm::vec2(dx / distance, dz / distance) + : glm::vec2(1.0f, 0.0f); + + // Repoussement jusqu'au contact, et non annulation du deplacement : + // c'est ce qui donne gratuitement le glissement le long du tronc. + corrected.x = tree.base.x + outward.x * reach; + corrected.z = tree.base.z + outward.y * reach; + touched = true; + } + + // Sortir des la premiere passe sans contact : sur le cas courant (aucun + // obstacle), la seconde passe ne couterait qu'une boucle pour rien. + if (!touched) { + break; + } + } + + return corrected; +} + +int Forest::buckingLogCount(float height, int bonusLogs) { + return std::clamp(static_cast(height / 2.4f), 2, 4) + std::max(0, bonusLogs); +} + +void Forest::scheduleBucking(const Tree& tree) { + const glm::vec3 f = tree.fallDirection; + const glm::vec3 perp = horizontalPerp(f); + + // Le mesh de buche est couche le long de +X ; une rotation d'angle a autour + // de Y envoie +X sur (cos a, 0, -sin a). Aligner sur f impose donc cet + // atan2 (voir GroundItem::modelMatrix). + const float alignYaw = std::atan2(-f.z, f.x); + + std::uniform_real_distribution jitter(-0.22f, 0.22f); + std::uniform_real_distribution lateral(-0.4f, 0.4f); + std::uniform_real_distribution spin(0.0f, 2.0f * kPi); + std::uniform_real_distribution unit(0.0f, 1.0f); + + // Un tronc de 7 m debite donne 3 buches : on tronconne la longueur reelle + // plutot que de sortir un nombre fixe, pour que la quantite de bois suive la + // taille de l'arbre. + const int logCount = buckingLogCount(tree.height, 0); + + // On demarre au-dela de la souche : les buches sont debitees dans la partie + // du tronc qui est effectivement tombee. + float cursor = tree.stumpHeight() + 0.7f; + + // Delai courant. La PREMIERE buche sort a delai nul, c'est-a-dire dans la + // frame meme ou l'arbre cesse d'etre dessine : sans ca, le tronc laisserait + // un trou visible avant que le bois n'arrive. + float delay = 0.0f; + + for (int k = 0; k < logCount; ++k) { + cursor += kLogLength * 0.5f; + + const float off = lateral(rng_); + const glm::vec3 position = tree.base + f * cursor + perp * off; + + PendingDrop drop; + drop.delay = delay; + drop.kind = GroundItemKind::Log; + drop.worldX = position.x; + drop.worldZ = position.z; + drop.yaw = alignYaw + jitter(rng_); + drop.roll = spin(rng_); + pendingDrops_.push_back(drop); + + cursor += kLogLength * 0.5f + 0.3f; + delay += kBuckingInterval; + } + + // PHASE 28 (Agent 3) : buches de la HACHE. Une hache tronconne plus court + // et plus net : les buches en plus sont rangees A COTE du tronc (decalees + // d'un metre sur le cote), du pied vers la cime, pour ne jamais depasser la + // longueur reelle de l'arbre tombe. Aucun tirage aleatoire si bonus = 0 : + // sans hache, la suite du RNG est celle d'avant (scenario A intact). + for (int k = 0; k < buckingBonusLogs_; ++k) { + const float along = tree.stumpHeight() + 0.7f + kLogLength * (0.5f + static_cast(k)); + const float side = (k % 2 == 0) ? 1.0f : -1.0f; + const glm::vec3 position = tree.base + f * std::min(along, tree.height) + perp * side; + + PendingDrop drop; + drop.delay = delay; + drop.kind = GroundItemKind::Log; + drop.worldX = position.x; + drop.worldZ = position.z; + drop.yaw = alignYaw + jitter(rng_); + drop.roll = spin(rng_); + pendingDrops_.push_back(drop); + + delay += kBuckingInterval; + } + + // Les branches se dispersent autour de la partie haute de l'arbre, la ou + // etait le houppier. Elles suivent le tronc : on ebranche apres avoir + // tronconne. + constexpr int kBranchCount = 4; + for (int k = 0; k < kBranchCount; ++k) { + const float distance = tree.height * (0.45f + 0.5f * unit(rng_)); + const float off = (unit(rng_) * 2.0f - 1.0f) * tree.crownRadius(); + + const glm::vec3 position = tree.base + f * distance + perp * off; + + PendingDrop drop; + drop.delay = delay; + drop.kind = GroundItemKind::Branch; + drop.worldX = position.x; + drop.worldZ = position.z; + drop.yaw = spin(rng_); + drop.roll = spin(rng_); + pendingDrops_.push_back(drop); + + delay += kBuckingInterval; + } + + logInfo("Debitage en cours : " + std::to_string(logCount + buckingBonusLogs_) + " buches et " + + std::to_string(kBranchCount) + " branches a degager."); +} + +} // namespace vercora diff --git a/src/world/Forest.hpp b/src/world/Forest.hpp new file mode 100644 index 0000000..ad0b3b6 --- /dev/null +++ b/src/world/Forest.hpp @@ -0,0 +1,215 @@ +#pragma once + +#include "core/CollisionSolver.hpp" +#include "world/GroundItem.hpp" +#include "world/Tree.hpp" + +#include + +#include +#include +#include +#include + +namespace vercora { + +class Ground; +class HeightSampler; + +// Indice d'arbre invalide, renvoye par pickTree quand la visee ne touche rien. +inline constexpr int kNoTree = -1; + +struct ForestParams { + // Nombre d'arbres de test. Volontairement modeste : le but de cette phase + // est la logique d'abattage, pas une vraie foret. + uint32_t treeCount = 16; + + // Les arbres sont semes dans un disque de ce rayon autour de l'origine + // (ou demarre la camera), mais pas trop pres d'elle. + float areaRadius = 34.0f; + float minDistanceFromStart = 7.0f; + + // Distance minimale entre deux pieds d'arbre. Sous cette valeur, deux + // houppiers s'interpenetrent et la detection de zone degagee n'a plus de + // sens (tout arbre bloquerait tout arbre). + float minSpacing = 5.5f; + + // Bornes de hauteur en unites monde (= metres, cf. la convention 1 unite = + // 1 m posee par la hauteur d'oeil de la camera). + float minHeight = 5.5f; + float maxHeight = 9.5f; + + // Pente maximale du terrain (en tangente : 0.6 ~ 31 degres) sur laquelle un + // arbre accepte de pousser. Au-dela, le pied de l'arbre flotterait d'un cote. + float maxSlope = 0.6f; + + // Graine : deux Forest de meme graine sont identiques, donc les tests sont + // reproductibles (meme principe que Heightmap). + uint32_t seed = 20260724u; +}; + +// Resultat de l'analyse de la zone degagee autour d'un arbre. +struct Clearance { + // Direction horizontale normalisee retenue pour la chute. + glm::vec3 direction{1.0f, 0.0f, 0.0f}; + + // Distance libre trouvee dans cette direction, en unites monde, ecretee a la + // hauteur de l'arbre (au-dela, ce qui s'y trouve ne le gene plus). + float distance = 0.0f; + + // true si AUCUNE direction n'offre la place de coucher l'arbre entier. + // L'abattage reste possible - c'est au gameplay de decider s'il l'autorise - + // mais le signaler evite de croire que le systeme a trouve un bon degagement. + bool cramped = true; + + // Ce qui a arrete le rayon retenu, pour les logs. + std::string obstacle = "aucun"; +}; + +// Les arbres du monde et la logique d'abattage : placement sur le terrain, +// visee au rayon, choix de la direction de chute, animation, debitage. +// +// Ne connait RIEN de Vulkan : elle produit des positions et des etats, c'est +// main.cpp qui les traduit en DrawItem. C'est ce qui permet de tester toute la +// logique sans GPU (voir tests/logic_tests.cpp). +// +// Implemente CollisionSolver : la Forest est la seule a savoir ou sont ses +// troncs et ses souches, c'est donc a elle de dire au joueur qu'il ne peut pas +// passer au travers. La camera, elle, ne voit que l'interface. +class Forest : public CollisionSolver { +public: + // Ni le terrain ni le sol ne sont possedes : tous deux doivent vivre plus + // longtemps que la Forest. Le Ground recoit les buches et les branches + // produites par le debitage des arbres abattus. + // terrainExtent = demi-cote du terrain, pour ne pas semer hors des donnees. + // Un treeCount nul donne une foret vide, a peupler par plantTree. + // `aspectExposure` (PHASE 26) decide de l'ESSENCE de chaque arbre seme. + // Il est PARAMETRE DU CONSTRUCTEUR et non un simple setter, parce que le + // constructeur seme immediatement : un setter aurait cree un ordre a + // respecter, donc un piege - « regler la source apres coup ne fait rien » + // est exactement le genre de silence dont ce projet a deja paye le prix. + // Nul = exposition nulle partout, donc la part de resineux neutre : c'est + // le comportement d'avant la Phase 26, et le TEMOIN de non-regression. + // La source n'est PAS possedee et doit vivre plus longtemps que la Forest. + Forest(const HeightSampler& terrain, Ground& ground, float terrainExtent, + const ForestParams& params = {}, + const AspectExposureSource* aspectExposure = nullptr, + const TreeSpeciesParams& speciesParams = {}); + + // Plante un arbre a une position CHOISIE, pose sur le terrain. Le semis + // aleatoire du constructeur n'est qu'un appelant parmi d'autres : c'est par + // ici que passeront un placement decide a la main et, plus tard, la couche + // de vegetation issue de la classification LiDAR. Aucun filtre de pente ni + // d'espacement n'est applique - l'appelant demande explicitement cet arbre. + // Renvoie son indice. + int plantTree(float worldX, float worldZ, float height, float yaw = 0.0f); + + // --- ESSENCES (PHASE 26) ------------------------------------------------ + // + // Ne sert QU'AUX ARBRES PLANTES ENSUITE (plantTree) : les arbres deja semes + // gardent leur essence. C'est pour cela que la source normale passe par le + // constructeur. + void setAspectExposure(const AspectExposureSource* source) { aspectExposure_ = source; } + + const TreeSpeciesParams& speciesParams() const { return speciesParams_; } + + // Nombre d'arbres de chaque essence, pour le journal et les tests. + std::size_t coniferCount() const; + + // --- Visee -------------------------------------------------------------- + // Premier arbre DEBOUT touche par le rayon (origine, direction normalisee), + // ou kNoTree. Le volume teste est un cylindre vertical englobant, pas la + // geometrie exacte : viser un arbre a 30 m doit rester jouable. + int pickTree(const glm::vec3& origin, const glm::vec3& direction, + float maxDistance) const; + + // --- Zone degagee ------------------------------------------------------- + // Balaye l'horizon autour de l'arbre par une serie de rayons et retient la + // direction ou il peut tomber le plus loin sans rien heurter. Sans effet de + // bord : appelable pour previsualiser avant d'abattre. + Clearance evaluateClearance(int treeIndex) const; + + // --- Abattage ----------------------------------------------------------- + // Passe l'arbre en chute vers sa zone degagee. Renvoie false si l'indice ne + // designe pas un arbre debout. Le Clearance retenu ressort par clearanceOut + // (peut etre nullptr) pour que l'appelant puisse le journaliser. + bool fell(int treeIndex, Clearance* clearanceOut = nullptr); + + // Fait avancer les chutes, les amortissements et les debitages en cours. + // deltaTime en secondes. + void update(float deltaTime); + + // --- CollisionSolver ---------------------------------------------------- + glm::vec3 resolve(const BodyCylinder& body) const override; + bool overlaps(const BodyCylinder& body) const override; + + const std::vector& trees() const { return trees_; } + + // Nombre d'arbres reellement semes (le rejet par pente/espacement peut en + // produire moins que demande). + std::size_t treeCount() const { return trees_.size(); } + + // Objets encore en attente d'apparition, le temps que le debitage progresse. + // Expose pour les tests : un debitage qui n'atteint jamais zero passerait + // sinon inapercu. + std::size_t pendingDropCount() const { return pendingDrops_.size(); } + + // --- PHASE 28 (Agent 3) : rendement de la hache --------------------------- + // Buches SUPPLEMENTAIRES donnees par chaque debitage programme a partir de + // maintenant (world/Crafting axeBonusLogs : 0 sans hache, 1 hache, 2 hache + // renforcee). Lu au moment ou l'arbre finit de s'amortir, donc c'est l'outil + // PORTE A CE MOMENT qui compte. 0 par defaut = comportement anterieur au + // tirage aleatoire pres (aucun tirage supplementaire). N'affecte PAS fell(). + void setBuckingBonusLogs(int bonus) { buckingBonusLogs_ = bonus < 0 ? 0 : bonus; } + int buckingBonusLogs() const { return buckingBonusLogs_; } + + // Nombre total de buches d'un arbre de hauteur height : 2 a 4 selon la + // longueur du tronc (Phase 5), plus le bonus. + static int buckingLogCount(float height, int bonusLogs); + +private: + // Un objet de sol dont l'apparition est DIFFEREE. C'est ce qui remplace le + // depot en bloc de la Phase 5 : au lieu que tout le bois surgisse a la + // milliseconde ou l'arbre touche terre, chaque piece attend son tour et le + // tronc se debite visiblement du pied vers la cime. + struct PendingDrop { + float delay = 0.0f; // secondes restantes + GroundItemKind kind = GroundItemKind::Log; + float worldX = 0.0f; + float worldZ = 0.0f; + float yaw = 0.0f; + float roll = 0.0f; + }; + + // Sonde la pente du terrain autour d'un point, par differences finies. + float slopeAt(float worldX, float worldZ) const; + + // PHASE 26 : essences. Ni l'un ni l'autre n'influe sur OU un arbre pousse - + // ils ne sont lus que dans plantTree, apres que la position est fixee. + const AspectExposureSource* aspectExposure_ = nullptr; + TreeSpeciesParams speciesParams_{}; + + // Programme buches et branches sur la trace de l'arbre tombe, avec leurs + // delais d'apparition respectifs. + void scheduleBucking(const Tree& tree); + + // Libere les objets dont le delai est ecoule. + void advancePendingDrops(float deltaTime); + + const HeightSampler& terrain_; + Ground& ground_; + float terrainExtent_; + ForestParams params_; + + std::vector trees_; + std::vector pendingDrops_; + int buckingBonusLogs_ = 0; // PHASE 28 (Agent 3) + + // RNG unique et seede : le placement ET les tirages de la chute en + // dependent, donc une meme graine rejoue exactement la meme partie. + // Mutable : evaluateClearance departage les directions ex aequo par tirage + // tout en restant logiquement une observation (const). + mutable std::mt19937 rng_; +}; + +} // namespace vercora diff --git a/src/world/GrassMesh.cpp b/src/world/GrassMesh.cpp new file mode 100644 index 0000000..9600114 --- /dev/null +++ b/src/world/GrassMesh.cpp @@ -0,0 +1,102 @@ +#include "world/GrassMesh.hpp" + +#include +#include + +namespace vercora { +namespace { + +constexpr float kPi = 3.14159265358979323846f; + +// Largeur d'un quad au pied, en fraction de la hauteur. +// +// PHASE 18 : elargi de 0,26 a 0,42, et l'effilement du quad presque supprime +// (0,06 -> 0,30). Ce n'est pas un changement de gout mais la consequence directe +// de la decoupe alpha : le quad n'est plus le brin, il est la PLANCHE dans +// laquelle shaders/foliage.frag decoupe trois brins effiles. Garder l'ancien +// quad etroit et deja effile aurait donne trois brins minuscules dans un +// triangle, c'est-a-dire moins de matiere qu'avant. C'est desormais le MASQUE +// qui porte la silhouette, et le quad qui doit lui laisser la place. +constexpr float kBaseHalfWidth = 0.42f; + +// Largeur a la pointe. Un leger retrecissement subsiste : au-dela de la portee +// de la decoupe (voir foliage.vert), le quad redevient plein et c'est cette +// forme-la qu'on voit de loin ; un rectangle parfait s'y lirait comme un ruban. +constexpr float kTipHalfWidth = 0.30f; + +// Teintes du pied et de la pointe. Un degrade vertical est ce qui donne le plus +// d'effet pour le moins de travail : le pied dans l'ombre de la touffe est plus +// sombre et plus froid, la pointe au soleil plus claire et plus jaune. Sans lui +// une touffe est un aplat vert qui se lit comme du carton. +constexpr float kBaseColor[3] = { 0.16f, 0.26f, 0.11f }; +constexpr float kTipColor[3] = { 0.47f, 0.58f, 0.24f }; + +} // namespace + +MeshData grassTuftMeshData(int blades) { + if (blades < 1) { + throw std::runtime_error("grassTuftMeshData : au moins un quad est requis."); + } + + MeshData mesh; + mesh.name = "touffe d'herbe (Phase 11, decoupee en brins Phase 18)"; + mesh.vertices.reserve(static_cast(blades) * 4); + mesh.indices.reserve(static_cast(blades) * 6); + + for (int blade = 0; blade < blades; ++blade) { + // Les quads sont repartis regulierement en azimut. Le lacet de + // l'INSTANCE (voir InstanceData) fait ensuite tourner la touffe entiere, + // donc deux touffes voisines ne presentent pas la meme face. + const float angle = kPi * static_cast(blade) / static_cast(blades); + const float dirX = std::cos(angle); + const float dirZ = std::sin(angle); + + // Normale du quad : perpendiculaire a son plan, donc horizontale. Un + // quad vertical eclaire par une lumiere venant d'en haut recevrait ainsi + // presque rien. On la RELEVE donc vers le haut : ce n'est pas la normale + // geometrique du polygone, c'est celle que le brin AURAIT s'il etait un + // volume. C'est le meme artifice que sur n'importe quel feuillage en + // billboard, et sans lui l'herbe est uniformement noire. + const float nx = -dirZ * 0.45f; + const float nz = dirX * 0.45f; + const float ny = 0.89f; + + const auto index = static_cast(mesh.vertices.size()); + + Vertex v; + v.normal = { nx, ny, nz }; + + // Pied gauche / droit (uv.y = 0 : ne bouge pas sous l'ondulation). + v.color = { kBaseColor[0], kBaseColor[1], kBaseColor[2] }; + v.pos = { -dirX * kBaseHalfWidth, 0.0f, -dirZ * kBaseHalfWidth }; + v.uv = { 0.0f, 0.0f }; + mesh.vertices.push_back(v); + + v.pos = { dirX * kBaseHalfWidth, 0.0f, dirZ * kBaseHalfWidth }; + v.uv = { 1.0f, 0.0f }; + mesh.vertices.push_back(v); + + // Pointes (uv.y = 1 : amplitude maximale de l'ondulation). + v.color = { kTipColor[0], kTipColor[1], kTipColor[2] }; + v.pos = { dirX * kTipHalfWidth, 1.0f, dirZ * kTipHalfWidth }; + v.uv = { 1.0f, 1.0f }; + mesh.vertices.push_back(v); + + v.pos = { -dirX * kTipHalfWidth, 1.0f, -dirZ * kTipHalfWidth }; + v.uv = { 0.0f, 1.0f }; + mesh.vertices.push_back(v); + + // Deux triangles. L'orientation n'a pas d'importance : le pipeline + // dessine sans culling de faces. + mesh.indices.push_back(index + 0); + mesh.indices.push_back(index + 1); + mesh.indices.push_back(index + 2); + mesh.indices.push_back(index + 0); + mesh.indices.push_back(index + 2); + mesh.indices.push_back(index + 3); + } + + return mesh; +} + +} // namespace vercora diff --git a/src/world/GrassMesh.hpp b/src/world/GrassMesh.hpp new file mode 100644 index 0000000..ff096f9 --- /dev/null +++ b/src/world/GrassMesh.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +namespace vercora { + +// Touffe d'herbe : quelques quads croises, generes en code comme les autres +// geometries synthetiques (voir world/TreeMesh.hpp). +// +// CONVENTION UNITE, la meme que l'arbre : pied a l'origine, hauteur exactement +// 1.0, largeurs en fraction de la hauteur. L'instance ne porte donc qu'une +// echelle uniforme, ce qui autorise le vertex shader a transporter la normale +// par la seule rotation (voir renderer/InstanceData.hpp). +// +// L'UV.y vaut 0 au pied du brin et 1 a sa pointe : c'est ce que lit +// shaders/foliage.vert pour faire plier la touffe SANS decoller son pied du sol. +// +// POURQUOI DES QUADS CROISES ET NON DE VRAIS BRINS. Un brin modelise en volume +// coute une dizaine de triangles ; il en faudrait des centaines par touffe pour +// que ce soit lisible, donc des dizaines de millions a l'ecran. Trois quads +// croises a 120 degres donnent une silhouette correcte depuis n'importe quel +// azimut pour 12 triangles, et le rendu se fait sans culling de faces (deja le +// cas dans Pipeline.cpp), donc les deux cotes de chaque quad sont visibles. +// +// LIMITE ASSUMEE de cette premiere version : les quads sont OPAQUES et +// rectangulaires, sans texture ni decoupe alpha. Une touffe est donc un +// eventail de rubans verts plutot qu'un bouquet de brins. C'est ce qui permet de +// se passer entierement de melange alpha - donc de tri en profondeur - au prix +// d'un aspect plus schematique de pres. Voir NOTES-PHASE11.md. +// +// `blades` = nombre de quads croises (3 par defaut). +MeshData grassTuftMeshData(int blades = 3); + +} // namespace vercora diff --git a/src/world/Ground.cpp b/src/world/Ground.cpp new file mode 100644 index 0000000..1d8ddbe --- /dev/null +++ b/src/world/Ground.cpp @@ -0,0 +1,277 @@ +#include "world/Ground.hpp" + +#include "core/HeightSampler.hpp" +#include "world/CraftMesh.hpp" +#include "world/HarvestMesh.hpp" +#include "world/StoneMesh.hpp" +#include "world/TreeMesh.hpp" + +#include + +#include +#include + +namespace vercora { +namespace { + +constexpr float kPi = 3.14159265359f; + +} // namespace + +// --------------------------------------------------------------------------- +// GroundItem +// --------------------------------------------------------------------------- +float groundItemRestRadius(GroundItemKind kind) { + switch (kind) { + case GroundItemKind::Log: return kLogRadius; + case GroundItemKind::Branch: return kBranchRadius; + case GroundItemKind::Stone: return kStoneRadius; + case GroundItemKind::Flake: return kFlakeRadius; + // PHASE 22. Les quatre nouvelles matieres sont de PETITS objets poses a + // plat : leur demi-hauteur vient de world/HarvestMesh.hpp, exactement + // comme celle du galet vient de world/StoneMesh.hpp. + case GroundItemKind::Clay: return kClayRadius; + case GroundItemKind::Sand: return kSandRadius; + case GroundItemKind::Resin: return kResinRadius; + case GroundItemKind::Fiber: return kFiberBundleRadius; + // PHASE 28 : objets faconnes, demi-hauteurs dans world/CraftMesh.hpp. + case GroundItemKind::Cord: return kCordRadius; + case GroundItemKind::Axe: return kAxeRadius; + case GroundItemKind::Hearth: return kHearthRadius; + case GroundItemKind::Ash: return kAshRadius; + case GroundItemKind::Pitch: return kPitchRadius; + case GroundItemKind::PitchedAxe: return kAxeRadius; + case GroundItemKind::Shelter: return kShelterRadius; + } + return 0.0f; +} + +const char* groundItemLabel(GroundItemKind kind) { + switch (kind) { + case GroundItemKind::Log: return "buche"; + case GroundItemKind::Branch: return "branche"; + case GroundItemKind::Stone: return "pierre"; + case GroundItemKind::Flake: return "eclat"; + case GroundItemKind::Clay: return "motte d'argile"; + case GroundItemKind::Sand: return "poignee de sable"; + case GroundItemKind::Resin: return "resine"; + case GroundItemKind::Fiber: return "tige a fibres"; + case GroundItemKind::Cord: return "ligature"; + case GroundItemKind::Axe: return "hache"; + case GroundItemKind::Hearth: return "foyer"; + case GroundItemKind::Ash: return "cendre"; + case GroundItemKind::Pitch: return "poix"; + case GroundItemKind::PitchedAxe: return "hache renforcee"; + case GroundItemKind::Shelter: return "abri"; + } + return "objet"; +} + +const char* groundItemLabelIndefinite(GroundItemKind kind) { + switch (kind) { + case GroundItemKind::Log: return "une buche"; + case GroundItemKind::Branch: return "une branche"; + case GroundItemKind::Stone: return "une pierre"; + case GroundItemKind::Flake: return "un eclat"; + // Le genre fait partie du libelle, pas de la phrase appelante (voir + // l'en-tete de GroundItem.hpp) : "une motte", "un peu de resine". + case GroundItemKind::Clay: return "une motte d'argile"; + case GroundItemKind::Sand: return "une poignee de sable"; + case GroundItemKind::Resin: return "un peu de resine"; + case GroundItemKind::Fiber: return "une tige a fibres"; + case GroundItemKind::Cord: return "une ligature"; + case GroundItemKind::Axe: return "une hache"; + case GroundItemKind::Hearth: return "un foyer"; + case GroundItemKind::Ash: return "un peu de cendre"; + case GroundItemKind::Pitch: return "un peu de poix"; + case GroundItemKind::PitchedAxe: return "une hache renforcee"; + case GroundItemKind::Shelter: return "un abri"; + } + return "un objet"; +} + +const char* groundItemLabelPlural(GroundItemKind kind) { + switch (kind) { + case GroundItemKind::Log: return "buches"; + case GroundItemKind::Branch: return "branches"; + case GroundItemKind::Stone: return "pierres"; + case GroundItemKind::Flake: return "eclats"; + case GroundItemKind::Clay: return "argile"; + case GroundItemKind::Sand: return "sable"; + case GroundItemKind::Resin: return "resine"; + case GroundItemKind::Fiber: return "fibres"; + case GroundItemKind::Cord: return "ligatures"; + case GroundItemKind::Axe: return "haches"; + case GroundItemKind::Hearth: return "foyers"; + case GroundItemKind::Ash: return "cendre"; + case GroundItemKind::Pitch: return "poix"; + case GroundItemKind::PitchedAxe: return "haches renforcees"; + case GroundItemKind::Shelter: return "abris"; + } + return "objets"; +} + +glm::mat4 GroundItem::modelMatrix() const { + // Les meshes couches (buche, branche, eclat) sont generes le long de +X. Une + // rotation d'angle a autour de Y envoie +X sur (cos a, 0, -sin a) : pour + // aligner l'objet sur une direction donnee, l'appelant fournit donc + // yaw = atan2(-dz, dx). + // Le roll ne fait que tourner l'objet sur lui-meme (l'orientation de sa face + // de coupe), il est purement esthetique. + glm::mat4 model = glm::translate(glm::mat4(1.0f), position); + model = glm::rotate(model, yaw, glm::vec3(0.0f, 1.0f, 0.0f)); + model = glm::rotate(model, roll, glm::vec3(1.0f, 0.0f, 0.0f)); + return model; +} + +// --------------------------------------------------------------------------- +// Ground +// --------------------------------------------------------------------------- +Ground::Ground(const HeightSampler& terrain, uint32_t seed) + : terrain_(terrain), rng_(seed) {} + +void Ground::drop(GroundItemKind kind, float worldX, float worldZ, float yaw, float roll) { + GroundItem item; + item.kind = kind; + item.position = { worldX, + terrain_.heightAt(worldX, worldZ) + groundItemRestRadius(kind), + worldZ }; + item.yaw = yaw; + item.roll = roll; + items_.push_back(item); +} + +uint32_t Ground::scatterStones(uint32_t count, float areaRadius, + float minDistanceFromStart, float terrainExtent) { + if (count == 0 || areaRadius <= minDistanceFromStart) { + return 0; + } + + std::uniform_real_distribution angleDist(0.0f, 2.0f * kPi); + std::uniform_real_distribution unitDist(0.0f, 1.0f); + + // Marge par rapport au bord du terrain, meme raison que pour le semis + // d'arbres : au-dela, heightAt ne renvoie plus que la valeur ecretee. + const float usableExtent = std::max(0.0f, terrainExtent - 3.0f); + + // Deux pierres collees seraient ramassees d'un seul geste depuis le meme + // endroit, ce qui viderait la mecanique de percussion de son deplacement. + constexpr float kMinSpacing = 3.0f; + + uint32_t placed = 0; + const uint32_t maxAttempts = count * 60u; + + for (uint32_t attempt = 0; attempt < maxAttempts && placed < count; ++attempt) { + // Racine carree sur le rayon : sans elle, le tirage se concentre au + // centre du disque (meme argument que Forest). + const float r0 = minDistanceFromStart; + const float r1 = areaRadius; + const float u = unitDist(rng_); + const float radius = std::sqrt(r0 * r0 + u * (r1 * r1 - r0 * r0)); + const float angle = angleDist(rng_); + + const float x = radius * std::cos(angle); + const float z = radius * std::sin(angle); + + if (std::abs(x) > usableExtent || std::abs(z) > usableExtent) { + continue; + } + + bool tooClose = false; + for (const GroundItem& other : items_) { + const float dx = other.position.x - x; + const float dz = other.position.z - z; + if (dx * dx + dz * dz < kMinSpacing * kMinSpacing) { + tooClose = true; + break; + } + } + if (tooClose) { + continue; + } + + // Les deux tirages sont nommes AVANT l'appel : l'ordre d'evaluation des + // arguments n'est pas specifie en C++, les ecrire dans l'appel laisserait + // le compilateur decider laquelle des deux valeurs devient le yaw. Le + // semis cesserait d'etre reproductible d'un compilateur a l'autre (meme + // precaution que dans Forest). + const float yaw = angleDist(rng_); + const float roll = angleDist(rng_); + drop(GroundItemKind::Stone, x, z, yaw, roll); + ++placed; + } + + return placed; +} + +int Ground::findNearest(const glm::vec3& playerPosition, float reach, + float verticalTolerance) const { + int bestIndex = kNoGroundItem; + float bestDistanceSq = reach * reach; + + for (std::size_t i = 0; i < items_.size(); ++i) { + const GroundItem& item = items_[i]; + + // PHASE 28 : un objet FIXE (le foyer) ne se ramasse pas. + if (!groundItemIsPortable(item.kind)) { + continue; + } + + if (std::abs(item.position.y - playerPosition.y) > verticalTolerance) { + continue; + } + + const float dx = item.position.x - playerPosition.x; + const float dz = item.position.z - playerPosition.z; + const float distanceSq = dx * dx + dz * dz; + + // Comparaison stricte : a egalite parfaite on garde le premier trouve, + // ce qui rend le choix deterministe. + if (distanceSq < bestDistanceSq) { + bestDistanceSq = distanceSq; + bestIndex = static_cast(i); + } + } + + return bestIndex; +} + +std::vector Ground::indicesWithin(const glm::vec3& position, float reach, + float verticalTolerance) const { + std::vector result; + const float reachSq = reach * reach; + for (std::size_t i = 0; i < items_.size(); ++i) { + const GroundItem& item = items_[i]; + if (std::abs(item.position.y - position.y) > verticalTolerance) { + continue; + } + const float dx = item.position.x - position.x; + const float dz = item.position.z - position.z; + if (dx * dx + dz * dz <= reachSq) { + result.push_back(static_cast(i)); + } + } + return result; +} + +bool Ground::pickUp(int index, GroundItemKind* kindOut) { + if (index < 0 || static_cast(index) >= items_.size()) { + return false; + } + + const auto slot = static_cast(index); + if (kindOut != nullptr) { + *kindOut = items_[slot].kind; + } + + // Suppression par echange avec le dernier : O(1), et l'ordre de la liste n'a + // aucun sens de jeu (rien ne depend de l'ordre d'apparition des objets). + // ATTENTION : les indices renvoyes par findNearest sont donc invalides des + // qu'un ramassage a eu lieu - ils ne doivent jamais etre conserves d'une + // frame a l'autre. + items_[slot] = items_.back(); + items_.pop_back(); + return true; +} + +} // namespace vercora diff --git a/src/world/Ground.hpp b/src/world/Ground.hpp new file mode 100644 index 0000000..a14286d --- /dev/null +++ b/src/world/Ground.hpp @@ -0,0 +1,78 @@ +#pragma once + +#include "world/GroundItem.hpp" + +#include + +#include +#include +#include + +namespace vercora { + +class HeightSampler; + +// Indice d'objet invalide, renvoye par findNearest quand rien n'est a portee. +inline constexpr int kNoGroundItem = -1; + +// Tout ce qui traine sur le sol : buches et branches laissees par un abattage, +// pierres semees par le monde, eclats produits par le taillage. +// +// Separee de Forest, qui gere les arbres DEBOUT et leur chute. La frontiere est +// nette : des qu'un objet est couche au sol et ramassable, il appartient au +// Ground ; tant qu'il pousse, il appartient a la Forest. Sans cette separation, +// Forest devrait connaitre les pierres, avec lesquelles elle n'a rien a voir. +// +// Ne connait RIEN de Vulkan : elle produit des positions et des natures, c'est +// main.cpp qui les traduit en DrawItem. +class Ground { +public: + // Le terrain n'est PAS possede : il doit vivre plus longtemps que le Ground. + Ground(const HeightSampler& terrain, uint32_t seed = 20260814u); + + // --- Depot -------------------------------------------------------------- + // Pose un objet a la verticale de (worldX, worldZ), exactement sur la + // surface : l'appelant donne une position horizontale, le Ground se charge + // du Y pour qu'aucun objet ne flotte ni ne s'enfonce. + void drop(GroundItemKind kind, float worldX, float worldZ, float yaw, float roll); + + // Seme des pierres dans une couronne autour de l'origine, la ou demarre le + // joueur. Meme tirage-rejet que le semis d'arbres : position au hasard, + // gardee si elle respecte l'espacement minimal. Renvoie le nombre reellement + // depose (la limite d'essais garantit qu'on sort meme si la zone est saturee). + uint32_t scatterStones(uint32_t count, float areaRadius, + float minDistanceFromStart, float terrainExtent); + + // --- Ramassage ---------------------------------------------------------- + // Objet ramassable le plus proche du joueur, ou kNoGroundItem. + // + // La portee se mesure a l'HORIZONTALE seulement : un objet en contrebas d'un + // talus reste attrapable, et surtout la portee ne depend pas de la taille du + // joueur ni du fait que la position de reference soit son oeil et non sa + // main. Le critere vertical est traite a part, avec une tolerance large. + int findNearest(const glm::vec3& playerPosition, float reach, + float verticalTolerance = 3.0f) const; + + // Retire l'objet d'indice donne et renvoie sa nature par kindOut (peut etre + // nullptr). false si l'indice ne designe rien. + bool pickUp(int index, GroundItemKind* kindOut = nullptr); + + // PHASE 28 : TOUS les objets a portee (meme critere horizontal + tolerance + // verticale que findNearest), portables ou non, tries par indice croissant. + // Sert au faconnage (world/Crafting) : une recette compte ce qui est POSE. + // Memes reserves que findNearest : indices invalides apres un pickUp. + std::vector indicesWithin(const glm::vec3& position, float reach, + float verticalTolerance = 3.0f) const; + + const std::vector& items() const { return items_; } + std::size_t itemCount() const { return items_.size(); } + +private: + const HeightSampler& terrain_; + std::vector items_; + + // RNG seede : une meme graine rejoue exactement le meme semis de pierres. + std::mt19937 rng_; +}; + +} // namespace vercora diff --git a/src/world/GroundCover.hpp b/src/world/GroundCover.hpp new file mode 100644 index 0000000..c89cf84 --- /dev/null +++ b/src/world/GroundCover.hpp @@ -0,0 +1,29 @@ +#pragma once + +namespace vercora { + +// =========================================================================== +// PHASE 17 : ce que le SEMIS DE DECOR a besoin de savoir de l'etat du milieu. +// =========================================================================== +// Une seule question, posee en coordonnees monde : ce sol est-il encore +// couvert ? 1 = intact, 0 = nu. +// +// L'interface existe pour la meme raison que HeightSampler : world/Vegetation +// ne doit PAS dependre de world/Habitat. Le semis d'herbe consomme ce contrat +// et ne sait rien de ce qui le calcule - une degradation par abattage +// aujourd'hui, une usure des sols par pietinement demain. Reciproquement, +// Habitat ne connait pas la vegetation : il repond a une question, il ne +// pilote pas un rendu. +class GroundCoverSource { +public: + virtual ~GroundCoverSource() = default; + + // Facteur multiplicatif de densite du couvert au sol en (worldX, worldZ), + // dans [0, 1]. Contrat : la fonction est TOTALE - partout ou aucune + // degradation n'est enregistree, elle doit rendre 1, pas echouer ni rendre + // zero. Un monde sans Habitat branche se comporte donc exactement comme + // avant la Phase 17. + virtual float groundCover(float worldX, float worldZ) const = 0; +}; + +} // namespace vercora diff --git a/src/world/GroundItem.hpp b/src/world/GroundItem.hpp new file mode 100644 index 0000000..296b431 --- /dev/null +++ b/src/world/GroundItem.hpp @@ -0,0 +1,80 @@ +#pragma once + +#include + +#include + +namespace vercora { + +// Nature d'un objet pose au sol. Un enum ferme, et non un booleen "isBranch" +// comme en Phase 5 : des que la pierre et l'eclat sont apparus, le booleen ne +// pouvait plus rien exprimer. Chaque valeur a son mesh (voir TreeMesh/StoneMesh) +// et son rayon de repos (voir groundItemRestRadius). +enum class GroundItemKind : uint8_t { + Log, // buche debitee dans un tronc abattu + Branch, // branche cassee du houppier + Stone, // galet ramassable, matiere premiere du taillage + Flake, // eclat tranchant obtenu par percussion de deux pierres + // --- PHASE 22 : les trois matieres du document de cadrage qui manquaient -- + // Elles arrivent toutes les trois PAR LE SOL, comme l'eclat de percussion : + // une interaction dans le monde depose l'objet aux pieds du joueur, qui doit + // ensuite le ramasser (touche R). Aucune ne tombe directement dans + // l'inventaire - c'est la meme regle qu'en Phase 6, et c'est ce qui fait + // qu'une recolte se VOIT. + Clay, // motte d'argile creusee dans un gisement (world/Deposits) + Sand, // poignee de sable creusee dans un gisement (world/Deposits) + Resin, // resine recoltee sur un resineux SANS l'abattre (world/Resin) + Fiber, // tige a fibres arrachee (ronce, ortie) (world/FiberPlants) + // --- PHASE 28 : les objets FACONNES (world/Crafting) --------------------- + // Ajoutes EN FIN d'enum : les valeurs 0..7 gardent leur numero, donc tout + // ce qui indexe par GroundItemKind (Inventory, groundMeshes de main.cpp) + // reste valable pour les matieres existantes. Meme regle que la Phase 22 : + // tout objet faconne nait AU SOL. + Cord, // ligature : trois fibres torsadees a la main + Axe, // hache emmanchee : eclat + branche + ligature, assemblee au sol + Hearth, // foyer : cercle de pierres + petit bois. FIXE (non ramassable) + Ash, // cendre laissee par un foyer qui s'eteint + Pitch, // poix : resine + cendre chauffees pres d'un foyer allume + // --- PHASE 28, Agent 3 : les objets qui BRANCHENT un effet ----------------- + PitchedAxe, // hache renforcee : hache + poix (rendement +2 buches au lieu de +1) + Shelter, // abri de branches : buches + branches + ligatures. FIXE (non ramassable) +}; + +inline constexpr uint32_t kGroundItemKindCount = 15; + +// PHASE 28. Faux pour les objets FIXES (le foyer) : Ground::findNearest les +// ignore, ils ne peuvent donc ni etre ramasses ni entrer dans l'inventaire. +// Vrai pour toutes les autres natures (comportement anterieur inchange). +inline constexpr bool groundItemIsPortable(GroundItemKind kind) { + return kind != GroundItemKind::Hearth && kind != GroundItemKind::Shelter; +} + +// Demi-epaisseur de l'objet couche, en unites monde. Sert a le poser sur le sol +// sans qu'il s'enfonce ni qu'il flotte : son centre est a terrain + ce rayon. +float groundItemRestRadius(GroundItemKind kind); + +// Libelle francais au singulier ("buche"), pour les messages a l'unite. +const char* groundItemLabel(GroundItemKind kind); + +// Libelle au singulier PRECEDE de son article indefini ("une buche", "un +// eclat"). Le genre fait partie du libelle et non de la phrase appelante : en +// francais il depend du mot, et coller un "une " devant groundItemLabel donnait +// "une eclat" - faute visible dans le journal des la premiere percussion. +const char* groundItemLabelIndefinite(GroundItemKind kind); + +// Libelle au pluriel ("buches"), pour les compteurs d'inventaire. +const char* groundItemLabelPlural(GroundItemKind kind); + +// Un objet ramassable pose au sol. Son mesh est genere a dimensions ABSOLUES et +// n'est donc jamais mis a l'echelle : la transformation se reduit a une +// translation et deux rotations, strictement rigide. +struct GroundItem { + glm::vec3 position{0.0f}; // centre de l'objet + float yaw = 0.0f; // orientation dans le plan horizontal, radians + float roll = 0.0f; // rotation autour de l'axe de l'objet, radians + GroundItemKind kind = GroundItemKind::Log; + + glm::mat4 modelMatrix() const; +}; + +} // namespace vercora diff --git a/src/world/Habitat.cpp b/src/world/Habitat.cpp new file mode 100644 index 0000000..0b819c6 --- /dev/null +++ b/src/world/Habitat.cpp @@ -0,0 +1,274 @@ +#include "world/Habitat.hpp" + +#include +#include + +namespace vercora { +namespace { + +// Rampe lineaire ecretee, identique a celle de Vegetation.cpp : 0 sous `from`, +// 1 au-dessus de `to`, lineaire entre les deux. Redefinie ici plutot que +// partagee parce que trois lignes exportees dans un en-tete commun feraient un +// couplage pour rien. +float ramp(float value, float from, float to) { + if (to <= from) { + return value >= to ? 1.0f : 0.0f; + } + return std::clamp((value - from) / (to - from), 0.0f, 1.0f); +} + +// En dessous, une cellule est consideree revenue a l'etat neuf et oubliee. La +// valeur n'a rien de critique : elle ne fait que borner la taille de la table. +constexpr float kForgetEpsilon = 1e-3f; + +// Meme garde-fou que Forest::update et Needs::update : une image qui a dure une +// demi-seconde (chargement de tuiles, fenetre deplacee) ne doit pas faire +// avancer la memoire d'un demi-cran d'un coup. +constexpr float kMaxStep = 0.25f; + +} // namespace + +float activityNoise(Activity activity) { + switch (activity) { + case Activity::Rest: return 0.25f; + case Activity::Walk: return 1.00f; + case Activity::Bike: return 2.00f; + case Activity::Climb: return 0.60f; + case Activity::Paraglide: return 0.15f; + } + return 1.0f; +} + +Habitat::Habitat(const HabitatParams& params) : params_(params) { + // Une taille de cellule nulle ou negative rendrait tous les indices + // indefinis ; on retombe sur le defaut plutot que de produire des NaN + // silencieux dans toute la grille. + if (!(params_.cellSize > 0.0f)) { + params_.cellSize = HabitatParams{}.cellSize; + } +} + +Habitat::CellKey Habitat::keyAt(float worldX, float worldZ) const { + return CellKey{ + static_cast(std::floor(worldX / params_.cellSize)), + static_cast(std::floor(worldZ / params_.cellSize)), + }; +} + +const HabitatCell* Habitat::find(const CellKey& key) const { + const auto found = cells_.find(key); + return found == cells_.end() ? nullptr : &found->second; +} + +void Habitat::notePresence(const glm::vec3& position, float deltaTime, float noise) { + const float dt = std::clamp(deltaTime, 0.0f, kMaxStep); + if (dt <= 0.0f || noise <= 0.0f) { + return; + } + + // Toutes les cellules qui MORDENT sur le disque de bruit. Le rayon valant + // 120 m pour des cellules de 32 m, il y en a une soixantaine - un balayage + // de 9x9 au plus, une fois par image. C'est negligeable devant le semis + // d'herbe, qui en visite des milliers. + const CellKey centre = keyAt(position.x, position.z); + const auto span = static_cast( + std::ceil(params_.noiseRadius / params_.cellSize)); + + for (int32_t dz = -span; dz <= span; ++dz) { + for (int32_t dx = -span; dx <= span; ++dx) { + const CellKey key{ centre.x + dx, centre.z + dz }; + + // Distance du joueur au POINT LE PLUS PROCHE de la cellule, et non + // a son centre. La difference n'est pas un detail : avec le centre, + // la cellule ou l'on se tient recevrait une ponderation qui depend + // de l'endroit ou l'on est TOMBE dans cette cellule - jusqu'a 23 m + // de son centre, donc la moitie du rayon perdue pour rien. La + // cellule qui nous contient est a distance nulle, donc pleinement + // derangee : c'est la seule lecture qui ait un sens. + const float minX = static_cast(key.x) * params_.cellSize; + const float minZ = static_cast(key.z) * params_.cellSize; + const float nearestX = std::clamp(position.x, minX, minX + params_.cellSize); + const float nearestZ = std::clamp(position.z, minZ, minZ + params_.cellSize); + const float distance = std::sqrt( + (nearestX - position.x) * (nearestX - position.x) + + (nearestZ - position.z) * (nearestZ - position.z)); + if (distance >= params_.noiseRadius) { + continue; + } + + // Ponderation en 1 - (d/r)^2 et non lineaire. Le choix est dicte par + // le rapport montee/decroissance : une ponderation lineaire s'ecrase + // si vite qu'a la peripherie du rayon la montee devient plus lente + // que la decroissance - une cellule lointaine ne pourrait alors + // jamais monter, quel que soit le temps passe, et la deuxieme + // mecanique du cahier des charges ("rester trop longtemps dans un + // rayon donne") n'existerait tout simplement pas. En carre, la + // ponderation vaut encore 0,31 a 100 m : un joueur installe a cette + // distance d'un animal vide son vallon en trois minutes, ce qui est + // le comportement voulu. + const float ratio = distance / params_.noiseRadius; + const float weight = 1.0f - ratio * ratio; + HabitatCell& cell = cells_[key]; + cell.disturbance = std::min( + 1.0f, cell.disturbance + params_.disturbanceRise * noise * weight * dt); + // La cellule est OCCUPEE : elle ne decroit pas cette image (voir + // update). Sans ce drapeau, la decroissance se retrancherait de la + // montee, et une presence faible mais continue - justement le cas + // du campement a distance - resterait indefiniment a zero au lieu + // de s'accumuler. + cell.occupied = true; + } + } +} + +void Habitat::recordFelling(const glm::vec3& position) { + HabitatCell& cell = cells_[keyAt(position.x, position.z)]; + cell.logging = std::min(1.0f, cell.logging + params_.loggingPerTree); + cell.disturbance = std::min(1.0f, cell.disturbance + params_.loggingNoise); + ++cell.treesFelled; + + // Volontairement PAS de debordement sur les cellules voisines, contrairement + // au bruit de presence : un arbre tombe a un endroit precis, et c'est cet + // endroit-la qui perd son couvert. L'interpolation bilineaire de + // groundCover() suffit a ce que la clairiere ne soit pas un carre net a + // l'oeil ; etaler en plus le compteur reviendrait a lisser deux fois. +} + +void Habitat::update(float deltaTime) { + const float dt = std::clamp(deltaTime, 0.0f, kMaxStep); + if (dt <= 0.0f) { + return; + } + + const float disturbanceStep = params_.disturbanceDecay * dt; + const float loggingStep = params_.loggingDecay * dt; + + for (auto it = cells_.begin(); it != cells_.end();) { + HabitatCell& cell = it->second; + + // La frequentation ne redescend QUE dans les cellules que le joueur ne + // derange plus. La deforestation, elle, se resorbe toujours : une coupe + // ne se remet pas a couper parce qu'on est reste sur place. + const bool occupied = cell.occupied; + cell.occupied = false; + if (!occupied) { + cell.disturbance = std::max(0.0f, cell.disturbance - disturbanceStep); + } + cell.logging = std::max(0.0f, cell.logging - loggingStep); + + // OUBLI. Sans lui, traverser les 25 km2 finirait par garder en memoire + // toutes les cellules traversees, dont l'immense majorite est revenue a + // l'etat neuf : c'est exactement l'eviction du cache de Vegetation, + // appliquee a la memoire du milieu. + // + // treesFelled n'est PAS une raison de garder la cellule : l'interet du + // compte brut est le journal du moment, pas un cadastre des coupes. Une + // cellule qui a repousse est une cellule ordinaire. + // Une cellule OCCUPEE n'est jamais oubliee, meme si son compteur est + // encore sous le seuil. Defaut reel, et il annulait toute la mecanique : + // au premier pas de temps, une cellule ne contient que 0,0003 - donc + // moins que l'epsilon d'oubli - et elle etait effacee a l'image meme ou + // elle venait d'etre creee. La frequentation restait a zero quel que + // soit le temps passe, sans que rien ne le signale. Mesure apres + // correction : une minute de marche sur place donne bien 1,0. + if (!occupied && cell.disturbance <= kForgetEpsilon && + cell.logging <= kForgetEpsilon) { + it = cells_.erase(it); + } else { + ++it; + } + } +} + +float Habitat::disturbanceAt(float worldX, float worldZ) const { + const HabitatCell* cell = find(keyAt(worldX, worldZ)); + return cell ? cell->disturbance : 0.0f; +} + +float Habitat::loggingAt(float worldX, float worldZ) const { + const HabitatCell* cell = find(keyAt(worldX, worldZ)); + return cell ? cell->logging : 0.0f; +} + +uint32_t Habitat::treesFelledAt(float worldX, float worldZ) const { + const HabitatCell* cell = find(keyAt(worldX, worldZ)); + return cell ? cell->treesFelled : 0u; +} + +float Habitat::coverFromLogging(float logging) const { + const float bareness = ramp(logging, params_.barenessBegin, params_.barenessFull); + return glm::mix(1.0f, params_.minGroundCover, bareness); +} + +float Habitat::clearing(float worldX, float worldZ) const { + // Ecretage explicite : loggingAt vit deja dans [0, 1] par construction, mais + // le contrat de ClearingSource l'exige et un jour ou l'autre quelqu'un + // changera loggingPerTree sans relire ce fichier. + const float logging = loggingAt(worldX, worldZ); + return (logging < 0.0f) ? 0.0f : ((logging > 1.0f) ? 1.0f : logging); +} + +float Habitat::groundCover(float worldX, float worldZ) const { + // Interpolation bilineaire entre les QUATRE centres de cellule qui + // encadrent le point. L'astuce d'indice est la meme que pour une texture : + // on decale d'une demi-cellule avant de prendre la partie entiere, ce qui + // fait que le repere des centres coincide avec celui des coins. + const float u = worldX / params_.cellSize - 0.5f; + const float v = worldZ / params_.cellSize - 0.5f; + const float u0 = std::floor(u); + const float v0 = std::floor(v); + const float fu = u - u0; + const float fv = v - v0; + + const auto ix = static_cast(u0); + const auto iz = static_cast(v0); + + const auto coverOf = [this](int32_t cx, int32_t cz) { + const HabitatCell* cell = find(CellKey{ cx, cz }); + // Cellule absente = milieu intact : c'est le contrat TOTAL de + // GroundCoverSource. Un monde neuf rend donc 1 partout, et le semis + // d'herbe est bit a bit celui d'avant la Phase 17. + return cell ? coverFromLogging(cell->logging) : 1.0f; + }; + + const float c00 = coverOf(ix, iz); + const float c10 = coverOf(ix + 1, iz); + const float c01 = coverOf(ix, iz + 1); + const float c11 = coverOf(ix + 1, iz + 1); + + return glm::mix(glm::mix(c00, c10, fu), glm::mix(c01, c11, fu), fv); +} + +bool Habitat::allowsWildlife(float worldX, float worldZ) const { + const HabitatCell* cell = find(keyAt(worldX, worldZ)); + if (cell == nullptr) { + return true; // zone vierge de toute memoire : la faune y est chez elle + } + return cell->disturbance < params_.respawnThreshold && + cell->logging < params_.loggingBlocksWildlife; +} + +bool Habitat::wildlifeFlees(float worldX, float worldZ) const { + const HabitatCell* cell = find(keyAt(worldX, worldZ)); + return cell != nullptr && cell->disturbance > params_.fleeThreshold; +} + +float Habitat::peakDisturbance() const { + float peak = 0.0f; + for (const auto& [key, cell] : cells_) { + (void)key; + peak = std::max(peak, cell.disturbance); + } + return peak; +} + +float Habitat::peakLogging() const { + float peak = 0.0f; + for (const auto& [key, cell] : cells_) { + (void)key; + peak = std::max(peak, cell.logging); + } + return peak; +} + +} // namespace vercora diff --git a/src/world/Habitat.hpp b/src/world/Habitat.hpp new file mode 100644 index 0000000..4bd51a9 --- /dev/null +++ b/src/world/Habitat.hpp @@ -0,0 +1,254 @@ +#pragma once + +#include "world/Clearing.hpp" +#include "world/GroundCover.hpp" +#include "world/Needs.hpp" + +#include + +#include +#include +#include + +namespace vercora { + +// =========================================================================== +// PHASE 17 : la MEMOIRE LOCALE du milieu. +// =========================================================================== +// Le jeu ne dit jamais au joueur qu'il derange. Il s'en SOUVIENT, par endroit, +// et ce souvenir change ce qui se passe la : la faune n'y revient pas tant que +// la zone reste frequentee, et un versant vide de ses arbres perd son couvert +// au sol. C'est tout le contenu de ce fichier - aucun message, aucun compteur +// affiche, aucune notification. +// +// DEUX MEMOIRES, PAS UNE. Elles ne se comportent pas pareil et les melanger +// aurait ete une erreur de modele : +// +// frequentation (disturbance) - monte avec la PRESENCE du joueur, ponderee +// par le bruit de son activite, et redescend en quelques minutes. C'est un +// derangement : il cesse quand on s'en va. +// +// deforestation (logging) - monte par MARCHE, un cran par arbre abattu, +// et redescend dix fois plus lentement. Ce n'est pas un derangement, c'est +// un prelevement : la zone met du temps a s'en remettre, et pendant ce +// temps elle est visiblement plus nue. +// +// UNE GRILLE CREUSE, PAS UN TABLEAU. La zone fait 25 km2, soit 24 000 cellules +// de 32 m. Les allouer toutes serait possible mais faux d'esprit : le joueur en +// touche quelques dizaines par partie, et une cellule revenue a zero est +// oubliee (voir update). C'est le meme raisonnement que le semis a la demande +// de Vegetation - ce qui n'a pas ete visite n'existe pas. +// +// Ne connait ni Vulkan, ni le terrain, ni la faune : une position, un temps, +// des compteurs. Entierement testable sans GPU. +// =========================================================================== + +struct HabitatParams { + // Cote d'une cellule de memoire, en m. 32 m : de l'ordre de la cellule de + // semis d'arbres (24 m), donc une zone degradee contient assez d'arbres + // pour que leur disparition se voie, et assez petite pour qu'on puisse + // "sortir" du derangement en marchant une trentaine de secondes. + float cellSize = 32.0f; + + // Rayon, en m, sur lequel la presence du joueur derange. Le derangement + // deborde donc toujours sur les cellules voisines, avec une ponderation qui + // decroit (voir notePresence). Sans ce debordement, la memoire aurait des + // bords carres de 32 m parfaitement lisibles a l'usage - on apprendrait la + // grille, pas le milieu. + // + // 120 m, et le chiffre a ete CORRIGE en cours de session apres une mesure + // sous Vulkan. Il valait 45 m, ce qui paraissait raisonnable - un peu plus + // d'une cellule. Le scenario I a montre que ca ne pouvait pas marcher : la + // faune n'apparait jamais a moins de WildlifeParams::spawnRadiusMin, soit + // 90 m, donc AUCUN animal ne se trouvait jamais dans le rayon derange. Un + // joueur pouvait rester deux minutes au meme endroit, sa cellule saturait a + // 100 % - et il ne se passait rien. Releve du run : 24 animaux au depart, + // 24 a la fin, zero fuite. + // + // La lecon est generale et vaut d'etre notee : deux rayons regles chacun + // pour de bonnes raisons, dans deux fichiers differents, peuvent se rater + // completement. Il faut que noiseRadius depasse spawnRadiusMin, sans quoi la + // deuxieme mecanique de la phase n'existe pas. + float noiseRadius = 120.0f; + + // Montee de la frequentation, par seconde, dans la cellule ou se tient le + // joueur et pour un bruit de 1 (la marche). 1/60 : une minute de marche sur + // place sature la cellule, quatre a cinq minutes suffisent depuis un camp + // installe a quarante metres. C'est court a l'echelle d'une partie et c'est + // voulu - le systeme doit etre OBSERVABLE en jouant, pas au bout d'une + // heure. + float disturbanceRise = 1.0f / 60.0f; + + // Descente de la frequentation, par seconde, quand le joueur est parti. + // 1/240 : quatre minutes pour tout oublier depuis la saturation, donc + // quatre fois plus lent que la montee. L'asymetrie EST le propos : on + // derange plus vite qu'on ne se fait oublier. + float disturbanceDecay = 1.0f / 240.0f; + + // Cran de deforestation par arbre abattu, au pied de l'arbre. 0,34 : trois + // arbres dans la meme cellule saturent. Le seuil n'est donc pas "couper du + // bois", c'est "vider un bosquet" - couper un arbre isole pour son bois ne + // declenche rien, et c'est exactement la nuance recherchee. + float loggingPerTree = 0.34f; + + // Un abattage FAIT DU BRUIT : il ajoute aussi ce cran de frequentation. + float loggingNoise = 0.25f; + + // Descente de la deforestation, par seconde. 1/900 : un quart d'heure de + // jeu reel pour qu'une coupe saturee redevienne un sous-bois. Quinze fois + // plus lent que la frequentation. + float loggingDecay = 1.0f / 900.0f; + + // --- Seuils de faune ---------------------------------------------------- + // Deux seuils DISTINCTS, et c'est une hysteresis deliberee : les animaux + // presents partent au-dessus de fleeThreshold, et ne reviennent que sous + // respawnThreshold. Avec un seuil unique, une zone posee juste dessus + // ferait clignoter la faune - apparition, fuite, apparition - a chaque + // image. + float fleeThreshold = 0.55f; + float respawnThreshold = 0.35f; + + // Deforestation au-dela de laquelle plus aucune faune ne reapparait, quelle + // que soit la frequentation. 0,40, soit un peu plus d'un arbre : une coupe + // vide la zone plus surement qu'un passage bruyant, et pour plus longtemps + // (voir loggingDecay). + float loggingBlocksWildlife = 0.40f; + + // --- Couvert au sol ----------------------------------------------------- + // Bornes de la rampe de mise a nu : en dessous de la premiere, le sol est + // intact ; au-dessus de la seconde, il est aussi nu qu'il peut l'etre. + float barenessBegin = 0.25f; + float barenessFull = 1.00f; + + // Ce qui SUBSISTE de couvert au sol au pire de la degradation. 0,15 et non + // zero : une coupe rase n'est pas de la roche nue, il y reste des touffes. + // Zero se lirait comme un bug d'affichage, pas comme un milieu abime. + float minGroundCover = 0.15f; +}; + +// L'etat d'une cellule. Les deux compteurs vivent dans [0, 1] ; treesFelled est +// un compte brut, pour le journal et les tests (un compteur ecrete ne dit plus +// combien d'arbres sont tombes). +struct HabitatCell { + float disturbance = 0.0f; + float logging = 0.0f; + uint32_t treesFelled = 0; + + // Le joueur derange cette cellule EN CE MOMENT. Pose par notePresence, + // consomme et remis a zero par update, qui ne fait decroitre que les + // cellules libres. C'est un detail d'implementation - le contrat reste + // "notePresence puis update, une fois par image, dans cet ordre" - mais un + // detail qui decide de tout : sans lui, montee et decroissance se + // retranchent, et une presence a quarante metres ne s'accumule jamais. + bool occupied = false; +}; + +// PHASE 22 : l'Habitat repond desormais a DEUX questions du semis de decor, par +// deux interfaces distinctes qu'il implemente toutes les deux. `groundCover` +// (Phase 17) rarefie l'herbe la ou le sol est mis a nu ; `clearing` (Phase 22) +// fait pousser les plantes a fibres la ou la foret a ete ouverte. Les deux se +// lisent aujourd'hui dans le meme compteur de deforestation, et le pourquoi de +// leur separation est dans world/Clearing.hpp. +class Habitat : public GroundCoverSource, public ClearingSource { +public: + explicit Habitat(const HabitatParams& params = {}); + + // --- Ecriture ----------------------------------------------------------- + // Presence du joueur pendant deltaTime, avec le bruit de son activite + // (voir activityNoise). Touche la cellule du joueur ET ses voisines, avec + // une ponderation qui decroit jusqu'a zero a noiseRadius. + void notePresence(const glm::vec3& position, float deltaTime, float noise); + + // Un arbre vient d'etre abattu ici. Appele par le gameplay APRES un + // Forest::fell reussi - Forest lui-meme ne connait pas l'Habitat, et c'est + // volontaire : l'abattage est une mecanique de la Phase 5, l'empreinte + // qu'il laisse est une lecture de la Phase 17. + void recordFelling(const glm::vec3& position); + + // Decroissance des deux memoires et OUBLI des cellules revenues a zero. + void update(float deltaTime); + + // --- Lecture ------------------------------------------------------------ + // Valeurs de la cellule contenant le point. Pas d'interpolation : ce sont + // des grandeurs de DECISION (seuils de faune), et une decision doit etre + // stable sur toute une cellule plutot que de dependre du demi-metre pres. + float disturbanceAt(float worldX, float worldZ) const; + float loggingAt(float worldX, float worldZ) const; + uint32_t treesFelledAt(float worldX, float worldZ) const; + + // Couvert au sol, INTERPOLE bilineairement entre les centres de cellule. + // Ici l'interpolation est indispensable : c'est une grandeur d'AFFICHAGE, et + // une valeur constante par cellule dessinerait au sol un damier de 32 m de + // cote, qui se lirait comme un defaut de rendu et non comme une clairiere. + float groundCover(float worldX, float worldZ) const override; + + // Part de sol OUVERT, dans [0, 1]. C'est le compteur de deforestation de la + // cellule, ecrete - donc sans interpolation, contrairement a groundCover. + // Ici la constance par cellule est le bon choix : une recolonisation par les + // ronces se fait par TACHES, et une tache de 32 m de cote est exactement ce + // qu'on veut voir apres une coupe. C'est la meme distinction qu'entre + // disturbanceAt (decision, constante) et groundCover (affichage, interpole). + float clearing(float worldX, float worldZ) const override; + + // La faune peut-elle REAPPARAITRE ici ? (frequentation sous le seuil bas ET + // deforestation sous le sien) + bool allowsWildlife(float worldX, float worldZ) const; + + // La faune DEJA presente ici doit-elle partir ? (frequentation au-dessus du + // seuil haut) + bool wildlifeFlees(float worldX, float worldZ) const; + + // --- Diagnostic --------------------------------------------------------- + std::size_t trackedCellCount() const { return cells_.size(); } + const HabitatParams& params() const { return params_; } + + // Cellule la plus degradee des deux natures, pour le journal periodique. + float peakDisturbance() const; + float peakLogging() const; + +private: + struct CellKey { + int32_t x = 0; + int32_t z = 0; + bool operator==(const CellKey& other) const { return x == other.x && z == other.z; } + }; + struct CellKeyHash { + std::size_t operator()(const CellKey& key) const { + // Meme melange que Vegetation::CellKeyHash : les deux moities + // occupent des bits distincts. + return (static_cast(static_cast(key.x)) * 0x9E3779B1ull) + ^ (static_cast(static_cast(key.z)) * 0x85EBCA77ull); + } + }; + + CellKey keyAt(float worldX, float worldZ) const; + const HabitatCell* find(const CellKey& key) const; + + // Couvert au sol deduit du seul compteur de deforestation d'une cellule. + float coverFromLogging(float logging) const; + + HabitatParams params_; + std::unordered_map cells_; +}; + +// Bruit relatif de chaque activite, la marche valant 1. C'est le pendant exact +// de activityEffort (world/Needs.hpp) : la meme liste d'activites, mais classee +// sur ce qu'elle DERANGE et non sur ce qu'elle coute au joueur. Les deux +// echelles different vraiment, et c'est le coeur du sujet : +// +// repos 0,25 un homme immobile derange encore - il est la, il sent +// marche 1,00 reference +// velo 2,00 vite, mecanique, sur des lignes : ce qui derange le plus +// escalade 0,60 lent et silencieux, mais sur une paroi, donc en evidence +// parapente 0,15 silencieux et passager, il ne fait que traverser +// +// L'escalade est l'exemple qui montre que les deux echelles ne sont pas la +// meme : c'est l'effort MAXIMAL du joueur (4,0 chez Needs) et l'une des +// activites qui derange le MOINS. +// +// Prend l'Activity de world/Needs.hpp - la meme enumeration, pas une copie : +// deux listes d'activites finiraient par diverger le jour ou une cinquieme +// activite arrivera, et le compilateur ne dirait rien. +float activityNoise(Activity activity); + +} // namespace vercora diff --git a/src/world/HarvestMesh.cpp b/src/world/HarvestMesh.cpp new file mode 100644 index 0000000..bd7794b --- /dev/null +++ b/src/world/HarvestMesh.cpp @@ -0,0 +1,297 @@ +#include "world/HarvestMesh.hpp" + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; + +// Teintes de sommet. Comme pour le galet et l'eclat, la couleur vient du SOMMET +// et non d'une texture : le materiau Object (cube.vert/frag) l'utilise telle +// quelle. +const glm::vec3 kClayColor {0.51f, 0.35f, 0.26f}; // argile humide, ocre-rouge +const glm::vec3 kSandColor {0.76f, 0.68f, 0.50f}; // sable clair, un peu jaune +const glm::vec3 kResinColor {0.85f, 0.60f, 0.18f}; // resine ambree +const glm::vec3 kStemColor {0.36f, 0.44f, 0.22f}; // tige verte, mate +const glm::vec3 kBindColor {0.44f, 0.38f, 0.24f}; // le lien du fagot + +// Meme fonction que StoneMesh.cpp, et volontairement RECOPIEE plutot que +// partagee : la sortir dans un en-tete commun obligerait StoneMesh a dependre +// d'un troisieme fichier pour zero gain - c'est douze lignes sans etat, pas un +// systeme. Le jour ou un cinquieme generateur en aura besoin, ce sera le moment +// de la remonter. +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 : rien a dessiner, sa normale n'existe pas + } + const glm::vec3 normal = rawNormal / length; + + const auto base = static_cast(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 }); +} + +using EdgeKey = std::pair; + +uint32_t midpointIndex(std::vector& points, + std::map& 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; + } + points.push_back(glm::normalize(points[a] + points[b])); + const auto index = static_cast(points.size() - 1); + cache.emplace(key, index); + return index; +} + +// Octaedre subdivise une fois (32 faces), sommets UNIQUES bruites puis mis aux +// dimensions voulues. Meme construction que le galet, et pour la meme raison : +// bruiter les triangles independamment ouvrirait le volume. +std::vector> subdividedOctahedron(std::vector& points) { + 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}, + }; + const std::vector> 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}, + }; + + std::map midpoints; + std::vector> subdivided; + subdivided.reserve(faces.size() * 4); + for (const auto& face : faces) { + const uint32_t ab = midpointIndex(points, midpoints, face[0], face[1]); + const uint32_t bc = midpointIndex(points, midpoints, face[1], face[2]); + const uint32_t ca = midpointIndex(points, midpoints, face[2], face[0]); + subdivided.push_back({ face[0], ab, ca }); + subdivided.push_back({ ab, face[1], bc }); + subdivided.push_back({ ca, bc, face[2] }); + subdivided.push_back({ ab, bc, ca }); + } + return subdivided; +} + +} // namespace + +MeshData clayLumpMeshData() { + MeshData mesh; + mesh.name = "motte d'argile (Phase 22)"; + + std::vector points; + const auto faces = subdividedOctahedron(points); + + // Bruitage NETTEMENT plus faible que celui du galet (0,74-1,00) : l'argile + // se petrit, elle n'a pas de cassures. C'est cette seule difference de + // fourchette qui separe visuellement une motte d'un caillou de meme taille. + std::mt19937 rng(0xC1A1Fu); + std::uniform_real_distribution bump(0.90f, 1.0f); + + for (glm::vec3& point : points) { + point *= bump(rng); + point.x *= kClayWidth; + point.z *= kClayWidth; + point.y *= kClayRadius; + } + for (const auto& face : faces) { + appendFacet(mesh, points[face[0]], points[face[1]], points[face[2]], kClayColor); + } + return mesh; +} + +MeshData sandPileMeshData() { + MeshData mesh; + mesh.name = "poignee de sable (Phase 22)"; + + // Un cone tres surbaisse, pose sur sa base. Le sable n'a pas de forme + // propre : sa seule geometrie est son ANGLE DE TALUS, et c'est exactement ce + // que ce cone represente (kSandRadius / kSandWidth ~ 0,23, soit 13 degres - + // volontairement plus plat que les ~34 degres d'un vrai talus de sable sec, + // pour qu'une poignee versee au sol se lise comme une trace et non comme un + // petit volcan). + constexpr int kSides = 9; + const glm::vec3 apex{ 0.0f, kSandRadius, 0.0f }; + const glm::vec3 baseCenter{ 0.0f, -kSandRadius, 0.0f }; + + std::mt19937 rng(0x5A11Du); + std::uniform_real_distribution wobble(0.82f, 1.0f); + + std::vector rim; + rim.reserve(kSides); + for (int i = 0; i < kSides; ++i) { + const float angle = kTwoPi * static_cast(i) / static_cast(kSides); + const float r = kSandWidth * wobble(rng); + rim.push_back({ r * std::cos(angle), -kSandRadius, r * std::sin(angle) }); + } + + for (int i = 0; i < kSides; ++i) { + const glm::vec3& a = rim[static_cast(i)]; + const glm::vec3& b = rim[static_cast((i + 1) % kSides)]; + appendFacet(mesh, apex, a, b, kSandColor); + // La base est fermee : sans elle, le tas serait vu de dessous comme un + // trou des que le joueur le regarde depuis un talus en contrebas. + appendFacet(mesh, baseCenter, b, a, kSandColor); + } + return mesh; +} + +MeshData resinBlobMeshData() { + MeshData mesh; + mesh.name = "perle de resine (Phase 22)"; + + std::vector points; + const auto faces = subdividedOctahedron(points); + + std::mt19937 rng(0x235112u); + std::uniform_real_distribution bump(0.88f, 1.0f); + + for (glm::vec3& point : points) { + point *= bump(rng); + point.x *= kResinWidth; + point.z *= kResinWidth; + // Goutte : la moitie HAUTE est etiree, la moitie basse reste ronde. + // C'est la silhouette d'une coulee figee, pas d'une bille. + point.y *= (point.y > 0.0f) ? (1.9f * kResinRadius) : kResinRadius; + } + for (const auto& face : faces) { + appendFacet(mesh, points[face[0]], points[face[1]], points[face[2]], kResinColor); + } + return mesh; +} + +MeshData fiberBundleMeshData() { + MeshData mesh; + mesh.name = "fagot de tiges a fibres (Phase 22)"; + + // Quelques tiges couchees le long de +X - meme convention que la buche, la + // branche et l'eclat, ce qui rend GroundItem::yaw interchangeable entre tous + // les objets au sol. + constexpr int kStems = 5; + const float halfLength = 0.5f * kFiberBundleLength; + const float stemHalf = 0.35f * kFiberBundleRadius; + + std::mt19937 rng(0xF1BE12u); + std::uniform_real_distribution jitter(-1.0f, 1.0f); + + for (int i = 0; i < kStems; ++i) { + const float offsetZ = jitter(rng) * (kFiberBundleRadius - stemHalf); + const float offsetY = jitter(rng) * (kFiberBundleRadius - stemHalf); + // Les deux bouts ne sont pas alignes : un fagot n'est pas un fagot si + // toutes les tiges finissent au meme endroit. + const float x0 = -halfLength * (0.75f + 0.25f * std::fabs(jitter(rng))); + const float x1 = halfLength * (0.75f + 0.25f * std::fabs(jitter(rng))); + + // Une tige = un prisme triangulaire, soit six triangles. Trois faces + // suffisent a ce qu'une tige lise comme un cylindre a cette taille. + const std::array section = { + glm::vec2{ 0.0f, stemHalf }, + glm::vec2{ -0.866f * stemHalf, -0.5f * stemHalf }, + glm::vec2{ 0.866f * stemHalf, -0.5f * stemHalf }, + }; + for (int k = 0; k < 3; ++k) { + const glm::vec2& p = section[static_cast(k)]; + const glm::vec2& q = section[static_cast((k + 1) % 3)]; + const glm::vec3 a{ x0, offsetY + p.y, offsetZ + p.x }; + const glm::vec3 b{ x1, offsetY + p.y, offsetZ + p.x }; + const glm::vec3 c{ x1, offsetY + q.y, offsetZ + q.x }; + const glm::vec3 d{ x0, offsetY + q.y, offsetZ + q.x }; + appendFacet(mesh, a, b, c, kStemColor); + appendFacet(mesh, a, c, d, kStemColor); + } + } + + // Le LIEN : un anneau plat au milieu du fagot. C'est ce qui fait la + // difference entre "des tiges par terre" et "des tiges recoltees". + constexpr int kBindSides = 6; + const float bindRadius = 1.15f * kFiberBundleRadius; + const float bindHalf = 0.035f * kFiberBundleLength; + for (int i = 0; i < kBindSides; ++i) { + const float a0 = kTwoPi * static_cast(i) / static_cast(kBindSides); + const float a1 = kTwoPi * static_cast(i + 1) / static_cast(kBindSides); + const glm::vec3 p0{ -bindHalf, bindRadius * std::sin(a0), bindRadius * std::cos(a0) }; + const glm::vec3 p1{ -bindHalf, bindRadius * std::sin(a1), bindRadius * std::cos(a1) }; + const glm::vec3 q0{ bindHalf, bindRadius * std::sin(a0), bindRadius * std::cos(a0) }; + const glm::vec3 q1{ bindHalf, bindRadius * std::sin(a1), bindRadius * std::cos(a1) }; + appendFacet(mesh, p0, q0, q1, kBindColor); + appendFacet(mesh, p0, q1, p1, kBindColor); + } + + return mesh; +} + +MeshData fiberPlantMeshData() { + MeshData mesh; + mesh.name = "plante a fibres sur pied (Phase 22)"; + + // A l'echelle UNITE : une tige d'un metre, pied a l'origine. Le semis donne + // sa taille a chaque instance (meme convention que la touffe d'herbe). + // + // Six tiges dressees et DIVERGENTES, chacune un prisme triangulaire qui + // s'affine vers la pointe. La divergence est ce qui distingue une ronce + // d'une touffe d'herbe a distance : l'herbe part droit, la ronce s'ecarte. + constexpr int kStems = 6; + constexpr float kBaseHalf = 0.020f; // demi-epaisseur au pied + constexpr float kSpread = 0.28f; // ecartement de la pointe, en unites + + std::mt19937 rng(0x1207125u); + std::uniform_real_distribution unit(0.0f, 1.0f); + + for (int i = 0; i < kStems; ++i) { + const float angle = kTwoPi * (static_cast(i) + 0.35f * unit(rng)) + / static_cast(kStems); + const float height = 0.55f + 0.45f * unit(rng); + const float lean = kSpread * (0.45f + 0.55f * unit(rng)); + + const glm::vec3 foot{ 0.06f * std::cos(angle), 0.0f, 0.06f * std::sin(angle) }; + const glm::vec3 tip{ foot.x + lean * std::cos(angle), height, + foot.z + lean * std::sin(angle) }; + + const std::array section = { + glm::vec2{ 0.0f, kBaseHalf }, + glm::vec2{ -0.866f * kBaseHalf, -0.5f * kBaseHalf }, + glm::vec2{ 0.866f * kBaseHalf, -0.5f * kBaseHalf }, + }; + for (int k = 0; k < 3; ++k) { + const glm::vec2& p = section[static_cast(k)]; + const glm::vec2& q = section[static_cast((k + 1) % 3)]; + // La pointe est ramenee a un POINT unique : la tige s'y termine en + // fuseau au lieu de finir carrement, ce qui coute deux triangles de + // moins par face et se lit mieux. + // La section est REMONTEE de la moitie de kBaseHalf, qui est + // exactement la profondeur du plus bas de ses trois sommets + // (-0,5 x kBaseHalf, cf. `section`). Sans ce decalage la plante + // s'enfoncerait d'un centimetre sous le sol a chaque instance ; + // avec un decalage plein, elle flotterait d'autant. Le contrat du + // mesh unite est que son pied est a y = 0, exactement. + const glm::vec3 a{ foot.x + p.x, foot.y + p.y + 0.5f * kBaseHalf, foot.z }; + const glm::vec3 b{ foot.x + q.x, foot.y + q.y + 0.5f * kBaseHalf, foot.z }; + appendFacet(mesh, a, b, tip, kStemColor); + } + } + + return mesh; +} + +} // namespace vercora diff --git a/src/world/HarvestMesh.hpp b/src/world/HarvestMesh.hpp new file mode 100644 index 0000000..58c4127 --- /dev/null +++ b/src/world/HarvestMesh.hpp @@ -0,0 +1,68 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +namespace vercora { + +// =========================================================================== +// PHASE 22 : les geometries des matieres recoltees. +// =========================================================================== +// Meme regle que world/StoneMesh.hpp, dont ce fichier est le prolongement +// direct : tout est genere EN CODE, aucun fichier, aucun telechargement, et les +// dimensions sont ABSOLUES. Une motte d'argile fait la meme taille partout, donc +// une instance se pose par translate * rotate SANS aucune echelle - la normal +// matrix reste exacte au sens strict. +// +// Les meshes sont centres sur l'origine, y compris verticalement : Ground::drop +// les pose en ajoutant simplement leur demi-hauteur a l'altitude du terrain +// (voir groundItemRestRadius). +// +// POURQUOI QUATRE MESHES ET NON UN SEUL RECOLORE. Parce que la philosophie +// "zero menu virtuel" fait reposer TOUTE la lisibilite sur la silhouette : le +// joueur n'a aucune liste d'inventaire a l'ecran pour distinguer deux objets +// gris poses cote a cote. Une motte d'argile ronde, un tas de sable etale, une +// perle de resine et un fagot de tiges se reconnaissent de loin ; quatre galets +// de couleurs differentes, non. + +// Une motte d'argile : bloc arrondi, legerement aplati, facette grossierement. +// Plus lisse et plus ramassee que le galet - l'argile se prend a la main et +// garde la forme qu'on lui donne. +MeshData clayLumpMeshData(); + +// Une poignee de sable : petit cone tres surbaisse, comme un tas verse au sol. +// C'est la seule des quatre matieres qui n'a pas de forme propre, et son mesh +// le dit. +MeshData sandPileMeshData(); + +// Une perle de resine : goutte allongee, facettee, la pointe vers le haut. +MeshData resinBlobMeshData(); + +// Un fagot de tiges a fibres : quelques tiges couchees en faisceau, liees au +// milieu. Cest ce qui reste d'une ronce ou d'une ortie une fois arrachee et +// ebranchee. +MeshData fiberBundleMeshData(); + +// La PLANTE SUR PIED (ronce ou ortie), par opposition au fagot recolte +// ci-dessus : une touffe de tiges dressees et divergentes, bas-poly. C'est elle +// qui est semee dans le monde par world/FiberPlants.hpp ; le fagot n'apparait +// qu'une fois la plante arrachee. +// +// Le mesh est a l'echelle UNITE (une tige d'un metre) et non a dimensions +// absolues, contrairement aux quatre precedents : une ronce n'a pas de taille +// unique, et le semis lui en donne une par instance - meme convention que la +// touffe d'herbe de world/GrassMesh.hpp. +MeshData fiberPlantMeshData(); + +// --- Dimensions en unites monde -------------------------------------------- +// Les "rayons" sont des DEMI-HAUTEURS : l'objet est centre sur son origine, et +// c'est cette valeur qui le pose sur le sol sans qu'il s'enfonce ni flotte. +inline constexpr float kClayRadius = 0.075f; // demi-hauteur de la motte +inline constexpr float kClayWidth = 0.11f; // demi-largeur horizontale +inline constexpr float kSandRadius = 0.035f; // demi-hauteur du tas +inline constexpr float kSandWidth = 0.15f; +inline constexpr float kResinRadius = 0.030f; // demi-hauteur de la perle +inline constexpr float kResinWidth = 0.035f; +inline constexpr float kFiberBundleRadius = 0.045f; // demi-epaisseur du fagot +inline constexpr float kFiberBundleLength = 0.38f; + +} // namespace vercora diff --git a/src/world/Inventory.hpp b/src/world/Inventory.hpp new file mode 100644 index 0000000..7a22c48 --- /dev/null +++ b/src/world/Inventory.hpp @@ -0,0 +1,75 @@ +#pragma once + +#include "world/GroundItem.hpp" + +#include +#include + +namespace vercora { + +// Ce que le joueur porte. Volontairement reduit a des COMPTEURS : la Phase 6 a +// besoin de savoir "combien de pierres ai-je" pour autoriser la percussion, pas +// de modeliser des emplacements, des masses ou de l'encombrement. +// +// Aucun rendu, aucun menu : conformement a la philosophie "zero menu virtuel" du +// jeu, l'inventaire ne s'affiche que dans le titre de la fenetre et les logs. Le +// jour ou le portage a dos sera un vrai sujet, c'est cette classe qui grossira, +// sans que le reste du monde ait a changer. +class Inventory { +public: + void add(GroundItemKind kind, int quantity = 1) { + counts_[static_cast(kind)] += quantity; + } + + int count(GroundItemKind kind) const { + return counts_[static_cast(kind)]; + } + + // Retire quantity exemplaires. Renvoie false et ne touche a RIEN si le + // joueur n'en a pas assez : un retrait partiel silencieux serait la + // meilleure facon de faire disparaitre de la matiere sans trace. + bool remove(GroundItemKind kind, int quantity = 1) { + const auto slot = static_cast(kind); + if (quantity <= 0 || counts_[slot] < quantity) { + return false; + } + counts_[slot] -= quantity; + return true; + } + + int total() const { + int sum = 0; + for (const int value : counts_) { + sum += value; + } + return sum; + } + + // Resume compact, du type "buches 3 | branches 2 | pierres 1 | eclats 0". + // + // PHASE 28 : les huit MATIERES (Log..Fiber) sont toujours affichees, meme a + // zero, comme avant ; les objets FACONNES (Cord et suivants) ne le sont que + // s'ils sont portes, pour ne pas allonger le titre de la fenetre de cinq + // compteurs a zero. + std::string summary() const { + std::string text; + for (uint32_t i = 0; i < kGroundItemKindCount; ++i) { + const auto kind = static_cast(i); + if (i >= static_cast(GroundItemKind::Cord) && counts_[i] == 0) { + continue; + } + if (!text.empty()) { + text += " | "; + } + text += groundItemLabelPlural(kind); + text += " "; + text += std::to_string(counts_[i]); + } + return text; + } + +private: + std::array counts_{}; +}; + +} // namespace vercora diff --git a/src/world/Knapping.cpp b/src/world/Knapping.cpp new file mode 100644 index 0000000..0c929b5 --- /dev/null +++ b/src/world/Knapping.cpp @@ -0,0 +1,62 @@ +#include "world/Knapping.hpp" + +#include "world/Ground.hpp" +#include "world/GroundItem.hpp" +#include "world/Inventory.hpp" + +#include + +namespace vercora { +namespace { + +// A quelle distance devant le joueur l'eclat retombe. Assez loin pour ne pas +// etre cache par le corps du joueur, assez pres pour etre ramasse sans bouger. +constexpr float kDropDistance = 1.1f; + +// Repli quand le joueur regarde exactement a la verticale : la projection +// horizontale du regard est alors nulle et ne donne aucune direction. +constexpr glm::vec3 kFallbackFacing{ 1.0f, 0.0f, 0.0f }; + +} // namespace + +const char* knapResultMessage(KnapResult result) { + switch (result) { + case KnapResult::Success: + return "Percussion : un eclat tranchant se detache et tombe a vos pieds."; + case KnapResult::NotEnoughStones: + return "Percussion impossible : il faut deux pierres, un percuteur et un nucleus."; + } + return "Percussion : issue inconnue."; +} + +KnapResult knapStones(Inventory& inventory, Ground& ground, + const glm::vec3& playerPosition, const glm::vec3& facing) { + if (inventory.count(GroundItemKind::Stone) < 2) { + return KnapResult::NotEnoughStones; + } + + // Direction horizontale du regard. On teste la longueur AVANT de normaliser : + // normaliser un vecteur nul propagerait des NaN jusque dans la position de + // l'objet depose, qui disparaitrait alors du monde sans le moindre message. + glm::vec3 flat(facing.x, 0.0f, facing.z); + const float flatLength = std::sqrt(flat.x * flat.x + flat.z * flat.z); + flat = (flatLength > 1e-4f) ? flat / flatLength : kFallbackFacing; + + // Le nucleus est consomme, le percuteur reste. Le retrait est teste : si + // l'inventaire refusait, on ne voudrait surtout pas creer l'eclat quand meme. + if (!inventory.remove(GroundItemKind::Stone, 1)) { + return KnapResult::NotEnoughStones; + } + + const float dropX = playerPosition.x + flat.x * kDropDistance; + const float dropZ = playerPosition.z + flat.z * kDropDistance; + + // L'eclat se pose a plat, aligne sur la direction du regard : meme convention + // de yaw que la buche (mesh couche le long de +X, cf. GroundItem). + const float yaw = std::atan2(-flat.z, flat.x); + ground.drop(GroundItemKind::Flake, dropX, dropZ, yaw, /*roll=*/0.0f); + + return KnapResult::Success; +} + +} // namespace vercora diff --git a/src/world/Knapping.hpp b/src/world/Knapping.hpp new file mode 100644 index 0000000..c96ab4c --- /dev/null +++ b/src/world/Knapping.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include + +namespace vercora { + +class Ground; +class Inventory; + +// Issue d'une tentative de percussion. +enum class KnapResult { + Success, // un eclat est tombe aux pieds du joueur + NotEnoughStones, // il en faut deux : un percuteur et un nucleus +}; + +// Message francais pret a journaliser pour une issue donnee. +const char* knapResultMessage(KnapResult result); + +// --- Taillage de pierre par percussion -------------------------------------- +// Le tout premier maillon de la chaine d'artisanat : deux pierres entrechoquees +// donnent un eclat tranchant. +// +// Choix de conception (Phase 6), a assumer et a revoir quand la taille de pierre +// deviendra un vrai sujet : +// +// - IL FAUT DEUX PIERRES. Une seule ne suffit pas : la percussion suppose un +// percuteur (celui qu'on tient) et un nucleus (celui qu'on frappe). C'est ce +// qui oblige le joueur a explorer pour en trouver une seconde, et c'est la +// seule "recette" du systeme - il n'y en a volontairement aucune table. +// +// - UNE SEULE PIERRE EST CONSOMMEE, le nucleus, considere comme epuise apres +// avoir livre son eclat. Le percuteur, lui, survit : c'est l'outil, pas la +// matiere. Consommer les deux rendrait la mecanique decourageante ; n'en +// consommer aucune la rendrait gratuite. +// +// - L'ECLAT TOMBE DANS LE MONDE, devant le joueur, et doit etre ramasse comme +// n'importe quel objet au sol. Il n'atterrit PAS directement dans +// l'inventaire : la philosophie "zero menu virtuel" du jeu veut que ce qui +// est produit existe d'abord comme une chose posee quelque part. +// +// facing : direction du regard du joueur (pas necessairement horizontale, elle +// est projetee et normalisee ici). playerPosition : position de l'oeil. +KnapResult knapStones(Inventory& inventory, Ground& ground, + const glm::vec3& playerPosition, const glm::vec3& facing); + +} // namespace vercora diff --git a/src/world/Needs.cpp b/src/world/Needs.cpp new file mode 100644 index 0000000..7b07e69 --- /dev/null +++ b/src/world/Needs.cpp @@ -0,0 +1,334 @@ +#include "world/Needs.hpp" + +#include "world/Weather.hpp" + +#include +#include + +namespace vercora { + +namespace { + +float clamp01(float value) { + // NaN : std::clamp propagerait la valeur telle quelle et une jauge NaN + // contaminerait ensuite tous les coefficients, donc l'affichage ET la + // vitesse du joueur. On la ramene a 0, ce qui est visible en jeu plutot + // que silencieux. + if (!std::isfinite(value)) { + return 0.0f; + } + return std::clamp(value, 0.0f, 1.0f); +} + +// Gravite d'un manque : 0 tant que la jauge est au-dessus du seuil critique, +// 1 quand elle est vide. Une seule ecriture pour la faim, la soif et le froid - +// c'est ce qui garantit que les trois penalites ont exactement la meme forme. +float deficitOf(float gauge, float threshold) { + if (threshold <= 0.0f) { + return gauge <= 0.0f ? 1.0f : 0.0f; + } + return std::clamp((threshold - gauge) / threshold, 0.0f, 1.0f); +} + +// Penalite qui vaut 1 au-dessus du seuil et descend lineairement jusqu'a +// floorFactor quand la jauge est vide. +float factorFrom(float gauge, float threshold, float floorFactor) { + return 1.0f - (1.0f - floorFactor) * deficitOf(gauge, threshold); +} + +} // namespace + +// --------------------------------------------------------------------------- +// Activites +// --------------------------------------------------------------------------- + +const char* activityLabel(Activity activity) { + switch (activity) { + case Activity::Rest: return "repos"; + case Activity::Walk: return "marche"; + case Activity::Bike: return "velo"; + case Activity::Climb: return "escalade"; + case Activity::Paraglide: return "parapente"; + } + return "inconnu"; +} + +float activityEffort(Activity activity) { + switch (activity) { + case Activity::Rest: return 0.0f; + case Activity::Walk: return 1.0f; + case Activity::Bike: return 1.8f; + case Activity::Climb: return 4.0f; + case Activity::Paraglide: return 0.3f; + } + return 0.0f; +} + +// --------------------------------------------------------------------------- +// Horloge +// --------------------------------------------------------------------------- + +GameClock::GameClock(float startHour, float scale) + : hours_(0.0f), scale_(scale > 0.0f ? scale : 1.0f) { + setHours(startHour); +} + +void GameClock::setHours(float hours) { + if (!std::isfinite(hours)) { + hours_ = 0.0f; + totalHours_ = 0.0f; + return; + } + // std::fmod garde le signe du dividende : un reglage negatif donnerait une + // heure negative, que clockText afficherait comme "-3:00". + hours_ = std::fmod(hours, 24.0f); + if (hours_ < 0.0f) { + hours_ += 24.0f; + } + + // Le compteur total est RECALE sur le jour courant, il n'est pas remis a + // zero : regler l'heure a la main deplace dans la journee, pas dans le + // calendrier meteo. Sans ca, une commande de debogage "il est 14 h" ferait + // sauter la meteo de plusieurs jours a chaque appel. + const float dayStart = std::floor(totalHours_ / 24.0f) * 24.0f; + totalHours_ = dayStart + hours_; +} + +void GameClock::advance(float realSeconds) { + if (!(realSeconds > 0.0f)) { + return; + } + const float gameHours = realSeconds * scale_ / 3600.0f; + + // Le TOTAL avance d'abord et sans rebouclage : c'est lui qui porte les + // journees, donc le calendrier des perturbations meteo. hours_ n'en est + // qu'une lecture modulo 24. + totalHours_ += gameHours; + + hours_ = std::fmod(totalHours_, 24.0f); + if (hours_ < 0.0f) { + hours_ += 24.0f; + } +} + +std::string GameClock::clockText() const { + const int hour = std::clamp(static_cast(hours_), 0, 23); + int minute = static_cast((hours_ - static_cast(hour)) * 60.0f); + minute = std::clamp(minute, 0, 59); + + std::string text; + if (hour < 10) { text += '0'; } + text += std::to_string(hour); + text += ':'; + if (minute < 10) { text += '0'; } + text += std::to_string(minute); + return text; +} + +// --------------------------------------------------------------------------- +// PHASE 23 : le bloc "Climat" qui occupait cette place - daylightFactor(), +// ambientTemperature() et terrainExposure() - a ete DEPLACE dans +// world/Weather.cpp. Needs ne calcule plus aucune temperature ambiante ; il en +// RECOIT une (NeedsContext::ambientTemperatureC) et n'y ajoute que ce qui +// concerne le corps du joueur : son effort, sa fatigue, son abri, le vent qu'il +// subit. C'est la separation qui garantit qu'il n'existe qu'une seule source de +// verite sur la temperature. +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// Needs +// --------------------------------------------------------------------------- + +Needs::Needs(const NeedsParams& params) : params_(params) { + // La temperature ressentie de depart n'a de sens qu'apres un update ; on + // l'initialise au confort pour qu'un affichage avant la premiere image + // n'annonce pas 0 degre. + lastAmbientC_ = params_.comfortTemperatureC; + lastFeltC_ = params_.comfortTemperatureC; +} + +void Needs::update(float deltaTime, const NeedsContext& context) { + if (!(deltaTime > 0.0f) || !std::isfinite(deltaTime)) { + return; + } + + const float effort = activityEffort(context.activity); + + // Les quatre jauges avancent depuis le MEME instantane : le manque qui + // aggrave la fatigue est celui du debut du pas, pas celui qu'on est en + // train de calculer. Sans ca, l'ordre des lignes ci-dessous changerait le + // resultat, ce qui rendrait tout test dependant d'un detail d'ecriture. + const float deficit = worstDeficit(); + const float deficitScale = 1.0f + params_.deficitFatigueGain * deficit; + + // --- Temperature -------------------------------------------------------- + // Calculee en premier parce que la soif en depend (chaleur), mais elle + // n'utilise que la fatigue du debut du pas. + // PHASE 23 : plus aucun calcul d'ambiante ici. Elle arrive du systeme meteo + // (world/Weather.hpp) par le contexte. Une valeur non finie serait la seule + // facon de contaminer les quatre jauges d'un coup, donc on la neutralise sur + // le confort plutot que de la propager. + lastAmbientC_ = std::isfinite(context.ambientTemperatureC) + ? context.ambientTemperatureC + : params_.comfortTemperatureC; + + // --- Refroidissement eolien -------------------------------------------- + // Applique AVANT les termes du corps, et c'est l'ordre correct : le vent + // refroidit l'AIR ressenti, il ne retranche pas la chaleur produite par + // l'effort. Un abri l'annule entierement - c'est ce qu'est un abri. + // + // La formule (JAG/TI, voir windChillC) ne mord qu'en dessous de 10 degres et + // au-dessus de 4,8 km/h de vent : par une apres-midi douce et calme, ce + // terme vaut exactement zero, et le comportement des jauges est celui de la + // Phase 16. + float felt = context.sheltered + ? lastAmbientC_ + : windChillC(lastAmbientC_, context.windSpeedMps); + + felt += params_.exertionWarmthCPerEffort * effort; + felt += params_.exhaustionChillC * (1.0f - fatigue_); + if (context.sheltered) { + felt += params_.shelterWarmthC; + } + lastFeltC_ = felt; + + const float margin = felt - params_.comfortTemperatureC; + if (margin < 0.0f) { + temperature_ = clamp01(temperature_ + + params_.coolingPerSecondPerDegree * margin * deltaTime); + } else { + const float ramp = params_.fullWarmingMarginC > 0.0f + ? std::min(1.0f, margin / params_.fullWarmingMarginC) + : 1.0f; + temperature_ = clamp01(temperature_ + + params_.warmingPerSecond * ramp * deltaTime); + } + + // --- Faim --------------------------------------------------------------- + const float hungerRate = + params_.hungerPerSecondAtRest * (1.0f + params_.hungerEffortGain * effort); + hunger_ = clamp01(hunger_ - hungerRate * deltaTime); + + // --- Soif --------------------------------------------------------------- + float thirstRate = + params_.thirstPerSecondAtRest * (1.0f + params_.thirstEffortGain * effort); + const float heat = felt - params_.heatThirstThresholdC; + if (heat > 0.0f) { + thirstRate += params_.thirstPerSecondPerDegreeHeat * heat; + } + thirst_ = clamp01(thirst_ - thirstRate * deltaTime); + + // --- Fatigue ------------------------------------------------------------ + // Le repos est le SEUL etat qui remonte la jauge, et il exige l'immobilite + // complete : c'est ce qui fait d'une pause une decision de jeu. + if (effort <= 0.0f) { + fatigue_ = clamp01(fatigue_ + + params_.fatigueRecoveryPerSecond / deficitScale * deltaTime); + } else { + fatigue_ = clamp01(fatigue_ - params_.fatiguePerSecondWalking * effort * + deficitScale * deltaTime); + } +} + +float Needs::fatigueFactor() const { + const float threshold = params_.fatiguePenaltyThreshold; + if (threshold <= 0.0f) { + return 1.0f; + } + if (fatigue_ >= threshold) { + return 1.0f; + } + return params_.fatigueFloorFactor + + (1.0f - params_.fatigueFloorFactor) * (fatigue_ / threshold); +} + +float Needs::hungerFactor() const { + return factorFrom(hunger_, params_.criticalThreshold, params_.hungerFloorFactor); +} + +float Needs::thirstFactor() const { + return factorFrom(thirst_, params_.criticalThreshold, params_.thirstFloorFactor); +} + +float Needs::coldFactor() const { + return factorFrom(temperature_, params_.criticalThreshold, params_.coldFloorFactor); +} + +float Needs::movementFactor() const { + const float product = fatigueFactor() * hungerFactor() * thirstFactor() * coldFactor(); + return std::clamp(product, params_.minimumMovementFactor, 1.0f); +} + +float Needs::worstDeficit() const { + const float threshold = params_.criticalThreshold; + return std::max({deficitOf(hunger_, threshold), + deficitOf(thirst_, threshold), + deficitOf(temperature_, threshold)}); +} + +bool Needs::drink() { + if (thirst_ >= 1.0f) { + return false; + } + thirst_ = 1.0f; + return true; +} + +bool Needs::eat(float nutrition) { + if (!(nutrition > 0.0f) || hunger_ >= 1.0f) { + return false; + } + hunger_ = clamp01(hunger_ + std::min(nutrition, 1.0f)); + return true; +} + +void Needs::reset() { + hunger_ = 1.0f; + thirst_ = 1.0f; + fatigue_ = 1.0f; + temperature_ = 1.0f; + lastAmbientC_ = params_.comfortTemperatureC; + lastFeltC_ = params_.comfortTemperatureC; +} + +void Needs::setHunger(float value) { hunger_ = clamp01(value); } +void Needs::setThirst(float value) { thirst_ = clamp01(value); } +void Needs::setFatigue(float value) { fatigue_ = clamp01(value); } +void Needs::setTemperature(float value) { temperature_ = clamp01(value); } + +namespace { + +// Pourcentage entier d'une jauge. Arrondi et non tronque : une jauge a 0,999 +// doit afficher 100 % et non 99 %. +int percent(float gauge) { + return static_cast(std::lround(100.0f * std::clamp(gauge, 0.0f, 1.0f))); +} + +// Un entier signe de degres, arrondi. Le titre n'a pas la place d'une decimale +// et le journal a statusLine pour le detail. +int degrees(float celsius) { + if (!std::isfinite(celsius)) { + return 0; + } + return static_cast(std::lround(celsius)); +} + +} // namespace + +std::string Needs::summary() const { + // "forme" et non "fatigue" : la jauge vaut 1 quand tout va bien, comme les + // trois autres. L'appeler "fatigue 100 %" se lirait a l'envers. + return "faim " + std::to_string(percent(hunger_)) + "% soif " + + std::to_string(percent(thirst_)) + "% forme " + + std::to_string(percent(fatigue_)) + "% chaud " + + std::to_string(percent(temperature_)) + "%"; +} + +std::string Needs::statusLine() const { + return "Besoins : " + summary() + ", ambiante " + + std::to_string(degrees(lastAmbientC_)) + " C, ressenti " + + std::to_string(degrees(lastFeltC_)) + " C, deplacement " + + std::to_string(percent(movementFactor())) + " %."; +} + +} // namespace vercora diff --git a/src/world/Needs.hpp b/src/world/Needs.hpp new file mode 100644 index 0000000..9845278 --- /dev/null +++ b/src/world/Needs.hpp @@ -0,0 +1,454 @@ +#pragma once + +#include + +namespace vercora { + +class HeightSampler; + +// =========================================================================== +// PHASE 16 : les besoins primaires du joueur. +// =========================================================================== +// Quatre jauges - faim, soif, fatigue, temperature - dans [0, 1], ou 1 est +// l'etat satisfait et 0 l'etat critique. AUCUNE ne tue : conformement au +// cadrage ("bac a sable et survie semi-simulee", pas de punition brutale), une +// jauge a zero degrade les capacites physiques et rien d'autre. Il n'y a ni +// mort, ni ecran de fin, ni compteur de score. +// +// La classe est dans le meme moule que Paraglider / Bike / Climber : elle ne +// connait ni Vulkan, ni GLFW, ni la Camera. Elle recoit un pas de temps et un +// CONTEXTE (ce que le joueur est en train de faire, ou il est, quelle heure il +// est), et elle rend des jauges et des COEFFICIENTS. C'est l'appelant - +// main.cpp - qui applique ces coefficients aux entrees des activites. Rien +// dans Bike ni dans Climber n'a ete modifie pour cette phase, et c'est +// volontaire : une penalite qui multiplie une commande deja ecretee ne peut +// pas casser une physique dont les tests passent depuis deux phases. +// +// --------------------------------------------------------------------------- +// ECHELLE DE TEMPS : les taux sont en SECONDES REELLES +// --------------------------------------------------------------------------- +// Toutes les vitesses de variation ci-dessous sont exprimees par seconde REELLE +// de jeu, pas par heure simulee. La cible annoncee dans le cahier des charges +// de la phase est : rien de perceptible en quelques minutes, un vrai enjeu sur +// une session de 30 a 60 minutes. Les valeurs par defaut donnent, depuis des +// jauges pleines et en marchant sans arret : +// +// fatigue vide en 90 min (penalite des 45 min, moitie de jauge) +// soif vide en 65 min a la marche (2 h 30 a l'arret) +// faim vide en 126 min a la marche (4 h a l'arret) +// temperature depend du relief et de l'heure - voir plus bas +// +// Autrement dit : sur une session d'une heure de marche, la fatigue est le +// premier sujet, la soif devient sensible vers la fin, la faim ne fait que +// commencer a se voir. C'est l'ordre voulu - il pousse a se reposer et a +// chercher un point d'eau, sans transformer une exploration en gestion de +// menus. Les activites intenses accelerent tout : l'escalade fatigue quatre +// fois plus vite que la marche, le velo pres de deux fois. +// +// Ces chiffres sont VERIFIES par les tests headless (tests/logic_tests.cpp, +// section Phase 16) : c'est la que se lit le comportement reellement obtenu. +// =========================================================================== + +// Ce que le joueur est en train de faire. Une par mode de camera qui coute de +// l'energie, plus Rest pour l'arret complet. +enum class Activity { + Rest, // debout ou assis, immobile : la seule ou la fatigue remonte + Walk, // marche + Bike, // velo (Phase 13) + Climb, // escalade (Phase 14) + Paraglide, // parapente (Phase 8) +}; + +const char* activityLabel(Activity activity); + +// Effort physique relatif de chaque activite, la marche valant 1. C'est le +// SEUL endroit ou l'intensite des activites est comparee ; faim, soif, fatigue +// et chaleur produite en derivent toutes. +// +// Rest 0,0 aucun effort - et c'est ce zero qui fait du repos un choix +// Walk 1,0 reference +// Bike 1,8 pedaler coute plus que marcher a duree egale, mais on +// descend aussi en roue libre : d'ou 1,8 et non 3 +// Climb 4,0 l'escalade est l'effort maximal du jeu, et de loin. Elle a +// deja sa propre jauge courte (Climber::stamina, qui se vide +// en quelques minutes) ; la fatigue, elle, est l'enveloppe +// longue qui interdit d'enchainer dix parois dans l'apres-midi +// Paraglide 0,3 le vol n'est pas un repos (on pilote, on a froid) mais ce +// n'est pas un effort musculaire +float activityEffort(Activity activity); + +// --------------------------------------------------------------------------- +// Contexte d'une image : tout ce que les jauges doivent savoir du monde. +// --------------------------------------------------------------------------- +struct NeedsContext { + Activity activity = Activity::Rest; + + // ---------------------------------------------------------------------- + // PHASE 23 - LA TEMPERATURE AMBIANTE ARRIVE DE L'EXTERIEUR + // ---------------------------------------------------------------------- + // Jusqu'a la Phase 22, ce contexte portait l'altitude, l'heure et + // l'exposition, et Needs en DEDUISAIT lui-meme l'ambiante par une formule + // qui lui appartenait (ambientTemperature(), supprimee). + // + // Cette formule a ete REMPLACEE, pas doublee : le calcul vit desormais dans + // world/Weather.hpp, qui sait des choses que Needs ne pouvait pas savoir + // (saison, masse d'air, nebulosite, inversion de fond de cuvette), et Needs + // en CONSOMME le resultat. Il n'existe donc qu'UN SEUL calcul de temperature + // dans tout le jeu, et il est impossible que deux versions divergent - ce + // qui etait le risque explicite du cahier des charges. + // + // Le remplissage habituel est : + // const WeatherSample w = weather.sampleAt(position, gameHours, terrain); + // ctx.ambientTemperatureC = w.temperatureC; + // ctx.windSpeedMps = w.windMps; + // + // La valeur par defaut (12 degres = le confort par defaut) existe pour qu'un + // contexte construit sans meteo - un test de faim, par exemple - ne fasse ni + // chaud ni froid, au lieu de geler le joueur a 0 degre. + float ambientTemperatureC = 12.0f; + + // Vent au point du joueur, en m/s. Alimente le refroidissement eolien (voir + // windChillC dans Weather.hpp), qui a remplace la constante forfaitaire + // NeedsParams::paraglideWindChillC de la Phase 16. + // + // EN VOL, C'EST A L'APPELANT D'Y AJOUTER LA VITESSE PROPRE DE L'AILE : un + // parapente qui vole a 10,5 m/s dans un air calme subit bien 10,5 m/s de + // vent relatif. C'est ce qui reproduit - en mieux, parce que ca depend + // desormais du vent reel et de la temperature - le refroidissement du vol + // libre que la Phase 16 codait en dur. + float windSpeedMps = 0.0f; + + // Le joueur est-il abrite du vent et du froid ? Aucun abri n'existe encore + // dans le jeu ; le champ est le point d'ancrage prevu pour le jour ou + // l'artisanat en produira un, et les tests l'exercent deja. Depuis la + // Phase 23 il annule AUSSI le refroidissement eolien, ce qui est la + // definition meme d'un abri. + bool sheltered = false; +}; + +// --------------------------------------------------------------------------- +// Parametres. Tous documentes, tous modifiables sans toucher au code. +// --------------------------------------------------------------------------- +struct NeedsParams { + // --- Faim --------------------------------------------------------------- + + // Fraction de jauge perdue par seconde A L'ARRET. 1/(4 h) : un joueur + // parfaitement immobile met quatre heures a avoir faim pour de bon. La + // faim est volontairement la plus lente des quatre - c'est le besoin qu'on + // ne peut pas encore satisfaire (voir eat(), sans appelant a ce stade). + float hungerPerSecondAtRest = 1.0f / (4.0f * 3600.0f); + + // Part de l'effort dans la depense. Consommation = repos * (1 + gain*effort). + // 0,9 : marcher (effort 1) fait consommer 1,9 fois plus qu'a l'arret. + float hungerEffortGain = 0.9f; + + // --- Soif --------------------------------------------------------------- + + // 1/(2 h 30) a l'arret : on a soif plus vite qu'on a faim, ce qui est vrai + // et ce qui est aussi le bon choix de jeu - la soif est le besoin qu'on + // PEUT satisfaire (un point d'eau, voir world/WaterSource.hpp), elle doit + // donc etre celle qui se manifeste. + float thirstPerSecondAtRest = 1.0f / (2.5f * 3600.0f); + + // 1,3 : l'effort compte plus pour la soif que pour la faim. Marcher fait + // boire 2,3 fois plus qu'a l'arret, grimper 6,2 fois plus. + float thirstEffortGain = 1.3f; + + // Chaleur : au-dela de ce ressenti, on transpire et on boit davantage. 22 + // degres, et NON la temperature de confort. Les deux seuils ne sont pas le + // meme : le confort (12 degres) est la limite en dessous de laquelle on se + // refroidit, il reste tres frais. Les avoir confondus dans une premiere + // version rendait le joueur assoiffe par une journee de printemps a 17 + // degres - la soif doublait, et cinq minutes de marche la faisaient deja + // descendre de 15 %. + float heatThirstThresholdC = 22.0f; + + // Soif supplementaire par degre RESSENTI au-dessus de ce seuil, en fraction + // par seconde et par degre. Le climat de montagne est froid : ce terme est + // presque toujours nul, il existe pour ne pas mentir sur le modele. + float thirstPerSecondPerDegreeHeat = 1.0f / (6.0f * 3600.0f); + + // --- Fatigue ------------------------------------------------------------ + + // Fatigue perdue par seconde A LA MARCHE (effort 1). 1/(90 min) : une + // heure et demie de marche continue vide la jauge. Les autres activites + // sont ce taux multiplie par leur effort. + float fatiguePerSecondWalking = 1.0f / (90.0f * 60.0f); + + // Recuperation a l'arret complet, par seconde. 1/(20 min) : vingt minutes + // d'immobilite REELLE refont une jauge pleine. C'est long a l'echelle d'une + // session, et c'est le but - se reposer doit etre une decision, pas un + // reflexe qu'on prend toutes les deux minutes. + float fatigueRecoveryPerSecond = 1.0f / (20.0f * 60.0f); + + // --- Temperature -------------------------------------------------------- + + // Temperature de confort du joueur, en degres Celsius : au-dessus la jauge + // remonte, en dessous elle descend. 12 degres et non 20 : le joueur est + // habille pour la montagne et en mouvement. + float comfortTemperatureC = 12.0f; + + // PHASE 23 : cinq parametres ont QUITTE cette struct - la moyenne au niveau + // de la mer, le gradient adiabatique, l'amplitude et l'heure du cycle + // diurne, et le bonus d'adret. Ils ne sont pas supprimes : ils vivent + // desormais dans WeatherParams (world/Weather.hpp), avec le calcul qui les + // employait. Ce qui reste ici ne decrit plus le CLIMAT mais le JOUEUR - sa + // temperature de confort, ce que son effort lui apporte, ce que la fatigue + // lui coute. C'est la bonne frontiere, et c'est celle qui garantit qu'il n'y + // a qu'une seule source de verite sur l'ambiante. + + // Chaleur produite par l'effort, en degres d'ambiante equivalente et par + // unite d'effort. 1,5 : marcher rechauffe de 1,5 degre, grimper de 6. C'est + // ce qui rend un bivouac immobile plus froid qu'une montee. + float exertionWarmthCPerEffort = 1.5f; + + // PHASE 23 : paraglideWindChillC (-6 degres forfaitaires en vol) a ete + // SUPPRIME. Le refroidissement eolien est desormais calcule par la formule + // JAG/TI (voir windChillC dans Weather.hpp) a partir du vent REEL au point + // et de la temperature REELLE - vitesse propre de l'aile comprise, que + // l'appelant ajoute a NeedsContext::windSpeedMps. Le vol reste donc + // refroidissant, mais il l'est desormais pour la bonne raison, et la marche + // en crete par vent fort l'est aussi, ce qu'un forfait reserve au vol ne + // pouvait pas exprimer. + + // Penalite thermique d'un joueur epuise, en degres a fatigue nulle. -3 : + // la fatigue empeche de se rechauffer. C'est le seul couplage entre jauges + // qui passe par la temperature ressentie plutot que par un coefficient. + float exhaustionChillC = -3.0f; + + // Abri : degres regagnes quand NeedsContext::sheltered est vrai. + float shelterWarmthC = 5.0f; + + // Vitesse de refroidissement, en fraction de jauge par seconde et par degre + // manquant. 1/(1800 * 10) : dix degres sous le confort (donc 2 degres + // ressentis) vident la jauge en 30 minutes ; cinq degres en dessous, il + // faut une heure. Une nuit en crete devient un vrai probleme, une soiree + // fraiche en vallee non. + float coolingPerSecondPerDegree = 1.0f / (1800.0f * 10.0f); + + // Vitesse maximale de rechauffement, par seconde. 1/(10 min) : on se + // rechauffe trois fois plus vite qu'on ne se refroidit, ce qui est le bon + // sens du desequilibre - se remettre d'un coup de froid ne doit pas couter + // une demi-session. + float warmingPerSecond = 1.0f / (10.0f * 60.0f); + + // Ecart au-dessus du confort qui donne le rechauffement maximal, en degres. + float fullWarmingMarginC = 5.0f; + + // --- Consequences ------------------------------------------------------- + + // Seuil sous lequel faim, soif et froid commencent a penaliser. 0,25 : les + // trois premiers quarts de chaque jauge sont sans effet, ce qui evite que + // le joueur soit diminue en permanence. + float criticalThreshold = 0.25f; + + // Coefficient de deplacement atteint a jauge NULLE, par besoin. Aucun n'est + // proche de zero : le joueur ralentit, il ne se fige jamais. + float hungerFloorFactor = 0.70f; + float thirstFloorFactor = 0.65f; + float coldFloorFactor = 0.70f; + + // Fatigue : la penalite commence plus tot (a la moitie de la jauge) parce + // que la fatigue EST la jauge d'effort - c'est elle qui doit se sentir en + // premier dans les activites physiques. + float fatiguePenaltyThreshold = 0.50f; + float fatigueFloorFactor = 0.55f; + + // Plancher absolu du coefficient de deplacement, une fois les quatre + // penalites multipliees. 0,35 : un joueur au plus mal avance encore a plus + // du tiers de sa vitesse. C'est la traduction chiffree de "pas de punition + // brutale" - sans ce plancher, le produit des quatre facteurs tomberait a + // 0,17 et le joueur serait pratiquement immobilise loin de tout. + float minimumMovementFactor = 0.35f; + + // Facteur d'aggravation de la fatigue par les autres manques. A 1,0, un + // joueur affame, assoiffe ou glace se fatigue deux fois plus vite et + // recupere deux fois moins vite. C'est ce qui empeche de compenser + // indefiniment la soif par des pauses. + float deficitFatigueGain = 1.0f; +}; + +// --------------------------------------------------------------------------- +// Horloge de jeu +// --------------------------------------------------------------------------- +// PHASE 23 - L'INCOHERENCE DE LA PHASE 16 EST CORRIGEE. Le commentaire qui +// occupait cette place disait : "cette horloge n'existe QUE pour la temperature, +// et rien dans le rendu ne change avec elle". Ce n'est plus vrai. La direction +// et l'intensite de la lumiere directionnelle suivent desormais cette horloge +// (voir SynopticState::sunDirection et Renderer::setSun), donc une heure de jeu +// se VOIT autant qu'elle se sent. +// +// Deuxieme changement de la Phase 23 : l'horloge compte desormais le temps +// TOTAL, et pas seulement l'heure du jour. Le systeme meteo en a besoin - une +// perturbation dure plusieurs jours, elle ne peut pas etre indexee par une heure +// qui reboucle toutes les 24 h. hours() n'a pas change (c'est toujours l'heure +// locale dans [0, 24)), totalHours() est le nouveau compteur monotone. +// +// Facteur 12 par defaut : une minute reelle vaut douze minutes de jeu, donc une +// session d'une heure couvre douze heures simulees et traverse reellement une +// tombee de nuit. Attention, ce facteur n'accelere PAS les jauges - elles +// restent reglees en secondes reelles (voir l'en-tete). Il ne pilote que +// l'heure, donc l'ambiante. +class GameClock { +public: + explicit GameClock(float startHour = 9.0f, float scale = 12.0f); + + void advance(float realSeconds); + + // Heure LOCALE dans [0, 24). + float hours() const { return hours_; } + + // Heures ECOULEES depuis le debut de partie, sans rebouclage. C'est cette + // valeur - et non hours() - qu'attend WeatherSystem::synopticAt : le + // calendrier des perturbations se compte en jours. + // + // Le compteur demarre a l'heure de depart (9 h par defaut) et non a zero, + // pour que totalHours() et hours() restent d'accord modulo 24 : un test qui + // verifie que la meteo de 14 h est la meme au jour 0 et au jour 3 n'a pas a + // se souvenir d'un decalage. + float totalHours() const { return totalHours_; } + + // Jour de partie ecoule, 0 pour le premier. + int day() const { return static_cast(totalHours_ / 24.0f); } + + float scale() const { return scale_; } + + // Regle l'heure LOCALE. Le compteur total est recale sur le meme jour, donc + // avancer l'horloge a la main ne fait pas voyager dans le temps meteo de + // plusieurs jours. + void setHours(float hours); + + // "09:35", pour le titre de la fenetre et le journal. + std::string clockText() const; + +private: + float hours_; + float totalHours_ = 0.0f; + float scale_; +}; + +// --------------------------------------------------------------------------- +// PHASE 23 : terrainExposure() et kFullExposureSlope ont DEMENAGE dans +// world/Weather.hpp. Ils n'ont jamais decrit un besoin du joueur - ils +// decrivent le terrain - et c'est le systeme meteo qui en a desormais l'usage +// principal. Le corps de la fonction est inchange, seul son domicile a change. +// Les appelants (main.cpp, les tests) incluent Weather.hpp. + +// --------------------------------------------------------------------------- +// Les quatre jauges +// --------------------------------------------------------------------------- +class Needs { +public: + explicit Needs(const NeedsParams& params = {}); + + const NeedsParams& params() const { return params_; } + + // Fait avancer les quatre jauges d'un pas de temps. C'est le seul point + // d'entree du modele ; deltaTime negatif ou nul ne fait rien. + void update(float deltaTime, const NeedsContext& context); + + // --- Etat --------------------------------------------------------------- + + float hunger() const { return hunger_; } + float thirst() const { return thirst_; } + float fatigue() const { return fatigue_; } + float temperature() const { return temperature_; } + + // Temperature AMBIANTE du dernier update(), en degres : ce qu'il fait + // dehors, avant la chaleur de l'effort. Exposee pour le journal et les + // tests - c'est elle qui relie la jauge au relief et a l'heure. + float ambientTemperatureC() const { return lastAmbientC_; } + + // Temperature RESSENTIE du dernier update() : ambiante + effort + abri + // - vent - epuisement. C'est celle que la jauge compare au confort. + float feltTemperatureC() const { return lastFeltC_; } + + // --- Consequences ------------------------------------------------------- + + // Coefficient a appliquer a une commande de deplacement, dans + // [minimumMovementFactor, 1]. Produit des quatre penalites. + // + // C'est la valeur que main.cpp multiplie a la vitesse de marche + // (Camera::setMoveSpeed), au pedalage (Bike::update) et a la commande de + // montee (Climber::update). Une seule grandeur pour les quatre activites : + // il ne peut pas y en avoir une qui oublie une jauge. + float movementFactor() const; + + // Facteurs individuels, exposes parce qu'un test qui ne verifie que le + // produit ne dit pas laquelle des quatre jauges a mordu. + float fatigueFactor() const; + float hungerFactor() const; + float thirstFactor() const; + float coldFactor() const; + + // Le manque le plus grave parmi faim, soif et froid, dans [0, 1] (0 = rien + // a signaler). Sert a aggraver la fatigue et a nommer le probleme dans le + // journal. + float worstDeficit() const; + + // Y a-t-il au moins un besoin sous le seuil critique ? + bool inTrouble() const { return worstDeficit() > 0.0f; } + + // --- Regeneration ------------------------------------------------------- + + // Boire un coup. Remplit la soif et rend true, sauf si la jauge etait deja + // pleine (rien a boire, rien a signaler) - l'appelant peut donc utiliser le + // retour pour decider s'il journalise. + // + // C'est le point d'ancrage demande par le cahier des charges. main.cpp ne + // l'appelle que si le joueur est effectivement AU BORD d'un point d'eau + // detecte sur le relief (voir world/WaterSource.hpp) : la jauge n'est pas + // remplissable a volonte depuis n'importe ou. + bool drink(); + + // Manger. AUCUN APPELANT A CE STADE, et c'est assume : le jeu ne produit + // rien de comestible (l'inventaire ne connait que buches, branches, pierres + // et eclats). La fonction existe pour que le jour ou la cueillette ou la + // chasse arrivera, il n'y ait rien a inventer ici - et parce que les tests + // headless peuvent ainsi verifier le remplissage sans attendre ce jour. + // nutrition est la fraction de jauge rendue, ecretee dans [0, 1]. + bool eat(float nutrition); + + // Remise a plat, pour les tests et pour une nouvelle partie. + void reset(); + + // Reglage direct d'une jauge, pour les tests et le demarrage d'une partie + // qui ne commencerait pas frais. Ecrete dans [0, 1]. + void setHunger(float value); + void setThirst(float value); + void setFatigue(float value); + void setTemperature(float value); + + // Ligne compacte "faim 87% soif 62% forme 44% chaud 91%", pour le titre de + // la fenetre. Volontairement des ENTIERS : le titre est relu a l'oeil + // soixante fois par seconde, pas depouille par un script. + std::string summary() const; + + // Ligne detaillee pour le journal : les jauges, les temperatures, le + // coefficient de deplacement. C'est cette ligne que depouille le harnais + // Vulkan. + std::string statusLine() const; + +private: + NeedsParams params_; + + float hunger_ = 1.0f; + float thirst_ = 1.0f; + float fatigue_ = 1.0f; + float temperature_ = 1.0f; + + float lastAmbientC_ = 0.0f; + float lastFeltC_ = 0.0f; +}; + +// PHASE 23 : ambientTemperature() et daylightFactor() ont ete SUPPRIMES d'ici. +// Leurs remplacants vivent dans world/Weather.hpp : +// ambientTemperature(...) -> WeatherSystem::sampleAt(...).temperatureC +// daylightFactor(hour) -> WeatherSystem::synopticAt(...).daylight +// +// Ce ne sont pas des renommages. La temperature tient desormais compte de la +// saison, de la masse d'air, de la nebulosite et de l'inversion de fond de +// cuvette ; l'ensoleillement est calcule a partir d'une vraie position solaire +// (latitude et declinaison) au lieu d'une demi-sinusoide fixe de 6 h a 18 h. + +} // namespace vercora diff --git a/src/world/Paraglider.cpp b/src/world/Paraglider.cpp new file mode 100644 index 0000000..a2aa064 --- /dev/null +++ b/src/world/Paraglider.cpp @@ -0,0 +1,113 @@ +#include "world/Paraglider.hpp" + +#include "core/HeightSampler.hpp" + +#include +#include + +namespace vercora { + +Paraglider::Paraglider(const ParagliderParams& params) : params_(params) {} + +glm::vec3 Paraglider::forward() const { + const float rad = glm::radians(heading_); + return glm::vec3(std::cos(rad), 0.0f, std::sin(rad)); +} + +void Paraglider::launch(const glm::vec3& position, float headingDegrees) { + position_ = position; + heading_ = headingDegrees; + // Depart au regime de croisiere : pas de phase d'acceleration a simuler, + // l'aile est deja gonflee et volante au moment du declencheur (voir la + // remarque de main.cpp sur l'absence de course d'elan pour cette session). + speed_ = params_.cruiseSpeed; + sinkRate_ = params_.cruiseSinkRate; + climbRate_ = -params_.cruiseSinkRate; + flightTime_ = 0.0f; + flying_ = true; +} + +void Paraglider::update(float deltaTime, float turnInput, float brakeInput, + const AirState& air) { + if (!flying_) { + return; + } + + turnInput = std::clamp(turnInput, -1.0f, 1.0f); + brakeInput = std::clamp(brakeInput, 0.0f, 1.0f); + + const float turbulence = std::clamp(std::isfinite(air.turbulence) ? air.turbulence : 0.0f, + 0.0f, 1.0f); + flightTime_ += deltaTime; + + heading_ += turnInput * params_.turnRateDegPerSec * deltaTime; + + // --- PHASE 23 : chahut turbulent --------------------------------------- + // Deux sinusoides de periodes INCOMMENSURABLES (le rapport est irrationnel) + // plutot qu'un tirage aleatoire, et c'est un choix, pas un raccourci : + // - le vol reste DETERMINISTE, donc rejouable et testable, ce qui est la + // regle de toute la Phase 23 ; + // - deux periodes sans rapport simple ne se resynchronisent jamais, donc le + // chahut ne degenere pas en balancement regulier, qui est ce qui trahit + // immediatement une turbulence fabriquee. + // Le modele ne represente NI fermeture NI decrochage : une aile chahutee ici + // perd du cap et de la finesse, elle ne tombe pas. + if (turbulence > 0.0f) { + const float period = std::max(0.1f, params_.turbulencePeriod); + const float yawPhase = 2.0f * 3.14159265358979323846f * flightTime_ / period; + const float yaw = std::sin(yawPhase) + 0.5f * std::sin(yawPhase * 2.618f); + heading_ += yaw * turbulence * params_.turbulenceYawDegPerSec * deltaTime; + } + + // Reponse EXPONENTIELLE au frein plutot qu'un saut instantane : une aile + // met une fraction de seconde a se stabiliser sur son nouveau regime de + // vitesse/taux de chute. La constante de temps responseTime fixe cette + // fraction de seconde (1 - e^-1 ~ 63 % du chemin parcouru apres ce delai). + const float targetSpeed = glm::mix(params_.cruiseSpeed, params_.brakeSpeed, brakeInput); + const float targetSink = glm::mix(params_.cruiseSinkRate, params_.brakeSinkRate, brakeInput); + const float responseRate = 1.0f - std::exp(-deltaTime / params_.responseTime); + speed_ += (targetSpeed - speed_) * responseRate; + sinkRate_ += (targetSink - sinkRate_) * responseRate; + + // --- PHASE 23 : le vol se fait DANS une masse d'air, pas dans le vide --- + // + // speed_ est une vitesse AIR : c'est ce que l'aile fait par rapport a l'air + // qui l'entoure. La vitesse SOL est cette vitesse air plus le vent. C'est + // l'ajout le plus important de cette phase pour le vol, et le plus lisible + // en jeu : par vent d'ouest, un vol vers l'est va bien plus loin qu'un vol + // vers l'ouest, sans qu'aucune regle particuliere n'ait ete ecrite. + glm::vec3 wind(0.0f); + if (std::isfinite(air.wind.x) && std::isfinite(air.wind.z)) { + wind = glm::vec3(air.wind.x, 0.0f, air.wind.z); + } + position_ += (forward() * speed_ + wind) * deltaTime; + + // Verticale : le taux de chute de l'aile DANS l'air, plus le mouvement de + // l'air lui-meme. Dans une thermique plus forte que le taux de chute, la + // somme est positive et l'aile MONTE - c'est la definition du vol thermique, + // et elle sort d'elle-meme de cette addition. + const float airVertical = std::isfinite(air.vertical) ? air.vertical : 0.0f; + const float turbulentSink = turbulence * params_.turbulenceSinkPenalty; + climbRate_ = airVertical - sinkRate_ - turbulentSink; + position_.y += climbRate_ * deltaTime; +} + +bool Paraglider::checkLanding(const HeightSampler& terrain, float eyeHeight) { + if (!flying_) { + return false; + } + + const float groundEyeY = terrain.heightAt(position_.x, position_.z) + eyeHeight; + if (position_.y > groundEyeY) { + return false; + } + + // Collee au sol exactement, comme Camera::snapToTerrain : sans ca, chaque + // atterrissage laisserait un residu (le pas de descente du dernier + // deltaTime) sous le relief. + position_.y = groundEyeY; + flying_ = false; + return true; +} + +} // namespace vercora diff --git a/src/world/Paraglider.hpp b/src/world/Paraglider.hpp new file mode 100644 index 0000000..81653d0 --- /dev/null +++ b/src/world/Paraglider.hpp @@ -0,0 +1,169 @@ +#pragma once + +#include + +namespace vercora { + +class HeightSampler; + +// Modele de vol simplifie (Phase 8) : pas une simulation aerodynamique - pas de +// decrochage, pas de fermeture, pas de pilotage a la sellette - juste de quoi +// decoller, tourner, freiner et se poser de facon credible. +// +// PHASE 23 : "pas de vent, pas de thermiques" n'est plus vrai. L'air dans lequel +// l'aile vole est desormais decrit par AirState, que l'appelant remplit depuis +// world/Weather.hpp. Le reste du modele est INCHANGE - c'est un ajout au +// deplacement, pas une reecriture de la physique de vol. + +// --------------------------------------------------------------------------- +// L'air dans lequel l'aile vole +// --------------------------------------------------------------------------- +// Volontairement une struct NUE et non un WeatherSample : Paraglider ne doit +// pas plus dependre du systeme meteo qu'il ne depend de Vulkan. Il decrit ce +// dont il a besoin, l'appelant le remplit. C'est la meme separation que +// HeightSampler, qui dit "une hauteur en fonction d'une position" sans savoir +// d'ou elle vient. +// +// Les valeurs par defaut sont l'AIR CALME, donc exactement le vol de la +// Phase 8 : un appelant qui ignore la meteo obtient le comportement d'avant. +struct AirState { + // Vent horizontal, en repere monde, en m/s. Il POINTE dans le sens ou l'air + // se deplace. Une aile derive avec la masse d'air : c'est l'effet le plus + // important de tout ce bloc, et celui qui change le plus la facon de voler. + glm::vec3 wind{0.0f}; + + // Vitesse VERTICALE de la masse d'air, en m/s. Positive = ascendance + // (thermique, ou vent qui remonte une pente). Negative = subsidence. + float vertical = 0.0f; + + // Turbulence dans [0, 1]. 0 = air lisse. + float turbulence = 0.0f; +}; + +struct ParagliderParams { + // Vitesse de croisière en air calme, en unites monde/seconde (= m/s, meme + // convention que le reste du jeu). ~38 km/h, au milieu de la fourchette + // 35-40 km/h d'une aile-ecole typique. + float cruiseSpeed = 10.5f; + + // Vitesse une fois les freins tires a fond. Un vrai parapente perd environ + // un tiers de sa vitesse de croisiere aux "grandes oreilles"/plein frein. + float brakeSpeed = 7.0f; + + // Taux de chute en air calme, vol stabilise : 1 a 1,5 m/s pour une aile + // grand public. On prend le milieu de la fourchette. + float cruiseSinkRate = 1.25f; + + // Le frein degrade legerement la finesse (on troque de la vitesse contre de + // la trainee), donc un taux de chute un peu plus fort qu'en croisiere. + float brakeSinkRate = 1.6f; + + // Vitesse angulaire maximale du cap, en degres/seconde. Avec la vitesse de + // croisiere ci-dessus, ca donne un rayon de virage stabilise d'environ + // vitesse / vitesseAngulaire(rad/s) ~ 10.5 / 0.44 ~ 24 m - un virage large et + // progressif, pas une rotation sur place. + float turnRateDegPerSec = 25.0f; + + // Constante de temps de la reponse vitesse/taux de chute au frein. Tirer un + // frein ne change pas le vol instantanement : l'aile met une fraction de + // seconde a se stabiliser sur son nouveau regime. Voir update(). + float responseTime = 0.5f; + + // --- PHASE 23 : reponse a l'air -------------------------------------- + // + // VALEURS PROVISOIRES, au meme titre que celles de WeatherParams : elles + // decrivent la reponse de l'aile a un air dont l'intensite n'est elle-meme + // pas encore calibree. Elles vivent ici et non dans WeatherParams parce + // qu'elles decrivent l'AILE, pas l'atmosphere. + + // Ecart de cap maximal, en degres par seconde, impose par une turbulence + // maximale. 12 : l'aile est chahutee, elle ne part pas en vrille. Le modele + // ne represente ni fermeture ni decrochage - c'est la limite assumee de + // cette session, et c'est pour ca que le chiffre reste modeste. + float turbulenceYawDegPerSec = 12.0f; + + // Degradation du taux de chute par une turbulence maximale, en m/s. 0,8 : + // un air brasse coute de la finesse, ce qui est reel et se sent - un vol + // sous le vent d'une crete ne va pas aussi loin qu'un vol en air lisse. + float turbulenceSinkPenalty = 0.8f; + + // Periode du chahut turbulent, en secondes. 1,7 : l'echelle de temps d'une + // rafale ressentie sous une aile. Une valeur NON ronde et sans rapport + // simple avec les autres, pour que les deux perturbations (cap et chute) ne + // se synchronisent pas en un balancement periodique visible. + float turbulencePeriod = 1.7f; +}; + +// Position, cap et vitesse d'un vol en parapente. Ne connait rien de Vulkan ni +// de la Camera : elle produit une position et un cap, c'est l'appelant (voir +// main.cpp) qui en tire une pose de camera en chase-cam via +// Camera::setChasePose(). Meme separation que Forest vis-a-vis du rendu. +class Paraglider { +public: + explicit Paraglider(const ParagliderParams& params = {}); + + // Debute un vol a la position et au cap (degres, meme convention que + // Camera : 0 = +X, 90 = +Z) donnes. La position DOIT deja etre au-dessus du + // terrain - c'est a l'appelant de le verifier avant de decoller (main.cpp + // exige une hauteur minimale au-dessus du sol). + void launch(const glm::vec3& position, float headingDegrees); + + // Fait avancer la simulation d'un pas de temps. turnInput dans [-1, 1] + // (virage gauche/droite), brakeInput dans [0, 1] (frein progressif). Les + // deux sont ecretes en interne : l'appelant peut passer des valeurs brutes + // de touches (0/1) sans y penser. + // air decrit la masse d'air au point de l'aile (vent, ascendance, + // turbulence). Sa valeur par defaut est l'air CALME : tous les appelants + // ecrits avant la Phase 23 - dont les tests de la Phase 8 - continuent de + // decrire exactement le meme vol. + void update(float deltaTime, float turnInput, float brakeInput, + const AirState& air = {}); + + // Vitesse verticale REELLE du dernier pas, en m/s (positive = ca monte). + // C'est le taux de chute de l'aile corrige de l'air : dans une bonne + // thermique elle est positive, et c'est tout l'interet. + // + // Exposee parce qu'un vol qui gagne de l'altitude est la propriete que les + // tests doivent verifier, et parce que c'est la seule grandeur qu'un vario + // afficherait si le jeu en avait un. + float climbRateMps() const { return climbRate_; } + + // Temps de vol ecoule depuis launch(), en secondes. Pilote le chahut + // turbulent, et sert de repere au journal. + float flightTime() const { return flightTime_; } + + // Termine le vol des que l'altitude rejoint le terrain sous le pilote (plus + // eyeHeight, meme convention que Camera::eyeHeight_). Renvoie true la frame + // ou l'atterrissage vient d'avoir lieu ; ajuste position().y pour qu'elle + // colle exactement au sol, comme Camera::snapToTerrain. + bool checkLanding(const HeightSampler& terrain, float eyeHeight); + + // Fin de vol immediate, quelle que soit l'altitude - filet de securite pour + // interrompre un vol qui ne rencontrerait pas le relief (ou pour un abandon + // volontaire). Ne touche pas a la position : c'est a l'appelant de la reposer + // sur le terrain s'il le souhaite. + void abort() { flying_ = false; } + + bool flying() const { return flying_; } + const glm::vec3& position() const { return position_; } + float headingDegrees() const { return heading_; } + + // Direction horizontale unitaire du cap courant. + glm::vec3 forward() const; + +private: + ParagliderParams params_; + + glm::vec3 position_{0.0f}; + float heading_ = 0.0f; // degres, convention Camera : 0 = +X, 90 = +Z + + float speed_ = 0.0f; // vitesse horizontale courante, m/s (AIR, pas sol) + float sinkRate_ = 0.0f; // taux de chute courant, m/s + + float climbRate_ = 0.0f; // vitesse verticale reelle du dernier pas + float flightTime_ = 0.0f; // secondes depuis launch() + + bool flying_ = false; +}; + +} // namespace vercora diff --git a/src/world/Resin.cpp b/src/world/Resin.cpp new file mode 100644 index 0000000..3ed6578 --- /dev/null +++ b/src/world/Resin.cpp @@ -0,0 +1,71 @@ +#include "world/Resin.hpp" + +#include + +namespace vercora { + +const char* resinResultMessage(ResinResult result) { + switch (result) { + case ResinResult::Success: + return "Resine : l'entaille pleure, une perle tombe au pied de l'arbre. " + "L'arbre reste debout."; + case ResinResult::NotConifer: + return "Resine : cet arbre n'est pas un resineux, l'entaille ne donne rien."; + case ResinResult::StillDry: + return "Resine : cet arbre a deja ete saigne, il faut lui laisser le " + "temps de couler a nouveau."; + case ResinResult::NoTree: + return "Resine : aucun arbre en vue a saigner."; + } + return "Resine : issue inconnue."; +} + +ResinStand::ResinStand(const ResinParams& params) : params_(params) {} + +ResinResult ResinStand::tap(int treeIndex, TreeSpecies species, float now) { + if (treeIndex < 0) { + return ResinResult::NoTree; + } + // L'essence est DONNEE, plus decidee ici : voir l'en-tete de Resin.hpp. + if (species != TreeSpecies::Conifer) { + return ResinResult::NotConifer; + } + + const auto found = taps_.find(treeIndex); + if (found != taps_.end()) { + const Tap& tap = found->second; + if (params_.maxTapsPerTree != 0 && tap.count >= params_.maxTapsPerTree) { + return ResinResult::StillDry; + } + if (now - tap.lastTapTime < params_.flowDelay) { + return ResinResult::StillDry; + } + } + + // L'arbre n'entre dans la memoire QU'ICI, c'est-a-dire au premier + // prelevement reel. Viser mille arbres sans en saigner un seul laisse la + // table vide - meme principe que la grille creuse de world/Habitat. + Tap& tap = taps_[treeIndex]; + tap.count += 1; + tap.lastTapTime = now; + return ResinResult::Success; +} + +uint32_t ResinStand::tapCount(int treeIndex) const { + const auto found = taps_.find(treeIndex); + return (found == taps_.end()) ? 0u : found->second.count; +} + +float ResinStand::secondsUntilFlow(int treeIndex, float now) const { + const auto found = taps_.find(treeIndex); + if (found == taps_.end()) { + return 0.0f; + } + const Tap& tap = found->second; + if (params_.maxTapsPerTree != 0 && tap.count >= params_.maxTapsPerTree) { + return 0.0f; // epuise : ce n'est plus une question de delai + } + return std::max(0.0f, params_.flowDelay - (now - tap.lastTapTime)); +} + +} // namespace vercora diff --git a/src/world/Resin.hpp b/src/world/Resin.hpp new file mode 100644 index 0000000..1c953e4 --- /dev/null +++ b/src/world/Resin.hpp @@ -0,0 +1,131 @@ +#pragma once + +#include "world/TreeSpecies.hpp" + +#include +#include + +namespace vercora { + +// =========================================================================== +// PHASE 22 : la RESINE DE PIN, recoltee SANS abattre l'arbre. +// =========================================================================== +// +// PHASE 26 : L'ESSENCE EST DEVENUE UNE VRAIE PROPRIETE DU MONDE. +// +// Ce fichier portait, en Phase 22, le paragraphe suivant : « Le jeu n'a AUCUNE +// notion d'essence d'arbre [...] Il n'y a donc RIEN, ni dans la geometrie ni +// dans les donnees, qui permette de dire qu'un arbre donne est un resineux. » +// D'ou un MARQUAGE ARBITRAIRE - un hachage de l'indice de l'arbre - et la dette +// que la phase assumait explicitement : « un joueur ne peut pas VOIR quel arbre +// est resineux avant d'essayer, puisque tous les arbres ont le meme mesh ». +// +// CETTE DETTE EST REFERMEE. world/TreeSpecies.hpp decide desormais de l'essence +// en fonction de la POSITION et de l'exposition adret/ubac, world/TreeMesh.hpp +// donne a chaque essence sa silhouette, et Tree::species porte le resultat. Un +// joueur qui vise un conifere le RECONNAIT a sa forme conique avant d'appuyer. +// +// CE QUI CHANGE ICI, CONCRETEMENT : ResinStand ne decide plus de rien. Il ne +// tient plus de graine d'essence, plus de part de resineux, plus de hachage ; +// il RECOIT l'essence de l'arbre vise en argument de tap(). Il ne reste dans +// cette classe que ce qui lui appartient vraiment : la memoire des arbres deja +// saignes et les delais. +// +// C'ETAIT LA SEULE FACON D'ETRE SUR QU'IL N'Y A PAS DEUX VERITES. Faire lire a +// ResinStand la meme fonction que le rendu aurait suffi a les faire coincider +// 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 a maintenir. La +// meme exigence que la Phase 23 pour le soleil et la Phase 25 pour l'ecart +// d'incidence. +// +// CE QUI DIFFERE DE L'ABATTAGE, ET C'EST LE POINT. Le bois demande de TUER +// l'arbre : Forest::fell le couche, le debite, et la Phase 17 en fait payer le +// prix au milieu (Habitat::recordFelling). La resine, elle, se preleve sur un +// arbre VIVANT et DEBOUT : rien n'est abattu, rien n'est debite, l'arbre reste +// exactement dans l'etat Standing. En echange, il ne redonne pas de resine +// avant un long moment - c'est la seule contrainte du systeme, et elle est +// suffisante pour que saigner soit une decision et non un reflexe. +// +// Ne connait ni Vulkan, ni la Forest, ni le terrain : un indice d'arbre, un +// temps. Entierement testable sans GPU. +// =========================================================================== + +// Issue d'une tentative de recolte. +enum class ResinResult { + Success, // la resine coule : un objet tombe au pied de l'arbre + NotConifer, // ce n'est pas un resineux, il n'y a rien a saigner + StillDry, // resineux, mais deja saigne trop recemment + NoTree, // aucun arbre vise +}; + +// Message francais pret a journaliser pour une issue donnee. +const char* resinResultMessage(ResinResult result); + +struct ResinParams { + // PHASE 26 : `coniferShare` et `seed` ont DISPARU d'ici. Elles ne decrivaient + // pas la resine, elles decrivaient le peuplement ; elles vivent desormais + // dans TreeSpeciesParams, ou elles servent AUSSI a ce qui est dessine. La + // valeur 0,55 y a ete reprise telle quelle sous le nom coniferShareNeutral. + + // Delai, en secondes de jeu, avant qu'un arbre deja saigne redonne de la + // resine. 600 s = dix minutes. C'est LONG a l'echelle d'une partie, et c'est + // volontaire : la resine doit se recolter en se DEPLACANT d'un arbre a + // l'autre, pas en restant plante devant le meme. L'ordre de grandeur est + // celui de HabitatParams::loggingDecay (900 s), l'autre grandeur du jeu qui + // dit "cette zone a donne ce qu'elle avait". + float flowDelay = 600.0f; + + // Nombre de recoltes qu'un meme arbre peut donner avant d'etre epuise pour + // de bon. 3 : au-dela, saigner un arbre le tuerait vraiment, et ce fichier + // affirme exactement le contraire. Zero signifierait "sans limite". + uint32_t maxTapsPerTree = 3; +}; + +// La memoire des arbres deja saignes, et elle seule. Le marquage des +// resineux a quitte cette classe en Phase 26 : voir l'en-tete. +class ResinStand { +public: + explicit ResinStand(const ResinParams& params = {}); + + // Tente une recolte sur l'arbre d'indice donne, a l'instant `now` (secondes + // ecoulees depuis le debut de la partie, la meme horloge que le reste du + // gameplay). treeIndex < 0 signifie "rien de vise". + // + // `species` est l'essence de CET arbre, telle que le monde la porte + // (Tree::species). Elle est passee et non deduite : voir l'en-tete. Un + // appelant qui se tromperait d'arbre ferait couler de la resine d'un feuillu + // - mais il aurait aussi dessine un feuillu, donc l'incoherence serait + // VISIBLE, ce qui est precisement ce qu'on cherchait. + // + // N'ABAT RIEN et ne touche a aucun arbre : cette classe ne connait meme pas + // la Forest. C'est l'appelant qui, sur Success, depose l'objet au sol. + ResinResult tap(int treeIndex, TreeSpecies species, float now); + + // Nombre de recoltes deja faites sur cet arbre. 0 pour un arbre jamais + // saigne - et il n'est alors PAS memorise, exactement comme une cellule + // d'Habitat revenue a zero. + uint32_t tapCount(int treeIndex) const; + + // Secondes restantes avant que cet arbre redonne de la resine, a l'instant + // `now`. 0 s'il est pret (ou jamais saigne), et 0 aussi s'il est epuise - + // c'est tapCount qu'il faut lire pour distinguer les deux. + float secondsUntilFlow(int treeIndex, float now) const; + + // Arbres reellement memorises. Expose pour les tests : une memoire qui + // grossirait a chaque visee plutot qu'a chaque recolte passerait sinon + // inapercue. + std::size_t trackedTreeCount() const { return taps_.size(); } + + const ResinParams& params() const { return params_; } + +private: + struct Tap { + uint32_t count = 0; + float lastTapTime = 0.0f; + }; + + ResinParams params_; + std::unordered_map taps_; +}; + +} // namespace vercora diff --git a/src/world/RockMesh.cpp b/src/world/RockMesh.cpp new file mode 100644 index 0000000..3e7f3a5 --- /dev/null +++ b/src/world/RockMesh.cpp @@ -0,0 +1,195 @@ +#include "world/RockMesh.hpp" + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace vercora { +namespace { + +// Calcaire clair : les pierriers de la zone sont les bandes les plus claires de +// l'ortho (luminance moyenne 161 dans le masque, NOTES-PHASE29-DESIGN.md), plus +// clairs que le galet ramassable (0,44), qui est une pierre de lit de ruisseau. +const glm::vec3 kLimestone{0.63f, 0.62f, 0.58f}; + +using Face = std::array; +using EdgeKey = std::pair; + +void appendFacet(MeshData& mesh, const glm::vec3& a, const glm::vec3& b, + const glm::vec3& c, const glm::vec3& color) { + const glm::vec3 raw = glm::cross(b - a, c - a); + const float length = glm::length(raw); + if (length < 1e-9f) { + return; // triangle degenere (plan de coupe) : ni surface ni normale + } + const glm::vec3 normal = raw / length; + const auto base = static_cast(mesh.vertices.size()); + for (const glm::vec3& p : { a, b, c }) { + Vertex v{}; + v.pos = p; + v.color = color; + v.normal = normal; + mesh.vertices.push_back(v); + } + mesh.indices.insert(mesh.indices.end(), { base, base + 1, base + 2 }); +} + +uint32_t midpoint(std::vector& points, std::map& 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; + } + points.push_back(glm::normalize(points[a] + points[b])); + const auto index = static_cast(points.size() - 1); + cache.emplace(key, index); + return index; +} + +// Octaedre subdivise `levels` fois, sur la sphere unite. Faces orientees vers +// l'exterieur (meme ordre que StoneMesh). +void unitSphere(int levels, std::vector& points, std::vector& faces) { + points = { { 1, 0, 0 }, { -1, 0, 0 }, { 0, 1, 0 }, { 0, -1, 0 }, { 0, 0, 1 }, { 0, 0, -1 } }; + 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 (int level = 0; level < levels; ++level) { + std::map cache; + std::vector next; + next.reserve(faces.size() * 4); + for (const Face& f : faces) { + const uint32_t ab = midpoint(points, cache, f[0], f[1]); + const uint32_t bc = midpoint(points, cache, f[1], f[2]); + const uint32_t ca = midpoint(points, cache, f[2], f[0]); + next.push_back({ f[0], ab, ca }); + next.push_back({ ab, f[1], bc }); + next.push_back({ ca, bc, f[2] }); + next.push_back({ ab, bc, ca }); + } + faces = std::move(next); + } +} + +// Un caillou irregulier : sphere bosselee puis TRONQUEE par `cuts` plans +// aleatoires - chaque plan aplatit une calotte et donne une face de fracture +// franche, ce qui distingue un bloc d'eboulis d'un galet roule. +struct RockShape { + int levels = 1; + float bumpMin = 0.78f; + int cuts = 5; + float cutDepth = 0.72f; // distance du plan au centre (sphere unite) + glm::vec3 halfSize{ 0.5f, 0.35f, 0.42f }; + float yOffset = 0.0f; // translation verticale apres mise a l'echelle + glm::vec2 offset{ 0.0f }; + glm::vec3 color = kLimestone; + uint32_t seed = 1u; +}; + +void appendRock(MeshData& mesh, const RockShape& shape) { + std::vector points; + std::vector faces; + unitSphere(shape.levels, points, faces); + + std::mt19937 rng(shape.seed); + std::uniform_real_distribution unit(0.0f, 1.0f); + std::uniform_real_distribution signedUnit(-1.0f, 1.0f); + + for (glm::vec3& p : points) { + p *= shape.bumpMin + (1.0f - shape.bumpMin) * unit(rng); + } + for (int cut = 0; cut < shape.cuts; ++cut) { + glm::vec3 n(signedUnit(rng), signedUnit(rng), signedUnit(rng)); + if (glm::length(n) < 1e-3f) { + n = { 0.0f, 1.0f, 0.0f }; + } + n = glm::normalize(n); + const float d = shape.cutDepth + 0.15f * unit(rng); + for (glm::vec3& p : points) { + const float excess = glm::dot(p, n) - d; + if (excess > 0.0f) { + p -= excess * n; // projection sur le plan de coupe + } + } + } + for (glm::vec3& p : points) { + p = p * shape.halfSize; + p.x += shape.offset.x; + p.z += shape.offset.y; + p.y += shape.yOffset; + } + // Legere variation de teinte par face (patine, lichen) : sans elle un bloc a + // facettes planes a l'air d'un solide de synthese uniforme. + for (const Face& f : faces) { + const float shade = 0.90f + 0.14f * unit(rng); + appendFacet(mesh, points[f[0]], points[f[1]], points[f[2]], shape.color * shade); + } +} + +} // namespace + +MeshData boulderMeshData() { + MeshData mesh; + mesh.name = "gros bloc d'eboulis (Phase 29)"; + RockShape shape; + shape.levels = 2; + shape.bumpMin = 0.82f; + shape.cuts = 7; + shape.cutDepth = 0.62f; + // Hauteur totale 2 x 0,475 = 0,95 : 0,70 visibles, 0,25 enterres. + shape.halfSize = { 0.52f, 0.475f, 0.44f }; + shape.yOffset = kRockVisibleHeight - 0.475f; + shape.seed = 0xB01DE5u; + appendRock(mesh, shape); + return mesh; +} + +MeshData rockMeshData() { + MeshData mesh; + mesh.name = "rocher moyen d'eboulis (Phase 29)"; + RockShape shape; + shape.levels = 1; + shape.bumpMin = 0.72f; + shape.cuts = 4; + shape.cutDepth = 0.70f; + shape.halfSize = { 0.50f, 0.475f, 0.38f }; + shape.yOffset = kRockVisibleHeight - 0.475f; + shape.color = kLimestone * 0.95f; + shape.seed = 0x70C4u; + appendRock(mesh, shape); + return mesh; +} + +MeshData gravelMeshData() { + MeshData mesh; + mesh.name = "plaque de pierraille (Phase 29)"; + std::mt19937 rng(0x6FA7E1u); + std::uniform_real_distribution unit(0.0f, 1.0f); + constexpr int kPebbles = 11; + for (int i = 0; i < kPebbles; ++i) { + // Disque de rayon 0,5, repartition en racine pour ne pas tasser au centre. + const float angle = 6.28318530718f * unit(rng); + const float radius = 0.44f * std::sqrt(unit(rng)); + const float size = 0.05f + 0.07f * unit(rng); // demi-largeur 5 a 12 cm + RockShape shape; + shape.levels = 0; // 8 faces : un caillou de quelques cm n'en montre pas plus + shape.bumpMin = 0.65f; + shape.cuts = 2; + shape.cutDepth = 0.55f; + shape.halfSize = { size, 0.6f * size, 0.8f * size }; + // A moitie enterre : 0,4 x hauteur au-dessus du sol. + shape.yOffset = -0.2f * shape.halfSize.y; + shape.offset = { radius * std::cos(angle), radius * std::sin(angle) }; + shape.color = kLimestone * (0.85f + 0.2f * unit(rng)); + shape.seed = 0x9E11u + static_cast(i) * 7919u; + appendRock(mesh, shape); + } + return mesh; +} + +} // namespace vercora diff --git a/src/world/RockMesh.hpp b/src/world/RockMesh.hpp new file mode 100644 index 0000000..f819143 --- /dev/null +++ b/src/world/RockMesh.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +namespace vercora { + +// PHASE 29 (Agent 2) : geometries des rochers de PIERRIER, generees EN CODE sur +// le modele de StoneMesh / TreeMesh / CubeMesh. Aucun fichier externe. +// +// Contrairement au galet ramassable (StoneMesh, dimensions absolues), ces meshes +// sont a l'ECHELLE UNITE, comme l'arbre et la touffe d'herbe : ils passent par le +// rendu INSTANCIE (world/Rocks.hpp), dont l'instance porte une echelle uniforme. +// Convention commune aux trois : +// - hauteur visible au-dessus de l'origine ~ kRockVisibleHeight x echelle ; +// - une partie ENTERREE sous y = 0 (kRockBuriedDepth x echelle) : un bloc pose +// sur une pente de 0,6 a 0,84 flotterait sinon de son cote aval. C'est aussi +// ce qu'on voit d'un vrai bloc d'eboulis, jamais pose sur un point ; +// - empreinte horizontale ~ rayon kRockFootprintRadius x echelle (sert a la +// collision des gros blocs). +// +// Trois variantes, choisies par la RUGOSITE comme le propose +// NOTES-PHASE29-DESIGN.md (rugosite >= 0,10 m -> blocs, < 0,10 -> pierraille) : + +// Gros bloc anguleux : polyedre irregulier coupe par des plans (faces de +// fracture), plus large que haut. +MeshData boulderMeshData(); + +// Rocher moyen : meme construction, graine et proportions differentes, plus +// arrondi. Accompagne les gros blocs sur les zones rugueuses. +MeshData rockMeshData(); + +// Pierraille fine : une PLAQUE d'une dizaine de petits cailloux dans un disque +// de rayon 0,5 (echelle 1 = plaque de 1 m). Une instance = une poignee de +// cailloux : c'est ce qui rend la pierraille dense abordable en instances. +MeshData gravelMeshData(); + +inline constexpr float kRockVisibleHeight = 0.70f; // bloc et rocher +inline constexpr float kRockBuriedDepth = 0.25f; +inline constexpr float kRockFootprintRadius = 0.50f; + +} // namespace vercora diff --git a/src/world/Rocks.cpp b/src/world/Rocks.cpp new file mode 100644 index 0000000..e55fc6b --- /dev/null +++ b/src/world/Rocks.cpp @@ -0,0 +1,524 @@ +#include "world/Rocks.hpp" + +#include "core/Frustum.hpp" +#include "core/HeightSampler.hpp" +#include "world/RockMesh.hpp" + +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; + +// Memes primitives que Vegetation.cpp (hachage sans etat, bruit de valeur) : +// recopiees plutot que partagees pour ne pas toucher a Vegetation (non-regression +// litterale). Le semis ne depend que de (cellule, graine, flux). +uint32_t mix32(uint32_t v) { + v ^= v >> 16; v *= 0x7feb352du; + v ^= v >> 15; v *= 0x846ca68bu; + v ^= v >> 16; + return v; +} +uint32_t cellHash(int32_t cx, int32_t cz, uint32_t seed, uint32_t stream) { + uint32_t h = seed; + h = mix32(h ^ static_cast(cx) * 0x9E3779B1u); + h = mix32(h ^ static_cast(cz) * 0x85EBCA77u); + h = mix32(h ^ (stream * 0xC2B2AE3Du)); + return h; +} +float unitFloat(uint32_t h) { return static_cast(h >> 8) * (1.0f / 16777216.0f); } + +float valueNoise(float x, float z, uint32_t seed) { + const float fx = std::floor(x), fz = std::floor(z); + const auto ix = static_cast(fx); + const auto iz = static_cast(fz); + const float tx = x - fx, tz = z - fz; + const float sx = tx * tx * tx * (tx * (tx * 6.0f - 15.0f) + 10.0f); + const float sz = tz * tz * tz * (tz * (tz * 6.0f - 15.0f) + 10.0f); + const float v00 = unitFloat(cellHash(ix, iz, seed, 1u)); + const float v10 = unitFloat(cellHash(ix + 1, iz, seed, 1u)); + const float v01 = unitFloat(cellHash(ix, iz + 1, seed, 1u)); + const float v11 = unitFloat(cellHash(ix + 1, iz + 1, seed, 1u)); + return glm::mix(glm::mix(v00, v10, sx), glm::mix(v01, v11, sx), sz); +} + +float ramp(float value, float from, float to) { + if (to <= from) { return value >= to ? 1.0f : 0.0f; } + return glm::clamp((value - from) / (to - from), 0.0f, 1.0f); +} + +// Marge au bord du terrain : la rugosite lit 4 m autour du point, la direction +// des trainees 8 m ; au-dela du bord heightAt ecrete et fausserait les deux. +constexpr float kEdgeMargin = 10.0f; + +} // namespace + +Rocks::Rocks(const HeightSampler& terrain, const HeightSampler* cover, float terrainExtent, + const RockParams& params) + : terrain_(terrain), cover_(cover), terrainExtent_(terrainExtent), params_(params) { + if (params_.blockCell <= 0.0f || params_.gravelCell <= 0.0f) { + throw std::runtime_error("Rocks : taille de cellule nulle ou negative."); + } + if (params_.slopeMin >= params_.slopeMax) { + throw std::runtime_error("Rocks : slopeMin doit rester sous slopeMax."); + } + if (params_.boulderDistanceNear > params_.boulderDistanceFar || + params_.stoneDistanceNear > params_.stoneDistanceFar || + params_.gravelDistanceNear > params_.gravelDistanceFar) { + throw std::runtime_error("Rocks : portee proche au-dela de la portee lointaine."); + } +} + +// --------------------------------------------------------------------------- +// Critere +// --------------------------------------------------------------------------- +float Rocks::coverAt(float worldX, float worldZ) const { + return glm::clamp(cover_->heightAt(worldX, worldZ), 0.0f, 1.0f); +} + +bool Rocks::maskAt(float worldX, float worldZ) const { + if (cover_ == nullptr) { + return false; // pas de donnee reelle, pas de rocher + } + const float usable = terrainExtent_ - kEdgeMargin; + if (std::abs(worldX) > usable || std::abs(worldZ) > usable) { + return false; + } + // LA pente du critere : Climber::slopeAt, base de 4 m (et non + // Vegetation::slopeAt, 1 m en differences avant : piege signale). + const float slope = slopeProbe_.slopeAt(terrain_, worldX, worldZ); + if (slope < params_.slopeMin || slope >= params_.slopeMax) { + return false; + } + return coverAt(worldX, worldZ) < params_.coverMax; +} + +float Rocks::roughnessAt(float worldX, float worldZ) const { + // Definition EXACTE de data/phase29/probe_rocks.py au point considere : + // res = H - moyenne5x5(H) ; rug = sqrt(moyenne5x5(res^2)). + // Le residu des 25 points de la fenetre demande leur propre moyenne 5x5, + // donc une grille de 9 x 9 sondes au pas de 1 m (le pas du DTM). + float h[9][9]; + for (int j = 0; j < 9; ++j) { + for (int i = 0; i < 9; ++i) { + h[j][i] = terrain_.heightAt(worldX + static_cast(i - 4), + worldZ + static_cast(j - 4)); + } + } + double sumSq = 0.0; + for (int j = 2; j <= 6; ++j) { + for (int i = 2; i <= 6; ++i) { + double mean = 0.0; + for (int b = -2; b <= 2; ++b) { + for (int a = -2; a <= 2; ++a) { + mean += h[j + b][i + a]; + } + } + mean /= 25.0; + const double r = h[j][i] - mean; + sumSq += r * r; + } + } + return static_cast(std::sqrt(sumSq / 25.0)); +} + +float Rocks::streakDensityAt(float worldX, float worldZ) const { + // Repere local de la pente : u le long de la ligne de plus grande pente, + // v en travers. Un bruit lent en u et rapide en v dessine des bandes + // allongees dans le sens de la descente - la forme d'une trainee d'eboulis. + // + // PIEGE EVITE (mesure par le test d'anisotropie) : tourner le repere avec la + // direction de pente AU POINT rend le bruit instable - loin de l'origine, + // un ecart de direction de quelques degres deplace v de plusieurs periodes, + // et le champ devient un bruit blanc. Le repere est donc fixe PAR TUILE + // (streakTile), centre sur la tuile, avec la direction lue au centre sur une + // base large ; les quatre tuiles voisines sont melangees en bilineaire lisse. + const float tile = params_.streakTile; + const float fx = worldX / tile - 0.5f; + const float fz = worldZ / tile - 0.5f; + const float ix = std::floor(fx), iz = std::floor(fz); + const float tx = fx - ix, tz = fz - iz; + const float sx = tx * tx * (3.0f - 2.0f * tx); + const float sz = tz * tz * (3.0f - 2.0f * tz); + const uint32_t seed = params_.seed ^ 0x51ED270Bu; + float noise[2][2]; + for (int j = 0; j < 2; ++j) { + for (int i = 0; i < 2; ++i) { + const float cx = (ix + static_cast(i) + 0.5f) * tile; + const float cz = (iz + static_cast(j) + 0.5f) * tile; + const glm::vec2 g = walkTerrainGradient(terrain_, cx, cz, params_.streakDirectionStep); + const float length = std::sqrt(g.x * g.x + g.y * g.y); + const glm::vec2 down = (length > 1e-4f) ? g / length : glm::vec2(0.0f, 1.0f); + const glm::vec2 across(-down.y, down.x); + const glm::vec2 q(worldX - cx, worldZ - cz); + // Decalage propre a la tuile : ses trainees ne sont pas celles de la voisine. + const uint32_t h = cellHash(static_cast(ix) + i, static_cast(iz) + j, seed, 9u); + const float u = glm::dot(q, down) * params_.streakAlong + 64.0f * unitFloat(h); + const float v = glm::dot(q, across) * params_.streakAcross + 64.0f * unitFloat(h ^ 0xA5A5A5A5u); + noise[j][i] = 0.7f * valueNoise(u, v, seed) + + 0.3f * valueNoise(u * 2.3f, v * 2.3f, seed ^ 0x2545F491u); + } + } + const float value = glm::mix(glm::mix(noise[0][0], noise[0][1], sx), + glm::mix(noise[1][0], noise[1][1], sx), sz); + return ramp(value, params_.streakThreshold, + params_.streakThreshold + params_.streakSoftness); +} + +// --------------------------------------------------------------------------- +// Semis +// --------------------------------------------------------------------------- +void Rocks::fitBox(Cell& cell, float baseX, float baseZ, float size) const { + float minY = 0.0f, maxY = 0.0f; + bool first = true; + for (const RockInstance& r : cell.rocks) { + const float lo = r.position.y - kRockBuriedDepth * r.scale; + const float hi = r.position.y + (kRockVisibleHeight + 0.3f) * r.scale; + minY = first ? lo : std::min(minY, lo); + maxY = first ? hi : std::max(maxY, hi); + first = false; + } + if (first) { + minY = maxY = terrain_.heightAt(baseX + 0.5f * size, baseZ + 0.5f * size); + } + // Marge horizontale : un bloc incline deborde un peu de sa cellule. + cell.boxMin = { baseX - 1.5f, minY, baseZ - 1.5f }; + cell.boxMax = { baseX + size + 1.5f, maxY, baseZ + size + 1.5f }; +} + +bool Rocks::makeCandidate(float x, float z, RockKind kind, uint32_t slot, uint32_t slots, + uint32_t hSize, uint32_t hYaw, uint32_t hTint, + RockInstance& out) const { + float sizeMin = 0.0f, sizeMax = 0.0f, far = 0.0f, near = 0.0f; + switch (kind) { + case RockKind::Boulder: + sizeMin = params_.boulderSizeMin; sizeMax = params_.boulderSizeMax; + far = params_.boulderDistanceFar; near = params_.boulderDistanceNear; + break; + case RockKind::Stone: + sizeMin = params_.stoneSizeMin; sizeMax = params_.stoneSizeMax; + far = params_.stoneDistanceFar; near = params_.stoneDistanceNear; + break; + case RockKind::Gravel: + sizeMin = params_.gravelSizeMin; sizeMax = params_.gravelSizeMax; + far = params_.gravelDistanceFar; near = params_.gravelDistanceNear; + break; + } + const glm::vec2 gradient = walkTerrainGradient(terrain_, x, z, slopeProbe_.params().slopeSampleStep); + out.kind = kind; + out.position = { x, terrain_.heightAt(x, z), z }; + // Taille : loi en carre, les petits sujets dominent comme dans un vrai eboulis. + const float s = unitFloat(hSize); + out.scale = sizeMin + (sizeMax - sizeMin) * s * s; + out.yaw = unitFloat(hYaw) * kTwoPi; + out.variation = packRockVariation(unitFloat(hTint), gradient * params_.tiltFollow); + const float t = slots > 1 ? static_cast(slot) / static_cast(slots - 1) : 0.0f; + out.maxDistance = glm::mix(far, near, t); + return true; +} + +Rocks::Cell Rocks::buildBlockCell(int32_t cx, int32_t cz) const { + Cell cell; + const float size = params_.blockCell; + const float baseX = static_cast(cx) * size; + const float baseZ = static_cast(cz) * size; + if (cover_ != nullptr) { + const uint32_t total = params_.boulderSlots + params_.stoneSlots; + for (uint32_t slot = 0; slot < total; ++slot) { + const bool boulder = slot < params_.boulderSlots; + const uint32_t kindSlot = boulder ? slot : slot - params_.boulderSlots; + const uint32_t kindSlots = boulder ? params_.boulderSlots : params_.stoneSlots; + const uint32_t stream = slot * 5u + 300u; + const float x = baseX + unitFloat(cellHash(cx, cz, params_.seed, stream)) * size; + const float z = baseZ + unitFloat(cellHash(cx, cz, params_.seed, stream + 1u)) * size; + // 1. Filtre DUR (masque de la conception). + if (!maskAt(x, z)) { continue; } + // 2. Densite modulee par les trainees : l'emplacement n'est retenu que + // si la densite lui laisse la place (meme regle d'ordre que les arbres). + const float allowed = streakDensityAt(x, z) * static_cast(kindSlots); + if (static_cast(kindSlot) >= allowed) { continue; } + // 3. Choix du mesh par la rugosite : les blocs ne vont que sur le rugueux. + if (roughnessAt(x, z) < params_.roughBlocks) { continue; } + RockInstance r; + makeCandidate(x, z, boulder ? RockKind::Boulder : RockKind::Stone, kindSlot, + kindSlots, cellHash(cx, cz, params_.seed, stream + 2u), + cellHash(cx, cz, params_.seed, stream + 3u), + cellHash(cx, cz, params_.seed, stream + 4u), r); + cell.rocks.push_back(r); + } + } + fitBox(cell, baseX, baseZ, size); + return cell; +} + +Rocks::Cell Rocks::buildGravelCell(int32_t cx, int32_t cz) const { + Cell cell; + const float size = params_.gravelCell; + const float baseX = static_cast(cx) * size; + const float baseZ = static_cast(cz) * size; + if (cover_ != nullptr) { + // Rugosite UNE fois par cellule, au centre : la cellule de 4 m est de la + // taille de la fenetre 5x5 de la definition, et 81 sondes par caillou + // seraient le premier poste du semis. + bool roughKnown = false; + bool rough = false; + const uint32_t seed = params_.seed ^ 0x6A09E667u; + for (uint32_t slot = 0; slot < params_.gravelSlots; ++slot) { + const uint32_t stream = slot * 5u + 700u; + const float x = baseX + unitFloat(cellHash(cx, cz, seed, stream)) * size; + const float z = baseZ + unitFloat(cellHash(cx, cz, seed, stream + 1u)) * size; + if (!maskAt(x, z)) { continue; } + const float allowed = streakDensityAt(x, z) * static_cast(params_.gravelSlots); + if (static_cast(slot) >= allowed) { continue; } + if (!roughKnown) { + rough = roughnessAt(baseX + 0.5f * size, baseZ + 0.5f * size) >= params_.roughBlocks; + roughKnown = true; + } + if (rough) { break; } // zone rugueuse : ce sont les blocs qui l'occupent + RockInstance r; + makeCandidate(x, z, RockKind::Gravel, slot, params_.gravelSlots, + cellHash(cx, cz, seed, stream + 2u), cellHash(cx, cz, seed, stream + 3u), + cellHash(cx, cz, seed, stream + 4u), r); + cell.rocks.push_back(r); + } + } + fitBox(cell, baseX, baseZ, size); + return cell; +} + +std::vector Rocks::blockCellRocks(int32_t cx, int32_t cz) const { + return buildBlockCell(cx, cz).rocks; +} +std::vector Rocks::gravelCellRocks(int32_t cx, int32_t cz) const { + return buildGravelCell(cx, cz).rocks; +} + +Rocks::Cell Rocks::buildBlock(int32_t bx, int32_t bz, bool gravelGrid) const { + // Un BLOC = kBlockCells x kBlockCells cellules de semis, cache d'un seul + // tenant. MESURE : avec un cache par cellule, le semis coutait ~400 us par + // image en Debug, surtout en recherches dans la table de hachage - alors que + // plus de 90 % des cellules sont hors masque, donc vides. + Cell block; + bool first = true; + for (int32_t j = 0; j < kBlockCells; ++j) { + for (int32_t i = 0; i < kBlockCells; ++i) { + const int32_t cx = bx * kBlockCells + i, cz = bz * kBlockCells + j; + const Cell cell = gravelGrid ? buildGravelCell(cx, cz) : buildBlockCell(cx, cz); + if (cell.rocks.empty()) { continue; } + block.boxMin = first ? cell.boxMin : glm::min(block.boxMin, cell.boxMin); + block.boxMax = first ? cell.boxMax : glm::max(block.boxMax, cell.boxMax); + first = false; + block.rocks.insert(block.rocks.end(), cell.rocks.begin(), cell.rocks.end()); + } + } + return block; +} + +const Rocks::Cell& Rocks::cachedBlock(int32_t bx, int32_t bz, bool gravelGrid) const { + Cache& cache = gravelGrid ? gravelCache_ : blockCache_; + const CellKey key{ bx, bz }; + auto found = cache.find(key); + if (found != cache.end()) { return found->second; } + return cache.emplace(key, buildBlock(bx, bz, gravelGrid)).first->second; +} + +void Rocks::gather(const glm::vec3& eye, const Frustum& frustum, + std::vector& boulders, std::vector& stones, + std::vector& gravel) { + boulders.clear(); + stones.clear(); + gravel.clear(); + if (cover_ != nullptr) { + std::vector* outs[3] = { &boulders, &stones, &gravel }; + gatherGrid(eye, frustum, false, outs); + gatherGrid(eye, frustum, true, outs); + } + lastBoulders_ = static_cast(boulders.size()); + lastStones_ = static_cast(stones.size()); + lastGravel_ = static_cast(gravel.size()); +} + +void Rocks::gatherGrid(const glm::vec3& eye, const Frustum& frustum, bool gravelGrid, + std::vector* outs[3]) { + const float cellSize = gravelGrid ? params_.gravelCell : params_.blockCell; + const float reach = gravelGrid ? params_.gravelDistanceFar + : std::max(params_.boulderDistanceFar, params_.stoneDistanceFar); + const uint32_t budget = gravelGrid ? params_.gravelCellBudget : params_.blockCellBudget; + Cache& cache = gravelGrid ? gravelCache_ : blockCache_; + const float blockSize = static_cast(kBlockCells) * cellSize; + + const auto bx0 = static_cast(std::floor((eye.x - reach) / blockSize)); + const auto bx1 = static_cast(std::floor((eye.x + reach) / blockSize)); + const auto bz0 = static_cast(std::floor((eye.z - reach) / blockSize)); + const auto bz1 = static_cast(std::floor((eye.z + reach) / blockSize)); + uint32_t built = 0; + + for (int32_t bz = bz0; bz <= bz1; ++bz) { + for (int32_t bx = bx0; bx <= bx1; ++bx) { + const float bMinX = static_cast(bx) * blockSize; + const float bMinZ = static_cast(bz) * blockSize; + const float bdx = eye.x - glm::clamp(eye.x, bMinX, bMinX + blockSize); + const float bdz = eye.z - glm::clamp(eye.z, bMinZ, bMinZ + blockSize); + if (bdx * bdx + bdz * bdz > reach * reach) { continue; } + auto found = cache.find(CellKey{ bx, bz }); + if (found == cache.end()) { + // Bloc inconnu : culle sur une boite grossiere AVANT de payer le + // semis (cinq sondes + marge large, comme Vegetation), puis budget. + float lo = terrain_.heightAt(bMinX + 0.5f * blockSize, bMinZ + 0.5f * blockSize); + float hi = lo; + for (int corner = 0; corner < 4; ++corner) { + const float h = terrain_.heightAt(bMinX + ((corner & 1) ? blockSize : 0.0f), + bMinZ + ((corner & 2) ? blockSize : 0.0f)); + lo = std::min(lo, h); + hi = std::max(hi, h); + } + const float margin = gravelGrid ? 40.0f : 130.0f; + if (!frustum.intersectsAABB({ bMinX, lo - margin, bMinZ }, + { bMinX + blockSize, hi + margin, bMinZ + blockSize })) { + continue; + } + if (built >= budget) { continue; } // servi a une image suivante + ++built; + found = cache.emplace(CellKey{ bx, bz }, buildBlock(bx, bz, gravelGrid)).first; + } + const Cell& block = found->second; + if (block.rocks.empty() || !frustum.intersectsAABB(block.boxMin, block.boxMax)) { + continue; + } + for (const RockInstance& r : block.rocks) { + const glm::vec3 d = eye - r.position; + const float d2 = glm::dot(d, d); + if (d2 >= r.maxDistance * r.maxDistance) { continue; } + const float distance = std::sqrt(d2); + InstanceData instance; + instance.position = r.position; + instance.scale = r.scale; + instance.yaw = r.yaw; + instance.variation = r.variation; + instance.fade = 1.0f - ramp(distance, 0.82f * r.maxDistance, r.maxDistance); + outs[static_cast(r.kind)]->push_back(instance); + } + } + } + + // Purge : au-dela de 1,5 x la portee (plus un bloc), comme Vegetation. + const float keep = 1.5f * reach + blockSize; + for (auto it = cache.begin(); it != cache.end();) { + const float ccx = (static_cast(it->first.x) + 0.5f) * blockSize; + const float ccz = (static_cast(it->first.z) + 0.5f) * blockSize; + const float ddx = eye.x - ccx, ddz = eye.z - ccz; + it = (ddx * ddx + ddz * ddz > keep * keep) ? cache.erase(it) : std::next(it); + } +} + +Rocks::Stats Rocks::estimate(uint32_t step) const { + Stats stats; + if (cover_ == nullptr) { return stats; } + step = std::max(step, 1u); + const float cell = params_.blockCell; + const auto half = static_cast((terrainExtent_ - kEdgeMargin) / cell) - 1; + uint64_t cells = 0, masked = 0, probes = 0, boulders = 0, stones = 0, gravel = 0; + const auto ratio = static_cast(std::lround(params_.blockCell / params_.gravelCell)); + for (int32_t cz = -half; cz <= half; cz += static_cast(step)) { + for (int32_t cx = -half; cx <= half; cx += static_cast(step)) { + ++cells; + for (const RockInstance& r : buildBlockCell(cx, cz).rocks) { + (r.kind == RockKind::Boulder ? boulders : stones) += 1; + } + // Une cellule de pierraille sur quatre de celles qui recouvrent la + // cellule de blocs (coin), remise a l'echelle ensuite. + gravel += buildGravelCell(cx * ratio, cz * ratio).rocks.size(); + for (int j = 0; j < 4; ++j) { + for (int i = 0; i < 4; ++i) { + ++probes; + masked += maskAt((static_cast(cx) + 0.125f + 0.25f * i) * cell, + (static_cast(cz) + 0.125f + 0.25f * j) * cell) ? 1 : 0; + } + } + } + } + if (cells == 0) { return stats; } + const double ha = static_cast(cells) * cell * cell / 10000.0; + const double gravelHa = static_cast(cells) * params_.gravelCell * params_.gravelCell / 10000.0; + stats.maskFraction = static_cast(masked) / static_cast(probes); + stats.bouldersPerHa = static_cast(boulders) / ha; + stats.stonesPerHa = static_cast(stones) / ha; + stats.gravelPerHa = static_cast(gravel) / gravelHa; + return stats; +} + +// --------------------------------------------------------------------------- +// Collision : gros blocs seulement +// --------------------------------------------------------------------------- +// Un gros bloc ne bloque que le corps qui est a sa hauteur : un parapente qui le +// survole, ou un joueur dont les pieds sont deja au-dessus de son sommet moins +// une marche (stepOver), passe. Meme tolerance de contact que Forest. +glm::vec3 Rocks::resolve(const BodyCylinder& body) const { + glm::vec3 corrected = body.position; + if (!params_.collide || cover_ == nullptr) { return corrected; } + const float maxRadius = kRockFootprintRadius * params_.colliderRadiusFactor * params_.boulderSizeMax; + const float reach = maxRadius + body.radius; + const float cell = params_.blockCell * static_cast(kBlockCells); // blocs + for (int pass = 0; pass < 3; ++pass) { + bool touched = false; + const auto cx0 = static_cast(std::floor((corrected.x - reach) / cell)); + const auto cx1 = static_cast(std::floor((corrected.x + reach) / cell)); + const auto cz0 = static_cast(std::floor((corrected.z - reach) / cell)); + const auto cz1 = static_cast(std::floor((corrected.z + reach) / cell)); + for (int32_t cz = cz0; cz <= cz1; ++cz) { + for (int32_t cx = cx0; cx <= cx1; ++cx) { + for (const RockInstance& r : cachedBlock(cx, cz, false).rocks) { + if (r.kind != RockKind::Boulder || r.scale < params_.collideMinScale) { continue; } + const float top = r.position.y + kRockVisibleHeight * r.scale; + if (body.feetY + params_.stepOver >= top || body.headY <= r.position.y) { continue; } + const float radius = kRockFootprintRadius * params_.colliderRadiusFactor * r.scale; + const float contact = radius + body.radius; + const float dx = corrected.x - r.position.x; + const float dz = corrected.z - r.position.z; + const float d2 = dx * dx + dz * dz; + if (d2 >= contact * contact) { continue; } + const float d = std::sqrt(d2); + const glm::vec2 outward = (d > 1e-4f) ? glm::vec2(dx / d, dz / d) : glm::vec2(1.0f, 0.0f); + corrected.x = r.position.x + outward.x * contact; + corrected.z = r.position.z + outward.y * contact; + touched = true; + } + } + } + if (!touched) { break; } + } + return corrected; +} + +bool Rocks::overlaps(const BodyCylinder& body) const { + if (!params_.collide || cover_ == nullptr) { return false; } + const float maxRadius = kRockFootprintRadius * params_.colliderRadiusFactor * params_.boulderSizeMax; + const float reach = maxRadius + body.radius; + const float cell = params_.blockCell * static_cast(kBlockCells); // blocs + const auto cx0 = static_cast(std::floor((body.position.x - reach) / cell)); + const auto cx1 = static_cast(std::floor((body.position.x + reach) / cell)); + const auto cz0 = static_cast(std::floor((body.position.z - reach) / cell)); + const auto cz1 = static_cast(std::floor((body.position.z + reach) / cell)); + constexpr float kContactEpsilon = 1e-3f; // meme tolerance que Forest::overlaps + for (int32_t cz = cz0; cz <= cz1; ++cz) { + for (int32_t cx = cx0; cx <= cx1; ++cx) { + for (const RockInstance& r : cachedBlock(cx, cz, false).rocks) { + if (r.kind != RockKind::Boulder || r.scale < params_.collideMinScale) { continue; } + const float top = r.position.y + kRockVisibleHeight * r.scale; + if (body.feetY + params_.stepOver >= top || body.headY <= r.position.y) { continue; } + const float contact = kRockFootprintRadius * params_.colliderRadiusFactor * r.scale + body.radius; + const float dx = body.position.x - r.position.x; + const float dz = body.position.z - r.position.z; + if (dx * dx + dz * dz < (contact - kContactEpsilon) * (contact - kContactEpsilon)) { + return true; + } + } + } + } + return false; +} + +} // namespace vercora diff --git a/src/world/Rocks.hpp b/src/world/Rocks.hpp new file mode 100644 index 0000000..2b011a4 --- /dev/null +++ b/src/world/Rocks.hpp @@ -0,0 +1,223 @@ +#pragma once + +#include "core/CollisionSolver.hpp" +#include "core/SlopeLimits.hpp" +#include "renderer/InstanceData.hpp" +#include "world/Climber.hpp" + +#include + +#include +#include +#include +#include + +namespace vercora { + +class HeightSampler; +struct Frustum; + +// PHASE 29 (Agent 2) : rochers et pierriers PROCEDURAUX, pilotes par les donnees +// reelles selon les criteres valides dans NOTES-PHASE29-DESIGN.md (Agent 1) : +// +// PIERRIER = kWalkComfortSlope <= pente(Climber::slopeAt, base 4 m) < kWalkMaxSlope +// ET couvert LiDAR < 0,10 (ET hors bati/eau : non expose au jeu, +// effet mesure 2 272 m2 sur 25 km2 - voir NOTES-PHASE29.md). +// MESH = rugosite (RMS du residu DTM - moyenne 5x5, sur 5x5) >= 0,10 m +// -> gros blocs + rochers moyens ; < 0,10 m -> pierraille fine. +// +// Le masque est un filtre DUR : aucune position hors masque n'est jamais +// retenue, quel que soit le bruit. Le bruit (basse frequence, etire dans le sens +// de la pente) ne fait que MODULER la densite a l'interieur du masque, pour +// dessiner des trainees d'eboulis au lieu d'un semis uniforme. +// +// Sans carte de couvert (terrain synthetique, dalle sans carte) : AUCUN rocher. +// C'est la regle "aucun rocher sans lien avec une donnee reelle" - on ne +// retombe PAS sur un substitut par pente seule, contrairement a Vegetation. +// +// Meme architecture que Vegetation : semis = fonction deterministe (hachage) de +// la cellule, cache des cellules proches, culling par blocs 8x8, LOD de DENSITE +// par emplacement (chaque emplacement a sa portee), InstanceData de 28 o. +struct RockParams { + // --- Criteres du masque (NOTES-PHASE29-DESIGN.md, section 3) ------------ + float slopeMin = kWalkComfortSlope; // 0,60 + float slopeMax = kWalkMaxSlope; // 0,84 (au-dela : paroi, Climber) + float coverMax = 0.10f; + float roughBlocks = 0.10f; // m : >= -> blocs, < -> pierraille + + // --- Blocs (gros blocs + rochers moyens), grille grossiere -------------- + // Cellule de 32 m (et non 16) : MESURE, le semis a 16 m / 900 m parcourait + // ~10 000 cellules par image, 1,6 ms en Debug. Meme densite surfacique. + float blockCell = 32.0f; + uint32_t boulderSlots = 8; // au plus 8 gros blocs / 1024 m2 (1 / 128 m2) + uint32_t stoneSlots = 20; // au plus 20 rochers moyens / 1024 m2 + float boulderSizeMin = 1.1f, boulderSizeMax = 2.6f; // echelle (m) + float stoneSizeMin = 0.35f, stoneSizeMax = 0.95f; + float boulderDistanceFar = 700.0f, boulderDistanceNear = 350.0f; + float stoneDistanceFar = 320.0f, stoneDistanceNear = 140.0f; + + // --- Pierraille fine, grille fine ---------------------------------------- + float gravelCell = 8.0f; + uint32_t gravelSlots = 12; // plaques de ~11 cailloux, au plus 12 / 64 m2 (3 / 16 m2) + float gravelSizeMin = 0.7f, gravelSizeMax = 1.5f; + float gravelDistanceFar = 70.0f, gravelDistanceNear = 30.0f; + + // --- Trainees : bruit de valeur a basse frequence, ANISOTROPE ----------- + // Frequences en cycles/m dans le repere local de la pente : lent dans le + // sens de la pente (trainees de ~110 m), rapide en travers (~28 m). + float streakAlong = 1.0f / 110.0f; + float streakAcross = 1.0f / 28.0f; + float streakThreshold = 0.35f; // densite nulle sous ce seuil de bruit + float streakSoftness = 0.30f; // largeur de la rampe au-dessus + // Pas des differences centrees pour la DIRECTION des trainees (pas pour le + // masque) : une base large evite que la trainee se torde a chaque bosse. + float streakDirectionStep = 16.0f; + // Tuile du repere des trainees (voir Rocks::streakDensityAt) : la direction + // de la pente est lue au centre de chaque tuile de 96 m. + float streakTile = 96.0f; + + // Part de la pente suivie par l'inclinaison du rocher (1 = normale au sol). + float tiltFollow = 0.85f; + + // --- Collision ------------------------------------------------------------ + // Seuls les gros blocs d'au moins cette echelle bloquent le joueur ; les + // rochers moyens et la pierraille se traversent (voir NOTES-PHASE29.md). + bool collide = true; + float collideMinScale = 1.3f; + float colliderRadiusFactor = 0.85f; // x kRockFootprintRadius x echelle + float stepOver = 0.40f; // un bloc dont le sommet est sous les pieds + ca ne bloque pas + + uint32_t seed = 20260927u; + // BLOCS de 8 x 8 cellules engendres au plus par appel (a-coup borne). + uint32_t blockCellBudget = 3; + uint32_t gravelCellBudget = 4; +}; + +enum class RockKind : uint8_t { Boulder = 0, Stone = 1, Gravel = 2 }; + +// Encodage de l'inclinaison dans InstanceData::variation (voir shaders/ +// foliage.vert, mode rocher = params.w < 0). La struct d'instance est pleine +// (28 o, stride fige) ; plutot que d'en creer une seconde et un second format +// de sommet, la partie ENTIERE de `variation` porte le gradient quantifie sur +// 64 x 64 niveaux dans [-1, 1], la partie fractionnaire garde l'alea de teinte. +// 4095 + fraction tient dans les 24 bits de mantisse avec 12 bits de fraction. +inline float packRockVariation(float tint, glm::vec2 gradient) { + const auto q = [](float g) { + const float c = std::fmin(std::fmax(g, -1.0f), 1.0f); + return std::floor((c + 1.0f) * 0.5f * 63.0f + 0.5f); + }; + const float t = std::fmin(std::fmax(tint, 0.0f), 0.999f); + return q(gradient.x) * 64.0f + q(gradient.y) + t; +} +inline glm::vec2 unpackRockGradient(float packed) { + const float index = std::floor(packed); + const float qx = std::floor(index / 64.0f); + const float qz = index - qx * 64.0f; + return glm::vec2(qx, qz) / 63.0f * 2.0f - 1.0f; +} +inline float unpackRockTint(float packed) { return packed - std::floor(packed); } + +struct RockInstance { + glm::vec3 position{0.0f}; // pied (origine du mesh), sur le terrain + float scale = 1.0f; + float yaw = 0.0f; + float variation = 0.0f; // deja encode (packRockVariation) + float maxDistance = 0.0f; // portee propre a l'emplacement (LOD de densite) + RockKind kind = RockKind::Gravel; +}; + +class Rocks : public CollisionSolver { +public: + // `cover` = carte de couvert LiDAR (vercora_zone_canopy.vchm), comme + // Vegetation. Nulle -> aucun rocher (voir plus haut). Non possedes. + Rocks(const HeightSampler& terrain, const HeightSampler* cover, float terrainExtent, + const RockParams& params = {}); + + bool enabled() const { return cover_ != nullptr; } + + // Remplit les trois vecteurs (vides d'abord) des rochers visibles. + void gather(const glm::vec3& eye, const Frustum& frustum, + std::vector& boulders, std::vector& stones, + std::vector& gravel); + + // --- Critere, expose pour les tests et le diagnostic -------------------- + bool maskAt(float worldX, float worldZ) const; // filtre dur + float roughnessAt(float worldX, float worldZ) const; // m + float streakDensityAt(float worldX, float worldZ) const; // [0,1] + + // Tous les candidats RETENUS par le semis d'une cellule (tests). + std::vector blockCellRocks(int32_t cx, int32_t cz) const; + std::vector gravelCellRocks(int32_t cx, int32_t cz) const; + + // Estimation sur toute la zone (une cellule de blocs sur `step`) : part de + // la surface sous masque et nombre de rochers par hectare de masque. + struct Stats { + double maskFraction = 0.0; + double bouldersPerHa = 0.0; // par hectare de ZONE + double stonesPerHa = 0.0; + double gravelPerHa = 0.0; // plaques + }; + Stats estimate(uint32_t step = 9) const; + + // --- CollisionSolver : gros blocs seulement ----------------------------- + glm::vec3 resolve(const BodyCylinder& body) const override; + bool overlaps(const BodyCylinder& body) const override; + + // --- Diagnostic ------------------------------------------------------- + uint32_t lastBoulderCount() const { return lastBoulders_; } + uint32_t lastStoneCount() const { return lastStones_; } + uint32_t lastGravelCount() const { return lastGravel_; } + std::size_t cachedBlockCount() const { return blockCache_.size() + gravelCache_.size(); } + const RockParams& params() const { return params_; } + +private: + struct CellKey { + int32_t x = 0, z = 0; + bool operator==(const CellKey& o) const { return x == o.x && z == o.z; } + }; + struct CellKeyHash { + std::size_t operator()(const CellKey& k) const { + return (static_cast(static_cast(k.x)) * 0x9E3779B1ull) ^ + (static_cast(static_cast(k.z)) * 0x85EBCA77ull); + } + }; + struct Cell { + std::vector rocks; + glm::vec3 boxMin{0.0f}, boxMax{0.0f}; + }; + using Cache = std::unordered_map; + + Cell buildBlockCell(int32_t cx, int32_t cz) const; + Cell buildGravelCell(int32_t cx, int32_t cz) const; + // Cache par BLOC de kBlockCells x kBlockCells cellules (voir buildBlock). + static constexpr int32_t kBlockCells = 8; + Cell buildBlock(int32_t bx, int32_t bz, bool gravelGrid) const; + const Cell& cachedBlock(int32_t bx, int32_t bz, bool gravelGrid) const; + + // Parcours commun aux deux grilles (culling par blocs 8x8, budget, LOD). + void gatherGrid(const glm::vec3& eye, const Frustum& frustum, bool gravelGrid, + std::vector* outs[3]); + + // Candidat a (x, z) : filtre dur + construction. Renvoie false si rejete. + bool makeCandidate(float x, float z, RockKind kind, uint32_t slot, uint32_t slots, + uint32_t hSize, uint32_t hYaw, uint32_t hTint, + RockInstance& out) const; + float coverAt(float worldX, float worldZ) const; + void fitBox(Cell& cell, float baseX, float baseZ, float size) const; + + const HeightSampler& terrain_; + const HeightSampler* cover_ = nullptr; + float terrainExtent_ = 0.0f; + RockParams params_; + Climber slopeProbe_; // Climber::slopeAt = LA pente du critere (base 4 m) + + // Mutables : la collision (const, interface CollisionSolver) engendre a la + // demande les cellules de blocs sous le joueur. Le contenu est une fonction + // pure de la cellule : le cache ne change aucun resultat, seulement le cout. + mutable Cache blockCache_; + mutable Cache gravelCache_; + + uint32_t lastBoulders_ = 0, lastStones_ = 0, lastGravel_ = 0; +}; + +} // namespace vercora diff --git a/src/world/StoneMesh.cpp b/src/world/StoneMesh.cpp new file mode 100644 index 0000000..f1b66fc --- /dev/null +++ b/src/world/StoneMesh.cpp @@ -0,0 +1,200 @@ +#include "world/StoneMesh.hpp" + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; + +// Teintes de sommet. Comme pour l'arbre, la couleur vient du SOMMET et non d'une +// texture : le materiau Object (cube.vert/frag) l'utilise telle quelle. +const glm::vec3 kStoneColor {0.44f, 0.43f, 0.41f}; // calcaire gris +const glm::vec3 kFlakeDorsal {0.38f, 0.37f, 0.36f}; // face dorsale, mate +const glm::vec3 kFlakeVentral {0.62f, 0.61f, 0.57f}; // face fraiche, plus claire + +// Ajoute un triangle FACETTE : trois sommets qui lui appartiennent, une seule +// normale. C'est ce qui donne aux cassures leur arete franche - un galet ou un +// eclat en normales lissees ressemblerait a une pomme de terre. +void appendFacet(MeshData& mesh, const glm::vec3& a, const glm::vec3& b, + const glm::vec3& c, const glm::vec3& color) { + const glm::vec3 edge1 = b - a; + const glm::vec3 edge2 = c - a; + const glm::vec3 rawNormal = glm::cross(edge1, edge2); + + const float length = glm::length(rawNormal); + if (length < 1e-9f) { + return; // triangle degenere : rien a dessiner, et sa normale n'existe pas + } + const glm::vec3 normal = rawNormal / length; + + const auto base = static_cast(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 }); +} + +// --- Construction du galet ------------------------------------------------- +// Un octaedre subdivise une fois (8 -> 32 faces), dont chaque sommet UNIQUE est +// ensuite pousse d'un facteur aleatoire le long de son rayon. +// +// Le point delicat est la ou porte le bruit : il est applique aux sommets +// UNIQUES du polyedre, avant de decouper les triangles facettes. Bruiter chaque +// triangle independamment ouvrirait le volume (deux triangles voisins ne +// partageraient plus leur arete) et on verrait a travers le galet. + +using EdgeKey = std::pair; + +uint32_t midpointIndex(std::vector& points, + std::map& cache, + uint32_t a, uint32_t b) { + // Cle ordonnee : l'arete (a,b) et l'arete (b,a) sont la meme, sans quoi les + // deux triangles qui la partagent creeraient chacun leur milieu et le + // maillage se dechirerait au moment du bruitage. + 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 normalisation, les subdivisions + // successives aplatiraient progressivement le volume vers l'octaedre initial. + const glm::vec3 midpoint = glm::normalize(points[a] + points[b]); + points.push_back(midpoint); + + const auto index = static_cast(points.size() - 1); + cache.emplace(key, index); + return index; +} + +} // namespace + +MeshData stoneMeshData() { + MeshData mesh; + mesh.name = "pierre synthetique (Phase 6)"; + + // Octaedre de depart : 6 sommets, 8 faces. + std::vector 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> 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}, + }; + + // Une subdivision : 32 faces. Deux subdivisions donneraient 128 faces, ce qui + // est beaucoup pour un galet vu de loin ; 32 suffit a ce que la silhouette ne + // se lise plus comme un octaedre une fois bruitee. + std::map midpoints; + std::vector> subdivided; + subdivided.reserve(faces.size() * 4); + + for (const auto& face : faces) { + const uint32_t ab = midpointIndex(points, midpoints, face[0], face[1]); + const uint32_t bc = midpointIndex(points, midpoints, face[1], face[2]); + const uint32_t ca = midpointIndex(points, midpoints, face[2], face[0]); + + subdivided.push_back({ face[0], ab, ca }); + subdivided.push_back({ ab, face[1], bc }); + subdivided.push_back({ ca, bc, face[2] }); + subdivided.push_back({ ab, bc, ca }); + } + faces = std::move(subdivided); + + // Bruitage. Graine FIXE et locale : toutes les pierres partagent ce mesh + // unique (une seule geometrie sur le GPU, N matrices), donc il n'y a rien a + // varier d'une instance a l'autre - seules leur orientation et leur position + // different. Une graine fixe garde en prime le mesh reproductible d'une + // execution a l'autre. + std::mt19937 rng(0x5701Eu); + std::uniform_real_distribution bump(0.74f, 1.0f); + + for (glm::vec3& point : points) { + point *= bump(rng); + // Aplatissement vertical : un galet pose au sol est plus large que haut. + // Applique ICI, dans la geometrie, et non par une echelle d'instance : + // une echelle non uniforme casserait la normal matrix mat3(model) sur + // laquelle repose le contrat de DrawItem. + point.x *= kStoneWidth; + point.z *= kStoneWidth; + point.y *= kStoneRadius; + } + + for (const auto& face : faces) { + appendFacet(mesh, points[face[0]], points[face[1]], points[face[2]], kStoneColor); + } + + return mesh; +} + +MeshData flakeMeshData() { + MeshData mesh; + mesh.name = "eclat de pierre taillee (Phase 6)"; + + // Contour irregulier dans le plan XZ, allonge le long de +X (meme convention + // que la buche et la branche : les objets couches pointent vers +X, ce qui + // rend GroundItem::yaw interchangeable entre tous les objets au sol). + constexpr int kSides = 7; + const float halfLength = 0.5f * kFlakeLength; + const float halfWidth = 0.5f * kFlakeWidth; + + std::mt19937 rng(0xEC1A7u); + std::uniform_real_distribution wobble(0.78f, 1.0f); + + std::vector rim; + rim.reserve(kSides); + for (int i = 0; i < kSides; ++i) { + const float angle = kTwoPi * static_cast(i) / static_cast(kSides); + const float r = wobble(rng); + rim.push_back({ halfLength * r * std::cos(angle), 0.0f, + halfWidth * r * std::sin(angle) }); + } + + // Face VENTRALE : plate, tournee vers le bas. C'est la surface laissee par + // l'onde de choc de la percussion, et c'est elle qui repose sur le sol. + const glm::vec3 ventralCenter{ 0.0f, -kFlakeRadius, 0.0f }; + for (int i = 0; i < kSides; ++i) { + const glm::vec3& a = rim[static_cast(i)]; + const glm::vec3& b = rim[static_cast((i + 1) % kSides)]; + // Les points du contour sont ramenes au plan ventral : le perimetre est + // donc l'arete vive entre les deux faces, exactement comme sur un eclat. + appendFacet(mesh, + ventralCenter, + { a.x, -kFlakeRadius, a.z }, + { b.x, -kFlakeRadius, b.z }, + kFlakeVentral); + } + + // Face DORSALE : une arete centrale, decalee vers l'arriere pour que l'eclat + // ne soit pas symetrique (le talon est epais, la pointe est fine). + const glm::vec3 dorsalApex{ -0.15f * kFlakeLength, kFlakeRadius, 0.0f }; + for (int i = 0; i < kSides; ++i) { + const glm::vec3& a = rim[static_cast(i)]; + const glm::vec3& b = rim[static_cast((i + 1) % kSides)]; + appendFacet(mesh, + dorsalApex, + { b.x, -kFlakeRadius, b.z }, + { a.x, -kFlakeRadius, a.z }, + kFlakeDorsal); + } + + return mesh; +} + +} // namespace vercora diff --git a/src/world/StoneMesh.hpp b/src/world/StoneMesh.hpp new file mode 100644 index 0000000..2e9d28c --- /dev/null +++ b/src/world/StoneMesh.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +namespace vercora { + +// Geometries synthetiques du premier maillon d'artisanat (taillage de pierre par +// percussion), generees EN CODE comme celles de l'arbre : aucun fichier, aucun +// telechargement. +// +// Ces meshes ne sont PAS a l'echelle unite (contrairement a l'arbre et a la +// souche) : leurs dimensions sont ABSOLUES, comme la buche et la branche. Une +// pierre fait la meme taille partout, donc une instance se pose par +// translate * rotate SANS aucune echelle - la normal matrix est alors exacte au +// sens strict, et non seulement a un facteur pres. +// +// Les deux meshes sont centres sur l'origine, y compris verticalement : c'est ce +// qui permet a Ground::drop de les poser en ajoutant simplement leur demi-hauteur +// a l'altitude du terrain (voir groundItemRestRadius). + +// Un galet : polyedre irregulier bas-poly, facette, legerement aplati pour qu'il +// ait l'air de reposer sur le sol plutot que d'y etre pose en equilibre. +MeshData stoneMeshData(); + +// Un eclat tranchant : face ventrale PLATE, face dorsale en arete, perimetre +// aigu. C'est la silhouette caracteristique d'un eclat de percussion, et elle se +// lit meme a quelques dizaines de triangles. +MeshData flakeMeshData(); + +// Dimensions en unites monde. Exposees parce que le code de placement en a +// besoin pour poser les objets sur le sol sans qu'ils s'enfoncent ni flottent. +// Les rayons sont des DEMI-HAUTEURS (l'objet est centre sur son origine). +inline constexpr float kStoneRadius = 0.20f; // demi-hauteur du galet +inline constexpr float kStoneWidth = 0.30f; // demi-largeur horizontale +inline constexpr float kFlakeRadius = 0.025f; // demi-epaisseur de l'eclat +inline constexpr float kFlakeLength = 0.24f; +inline constexpr float kFlakeWidth = 0.15f; + +} // namespace vercora diff --git a/src/world/TerrainQuadtree.cpp b/src/world/TerrainQuadtree.cpp new file mode 100644 index 0000000..eec3061 --- /dev/null +++ b/src/world/TerrainQuadtree.cpp @@ -0,0 +1,261 @@ +#include "world/TerrainQuadtree.hpp" + +#include "assets/Heightmap.hpp" + +#include +#include +#include + +namespace vercora { + +TerrainQuadtree::TerrainQuadtree(const Heightmap& heightmap, const Params& params) + : heightmap_(heightmap), params_(params) { + if (params_.nodeCells < 2 || (params_.nodeCells & (params_.nodeCells - 1)) != 0) { + throw std::runtime_error( + "TerrainQuadtree : nodeCells doit etre une puissance de deux >= 2 (recu " + + std::to_string(params_.nodeCells) + ")."); + } + if (heightmap.resolution() < 2) { + throw std::runtime_error("TerrainQuadtree : grille trop petite pour former un noeud."); + } + if (!(params_.morphStartRatio > 0.5f) || params_.morphEndRatio > 1.0f || + params_.morphEndRatio <= params_.morphStartRatio) { + throw std::runtime_error( + "TerrainQuadtree : bande de morphing invalide (il faut " + "0.5 < morphStartRatio < morphEndRatio <= 1)."); + } + + cells_ = heightmap.resolution() - 1; + + // Racine = plus petit niveau dont l'emprise couvre toute la grille. Un + // terrain procedural de 128 echantillons (127 cellules) tient donc en un + // seul niveau au-dessus des feuilles, et la dalle de la Phase 7 (1000 + // cellules) en quatre. + uint32_t span = params_.nodeCells; + rootLevel_ = 0; + while (span < cells_) { + span *= 2; + ++rootLevel_; + if (rootLevel_ > 24) { // garde-fou : 64 * 2^24 cellules, hors de portee + throw std::runtime_error("TerrainQuadtree : grille trop grande."); + } + } + + ranges_.resize(static_cast(rootLevel_) + 1); + const float leafWorldSize = static_cast(params_.nodeCells) * heightmap.spacing(); + for (uint8_t level = 0; level <= rootLevel_; ++level) { + ranges_[level] = params_.rangeFactor * leafWorldSize * + static_cast(1u << level); + } + + // Reservation genereuse : le quadtree complet d'une grille de 5000 cellules + // fait ~8300 noeuds, soit moins d'un demi-megaoctet. + nodes_.reserve(1024); + + const int32_t root = build(0, 0, span, rootLevel_); + if (root < 0) { + throw std::runtime_error("TerrainQuadtree : aucune racine construite."); + } + rootIndex_ = static_cast(root); +} + +int32_t TerrainQuadtree::build(uint32_t ix0, uint32_t iz0, uint32_t span, uint8_t level) { + // Entierement au-dela du bord : le noeud n'existe pas. Le test porte sur le + // COIN : un noeud qui commencerait sur la derniere ligne d'echantillons ne + // couvrirait aucune cellule. + if (ix0 >= cells_ || iz0 >= cells_) { + return -1; + } + + const uint32_t index = static_cast(nodes_.size()); + nodes_.push_back(Node{}); + { + Node& node = nodes_[index]; + node.ix0 = ix0; + node.iz0 = iz0; + node.span = span; + node.stride = span / params_.nodeCells; + node.level = level; + } + + if (level == 0) { + float minY = 0.0f; + float maxY = 0.0f; + leafBounds(nodes_[index], &minY, &maxY); + + // Emprise monde ECRETEE sur la grille : c'est ce qui sera reellement + // maille (voir TerrainNodeMesh), donc ce qui doit etre teste au culling. + const uint32_t ix1 = std::min(ix0 + span, cells_); + const uint32_t iz1 = std::min(iz0 + span, cells_); + + Node& node = nodes_[index]; + node.boundsMin = { heightmap_.worldCoord(ix0), minY, heightmap_.worldCoord(iz0) }; + node.boundsMax = { heightmap_.worldCoord(ix1), maxY, heightmap_.worldCoord(iz1) }; + return static_cast(index); + } + + // Fils : quatre quadrants de demi-emprise, un niveau plus fin. + const uint32_t half = span / 2; + const uint32_t offsets[4][2] = { + { ix0, iz0 }, + { ix0 + half, iz0 }, + { ix0, iz0 + half }, + { ix0 + half, iz0 + half }, + }; + + int32_t childIndices[4]; + for (int i = 0; i < 4; ++i) { + childIndices[i] = build(offsets[i][0], offsets[i][1], half, + static_cast(level - 1)); + // PHASE 12 : chainage vers le pere, pose des le retour du fils. Ecrit + // par INDICE et non par reference : nodes_ vient d'etre reallouee par + // l'appel recursif ci-dessus (meme piege que plus bas). + if (childIndices[i] >= 0) { + nodes_[static_cast(childIndices[i])].parent = + static_cast(index); + } + } + + // ATTENTION : nodes_ a pu etre REALLOUE par les appels recursifs ci-dessus. + // Toute reference prise avant eux serait pendante - d'ou la reprise par + // indice ici, et les blocs a portee courte plus haut. + Node& node = nodes_[index]; + bool hasChild = false; + glm::vec3 boundsMin(0.0f); + glm::vec3 boundsMax(0.0f); + for (int i = 0; i < 4; ++i) { + node.children[i] = childIndices[i]; + if (childIndices[i] < 0) { + continue; + } + const Node& child = nodes_[static_cast(childIndices[i])]; + if (!hasChild) { + boundsMin = child.boundsMin; + boundsMax = child.boundsMax; + hasChild = true; + } else { + boundsMin = glm::min(boundsMin, child.boundsMin); + boundsMax = glm::max(boundsMax, child.boundsMax); + } + } + + // Les bornes remontent des fils : exact ET gratuit, alors qu'un balayage par + // noeud relirait la grille entiere une fois par niveau. + node.boundsMin = boundsMin; + node.boundsMax = boundsMax; + return static_cast(index); +} + +void TerrainQuadtree::leafBounds(const Node& node, float* minY, float* maxY) const { + // Balayage a la PLEINE resolution, et non au pas du noeud : la boite doit + // englober le relief reel, y compris un pic qui tomberait entre deux + // echantillons retenus par le maillage. Une boite trop petite ferait + // disparaitre du terrain au culling. + const uint32_t ix1 = std::min(node.ix0 + node.span, cells_); + const uint32_t iz1 = std::min(node.iz0 + node.span, cells_); + + float lo = heightmap_.at(node.ix0, node.iz0); + float hi = lo; + for (uint32_t iz = node.iz0; iz <= iz1; ++iz) { + for (uint32_t ix = node.ix0; ix <= ix1; ++ix) { + const float h = heightmap_.at(ix, iz); + lo = std::min(lo, h); + hi = std::max(hi, h); + } + } + *minY = lo; + *maxY = hi; +} + +void TerrainQuadtree::select(const glm::vec3& cameraPosition, const Frustum& frustum, + std::vector& out) const { + out.clear(); + selectRecursive(rootIndex_, cameraPosition, frustum, out); + + // Du plus proche au plus lointain : quand le budget de construction d'une + // frame est sature, ce sont les tuiles LOINTAINES qui attendent une frame de + // plus, jamais celles sous les pieds du joueur. + std::sort(out.begin(), out.end(), + [](const SelectedNode& a, const SelectedNode& b) { + return a.distance < b.distance; + }); +} + +void TerrainQuadtree::selectRecursive(uint32_t nodeIndex, const glm::vec3& cameraPosition, + const Frustum& frustum, + std::vector& out) const { + const Node& node = nodes_[nodeIndex]; + + // --- Frustum culling ---------------------------------------------------- + // Fait AVANT la descente : un noeud hors champ elimine tout son sous-arbre + // d'un coup. C'est ce qui rend le culling par quadtree bien moins cher qu'un + // test par tuile a plat. + if (!frustum.intersectsAABB(node.boundsMin, node.boundsMax)) { + return; + } + + const float distance = distanceToAABB(cameraPosition, node.boundsMin, node.boundsMax); + + // On descend tant que le niveau INFERIEUR a encore de la portee ici. + const bool refine = (node.level > 0) && (distance < ranges_[node.level - 1]); + + if (refine) { + bool descended = false; + for (int i = 0; i < 4; ++i) { + if (node.children[i] >= 0) { + selectRecursive(static_cast(node.children[i]), cameraPosition, + frustum, out); + descended = true; + } + } + if (descended) { + return; + } + // Aucun fils : ne devrait pas arriver (un noeud existe parce qu'il couvre + // de la grille, donc au moins un quadrant en couvre aussi). On retombe + // sur le dessin du noeud lui-meme plutot que de laisser un trou. + } + + SelectedNode selected; + selected.nodeIndex = nodeIndex; + selected.level = node.level; + selected.morphStart = ranges_[node.level] * params_.morphStartRatio; + selected.morphEnd = ranges_[node.level] * params_.morphEndRatio; + selected.distance = distance; + out.push_back(selected); +} + +TerrainQuadtree::SelectedNode TerrainQuadtree::describeNode( + uint32_t nodeIndex, const glm::vec3& cameraPosition) const { + const Node& node = nodes_[nodeIndex]; + + // Exactement le calcul de la fin de selectRecursive : un noeud dessine par + // repli doit etre decrit comme s'il avait ete selectionne normalement, sans + // quoi sa bande de morphing differerait de celle qu'il aurait eue une frame + // plus tot, ce qui se verrait comme un saut de geometrie. + SelectedNode selected; + selected.nodeIndex = nodeIndex; + selected.level = node.level; + selected.morphStart = ranges_[node.level] * params_.morphStartRatio; + selected.morphEnd = ranges_[node.level] * params_.morphEndRatio; + selected.distance = distanceToAABB(cameraPosition, node.boundsMin, node.boundsMax); + return selected; +} + +std::string TerrainQuadtree::describe() const { + const float leafWorldSize = static_cast(params_.nodeCells) * heightmap_.spacing(); + std::string text = + "Quadtree terrain : " + std::to_string(nodes_.size()) + " noeuds, " + + std::to_string(static_cast(rootLevel_) + 1) + " niveaux (0.." + + std::to_string(static_cast(rootLevel_)) + "), " + + std::to_string(params_.nodeCells) + " cellules par cote et " + + std::to_string(trianglesPerNode()) + " triangles par noeud, tuile de niveau 0 = " + + std::to_string(static_cast(leafWorldSize)) + " m. Portees :"; + for (uint8_t level = 0; level <= rootLevel_; ++level) { + text += " L" + std::to_string(static_cast(level)) + "<=" + + std::to_string(static_cast(ranges_[level])) + "m"; + } + return text; +} + +} // namespace vercora diff --git a/src/world/TerrainQuadtree.hpp b/src/world/TerrainQuadtree.hpp new file mode 100644 index 0000000..ae47ac3 --- /dev/null +++ b/src/world/TerrainQuadtree.hpp @@ -0,0 +1,186 @@ +#pragma once + +#include "core/Frustum.hpp" + +#include + +#include +#include +#include + +namespace vercora { + +class Heightmap; + +// Quadtree de terrain + selection de niveau de detail par distance (CDLOD) + +// frustum culling. +// +// PHASE 10. Motivation, mesuree en Phase 9 : le moteur envoyait UN SEUL +// maillage entier a chaque image, donc un cout proportionnel a la SURFACE du +// terrain (247 -> 67 -> 12 FPS pour 1 -> 4 -> 25 km2), alors que le joueur n'en +// voit qu'une fraction infime. +// +// --- Structure ------------------------------------------------------------- +// La grille d'altitudes est decoupee en noeuds carres. Chaque noeud est TOUJOURS +// maille avec le meme nombre de sommets (nodeCells + 1 par cote, 65 par defaut) : +// ce qui change d'un niveau a l'autre, c'est le PAS d'echantillonnage. +// +// niveau 0 (feuille) : pas 1 echantillon, couvre nodeCells cellules +// niveau L : pas 2^L echantillons, couvre nodeCells * 2^L cellules +// +// Un noeud de niveau L a donc exactement le meme cout GPU qu'une feuille tout en +// couvrant 4^L fois plus de terrain : c'est tout le principe. La racine est le +// plus petit niveau dont l'emprise couvre la grille entiere. +// +// Les noeuds qui tombent entierement HORS de la grille ne sont pas crees ; ceux +// qui depassent partiellement voient leurs indices ECRETES sur le bord (les +// sommets excedentaires se superposent au bord, ce qui produit des triangles +// degeneres invisibles plutot qu'une "etagere" plate au-dela du terrain). +// +// --- Selection de LOD ------------------------------------------------------ +// Une portee par niveau, qui DOUBLE a chaque niveau : +// range[L] = rangeFactor * tailleMonde(noeud de niveau L) +// Comme la taille d'un noeud double elle aussi, range[L] = range[0] * 2^L. +// +// La descente part de la racine : +// - noeud invisible (frustum) -> abandonne, rien dessous +// - niveau 0, ou camera hors de range[L-1] -> le noeud est DESSINE tel quel +// - sinon -> on descend dans les 4 fils +// Le resultat est un anneau concentrique de niveaux autour de la camera, avec la +// pleine resolution (pas de 1 m) au contact immediat. +// +// --- Geomorphing ----------------------------------------------------------- +// Chaque sommet porte AUSSI sa position dans la grille du niveau superieur (voir +// renderer/TerrainNodeMesh.hpp). Le vertex shader interpole entre les deux selon +// la distance du sommet a la camera, dans la bande [morphStart, morphEnd] que +// cette classe calcule par niveau. Deux consequences : +// - pas de "popping" au changement de niveau : la geometrie fine a DEJA pris +// la forme de la grossiere quand la bascule a lieu ; +// - pas de fissure entre deux noeuds de niveaux differents : au-dela de +// range[L], un noeud de niveau L est entierement morphe sur la grille L+1, +// et son voisin de niveau L+1 y est encore a morph = 0, donc sur la meme +// grille. Les deux bords coincident exactement. +// C'est pour cette derniere raison que morphStart doit rester >= range[L] / 2. +class TerrainQuadtree { +public: + struct Params { + // Cellules par cote d'un noeud de niveau 0. Fixe le cout GPU d'un noeud + // (nodeCells^2 * 2 triangles) et la granularite du culling. 64 -> 8192 + // triangles et 4225 sommets par noeud : assez gros pour que le cout par + // draw call reste negligeable, assez petit pour que le frustum culling + // morde vraiment. + // DOIT etre une puissance de deux (l'ecretage du morphing suppose que la + // grille du niveau superieur s'obtient en ne gardant qu'un indice sur 2). + uint32_t nodeCells = 64; + + // Portee du niveau 0, exprimee en MULTIPLES de la taille monde d'un + // noeud de niveau 0. 3 = "on garde la pleine resolution jusqu'a environ + // trois largeurs de tuile", soit ~192 m au pas de 1 m. + float rangeFactor = 3.0f; + + // Bande de morphing, en fraction de range[L] : le geomorphing commence a + // morphStartRatio * range[L] et est termine a morphEndRatio * range[L]. + // morphStartRatio DOIT rester > 0.5 (voir l'argument anti-fissure + // ci-dessus) et morphEndRatio <= 1. + float morphStartRatio = 0.70f; + float morphEndRatio = 0.95f; + }; + + // Un noeud du quadtree. Les bornes sont en espace MONDE (celui des sommets + // produits par TerrainNodeMesh), pretes pour le culling et la distance. + struct Node { + uint32_t ix0 = 0; // indice de grille du coin nord-ouest + uint32_t iz0 = 0; + uint32_t span = 0; // cellules couvertes par cote (avant ecretage) + uint32_t stride = 0; // pas d'echantillonnage = span / nodeCells = 2^level + uint8_t level = 0; // 0 = feuille, pleine resolution + + // Indices dans nodes_, -1 si le fils n'existe pas (hors grille). + int32_t children[4] = { -1, -1, -1, -1 }; + + // PHASE 12 : indice du pere, -1 pour la racine. Sert au REPLI SUR + // L'ANCETRE : quand une tuile selectionnee n'est pas encore construite, + // on remonte cette chaine jusqu'a une tuile deja residente (donc de + // resolution inferieure, mais couvrant la meme surface) et on dessine + // celle-la plutot que de laisser un trou. Voir TerrainStreamer. + int32_t parent = -1; + + glm::vec3 boundsMin{0.0f}; + glm::vec3 boundsMax{0.0f}; + }; + + // Un noeud retenu pour cette frame. + struct SelectedNode { + uint32_t nodeIndex = 0; + uint8_t level = 0; + // Bande de geomorphing en metres, poussee telle quelle au vertex shader. + float morphStart = 0.0f; + float morphEnd = 0.0f; + // Distance camera -> boite du noeud : sert a servir les noeuds les plus + // proches en premier quand le budget de construction d'une frame est + // sature (les trous eventuels sont alors repousses vers l'horizon). + float distance = 0.0f; + }; + + // Construit l'arbre a partir d'une grille DEJA CHARGEE. La Heightmap n'est ni + // copiee ni possedee : elle reste la source unique des altitudes, aussi bien + // pour le rendu que pour la COLLISION (voir la note de decouplage dans + // MEMORY.md). L'arbre n'en garde que des bornes. + // Lance std::runtime_error si les parametres sont inexploitables. + TerrainQuadtree(const Heightmap& heightmap, const Params& params = {}); + + // Remplit `out` avec les noeuds a dessiner, tries du plus proche au plus + // lointain. `out` est vide au prealable ; sa capacite est conservee. + void select(const glm::vec3& cameraPosition, const Frustum& frustum, + std::vector& out) const; + + const Node& node(uint32_t index) const { return nodes_[index]; } + + // PHASE 12. Indice du pere d'un noeud, ou -1 s'il n'en a pas (racine). + int32_t parentIndex(uint32_t index) const { return nodes_[index].parent; } + + // PHASE 12. Renseigne un SelectedNode pour un noeud QUELCONQUE, hors de la + // descente de select(). Sert au repli sur l'ancetre : celui-ci est dessine + // alors que la selection ne l'avait pas retenu, mais il lui faut quand meme + // sa bande de geomorphing et sa distance. + SelectedNode describeNode(uint32_t nodeIndex, const glm::vec3& cameraPosition) const; + uint32_t nodeCount() const { return static_cast(nodes_.size()); } + uint8_t rootLevel() const { return rootLevel_; } + uint32_t nodeCells() const { return params_.nodeCells; } + const Params& params() const { return params_; } + + // Portee (en unites monde) du niveau L. Exposee pour les tests et les logs. + float range(uint8_t level) const { return ranges_[level]; } + + // Nombre de triangles qu'un noeud dessine, quel que soit son niveau. + uint32_t trianglesPerNode() const { + return params_.nodeCells * params_.nodeCells * 2; + } + + // Resume lisible, journalise au demarrage. + std::string describe() const; + +private: + // Cree recursivement le sous-arbre et renvoie son indice, ou -1 si le noeud + // est entierement hors de la grille. + int32_t build(uint32_t ix0, uint32_t iz0, uint32_t span, uint8_t level); + + // Min/max des altitudes sur la region ECRETEE d'un noeud feuille. + void leafBounds(const Node& node, float* minY, float* maxY) const; + + void selectRecursive(uint32_t nodeIndex, const glm::vec3& cameraPosition, + const Frustum& frustum, std::vector& out) const; + + const Heightmap& heightmap_; + Params params_; + + std::vector nodes_; + uint32_t rootIndex_ = 0; + uint8_t rootLevel_ = 0; + uint32_t cells_ = 0; // resolution - 1 + + // ranges_[L] = portee du niveau L. Dimensionne a rootLevel_ + 1. + std::vector ranges_; +}; + +} // namespace vercora diff --git a/src/world/Tree.cpp b/src/world/Tree.cpp new file mode 100644 index 0000000..2e33756 --- /dev/null +++ b/src/world/Tree.cpp @@ -0,0 +1,46 @@ +#include "world/Tree.hpp" + +#include + +namespace vercora { + +glm::mat4 Tree::modelMatrix() const { + // Arbre debout : le mesh unite est oriente puis mis a l'echelle de sa + // hauteur reelle. Rotation + echelle UNIFORME = mat3(model) reste une normal + // matrix valide (contrat de DrawItem). + const glm::mat4 standing = + glm::scale(glm::rotate(glm::translate(glm::mat4(1.0f), base), + yaw, glm::vec3(0.0f, 1.0f, 0.0f)), + glm::vec3(height)); + + const bool tilted = (state == TreeState::Falling || state == TreeState::Settling); + if (!tilted || fallAngle <= 0.0f) { + return standing; + } + + // Chute : rotation MONDE autour de la charniere (le trait de coupe). + // + // L'axe est horizontal et perpendiculaire a la direction de chute. On veut + // qu'un angle croissant couche l'arbre VERS fallDirection : en notant f + // cette direction et Y la verticale, la derivee de Y par rotation autour + // d'un axe A vaut A x Y. Il faut donc A x Y = f, ce que satisfait + // A = (f.z, 0, -f.x). Se tromper de signe ici fait tomber l'arbre a + // l'exact oppose de la zone degagee - erreur silencieuse et tres visible. + const glm::vec3 axis(fallDirection.z, 0.0f, -fallDirection.x); + const glm::vec3 pivot = hinge(); + + const glm::mat4 aboutHinge = + glm::translate(glm::mat4(1.0f), pivot) * + glm::rotate(glm::mat4(1.0f), fallAngle, axis) * + glm::translate(glm::mat4(1.0f), -pivot); + + return aboutHinge * standing; +} + +glm::mat4 Tree::stumpMatrix() const { + return glm::scale(glm::rotate(glm::translate(glm::mat4(1.0f), base), + yaw, glm::vec3(0.0f, 1.0f, 0.0f)), + glm::vec3(height)); +} + +} // namespace vercora diff --git a/src/world/Tree.hpp b/src/world/Tree.hpp new file mode 100644 index 0000000..910f6df --- /dev/null +++ b/src/world/Tree.hpp @@ -0,0 +1,108 @@ +#pragma once + +#include "world/TreeMesh.hpp" +#include "world/TreeSpecies.hpp" + +#include + +namespace vercora { + +// Proportions partagees par TOUS les arbres de la scene. Une seule valeur pour +// tout le monde, volontairement : le mesh d'arbre est genere une fois avec ces +// proportions et instancie N fois (voir la convention du mesh unite dans +// TreeMesh.hpp), donc un arbre qui aurait d'autres proportions aurait besoin de +// son propre mesh. C'est aussi ce qui garantit que la souche s'emboite pile a +// l'endroit de la coupe. +inline const TreeProportions kTreeProportions{}; + +// Cycle de vie d'un arbre. La physique de chute ne fait que faire avancer cet +// etat ; le rendu, lui, se contente de le lire. +// +// Settling s'intercale entre Falling et Fallen depuis la Phase 6. En Phase 5, +// l'arbre disparaissait NET a l'instant ou son angle atteignait 90 degres et +// toutes les buches apparaissaient d'un coup : on ne voyait jamais l'arbre +// couche, ce qui se lisait comme un bug d'affichage plutot que comme un +// abattage. Pendant Settling, l'arbre EST dessine, pose au sol, en train +// d'amortir son impact ; ce n'est qu'ensuite qu'il se debite, buche par buche. +enum class TreeState { + Standing, // debout, abattable + Falling, // bascule en cours autour de la charniere + Settling, // vient de toucher le sol : couche, dessine, en train de s'immobiliser + Fallen, // debite : l'arbre n'est plus dessine, la souche et les buches le sont +}; + +// Un arbre pose sur le terrain. +// +// La geometrie n'est PAS stockee ici : un arbre n'est qu'une position, une +// taille et un etat. C'est tout l'interet du couple MeshHandle/DrawItem - une +// foret de 500 arbres, c'est un seul mesh sur le GPU et 500 matrices. +struct Tree { + // Pied du tronc, en coordonnees monde, pose sur la surface du terrain. + glm::vec3 base{0.0f}; + + // Hauteur totale en unites monde. Sert aussi de facteur d'echelle UNIFORME + // du mesh unite : toutes les cotes ci-dessous s'en deduisent. + float height = 7.0f; + + // Orientation autour de Y, en radians. Purement visuel (le mesh n'est pas a + // symetrie de revolution : ses 8 facettes le sont a 45 degres pres), mais + // suffit a ce que deux arbres voisins ne paraissent pas clones. + float yaw = 0.0f; + + TreeState state = TreeState::Standing; + + // PHASE 26 : l'ESSENCE. Elle decide de deux choses a la fois, et c'est tout + // l'interet de la porter ici plutot qu'en deux endroits : + // * quel MESH est dessine (conifere ou feuillu, world/TreeMesh.hpp) ; + // * si l'arbre donne de la RESINE (world/Resin.hpp). + // La Phase 22 tirait le second d'un hachage de l'indice de l'arbre, sans + // aucun rapport avec le premier, et notait elle-meme la dette : « un joueur + // ne peut pas VOIR quel arbre est resineux avant d'essayer ». Il le voit + // desormais, parce que les deux lisent ce champ. + // + // Ce n'est PAS une seconde source de verite : le champ est rempli au moment + // de la plantation par treeSpeciesAt(), qui est aussi ce qu'appelle le semis + // de decor. La memoriser evite seulement de la recalculer a chaque image. + TreeSpecies species = TreeSpecies::Conifer; + + // --- Etat de chute (etape 2) ------------------------------------------- + // Direction horizontale normalisee vers laquelle l'arbre bascule, choisie + // par Forest::evaluateClearance au moment de l'abattage. + glm::vec3 fallDirection{1.0f, 0.0f, 0.0f}; + // Angle depuis la verticale, en radians. 0 = debout, pi/2 = couche. + float fallAngle = 0.0f; + // Vitesse angulaire courante, en rad/s. + float fallRate = 0.0f; + + // Temps ecoule depuis l'impact au sol, en secondes. Ne sert que pendant + // Settling : il pilote l'amortissement du rebond puis le passage au debitage. + float settleTime = 0.0f; + + // --- Cotes derivees, en unites monde ------------------------------------ + float trunkRadius() const { return kTreeProportions.trunkRadius * height; } + float crownRadius() const { return kTreeProportions.crownRadius * height; } + float stumpHeight() const { return kTreeProportions.stumpHeight * height; } + + // Point autour duquel l'arbre pivote pendant sa chute : le sommet de la + // souche, c'est-a-dire le trait de coupe. + glm::vec3 hinge() const { return base + glm::vec3(0.0f, stumpHeight(), 0.0f); } + + // Transformation du mesh d'arbre unite vers le monde, etat de chute inclus. + glm::mat4 modelMatrix() const; + + // Transformation du mesh de souche unite vers le monde. Independante de + // l'etat de chute : la souche ne bouge pas. + glm::mat4 stumpMatrix() const; + + // Rayon du CYLINDRE DE COLLISION et altitude de son sommet, en monde. + // Debout, l'obstacle est le tronc sur toute sa hauteur ; une fois l'arbre + // coupe, il ne reste que la souche. Le houppier n'entre jamais dans le + // volume de collision : sa base est a 35 % de la hauteur de l'arbre, donc + // tres au-dessus de la tete du joueur, et on doit pouvoir marcher dessous. + float colliderRadius() const { return trunkRadius(); } + float colliderTopY() const { + return base.y + (state == TreeState::Standing ? height : stumpHeight()); + } +}; + +} // namespace vercora diff --git a/src/world/TreeMesh.cpp b/src/world/TreeMesh.cpp new file mode 100644 index 0000000..312cbd1 --- /dev/null +++ b/src/world/TreeMesh.cpp @@ -0,0 +1,340 @@ +#include "world/TreeMesh.hpp" + +#include + +#include +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; + +// Teintes des sommets. Les meshes d'arbre passent par le materiau "Object" +// (cube.vert/frag) : leur couleur vient donc de la COULEUR DE SOMMET, pas du +// shader. Aucune texture, aucun fichier - c'est le point de cette phase. +const glm::vec3 kBarkColor {0.30f, 0.21f, 0.14f}; // ecorce +const glm::vec3 kCutWoodColor {0.74f, 0.61f, 0.42f}; // bois frais coupe +const glm::vec3 kFoliageLow {0.13f, 0.30f, 0.16f}; // etage bas, a l'ombre +const glm::vec3 kFoliageHigh {0.19f, 0.40f, 0.20f}; // etage haut, expose +const glm::vec3 kBranchColor {0.24f, 0.17f, 0.11f}; + +// PHASE 26 : le feuillu. Teintes franchement plus CLAIRES et plus JAUNES que +// celles du conifere - un hetre ne rend pas le vert bleute d'un epicea, et c'est +// le second indice de lecture apres la silhouette. Elles restent dans la meme +// famille de valeurs (rien de fluorescent) : ce qui doit se voir est une +// dominante de versant, pas un damier. +const glm::vec3 kBroadleafLow {0.22f, 0.36f, 0.15f}; +const glm::vec3 kBroadleafHigh {0.38f, 0.55f, 0.21f}; + +// Elargissement du houppier du feuillu par rapport a celui du conifere. 1,45 : +// un houppier de feuillu est nettement plus large que haut, et c'est ce rapport +// qui porte la silhouette de loin, quand les facettes ne se distinguent plus. +constexpr float kBroadleafCrownWidening = 1.45f; + +// Anneaux du houppier arrondi. 5 anneaux + le cone de fermeture donnent une +// boule lisible pour ~100 triangles : le meme ordre de grandeur que le conifere +// (qui en fait 32 pour son houppier), donc aucun poste de cout nouveau. En +// dessous de 4 la boule se lit comme un tonneau. +constexpr uint32_t kBroadleafRings = 5; + +// Hauteur relative, dans la bande du houppier, ou commence le premier anneau. +// Non nulle : le profil elliptique vaut zero a t = 0, et un houppier qui +// commencerait par un rayon nul laisserait voir le raccord au tronc. +constexpr float kBroadleafBaseT = 0.18f; + +// Ajoute la SURFACE LATERALE d'un tronc de cone d'axe Y, entre les cercles +// (y0, r0) et (y1, r1). Sommets partages entre secteurs voisins et normales +// radiales : le tronc parait rond malgre ses 8 cotes, ce qui est exactement ce +// qu'on veut pour un cylindre (a l'inverse du houppier, volontairement facette). +// +// Normale exacte de la surface reglee, et non (cos, 0, sin) : sur un cone la +// normale est inclinee. La negliger donnerait un eclairage faux sur un tronc +// conique, d'autant plus visible que la lumiere est rasante. +void appendTube(MeshData& mesh, float y0, float r0, float y1, float r1, + uint32_t sides, const glm::vec3& color) { + const auto base = static_cast(mesh.vertices.size()); + + const float dy = y1 - y0; + const float dr = r1 - r0; + + for (uint32_t i = 0; i < sides; ++i) { + const float angle = kTwoPi * static_cast(i) / static_cast(sides); + const float c = std::cos(angle); + const float s = std::sin(angle); + + // Voir la derivation dans le commentaire ci-dessus : la normale sortante + // vaut (dy*cos, -dr, dy*sin), normalisee. + const glm::vec3 normal = glm::normalize(glm::vec3(dy * c, -dr, dy * s)); + + Vertex bottom{}; + bottom.pos = { r0 * c, y0, r0 * s }; + bottom.color = color; + bottom.normal = normal; + mesh.vertices.push_back(bottom); + + Vertex top{}; + top.pos = { r1 * c, y1, r1 * s }; + top.color = color; + top.normal = normal; + mesh.vertices.push_back(top); + } + + // Deux sommets par secteur : indice 2*i = bas, 2*i+1 = haut. Le modulo + // referme l'anneau sur le premier secteur sans dupliquer de sommet (aucune + // couture a gerer : ces meshes n'ont pas d'UV). + for (uint32_t i = 0; i < sides; ++i) { + const uint32_t next = (i + 1) % sides; + const uint32_t b0 = base + 2 * i; + const uint32_t t0 = b0 + 1; + const uint32_t b1 = base + 2 * next; + const uint32_t t1 = b1 + 1; + + // Enroulement anti-horaire vu de l'EXTERIEUR (meme convention que le + // cube de la Phase 1). Le culling est desactive dans Pipeline, donc + // l'ordre n'est pas critique, mais il reste correct pour l'activer. + mesh.indices.insert(mesh.indices.end(), { b0, t0, t1 }); + mesh.indices.insert(mesh.indices.end(), { b0, t1, b1 }); + } +} + +// Ajoute un disque plein d'axe Y a l'altitude y. upward = true : le disque +// regarde vers +Y (dessus de souche), false : vers -Y (dessous d'un houppier). +// Sans ces disques, le culling etant desactive, on verrait l'interieur du cone, +// eclaire par des normales tournees a l'envers. +void appendDisc(MeshData& mesh, float y, float radius, uint32_t sides, + bool upward, const glm::vec3& color) { + const auto base = static_cast(mesh.vertices.size()); + const glm::vec3 normal = upward ? glm::vec3(0.0f, 1.0f, 0.0f) + : glm::vec3(0.0f, -1.0f, 0.0f); + + Vertex center{}; + center.pos = { 0.0f, y, 0.0f }; + center.color = color; + center.normal = normal; + mesh.vertices.push_back(center); + + for (uint32_t i = 0; i < sides; ++i) { + const float angle = kTwoPi * static_cast(i) / static_cast(sides); + Vertex rim{}; + rim.pos = { radius * std::cos(angle), y, radius * std::sin(angle) }; + rim.color = color; + rim.normal = normal; + mesh.vertices.push_back(rim); + } + + for (uint32_t i = 0; i < sides; ++i) { + const uint32_t a = base + 1 + i; + const uint32_t b = base + 1 + (i + 1) % sides; + // (centre, i, i+1) tourne dans le sens anti-horaire vu de DESSOUS ; + // l'ordre s'inverse donc pour un disque tourne vers le haut. + if (upward) { + mesh.indices.insert(mesh.indices.end(), { base, b, a }); + } else { + mesh.indices.insert(mesh.indices.end(), { base, a, b }); + } + } +} + +// Ajoute un cone d'axe Y, base (yBase, radius) et sommet (yApex, 0), FACETTE : +// chaque triangle possede ses trois sommets et une normale unique. Contrairement +// au tronc, on veut ici des facettes nettes - c'est ce qui donne au houppier sa +// silhouette bas-poly lisible plutot qu'une bougie fondue. Ca resout aussi le +// probleme de la normale au sommet du cone, qui n'est pas definie si on partage +// le sommet entre tous les secteurs. +void appendFacetedCone(MeshData& mesh, float yBase, float radius, float yApex, + uint32_t sides, const glm::vec3& color) { + for (uint32_t i = 0; i < sides; ++i) { + const float a0 = kTwoPi * static_cast(i) / static_cast(sides); + const float a1 = kTwoPi * static_cast(i + 1) / static_cast(sides); + + const glm::vec3 p0{ radius * std::cos(a0), yBase, radius * std::sin(a0) }; + const glm::vec3 p1{ radius * std::cos(a1), yBase, radius * std::sin(a1) }; + const glm::vec3 apex{ 0.0f, yApex, 0.0f }; + + // Normale de la facette. L'ordre (p0, apex, p1) est anti-horaire vu de + // l'exterieur, donc ce produit vectoriel sort du cone. + const glm::vec3 normal = glm::normalize(glm::cross(apex - p0, p1 - p0)); + + const auto base = static_cast(mesh.vertices.size()); + for (const glm::vec3& position : { p0, apex, p1 }) { + 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 }); + } +} + +// Bascule un mesh genere le long de +Y pour qu'il s'etende le long de +X. +// Rotation de -90 degres autour de Z : (x, y) -> (y, -x). Appliquee aux +// positions ET aux normales (c'est une rotation pure, donc la meme matrice +// convient aux deux - c'est precisement l'argument de la normal matrix). +// Permet de reutiliser appendTube/appendDisc pour une buche couchee. +void layDownAlongX(MeshData& mesh) { + for (Vertex& vertex : mesh.vertices) { + vertex.pos = { vertex.pos.y, -vertex.pos.x, vertex.pos.z }; + vertex.normal = { vertex.normal.y, -vertex.normal.x, vertex.normal.z }; + } +} + +void validateProportions(const TreeProportions& p) { + if (p.sides < 3) { + throw std::runtime_error("TreeMesh : il faut au moins 3 cotes pour former un volume."); + } + if (p.trunkRadius <= 0.0f || p.crownRadius <= 0.0f) { + throw std::runtime_error("TreeMesh : rayons de tronc et de houppier strictement positifs attendus."); + } + if (p.stumpHeight <= 0.0f || p.stumpHeight >= p.crownBase || p.crownBase >= 1.0f) { + throw std::runtime_error( + "TreeMesh : l'ordre 0 < stumpHeight < crownBase < 1 doit etre respecte " + "(la charniere de chute doit se situer sous le houppier)."); + } +} + +// Cylindre couche le long de X, centre sur l'origine, avec ses deux faces de +// coupe. Facteur commun a la buche et a la branche. +MeshData lyingCylinder(float length, float radius, uint32_t sides, + const glm::vec3& sideColor, const glm::vec3& capColor, + std::string name) { + MeshData mesh; + mesh.name = std::move(name); + + const float half = 0.5f * length; + appendTube(mesh, -half, radius, half, radius, sides, sideColor); + appendDisc(mesh, half, radius, sides, /*upward=*/true, capColor); + appendDisc(mesh, -half, radius, sides, /*upward=*/false, capColor); + + layDownAlongX(mesh); + return mesh; +} + +} // namespace + +MeshData treeMeshData(const TreeProportions& p) { + validateProportions(p); + + MeshData mesh; + mesh.name = "arbre synthetique (Phase 5)"; + + // --- Tronc -------------------------------------------------------------- + // Il monte legerement AU-DELA du bas du houppier : sans ce recouvrement, le + // raccord entre le cone et le tronc laisse voir un anneau de ciel des que la + // camera passe au-dessus. + const float trunkTop = p.crownBase + 0.08f; + appendTube(mesh, 0.0f, p.trunkRadius, trunkTop, p.topRadius, p.sides, kBarkColor); + + // --- Houppier : deux cones empietant l'un sur l'autre -------------------- + // Deux etages plutot qu'un seul cone : la silhouette d'un conifere se lit a + // la rupture de pente entre les etages, et ca ne coute que 8 triangles. + const float crownSpan = 1.0f - p.crownBase; + + const float lowerApex = p.crownBase + crownSpan * 0.62f; + appendFacetedCone(mesh, p.crownBase, p.crownRadius, lowerApex, p.sides, kFoliageLow); + appendDisc(mesh, p.crownBase, p.crownRadius, p.sides, /*upward=*/false, kFoliageLow); + + const float upperBase = p.crownBase + crownSpan * 0.45f; + const float upperRadius = p.crownRadius * 0.62f; + appendFacetedCone(mesh, upperBase, upperRadius, 1.0f, p.sides, kFoliageHigh); + appendDisc(mesh, upperBase, upperRadius, p.sides, /*upward=*/false, kFoliageHigh); + + return mesh; +} + +MeshData broadleafTreeMeshData(const TreeProportions& p) { + validateProportions(p); + + MeshData mesh; + mesh.name = "feuillu synthetique (Phase 26)"; + + // --- Tronc : STRICTEMENT celui du conifere ------------------------------ + // Meme appel, memes rayons, meme recouvrement de 0,08. C'est ce qui permet a + // UNE souche de servir les deux essences (voir TreeMesh.hpp) : la souche + // interpole son rayon de coupe sur cette droite-la, et sur aucune autre. + const float trunkTop = p.crownBase + 0.08f; + appendTube(mesh, 0.0f, p.trunkRadius, trunkTop, p.topRadius, p.sides, kBarkColor); + + // --- Houppier : anneaux empiles sur un profil elliptique ---------------- + // Le houppier occupe la meme bande verticale que celui du conifere, mais il + // est PLUS LARGE (facteur ci-dessous) et surtout son rayon maximal est + // atteint au MILIEU de la bande, non a sa base. C'est toute la difference de + // lecture entre un cone et une boule : le conifere est le plus large en bas, + // le feuillu au centre. + const float crownSpan = 1.0f - p.crownBase; + const float maxRadius = p.crownRadius * kBroadleafCrownWidening; + + // Le profil r(t) = maxRadius * sqrt(1 - (2t - 1)^2) est un demi-cercle + // ecrase sur la bande : nul aux deux bouts, maximal au milieu. On ne l'evalue + // PAS jusqu'a t = 0 : un houppier de rayon nul a sa base laisserait voir le + // tronc nu sur toute la hauteur de raccord. On demarre donc a un rayon + // franc, ce que fait le decalage kBroadleafBaseT. + float previousY = 0.0f; + float previousRadius = 0.0f; + for (uint32_t ring = 0; ring <= kBroadleafRings; ++ring) { + const float t = kBroadleafBaseT + + (1.0f - kBroadleafBaseT) * + (static_cast(ring) / static_cast(kBroadleafRings)); + const float y = p.crownBase + crownSpan * t; + const float centred = 2.0f * t - 1.0f; + const float radius = maxRadius * std::sqrt(std::max(0.0f, 1.0f - centred * centred)); + + if (ring == 0) { + // Disque tourne vers le BAS qui ferme le houppier par en dessous : + // le culling etant desactive, sans lui on verrait l'interieur des + // anneaux, eclaire par des normales retournees. + appendDisc(mesh, y, radius, p.sides, /*upward=*/false, kBroadleafLow); + } else { + // Teinte interpolee du bas vers le haut : l'etage bas est a l'ombre + // du houppier, l'etage haut est expose. Meme intention que les deux + // teintes du conifere, en degrade continu puisque la forme l'est. + const glm::vec3 color = glm::mix(kBroadleafLow, kBroadleafHigh, t); + appendTube(mesh, previousY, previousRadius, y, radius, p.sides, color); + } + previousY = y; + previousRadius = radius; + } + + // Le dernier anneau a un rayon petit mais non nul : on le referme par un + // cone jusqu'a y = 1.0 exactement, pour que la convention unite tienne au + // sommet comme elle tient au pied. + appendFacetedCone(mesh, previousY, previousRadius, 1.0f, p.sides, kBroadleafHigh); + + return mesh; +} + +MeshData stumpMeshData(const TreeProportions& p) { + validateProportions(p); + + MeshData mesh; + mesh.name = "souche synthetique (Phase 5)"; + + // Le rayon au sommet de la souche est interpole sur la meme droite que le + // tronc de l'arbre : la souche est litteralement le bas de ce tronc, donc + // les diametres coincident au point de coupe. + const float trunkTop = p.crownBase + 0.08f; + const float t = p.stumpHeight / trunkTop; + const float cutRadius = p.trunkRadius + (p.topRadius - p.trunkRadius) * t; + + // Legerement enfoncee sous 0 : sur un terrain en pente, une souche posee + // pile a y = 0 laisse un croissant de vide du cote amont. + appendTube(mesh, -0.02f, p.trunkRadius, p.stumpHeight, cutRadius, p.sides, kBarkColor); + appendDisc(mesh, p.stumpHeight, cutRadius, p.sides, /*upward=*/true, kCutWoodColor); + + return mesh; +} + +MeshData logMeshData() { + return lyingCylinder(kLogLength, kLogRadius, 8, kBarkColor, kCutWoodColor, + "buche synthetique (Phase 5)"); +} + +MeshData branchMeshData() { + return lyingCylinder(kBranchLength, kBranchRadius, 6, kBranchColor, kBranchColor, + "branche synthetique (Phase 5)"); +} + +} // namespace vercora diff --git a/src/world/TreeMesh.hpp b/src/world/TreeMesh.hpp new file mode 100644 index 0000000..585ee32 --- /dev/null +++ b/src/world/TreeMesh.hpp @@ -0,0 +1,108 @@ +#pragma once + +#include "renderer/MeshData.hpp" + +#include + +namespace vercora { + +// Geometries synthetiques bas-poly de la Phase 5, generees EN CODE (aucun +// fichier, aucun telechargement), dans le meme MeshData que le cube en dur, le +// loader .obj et le terrain : la classe Mesh et le Renderer les consomment sans +// rien savoir de leur origine. +// +// --- Convention CANONIQUE, valable pour treeMeshData et stumpMeshData ------- +// Le mesh est genere "unite" : pied du tronc a l'origine, axe le long de +Y, +// hauteur totale exactement 1.0, et toutes les largeurs exprimees en fraction +// de cette hauteur. Une instance se place donc par +// translate(pied) * rotateY(orientation) * scale(hauteur reelle) +// c'est-a-dire une rotation suivie d'une echelle UNIFORME - exactement le +// contrat de DrawItem, qui autorise mat3(model) comme normal matrix. Un mesh +// deja a l'echelle obligerait au contraire a etirer separement la hauteur et le +// rayon pour varier la silhouette, donc a une echelle NON uniforme, donc a +// transporter une vraie normal matrix. Le choix du mesh unite est ce qui evite +// tout ce probleme. +// +// Consequence assumee : tous les arbres ont les memes PROPORTIONS, seule leur +// taille varie. La variete de silhouette viendra de plusieurs meshes distincts +// le jour ou ce sera un sujet, pas d'un etirement. + +// Proportions communes a l'arbre et a sa souche, en fraction de la hauteur +// totale de l'arbre. Regroupees ici parce que la souche doit imperativement +// avoir le meme rayon de tronc et la meme hauteur de coupe que l'arbre dont +// elle prend la place, sinon le raccord se voit. +struct TreeProportions { + // Rayon du tronc au pied. + float trunkRadius = 0.045f; + // Rayon du tronc juste sous le houppier (un tronc legerement conique se lit + // beaucoup mieux qu'un cylindre parfait, pour zero triangle de plus). + float topRadius = 0.028f; + // Hauteur a laquelle le tronc sort du sol nu et ou commence le houppier. + float crownBase = 0.35f; + // Rayon maximal du houppier. + float crownRadius = 0.22f; + // Hauteur de la souche laissee au sol apres l'abattage. C'est aussi la + // hauteur de la CHARNIERE autour de laquelle l'arbre bascule. + float stumpHeight = 0.045f; + + // Nombre de secteurs autour de l'axe. 8 = bas-poly assume, silhouette + // encore lisible, et un arbre complet reste sous les 200 triangles. + uint32_t sides = 8; +}; + +// Un conifere : tronc legerement conique + houppier en deux cones empiles. +// Le sommet du cone superieur est exactement a y = 1.0. +MeshData treeMeshData(const TreeProportions& proportions = {}); + +// --------------------------------------------------------------------------- +// PHASE 26 : le FEUILLU, seconde silhouette. +// --------------------------------------------------------------------------- +// Le paragraphe de convention ci-dessus annoncait que « la variete de silhouette +// viendra de plusieurs meshes distincts le jour ou ce sera un sujet, pas d'un +// etirement ». C'est ce jour-la : world/TreeSpecies.hpp decide desormais quelle +// essence pousse ou, et il lui faut deux formes a opposer. +// +// LE TRONC EST LE MEME, ET CE N'EST PAS UN RACCOURCI. La souche +// (stumpMeshData) interpole son rayon de coupe sur la droite du tronc de +// l'arbre ; donner au feuillu un autre tronc obligerait a une seconde souche, +// et surtout ferait que la souche laissee par un feuillu abattu ne coinciderait +// plus avec le trait de coupe. UNE souche sert les deux essences parce que les +// deux partagent exactement le meme tronc. Ce qui les distingue est le +// HOUPPIER, et c'est aussi ce qu'un joueur lit de loin. +// +// La silhouette : un houppier ARRONDI, fait d'anneaux empiles dont le rayon +// suit un profil elliptique, et LISSE (normales radiales partagees) la ou le +// conifere est FACETTE. L'opposition ne tient donc pas qu'au contour : les deux +// arbres n'accrochent pas la lumiere de la meme facon. +// +// Meme convention unite que treeMeshData : pied a l'origine, hauteur totale +// exactement 1.0, donc meme matrice d'instance et meme echelle uniforme. +MeshData broadleafTreeMeshData(const TreeProportions& proportions = {}); + +// La souche qui reste apres l'abattage : le bas du tronc, coupe net a +// proportions.stumpHeight, avec un disque de bois clair en haut. Meme +// convention unite que treeMeshData, donc meme echelle d'instance. +MeshData stumpMeshData(const TreeProportions& proportions = {}); + +// --- Objets ramassables au sol --------------------------------------------- +// Ceux-ci ne sont PAS a l'echelle unite : leurs dimensions sont absolues et +// fixes (une buche fait la meme taille quel que soit l'arbre dont elle vient). +// Une instance se pose donc par translate * rotate SANS aucune echelle, ce qui +// rend la normal matrix exacte au sens strict. + +// Une buche : cylindre couche le long de l'axe +X, centre sur l'origine, avec +// une face de coupe claire a chaque bout. +MeshData logMeshData(); + +// Une branche : meme forme, plus fine et plus courte, teinte plus sombre. +MeshData branchMeshData(); + +// Longueurs/rayons des objets ci-dessus, en unites monde. Exposes parce que le +// code de placement en a besoin pour poser les buches sur le sol sans qu'elles +// s'enfoncent ni flottent. +inline constexpr float kLogLength = 1.6f; +inline constexpr float kLogRadius = 0.16f; +inline constexpr float kBranchLength = 0.9f; +inline constexpr float kBranchRadius = 0.06f; + +} // namespace vercora diff --git a/src/world/TreeSpecies.cpp b/src/world/TreeSpecies.cpp new file mode 100644 index 0000000..cc24c04 --- /dev/null +++ b/src/world/TreeSpecies.cpp @@ -0,0 +1,96 @@ +#include "world/TreeSpecies.hpp" + +#include +#include + +namespace vercora { +namespace { + +// Hachage entier 32 bits (finalisateur de MurmurHash3). Meme fonction que celle +// employee ailleurs dans le projet pour transformer une clef en alea reproductible. +uint32_t mix(uint32_t h) { + h ^= h >> 16; + h *= 0x85EBCA6Bu; + h ^= h >> 13; + h *= 0xC2B2AE35u; + h ^= h >> 16; + return h; +} + +// Quantification de la position avant hachage, en metres. +// +// POURQUOI QUANTIFIER. Deux systemes demandent l'essence du MEME arbre par des +// chemins de calcul differents (Forest garde une position posee sur le terrain, +// Vegetation la reconstruit depuis sa cellule de semis). Hacher les bits bruts +// d'un float ferait dependre la reponse du dernier bit de mantisse, donc du +// chemin - et deux arbres au meme endroit pourraient etre d'essences +// differentes. Un pas de 25 cm est bien plus fin que l'espacement minimal entre +// deux pieds (ForestParams::minSpacing = 5,5 m ; une cellule de decor fait +// 24 m), donc il ne fusionne jamais deux arbres distincts, et bien plus gros que +// le bruit de calcul. +constexpr float kPositionQuantum = 0.25f; + +int32_t quantize(float value) { + return static_cast(std::floor(value / kPositionQuantum)); +} + +float clamp01(float value) { return std::clamp(value, 0.0f, 1.0f); } + +} // namespace + +const char* treeSpeciesName(TreeSpecies species) { + switch (species) { + case TreeSpecies::Conifer: return "resineux"; + case TreeSpecies::Broadleaf: return "feuillu"; + } + return "inconnu"; +} + +float coniferShareFor(float aspectExposure, const TreeSpeciesParams& params) { + // Exposition ecretee : une source qui renverrait n'importe quoi ne doit pas + // pouvoir sortir la part de sa plage. + const float exposure = std::clamp(aspectExposure, -1.0f, 1.0f); + + // Le SIGNE est le coeur de la regle : l'adret (exposure > 0) est plus chaud + // et plus sec, donc MOINS de resineux ; l'ubac, plus frais et plus humide, + // en porte davantage. C'est pour cela que le terme est soustrait. + const float share = params.coniferShareNeutral - params.aspectSwing * exposure; + + // Bornes appliquees dans l'ordre min puis max, et non par un clamp qui + // supposerait min <= max : un reglage incoherent doit donner une valeur + // valide plutot qu'un comportement non defini. + const float low = clamp01(params.coniferShareMin); + const float high = clamp01(std::max(params.coniferShareMax, low)); + return std::clamp(clamp01(share), low, high); +} + +TreeSpecies treeSpeciesAt(float worldX, float worldZ, float aspectExposure, + const TreeSpeciesParams& params) { + const float share = coniferShareFor(aspectExposure, params); + + // Tirage uniforme dans [0, 1) issu du hachage de la position et de la + // graine. Les deux coordonnees passent par des multiplicateurs impairs + // distincts avant d'etre melangees : sans cela, les points de la diagonale + // x = z se hacheraient tous pareil et une bande d'arbres identiques se + // verrait sur le terrain. + const uint32_t hx = static_cast(quantize(worldX)) * 0x9E3779B1u; + const uint32_t hz = static_cast(quantize(worldZ)) * 0x85EBCA77u; + const uint32_t h = mix(hx ^ mix(hz ^ params.seed)); + + // Division par 2^32 : le quotient est dans [0, 1), donc un `share` de 0 ne + // peut jamais rendre Conifer et un `share` de 1 le rend toujours. + const float draw = static_cast(h) * (1.0f / 4294967296.0f); + return (draw < share) ? TreeSpecies::Conifer : TreeSpecies::Broadleaf; +} + +TreeSpecies treeSpeciesAt(float worldX, float worldZ, + const AspectExposureSource* exposure, + const TreeSpeciesParams& params) { + // Source absente = exposition nulle. Voir le "contrat total" de + // AspectExposureSource : c'est ce qui rend la non-regression verifiable. + const float value = (exposure != nullptr) ? exposure->aspectExposureAt(worldX, worldZ) + : 0.0f; + return treeSpeciesAt(worldX, worldZ, value, params); +} + +} // namespace vercora diff --git a/src/world/TreeSpecies.hpp b/src/world/TreeSpecies.hpp new file mode 100644 index 0000000..e1af70c --- /dev/null +++ b/src/world/TreeSpecies.hpp @@ -0,0 +1,136 @@ +#pragma once + +#include + +namespace vercora { + +// =========================================================================== +// PHASE 26 : L'ESSENCE D'UN ARBRE, ET LE SEUL ENDROIT QUI LA DECIDE. +// =========================================================================== +// +// CE QUE CE FICHIER REFERME. world/Resin.hpp ecrivait, en Phase 22 : « Le jeu +// n'a AUCUNE notion d'essence d'arbre [...] un joueur ne peut pas VOIR quel +// arbre est resineux avant d'essayer ». La recolte de resine reposait donc sur +// un MARQUAGE ARBITRAIRE - un hachage de l'indice de l'arbre - sans aucun +// rapport avec ce qui etait dessine a l'ecran. C'etait la dette principale que +// cette phase-la assumait, et c'est elle qu'on referme ici. +// +// LE PRINCIPE : UNE SEULE SOURCE. L'essence est une FONCTION PURE de la +// position monde et d'une graine. Elle n'est stockee nulle part comme verite - +// Forest la memorise dans chaque arbre par commodite d'acces, Vegetation la +// met en cache avec sa cellule - mais les deux la tirent du MEME appel. Ce qui +// est resineux a l'oeil est donc resineux a la saignee, par construction et non +// par accord entre deux tables qu'il faudrait tenir a jour. +// +// LE FACTEUR : L'EXPOSITION ADRET / UBAC, DEJA CALCULEE AILLEURS. La Phase 23 +// a fait de WeatherSystem la seule autorite sur l'adret/ubac, et la Phase 25 l'a +// rendue visible sans la recalculer. Cette phase ne la recalcule pas davantage : +// elle la CONSOMME au travers de AspectExposureSource, dont l'unique +// implementation du jeu delegue a WeatherSystem::aspectExposureAt. +// +// POURQUOI UNE EXPOSITION "DE MIDI" ET NON CELLE DE L'INSTANT. Le signal +// d'adret de WeatherSample::aspectC depend du soleil COURANT : il tourne avec +// l'heure et s'eteint la nuit - c'est justement ce qui fait sa justesse pour la +// temperature. Une essence, elle, ne peut pas changer entre midi et minuit. Ce +// qu'il faut ici est la grandeur CLIMATIQUE : l'ensoleillement que ce versant +// recoit habituellement. WeatherSystem l'expose en evaluant EXACTEMENT le meme +// signal au soleil de midi. Une seule formule, deux instants d'evaluation. +// +// UNE TENDANCE, PAS UNE REGLE. Un versant nord n'est pas fait que d'epiceas et +// un versant sud que de hetres. Les bornes de TreeSpeciesParams interdisent le +// 0 % et le 100 % : sur l'adret le plus franc il reste des resineux, et +// reciproquement. Un joueur doit lire une DOMINANTE en levant les yeux, pas une +// frontiere. +// +// CE FICHIER NE CONNAIT NI VULKAN, NI LE TERRAIN, NI LA METEO : une position, +// une exposition, une graine. Entierement testable sans GPU. +// =========================================================================== + +// Les essences representees. Deux suffisent a porter l'opposition adret/ubac, +// et chacune a sa silhouette dans world/TreeMesh.hpp. +enum class TreeSpecies : uint8_t { + Conifer = 0, // sapin / epicea : silhouette conique, dominante en ubac + Broadleaf = 1, // hetre / erable : houppier arrondi, dominante en adret +}; + +inline constexpr int kTreeSpeciesCount = 2; + +// Nom francais, pour les journaux et les messages de jeu. +const char* treeSpeciesName(TreeSpecies species); + +// --------------------------------------------------------------------------- +// Source d'exposition adret / ubac. +// --------------------------------------------------------------------------- +// Meme patron que GroundCoverSource (Phase 17) : une interface minuscule qui +// permet a Forest et Vegetation d'etre semees SANS connaitre WeatherSystem, donc +// d'etre testables sans monter tout le systeme meteo. +// +// CONTRAT TOTAL, et il compte : une source ABSENTE (pointeur nul) vaut une +// exposition NULLE partout, donc la part de resineux neutre partout, donc +// exactement le comportement d'avant cette phase cote proportions. C'est ce qui +// rend la non-regression verifiable au lieu d'etre esperee. +class AspectExposureSource { +public: + virtual ~AspectExposureSource() = default; + + // Exposition CLIMATIQUE au point (worldX, worldZ), dans [-1, +1] : + // +1 = adret franc (versant au soleil), 0 = plat ou indifferent, + // -1 = ubac franc (versant a l'ombre). + // Doit etre STABLE dans le temps : c'est une propriete du relief, pas de + // l'heure qu'il est. + virtual float aspectExposureAt(float worldX, float worldZ) const = 0; +}; + +struct TreeSpeciesParams { + // Part de resineux sur un terrain SANS exposition marquee (plat, ou source + // absente). 0,55 reprend TEL QUEL l'ancien ResinParams::coniferShare : le + // reglage de la Phase 22 n'est pas perdu, il devient le point neutre autour + // duquel l'exposition fait pencher la balance. Sur ce massif, l'epicea et le + // sapin dominent l'etage montagnard sans etre seuls. + float coniferShareNeutral = 0.55f; + + // Amplitude de la tendance : de combien la part de resineux se deplace entre + // l'ubac franc et l'adret franc. 0,35 donne 0,90 en ubac et 0,20 en adret - + // une dominante nette des deux cotes, jamais une exclusivite. + float aspectSwing = 0.35f; + + // Bornes dures de la part de resineux. Elles ne mordent pas avec les valeurs + // ci-dessus ; elles sont la pour que RE-REGLER aspectSwing ne puisse pas, + // par inadvertance, transformer la tendance en regle stricte. Un versant + // monospecifique se verrait immediatement, et se verrait comme un bug. + float coniferShareMin = 0.10f; + float coniferShareMax = 0.92f; + + // Graine du tirage. Reprend celle de l'ancien ResinParams pour que le + // marquage ne soit pas rebattu sans raison, et reste DISTINCTE de celle du + // semis (ForestParams::seed, VegetationParams::seed) : changer ou poussent + // les arbres ne doit pas changer leur essence, et reciproquement. + uint32_t seed = 20260827u; +}; + +// L'essence de l'arbre qui pousse en (worldX, worldZ), sous l'exposition donnee. +// +// FONCTION PURE et DETERMINISTE : meme position, meme exposition, meme graine => +// meme essence, d'une execution a l'autre et d'un systeme a l'autre. C'est ce +// qui permet a Forest et a Vegetation d'y repondre pareil sans se parler, et ce +// qui rend les captures comparables. +// +// Le tirage porte sur la POSITION et non sur un indice : un indice n'existe que +// dans le systeme qui l'attribue, et les deux systemes n'en ont pas de commun. +TreeSpecies treeSpeciesAt(float worldX, float worldZ, float aspectExposure, + const TreeSpeciesParams& params = {}); + +// Meme chose, en allant chercher l'exposition dans la source (nulle = 0). +// Sucre destine aux appelants qui tiennent deja un AspectExposureSource*. +TreeSpecies treeSpeciesAt(float worldX, float worldZ, + const AspectExposureSource* exposure, + const TreeSpeciesParams& params = {}); + +// Part de resineux ATTENDUE pour une exposition donnee, dans [0, 1]. Exposee +// parce que c'est la grandeur que les tests headless verifient : on peut +// affirmer "plus de resineux en ubac" sur la LOI avant de le compter sur un +// echantillon, et l'ecart entre les deux est alors du bruit d'echantillonnage +// et non un desaccord. +float coniferShareFor(float aspectExposure, const TreeSpeciesParams& params = {}); + +} // namespace vercora diff --git a/src/world/Vegetation.cpp b/src/world/Vegetation.cpp new file mode 100644 index 0000000..b9546ce --- /dev/null +++ b/src/world/Vegetation.cpp @@ -0,0 +1,720 @@ +#include "world/Vegetation.hpp" + +#include "core/Frustum.hpp" +#include "core/HeightSampler.hpp" + +#include +#include +#include + +namespace vercora { +namespace { + +constexpr float kTwoPi = 6.28318530718f; + +// --- Aleatoire DETERMINISTE et sans etat ----------------------------------- +// Pas de std::mt19937 ici, volontairement. Un generateur a etat impose un ORDRE +// d'appel : la cellule (17, -42) ne donnerait le meme resultat que si toutes les +// cellules precedentes avaient ete tirees dans le meme ordre - ce qui est faux +// des que le joueur arrive par un autre chemin. Un HACHAGE, lui, ne depend que +// de ses entrees : la cellule (17, -42) donne toujours la meme foret, qu'on la +// decouvre en premier ou en dernier, et deux cellules voisines engendrees a des +// images differentes restent coherentes. C'est ce qui permet de ne rien stocker +// pour les 25 km2. +uint32_t hashCombine(uint32_t value) { + // Melangeur entier de Murmur3 : bon melange des bits pour trois operations. + value ^= value >> 16; + value *= 0x7feb352du; + value ^= value >> 15; + value *= 0x846ca68bu; + value ^= value >> 16; + return value; +} + +uint32_t cellHash(int32_t cx, int32_t cz, uint32_t seed, uint32_t stream) { + uint32_t h = seed; + h = hashCombine(h ^ static_cast(cx) * 0x9E3779B1u); + h = hashCombine(h ^ static_cast(cz) * 0x85EBCA77u); + h = hashCombine(h ^ (stream * 0xC2B2AE3Du)); + return h; +} + +// Flottant dans [0,1) tire du hachage. Les 24 bits de poids fort suffisent +// largement et evitent les artefacts de periodicite des bits de poids faible. +float unitFloat(uint32_t hash) { + return static_cast(hash >> 8) * (1.0f / 16777216.0f); +} + +// --- Bruit de valeur 2D ----------------------------------------------------- +// Utilise pour GROUPER l'herbe en touffes. Un simple tirage par emplacement +// donnerait une repartition de Poisson : uniforme a grande echelle, donc +// exactement l'aspect "un brin tous les deux centimetres" qu'on cherche a +// eviter. Il faut une grandeur CORRELEE SPATIALEMENT, c'est-a-dire un bruit. +// +// Bruit de VALEUR et non Perlin : Perlin interpole des gradients, ce qui donne +// un champ plus isotrope mais coute quatre produits scalaires par point. Ici le +// champ ne sert qu'a moduler une probabilite, jamais a etre regarde +// directement ; ses defauts (legere preference pour les axes de la grille) sont +// invisibles une fois traduits en presence ou absence de touffes. Deux octaves +// suffisent a casser la regularite de la grille du bruit lui-meme. +float valueNoise(float x, float z, uint32_t seed) { + const float fx = std::floor(x); + const float fz = std::floor(z); + const int32_t ix = static_cast(fx); + const int32_t iz = static_cast(fz); + const float tx = x - fx; + const float tz = z - fz; + + // Courbe de lissage de Perlin (6t^5 - 15t^4 + 10t^3) : ses derivees + // premiere ET seconde sont nulles aux noeuds, donc aucune arete visible aux + // frontieres de la grille du bruit. + const float sx = tx * tx * tx * (tx * (tx * 6.0f - 15.0f) + 10.0f); + const float sz = tz * tz * tz * (tz * (tz * 6.0f - 15.0f) + 10.0f); + + const float v00 = unitFloat(cellHash(ix, iz, seed, 1u)); + const float v10 = unitFloat(cellHash(ix + 1, iz, seed, 1u)); + const float v01 = unitFloat(cellHash(ix, iz + 1, seed, 1u)); + const float v11 = unitFloat(cellHash(ix + 1, iz + 1, seed, 1u)); + + return glm::mix(glm::mix(v00, v10, sx), glm::mix(v01, v11, sx), sz); +} + +float clusterNoise(float x, float z, float frequency, uint32_t seed) { + const float base = valueNoise(x * frequency, z * frequency, seed); + const float detail = valueNoise(x * frequency * 2.7f, z * frequency * 2.7f, seed ^ 0x5bf03635u); + return 0.68f * base + 0.32f * detail; +} + +// Rampe lineaire ecretee : 0 en dessous de `from`, 1 au-dessus de `to`. +float ramp(float value, float from, float to) { + if (to <= from) { + return value >= to ? 1.0f : 0.0f; + } + return glm::clamp((value - from) / (to - from), 0.0f, 1.0f); +} + +} // namespace + +Vegetation::Vegetation(const HeightSampler& terrain, const HeightSampler* cover, + const HeightSampler* canopyHeight, float terrainExtent, + const VegetationParams& params) + : terrain_(terrain), cover_(cover), canopyHeight_(canopyHeight), + terrainExtent_(terrainExtent), params_(params) { + if (params_.treeCell <= 0.0f || params_.grassCell <= 0.0f) { + throw std::runtime_error("Vegetation : taille de cellule nulle ou negative."); + } + if (params_.treeSlots == 0) { + throw std::runtime_error("Vegetation : treeSlots nul, aucun arbre possible."); + } + if (params_.treeDistanceNear > params_.treeDistanceFar) { + throw std::runtime_error( + "Vegetation : treeDistanceNear depasse treeDistanceFar. Le niveau de " + "detail de densite suppose que l'emplacement 0 porte le plus loin."); + } + if (params_.treeMinHeight <= 0.0f || params_.treeMaxHeight < params_.treeMinHeight) { + throw std::runtime_error("Vegetation : bornes de hauteur d'arbre incoherentes."); + } +} + +// --------------------------------------------------------------------------- +// Interrogation des cartes +// --------------------------------------------------------------------------- +float Vegetation::slopeAt(float worldX, float worldZ) const { + // Pas de sonde d'un metre : c'est la resolution de la heightmap la plus fine, + // donc la plus petite difference finie qui ait un sens. + const float h = terrain_.heightAt(worldX, worldZ); + const float dx = terrain_.heightAt(worldX + 1.0f, worldZ) - h; + const float dz = terrain_.heightAt(worldX, worldZ + 1.0f) - h; + return std::sqrt(dx * dx + dz * dz); +} + +float Vegetation::coverAt(float worldX, float worldZ) const { + if (cover_ != nullptr) { + return glm::clamp(cover_->heightAt(worldX, worldZ), 0.0f, 1.0f); + } + + // SUBSTITUT quand la carte LiDAR n'est pas disponible (terrain synthetique, + // ou dalle sans carte produite). On se rabat sur ce que le relief seul + // permet de dire : la foret de montagne s'arrete a une limite d'altitude et + // ne tient pas sur les parois. C'est GROSSIER et ca ne connait ni les + // pistes, ni les clairieres, ni les eboulis - toutes choses que la vraie + // carte, elle, restitue. D'ou le fait que ce soit un repli et non le + // comportement normal. + const float altitude = terrain_.heightAt(worldX, worldZ); + const float slope = slopeAt(worldX, worldZ); + const float byAltitude = 1.0f - ramp(altitude, 1650.0f, 1950.0f); + const float bySlope = 1.0f - ramp(slope, 0.7f, 1.2f); + return glm::clamp(byAltitude * bySlope, 0.0f, 1.0f); +} + +float Vegetation::canopyHeightAt(float worldX, float worldZ) const { + if (canopyHeight_ != nullptr) { + return std::max(0.0f, canopyHeight_->heightAt(worldX, worldZ)); + } + // Sans carte de canopee, une futaie moyenne de montagne. + return 18.0f; +} + +// --------------------------------------------------------------------------- +// Semis des arbres +// --------------------------------------------------------------------------- +Vegetation::Cell Vegetation::buildTreeCell(int32_t cx, int32_t cz) const { + Cell cell; + + const float cellSize = params_.treeCell; + const float baseX = static_cast(cx) * cellSize; + const float baseZ = static_cast(cz) * cellSize; + + // Marge sur le bord du terrain : au-dela, heightAt ne renvoie plus que la + // valeur ecretee du bord et un arbre y flotterait a plat. + const float usable = std::max(0.0f, terrainExtent_ - 2.0f); + + float minY = 0.0f; + float maxY = 0.0f; + bool first = true; + + cell.candidates.reserve(params_.treeSlots); + for (uint32_t slot = 0; slot < params_.treeSlots; ++slot) { + const uint32_t h0 = cellHash(cx, cz, params_.seed, slot * 4u + 100u); + const uint32_t h1 = cellHash(cx, cz, params_.seed, slot * 4u + 101u); + const uint32_t h2 = cellHash(cx, cz, params_.seed, slot * 4u + 102u); + const uint32_t h3 = cellHash(cx, cz, params_.seed, slot * 4u + 103u); + + const float x = baseX + unitFloat(h0) * cellSize; + const float z = baseZ + unitFloat(h1) * cellSize; + + if (std::abs(x) > usable || std::abs(z) > usable) { + continue; + } + + // --- Filtre par le COUVERT REEL ------------------------------------ + // C'est le coeur de la tache 2. La densite locale vaut 0 sous coverMin + // et 1 au-dessus de coverFull ; l'emplacement `slot` n'est retenu que si + // cette densite lui laisse la place. Comparer `slot` a `densite * slots` + // plutot que de tirer un des a chaque emplacement garantit que les + // emplacements sont retenus TOUJOURS DANS LE MEME ORDRE : c'est ce qui + // rend la portee par emplacement (plus bas) coherente, et ce qui evite + // qu'un arbre change d'identite quand la densite bouge d'un cheveu. + const float density = ramp(coverAt(x, z), params_.coverMin, params_.coverFull); + const float allowed = density * static_cast(params_.treeSlots); + if (static_cast(slot) >= allowed) { + continue; + } + + if (slopeAt(x, z) > params_.treeMaxSlope) { + continue; + } + + // --- Hauteur --------------------------------------------------------- + // La carte de canopee donne la hauteur du PLUS GRAND arbre de sa cellule + // de 5 m. Les arbres d'un meme bosquet se repartissent entre 55 % et + // 100 % de cette valeur : une futaie ou tous les sujets ont exactement la + // meme taille se voit immediatement (effet "brosse a dents"). + const float local = glm::clamp(canopyHeightAt(x, z), + params_.treeMinHeight, params_.treeMaxHeight); + const float height = local * (0.55f + 0.45f * unitFloat(h2)); + if (height < params_.treeMinHeight) { + continue; + } + + Candidate candidate; + candidate.position = { x, terrain_.heightAt(x, z), z }; + candidate.height = height; + candidate.yaw = unitFloat(h3) * kTwoPi; + candidate.variation = unitFloat(h2 ^ 0x9E3779B9u); + + // --- ESSENCE (PHASE 26) ------------------------------------------ + // NOTER L'ENDROIT : ici, et pas plus haut. Tous les filtres de PRESENCE + // - couvert LiDAR, pente, altitude, hauteur de canopee - ont deja + // statue ; l'emplacement EST retenu. L'exposition n'a donc aucun moyen + // d'ajouter ou de retirer un arbre, elle ne fait que dire lequel c'est. + // C'est la contrainte du chantier 4, et elle est tenue par la STRUCTURE + // du code plutot que par une intention : deplacer cet appel de vingt + // lignes vers le haut serait le seul moyen de la rompre. + candidate.species = treeSpeciesAt(x, z, aspectExposure_, params_.species); + + // --- Portee PROPRE a l'emplacement (niveau de detail de densite) ----- + // L'emplacement 0 porte a treeDistanceFar, le dernier a + // treeDistanceNear, les autres entre les deux. Consequence : de loin + // seuls les premiers emplacements de chaque cellule subsistent, donc la + // foret s'eclaircit progressivement au lieu de disparaitre d'un bloc, et + // chaque arbre a sa propre distance de fondu - il n'y a jamais de saut + // collectif. + const float t = params_.treeSlots > 1 + ? static_cast(slot) / static_cast(params_.treeSlots - 1) + : 0.0f; + candidate.maxDistance = glm::mix(params_.treeDistanceFar, + params_.treeDistanceNear, t); + + const float top = candidate.position.y + height; + if (first) { + minY = candidate.position.y; + maxY = top; + first = false; + } else { + minY = std::min(minY, candidate.position.y); + maxY = std::max(maxY, top); + } + cell.candidates.push_back(candidate); + } + + // Boite englobante de la cellule, pour le frustum culling. Une cellule vide + // recoit une boite plate a l'altitude du terrain : elle sera cullee ou non, + // sans consequence puisqu'elle ne produit rien. + if (first) { + const float y = terrain_.heightAt(baseX + 0.5f * cellSize, baseZ + 0.5f * cellSize); + minY = y; + maxY = y; + } + cell.boxMin = { baseX, minY, baseZ }; + cell.boxMax = { baseX + cellSize, maxY, baseZ + cellSize }; + return cell; +} + +const Vegetation::Cell& Vegetation::treeCell(int32_t cx, int32_t cz) { + const CellKey key{ cx, cz }; + auto found = cache_.find(key); + if (found != cache_.end()) { + return found->second; + } + return cache_.emplace(key, buildTreeCell(cx, cz)).first->second; +} + +void Vegetation::setAspectExposure(const AspectExposureSource* source) { + if (source == aspectExposure_) { return; } + aspectExposure_ = source; + // L'essence est mise en cache AVEC la cellule : garder les cellules deja + // engendrees laisserait cohabiter deux lois dans le meme monde, avec une + // frontiere invisible la ou le joueur se trouvait au moment du changement. + cache_.clear(); +} + +void Vegetation::gatherTrees(const glm::vec3& eye, const Frustum& frustum, + std::vector& out) { + // Les DEUX sorties du coeur pointent sur le MEME vecteur : l'union est donc + // rendue dans exactement l'ordre d'avant la Phase 26, sans copie ni + // concatenation, et sans qu'il existe une seconde version du parcours. + gatherTrees(eye, frustum, out, out); +} + +void Vegetation::gatherTrees(const glm::vec3& eye, const Frustum& frustum, + std::vector& conifers, + std::vector& broadleaves) { + conifers.clear(); + broadleaves.clear(); + lastConiferCount_ = 0; + lastBroadleafCount_ = 0; + + const float cellSize = params_.treeCell; + const float reach = params_.treeDistanceFar; + + const int32_t cx0 = static_cast(std::floor((eye.x - reach) / cellSize)); + const int32_t cx1 = static_cast(std::floor((eye.x + reach) / cellSize)); + const int32_t cz0 = static_cast(std::floor((eye.z - reach) / cellSize)); + const int32_t cz1 = static_cast(std::floor((eye.z + reach) / cellSize)); + + uint32_t built = 0; + + // --- Culling par BLOCS de cellules -------------------------------------- + // Sans lui, chaque image visite les ~8 400 cellules du carre de portee et + // fait une recherche dans le cache pour chacune, y compris pour celles + // situees derriere le joueur. Mesure directe : camera tournee vers le CIEL, + // donc pratiquement aucun arbre dessine, la vegetation faisait quand meme + // tomber la scene de 1946 a 351 FPS - soit 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 cette boucle. + // + // Un bloc de 8x8 cellules est teste d'un coup contre le tronc de vision ; + // s'il echoue, 64 cellules sont ecartees pour un seul test. Comme le champ + // de vision ne couvre qu'une fraction du disque de portee, l'essentiel des + // blocs tombe ici. + // + // Les bornes verticales du bloc sont ESTIMEES (cinq sondes d'altitude, puis + // une marge large) et non exactes. C'est sans danger : un bloc situe derriere + // le joueur est rejete par les plans lateraux et le plan proche, qui ne + // dependent pas de cette estimation ; la marge ne sert qu'a ne jamais ecarter + // par erreur un bloc reellement visible. + constexpr int32_t kBlock = 8; + const auto blockFloor = [](int32_t value) { + // Division entiere qui arrondit vers le BAS, y compris en negatif : en + // C++ la division tronque vers zero, ce qui decalerait les blocs d'un + // cran du cote des coordonnees negatives. + return (value >= 0) ? value / kBlock : -((-value + kBlock - 1) / kBlock); + }; + + for (int32_t bz = blockFloor(cz0); bz <= blockFloor(cz1); ++bz) { + for (int32_t bx = blockFloor(cx0); bx <= blockFloor(cx1); ++bx) { + const float blockMinX = static_cast(bx * kBlock) * cellSize; + const float blockMinZ = static_cast(bz * kBlock) * cellSize; + const float blockSize = static_cast(kBlock) * cellSize; + + const float bnx = glm::clamp(eye.x, blockMinX, blockMinX + blockSize); + const float bnz = glm::clamp(eye.z, blockMinZ, blockMinZ + blockSize); + const float bdx = eye.x - bnx; + const float bdz = eye.z - bnz; + if (bdx * bdx + bdz * bdz > reach * reach) { + continue; + } + + float lowest = terrain_.heightAt(blockMinX + 0.5f * blockSize, + blockMinZ + 0.5f * blockSize); + float highest = lowest; + for (int corner = 0; corner < 4; ++corner) { + const float sx = blockMinX + ((corner & 1) ? blockSize : 0.0f); + const float sz = blockMinZ + ((corner & 2) ? blockSize : 0.0f); + const float h = terrain_.heightAt(sx, sz); + lowest = std::min(lowest, h); + highest = std::max(highest, h); + } + // Marge large : les cinq sondes ne voient pas l'interieur du bloc, + // et un ressaut de terrain de 100 m sur 192 m est courant ici. + if (!frustum.intersectsAABB({ blockMinX, lowest - 130.0f, blockMinZ }, + { blockMinX + blockSize, highest + 130.0f, + blockMinZ + blockSize })) { + continue; + } + + const int32_t inCx0 = std::max(cx0, bx * kBlock); + const int32_t inCx1 = std::min(cx1, bx * kBlock + kBlock - 1); + const int32_t inCz0 = std::max(cz0, bz * kBlock); + const int32_t inCz1 = std::min(cz1, bz * kBlock + kBlock - 1); + + for (int32_t cz = inCz0; cz <= inCz1; ++cz) { + for (int32_t cx = inCx0; cx <= inCx1; ++cx) { + // Rejet par la DISTANCE avant tout le reste : c'est le test le moins + // cher, et il elimine les coins du carre de cellules balaye, qui ne + // sont pas dans le disque de portee. + const float boxMinX = static_cast(cx) * cellSize; + const float boxMinZ = static_cast(cz) * cellSize; + const float nearestX = glm::clamp(eye.x, boxMinX, boxMinX + cellSize); + const float nearestZ = glm::clamp(eye.z, boxMinZ, boxMinZ + cellSize); + const float dx = eye.x - nearestX; + const float dz = eye.z - nearestZ; + if (dx * dx + dz * dz > reach * reach) { + continue; + } + + // Une cellule DEJA en cache est cullee sur sa vraie boite ; une + // cellule inconnue ne peut pas l'etre sans etre engendree, donc on + // la teste sur une boite verticale genereuse avant de payer le + // semis. Sans cette precaution, le budget par image serait consomme + // par des cellules situees derriere le joueur. + auto found = cache_.find(CellKey{ cx, cz }); + if (found == cache_.end()) { + const float groundY = terrain_.heightAt(boxMinX + 0.5f * cellSize, + boxMinZ + 0.5f * cellSize); + const glm::vec3 coarseMin{ boxMinX, groundY - 40.0f, boxMinZ }; + const glm::vec3 coarseMax{ boxMinX + cellSize, groundY + 40.0f, + boxMinZ + cellSize }; + if (!frustum.intersectsAABB(coarseMin, coarseMax)) { + continue; + } + if (built >= params_.treeCellBudget) { + continue; // servie a une image suivante + } + ++built; + } + + const Cell& cell = treeCell(cx, cz); + if (cell.candidates.empty()) { + continue; + } + if (!frustum.intersectsAABB(cell.boxMin, cell.boxMax)) { + continue; + } + + for (const Candidate& candidate : cell.candidates) { + const float distance = glm::length(eye - candidate.position); + if (distance >= candidate.maxDistance) { + continue; + } + + InstanceData instance; + instance.position = candidate.position; + instance.scale = candidate.height; + instance.yaw = candidate.yaw; + instance.variation = candidate.variation; + // Fondu sur les 18 derniers pour cent de la portee de CET + // emplacement : l'arbre retrecit jusqu'a disparaitre au lieu de + // s'evanouir d'un coup. Voir shaders/foliage.vert. + const float fadeStart = candidate.maxDistance * 0.82f; + instance.fade = 1.0f - ramp(distance, fadeStart, candidate.maxDistance); + if (candidate.species == TreeSpecies::Conifer) { + conifers.push_back(instance); + ++lastConiferCount_; + } else { + broadleaves.push_back(instance); + ++lastBroadleafCount_; + } + } + } + } + } + } + + // --- Purge du cache ----------------------------------------------------- + // Toute cellule au-dela de 1,5 fois la portee est oubliee. Sans purge, + // traverser les 25 km2 finirait par tout garder en memoire, ce qui annulerait + // exactement l'interet du semis a la demande. + const float keep = reach * 1.5f; + for (auto it = cache_.begin(); it != cache_.end();) { + const float centreX = (static_cast(it->first.x) + 0.5f) * cellSize; + const float centreZ = (static_cast(it->first.z) + 0.5f) * cellSize; + const float ddx = eye.x - centreX; + const float ddz = eye.z - centreZ; + if (ddx * ddx + ddz * ddz > keep * keep) { + it = cache_.erase(it); + } else { + ++it; + } + } + + // Somme des deux compteurs, et non `out.size()` : quand les deux sorties + // aliasent le meme vecteur (surcharge d'union), sa taille est deja le total ; + // quand elles sont distinctes, elle ne serait que la moitie du travail. + // Les compteurs, eux, disent la meme chose dans les deux cas. + lastTreeCount_ = lastConiferCount_ + lastBroadleafCount_; +} + +// --------------------------------------------------------------------------- +// Semis de l'herbe +// --------------------------------------------------------------------------- +void Vegetation::gatherGrass(const glm::vec3& eye, const Frustum& frustum, + std::vector& out) const { + out.clear(); + + const float cellSize = params_.grassCell; + const float reach = params_.grassDistanceFar; + + const int32_t cx0 = static_cast(std::floor((eye.x - reach) / cellSize)); + const int32_t cx1 = static_cast(std::floor((eye.x + reach) / cellSize)); + const int32_t cz0 = static_cast(std::floor((eye.z - reach) / cellSize)); + const int32_t cz1 = static_cast(std::floor((eye.z + reach) / cellSize)); + + const float usable = std::max(0.0f, terrainExtent_ - 2.0f); + + // Culling par BLOCS, exactement comme pour les arbres (voir gatherTrees). + // La cellule d'herbe fait 1 m : un bloc de 16x16 couvre 16 m et epargne 256 + // tests de cellule d'un seul coup. + constexpr int32_t kBlock = 16; + const auto blockFloor = [](int32_t value) { + return (value >= 0) ? value / kBlock : -((-value + kBlock - 1) / kBlock); + }; + + for (int32_t bz = blockFloor(cz0); bz <= blockFloor(cz1); ++bz) { + for (int32_t bx = blockFloor(cx0); bx <= blockFloor(cx1); ++bx) { + const float blockMinX = static_cast(bx * kBlock) * cellSize; + const float blockMinZ = static_cast(bz * kBlock) * cellSize; + const float blockSize = static_cast(kBlock) * cellSize; + + const float bnx = glm::clamp(eye.x, blockMinX, blockMinX + blockSize); + const float bnz = glm::clamp(eye.z, blockMinZ, blockMinZ + blockSize); + const float bdx = eye.x - bnx; + const float bdz = eye.z - bnz; + if (bdx * bdx + bdz * bdz > reach * reach) { + continue; + } + + const float blockY = terrain_.heightAt(blockMinX + 0.5f * blockSize, + blockMinZ + 0.5f * blockSize); + // Marge verticale large : cinq sondes ne verraient pas l'interieur du + // bloc, et l'herbe est basse - mieux vaut ne jamais l'ecarter a tort. + if (!frustum.intersectsAABB({ blockMinX, blockY - 45.0f, blockMinZ }, + { blockMinX + blockSize, blockY + 45.0f, + blockMinZ + blockSize })) { + continue; + } + + const int32_t inCx0 = std::max(cx0, bx * kBlock); + const int32_t inCx1 = std::min(cx1, bx * kBlock + kBlock - 1); + const int32_t inCz0 = std::max(cz0, bz * kBlock); + const int32_t inCz1 = std::min(cz1, bz * kBlock + kBlock - 1); + + for (int32_t cz = inCz0; cz <= inCz1; ++cz) { + for (int32_t cx = inCx0; cx <= inCx1; ++cx) { + const float baseX = static_cast(cx) * cellSize; + const float baseZ = static_cast(cz) * cellSize; + + const float nearestX = glm::clamp(eye.x, baseX, baseX + cellSize); + const float nearestZ = glm::clamp(eye.z, baseZ, baseZ + cellSize); + const float ddx = eye.x - nearestX; + const float ddz = eye.z - nearestZ; + if (ddx * ddx + ddz * ddz > reach * reach) { + continue; + } + + const float groundY = terrain_.heightAt(baseX + 0.5f * cellSize, + baseZ + 0.5f * cellSize); + // Boite basse : une touffe ne depasse guere le demi-metre. + if (!frustum.intersectsAABB({ baseX, groundY - 3.0f, baseZ }, + { baseX + cellSize, groundY + 3.0f, + baseZ + cellSize })) { + continue; + } + + // --- Densite locale -------------------------------------------- + // Trois facteurs INDEPENDANTS, evalues au centre de la cellule (les + // evaluer par touffe couterait trois fois plus pour une difference + // invisible a 3 m de resolution) : + // + // 1. le BRUIT groupe les touffes. C'est lui qui repond a l'exigence + // "pas une grille reguliere" : sans lui, une touffe par + // emplacement partout donnerait un tapis d'une regularite + // immediatement lisible. + // 2. l'ALTITUDE rarefie l'herbe vers le haut (pelouse alpine rase + // puis rocher nu). + // 3. la donnee LiDAR distingue le PRE du SOUS-BOIS et du LAPIAZ : + // il faut des retours de vegetation (sinon c'est du rocher) mais + // pas de canopee haute (sinon c'est une futaie, ou il pousse peu + // d'herbe). + const float noise = clusterNoise(baseX, baseZ, + params_.grassClusterFrequency, + params_.seed ^ 0x2545F491u); + const float clustered = ramp(noise, params_.grassClusterThreshold, + params_.grassClusterThreshold + + params_.grassClusterSoftness); + if (clustered <= 0.0f) { + continue; + } + + const float altitude = groundY; + const float byAltitude = 1.0f - ramp(altitude, params_.grassAltitudeLush, + params_.grassAltitudeBarren); + if (byAltitude <= 0.0f) { + continue; + } + + const float centreX = baseX + 0.5f * cellSize; + const float centreZ = baseZ + 0.5f * cellSize; + // Il faut des retours de vegetation (sinon c'est du rocher nu), et + // la densite baisse - sans s'annuler - sous une canopee haute : une + // futaie de montagne est claire, son sol porte de l'herbe. + const float openness = 1.0f - ramp(canopyHeightAt(centreX, centreZ), 3.0f, 14.0f); + const float meadow = ramp(coverAt(centreX, centreZ), 0.05f, 0.30f) * + glm::mix(params_.grassUnderCanopy, 1.0f, openness); + if (meadow <= 0.0f) { + continue; + } + + if (slopeAt(centreX, centreZ) > params_.grassMaxSlope) { + continue; + } + + // PHASE 17 : etat du sol. Quatrieme facteur, et le seul qui ne + // soit pas une propriete du terrain : il vient de ce que le JOUEUR a + // fait ici (voir world/Habitat.hpp). Une cellule jamais touchee rend + // 1 et le produit est inchange - la non-regression est litterale, pas + // approximative. + const float degraded = (groundCover_ != nullptr) + ? std::clamp(groundCover_->groundCover(centreX, centreZ), 0.0f, 1.0f) + : 1.0f; + + const float density = clustered * byAltitude * meadow * degraded; + const float allowed = density * static_cast(params_.grassSlots); + + // Taille decroissant avec l'altitude : c'est la demande explicite de + // la tache 3. La meme rampe sert a la densite et a la taille, ce qui + // fait que la transition vers la pelouse rase est continue. + const float sizeFactor = ramp(altitude, params_.grassAltitudeLush, + params_.grassAltitudeBarren); + const float tuftSize = glm::mix(params_.grassSizeLow, + params_.grassSizeHigh, sizeFactor); + + // --- PHASE 18 : hauteur du sol, une fois pour la CELLULE ------ + // Le semis appelait terrain_.heightAt() UNE FOIS PAR TOUFFE. A 56 + // emplacements par cellule et un millier de cellules par image, + // c'est le poste le plus lourd de tout le semis - et il grandit + // exactement au rythme de la densite, donc c'est lui qui plafonnait + // le tapis. + // + // On echantillonne desormais les QUATRE COINS de la cellule, puis on + // interpole a l'interieur. Ce n'est pas une approximation quand la + // cellule d'herbe coincide avec une cellule du terrain (1 m et 1 m + // sur cette zone) : on reproduit ici le MEME decoupage en deux + // triangles le long de la diagonale h00-h11 que Heightmap::heightAt, + // donc la touffe est posee au pixel pres sur la surface affichee. + // Sur un terrain au pas de 2 m, l'ecart residuel est celui de la + // courbure du sol sur un metre - de l'ordre du centimetre, sous la + // hauteur d'un brin. + const float h00 = terrain_.heightAt(baseX, baseZ); + const float h10 = terrain_.heightAt(baseX + cellSize, baseZ); + const float h01 = terrain_.heightAt(baseX, baseZ + cellSize); + const float h11 = terrain_.heightAt(baseX + cellSize, baseZ + cellSize); + const auto heightInCell = [&](float tx, float tz) { + return (tz > tx) ? h00 + (h01 - h00) * tz + (h11 - h01) * tx + : h00 + (h10 - h00) * tx + (h11 - h10) * tz; + }; + + for (uint32_t slot = 0; slot < params_.grassSlots; ++slot) { + if (static_cast(slot) >= allowed) { + break; + } + const uint32_t h0 = cellHash(cx, cz, params_.seed ^ 0x68bc21ebu, slot * 3u + 7u); + const uint32_t h1 = cellHash(cx, cz, params_.seed ^ 0x68bc21ebu, slot * 3u + 8u); + const uint32_t h2 = cellHash(cx, cz, params_.seed ^ 0x68bc21ebu, slot * 3u + 9u); + + const float tx = unitFloat(h0); + const float tz = unitFloat(h1); + const float x = baseX + tx * cellSize; + const float z = baseZ + tz * cellSize; + if (std::abs(x) > usable || std::abs(z) > usable) { + continue; + } + + // AUCUN appel a heightAt par touffe (PHASE 18) : quatre par + // cellule, interpoles ici. La Phase 11 en faisait deja passer le + // compte de deux a un par touffe - un pour le test de distance, + // un pour la position ; c'est la meme lecon poussee un cran plus + // loin, au niveau de la cellule. + const glm::vec3 foot(x, heightInCell(tx, tz), z); + const float distance = glm::length(eye - foot); + if (distance >= reach) { + continue; + } + + InstanceData instance; + instance.position = foot; + // Taille variee de +/- 25 % autour de la taille locale. + instance.scale = tuftSize * (0.75f + 0.5f * unitFloat(h2)); + instance.yaw = unitFloat(h2 ^ 0x1b873593u) * kTwoPi; + instance.variation = unitFloat(h0 ^ 0xcc9e2d51u); + // Fondu sur toute la bande entre grassDistanceNear et + // grassDistanceFar - bien plus large que pour les arbres, parce + // que l'herbe est proche : un fondu court se lirait comme une + // muraille de touffes qui poussent devant le joueur. + instance.fade = 1.0f - ramp(distance, params_.grassDistanceNear, + params_.grassDistanceFar); + out.push_back(instance); + } + } + } + } + } + + lastGrassCount_ = static_cast(out.size()); +} + +// --------------------------------------------------------------------------- +double Vegetation::estimateTreeDensityPerHectare(uint32_t step) const { + if (step == 0) { + step = 1; + } + const float cellSize = params_.treeCell; + const int32_t half = static_cast(terrainExtent_ / cellSize); + + uint64_t trees = 0; + uint64_t cells = 0; + for (int32_t cz = -half; cz <= half; cz += static_cast(step)) { + for (int32_t cx = -half; cx <= half; cx += static_cast(step)) { + trees += buildTreeCell(cx, cz).candidates.size(); + ++cells; + } + } + if (cells == 0) { + return 0.0; + } + const double areaHectares = static_cast(cells) * cellSize * cellSize / 10000.0; + return static_cast(trees) / areaHectares; +} + +} // namespace vercora diff --git a/src/world/Vegetation.hpp b/src/world/Vegetation.hpp new file mode 100644 index 0000000..e18d8a8 --- /dev/null +++ b/src/world/Vegetation.hpp @@ -0,0 +1,342 @@ +#pragma once + +#include "renderer/InstanceData.hpp" +#include "world/GroundCover.hpp" +#include "world/TreeSpecies.hpp" + +#include + +#include +#include +#include + +namespace vercora { + +class HeightSampler; +struct Frustum; + +// Reglages du semis de vegetation de decor. Tous les seuils sont nommes ici +// plutot que disperses dans le .cpp : c'est le tableau de bord de la Phase 11, +// et NOTES-PHASE11.md renvoie a ces noms. +struct VegetationParams { + // --- Arbres ------------------------------------------------------------- + // Cote d'une cellule de semis. C'est l'unite de travail : une cellule est + // engendree d'un bloc, mise en cache, et cullee d'un bloc. + float treeCell = 24.0f; + + // Nombre d'emplacements d'arbre engendres par cellule. Le nombre REELLEMENT + // retenu depend du couvert local et de la distance (voir plus bas). + // 8 emplacements sur 24 m de cote = au plus un arbre pour 72 m2, soit une + // futaie dense mais pas un mur. + uint32_t treeSlots = 8; + + // Portee de rendu de l'emplacement 0 (le plus persistant) et du dernier. + // C'est ICI que se joue le niveau de detail de DENSITE : chaque emplacement + // a sa PROPRE portee, interpolee entre ces deux bornes. Les arbres + // disparaissent donc un par un et progressivement quand on s'eloigne, au + // lieu que toute une cellule change de compte d'un coup - ce qui serait + // visible comme un clignotement de bosquet. + float treeDistanceFar = 1100.0f; + float treeDistanceNear = 320.0f; + + // Couvert (part de retours de vegetation, voir tools/lidar_to_canopy.py) + // en dessous duquel aucune cellule n'est boisee, et au-dessus duquel elle + // l'est au maximum. Entre les deux, la densite croit lineairement. + float coverMin = 0.20f; + float coverFull = 0.75f; + + // Bornes de hauteur d'arbre, en metres. La carte de canopee donne la hauteur + // du plus grand arbre de sa cellule ; les emplacements d'une meme cellule se + // repartissent en dessous, pour que la futaie ne soit pas une brosse. + float treeMinHeight = 4.5f; + float treeMaxHeight = 32.0f; + + // Pente maximale (en tangente) sur laquelle un arbre de decor accepte de + // pousser. Meme role que ForestParams::maxSlope, mais plus permissif : un + // arbre de decor n'a pas a etre abattable, seulement a ne pas flotter. + float treeMaxSlope = 1.1f; + + // --- Herbe -------------------------------------------------------------- + // Cellule de semis de l'herbe et emplacements par cellule. Au maximum + // 18 touffes par cellule de 2 m, soit 4,5 touffes/m2 ; la densite reellement + // retenue vaut la moitie environ (voir gatherGrass). Les premiers reglages + // (cellule de 3 m, 6 emplacements) donnaient moins d'une touffe par 9 m2 : + // des brins isoles au milieu du vide, pas un pre. + float grassCell = 1.0f; + + // PHASE 18 : 24 -> 56 emplacements. Au maximum 14 touffes/m2 sur une cellule + // de 1 m, et la densite REELLEMENT retenue vaut `density * grassSlots`, donc + // environ 5 touffes/m2 sur un alpage ordinaire de cette zone (2 avant). + // + // POURQUOI AGIR ICI ET PAS SUR LES SEUILS DE SELECTION. Baisser + // grassClusterThreshold ou grassMaxSlope aurait aussi produit plus de + // touffes - mais en en mettant LA OU IL N'Y EN A PAS : sur le rocher, sous + // la futaie dense, sur les versants que la carte LiDAR declare nus. Le + // reproche de la Phase 11 n'etait pas que l'herbe manquait d'emprise, il + // etait qu'elle formait un semis clairseme LA OU ELLE POUSSE. Le nombre + // d'emplacements est le seul reglage qui densifie sans deplacer une seule + // frontiere : la carte de repartition de la Phase 11 est litteralement + // inchangee, seul son remplissage l'est. + uint32_t grassSlots = 56; + + // PHASE 18 : force de la DECOUPE ALPHA des brins, entre 0 et 1 (voir + // shaders/foliage.frag). 0 rend exactement les quads opaques de la Phase 11 : + // c'est le TEMOIN qui permet de mesurer ce que la decoupe coute reellement, + // sur le meme binaire et la meme vue (option de jeu --no-grass-cutout). + float grassCutout = 1.0f; + + // Portee volontairement COURTE : l'herbe n'a pas a etre visible a des + // kilometres, contrairement au terrain et aux arbres, et c'est de loin le + // poste le plus couteux en nombre d'instances. Le fondu occupe toute la + // bande entre les deux valeurs. + float grassDistanceFar = 34.0f; + float grassDistanceNear = 14.0f; + + // Taille d'une touffe au plus bas et au plus haut de la zone, en metres. + // C'est la traduction directe de "vegetation alpine rase en altitude". + float grassSizeLow = 0.30f; + float grassSizeHigh = 0.11f; + + // Altitudes, en metres, entre lesquelles l'herbe se rarefie et rapetisse. + // Reglees sur la zone reelle (1029 a 2285 m) : dense en dessous de la + // premiere, absente au-dessus de la seconde. + // Reglees sur CE massif : la limite des arbres y est vers 1800-1900 m et + // l'alpage reste dense bien au-dessus. Les premieres valeurs (1500 / 2150) + // 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 de ski du nord-ouest. + float grassAltitudeLush = 1750.0f; + float grassAltitudeBarren = 2250.0f; + + // Pente maximale portant de l'herbe. 1,3 en tangente ~ 52 degres : une + // pelouse d'alpage tient sur des versants bien plus raides qu'on ne le + // croit, et le premier reglage (0,9) rejetait 42 % des cellules d'un + // versant herbeux ordinaire de ce massif. + float grassMaxSlope = 1.3f; + + // Part de la densite d'herbe qui subsiste SOUS UNE CANOPEE HAUTE. Zero + // voudrait dire qu'il ne pousse rien en foret, ce qui est faux : une futaie + // de montagne est claire et son sol porte de l'herbe. C'etait pourtant le + // premier reglage, et il vidait 79 % des cellules d'un versant boise. + float grassUnderCanopy = 0.35f; + + // Frequence spatiale du bruit qui module la densite d'herbe, en cycles par + // metre. 1/14 m : les taches d'herbe font une quinzaine de metres. Le premier + // reglage (1/45 m) produisait des taches si larges qu'a hauteur d'oeil on + // n'en voyait qu'une seule : l'impression n'etait plus celle de touffes mais + // d'une moitie de paysage herbeuse et d'une moitie nue. + float grassClusterFrequency = 1.0f / 14.0f; + + // Seuil du bruit au-dessus duquel une zone est herbeuse. Plus il est haut, + // plus les touffes sont groupees et separees par du sol nu. + float grassClusterThreshold = 0.25f; + + // Largeur de la rampe au-dessus du seuil : c'est elle qui decide si le bord + // d'une tache d'herbe est franc (valeur petite) ou degrade (valeur grande). + float grassClusterSoftness = 0.35f; + + // Amplitude d'ondulation, en metres, a la pointe d'un brin. + float grassSway = 0.06f; + + // --- Commun ------------------------------------------------------------- + // Deux Vegetation de meme graine sont identiques : le decor ne bouge pas + // d'une execution a l'autre, ce qui rend les captures comparables. + uint32_t seed = 20260821u; + + // PHASE 26 : reglages des ESSENCES d'arbres. Le semis de decor ne decide pas + // lui-meme de la part de resineux : il delegue a world/TreeSpecies.hpp, qui + // est aussi ce que consultent les arbres abattables et la recolte de resine. + // Une seule loi pour les trois. + TreeSpeciesParams species; + + // Cellules d'arbres engendrees au plus par appel. Un budget, comme celui du + // TerrainStreamer : sans lui, le premier passage dans une zone vierge + // engendrerait des milliers de cellules d'un coup et ferait un a-coup + // visible. Les cellules manquantes arrivent aux images suivantes. + uint32_t treeCellBudget = 96; +}; + +// Vegetation de DECOR : les dizaines de milliers d'arbres et les centaines de +// milliers de touffes d'herbe qui habillent les 25 km2, par opposition aux +// quelques arbres ABATTABLES de world/Forest.hpp. +// +// POURQUOI DEUX SYSTEMES ET NON UN SEUL. Forest tient un vecteur d'arbres, et +// resolve()/pickTree() le parcourent en entier a chaque appel : c'est parfait +// pour seize arbres avec lesquels on interagit, et intenable pour cinquante +// mille. Surtout, un arbre de Forest porte un ETAT (debout, en chute, en +// debitage) qu'il faut conserver, alors qu'un arbre de decor n'en a aucun. Les +// fusionner obligerait a payer le prix du plus exigeant des deux partout. La +// promotion d'un arbre de decor en arbre abattable quand le joueur s'en approche +// est le prolongement naturel de cette architecture ; elle n'est PAS faite dans +// cette phase (voir NOTES-PHASE11.md). +// +// AUCUN ARBRE N'EST STOCKE POUR LES 25 KM2. Le semis est une FONCTION +// DETERMINISTE de la cellule : engendrer la cellule (17, -42) donne toujours les +// memes arbres, quelle que soit la facon dont on y est arrive. La memoire ne +// contient donc que les cellules proches du joueur, et il n'y a rien a +// sauvegarder ni a charger. C'est le meme principe que le quadtree du terrain, +// applique au semis plutot qu'au maillage. +// +// Ne connait RIEN de Vulkan : produit des InstanceData, c'est main.cpp qui les +// remet au Renderer. Testable sans GPU. +class Vegetation { +public: + // `terrain` fournit l'altitude et la pente ; il n'est pas possede et doit + // vivre plus longtemps. + // `cover` et `canopyHeight` sont les cartes produites par + // tools/lidar_to_canopy.py, echantillonnees en coordonnees MONDE comme le + // terrain (elles partagent son origine et son emprise). Toutes deux peuvent + // etre nulles : le semis retombe alors sur un substitut par pente et + // altitude, documente dans NOTES-PHASE11.md. + // `terrainExtent` = demi-cote du terrain, pour ne pas semer hors des donnees. + Vegetation(const HeightSampler& terrain, const HeightSampler* cover, + const HeightSampler* canopyHeight, float terrainExtent, + const VegetationParams& params = {}); + + // Remplit `out` (vide d'abord) des arbres visibles depuis `eye`. Les + // cellules hors du frustum ne sont pas engendrees du tout : c'est le + // frustum culling qui evite le gros du travail, exactement comme pour le + // terrain. + void gatherTrees(const glm::vec3& eye, const Frustum& frustum, + std::vector& out); + + // PHASE 26 : meme chose, mais TRIEE PAR ESSENCE. Les deux essences ont des + // geometries distinctes (world/TreeMesh.hpp), donc deux appels de dessin + // instancies au lieu d'un : le rendu instancie tient UNE geometrie pour N + // instances, c'est sa definition meme, et il n'y a pas de facon de melanger + // deux formes dans un seul appel sans reintroduire une matrice par arbre - + // c'est-a-dire sans defaire la Phase 11. + // + // Les deux vecteurs sont vides d'abord. La surcharge a un seul vecteur + // ci-dessus reste EXACTE et sert encore (tests, estimation de densite) : + // elle rend l'union des deux, dans le meme ordre qu'avant cette phase. + void gatherTrees(const glm::vec3& eye, const Frustum& frustum, + std::vector& conifers, + std::vector& broadleaves); + + // Idem pour l'herbe. PAS de cache : la portee etant courte (une soixantaine + // de metres), le nombre de cellules concernees est petit et l'engendrement + // direct coute moins cher que la gestion d'un cache et son eviction. + void gatherGrass(const glm::vec3& eye, const Frustum& frustum, + std::vector& out) const; + + // PHASE 17 : etat du sol. Branche l'HERBE - et elle seule - sur une source + // de couvert (world/Habitat.hpp en pratique), qui la rarefie la ou le + // milieu a ete degrade. Nul par defaut, et un Vegetation sans source se + // comporte EXACTEMENT comme avant la Phase 17 (voir le contrat total de + // GroundCoverSource) : c'est ce qui rend la non-regression verifiable. + // + // Pourquoi l'herbe et pas les arbres : les arbres de decor sont la FORET, + // et la foret ne disparait pas parce qu'on en a coupe trois pieds - ce sont + // les arbres ABATTABLES de Forest qui tombent, et ils tombent un par un, + // visiblement. Ce qui change apres une coupe, c'est le sol : pietine, + // debarde, mis a nu. Faire disparaitre les arbres de decor aurait efface la + // coupe au lieu de la montrer. + // + // La source n'est PAS possedee et doit vivre plus longtemps que la + // Vegetation. + void setGroundCover(const GroundCoverSource* source) { groundCover_ = source; } + const GroundCoverSource* groundCoverSource() const { return groundCover_; } + + // PHASE 26 : source d'exposition adret/ubac, qui decide de l'ESSENCE d'un + // arbre - et d'elle seule. + // + // CE QU'ELLE NE TOUCHE PAS, ET C'EST LE POINT. La PRESENCE d'un arbre reste + // pilotee exactement comme depuis la Phase 11 : par la carte de couvert + // LiDAR (coverAt), la pente et l'altitude. L'exposition n'entre nulle part + // dans buildTreeCell avant que l'emplacement ne soit DEJA retenu ; elle ne + // peut donc ni ajouter ni retirer un seul arbre. Un versant boise le reste, + // seule la composition de son peuplement change. + // + // Nulle par defaut : le semis rend alors la part de resineux neutre partout, + // donc la meme repartition qu'un tirage sans exposition. La source n'est PAS + // possedee et doit vivre plus longtemps que la Vegetation. + // + // A APPELER AVANT le premier gatherTrees : l'essence est mise en cache avec + // la cellule, comme le reste du semis. Changer la source ensuite purge le + // cache, pour qu'aucune cellule ne garde une essence calculee sous l'ancienne. + void setAspectExposure(const AspectExposureSource* source); + const AspectExposureSource* aspectExposureSource() const { return aspectExposure_; } + + // --- Diagnostic --------------------------------------------------------- + std::size_t cachedCellCount() const { return cache_.size(); } + uint32_t lastTreeCount() const { return lastTreeCount_; } + uint32_t lastConiferCount() const { return lastConiferCount_; } // PHASE 26 + uint32_t lastBroadleafCount() const { return lastBroadleafCount_; } // PHASE 26 + uint32_t lastGrassCount() const { return lastGrassCount_; } + + // Densite d'arbres estimee sur toute la zone, en arbres par hectare, obtenue + // en engendrant un echantillon regulier de cellules. Sert au journal de + // demarrage et aux tests : c'est le seul chiffre qui dit si la carte de + // couvert a reellement ete prise en compte. + // `step` = une cellule sondee sur `step` dans chaque direction. + double estimateTreeDensityPerHectare(uint32_t step = 7) const; + + const VegetationParams& params() const { return params_; } + +private: + struct CellKey { + int32_t x = 0; + int32_t z = 0; + bool operator==(const CellKey& other) const { return x == other.x && z == other.z; } + }; + struct CellKeyHash { + std::size_t operator()(const CellKey& key) const { + // Melange simple : les deux moities occupent des bits distincts. + return (static_cast(static_cast(key.x)) * 0x9E3779B1ull) + ^ (static_cast(static_cast(key.z)) * 0x85EBCA77ull); + } + }; + + // Emplacements CANDIDATS d'une cellule, avec leur portee individuelle. Ce + // qui est mis en cache est le resultat du semis, pas ce qui est visible : + // la distance et le frustum sont reevalues a chaque image. + struct Candidate { + glm::vec3 position{0.0f}; + float height = 0.0f; + float yaw = 0.0f; + float variation = 0.0f; + float maxDistance = 0.0f; // portee propre a l'emplacement + TreeSpecies species = TreeSpecies::Conifer; // PHASE 26 + }; + struct Cell { + std::vector candidates; + glm::vec3 boxMin{0.0f}; + glm::vec3 boxMax{0.0f}; + }; + + // Engendre (ou retrouve) une cellule d'arbres. + const Cell& treeCell(int32_t cx, int32_t cz); + Cell buildTreeCell(int32_t cx, int32_t cz) const; + + // Pente du terrain en un point, par differences finies. Meme definition que + // Forest::slopeAt : les deux filtres doivent parler de la meme grandeur. + float slopeAt(float worldX, float worldZ) const; + + // Couvert et hauteur de canopee en un point, avec leur substitut quand les + // cartes LiDAR ne sont pas fournies. + float coverAt(float worldX, float worldZ) const; + float canopyHeightAt(float worldX, float worldZ) const; + + const HeightSampler& terrain_; + const HeightSampler* cover_ = nullptr; + const HeightSampler* canopyHeight_ = nullptr; + const GroundCoverSource* groundCover_ = nullptr; // PHASE 17, optionnel + const AspectExposureSource* aspectExposure_ = nullptr; // PHASE 26, optionnel + float terrainExtent_ = 0.0f; + VegetationParams params_; + + // Cache des cellules d'arbres. Purge des cellules trop lointaines a chaque + // appel de gatherTrees : sans elle, traverser la zone entiere finirait par + // tout garder en memoire, ce qui annulerait l'interet du semis a la demande. + std::unordered_map cache_; + + uint32_t lastTreeCount_ = 0; + // Comptes par essence du dernier gatherTrees, pour le journal et les tests : + // sans eux, "il y a plus de resineux en ubac" ne serait qu'une impression. + uint32_t lastConiferCount_ = 0; + uint32_t lastBroadleafCount_ = 0; + mutable uint32_t lastGrassCount_ = 0; +}; + +} // namespace vercora diff --git a/src/world/WaterSource.cpp b/src/world/WaterSource.cpp new file mode 100644 index 0000000..6d5e97e --- /dev/null +++ b/src/world/WaterSource.cpp @@ -0,0 +1,156 @@ +#include "world/WaterSource.hpp" + +#include "core/HeightSampler.hpp" + +#include +#include + +namespace vercora { + +namespace { + +// Les HUIT directions de sonde, normalisees : les quatre axes et les quatre +// diagonales. Le pourquoi de huit et non quatre est dans WaterSurveyParams +// (risingProbesRequired) - c'est ce qui separe un talweg d'un col. +constexpr float kDiagonal = 0.70710678f; // 1/sqrt(2) +constexpr std::size_t kProbeCount = 8; +const glm::vec2 kProbeDirections[kProbeCount] = { + { 1.0f, 0.0f}, {-1.0f, 0.0f}, {0.0f, 1.0f}, {0.0f, -1.0f}, + { kDiagonal, kDiagonal}, { kDiagonal, -kDiagonal}, + {-kDiagonal, kDiagonal}, {-kDiagonal, -kDiagonal}, +}; + +// Pente locale (magnitude du gradient), differences finies centrees. Meme +// construction que Bike::terrainGradient et Needs::terrainExposure ; elle n'est +// pas partagee avec eux parce que ce fichier ne doit dependre que du +// HeightSampler, exactement comme les trois activites. +float localSlope(const HeightSampler& terrain, float x, float z, float step) { + const float s = step > 0.0f ? step : 2.0f; + const float dhdx = (terrain.heightAt(x + s, z) - terrain.heightAt(x - s, z)) / (2.0f * s); + const float dhdz = (terrain.heightAt(x, z + s) - terrain.heightAt(x, z - s)) / (2.0f * s); + return std::sqrt(dhdx * dhdx + dhdz * dhdz); +} + +} // namespace + +std::vector findWaterSources(const HeightSampler& terrain, + float minX, float maxX, + float minZ, float maxZ, + const WaterSurveyParams& params) { + std::vector found; + + const float step = params.scanStep > 0.0f ? params.scanStep : 50.0f; + const float probe = params.probeDistance > 0.0f ? params.probeDistance : 25.0f; + if (!(maxX > minX) || !(maxZ > minZ)) { + return found; + } + + // Les sondes sortiraient du rectangle sur les bords ; heightAt est TOTALE + // (voir son contrat) et prolongerait la hauteur du bord, ce qui fabriquerait + // de fausses cuvettes tout le long du perimetre. On rentre donc d'une + // portee de sonde. + const float x0 = minX + probe; + const float x1 = maxX - probe; + const float z0 = minZ + probe; + const float z1 = maxZ - probe; + if (!(x1 > x0) || !(z1 > z0)) { + return found; + } + + std::vector candidates; + + for (float z = z0; z <= z1; z += step) { + for (float x = x0; x <= x1; x += step) { + if (localSlope(terrain, x, z, params.slopeSampleStep) > params.maxSlope) { + continue; + } + + const float h = terrain.heightAt(x, z); + + int rising = 0; + float sum = 0.0f; + for (const glm::vec2& direction : kProbeDirections) { + const float rise = + terrain.heightAt(x + direction.x * probe, z + direction.y * probe) - h; + sum += rise; + if (rise >= params.minDepth) { + ++rising; + } + } + if (rising < params.risingProbesRequired) { + continue; + } + + const float depth = sum / static_cast(kProbeCount); + if (depth < params.minDepth) { + continue; + } + + candidates.push_back(WaterSource{glm::vec3(x, h, z), depth}); + } + } + + // Du plus creux au moins creux : c'est dans cet ordre qu'on veut les garder + // quand il y en a trop, et c'est aussi celui qui rend l'ecartement stable - + // le meilleur point d'un groupe survit, pas celui que le balayage a croise + // en premier. + std::sort(candidates.begin(), candidates.end(), + [](const WaterSource& a, const WaterSource& b) { + if (a.depth != b.depth) { + return a.depth > b.depth; + } + // Depart au coordonnees a egalite de profondeur : sans lui, + // deux points aussi creux l'un que l'autre pourraient sortir + // dans un ordre dependant de l'implementation du tri, et le + // resultat cesserait d'etre reproductible d'un run a l'autre. + if (a.position.x != b.position.x) { + return a.position.x < b.position.x; + } + return a.position.z < b.position.z; + }); + + const float separation2 = params.minSeparation * params.minSeparation; + for (const WaterSource& candidate : candidates) { + if (found.size() >= params.maxSources) { + break; + } + bool tooClose = false; + for (const WaterSource& kept : found) { + const float dx = kept.position.x - candidate.position.x; + const float dz = kept.position.z - candidate.position.z; + if (dx * dx + dz * dz < separation2) { + tooClose = true; + break; + } + } + if (!tooClose) { + found.push_back(candidate); + } + } + + return found; +} + +const WaterSource* nearestWaterSource(const std::vector& sources, + const glm::vec3& position, + float* outDistance) { + const WaterSource* best = nullptr; + float bestDistance2 = 0.0f; + + for (const WaterSource& source : sources) { + const float dx = source.position.x - position.x; + const float dz = source.position.z - position.z; + const float d2 = dx * dx + dz * dz; + if (best == nullptr || d2 < bestDistance2) { + best = &source; + bestDistance2 = d2; + } + } + + if (outDistance) { + *outDistance = best ? std::sqrt(bestDistance2) : 0.0f; + } + return best; +} + +} // namespace vercora diff --git a/src/world/WaterSource.hpp b/src/world/WaterSource.hpp new file mode 100644 index 0000000..4248dfd --- /dev/null +++ b/src/world/WaterSource.hpp @@ -0,0 +1,132 @@ +#pragma once + +#include + +#include +#include + +namespace vercora { + +class HeightSampler; + +// =========================================================================== +// PHASE 16 : les points d'eau. +// =========================================================================== +// Le jeu n'a PAS d'eau : ni surface liquide, ni rendu, ni physique de fluide. +// Ce fichier ne pretend pas en ajouter. Il repond a une question beaucoup plus +// etroite, celle que pose le cahier des charges de la phase : ou, sur un relief +// LiDAR reel, y a-t-il un endroit ou il serait credible de boire ? +// +// La reponse est cherchee dans la FORME du terrain, sans donnee +// supplementaire : l'eau s'accumule dans les creux et les talwegs, donc dans +// les points a la fois PEU PENTUS et CONCAVES - ceux que le relief entoure de +// terrain plus haut. C'est exactement ce que teste findWaterSources. +// +// C'est une heuristique, et elle est fausse par endroits : une source de +// versant ne le passe pas, et un replat de col assez ferme peut le passer. Elle est retenue parce +// qu'elle est verifiable (les tests headless la confrontent a une cuvette +// construite expres, a un plan incline et a une crete), qu'elle est bon marche (un +// balayage unique au chargement, voir WaterSurveyParams::scanStep), et +// surtout parce que la lecon de la Phase 14 vaut ici aussi : savoir OU il y a +// de la pente ne dit pas par ou l'aborder, et 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. +// =========================================================================== + +// Un point ou le joueur peut boire. +struct WaterSource { + glm::vec3 position{0.0f}; // sur la surface : y = heightAt(x, z) + + // Profondeur apparente de la cuvette en m (elevation moyenne du pourtour + // au-dessus du point). Sert a classer les candidats du plus creux au moins + // creux, donc a garder les meilleurs quand il y en a trop. + float depth = 0.0f; +}; + +struct WaterSurveyParams { + // Pas du balayage, en m. 20 m, et ce n'est PAS un reglage de confort : le + // rayon utile d'un creux (celui ou la pente reste sous maxSlope tout en + // gardant une concavite d'au moins minDepth sur 25 m) vaut une vingtaine de + // metres. Un pas plus large passe simplement a cote. Mesure sur la dalle + // reelle du Gua : au pas de 50 m, ZERO point d'eau sur 1 km2 ; au pas de + // 20 m, quatre. La zone de 25 km2 demande 62 500 candidats, soit environ + // 800 000 appels a heightAt, une seule fois au chargement. + float scanStep = 20.0f; + + // Rayon des sondes de pourtour, en m. 25 m : assez large pour voir un + // talweg, assez etroit pour ne pas confondre un vallon avec la vallee + // entiere. + float probeDistance = 25.0f; + + // Demi-base de la lecture de pente, en m. 2,0, donc une base de 4 m : + // meme valeur et MEME RAISON que BikeParams::slopeSampleStep - au pas de + // 1 m, le bruit decimetrique du LiDAR fait lire des pentes qui n'existent + // pas, et le filtre de platitude ne selectionnerait plus rien. + float slopeSampleStep = 2.0f; + + // Pente locale maximale admise. 0,15 : au-dela de 15 %, l'eau s'ecoule au + // lieu de stagner. Le seuil etait a 0,10 dans une premiere version ; sur la + // dalle reelle, SEULS 10 points sur 361 passent sous 10 % de pente - ce + // massif est raide, 562 m de denivele sur 1 km - et le detecteur ne rendait + // rien. 15 % reste tres en dessous des 60 % typiques du versant. + float maxSlope = 0.15f; + + // Elevation moyenne du pourtour au-dessus du point, en m, pour que le point + // compte comme un creux. 1,0 m sur 25 m de rayon, soit une concavite de + // 4 % - modeste, mais c'est ce qu'on trouve reellement en montagne hors des + // lacs, qui eux ne sont pas dans cette dalle. + float minDepth = 1.0f; + + // Nombre de sondes du pourtour (sur HUIT) qui doivent etre plus hautes d'au + // moins minDepth. + // + // POURQUOI HUIT SONDES ET NON QUATRE. Avec quatre sondes sur les axes, un + // talweg - la forme qui compte vraiment ici - en a deux plus hautes (les + // deux versants) et deux plus basses (l'amont et l'aval). Exiger trois + // sondes montantes ne retenait donc que les cuvettes FERMEES, qui + // n'existent pratiquement pas sur ce relief : mesure, zero point d'eau sur + // la dalle reelle. Descendre a deux sondes sur quatre, en revanche, laisse + // passer les COLS, qui ont exactement la meme signature et ou il n'y a rien + // a boire. + // + // Huit directions separent les deux cas : un talweg a ses deux versants qui + // couvrent chacun plus d'une direction (5 a 6 sondes montantes), un col n'en + // a que quatre. Le seuil de 5 sur 8 est donc au-dessus du col et en dessous + // du talweg. Verifie sur la dalle reelle : 4 points retenus la ou le critere + // en quatre sondes en rendait 0 ou 12 selon le seuil. + int risingProbesRequired = 5; + + // Distance minimale entre deux points retenus, en m. 150 m : sans elle, une + // cuvette de 300 m de large rendrait quarante points collants. + float minSeparation = 150.0f; + + // Garde-fou : au-dela, on ne garde que les plus creux. Un joueur n'a pas + // besoin de plus, et une liste bornee garantit que la recherche du plus + // proche reste triviale a chaque image. + std::size_t maxSources = 64; +}; + +// Balaie le rectangle [minX, maxX] x [minZ, maxZ] (coordonnees monde, en m) et +// rend les points d'eau retenus, du plus creux au moins creux. +// +// Le rectangle est celui du terrain charge ; l'appelant le connait +// (Heightmap::halfSize), la fonction ne le devine pas - c'est ce qui lui permet +// de rester dependante du seul HeightSampler, comme Bike et Climber. +std::vector findWaterSources(const HeightSampler& terrain, + float minX, float maxX, + float minZ, float maxZ, + const WaterSurveyParams& params = {}); + +// Portee pour boire, en m, mesuree a l'HORIZONTALE. 4 m : un peu plus que le +// ramassage d'objet (2,5 m), parce qu'un point d'eau est une zone et non un +// objet pose au centimetre pres. +inline constexpr float kDrinkReach = 4.0f; + +// Point d'eau le plus proche d'une position, a l'horizontale. Renvoie nullptr +// si la liste est vide. outDistance, s'il est fourni, recoit la distance +// horizontale au point rendu. +const WaterSource* nearestWaterSource(const std::vector& sources, + const glm::vec3& position, + float* outDistance = nullptr); + +} // namespace vercora diff --git a/src/world/Weather.cpp b/src/world/Weather.cpp new file mode 100644 index 0000000..74bae11 --- /dev/null +++ b/src/world/Weather.cpp @@ -0,0 +1,890 @@ +#include "world/Weather.hpp" + +#include "core/HeightSampler.hpp" + +#include +#include + +namespace vercora { +namespace { + +constexpr float kPi = 3.14159265358979323846f; + +float clamp01(float value) { + if (!std::isfinite(value)) { + return 0.0f; + } + return std::clamp(value, 0.0f, 1.0f); +} + +float safeFinite(float value, float fallback = 0.0f) { + return std::isfinite(value) ? value : fallback; +} + +// --------------------------------------------------------------------------- +// Bruit deterministe 1D +// --------------------------------------------------------------------------- +// Bruit de GRADIENT (la famille de Perlin/Simplex), et non de valeur comme +// Heightmap et Vegetation. La raison est propre a ce module : un bruit de valeur +// atteint ses extremes SUR les noeuds entiers, donc a intervalles reguliers - +// une perturbation tomberait pile toutes les 3,5 journees de jeu, et le joueur +// le remarquerait en une semaine. Un bruit de gradient vaut zero sur les noeuds +// et place ses extremes entre eux, a des positions qui dependent des gradients +// tires : le calendrier meteo est irregulier, ce qui est le but. +// +// En 1D, Simplex et Perlin sont la MEME construction (le simplexe de dimension 1 +// est le segment) : parler de "Simplex 1D" comme le fait le cahier des charges +// et implementer un bruit de gradient 1D est la meme chose, sans le detour du +// gradient tabule d'une vraie implementation Simplex 2D+. +uint32_t hashU32(uint32_t x) { + // lowbias32 de Chris Wellons : melange complet, aucun motif visible sur des + // entrees consecutives - ce qui est exactement le cas d'usage ici, ou les + // noeuds sont 0, 1, 2, 3... + x ^= x >> 16; + x *= 0x7feb352du; + x ^= x >> 15; + x *= 0x846ca68bu; + x ^= x >> 16; + return x; +} + +// Gradient d'un noeud, dans [-1, 1). +float nodeGradient(int32_t node, uint32_t seed) { + const uint32_t h = hashU32(static_cast(node) * 0x9E3779B9u ^ seed); + return static_cast(h) * (2.0f / 4294967296.0f) - 1.0f; +} + +// Courbe de lissage de Perlin (6t^5 - 15t^4 + 10t^3) : ses derivees premiere ET +// seconde sont nulles aux noeuds, donc aucune cassure visible au raccord. +float smootherStep(float t) { + return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f); +} + +// Bruit de gradient 1D dans [-1, 1] environ. +float gradientNoise1D(float x, uint32_t seed) { + const float floored = std::floor(x); + const int32_t i0 = static_cast(floored); + const float f = x - floored; + + const float g0 = nodeGradient(i0, seed); + const float g1 = nodeGradient(i0 + 1, seed); + + const float n0 = g0 * f; + const float n1 = g1 * (f - 1.0f); + + // * 2 : un bruit de gradient 1D a gradients dans [-1, 1] plafonne a 0,5 en + // valeur absolue. Le facteur le ramene a la plage [-1, 1] annoncee. + return 2.0f * (n0 + (n1 - n0) * smootherStep(f)); +} + +// fBm : plusieurs octaves du bruit ci-dessus, normalise dans [-1, 1]. +float fbm1D(float x, uint32_t seed, int octaves) { + octaves = std::clamp(octaves, 1, 8); + + float sum = 0.0f; + float amplitude = 1.0f; + float frequency = 1.0f; + float total = 0.0f; + + for (int i = 0; i < octaves; ++i) { + sum += amplitude * gradientNoise1D(x * frequency, seed + static_cast(i) * 0x9E3779B9u); + total += amplitude; + amplitude *= 0.5f; + frequency *= 2.0f; + } + + return total > 0.0f ? sum / total : 0.0f; +} + +// --------------------------------------------------------------------------- +// Astronomie minimale +// --------------------------------------------------------------------------- +// Modele de position solaire "de poche" : declinaison de Cooper, angle horaire +// lineaire, pas d'equation du temps, pas de refraction, pas de longitude. +// +// C'est SUFFISANT et c'est un choix, pas un oubli : ce dont le jeu a besoin, +// c'est que le soleil se leve a l'est, culmine au sud, se couche a l'ouest, et +// que sa hauteur suive la saison. Les corrections omises valent au plus une +// quinzaine de minutes sur les heures de lever et coucher - invisible dans une +// horloge acceleree douze fois. +float solarDeclinationDegrees(float dayOfYear) { + // Cooper (1969) : delta = 23,44 * sin(360 * (284 + n) / 365). + return 23.44f * std::sin(2.0f * kPi * (284.0f + dayOfYear) / 365.0f); +} + +} // namespace + +// --------------------------------------------------------------------------- +// Geometrie du terrain +// --------------------------------------------------------------------------- + +glm::vec3 compassDirection(float degrees) { + // Convention du projet, verifiee dans Heightmap::toProjected : + // +X = EST, +Z = SUD. Le nord est donc -Z. + const float rad = glm::radians(degrees); + return glm::vec3(std::sin(rad), 0.0f, -std::cos(rad)); +} + +float terrainExposure(const HeightSampler& terrain, float worldX, float worldZ, + float sampleStep) { + const float s = sampleStep > 0.0f ? sampleStep : 2.0f; + + const float dhdx = (terrain.heightAt(worldX + s, worldZ) - + terrain.heightAt(worldX - s, worldZ)) / (2.0f * s); + const float dhdz = (terrain.heightAt(worldX, worldZ + s) - + terrain.heightAt(worldX, worldZ - s)) / (2.0f * s); + + const float slope = std::sqrt(dhdx * dhdx + dhdz * dhdz); + if (!(slope > 1e-6f)) { + return 0.5f; // du plat n'a ni adret ni ubac + } + + // +Z va vers le SUD. Un versant qui DESCEND vers le sud (dh/dz < 0) est un + // adret : d'ou le signe moins. + const float aspect = -dhdz / slope; // [-1, 1] + const float weight = std::min(1.0f, slope / kFullExposureSlope); + return std::clamp(0.5f + 0.5f * aspect * weight, 0.0f, 1.0f); +} + +glm::vec3 terrainNormal(const HeightSampler& terrain, float worldX, float worldZ, + float sampleStep) { + const float s = sampleStep > 0.0f ? sampleStep : 2.0f; + + const float dhdx = (terrain.heightAt(worldX + s, worldZ) - + terrain.heightAt(worldX - s, worldZ)) / (2.0f * s); + const float dhdz = (terrain.heightAt(worldX, worldZ + s) - + terrain.heightAt(worldX, worldZ - s)) / (2.0f * s); + + // Surface y = h(x, z) : la normale non normalisee vaut (-dh/dx, 1, -dh/dz). + return glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz)); +} + +// --------------------------------------------------------------------------- +// Lumiere du jour +// --------------------------------------------------------------------------- + +SunLight sunLightFor(const SynopticState& sky, const WeatherParams& params) { + SunLight light; + + // Intensite directe : elle monte avec le soleil et s'eteint au coucher. Le + // seuil lightFullDaylightSin donne l'aube et le crepuscule - sans lui, le + // jour s'allumerait d'un coup a l'instant ou l'elevation passe zero. + const float rise = clamp01(sky.daylight / std::max(1e-3f, params.lightFullDaylightSin)); + light.intensity = rise; + + // Direction : celle du soleil tant qu'il est leve, la verticale une fois + // couche. Le basculement se fait sur le meme facteur que l'intensite, donc + // il est invisible : quand la direction commence a remonter, la lumiere + // directe est deja presque eteinte. + const glm::vec3 up(0.0f, 1.0f, 0.0f); + const glm::vec3 blended = glm::mix(up, sky.sunDirection, rise); + light.direction = glm::length(blended) > 1e-4f ? glm::normalize(blended) : up; + + // Couleur : orangee quand le soleil rase, franche quand il est haut, bleutee + // une fois couche. + const glm::vec3 dayTint = glm::mix(params.horizonColor, params.daylightColor, rise); + light.color = rise > 0.0f ? dayTint : params.nightColor; + + // Ambiante : elle ne descend jamais a zero (voir nightAmbientFactor - c'est + // un choix de jouabilite assume, le jeu n'a encore aucune source de lumiere + // portable). + // + // PHASE 27 - CORRECTION D'UN COMMENTAIRE MENSONGER. Ce paragraphe affirmait + // depuis la Phase 23 que l'ambiante etait "ecrasee par les nuages en plein + // jour". Le code n'a JAMAIS lu la nebulosite. L'effet des nuages sur la + // lumiere existe desormais, mais dans weatherVisualsFor(), qui part de cette + // fonction ; celle-ci reste la lumiere d'un ciel CLAIR. + const float night = std::clamp(params.nightAmbientFactor, 0.0f, 1.0f); + light.ambient = night + (1.0f - night) * rise; + + // Ciel : nuit -> crepuscule -> plein jour, en deux segments. Le crepuscule + // occupe la premiere moitie de la montee du soleil, ce qui donne une aube et + // un coucher qui DURENT au lieu d'un fondu direct du noir au bleu. + light.skyColor = rise < 0.5f + ? glm::mix(params.nightSkyColor, params.duskSkyColor, rise * 2.0f) + : glm::mix(params.duskSkyColor, params.daySkyColor, + (rise - 0.5f) * 2.0f); + + return light; +} + +// --------------------------------------------------------------------------- +// PHASE 27 - Meteo visible +// --------------------------------------------------------------------------- + +WeatherVisuals weatherVisualsFor(const SynopticState& sky, const WeatherSample& local, + const WeatherParams& params) { + WeatherVisuals visuals; + visuals.light = sunLightFor(sky, params); + + // La nebulosite LOCALE et non synoptique : c'est celle que voit le joueur, + // renforcement orographique compris (un versant au vent s'accroche des + // nuages que la vallee n'a pas - section 7 des parametres). + const float cloud = clamp01(safeFinite(local.cloudCover)); + const float rise = visuals.light.intensity; // 0 la nuit, 1 en plein jour + + // --- Rayonnement direct voile ------------------------------------------ + // MEME loi et MEME chiffre que l'extinction de l'adret dans sampleAt() : + // sous un ciel couvert, il ne reste que (1 - cloudAspectDamping) du + // rayonnement direct. Une seule definition de "les nuages cachent le + // soleil" - l'indice visuel adret/ubac (Phase 25) l'utilise deja aussi. + const float directKept = std::max(0.0f, 1.0f - params.cloudAspectDamping * cloud); + visuals.light.intensity *= directKept; + + // --- Ambiante diffuse --------------------------------------------------- + // Renforcee de jour seulement (facteur rise) : c'est le soleil que les + // nuages diffusent, il n'y a rien a diffuser la nuit. + // + // PAS d'ecretage a 1 : le multiplicateur d'ambiante DEPASSE 1 sous un ciel + // couvert, c'est tout l'objet de ce terme. La premiere version l'ecretait a + // [0, 1] (comme sunLightFor, qui n'en avait jamais eu besoin) - et comme + // l'ambiante de plein jour vaut deja 1, le gain etait MORT : le journal des + // captures affichait "ambiante x1.00" sous 99 % de nuages. + visuals.light.ambient = std::max( + 0.0f, visuals.light.ambient * (1.0f + std::max(0.0f, params.overcastAmbientGain) * + cloud * rise)); + + // --- Ciel grise --------------------------------------------------------- + // Desature vers sa PROPRE luminance puis assombri : la luminosite du ciel + // continue de suivre le cycle jour/nuit, seule sa couleur tombe au gris. + const glm::vec3 clearSky = visuals.light.skyColor; + const float luminance = glm::dot(clearSky, glm::vec3(0.2126f, 0.7152f, 0.0722f)); + const glm::vec3 overcastSky = glm::vec3(luminance * params.overcastSkyDarkening); + visuals.light.skyColor = glm::mix(clearSky, overcastSky, cloud); + + // --- Precipitation ------------------------------------------------------ + const float precip = std::max(0.0f, safeFinite(local.precipitationMmPerHour)); + visuals.snow = local.snowing; + visuals.precipitation = + clamp01(precip / std::max(1e-3f, params.precipitationMaxMmPerHour)); + + // Vitesse de chute apparente : le vent LOCAL (celui que le joueur subit) et + // une vitesse verticale de chute. Le vent incline donc la pluie dans le sens + // ou il souffle reellement a cet endroit, sondage amont et col compris. + const float fall = visuals.snow ? params.snowFallSpeedMps : params.rainFallSpeedMps; + visuals.fallVelocity = glm::vec3(local.windVector.x, -fall, local.windVector.z); + + // --- Brouillard de distance --------------------------------------------- + // Seule source : la precipitation. Loi de puissance sigma = a R^b (1/km), + // multipliee pour la neige. AUCUN brouillard sans precipitation : le modele + // ne connait ni l'humidite relative, ni le point de rosee, ni la base des + // nuages, donc il n'a rien pour dire qu'il y a de la brume par temps sec. + // Voir NOTES-PHASE27.md, "Prerequis manquants". + if (precip > 0.0f) { + float sigmaPerKm = params.rainExtinctionPerKm * + std::pow(precip, params.rainExtinctionExponent); + if (visuals.snow) { + sigmaPerKm *= params.snowExtinctionMultiplier; + } + visuals.fogDensityPerMeter = std::max(0.0f, sigmaPerKm) / 1000.0f; + } + // Le brouillard se fond dans le ciel : sans ca, le relief lointain + // tournerait a une couleur que rien d'autre a l'ecran ne porte. + visuals.fogColor = visuals.light.skyColor; + + // --- Sol mouille -------------------------------------------------------- + visuals.groundDarkening = + clamp01(params.wetGroundDarkening * clamp01(safeFinite(local.wetness))); + + return visuals; +} + +// --------------------------------------------------------------------------- +// Refroidissement eolien +// --------------------------------------------------------------------------- + +float windChillC(float temperatureC, float windMps) { + const float t = safeFinite(temperatureC); + const float v = std::max(0.0f, safeFinite(windMps)); + + const float kmh = v * 3.6f; + + // Domaine de validite publie de la formule JAG/TI. En dehors, on rend la + // temperature inchangee : mieux vaut n'appliquer AUCUN effet qu'appliquer un + // effet faux (a 25 degres la formule rendrait un vent rechauffant). + if (t > 10.0f || kmh < 4.8f) { + return t; + } + + const float p = std::pow(kmh, 0.16f); + const float chilled = 13.12f + 0.6215f * t - 11.37f * p + 0.3965f * t * p; + + // Garde-fou : le ressenti ne peut pas DEPASSER l'ambiante par vent fort et + // froid. La formule le respecte dans son domaine, l'ecretage protege des + // bords. + return std::min(chilled, t); +} + +// --------------------------------------------------------------------------- +// SynopticState / WeatherSample : descriptions +// --------------------------------------------------------------------------- +namespace { + +std::string round1(float value) { + // Une decimale, sans : le reste du projet ecrit ses journaux avec + // std::to_string, on garde la meme dependance. + const float rounded = std::round(value * 10.0f) / 10.0f; + std::string text = std::to_string(rounded); + const std::size_t dot = text.find('.'); + if (dot != std::string::npos && text.size() > dot + 2) { + text.erase(dot + 2); + } + return text; +} + +} // namespace + +std::string SynopticState::describe() const { + return "meteo j+" + std::to_string(static_cast(gameHours / 24.0f)) + + " " + round1(timeOfDayHours) + "h : " + round1(seaLevelTemperatureC) + + " C (niveau mer), vent " + round1(seaLevelWindMps) + " m/s de " + + std::to_string(static_cast(std::round(windFromDegrees))) + + " deg, nuages " + std::to_string(static_cast(std::round(cloudCover * 100.0f))) + + " %, pluie " + round1(precipitationMmPerHour) + " mm/h, soleil " + + round1(sunElevationDegrees) + " deg"; +} + +std::string WeatherSample::describe() const { + return "local : " + round1(temperatureC) + " C (gradient " + round1(lapseC) + + ", versant " + round1(aspectC) + ", inversion " + round1(inversionC) + + "), vent " + round1(windMps) + " m/s, vertical " + round1(verticalMps) + + " m/s (pente " + round1(ridgeLiftMps) + ", thermique " + round1(thermalMps) + + ", subsidence " + round1(subsidenceMps) + "), turbulence " + + round1(turbulence) + ", mouillure " + round1(wetness); +} + +// --------------------------------------------------------------------------- +// ColdAirTrapMap +// --------------------------------------------------------------------------- + +constexpr float ColdAirTrapMap::kProbeRadii[3]; + +ColdAirTrapMap::ColdAirTrapMap(const HeightSampler& terrain, float halfSize, + uint32_t resolution) + : resolution_(resolution), halfSize_(halfSize) { + if (resolution < 2 || !(halfSize > 0.0f)) { + // Construction impossible : on reste une carte VIDE, donc un index nul + // partout. Le systeme meteo continue de fonctionner sans inversion, ce + // qui est le repli documente. + resolution_ = 0; + halfSize_ = 0.0f; + return; + } + + values_.resize(static_cast(resolution) * resolution, 0.0f); + + const float span = 2.0f * halfSize; + const float step = span / static_cast(resolution - 1); + + // Huit directions : les quatre points cardinaux et les quatre diagonales. + // Huit et non quatre parce qu'une vallee orientee en diagonale serait vue + // comme ouverte par un echantillonnage cardinal seul. + constexpr int kDirections = 8; + + double total = 0.0; + float maxValue = 0.0f; + + for (uint32_t iz = 0; iz < resolution; ++iz) { + const float z = -halfSize + static_cast(iz) * step; + for (uint32_t ix = 0; ix < resolution; ++ix) { + const float x = -halfSize + static_cast(ix) * step; + const float h0 = terrain.heightAt(x, z); + + float enclosure = 0.0f; + int probes = 0; + + for (int d = 0; d < kDirections; ++d) { + const float angle = 2.0f * kPi * static_cast(d) / + static_cast(kDirections); + const float dx = std::cos(angle); + const float dz = std::sin(angle); + + for (float radius : kProbeRadii) { + const float h = terrain.heightAt(x + dx * radius, z + dz * radius); + + // Ce qui compte est le RELIEF AU-DESSUS de la cellule, et + // seulement lui : du terrain plus bas dans une direction est + // une FUITE pour l'air froid, elle ne contribue pas + // negativement, elle contribue simplement zero. Un point + // ouvert dans une seule direction reste largement moins + // piegeant qu'un point ferme partout, ce qui est le bon + // comportement et sort tout seul de la moyenne. + enclosure += clamp01((h - h0) / kFullEnclosureRise); + ++probes; + } + } + + const float value = probes > 0 ? enclosure / static_cast(probes) : 0.0f; + values_[static_cast(iz) * resolution + ix] = value; + total += value; + maxValue = std::max(maxValue, value); + } + } + + maxValue_ = maxValue; + meanValue_ = values_.empty() ? 0.0f + : static_cast(total / static_cast(values_.size())); +} + +float ColdAirTrapMap::at(float worldX, float worldZ) const { + if (values_.empty() || resolution_ < 2) { + return 0.0f; + } + + const float span = 2.0f * halfSize_; + const float step = span / static_cast(resolution_ - 1); + + // Ecretage AVANT interpolation : c'est le contrat de TOTALITE de + // HeightSampler::heightAt applique ici - un point hors emprise rend la + // valeur du bord, jamais une erreur. + const float fx = std::clamp((safeFinite(worldX) + halfSize_) / step, 0.0f, + static_cast(resolution_ - 1)); + const float fz = std::clamp((safeFinite(worldZ) + halfSize_) / step, 0.0f, + static_cast(resolution_ - 1)); + + const uint32_t x0 = static_cast(fx); + const uint32_t z0 = static_cast(fz); + const uint32_t x1 = std::min(x0 + 1u, resolution_ - 1u); + const uint32_t z1 = std::min(z0 + 1u, resolution_ - 1u); + + const float tx = fx - static_cast(x0); + const float tz = fz - static_cast(z0); + + const auto value = [this](uint32_t ix, uint32_t iz) { + return values_[static_cast(iz) * resolution_ + ix]; + }; + + const float top = value(x0, z0) + (value(x1, z0) - value(x0, z0)) * tx; + const float bottom = value(x0, z1) + (value(x1, z1) - value(x0, z1)) * tx; + return top + (bottom - top) * tz; +} + +// --------------------------------------------------------------------------- +// WeatherSystem - COUCHE 1 +// --------------------------------------------------------------------------- + +WeatherSystem::WeatherSystem(const WeatherParams& params, uint32_t seed) + : params_(params), seed_(seed) {} + +float WeatherSystem::frontNoise(float gameHours, uint32_t channel) const { + const float periodHours = std::max(1.0f, params_.frontPeriodDays * 24.0f); + + // Le canal decale la GRAINE, pas la coordonnee : deux canaux sont alors des + // bruits independants, alors qu'un simple decalage temporel donnerait deux + // fois le meme temps qu'il fait, avec un jour de retard. + const uint32_t channelSeed = seed_ ^ hashU32(channel * 0x85EBCA6Bu + 1u); + const float raw = fbm1D(gameHours / periodHours, channelSeed, params_.frontOctaves); + + // Gain puis ecretage : voir WeatherParams::frontNoiseGain pour la raison, + // qui est un ECHEC DE TEST et non un reglage de gout - sans gain, le modele + // ne produisait ni grand beau ni vraie pluie. + return std::clamp(raw * params_.frontNoiseGain, -1.0f, 1.0f); +} + +SynopticState WeatherSystem::synopticAt(float gameHours) const { + SynopticState sky; + sky.gameHours = safeFinite(gameHours); + + // --- Calendrier --------------------------------------------------------- + sky.timeOfDayHours = std::fmod(sky.gameHours, 24.0f); + if (sky.timeOfDayHours < 0.0f) { + sky.timeOfDayHours += 24.0f; + } + sky.dayOfYear = std::fmod(params_.startDayOfYear + sky.gameHours / 24.0f, 365.0f); + if (sky.dayOfYear < 0.0f) { + sky.dayOfYear += 365.0f; + } + + // --- Soleil ------------------------------------------------------------- + const float declination = solarDeclinationDegrees(sky.dayOfYear); + const float latRad = glm::radians(params_.latitudeDegrees); + const float decRad = glm::radians(declination); + // Angle horaire : 15 degres par heure, nul au midi solaire. + const float hourAngle = glm::radians(15.0f * (sky.timeOfDayHours - 12.0f)); + + const float sinElevation = std::clamp( + std::sin(latRad) * std::sin(decRad) + + std::cos(latRad) * std::cos(decRad) * std::cos(hourAngle), + -1.0f, 1.0f); + const float elevation = std::asin(sinElevation); + sky.sunElevationDegrees = glm::degrees(elevation); + + const float cosElevation = std::cos(elevation); + float azimuth = 180.0f; // plein sud, valeur de repli au zenith exact + if (cosElevation > 1e-4f && std::cos(latRad) > 1e-4f) { + const float cosAzimuth = std::clamp( + (std::sin(decRad) - sinElevation * std::sin(latRad)) / + (cosElevation * std::cos(latRad)), + -1.0f, 1.0f); + azimuth = glm::degrees(std::acos(cosAzimuth)); + // acos rend [0, 180] : c'est le matin (soleil a l'est). L'apres-midi + // (angle horaire positif) se lit en miroir a l'ouest. + if (hourAngle > 0.0f) { + azimuth = 360.0f - azimuth; + } + } + sky.sunAzimuthDegrees = azimuth; + + // Vecteur DU POINT VERS LE SOLEIL. Verification a midi : azimut 180, donc + // sin(180) = 0 et -cos(180) = +1, soit +Z, soit le SUD. Conforme. + const glm::vec3 horizontal = compassDirection(azimuth); + sky.sunDirection = glm::vec3(horizontal.x * cosElevation, sinElevation, + horizontal.z * cosElevation); + if (glm::length(sky.sunDirection) > 1e-6f) { + sky.sunDirection = glm::normalize(sky.sunDirection); + } else { + sky.sunDirection = glm::vec3(0.0f, 1.0f, 0.0f); + } + + sky.daylight = std::max(0.0f, sinElevation); + + // --- Nebulosite (canal 1) ---------------------------------------------- + // Calculee AVANT la temperature parce que celle-ci en depend : un ciel + // couvert ecrase l'amplitude diurne. + const float cloudNoise = frontNoise(sky.gameHours, 1u); + sky.cloudCover = clamp01(params_.meanCloudCover + params_.cloudAmplitude * cloudNoise); + + // --- Temperature de reference ------------------------------------------ + // Saison : deux harmoniques. + const float seasonPhase = 2.0f * kPi * (sky.dayOfYear - params_.seasonalPeakDay) / 365.0f; + const float seasonal = params_.seasonalAmplitudeC * std::cos(seasonPhase) + + params_.seasonalHarmonic2C * std::cos(2.0f * seasonPhase); + + // Diurne : deux harmoniques, attenuees par les nuages. La deuxieme + // harmonique est ce qui rend le matin plus raide que le soir. + const float diurnalPhase = 2.0f * kPi * (sky.timeOfDayHours - params_.diurnalPeakHour) / 24.0f; + const float cloudDamping = 1.0f - params_.cloudDiurnalDamping * sky.cloudCover; + const float diurnal = (params_.diurnalAmplitudeC * std::cos(diurnalPhase) + + params_.diurnalHarmonic2C * std::cos(2.0f * diurnalPhase)) * + cloudDamping; + + // Masse d'air (canal 0). + const float airMass = params_.frontTemperatureAmplitudeC * frontNoise(sky.gameHours, 0u); + + sky.seaLevelTemperatureC = params_.seaLevelAnnualMeanC + seasonal + diurnal + airMass; + + // --- Vent (canaux 2 et 3) ---------------------------------------------- + // Le renfort de vent est pris en VALEUR ABSOLUE du bruit : un front qui + // passe fait forcir le vent, qu'il apporte du chaud ou du froid. Sans la + // valeur absolue, la moitie des perturbations produirait un vent NEGATIF, + // donc un calme plat aussi frequent que la tempete. + const float windNoise = std::abs(frontNoise(sky.gameHours, 2u)); + sky.seaLevelWindMps = std::max(0.0f, params_.baseWindMps + + params_.frontWindAmplitudeMps * windNoise); + + const float directionNoise = frontNoise(sky.gameHours, 3u); + sky.windFromDegrees = params_.meanWindFromDegrees + + params_.windDirectionSwingDegrees * directionNoise; + sky.windFromDegrees = std::fmod(sky.windFromDegrees, 360.0f); + if (sky.windFromDegrees < 0.0f) { + sky.windFromDegrees += 360.0f; + } + + // --- Precipitations ----------------------------------------------------- + // Rien en dessous du seuil, puis montee lineaire jusqu'a l'intensite + // maximale a nebulosite 1. + const float threshold = std::clamp(params_.precipitationCloudThreshold, 0.0f, 0.999f); + if (sky.cloudCover > threshold) { + const float excess = (sky.cloudCover - threshold) / (1.0f - threshold); + sky.precipitationMmPerHour = params_.precipitationMaxMmPerHour * clamp01(excess); + } + + return sky; +} + +// --------------------------------------------------------------------------- +// WeatherSystem - COUCHE 2 +// --------------------------------------------------------------------------- + +float WeatherSystem::aspectSignal(const glm::vec3& normal, + const glm::vec3& sunDirection, bool sunUp) const { + // Le cosinus d'incidence du point, compare a celui qu'aurait du terrain PLAT + // au meme instant. Les deux sont ecretes a zero : une surface qui tourne le + // dos au soleil ne recoit pas un rayonnement negatif, elle n'en recoit pas. + const float incidence = sunUp ? std::max(0.0f, glm::dot(normal, sunDirection)) + : 0.0f; + const float flatIncidence = std::max(0.0f, sunDirection.y); + return std::clamp( + (incidence - flatIncidence) / std::max(1e-3f, params_.aspectIncidenceReference), + -1.0f, 1.0f); +} + +float WeatherSystem::aspectExposureAt(const glm::vec3& position, + const HeightSampler* terrain) const { + // Pas de relief, pas de versant. Le repli est la meme convention que celle + // de sampleAt avec un terrain nul. + if (terrain == nullptr) { return 0.0f; } + + // MIDI, et le meme midi pour tout le monde. C'est ce qui fait de cette + // grandeur un CLIMAT et non une meteo : la valeur rendue pour un point donne + // ne depend d'aucune horloge, donc une essence d'arbre ne peut pas changer + // entre deux images. Le jour de l'annee retenu est celui de l'origine de + // partie ; la saison deplace l'elevation du soleil de midi mais pas + // l'ORDRE des versants, qui est tout ce dont l'appelant a besoin. + const SynopticState noon = synopticAt(12.0f); + + const glm::vec3 normal = terrainNormal(*terrain, safeFinite(position.x), + safeFinite(position.z)); + // sunUp force a true : a midi le soleil l'est, sauf a une latitude polaire + // que ce jeu n'a pas, et le forcer evite de faire dependre une propriete + // permanente du relief d'un test qui pourrait basculer. + return aspectSignal(normal, noon.sunDirection, /*sunUp=*/true); +} + +WeatherSample WeatherSystem::sampleAt(const glm::vec3& position, float gameHours, + const HeightSampler* terrain) const { + return sampleAt(position, synopticAt(gameHours), terrain); +} + +WeatherSample WeatherSystem::sampleAt(const glm::vec3& position, const SynopticState& sky, + const HeightSampler* terrain) const { + WeatherSample out; + + const float x = safeFinite(position.x); + const float y = safeFinite(position.y); + const float z = safeFinite(position.z); + const float altitudeKm = y / 1000.0f; + + out.cloudCover = sky.cloudCover; + + // ======================================================================= + // Geometrie locale : une seule lecture de normale, reutilisee partout. + // ======================================================================= + glm::vec3 normal(0.0f, 1.0f, 0.0f); + if (terrain != nullptr) { + normal = terrainNormal(*terrain, x, z); + } + + // ======================================================================= + // 1. Temperature locale + // ======================================================================= + + // --- Gradient altitudinal ---------------------------------------------- + // MEME mecanisme que NeedsParams::lapseRateCPerKm (Phase 16) - et non un + // second gradient qui coexisterait avec lui : le parametre a ete DEPLACE + // ici, il n'existe plus dans Needs. + out.lapseC = -params_.lapseRateCPerKm * altitudeKm; + + // --- Adret / ubac par produit scalaire --------------------------------- + // Le cosinus d'incidence du point, compare a celui qu'aurait du terrain PLAT + // au meme instant. Les deux sont ecretes a zero : une surface qui tourne le + // dos au soleil ne recoit pas un rayonnement negatif, elle n'en recoit pas. + // Le signal lui-meme vit dans aspectSignal() depuis la Phase 26 : la Phase 26 + // en a besoin AU SOLEIL DE MIDI pour decider des essences d'arbres, et la + // pire facon de le lui donner aurait ete d'en recopier la formule ailleurs. + // Ce qui reste ici est ce qui appartient VRAIMENT a la meteo de l'instant : + // la force du soleil et l'attenuation par les nuages. + const float signal = aspectSignal(normal, sky.sunDirection, sky.daylight > 0.0f); + + // LE SOLEIL DOIT ETRE LEVE. Sans cette condition, l'ecart d'incidence + // continuait de se calculer avec un soleil SOUS l'horizon et rendait un + // versant sud plus chaud de 2,9 degres a deux heures du matin - un echec de + // test, pas une hypothese. Le second facteur eteint progressivement l'effet + // quand le soleil est rasant, ce qui est aussi le comportement reel. + const float sunStrength = clamp01(sky.daylight / + std::max(1e-3f, params_.aspectFullDaylightSin)); + out.aspectC = params_.aspectBonusC * signal * sunStrength * + (1.0f - params_.cloudAspectDamping * sky.cloudCover); + + // ======================================================================= + // 2. Vent local - SONDAGE AMONT + // ======================================================================= + // Vent de reference au point : le synoptique corrige de l'altitude. C'est + // deja un vent "en air libre" ; tout ce qui suit est la reponse du RELIEF. + const float referenceWind = + std::max(0.0f, sky.seaLevelWindMps + params_.windAltitudeGainMpsPerKm * altitudeKm); + + const glm::vec3 fromWind = compassDirection(sky.windFromDegrees); // vers l'AMONT + const glm::vec3 flow = -fromWind; // sens du deplacement de l'air + + float speedFactor = 1.0f; + float exposureSignal = 0.0f; // > 0 expose, < 0 abrite + float slopeAlongFlow = 0.0f; // > 0 : le terrain monte dans le sens du vent + + if (terrain != nullptr) { + const float h0 = terrain->heightAt(x, z); + + const float hNear = terrain->heightAt(x + fromWind.x * params_.upwindNearMeters, + z + fromWind.z * params_.upwindNearMeters); + const float hMid = terrain->heightAt(x + fromWind.x * params_.upwindMidMeters, + z + fromWind.z * params_.upwindMidMeters); + const float hFar = terrain->heightAt(x + fromWind.x * params_.upwindFarMeters, + z + fromWind.z * params_.upwindFarMeters); + + // COMBINAISON DES TROIS ECHELLES : un MAXIMUM d'abri contre un MINIMUM + // d'exposition, et surtout PAS une moyenne des trois altitudes. + // + // La premiere version faisait cette moyenne ponderee, et elle etait + // fausse - le test l'a montre. Un point situe 250 m sous le vent d'une + // crete de 200 m, donc dans un abri franc, obtenait un signal 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 lui-meme, 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 le max d'un + // cote et le min de l'autre. + const float relief = std::max(1.0f, params_.exposureReliefMeters); + const float shelter = std::max({clamp01((hNear - h0) / relief), + clamp01((hMid - h0) / relief), + clamp01((hFar - h0) / relief)}); + const float dominance = std::min({clamp01((h0 - hNear) / relief), + clamp01((h0 - hMid) / relief), + clamp01((h0 - hFar) / relief)}); + + // Les deux ne peuvent pas etre non nuls en meme temps (l'un exige d'etre + // sous une sonde, l'autre d'etre au-dessus de toutes) : la difference est + // donc bien un signal unique dans [-1, 1], positif = expose. + exposureSignal = std::clamp(dominance - shelter, -1.0f, 1.0f); + + speedFactor = 1.0f + (exposureSignal > 0.0f + ? exposureSignal * params_.exposureWindGain + : exposureSignal * params_.shelterWindReduction); + + // --- Retrecissement (Venturi) -------------------------------------- + // Deux sondes PERPENDICULAIRES au vent. Si les deux epaules dominent le + // point, le flux passe par un entonnoir et accelere. + const glm::vec3 lateral(flow.z, 0.0f, -flow.x); + const float hLeft = terrain->heightAt(x + lateral.x * params_.lateralMeters, + z + lateral.z * params_.lateralMeters); + const float hRight = terrain->heightAt(x - lateral.x * params_.lateralMeters, + z - lateral.z * params_.lateralMeters); + + const float gap = std::min(hLeft, hRight) - h0; + const float venturiSignal = clamp01(gap / std::max(1.0f, params_.venturiReliefMeters)); + + // POURQUOI CETTE PONDERATION EXISTE, et ce qu'elle corrige : 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, ce qui est exactement l'inverse de la + // realite. + const float venturiWeight = clamp01(0.5f + 0.5f * exposureSignal); + speedFactor *= 1.0f + params_.venturiWindGain * venturiSignal * venturiWeight; + + // --- Pente dans le sens du vent, pour le ridge lift ---------------- + slopeAlongFlow = (h0 - hNear) / std::max(1.0f, params_.upwindNearMeters); + } + + out.windMps = std::clamp(referenceWind * speedFactor, 0.0f, params_.maxLocalWindMps); + out.windVector = flow * out.windMps; + + // ======================================================================= + // 3. Composante verticale + // ======================================================================= + + // --- Ridge lift --------------------------------------------------------- + // L'air suit le relief : s'il monte d'une pente s en avancant a la vitesse + // U, sa vitesse verticale vaut s * U, moins un rendement (une partie du flux + // contourne au lieu de monter). + if (slopeAlongFlow > 0.0f) { + out.ridgeLiftMps = std::min(params_.maxRidgeLiftMps, + params_.ridgeLiftEfficiency * slopeAlongFlow * out.windMps); + } + + // --- Subsidence et turbulence sous le vent ------------------------------ + // Un point nettement plus bas que son amont est SOUS LE VENT du relief : + // l'air y redescend et il y est desordonne. Les deux effets grandissent avec + // le vent - sans vent, un versant sous le vent est parfaitement calme. + const float leeFactor = clamp01(-exposureSignal); + + // L'intensite se mesure sur le vent DE REFERENCE et non sur le vent local, et + // ce n'est pas un detail : le vent local d'un point sous le vent est + // justement FAIBLE (c'est ce que le facteur d'abri vient de calculer), alors + // que ce qui l'agite est le flux qui vient de decoller de la crete, lequel a + // la vitesse AMONT. Prendre le vent local rendait un sillage d'autant plus + // calme qu'il etait plus abrite - exactement l'inverse de la realite. + const float windIntensity = + clamp01(referenceWind / std::max(1.0f, params_.turbulenceFullWindMps)); + out.subsidenceMps = params_.leeSubsidenceMps * leeFactor * windIntensity; + out.turbulence = clamp01(params_.leeTurbulenceMax * leeFactor * windIntensity); + + // --- Thermiques --------------------------------------------------------- + // Pilotees par l'INSOLATION du sol (le meme cosinus d'incidence que + // l'adret/ubac : un seul calcul de "combien de soleil ce versant prend"), + // et par l'heure - le flux de chaleur du sol culmine avant la temperature. + const float incidence = (sky.daylight > 0.0f) ? std::max(0.0f, glm::dot(normal, sky.sunDirection)) : 0.0f; + if (sky.daylight > 0.0f && incidence > 0.0f) { + const float hourOffset = (sky.timeOfDayHours - params_.thermalPeakHour) / + std::max(0.5f, params_.thermalHalfWidthHours); + const float timeWindow = std::max(0.0f, 1.0f - hourOffset * hourOffset); + const float cloudFactor = 1.0f - params_.cloudThermalDamping * sky.cloudCover; + out.thermalMps = params_.thermalMaxMps * incidence * timeWindow * + std::max(0.0f, cloudFactor); + } + + out.verticalMps = out.ridgeLiftMps + out.thermalMps + out.subsidenceMps; + + // ======================================================================= + // 4. Precipitations locales et etat du sol + // ======================================================================= + // Barriere orographique VOLONTAIREMENT SIMPLE : un versant que le flux doit + // gravir souleve la masse d'air, donc il pleut plus. L'ombre pluviometrique + // sous le vent n'est PAS modelisee au-dela de l'absence de renforcement - + // c'est la limite assumee de cette session, notee dans NOTES-PHASE23.md. + const float orographicSignal = + clamp01(slopeAlongFlow / std::max(1e-3f, params_.orographicFullSlope)); + const float orographic = (1.0f + params_.orographicGain * orographicSignal) * + (1.0f + params_.precipitationAltitudeGainPerKm * altitudeKm); + + out.precipitationMmPerHour = std::max(0.0f, sky.precipitationMmPerHour * orographic); + out.cloudCover = clamp01(sky.cloudCover + params_.orographicCloudGain * orographicSignal); + + out.temperatureC = sky.seaLevelTemperatureC + out.lapseC + out.aspectC; + + // --- Inversion de fond de cuvette -------------------------------------- + // Calculee APRES la temperature de base parce qu'elle depend du vent (qui + // brasse) et de la nebulosite (qui empeche le rayonnement nocturne), et + // APPLIQUEE ensuite. Trois conditions doivent etre reunies pour qu'une + // inversion s'installe, et le produit des trois les exprime directement : + // il faut un creux ferme, il faut la NUIT, et il faut un ciel clair et + // calme. + if (trapMap_ != nullptr && !trapMap_->empty()) { + const float trap = clamp01(trapMap_->at(x, z)); + const float nightFactor = 1.0f - clamp01(sky.daylight * 3.0f); + const float clearFactor = 1.0f - sky.cloudCover; + const float calmFactor = + 1.0f - clamp01(out.windMps / std::max(0.1f, params_.inversionMixingWindMps)); + out.inversionC = params_.inversionMaxC * trap * nightFactor * clearFactor * calmFactor; + out.temperatureC += out.inversionC; + } + + out.snowing = out.precipitationMmPerHour > 0.0f && + out.temperatureC <= params_.snowThresholdC; + + out.wetness = groundWetness(sky.gameHours, y, orographic); + + return out; +} + +float WeatherSystem::groundWetness(float gameHours, float altitudeMeters, + float orographicFactor) const { + const float now = safeFinite(gameHours); + const int samples = std::clamp(params_.wetnessSamples, 1, 32); + const float window = std::max(0.1f, params_.wetnessMemoryHours); + const float drying = std::max(0.1f, params_.dryingTimeHours); + const float oro = std::max(0.0f, safeFinite(orographicFactor, 1.0f)); + const float altitudeKm = safeFinite(altitudeMeters) / 1000.0f; + const float altitudeGain = 1.0f + params_.precipitationAltitudeGainPerKm * altitudeKm; + + // NON INTEGREE, RELUE : on remonte le temps dans la fonction synoptique - qui + // est pure - au lieu d'accumuler image par image. C'est ce qui garantit + // qu'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. + float wettest = 0.0f; + for (int i = 0; i < samples; ++i) { + const float age = window * (static_cast(i) + 0.5f) / static_cast(samples); + const SynopticState past = synopticAt(now - age); + + const float precip = past.precipitationMmPerHour * oro * altitudeGain; + const float soaked = clamp01(precip / std::max(0.01f, params_.wetnessSaturationMmPerHour)); + const float dried = std::exp(-age / drying); + wettest = std::max(wettest, soaked * dried); + } + + return clamp01(wettest); +} + +} // namespace vercora diff --git a/src/world/Weather.hpp b/src/world/Weather.hpp new file mode 100644 index 0000000..b179ee4 --- /dev/null +++ b/src/world/Weather.hpp @@ -0,0 +1,991 @@ +#pragma once + +#include +#include +#include + +#include + +namespace vercora { + +class HeightSampler; + +// =========================================================================== +// PHASE 23 - Systeme meteo deterministe +// =========================================================================== +// +// CE QUE CE MODULE EST, en une phrase : une FONCTION D'ETAT PURE. Pour un point +// (x, y, z) et un instant t, il rend l'etat meteo exact, sans aucun etat cache +// et sans aucune integration dependante du pas de temps. +// +// La consequence de jeu est celle demandee par le cahier des charges : deux +// joueurs qui arrivent au meme endroit au meme instant de jeu 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 fois ou la partie a ete mise en +// pause. C'est aussi ce qui rend le systeme testable : un test peut sauter +// directement a t = 137 h sans simuler les 137 heures. +// +// Contraste explicite avec Needs (Phase 16) : les quatre jauges, elles, +// INTEGRENT dans le temps - elles ont une memoire, c'est leur role. Ce module +// n'en a aucune. La seule grandeur qui pourrait sembler avoir de la memoire (la +// mouillure du sol, qui depend de la pluie recente) est obtenue en RELISANT le +// passe de la fonction synoptique, pas en accumulant : voir groundWetness(). +// +// --------------------------------------------------------------------------- +// DEUX COUCHES +// --------------------------------------------------------------------------- +// Couche 1, synoptique (0D) : l'etat macro du massif a l'instant t. Saison, +// cycle diurne, passage de perturbations. Ne connait AUCUNE position. +// -> SynopticState / WeatherSystem::synopticAt() +// +// Couche 2, spatialisation (3D) : la reponse du terrain a cet etat macro en un +// point donne. Gradient altitudinal, adret/ubac, inversion de fond de +// cuvette, vent local par sondage amont, renforcement orographique. +// -> WeatherSample / WeatherSystem::sampleAt() +// +// --------------------------------------------------------------------------- +// AVERTISSEMENT SUR LES VALEURS NUMERIQUES - A LIRE AVANT DE S'Y FIER +// --------------------------------------------------------------------------- +// AUCUNE des valeurs de WeatherParams 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, et regroupes ICI - dans une seule struct - +// precisement pour pouvoir etre remplaces en bloc apres une vraie relecture +// scientifique. +// +// Ce qui est en revanche implemente serieusement et ne depend pas de ces +// chiffres : l'ARCHITECTURE (purete, determinisme, separation des deux couches) +// et les MECANISMES (comment un gradient, un sondage amont ou une inversion se +// calculent). Changer les chiffres change l'intensite des phenomenes, pas leur +// existence ni leur signe. Les tests headless verifient donc des PROPRIETES +// ("un adret est plus chaud qu'un ubac", "un col vente plus qu'un plateau") et +// jamais des valeurs absolues. +// +// Chaque champ ci-dessous porte, en commentaire : ce qu'il fait, sa valeur +// provisoire, et d'ou elle sort. +// =========================================================================== + +// --------------------------------------------------------------------------- +// Constantes provisoires - LE SEUL ENDROIT A MODIFIER APRES RECALIBRAGE +// --------------------------------------------------------------------------- +struct WeatherParams { + // ======================================================================= + // 1. TEMPS ET SAISON + // ======================================================================= + + // Jour de l'annee du debut de partie, dans [0, 365). 135 = mi-mai : une fin + // de printemps en moyenne montagne, qui est le climat que decrivaient deja + // les parametres de la Phase 16 (7 degres de moyenne a 1200 m). + // PROVISOIRE : c'est un choix de decor, pas une mesure. + float startDayOfYear = 135.0f; + + // Latitude du massif, en degres. 45,0 : la dalle LiDAR chargee est en Isere + // (Le Gua), donc tout pres du 45e parallele. C'est la seule valeur de ce + // fichier qui soit un FAIT plutot qu'un reglage. + float latitudeDegrees = 45.0f; + + // ======================================================================= + // 2. TEMPERATURE DE REFERENCE (couche 1) + // ======================================================================= + + // Moyenne annuelle au NIVEAU DE LA MER, en degres. 11,0 - un peu plus bas + // que les 15,0 de NeedsParams (Phase 16), parce que ce 15,0 englobait + // implicitement la saison : ici la saison est explicite et s'y ajoute. + // PROVISOIRE. + float seaLevelAnnualMeanC = 11.0f; + + // Demi-amplitude du cycle SAISONNIER au niveau de la mer, en degres. 9,0 + // donne 18 degres d'ecart entre le coeur de l'hiver et celui de l'ete. + // PROVISOIRE. + float seasonalAmplitudeC = 9.0f; + + // Jour du maximum thermique annuel. 205 (fin juillet) et non le solstice + // (172) : le sol et l'air restituent avec un mois de retard. Le principe est + // reel, la valeur exacte est PROVISOIRE. + float seasonalPeakDay = 205.0f; + + // Deuxieme harmonique du cycle saisonnier, en degres. 1,2 : elle rend l'ete + // legerement plus large et l'hiver legerement plus creux qu'une sinusoide + // pure. Purement cosmetique a ce stade. PROVISOIRE. + float seasonalHarmonic2C = 1.2f; + + // Demi-amplitude du cycle DIURNE, en degres. 8,0 : valeur reprise telle + // quelle de NeedsParams::diurnalAmplitudeC (Phase 16), pour que le + // remplacement du calcul de temperature ne change pas silencieusement + // l'equilibre des besoins. PROVISOIRE, comme elle l'etait deja. + float diurnalAmplitudeC = 8.0f; + + // Heure du maximum thermique quotidien. 15,0, reprise de la Phase 16 : le + // sol restitue avec retard, le maximum n'est pas a midi. PROVISOIRE. + float diurnalPeakHour = 15.0f; + + // Deuxieme harmonique du cycle diurne, en degres. 1,0 : elle asymetrise la + // journee - le rechauffement du matin est plus rapide que le refroidissement + // du soir, ce qui est le comportement reel. PROVISOIRE. + float diurnalHarmonic2C = 1.0f; + + // Attenuation de l'amplitude diurne par la couverture nuageuse, sans unite. + // 0,60 : sous un ciel entierement couvert, l'ecart jour/nuit tombe a 40 % de + // sa valeur par ciel clair. Le MECANISME est reel et important (c'est lui + // qui fait qu'une nuit couverte est douce et une nuit claire glaciale) ; la + // valeur est PROVISOIRE. + float cloudDiurnalDamping = 0.60f; + + // Gradient thermique vertical, en degres par km. 6,5 = gradient adiabatique + // standard de l'atmosphere. Valeur reprise de NeedsParams::lapseRateCPerKm. + // C'est la moins provisoire des valeurs de ce fichier, mais un gradient reel + // varie de 4 (air humide) a 9,8 (air sec) : a recalibrer avec le + // climatologue si le realisme prime. + float lapseRateCPerKm = 6.5f; + + // ======================================================================= + // 3. PERTURBATIONS (couche 1) - bruit 1D en fonction du temps + // ======================================================================= + + // Duree caracteristique d'un systeme meteo, en JOURS de jeu. 3,5 : c'est la + // periode du bruit, donc la duree typique d'un cycle "beau temps -> + // degradation -> retour au beau". Ordre de grandeur reel pour un regime + // perturbe d'ouest en moyenne montagne. PROVISOIRE. + float frontPeriodDays = 3.5f; + + // Nombre d'octaves du bruit synoptique. 3 : assez pour qu'une perturbation + // ait de la structure (des accalmies dans un mauvais temps) sans devenir du + // bruit blanc. Ce n'est pas une valeur climatologique, c'est un reglage de + // texture. + int frontOctaves = 3; + + // Gain applique au bruit de perturbation avant ecretage dans [-1, 1]. 2,2. + // + // POURQUOI CE PARAMETRE EXISTE, et ce n'est pas un fudge : un fBm de bruit + // de gradient n'atteint PAS ses bornes theoriques. Sans gain, la nebulosite + // mesuree sur trente jours de jeu simules restait entre 0,20 et 0,70 - donc + // il n'y avait JAMAIS de grand beau (jamais de nuit claire, donc jamais + // d'inversion) et presque jamais de vraie pluie. Ce n'est pas un reglage de + // gout, c'est ce qui rend le modele capable de produire ses propres cas + // extremes ; les tests headless verifient qu'un mois de jeu contient bien + // des journees claires ET des journees de pluie. PROVISOIRE. + float frontNoiseGain = 2.2f; + + // Amplitude thermique d'une perturbation, en degres. 4,0 : une masse d'air + // froide fait 4 degres de moins que la moyenne de saison, une masse chaude 4 + // de plus. PROVISOIRE. + float frontTemperatureAmplitudeC = 4.0f; + + // Nebulosite moyenne, dans [0, 1]. 0,45 : un ciel a moitie couvert en + // moyenne, ce qui laisse de vraies journees claires et de vraies journees + // bouchees. PROVISOIRE. + float meanCloudCover = 0.45f; + + // Demi-amplitude de la nebulosite. 0,50 : combinee a la moyenne ci-dessus, + // elle permet d'atteindre 0 (grand beau) comme 0,95 (couvert). PROVISOIRE. + float cloudAmplitude = 0.50f; + + // Nebulosite au-dela de laquelle il PLEUT. 0,72 : un ciel couvert ne donne + // pas systematiquement de la pluie, il faut le haut de la fourchette. C'est + // ce seuil qui fixe la frequence des precipitations, et il est PROVISOIRE - + // c'est probablement la valeur la plus arbitraire du fichier. + float precipitationCloudThreshold = 0.72f; + + // Intensite de precipitation, en mm/h equivalents, atteinte a nebulosite 1. + // 6,0 : une pluie franche sans etre un orage. PROVISOIRE. + float precipitationMaxMmPerHour = 6.0f; + + // Temperature en dessous de laquelle la precipitation tombe en NEIGE. + // 1,0 degre et non 0 : la neige tient jusqu'a environ +1 degre dans l'air + // reel. Sert a NOMMER le phenomene ; aucun effet gameplay a ce stade. + float snowThresholdC = 1.0f; + + // ======================================================================= + // 4. VENT SYNOPTIQUE (couche 1) + // ======================================================================= + + // Direction moyenne d'ou VIENT le vent, en degres de cap compas + // (0 = nord, 90 = est). 270 = ouest : le regime dominant des Alpes du Nord. + // Le principe (un regime dominant existe) est solide, la valeur exacte est + // PROVISOIRE. + float meanWindFromDegrees = 270.0f; + + // Debattement de la direction autour de la moyenne, en degres. 75 : le vent + // balaie du sud-ouest au nord-ouest selon la perturbation, sans jamais + // devenir un vent d'est. PROVISOIRE. + float windDirectionSwingDegrees = 75.0f; + + // Vent synoptique de base au niveau de la mer, en m/s. 3,0 : une brise + // permanente, jamais un calme parfait. PROVISOIRE. + float baseWindMps = 3.0f; + + // Renfort de vent apporte par une perturbation, en m/s. 9,0 : le passage + // d'un front porte le vent de reference a 12 m/s (43 km/h) au niveau de la + // mer. PROVISOIRE. + float frontWindAmplitudeMps = 9.0f; + + // Augmentation du vent avec l'ALTITUDE, en m/s par km. 4,0 : le frottement + // du sol diminue avec la hauteur, une crete vente plus qu'une vallee meme + // sans effet de relief. C'est un mecanisme reel et de premier ordre ; la + // valeur est PROVISOIRE. + float windAltitudeGainMpsPerKm = 4.0f; + + // ======================================================================= + // 5. SPATIALISATION - TEMPERATURE (couche 2) + // ======================================================================= + + // Bonus thermique d'un adret en plein soleil, en degres. 4,0, repris de + // NeedsParams::exposureBonusC (Phase 16). PROVISOIRE. + float aspectBonusC = 4.0f; + + // Attenuation du bonus d'adret par les nuages. 0,85 : sous un ciel couvert, + // il ne reste que 15 % de l'ecart adret/ubac. Le mecanisme est reel (pas de + // rayonnement direct, pas d'adret) ; la valeur est PROVISOIRE. + float cloudAspectDamping = 0.85f; + + // Sinus d'elevation solaire au-dela duquel l'effet d'adret joue a PLEIN. + // 0,25, soit un soleil a 14,5 degres au-dessus de l'horizon. + // + // Ce parametre a ete AJOUTE APRES UN ECHEC DE TEST, et il vaut la peine de + // dire lequel : sans lui, un versant sud etait plus chaud qu'un ubac de + // 2,9 degres A DEUX HEURES DU MATIN. La cause etait que l'ecart d'incidence + // se calcule encore quand le soleil est SOUS l'horizon, ou il n'a plus + // aucun sens. Le facteur 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. PROVISOIRE. + float aspectFullDaylightSin = 0.25f; + + // Ecart de cosinus d'incidence qui vaut un effet d'adret COMPLET, sans + // unite. 0,35. + // + // A QUOI CA SERT, et pourquoi ce n'est pas un detail : l'adret/ubac est + // calcule par PRODUIT SCALAIRE entre la normale du terrain et la direction + // du soleil, compare a ce que recevrait du terrain PLAT au meme instant. La + // difference des deux est un ecart de cosinus, sans unite, qu'il faut bien + // convertir en degres - c'est ce que fait ce nombre. + // + // Le comportement qui en decoule est le bon, et il est meilleur que celui de + // la Phase 16 : a midi, soleil au zenith, un versant sud ne gagne presque + // rien (il est deja perpendiculaire au rayonnement) alors qu'un versant nord + // perd beaucoup ; au petit matin, un versant EST recoit le maximum, ce qu'un + // modele purement nord/sud ne pouvait pas produire. PROVISOIRE. + float aspectIncidenceReference = 0.35f; + + // Refroidissement MAXIMAL d'un fond de cuvette parfaitement piege par une + // nuit claire et calme, en degres. -6,0 : une inversion nocturne reelle en + // moyenne montagne atteint couramment 5 a 10 degres. PROVISOIRE, mais le + // signe et l'ordre de grandeur sont surs. + float inversionMaxC = -6.0f; + + // Vent au-dela duquel l'inversion est entierement BRASSEE, en m/s. 4,0 : de + // l'air froid ne stagne pas dans un fond de vallee vente. Mecanisme reel, + // valeur PROVISOIRE. + float inversionMixingWindMps = 4.0f; + + // ======================================================================= + // 6. SPATIALISATION - VENT LOCAL, SONDAGE AMONT (couche 2) + // ======================================================================= + // + // Le sondage amont est la technique centrale de cette couche : 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. Cout total : + // 7 appels a heightAt() par evaluation (le point, trois amont, un aval, deux + // lateraux), soit le budget d'une seule lecture de pente du velo. + + // Distances de sondage EN AMONT, en metres. 250 / 750 / 2000 : trois + // echelles, parce qu'un seul sondage ne peut pas distinguer un ressaut de + // dix metres d'un versant de deux kilometres. Ordres de grandeur suggeres + // par la recherche preparatoire, PROVISOIRES. + float upwindNearMeters = 250.0f; + float upwindMidMeters = 750.0f; + float upwindFarMeters = 2000.0f; + + // Distance de sondage EN AVAL, en metres. 100 : assez proche pour dire si le + // point est sur une rupture de pente, donc en bord de crete. PROVISOIRE. + float downwindMeters = 100.0f; + + // Distance de sondage LATERAL, perpendiculairement au vent, en metres. 400 : + // l'echelle d'un col. C'est ce sondage, et lui seul, qui detecte un + // retrecissement. PROVISOIRE. + float lateralMeters = 400.0f; + + // Denivele, en metres, qui vaut une exposition COMPLETE. 150 : un point qui + // domine son amont de 150 m est pleinement expose ; un point qui est 150 m + // en dessous de son amont est pleinement abrite. PROVISOIRE. + float exposureReliefMeters = 150.0f; + + // Gain de vent d'un point pleinement expose, sans unite. 0,80 : une crete + // vente 1,8 fois plus que le vent de reference. Ordre de grandeur reel + // (l'acceleration au-dessus d'une crete est de 1,5 a 2). PROVISOIRE. + float exposureWindGain = 0.80f; + + // Reduction de vent d'un point pleinement abrite, sans unite. 0,75 : un fond + // de vallee abrite ne garde que 25 % du vent de reference. PROVISOIRE. + float shelterWindReduction = 0.75f; + + // Denivele lateral, en metres, qui vaut un retrecissement COMPLET. 200 : un + // col dont les deux epaules dominent de 200 m est un entonnoir parfait. + // PROVISOIRE. + float venturiReliefMeters = 200.0f; + + // Gain de vent d'un col parfait, sans unite. 0,70 : le vent y est 1,7 fois + // celui du terrain libre. Effet Venturi reel et bien connu des vols en + // montagne ; la valeur est PROVISOIRE. + float venturiWindGain = 0.70f; + + // Vent local maximal, en m/s, tous facteurs cumules. 35 : garde-fou, pas un + // phenomene. Sans lui, un col en crete un jour de tempete cumulerait les + // gains et sortirait une valeur absurde. + float maxLocalWindMps = 35.0f; + + // --- Composante VERTICALE --------------------------------------------- + + // Efficacite de la pente ascendante a soulever l'air (ridge lift), sans + // unite. 0,55 : une pente de 50 % face a un vent de 10 m/s produit + // 0,55 * 0,5 * 10 = 2,75 m/s d'ascendance. C'est l'ordre de grandeur reel + // d'un vol de pente exploitable. PROVISOIRE. + float ridgeLiftEfficiency = 0.55f; + + // Vitesse verticale maximale d'origine dynamique, en m/s. 6,0 : garde-fou. + float maxRidgeLiftMps = 6.0f; + + // Subsidence maximale sous le vent, en m/s. -3,0 : le rabattant derriere une + // crete, qui est ce qui pose les vrais problemes en parapente. Le signe est + // sur, la valeur est PROVISOIRE. + float leeSubsidenceMps = -3.0f; + + // Intensite de turbulence maximale sous le vent, dans [0, 1]. 1,0 par + // construction ; le champ existe pour pouvoir l'adoucir sans toucher au + // code. + float leeTurbulenceMax = 1.0f; + + // Vent de reference, en m/s, au-dela duquel la turbulence de sillage est a + // son maximum. 12,0 : sans vent, pas de turbulence de relief. PROVISOIRE. + float turbulenceFullWindMps = 12.0f; + + // --- THERMIQUES -------------------------------------------------------- + + // Ascendance thermique maximale, en m/s, sur un adret parfaitement expose, + // par ciel clair, a l'heure la plus chaude. 3,5 : une bonne thermique de + // moyenne montagne au printemps. PROVISOIRE. + float thermalMaxMps = 3.5f; + + // Heure du maximum de production thermique. 14,0, une heure AVANT le maximum + // de temperature : les thermiques sont pilotees par le flux de chaleur du + // sol, pas par la temperature de l'air, et le flux culmine plus tot. + // PROVISOIRE, mais l'antecedence est reelle. + float thermalPeakHour = 14.0f; + + // Demi-largeur de la plage horaire thermique, en heures. 4,5 : les + // thermiques vivent de ~9 h 30 a ~18 h 30. PROVISOIRE. + float thermalHalfWidthHours = 4.5f; + + // Attenuation des thermiques par les nuages. 0,80 : sous un ciel couvert il + // ne reste que 20 % du declenchement. Mecanisme reel, valeur PROVISOIRE. + float cloudThermalDamping = 0.80f; + + // ======================================================================= + // 6 bis. LUMIERE DU JOUR (rendu) + // ======================================================================= + // + // POURQUOI CES QUATRE VALEURS SONT ICI ET NON DANS LE RENDERER : parce que + // la Phase 16 avait laisse une incoherence explicite - une horloge de jeu + // acceleree douze fois, dont RIEN dans l'image ne tenait compte, le soleil + // des shaders etant une direction constante depuis la Phase 2. Corriger ca + // demande que la lumiere vienne de la MEME position solaire que l'adret et + // les thermiques, sinon on recree exactement le probleme qu'on repare : deux + // soleils qui peuvent diverger. Voir sunLightFor(). + + // Sinus d'elevation solaire au-dela duquel la lumiere directe est a pleine + // intensite. 0,15 (8,6 degres) : le soleil met un moment a "s'allumer" apres + // le lever, ce qui donne une aube et un crepuscule au lieu d'un interrupteur. + // PROVISOIRE. + float lightFullDaylightSin = 0.15f; + + // Part de l'eclairage ambiant conservee en pleine nuit, sans unite. 0,30 : + // la nuit est sombre mais le relief reste lisible. C'est un choix de + // JOUABILITE assume, pas une mesure - une vraie nuit sans lune est noire, et + // 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'existe + // encore). PROVISOIRE, et a revoir le jour ou le feu de camp arrivera. + float nightAmbientFactor = 0.30f; + + // Couleur de la lumiere en plein jour, puis a l'horizon. La seconde est la + // teinte rouge-orangee d'un soleil rasant, dont la lumiere traverse beaucoup + // plus d'atmosphere. PROVISOIRES toutes les deux, mais le SENS du glissement + // est reel. + glm::vec3 daylightColor{1.00f, 0.97f, 0.90f}; + glm::vec3 horizonColor{1.00f, 0.62f, 0.36f}; + + // Couleur de l'ambiante nocturne. Bleutee : c'est la convention de tout + // rendu de nuit, et elle vient de la diffusion de Rayleigh du peu de lumiere + // residuelle. PROVISOIRE. + glm::vec3 nightColor{0.42f, 0.50f, 0.72f}; + + // Couleur du CIEL en plein jour, au crepuscule et en pleine nuit. Le ciel + // n'est pas eclaire par le modele de lumiere - c'est une couleur + // d'effacement - donc il lui faut sa propre palette. + // + // Ces trois valeurs ont ete ajoutees APRES la premiere capture du cycle : + // le relief s'assombrissait correctement mais le ciel restait le bleu vif de + // midi, ce qui donnait une nuit ou l'on distinguait la silhouette NOIRE des + // sapins sur un ciel de plein jour. La lumiere etait juste, l'image ne + // l'etait pas. PROVISOIRES. + glm::vec3 daySkyColor{0.52f, 0.66f, 0.82f}; + glm::vec3 duskSkyColor{0.42f, 0.33f, 0.36f}; + glm::vec3 nightSkyColor{0.03f, 0.04f, 0.09f}; + + // ======================================================================= + // 6 ter. METEO VISIBLE (rendu) - PHASE 27 + // ======================================================================= + // + // CE BLOC N'AJOUTE AUCUNE MECANIQUE METEO. Chaque valeur ci-dessous est un + // coefficient d'AFFICHAGE qui traduit en image une grandeur que ce module + // calculait DEJA - nebulosite, precipitation, neige (donc temperature), + // vent, mouillure. Aucun de ces champs ne cree de phenomene : mis a zero, ils + // eteignent l'effet visuel, et le temps qu'il fait reste exactement le meme. + // La tracabilite complete, grandeur par grandeur, est dans + // NOTES-PHASE27.md. Voir weatherVisualsFor(). + // + // Ce que ces coefficients ne pretendent PAS etre : des mesures. Ils sont + // PROVISOIRES au meme titre que tout ce fichier, et regroupes ici pour la + // meme raison - pouvoir etre revus en bloc. + + // Assombrissement du ciel COUVERT par rapport a un ciel clair de meme + // luminosite, sans unite. 0,80 : un ciel bouche est gris et un peu plus + // sombre qu'un ciel bleu. Pilote par : cloudCover. Le ciel est d'abord + // DESATURE vers sa propre luminance, puis assombri : c'est ce qui laisse le + // cycle jour/nuit intact (un ciel couvert de nuit reste un ciel de nuit). + float overcastSkyDarkening = 0.80f; + + // Gain de l'eclairage AMBIANT sous un ciel couvert, sans unite. 1,0 : a + // couverture totale et en plein jour, l'ambiante double. Pilote par : + // cloudCover. Le mecanisme est reel - un ciel couvert diffuse vers le sol une + // bonne partie de la lumiere qu'il retire au rayonnement direct, ce qui + // aplatit l'image au lieu de simplement la noircir. N'agit que de JOUR : une + // nuit couverte n'est pas plus claire qu'une nuit claire. PROVISOIRE. + // + // L'extinction du rayonnement DIRECT, elle, n'a pas de parametre ici : elle + // reprend cloudAspectDamping (section 5), qui modelisait deja exactement ce + // phenomene pour l'adret. Un seul chiffre pour "les nuages cachent le + // soleil", donc un seul soleil voile dans tout le jeu. + float overcastAmbientGain = 1.0f; + + // Coefficient d'extinction de la PLUIE, en 1/km, pour 1 mm/h, et son + // exposant. Pilote par : precipitationMmPerHour locale. Forme en loi de + // puissance sigma = a * R^b, qui est la forme des relations empiriques + // publiees pluie/visibilite ; les deux valeurs sont des ORDRES DE GRANDEUR + // PROVISOIRES, non verifies contre une source precise. Avec 0,25 et 0,63, + // une pluie de 5 mm/h donne sigma = 0,69 /km, soit une visibilite de + // Koschmieder (3,912 / sigma) de 5,7 km : la pluie voile le fond de la zone + // de 5 km, pas le premier plan. PROVISOIRE. + float rainExtinctionPerKm = 0.25f; + float rainExtinctionExponent = 0.63f; + + // Multiplicateur d'extinction quand la precipitation tombe en NEIGE, sans + // unite. 8,0 : a lame d'eau egale, la neige reduit beaucoup plus la + // visibilite que la pluie (flocons larges et lents). Le sens est sur, + // l'ordre de grandeur est PROVISOIRE. Pilote par : snowing, donc par la + // temperature locale et snowThresholdC. + float snowExtinctionMultiplier = 8.0f; + + // Vitesse de chute apparente, en m/s, de la pluie et de la neige, pour + // l'inclinaison des traits a l'ecran (combinee au VENT LOCAL). 6,5 et 1,2 : + // vitesses terminales usuelles d'une goutte millimetrique et d'un flocon. + // Ce sont des faits physiques plutot que des reglages, mais retenus a la + // louche. + float rainFallSpeedMps = 6.5f; + float snowFallSpeedMps = 1.2f; + + // Assombrissement d'un sol MOUILLE, sans unite. 0,35 : un sol ruisselant + // renvoie 35 % de lumiere en moins qu'un sol sec. Pilote par : wetness. Le + // phenomene est reel et bien connu (un sol humide fonce nettement) ; + // l'amplitude est PROVISOIRE. + float wetGroundDarkening = 0.35f; + + // ======================================================================= + // 7. PRECIPITATIONS LOCALES ET ETAT DU SOL (couche 2) + // ======================================================================= + + // Renforcement orographique maximal, sans unite. 0,90 : un versant au vent + // recoit presque le double de precipitation d'un terrain plat. Le mecanisme + // (barriere orographique) est reel et de premier ordre en montagne ; le + // modele employe ici est volontairement SIMPLE - pas d'ombre pluviometrique + // sous le vent au-dela de la simple absence de renforcement. PROVISOIRE. + float orographicGain = 0.90f; + + // Pente ASCENDANTE DANS LE SENS DU VENT, en rise par metre, qui vaut un + // renforcement orographique complet. 0,35 : un versant a 35 % face au flux + // souleve deja franchement la masse d'air. PROVISOIRE. + float orographicFullSlope = 0.35f; + + // Nebulosite ajoutee par un renforcement orographique complet, dans [0, 1]. + // 0,15 : le versant au vent s'accroche des nuages que le fond de vallee n'a + // pas. PROVISOIRE. + float orographicCloudGain = 0.15f; + + // Renforcement des precipitations avec l'altitude, par km. 0,35 : il pleut + // et il neige plus haut que plus bas. PROVISOIRE. + float precipitationAltitudeGainPerKm = 0.35f; + + // --- Mouillure du sol --------------------------------------------------- + // + // NON INTEGREE : la mouillure est obtenue en RELISANT la pluie des dernieres + // heures dans la fonction synoptique (qui est pure), pas en accumulant image + // par image. C'est ce qui la garde deterministe et rejouable. + + // Fenetre de memoire de la pluie, en HEURES de jeu. 6,0 : de la pluie tombee + // il y a plus de six heures ne compte plus. PROVISOIRE. + float wetnessMemoryHours = 6.0f; + + // Nombre d'echantillons de cette fenetre. 8 : un echantillon toutes les + // 45 minutes de jeu. Reglage de COUT, pas de climat - c'est le seul endroit + // ou l'evaluation meteo depasse la dizaine d'operations. + int wetnessSamples = 8; + + // Precipitation, en mm/h, qui suffit a saturer le sol. 3,0. PROVISOIRE. + float wetnessSaturationMmPerHour = 3.0f; + + // Temps de sechage, en heures de jeu. 4,0 : c'est la constante de la + // decroissance exponentielle appliquee a chaque echantillon passe. + // PROVISOIRE. + float dryingTimeHours = 4.0f; +}; + +// --------------------------------------------------------------------------- +// COUCHE 1 - Etat synoptique du massif (0D, aucune position) +// --------------------------------------------------------------------------- +struct SynopticState { + // Temps de jeu correspondant, en heures depuis le debut de partie. Recopie + // ici pour qu'un etat soit auto-descriptif dans un journal ou un test. + float gameHours = 0.0f; + + // Heure locale dans [0, 24) et jour de l'annee dans [0, 365). + float timeOfDayHours = 12.0f; + float dayOfYear = 0.0f; + + // Temperature de reference AU NIVEAU DE LA MER, en degres. C'est la sortie + // principale de la couche 1 : la couche 2 en tire toutes les temperatures + // locales par le gradient altitudinal. + float seaLevelTemperatureC = 0.0f; + + // Direction d'ou VIENT le vent, en degres compas (0 = nord, 90 = est). + float windFromDegrees = 270.0f; + + // Vitesse du vent synoptique AU NIVEAU DE LA MER, en m/s. La couche 2 y + // ajoute l'altitude et le relief. + float seaLevelWindMps = 0.0f; + + // Nebulosite dans [0, 1] : 0 = grand beau, 1 = entierement couvert. + float cloudCover = 0.0f; + + // Precipitation de reference (terrain plat, niveau de la mer), en mm/h. + float precipitationMmPerHour = 0.0f; + + // Elevation du soleil au-dessus de l'horizon, en degres (negative la nuit), + // et azimut d'ou il VIENT, en degres compas. + float sunElevationDegrees = 0.0f; + float sunAzimuthDegrees = 180.0f; + + // Part de soleil dans [0, 1] : sinus de l'elevation, ecrete a 0 la nuit. + // Remplace daylightFactor() de la Phase 16, qui etait une demi-sinusoide + // fixe de 6 h a 18 h sans aucune notion de saison ni de latitude. + float daylight = 0.0f; + + // Direction unitaire DU POINT VERS LE SOLEIL, en repere monde + // (+X = est, +Z = sud, +Y = haut). C'est ce vecteur qui sert a l'adret/ubac + // ET a la lumiere directionnelle du rendu : une seule definition du soleil + // dans tout le jeu. + glm::vec3 sunDirection{0.0f, 1.0f, 0.0f}; + + // Ligne compacte pour le journal et les tests. + std::string describe() const; +}; + +// --------------------------------------------------------------------------- +// COUCHE 2 - Etat meteo en un point du monde +// --------------------------------------------------------------------------- +struct WeatherSample { + // --- Temperature ------------------------------------------------------- + + // Temperature AMBIANTE en degres au point demande. C'est desormais la SEULE + // temperature ambiante du jeu : Needs la consomme au lieu de la recalculer + // (voir NeedsContext::ambientTemperatureC). + float temperatureC = 0.0f; + + // Decomposition, exposee pour les tests et le journal - un test qui ne voit + // que la somme ne dit pas lequel des trois termes a mordu. + float lapseC = 0.0f; // part du gradient altitudinal (negative en altitude) + float aspectC = 0.0f; // part de l'adret/ubac + float inversionC = 0.0f; // part de l'inversion de fond de cuvette (<= 0) + + // --- Vent -------------------------------------------------------------- + + // Vitesse du vent HORIZONTAL au point, en m/s. + float windMps = 0.0f; + + // Vecteur vent horizontal complet, en repere monde, en m/s : il POINTE dans + // le sens ou l'air se deplace (et non d'ou il vient). + glm::vec3 windVector{0.0f}; + + // Vitesse VERTICALE de l'air, en m/s. Positive = ascendance. Somme des trois + // contributions exposees juste en dessous. + float verticalMps = 0.0f; + float ridgeLiftMps = 0.0f; // dynamique : le relief force l'air a monter + float thermalMps = 0.0f; // convectif : le sol chauffe au soleil + float subsidenceMps = 0.0f; // sous le vent : l'air redescend (<= 0) + + // Intensite de turbulence dans [0, 1]. 0 = air lisse. + float turbulence = 0.0f; + + // --- Humidite ---------------------------------------------------------- + + // Nebulosite locale dans [0, 1] (celle de la couche 1, modulee). + float cloudCover = 0.0f; + + // Precipitation locale, en mm/h. + float precipitationMmPerHour = 0.0f; + + // La precipitation tombe-t-elle en neige au point ? + bool snowing = false; + + // Mouillure du sol et du rocher dans [0, 1]. 0 = sec, 1 = ruisselant. + float wetness = 0.0f; + + std::string describe() const; +}; + +// --------------------------------------------------------------------------- +// Carte de piegeage d'air froid +// --------------------------------------------------------------------------- +// Precalculee UNE FOIS au chargement du terrain, jamais par image - c'est +// l'exigence de cout du cahier des charges. +// +// CE QU'ELLE MESURE : a quel point un point du terrain est un CREUX ENFERME. On +// sonde, autour de chaque cellule, huit directions a trois rayons, et on regarde +// combien de ces 24 sondes sont PLUS HAUTES que la cellule, et de combien. Un +// fond de cuvette est entoure de terrain plus haut dans toutes les directions ; +// une crete ne l'est dans aucune ; un versant l'est dans la moitie. +// +// POURQUOI PAS SIMPLEMENT "L'ALTITUDE EST BASSE" : parce qu'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 - et +// c'est exactement la lecon deja apprise en Phase 22 sur le relief (savoir ou il +// y a de la pente ne dit pas par ou l'aborder). +class ColdAirTrapMap { +public: + // Rayons de sondage, en metres. 120 / 350 / 900 : une cuvette de fond de + // vallee, un cirque, un bassin. PROVISOIRES comme le reste. + static constexpr float kProbeRadii[3] = {120.0f, 350.0f, 900.0f}; + + // Denivele, en metres, au-dela duquel une sonde compte pour un enfermement + // COMPLET dans sa direction. 80 : un relief de 80 m au-dessus de soi suffit + // a retenir une nappe d'air froid. PROVISOIRE. + static constexpr float kFullEnclosureRise = 80.0f; + + // Carte vide : index 0 partout. C'est le repli legitime quand aucun terrain + // n'est charge - le systeme meteo reste utilisable, sans inversion. + ColdAirTrapMap() = default; + + // Construit la carte sur l'emprise [-halfSize, +halfSize] en X et Z. + // + // resolution : cote de la grille. 128 sur les 5 km de la zone de jeu donne + // des cellules de 39 m, ce qui est la bonne echelle pour une + // cuvette (une cuvette de 39 m n'en est pas une). Cout : + // 128 * 128 * 24 = 393 216 lectures de heightmap, une seule + // fois au chargement. + ColdAirTrapMap(const HeightSampler& terrain, float halfSize, + uint32_t resolution); + + bool empty() const { return values_.empty(); } + uint32_t resolution() const { return resolution_; } + float halfSize() const { return halfSize_; } + + // Index de piegeage dans [0, 1] au point monde donne, par interpolation + // bilineaire. Hors emprise : la valeur du bord le plus proche (meme contrat + // de TOTALITE que HeightSampler::heightAt). + float at(float worldX, float worldZ) const; + + // Statistiques, pour le journal de chargement et les tests. + float maxValue() const { return maxValue_; } + float meanValue() const { return meanValue_; } + +private: + std::vector values_; + uint32_t resolution_ = 0; + float halfSize_ = 0.0f; + float maxValue_ = 0.0f; + float meanValue_ = 0.0f; +}; + +// --------------------------------------------------------------------------- +// Exposition du versant (adret / ubac) +// --------------------------------------------------------------------------- +// DEPLACEE DEPUIS Needs.hpp EN PHASE 23. Elle n'a jamais decrit un besoin du +// joueur : elle decrit le TERRAIN, donc sa place est ici, a cote du reste de la +// spatialisation. Le corps est inchange. +// +// ELLE N'EST PLUS SUR LE CHEMIN DU GAMEPLAY, et il faut le dire clairement : +// depuis la Phase 23, l'effet thermique d'un versant passe par le PRODUIT +// SCALAIRE entre la normale du terrain et la direction du soleil (voir +// WeatherSystem::sampleAt), qui sait faire ce que cette fonction ne sait pas - +// distinguer un versant est d'un versant ouest, et savoir a quelle heure ca +// compte. Ce qui reste ici est une requete de terrain simple, honnete et bon +// marche : "ce point regarde-t-il le sud ?". Elle est toujours exercee par les +// tests, et c'est aujourd'hui son seul appelant. +// +// Renvoie 0 pour un ubac franc (versant nord), 1 pour un adret franc (versant +// sud), 0,5 sur du plat ou sur un versant est/ouest. +// +// La convention d'axes est celle du projet depuis la Phase 7, verifiee dans +// Heightmap::toProjected : **+X va vers l'EST, +Z va vers le SUD**. Un versant +// expose au sud descend donc vers +Z, c'est-a-dire dh/dz < 0. +// +// sampleStep est la DEMI-base de la difference finie, en metres. 2,0 par defaut, +// donc une base de 4 m : exactement la valeur et la raison de +// BikeParams::slopeSampleStep - au pas de 1 m, le bruit decimetrique du LiDAR +// fait lire un adret sur un ubac. +// +// L'exposition est ponderee par la PENTE : sur du terrain quasi plat il n'y a ni +// adret ni ubac, la fonction rend 0,5 quelle que soit la direction du gradient +// residuel. +float terrainExposure(const HeightSampler& terrain, float worldX, float worldZ, + float sampleStep = 2.0f); + +// Pente (magnitude du gradient) au-dela de laquelle l'exposition est prise en +// compte a 100 %. 30 % : un versant a 30 % est franchement oriente. +inline constexpr float kFullExposureSlope = 0.30f; + +// Normale unitaire de la surface en un point, en repere monde. Sert a +// l'adret/ubac "vrai" (produit scalaire avec la direction du soleil) et au +// ridge lift. Meme base de difference finie que terrainExposure. +glm::vec3 terrainNormal(const HeightSampler& terrain, float worldX, float worldZ, + float sampleStep = 2.0f); + +// Direction monde unitaire correspondant a un cap compas (0 = nord, 90 = est), +// dans la convention d'axes du projet (+X est, +Z sud). Exposee parce que la +// direction du vent est manipulee en degres compas partout dans ce fichier et +// qu'une seule conversion doit exister. +glm::vec3 compassDirection(float degrees); + +// --------------------------------------------------------------------------- +// Le systeme +// --------------------------------------------------------------------------- +// SEED : fixe par defaut (kDefaultSeed), et DERIVABLE d'une graine de partie par +// le constructeur. Le choix par defaut est le seed FIXE, et il 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, et le semis de vegetation comme celui de la faune sont eux aussi +// 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 (voir la lecon +// de la Phase 12 sur --look) ; +// - le jour ou les parties multiples existeront, passer la graine de partie au +// constructeur suffit, sans rien changer d'autre. +class WeatherSystem { +public: + // Graine par defaut. Valeur arbitraire, choisie une fois et figee : la + // changer change tout le calendrier meteo de toutes les parties. + static constexpr uint32_t kDefaultSeed = 0x5EA50Eu; + + explicit WeatherSystem(const WeatherParams& params = {}, + uint32_t seed = kDefaultSeed); + + const WeatherParams& params() const { return params_; } + uint32_t seed() const { return seed_; } + + // Relie une carte de piegeage d'air froid. Sans elle, le systeme fonctionne + // et l'inversion vaut zero partout - c'est un repli explicite, pas une + // panne. Le pointeur n'est PAS possede : la carte vit aussi longtemps que le + // terrain, donc plus longtemps que n'importe quelle evaluation meteo. + void setTrapMap(const ColdAirTrapMap* map) { trapMap_ = map; } + const ColdAirTrapMap* trapMap() const { return trapMap_; } + + // --- COUCHE 1 ---------------------------------------------------------- + + // Etat synoptique a gameHours heures depuis le debut de partie. FONCTION + // PURE : aucun etat de l'objet n'est modifie, et deux appels avec la meme + // valeur rendent bit a bit le meme resultat. + SynopticState synopticAt(float gameHours) const; + + // --- COUCHE 2 ---------------------------------------------------------- + + // Etat meteo complet au point (x, y, z) a l'instant gameHours. + // + // terrain peut etre nullptr : on obtient alors la meteo "en air libre" + // (gradient altitudinal, vent synoptique corrige de l'altitude, nebulosite), + // sans aucun effet de relief. C'est le repli utilise avant qu'un terrain soit + // charge, et il est explicitement teste. + WeatherSample sampleAt(const glm::vec3& position, float gameHours, + const HeightSampler* terrain) const; + + // Meme chose a partir d'un etat synoptique DEJA calcule. C'est cette + // surcharge qu'il faut appeler quand plusieurs points sont echantillonnes au + // meme instant (le joueur et des zones de vol, par exemple) : la couche 1 ne + // depend pas de la position, la recalculer par point serait du gaspillage. + WeatherSample sampleAt(const glm::vec3& position, const SynopticState& sky, + const HeightSampler* terrain) const; + + // Mouillure du sol dans [0, 1] a l'instant gameHours. Exposee separement + // parce qu'elle coute plus cher que le reste (elle relit wetnessSamples + // instants passes) et que tous les appelants n'en ont pas besoin. + // sampleAt() l'inclut deja dans WeatherSample::wetness. + float groundWetness(float gameHours, float altitudeMeters, + float orographicFactor) const; + + // ----------------------------------------------------------------------- + // PHASE 26 : l'exposition adret / ubac CLIMATIQUE, dans [-1, +1]. + // ----------------------------------------------------------------------- + // +1 = adret franc, 0 = plat ou indifferent, -1 = ubac franc. + // + // POURQUOI CETTE FONCTION EXISTE A COTE DE WeatherSample::aspectC. Les deux + // reposent sur le MEME signal - aspectSignal(), une seule implementation + // dans le .cpp - mais pas au meme instant, et c'est toute la difference : + // + // * aspectC repond a « ce versant recoit-il le soleil MAINTENANT » : il + // tourne avec l'heure, s'attenue sous les nuages, et s'eteint la nuit. + // C'est ce qu'il faut pour une temperature, et c'est ce qui a corrige en + // Phase 23 le versant sud plus chaud a deux heures du matin ; + // * celle-ci repond a « ce versant est-il un adret », question a laquelle + // l'heure qu'il est n'a rien a voir. Elle evalue donc le signal AU + // SOLEIL DE MIDI, et ignore la nebulosite du jour. + // + // Une essence d'arbre, une repartition de vegetation, tout ce qui releve du + // CLIMAT d'un versant et non de sa meteo doit passer par ici : la valeur y + // est stable dans le temps. Un arbre qui changerait d'essence au coucher du + // soleil serait le symptome exact d'un appel a la mauvaise des deux. + // + // terrain nul => 0 (aucun relief, donc aucun versant). + float aspectExposureAt(const glm::vec3& position, + const HeightSampler* terrain) const; + +private: + // Bruit de perturbation dans [-1, 1] a l'instant donne, sur un canal donne + // (temperature, nuage, vent, direction). Des canaux SEPARES et non un seul + // bruit deforme : sans ca, le vent forcirait toujours exactement en meme + // temps que le ciel se couvre, ce qui se remarque en une journee de jeu. + float frontNoise(float gameHours, uint32_t channel) const; + + // PHASE 26. Signal d'adret/ubac brut dans [-1, +1] pour une normale de + // terrain et une direction solaire donnees : l'ecart entre le cosinus + // d'incidence du point et celui qu'aurait du terrain PLAT, rapporte a + // params_.aspectIncidenceReference. + // + // EXTRAITE de sampleAt SANS EN CHANGER UNE LIGNE DE CALCUL, precisement + // pour qu'il n'y ait pas deux formules d'adret dans le jeu. C'est la meme + // exigence que la Phase 23 (un seul soleil) et que la Phase 25 (un seul + // ecart de reference), appliquee ici a la loi elle-meme : sampleAt l'evalue + // au soleil courant, aspectExposureAt au soleil de midi, et personne + // d'autre ne l'ecrit. + float aspectSignal(const glm::vec3& normal, const glm::vec3& sunDirection, + bool sunUp) const; + + WeatherParams params_; + uint32_t seed_ = kDefaultSeed; + const ColdAirTrapMap* trapMap_ = nullptr; +}; + +// --------------------------------------------------------------------------- +// Lumiere du jour, pour le rendu +// --------------------------------------------------------------------------- +// PHASE 23 : CORRECTION DE L'INCOHERENCE DE LA PHASE 16. +// +// Le jeu simulait une horloge acceleree douze fois depuis la Phase 16, et rien +// dans l'image ne bougeait avec elle : la lumiere directionnelle des shaders +// etait la constante vec3(-0.4, -1.0, -0.6) depuis la Phase 2. Une session +// d'une heure traversait une tombee de nuit qui ne se voyait nulle part. +// +// Ce qui suit alimente la lumiere directionnelle EXISTANTE (Blinn-Phong, +// Phase 2) a partir de la position solaire deja calculee pour l'adret 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. +// +// Ce que ce n'est PAS : un ciel physique. Pas de diffusion atmospherique +// calculee, pas d'ombres portees, pas de lune. La direction et l'intensite +// suivent le cycle, c'est tout ce que le cahier des charges demandait. +struct SunLight { + // Direction unitaire DU FRAGMENT VERS LA LUMIERE, en repere monde. Quand le + // soleil est sous l'horizon elle bascule a la verticale : une lumiere + // directionnelle venue d'en dessous eclairerait le relief par le bas, ce qui + // est le defaut visuel classique d'un cycle jour/nuit bacle. + glm::vec3 direction{0.0f, 1.0f, 0.0f}; + + // Intensite de la lumiere DIRECTE, dans [0, 1]. Nulle la nuit. + float intensity = 1.0f; + + // Couleur de la lumiere. Chaude au zenith, orangee a l'horizon, bleutee la + // nuit. + glm::vec3 color{1.0f, 0.97f, 0.90f}; + + // MULTIPLICATEUR de l'eclairage ambiant propre a chaque shader, dans + // [nightAmbientFactor, 1]. Un multiplicateur et non une valeur absolue, + // parce que 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. + float ambient = 1.0f; + + // Couleur du CIEL, a poser dans la couleur d'effacement du renderer. Elle + // suit sa propre palette et non celle de la lumiere : le ciel n'est pas + // eclaire par le modele d'eclairage, c'est un fond. + glm::vec3 skyColor{0.52f, 0.66f, 0.82f}; +}; + +// Lumiere correspondant a un etat synoptique. Fonction PURE, comme tout le +// reste du module : la meme heure rend la meme lumiere, donc deux captures +// d'ecran au meme instant de jeu sont comparables - ce qui est la condition de +// la verification visuelle du projet depuis la Phase 12. +SunLight sunLightFor(const SynopticState& sky, const WeatherParams& params = {}); + +// --------------------------------------------------------------------------- +// PHASE 27 : la meteo VISIBLE +// --------------------------------------------------------------------------- +// Jusqu'ici, un jour de pluie a 95 % de nebulosite se rendait EXACTEMENT comme +// un jour de grand beau : ciel bleu vif, soleil franc. La meteo etait calculee, +// journalisee, consommee par les besoins et les activites, et invisible. +// +// Cette fonction est la SEULE traduction meteo -> image du jeu. Elle ne calcule +// aucune grandeur meteo : elle LIT l'etat synoptique et l'echantillon local +// deja produits par WeatherSystem, et les convertit en parametres de rendu. +// Fonction PURE, comme sunLightFor : la meme meteo rend la meme image, et elle +// se teste sans GPU. +struct WeatherVisuals { + // Lumiere du jour, CORRIGEE de la nebulosite : rayonnement direct voile par + // les nuages, ambiante renforcee par la diffusion, ciel grise. Par ciel + // clair, identique bit a bit a sunLightFor(). + SunLight light; + + // Brouillard de distance : couleur (celle du ciel, pour que le relief se + // fonde dans le fond) et coefficient d'extinction, en 1/m. Nul sans + // precipitation. + glm::vec3 fogColor{0.52f, 0.66f, 0.82f}; + float fogDensityPerMeter = 0.0f; + + // Precipitation a l'ecran : intensite dans [0, 1] (0 = rien a dessiner), + // nature (neige ou pluie) et vitesse apparente de chute en repere monde, + // en m/s (vent local + chute verticale). + float precipitation = 0.0f; + bool snow = false; + glm::vec3 fallVelocity{0.0f, -6.5f, 0.0f}; + + // Assombrissement de l'albedo du sol par la mouillure, dans [0, 1]. + float groundDarkening = 0.0f; +}; + +WeatherVisuals weatherVisualsFor(const SynopticState& sky, const WeatherSample& local, + const WeatherParams& params = {}); + +// --------------------------------------------------------------------------- +// Refroidissement eolien +// --------------------------------------------------------------------------- +// Formule JAG/TI (Joint Action Group for Temperature Indices), celle qu'emploient +// Environnement Canada et le NWS depuis 2001 : +// +// Tressenti = 13,12 + 0,6215 T - 11,37 V^0,16 + 0,3965 T V^0,16 +// +// avec T en degres Celsius et V la vitesse du vent en km/h a 10 m. +// +// Son domaine de validite est T <= 10 degres et V >= 4,8 km/h. HORS de ce +// domaine, la fonction rend la temperature INCHANGEE plutot qu'une +// extrapolation : au-dessus de 10 degres la formule diverge (elle rendrait un +// vent RECHAUFFANT a 25 degres, ce qui est faux), et sous 4,8 km/h elle rend un +// ressenti superieur a l'ambiante. C'est la seule formule de tout ce fichier qui +// ne soit PAS provisoire - elle est publiee et sourcable. +float windChillC(float temperatureC, float windMps); + +} // namespace vercora diff --git a/src/world/Wildlife.cpp b/src/world/Wildlife.cpp new file mode 100644 index 0000000..9e5e391 --- /dev/null +++ b/src/world/Wildlife.cpp @@ -0,0 +1,364 @@ +#include "world/Wildlife.hpp" + +#include "core/HeightSampler.hpp" +// PHASE 20 : kAnimalHeight / kAnimalLength. La collision doit etre deduite des +// dimensions du MESH et non les redeclarer : un cervide qui grandirait sans que +// son collider suive redeviendrait traversable par le haut. +#include "world/AnimalMesh.hpp" +#include "world/Habitat.hpp" + +#include + +#include +#include + +namespace vercora { +namespace { + +// Meme garde-fou que Forest::update, Needs::update et Habitat::update : une +// image anormalement longue ne doit pas telporter les animaux. +constexpr float kMaxStep = 0.25f; + +// Demi-base de la lecture de pente, en m. 2,0, donc une base de 4 m : MEME +// valeur et MEME raison que BikeParams::slopeSampleStep et +// WaterSurveyParams::slopeSampleStep - au pas de 1 m, le bruit decimetrique du +// LiDAR fait lire des contre-pentes qui n'existent pas. +constexpr float kSlopeStep = 2.0f; + +float horizontalDistance(const glm::vec3& a, const glm::vec3& b) { + const float dx = a.x - b.x; + const float dz = a.z - b.z; + return std::sqrt(dx * dx + dz * dz); +} + +} // namespace + +glm::mat4 Animal::modelMatrix() const { + glm::mat4 model = glm::translate(glm::mat4(1.0f), position); + model = glm::rotate(model, glm::radians(-headingDegrees), glm::vec3(0.0f, 1.0f, 0.0f)); + return glm::scale(model, glm::vec3(scale)); +} + +Wildlife::Wildlife(const HeightSampler& terrain, const HeightSampler* cover, + float terrainExtent, const WildlifeParams& params) + : terrain_(terrain), + cover_(cover), + terrainExtent_(terrainExtent), + params_(params), + rng_(params.seed) { + animals_.reserve(params_.maxAnimals); +} + +float Wildlife::slopeAt(float worldX, float worldZ) const { + const float hx1 = terrain_.heightAt(worldX - kSlopeStep, worldZ); + const float hx2 = terrain_.heightAt(worldX + kSlopeStep, worldZ); + const float hz1 = terrain_.heightAt(worldX, worldZ - kSlopeStep); + const float hz2 = terrain_.heightAt(worldX, worldZ + kSlopeStep); + + const float dx = (hx2 - hx1) / (2.0f * kSlopeStep); + const float dz = (hz2 - hz1) / (2.0f * kSlopeStep); + return std::sqrt(dx * dx + dz * dz); +} + +float Wildlife::coverAt(float worldX, float worldZ) const { + if (cover_ == nullptr) { + return params_.coverWithoutMap; + } + // La carte de couvert est une Heightmap dont la "hauteur" est une part de + // retours de vegetation dans [0, 1] - c'est la convention posee par + // tools/lidar_to_canopy.py et deja consommee par Vegetation::coverAt. Le + // clamp protege d'une carte hors norme plutot que de propager un couvert + // negatif dans les filtres. + return std::clamp(cover_->heightAt(worldX, worldZ), 0.0f, 1.0f); +} + +bool Wildlife::isPlaceable(float worldX, float worldZ, const Habitat& habitat) const { + // Emprise, avec une marge : un animal pile au bord verrait ses sondes de + // pente sortir des donnees. + const float usable = std::max(0.0f, terrainExtent_ - 2.0f * kSlopeStep); + if (std::abs(worldX) > usable || std::abs(worldZ) > usable) { + return false; + } + if (slopeAt(worldX, worldZ) > params_.maxSlope) { + return false; + } + if (coverAt(worldX, worldZ) < params_.minCover) { + return false; + } + // LE filtre de la phase : le milieu se souvient, et il refuse. + if (!habitat.allowsWildlife(worldX, worldZ)) { + return false; + } + for (const Animal& other : animals_) { + const float dx = other.position.x - worldX; + const float dz = other.position.z - worldZ; + if (dx * dx + dz * dz < params_.minSpacing * params_.minSpacing) { + return false; + } + } + return true; +} + +void Wildlife::spawnWave(const glm::vec3& playerPosition, const Habitat& habitat) { + if (animals_.size() >= params_.maxAnimals) { + return; + } + + std::uniform_real_distribution angle(0.0f, 6.28318530718f); + // Tirage du rayon en RACINE : un tirage uniforme sur [min, max] concentrerait + // les animaux vers le bord interieur de l'anneau, ou l'aire est plus petite. + // C'est le meme correctif que pour un semis en disque. + std::uniform_real_distribution unit(0.0f, 1.0f); + std::uniform_real_distribution sizeDist(0.88f, 1.12f); + + const float rmin2 = params_.spawnRadiusMin * params_.spawnRadiusMin; + const float rmax2 = params_.spawnRadiusMax * params_.spawnRadiusMax; + + for (uint32_t attempt = 0; attempt < params_.spawnAttempts; ++attempt) { + if (animals_.size() >= params_.maxAnimals) { + return; + } + const float theta = angle(rng_); + const float radius = std::sqrt(glm::mix(rmin2, rmax2, unit(rng_))); + const float x = playerPosition.x + radius * std::cos(theta); + const float z = playerPosition.z + radius * std::sin(theta); + + if (!isPlaceable(x, z, habitat)) { + continue; + } + + Animal animal; + animal.position = { x, terrain_.heightAt(x, z), z }; + animal.headingDegrees = glm::degrees(angle(rng_)); + animal.scale = sizeDist(rng_); + animal.state = AnimalState::Calm; + animal.id = nextId_++; + animals_.push_back(animal); + ++spawnCount_; + } +} + +void Wildlife::populate(const glm::vec3& playerPosition, const Habitat& habitat, + uint32_t waves) { + for (uint32_t i = 0; i < waves; ++i) { + spawnWave(playerPosition, habitat); + } +} + +void Wildlife::update(float deltaTime, const glm::vec3& playerPosition, + const Habitat& habitat) { + const float dt = std::clamp(deltaTime, 0.0f, kMaxStep); + + // --- 1. Oubli des animaux trop lointains ------------------------------ + const std::size_t before = animals_.size(); + animals_.erase( + std::remove_if(animals_.begin(), animals_.end(), + [&](const Animal& animal) { + return horizontalDistance(animal.position, playerPosition) > + params_.despawnRadius; + }), + animals_.end()); + despawnCount_ += static_cast(before - animals_.size()); + + // --- 2. Comportement --------------------------------------------------- + std::uniform_real_distribution turn(-1.0f, 1.0f); + + for (Animal& animal : animals_) { + const float distance = horizontalDistance(animal.position, playerPosition); + + // DEUX declencheurs de fuite, et ce sont les deux demandes du cahier des + // charges : + // - le joueur s'approche TROP PRES (distance) ; + // - le joueur est reste TROP LONGTEMPS dans le secteur, meme sans + // jamais s'approcher (habitat.wildlifeFlees, qui lit la memoire de + // frequentation remplie par Habitat::notePresence). + // Le second est le plus important des deux : c'est lui qui fait qu'un + // camp de base finit par vider son vallon. + const bool startled = + distance < params_.fleeRadius || + habitat.wildlifeFlees(animal.position.x, animal.position.z); + + if (startled && animal.state == AnimalState::Calm) { + animal.state = AnimalState::Fleeing; + animal.fleeTimer = params_.fleeDuration; + // Cap DIRECTEMENT oppose au joueur. Pas d'evitement d'obstacle, pas + // de recherche de couvert : c'est la simplification annoncee dans + // l'en-tete. Le cas degenere (animal exactement sur le joueur) garde + // le cap courant plutot que de produire un atan2(0,0). + const float dx = animal.position.x - playerPosition.x; + const float dz = animal.position.z - playerPosition.z; + if (dx * dx + dz * dz > 1e-6f) { + animal.headingDegrees = glm::degrees(std::atan2(dz, dx)); + } + } + + float speed = params_.wanderSpeed; + if (animal.state == AnimalState::Fleeing) { + speed = params_.fleeSpeed; + animal.fleeTimer -= dt; + if (animal.fleeTimer <= 0.0f) { + if (distance > params_.fleeSafeDistance && !startled) { + animal.state = AnimalState::Calm; + } else { + // Toujours trop pres (ou toujours derange) : reparti pour + // une pointe. C'est ce qui fait qu'un joueur qui poursuit + // n'attrape jamais rien - et c'est voulu. + animal.fleeTimer = params_.fleeDuration; + } + } + } else { + // Errance : le cap derive doucement. Sans elle, un animal paisible + // avancerait indefiniment en ligne droite et sortirait du decor. + animal.headingDegrees += params_.wanderTurn * turn(rng_) * dt; + } + + const float heading = glm::radians(animal.headingDegrees); + animal.position.x += std::cos(heading) * speed * dt; + animal.position.z += std::sin(heading) * speed * dt; + + // Recollage au relief a chaque image : c'est le meme contrat que la + // camera en mode marche. Un animal ne "tombe" pas, il suit la surface. + animal.position.y = terrain_.heightAt(animal.position.x, animal.position.z); + } + + // --- 3. Apparitions ---------------------------------------------------- + spawnAccumulator_ += dt; + if (spawnAccumulator_ >= params_.spawnInterval) { + spawnAccumulator_ = 0.0f; + spawnWave(playerPosition, habitat); + } +} + +std::size_t Wildlife::countWithin(const glm::vec3& position, float radius) const { + return static_cast( + std::count_if(animals_.begin(), animals_.end(), [&](const Animal& animal) { + return horizontalDistance(animal.position, position) <= radius; + })); +} + +std::size_t Wildlife::fleeingCount() const { + return static_cast( + std::count_if(animals_.begin(), animals_.end(), [](const Animal& animal) { + return animal.state == AnimalState::Fleeing; + })); +} + +// --------------------------------------------------------------------------- +// PHASE 20 : collision. Le joueur ne traverse plus un animal. +// --------------------------------------------------------------------------- +// Rien d'original ici, et c'est l'intention : la geometrie est celle de +// Forest::resolve (cercles dans le plan XZ, recouvrement d'intervalles en Y, +// repoussement jusqu'au contact) parce que le monde doit se cogner PARTOUT de la +// meme facon. Ecrire un second modele de collision pour la faune aurait donne +// deux comportements a regler, a tester et a garder d'accord. +// +// Une seule chose distingue vraiment un animal d'un tronc, et elle ne se voit +// pas dans ce code : il BOUGE. Consequences assumees, toutes les deux : +// - un animal peut venir se poser SUR le joueur immobile (le joueur ne bouge +// pas, donc aucun moveBody() n'est appele, donc rien ne l'ecarte). Il sera +// repousse au premier pas : c'est exactement le cas degenere que +// moveBody() traite deja en dernier recours pour "un arbre plante sur le +// joueur" ; +// - la position "precedente" sur laquelle moveBody() se replie a pu devenir +// occupee entre deux images. Le repli le teste, il n'y a donc rien de +// special a faire - le repoussement reprend la main. +namespace { + +// Le rayon par defaut est la DEMI-LONGUEUR du cervide, et ce lien doit tenir +// tout seul : WildlifeParams ne peut pas inclure AnimalMesh.hpp (elle serait +// alors trainee par tout ce qui parametre la faune), donc la valeur y est +// ecrite en clair. Cette assertion est ce qui empeche les deux de diverger le +// jour ou le mesh changera de taille - elle echoue a la COMPILATION. +static_assert(WildlifeParams{}.colliderRadius == 0.5f * kAnimalLength, + "Le rayon de collision par defaut doit rester la demi-longueur " + "du mesh de cervide (kAnimalLength)."); + +// Un animal mord-il la bande verticale du corps ? Meme forme que +// Forest::blocksBody. animal.position est aux SABOTS (voir AnimalMesh.hpp). +bool blocksBody(const Animal& animal, float height, const BodyCylinder& body) { + return body.feetY <= animal.position.y + height && body.headY >= animal.position.y; +} + +} // namespace + +bool Wildlife::overlaps(const BodyCylinder& body) const { + if (!params_.solid) { + return false; + } + + for (const Animal& animal : animals_) { + const float height = kAnimalHeight * animal.scale; + if (!blocksBody(animal, height, body)) { + continue; + } + + const float reach = colliderRadiusOf(animal) + body.radius; + const float dx = body.position.x - animal.position.x; + const float dz = body.position.z - animal.position.z; + + // Meme marge de tolerance, et pour la meme raison, que Forest::overlaps + // et EditorScene::overlaps : resolve() repousse EXACTEMENT au contact, + // et un test strict sur la meme valeur declarerait le joueur bloque sur + // la sortie de resolve(). moveBody() refuserait alors tout deplacement + // le long d'un animal au lieu de laisser glisser. + constexpr float kContactEpsilon = 1e-3f; + if (dx * dx + dz * dz < (reach - kContactEpsilon) * (reach - kContactEpsilon)) { + return true; + } + } + return false; +} + +glm::vec3 Wildlife::resolve(const BodyCylinder& body) const { + if (!params_.solid) { + return body.position; + } + + glm::vec3 corrected = body.position; + + // Meme nombre de passes que Forest, meme sortie anticipee : le cas courant + // (aucun animal au contact) ne coute qu'un balayage. + constexpr int kCollisionPasses = 4; + for (int pass = 0; pass < kCollisionPasses; ++pass) { + bool touched = false; + + for (const Animal& animal : animals_) { + const float height = kAnimalHeight * animal.scale; + // Bande verticale evaluee sur le corps SOUMIS, comme Forest : la + // resolution ne deplace jamais qu'a l'horizontale, donc la bande ne + // peut pas changer d'une passe a l'autre. + if (!blocksBody(animal, height, body)) { + continue; + } + + const float reach = colliderRadiusOf(animal) + body.radius; + const float dx = corrected.x - animal.position.x; + const float dz = corrected.z - animal.position.z; + const float distanceSq = dx * dx + dz * dz; + + if (distanceSq >= reach * reach) { + continue; + } + + const float distance = std::sqrt(distanceSq); + // Cas degenere : le joueur est exactement sur l'axe de l'animal. + // Direction arbitraire mais DETERMINISTE, plutot qu'une division + // par zero qui propagerait un NaN jusqu'a la camera. + const glm::vec2 outward = (distance > 1e-4f) + ? glm::vec2(dx / distance, dz / distance) + : glm::vec2(1.0f, 0.0f); + + corrected.x = animal.position.x + outward.x * reach; + corrected.z = animal.position.z + outward.y * reach; + touched = true; + } + + if (!touched) { + break; + } + } + + return corrected; +} + +} // namespace vercora diff --git a/src/world/Wildlife.hpp b/src/world/Wildlife.hpp new file mode 100644 index 0000000..7315dd9 --- /dev/null +++ b/src/world/Wildlife.hpp @@ -0,0 +1,308 @@ +#pragma once + +#include "core/CollisionSolver.hpp" + +#include + +#include +#include +#include +#include + +namespace vercora { + +class Habitat; +class HeightSampler; + +// =========================================================================== +// PHASE 17 : la faune, et ce qu'elle rend visible. +// =========================================================================== +// Ce fichier n'a pas pour but de simuler des animaux. Il a pour but de rendre +// OBSERVABLE une consequence : la ou le joueur passe et repasse, il n'y a plus +// rien a voir. L'animal est le seul affichage de la memoire du milieu (voir +// world/Habitat.hpp) - il n'y a ni pop-up, ni compteur, ni message. +// +// D'ou un modele deliberement pauvre, et il faut le dire franchement : +// - AUCUNE intelligence artificielle. Deux etats (paisible, en fuite), une +// direction de fuite qui est la direction oppose au joueur, et c'est tout. +// Pas de trajet, pas d'evitement d'obstacle, pas de troupeau. +// - PHASE 20 : le joueur ne traverse PLUS un animal. Wildlife implemente +// desormais CollisionSolver, exactement comme Forest et EditorScene, et +// rejoint le CompositeCollisionSolver du monde. Ce qui reste faux et le +// restera dans cette phase : un ANIMAL, lui, traverse toujours les troncs, +// les rochers poses et ses congeneres. Ce n'est pas un oubli, c'est le +// corollaire du "aucune IA" ci-dessus - une fuite en ligne droite qui +// buterait sur un obstacle resterait COLLEE dessus, faute d'evitement, et +// un animal encastre dans un tronc serait plus laid que le probleme +// resolu. Le sens qui compte pour le joueur est celui qui est traite. +// - AUCUNE persistance. Un animal qui s'eloigne assez disparait, et un autre +// apparaitra ailleurs. Ce ne sont pas des individus qu'on suit, c'est une +// POPULATION locale dont la densite depend de l'etat du milieu. +// +// C'est la meme economie que Vegetation : ce qui compte n'est pas l'objet, c'est +// la loi qui decide ou il y en a. +// +// LE SEMIS EST UN TIRAGE-REJET, comme celui de Forest : on tire un point au +// hasard autour du joueur et on le refuse s'il ne remplit pas TOUTES les +// conditions (dans l'emprise, pas trop pentu, assez boise selon la carte de +// couvert LiDAR, milieu pas trop derange, pas colle a un autre animal). Le +// nombre d'animaux reellement presents est donc une CONSEQUENCE du terrain et +// de l'etat de l'habitat, jamais une consigne. +// +// Ne connait RIEN de Vulkan : produit des positions et des matrices, c'est +// main.cpp qui en fait des DrawItem. Entierement testable sans GPU. +// =========================================================================== + +struct WildlifeParams { + // Population maximale simultanee AUTOUR DU JOUEUR. 24 : assez pour qu'une + // zone calme paraisse habitee, assez peu pour que la difference avec une + // zone derangee se compte a l'oeil. + uint32_t maxAnimals = 24; + + // Anneau d'apparition autour du joueur, en m. Le minimum est le point qui + // compte : un animal ne doit jamais apparaitre dans le champ PROCHE, sans + // quoi on verrait la mecanique au lieu du monde. + // + // 55 m, CORRIGE en cours de session apres mesure sous Vulkan (scenario I). + // Il valait 90 m, ce qui semblait prudent. Deux consequences, toutes deux + // mauvaises, et aucune n'etait visible sans faire tourner le jeu : + // 1. le joueur ne voyait jamais un animal a moins de 90 m, c'est-a-dire + // jamais un animal LISIBLE - un cervide de 1,3 m a cette distance est + // un point. La faune existait sans qu'on puisse la regarder. + // 2. surtout, l'anneau d'apparition ne recouvrait presque pas le rayon + // derange (HabitatParams::noiseRadius, 120 m) : ce qui apparaissait + // apparaissait la ou le derangement est le plus faible, donc la zone + // autour du joueur se repeuplait indefiniment malgre sa presence. Le + // run le disait : un animal a portee de vue au debut, un a la fin, + // apres quatre minutes de presence continue. + // 55 m reste au-dessus de fleeRadius (30 m) - on n'apparait pas sous le nez + // du joueur - et bien en dessous du rayon derange, ce qui est la condition + // pour que "la zone se vide" veuille dire quelque chose. + float spawnRadiusMin = 55.0f; + float spawnRadiusMax = 260.0f; + + // Au-dela, l'animal est oublie. Franchement plus grand que spawnRadiusMax : + // un animal qui fuit doit pouvoir sortir de l'anneau sans disparaitre sous + // les yeux du joueur. + float despawnRadius = 420.0f; + + // Distance a laquelle l'approche du joueur declenche la fuite, en m. 30 m : + // c'est la distance de fuite d'un chevreuil vraiment peu farouche, et c'est + // surtout la distance a laquelle un animal de 1,3 m reste identifiable a + // l'ecran. Plus court et on ne verrait jamais partir que des points. + float fleeRadius = 30.0f; + + // Vitesse de fuite en m/s. 8 m/s = 29 km/h, soit environ trois fois la + // vitesse de marche du joueur : la fuite se lit comme un depart net, et + // poursuivre un animal ne mene nulle part - ce qui est le propos. + float fleeSpeed = 8.0f; + + // Duree d'une pointe de fuite, en s. Au terme, l'animal se calme s'il est + // assez loin, sinon il repart pour un tour. + float fleeDuration = 5.0f; + + // Distance au joueur au-dela de laquelle un animal en fuite se calme. + float fleeSafeDistance = 70.0f; + + // Deplacement paisible, en m/s. 0,5 : un animal qui broute avance + // reellement, mais assez peu pour qu'on ne le prenne pas pour un patineur. + float wanderSpeed = 0.5f; + + // Changement de cap paisible, en degres par seconde (amplitude du tirage). + float wanderTurn = 25.0f; + + // --- Filtres de placement ---------------------------------------------- + // Couvert LiDAR minimal (meme grandeur que VegetationParams::coverMin) sous + // lequel aucun animal n'est place. 0,25 : un peu plus permissif que le + // semis d'arbres (0,20) parce qu'on cherche du BOIS, pas de la lande. + float minCover = 0.25f; + + // Pente maximale (en tangente) acceptee. Un ongule de montagne tient sur du + // raide, mais pas sur une paroi. + // + // PHASE 24 : 0,9 -> 0,80. La valeur n'a jamais eu de justification propre ; + // ce qu'elle porte, c'est un RAPPORT, verifie par une assertion des tests + // depuis la Phase 20 - aucun animal ne se tient sur une pente grimpable, + // sans quoi on rencontrerait des cervides en pleine paroi. L'escalade + // s'engage desormais a 0,84 au lieu de 1,00 (voir ClimberParams::wallSlope + // et core/SlopeLimits.hpp), donc ce plafond devait descendre avec elle. + // + // L'effet reel sur le jeu est proche de nul, et c'est mesurable plutot que + // suppose : les animaux sont semes sur les zones BOISEES, or ForestParams + // ::maxSlope vaut 0,6 - aucun animal n'est jamais place au-dela. Le seuil + // ne borne que l'errance a partir du point de depart. + float maxSlope = 0.80f; + + // Distance minimale entre deux animaux, en m. Evite les tas. + float minSpacing = 14.0f; + + // --- Collision (PHASE 20) ---------------------------------------------- + // Rayon du cylindre vertical qui represente l'animal face au joueur. + // + // 0,65 m = la DEMI-LONGUEUR du cervide (kAnimalLength / 2), c'est-a-dire le + // cylindre CONTENANT sa boite englobante - meme convention que l'empreinte + // des objets d'editeur (Phase 15), et pour la meme raison : un collider + // trop petit se traverse par les coins, ce qui est exactement le defaut + // qu'on vient corriger. Contrepartie assumee : de face, l'animal ne fait + // que 0,42 m de large et son cylindre est donc trop genereux d'une + // vingtaine de centimetres de chaque cote. Un cylindre ne peut pas etre + // juste dans les deux sens, et l'erreur qui bloque un peu tot est moins + // choquante que celle qui laisse passer au travers d'un flanc. + // + // Mis a l'echelle par Animal::scale, comme le mesh. + float colliderRadius = 0.65f; + + // Un animal bloque-t-il le joueur ? Faux = comportement d'AVANT la Phase 20 + // (le joueur traverse la faune). C'est le TEMOIN de la mesure, au meme + // titre que --no-scene pour l'editeur : sans lui, aucune mesure ne peut + // montrer ce que la collision change, puisqu'on ne pourrait comparer qu'a + // un autre binaire. Expose en ligne de commande par --no-animal-collision. + bool solid = true; + + // Couvert suppose quand AUCUNE carte LiDAR n'est fournie. 0,5, donc + // au-dessus de minCover : un terrain sans carte accepte la faune partout, + // ce qui est le comportement voulu pour le terrain synthetique et pour les + // tests. Ce n'est PAS un substitut par pente et altitude comme celui de + // Vegetation - il n'y a rien a imiter ici, un animal n'a pas de sylviculture. + float coverWithoutMap = 0.5f; + + // --- Cadence ----------------------------------------------------------- + // Intervalle entre deux vagues d'apparition, en s, et nombre de tirages par + // vague. Une vague par seconde avec 6 tirages : le repeuplement d'une zone + // calme prend une poignee de secondes, ce qui est assez lent pour se voir et + // assez rapide pour tenir dans une session de test. + float spawnInterval = 1.0f; + uint32_t spawnAttempts = 6; + + // Deux Wildlife de meme graine sont identiques : les tests sont + // reproductibles, comme pour Forest et Vegetation. + uint32_t seed = 20260825u; +}; + +// Deux etats, pas trois : ce que le joueur doit pouvoir lire est "il est la" ou +// "il s'en va". +enum class AnimalState { + Calm, // broute, se deplace lentement + Fleeing, // s'eloigne du joueur en ligne droite +}; + +struct Animal { + // Sabots au sol : y = terrain.heightAt(x, z). + glm::vec3 position{0.0f}; + + // Cap en degres, convention du velo (0 = +X, croissant vers +Z). + float headingDegrees = 0.0f; + + // Echelle UNIFORME du mesh (voir world/AnimalMesh.hpp). Autour de 1. + float scale = 1.0f; + + AnimalState state = AnimalState::Calm; + + // Temps restant de la pointe de fuite en cours, en s. + float fleeTimer = 0.0f; + + // Identite stable tant que l'animal vit. Sert aux tests et au journal : sans + // elle, "il y a toujours douze animaux" ne dit pas si ce sont les memes. + uint32_t id = 0; + + // translate(pieds) * rotateY(-cap) * scale(echelle). Voir la convention + // detaillee dans world/AnimalMesh.hpp. + glm::mat4 modelMatrix() const; +}; + +// Implemente CollisionSolver depuis la Phase 20 : la faune est la seule a +// savoir ou sont ses animaux, c'est donc a elle de dire au joueur qu'il ne peut +// pas passer au travers - meme partage des roles que Forest pour ses troncs et +// EditorScene pour ses objets poses. Ni Camera, ni Bike, ni Climber n'ont a +// changer : ils voient toujours l'unique CompositeCollisionSolver du monde. +class Wildlife : public CollisionSolver { +public: + // `terrain` donne l'altitude et la pente, `cover` est la carte de couvert + // LiDAR produite par tools/lidar_to_canopy.py - LA MEME que celle qui sert + // au semis d'arbres de Vegetation, echantillonnee en coordonnees monde. + // Elle peut etre nulle (voir WildlifeParams::coverWithoutMap). Aucun des + // deux n'est possede : tous deux doivent vivre plus longtemps. + // `terrainExtent` = demi-cote du terrain, pour ne rien placer hors donnees. + Wildlife(const HeightSampler& terrain, const HeightSampler* cover, + float terrainExtent, const WildlifeParams& params = {}); + + // Fait vivre la population : disparitions, fuites, deplacements paisibles, + // puis apparitions. L'`habitat` est consulte dans les deux sens - il decide + // qui part (wildlifeFlees) et ou l'on peut reapparaitre (allowsWildlife) - + // mais n'est jamais MODIFIE ici : la faune ne derange personne. + void update(float deltaTime, const glm::vec3& playerPosition, + const Habitat& habitat); + + const std::vector& animals() const { return animals_; } + std::size_t animalCount() const { return animals_.size(); } + + // Animaux presents a moins de `radius` du point donne. C'est LA grandeur + // qui dit si une zone s'est videe, et le compte total ne la remplace pas : + // la faune derangee s'ECARTE, elle ne s'evapore pas, donc la population + // globale peut rester identique pendant qu'il n'y a plus rien autour du + // joueur. Mesure sous Vulkan : 24 animaux au depart, 24 apres deux minutes + // de presence - et zero a portee de vue. + std::size_t countWithin(const glm::vec3& position, float radius) const; + + // Animaux actuellement en fuite. Expose pour le journal periodique et les + // tests : c'est la grandeur qui dit que la reaction au joueur a eu lieu. + std::size_t fleeingCount() const; + + // Nombre d'apparitions et de disparitions depuis le debut. Deux compteurs + // qui montent en permanence, donc lisibles dans un journal une fois par + // seconde : une population stable en nombre peut tres bien etre en train de + // se renouveler entierement, et c'est ce qu'on veut pouvoir constater. + uint32_t spawnCount() const { return spawnCount_; } + uint32_t despawnCount() const { return despawnCount_; } + + // Force une tentative de peuplement immediate, sans attendre la cadence. + // Utilisee au demarrage - sinon le joueur ouvre sur un monde vide qui se + // remplit sous ses yeux - et par les tests, qui ne veulent pas simuler + // vingt secondes pour observer un semis. + void populate(const glm::vec3& playerPosition, const Habitat& habitat, + uint32_t waves = 8); + + const WildlifeParams& params() const { return params_; } + + // --- CollisionSolver (PHASE 20) ---------------------------------------- + glm::vec3 resolve(const BodyCylinder& body) const override; + bool overlaps(const BodyCylinder& body) const override; + + // Rayon de collision effectif d'un animal donne (rayon nominal x echelle). + // Expose parce que c'est la grandeur que les tests PREDISENT : un arret + // annonce a `colliderRadius + bodyRadius` du centre n'est verifiable que si + // l'appelant peut lire le meme nombre que le solveur. + float colliderRadiusOf(const Animal& animal) const { + return params_.colliderRadius * animal.scale; + } + +private: + // Un point est-il un emplacement acceptable ? (emprise, pente, couvert, + // etat du milieu, espacement) + bool isPlaceable(float worldX, float worldZ, const Habitat& habitat) const; + + // Une vague de tirage-rejet. + void spawnWave(const glm::vec3& playerPosition, const Habitat& habitat); + + // Pente du terrain, par differences finies. MEME definition que + // Forest::slopeAt et Vegetation::slopeAt : les trois filtres doivent parler + // de la meme grandeur. + float slopeAt(float worldX, float worldZ) const; + + float coverAt(float worldX, float worldZ) const; + + const HeightSampler& terrain_; + const HeightSampler* cover_ = nullptr; + float terrainExtent_ = 0.0f; + WildlifeParams params_; + + std::vector animals_; + float spawnAccumulator_ = 0.0f; + uint32_t nextId_ = 1; + uint32_t spawnCount_ = 0; + uint32_t despawnCount_ = 0; + + std::mt19937 rng_; +}; + +} // namespace vercora diff --git a/tests/logic_tests.cpp b/tests/logic_tests.cpp new file mode 100644 index 0000000..96f53e2 --- /dev/null +++ b/tests/logic_tests.cpp @@ -0,0 +1,10173 @@ +// =========================================================================== +// Tests HEADLESS de la logique de jeu de Vercora. +// =========================================================================== +// Aucun GPU, aucune fenetre, aucun Vulkan : ce fichier ne compile que des unites +// qui ne dependent que de GLM (src/world, src/assets, src/core hors Window). +// Lancement : tools\run_logic_tests.bat (voir l'en-tete de ce script pour la +// raison d'etre d'un harnais separe du CMakeLists). +// +// PHASE 15 : s'y ajoute tout l'EDITEUR sauf le dessin - assets generes, +// catalogue et scan de dossier, raycast terrain, scene editable, pile +// d'annulation, collision des objets poses, solveur composite, et le format +// de scene .vcsc (aller-retour, robustesse, independance vis-a-vis de +// l'emprise du terrain charge). +// +// Ce qui est couvert : collision joueur/troncs/souches, ramassage et inventaire, +// debitage progressif d'un arbre abattu, taillage de pierre par percussion, le +// chargement d'une heightmap LiDAR .vchm (Phase 7) avec son georeferencement et +// le refus des fichiers casses, et la non-regression des phases precedentes +// (terrain, semis, visee, chute). +// +// Ce qui n'est PAS couvert et ne peut pas l'etre ici : le rendu, les couches de +// validation Vulkan, le resize, la fermeture propre. +// =========================================================================== + +#include "assets/Heightmap.hpp" +#include "assets/TerrainFile.hpp" +#include "core/CollisionSolver.hpp" +#include "core/CompositeCollisionSolver.hpp" +#include "core/Frustum.hpp" +#include "core/HeightSampler.hpp" +#include "core/SlopeLimits.hpp" +#include "core/TerrainRay.hpp" +#include "editor/AssetCatalog.hpp" +#include "editor/EditorAssets.hpp" +#include "editor/EditorController.hpp" +#include "editor/EditorScene.hpp" +#include "editor/PlacedObject.hpp" +#include "editor/SceneFile.hpp" +#include "renderer/DrawItem.hpp" +#include "renderer/TerrainMesh.hpp" +#include "renderer/TerrainNodeMesh.hpp" +#include "world/AnimalMesh.hpp" +#include "world/Forest.hpp" +#include "world/Habitat.hpp" +#include "world/Ground.hpp" +#include "world/GroundItem.hpp" +#include "world/Inventory.hpp" +#include "world/Knapping.hpp" +#include "world/Crafting.hpp" +#include "world/CraftMesh.hpp" +#include "world/StoneMesh.hpp" +#include "world/Bike.hpp" +#include "world/Climber.hpp" +#include "world/Needs.hpp" +#include "world/Weather.hpp" +#include "world/WaterSource.hpp" +#include "world/Deposits.hpp" +#include "world/Resin.hpp" +#include "world/FiberPlants.hpp" +#include "world/RockMesh.hpp" +#include "world/Rocks.hpp" +#include "world/BushMesh.hpp" +#include "world/Bushes.hpp" +#include "world/HarvestMesh.hpp" +#include "world/Paraglider.hpp" +#include "assets/TextureFile.hpp" +#include "assets/DetailNoise.hpp" +#include "renderer/InstanceData.hpp" +#include "world/GrassMesh.hpp" +#include "world/TerrainQuadtree.hpp" +#include "world/Vegetation.hpp" +#include "world/Wildlife.hpp" +#include "world/Tree.hpp" +#include "world/TreeMesh.hpp" +#include "world/TreeSpecies.hpp" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace vercora; + +namespace { + +int g_checks = 0; +int g_failures = 0; + +void check(bool condition, const std::string& label) { + ++g_checks; + if (!condition) { + ++g_failures; + std::printf(" [ECHEC] %s\n", label.c_str()); + } +} + +void checkNear(float actual, float expected, float tolerance, const std::string& label) { + const bool ok = std::abs(actual - expected) <= tolerance; + if (!ok) { + std::printf(" (attendu %.4f +/- %.4f, obtenu %.4f)\n", expected, tolerance, actual); + } + check(ok, label); +} + +void section(const char* name) { + std::printf("\n== %s ==\n", name); +} + +// Terrain plat et parfaitement previsible : les tests de collision et de +// ramassage doivent verifier LEUR logique, pas se battre avec un relief bruite. +class FlatTerrain : public HeightSampler { +public: + explicit FlatTerrain(float height = 0.0f) : height_(height) {} + float heightAt(float, float) const override { return height_; } + +private: + float height_; +}; + +// Terrain en PENTE constante : l'altitude ne depend que de x. Deux usages, tous +// deux impossibles sur un terrain plat : +// - Phase 11 : exercer d'un coup le filtre de pente et les seuils d'altitude du +// semis de vegetation ; +// - Phase 13 : imposer EXACTEMENT la pente sous les roues du velo, dont toute +// la dynamique longitudinale depend - la deviner sur du relief bruite ne +// prouverait rien. +// slope est un RISE PAR METRE horizontal (0,20 = 20 %), positif vers +X. +class SlopedTerrain : public HeightSampler { +public: + SlopedTerrain(float base, float slope) : base_(base), slope_(slope) {} + float heightAt(float x, float) const override { return base_ + slope_ * x; } + +private: + float base_; + float slope_; +}; + +// Fait rouler le velo jusqu'a ce que sa vitesse se stabilise (variation sous +// 1 mm/s d'un pas a l'autre), ou jusqu'a expiration. Renvoie la vitesse finale +// en m/s. C'est ce qui permet de verifier les vitesses D'EQUILIBRE annoncees +// dans world/Bike.hpp sans les recalculer a la main dans le test. +float settleSpeed(Bike& bike, const HeightSampler& terrain, float pedal, float brake, + float maxSeconds = 120.0f) { + constexpr float dt = 1.0f / 60.0f; + float previous = -1.0f; + for (float t = 0.0f; t < maxSeconds; t += dt) { + bike.update(dt, 0.0f, pedal, brake, terrain, nullptr); + if (t > 1.0f && std::abs(bike.speed() - previous) < 1e-3f * dt * 60.0f) { + break; + } + previous = bike.speed(); + } + return bike.speed(); +} + +// Distance horizontale entre deux points. +float horizontalDistance(const glm::vec3& a, const glm::vec3& b) { + const float dx = a.x - b.x; + const float dz = a.z - b.z; + return std::sqrt(dx * dx + dz * dz); +} + +// Corps de joueur debout sur un terrain a l'altitude groundY. +BodyCylinder standingBody(float x, float z, float groundY = 0.0f) { + constexpr float kEyeHeight = 1.7f; + BodyCylinder body; + body.position = { x, groundY + kEyeHeight, z }; + body.radius = 0.35f; + body.feetY = groundY; + body.headY = groundY + kEyeHeight + 0.15f; + return body; +} + +// Fait tourner le monde jusqu'a ce que l'arbre soit entierement debite, ou +// jusqu'a expiration. Renvoie le temps simule. +float runUntilFallen(Forest& forest, float maxSeconds, float step = 1.0f / 60.0f) { + float elapsed = 0.0f; + while (elapsed < maxSeconds) { + forest.update(step); + elapsed += step; + const bool stillMoving = + forest.trees()[0].state != TreeState::Fallen || forest.pendingDropCount() > 0; + if (!stillMoving) { + break; + } + } + return elapsed; +} + +// --------------------------------------------------------------------------- +// Non-regression des phases 1 a 5 +// --------------------------------------------------------------------------- +void testExistingBehaviourStillWorks() { + section("Non-regression : terrain, meshes, semis, visee, chute"); + + Heightmap heightmap; + check(heightmap.resolution() == 128, "Heightmap : resolution par defaut"); + check(heightmap.maxHeight() > heightmap.minHeight(), "Heightmap : relief non plat"); + + // Reproductibilite : deux terrains de meme graine sont identiques. + Heightmap twin; + check(heightmap.heightAt(3.5f, -7.25f) == twin.heightAt(3.5f, -7.25f), + "Heightmap : meme graine, meme altitude"); + + const MeshData tree = treeMeshData(kTreeProportions); + const MeshData stump = stumpMeshData(kTreeProportions); + const MeshData log = logMeshData(); + const MeshData branch = branchMeshData(); + check(!tree.empty() && !stump.empty(), "Meshes arbre et souche non vides"); + check(!log.empty() && !branch.empty(), "Meshes buche et branche non vides"); + + // Tout indice doit designer un sommet existant, sur TOUS les meshes generes. + // Un depassement ici ne planterait pas le CPU mais ferait lire au GPU de la + // memoire arbitraire - exactement le genre d'erreur que les couches de + // validation signalent et qu'on ne peut pas verifier sur cette machine. + for (const MeshData* mesh : { &tree, &stump, &log, &branch }) { + bool indicesValid = true; + for (const uint32_t index : mesh->indices) { + if (index >= mesh->vertices.size()) { + indicesValid = false; + break; + } + } + check(indicesValid, "Indices dans les bornes : " + mesh->name); + check(mesh->indices.size() % 3 == 0, "Indices multiples de 3 : " + mesh->name); + } + + // Semis, visee, abattage. + FlatTerrain flat; + Ground ground(flat); + ForestParams params; + params.treeCount = 0; // on plante a la main pour un test deterministe + Forest forest(flat, ground, 50.0f, params); + + const int index = forest.plantTree(0.0f, -10.0f, 7.0f); + check(index == 0, "plantTree renvoie l'indice du nouvel arbre"); + check(forest.treeCount() == 1, "Un seul arbre plante"); + + // Visee depuis l'origine, regard vers -Z : l'arbre est droit devant. + const int aimed = forest.pickTree({ 0.0f, 1.7f, 0.0f }, { 0.0f, 0.0f, -1.0f }, 40.0f); + check(aimed == 0, "pickTree touche l'arbre vise"); + + const int missed = forest.pickTree({ 0.0f, 1.7f, 0.0f }, { 0.0f, 0.0f, 1.0f }, 40.0f); + check(missed == kNoTree, "pickTree ne touche rien dans le dos"); + + Clearance clearance; + check(forest.fell(0, &clearance), "fell reussit sur un arbre debout"); + check(!forest.fell(0), "fell refuse un arbre deja coupe"); + checkNear(glm::length(clearance.direction), 1.0f, 1e-3f, + "Direction de chute normalisee"); +} + +// --------------------------------------------------------------------------- +// TACHE 1.1 : collision avec les troncs et les souches +// --------------------------------------------------------------------------- +void testCollision() { + section("Tache 1.1 : collision troncs et souches"); + + FlatTerrain flat; + Ground ground(flat); + ForestParams params; + params.treeCount = 0; + Forest forest(flat, ground, 50.0f, params); + + forest.plantTree(0.0f, 0.0f, 7.0f); + const Tree& tree = forest.trees()[0]; + const float trunkRadius = tree.trunkRadius(); + const float bodyRadius = 0.35f; + const float contactDistance = trunkRadius + bodyRadius; + + // 1. Loin du tronc : aucune correction. + { + const BodyCylinder body = standingBody(10.0f, 10.0f); + const glm::vec3 out = forest.resolve(body); + check(out == body.position, "Loin de tout : position inchangee"); + } + + // 2. Dans le tronc : repousse exactement au contact. + { + const BodyCylinder body = standingBody(0.05f, 0.0f); + const glm::vec3 out = forest.resolve(body); + const float distance = horizontalDistance(out, tree.base); + checkNear(distance, contactDistance, 1e-3f, + "Dans le tronc : repousse pile au contact"); + check(out.y == body.position.y, "Collision : la verticale n'est pas touchee"); + } + + // 3. Pile sur l'axe du tronc : cas degenere, pas de NaN, repousse quand meme. + { + const BodyCylinder body = standingBody(0.0f, 0.0f); + const glm::vec3 out = forest.resolve(body); + check(!std::isnan(out.x) && !std::isnan(out.z), "Cas degenere : aucun NaN"); + checkNear(horizontalDistance(out, tree.base), contactDistance, 1e-3f, + "Cas degenere : repousse au contact"); + } + + // 4. Juste en dehors du rayon de contact : rien ne bouge. + { + const BodyCylinder body = standingBody(contactDistance + 0.01f, 0.0f); + const glm::vec3 out = forest.resolve(body); + checkNear(out.x, contactDistance + 0.01f, 1e-4f, + "Juste en dehors : position inchangee"); + } + + // 5. Le houppier ne bloque pas : un corps place tres haut, au-dessus de la + // cime, ne doit plus rien rencontrer. + { + BodyCylinder body = standingBody(0.0f, 0.0f); + body.feetY = tree.base.y + tree.height + 1.0f; + body.headY = body.feetY + 1.85f; + const glm::vec3 out = forest.resolve(body); + check(out == body.position, "Au-dessus de la cime : pas de collision"); + } + + // 6. Souche : une fois l'arbre entierement debite, l'obstacle se reduit a la + // souche. Les pieds sont bloques... + { + forest.fell(0); + runUntilFallen(forest, 12.0f); + check(forest.trees()[0].state == TreeState::Fallen, + "L'arbre finit par atteindre l'etat Fallen"); + + const BodyCylinder body = standingBody(0.05f, 0.0f); + const glm::vec3 out = forest.resolve(body); + checkNear(horizontalDistance(out, tree.base), contactDistance, 1e-3f, + "Souche : le joueur ne la traverse pas"); + } + + // 7. ... mais le volume au-dessus de la souche est libre : un corps dont les + // pieds sont plus haut que la souche passe. + { + const Tree& felled = forest.trees()[0]; + BodyCylinder body = standingBody(0.05f, 0.0f); + body.feetY = felled.base.y + felled.stumpHeight() + 0.05f; + body.headY = body.feetY + 1.85f; + const glm::vec3 out = forest.resolve(body); + check(out == body.position, "Au-dessus de la souche : plus d'obstacle"); + } + + // 8. Glissement : un joueur pousse contre le tronc mais decale lateralement + // doit ressortir decale du meme cote, pas rejete a l'oppose. + { + Ground ground2(flat); + Forest forest2(flat, ground2, 50.0f, params); + forest2.plantTree(0.0f, 0.0f, 7.0f); + + const BodyCylinder body = standingBody(0.10f, 0.20f); + const glm::vec3 out = forest2.resolve(body); + check(out.x > 0.0f && out.z > 0.0f, "Glissement : repousse du bon cote"); + checkNear(horizontalDistance(out, glm::vec3(0.0f)), contactDistance, 1e-3f, + "Glissement : ressort au contact"); + } + + // 9. MARCHE reelle vers un passage trop etroit. C'est le vrai scenario de + // jeu, et le seul qui compte : le joueur avance pas a pas, la collision + // etant resolue a chaque pas. Il ne doit JAMAIS finir a l'interieur d'un + // tronc, meme en poussant contre un entre-deux infranchissable. + // + // Deux troncs distants de 1.2 m et larges de 0.63 m laissent un passage + // de 0.57 m, alors que le joueur en fait 0.70 : le passage est + // geometriquement infranchissable, et c'est voulu - on veut verifier que + // la collision refuse proprement, pas qu'elle laisse passer. + { + Ground ground3(flat); + Forest forest3(flat, ground3, 50.0f, params); + forest3.plantTree(-0.6f, 0.0f, 7.0f); + forest3.plantTree(0.6f, 0.0f, 7.0f); + + glm::vec3 position{ 0.0f, 1.7f, 4.0f }; + bool everInsideATrunk = false; + bool everNaN = false; + + // 200 pas de 5 cm droit vers -Z : de quoi traverser largement, si la + // collision ne faisait pas son travail. On passe par moveBody, comme la + // camera : c'est lui qui garantit qu'on ne franchit pas un passage plus + // etroit que soi. + for (int step = 0; step < 200; ++step) { + const glm::vec3 previous = position; + position.z -= 0.05f; + + BodyCylinder body = standingBody(position.x, position.z); + body.position = position; + position = moveBody(forest3, body, previous); + + if (std::isnan(position.x) || std::isnan(position.z)) { + everNaN = true; + break; + } + for (const Tree& other : forest3.trees()) { + if (horizontalDistance(position, other.base) < + other.trunkRadius() + 0.35f - 1e-3f) { + everInsideATrunk = true; + } + } + } + + check(!everNaN, "Marche : aucun NaN sur 200 pas"); + check(!everInsideATrunk, "Marche : jamais a l'interieur d'un tronc"); + check(position.z > -0.6f, + "Marche : le passage trop etroit n'est pas franchi"); + } + + // 10. Le meme passage, mais assez large pour passer : la collision ne doit + // pas bloquer un joueur qui a la place de se faufiler. + { + Ground ground4(flat); + Forest forest4(flat, ground4, 50.0f, params); + forest4.plantTree(-1.6f, 0.0f, 7.0f); + forest4.plantTree(1.6f, 0.0f, 7.0f); + + glm::vec3 position{ 0.0f, 1.7f, 4.0f }; + for (int step = 0; step < 200; ++step) { + const glm::vec3 previous = position; + position.z -= 0.05f; + BodyCylinder body = standingBody(position.x, position.z); + body.position = position; + position = moveBody(forest4, body, previous); + } + check(position.z < -4.0f, "Marche : un passage assez large se franchit"); + } + + // 11. L'exigence de base, de bout en bout : marcher droit sur un tronc doit + // s'arreter dessus. C'est litteralement ce que la Phase 5 ne faisait pas. + { + Ground ground5(flat); + Forest forest5(flat, ground5, 50.0f, params); + forest5.plantTree(0.0f, 0.0f, 7.0f); + const float stopDistance = forest5.trees()[0].trunkRadius() + 0.35f; + + glm::vec3 position{ 0.0f, 1.7f, 4.0f }; + for (int step = 0; step < 200; ++step) { + const glm::vec3 previous = position; + position.z -= 0.05f; + BodyCylinder body = standingBody(position.x, position.z); + body.position = position; + position = moveBody(forest5, body, previous); + } + check(position.z > 0.0f, "Marche : le tronc arrete le joueur"); + checkNear(horizontalDistance(position, glm::vec3(0.0f)), stopDistance, 0.06f, + "Marche : le joueur s'arrete au contact du tronc"); + } + + // 12. Une souche, elle, arrete aussi le joueur (exigence explicite), et + // resolve()/overlaps() doivent etre d'accord sur leur propre sortie. + { + Ground ground6(flat); + Forest forest6(flat, ground6, 50.0f, params); + forest6.plantTree(0.0f, 0.0f, 7.0f); + forest6.fell(0); + runUntilFallen(forest6, 12.0f); + + glm::vec3 position{ 0.0f, 1.7f, 4.0f }; + for (int step = 0; step < 200; ++step) { + const glm::vec3 previous = position; + position.z -= 0.05f; + BodyCylinder body = standingBody(position.x, position.z); + body.position = position; + position = moveBody(forest6, body, previous); + } + check(position.z > 0.0f, "Marche : la souche arrete le joueur"); + + BodyCylinder settled = standingBody(position.x, position.z); + settled.position = position; + check(!forest6.overlaps(settled), + "overlaps() et resolve() sont d'accord sur la position finale"); + } +} + +// --------------------------------------------------------------------------- +// TACHE 1.2 : ramassage reel des buches et branches +// --------------------------------------------------------------------------- +void testPickup() { + section("Tache 1.2 : ramassage et inventaire"); + + FlatTerrain flat(12.0f); + Ground ground(flat); + + check(ground.itemCount() == 0, "Sol vide au depart"); + + ground.drop(GroundItemKind::Log, 2.0f, 0.0f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Branch, 20.0f, 0.0f, 0.0f, 0.0f); + check(ground.itemCount() == 2, "Deux objets deposes"); + + // Depose sur le terrain, pas dedans ni au-dessus. + checkNear(ground.items()[0].position.y, 12.0f + kLogRadius, 1e-4f, + "Buche posee sur la surface du terrain"); + + const glm::vec3 player{ 0.0f, 13.7f, 0.0f }; + + // Hors de portee : rien. + check(ground.findNearest(player, 1.0f) == kNoGroundItem, + "Rien a portee de 1 m"); + + // A portee : la buche, pas la branche lointaine. + const int nearest = ground.findNearest(player, 3.0f); + check(nearest != kNoGroundItem, "Buche trouvee a portee de 3 m"); + + GroundItemKind picked = GroundItemKind::Stone; + check(ground.pickUp(nearest, &picked), "Ramassage reussi"); + check(picked == GroundItemKind::Log, "L'objet ramasse est bien la buche"); + check(ground.itemCount() == 1, "L'objet a disparu de la scene"); + + // Le meme indice ne doit plus rien donner de valide au-dela de la taille. + check(!ground.pickUp(5), "Indice hors bornes refuse"); + check(!ground.pickUp(-1), "Indice negatif refuse"); + + // Inventaire. + Inventory inventory; + check(inventory.total() == 0, "Inventaire vide au depart"); + inventory.add(picked); + check(inventory.count(GroundItemKind::Log) == 1, "Une buche comptee"); + check(inventory.total() == 1, "Total d'inventaire coherent"); + check(!inventory.remove(GroundItemKind::Log, 2), "Retrait impossible refuse"); + check(inventory.count(GroundItemKind::Log) == 1, + "Un retrait refuse ne modifie rien"); + check(inventory.remove(GroundItemKind::Log), "Retrait possible accepte"); + check(inventory.total() == 0, "Inventaire vide apres retrait"); + + // Le resume doit nommer les quatre natures : c'est ce qui s'affiche dans le + // titre de la fenetre. + const std::string summary = inventory.summary(); + check(summary.find("buches") != std::string::npos, "Resume : buches"); + check(summary.find("branches") != std::string::npos, "Resume : branches"); + check(summary.find("pierres") != std::string::npos, "Resume : pierres"); + check(summary.find("eclats") != std::string::npos, "Resume : eclats"); + + // Ramassage a repetition : tout doit pouvoir etre vide sans trou ni doublon + // (le pickUp par echange avec le dernier element est un piege classique). + { + Ground bulk(flat); + for (int i = 0; i < 10; ++i) { + bulk.drop(GroundItemKind::Stone, static_cast(i) * 0.1f, 0.0f, 0.0f, 0.0f); + } + int collected = 0; + while (true) { + const int index = bulk.findNearest({ 0.0f, 13.7f, 0.0f }, 50.0f); + if (index == kNoGroundItem) { + break; + } + if (!bulk.pickUp(index)) { + break; + } + ++collected; + } + check(collected == 10, "Les 10 objets sont tous ramassables"); + check(bulk.itemCount() == 0, "Sol vide apres ramassage complet"); + } +} + +// --------------------------------------------------------------------------- +// TACHE 1.3 : transition de chute et debitage progressif +// --------------------------------------------------------------------------- +void testProgressiveFall() { + section("Tache 1.3 : chute, amortissement, debitage progressif"); + + FlatTerrain flat; + Ground ground(flat); + ForestParams params; + params.treeCount = 0; + Forest forest(flat, ground, 50.0f, params); + forest.plantTree(0.0f, 0.0f, 7.0f); + + check(forest.trees()[0].state == TreeState::Standing, "Arbre debout au depart"); + forest.fell(0); + check(forest.trees()[0].state == TreeState::Falling, "Arbre en chute apres fell"); + + constexpr float kStep = 1.0f / 60.0f; + + // Phase 1 : la bascule. Rien ne doit tomber au sol pendant ce temps. + float elapsed = 0.0f; + while (forest.trees()[0].state == TreeState::Falling && elapsed < 10.0f) { + forest.update(kStep); + elapsed += kStep; + } + check(forest.trees()[0].state == TreeState::Settling, + "La chute debouche sur l'amortissement, pas sur la disparition"); + check(ground.itemCount() == 0, "Aucun bois au sol pendant la chute"); + check(elapsed < 4.0f, "La chute dure un temps raisonnable"); + + // Phase 2 : l'amortissement. L'arbre est TOUJOURS dessine (state != Fallen) + // et reste couche, jamais au-dessus de l'horizontale. + constexpr float kHalfPi = 1.57079632679f; + float settlingFrames = 0.0f; + bool stayedBelowHorizontal = true; + while (forest.trees()[0].state == TreeState::Settling && settlingFrames < 5.0f) { + forest.update(kStep); + settlingFrames += kStep; + if (forest.trees()[0].fallAngle > kHalfPi + 1e-4f) { + stayedBelowHorizontal = false; + } + } + check(settlingFrames > 0.3f, "L'arbre reste visible au sol un temps lisible"); + check(stayedBelowHorizontal, + "L'amortissement ne fait jamais repasser l'arbre sous terre"); + check(forest.trees()[0].state == TreeState::Fallen, + "L'amortissement debouche sur le debitage"); + + // Phase 3 : le debitage. Les pieces arrivent une par une, pas toutes d'un + // coup - c'est precisement le defaut de la Phase 5 qu'on corrige ici. + const std::size_t afterFirstFrame = ground.itemCount(); + check(afterFirstFrame >= 1, "La premiere buche sort des la disparition du tronc"); + check(forest.pendingDropCount() > 0, "Il reste du bois a degager"); + check(afterFirstFrame < 7, "Le bois n'apparait PAS tout d'un coup"); + + // On laisse le debitage se terminer. + int distinctCounts = 0; + std::size_t previous = afterFirstFrame; + float buckingTime = 0.0f; + while (forest.pendingDropCount() > 0 && buckingTime < 10.0f) { + forest.update(kStep); + buckingTime += kStep; + if (ground.itemCount() != previous) { + ++distinctCounts; + previous = ground.itemCount(); + } + } + + check(forest.pendingDropCount() == 0, "Tout le bois a fini par tomber"); + check(distinctCounts >= 3, "Le bois est apparu en plusieurs fois"); + check(buckingTime > 0.3f, "Le debitage s'etale dans le temps"); + + // Un arbre de 7 m : 2 buches (7/2.4 = 2) et 4 branches. + const int logs = static_cast(7.0f / 2.4f); + check(ground.itemCount() == static_cast(logs + 4), + "Nombre total de pieces conforme"); + + int logCount = 0; + int branchCount = 0; + for (const GroundItem& item : ground.items()) { + if (item.kind == GroundItemKind::Log) ++logCount; + if (item.kind == GroundItemKind::Branch) ++branchCount; + } + check(logCount == logs, "Le bon nombre de buches"); + check(branchCount == 4, "Le bon nombre de branches"); + + // Plus rien ne doit bouger une fois tout retombe. + const std::size_t settled = ground.itemCount(); + for (int i = 0; i < 120; ++i) { + forest.update(kStep); + } + check(ground.itemCount() == settled, "Etat stable apres debitage"); +} + +// --------------------------------------------------------------------------- +// TACHE 2 : pierres et taillage par percussion +// --------------------------------------------------------------------------- +void testStoneKnapping() { + section("Tache 2 : pierres ramassables et percussion"); + + // Meshes generes en code. + const MeshData stone = stoneMeshData(); + const MeshData flake = flakeMeshData(); + check(!stone.empty(), "Mesh de pierre non vide"); + check(!flake.empty(), "Mesh d'eclat non vide"); + check(stone.indices.size() % 3 == 0, "Pierre : indices multiples de 3"); + check(flake.indices.size() % 3 == 0, "Eclat : indices multiples de 3"); + + for (const MeshData* mesh : { &stone, &flake }) { + bool indicesValid = true; + bool normalsUnit = true; + bool withinBounds = true; + for (const uint32_t index : mesh->indices) { + if (index >= mesh->vertices.size()) { + indicesValid = false; + break; + } + } + for (const Vertex& vertex : mesh->vertices) { + if (std::abs(glm::length(vertex.normal) - 1.0f) > 1e-3f) { + normalsUnit = false; + } + // Un objet ramassable doit tenir dans un volume de la taille d'une + // main : une erreur d'echelle donnerait un rocher de 3 m qu'on + // ramasserait quand meme, sans que rien ne le signale. + if (std::abs(vertex.pos.x) > 0.4f || std::abs(vertex.pos.y) > 0.4f || + std::abs(vertex.pos.z) > 0.4f) { + withinBounds = false; + } + } + check(indicesValid, "Indices dans les bornes : " + mesh->name); + check(normalsUnit, "Normales unitaires : " + mesh->name); + check(withinBounds, "Dimensions plausibles : " + mesh->name); + } + + // Semis de pierres. + FlatTerrain flat; + Ground ground(flat); + const uint32_t placed = ground.scatterStones(2, 20.0f, 4.0f, 50.0f); + check(placed == 2, "Les deux pierres demandees sont semees"); + check(ground.itemCount() == 2, "Deux objets au sol"); + + bool allStones = true; + bool allReachable = true; + for (const GroundItem& item : ground.items()) { + if (item.kind != GroundItemKind::Stone) allStones = false; + const float distance = std::sqrt(item.position.x * item.position.x + + item.position.z * item.position.z); + if (distance < 4.0f || distance > 20.0f) allReachable = false; + } + check(allStones, "Les objets semes sont bien des pierres"); + check(allReachable, "Pierres semees dans la couronne demandee"); + checkNear(ground.items()[0].position.y, kStoneRadius, 1e-4f, + "Pierre posee sur la surface du terrain"); + + // Percussion. + Inventory inventory; + const glm::vec3 player{ 0.0f, 1.7f, 0.0f }; + const glm::vec3 facing{ 0.0f, -0.2f, -1.0f }; // regard vers -Z, legerement baisse + + check(knapStones(inventory, ground, player, facing) == KnapResult::NotEnoughStones, + "Percussion refusee sans pierre"); + + inventory.add(GroundItemKind::Stone); + check(knapStones(inventory, ground, player, facing) == KnapResult::NotEnoughStones, + "Percussion refusee avec une seule pierre"); + check(inventory.count(GroundItemKind::Stone) == 1, + "Un echec ne consomme aucune pierre"); + + inventory.add(GroundItemKind::Stone); + const std::size_t beforeKnap = ground.itemCount(); + check(knapStones(inventory, ground, player, facing) == KnapResult::Success, + "Percussion reussie avec deux pierres"); + check(inventory.count(GroundItemKind::Stone) == 1, + "La percussion consomme exactement une pierre"); + check(ground.itemCount() == beforeKnap + 1, "Un objet est apparu dans le monde"); + + // L'eclat existe dans le MONDE (et non dans l'inventaire), devant le joueur. + const GroundItem& produced = ground.items().back(); + check(produced.kind == GroundItemKind::Flake, "L'objet produit est un eclat"); + check(inventory.count(GroundItemKind::Flake) == 0, + "L'eclat n'atterrit pas directement dans l'inventaire"); + check(produced.position.z < player.z, "L'eclat tombe devant le joueur (vers -Z)"); + checkNear(horizontalDistance(produced.position, player), 1.1f, 1e-3f, + "L'eclat tombe a portee de bras"); + + // ... et il est ramassable comme n'importe quoi d'autre. + const int index = ground.findNearest(player, 2.0f); + check(index != kNoGroundItem, "L'eclat est a portee de ramassage"); + GroundItemKind kind = GroundItemKind::Log; + check(ground.pickUp(index, &kind) && kind == GroundItemKind::Flake, + "L'eclat se ramasse"); + + // Regard parfaitement vertical : cas degenere, aucun NaN dans la position. + { + Inventory vertical; + vertical.add(GroundItemKind::Stone, 2); + Ground groundVertical(flat); + check(knapStones(vertical, groundVertical, player, { 0.0f, -1.0f, 0.0f }) == + KnapResult::Success, + "Percussion possible en regardant ses pieds"); + const GroundItem& item = groundVertical.items().back(); + check(!std::isnan(item.position.x) && !std::isnan(item.position.z), + "Regard vertical : aucun NaN dans la position de l'eclat"); + } +} + +// --------------------------------------------------------------------------- +// Construction de la liste d'objets a dessiner +// --------------------------------------------------------------------------- +// main.cpp ne peut PAS etre compile par ce harnais : il tire le Renderer, donc +// Vulkan. Mais DrawItem, lui, ne depend que de GLM - on peut donc rejouer ici la +// partie la plus facile a casser de la boucle de rendu (quel objet est dessine +// dans quel etat, et avec quel mesh) et verifier qu'elle tient. +// +// Ce test ne prouve pas que main.cpp compile. Il prouve que la LOGIQUE qu'il +// applique est correcte, ce qui est le principal risque a cet endroit. +void testDrawListConstruction() { + section("Rendu : composition de la liste d'objets"); + + FlatTerrain flat; + Ground ground(flat); + ForestParams params; + params.treeCount = 0; + Forest forest(flat, ground, 50.0f, params); + forest.plantTree(0.0f, -8.0f, 7.0f); + + // Table mesh-par-nature, exactement comme dans main.cpp : c'est le passage + // ou un oubli donnerait un kInvalidMesh envoye au Renderer. + std::array groundMeshes{}; + groundMeshes.fill(kInvalidMesh); + groundMeshes[static_cast(GroundItemKind::Log)] = 10; + groundMeshes[static_cast(GroundItemKind::Branch)] = 11; + groundMeshes[static_cast(GroundItemKind::Stone)] = 12; + groundMeshes[static_cast(GroundItemKind::Flake)] = 13; + // PHASE 22 : les quatre matieres ajoutees doivent elles aussi avoir leur + // mesh. C'est CE test qui a signale leur oubli quand l'enum a grandi. + groundMeshes[static_cast(GroundItemKind::Clay)] = 14; + groundMeshes[static_cast(GroundItemKind::Sand)] = 15; + groundMeshes[static_cast(GroundItemKind::Resin)] = 16; + groundMeshes[static_cast(GroundItemKind::Fiber)] = 17; + // PHASE 28 : les cinq objets faconnes, comme dans main.cpp. + groundMeshes[static_cast(GroundItemKind::Cord)] = 18; + groundMeshes[static_cast(GroundItemKind::Axe)] = 19; + groundMeshes[static_cast(GroundItemKind::Hearth)] = 20; + groundMeshes[static_cast(GroundItemKind::Ash)] = 21; + groundMeshes[static_cast(GroundItemKind::Pitch)] = 22; + // PHASE 28 (Agent 3) : hache renforcee et abri. + groundMeshes[static_cast(GroundItemKind::PitchedAxe)] = 23; + groundMeshes[static_cast(GroundItemKind::Shelter)] = 24; + + bool everyKindHasAMesh = true; + for (const MeshHandle handle : groundMeshes) { + if (handle == kInvalidMesh) { + everyKindHasAMesh = false; + } + } + check(everyKindHasAMesh, + "Chaque nature d'objet au sol a son mesh (aucun trou dans la table)"); + + constexpr MeshHandle kTreeMesh = 1; + constexpr MeshHandle kStumpMesh = 2; + + // Reproduit la boucle de main.cpp. + const auto buildDrawItems = [&]() { + std::vector items; + for (const Tree& tree : forest.trees()) { + if (tree.state != TreeState::Standing) { + items.push_back({ kStumpMesh, tree.stumpMatrix(), Material::Object }); + } + if (tree.state != TreeState::Fallen) { + items.push_back({ kTreeMesh, tree.modelMatrix(), Material::Object }); + } + } + for (const GroundItem& item : ground.items()) { + const MeshHandle mesh = groundMeshes[static_cast(item.kind)]; + if (mesh != kInvalidMesh) { + items.push_back({ mesh, item.modelMatrix(), Material::Object }); + } + } + return items; + }; + + // Debout : l'arbre seul, pas de souche. + { + const std::vector items = buildDrawItems(); + check(items.size() == 1, "Arbre debout : un seul objet dessine"); + check(items[0].mesh == kTreeMesh, "Arbre debout : c'est le mesh d'arbre"); + } + + constexpr float kStep = 1.0f / 60.0f; + forest.fell(0); + + // En chute : souche + arbre incline. C'est ce couple qui rend le trait de + // coupe lisible. + forest.update(kStep); + { + const std::vector items = buildDrawItems(); + check(items.size() == 2, "Arbre en chute : souche + arbre"); + } + + // Amortissement : l'arbre est TOUJOURS dessine. C'est tout l'objet de la + // Tache 1.3 - en Phase 5 il avait deja disparu a cet instant. + while (forest.trees()[0].state == TreeState::Falling) { + forest.update(kStep); + } + { + const std::vector items = buildDrawItems(); + check(forest.trees()[0].state == TreeState::Settling, "Etat Settling atteint"); + check(items.size() == 2, "Arbre couche en amortissement : encore dessine"); + check(ground.items().empty(), "Amortissement : rien encore au sol"); + } + + // Debitage termine : plus d'arbre, une souche, et tout le bois. + runUntilFallen(forest, 12.0f); + { + const std::vector items = buildDrawItems(); + const std::size_t expected = 1 + ground.items().size(); // souche + bois + + check(items.size() == expected, "Arbre debite : souche + tout le bois"); + + bool anyTreeMesh = false; + bool allHandlesValid = true; + for (const DrawItem& item : items) { + if (item.mesh == kTreeMesh) anyTreeMesh = true; + if (item.mesh == kInvalidMesh) allHandlesValid = false; + } + check(!anyTreeMesh, "Arbre debite : le mesh d'arbre n'est plus dessine"); + check(allHandlesValid, "Aucun mesh invalide envoye au rendu"); + } + + // Les matrices d'instance doivent rester finies : un NaN dans une model + // matrix ne fait pas planter le CPU, il fait disparaitre l'objet a l'ecran + // (ou pire, tout l'ecran) sans le moindre message. + { + ground.drop(GroundItemKind::Stone, 3.0f, 4.0f, 1.2f, 0.4f); + const std::vector items = buildDrawItems(); + bool allFinite = true; + for (const DrawItem& item : items) { + for (int column = 0; column < 4; ++column) { + for (int row = 0; row < 4; ++row) { + if (std::isnan(item.model[column][row]) || + std::isinf(item.model[column][row])) { + allFinite = false; + } + } + } + } + check(allFinite, "Toutes les matrices d'instance sont finies"); + } +} + +// --------------------------------------------------------------------------- +// PHASE 7 : heightmap chargee depuis un fichier .vchm (donnees LiDAR reelles) +// --------------------------------------------------------------------------- +// La grille de test est construite ICI, octet par octet, plutot que lue depuis +// assets/ : le harnais reste ainsi executable sur un depot frais, ou les 4 Mo de +// heightmap et les 167 Mo de nuage de points ne sont pas versionnes. Le vrai +// fichier, s'il est present, est verifie en plus a la fin. + +constexpr std::size_t kVchmHeaderSize = 120; + +// Ecrit un .vchm minimal. Reproduit le format decrit dans TerrainFile.hpp, sans +// rien partager avec le lecteur : une erreur de decalage dans l'un ne peut pas +// se compenser dans l'autre. +void writeVchm(const std::filesystem::path& path, uint32_t nx, uint32_t nz, + float spacing, const std::vector& heights, + const char* label = "grille de test", + uint32_t version = 1, const char* magic = "VCHM", + double originEast = 907000.0, double originNorth = 6440000.0, + uint32_t epsg = 2154, uint32_t flags = 1, + bool lieAboutBounds = false) { + unsigned char header[kVchmHeaderSize] = {}; + std::memcpy(header + 0, magic, 4); + std::memcpy(header + 4, &version, 4); + std::memcpy(header + 8, &nx, 4); + std::memcpy(header + 12, &nz, 4); + std::memcpy(header + 16, &spacing, 4); + + std::memcpy(header + 24, &originEast, 8); + std::memcpy(header + 32, &originNorth, 8); + + float lo = heights.empty() ? 0.0f : heights[0]; + float hi = lo; + for (float h : heights) { lo = std::min(lo, h); hi = std::max(hi, h); } + if (lieAboutBounds) { lo -= 100.0f; hi += 100.0f; } + std::memcpy(header + 40, &lo, 4); + std::memcpy(header + 44, &hi, 4); + std::memcpy(header + 48, &epsg, 4); + std::memcpy(header + 52, &flags, 4); + std::memcpy(header + 56, label, std::min(std::strlen(label), 63)); + + std::ofstream out(path, std::ios::binary | std::ios::trunc); + out.write(reinterpret_cast(header), kVchmHeaderSize); + out.write(reinterpret_cast(heights.data()), + static_cast(heights.size() * sizeof(float))); +} + +// true si loadTerrainFile refuse le fichier. Un fichier casse DOIT lever : +// charger un terrain a moitie faux et s'en apercevoir a l'ecran est exactement +// ce que ces gardes-fous evitent. +bool rejects(const std::filesystem::path& path) { + try { + loadTerrainFile(path.string()); + return false; + } catch (const std::exception&) { + return true; + } +} + +void testTerrainFile() { + section("Phase 7 : heightmap LiDAR chargee depuis un fichier .vchm"); + + const std::filesystem::path dir = + std::filesystem::temp_directory_path() / "vercora_tests"; + std::filesystem::create_directories(dir); + + // Grille ASYMETRIQUE dans les deux directions, et avec des coefficients + // differents sur chaque axe : c'est ce qui rend un axe inverse ou deux axes + // echanges detectables. Une grille symetrique passerait tous les tests + // ci-dessous meme lue de travers. + const uint32_t n = 5; + const float spacing = 2.0f; + std::vector heights(static_cast(n) * n); + for (uint32_t iz = 0; iz < n; ++iz) { + for (uint32_t ix = 0; ix < n; ++ix) { + heights[static_cast(iz) * n + ix] = + 400.0f + static_cast(ix) + 10.0f * static_cast(iz); + } + } + + const std::filesystem::path good = dir / "good.vchm"; + writeVchm(good, n, n, spacing, heights, "dalle de test"); + + { + const Heightmap loaded = loadTerrainFile(good.string()); + + check(loaded.resolution() == n, "Fichier : resolution relue"); + checkNear(loaded.spacing(), spacing, 1e-6f, "Fichier : pas relu"); + // worldSize DECOULE du pas : (n - 1) cellules de 2 m = 8 m. + checkNear(loaded.worldSize(), 8.0f, 1e-6f, "Fichier : emprise deduite du pas"); + checkNear(loaded.minHeight(), 400.0f, 1e-4f, "Fichier : altitude minimale"); + checkNear(loaded.maxHeight(), 444.0f, 1e-4f, "Fichier : altitude maximale"); + check(loaded.describe() == "dalle de test", "Fichier : label repris dans describe()"); + + // Indexation : at(ix, iz), donc l'altitude doit croitre de 1 vers l'est + // et de 10 vers le sud. Inverser les deux boucles de lecture donnerait + // ici 10 et 1 - le test discrimine. + checkNear(loaded.at(0, 0), 400.0f, 1e-4f, "Fichier : coin (0,0)"); + checkNear(loaded.at(4, 0), 404.0f, 1e-4f, "Fichier : +1 par pas vers l'est"); + checkNear(loaded.at(0, 4), 440.0f, 1e-4f, "Fichier : +10 par pas vers le sud"); + checkNear(loaded.at(4, 4), 444.0f, 1e-4f, "Fichier : coin oppose"); + + // Le terrain est centre sur l'origine : l'echantillon (0,0) est donc en + // (-4, -4) et le dernier en (+4, +4). + checkNear(loaded.worldCoord(0), -4.0f, 1e-6f, "Fichier : bord ouest a -worldSize/2"); + checkNear(loaded.worldCoord(4), 4.0f, 1e-6f, "Fichier : bord est a +worldSize/2"); + checkNear(loaded.heightAt(-4.0f, -4.0f), 400.0f, 1e-4f, + "Fichier : heightAt au coin nord-ouest"); + checkNear(loaded.heightAt(4.0f, 4.0f), 444.0f, 1e-4f, + "Fichier : heightAt au coin sud-est"); + // Milieu d'une cellule : l'interpolation affine doit donner la moyenne + // exacte des deux extremites sur cette grille lineaire. + checkNear(loaded.heightAt(-3.0f, -4.0f), 400.5f, 1e-4f, + "Fichier : heightAt interpole entre deux echantillons"); + + // Georeferencement. + check(loaded.geo().isGeoreferenced(), "Fichier : grille georeferencee"); + check(loaded.geo().epsg == 2154, "Fichier : EPSG relu"); + check(loaded.geo().absoluteAltitude, "Fichier : drapeau d'altitude absolue"); + + // toProjected : le centre du monde tombe au centre de la dalle, et les + // deux axes ont des SIGNES OPPOSES en projection (est croissant, nord + // decroissant). C'est la seule verification ecrite de cette regle. + double east = 0.0, north = 0.0; + loaded.toProjected(0.0f, 0.0f, &east, &north); + checkNear(static_cast(east), 907004.0f, 1e-2f, + "toProjected : centre, coordonnee est"); + checkNear(static_cast(north), 6439996.0f, 1e-2f, + "toProjected : centre, coordonnee nord"); + + loaded.toProjected(-4.0f, -4.0f, &east, &north); + checkNear(static_cast(east), 907000.0f, 1e-2f, + "toProjected : coin nord-ouest = origine du fichier (est)"); + checkNear(static_cast(north), 6440000.0f, 1e-2f, + "toProjected : coin nord-ouest = origine du fichier (nord)"); + + loaded.toProjected(4.0f, 4.0f, &east, &north); + checkNear(static_cast(east), 907008.0f, 1e-2f, + "toProjected : aller a l'est AUGMENTE l'abscisse projetee"); + checkNear(static_cast(north), 6439992.0f, 1e-2f, + "toProjected : aller au sud (+Z) DIMINUE l'ordonnee projetee"); + + // Le maillage reste celui de la Phase 4, sans adaptation : c'etait tout + // l'interet de faire passer les donnees par Heightmap. + const MeshData mesh = terrainMeshData(loaded); + check(mesh.vertices.size() == static_cast(n) * n, + "TerrainMesh : un sommet par echantillon"); + check(mesh.triangleCount() == (n - 1) * (n - 1) * 2, + "TerrainMesh : deux triangles par cellule"); + check(mesh.name == "dalle de test", "TerrainMesh : nom repris de la heightmap"); + bool posMatches = true; + for (uint32_t iz = 0; iz < n; ++iz) { + for (uint32_t ix = 0; ix < n; ++ix) { + const Vertex& v = mesh.vertices[static_cast(iz) * n + ix]; + if (std::abs(v.pos.y - loaded.at(ix, iz)) > 1e-4f) { posMatches = false; } + } + } + check(posMatches, "TerrainMesh : altitude de chaque sommet = celle de la grille"); + } + + // --- Fichiers refuses --------------------------------------------------- + { + const std::filesystem::path bad = dir / "bad.vchm"; + + writeVchm(bad, n, n, spacing, heights, "x", 1, "NOPE"); + check(rejects(bad), "Refus : magie incorrecte"); + + writeVchm(bad, n, n, spacing, heights, "x", 99); + check(rejects(bad), "Refus : version inconnue"); + + // Grille rectangulaire : limite assumee, mais elle doit etre SIGNALEE. + std::vector rect(static_cast(n) * (n + 1), 1.0f); + writeVchm(bad, n, n + 1, spacing, rect); + check(rejects(bad), "Refus : grille non carree"); + + writeVchm(bad, n, n, 0.0f, heights); + check(rejects(bad), "Refus : pas de grille nul"); + + writeVchm(bad, 1, 1, spacing, std::vector{1.0f}); + check(rejects(bad), "Refus : grille d'un seul echantillon"); + + // Tronque : l'en-tete annonce 25 altitudes, le fichier n'en contient + // que 10. Sans le controle de taille, on lirait des zeros en silence. + writeVchm(bad, n, n, spacing, heights); + std::filesystem::resize_file(bad, kVchmHeaderSize + 10 * sizeof(float)); + check(rejects(bad), "Refus : fichier tronque"); + + // NaN : le cas typique d'une cellule sans point de retour mal traitee en + // amont. Un seul suffit a produire un triangle degenere. + std::vector withNan = heights; + withNan[7] = std::numeric_limits::quiet_NaN(); + writeVchm(bad, n, n, spacing, withNan); + check(rejects(bad), "Refus : altitude NaN"); + + check(rejects(dir / "ce-fichier-n-existe-pas.vchm"), "Refus : fichier absent"); + + // En-tete qui ment sur les bornes : accepte (les donnees font foi) mais + // doit produire un avertissement. On verifie au moins que ca ne casse pas. + writeVchm(bad, n, n, spacing, heights, "bornes fausses", 1, "VCHM", + 907000.0, 6440000.0, 2154, 1, /*lieAboutBounds=*/true); + bool loadedDespiteBadBounds = false; + try { + const Heightmap h = loadTerrainFile(bad.string()); + loadedDespiteBadBounds = (std::abs(h.minHeight() - 400.0f) < 1e-4f); + } catch (const std::exception&) {} + check(loadedDespiteBadBounds, + "Bornes d'en-tete fausses : les DONNEES font foi, le chargement passe"); + } + + std::filesystem::remove_all(dir); + + // --- La vraie dalle, si elle a ete produite ------------------------------ + // Conditionnel a dessein : le depot ne versionne pas les 4 Mo de heightmap. + // Quand elle est la, ce bloc est le seul test qui touche de VRAIES donnees. + const std::filesystem::path realTile = + std::filesystem::path(ASSETS_DIR) / "terrain" / "LHD_0907_6440_1m.vchm"; + if (!std::filesystem::exists(realTile)) { + std::printf(" (dalle reelle absente, bloc ignore : %s)\n", + realTile.string().c_str()); + return; + } + + const Heightmap tile = loadTerrainFile(realTile.string()); + check(tile.resolution() == 1001, "Dalle reelle : 1001 echantillons par cote"); + checkNear(tile.spacing(), 1.0f, 1e-6f, "Dalle reelle : pas de 1 m"); + checkNear(tile.worldSize(), 1000.0f, 1e-3f, "Dalle reelle : emprise de 1 km"); + check(tile.geo().epsg == 2154, "Dalle reelle : Lambert 93"); + // Altitudes plausibles pour un relief de moyenne montagne, et surtout un + // denivele qui exclut un terrain plat par erreur de lecture. + check(tile.minHeight() > 400.0f && tile.maxHeight() < 1000.0f, + "Dalle reelle : altitudes dans une plage plausible"); + check(tile.maxHeight() - tile.minHeight() > 500.0f, + "Dalle reelle : denivele reel de plus de 500 m"); + + double east = 0.0, north = 0.0; + tile.toProjected(0.0f, 0.0f, &east, &north); + checkNear(static_cast(east - 907000.0), 500.0f, 1e-2f, + "Dalle reelle : l'origine du monde est au centre de la dalle (est)"); + checkNear(static_cast(north - 6439000.0), 500.0f, 1e-2f, + "Dalle reelle : l'origine du monde est au centre de la dalle (nord)"); + // Valeur relevee independamment par tools\check_terrain_file.py sur le nuage + // brut : la mediane des points sol a E 907500 / N 6439500 vaut 605.38 m. + checkNear(tile.heightAt(0.0f, 0.0f), 605.38f, 0.01f, + "Dalle reelle : altitude au point de depart conforme au nuage brut"); + + const MeshData mesh = terrainMeshData(tile); + check(mesh.vertices.size() == 1001u * 1001u, "Dalle reelle : 1 002 001 sommets"); + check(mesh.triangleCount() == 1000u * 1000u * 2u, "Dalle reelle : 2 000 000 triangles"); +} + +// --------------------------------------------------------------------------- +// Phase 8 : physique de base du parapente +// --------------------------------------------------------------------------- +void testParaglider() { + section("Phase 8 : physique de base du parapente"); + + // --- Vol droit devant, air calme ----------------------------------------- + { + Paraglider glider; + glider.launch(glm::vec3(0.0f, 100.0f, 0.0f), 0.0f); // cap = +X + check(glider.flying(), "launch() met le vol en cours"); + checkNear(glm::length(glider.forward()), 1.0f, 1e-4f, + "forward() est unitaire au decollage"); + + constexpr float dt = 1.0f / 60.0f; + for (int i = 0; i < 120; ++i) { + glider.update(dt, /*turnInput=*/0.0f, /*brakeInput=*/0.0f); + } + // 2 s en ligne droite, cap +X : Z ne doit pas avoir bouge, Y doit avoir + // baisse d'a peu pres cruiseSinkRate * 2 s des que la reponse + // exponentielle du taux de chute (partant deja au regime de croisiere, + // donc sans transitoire ici) s'est stabilisee. + checkNear(glider.position().z, 0.0f, 1e-3f, + "Vol tout droit (cap +X) : aucune derive laterale"); + check(glider.position().x > 0.0f, "Vol tout droit : avance bien vers +X"); + checkNear(glider.position().y, 100.0f - ParagliderParams{}.cruiseSinkRate * 2.0f, + 0.05f, "Taux de chute de croisiere respecte sur 2 s"); + } + + // --- Virage : rayon fini, pas une rotation instantanee -------------------- + { + Paraglider glider; + glider.launch(glm::vec3(0.0f, 200.0f, 0.0f), 0.0f); + + constexpr float dt = 1.0f / 60.0f; + for (int i = 0; i < 60; ++i) { + glider.update(dt, /*turnInput=*/1.0f, /*brakeInput=*/0.0f); + } + // Une seconde de virage plein a droite : le cap a change d'exactement + // turnRateDegPerSec degres (integration a vitesse angulaire constante), + // ni plus (pas de rotation instantanee sur la premiere frame) ni moins. + checkNear(glider.headingDegrees(), ParagliderParams{}.turnRateDegPerSec, 0.5f, + "Le cap tourne a vitesse angulaire constante, pas instantanement"); + check(glider.position().z > 0.1f, + "Le virage courbe bien la trajectoire (Z s'est ecarte de 0)"); + } + + // --- Frein : vitesse plus faible, taux de chute plus fort, progressivement - + { + Paraglider glider; + glider.launch(glm::vec3(0.0f, 200.0f, 0.0f), 0.0f); + + const float yAfterOneFrameNoBrake = [&] { + Paraglider probe; + probe.launch(glm::vec3(0.0f, 200.0f, 0.0f), 0.0f); + probe.update(1.0f / 60.0f, 0.0f, 0.0f); + return probe.position().y; + }(); + + glider.update(1.0f / 60.0f, 0.0f, /*brakeInput=*/1.0f); + check(glider.position().y < yAfterOneFrameNoBrake, + "Freiner degrade le taux de chute des la premiere frame (mais peu : " + "reponse progressive, pas un saut)"); + + constexpr float dt = 1.0f / 60.0f; + for (int i = 0; i < 180; ++i) { + glider.update(dt, 0.0f, 1.0f); + } + // Apres 3 s de frein a fond, la vitesse doit s'etre stabilisee pres de + // brakeSpeed : on le verifie indirectement via la distance parcourue au + // pas suivant plutot que d'exposer un accesseur de vitesse rien que pour + // le test. + const glm::vec3 beforeStep = glider.position(); + glider.update(dt, 0.0f, 1.0f); + const float stepDistance = horizontalDistance(glider.position(), beforeStep); + checkNear(stepDistance, ParagliderParams{}.brakeSpeed * dt, 0.02f, + "Plein frein maintenu : la vitesse s'est stabilisee pres de brakeSpeed"); + } + + // --- Atterrissage : le vol s'arrete pile au niveau du terrain ------------ + { + FlatTerrain terrain(50.0f); + constexpr float kEyeHeight = 1.7f; + + Paraglider glider; + glider.launch(glm::vec3(0.0f, 52.0f, 0.0f), 0.0f); + check(!glider.checkLanding(terrain, kEyeHeight), + "checkLanding() ne declenche rien tant qu'on est au-dessus du sol"); + + bool landed = false; + for (int i = 0; i < 6000 && !landed; ++i) { + glider.update(1.0f / 60.0f, 0.0f, 0.0f); + landed = glider.checkLanding(terrain, kEyeHeight); + } + check(landed, "Le vol finit par atterrir sur un terrain plat"); + check(!glider.flying(), "flying() redevient faux apres l'atterrissage"); + checkNear(glider.position().y, terrain.heightAt(0.0f, 0.0f) + kEyeHeight, 1e-3f, + "Position posee EXACTEMENT au niveau du terrain (hauteur d'oeil incluse)"); + } + + // --- abort() : filet de securite, independant de l'altitude -------------- + { + Paraglider glider; + glider.launch(glm::vec3(0.0f, 500.0f, 0.0f), 0.0f); + glider.abort(); + check(!glider.flying(), "abort() termine le vol immediatement, quelle que soit l'altitude"); + } + + // --- update()/checkLanding() sans vol en cours : aucun effet ------------- + { + FlatTerrain terrain(10.0f); + Paraglider glider; + const glm::vec3 before = glider.position(); + glider.update(1.0f / 60.0f, 1.0f, 1.0f); + check(glider.position() == before, "update() sans launch() ne deplace rien"); + check(!glider.checkLanding(terrain, 1.7f), + "checkLanding() sans vol en cours ne fait rien"); + } +} + + + +// --------------------------------------------------------------------------- +// Phase 13 : physique de base du velo +// --------------------------------------------------------------------------- +// Ce que ces tests verifient, et pourquoi ils sont ecrits ainsi : la valeur d'un +// modele simplifie ne tient pas dans ses formules mais dans les VITESSES qu'il +// produit. Chaque bloc ci-dessous mesure donc une vitesse d'equilibre reelle et +// la confronte a la fourchette annoncee dans world/Bike.hpp et +// NOTES-PHASE-VELO.md - au lieu de re-deriver l'equation, ce qui ne prouverait +// que l'accord du test avec lui-meme. +void testBike() { + section("Phase 13 : physique de base du velo"); + + const BikeParams defaults; + + // --- Contact permanent avec le sol --------------------------------------- + { + SlopedTerrain slope(0.0f, 0.10f); // 10 %, monte vers +X + Bike bike; + // On enfourche a une altitude VOLONTAIREMENT fausse : le velo doit se + // recoller au terrain de lui-meme, des mount(). + bike.mount(glm::vec3(20.0f, 999.0f, 0.0f), 0.0f, slope); + check(bike.riding(), "mount() met la sortie en cours"); + checkNear(bike.position().y, slope.heightAt(20.0f, 0.0f) + defaults.eyeHeight, + 1e-3f, "mount() recolle le velo au terrain, quelle que soit " + "l'altitude demandee"); + checkNear(bike.speed(), 0.0f, 1e-6f, "On part a l'arret, pas lance"); + + // Cap +X = plein dans la montee : la pente lue doit etre celle du plan. + checkNear(bike.slopeAlongHeading(slope), 0.10f, 1e-4f, + "La pente le long du cap est bien celle du terrain (montee)"); + // Demi-tour : la meme pente, en descente. + bike.mount(glm::vec3(20.0f, 0.0f, 0.0f), 180.0f, slope); + checkNear(bike.slopeAlongHeading(slope), -0.10f, 1e-4f, + "Cap inverse : meme pente, signe oppose"); + // En travers : pente nulle le long du cap. + bike.mount(glm::vec3(20.0f, 0.0f, 0.0f), 90.0f, slope); + checkNear(bike.slopeAlongHeading(slope), 0.0f, 1e-4f, + "Cap en travers de la pente : pente longitudinale nulle"); + + // Et le contact tient pendant qu'on roule : une seule assertion pour les + // 300 pas, sans quoi un test isole pesserait 300 fois dans le compte. + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, slope); + bool alwaysOnGround = true; + for (int i = 0; i < 300; ++i) { + bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, slope, nullptr); + const float expected = + slope.heightAt(bike.position().x, bike.position().z) + defaults.eyeHeight; + if (std::abs(bike.position().y - expected) > 1e-3f) { + alwaysOnGround = false; + } + } + check(alwaysOnGround, + "Le velo reste colle a la surface a chacun des 300 pas (jamais en l'air)"); + } + + // --- Inertie : ni acceleration ni freinage instantanes ------------------- + { + FlatTerrain flat; + Bike bike; + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + + bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr); + const float afterOneFrame = bike.speed(); + check(afterOneFrame > 0.0f, "Pedaler fait avancer"); + // Une frame de pedalage a fond ne peut pas donner plus que + // pedalAcceleration * dt, soit ~3,7 cm/s : c'est ca, l'inertie, et c'est + // verifiable sans connaitre la vitesse finale. + check(afterOneFrame < defaults.pedalAcceleration / 60.0f + 1e-4f, + "Une frame de pedalage ne donne qu'une fraction de m/s (inertie)"); + + // Vitesse de croisiere sur le plat, puis freinage. + const float cruise = settleSpeed(bike, flat, 1.0f, 0.0f); + bike.update(1.0f / 60.0f, 0.0f, 0.0f, 1.0f, flat, nullptr); + check(bike.speed() > 0.0f, + "Le frein a fond ne met pas a l'arret en une frame (inertie)"); + check(bike.speed() < cruise, "Le frein ralentit bien des la premiere frame"); + + // Distance et duree d'arret depuis la croisiere. + const glm::vec3 beforeStop = bike.position(); + float stopTime = 0.0f; + for (int i = 0; i < 600 && bike.speed() > 0.0f; ++i) { + bike.update(1.0f / 60.0f, 0.0f, 0.0f, 1.0f, flat, nullptr); + stopTime += 1.0f / 60.0f; + } + checkNear(bike.speed(), 0.0f, 1e-6f, + "Le frein maintenu finit par arreter le velo"); + const float stopDistance = horizontalDistance(bike.position(), beforeStop); + check(stopTime > 3.0f / 60.0f, "L'arret prend plusieurs frames, pas une seule"); + check(stopDistance > 0.3f && stopDistance < 3.0f, + "Distance d'arret plausible depuis la croisiere (entre 0,3 et 3 m)"); + } + + // --- Vitesses d'equilibre : LE chiffre qui compte ------------------------ + { + // Plat, pedalage a fond. + FlatTerrain flat; + Bike bike; + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + const float flatKmh = settleSpeed(bike, flat, 1.0f, 0.0f) * 3.6f; + check(flatKmh > 12.0f && flatKmh < 22.0f, + "Plat, pedalage a fond : 12 a 22 km/h (VTT sur chemin)"); + + // Montee a 10 % : nettement plus lent, mais on monte. + SlopedTerrain up10(0.0f, 0.10f); + Bike climber; + climber.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, up10); + const float up10Kmh = settleSpeed(climber, up10, 1.0f, 0.0f) * 3.6f; + check(up10Kmh > 4.0f && up10Kmh < 12.0f, + "Montee a 10 %, pedalage a fond : 4 a 12 km/h"); + check(up10Kmh < flatKmh - 3.0f, + "La montee ralentit franchement par rapport au plat"); + + // Montee a 25 % : le velo cale. C'est VOULU (25 % est du portage), et + // c'est aussi la garantie qu'il ne recule jamais. + SlopedTerrain up25(0.0f, 0.25f); + Bike staller; + staller.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, up25); + const float up25Speed = settleSpeed(staller, up25, 1.0f, 0.0f, 20.0f); + checkNear(up25Speed, 0.0f, 1e-6f, + "Montee a 25 % : le velo cale (pas de portage simule) ..."); + check(staller.position().x >= -1e-3f, + "... et il ne RECULE pas : la vitesse est ecretee a zero"); + + // Descente a 20 %, en roue libre : la fourchette VTT demandee. + SlopedTerrain down20(0.0f, -0.20f); // descend vers +X + Bike descender; + descender.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, down20); + const float down20Kmh = settleSpeed(descender, down20, 0.0f, 0.0f) * 3.6f; + check(down20Kmh > 30.0f && down20Kmh <= 50.0f, + "Descente a 20 % en roue libre : 30 a 50 km/h (fourchette VTT visee)"); + + // Descente a 30 % : plus vite, mais toujours sous le plafond. + SlopedTerrain down30(0.0f, -0.30f); + Bike descender30; + descender30.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, down30); + const float down30Kmh = settleSpeed(descender30, down30, 0.0f, 0.0f) * 3.6f; + check(down30Kmh > down20Kmh, + "Une descente plus raide donne une vitesse plus elevee"); + check(down30Kmh <= defaults.maxSpeed * 3.6f + 1e-3f, + "Le plafond de 50 km/h n'est jamais depasse"); + + // Falaise LiDAR : meme a 200 % de pente, la vitesse reste bornee. C'est + // le cas que la zone de jeu contient reellement (parois verticales, cf. + // NOTES-PHASE9.md), et celui ou une formule en tan() divergerait. + SlopedTerrain cliff(0.0f, -2.0f); + Bike faller; + faller.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, cliff); + const float cliffKmh = settleSpeed(faller, cliff, 1.0f, 0.0f, 60.0f) * 3.6f; + check(cliffKmh <= defaults.maxSpeed * 3.6f + 1e-3f, + "Pente de 200 % : la vitesse reste bornee par maxSpeed, sans divergence"); + check(!std::isnan(cliffKmh), "Pente extreme : aucun NaN"); + + // Le frein bat la gravite : on doit pouvoir descendre au pas. + Bike braker; + braker.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, down30); + const float brakedKmh = settleSpeed(braker, down30, 0.0f, 1.0f, 20.0f) * 3.6f; + checkNear(brakedKmh, 0.0f, 1e-3f, + "Frein a fond en descente a 30 % : le velo s'arrete (le frein " + "l'emporte sur la gravite)"); + } + + // --- Roue libre sur pente tres faible : le velo ne part pas tout seul ---- + { + SlopedTerrain gentle(0.0f, -0.02f); // 2 % de descente + Bike bike; + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, gentle); + const float speed = settleSpeed(bike, gentle, 0.0f, 0.0f, 20.0f); + checkNear(speed, 0.0f, 1e-6f, + "Descente a 2 %, sans pedaler : la resistance au roulement " + "empeche le velo de partir seul"); + } + + // --- Direction : rayon de braquage fini, et croissant avec la vitesse ---- + { + FlatTerrain flat; + + // Rayon mesure a deux vitesses differentes, par la vitesse angulaire + // effectivement obtenue (R = v / omega). + auto measureRadius = [&](float targetSpeed) { + Bike bike; + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + // On amene le velo a la vitesse voulue en pedalant en ligne droite, + // puis on mesure UN pas de virage a fond. + for (int i = 0; i < 4000 && bike.speed() < targetSpeed; ++i) { + bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr); + } + const float v = bike.speed(); + const float before = bike.headingDegrees(); + bike.update(1.0f / 60.0f, 1.0f, 0.0f, 0.0f, flat, nullptr); + const float omega = glm::radians(bike.headingDegrees() - before) * 60.0f; + return std::make_pair(v, v / omega); + }; + + const std::pair slow = measureRadius(3.0f); + const std::pair fast = measureRadius(4.5f); + check(slow.second > 0.0f && fast.second > 0.0f, + "Le rayon de braquage est fini et positif : pas de rotation sur place " + "en roulant"); + check(fast.second > slow.second + 0.5f, + "Le rayon de braquage GRANDIT avec la vitesse (pas de virage a angle " + "droit a pleine vitesse)"); + // R = v^2 / maxLateralAccel : c'est la formule annoncee, on la confronte + // a la mesure. + checkNear(fast.second, fast.first * fast.first / defaults.maxLateralAccel, 0.2f, + "Le rayon mesure vaut bien v^2 / maxLateralAccel"); + + // A l'arret, le plafond de vitesse angulaire prend le relais : on peut + // replacer la machine, mais pas plus vite que maxTurnRateDegPerSec. + Bike still; + still.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + const float beforeHeading = still.headingDegrees(); + still.update(1.0f / 60.0f, 1.0f, 0.0f, 0.0f, flat, nullptr); + checkNear((still.headingDegrees() - beforeHeading) * 60.0f, + defaults.maxTurnRateDegPerSec, 1e-2f, + "A l'arret : rotation plafonnee a maxTurnRateDegPerSec, jamais " + "infinie"); + + // Sens de rotation : +1 tourne a droite (vers +Z depuis le cap +X, meme + // convention que Camera et Paraglider). + // + // On lance d'abord le velo EN LIGNE DROITE avant de tourner. Tourner des + // l'arret ne prouverait rien : a vitesse nulle le braquage est plafonne a + // 140 deg/s, donc deux secondes de virage font trois quarts de tour et la + // trajectoire revient sur elle-meme - le signe de z ne dirait plus rien + // du sens de rotation. + Bike turner; + turner.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + for (int i = 0; i < 600; ++i) { + turner.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr); + } + const float zBeforeTurn = turner.position().z; + const float headingBeforeTurn = turner.headingDegrees(); + for (int i = 0; i < 30; ++i) { // une demi-seconde de virage a droite + turner.update(1.0f / 60.0f, 1.0f, 1.0f, 0.0f, flat, nullptr); + } + check(turner.headingDegrees() > headingBeforeTurn, + "steerInput > 0 fait croitre le cap"); + check(turner.position().z > zBeforeTurn, + "steerInput > 0 courbe la trajectoire vers +Z (a droite du cap +X)"); + + // Et le miroir, pour ecarter un test qui passerait avec n'importe quel + // signe. + Bike turnerLeft; + turnerLeft.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + for (int i = 0; i < 600; ++i) { + turnerLeft.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr); + } + const float zBeforeLeft = turnerLeft.position().z; + for (int i = 0; i < 30; ++i) { + turnerLeft.update(1.0f / 60.0f, -1.0f, 1.0f, 0.0f, flat, nullptr); + } + check(turnerLeft.position().z < zBeforeLeft, + "steerInput < 0 courbe la trajectoire dans l'autre sens"); + } + + // --- Assiette visuelle : suit la pente locale ---------------------------- + { + SlopedTerrain up20(0.0f, 0.20f); + Bike bike; + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, up20); + bike.update(1.0f / 60.0f, 0.0f, 0.0f, 0.0f, up20, nullptr); + checkNear(bike.pitchDegrees(), glm::degrees(std::atan(0.20f)), 0.1f, + "Tangage : le nez se leve de l'angle de la pente en montee"); + checkNear(bike.rollDegrees(), 0.0f, 0.1f, + "Roulis nul quand on monte droit dans la pente"); + + // Meme plan, cap en travers : plus de tangage, mais du devers. + Bike crossing; + crossing.mount(glm::vec3(0.0f, 0.0f, 0.0f), 90.0f, up20); // cap +Z + crossing.update(1.0f / 60.0f, 0.0f, 0.0f, 0.0f, up20, nullptr); + checkNear(crossing.pitchDegrees(), 0.0f, 0.1f, + "Cap en travers : plus de tangage"); + check(std::abs(crossing.rollDegrees()) > 5.0f, + "Cap en travers : le velo epouse le devers (roulis non nul)"); + + // Descente : le nez pique. + SlopedTerrain down20(0.0f, -0.20f); + Bike descender; + descender.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, down20); + descender.update(1.0f / 60.0f, 0.0f, 0.0f, 0.0f, down20, nullptr); + check(descender.pitchDegrees() < -5.0f, "Tangage negatif en descente"); + + // Inclinaison en virage : a vitesse non nulle, tourner penche la machine + // vers l'interieur, en plus du devers. + FlatTerrain flat; + Bike leaner; + leaner.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + for (int i = 0; i < 600; ++i) { + leaner.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr); + } + leaner.update(1.0f / 60.0f, 1.0f, 1.0f, 0.0f, flat, nullptr); + check(leaner.rollDegrees() > 2.0f, + "Virage a droite sur le plat : le velo s'incline a droite"); + leaner.update(1.0f / 60.0f, -1.0f, 1.0f, 0.0f, flat, nullptr); + check(leaner.rollDegrees() < -2.0f, "Virage a gauche : inclinaison opposee"); + + // L'ecretage tient sur une paroi. + SlopedTerrain wall(0.0f, 3.0f); + Bike onWall; + onWall.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, wall); + onWall.update(1.0f / 60.0f, 0.0f, 0.0f, 0.0f, wall, nullptr); + check(std::abs(onWall.pitchDegrees()) <= defaults.maxVisualTiltDegrees + 1e-3f, + "L'assiette visuelle est ecretee sur une paroi (pas de marqueur a plat)"); + } + + // --- Obstacles : LE MEME systeme de collision que le joueur a pied ------- + { + FlatTerrain flat; + Ground ground(flat); + ForestParams noAutoSeed; + noAutoSeed.treeCount = 0; + Forest forest(flat, ground, 50.0f, noAutoSeed); + forest.plantTree(10.0f, 0.0f, 7.0f); // droit devant un velo cap +X + + Bike bike; + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + + // On roule droit sur le tronc pendant largement de quoi le depasser. + for (int i = 0; i < 1200; ++i) { + bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, &forest); + } + + const float trunkRadius = forest.trees()[0].trunkRadius(); + const float contact = trunkRadius + BikeParams{}.bodyRadius; + check(bike.position().x < 10.0f, + "Le velo n'a PAS traverse le tronc (il est reste en deca)"); + check(horizontalDistance(bike.position(), forest.trees()[0].base) >= + contact - 1e-2f, + "Le velo est arrete au contact du tronc, pas dedans"); + check(bike.speed() < 1.0f, + "Le choc coute sa vitesse au velo (il ne pousse pas l'arbre a 16 km/h)"); + + // Temoin : sans solveur, le meme trajet TRAVERSE. Sans ce controle, un + // test qui bloque parce que le velo n'avance pas du tout passerait aussi. + Bike ghost; + ghost.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + for (int i = 0; i < 1200; ++i) { + ghost.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr); + } + check(ghost.position().x > 12.0f, + "TEMOIN : sans solveur de collision, le meme trajet depasse l'arbre " + "(donc le blocage ci-dessus vient bien de la collision)"); + + // Une souche basse arrete aussi le velo : c'est la bande verticale du + // BodyCylinder qui le garantit, exactement comme pour le joueur a pied. + Forest stumpOnly(flat, ground, 50.0f, noAutoSeed); + stumpOnly.plantTree(10.0f, 0.0f, 7.0f); + stumpOnly.fell(0); + runUntilFallen(stumpOnly, 12.0f); + check(stumpOnly.trees()[0].state == TreeState::Fallen, + "L'arbre du test de souche est bien entierement debite"); + + Bike overStump; + overStump.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + for (int i = 0; i < 1200; ++i) { + overStump.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, &stumpOnly); + } + check(overStump.position().x < 10.0f, + "Une souche basse arrete le velo comme elle arrete les jambes"); + } + + // --- Sans mount() : aucun effet ----------------------------------------- + { + FlatTerrain flat; + Bike bike; + const glm::vec3 before = bike.position(); + bike.update(1.0f / 60.0f, 1.0f, 1.0f, 1.0f, flat, nullptr); + check(bike.position() == before, "update() sans mount() ne deplace rien"); + check(!bike.riding(), "Un velo neuf n'est pas en cours d'utilisation"); + + bike.mount(glm::vec3(5.0f, 0.0f, 5.0f), 0.0f, flat); + bike.dismount(); + check(!bike.riding(), "dismount() termine la sortie"); + const glm::vec3 parked = bike.position(); + bike.update(1.0f / 60.0f, 1.0f, 1.0f, 0.0f, flat, nullptr); + check(bike.position() == parked, + "Apres dismount(), plus aucun pas n'est simule"); + + // deltaTime nul : pas d'integration, pas de NaN. + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + const glm::vec3 atMount = bike.position(); + bike.update(0.0f, 1.0f, 1.0f, 0.0f, flat, nullptr); + check(bike.position() == atMount, "deltaTime nul : aucun pas simule"); + } + + // --- Ecretage des entrees : des valeurs brutes hors bornes sont sures ---- + { + FlatTerrain flat; + Bike wild; + wild.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + Bike tame; + tame.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + for (int i = 0; i < 300; ++i) { + wild.update(1.0f / 60.0f, 50.0f, 50.0f, 0.0f, flat, nullptr); + tame.update(1.0f / 60.0f, 1.0f, 1.0f, 0.0f, flat, nullptr); + } + checkNear(wild.speed(), tame.speed(), 1e-5f, + "Les entrees sont ecretees : 50 se comporte comme 1"); + checkNear(wild.headingDegrees(), tame.headingDegrees(), 1e-3f, + "Ecretage aussi sur la direction"); + } +} + +// --------------------------------------------------------------------------- +// Phase 14 : physique de base de l'escalade +// --------------------------------------------------------------------------- +// Deux terrains de test que les precedents ne fournissaient pas. SlopedTerrain +// est un plan infini : parfait pour mesurer une vitesse ou un cout par metre sur +// une pente EXACTE, mais il n'a ni pied ni sommet, donc il ne peut prouver +// aucune des transitions de mode. D'ou les deux ci-dessous. + +// Falaise minimale : plat en bas, paroi, plat en haut. C'est le plus petit +// terrain qui contienne les trois situations de l'escalade (s'engager, monter, +// topper), et il est PARFAITEMENT previsible - contrairement a du relief LiDAR, +// ou un test qui echoue laisse toujours le doute entre le modele et la donnee. +class CliffTerrain : public HeightSampler { +public: + CliffTerrain(float baseHeight, float slope, float footX, float topX) + : base_(baseHeight), slope_(slope), footX_(footX), topX_(topX) {} + + float heightAt(float x, float) const override { + if (x <= footX_) return base_; + if (x >= topX_) return base_ + slope_ * (topX_ - footX_); + return base_ + slope_ * (x - footX_); + } + +private: + float base_, slope_, footX_, topX_; +}; + +// Meme falaise, mais avec une VIRE horizontale a mi-hauteur, de largeur +// reglable. C'est le terrain qui met a l'epreuve la confirmation du sommet : +// une vire d'un metre ne doit pas terminer l'escalade (on serait debout en plein +// vide), une vire de six metres si (on y tient reellement debout). +class LedgedCliffTerrain : public HeightSampler { +public: + LedgedCliffTerrain(float slope, float topX, float ledgeWidth) + : slope_(slope), topX_(topX), ledgeWidth_(ledgeWidth) { + ledgeStart_ = 0.5f * topX_; + } + + float heightAt(float x, float) const override { + if (x <= 0.0f) return 0.0f; + if (x <= ledgeStart_) return slope_ * x; + const float ledgeY = slope_ * ledgeStart_; + if (x <= ledgeStart_ + ledgeWidth_) return ledgeY; + const float afterLedge = x - (ledgeStart_ + ledgeWidth_); + const float wallLeft = topX_ - ledgeStart_; + if (afterLedge >= wallLeft) return ledgeY + slope_ * wallLeft; + return ledgeY + slope_ * afterLedge; + } + +private: + float slope_, topX_, ledgeWidth_, ledgeStart_; +}; + +// Ce qui fait la valeur d'un modele simplifie n'est pas sa formule mais les +// GRANDEURS qu'il produit - meme intention que les tests du velo. Chaque bloc +// mesure donc un comportement reel (une vitesse d'ascension, une hauteur +// maximale, une position de repli) et le confronte a ce qu'annonce +// world/Climber.hpp, au lieu de re-deriver l'equation, ce qui ne prouverait que +// l'accord du test avec lui-meme. +void testClimber() { + section("Phase 14 : physique de base de l'escalade"); + + const ClimberParams defaults; + constexpr float dt = 1.0f / 60.0f; + + // --- Detection de paroi -------------------------------------------------- + { + Climber climber; + FlatTerrain flat(100.0f); + checkNear(climber.slopeAt(flat, 3.0f, -7.0f), 0.0f, 1e-6f, + "Terrain plat : pente nulle"); + check(!climber.isWall(flat, 3.0f, -7.0f), + "Terrain plat : ce n'est pas une paroi"); + + // Un versant raide MAIS marchable : 60 %, la valeur type de ce massif. + // C'est le cas qui compte - si celui-la passait pour une paroi, le seuil + // ne servirait a rien, la moitie du terrain etant au-dessus de 50 %. + SlopedTerrain steep(0.0f, 0.60f); + checkNear(climber.slopeAt(steep, 12.0f, 5.0f), 0.60f, 1e-4f, + "Versant a 60 % : la pente lue est exacte"); + check(!climber.isWall(steep, 12.0f, 5.0f), + "Versant a 60 % : ce n'est PAS une paroi (sous le seuil de paroi)"); + + SlopedTerrain wall(0.0f, 1.05f); + check(climber.isWall(wall, 12.0f, 5.0f), "Pente a 105 % : c'est une paroi"); + + SlopedTerrain exactly(0.0f, defaults.wallSlope); + check(climber.isWall(exactly, 0.0f, 0.0f), + "Pente exactement au seuil : c'est une paroi (comparaison >=)"); + + // La pente est une MAGNITUDE : une paroi qui descend vers +X en est une + // aussi. Un signe oublie se verrait ici et nulle part ailleurs. + SlopedTerrain descending(0.0f, -1.50f); + check(climber.isWall(descending, 0.0f, 0.0f), + "Paroi de pente negative : c'est une paroi (magnitude, pas signe)"); + + // Ce n'est pas un detail de reglage : si walkableSlope rattrapait + // wallSlope, l'hysteresis disparaitrait et le mode escalade se mettrait + // a clignoter d'une frame a l'autre sur une paroi reelle. + check(defaults.walkableSlope < defaults.wallSlope, + "Hysteresis : le seuil de sortie est STRICTEMENT sous celui d'entree"); + } + + // --- Engagement : tryStart ------------------------------------------------ + { + CliffTerrain cliff(0.0f, 3.0f, 0.0f, 10.0f); + + { + Climber climber; + const glm::vec3 eye(-1.5f, 1.7f, 0.0f); + check(climber.tryStart(cliff, eye, glm::vec3(1.0f, 0.0f, 0.0f)), + "Engagement : une paroi a portee, on s'accroche"); + check(climber.climbing(), "Engagement : l'escalade est en cours"); + checkNear(climber.anchor().y, + cliff.heightAt(climber.anchor().x, climber.anchor().z), 1e-4f, + "Engagement : le point d'accroche est SUR la surface"); + check(climber.isWall(cliff, climber.anchor().x, climber.anchor().z), + "Engagement : le point d'accroche est bien sur une paroi"); + } + { + Climber climber; + check(!climber.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), + glm::vec3(-1.0f, 0.0f, 0.0f)), + "Engagement refuse : la paroi est dans le dos"); + check(!climber.climbing(), "Engagement refuse : rien n'a change"); + } + { + Climber climber; + check(!climber.tryStart(cliff, glm::vec3(-5.0f, 1.7f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)), + "Engagement refuse : la paroi est hors de portee"); + } + { + Climber climber; + FlatTerrain flat; + check(!climber.tryStart(flat, glm::vec3(0.0f, 1.7f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)), + "Engagement refuse : il n'y a pas de paroi du tout"); + } + { + // Regard strictement vertical : aucune direction au sol, donc aucune + // cible. Le cas degenere doit REFUSER, pas normaliser un vecteur nul. + Climber climber; + check(!climber.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), + glm::vec3(0.0f, 1.0f, 0.0f)), + "Engagement refuse : regard strictement vertical (cas degenere)"); + } + } + + // --- Contact permanent avec la surface ------------------------------------ + { + // Le meme invariant que le velo, et pour la meme raison : la verticale + // n'est jamais une variable d'etat, elle est relue de heightAt(). + SlopedTerrain wall(0.0f, 3.0f); + Climber climber; + check(climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)), + "Contact : engagement sur une paroi uniforme a 300 %"); + + bool alwaysOnSurface = true; + bool everNaN = false; + for (int i = 0; i < 400; ++i) { + climber.update(dt, 1.0f, 0.3f, wall, nullptr); + const float expected = wall.heightAt(climber.anchor().x, climber.anchor().z); + if (std::abs(climber.anchor().y - expected) > 1e-3f) { + alwaysOnSurface = false; + } + if (std::isnan(climber.anchor().x) || std::isnan(climber.anchor().y) || + std::isnan(climber.anchor().z) || std::isnan(climber.stamina())) { + everNaN = true; + } + } + check(alwaysOnSurface, "Le grimpeur reste sur la surface a chacun des 400 pas"); + check(!everNaN, "Escalade : aucun NaN sur 400 pas"); + } + + // --- Vitesse le long de la surface ---------------------------------------- + { + // Ce que le modele promet : on avance a climbSpeed LE LONG DE LA + // SURFACE. La montee verticale qui en resulte vaut donc climbSpeed x + // sin(theta), pas climbSpeed. Le verifier sur une pente connue est la + // seule facon de prouver que la projection est reellement faite. + const float slope = 3.0f; // 300 %, 71,6 degres + SlopedTerrain wall(0.0f, slope); + Climber climber; + climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + + const glm::vec3 before = climber.anchor(); + const int steps = 60; // une seconde + for (int i = 0; i < steps; ++i) { + climber.update(dt, 1.0f, 0.0f, wall, nullptr); + } + const glm::vec3 after = climber.anchor(); + const float dx = after.x - before.x; + const float dz = after.z - before.z; + const float dy = after.y - before.y; + const float alongSurface = std::sqrt(dx * dx + dz * dz + dy * dy); + const float elapsed = steps * dt; + + checkNear(alongSurface / elapsed, defaults.climbSpeed, 1e-2f, + "Vitesse le long de la SURFACE : c'est bien climbSpeed"); + checkNear(dy / elapsed, + defaults.climbSpeed * slope / std::sqrt(1.0f + slope * slope), 1e-2f, + "Vitesse VERTICALE = climbSpeed x sin(pente)"); + check(dy / elapsed < defaults.climbSpeed, + "La montee verticale est plus lente que la progression sur la paroi"); + check(defaults.climbSpeed < 14.0f / 10.0f, + "Grimper est au moins dix fois plus lent que marcher (14 m/s)"); + } + + // --- Une paroi quasi verticale se monte quasi verticalement --------------- + { + // Aucun cas particulier n'est ecrit pour ca dans Climber : c'est la + // projection 1/sqrt(1+pente^2) qui le produit toute seule. Ce test fige + // ce comportement emergent, qui est le coeur du modele. + SlopedTerrain sheer(0.0f, 20.0f); // 2000 %, 87,1 degres + Climber climber; + climber.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + + const glm::vec3 before = climber.anchor(); + for (int i = 0; i < 60; ++i) { + climber.update(dt, 1.0f, 0.0f, sheer, nullptr); + } + const glm::vec3 after = climber.anchor(); + const float dHoriz = horizontalDistance(after, before); + const float dAlt = after.y - before.y; + check(dAlt > 0.99f * defaults.climbSpeed, + "Paroi a 87 degres : la montee est quasi integralement verticale"); + check(dHoriz < 0.06f * defaults.climbSpeed, + "Paroi a 87 degres : l'avance horizontale est negligeable"); + } + + // --- Traversee : le long de la LIGNE DE NIVEAU ---------------------------- + { + // Sur un terrain dont l'altitude ne depend que de x, la ligne de niveau + // est l'axe z. Traverser doit donc deplacer en z et laisser l'altitude ou + // elle est - c'est ce qui distingue une traversee d'une diagonale. + SlopedTerrain wall(0.0f, 2.0f); + Climber climber; + climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + + const glm::vec3 before = climber.anchor(); + for (int i = 0; i < 60; ++i) { + climber.update(dt, 0.0f, 1.0f, wall, nullptr); + } + const glm::vec3 after = climber.anchor(); + checkNear(after.y, before.y, 1e-3f, + "Traversee : l'altitude ne change pas (ligne de niveau)"); + checkNear(std::abs(after.z - before.z), defaults.traverseSpeed, 1e-2f, + "Traversee : on parcourt traverseSpeed en une seconde"); + checkNear(after.x, before.x, 1e-3f, + "Traversee : aucune avance dans la ligne de plus grande pente"); + + const float rightward = after.z - before.z; + Climber other; + other.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + const glm::vec3 b2 = other.anchor(); + for (int i = 0; i < 60; ++i) { + other.update(dt, 0.0f, -1.0f, wall, nullptr); + } + checkNear(other.anchor().z - b2.z, -rightward, 1e-3f, + "Traversee : gauche et droite sont exactement symetriques"); + } + + // --- L'oeil est HORS du relief -------------------------------------------- + { + // Une camera a la premiere personne collee a une falaise est le piege + // evident de cette phase : un oeil sous la surface montre l'interieur du + // terrain. Le decalage vers l'AVAL doit le rendre impossible, sur toute + // une ascension et pas seulement au depart. + SlopedTerrain wall(0.0f, 4.0f); + Climber climber; + climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + + bool alwaysOutside = true; + for (int i = 0; i < 200; ++i) { + climber.update(dt, 1.0f, 0.0f, wall, nullptr); + const glm::vec3 eye = climber.position(); + if (eye.y <= wall.heightAt(eye.x, eye.z)) { + alwaysOutside = false; + } + } + check(alwaysOutside, + "L'oeil du grimpeur reste au-dessus de la surface sur 200 pas"); + check(climber.position().y > climber.anchor().y, + "L'oeil est au-dessus du point d'accroche (eyeRise)"); + check(horizontalDistance(climber.position(), climber.anchor()) > 0.5f, + "L'oeil est ecarte de la paroi (wallOffset)"); + } + + // --- Energie : les couts sont PAR METRE, pas par seconde ------------------ + { + SlopedTerrain sheer(0.0f, 20.0f); + Climber climber; + climber.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + checkNear(climber.stamina(), 1.0f, 1e-6f, + "Energie : on part avec la jauge pleine"); + + const float startY = climber.anchor().y; + for (int i = 0; i < 300; ++i) { + climber.update(dt, 1.0f, 0.0f, sheer, nullptr); + } + const float climbed = climber.anchor().y - startY; + const float spent = 1.0f - climber.stamina(); + check(climbed > 4.0f, "Energie : l'ascension de reference a bien eu lieu"); + // Sur une paroi a 2000 % la composante horizontale ne vaut que 5 % : le + // cout par metre monte doit donc etre celui annonce, a 2 % pres. + checkNear(spent / climbed, defaults.staminaPerMeterUp, + 0.02f * defaults.staminaPerMeterUp, + "Energie : le cout par metre monte est bien staminaPerMeterUp"); + + // Le meme trajet en DEUX FOIS PLUS DE TEMPS coute pareil : c'est la + // consequence d'un cout par metre, et ca rend la jauge independante du + // nombre d'images par seconde. + Climber slow; + slow.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + const float slowStart = slow.anchor().y; + for (int i = 0; i < 600; ++i) { + slow.update(dt, 0.5f, 0.0f, sheer, nullptr); + } + checkNear(slow.anchor().y - slowStart, climbed, 1e-2f, + "Meme ascension, moitie moins vite, deux fois plus longtemps"); + checkNear(1.0f - slow.stamina(), spent, 0.02f * spent, + "Energie : monter lentement coute la MEME chose (cout par metre)"); + } + + // --- Energie : suspendu, desescalader ------------------------------------- + { + SlopedTerrain sheer(0.0f, 20.0f); + + Climber hanging; + hanging.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + for (int i = 0; i < 300; ++i) { // 5 secondes + hanging.update(dt, 0.0f, 0.0f, sheer, nullptr); + } + checkNear(1.0f - hanging.stamina(), defaults.staminaHangPerSecond * 5.0f, 1e-4f, + "Energie : suspendu immobile, cout par SECONDE"); + check(hanging.stamina() > 0.97f, + "Energie : rester suspendu 5 s ne vide pas la jauge"); + + // Descendre coute moins cher que monter - le choix de JEU qui garde la + // desescalade comme porte de sortie. + Climber up; + up.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + for (int i = 0; i < 120; ++i) up.update(dt, 1.0f, 0.0f, sheer, nullptr); + const float upCost = 1.0f - up.stamina(); + + Climber down; + down.tryStart(sheer, glm::vec3(50.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + const float downStart = down.anchor().y; + for (int i = 0; i < 120; ++i) down.update(dt, -1.0f, 0.0f, sheer, nullptr); + const float downCost = 1.0f - down.stamina(); + check(down.anchor().y < downStart, "Desescalade : on descend bien"); + check(downCost < upCost, "Energie : desescalader coute moins cher que monter"); + checkNear(downCost / upCost, + defaults.staminaPerMeterDown / defaults.staminaPerMeterUp, 0.05f, + "Energie : le rapport descente/montee est celui annonce"); + } + + // --- Recuperation : au sol seulement -------------------------------------- + { + SlopedTerrain sheer(0.0f, 20.0f); + Climber climber; + climber.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + for (int i = 0; i < 600; ++i) climber.update(dt, 1.0f, 0.0f, sheer, nullptr); + const float inWall = climber.stamina(); + check(inWall < 1.0f, "Recuperation : la jauge a bien baisse"); + + // En paroi, restOnGround ne doit RIEN faire - sans quoi l'appelant, qui + // l'appelle a chaque frame, rechargerait le grimpeur pendant sa montee. + climber.restOnGround(1.0f); + checkNear(climber.stamina(), inWall, 1e-6f, + "Recuperation : aucune recuperation en paroi"); + + climber.release(); + climber.restOnGround(2.0f); + checkNear(climber.stamina(), inWall + 2.0f * defaults.staminaRecoveryPerSecond, + 1e-4f, "Recuperation : au sol, staminaRecoveryPerSecond par seconde"); + + climber.restOnGround(1000.0f); + checkNear(climber.stamina(), 1.0f, 1e-6f, + "Recuperation : la jauge ne depasse jamais 1"); + } + + // --- LA hauteur qui compte : ce qu'une jauge pleine permet ---------------- + { + // Le chiffre annonce dans world/Climber.hpp (62,5 m de paroi strictement + // verticale) est une limite theorique. Sur une paroi a 87 degres - la + // plus raide qu'on trouve reellement dans la zone de jeu - la composante + // horizontale en retire un peu. C'est CE chiffre-la qu'il faut mesurer, + // parce que c'est lui qui decide quelles parois du massif sont faisables. + SlopedTerrain sheer(0.0f, 20.0f); + Climber climber; + climber.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + + float highest = climber.anchor().y; + ClimbExit exit = ClimbExit::None; + int steps = 0; + while (exit == ClimbExit::None && steps < 200000) { + exit = climber.update(dt, 1.0f, 0.0f, sheer, nullptr); + if (exit == ClimbExit::None) { + highest = climber.anchor().y; + } + ++steps; + } + check(exit == ClimbExit::Exhausted, + "Jauge pleine : sur une paroi sans sommet, on finit par tomber"); + std::printf(" [mesure] jauge pleine sur une paroi a 87 deg : %.1f m atteints\n", + static_cast(highest)); + check(highest > 58.0f && highest < 63.0f, + "Jauge pleine : entre 58 et 63 m de paroi a 87 degres"); + + // Corollaire qui donne son sens a l'activite : les grandes falaises de + // ce massif (250 a 276 m, mesurees par tools/find_climb_walls.py) sont + // HORS DE PORTEE d'une seule jauge. C'est voulu, pas un reglage rate. + check(highest < 250.0f, + "Jauge pleine : les falaises de 250 m du massif restent hors de portee"); + } + + // --- Les trois sorties ---------------------------------------------------- + { + CliffTerrain cliff(0.0f, 3.0f, 0.0f, 10.0f); // 30 m de paroi a 300 % + + // 1. SOMMET. + { + Climber climber; + check(climber.tryStart(cliff, glm::vec3(-1.0f, 0.0f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)), + "Sortie sommet : engagement"); + ClimbExit exit = ClimbExit::None; + int steps = 0; + while (exit == ClimbExit::None && steps < 200000) { + exit = climber.update(dt, 1.0f, 0.0f, cliff, nullptr); + ++steps; + } + check(exit == ClimbExit::ToppedOut, + "Sortie sommet : une paroi de 30 m se termine par un SOMMET"); + check(!climber.climbing(), "Sortie sommet : l'escalade est terminee"); + // Au sommet on reste OU L'ON EST : c'est la seule des trois sorties + // qui ne ramene pas au pied, et c'est toute la recompense. + check(climber.anchor().x > 9.0f, + "Sortie sommet : on reste sur le plateau, pas au pied"); + check(climber.heightGained() > 28.0f, + "Sortie sommet : la trentaine de metres a bien ete gagnee"); + check(climber.stamina() > 0.0f, "Sortie sommet : il restait de l'energie"); + checkNear(climber.anchor().y, + cliff.heightAt(climber.anchor().x, climber.anchor().z), 1e-3f, + "Sortie sommet : la position finale est sur la surface"); + } + + // 2. LACHAGE VOLONTAIRE. + { + Climber climber; + climber.tryStart(cliff, glm::vec3(-1.0f, 0.0f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)); + const glm::vec3 foot = climber.groundAnchor(); + for (int i = 0; i < 300; ++i) climber.update(dt, 1.0f, 0.0f, cliff, nullptr); + check(climber.heightGained() > 3.0f, "Lachage : on etait bien monte"); + + const ClimbExit exit = climber.release(); + check(exit == ClimbExit::Released, "Lachage : la sortie est Released"); + check(!climber.climbing(), "Lachage : l'escalade est terminee"); + check(climber.anchor() == foot, + "Lachage : retour EXACT au point d'engagement"); + checkNear(climber.heightGained(), 0.0f, 1e-6f, + "Lachage : le gain d'altitude est annule"); + check(climber.release() == ClimbExit::None, + "Lachage : lacher deux fois ne fait rien la seconde fois"); + } + + // 3. EPUISEMENT. + { + Climber climber; + climber.tryStart(cliff, glm::vec3(-1.0f, 0.0f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)); + const glm::vec3 foot = climber.groundAnchor(); + + ClimbExit exit = ClimbExit::None; + int steps = 0; + // On monte puis on redescend en boucle : l'altitude ne progresse pas, + // mais l'energie, elle, se consomme. C'est le scenario "je tourne en + // rond sur la paroi", celui ou la chute doit finir par arriver. + while (exit == ClimbExit::None && steps < 400000) { + const float input = ((steps / 120) % 2 == 0) ? 1.0f : -1.0f; + exit = climber.update(dt, input, 0.0f, cliff, nullptr); + ++steps; + } + check(exit == ClimbExit::Exhausted, + "Epuisement : tourner en rond sur la paroi finit par une CHUTE"); + check(!climber.climbing(), "Epuisement : l'escalade est terminee"); + checkNear(climber.stamina(), 0.0f, 1e-6f, + "Epuisement : la jauge est bien a zero"); + check(climber.anchor() == foot, + "Epuisement : reinitialisation EXACTE au point d'engagement"); + check(!std::isnan(climber.anchor().x) && !std::isnan(climber.anchor().y), + "Epuisement : la position de repli est valide"); + } + } + + // --- Le sommet l'emporte sur l'epuisement --------------------------------- + { + // L'ordre des deux tests de sortie dans update() est un choix, pas un + // hasard : poser la main sur la vire avec sa derniere goutte d'energie, + // c'est topper, pas tomber. Le figer ici evite qu'un remaniement + // n'inverse les deux sans que personne ne s'en apercoive. + CliffTerrain cliff(0.0f, 3.0f, 0.0f, 3.0f); // paroi courte : 9 m + Climber climber; + climber.tryStart(cliff, glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + + ClimbExit exit = ClimbExit::None; + int steps = 0; + while (exit == ClimbExit::None && steps < 200000) { + exit = climber.update(dt, 1.0f, 0.0f, cliff, nullptr); + ++steps; + } + check(exit == ClimbExit::ToppedOut, + "Paroi courte : on toppe, la jauge n'a pas le temps de se vider"); + } + + // --- Hysteresis : pas de sortie au milieu d'une paroi --------------------- + { + // Le piege de cette phase : une vire etroite au milieu de la face ne doit + // PAS terminer l'escalade, sinon le joueur se retrouve debout en plein + // vide. Climber confirme donc le terrain marchable 3 m plus loin. + LedgedCliffTerrain narrow(3.0f, 15.0f, 1.0f); + Climber climber; + climber.tryStart(narrow, glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + ClimbExit exit = ClimbExit::None; + int steps = 0; + while (exit == ClimbExit::None && steps < 200000) { + exit = climber.update(dt, 1.0f, 0.0f, narrow, nullptr); + ++steps; + } + check(exit == ClimbExit::ToppedOut, + "Vire etroite : l'escalade se poursuit jusqu'au VRAI sommet"); + check(climber.anchor().x > 15.0f, + "Vire etroite de 1 m : on ne s'y arrete PAS (pas de sortie en plein vide)"); + + // Vire de 6 m : assez profonde pour s'y tenir debout. S'y arreter est le + // comportement CORRECT et non un pis-aller - 6 m de terrain marchable, + // on y est reellement. + LedgedCliffTerrain wide(3.0f, 15.0f, 6.0f); + Climber other; + other.tryStart(wide, glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + exit = ClimbExit::None; + steps = 0; + while (exit == ClimbExit::None && steps < 200000) { + exit = other.update(dt, 1.0f, 0.0f, wide, nullptr); + ++steps; + } + check(exit == ClimbExit::ToppedOut, "Vire large : sortie par le sommet"); + check(other.anchor().x < 15.0f, + "Vire large de 6 m : on s'y arrete, c'est du terrain ou l'on tient debout"); + } + + // --- Seuil d'energie a l'engagement --------------------------------------- + { + SlopedTerrain wall(0.0f, 3.0f); + Climber climber; + climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + while (climber.climbing()) { + climber.update(dt, 1.0f, 0.0f, wall, nullptr); + } + checkNear(climber.stamina(), 0.0f, 1e-6f, "Seuil d'engagement : jauge videe"); + check(!climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)), + "Seuil d'engagement : jauge vide, on refuse de s'engager"); + + climber.restOnGround(Climber::minStaminaToStart() / + defaults.staminaRecoveryPerSecond + 1.0f); + check(climber.stamina() >= Climber::minStaminaToStart(), + "Seuil d'engagement : la jauge est remontee au-dessus du seuil"); + check(climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)), + "Seuil d'engagement : au-dessus du seuil, on peut repartir"); + } + + // --- Collision : le meme moveBody que le joueur a pied -------------------- + { + // Rien de la collision n'est reecrit dans Climber : si ce test passe, + // c'est que le grimpeur emprunte bien le point d'entree unique du projet. + SlopedTerrain wall(0.0f, 3.0f); + Ground ground(wall); + ForestParams params; + params.treeCount = 0; // on plante a la main : test deterministe + Forest forest(wall, ground, 200.0f, params); + + Climber climber; + climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + + const glm::vec3 start = climber.anchor(); + forest.plantTree(start.x, start.z + 1.5f, 8.0f); + + for (int i = 0; i < 300; ++i) { + climber.update(dt, 0.0f, 1.0f, wall, &forest); + } + // Sans obstacle, 5 s de traversee a 0,6 m/s feraient 3 m. Le tronc est a + // 1,5 m : on ne doit pas l'avoir traverse. + const float travelled = climber.anchor().z - start.z; + check(travelled < 1.5f, + "Collision : le grimpeur bute sur le tronc au lieu de le traverser"); + check(travelled > 0.0f, "Collision : il a quand meme progresse jusqu'au tronc"); + + // Rester coince contre un tronc ne doit PAS etre un repos gratuit. Une + // premiere version de ce test attendait l'inverse ("buter coute moins + // que traverser") ; la mesure a montre que c'est faux, et que c'est tant + // mieux : un grimpeur bloque est facture au tarif SUSPENDU (par seconde), + // et sur ce modele suspendre 5 s coute 0,020 quand traverser 3 m n'en + // coute que 0,015. Pousser contre un obstacle est donc plus couteux que + // d'avancer, ce qui est le bon comportement - on ne se repose pas en + // s'appuyant sur un arbre. + const float pushedCost = 1.0f - climber.stamina(); + check(pushedCost > 0.0f, + "Collision : rester bloque contre un tronc consomme quand meme de " + "l'energie (pas de repos gratuit)"); + + Climber unobstructed; + unobstructed.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)); + for (int i = 0; i < 300; ++i) { + unobstructed.update(dt, 0.0f, 1.0f, wall, nullptr); + } + check(horizontalDistance(unobstructed.anchor(), + glm::vec3(0.0f, 0.0f, 0.0f)) > travelled, + "Collision : sans obstacle, la meme duree fait parcourir plus de " + "chemin - c'est bien le tronc qui a arrete le grimpeur"); + } + + // --- LA VRAIE PAROI DU TERRAIN LIDAR -------------------------------------- + // Conditionnel a dessein, comme le bloc de dalle reelle de testTerrainFile : + // le depot ne versionne pas les heightmaps. Quand la dalle est la, c'est le + // SEUL test d'escalade qui touche du relief mesure - et c'est celui qui + // compte, parce qu'un plan incline synthetique ne porte aucun bruit et n'a + // jamais prouve grand-chose (lecon de la Phase 13). + { + const std::filesystem::path realTile = + std::filesystem::path(ASSETS_DIR) / "terrain" / "LHD_0899_6436_1m.vchm"; + if (!std::filesystem::exists(realTile)) { + std::printf(" (dalle reelle absente, bloc ignore : %s)\n", + realTile.string().c_str()); + } else { + const Heightmap tile = loadTerrainFile(realTile.string()); + + // VOIE de reference de la Phase 14, trouvee par + // `find_climb_walls.py --routes` : depart E 899900 / N 6435550, soit + // x = +400 / z = -50 dans le monde moteur de cette dalle, cap 0 degre + // (plein est). 21,4 m gagnes sur 27 m de trajet en ligne droite, dont + // 63 % au-dessus du seuil de paroi, et un depart a 57 % de pente - + // donc du terrain ou l'on tient debout. + // + // POURQUOI UNE "VOIE" ET PAS UNE "PAROI" : le premier essai de ce + // test visait le centre d'une paroi reperee par le mode par defaut de + // l'outil (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 de l'outil, qui evalue le relief le long de chaque + // cap depuis un pied marchable. + const float footX = 400.0f; + const float footZ = -50.0f; + const float headingRad = glm::radians(0.0f); + const glm::vec3 lookDir(std::cos(headingRad), 0.0f, std::sin(headingRad)); + + Climber climber; + const float measured = climber.slopeAt(tile, footX, footZ); + std::printf(" [mesure] voie de reference E 899900 N 6435550 : " + "pente au depart %.1f %%\n", + static_cast(100.0f * measured)); + check(!climber.isWall(tile, footX, footZ), + "Voie LiDAR reelle : le pied n'est PAS une paroi (on y marche)"); + + // Engagement : on marche vers la paroi le long du cap jusqu'a + // l'avoir a portee - exactement ce que fait le joueur. + float approach = 0.0f; + bool engaged = false; + for (int step = 0; step < 160 && !engaged; ++step) { + const float ex = footX + lookDir.x * approach; + const float ez = footZ + lookDir.z * approach; + const glm::vec3 eye(ex, tile.heightAt(ex, ez) + 1.7f, ez); + engaged = climber.tryStart(tile, eye, lookDir); + approach += 0.25f; + } + check(engaged, + "Voie LiDAR reelle : on s'engage en marchant vers la paroi"); + check(climber.isWall(tile, climber.anchor().x, climber.anchor().z), + "Voie LiDAR reelle : le point d'accroche est bien sur une paroi"); + + if (engaged) { + const float startY = climber.anchor().y; + ClimbExit exit = ClimbExit::None; + int steps = 0; + float peak = startY; + bool everNaN = false; + bool alwaysOnSurface = true; + bool eyeAlwaysOutside = true; + while (exit == ClimbExit::None && steps < 200000) { + exit = climber.update(dt, 1.0f, 0.0f, tile, nullptr); + const glm::vec3 a = climber.anchor(); + if (std::isnan(a.x) || std::isnan(a.y) || std::isnan(a.z) || + std::isnan(climber.stamina())) { + everNaN = true; + } + if (exit == ClimbExit::None) { + peak = std::max(peak, a.y); + if (std::abs(a.y - tile.heightAt(a.x, a.z)) > 1e-2f) { + alwaysOnSurface = false; + } + const glm::vec3 eye = climber.position(); + if (eye.y <= tile.heightAt(eye.x, eye.z)) { + eyeAlwaysOutside = false; + } + } + ++steps; + } + + std::printf(" [mesure] ascension sur relief LiDAR reel : %.1f m " + "gagnes en %.1f s, sortie %s, energie restante %.0f %%\n", + static_cast(peak - startY), + static_cast(steps * dt), + exit == ClimbExit::ToppedOut ? "SOMMET" + : "epuisement", + static_cast(100.0f * climber.stamina())); + + check(!everNaN, + "Voie LiDAR reelle : aucun NaN sur toute l'ascension"); + check(alwaysOnSurface, + "Voie LiDAR reelle : le grimpeur ne quitte jamais la surface"); + check(eyeAlwaysOutside, + "Voie LiDAR reelle : l'oeil ne passe jamais sous le relief"); + // 15 m et non 21,4 : 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 m) est donc inferieur a la projection en + // ligne droite. C'est un resultat, pas un defaut - mais ca + // interdit de recopier le chiffre de l'outil dans une assertion. + check(peak - startY > 15.0f, + "Voie LiDAR reelle : plus de 15 m reellement gagnes"); + check(exit == ClimbExit::ToppedOut, + "Voie LiDAR reelle : la voie de reference se TOPPE"); + check(climber.stamina() > 0.0f, + "Voie LiDAR reelle : il restait de l'energie au sommet"); + check(!climber.isWall(tile, climber.anchor().x, climber.anchor().z), + "Voie LiDAR reelle : on termine sur du terrain non-paroi"); + } + } + } +} + + +// --------------------------------------------------------------------------- +// PHASE 24 : LA MARCHE A UNE LIMITE DE PENTE, ET ELLE REJOINT L'ESCALADE +// --------------------------------------------------------------------------- +// Ce qui est teste ici est core/SlopeLimits.hpp, pas core/Camera : la camera se +// contente d'appeler resolveWalkStep() une fois par frame avec le pas que le +// clavier demandait. Tester la fonction plutot que la camera n'est pas un +// contournement du fait que Camera::update() exige une Window - c'est le bon +// niveau : toute la decision est dans le filtre, la camera n'y ajoute que la +// lecture des touches. +// +// L'assertion qui compte le plus est celle du premier bloc : celle qui verifie +// qu'il n'existe aucune pente ou l'on ne puisse ni marcher ni grimper. C'etait +// le vrai defaut de coherence, et c'est la seule chose ici qu'un reglage +// distrait pourrait reintroduire sans rien casser d'autre. +void testWalkSlopeLimit() { + section("Phase 24 : limite de pente a la marche, et sa jonction avec l'escalade"); + + const WalkSlopeParams walkParams; + const ClimberParams climbing; + constexpr float dt = 1.0f / 60.0f; + constexpr float walkSpeed = 14.0f; // la vitesse de marche du moteur + const float step = walkSpeed * dt; + + // --- LA PROPRIETE STRUCTURELLE : AUCUN TROU ENTRE LES DEUX ACTIVITES ----- + // Elle se verifie sans terrain du tout, parce qu'elle ne porte que sur les + // seuils. Deux nombres regles separement finissent toujours par diverger ; + // cette assertion est ce qui l'empeche. + { + check(climbing.wallSlope <= walkParams.maxSlope, + "Coherence : l'escalade s'engage AU PLUS TARD la ou la marche " + "s'arrete (aucune bande interdite aux deux)"); + check(climbing.walkableSlope < walkParams.maxSlope, + "Coherence : on sort de l'escalade sur du terrain reellement " + "marchable, pas sur du terrain deja trop raide"); + check(walkParams.comfortSlope < walkParams.maxSlope, + "Coherence : le ralentissement precede le blocage (pas de mur sec)"); + + // Le balayage explicite, parce que l'inegalite ci-dessus se lit vite + // mais se croit mal : pour 300 pentes reparties de 0 a 300 %, il y a + // TOUJOURS au moins une des deux activites qui accepte. + bool everStuck = false; + float worstSlope = -1.0f; + for (int i = 0; i <= 300; ++i) { + const float slope = 0.01f * static_cast(i); + const bool canWalk = walkSpeedFactor(slope, walkParams) > 0.0f; + const bool canClimb = slope >= climbing.wallSlope; + if (!canWalk && !canClimb) { + everStuck = true; + worstSlope = slope; + } + } + if (everStuck) { + std::printf(" [mesure] pente sans issue trouvee : %.0f %%\n", + static_cast(100.0f * worstSlope)); + } + check(!everStuck, + "Aucune pente de 0 a 300 % n'est a la fois trop raide pour " + "marcher et trop douce pour grimper"); + } + + // --- LE FACTEUR DE VITESSE ---------------------------------------------- + { + checkNear(walkSpeedFactor(0.0f, walkParams), 1.0f, 1e-6f, + "A plat : pleine vitesse"); + checkNear(walkSpeedFactor(walkParams.comfortSlope, walkParams), 1.0f, 1e-6f, + "Au seuil de confort (60 %) : encore pleine vitesse"); + checkNear(walkSpeedFactor(0.5f * (walkParams.comfortSlope + walkParams.maxSlope), + walkParams), + 0.5f, 1e-4f, "A mi-chemin (72 %) : demi-vitesse"); + checkNear(walkSpeedFactor(walkParams.maxSlope, walkParams), 0.0f, 1e-6f, + "Au seuil maximal (84 %) : plus aucune progression"); + checkNear(walkSpeedFactor(30.0f, walkParams), 0.0f, 1e-6f, + "Sur une paroi a 3000 % : toujours zero, jamais de negatif"); + + // La rampe doit etre MONOTONE : un joueur qui aborde une pente de plus + // en plus raide ne doit jamais reaccelerer. + bool monotone = true; + float previous = 1.0f; + for (int i = 0; i <= 200; ++i) { + const float f = walkSpeedFactor(0.01f * static_cast(i), walkParams); + if (f > previous + 1e-6f) monotone = false; + previous = f; + } + check(monotone, "Le ralentissement est monotone : jamais de reprise de " + "vitesse quand ca se redresse"); + } + + // --- UN VERSANT DE RANDONNEE NORMALE N'EST PAS TOUCHE -------------------- + // C'est la contrainte explicite de la consigne : ne pas casser la traversee + // des pentes raides de randonnee. 30 %, c'est un sentier de montagne + // soutenu ; il doit se marcher exactement comme avant la Phase 24. + { + SlopedTerrain hike(0.0f, 0.30f); + const glm::vec3 from(0.0f, 0.0f, 0.0f); + const WalkStepResult up = + resolveWalkStep(hike, from, glm::vec3(step, 0.0f, 0.0f), dt, walkParams); + checkNear(up.speedFactor, 1.0f, 1e-6f, + "Sentier a 30 % : aucun ralentissement"); + checkNear(up.position.x - from.x, step, 1e-4f, + "Sentier a 30 % : le pas complet est accorde en montee"); + check(!up.sliding, "Sentier a 30 % : on ne glisse pas"); + + // Et le raidillon ponctuel a 80 % passe encore, ralenti. S'il etait + // refuse, la limite serait mal placee. + SlopedTerrain hard(0.0f, 0.80f); + const WalkStepResult tough = + resolveWalkStep(hard, from, glm::vec3(step, 0.0f, 0.0f), dt, walkParams); + check(tough.position.x - from.x > 0.0f, + "Raidillon a 80 % : ca monte encore, meme ralenti"); + std::printf(" [mesure] vitesse de marche accordee : 30 %% -> %.0f %%, " + "60 %% -> %.0f %%, 72 %% -> %.0f %%, 80 %% -> %.0f %%, " + "84 %% -> %.0f %%\n", + static_cast(100.0f * walkSpeedFactor(0.30f, walkParams)), + static_cast(100.0f * walkSpeedFactor(0.60f, walkParams)), + static_cast(100.0f * walkSpeedFactor(0.72f, walkParams)), + static_cast(100.0f * walkSpeedFactor(0.80f, walkParams)), + static_cast(100.0f * walkSpeedFactor(0.84f, walkParams))); + } + + // --- LA DISSYMETRIE AMONT / AVAL ---------------------------------------- + // Point de conception : on refuse de MONTER, jamais de redescendre. Sans + // cette dissymetrie, un joueur pose sur du trop raide serait fige, ce qui + // est exactement le blocage frustrant qu'il fallait eviter. + { + SlopedTerrain wall(0.0f, 1.00f); // 100 %, au-dessus du maximum + const glm::vec3 from(0.0f, 0.0f, 0.0f); + + const WalkStepResult up = + resolveWalkStep(wall, from, glm::vec3(step, 0.0f, 0.0f), dt, walkParams); + check(up.speedFactor <= 0.0f, + "Pente a 100 % : la montee a pied n'est plus accordee du tout"); + + const WalkStepResult down = + resolveWalkStep(wall, from, glm::vec3(-step, 0.0f, 0.0f), dt, walkParams); + check(down.position.x - from.x < -step * 0.99f, + "Pente a 100 % : REDESCENDRE reste possible, a pleine vitesse"); + + check(up.sliding && down.sliding, + "Pente a 100 % : on glisse, qu'on pousse la touche ou non"); + + // La glissade descend, et elle est douce a 100 % (0,16 d'exces). + const WalkStepResult idle = + resolveWalkStep(wall, from, glm::vec3(0.0f), dt, walkParams); + check(idle.position.x < from.x, + "Pente a 100 %, sans aucune touche : le joueur glisse vers l'AVAL"); + const float slideSpeed = (from.x - idle.position.x) / dt; + std::printf(" [mesure] glissade : %.2f m/s a 100 %% de pente\n", + static_cast(slideSpeed)); + check(slideSpeed > 0.0f && slideSpeed < 1.0f, + "Glissade a 100 % : un decrochage lent (<1 m/s), pas une ejection"); + + // Et sur une vraie paroi elle est plafonnee : sans plafond, les 5018 % + // mesures sur cette dalle ejecteraient le joueur a 150 m/s. + SlopedTerrain cliff(0.0f, 30.0f); + const WalkStepResult ejected = + resolveWalkStep(cliff, from, glm::vec3(0.0f), dt, walkParams); + const float cliffSpeed = (from.x - ejected.position.x) / dt; + check(cliffSpeed <= walkParams.slideSpeedMax + 1e-3f, + "Glissade sur une paroi a 3000 % : plafonnee, pas d'ejection"); + } + + // --- AUCUNE POSITION N'EST UN PIEGE ------------------------------------- + // La garantie de fond du chantier : ou qu'on depose le joueur, il finit sur + // du terrain marchable sans rien faire. C'est ce qui rend le blocage + // acceptable - il n'immobilise jamais, il renvoie en arriere. + { + CliffTerrain cliff(0.0f, 1.60f, 0.0f, 40.0f); // plat / paroi 160 % / plat + glm::vec3 player(20.0f, 0.0f, 0.0f); // depose en pleine paroi + int frames = 0; + while (frames < 60 * 60) { // une minute de jeu au maximum + const WalkStepResult r = + resolveWalkStep(cliff, player, glm::vec3(0.0f), dt, walkParams); + player = r.position; + if (!r.sliding) break; + ++frames; + } + const float finalSlope = + walkTerrainSlope(cliff, player.x, player.z, walkParams.sampleStep); + std::printf(" [mesure] depose en pleine paroi a 160 %% : ramene sur du " + "%.0f %% en %.1f s\n", + static_cast(100.0f * finalSlope), + static_cast(frames * dt)); + check(finalSlope <= walkParams.maxSlope + 1e-3f, + "Depose sur du trop raide : la glissade ramene sur du marchable"); + check(player.x < 20.0f, "La glissade va bien vers l'AVAL de la paroi"); + } + + // --- LE ZIGZAG NE CONTOURNE PAS LA LIMITE ------------------------------- + // Controle negatif de la decision de facturer aussi le deplacement LATERAL. + // Si le lateral etait gratuit, monter en travers a 45 degres rendrait 71 % + // du gain d'altitude a pleine vitesse et la limite ne servirait a rien. + { + SlopedTerrain slope(0.0f, 0.80f); + const glm::vec3 from(0.0f, 0.0f, 0.0f); + + const WalkStepResult direct = + resolveWalkStep(slope, from, glm::vec3(step, 0.0f, 0.0f), dt, walkParams); + const float diagonal = step * 0.70710678f; + const WalkStepResult zigzag = resolveWalkStep( + slope, from, glm::vec3(diagonal, 0.0f, diagonal), dt, walkParams); + + const float riseDirect = 0.80f * (direct.position.x - from.x); + const float riseZigzag = 0.80f * (zigzag.position.x - from.x); + check(riseZigzag <= riseDirect + 1e-5f, + "Zigzag : monter en travers ne fait pas gagner plus de hauteur " + "que monter droit"); + } + + // --- LA JONCTION, SUR UNE FALAISE SYNTHETIQUE --------------------------- + // Le scenario du joueur : il marche vers une paroi, il est arrete par la + // pente. La question qui decide de tout le chantier est celle-ci - a + // l'endroit exact ou la marche s'arrete, est-ce que l'escalade accepte ? + { + CliffTerrain cliff(0.0f, 1.60f, 30.0f, 70.0f); + const glm::vec3 lookDir(1.0f, 0.0f, 0.0f); + + glm::vec3 player(0.0f, 0.0f, 0.0f); + int frames = 0; + float lastAdvance = step; + while (frames < 60 * 60 && lastAdvance > 1e-4f) { + const WalkStepResult r = + resolveWalkStep(cliff, player, glm::vec3(step, 0.0f, 0.0f), dt, walkParams); + lastAdvance = r.position.x - player.x; + player = r.position; + ++frames; + } + + const float stopSlope = + walkTerrainSlope(cliff, player.x, player.z, walkParams.sampleStep); + std::printf(" [mesure] falaise synthetique : la marche s'arrete a " + "x = %.2f m, pente sous les pieds %.0f %%\n", + static_cast(player.x), + static_cast(100.0f * stopSlope)); + + check(player.x < 70.0f, + "Falaise : la marche ne franchit plus la paroi (elle passait avant " + "la Phase 24)"); + check(stopSlope <= walkParams.maxSlope + 1e-3f, + "Falaise : le joueur s'arrete AU PIED, sur du terrain ou il tient " + "encore debout - pas coince en pleine paroi"); + + // ET C'EST ICI QUE LE CHANTIER SE JOUE : depuis ce point d'arret, + // l'escalade doit accepter de s'engager. + Climber climber; + const glm::vec3 eye(player.x, cliff.heightAt(player.x, player.z) + 1.7f, + player.z); + check(climber.tryStart(cliff, eye, lookDir), + "Falaise : la ou la marche s'arrete, l'ESCALADE PREND LE RELAIS"); + } + + // --- LA MEME JONCTION, SUR LE VRAI RELIEF LIDAR ------------------------- + // Meme raison d'etre que le bloc LiDAR de testClimber() : un plan incline + // synthetique n'a jamais rien prouve sur ce projet. La voie employee est + // celle de reference de la Phase 14 - pied marchable a E 899900 / + // N 6435550, cap plein est - precisement parce qu'elle est deja connue + // comme une VRAIE transition marche / paroi. + { + const std::filesystem::path realTile = + std::filesystem::path(ASSETS_DIR) / "terrain" / "LHD_0899_6436_1m.vchm"; + if (!std::filesystem::exists(realTile)) { + std::printf(" (dalle reelle absente, bloc ignore : %s)\n", + realTile.string().c_str()); + } else { + const Heightmap tile = loadTerrainFile(realTile.string()); + const glm::vec3 lookDir(1.0f, 0.0f, 0.0f); + + glm::vec3 player(400.0f, 0.0f, -50.0f); + const float startSlope = + walkTerrainSlope(tile, player.x, player.z, walkParams.sampleStep); + check(startSlope < walkParams.maxSlope, + "Voie LiDAR reelle : le pied de la voie se marche encore"); + + float travelled = 0.0f; + int frames = 0; + float lastAdvance = step; + while (frames < 60 * 120 && lastAdvance > 1e-4f) { + const WalkStepResult r = resolveWalkStep( + tile, player, glm::vec3(step, 0.0f, 0.0f), dt, walkParams); + lastAdvance = r.position.x - player.x; + travelled += lastAdvance; + player = r.position; + ++frames; + } + + const float stopSlope = + walkTerrainSlope(tile, player.x, player.z, walkParams.sampleStep); + std::printf(" [mesure] relief LiDAR reel : la marche progresse de " + "%.1f m puis s'arrete, pente au point d'arret %.0f %%, " + "altitude gagnee %.1f m\n", + static_cast(travelled), + static_cast(100.0f * stopSlope), + static_cast(tile.heightAt(player.x, player.z) - + tile.heightAt(400.0f, -50.0f))); + + check(travelled > 1.0f, + "Voie LiDAR reelle : le joueur avance reellement avant d'etre " + "arrete (ce n'est pas un blocage des le premier pas)"); + check(stopSlope <= walkParams.maxSlope + 1e-3f, + "Voie LiDAR reelle : l'arret se fait sur du terrain ou l'on " + "tient debout"); + + Climber climber; + const glm::vec3 eye(player.x, tile.heightAt(player.x, player.z) + 1.7f, + player.z); + const bool engaged = climber.tryStart(tile, eye, lookDir); + check(engaged, + "Voie LiDAR reelle : l'escalade prend le relais LA OU la " + "marche s'est arretee"); + if (!engaged) { + // Diagnostic plutot qu'une simple croix : sur ce projet, savoir + // POURQUOI un engagement echoue a deja fait gagner des phases + // entieres (pente insuffisante ? ou ressaut sans relief ?). + std::printf(" [diagnostic] pente devant = %.0f %%, seuil de " + "paroi = %.0f %%\n", + static_cast( + 100.0f * climber.slopeAt(tile, player.x + 1.0f, player.z)), + static_cast(100.0f * climber.params().wallSlope)); + } + } + } +} + +// --------------------------------------------------------------------------- +// Phase 10 : quadtree de terrain, selection de LOD, frustum culling +// --------------------------------------------------------------------------- +void testTerrainQuadtree() { + section("Phase 10 : quadtree, LOD et frustum culling"); + + // Matrice view-projection reutilisee par les tests de culling : camera a + // l'origine regardant vers -Z (la convention du moteur : Camera part avec un + // yaw de -90 degres), 60 degres de champ, exactement comme le Renderer. + const auto viewProjectionLookingNorth = [](float farPlane) { + glm::mat4 proj = glm::perspective(glm::radians(60.0f), 16.0f / 9.0f, 0.1f, farPlane); + proj[1][1] *= -1.0f; // convention Vulkan, comme Renderer::projectionMatrix + const glm::mat4 view = glm::lookAt(glm::vec3(0.0f), glm::vec3(0.0f, 0.0f, -1.0f), + glm::vec3(0.0f, 1.0f, 0.0f)); + return proj * view; + }; + + // --- Frustum : ce qui est devant est vu, ce qui est derriere ne l'est pas - + { + const Frustum frustum = Frustum::fromViewProjection(viewProjectionLookingNorth(1000.0f)); + + check(frustum.intersectsAABB(glm::vec3(-1.0f, -1.0f, -51.0f), + glm::vec3(1.0f, 1.0f, -49.0f)), + "Frustum : une boite droit devant est visible"); + check(!frustum.intersectsAABB(glm::vec3(-1.0f, -1.0f, 49.0f), + glm::vec3(1.0f, 1.0f, 51.0f)), + "Frustum : une boite DERRIERE la camera est ecartee"); + check(!frustum.intersectsAABB(glm::vec3(499.0f, -1.0f, -51.0f), + glm::vec3(501.0f, 1.0f, -49.0f)), + "Frustum : une boite loin sur le cote est ecartee"); + check(!frustum.intersectsAABB(glm::vec3(-1.0f, -1.0f, -2001.0f), + glm::vec3(1.0f, 1.0f, -1999.0f)), + "Frustum : une boite au-dela du plan lointain est ecartee"); + check(frustum.intersectsAABB(glm::vec3(-10000.0f, -10000.0f, -10000.0f), + glm::vec3(10000.0f, 10000.0f, 10000.0f)), + "Frustum : une boite qui englobe la camera est visible"); + } + + // --- distanceToAABB ----------------------------------------------------- + { + const glm::vec3 lo(-1.0f, -1.0f, -1.0f); + const glm::vec3 hi(1.0f, 1.0f, 1.0f); + checkNear(distanceToAABB(glm::vec3(0.0f), lo, hi), 0.0f, 1e-5f, + "distanceToAABB : nulle a l'interieur de la boite"); + checkNear(distanceToAABB(glm::vec3(4.0f, 0.0f, 0.0f), lo, hi), 3.0f, 1e-5f, + "distanceToAABB : distance a la FACE la plus proche, pas au centre"); + } + + // --- Structure de l'arbre ---------------------------------------------- + Heightmap::Params params; + params.resolution = 257; // 256 cellules = 4 x 4 feuilles de 64 + params.worldSize = 256.0f; // pas de 1 unite, pour raisonner en metres ronds + const Heightmap heightmap(params); + + TerrainQuadtree::Params quadtreeParams; + quadtreeParams.nodeCells = 64; + const TerrainQuadtree quadtree(heightmap, quadtreeParams); + + check(quadtree.rootLevel() == 2, + "Quadtree : 256 cellules / 64 = 4 x 4 feuilles -> racine au niveau 2"); + check(quadtree.nodeCount() == 21, "Quadtree : 16 feuilles + 4 noeuds + 1 racine = 21"); + check(quadtree.trianglesPerNode() == 64 * 64 * 2, + "Quadtree : un noeud dessine le meme nombre de triangles a tous les niveaux"); + check(quadtree.range(1) > quadtree.range(0), + "Quadtree : la portee croit avec le niveau"); + checkNear(quadtree.range(1), 2.0f * quadtree.range(0), 1e-3f, + "Quadtree : la portee DOUBLE d'un niveau au suivant"); + + // La racine couvre tout le terrain, et ses bornes verticales encadrent + // reellement le relief : une boite trop petite ferait disparaitre du terrain + // au culling. + { + const TerrainQuadtree::Node& root = quadtree.node(0); + check(root.level == quadtree.rootLevel(), "Quadtree : le noeud 0 est la racine"); + checkNear(root.boundsMin.x, -128.0f, 1e-3f, "Quadtree : la racine part du bord ouest"); + checkNear(root.boundsMax.x, 128.0f, 1e-3f, "Quadtree : la racine va au bord est"); + check(root.boundsMin.y <= heightmap.minHeight() + 1e-3f && + root.boundsMax.y >= heightmap.maxHeight() - 1e-3f, + "Quadtree : la boite de la racine englobe TOUTE la plage d'altitudes"); + } + + // --- Selection : plus on est pres, plus le niveau est fin --------------- + std::vector selection; + { + // Frustum permissif (tout est visible) : on isole ici le critere de + // DISTANCE, le culling est teste separement juste apres. + const Frustum everything = Frustum::fromViewProjection(glm::mat4(0.0f)); + + const glm::vec3 corner(-120.0f, heightmap.maxHeight(), -120.0f); + quadtree.select(corner, everything, selection); + check(!selection.empty(), "Selection : au moins un noeud retenu"); + + // Le noeud le plus proche doit etre au niveau le plus fin, et le plus + // lointain a un niveau plus grossier : c'est exactement la promesse du + // LOD par distance. + check(selection.front().level == 0, + "Selection : la tuile la plus proche est a la PLEINE resolution"); + check(selection.back().level >= selection.front().level, + "Selection : la tuile la plus lointaine n'est pas plus fine que la plus proche"); + + bool sorted = true; + for (std::size_t i = 1; i < selection.size(); ++i) { + sorted = sorted && (selection[i - 1].distance <= selection[i].distance + 1e-4f); + } + check(sorted, "Selection : triee du plus proche au plus lointain"); + + // Bande de morphing : condition ANTI-FISSURE. Un noeud de niveau L doit + // etre entierement morphe sur la grille L+1 avant range[L], sans quoi son + // voisin plus grossier ne le rejoint pas. + bool bandsValid = true; + for (const TerrainQuadtree::SelectedNode& node : selection) { + bandsValid = bandsValid && + node.morphStart > 0.5f * quadtree.range(node.level) && + node.morphEnd > node.morphStart && + node.morphEnd <= quadtree.range(node.level); + } + check(bandsValid, + "Selection : bande de morphing dans (range/2, range] pour chaque tuile"); + + // COUVERTURE : les tuiles retenues doivent paver tout le terrain, sans + // trou ni recouvrement. On le verifie en surface : la somme des emprises + // horizontales doit valoir exactement celle du terrain. + double coveredArea = 0.0; + for (const TerrainQuadtree::SelectedNode& selected : selection) { + const TerrainQuadtree::Node& node = quadtree.node(selected.nodeIndex); + coveredArea += static_cast(node.boundsMax.x - node.boundsMin.x) * + static_cast(node.boundsMax.z - node.boundsMin.z); + } + checkNear(static_cast(coveredArea), 256.0f * 256.0f, 1.0f, + "Selection : les tuiles retenues pavent le terrain, sans trou ni recouvrement"); + } + + // --- Frustum culling : regarder ailleurs retire des tuiles --------------- + { + const Frustum everything = Frustum::fromViewProjection(glm::mat4(0.0f)); + const glm::vec3 eye(0.0f, heightmap.maxHeight() + 50.0f, 0.0f); + + quadtree.select(eye, everything, selection); + const std::size_t withoutCulling = selection.size(); + + const Frustum frustum = Frustum::fromViewProjection(viewProjectionLookingNorth(2000.0f)); + quadtree.select(eye, frustum, selection); + const std::size_t withCulling = selection.size(); + + check(withCulling < withoutCulling, + "Culling : regarder dans une direction retient MOINS de tuiles que tout voir"); + check(withCulling > 0, "Culling : il reste des tuiles devant la camera"); + } + + // --- Maillage d'un noeud ------------------------------------------------ + { + // Une feuille : pas de 1 echantillon, donc les sommets doivent tomber + // EXACTEMENT sur la grille - c'est ce qui garantit qu'au contact du + // joueur la surface affichee est celle sur laquelle il marche. + uint32_t leafIndex = 0; + for (uint32_t i = 0; i < quadtree.nodeCount(); ++i) { + if (quadtree.node(i).level == 0) { + leafIndex = i; + break; + } + } + const TerrainQuadtree::Node& leaf = quadtree.node(leafIndex); + check(leaf.stride == 1, "Tuile : une feuille echantillonne au pas de la donnee"); + + const MeshData mesh = terrainNodeMeshData(heightmap, quadtree, leafIndex); + check(mesh.vertices.size() == 65u * 65u, "Tuile : 65 x 65 sommets"); + check(mesh.triangleCount() == 64u * 64u * 2u, "Tuile : 8192 triangles"); + + // --- PHASE 18 ----------------------------------------------------- + // La cible de morphing est desormais lue dans une grille grossiere + // calculee une fois par tuile, au lieu d'etre recalculee par sommet. + // Cela n'est legitime QUE si les quatre sommets d'un bloc 2x2 partagent + // bien la meme cible - c'est l'hypothese sur laquelle repose toute + // l'optimisation, et elle merite d'etre verifiee plutot que crue. + bool blockShared = true; + for (uint32_t j = 0; j + 1 <= 64 && blockShared; j += 2) { + for (uint32_t i = 0; i + 1 <= 64 && blockShared; i += 2) { + const Vertex& reference = mesh.vertices[j * 65u + i]; + for (uint32_t dj = 0; dj < 2; ++dj) { + for (uint32_t di = 0; di < 2; ++di) { + const Vertex& other = mesh.vertices[(j + dj) * 65u + (i + di)]; + if (other.morphPos != reference.morphPos || + other.morphNormal != reference.morphNormal) { + blockShared = false; + } + } + } + } + } + check(blockShared, + "Tuile : les 4 sommets d'un bloc 2x2 visent la MEME cible de morphing"); + + // `withIndices = false` (le chemin du TerrainStreamer depuis la + // Phase 18) doit produire exactement les memes SOMMETS et laisser la + // topologie a l'appelant. Sans cette verification, une tuile pourrait + // etre construite differemment selon l'appelant. + const MeshData bare = terrainNodeMeshData(heightmap, quadtree, leafIndex, false); + check(bare.indices.empty(), "Tuile : withIndices=false laisse la topologie vide"); + bool sameVertices = (bare.vertices.size() == mesh.vertices.size()); + for (std::size_t v = 0; v < bare.vertices.size() && sameVertices; ++v) { + sameVertices = (bare.vertices[v].pos == mesh.vertices[v].pos) && + (bare.vertices[v].normal == mesh.vertices[v].normal) && + (bare.vertices[v].morphPos == mesh.vertices[v].morphPos); + } + check(sameVertices, "Tuile : memes sommets avec et sans la topologie"); + check(terrainNodeIndices(64u).size() == 64u * 64u * 6u && + terrainNodeIndices(64u) == mesh.indices, + "Tuile : la topologie posee par l'appelant est bien la meme"); + + bool onGrid = true; + for (uint32_t j = 0; j <= 64 && onGrid; ++j) { + for (uint32_t i = 0; i <= 64 && onGrid; ++i) { + const Vertex& vertex = mesh.vertices[j * 65 + i]; + onGrid = std::abs(vertex.pos.y - + heightmap.at(leaf.ix0 + i, leaf.iz0 + j)) < 1e-4f; + } + } + check(onGrid, "Tuile de niveau 0 : chaque sommet porte l'altitude EXACTE de la grille"); + + // Geomorphing : un sommet d'indice local PAIR est deja sur la grille du + // niveau superieur et ne doit pas bouger ; un sommet IMPAIR doit venir se + // confondre avec son voisin pair. C'est cette propriete qui fait qu'a + // morph = 1 la tuile a exactement la forme de son parent. + bool evenStaysPut = true; + bool oddCollapses = true; + for (uint32_t j = 0; j <= 64; j += 2) { + for (uint32_t i = 0; i <= 64; ++i) { + const Vertex& vertex = mesh.vertices[j * 65 + i]; + if (i % 2 == 0) { + evenStaysPut = evenStaysPut && + glm::length(vertex.morphPos - vertex.pos) < 1e-4f; + } else { + const Vertex& evenNeighbour = mesh.vertices[j * 65 + (i - 1)]; + oddCollapses = oddCollapses && + glm::length(vertex.morphPos - evenNeighbour.pos) < 1e-4f; + } + } + } + check(evenStaysPut, "Geomorphing : un sommet d'indice pair ne bouge pas"); + check(oddCollapses, + "Geomorphing : un sommet impair rejoint son voisin pair (grille du parent)"); + + // Les indices sont les MEMES pour toutes les tuiles : c'est ce qui + // permettra de partager un seul index buffer le jour ou on le fera. + const std::vector shared = terrainNodeIndices(quadtree.nodeCells()); + check(shared == mesh.indices, "Tuile : topologie identique pour tous les noeuds"); + } + + // --- Une tuile grossiere reste DANS les bornes de son noeud ------------- + { + const MeshData rootMesh = terrainNodeMeshData(heightmap, quadtree, 0); + const TerrainQuadtree::Node& root = quadtree.node(0); + bool inside = true; + for (const Vertex& vertex : rootMesh.vertices) { + inside = inside && + vertex.pos.x >= root.boundsMin.x - 1e-3f && + vertex.pos.x <= root.boundsMax.x + 1e-3f && + vertex.pos.z >= root.boundsMin.z - 1e-3f && + vertex.pos.z <= root.boundsMax.z + 1e-3f && + vertex.pos.y >= root.boundsMin.y - 1e-3f && + vertex.pos.y <= root.boundsMax.y + 1e-3f; + } + check(inside, "Tuile grossiere : tous ses sommets tiennent dans la boite du noeud"); + } + + // --- DECOUPLAGE RENDU / COLLISION --------------------------------------- + // Le point le plus important de la Phase 10 cote gameplay : la physique ne + // doit RIEN devoir au niveau de detail affiche. La Heightmap reste la source + // unique et pleine resolution de heightAt() ; construire, selectionner ou + // mailler le quadtree ne la touche pas. + { + const float before = heightmap.heightAt(12.5f, -33.25f); + + const Frustum everything = Frustum::fromViewProjection(glm::mat4(0.0f)); + quadtree.select(glm::vec3(0.0f, 5000.0f, 0.0f), everything, selection); // tout au loin + const float farAway = heightmap.heightAt(12.5f, -33.25f); + quadtree.select(glm::vec3(12.5f, 0.0f, -33.25f), everything, selection); // au contact + const float closeUp = heightmap.heightAt(12.5f, -33.25f); + + check(before == farAway && before == closeUp, + "Collision : heightAt() est insensible au niveau de detail selectionne"); + + // Et la surface de collision est bien celle de la donnee, pas celle + // d'une tuile grossiere : au noeud de grille, heightAt() vaut at(). + checkNear(heightmap.heightAt(heightmap.worldCoord(70), heightmap.worldCoord(70)), + heightmap.at(70, 70), 1e-3f, + "Collision : heightAt() reste la surface pleine resolution"); + } + + // --- Grilles non multiples de la taille de tuile ------------------------- + // Le terrain procedural (128 echantillons, donc 127 cellules) et la zone + // assemblee (5001, donc 5000) ne tombent PAS sur un multiple de 64. Le + // quadtree doit les accepter en ecretant, sans deborder ni laisser de trou. + { + Heightmap::Params odd; + odd.resolution = 128; + odd.worldSize = 127.0f; + const Heightmap oddMap(odd); + const TerrainQuadtree oddTree(oddMap, quadtreeParams); + check(oddTree.rootLevel() == 1, "Grille de 127 cellules : racine au niveau 1"); + + const MeshData mesh = terrainNodeMeshData(oddMap, oddTree, 0); + const float edge = oddMap.worldCoord(oddMap.resolution() - 1); + bool clamped = true; + for (const Vertex& vertex : mesh.vertices) { + clamped = clamped && vertex.pos.x <= edge + 1e-3f && vertex.pos.z <= edge + 1e-3f; + } + check(clamped, + "Grille non multiple : aucun sommet ne depasse le bord (ecretage, pas d'etagere)"); + } + + // --- Parametres invalides refuses --------------------------------------- + { + const auto rejected = [&](const TerrainQuadtree::Params& bad) { + try { + TerrainQuadtree tree(heightmap, bad); + return false; + } catch (const std::runtime_error&) { + return true; + } + }; + + TerrainQuadtree::Params notPowerOfTwo = quadtreeParams; + notPowerOfTwo.nodeCells = 60; + check(rejected(notPowerOfTwo), "Refus : nodeCells qui n'est pas une puissance de deux"); + + // morphStartRatio <= 0.5 rouvrirait les fissures entre niveaux : le + // constructeur doit le refuser plutot que de produire un terrain fendu. + TerrainQuadtree::Params tooEarly = quadtreeParams; + tooEarly.morphStartRatio = 0.4f; + check(rejected(tooEarly), "Refus : bande de morphing qui commence trop tot"); + } +} + +// =========================================================================== +// PHASE 11 : orthophoto, vegetation de decor, herbe +// =========================================================================== + +// Carte constante : sert a verifier que le semis SUIT bien la carte, en +// comparant deux mondes qui ne different QUE par elle. +class ConstantMap : public HeightSampler { +public: + explicit ConstantMap(float value) : value_(value) {} + float heightAt(float, float) const override { return value_; } + +private: + float value_; +}; + +// Couvert coupe en deux : boise a l'est de x = 0, nu a l'ouest. C'est le test +// decisif de la tache 2 - le semis doit reproduire la frontiere. +class HalfCoveredMap : public HeightSampler { +public: + float heightAt(float x, float) const override { return x > 0.0f ? 1.0f : 0.0f; } +}; + +// Frustum qui accepte tout : les tests de SEMIS ne doivent pas dependre du +// cadrage. Les six plans delimitent un volume immense. +Frustum permissiveFrustum() { + Frustum frustum; + const float far = 1.0e6f; + frustum.planes[0] = { 1.0f, 0.0f, 0.0f, far }; + frustum.planes[1] = { -1.0f, 0.0f, 0.0f, far }; + frustum.planes[2] = { 0.0f, 1.0f, 0.0f, far }; + frustum.planes[3] = { 0.0f, -1.0f, 0.0f, far }; + frustum.planes[4] = { 0.0f, 0.0f, 1.0f, far }; + frustum.planes[5] = { 0.0f, 0.0f, -1.0f, far }; + return frustum; +} + + +// Le semis d'arbres est BUDGETE : gatherTrees ne construit qu'un nombre limite +// de cellules neuves par appel (VegetationParams::treeCellBudget), pour qu'une +// arrivee dans une zone vierge n'engendre pas des milliers de cellules d'un coup +// et ne fasse pas un a-coup visible. En jeu, les cellules manquantes arrivent aux +// images suivantes ; dans un test, il faut donc appeler jusqu'a ce que le semis +// se stabilise, sinon on ne juge que du premier lot construit - c'est-a-dire du +// coin le plus au sud-ouest de la zone balayee, ce qui n'a aucun sens. +void gatherTreesUntilStable(Vegetation& vegetation, const glm::vec3& eye, + const Frustum& frustum, std::vector& out) { + std::size_t previous = 0; + int stable = 0; + for (int pass = 0; pass < 400 && stable < 3; ++pass) { + vegetation.gatherTrees(eye, frustum, out); + stable = (out.size() == previous) ? stable + 1 : 0; + previous = out.size(); + } +} + +void testTextureFile() { + section("Phase 11 : format de texture .vcto"); + + // BC1 : blocs de 4x4 texels sur 8 octets. + check(textureLevelSize(TextureFormat::BC1, 8, 8) == 4ull * 8ull, + "BC1 8x8 = 4 blocs de 8 octets"); + check(textureLevelSize(TextureFormat::BC1, 8192, 8192) == 33554432ull, + "BC1 8192x8192 = 32 Mo"); + // Les derniers niveaux de mipmap ne sont PAS multiples de 4 : ils occupent + // quand meme un bloc entier. Se tromper ici decale toute la fin de la chaine + // et le fichier ne correspond plus a son en-tete. + check(textureLevelSize(TextureFormat::BC1, 2, 2) == 8ull, + "BC1 2x2 occupe un bloc entier"); + check(textureLevelSize(TextureFormat::BC1, 1, 1) == 8ull, + "BC1 1x1 occupe un bloc entier"); + check(textureLevelSize(TextureFormat::RGBA8, 16, 8) == 512ull, + "RGBA8 16x8 = 512 octets"); + + // La chaine complete d'une texture de 8192, telle que la calcule le + // chargeur, doit valoir exactement la taille produite par l'outil Python. + uint64_t total = 0; + for (uint32_t level = 0; level < 14; ++level) { + const uint32_t side = std::max(1u, 8192u >> level); + total += textureLevelSize(TextureFormat::BC1, side, side); + } + check(total == 44739256ull, + "Chaine de 14 mipmaps BC1 8192 = 44 739 256 octets"); + + TextureData data; + data.width = 8192; + data.height = 8192; + data.eastMin = 899000.0; + data.eastMax = 904000.0; + data.northMin = 6435000.0; + data.northMax = 6440000.0; + checkNear(static_cast(data.metresPerTexel()), 0.6104f, 0.001f, + "0,61 m par texel sur 5 km en 8192 texels"); + + // Un fichier absent doit LEVER, pas renvoyer une texture vide qui serait + // ensuite drapee en silence sur le terrain. + bool threw = false; + try { + loadTextureFile("chemin/qui/n/existe/pas.vcto"); + } catch (const std::exception&) { + threw = true; + } + check(threw, "Refus : fichier .vcto absent"); +} + +void testGrassMesh() { + section("Phase 11 : maillage de touffe d'herbe"); + + const MeshData tuft = grassTuftMeshData(3); + check(tuft.vertices.size() == 12, "3 quads croises = 12 sommets"); + check(tuft.triangleCount() == 6, "3 quads croises = 6 triangles"); + + // CONVENTION UNITE, la meme que l'arbre : pied a l'origine, hauteur 1. Une + // touffe deja a l'echelle obligerait a une echelle non uniforme, donc a + // transporter une vraie normal matrix (voir InstanceData.hpp). + float lowest = 1.0e9f; + float highest = -1.0e9f; + for (const Vertex& vertex : tuft.vertices) { + lowest = std::min(lowest, vertex.pos.y); + highest = std::max(highest, vertex.pos.y); + } + checkNear(lowest, 0.0f, 1e-5f, "Pied de la touffe a l'altitude zero"); + checkNear(highest, 1.0f, 1e-5f, "Sommet de la touffe a l'altitude un"); + + // L'UV.y porte la hauteur dans le brin : c'est ce que lit le vertex shader + // pour plier la touffe SANS decoller son pied du sol. Un uv.y non nul au + // pied ferait glisser la touffe hors de terre a chaque coup de vent. + bool feetPinned = true; + bool normalsRaised = true; + for (const Vertex& vertex : tuft.vertices) { + if (vertex.pos.y < 0.5f && std::abs(vertex.uv.y) > 1e-5f) { + feetPinned = false; + } + if (vertex.normal.y <= 0.5f) { + normalsRaised = false; + } + } + check(feetPinned, "uv.y nul au pied de chaque brin"); + // Normale relevee vers le haut : un quad vertical dont la normale serait + // horizontale ne recevrait presque rien d'une lumiere zenithale. + check(normalsRaised, "Normales de brin relevees vers le haut"); +} + +// --------------------------------------------------------------------------- +// PHASE 19 : le maillage d'une tuile est-il vraiment insensible au thread ? +// --------------------------------------------------------------------------- +// La Phase 19 deplace terrainNodeMeshData du thread de rendu vers un petit +// groupe de threads. Tout repose sur UNE affirmation : cette fonction est PURE, +// donc N tuiles maillees en parallele donnent exactement les memes octets que +// les memes N tuiles maillees en sequence. +// +// C'est une affirmation qu'on ne peut PAS verifier en regardant l'image. Deux +// captures du jeu different deja entre deux executions identiques (l'herbe et +// la faune s'animent avec le temps ecoule, et le temps ecoule depend du debit +// d'images, que la phase change justement) : la comparaison de pixels a un +// plancher de bruit de l'ordre du pour-cent, largement au-dessus de ce qu'on +// cherche a detecter. Le seul controle qui tranche est celui-ci, deterministe +// et bit a bit. +// +// Le test compare les SOMMETS octet par octet, et non a une tolerance pres : +// une course sur une donnee partagee ne produirait pas un petit ecart +// numerique, elle produirait un sommet pris a la mauvaise tuile. +void testTileMeshingIsThreadSafe() { + section("Phase 19 : maillage de tuiles en parallele"); + + Heightmap::Params hparams; + hparams.resolution = 513; // 512 cellules = 8 x 8 feuilles de 64 + hparams.worldSize = 512.0f; + hparams.seed = 1907u; + const Heightmap heightmap(hparams); + + TerrainQuadtree::Params qparams; + qparams.nodeCells = 64; + const TerrainQuadtree quadtree(heightmap, qparams); + + // Un lot volontairement plus GROS que le nombre de threads, et melangeant + // les niveaux : une tuile grossiere lit la heightmap au pas du noeud et + // touche donc une tout autre partie de la donnee qu'une feuille. Si un etat + // etait partage quelque part dans terrainNodeMeshData, c'est ce melange qui + // le ferait sortir. + std::vector nodes; + for (uint32_t index = 0; index < quadtree.nodeCount() && nodes.size() < 40; ++index) { + nodes.push_back(index); + } + check(nodes.size() >= 8, "Phase 19 : assez de tuiles pour un lot de test"); + + // --- Reference : tout en sequence, sur ce thread ----------------------- + std::vector reference(nodes.size()); + for (std::size_t k = 0; k < nodes.size(); ++k) { + reference[k] = terrainNodeMeshData(heightmap, quadtree, nodes[k], false); + } + + // --- Le meme lot, sur 4 threads, decoupe en tranches contigues ---------- + // Meme decoupage que TerrainStreamer::meshBatch : chaque thread ecrit dans + // des elements disjoints d'un vecteur deja dimensionne. + const std::size_t slices = 4; + std::vector parallel(nodes.size()); + { + std::vector threads; + const std::size_t total = nodes.size(); + const auto sliceBegin = [total, slices](std::size_t s) { + return (total * s) / slices; + }; + const auto worker = [&](std::size_t begin, std::size_t end) { + for (std::size_t k = begin; k < end; ++k) { + parallel[k] = terrainNodeMeshData(heightmap, quadtree, nodes[k], false); + } + }; + for (std::size_t s = 1; s < slices; ++s) { + threads.emplace_back(worker, sliceBegin(s), sliceBegin(s + 1)); + } + worker(sliceBegin(0), sliceBegin(1)); + for (std::thread& t : threads) { + t.join(); + } + } + + bool sameCount = true; + bool sameBytes = true; + bool sameNames = true; + for (std::size_t k = 0; k < nodes.size(); ++k) { + if (reference[k].vertices.size() != parallel[k].vertices.size()) { + sameCount = false; + continue; + } + sameNames = sameNames && (reference[k].name == parallel[k].name); + // memcmp, et non une comparaison champ a champ : on veut que le test + // echoue aussi sur un champ qu'on aurait oublie d'ajouter ici le jour + // ou Vertex grandira. + if (std::memcmp(reference[k].vertices.data(), parallel[k].vertices.data(), + reference[k].vertices.size() * sizeof(Vertex)) != 0) { + sameBytes = false; + } + } + check(sameCount, "Phase 19 : meme nombre de sommets par tuile en parallele"); + check(sameNames, "Phase 19 : meme nom de tuile en parallele"); + check(sameBytes, + "Phase 19 : sommets BIT A BIT identiques, en sequence et sur 4 threads"); + + // Le temoin du test lui-meme : si le lot etait constitue de tuiles toutes + // identiques, la verification ci-dessus passerait sans rien prouver. On + // s'assure donc que les tuiles comparees sont bien DIFFERENTES entre elles. + bool tilesDiffer = false; + for (std::size_t k = 1; k < reference.size() && !tilesDiffer; ++k) { + tilesDiffer = std::memcmp(reference[0].vertices.data(), + reference[k].vertices.data(), + reference[0].vertices.size() * sizeof(Vertex)) != 0; + } + check(tilesDiffer, + "Phase 19 : le lot compare contient bien des tuiles distinctes (temoin)"); + + // Repetitions : une course se manifeste rarement. Un seul passage qui + // reussit ne dit presque rien ; c'est la raison d'etre de cette boucle. + bool stableOverRuns = true; + for (int attempt = 0; attempt < 12 && stableOverRuns; ++attempt) { + std::vector again(nodes.size()); + std::vector threads; + const std::size_t total = nodes.size(); + const auto sliceBegin = [total, slices](std::size_t s) { + return (total * s) / slices; + }; + const auto worker = [&](std::size_t begin, std::size_t end) { + for (std::size_t k = begin; k < end; ++k) { + again[k] = terrainNodeMeshData(heightmap, quadtree, nodes[k], false); + } + }; + for (std::size_t s = 1; s < slices; ++s) { + threads.emplace_back(worker, sliceBegin(s), sliceBegin(s + 1)); + } + worker(sliceBegin(0), sliceBegin(1)); + for (std::thread& t : threads) { + t.join(); + } + for (std::size_t k = 0; k < nodes.size() && stableOverRuns; ++k) { + stableOverRuns = + (again[k].vertices.size() == reference[k].vertices.size()) && + std::memcmp(again[k].vertices.data(), reference[k].vertices.data(), + reference[k].vertices.size() * sizeof(Vertex)) == 0; + } + } + check(stableOverRuns, + "Phase 19 : 12 passages paralleles de plus, tous identiques a la reference"); +} + +void testGrassPhase18() { + section("Phase 18 : herbe plus dense et brins decoupes"); + + // --- Le quad est devenu une PLANCHE a decouper ------------------------- + // La silhouette n'est plus portee par le contour du polygone mais par le + // masque de shaders/foliage.frag. Le quad doit donc etre large et peu + // effile, faute de quoi les brins decoupes seraient plus maigres que le + // ruban de la Phase 11 - c'est-a-dire un recul. + const MeshData tuft = grassTuftMeshData(3); + float baseHalfWidth = 0.0f; + float tipHalfWidth = 0.0f; + for (const Vertex& vertex : tuft.vertices) { + const float halfWidth = std::sqrt(vertex.pos.x * vertex.pos.x + + vertex.pos.z * vertex.pos.z); + if (vertex.pos.y < 0.5f) { + baseHalfWidth = std::max(baseHalfWidth, halfWidth); + } else { + tipHalfWidth = std::max(tipHalfWidth, halfWidth); + } + } + check(baseHalfWidth > 0.35f, "Quad large au pied : le masque a la place de decouper"); + check(tipHalfWidth > 0.25f, + "Quad a peine effile : c'est le masque, et non le polygone, qui effile le brin"); + + // --- Densite ---------------------------------------------------------- + SlopedTerrain terrain(1200.0f, 0.0f); + const Frustum frustum = permissiveFrustum(); + const glm::vec3 eye(0.0f, 1200.0f, 0.0f); + ConstantMap dense(1.0f); + ConstantMap lowCanopy(0.0f); + + VegetationParams phase18; + VegetationParams phase11 = phase18; + phase11.grassSlots = 24; // le reglage d'avant la Phase 18 + + std::vector now; + std::vector before; + Vegetation(terrain, &dense, &lowCanopy, 2000.0f, phase18) + .gatherGrass(eye, frustum, now); + Vegetation(terrain, &dense, &lowCanopy, 2000.0f, phase11) + .gatherGrass(eye, frustum, before); + check(!before.empty(), "Temoin Phase 11 : de l'herbe est bien semee"); + check(now.size() > before.size() * 2, + "Phase 18 : plus du DOUBLE de touffes sur la meme vue et la meme carte"); + + // --- La decoupe alpha ne touche pas au SEMIS -------------------------- + // grassCutout est un parametre de RENDU. S'il changeait le nombre de + // touffes, le temoin --no-grass-cutout ne mesurerait plus la decoupe seule + // mais un melange des deux, et la mesure de la phase n'aurait aucune valeur. + VegetationParams opaque = phase18; + opaque.grassCutout = 0.0f; + std::vector opaqueGrass; + Vegetation(terrain, &dense, &lowCanopy, 2000.0f, opaque) + .gatherGrass(eye, frustum, opaqueGrass); + check(opaqueGrass.size() == now.size(), + "grassCutout ne change pas d'une touffe le semis (temoin honnete)"); + + // --- Le pied des touffes reste SUR le sol ------------------------------ + // La hauteur n'est plus echantillonnee par touffe mais interpolee entre les + // quatre coins de la cellule. Sur un plan incline - que les deux triangles + // reproduisent exactement - l'ecart doit etre nul : c'est ce qui prouve que + // l'optimisation n'a pas decolle l'herbe du terrain. + SlopedTerrain ramp(1200.0f, 0.35f); + std::vector onRamp; + Vegetation(ramp, &dense, &lowCanopy, 2000.0f, phase18) + .gatherGrass(glm::vec3(0.0f, 1200.0f, 0.0f), frustum, onRamp); + check(!onRamp.empty(), "De l'herbe pousse aussi sur le versant"); + float worstGap = 0.0f; + for (const InstanceData& blade : onRamp) { + worstGap = std::max(worstGap, + std::abs(blade.position.y - + ramp.heightAt(blade.position.x, blade.position.z))); + } + checkNear(worstGap, 0.0f, 1e-3f, + "Pied pose au sol malgre l'interpolation par cellule (versant a 35 %)"); +} + +void testVegetationPlacement() { + section("Phase 11 : semis de la vegetation de decor"); + + SlopedTerrain terrain(1200.0f, 0.0f); // plat a 1200 m : pente nulle + const Frustum frustum = permissiveFrustum(); + const glm::vec3 eye(0.0f, 1200.0f, 0.0f); + + VegetationParams params; + ConstantMap dense(1.0f); + ConstantMap canopy(20.0f); + + // --- Le couvert commande bien le semis --------------------------------- + { + ConstantMap bare(0.0f); + Vegetation wooded(terrain, &dense, &canopy, 2000.0f, params); + Vegetation empty(terrain, &bare, &canopy, 2000.0f, params); + + std::vector woodedTrees; + std::vector emptyTrees; + gatherTreesUntilStable(wooded, eye, frustum, woodedTrees); + gatherTreesUntilStable(empty, eye, frustum, emptyTrees); + + check(!woodedTrees.empty(), "Couvert a 1 : des arbres sont semes"); + check(emptyTrees.empty(), + "Couvert a 0 : AUCUN arbre - c'est ce qui garde les lapiaz nus"); + } + + // --- Frontiere de foret : le semis reproduit la carte ------------------- + { + HalfCoveredMap half; + Vegetation vegetation(terrain, &half, &canopy, 2000.0f, params); + std::vector trees; + gatherTreesUntilStable(vegetation, eye, frustum, trees); + + check(!trees.empty(), "Carte a deux moities : des arbres sont semes"); + std::size_t west = 0; + for (const InstanceData& tree : trees) { + if (tree.position.x < -params.treeCell) { + ++west; + } + } + check(west == 0, "Aucun arbre du cote NU de la frontiere de couvert"); + } + + // --- Determinisme : meme graine, meme foret ---------------------------- + { + Vegetation a(terrain, &dense, &canopy, 2000.0f, params); + Vegetation b(terrain, &dense, &canopy, 2000.0f, params); + std::vector first; + std::vector second; + gatherTreesUntilStable(a, eye, frustum, first); + gatherTreesUntilStable(b, eye, frustum, second); + + check(first.size() == second.size(), "Meme graine : meme nombre d'arbres"); + bool identical = first.size() == second.size(); + for (std::size_t i = 0; identical && i < first.size(); ++i) { + identical = first[i].position == second[i].position && + first[i].scale == second[i].scale && + first[i].yaw == second[i].yaw; + } + check(identical, "Meme graine : arbres identiques au bit pres"); + } + + // --- Le semis ne depend PAS du chemin parcouru ------------------------- + // C'est la propriete qui autorise a ne rien stocker pour les 25 km2 : une + // cellule decouverte de loin puis approchee doit donner les memes arbres + // qu'une cellule decouverte directement au contact. Un generateur A ETAT + // (mt19937) echouerait ici ; un hachage passe. + { + Vegetation direct(terrain, &dense, &canopy, 2000.0f, params); + Vegetation wandered(terrain, &dense, &canopy, 2000.0f, params); + + std::vector scratch; + gatherTreesUntilStable(wandered, { 700.0f, 1200.0f, -400.0f }, frustum, scratch); + gatherTreesUntilStable(wandered, { -900.0f, 1200.0f, 850.0f }, frustum, scratch); + gatherTreesUntilStable(wandered, { 120.0f, 1200.0f, 60.0f }, frustum, scratch); + + std::vector a; + std::vector b; + gatherTreesUntilStable(direct, eye, frustum, a); + gatherTreesUntilStable(wandered, eye, frustum, b); + + check(a.size() == b.size(), + "Semis independant du chemin : meme nombre d'arbres"); + bool identical = a.size() == b.size(); + for (std::size_t i = 0; identical && i < a.size(); ++i) { + identical = a[i].position == b[i].position && a[i].scale == b[i].scale; + } + check(identical, "Semis independant du chemin : arbres identiques"); + } + + // --- Rien hors des donnees --------------------------------------------- + { + const float extent = 300.0f; + Vegetation vegetation(terrain, &dense, &canopy, extent, params); + std::vector trees; + gatherTreesUntilStable(vegetation, eye, frustum, trees); + bool inside = true; + for (const InstanceData& tree : trees) { + inside = inside && std::abs(tree.position.x) <= extent && + std::abs(tree.position.z) <= extent; + } + check(inside, "Aucun arbre au-dela de l'emprise du terrain"); + } + + // --- Niveau de detail de DENSITE --------------------------------------- + // Les arbres proches doivent etre plus nombreux, PAR UNITE DE SURFACE, que + // les arbres lointains : c'est tout l'objet de la portee par emplacement. + { + Vegetation vegetation(terrain, &dense, &canopy, 4000.0f, params); + std::vector trees; + gatherTreesUntilStable(vegetation, eye, frustum, trees); + + std::size_t near = 0; + std::size_t far = 0; + for (const InstanceData& tree : trees) { + const float d = glm::length(tree.position - eye); + if (d < 200.0f) { + ++near; + } else if (d > 600.0f && d < 1000.0f) { + ++far; + } + } + // On compare des DENSITES et non des comptes bruts : la couronne + // lointaine est bien plus vaste que le disque proche. + const double nearArea = 3.14159 * 200.0 * 200.0; + const double farArea = 3.14159 * (1000.0 * 1000.0 - 600.0 * 600.0); + const double nearDensity = static_cast(near) / nearArea; + const double farDensity = static_cast(far) / farArea; + check(near > 0 && far > 0, "Des arbres proches ET lointains"); + check(nearDensity > farDensity * 1.5, + "Niveau de detail de densite : la foret s'eclaircit avec la distance"); + } + + // --- Attenuation : les plus lointains retrecissent --------------------- + { + Vegetation vegetation(terrain, &dense, &canopy, 4000.0f, params); + std::vector trees; + gatherTreesUntilStable(vegetation, eye, frustum, trees); + bool fadeInRange = true; + bool someFaded = false; + for (const InstanceData& tree : trees) { + fadeInRange = fadeInRange && tree.fade >= 0.0f && tree.fade <= 1.0f; + if (tree.fade < 0.999f) { + someFaded = true; + } + } + check(fadeInRange, "Attenuation toujours dans [0,1]"); + check(someFaded, "Certains arbres lointains sont attenues"); + } + + // --- Substitut sans carte LiDAR ---------------------------------------- + // Sans carte, le semis doit encore produire quelque chose de plausible et + // refuser les hautes altitudes (limite des arbres). + { + SlopedTerrain low(1200.0f, 0.0f); + SlopedTerrain high(2100.0f, 0.0f); + Vegetation belowTreeline(low, nullptr, nullptr, 2000.0f, params); + Vegetation aboveTreeline(high, nullptr, nullptr, 2000.0f, params); + + std::vector lowTrees; + std::vector highTrees; + gatherTreesUntilStable(belowTreeline, { 0.0f, 1200.0f, 0.0f }, frustum, lowTrees); + gatherTreesUntilStable(aboveTreeline, { 0.0f, 2100.0f, 0.0f }, frustum, highTrees); + + check(!lowTrees.empty(), "Substitut : des arbres sous la limite des arbres"); + check(highTrees.empty(), "Substitut : aucun arbre au-dessus de 1950 m"); + } + + // --- Pente : pas d'arbre sur une paroi --------------------------------- + { + SlopedTerrain cliff(1200.0f, 3.0f); // 3 m d'altitude par metre parcouru + Vegetation vegetation(cliff, &dense, &canopy, 2000.0f, params); + std::vector trees; + gatherTreesUntilStable(vegetation, { 0.0f, 1200.0f, 0.0f }, frustum, trees); + check(trees.empty(), "Aucun arbre sur une pente de 3 pour 1"); + } +} + +void testGrassPlacement() { + section("Phase 11 : semis de l'herbe"); + + const Frustum frustum = permissiveFrustum(); + VegetationParams params; + ConstantMap cover(0.5f); + ConstantMap noCanopy(0.0f); + + // --- L'altitude commande la TAILLE et la DENSITE ------------------------ + // C'est la demande explicite de la tache 3 : plus haut = plus petit et plus + // rare (pelouse alpine rase). + auto sampleAt = [&](float altitude, std::vector& out) { + SlopedTerrain terrain(altitude, 0.0f); + Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f, params); + vegetation.gatherGrass({ 0.0f, altitude, 0.0f }, frustum, out); + }; + + std::vector low; + std::vector mid; + std::vector high; + sampleAt(1200.0f, low); // sous grassAltitudeLush : pleine densite + sampleAt(2050.0f, mid); // entre les deux seuils + sampleAt(2400.0f, high); // au-dessus de grassAltitudeBarren + + check(!low.empty(), "De l'herbe en dessous de la limite d'alpage"); + check(high.empty(), "Aucune herbe au-dessus de l'altitude sterile"); + check(mid.size() < low.size(), "L'herbe se rarefie avec l'altitude"); + + auto meanScale = [](const std::vector& tufts) { + double total = 0.0; + for (const InstanceData& tuft : tufts) { + total += tuft.scale; + } + return tufts.empty() ? 0.0 : total / static_cast(tufts.size()); + }; + check(meanScale(mid) < meanScale(low), "Les touffes rapetissent avec l'altitude"); + check(meanScale(low) < params.grassSizeLow * 1.3, + "Taille des touffes coherente avec grassSizeLow"); + + // --- Portee COURTE ------------------------------------------------------ + { + SlopedTerrain terrain(1200.0f, 0.0f); + Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f, params); + std::vector tufts; + const glm::vec3 eye(0.0f, 1200.0f, 0.0f); + vegetation.gatherGrass(eye, frustum, tufts); + float furthest = 0.0f; + for (const InstanceData& tuft : tufts) { + furthest = std::max(furthest, glm::length(tuft.position - eye)); + } + check(furthest <= params.grassDistanceFar + 0.001f, + "Aucune touffe au-dela de la portee de rendu"); + check(furthest > 0.5f * params.grassDistanceFar, + "L'herbe occupe bien sa portee"); + } + + // --- Le placement n'est PAS une grille reguliere ------------------------ + // Le risque explicitement a eviter. Un semis regulier donnerait des + // distances au plus proche voisin toutes egales ; un semis groupe donne une + // large dispersion. On compare l'ecart-type a la moyenne. + { + SlopedTerrain terrain(1200.0f, 0.0f); + Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f, params); + std::vector tufts; + vegetation.gatherGrass({ 0.0f, 1200.0f, 0.0f }, frustum, tufts); + + check(tufts.size() > 200, "Assez de touffes pour juger de la repartition"); + + // Distance au plus proche voisin, sur un echantillon (le calcul est + // quadratique). + const std::size_t sampleCount = + std::min(150, tufts.size()); + std::vector nearest; + nearest.reserve(sampleCount); + for (std::size_t i = 0; i < sampleCount; ++i) { + float best = 1.0e9f; + for (std::size_t j = 0; j < tufts.size(); ++j) { + if (i == j) { + continue; + } + best = std::min(best, horizontalDistance(tufts[i].position, + tufts[j].position)); + } + nearest.push_back(best); + } + double mean = 0.0; + for (float value : nearest) { + mean += value; + } + mean /= static_cast(nearest.size()); + double variance = 0.0; + for (float value : nearest) { + variance += (value - mean) * (value - mean); + } + variance /= static_cast(nearest.size()); + const double deviation = std::sqrt(variance); + + // Sur une grille PARFAITE toutes les distances seraient egales et + // l'ecart-type nul. On exige une dispersion d'au moins 25 % de la + // moyenne : c'est la signature d'un placement groupe. + check(deviation > 0.25 * mean, + "Placement groupe et non regulier (dispersion du plus proche voisin)"); + } + + // --- Determinisme ------------------------------------------------------- + { + SlopedTerrain terrain(1200.0f, 0.0f); + Vegetation a(terrain, &cover, &noCanopy, 4000.0f, params); + Vegetation b(terrain, &cover, &noCanopy, 4000.0f, params); + std::vector first; + std::vector second; + a.gatherGrass({ 12.0f, 1200.0f, -7.0f }, frustum, first); + b.gatherGrass({ 12.0f, 1200.0f, -7.0f }, frustum, second); + check(first.size() == second.size() && !first.empty(), + "Meme graine : meme herbe"); + } +} + +void testInstanceLayout() { + section("Phase 11 : format d'instance"); + + // Ces proprietes sont SUPPOSEES par VertexFormat.hpp, qui lit (scale, yaw) + // et (variation, fade) comme des vec2. Un membre insere entre les deux + // ferait lire n'importe quoi par le GPU, en silence. + check(sizeof(InstanceData) == 28, "InstanceData tient en 28 octets"); + check(offsetof(InstanceData, yaw) == offsetof(InstanceData, scale) + sizeof(float), + "scale et yaw contigus"); + check(offsetof(InstanceData, fade) == offsetof(InstanceData, variation) + sizeof(float), + "variation et fade contigus"); + + // Valeurs par defaut NEUTRES : une instance non renseignee doit etre visible + // a sa taille normale, pas invisible. + const InstanceData fresh; + checkNear(fresh.scale, 1.0f, 1e-6f, "Echelle par defaut a 1"); + checkNear(fresh.fade, 1.0f, 1e-6f, "Attenuation par defaut a 1"); +} + +} // namespace + +// --------------------------------------------------------------------------- +// Phase 12 : chaine de peres du quadtree et repli sur l'ancetre +// --------------------------------------------------------------------------- +// Le repli sur l'ancetre vit dans TerrainStreamer, qui pilote le Renderer donc +// Vulkan : il n'est pas testable ici. Ce qui l'EST, et qui est ce dont il +// depend entierement, c'est la structure sur laquelle il s'appuie - la chaine de +// peres et la description d'un noeud hors selection. Une erreur a ce niveau +// (chainage casse par une reallocation de nodes_, boucle, morphing different de +// celui de la selection) donnerait un repli silencieusement faux. +void testQuadtreeAncestry() { + section("Phase 12 : chaine de peres et repli sur l'ancetre"); + + Heightmap::Params params; + params.resolution = 513; + params.worldSize = 512.0f; + params.seed = 4242u; + Heightmap heightmap(params); + + TerrainQuadtree quadtree(heightmap); + + // --- La chaine de peres est complete et coherente ------------------------ + { + uint32_t roots = 0; + bool levelsIncrease = true; + bool childOfItsParent = true; + uint32_t maxDepth = 0; + + for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) { + const int32_t parent = quadtree.parentIndex(index); + if (parent < 0) { + ++roots; + continue; + } + const TerrainQuadtree::Node& node = quadtree.node(index); + const TerrainQuadtree::Node& up = quadtree.node(static_cast(parent)); + + // Le pere est exactement un niveau au-dessus. + if (up.level != node.level + 1) { + levelsIncrease = false; + } + // ... et il reconnait bien ce fils. C'est ce test qui attraperait un + // chainage pose sur une reference devenue pendante apres + // reallocation de nodes_ pendant la construction recursive. + bool found = false; + for (int i = 0; i < 4; ++i) { + if (up.children[i] == static_cast(index)) { + found = true; + } + } + if (!found) { + childOfItsParent = false; + } + + // Remontee : elle doit se terminer, et sur la racine. + uint32_t depth = 0; + int32_t current = parent; + while (current >= 0 && depth <= quadtree.rootLevel() + 1u) { + current = quadtree.parentIndex(static_cast(current)); + ++depth; + } + maxDepth = std::max(maxDepth, depth); + } + + check(roots == 1, "Chaine de peres : un seul noeud sans pere (la racine)"); + check(levelsIncrease, "Chaine de peres : le pere est toujours au niveau du dessus"); + check(childOfItsParent, "Chaine de peres : chaque noeud est bien un fils de son pere"); + check(maxDepth <= quadtree.rootLevel(), + "Chaine de peres : la remontee se termine, en au plus rootLevel etapes"); + } + + // --- La boite d'un ancetre contient bien celle de ses descendants -------- + // C'est LA propriete qui rend le repli correct : dessiner l'ancetre a la + // place d'un descendant couvre au moins la meme surface. + { + bool contains = true; + for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) { + const int32_t parent = quadtree.parentIndex(index); + if (parent < 0) { + continue; + } + const TerrainQuadtree::Node& node = quadtree.node(index); + const TerrainQuadtree::Node& up = quadtree.node(static_cast(parent)); + // Emprise horizontale seulement : c'est la couverture du sol qui + // compte pour un trou, et les bornes verticales remontent deja des + // fils par construction. + if (node.boundsMin.x < up.boundsMin.x || node.boundsMin.z < up.boundsMin.z || + node.boundsMax.x > up.boundsMax.x || node.boundsMax.z > up.boundsMax.z) { + contains = false; + } + } + check(contains, + "Repli : l'emprise d'un pere contient celle de chacun de ses fils"); + } + + // --- describeNode redit exactement ce que dit la selection --------------- + // Un ancetre dessine par repli doit recevoir la MEME bande de geomorphing + // que s'il avait ete selectionne normalement, sinon la geometrie sauterait + // au moment ou le repli cesse. + { + const glm::vec3 eye(3.0f, 40.0f, 7.0f); + const Frustum everything = Frustum::fromViewProjection(glm::mat4(0.0f)); + std::vector selection; + quadtree.select(eye, everything, selection); + + check(!selection.empty(), "Repli : la selection de reference n'est pas vide"); + + bool identical = true; + for (const TerrainQuadtree::SelectedNode& selected : selection) { + const TerrainQuadtree::SelectedNode described = + quadtree.describeNode(selected.nodeIndex, eye); + if (described.level != selected.level || + described.morphStart != selected.morphStart || + described.morphEnd != selected.morphEnd || + described.distance != selected.distance) { + identical = false; + } + } + check(identical, + "Repli : describeNode redonne au bit pres ce que produit select()"); + + // Et pour un noeud que la selection n'a PAS retenu (un ancetre, justement), + // la bande de morphing suit bien la portee de SON niveau. + const uint32_t leaf = selection.front().nodeIndex; + const int32_t up = quadtree.parentIndex(leaf); + check(up >= 0, "Repli : la tuile la plus proche a bien un pere"); + if (up >= 0) { + const TerrainQuadtree::SelectedNode described = + quadtree.describeNode(static_cast(up), eye); + checkNear(described.morphStart, + quadtree.range(described.level) * quadtree.params().morphStartRatio, + 1e-3f, "Repli : la bande de morphing de l'ancetre suit SON niveau"); + check(described.level == quadtree.node(leaf).level + 1, + "Repli : l'ancetre immediat est bien un niveau plus grossier"); + } + } + + // --- Le sommet du quadtree est peu peuple -------------------------------- + // Le TerrainStreamer epingle les trois niveaux les plus grossiers pour que le + // repli soit toujours disponible. Ce n'est defendable que si ces niveaux + // comptent une poignee de tuiles : ce test fige cette hypothese. + { + uint32_t top = 0; + const int lowest = std::max(0, static_cast(quadtree.rootLevel()) - 2); + for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) { + if (static_cast(quadtree.node(index).level) >= lowest) { + ++top; + } + } + check(top <= 21, + "Sommet epingle : au plus 21 tuiles sur les trois niveaux les plus grossiers"); + check(top >= 1, "Sommet epingle : au moins la racine"); + } +} + +// =========================================================================== +// PHASE 15 : editeur de niveau +// =========================================================================== +// Ce que ce bloc couvre, et pourquoi il peut le couvrir sans GPU : TOUT +// l'editeur sauf le dessin. Le catalogue produit des MeshData, la scene et le +// controleur ne dependent que de GLM, le format de scene ne depend que de la +// bibliotheque standard, et le raycast terrain ne connait que HeightSampler. +// C'est le meme decoupage qui avait permis de tester la physique du parapente, +// du velo et de l'escalade sans fenetre. +// +// Ce qui n'est PAS couvert ici et ne peut pas l'etre : le fantome REELLEMENT +// dessine a l'ecran, la teinte de temoin, et la lecture du clavier. + +// Terrain georeference et parfaitement previsible : l'altitude ne depend que de +// X et vaut 400 + (x + 50), donc 400 au bord ouest et 500 au bord est. +// +// Construit par le constructeur "grille toute faite" - celui par lequel entrent +// les dalles LiDAR - et non par le generateur de bruit : les tests de scene +// verifient des CONVERSIONS DE COORDONNEES au millimetre, ce qui exige de savoir +// exactement quelle altitude repond le terrain, y compris apres un changement de +// resolution. +Heightmap makeGeoTerrain(uint32_t resolution, float spacing) { + std::vector heights(static_cast(resolution) * resolution, 0.0f); + for (uint32_t iz = 0; iz < resolution; ++iz) { + for (uint32_t ix = 0; ix < resolution; ++ix) { + heights[static_cast(iz) * resolution + ix] = + 400.0f + static_cast(ix) * spacing; + } + } + GeoReference geo; + geo.originEast = 907000.0; + geo.originNorth = 6440000.0; + geo.epsg = 2154; + geo.absoluteAltitude = true; + return Heightmap(std::move(heights), resolution, spacing, "terrain de test", geo); +} + +// Ecrit un .obj minimal (tetraedre), pour exercer le SCAN du catalogue par le +// vrai loader de la Phase 3 plutot que par un substitut. +void writeTestObj(const std::filesystem::path& path, float scale) { + std::ofstream file(path); + file << "# asset de test\n" + << "v 0 0 0\n" + << "v " << scale << " 0 0\n" + << "v 0 0 " << scale << "\n" + << "v 0 " << scale << " 0\n" + << "f 1 2 3\n" + << "f 1 2 4\n" + << "f 2 3 4\n" + << "f 1 3 4\n"; +} + +// Boite englobante d'un MeshData, pour verifier la convention d'ancrage. +void meshBounds(const MeshData& mesh, glm::vec3* minOut, glm::vec3* maxOut) { + glm::vec3 lo(std::numeric_limits::max()); + glm::vec3 hi(std::numeric_limits::lowest()); + for (const Vertex& vertex : mesh.vertices) { + lo = glm::min(lo, vertex.pos); + hi = glm::max(hi, vertex.pos); + } + *minOut = lo; + *maxOut = hi; +} + +void testEditorAssets() { + section("Phase 15 : assets generes et convention d'ancrage"); + + check(builtinEditorAssets().size() >= 5, + "Assets : au moins cinq modeles generes en code"); + + for (const BuiltinAsset& builtin : builtinEditorAssets()) { + const MeshData mesh = builtin.build(); + check(!mesh.empty(), "Asset \"" + builtin.id + "\" : geometrie non vide"); + check(mesh.indices.size() % 3 == 0, + "Asset \"" + builtin.id + "\" : indices multiples de 3"); + + glm::vec3 lo(0.0f); + glm::vec3 hi(0.0f); + meshBounds(mesh, &lo, &hi); + + // Le PIED est a zero : c'est ce qui rend "poser au point vise" exact. + checkNear(lo.y, 0.0f, 1e-4f, "Asset \"" + builtin.id + "\" : pied a y = 0"); + check(hi.y > 0.05f, "Asset \"" + builtin.id + "\" : hauteur non nulle"); + + // L'ancrage tombe DANS l'empreinte horizontale, pas a cote : un objet + // pose entoure le point vise. + // + // Volontairement plus faible qu'un centrage exact sur la boite + // englobante. Le poteau de balisage a son MAT a l'origine et sa plaque + // qui deborde vers +X : sa boite n'est pas centree, et elle ne doit pas + // l'etre - planter un panneau, c'est planter le mat au point vise, pas y + // placer le milieu de l'ensemble mat + panneau. Voir la note + // "ancrage n'est pas centrage" dans editor/EditorAssets.hpp. + check(lo.x <= 1e-4f && hi.x >= -1e-4f, + "Asset \"" + builtin.id + "\" : ancrage dans l'empreinte en X"); + check(lo.z <= 1e-4f && hi.z >= -1e-4f, + "Asset \"" + builtin.id + "\" : ancrage dans l'empreinte en Z"); + // Et pas au bord non plus : l'ancrage reste dans la moitie centrale de + // l'empreinte, sinon l'objet se poserait visiblement de travers. + check(std::abs(0.5f * (lo.x + hi.x)) <= 0.5f * std::max(std::abs(lo.x), hi.x), + "Asset \"" + builtin.id + "\" : ancrage pas au bord en X"); + check(std::abs(0.5f * (lo.z + hi.z)) <= 0.5f * std::max(std::abs(lo.z), hi.z), + "Asset \"" + builtin.id + "\" : ancrage pas au bord en Z"); + + // Toutes les normales sont unitaires : une normale nulle donnerait un + // triangle noir, et le facettage en produit une par triangle. + bool normalsOk = true; + for (const Vertex& vertex : mesh.vertices) { + normalsOk = normalsOk && std::abs(glm::length(vertex.normal) - 1.0f) < 1e-3f; + } + check(normalsOk, "Asset \"" + builtin.id + "\" : normales unitaires"); + } + + // DETERMINISME. Les rochers sont deformes par HACHAGE de l'indice de sommet + // et non par un generateur a etat (meme lecon qu'en Phase 11) : deux appels + // doivent donner la meme geometrie au bit pres. Ca compte parce que + // l'empreinte de COLLISION est deduite de la boite englobante du mesh - une + // geometrie qui varierait donnerait une collision qui varie, et une scene + // sauvegardee ne se rechargerait pas a l'identique. + const MeshData first = editorBoulderMeshData(); + const MeshData second = editorBoulderMeshData(); + bool identical = first.vertices.size() == second.vertices.size(); + for (std::size_t i = 0; identical && i < first.vertices.size(); ++i) { + identical = std::memcmp(&first.vertices[i].pos, &second.vertices[i].pos, + sizeof(glm::vec3)) == 0; + } + check(identical, "Assets : le rocher est identique au bit pres a chaque appel"); +} + +void testAssetCatalog() { + section("Phase 15 : catalogue d'assets"); + + { + AssetCatalog catalog; + catalog.addBuiltins(); + check(catalog.size() == builtinEditorAssets().size(), + "Catalogue : tous les builtins ajoutes"); + check(catalog.indexOf("rocher") >= 0, "Catalogue : \"rocher\" retrouve par nom"); + check(catalog.indexOf("inexistant") < 0, "Catalogue : nom inconnu -> -1"); + + const AssetEntry& boulder = + catalog.entries()[static_cast(catalog.indexOf("rocher"))]; + check(boulder.height > 0.5f && boulder.height < 4.0f, + "Catalogue : hauteur du rocher plausible"); + // Cylindre CONTENANT : le rayon est la demi-diagonale horizontale, donc + // au moins aussi grand que la plus grande demi-etendue. + check(boulder.collisionRadius >= + std::max(boulder.halfExtentX, boulder.halfExtentZ) - 1e-4f, + "Catalogue : le rayon de collision contient la boite"); + check(boulder.sourcePath.empty(), "Catalogue : un builtin n'a pas de fichier source"); + + // Deuxieme appel : les identifiants sont deja pris, rien ne doit doubler. + catalog.addBuiltins(); + check(catalog.size() == builtinEditorAssets().size(), + "Catalogue : les doublons d'identifiant sont refuses"); + } + + // --- sanitizeAssetId ---------------------------------------------------- + check(sanitizeAssetId("Gros Rocher") == "gros_rocher", + "Catalogue : espaces et majuscules normalises"); + check(sanitizeAssetId("mur-de-pierre.v2") == "mur-de-pierre.v2", + "Catalogue : tiret et point conserves"); + check(sanitizeAssetId("") == "asset", "Catalogue : identifiant vide remplace"); + + // --- normalizeAssetMesh ------------------------------------------------- + { + MeshData mesh; + for (const glm::vec3 position : { glm::vec3(10.0f, 5.0f, -3.0f), + glm::vec3(12.0f, 9.0f, -1.0f), + glm::vec3(11.0f, 5.0f, -2.0f) }) { + Vertex vertex{}; + vertex.pos = position; + vertex.normal = glm::vec3(0.0f, 1.0f, 0.0f); + mesh.vertices.push_back(vertex); + } + mesh.indices = { 0, 1, 2 }; + normalizeAssetMesh(mesh); + + glm::vec3 lo(0.0f); + glm::vec3 hi(0.0f); + meshBounds(mesh, &lo, &hi); + checkNear(lo.y, 0.0f, 1e-5f, "Normalisation : pied ramene a y = 0"); + checkNear(0.5f * (lo.x + hi.x), 0.0f, 1e-5f, "Normalisation : recentre en X"); + checkNear(0.5f * (lo.z + hi.z), 0.0f, 1e-5f, "Normalisation : recentre en Z"); + // La FORME ne bouge pas : seule l'origine change. + checkNear(hi.y - lo.y, 4.0f, 1e-5f, "Normalisation : hauteur inchangee"); + } + + // --- scanDirectory ------------------------------------------------------ + { + namespace fs = std::filesystem; + const fs::path directory = + fs::temp_directory_path() / "vercora_p15_catalogue"; + std::error_code ec; + fs::remove_all(directory, ec); + fs::create_directories(directory, ec); + + writeTestObj(directory / "b_deuxieme.obj", 2.0f); + writeTestObj(directory / "a_premier.obj", 1.0f); + // Un fichier illisible ne doit priver l'editeur d'AUCUN autre modele. + { + std::ofstream broken(directory / "c_casse.obj"); + broken << "ceci n'est pas un maillage\nf 1 2 3\n"; + } + // Une extension non reconnue est simplement ignoree. + { + std::ofstream note(directory / "notes.txt"); + note << "rien a voir"; + } + + AssetCatalog catalog; + catalog.addBuiltins(); + const std::size_t builtinCount = catalog.size(); + const uint32_t added = catalog.scanDirectory(directory.string()); + + check(added == 2, "Catalogue : deux modeles valides charges sur trois .obj"); + check(catalog.size() == builtinCount + 2, + "Catalogue : le fichier casse n'a pas interrompu le scan"); + check(catalog.indexOf("a_premier") >= 0, "Catalogue : identifiant tire du nom de fichier"); + check(catalog.indexOf("notes") < 0, "Catalogue : extension non reconnue ignoree"); + // ORDRE : les fichiers sont tries par nom. Les touches 1..9 de l'editeur + // designent des rangs dans cette liste, et directory_iterator ne garantit + // aucun ordre - sans le tri, la meme touche poserait un modele different + // d'une execution a l'autre. + check(catalog.indexOf("a_premier") < catalog.indexOf("b_deuxieme"), + "Catalogue : les fichiers scannes sont tries par nom"); + // Le scan applique la convention d'ancrage a un fichier qui ne la + // respectait pas (le tetraedre a son origine dans un coin). + const AssetEntry& scanned = + catalog.entries()[static_cast(catalog.indexOf("b_deuxieme"))]; + glm::vec3 lo(0.0f); + glm::vec3 hi(0.0f); + meshBounds(scanned.mesh, &lo, &hi); + checkNear(lo.y, 0.0f, 1e-4f, "Catalogue : modele scanne repose sur y = 0"); + checkNear(0.5f * (lo.x + hi.x), 0.0f, 1e-4f, "Catalogue : modele scanne recentre"); + check(!scanned.sourcePath.empty(), "Catalogue : chemin d'origine conserve"); + + // Un dossier absent n'est pas une erreur : l'editeur doit demarrer avec + // les seuls builtins. + AssetCatalog empty; + empty.addBuiltins(); + check(empty.scanDirectory((directory / "nexiste_pas").string()) == 0, + "Catalogue : dossier absent -> zero modele, pas d'erreur"); + check(empty.size() == builtinCount, "Catalogue : builtins intacts"); + + fs::remove_all(directory, ec); + } +} + +void testTerrainRaycast() { + section("Phase 15 : intersection rayon / terrain"); + + { + const FlatTerrain flat(0.0f); + // Oeil a 10 m, regard a 45 degres vers le bas : la surface est atteinte + // a 10 m devant, donc a 10*sqrt(2) le long du rayon. + const glm::vec3 eye(0.0f, 10.0f, 0.0f); + const glm::vec3 direction = glm::normalize(glm::vec3(0.0f, -1.0f, -1.0f)); + const TerrainRayHit hit = raycastTerrain(flat, eye, direction, 400.0f, 1000.0f); + check(hit.hit, "Raycast : la surface plate est touchee"); + checkNear(hit.distance, 14.1421f, 0.01f, "Raycast : distance le long du rayon"); + checkNear(hit.position.z, -10.0f, 0.01f, "Raycast : point d'impact en Z"); + checkNear(hit.position.y, 0.0f, 1e-3f, "Raycast : le point est SUR la surface"); + } + + { + // Regard vers le HAUT : rien a toucher. C'est ce qui fait que viser le + // ciel ne pose aucun objet, au lieu d'en poser un a distance arbitraire. + const FlatTerrain flat(0.0f); + const TerrainRayHit hit = + raycastTerrain(flat, glm::vec3(0.0f, 10.0f, 0.0f), + glm::normalize(glm::vec3(0.0f, 1.0f, -1.0f)), 400.0f, 1000.0f); + check(!hit.hit, "Raycast : un regard vers le ciel ne touche rien"); + } + + { + // L'EMPRISE compte. heightAt est TOTALE par contrat (hors donnees elle + // prolonge le bord), donc sans halfExtent un rayon partant vers + // l'exterieur accrocherait une etagere plate infinie. + const FlatTerrain flat(0.0f); + const glm::vec3 eye(0.0f, 10.0f, 0.0f); + const glm::vec3 direction = glm::normalize(glm::vec3(0.0f, -0.05f, -1.0f)); + const TerrainRayHit bounded = + raycastTerrain(flat, eye, direction, 400.0f, 50.0f); + const TerrainRayHit unbounded = + raycastTerrain(flat, eye, direction, 400.0f, 0.0f); + check(!bounded.hit, "Raycast : hors emprise -> aucun impact"); + check(unbounded.hit, "Raycast : sans emprise declaree, le bord prolonge touche"); + } + + { + // Oeil DEJA sous la surface (vol libre dans le relief) : on rend le point + // de depart projete sur la surface plutot que rien du tout. + const FlatTerrain flat(100.0f); + const TerrainRayHit hit = + raycastTerrain(flat, glm::vec3(3.0f, 90.0f, 4.0f), + glm::vec3(0.0f, 0.0f, -1.0f), 400.0f, 1000.0f); + check(hit.hit, "Raycast : oeil sous la surface -> impact"); + checkNear(hit.distance, 0.0f, 1e-5f, "Raycast : impact a distance nulle"); + checkNear(hit.position.y, 100.0f, 1e-4f, "Raycast : projete sur la surface"); + } + + { + // Pente reelle : le point rendu doit etre sur la surface, quelle que + // soit son inclinaison. + const SlopedTerrain slope(0.0f, 0.40f); // 40 % vers +X + const glm::vec3 eye(-30.0f, 20.0f, 0.0f); + const glm::vec3 direction = glm::normalize(glm::vec3(1.0f, -0.35f, 0.0f)); + const TerrainRayHit hit = raycastTerrain(slope, eye, direction, 400.0f, 1000.0f); + check(hit.hit, "Raycast : la pente est touchee"); + checkNear(hit.position.y, slope.heightAt(hit.position.x, hit.position.z), 1e-2f, + "Raycast : le point d'impact est sur la pente"); + } + + { + // Normale de surface : sur une pente de 40 % vers +X, elle penche vers + // l'aval (composante X negative) et reste unitaire. + const SlopedTerrain slope(0.0f, 0.40f); + const glm::vec3 normal = terrainNormalAt(slope, 0.0f, 0.0f); + checkNear(glm::length(normal), 1.0f, 1e-4f, "Normale de terrain : unitaire"); + check(normal.x < -0.3f, "Normale de terrain : penchee vers l'aval"); + checkNear(normal.z, 0.0f, 1e-4f, "Normale de terrain : rien selon Z sur cette pente"); + } +} + +void testEditorScene() { + section("Phase 15 : scene editable, selection et annulation"); + + AssetCatalog catalog; + catalog.addBuiltins(); + EditorScene scene(&catalog); + + const auto makeObject = [](const char* asset, float x, float z) { + PlacedObject object; + object.asset = asset; + object.position = { x, 0.0f, z }; + return object; + }; + + const uint32_t a = scene.place(makeObject("rocher", 0.0f, 0.0f)); + const uint32_t b = scene.place(makeObject("cairn", 10.0f, 0.0f)); + const uint32_t c = scene.place(makeObject("poteau", 20.0f, 0.0f)); + check(scene.size() == 3, "Scene : trois objets poses"); + check(a != b && b != c, "Scene : les identifiants sont distincts"); + check(scene.find(b) != nullptr && scene.find(b)->asset == "cairn", + "Scene : retrouve un objet par identifiant"); + check(scene.find(9999) == nullptr, "Scene : identifiant inconnu -> nullptr"); + + // --- Suppression au MILIEU, puis annulation -------------------------- + // Le cas qui distingue une pile d'annulation correcte d'une pile naive : + // l'objet doit reprendre SA PLACE dans la liste, pas atterrir a la fin. + check(scene.erase(b), "Scene : suppression d'un objet du milieu"); + check(scene.size() == 2, "Scene : il en reste deux"); + check(scene.undo(), "Scene : annulation de la suppression"); + check(scene.size() == 3, "Scene : l'objet est revenu"); + check(scene.objects()[1].id == b, "Scene : il a repris SON indice, pas la fin"); + + // --- Annulation d'une pose ------------------------------------------ + check(scene.undo(), "Scene : annulation de la pose du poteau"); + check(scene.size() == 2 && scene.find(c) == nullptr, + "Scene : le poteau a disparu"); + + // --- Regroupement des retouches ------------------------------------- + // Vingt petites rotations dans la meme seconde ne doivent laisser QU'UNE + // annulation : sans ce regroupement, "annuler" ne rendrait jamais l'etat + // d'avant la manipulation, qui est pourtant la seule chose qu'on veut. + const std::size_t depthBefore = scene.undoDepth(); + for (int i = 0; i < 20; ++i) { + PlacedObject updated = *scene.find(a); + updated.yawDegrees += 5.0f; + scene.transform(a, updated, 100.0f + 0.01f * static_cast(i)); + } + checkNear(scene.find(a)->yawDegrees, 100.0f, 1e-3f, "Scene : 20 x 5 degres appliques"); + check(scene.undoDepth() == depthBefore + 1, + "Scene : les retouches rapprochees ne font qu'UNE annulation"); + check(scene.undo(), "Scene : annulation du reglage"); + checkNear(scene.find(a)->yawDegrees, 0.0f, 1e-3f, + "Scene : le cap d'AVANT toute la manipulation est rendu"); + + // Deux retouches ESPACEES restent deux annulations distinctes : le + // regroupement ne doit pas avaler un geste separe. + { + const std::size_t before = scene.undoDepth(); + PlacedObject updated = *scene.find(a); + updated.scale = 2.0f; + scene.transform(a, updated, 200.0f); + updated.scale = 3.0f; + scene.transform(a, updated, 260.0f); // une minute plus tard + check(scene.undoDepth() == before + 2, + "Scene : deux retouches espacees = deux annulations"); + scene.undo(); + checkNear(scene.find(a)->scale, 2.0f, 1e-4f, "Scene : retour a l'echelle intermediaire"); + scene.undo(); + checkNear(scene.find(a)->scale, 1.0f, 1e-4f, "Scene : retour a l'echelle d'origine"); + } + + // transform() ne peut PAS changer l'asset ni l'identite, meme si l'appelant + // le lui demande : c'est l'invariant qui rend la scene incassable de + // l'exterieur. + { + PlacedObject hostile = *scene.find(a); + hostile.asset = "abri"; + hostile.id = 4321; + hostile.scale = -5.0f; // echelle invalide + scene.transform(a, hostile, 400.0f); + check(scene.find(a) != nullptr && scene.find(a)->asset == "rocher", + "Scene : transform() ne change ni l'asset ni l'identifiant"); + check(scene.find(a)->scale > 0.0f, "Scene : une echelle invalide est corrigee"); + } + + // --- replaceAll : renumerotation et pile videe ----------------------- + { + std::vector loaded; + loaded.push_back(makeObject("rocher", 1.0f, 1.0f)); + loaded.push_back(makeObject("bloc", 2.0f, 2.0f)); + scene.replaceAll(loaded); + check(scene.size() == 2, "Scene : contenu remplace"); + check(scene.undoDepth() == 0, + "Scene : la pile d'annulation est videe par un chargement"); + check(scene.objects()[0].id == 1 && scene.objects()[1].id == 2, + "Scene : identifiants renumerotes dans l'ordre du fichier"); + check(!scene.undo(), "Scene : plus rien a annuler"); + } + + // --- Profondeur bornee ------------------------------------------------ + // On jette la PLUS ANCIENNE, jamais la plus recente : une pile bornee doit + // continuer d'annuler ce qu'on vient de faire. + { + EditorScene deep(&catalog); + for (std::size_t i = 0; i < EditorScene::kMaxUndoDepth + 20; ++i) { + deep.place(makeObject("rocher", static_cast(i), 0.0f)); + } + check(deep.undoDepth() == EditorScene::kMaxUndoDepth, + "Scene : la pile d'annulation est bornee"); + const std::size_t sizeBefore = deep.size(); + check(deep.undo() && deep.size() == sizeBefore - 1, + "Scene : la derniere action reste annulable malgre la borne"); + } +} + +void testEditorSceneCollision() { + section("Phase 15 : collision des objets poses"); + + AssetCatalog catalog; + catalog.addBuiltins(); + const AssetEntry& boulder = + catalog.entries()[static_cast(catalog.indexOf("rocher"))]; + + EditorScene scene(&catalog); + PlacedObject rock; + rock.asset = "rocher"; + rock.position = { 0.0f, 0.0f, 0.0f }; + rock.solid = true; + scene.place(rock); + + BodyCylinder body; + body.radius = 0.35f; + body.feetY = 0.0f; + body.headY = 1.7f; + + // Le joueur veut traverser le rocher : il doit etre repousse HORS du + // cylindre, exactement comme contre un tronc depuis la Phase 6. + body.position = { 0.1f, 1.7f, 0.0f }; + check(scene.overlaps(body), "Collision : le joueur chevauche le rocher"); + const glm::vec3 pushed = scene.resolve(body); + const float distance = std::sqrt(pushed.x * pushed.x + pushed.z * pushed.z); + check(distance >= boulder.collisionRadius + body.radius - 1e-3f, + "Collision : repousse juste en dehors du cylindre"); + + // Le resultat du repoussement doit etre LIBRE, sinon moveBody() refuserait + // tout deplacement le long du rocher au lieu de laisser glisser. C'est la + // raison de la marge d'un dixieme de millimetre dans overlaps(). + BodyCylinder probe = body; + probe.position = pushed; + check(!scene.overlaps(probe), "Collision : la position repoussee est libre"); + + // Loin : rien ne bouge. + body.position = { 40.0f, 1.7f, 0.0f }; + check(!scene.overlaps(body), "Collision : pas de contact a 40 m"); + checkNear(scene.resolve(body).x, 40.0f, 1e-5f, "Collision : position intacte au loin"); + + // Au-DESSUS de l'objet : pas de contact. Meme regle que pour les souches - + // c'est ce qui permettra de passer sur un rocher plutot qu'a travers. + body.position = { 0.0f, 60.0f, 0.0f }; + body.feetY = 58.3f; + body.headY = 60.15f; + check(!scene.overlaps(body), "Collision : rien a 58 m au-dessus du rocher"); + + // TRAVERSABLE : le drapeau par objet est la seule reponse immediate au cas + // ou le cylindre englobant est faux (un abri a un interieur). + { + EditorScene ghostly(&catalog); + PlacedObject shelter; + shelter.asset = "abri"; + shelter.solid = false; + ghostly.place(shelter); + BodyCylinder inside; + inside.radius = 0.35f; + inside.feetY = 0.0f; + inside.headY = 1.7f; + inside.position = { 0.0f, 1.7f, 0.0f }; + check(!ghostly.overlaps(inside), "Collision : un objet traversable ne bloque pas"); + check(ghostly.solidCount() == 0, "Collision : compte des objets solides"); + } + + // ASSET INCONNU : sans dimensions on ne peut pas inventer une empreinte. + { + EditorScene orphan(&catalog); + PlacedObject unknown; + unknown.asset = "modele_disparu"; + unknown.solid = true; + orphan.place(unknown); + BodyCylinder here; + here.radius = 0.35f; + here.feetY = 0.0f; + here.headY = 1.7f; + here.position = { 0.0f, 1.7f, 0.0f }; + check(!orphan.overlaps(here), + "Collision : un asset absent du catalogue ne bloque pas"); + } + + // --- Solveur COMPOSITE : foret + editeur -------------------------------- + // Le vrai chemin du jeu depuis la Phase 15. On verifie que les deux sources + // d'obstacles bloquent toutes les deux, par le meme moveBody(). + { + FlatTerrain flat(0.0f); + Ground ground(flat); + ForestParams noTrees; + noTrees.treeCount = 0; + Forest forest(flat, ground, 100.0f, noTrees); + forest.plantTree(6.0f, 0.0f, 8.0f); + + CompositeCollisionSolver composite; + composite.add(&forest); + composite.add(&scene); + check(composite.size() == 2, "Composite : deux solveurs enregistres"); + + BodyCylinder walker; + walker.radius = 0.35f; + walker.feetY = 0.0f; + walker.headY = 1.7f; + + // Contre le ROCHER de l'editeur. + walker.position = { 0.05f, 1.7f, 0.0f }; + check(composite.overlaps(walker), "Composite : le rocher de l'editeur bloque"); + const glm::vec3 outOfRock = + moveBody(composite, walker, glm::vec3(-8.0f, 1.7f, 0.0f)); + BodyCylinder after = walker; + after.position = outOfRock; + check(!composite.overlaps(after), "Composite : moveBody sort du rocher"); + + // Contre le TRONC de la foret, inchange depuis la Phase 6. + walker.position = { 6.0f, 1.7f, 0.0f }; + check(composite.overlaps(walker), "Composite : le tronc bloque toujours"); + + // Entre les deux : libre. + walker.position = { 3.0f, 1.7f, 0.0f }; + check(!composite.overlaps(walker), "Composite : passage libre entre les deux"); + + // Un composite VIDE est totalement transparent : c'est le contrat de + // CollisionSolver ("une implementation qui n'a rien a dire renvoie la + // position telle quelle"). + CompositeCollisionSolver nothing; + check(!nothing.overlaps(walker), "Composite : vide -> aucun obstacle"); + checkNear(nothing.resolve(walker).x, 3.0f, 1e-6f, + "Composite : vide -> position inchangee"); + } +} + +void testEditorScenePick() { + section("Phase 15 : visee des objets poses"); + + AssetCatalog catalog; + catalog.addBuiltins(); + EditorScene scene(&catalog); + + PlacedObject near; + near.asset = "rocher"; + near.position = { 0.0f, 0.0f, -10.0f }; + const uint32_t nearId = scene.place(near); + + PlacedObject far; + far.asset = "rocher"; + far.position = { 0.0f, 0.0f, -30.0f }; + const uint32_t farId = scene.place(far); + + const glm::vec3 eye(0.0f, 0.9f, 0.0f); + const glm::vec3 ahead(0.0f, 0.0f, -1.0f); + + check(scene.pick(eye, ahead, 100.0f) == nearId, + "Visee : le PLUS PROCHE des deux est touche"); + check(scene.pick(eye, ahead, 5.0f) == kNoPlacedObject, + "Visee : hors de portee -> rien"); + check(scene.pick(glm::vec3(30.0f, 0.9f, 0.0f), ahead, 100.0f) == kNoPlacedObject, + "Visee : a cote -> rien"); + + // En supprimant le proche, c'est le lointain qui vient. + scene.erase(nearId); + check(scene.pick(eye, ahead, 100.0f) == farId, + "Visee : le suivant apres suppression du premier"); + + // Trop HAUT : le rayon passe au-dessus. C'est le test de la borne verticale, + // sans laquelle un objet au sol serait selectionnable depuis le ciel. + check(scene.pick(glm::vec3(0.0f, 50.0f, 0.0f), ahead, 100.0f) == kNoPlacedObject, + "Visee : un rayon au-dessus de l'objet ne le touche pas"); +} + +void testSceneFile() { + section("Phase 15 : format de scene .vcsc"); + + namespace fs = std::filesystem; + const fs::path directory = fs::temp_directory_path() / "vercora_p15_scene"; + std::error_code ec; + fs::remove_all(directory, ec); + fs::create_directories(directory, ec); + const std::string path = (directory / "test.vcsc").string(); + + const Heightmap terrain = makeGeoTerrain(101, 1.0f); + + // --- Fichier absent : ce n'est PAS une erreur ------------------------- + { + const SceneLoadResult missing = loadSceneFile(path, terrain); + check(!missing.fileExisted, "Scene : fichier absent signale comme tel"); + check(!missing.ok && missing.objects.empty(), + "Scene : rien charge, aucune exception"); + } + + // --- Aller-retour exact ---------------------------------------------- + std::vector original; + { + PlacedObject rock; + rock.asset = "rocher"; + rock.position = { 12.5f, 0.0f, -7.25f }; + rock.position.y = terrain.heightAt(rock.position.x, rock.position.z); + rock.yawDegrees = 137.5f; + rock.scale = 1.75f; + rock.solid = true; + original.push_back(rock); + + PlacedObject post; + post.asset = "poteau"; + post.position = { -30.0f, 0.0f, 41.0f }; + // Volontairement SURELEVE de 2,5 m : le dz doit survivre a l'aller-retour. + post.position.y = terrain.heightAt(post.position.x, post.position.z) + 2.5f; + post.yawDegrees = -45.0f; + post.scale = 0.5f; + post.solid = false; + original.push_back(post); + } + + check(saveSceneFile(path, original, terrain, "terrain_de_test.vchm"), + "Scene : ecriture reussie"); + check(fs::exists(path), "Scene : le fichier existe"); + check(!fs::exists(path + ".tmp"), + "Scene : le temporaire d'ecriture atomique a disparu"); + + { + const SceneLoadResult loaded = loadSceneFile(path, terrain); + check(loaded.fileExisted && loaded.ok, "Scene : relecture reussie"); + check(loaded.version == 1, "Scene : version 1"); + check(loaded.epsg == 2154, "Scene : projection conservee"); + check(loaded.terrainLabel == "terrain_de_test.vchm", "Scene : terrain d'origine note"); + check(loaded.objects.size() == 2, "Scene : deux objets relus"); + check(loaded.skippedObjects == 0 && loaded.unknownDirectives == 0, + "Scene : aucune ligne perdue"); + + for (std::size_t i = 0; i < loaded.objects.size(); ++i) { + const PlacedObject& before = original[i]; + const PlacedObject& after = loaded.objects[i]; + check(after.asset == before.asset, "Scene : asset conserve"); + // Tolerance d'un demi-millimetre : le fichier ecrit trois decimales, + // en metres, sur des coordonnees Lambert 93 de sept chiffres. + checkNear(after.position.x, before.position.x, 5e-4f, "Scene : X conserve"); + checkNear(after.position.z, before.position.z, 5e-4f, "Scene : Z conserve"); + checkNear(after.position.y, before.position.y, 5e-3f, "Scene : altitude conservee"); + checkNear(after.yawDegrees, before.yawDegrees, 1e-2f, "Scene : cap conserve"); + checkNear(after.scale, before.scale, 1e-3f, "Scene : echelle conservee"); + check(after.solid == before.solid, "Scene : solidite conservee"); + } + } + + // --- LE point du format : independance vis-a-vis de l'emprise --------- + // La meme scene rechargee sur le MEME endroit echantillonne au pas de 2 m. + // Les coordonnees sont projetees et l'altitude est relative, donc les objets + // doivent retomber au meme endroit du massif et rester poses au sol. + { + const Heightmap coarse = makeGeoTerrain(51, 2.0f); + const SceneLoadResult loaded = loadSceneFile(path, coarse); + check(loaded.ok && loaded.objects.size() == 2, + "Scene : rechargee sur le terrain au pas de 2 m"); + checkNear(loaded.objects[0].position.x, original[0].position.x, 5e-4f, + "Scene : X identique malgre le changement de resolution"); + // Pose au sol : l'altitude est celle de la SURFACE du terrain courant. + checkNear(loaded.objects[0].position.y, + coarse.heightAt(loaded.objects[0].position.x, loaded.objects[0].position.z), + 5e-3f, "Scene : l'objet pose au sol y reste"); + // Souleve de 2,5 m : il reste souleve de 2,5 m. + checkNear(loaded.objects[1].position.y - + coarse.heightAt(loaded.objects[1].position.x, + loaded.objects[1].position.z), + 2.5f, 5e-3f, "Scene : l'objet souleve garde sa hauteur relative"); + } + + // --- Robustesse : le fichier s'edite aussi a la main ------------------ + { + const std::string messy = (directory / "messy.vcsc").string(); + { + std::ofstream file(messy); + file << "# un commentaire\n" + "version 1\n" + "terrain autre.vchm\n" + "crs 2154\n" + "brouette 42\n" // directive inconnue + "object rocher 907050.000 6439950.000 0.000 0.000 1.000 1\n" + "object incomplet 907050.000\n" // champs manquants + "object cairn 907060.000 6439950.000 0.000 90.000 0.000 1\n" // echelle nulle + "\n" + "object bloc 907070.000 6439950.000 1.500 10.000 2.000 0 # avec commentaire\n"; + } + const SceneLoadResult loaded = loadSceneFile(messy, terrain); + check(loaded.ok, "Scene : un fichier partiellement fautif se charge quand meme"); + check(loaded.objects.size() == 2, "Scene : les deux lignes valides sont gardees"); + check(loaded.skippedObjects == 2, "Scene : les deux lignes fautives sont comptees"); + check(loaded.unknownDirectives == 1, "Scene : la directive inconnue est comptee"); + check(loaded.objects[1].asset == "bloc" && !loaded.objects[1].solid, + "Scene : commentaire de fin de ligne ignore, solidite lue"); + } + + // --- En-tete obligatoire --------------------------------------------- + { + const std::string headless = (directory / "sans_entete.vcsc").string(); + { + std::ofstream file(headless); + file << "object rocher 907050.000 6439950.000 0.000 0.000 1.000 1\n"; + } + const SceneLoadResult loaded = loadSceneFile(headless, terrain); + check(loaded.fileExisted && !loaded.ok, + "Scene : sans directive version, le fichier est refuse"); + check(!loaded.error.empty(), "Scene : le refus est explique"); + } + + // --- Terrain SANS georeferencement ------------------------------------ + // Le terrain synthetique n'a pas de projection : les coordonnees sont alors + // locales, et l'aller-retour doit rester exact. + { + Heightmap::Params params; + params.resolution = 64; + params.worldSize = 128.0f; + const Heightmap procedural(params); + const std::string localPath = (directory / "local.vcsc").string(); + + std::vector objects; + PlacedObject object; + object.asset = "cairn"; + object.position = { -12.0f, 0.0f, 33.0f }; + object.position.y = procedural.heightAt(object.position.x, object.position.z); + objects.push_back(object); + + check(saveSceneFile(localPath, objects, procedural, "procedural"), + "Scene : ecriture sur terrain non georeference"); + const SceneLoadResult loaded = loadSceneFile(localPath, procedural); + check(loaded.ok && loaded.epsg == 0, "Scene : crs 0 pour un terrain local"); + check(loaded.objects.size() == 1, "Scene : objet relu"); + checkNear(loaded.objects[0].position.x, -12.0f, 1e-3f, "Scene : X local conserve"); + checkNear(loaded.objects[0].position.z, 33.0f, 1e-3f, "Scene : Z local conserve"); + } + + // --- Objets hors emprise : conserves, mais comptes --------------------- + { + const std::string outside = (directory / "dehors.vcsc").string(); + { + std::ofstream file(outside); + file << "version 1\ncrs 2154\n" + "object rocher 912000.000 6439950.000 0.000 0.000 1.000 1\n"; + } + const SceneLoadResult loaded = loadSceneFile(outside, terrain); + check(loaded.ok && loaded.objects.size() == 1, + "Scene : un objet hors emprise est CONSERVE"); + check(loaded.outsideExtent == 1, "Scene : il est signale"); + } + + // --- Convention de chemin --------------------------------------------- + { + const std::string derived = scenePathFor("assets/terrain/vercora_zone_1m.vchm", + "assets/scenes"); + check(derived.find("vercora_zone.vcsc") != std::string::npos, + "Scene : le suffixe de resolution est retire du nom de scene"); + const std::string coarse = scenePathFor("assets/terrain/vercora_zone_2m.vchm", + "assets/scenes"); + check(derived == coarse, + "Scene : 1 m et 2 m partagent la MEME scene (meme endroit)"); + } + + // --- Conversion projetee : les deux sens sont inverses l'un de l'autre - + { + double east = 0.0; + double north = 0.0; + terrain.toProjected(17.5f, -23.25f, &east, &north); + float backX = 0.0f; + float backZ = 0.0f; + terrain.fromProjected(east, north, &backX, &backZ); + checkNear(backX, 17.5f, 1e-4f, "Georeferencement : aller-retour exact en X"); + checkNear(backZ, -23.25f, 1e-4f, "Georeferencement : aller-retour exact en Z"); + } + + fs::remove_all(directory, ec); +} + +void testEditorController() { + section("Phase 15 : controleur d'editeur"); + + AssetCatalog catalog; + catalog.addBuiltins(); + EditorScene scene(&catalog); + EditorController controller(catalog, scene); + const FlatTerrain terrain(0.0f); + constexpr float kHalfExtent = 1000.0f; + + check(controller.brushIndex() == 0, "Controleur : premier asset arme au demarrage"); + + // Visee : oeil a 10 m, regard a 45 degres vers -Z. Le point vise est donc + // (0, 0, -10) sur ce terrain plat. + EditorInput input; + input.deltaTime = 1.0f / 60.0f; + input.now = 0.0f; + input.eye = { 0.0f, 10.0f, 0.0f }; + input.forward = glm::normalize(glm::vec3(0.0f, -1.0f, -1.0f)); + + controller.update(input, terrain, kHalfExtent); + check(controller.hasPreview(), "Controleur : un fantome suit la visee"); + checkNear(controller.preview().position.z, -10.0f, 0.01f, + "Controleur : le fantome est au point vise"); + check(controller.preview().id == kNoPlacedObject, + "Controleur : un fantome de pose n'a pas encore d'identifiant"); + check(scene.empty(), "Controleur : previsualiser ne pose rien"); + + // Regard vers le CIEL : pas de fantome, et un clic ne pose rien. + { + EditorInput sky = input; + sky.forward = glm::normalize(glm::vec3(0.0f, 1.0f, -1.0f)); + sky.placePressed = true; + controller.update(sky, terrain, kHalfExtent); + check(!controller.hasPreview(), "Controleur : rien a previsualiser vers le ciel"); + check(scene.empty(), "Controleur : viser le ciel ne pose rien"); + } + + // --- Pose -------------------------------------------------------------- + { + EditorInput place = input; + place.placePressed = true; + controller.update(place, terrain, kHalfExtent); + check(scene.size() == 1, "Controleur : un objet pose au clic"); + checkNear(scene.objects()[0].position.z, -10.0f, 0.01f, + "Controleur : pose au point exactement vise"); + // La pose ne SELECTIONNE PAS. Sinon les reglages, qui visent la + // selection en priorite, seraient silencieusement detournes du pinceau + // des la premiere pose - et "regler une fois, poser dix fois" deviendrait + // impossible. Voir le commentaire du bloc de pose dans + // editor/EditorController.cpp. + check(controller.selection() == kNoPlacedObject, + "Controleur : poser ne selectionne pas, le pinceau reste la cible"); + } + + // --- Le PINCEAU garde ses reglages d'une pose a l'autre ---------------- + // C'est le comportement utile quand on aligne une serie de blocs : on regle + // une fois, on pose dix fois. + { + EditorInput turn = input; + turn.holdRotateRight = true; + turn.deltaTime = 0.5f; // 90 deg/s x 0,5 s = 45 degres + controller.update(turn, terrain, kHalfExtent); + checkNear(controller.preview().yawDegrees, 45.0f, 1e-3f, + "Controleur : le pinceau a tourne de 45 degres"); + + EditorInput grow = input; + grow.holdScaleUp = true; + grow.deltaTime = 1.0f; // facteur 1,8 par seconde + controller.update(grow, terrain, kHalfExtent); + checkNear(controller.preview().scale, 1.8f, 1e-3f, + "Controleur : echelle multiplicative"); + + EditorInput lift = input; + lift.holdRaise = true; + lift.deltaTime = 1.0f; // 0,6 m/s + controller.update(lift, terrain, kHalfExtent); + checkNear(controller.preview().position.y, 0.6f, 1e-3f, + "Controleur : decalage vertical par rapport au sol"); + + EditorInput place = input; + place.placePressed = true; + controller.update(place, terrain, kHalfExtent); + check(scene.size() == 2, "Controleur : deuxieme objet pose"); + checkNear(scene.objects()[1].yawDegrees, 45.0f, 1e-3f, + "Controleur : le cap du pinceau est repris a la pose"); + checkNear(scene.objects()[1].scale, 1.8f, 1e-3f, + "Controleur : l'echelle du pinceau est reprise"); + checkNear(scene.objects()[1].position.y, 0.6f, 1e-3f, + "Controleur : la hauteur du pinceau est reprise"); + } + + // --- Pas fin ------------------------------------------------------------ + { + EditorController fine(catalog, scene); + EditorInput slow = input; + slow.holdRotateRight = true; + slow.holdFineStep = true; + slow.deltaTime = 0.5f; // 45 degres / 8 + fine.update(slow, terrain, kHalfExtent); + checkNear(fine.preview().yawDegrees, 45.0f / 8.0f, 1e-3f, + "Controleur : la touche de pas fin divise le reglage"); + } + + // --- Selection puis SAISIE --------------------------------------------- + { + EditorScene moving(&catalog); + EditorController tool(catalog, moving); + + EditorInput place = input; + place.placePressed = true; + tool.update(place, terrain, kHalfExtent); + const uint32_t id = moving.objects()[0].id; + const std::size_t depthAfterPlace = moving.undoDepth(); + + // On SELECTIONNE d'abord : la saisie porte sur la selection, et poser ne + // selectionne plus rien. + EditorInput pick = input; + pick.eye = { 0.0f, 0.9f, 0.0f }; + pick.forward = { 0.0f, 0.0f, -1.0f }; + pick.pickPressed = true; + tool.update(pick, terrain, kHalfExtent); + check(tool.selection() == id, "Controleur : objet vise puis selectionne"); + + // Saisie, puis 60 images de deplacement du regard : la scene ne doit PAS + // bouger tant que l'objet est en main. Sans ca, deplacer un rocher de + // trente metres empilerait une annulation par image. + EditorInput grab = input; + grab.grabPressed = true; + tool.update(grab, terrain, kHalfExtent); + check(tool.grabbing(), "Controleur : objet en main"); + check(tool.hiddenObjectId() == id, + "Controleur : l'objet en main n'est plus dessine a sa place"); + + EditorInput move = input; + move.eye = { 25.0f, 10.0f, 0.0f }; + for (int frame = 0; frame < 60; ++frame) { + move.now = 1.0f + 0.016f * static_cast(frame); + tool.update(move, terrain, kHalfExtent); + } + checkNear(moving.objects()[0].position.x, 0.0f, 1e-3f, + "Controleur : la scene ne bouge pas tant que l'objet est en main"); + check(moving.undoDepth() == depthAfterPlace, + "Controleur : aucune annulation empilee pendant le deplacement"); + checkNear(tool.preview().position.x, 25.0f, 0.05f, + "Controleur : la previsualisation, elle, suit la visee"); + + // Repose : UNE seule annulation pour tout le deplacement. + EditorInput drop = move; + drop.now = 3.0f; + drop.grabPressed = true; + tool.update(drop, terrain, kHalfExtent); + check(!tool.grabbing(), "Controleur : objet repose"); + checkNear(moving.objects()[0].position.x, 25.0f, 0.05f, + "Controleur : l'objet a bien ete deplace"); + check(moving.undoDepth() == depthAfterPlace + 1, + "Controleur : UNE annulation pour tout le deplacement"); + + EditorInput undo = input; + undo.now = 4.0f; + undo.undoPressed = true; + tool.update(undo, terrain, kHalfExtent); + checkNear(moving.objects()[0].position.x, 0.0f, 1e-3f, + "Controleur : l'annulation ramene l'objet d'ou il venait"); + } + + // --- Selection par la visee, puis suppression -------------------------- + { + EditorScene target(&catalog); + EditorController tool(catalog, target); + + EditorInput place = input; + place.placePressed = true; + tool.update(place, terrain, kHalfExtent); + const uint32_t id = target.objects()[0].id; + + check(tool.selection() == kNoPlacedObject, + "Controleur : rien de selectionne juste apres la pose"); + + // On vise l'objet depuis le sol, a l'horizontale. + EditorInput pick = input; + pick.eye = { 0.0f, 0.9f, 0.0f }; + pick.forward = { 0.0f, 0.0f, -1.0f }; + pick.pickPressed = true; + tool.update(pick, terrain, kHalfExtent); + check(tool.selection() == id, "Controleur : l'objet vise est selectionne"); + + EditorInput erase = input; + erase.deletePressed = true; + tool.update(erase, terrain, kHalfExtent); + check(target.empty(), "Controleur : la selection est supprimee"); + check(tool.selection() == kNoPlacedObject, "Controleur : plus rien de selectionne"); + + EditorInput undo = input; + undo.undoPressed = true; + undo.now = 10.0f; + tool.update(undo, terrain, kHalfExtent); + check(target.size() == 1, "Controleur : la suppression est annulable"); + } + + // --- Cycle F3/F4 parmi les objets poses, SANS viser --------------------- + // Ajoute apres la session initiale de la Phase 15 (voir NOTES-PHASE15.md + // ss13) : pickPressed exige que la visee touche l'objet, ce qui n'aide en + // rien a retrouver un objet pose hors du champ courant. F3/F4 parcourent la + // liste de la scene independamment du regard. + { + EditorScene noneScene(&catalog); + EditorController none(catalog, noneScene); + EditorInput nextOnEmpty = input; + nextOnEmpty.cycleNextPressed = true; + none.update(nextOnEmpty, terrain, kHalfExtent); + check(none.selection() == kNoPlacedObject, + "Cycle : rien a selectionner dans une scene vide"); + } + { + EditorScene many(&catalog); + EditorController tool(catalog, many); + PlacedObject a; a.asset = catalog.entries()[0].id; a.position = { 0.0f, 0.0f, 0.0f }; + PlacedObject b; b.asset = catalog.entries()[0].id; b.position = { 5.0f, 0.0f, 0.0f }; + PlacedObject c; c.asset = catalog.entries()[0].id; c.position = { 10.0f, 0.0f, 0.0f }; + const uint32_t idA = many.place(a); + const uint32_t idB = many.place(b); + const uint32_t idC = many.place(c); + + EditorInput next = input; + next.cycleNextPressed = true; + tool.update(next, terrain, kHalfExtent); + check(tool.selection() == idA, "Cycle : F3 depuis rien selectionne prend le premier"); + tool.update(next, terrain, kHalfExtent); + check(tool.selection() == idB, "Cycle : F3 avance d'un objet"); + tool.update(next, terrain, kHalfExtent); + check(tool.selection() == idC, "Cycle : F3 avance encore"); + tool.update(next, terrain, kHalfExtent); + check(tool.selection() == idA, "Cycle : F3 boucle apres le dernier"); + + EditorInput prev = input; + prev.cyclePrevPressed = true; + tool.update(prev, terrain, kHalfExtent); + check(tool.selection() == idC, "Cycle : F4 recule et boucle avant le premier"); + + // Pendant une saisie, le cycle ne doit RIEN faire - changer la selection + // sous un objet en main serait incoherent (quel objet suit alors la + // visee ?). + EditorInput grab = input; + grab.grabPressed = true; + tool.update(grab, terrain, kHalfExtent); + check(tool.grabbing(), "Cycle : objet en main avant le test d'ignorance"); + EditorInput cycleWhileGrabbing = input; + cycleWhileGrabbing.cycleNextPressed = true; + tool.update(cycleWhileGrabbing, terrain, kHalfExtent); + check(tool.selection() == idC, "Cycle : ignore pendant une saisie"); + check(tool.grabbing(), "Cycle : la saisie en cours n'est pas interrompue"); + } + + // --- Catalogue : parcours et rang direct ------------------------------- + { + EditorScene empty(&catalog); + EditorController tool(catalog, empty); + + EditorInput next = input; + next.nextAssetPressed = true; + tool.update(next, terrain, kHalfExtent); + check(tool.brushIndex() == 1, "Controleur : asset suivant"); + + EditorInput prev = input; + prev.prevAssetPressed = true; + tool.update(prev, terrain, kHalfExtent); + check(tool.brushIndex() == 0, "Controleur : asset precedent"); + + // Reculer depuis le premier doit ramener au DERNIER (modulo positif). + tool.update(prev, terrain, kHalfExtent); + check(tool.brushIndex() == static_cast(catalog.size()) - 1, + "Controleur : le parcours est cyclique dans les deux sens"); + + EditorInput quick = input; + quick.quickPick = 2; // troisieme rang de la page courante + tool.update(quick, terrain, kHalfExtent); + check(tool.brushIndex() == 2, "Controleur : rang direct au clavier"); + check(tool.preview().asset == catalog.entries()[2].id, + "Controleur : le fantome suit l'asset arme"); + } + + // --- Les requetes d'entree/sortie sont des drapeaux, consommes une fois - + { + EditorScene empty(&catalog); + EditorController tool(catalog, empty); + EditorInput ask = input; + ask.savePressed = true; + ask.reloadPressed = true; + ask.listPressed = true; + tool.update(ask, terrain, kHalfExtent); + check(tool.consumeSaveRequest(), "Controleur : sauvegarde demandee"); + check(!tool.consumeSaveRequest(), "Controleur : la demande n'est consommee qu'une fois"); + check(tool.consumeReloadRequest(), "Controleur : rechargement demande"); + check(tool.consumeListRequest(), "Controleur : liste demandee"); + } + + // --- resetInteraction --------------------------------------------------- + // Appele en sortant du mode edition : laisser un objet "en main" pendant une + // partie normale le figerait sur le reticule pour toujours. + { + EditorScene held(&catalog); + EditorController tool(catalog, held); + EditorInput place = input; + place.placePressed = true; + tool.update(place, terrain, kHalfExtent); + EditorInput pick = input; + pick.eye = { 0.0f, 0.9f, 0.0f }; + pick.forward = { 0.0f, 0.0f, -1.0f }; + pick.pickPressed = true; + tool.update(pick, terrain, kHalfExtent); + EditorInput grab = input; + grab.grabPressed = true; + tool.update(grab, terrain, kHalfExtent); + check(tool.grabbing(), "Controleur : objet en main avant la sortie"); + tool.resetInteraction(); + check(!tool.grabbing() && tool.selection() == kNoPlacedObject, + "Controleur : sortie du mode -> ni saisie ni selection"); + check(held.size() == 1, "Controleur : l'objet reste dans la scene"); + } +} + +// =========================================================================== +// PHASE 16 : besoins primaires (faim, soif, fatigue, temperature) +// =========================================================================== + +// Relief qui ne varie que selon Z. Indispensable ici et nulle part ailleurs : +// SlopedTerrain penche selon X, or l'exposition adret/ubac ne depend QUE de +// l'axe nord-sud, c'est-a-dire de Z (convention Heightmap : +Z va vers le sud). +// Un test d'exposition sur SlopedTerrain lirait donc 0,5 quelle que soit la +// pente, et passerait meme avec un signe inverse. +class NorthSouthSlope : public HeightSampler { +public: + explicit NorthSouthSlope(float slope) : slope_(slope) {} + // slope > 0 : le terrain MONTE vers le sud, donc il descend vers le nord. + // C'est un UBAC. + float heightAt(float, float z) const override { return slope_ * z; } + +private: + float slope_; +}; + +// Cuvette parabolique centree, posee dans un plateau plat. C'est le seul relief +// ou l'on sache a l'avance ou est le creux, donc le seul qui permette de dire +// si le detecteur de points d'eau trouve LE bon endroit et pas seulement un +// endroit. +class BowlTerrain : public HeightSampler { +public: + BowlTerrain(float centerX, float centerZ, float curvature, float rim) + : cx_(centerX), cz_(centerZ), k_(curvature), rim_(rim) {} + + float heightAt(float x, float z) const override { + const float dx = x - cx_; + const float dz = z - cz_; + return std::min(rim_, k_ * (dx * dx + dz * dz)); + } + +private: + float cx_, cz_, k_, rim_; +}; + +// La meme, retournee : une bosse. Elle doit etre rejetee - c'est le controle +// negatif du critere de concavite, sans lequel un detecteur qui ne regarderait +// que la platitude passerait le test de la cuvette par accident. +class DomeTerrain : public HeightSampler { +public: + DomeTerrain(float centerX, float centerZ, float curvature, float floor) + : cx_(centerX), cz_(centerZ), k_(curvature), floor_(floor) {} + + float heightAt(float x, float z) const override { + const float dx = x - cx_; + const float dz = z - cz_; + return std::max(floor_, 100.0f - k_ * (dx * dx + dz * dz)); + } + +private: + float cx_, cz_, k_, floor_; +}; + +// Plusieurs cuvettes creusees dans un meme plateau : la hauteur est celle de la +// cuvette la plus proche. C'est le seul relief qui produise plus d'un point +// d'eau, donc le seul sur lequel l'ecartement minimal veuille dire quelque +// chose - une cuvette unique ne rend qu'un point, et le test passerait a vide. +class MultiBowlTerrain : public HeightSampler { +public: + MultiBowlTerrain(std::vector centers, float curvature, float rim) + : centers_(std::move(centers)), k_(curvature), rim_(rim) {} + + float heightAt(float x, float z) const override { + float best = rim_; + for (const glm::vec2& c : centers_) { + const float dx = x - c.x; + const float dz = z - c.y; + best = std::min(best, k_ * (dx * dx + dz * dz)); + } + return best; + } + +private: + std::vector centers_; + float k_, rim_; +}; + +// Fait tourner les jauges pendant `seconds` avec un contexte constant. +// keepFedAndWatered remet faim et soif a plein a chaque pas : c'est ce qui +// permet de mesurer la fatigue SEULE, sans l'aggravation par les autres manques +// (NeedsParams::deficitFatigueGain). Sans cette option, un test de fatigue +// mesurerait en realite le couplage. +void runNeeds(Needs& needs, const NeedsContext& context, float seconds, + bool keepFedAndWatered = false, float dt = 1.0f) { + for (float t = 0.0f; t < seconds; t += dt) { + needs.update(dt, context); + if (keepFedAndWatered) { + needs.setHunger(1.0f); + needs.setThirst(1.0f); + } + } +} + +// Distance parcourue par le velo en `seconds` a pedalage donne, sur terrain +// plat. Sert a mesurer une CONSEQUENCE de la fatigue plutot qu'un coefficient : +// le cahier des charges demande "moins de distance en velo", pas "un facteur +// plus petit". +float bikeDistance(float pedalInput, float seconds) { + FlatTerrain flat(100.0f); + Bike bike; + bike.mount(glm::vec3(0.0f, 100.0f, 0.0f), 0.0f, flat); + const glm::vec3 start = bike.position(); + constexpr float dt = 1.0f / 60.0f; + for (float t = 0.0f; t < seconds; t += dt) { + bike.update(dt, 0.0f, pedalInput, 0.0f, flat, nullptr); + } + return horizontalDistance(bike.position(), start); +} + +void testNeeds() { + section("Phase 16 : jauges de besoins primaires"); + + const NeedsParams defaults; + + // --- Etat de depart ------------------------------------------------------ + { + Needs needs; + checkNear(needs.hunger(), 1.0f, 1e-6f, "Depart : faim pleine"); + checkNear(needs.thirst(), 1.0f, 1e-6f, "Depart : soif pleine"); + checkNear(needs.fatigue(), 1.0f, 1e-6f, "Depart : forme pleine"); + checkNear(needs.temperature(), 1.0f, 1e-6f, "Depart : temperature pleine"); + checkNear(needs.movementFactor(), 1.0f, 1e-6f, + "Depart : aucune penalite de deplacement"); + check(!needs.inTrouble(), "Depart : aucun besoin critique"); + + // Un pas de temps nul ou negatif ne doit RIEN faire : la premiere image + // du jeu a un deltaTime issu d'une soustraction d'horloges, et une + // valeur nulle y est normale. + needs.update(0.0f, NeedsContext{}); + needs.update(-1.0f, NeedsContext{}); + checkNear(needs.fatigue(), 1.0f, 1e-6f, "deltaTime <= 0 : jauges intactes"); + } + + // --- Rythme : rien de perceptible en quelques minutes --------------------- + // C'est la contrainte explicite du cahier des charges, et c'est aussi celle + // qu'un reglage trop nerveux casserait en premier. + { + NeedsContext walking; + walking.activity = Activity::Walk; + // PHASE 23 : une ambiante douce et posee, la ou ce bloc reglait avant + // une altitude et une heure pour l'obtenir. Ce test parle du RYTHME des + // jauges, pas du climat : il ne doit dependre d'aucun modele meteo. + walking.ambientTemperatureC = 14.0f; + + Needs needs; + runNeeds(needs, walking, 5.0f * 60.0f); + check(needs.hunger() > 0.90f, "5 min de marche : la faim se voit a peine"); + check(needs.thirst() > 0.90f, "5 min de marche : la soif se voit a peine"); + check(needs.fatigue() > 0.90f, "5 min de marche : la forme se voit a peine"); + checkNear(needs.movementFactor(), 1.0f, 1e-6f, + "5 min de marche : toujours aucune penalite"); + } + + // --- Rythme : un vrai enjeu sur une session de 30 a 60 min --------------- + { + NeedsContext walking; + walking.activity = Activity::Walk; + // PHASE 23 : une ambiante douce et posee, la ou ce bloc reglait avant + // une altitude et une heure pour l'obtenir. Ce test parle du RYTHME des + // jauges, pas du climat : il ne doit dependre d'aucun modele meteo. + walking.ambientTemperatureC = 14.0f; + + Needs needs; + runNeeds(needs, walking, 30.0f * 60.0f); + check(needs.thirst() < 0.60f, "30 min de marche : la soif est bien entamee"); + check(needs.fatigue() < 0.75f, "30 min de marche : la forme est entamee"); + check(needs.hunger() > 0.70f, + "30 min de marche : la faim reste le besoin le plus lent"); + check(needs.hunger() > needs.thirst(), + "On a soif AVANT d'avoir faim (ordre voulu des besoins)"); + } + + // --- Fatigue : les taux annonces dans world/Needs.hpp --------------------- + { + NeedsContext walking; + walking.activity = Activity::Walk; + + Needs half; + runNeeds(half, walking, 45.0f * 60.0f, /*keepFedAndWatered=*/true); + checkNear(half.fatigue(), 0.5f, 0.01f, + "45 min de marche : la moitie de la forme (1/(90 min) annonce)"); + checkNear(half.fatigueFactor(), 1.0f, 1e-3f, + "Forme a la moitie : la penalite commence tout juste"); + + Needs empty; + runNeeds(empty, walking, 90.0f * 60.0f, /*keepFedAndWatered=*/true); + checkNear(empty.fatigue(), 0.0f, 0.01f, "90 min de marche : forme a plat"); + checkNear(empty.fatigueFactor(), defaults.fatigueFloorFactor, 1e-3f, + "Forme a plat : le coefficient tombe a son plancher"); + } + + // --- Chaque activite coute selon son effort ------------------------------ + { + checkNear(activityEffort(Activity::Rest), 0.0f, 1e-6f, "Effort : le repos ne coute rien"); + check(activityEffort(Activity::Climb) > activityEffort(Activity::Bike), + "Effort : l'escalade coute plus que le velo"); + check(activityEffort(Activity::Bike) > activityEffort(Activity::Walk), + "Effort : le velo coute plus que la marche"); + check(activityEffort(Activity::Paraglide) < activityEffort(Activity::Walk), + "Effort : le parapente coute moins que la marche"); + + // Meme duree, quatre activites : la fatigue restante doit se classer + // dans l'ordre inverse des efforts. C'est la verification demandee - + // "l'escalade et le velo fatiguent plus vite que la marche". + auto fatigueAfter = [](Activity activity, float seconds) { + NeedsContext context; + context.activity = activity; + Needs needs; + runNeeds(needs, context, seconds, /*keepFedAndWatered=*/true); + return needs.fatigue(); + }; + const float minutes10 = 10.0f * 60.0f; + const float rest = fatigueAfter(Activity::Rest, minutes10); + const float walk = fatigueAfter(Activity::Walk, minutes10); + const float bike = fatigueAfter(Activity::Bike, minutes10); + const float climb = fatigueAfter(Activity::Climb, minutes10); + checkNear(rest, 1.0f, 1e-6f, "10 min a l'arret : la forme reste pleine"); + check(walk > bike, "10 min : le velo fatigue plus que la marche"); + check(bike > climb, "10 min : l'escalade fatigue plus que le velo"); + checkNear(1.0f - climb, 4.0f * (1.0f - walk), 1e-3f, + "L'escalade fatigue exactement 4 fois plus vite que la marche"); + } + + // --- Repos : la seule source de recuperation de la forme ------------------ + { + NeedsContext resting; + resting.activity = Activity::Rest; + + Needs needs; + needs.setFatigue(0.0f); + runNeeds(needs, resting, 10.0f * 60.0f, /*keepFedAndWatered=*/true); + checkNear(needs.fatigue(), 0.5f, 0.01f, + "10 min de repos : la moitie de la forme (1/(20 min) annonce)"); + runNeeds(needs, resting, 10.0f * 60.0f, /*keepFedAndWatered=*/true); + checkNear(needs.fatigue(), 1.0f, 1e-3f, "20 min de repos : forme refaite"); + + // Le repos ne rend NI faim NI soif : sans ca, s'arreter reglerait tout + // et le point d'eau ne servirait a rien. + Needs other; + other.setHunger(0.5f); + other.setThirst(0.5f); + runNeeds(other, resting, 5.0f * 60.0f); + check(other.hunger() < 0.5f, "Repos : la faim continue de descendre"); + check(other.thirst() < 0.5f, "Repos : la soif continue de descendre"); + } + + // --- Aggravation croisee ------------------------------------------------- + { + NeedsContext walking; + walking.activity = Activity::Walk; + + Needs healthy; + runNeeds(healthy, walking, 10.0f * 60.0f, /*keepFedAndWatered=*/true); + + Needs parched; + parched.setThirst(0.0f); + // On maintient la soif a zero pour isoler l'effet : sinon elle + // remonterait d'elle-meme, ce qu'aucune jauge ne fait, mais le test + // doit tenir meme si les taux changent. + for (float t = 0.0f; t < 10.0f * 60.0f; t += 1.0f) { + parched.setThirst(0.0f); + parched.update(1.0f, walking); + } + check(parched.fatigue() < healthy.fatigue(), + "Un joueur assoiffe se fatigue plus vite"); + checkNear(1.0f - parched.fatigue(), + (1.0f + defaults.deficitFatigueGain) * (1.0f - healthy.fatigue()), + 1e-3f, "Manque total : la fatigue double exactement"); + } + + // --- Consequences : les coefficients ------------------------------------- + { + Needs needs; + needs.setFatigue(defaults.fatiguePenaltyThreshold); + checkNear(needs.fatigueFactor(), 1.0f, 1e-6f, + "Forme au seuil : aucune penalite encore"); + needs.setFatigue(0.5f * defaults.fatiguePenaltyThreshold); + checkNear(needs.fatigueFactor(), + 0.5f * (1.0f + defaults.fatigueFloorFactor), 1e-6f, + "Forme a mi-seuil : penalite a mi-chemin du plancher"); + + Needs thirsty; + thirsty.setThirst(defaults.criticalThreshold); + checkNear(thirsty.thirstFactor(), 1.0f, 1e-6f, + "Soif au seuil critique : aucune penalite encore"); + thirsty.setThirst(0.0f); + checkNear(thirsty.thirstFactor(), defaults.thirstFloorFactor, 1e-6f, + "Soif a zero : le coefficient tombe a son plancher"); + check(thirsty.inTrouble(), "Soif a zero : besoin critique signale"); + + Needs starving; + starving.setHunger(0.0f); + checkNear(starving.hungerFactor(), defaults.hungerFloorFactor, 1e-6f, + "Faim a zero : penalite progressive, pas de mort"); + + Needs frozen; + frozen.setTemperature(0.0f); + checkNear(frozen.coldFactor(), defaults.coldFloorFactor, 1e-6f, + "Froid extreme : penalite progressive, pas de mort"); + } + + // --- Aucune jauge ne tue, jamais ----------------------------------------- + { + Needs dead; + dead.setHunger(0.0f); + dead.setThirst(0.0f); + dead.setFatigue(0.0f); + dead.setTemperature(0.0f); + checkNear(dead.movementFactor(), defaults.minimumMovementFactor, 1e-6f, + "Les quatre jauges a zero : le plancher de deplacement s'applique"); + check(dead.movementFactor() > 0.3f, + "Les quatre jauges a zero : le joueur avance encore (pas de punition brutale)"); + + // Le plancher MORD reellement : sans lui, le produit des quatre + // penalites serait bien plus bas. C'est le controle negatif du choix. + const float rawProduct = dead.fatigueFactor() * dead.hungerFactor() * + dead.thirstFactor() * dead.coldFactor(); + check(rawProduct < defaults.minimumMovementFactor, + "Le plancher n'est pas decoratif : le produit brut est sous lui"); + } + + // --- Regeneration : boire, manger ---------------------------------------- + { + Needs needs; + needs.setThirst(0.2f); + check(needs.drink(), "Boire : la gorgee compte quand on avait soif"); + checkNear(needs.thirst(), 1.0f, 1e-6f, "Boire : la soif est etanchee"); + check(!needs.drink(), "Boire a soif pleine : rien a signaler"); + + needs.setHunger(0.5f); + check(needs.eat(0.3f), "Manger : la faim remonte"); + checkNear(needs.hunger(), 0.8f, 1e-6f, "Manger : de la valeur nutritive exacte"); + check(!needs.eat(0.0f), "Manger du vide : refuse"); + check(!needs.eat(-1.0f), "Manger une valeur negative : refuse"); + needs.eat(5.0f); + checkNear(needs.hunger(), 1.0f, 1e-6f, "Manger : la jauge ne depasse pas 1"); + + needs.reset(); + checkNear(needs.hunger(), 1.0f, 1e-6f, "reset : tout est plein"); + checkNear(needs.temperature(), 1.0f, 1e-6f, "reset : temperature pleine"); + } + + // --- Climat -------------------------------------------------------------- + // PHASE 23 : le bloc qui verifiait ici le gradient adiabatique, le cycle + // diurne et l'adret/ubac a DEMENAGE dans testWeather(). Ce n'est pas une + // perte de couverture, c'est le deplacement du calcul : Needs ne calcule + // plus aucune ambiante, il en recoit une. Ce qui se verifie desormais ici + // est ce que Needs fait de cette ambiante, et rien d'autre. + + // --- Exposition lue sur le relief ---------------------------------------- + { + FlatTerrain flat(300.0f); + checkNear(terrainExposure(flat, 10.0f, -5.0f), 0.5f, 1e-6f, + "Exposition : du plat n'est ni adret ni ubac"); + + // SlopedTerrain penche selon X (est-ouest) : aucune exposition non plus. + SlopedTerrain eastWest(0.0f, 0.80f); + checkNear(terrainExposure(eastWest, 10.0f, 0.0f), 0.5f, 1e-6f, + "Exposition : un versant est-ouest n'est ni adret ni ubac"); + + // +Z va vers le SUD : un terrain qui DESCEND vers +Z est un adret. + NorthSouthSlope adret(-0.50f); + checkNear(terrainExposure(adret, 0.0f, 0.0f), 1.0f, 1e-4f, + "Exposition : versant descendant vers le sud = adret franc"); + + NorthSouthSlope ubac(0.50f); + checkNear(terrainExposure(ubac, 0.0f, 0.0f), 0.0f, 1e-4f, + "Exposition : versant descendant vers le nord = ubac franc"); + + // Pente douce : l'exposition est ponderee, elle n'est pas franche. + NorthSouthSlope gentle(kFullExposureSlope * 0.5f); + checkNear(terrainExposure(gentle, 0.0f, 0.0f), 0.25f, 1e-4f, + "Exposition : une pente a mi-seuil ne compte qu'a moitie"); + } + + // --- Temperature : la jauge elle-meme ------------------------------------ + { + // Parametres depouilles : pas de cycle diurne, pas d'exposition, une + // ambiante fixee a 10 degres SOUS le confort. C'est le seul moyen de + // verifier une vitesse de refroidissement sans qu'elle depende de + // l'heure choisie par le test. + // PHASE 23 : plus rien a neutraliser dans les parametres - l'ambiante + // arrive du contexte, on la POSE. Le test est du meme coup plus direct + // qu'avant, ou il fallait annuler trois termes de climat pour obtenir + // une temperature stable. + NeedsParams cold = defaults; + + NeedsContext still; + still.activity = Activity::Rest; + still.ambientTemperatureC = cold.comfortTemperatureC - 10.0f; + + Needs needs(cold); + checkNear(needs.temperature(), 1.0f, 1e-6f, "Froid : on part au chaud"); + runNeeds(needs, still, 15.0f * 60.0f); + checkNear(needs.temperature(), 0.5f, 0.01f, + "10 degres sous le confort : moitie de jauge en 15 min"); + checkNear(needs.ambientTemperatureC(), cold.comfortTemperatureC - 10.0f, 1e-3f, + "Froid : l'ambiante relevee est celle attendue"); + runNeeds(needs, still, 15.0f * 60.0f); + checkNear(needs.temperature(), 0.0f, 0.01f, + "10 degres sous le confort : jauge vide en 30 min"); + checkNear(needs.movementFactor(), defaults.coldFloorFactor, 1e-3f, + "Gele : la seule penalite active est celle du froid"); + + // L'effort rechauffe : meme climat, mais en marchant. + Needs walker(cold); + NeedsContext walking = still; + walking.activity = Activity::Walk; + runNeeds(walker, walking, 15.0f * 60.0f, /*keepFedAndWatered=*/true); + check(walker.temperature() > needs.temperature() + 0.05f || + walker.temperature() > 0.5f, + "Marcher rechauffe : on a moins froid qu'a l'arret"); + check(walker.feltTemperatureC() > walker.ambientTemperatureC(), + "Marcher : le ressenti est au-dessus de l'ambiante"); + + // Le vol refroidit malgre l'effort : c'est le vent. PHASE 23 : ce n'est + // plus un forfait de -6 degres reserve au parapente, c'est la formule + // JAG/TI appliquee au vent que l'appelant declare - ici les 10,5 m/s de + // vitesse propre de l'aile. La MEME mecanique refroidit desormais un + // marcheur en crete par vent fort, ce qu'un forfait ne pouvait pas + // faire. + Needs pilot(cold); + NeedsContext flying = still; + flying.activity = Activity::Paraglide; + flying.windSpeedMps = 10.5f; + pilot.update(1.0f, flying); + check(pilot.feltTemperatureC() < pilot.ambientTemperatureC(), + "Parapente : le ressenti est SOUS l'ambiante (vent relatif)"); + + Needs windyWalker(cold); + NeedsContext exposedRidge = still; + exposedRidge.windSpeedMps = 14.0f; + windyWalker.update(1.0f, exposedRidge); + Needs calmWalker(cold); + calmWalker.update(1.0f, still); + check(windyWalker.feltTemperatureC() < calmWalker.feltTemperatureC() - 1.0f, + "Vent : a l'arret aussi, le vent refroidit le ressenti"); + check(windyWalker.ambientTemperatureC() == calmWalker.ambientTemperatureC(), + "Vent : il change le RESSENTI, jamais l'ambiante"); + + // Un abri annule le vent, pas seulement le froid. + Needs hutted(cold); + NeedsContext shelteredGale = exposedRidge; + shelteredGale.sheltered = true; + hutted.update(1.0f, shelteredGale); + check(hutted.feltTemperatureC() > windyWalker.feltTemperatureC(), + "Abri : le refroidissement eolien ne s'y applique pas"); + + // L'abri est le point d'ancrage prevu pour l'artisanat a venir. + Needs sheltered(cold); + NeedsContext hut = still; + hut.sheltered = true; + runNeeds(sheltered, hut, 15.0f * 60.0f); + check(sheltered.temperature() > needs.temperature(), + "Abri : on se refroidit moins vite qu'a decouvert"); + + // Rechauffement : au-dessus du confort, la jauge remonte. + Needs thawing(cold); + NeedsContext mild = still; + mild.ambientTemperatureC = cold.comfortTemperatureC + 10.0f; + thawing.setTemperature(0.0f); + runNeeds(thawing, mild, 10.0f * 60.0f); + checkNear(thawing.temperature(), 1.0f, 1e-3f, + "Au chaud : la jauge se refait en 10 min"); + } + + // --- L'altitude mord vraiment sur la jauge ------------------------------- + // C'est la demande explicite du cahier des charges : "lien avec l'altitude + // deja disponible (heightAt())". Deux joueurs, meme heure, meme activite, + // 1000 m d'ecart -> celui d'en haut a plus froid. + { + // PHASE 23 : les deux ambiantes sont desormais PRODUITES par le systeme + // meteo, a la meme heure et au meme instant, et Needs ne fait que les + // consommer. Le test verifie donc la chaine COMPLETE - Weather calcule, + // Needs subit - au lieu de la seule formule interne d'avant. + const WeatherSystem sky; + const float nightHours = 24.0f + 2.0f; // 2 h du matin, jour 1 + const WeatherSample lowAir = + sky.sampleAt(glm::vec3(0.0f, 300.0f, 0.0f), nightHours, nullptr); + const WeatherSample highAir = + sky.sampleAt(glm::vec3(0.0f, 1300.0f, 0.0f), nightHours, nullptr); + + NeedsContext valley; + valley.activity = Activity::Walk; + valley.ambientTemperatureC = lowAir.temperatureC; + NeedsContext summit = valley; + summit.ambientTemperatureC = highAir.temperatureC; + + Needs low; + Needs high; + runNeeds(low, valley, 20.0f * 60.0f, /*keepFedAndWatered=*/true); + runNeeds(high, summit, 20.0f * 60.0f, /*keepFedAndWatered=*/true); + check(high.temperature() < low.temperature(), + "Altitude : a 1000 m plus haut, on se refroidit plus vite"); + checkNear(low.ambientTemperatureC() - high.ambientTemperatureC(), + WeatherParams{}.lapseRateCPerKm, 1e-2f, + "Altitude : l'ecart d'ambiante vaut le gradient annonce"); + } + + // --- Horloge de jeu ------------------------------------------------------ + { + GameClock clock(9.0f, 12.0f); + checkNear(clock.hours(), 9.0f, 1e-6f, "Horloge : heure de depart"); + check(clock.clockText() == "09:00", "Horloge : texte a deux chiffres"); + + // 300 s reelles x 12 = 3600 s de jeu = une heure. + clock.advance(300.0f); + checkNear(clock.hours(), 10.0f, 1e-3f, + "Horloge : 5 min reelles = 1 h de jeu au facteur 12"); + check(clock.clockText() == "10:00", "Horloge : texte apres avance"); + + clock.advance(150.0f); + check(clock.clockText() == "10:30", "Horloge : demi-heure lisible"); + + // Une session d'une heure reelle traverse bien une journee. + GameClock day(9.0f, 12.0f); + day.advance(60.0f * 60.0f); + checkNear(day.hours(), 21.0f, 1e-2f, + "Horloge : 1 h reelle = 12 h de jeu, la nuit tombe dans la session"); + + // Repli au tour suivant, sans heure negative ni heure >= 24. + GameClock wrap(23.5f, 12.0f); + wrap.advance(300.0f); + checkNear(wrap.hours(), 0.5f, 1e-3f, "Horloge : passage de minuit"); + wrap.setHours(-2.0f); + checkNear(wrap.hours(), 22.0f, 1e-3f, "Horloge : reglage negatif ramene dans [0,24)"); + wrap.setHours(26.0f); + checkNear(wrap.hours(), 2.0f, 1e-3f, "Horloge : reglage au-dela de 24 h"); + } + + // --- Affichage ----------------------------------------------------------- + { + Needs needs; + const std::string summary = needs.summary(); + check(summary.find("faim 100%") != std::string::npos, + "Titre : la faim y figure en pourcentage entier"); + check(summary.find("forme 100%") != std::string::npos, + "Titre : la forme y figure (jauge a l'endroit, pas 'fatigue')"); + const std::string status = needs.statusLine(); + check(status.find("ambiante") != std::string::npos, + "Journal : la temperature ambiante y figure"); + check(status.find("deplacement") != std::string::npos, + "Journal : le coefficient de deplacement y figure"); + } + + // --- CONSEQUENCE REELLE : moins de distance a velo ------------------------ + // Le cahier des charges ne demande pas un coefficient, il demande un effet. + // On mesure donc la distance parcourue en une minute, pedale au plancher, + // avec et sans la penalite d'un joueur epuise. + { + Needs spent; + spent.setFatigue(0.0f); + const float factor = spent.movementFactor(); + check(factor < 0.6f, "Joueur epuise : le coefficient mord"); + + const float fresh = bikeDistance(1.0f, 60.0f); + const float tired = bikeDistance(factor, 60.0f); + check(tired < fresh, "Velo : un joueur epuise va moins loin en une minute"); + check(tired < 0.85f * fresh, + "Velo : la perte de distance est franche, pas symbolique"); + check(tired > 0.30f * fresh, + "Velo : le velo avance encore (pas de blocage)"); + } + + // --- CONSEQUENCE REELLE : escalade plus lente ---------------------------- + { + CliffTerrain cliff(0.0f, 3.0f, 0.0f, 40.0f); + constexpr float dt = 1.0f / 60.0f; + + auto climbGain = [&](float climbInput) { + Climber climber; + climber.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), + glm::vec3(1.0f, 0.0f, 0.0f)); + check(climber.climbing(), "Escalade : engagement pour la mesure"); + for (float t = 0.0f; t < 20.0f; t += dt) { + if (climber.update(dt, climbInput, 0.0f, cliff, nullptr) != + ClimbExit::None) { + break; + } + } + return climber.heightGained(); + }; + + Needs spent; + spent.setFatigue(0.0f); + const float full = climbGain(1.0f); + const float weak = climbGain(spent.movementFactor()); + check(full > 0.0f, "Escalade : un grimpeur frais gagne de la hauteur"); + check(weak < full, "Escalade : un joueur epuise grimpe moins haut en 20 s"); + check(weak > 0.0f, "Escalade : un joueur epuise grimpe encore"); + } +} + +void testWaterSources() { + section("Phase 16 : detection des points d'eau"); + + const WaterSurveyParams defaults; + + // --- Une cuvette est trouvee, et au bon endroit -------------------------- + { + // Courbure 0,004 : le pourtour a 25 m est 2,5 m plus haut que le fond, + // au-dessus des 1,5 m exiges. Levre a 40 m : au-dela, plateau plat, qui + // ne doit rien produire. + BowlTerrain bowl(120.0f, -80.0f, 0.004f, 40.0f); + const auto sources = findWaterSources(bowl, -500.0f, 500.0f, -500.0f, 500.0f); + check(!sources.empty(), "Cuvette : au moins un point d'eau trouve"); + if (!sources.empty()) { + // Le plus creux est le premier : c'est l'ordre annonce. + const float distance = + horizontalDistance(sources.front().position, glm::vec3(120.0f, 0.0f, -80.0f)); + check(distance <= defaults.scanStep, + "Cuvette : le meilleur point est a moins d'un pas de balayage du fond"); + checkNear(sources.front().position.y, + bowl.heightAt(sources.front().position.x, sources.front().position.z), + 1e-3f, "Cuvette : le point est SUR la surface"); + check(sources.front().depth >= defaults.minDepth, + "Cuvette : la profondeur retenue atteint le minimum exige"); + + for (std::size_t i = 1; i < sources.size(); ++i) { + check(sources[i].depth <= sources[i - 1].depth, + "Points d'eau : classes du plus creux au moins creux"); + } + } + } + + // --- Controles negatifs : ce qui ne doit RIEN produire ------------------- + { + FlatTerrain flat(500.0f); + check(findWaterSources(flat, -500.0f, 500.0f, -500.0f, 500.0f).empty(), + "Terrain plat : aucun point d'eau (plat n'est pas creux)"); + + // Un versant a 20 % : trop pentu, l'eau s'ecoule. + SlopedTerrain steep(0.0f, 0.20f); + check(findWaterSources(steep, -500.0f, 500.0f, -500.0f, 500.0f).empty(), + "Versant a 20 % : aucun point d'eau"); + + // Un versant DOUX a 5 % : la pente passe le filtre, mais il n'y a + // aucune concavite. C'est le controle qui separe les deux criteres - + // sans lui, un detecteur qui ne regarderait que la platitude passerait. + SlopedTerrain gentle(0.0f, 0.05f); + check(findWaterSources(gentle, -500.0f, 500.0f, -500.0f, 500.0f).empty(), + "Versant doux a 5 % : plat ne suffit pas, il faut du creux"); + + // Une bosse : plate au sommet, mais convexe. + DomeTerrain dome(0.0f, 0.0f, 0.004f, 0.0f); + check(findWaterSources(dome, -500.0f, 500.0f, -500.0f, 500.0f).empty(), + "Sommet de bosse : plat mais convexe, aucun point d'eau"); + } + + // --- Bords : les sondes ne doivent pas fabriquer de fausses cuvettes ------ + // heightAt est TOTALE (elle prolonge la hauteur du bord), donc sans le + // retrait d'une portee de sonde, tout le perimetre du terrain passerait + // pour un creux. + { + BowlTerrain bowl(0.0f, 0.0f, 0.004f, 40.0f); + const auto sources = findWaterSources(bowl, -300.0f, 300.0f, -300.0f, 300.0f); + for (const WaterSource& source : sources) { + check(source.position.x >= -300.0f + defaults.probeDistance - 1e-3f && + source.position.x <= 300.0f - defaults.probeDistance + 1e-3f && + source.position.z >= -300.0f + defaults.probeDistance - 1e-3f && + source.position.z <= 300.0f - defaults.probeDistance + 1e-3f, + "Points d'eau : aucun a portee de sonde du bord du terrain"); + } + + // Un rectangle plus petit que deux portees de sonde ne rend rien plutot + // que de sonder hors emprise. + check(findWaterSources(bowl, -10.0f, 10.0f, -10.0f, 10.0f).empty(), + "Emprise minuscule : aucun point d'eau, aucune sonde hors bornes"); + check(findWaterSources(bowl, 100.0f, -100.0f, -100.0f, 100.0f).empty(), + "Emprise inversee : rien, et pas de boucle infinie"); + } + + // --- Ecartement et bornage ----------------------------------------------- + { + // Centres poses SUR les points du balayage (x0 = -575, pas de 20) et + // ecartes de 200 m, donc au-dessus de la separation minimale de 150 m : + // les trois doivent ressortir, tous les trois. + MultiBowlTerrain bowl({{25.0f, 25.0f}, {225.0f, 25.0f}, {25.0f, 225.0f}}, + 0.004f, 40.0f); + const auto sources = findWaterSources(bowl, -600.0f, 600.0f, -600.0f, 600.0f); + check(sources.size() == 3, + "Trois cuvettes ecartees : trois points d'eau, un par cuvette"); + check(sources.size() <= defaults.maxSources, + "Points d'eau : la liste reste bornee"); + for (std::size_t i = 0; i < sources.size(); ++i) { + for (std::size_t j = i + 1; j < sources.size(); ++j) { + check(horizontalDistance(sources[i].position, sources[j].position) >= + defaults.minSeparation - 1e-3f, + "Points d'eau : deux points retenus sont toujours ecartes"); + } + } + + // Reproductible : deux balayages du meme relief donnent la meme liste. + // C'est la condition pour qu'un scenario Vulkan puisse aller boire au + // meme endroit deux fois de suite. + const auto again = findWaterSources(bowl, -600.0f, 600.0f, -600.0f, 600.0f); + check(again.size() == sources.size(), "Points d'eau : meme nombre a chaque balayage"); + bool identical = again.size() == sources.size(); + for (std::size_t i = 0; identical && i < sources.size(); ++i) { + identical = horizontalDistance(again[i].position, sources[i].position) < 1e-3f; + } + check(identical, "Points d'eau : balayage deterministe"); + } + + // --- Recherche du plus proche -------------------------------------------- + { + std::vector empty; + float distance = -1.0f; + check(nearestWaterSource(empty, glm::vec3(0.0f), &distance) == nullptr, + "Plus proche : rien a trouver dans une liste vide"); + + std::vector sources = { + WaterSource{glm::vec3(100.0f, 10.0f, 0.0f), 2.0f}, + WaterSource{glm::vec3(0.0f, 90.0f, 20.0f), 3.0f}, + }; + const WaterSource* best = + nearestWaterSource(sources, glm::vec3(5.0f, 0.0f, 5.0f), &distance); + check(best == &sources[1], "Plus proche : le bon point est retenu"); + // La distance est HORIZONTALE : les 90 m d'altitude du point ne doivent + // pas compter, sans quoi on ne pourrait jamais boire. + checkNear(distance, std::sqrt(25.0f + 225.0f), 1e-3f, + "Plus proche : la distance rendue est horizontale"); + check(distance < kDrinkReach * 10.0f, "Plus proche : ordre de grandeur coherent"); + } + + // --- Boire au point d'eau : la chaine complete ---------------------------- + // C'est le point d'ancrage demande : une jauge qui ne se remplit QUE si le + // joueur est reellement au bord d'un creux detecte sur le relief. + { + // Centre pose sur un point du balayage. Ce n'est pas un arrangement de + // confort : le balayage a un pas de 20 m, et le rayon utile d'une + // cuvette assez creuse pour etre retenue vaut une vingtaine de metres + // (au-dela, la pente depasse maxSlope) - c'est d'ailleurs pour ca que le + // pas du balayage vaut 20 m et non 50. Une cuvette placee entre deux + // points de grille peut malgre tout passer inapercue : c'est une limite + // REELLE de la methode, notee dans NOTES-PHASE16.md, pas un artefact de + // ce test. + BowlTerrain bowl(25.0f, 25.0f, 0.004f, 40.0f); + const auto sources = findWaterSources(bowl, -400.0f, 400.0f, -400.0f, 400.0f); + check(!sources.empty(), "Chaine complete : un point d'eau existe"); + if (!sources.empty()) { + const glm::vec3 atSource = sources.front().position; + const glm::vec3 farAway = atSource + glm::vec3(500.0f, 0.0f, 0.0f); + + float distance = 0.0f; + nearestWaterSource(sources, atSource, &distance); + check(distance <= kDrinkReach, "Chaine complete : au bord, on est a portee"); + + nearestWaterSource(sources, farAway, &distance); + check(distance > kDrinkReach, + "Chaine complete : a 500 m, on n'est pas a portee"); + + Needs needs; + needs.setThirst(0.1f); + nearestWaterSource(sources, atSource, &distance); + if (distance <= kDrinkReach) { + check(needs.drink(), "Chaine complete : on boit au point d'eau"); + } + checkNear(needs.thirst(), 1.0f, 1e-6f, + "Chaine complete : la soif est etanchee sur place"); + } + } +} + +// --------------------------------------------------------------------------- +// Phase 17 : empreinte environnementale (memoire du milieu, faune, degradation) +// --------------------------------------------------------------------------- +// Ce que ces tests couvrent : les deux memoires de l'Habitat et leur asymetrie, +// les seuils de faune et leur hysteresis, la mise a nu du sol et son effet REEL +// sur le semis d'herbe, le placement de la faune par tirage-rejet et ses +// filtres, les deux declencheurs de fuite, la disparition et le retour. +// +// Ce qu'ils ne couvrent pas : le rendu des animaux (aucun GPU ici) et +// l'impression PRODUITE sur un joueur, qui ne se teste pas - seulement le +// scenario Vulkan et l'oeil peuvent dire si "la vallee s'est videe" se voit. + +namespace { + +// Fait tourner l'Habitat pendant `seconds` SANS presence du joueur, au pas de +// 1/60 s. Passer un seul grand deltaTime ne testerait rien : Habitat::update +// ecrete a kMaxStep (0,25 s), donc un appel unique de 240 s ne ferait +// decroitre que d'un quart de seconde. C'est precisement le genre de piege que +// le test doit exercer, pas contourner. +void idleHabitat(Habitat& habitat, float seconds) { + constexpr float dt = 1.0f / 60.0f; + for (float t = 0.0f; t < seconds; t += dt) { + habitat.update(dt); + } +} + +// Presence continue du joueur au meme endroit pendant `seconds`. +void occupyHabitat(Habitat& habitat, const glm::vec3& position, float seconds, + float noise = 1.0f) { + constexpr float dt = 1.0f / 60.0f; + for (float t = 0.0f; t < seconds; t += dt) { + habitat.notePresence(position, dt, noise); + habitat.update(dt); + } +} + +} // namespace + +void testHabitatMemory() { + section("Phase 17 : memoire locale du milieu"); + + const glm::vec3 here(10.0f, 0.0f, 10.0f); + const glm::vec3 faraway(600.0f, 0.0f, 600.0f); + + // --- Un monde neuf ne se souvient de rien ------------------------------- + // C'est le contrat TOTAL de GroundCoverSource, et c'est ce qui garantit la + // non-regression : sans presence ni abattage, tout le reste du jeu doit se + // comporter exactement comme avant la Phase 17. + { + Habitat habitat; + check(habitat.trackedCellCount() == 0, "Neuf : aucune cellule memorisee"); + checkNear(habitat.disturbanceAt(0.0f, 0.0f), 0.0f, 1e-6f, + "Neuf : aucune frequentation"); + checkNear(habitat.loggingAt(0.0f, 0.0f), 0.0f, 1e-6f, + "Neuf : aucune deforestation"); + checkNear(habitat.groundCover(0.0f, 0.0f), 1.0f, 1e-6f, + "Neuf : le sol est intact"); + check(habitat.allowsWildlife(0.0f, 0.0f), "Neuf : la faune est chez elle"); + check(!habitat.wildlifeFlees(0.0f, 0.0f), "Neuf : rien ne fait fuir"); + } + + // --- La presence monte, et seulement la ou l'on est --------------------- + { + Habitat habitat; + occupyHabitat(habitat, here, 60.0f); + check(habitat.disturbanceAt(here.x, here.z) > 0.9f, + "Une minute de marche sur place sature la cellule"); + checkNear(habitat.disturbanceAt(faraway.x, faraway.z), 0.0f, 1e-6f, + "A 600 m, le milieu n'a rien remarque"); + check(habitat.trackedCellCount() > 1, + "Le derangement deborde sur les cellules voisines"); + + // Le debordement DECROIT avec la distance : c'est ce qui empeche la + // grille de 32 m de se lire comme une grille. + const float atPlayer = habitat.disturbanceAt(here.x, here.z); + const float aside = habitat.disturbanceAt(here.x + 40.0f, here.z); + check(aside > 0.0f, "La cellule voisine se souvient aussi"); + check(aside < atPlayer, "Mais moins que celle ou l'on se tient"); + } + + // --- L'oubli, et son ASYMETRIE ------------------------------------------ + { + Habitat habitat; + occupyHabitat(habitat, here, 60.0f); + const float peak = habitat.disturbanceAt(here.x, here.z); + + idleHabitat(habitat, 60.0f); + const float afterOneMinute = habitat.disturbanceAt(here.x, here.z); + check(afterOneMinute < peak, "La frequentation redescend quand on part"); + check(afterOneMinute > 0.5f * peak, + "On derange plus vite qu'on ne se fait oublier (asymetrie 4x)"); + + idleHabitat(habitat, 300.0f); + checkNear(habitat.disturbanceAt(here.x, here.z), 0.0f, 1e-6f, + "Cinq minutes de calme effacent le derangement"); + check(habitat.trackedCellCount() == 0, + "Une cellule revenue a neuf est OUBLIEE (la table ne gonfle pas)"); + } + + // --- Le bruit depend de l'activite -------------------------------------- + // La table activityNoise n'est PAS celle des efforts de la Phase 16, et + // l'escalade est le cas qui le prouve : effort maximal du joueur, et l'une + // des activites qui derange le moins. + { + check(activityNoise(Activity::Bike) > activityNoise(Activity::Walk), + "Le velo derange plus que la marche"); + check(activityNoise(Activity::Climb) < activityNoise(Activity::Walk), + "L'escalade derange moins que la marche"); + check(activityNoise(Activity::Climb) > activityNoise(Activity::Paraglide), + "Le parapente est ce qui derange le moins"); + check(activityNoise(Activity::Rest) > 0.0f, + "Meme immobile, un homme derange encore"); + check(activityNoise(Activity::Paraglide) > 0.0f, + "Aucune activite n'est parfaitement transparente"); + + Habitat bikeHabitat; + Habitat walkHabitat; + occupyHabitat(bikeHabitat, here, 20.0f, activityNoise(Activity::Bike)); + occupyHabitat(walkHabitat, here, 20.0f, activityNoise(Activity::Walk)); + check(bikeHabitat.disturbanceAt(here.x, here.z) > + walkHabitat.disturbanceAt(here.x, here.z), + "A duree egale, le velo laisse plus de trace que la marche"); + } + + // --- Les deux seuils de faune, et l'hysteresis -------------------------- + { + Habitat habitat; + occupyHabitat(habitat, here, 25.0f); + check(!habitat.wildlifeFlees(here.x, here.z), + "Vingt-cinq secondes ne suffisent pas a vider la zone"); + + occupyHabitat(habitat, here, 40.0f); + check(habitat.wildlifeFlees(here.x, here.z), + "Rester trop longtemps finit par faire fuir la faune"); + check(!habitat.allowsWildlife(here.x, here.z), + "Et elle ne revient pas tant qu'on est la"); + + // La bande d'hysteresis : entre les deux seuils, la faune ne fuit plus + // mais ne revient pas encore. Sans elle, une zone posee sur le seuil + // ferait clignoter les animaux a chaque image. + idleHabitat(habitat, 60.0f); + const float mid = habitat.disturbanceAt(here.x, here.z); + if (mid < habitat.params().fleeThreshold && + mid > habitat.params().respawnThreshold) { + check(!habitat.wildlifeFlees(here.x, here.z), + "Hysteresis : sous le seuil haut, on ne fuit plus"); + check(!habitat.allowsWildlife(here.x, here.z), + "Hysteresis : mais pas encore de retour"); + } + + idleHabitat(habitat, 240.0f); + check(habitat.allowsWildlife(here.x, here.z), + "Une zone laissee tranquille redevient accueillante"); + } + + // --- La deforestation : un compteur SEPARE, bien plus lent -------------- + { + Habitat habitat; + const glm::vec3 stump(16.0f, 0.0f, 16.0f); // centre de la cellule (0,0) + + habitat.recordFelling(stump); + check(habitat.treesFelledAt(stump.x, stump.z) == 1u, + "Un arbre abattu est compte"); + check(habitat.allowsWildlife(stump.x, stump.z), + "Un seul arbre ne suffit pas a interdire la faune"); + check(habitat.groundCover(stump.x, stump.z) < 1.0f, + "Il laisse tout de meme une marque au sol"); + check(habitat.groundCover(stump.x, stump.z) > 0.8f, + "Marque MODESTE : couper un arbre n'est pas une coupe rase"); + + habitat.recordFelling(stump); + check(!habitat.allowsWildlife(stump.x, stump.z), + "Deux arbres dans la meme cellule : la faune n'y revient plus"); + + habitat.recordFelling(stump); + checkNear(habitat.loggingAt(stump.x, stump.z), 1.0f, 1e-3f, + "Trois arbres saturent la cellule"); + checkNear(habitat.groundCover(stump.x, stump.z), + habitat.params().minGroundCover, 1e-3f, + "Le sol est aussi nu qu'il peut l'etre"); + + for (int i = 0; i < 10; ++i) { + habitat.recordFelling(stump); + } + check(habitat.loggingAt(stump.x, stump.z) <= 1.0f, + "Le compteur reste ecrete a 1"); + check(habitat.treesFelledAt(stump.x, stump.z) == 13u, + "Mais le COMPTE brut d'arbres, lui, continue de monter"); + + // Une coupe n'est PAS un derangement : elle survit tres largement au + // temps qu'il faut pour oublier un passage. + idleHabitat(habitat, 240.0f); + checkNear(habitat.disturbanceAt(stump.x, stump.z), 0.0f, 1e-6f, + "Quatre minutes plus tard, le bruit de la coupe est oublie"); + check(habitat.loggingAt(stump.x, stump.z) > 0.6f, + "La coupe, elle, est toujours la"); + check(habitat.groundCover(stump.x, stump.z) < 0.5f, + "Et le sol est toujours nu"); + + idleHabitat(habitat, 900.0f); + checkNear(habitat.groundCover(stump.x, stump.z), 1.0f, 1e-3f, + "Un quart d'heure de plus et le sous-bois est revenu"); + check(habitat.allowsWildlife(stump.x, stump.z), + "La faune peut y revenir"); + } + + // --- La coupe est LOCALE, et son bord est adouci ------------------------ + { + Habitat habitat; + const glm::vec3 stump(16.0f, 0.0f, 16.0f); + for (int i = 0; i < 3; ++i) { + habitat.recordFelling(stump); + } + + checkNear(habitat.groundCover(200.0f, 200.0f), 1.0f, 1e-6f, + "Deux cents metres plus loin, le sol est intact"); + + // Interpolation bilineaire : le couvert doit remonter PROGRESSIVEMENT en + // s'eloignant du centre de la coupe, sans marche d'escalier au bord de la + // cellule. Une valeur constante par cellule dessinerait un damier. + const float atCentre = habitat.groundCover(stump.x, stump.z); + const float at20 = habitat.groundCover(stump.x + 20.0f, stump.z); + const float at40 = habitat.groundCover(stump.x + 40.0f, stump.z); + check(atCentre < at20, "Le couvert remonte des qu'on s'ecarte du centre"); + check(at20 < at40, "Et continue de remonter : le bord est degrade"); + check(at40 <= 1.0f && atCentre >= habitat.params().minGroundCover, + "Le couvert interpole reste dans ses bornes"); + } + + // --- Robustesse du pas de temps ----------------------------------------- + // Meme garde-fou que Forest et Needs : une image anormalement longue ne doit + // pas faire un bond dans la memoire, et un pas negatif ne doit rien faire. + { + Habitat habitat; + habitat.notePresence(here, -1.0f, 1.0f); + check(habitat.trackedCellCount() == 0, "Un pas negatif n'ecrit rien"); + + habitat.notePresence(here, 1000.0f, 1.0f); + const float capped = habitat.disturbanceAt(here.x, here.z); + check(capped > 0.0f && capped < 0.1f, + "Une image de mille secondes est ecretee comme ailleurs"); + } +} + +void testAnimalMesh() { + section("Phase 17 : geometrie de la faune"); + + const MeshData animal = animalMeshData(); + check(!animal.empty(), "Le mesh d'animal n'est pas vide"); + check(animal.indices.size() % 3 == 0, "Indices par multiples de trois"); + check(animal.triangleCount() < 200u, + "Bas-poly assume : moins de 200 triangles"); + check(!animal.name.empty(), "Le mesh porte un nom lisible"); + + float minY = 1e9f, maxY = -1e9f, maxX = -1e9f, minX = 1e9f, maxAbsZ = 0.0f; + bool normalsUnit = true; + for (const Vertex& vertex : animal.vertices) { + minY = std::min(minY, vertex.pos.y); + maxY = std::max(maxY, vertex.pos.y); + minX = std::min(minX, vertex.pos.x); + maxX = std::max(maxX, vertex.pos.x); + maxAbsZ = std::max(maxAbsZ, std::abs(vertex.pos.z)); + normalsUnit = normalsUnit && std::abs(glm::length(vertex.normal) - 1.0f) < 1e-3f; + } + + // Convention de world/AnimalMesh.hpp : sabots a y = 0, regard vers +X. Un + // mesh centre sur l'origine s'enfoncerait de moitie dans le terrain, et un + // mesh regardant vers +Z tournerait le dos a son cap. + checkNear(minY, 0.0f, 1e-4f, "Les sabots sont a y = 0"); + checkNear(maxY, kAnimalHeight, 0.02f, "La hauteur annoncee est la bonne"); + check(maxX > 0.0f && std::abs(maxX) > std::abs(minX), + "L'animal regarde vers +X (la tete depasse la croupe)"); + check(maxX - minX <= kAnimalLength + 0.1f, "La longueur annoncee est tenue"); + check(2.0f * maxAbsZ <= kAnimalWidth + 0.1f, "La largeur annoncee est tenue"); + check(normalsUnit, "Toutes les normales sont unitaires"); + + // La matrice d'instance : meme convention de cap que le velo. + { + Animal deer; + deer.position = { 5.0f, 100.0f, -3.0f }; + deer.headingDegrees = 0.0f; + const glm::vec3 nose = + glm::vec3(deer.modelMatrix() * glm::vec4(1.0f, 0.0f, 0.0f, 1.0f)) - + deer.position; + checkNear(nose.x, 1.0f, 1e-4f, "Cap 0 : l'animal regarde vers +X"); + checkNear(nose.z, 0.0f, 1e-4f, "Cap 0 : rien sur Z"); + + deer.headingDegrees = 90.0f; + const glm::vec3 turned = + glm::vec3(deer.modelMatrix() * glm::vec4(1.0f, 0.0f, 0.0f, 1.0f)) - + deer.position; + checkNear(turned.z, 1.0f, 1e-4f, "Cap 90 : l'animal regarde vers +Z"); + checkNear(turned.x, 0.0f, 1e-4f, "Cap 90 : plus rien sur X"); + + // Le pied de l'animal reste ou on l'a mis, quelle que soit l'echelle : + // c'est ce qui permet de le poser sur le terrain sans correction. + deer.scale = 1.2f; + const glm::vec3 foot = + glm::vec3(deer.modelMatrix() * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)); + checkNear(foot.y, deer.position.y, 1e-4f, + "L'echelle ne decolle pas l'animal du sol"); + } +} + +void testWildlife() { + section("Phase 17 : faune, placement et fuite"); + + FlatTerrain flat(1200.0f); + ConstantMap wooded(0.6f); // au-dessus de WildlifeParams::minCover + ConstantMap bare(0.05f); // en dessous + const glm::vec3 player(0.0f, 1200.0f, 0.0f); + + // --- Placement par tirage-rejet ----------------------------------------- + { + Habitat habitat; + Wildlife wildlife(flat, &wooded, 4000.0f); + wildlife.populate(player, habitat); + + check(wildlife.animalCount() > 0, "Un bois calme se peuple"); + check(wildlife.animalCount() <= wildlife.params().maxAnimals, + "La population reste sous son plafond"); + check(wildlife.spawnCount() == wildlife.animalCount(), + "Le compteur d'apparitions suit la population"); + + bool inRing = true; + bool spaced = true; + bool onGround = true; + const auto& animals = wildlife.animals(); + for (std::size_t i = 0; i < animals.size(); ++i) { + const glm::vec3 delta = animals[i].position - player; + const float distance = std::sqrt(delta.x * delta.x + delta.z * delta.z); + inRing = inRing && distance >= wildlife.params().spawnRadiusMin - 0.01f && + distance <= wildlife.params().spawnRadiusMax + 0.01f; + onGround = onGround && std::abs(animals[i].position.y - 1200.0f) < 1e-3f; + for (std::size_t j = i + 1; j < animals.size(); ++j) { + const float dx = animals[i].position.x - animals[j].position.x; + const float dz = animals[i].position.z - animals[j].position.z; + spaced = spaced && (dx * dx + dz * dz) >= + wildlife.params().minSpacing * + wildlife.params().minSpacing - 0.01f; + } + } + // Le minimum de l'anneau EST le point important : un animal qui + // apparaitrait dans le champ proche montrerait la mecanique. + check(inRing, "Aucun animal n'apparait dans le champ proche du joueur"); + check(spaced, "Les animaux ne s'entassent pas"); + check(onGround, "Les animaux sont poses sur la surface du terrain"); + } + + // --- Determinisme (meme graine, meme monde) ----------------------------- + { + Habitat habitat; + Wildlife a(flat, &wooded, 4000.0f); + Wildlife b(flat, &wooded, 4000.0f); + a.populate(player, habitat); + b.populate(player, habitat); + bool identical = a.animalCount() == b.animalCount(); + for (std::size_t i = 0; identical && i < a.animals().size(); ++i) { + identical = glm::length(a.animals()[i].position - b.animals()[i].position) < 1e-5f; + } + check(identical, "Deux Wildlife de meme graine placent les memes animaux"); + } + + // --- Les filtres refusent ----------------------------------------------- + { + Habitat habitat; + Wildlife onBareRock(flat, &bare, 4000.0f); + onBareRock.populate(player, habitat); + check(onBareRock.animalCount() == 0, + "Aucun animal sur du lapiaz nu (carte de couvert)"); + + SlopedTerrain cliff(1200.0f, 1.6f); // 160 %, bien au-dela de maxSlope + Wildlife onCliff(cliff, &wooded, 4000.0f); + onCliff.populate(player, habitat); + check(onCliff.animalCount() == 0, "Aucun animal sur une paroi"); + + // Sans carte LiDAR, on ne refuse pas tout : c'est le cas du terrain + // synthetique, et un monde vide y serait un faux negatif permanent. + Wildlife noMap(flat, nullptr, 4000.0f); + noMap.populate(player, habitat); + check(noMap.animalCount() > 0, "Sans carte de couvert, la faune existe quand meme"); + + // Emprise : rien hors des donnees, meme si tout le reste est bon. + Wildlife tiny(flat, &wooded, 40.0f); + tiny.populate(player, habitat); + check(tiny.animalCount() == 0, + "Rien n'est place hors de l'emprise du terrain"); + } + + // --- Fuite 1 : le joueur s'approche trop pres --------------------------- + { + Habitat habitat; + Wildlife wildlife(flat, &wooded, 4000.0f); + wildlife.populate(player, habitat); + check(wildlife.fleeingCount() == 0, "Au repos, personne ne fuit"); + + const Animal target = wildlife.animals().front(); + // Le joueur se teleporte a cinq metres de cet animal. + const glm::vec3 intruder(target.position.x + 5.0f, target.position.y, + target.position.z); + wildlife.update(1.0f / 60.0f, intruder, habitat); + + check(wildlife.fleeingCount() >= 1, "S'approcher fait fuir"); + const Animal* moved = nullptr; + for (const Animal& animal : wildlife.animals()) { + if (animal.id == target.id) { + moved = &animal; + } + } + check(moved != nullptr, "L'animal derange est toujours la (il fuit, il ne disparait pas)"); + if (moved != nullptr) { + check(moved->state == AnimalState::Fleeing, "Il est en fuite"); + const float before = 5.0f; + for (int i = 0; i < 60; ++i) { + wildlife.update(1.0f / 60.0f, intruder, habitat); + } + const Animal* after = nullptr; + for (const Animal& animal : wildlife.animals()) { + if (animal.id == target.id) { + after = &animal; + } + } + if (after != nullptr) { + const float dx = after->position.x - intruder.x; + const float dz = after->position.z - intruder.z; + const float distance = std::sqrt(dx * dx + dz * dz); + check(distance > before, "Il s'ELOIGNE du joueur"); + check(distance > before + 0.5f * wildlife.params().fleeSpeed, + "Et il s'eloigne vite : poursuivre ne sert a rien"); + } + } + } + + // --- Fuite 2 : le joueur reste trop longtemps (LE point de la phase) ---- + // Le joueur ne s'est jamais approche a moins de 30 m. C'est la MEMOIRE du + // milieu, remplie par sa presence prolongee, qui vide la zone. + { + Habitat habitat; + Wildlife wildlife(flat, &wooded, 4000.0f); + wildlife.populate(player, habitat); + check(wildlife.animalCount() > 0, "Depart : le bois est habite"); + + const Animal target = wildlife.animals().front(); + // Camp installe a 40 m de l'animal : au-dela de fleeRadius (30 m), donc + // AUCUNE fuite par approche possible. + const glm::vec3 camp(target.position.x + 40.0f, target.position.y, + target.position.z); + check(glm::length(glm::vec2(camp.x - target.position.x, + camp.z - target.position.z)) > + wildlife.params().fleeRadius, + "Le camp est hors de la distance de fuite par approche"); + + // Quatre-vingt-dix secondes de camp. C'est ce que produit le modele a + // cette distance (ponderation 0,89 a 40 m sur un rayon de 120 m, voir + // Habitat::notePresence), et c'est le bon ordre de grandeur de jeu : on + // ne vide pas un vallon en le traversant, on le vide en s'y installant. + occupyHabitat(habitat, camp, 90.0f); + check(habitat.wildlifeFlees(target.position.x, target.position.z), + "Le milieu, lui, a retenu la presence prolongee"); + + wildlife.update(1.0f / 60.0f, camp, habitat); + bool stillCalm = false; + for (const Animal& animal : wildlife.animals()) { + if (animal.id == target.id) { + stillCalm = animal.state == AnimalState::Calm; + } + } + check(!stillCalm, "Rester trop longtemps vide la zone sans s'etre approche"); + } + + // --- Le milieu derange refuse les nouvelles apparitions ------------------ + { + Habitat saturated; + // On sature tout l'anneau d'apparition : le joueur a passe une minute + // partout. C'est artificiel - un vrai joueur mettrait une heure - mais + // c'est exactement l'etat que le systeme doit savoir produire. + for (float x = -320.0f; x <= 320.0f; x += 30.0f) { + for (float z = -320.0f; z <= 320.0f; z += 30.0f) { + saturated.notePresence({ x, 1200.0f, z }, 0.25f, 1.0f); + } + } + for (int i = 0; i < 300; ++i) { + for (float x = -320.0f; x <= 320.0f; x += 30.0f) { + for (float z = -320.0f; z <= 320.0f; z += 30.0f) { + saturated.notePresence({ x, 1200.0f, z }, 0.25f, 1.0f); + } + } + } + check(!saturated.allowsWildlife(150.0f, 0.0f), + "L'anneau entier est sature de frequentation"); + + Wildlife wildlife(flat, &wooded, 4000.0f); + wildlife.populate(player, saturated); + check(wildlife.animalCount() == 0, + "Une zone sur-frequentee ne se repeuple pas"); + + // ... ET LA FAUNE PEUT REVENIR. C'est la moitie du systeme : une + // consequence qu'on ne peut pas defaire serait une punition, pas un + // milieu vivant. + idleHabitat(saturated, 400.0f); + check(saturated.allowsWildlife(150.0f, 0.0f), + "Laissee tranquille, la zone redevient accueillante"); + wildlife.populate(player, saturated); + check(wildlife.animalCount() > 0, "Et la faune y revient"); + } + + // --- Une coupe interdit la faune bien plus longtemps qu'un passage ------ + { + Habitat habitat; + Wildlife wildlife(flat, &wooded, 4000.0f); + + // Deux arbres abattus dans chaque cellule de l'anneau. + for (float x = -320.0f; x <= 320.0f; x += 30.0f) { + for (float z = -320.0f; z <= 320.0f; z += 30.0f) { + habitat.recordFelling({ x, 1200.0f, z }); + habitat.recordFelling({ x, 1200.0f, z }); + } + } + wildlife.populate(player, habitat); + check(wildlife.animalCount() == 0, "Un versant deforeste reste vide"); + + // Quatre minutes suffisent a effacer un passage (test precedent) ; elles + // ne suffisent PAS a effacer une coupe. + idleHabitat(habitat, 240.0f); + wildlife.populate(player, habitat); + check(wildlife.animalCount() == 0, + "Quatre minutes plus tard, toujours vide : une coupe n'est pas un passage"); + } + + // --- Disparition au loin ------------------------------------------------- + { + Habitat habitat; + Wildlife wildlife(flat, &wooded, 4000.0f); + wildlife.populate(player, habitat); + const std::size_t before = wildlife.animalCount(); + check(before > 0, "Des animaux au depart"); + + const glm::vec3 elsewhere(3000.0f, 1200.0f, 3000.0f); + wildlife.update(1.0f / 60.0f, elsewhere, habitat); + check(wildlife.animalCount() == 0, + "A trois kilometres, la population precedente est oubliee"); + check(wildlife.despawnCount() == static_cast(before), + "Et les disparitions sont comptees"); + } +} + +void testEnvironmentalFootprint() { + section("Phase 17 : la coupe se VOIT au sol"); + + // Le bout de chaine qui compte : Habitat -> GroundCoverSource -> semis + // d'herbe. C'est la seule consequence VISUELLE de la degradation dans cette + // premiere version (voir NOTES-PHASE17.md pour ce qui a ete ecarte). + const Frustum frustum = permissiveFrustum(); + SlopedTerrain terrain(1200.0f, 0.0f); // plat, sous grassAltitudeLush + ConstantMap cover(0.5f); + ConstantMap noCanopy(0.0f); + const glm::vec3 eye(16.0f, 1200.0f, 16.0f); // centre de la cellule (0,0) + + std::vector reference; + { + Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f); + vegetation.gatherGrass(eye, frustum, reference); + check(!reference.empty(), "Sans degradation, le pre est herbeux"); + } + + // NON-REGRESSION LITTERALE : un Habitat vierge branche ne doit RIEN changer, + // pas "presque rien". C'est ce que garantit le contrat total de + // GroundCoverSource, et c'est ce qui permet d'affirmer que la Phase 17 ne + // touche pas au decor d'un monde qu'on n'a pas abime. + { + Habitat habitat; + Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f); + vegetation.setGroundCover(&habitat); + std::vector tufts; + vegetation.gatherGrass(eye, frustum, tufts); + check(tufts.size() == reference.size(), + "Habitat vierge : le semis d'herbe est INCHANGE"); + } + + // Trois arbres abattus dans la cellule sous les pieds. + { + Habitat habitat; + for (int i = 0; i < 3; ++i) { + habitat.recordFelling(eye); + } + Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f); + vegetation.setGroundCover(&habitat); + std::vector tufts; + vegetation.gatherGrass(eye, frustum, tufts); + + check(tufts.size() < reference.size(), + "Apres la coupe, le sol se denude"); + check(!tufts.empty(), + "Mais il reste des touffes : une coupe rase n'est pas de la roche"); + + // La mise a nu est LOCALE : les touffes qui subsistent sont surtout + // celles des cellules voisines, epargnees par la coupe. + std::size_t nearStump = 0; + std::size_t nearStumpBefore = 0; + for (const InstanceData& tuft : tufts) { + if (std::abs(tuft.position.x - eye.x) < 12.0f && + std::abs(tuft.position.z - eye.z) < 12.0f) { + ++nearStump; + } + } + for (const InstanceData& tuft : reference) { + if (std::abs(tuft.position.x - eye.x) < 12.0f && + std::abs(tuft.position.z - eye.z) < 12.0f) { + ++nearStumpBefore; + } + } + check(nearStump < nearStumpBefore, + "Le manque se voit AU PIED de la coupe"); + check(static_cast(nearStump) / std::max(1, nearStumpBefore) < + 0.5, + "Et il s'y voit franchement (plus de la moitie de l'herbe en moins)"); + } + + // La repousse rend son herbe au sol : le systeme est reversible. + { + Habitat habitat; + for (int i = 0; i < 3; ++i) { + habitat.recordFelling(eye); + } + idleHabitat(habitat, 1200.0f); + Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f); + vegetation.setGroundCover(&habitat); + std::vector tufts; + vegetation.gatherGrass(eye, frustum, tufts); + check(tufts.size() == reference.size(), + "Vingt minutes plus tard, l'herbe est integralement revenue"); + } +} + +// =========================================================================== +// PHASE 20 : la collision s'etend a la faune +// =========================================================================== +// Ce qui est verifie ici n'est pas "il y a du code de collision" mais "sans le +// solveur, on TRAVERSE ; avec lui, on s'arrete la ou le modele le dit". C'est +// la meme methode qu'en Phase 15 pour les objets d'editeur : un temoin negatif +// et un chiffre PREDIT, pas une impression. +// +// Le temoin est obtenu en rejouant EXACTEMENT le meme monde avec +// WildlifeParams::solid a false - c'est-a-dire l'option --no-animal-collision +// du jeu. Meme graine, donc meme semis, donc meme animal a la meme place : la +// seule difference entre les deux marches est la collision elle-meme. + +namespace { + +// Marche en ligne droite, pas par pas, par le MEME moveBody que la camera, le +// velo et le grimpeur. Renvoie la position finale ; remplit les temoins passes +// en pointeur (peuvent etre nuls). +glm::vec3 walkThrough(const CollisionSolver& solver, const glm::vec3& start, + const glm::vec3& direction, int steps, float stepLength, + const glm::vec3& landmark, float* closestApproachOut, + bool* sawNaNOut) { + glm::vec3 position = start; + float closest = horizontalDistance(start, landmark); + bool sawNaN = false; + + for (int step = 0; step < steps; ++step) { + const glm::vec3 previous = position; + const glm::vec3 desired = position + direction * stepLength; + + BodyCylinder body = standingBody(desired.x, desired.z); + position = moveBody(solver, body, previous); + + if (std::isnan(position.x) || std::isnan(position.z)) { + sawNaN = true; + break; + } + closest = std::min(closest, horizontalDistance(position, landmark)); + } + + if (closestApproachOut != nullptr) { + *closestApproachOut = closest; + } + if (sawNaNOut != nullptr) { + *sawNaNOut = sawNaN; + } + return position; +} + +} // namespace + +void testWildlifeCollision() { + section("Phase 20 : collision de la faune"); + + FlatTerrain flat(0.0f); + ConstantMap wooded(0.6f); + const glm::vec3 player(0.0f, 1.7f, 0.0f); + + // Deux mondes IDENTIQUES a une option pres. La graine par defaut est la + // meme, le terrain est le meme, le semis est donc le meme animal a la meme + // place - c'est ce qui autorise a comparer les deux marches. + // + // UN SEUL animal, et c'est ce qui rend la mesure interpretable : avec la + // population par defaut (24 animaux espaces d'au moins 14 m), un trajet de + // 20 m peut en croiser un SECOND, et la marche s'arrete alors sur celui-la. + // Le premier jet de ce test echouait exactement la-dessus : la collision + // fonctionnait, c'est la distance predite qui parlait du mauvais animal. + WildlifeParams soloParams; + soloParams.maxAnimals = 1; + WildlifeParams passableParams = soloParams; + passableParams.solid = false; // == --no-animal-collision + + Habitat habitat; + Wildlife solidFauna(flat, &wooded, 4000.0f, soloParams); + Wildlife passableFauna(flat, &wooded, 4000.0f, passableParams); + solidFauna.populate(player, habitat); + passableFauna.populate(player, habitat); + + check(solidFauna.animalCount() > 0, "Un animal est seme pour la mesure"); + check(solidFauna.animalCount() == passableFauna.animalCount(), + "Temoin et mesure ont la meme population"); + + const Animal& animal = solidFauna.animals()[0]; + const Animal& twin = passableFauna.animals()[0]; + check(horizontalDistance(animal.position, twin.position) < 1e-4f, + "Temoin et mesure ont le meme animal au meme endroit"); + + // Rayon d'arret ATTENDU, calcule ici et pas lu dans le solveur : rayon de + // collision de cet animal + demi-largeur du joueur. + const float reach = solidFauna.colliderRadiusOf(animal) + 0.35f; + + // Trajet : on part a 10 m de l'animal et on marche DROIT dessus sur 20 m, + // donc de quoi ressortir largement de l'autre cote si rien n'arrete. + const glm::vec3 toPlayer = + glm::normalize(glm::vec3(player.x - animal.position.x, 0.0f, + player.z - animal.position.z)); + const glm::vec3 start = animal.position + toPlayer * 10.0f + glm::vec3(0.0f, 1.7f, 0.0f); + const glm::vec3 heading = -toPlayer; + + float closestWithSolver = 0.0f; + bool sawNaN = false; + const glm::vec3 stopped = walkThrough(solidFauna, start, heading, 400, 0.05f, + animal.position, &closestWithSolver, &sawNaN); + + float closestWitness = 0.0f; + bool witnessNaN = false; + const glm::vec3 crossed = walkThrough(passableFauna, start, heading, 400, 0.05f, + animal.position, &closestWitness, &witnessNaN); + + const float travelled = horizontalDistance(stopped, start); + const float travelledWitness = horizontalDistance(crossed, start); + + check(!sawNaN && !witnessNaN, "Aucun NaN sur les 400 pas des deux marches"); + + // --- LE TEMOIN : sans collision, on passe AU TRAVERS --------------------- + // Mesure : approche la plus proche 0,0010 m, soit le centre de l'animal, et + // les 20 m parcourus en entier. C'est le comportement d'avant la Phase 20. + check(closestWitness < 0.05f, + "Temoin (--no-animal-collision) : la marche passe par le centre de l'animal"); + check(travelledWitness > 19.9f, + "Temoin : les 20 m sont parcourus, l'animal ne freine rien"); + + // --- LA MESURE : le contact a lieu au rayon PREDIT ----------------------- + // La premiere version de ce test attendait un ARRET NET a `10 - reach`, et + // elle avait tort - la mesure l'a dit tout de suite : 13,20 m parcourus au + // lieu des 8,96 m attendus, pour une approche la plus proche de 1,0418 m + // EXACTEMENT egale au rayon predit. + // + // Ce n'est pas un defaut, c'est le GLISSEMENT que le solveur par + // repoussement produit exprès (voir CollisionSolver.hpp : "on longe un tronc + // au lieu de s'y coller net"). Contre un obstacle convexe ISOLE, une poussee + // frontale n'est jamais parfaitement frontale a l'arrondi pres, et la + // composante laterale accumulee fait contourner l'animal. Le joueur en sort + // par le cote, comme il contournerait un tronc. + // + // La grandeur qui est reellement PREDITE par le modele, et qu'on verifie + // donc, est le rayon de CONTACT : rayon de collision de l'animal + demi- + // largeur du joueur. Elle est atteinte au millimetre pres. + check(closestWithSolver >= reach - 1e-3f, + "Avec collision : jamais a l'interieur de l'animal"); + check(std::abs(closestWithSolver - reach) < 1e-3f, + "Avec collision : le contact a lieu exactement au rayon predit"); + check(travelled < travelledWitness - 5.0f, + "Avec collision : contourner l'animal coute de la distance (13,2 m contre 20,0 m)"); + check(horizontalDistance(stopped, animal.position) > reach - 1e-3f, + "Avec collision : la marche finit hors de l'animal, pas dedans"); + + // --- Coherence resolve / overlaps --------------------------------------- + // Le contrat de CollisionSolver : la sortie de resolve() doit etre LIBRE, + // sinon moveBody() refuserait tout deplacement le long d'un animal. + { + BodyCylinder inside = standingBody(animal.position.x + 0.1f, + animal.position.z + 0.1f); + check(solidFauna.overlaps(inside), "Un corps dans l'animal est declare en contact"); + + BodyCylinder pushed = inside; + pushed.position = solidFauna.resolve(inside); + check(!solidFauna.overlaps(pushed), "La sortie de resolve() est libre"); + check(std::abs(horizontalDistance(pushed.position, animal.position) - reach) < 1e-3f, + "resolve() repousse exactement au contact"); + } + + // --- Cas degenere : le joueur exactement sur l'axe de l'animal ----------- + // Un animal peut venir se poser sur un joueur immobile, puisqu'il bouge et + // que le joueur n'appelle moveBody() qu'en se deplacant. + { + BodyCylinder centred = standingBody(animal.position.x, animal.position.z); + const glm::vec3 out = solidFauna.resolve(centred); + check(!std::isnan(out.x) && !std::isnan(out.z), + "Joueur exactement sur l'animal : aucun NaN"); + check(std::abs(horizontalDistance(out, animal.position) - reach) < 1e-3f, + "Joueur exactement sur l'animal : ecarte au contact"); + } + + // --- La bande verticale : un animal n'est pas un mur ------------------- + // C'est ce qui rend l'extension sans danger pour l'ESCALADE. Le grimpeur + // soumet une bande centree sur son point d'ancrage : des qu'il est plus + // haut qu'un cervide, la faune du pied de la paroi ne peut plus le + // concerner. Aucune ligne de Climber n'a ete ecrite pour ca. + { + BodyCylinder onTheWall; + onTheWall.radius = 0.35f; + onTheWall.position = { animal.position.x, animal.position.y + 3.0f, + animal.position.z }; + onTheWall.feetY = animal.position.y + 2.4f; + onTheWall.headY = animal.position.y + 3.6f; + check(!solidFauna.overlaps(onTheWall), + "Un grimpeur au-dessus du cervide n'est pas gene par lui"); + + BodyCylinder atItsFeet = standingBody(animal.position.x, animal.position.z); + check(solidFauna.overlaps(atItsFeet), + "Le meme point, au sol, est bien bloque"); + } + + // --- Le rayon suit l'echelle du mesh ------------------------------------ + { + bool radiusFollowsScale = true; + for (const Animal& each : solidFauna.animals()) { + radiusFollowsScale = + radiusFollowsScale && + std::abs(solidFauna.colliderRadiusOf(each) - + solidFauna.params().colliderRadius * each.scale) < 1e-6f; + } + check(radiusFollowsScale, "Le rayon de collision suit l'echelle de l'animal"); + check(std::abs(solidFauna.params().colliderRadius - 0.5f * kAnimalLength) < 1e-6f, + "Le rayon par defaut est la demi-longueur du mesh"); + } + + // --- Le monde entier, par le solveur composite -------------------------- + // Le chemin REEL du jeu : les trois sources d'obstacles dans le meme + // CompositeCollisionSolver, comme main.cpp les y met. + { + Ground ground(flat); + ForestParams noTrees; + noTrees.treeCount = 0; + Forest forest(flat, ground, 100.0f, noTrees); + forest.plantTree(6.0f, 0.0f, 8.0f); + + AssetCatalog catalog; + catalog.addBuiltins(); + EditorScene scene(&catalog); + PlacedObject rock; + rock.asset = "rocher"; + rock.position = { 12.0f, 0.0f, 0.0f }; + rock.solid = true; + scene.place(rock); + + CompositeCollisionSolver world; + world.add(&forest); + world.add(&scene); + world.add(&solidFauna); + check(world.size() == 3, "Composite : trois sources d'obstacles"); + + BodyCylinder walker = standingBody(6.0f, 0.0f); + check(world.overlaps(walker), "Composite : le tronc bloque toujours (Phase 6)"); + walker = standingBody(12.0f, 0.0f); + check(world.overlaps(walker), "Composite : le rocher pose bloque toujours (Phase 15)"); + walker = standingBody(animal.position.x, animal.position.z); + check(world.overlaps(walker), "Composite : l'animal bloque desormais (Phase 20)"); + walker = standingBody(3.0f, 0.0f); + check(!world.overlaps(walker), "Composite : le passage libre le reste"); + + // --- DECISION DOCUMENTEE : les objets au sol ne bloquent PAS -------- + // Ground n'est pas un CollisionSolver et n'est pas dans ce composite. + // Ce n'est pas un oubli : buches, branches, pierres et eclats sont des + // cibles de RAMASSAGE (Ground::findNearest exige de s'en approcher), et + // le plus haut d'entre eux - la pierre - culmine a 0,40 m, sous le + // genou. Un debitage depose 3 a 4 buches autour du joueur : les rendre + // solides pourrait l'emmurer dans le bois qu'il vient de produire. + ground.drop(GroundItemKind::Stone, 3.0f, 0.0f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Log, 3.4f, 0.0f, 0.0f, 0.0f); + check(ground.itemCount() >= 2, "Deux objets sont bien poses sur le trajet"); + check(2.0f * kStoneRadius < 0.5f, + "Le plus haut objet au sol reste sous le genou"); + walker = standingBody(3.0f, 0.0f); + check(!world.overlaps(walker), + "Un objet ramassable au sol ne bloque pas (decision de la Phase 20)"); + } + + // --- LE VELO : la meme collision, sans une ligne ecrite dans Bike -------- + // La consigne de la phase demandait explicitement que l'extension vaille + // pour TOUTES les activites qui se deplacent, pas seulement la marche. Le + // velo est le cas qui compte le plus : il roule a 30 km/h, c'est-a-dire a + // la vitesse de FUITE de l'animal (8 m/s), donc c'est la seule activite qui + // peut reellement rattraper un cervide et lui rentrer dedans. A pied, on + // n'en approche jamais - il part a 30 m. + { + // On enfourche a 15 m de l'animal, cap droit dessus. Convention de cap + // du velo : 0 = +X, croissant vers +Z (voir Bike.hpp). + const glm::vec3 mountPoint = animal.position + toPlayer * 15.0f; + const glm::vec3 toAnimal = -toPlayer; + const float headingDegrees = glm::degrees(std::atan2(toAnimal.z, toAnimal.x)); + + auto rideAt = [&](const Wildlife& fauna) { + Bike bike; + bike.mount(mountPoint, headingDegrees, flat); + float closest = horizontalDistance(bike.position(), animal.position); + for (int i = 0; i < 900; ++i) { + bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, &fauna); + closest = std::min(closest, horizontalDistance(bike.position(), + animal.position)); + } + return closest; + }; + + const float closestRiding = rideAt(solidFauna); + const float closestRidingWitness = rideAt(passableFauna); + + check(closestRidingWitness < 0.5f, + "Velo, temoin : sans collision le velo passe sur l'animal"); + check(closestRiding >= reach - 1e-3f, + "Velo : le cycliste bute sur l'animal au lieu de le traverser"); + check(closestRiding > closestRidingWitness + 0.4f, + "Velo : l'ecart avec le temoin est celui d'un obstacle reel"); + } + + // --- L'ESCALADE : concernee au PIED de la paroi, jamais dessus ----------- + // Le grimpeur recoit le meme `worldSolver` que les deux autres, donc il + // herite de la collision sans qu'une ligne de Climber change (le test de la + // Phase 14 le prouve deja pour les troncs). Mais il y a mieux, et c'est une + // propriete du MODELE, pas du code : un animal ne peut pas se tenir sur une + // surface assez raide pour etre grimpable. + // + // C'est le meme genre de rapport entre deux constantes reglees separement + // que la lecon de la Phase 17 (noiseRadius vs spawnRadiusMin) - sauf qu'ici + // le rapport est celui qu'on veut, et cette assertion est ce qui empeche de + // le perdre par inadvertance en retouchant l'une des deux. + { + const ClimberParams climbing; + // PHASE 24 : les deux nombres ont bouge ensemble (1,00 -> 0,84 pour la + // paroi, 0,90 -> 0,80 pour l'animal). L'assertion, elle, n'a pas + // change - et c'est exactement ce qu'on lui demandait : elle porte le + // RAPPORT, pas les valeurs, donc elle survit au reglage et continue + // d'interdire de le perdre. + check(WildlifeParams{}.maxSlope < climbing.wallSlope, + "Aucun animal ne peut se tenir sur une pente grimpable " + "(maxSlope < wallSlope)"); + + // Et en paroi, la bande verticale suffit de toute facon : verifie plus + // haut ("Un grimpeur au-dessus du cervide n'est pas gene par lui"). + } + + // --- Le temoin, une derniere fois, cote interface ------------------------ + { + BodyCylinder centred = standingBody(twin.position.x, twin.position.z); + check(!passableFauna.overlaps(centred), + "--no-animal-collision : aucun contact declare"); + check(passableFauna.resolve(centred) == centred.position, + "--no-animal-collision : resolve() rend la position telle quelle"); + } +} + +// =========================================================================== +// PHASE 22 : les gisements d'argile et de sable +// =========================================================================== +// Ce que ces tests peuvent prouver et ce qu'ils ne peuvent PAS prouver merite +// d'etre dit une fois : ils verifient que le detecteur applique bien la regle +// annoncee dans world/Deposits.hpp (creux + versant amont, puis partage par la +// distance a l'eau). Ils ne verifient AUCUNEMENT qu'il y a de l'argile la ou il +// en place - c'est un proxy morphologique, pas une carte geologique, et aucun +// test ne peut valider une vraisemblance. +void testMineralDeposits() { + section("Phase 22 : gisements d'argile et de sable"); + + const DepositSurveyParams defaults; + const std::vector noWater; + + // --- Un creux alimente par un versant est trouve ------------------------ + { + // Cuvette de courbure 0,006 : le pourtour a 25 m est 3,75 m plus haut + // que le fond, donc au-dessus de minUpslope (3,0 m). Levre a 60 m. + BowlTerrain bowl(160.0f, -120.0f, 0.006f, 60.0f); + const auto deposits = + findMineralDeposits(bowl, -600.0f, 600.0f, -600.0f, 600.0f, noWater); + + check(!deposits.empty(), "Cuvette : au moins un gisement trouve"); + if (!deposits.empty()) { + const float distance = horizontalDistance( + deposits.front().position, glm::vec3(160.0f, 0.0f, -120.0f)); + check(distance <= defaults.scanStep, + "Cuvette : le meilleur gisement est a moins d'un pas du fond"); + checkNear(deposits.front().position.y, + bowl.heightAt(deposits.front().position.x, + deposits.front().position.z), + 1e-3f, "Cuvette : le gisement est SUR la surface"); + check(deposits.front().upslope >= defaults.minUpslope, + "Cuvette : le denivele amont retenu atteint le minimum exige"); + + for (std::size_t i = 1; i < deposits.size(); ++i) { + check(deposits[i].depth <= deposits[i - 1].depth, + "Gisements : classes du plus creux au moins creux"); + } + // Ecartement : c'est la seule garantie qui empeche une grande + // cuvette de rendre quarante gisements colles. + bool spaced = true; + for (std::size_t i = 0; i < deposits.size(); ++i) { + for (std::size_t j = i + 1; j < deposits.size(); ++j) { + if (horizontalDistance(deposits[i].position, deposits[j].position) + < defaults.minSeparation - 1e-3f) { + spaced = false; + } + } + } + check(spaced, + "Gisements : deux retenus sont toujours separes de minSeparation"); + } + } + + // --- Controles negatifs : ce qui ne doit RIEN produire ------------------ + { + FlatTerrain flat(500.0f); + check(findMineralDeposits(flat, -600.0f, 600.0f, -600.0f, 600.0f, noWater).empty(), + "TEMOIN terrain plat : aucun gisement (plat n'est ni creux ni alimente)"); + + // Bosse PURE : convexe PARTOUT, sans palier. Courbure choisie faible + // (0,00002) pour que la pente reste sous maxSlope sur tout le + // rectangle - sans quoi le rejet viendrait de la pente et non de la + // convexite, et le temoin ne prouverait pas ce qu'il annonce. + DomeTerrain dome(0.0f, 0.0f, 0.00002f, -1.0e6f); + check(findMineralDeposits(dome, -600.0f, 600.0f, -600.0f, 600.0f, noWater).empty(), + "TEMOIN bosse convexe partout : aucun gisement"); + + // Versant regulier a 40 % : pente trop forte ET aucune concavite. + SlopedTerrain steep(0.0f, 0.40f); + check(findMineralDeposits(steep, -600.0f, 600.0f, -600.0f, 600.0f, noWater).empty(), + "TEMOIN versant a 40 % : aucun gisement"); + + // MAIS le PIED d'une bosse, lui, doit etre retenu - et c'est une + // propriete voulue, pas un accident. La rupture de pente au bas d'un + // versant est CONCAVE et a tout le versant au-dessus d'elle : c'est + // exactement la definition d'un cone de dejection, l'endroit le plus + // credible de tout un relief pour trouver du sediment. + // + // Ce cas a d'abord ete ecrit comme un controle NEGATIF, et la mesure a + // montre qu'il ne devait pas l'etre : la bosse a palier rend deux + // gisements a 160 m du centre, avec 8,1 m de concavite et 26,8 m de + // versant au-dessus. C'est le detecteur qui avait raison. + DomeTerrain footed(0.0f, 0.0f, 0.004f, 0.0f); + const auto atFoot = + findMineralDeposits(footed, -600.0f, 600.0f, -600.0f, 600.0f, noWater); + check(!atFoot.empty(), "Pied de bosse : des gisements y sont retenus"); + for (const MineralDeposit& deposit : atFoot) { + const float radius = horizontalDistance(deposit.position, glm::vec3(0.0f)); + check(radius > 100.0f, + "Pied de bosse : les gisements sont au PIED, pas au sommet"); + check(deposit.upslope > deposit.depth, + "Pied de bosse : le versant amont domine largement la concavite"); + } + } + + // --- LE controle qui distingue ce detecteur de celui des points d'eau ---- + // Une cuvette TRES PLATE : concave, mais dont le pourtour ne domine le fond + // que de 1,0 m. Elle passe le critere de concavite et doit etre rejetee par + // le seul critere de denivele amont. Sans ce test, minUpslope pourrait etre + // supprime sans qu'aucune verification ne bronche. + { + // Une cuvette dont le RELIEF TOTAL est plafonne a 2 m : aucun point du + // terrain ne peut donc en dominer un autre de plus de 2 m, et le + // critere de denivele amont (3 m) est le SEUL qui puisse la rejeter. + // + // Le premier jet de ce temoin plafonnait a 40 m et il etait faux : la + // mesure a montre que le detecteur retenait alors trois points sur un + // anneau a 60 m du centre, ou le flanc de la cuvette fournit 5,5 m + // d'amont. Une cuvette n'est "sans amont" qu'a son centre, pas partout. + BowlTerrain shallow(0.0f, 0.0f, 0.0016f, 2.0f); + const auto deposits = + findMineralDeposits(shallow, -600.0f, 600.0f, -600.0f, 600.0f, noWater); + check(deposits.empty(), + "TEMOIN cuvette sans amont : rejetee par minUpslope, pas par la concavite"); + + // La MEME cuvette avec minUpslope abaisse : elle passe. C'est ce qui + // prouve que c'est bien ce seuil-la qui l'avait ecartee, et non un + // autre filtre. + DepositSurveyParams permissive; + permissive.minUpslope = 0.5f; + check(!findMineralDeposits(shallow, -600.0f, 600.0f, -600.0f, 600.0f, + noWater, permissive).empty(), + "Cuvette sans amont : retenue des que minUpslope est abaisse"); + } + + // --- Le partage argile / sable ------------------------------------------ + { + BowlTerrain bowl(160.0f, -120.0f, 0.006f, 60.0f); + + // Sans aucun point d'eau connu : TOUT est sable. C'est le comportement + // annonce - sans eau, on n'affirme rien sur l'argile. + const auto dry = + findMineralDeposits(bowl, -600.0f, 600.0f, -600.0f, 600.0f, noWater); + bool allSand = !dry.empty(); + for (const MineralDeposit& deposit : dry) { + if (deposit.kind != DepositKind::Sand) { + allSand = false; + } + } + check(allSand, "TEMOIN sans point d'eau : tous les gisements sont du sable"); + + // Avec un point d'eau POSE AU FOND de la cuvette : le gisement du fond + // devient de l'argile. Meme terrain, meme balayage : la SEULE chose qui + // a change est la liste des points d'eau. + std::vector water; + water.push_back(WaterSource{glm::vec3(160.0f, 0.0f, -120.0f), 3.0f}); + const auto wet = + findMineralDeposits(bowl, -600.0f, 600.0f, -600.0f, 600.0f, water); + check(dry.size() == wet.size(), + "Le point d'eau ne change PAS quels creux sont retenus, seulement leur nature"); + check(!wet.empty() && wet.front().kind == DepositKind::Clay, + "Creux au bord de l'eau : classe ARGILE"); + check(!wet.empty() && wet.front().waterDistance <= defaults.clayWaterRadius, + "Creux classe argile : sa distance a l'eau est bien sous le rayon"); + + // Un gisement au-dela du rayon reste du sable, dans le MEME balayage : + // c'est ce qui prouve que le partage est local et non global. + for (const MineralDeposit& deposit : wet) { + if (deposit.waterDistance > defaults.clayWaterRadius) { + check(deposit.kind == DepositKind::Sand, + "Creux loin de l'eau : classe SABLE, dans le meme balayage"); + } + } + } + + // --- Recherche du plus proche, et son temoin ---------------------------- + { + std::vector deposits; + MineralDeposit a; + a.position = glm::vec3(0.0f, 10.0f, 0.0f); + a.kind = DepositKind::Clay; + MineralDeposit b; + b.position = glm::vec3(50.0f, 90.0f, 0.0f); + b.kind = DepositKind::Sand; + deposits.push_back(a); + deposits.push_back(b); + + float distance = -1.0f; + const MineralDeposit* found = + nearestDeposit(deposits, glm::vec3(4.0f, 0.0f, 3.0f), &distance); + check(found != nullptr && found->kind == DepositKind::Clay, + "nearestDeposit : rend bien le plus proche a l'horizontale"); + checkNear(distance, 5.0f, 1e-3f, + "nearestDeposit : la distance rendue est horizontale"); + + // L'altitude ne doit PAS entrer dans le calcul : b est 80 m plus haut, + // et pourtant c'est lui le plus proche depuis un point proche de lui. + found = nearestDeposit(deposits, glm::vec3(48.0f, 0.0f, 0.0f), &distance); + check(found != nullptr && found->kind == DepositKind::Sand, + "nearestDeposit : l'altitude n'intervient pas"); + + const std::vector empty; + check(nearestDeposit(empty, glm::vec3(0.0f)) == nullptr, + "TEMOIN liste vide : nearestDeposit rend nullptr"); + } + + // --- Rectangles degeneres : aucune sortie, aucun plantage --------------- + { + FlatTerrain flat; + check(findMineralDeposits(flat, 10.0f, 10.0f, -100.0f, 100.0f, noWater).empty(), + "Rectangle de largeur nulle : aucun gisement, aucun plantage"); + check(findMineralDeposits(flat, -10.0f, 10.0f, -10.0f, 10.0f, noWater).empty(), + "Rectangle plus petit qu'une portee de sonde : aucun gisement"); + } + + // --- Les deux natures ont un libelle ------------------------------------ + { + check(std::strcmp(depositLabel(DepositKind::Clay), "gisement") != 0, + "L'argile a son libelle propre"); + check(std::strcmp(depositLabel(DepositKind::Sand), "gisement") != 0, + "Le sable a son libelle propre"); + } +} + +// =========================================================================== +// PHASE 22 / PHASE 26 : essences d'arbres et recolte de resine +// =========================================================================== +void testResin() { + section("Phase 22 / 26 : essences d'arbres et resine de pin"); + + // --- TreeSpecies : Le tirage d'essence est DETERMINISTE et reparti ------ + { + bool identical = true; + int coniferCount = 0; + for (int i = 0; i < 2000; ++i) { + const float x = static_cast(i % 45) * 12.0f; + const float z = static_cast(i / 45) * 12.0f; + const TreeSpecies a = treeSpeciesAt(x, z, 0.0f); + const TreeSpecies b = treeSpeciesAt(x, z, 0.0f); + if (a != b) { + identical = false; + } + if (a == TreeSpecies::Conifer) { + ++coniferCount; + } + } + check(identical, + "Essences : deux appels de meme position designent la MEME essence"); + + // La part observee doit tomber pres de coniferShareNeutral (0.55). + const double share = static_cast(coniferCount) / 2000.0; + check(std::fabs(share - 0.55) < 0.04, + "Essences : la part de resineux observee est bien celle demandee"); + } + + // --- Les deux temoins de l'essence -------------------------------------- + { + TreeSpeciesParams none; + none.coniferShareNeutral = 0.0f; + none.aspectSwing = 0.0f; + none.coniferShareMin = 0.0f; + none.coniferShareMax = 0.0f; + + TreeSpeciesParams all; + all.coniferShareNeutral = 1.0f; + all.aspectSwing = 0.0f; + all.coniferShareMin = 1.0f; + all.coniferShareMax = 1.0f; + + bool noneTagged = true; + bool allTagged = true; + for (int i = 0; i < 500; ++i) { + const float x = static_cast(i) * 7.5f; + const float z = static_cast(i) * 3.2f; + if (treeSpeciesAt(x, z, 0.0f, none) == TreeSpecies::Conifer) { + noneTagged = false; + } + if (treeSpeciesAt(x, z, 0.0f, all) != TreeSpecies::Conifer) { + allTagged = false; + } + } + check(noneTagged, "TEMOIN part nulle : aucun arbre n'est resineux"); + check(allTagged, "TEMOIN part pleine : tous les arbres sont resineux"); + } + + // --- Une graine differente donne un AUTRE tirage ------------------------ + { + TreeSpeciesParams other; + other.seed = 12345u; + int differences = 0; + for (int i = 0; i < 500; ++i) { + const float x = static_cast(i) * 5.0f; + const float z = static_cast(i) * 8.0f; + if (treeSpeciesAt(x, z, 0.0f) != treeSpeciesAt(x, z, 0.0f, other)) { + ++differences; + } + } + check(differences > 50, + "Graine differente : le tirage change reellement (pas un no-op)"); + } + + // --- Exposition adret / ubac : deplace la repartition ------------------- + { + int ubacConifers = 0; + int adretConifers = 0; + for (int i = 0; i < 1000; ++i) { + const float x = static_cast(i % 30) * 10.0f; + const float z = static_cast(i / 30) * 10.0f; + if (treeSpeciesAt(x, z, -1.0f) == TreeSpecies::Conifer) { + ++ubacConifers; + } + if (treeSpeciesAt(x, z, +1.0f) == TreeSpecies::Conifer) { + ++adretConifers; + } + } + check(ubacConifers > adretConifers, + "Adret / ubac : plus de resineux en ubac (-1) qu'en adret (+1)"); + } + + // --- La recolte de resine elle-meme (ResinStand) ------------------------- + { + ResinStand stand; + const int conifer = 10; + const int broadleaf = 20; + + check(stand.tap(-1, TreeSpecies::Conifer, 0.0f) == ResinResult::NoTree, + "TEMOIN rien de vise : la recolte refuse"); + check(stand.tap(broadleaf, TreeSpecies::Broadleaf, 0.0f) == ResinResult::NotConifer, + "TEMOIN feuillu : la recolte refuse, l'arbre n'est pas resineux"); + check(stand.trackedTreeCount() == 0, + "Un refus ne memorise RIEN : la table reste vide"); + + check(stand.tap(conifer, TreeSpecies::Conifer, 0.0f) == ResinResult::Success, + "Resineux : la premiere recolte reussit"); + check(stand.tapCount(conifer) == 1, "Resineux : la recolte est comptee"); + check(stand.trackedTreeCount() == 1, + "Seul l'arbre reellement saigne entre dans la memoire"); + + // Aussitot apres : sec. + check(stand.tap(conifer, TreeSpecies::Conifer, 1.0f) == ResinResult::StillDry, + "Resineux : deuxieme recolte immediate refusee (il faut du temps)"); + check(stand.secondsUntilFlow(conifer, 1.0f) > 0.0f, + "Resineux : un delai restant est annonce"); + + // Apres le delai : de nouveau. + const float delay = stand.params().flowDelay; + check(stand.tap(conifer, TreeSpecies::Conifer, 1.0f + delay) == ResinResult::Success, + "Resineux : la resine recoule apres flowDelay"); + checkNear(stand.secondsUntilFlow(conifer, 1.0f + delay), delay, 1e-3f, + "Resineux : le delai repart a plein apres une recolte"); + + // Epuisement au bout de maxTapsPerTree. + check(stand.tap(conifer, TreeSpecies::Conifer, 1.0f + 2.0f * delay) == ResinResult::Success, + "Resineux : troisieme recolte encore possible"); + check(stand.tapCount(conifer) == stand.params().maxTapsPerTree, + "Resineux : le compte atteint maxTapsPerTree"); + check(stand.tap(conifer, TreeSpecies::Conifer, 1.0f + 10.0f * delay) == ResinResult::StillDry, + "Resineux epuise : refuse meme apres un temps tres long"); + checkNear(stand.secondsUntilFlow(conifer, 1.0f + 10.0f * delay), 0.0f, 1e-3f, + "Resineux epuise : plus de delai annonce (c'est tapCount qui le dit)"); + + // Un AUTRE resineux reste intact : l'epuisement est par arbre. + const int otherConifer = 11; + check(stand.tap(otherConifer, TreeSpecies::Conifer, 0.0f) == ResinResult::Success, + "L'epuisement est PAR ARBRE : un autre resineux donne toujours"); + } + + // --- Les messages existent pour toutes les issues ------------------------ + { + const ResinResult results[] = { ResinResult::Success, ResinResult::NotConifer, + ResinResult::StillDry, ResinResult::NoTree }; + for (ResinResult result : results) { + const char* message = resinResultMessage(result); + check(message != nullptr && message[0] != '\0', + "Chaque issue de recolte a un message journalisable"); + } + } +} + +// =========================================================================== +// PHASE 22 : les plantes a fibres +// =========================================================================== + +// Carte de couvert CONSTANTE : le seul moyen de placer le semis exactement au +// milieu, au bord ou hors de la bande de lisiere, sans dependre d'une vraie +// carte LiDAR. +class ConstantCover : public HeightSampler { +public: + explicit ConstantCover(float value) : value_(value) {} + float heightAt(float, float) const override { return value_; } + +private: + float value_; +}; + +// Source d'ouverture CONSTANTE : le pendant du precedent pour la voie 2. +class ConstantClearing : public ClearingSource { +public: + explicit ConstantClearing(float value) : value_(value) {} + float clearing(float, float) const override { return value_; } + +private: + float value_; +}; + +void testFiberPlants() { + section("Phase 22 : plantes a fibres (ronces, orties)"); + + FlatTerrain flat(800.0f); + const FiberPlantParams defaults; + const float middleCover = 0.5f * (defaults.coverOpen + defaults.coverClosed); + + // --- Voie 1 : la LISIERE ------------------------------------------------- + { + ConstantCover edge(middleCover); + FiberPlants plants(flat, &edge, 500.0f); + checkNear(plants.edgeDensityAt(0.0f, 0.0f), 1.0f, 1e-3f, + "Lisiere : densite maximale au MILIEU de la bande de couvert"); + check(!plants.plantsNear(glm::vec3(0.0f), 30.0f).empty(), + "Lisiere : des plantes sont bien semees"); + + // Les deux bords de la bande, et au-dela : rien. C'est ce qui fait de ce + // critere une bordure et non un intervalle. + ConstantCover openGround(defaults.coverOpen - 0.01f); + ConstantCover deepForest(defaults.coverClosed + 0.01f); + FiberPlants onOpen(flat, &openGround, 500.0f); + FiberPlants inForest(flat, &deepForest, 500.0f); + checkNear(onOpen.edgeDensityAt(0.0f, 0.0f), 0.0f, 1e-3f, + "TEMOIN alpage nu : densite de lisiere nulle"); + checkNear(inForest.edgeDensityAt(0.0f, 0.0f), 0.0f, 1e-3f, + "TEMOIN futaie fermee : densite de lisiere nulle"); + check(onOpen.plantsNear(glm::vec3(0.0f), 30.0f).empty(), + "TEMOIN alpage nu : aucune plante semee"); + check(inForest.plantsNear(glm::vec3(0.0f), 30.0f).empty(), + "TEMOIN futaie fermee : aucune plante semee"); + + // Le toit triangulaire : a mi-chemin du bord, la densite doit valoir la + // moitie. Sans ca, un creneau passerait les tests ci-dessus. + const float quarter = 0.5f * (defaults.coverOpen + middleCover); + ConstantCover slope(quarter); + FiberPlants half(flat, &slope, 500.0f); + checkNear(half.edgeDensityAt(0.0f, 0.0f), 0.5f, 0.02f, + "Lisiere : la densite decroit LINEAIREMENT vers les bords"); + } + + // --- Sans carte de couvert : la voie 1 est muette ------------------------ + { + FiberPlants plants(flat, nullptr, 500.0f); + checkNear(plants.edgeDensityAt(0.0f, 0.0f), 0.0f, 1e-3f, + "TEMOIN sans carte de couvert : aucune lisiere connue"); + check(plants.plantsNear(glm::vec3(0.0f), 30.0f).empty(), + "TEMOIN sans carte ni coupe : aucune plante a fibres dans le monde"); + } + + // --- Voie 2 : le SOL OUVERT, et c'est le joueur qui l'ouvre -------------- + { + // Sans carte de couvert, pour que la voie 2 soit SEULE en cause : tout + // ce qui pousse ici pousse parce qu'on a coupe. + FiberPlants plants(flat, nullptr, 500.0f); + check(plants.plantsNear(glm::vec3(0.0f), 30.0f).empty(), "Avant la coupe : rien"); + + ConstantClearing cleared(1.0f); + plants.setClearingSource(&cleared); + checkNear(plants.clearingDensityAt(0.0f, 0.0f), 1.0f, 1e-3f, + "Sol entierement ouvert : densite de recolonisation maximale"); + check(!plants.plantsNear(glm::vec3(0.0f), 30.0f).empty(), + "Apres la coupe : des plantes a fibres apparaissent"); + + // Le seuil bas est bien un seuil. + ConstantClearing untouched(defaults.clearingBegin - 0.01f); + FiberPlants below(flat, nullptr, 500.0f); + below.setClearingSource(&untouched); + checkNear(below.clearingDensityAt(0.0f, 0.0f), 0.0f, 1e-3f, + "TEMOIN sous clearingBegin : aucune recolonisation"); + check(below.plantsNear(glm::vec3(0.0f), 30.0f).empty(), + "TEMOIN sous clearingBegin : aucune plante"); + } + + // --- La regle de combinaison est un MAXIMUM, pas une somme --------------- + { + ConstantCover edge(middleCover); + ConstantClearing cleared(1.0f); + FiberPlants both(flat, &edge, 500.0f); + both.setClearingSource(&cleared); + checkNear(both.densityAt(0.0f, 0.0f), 1.0f, 1e-3f, + "Lisiere ET coupe : la densite reste bornee a 1 (maximum, pas somme)"); + + // Une lisiere a mi-densite plus une coupe pleine doit donner la coupe. + const float quarter = 0.5f * (defaults.coverOpen + middleCover); + ConstantCover half(quarter); + FiberPlants mixed(flat, &half, 500.0f); + mixed.setClearingSource(&cleared); + checkNear(mixed.densityAt(0.0f, 0.0f), 1.0f, 1e-3f, + "La voie la plus forte l'emporte"); + } + + // --- Les filtres de terrain INTERDISENT, ils ne choisissent pas ---------- + { + ConstantCover edge(middleCover); + + // Un versant a 150 % : au-dela de maxSlope (1,0). + SlopedTerrain cliff(800.0f, 1.5f); + FiberPlants onCliff(cliff, &edge, 500.0f); + checkNear(onCliff.densityAt(0.0f, 0.0f), 0.0f, 1e-3f, + "TEMOIN paroi : aucune plante malgre un couvert de lisiere"); + + // Au-dessus de la limite d'altitude. + FlatTerrain high(defaults.maxAltitude + 50.0f); + FiberPlants tooHigh(high, &edge, 500.0f); + checkNear(tooHigh.densityAt(0.0f, 0.0f), 0.0f, 1e-3f, + "TEMOIN au-dessus de la limite des arbres : aucune plante"); + // Et juste en dessous, la MEME configuration en produit : c'est ce qui + // prouve que c'est bien l'altitude qui a decide. + FlatTerrain justBelow(defaults.maxAltitude - 50.0f); + FiberPlants allowed(justBelow, &edge, 500.0f); + check(allowed.densityAt(0.0f, 0.0f) > 0.0f, + "Juste sous la limite : la meme configuration produit des plantes"); + } + + // --- Le semis est DETERMINISTE ------------------------------------------- + { + ConstantCover edge(middleCover); + FiberPlants a(flat, &edge, 500.0f); + FiberPlants b(flat, &edge, 500.0f); + const auto pa = a.plantsNear(glm::vec3(20.0f, 0.0f, -13.0f), 25.0f); + const auto pb = b.plantsNear(glm::vec3(20.0f, 0.0f, -13.0f), 25.0f); + check(pa.size() == pb.size() && !pa.empty(), + "Semis : deux FiberPlants de meme graine rendent le meme nombre de plantes"); + bool same = (pa.size() == pb.size()); + for (std::size_t i = 0; i < pa.size() && same; ++i) { + same = (pa[i].id == pb[i].id) + && std::fabs(pa[i].position.x - pb[i].position.x) < 1e-4f + && std::fabs(pa[i].position.z - pb[i].position.z) < 1e-4f + && std::fabs(pa[i].size - pb[i].size) < 1e-4f; + } + check(same, "Semis : les memes plantes, aux memes places, aux memes tailles"); + + // Les tailles restent dans les bornes annoncees. + bool sized = true; + for (const FiberPlant& plant : pa) { + if (plant.size < defaults.sizeMin - 1e-4f + || plant.size > defaults.sizeMax + 1e-4f) { + sized = false; + } + } + check(sized, "Semis : toutes les tailles tiennent dans [sizeMin, sizeMax]"); + } + + // --- Arrachage et repousse ------------------------------------------------ + { + ConstantCover edge(middleCover); + FiberPlants plants(flat, &edge, 500.0f); + + const glm::vec3 player(0.0f, 800.0f, 0.0f); + const std::size_t before = plants.plantsNear(player, kPullReach).size(); + check(before > 0, "Arrachage : il y a bien une plante a portee pour ce test"); + + FiberPlant pulled; + check(plants.pullNearest(player, kPullReach, &pulled), + "Arrachage : la plante la plus proche est arrachee"); + check(!plants.isStanding(pulled.id), "Arrachage : la plante n'est plus sur pied"); + check(plants.pulledPlantCount() == 1, + "Arrachage : une seule plante entre dans la memoire de repousse"); + check(plants.plantsNear(player, kPullReach).size() == before - 1, + "Arrachage : le semis en rend exactement une de moins"); + + // Elle ne repousse PAS avant l'heure. + plants.update(defaults.regrowthDelay - 1.0f); + check(!plants.isStanding(pulled.id), "Repousse : rien avant regrowthDelay"); + check(plants.pulledPlantCount() == 1, + "Repousse : la plante est toujours memorisee"); + + // Et elle repousse apres, a l'identique - c'est la promesse du semis + // deterministe : rien n'est stocke, donc rien ne peut se perdre. + plants.update(2.0f); + check(plants.isStanding(pulled.id), "Repousse : la plante revient apres le delai"); + check(plants.pulledPlantCount() == 0, + "Repousse : la plante SORT de la memoire (grille creuse)"); + check(plants.plantsNear(player, kPullReach).size() == before, + "Repousse : le semis retrouve exactement son compte"); + + bool identical = false; + for (const FiberPlant& plant : plants.plantsNear(player, kPullReach)) { + if (plant.id == pulled.id) { + identical = std::fabs(plant.position.x - pulled.position.x) < 1e-4f + && std::fabs(plant.position.z - pulled.position.z) < 1e-4f + && std::fabs(plant.size - pulled.size) < 1e-4f; + } + } + check(identical, "Repousse : la MEME plante, a la meme place, a la meme taille"); + } + + // --- Le temoin de l'arrachage : rien a portee ---------------------------- + { + FiberPlants empty(flat, nullptr, 500.0f); + check(!empty.pullNearest(glm::vec3(0.0f), kPullReach), + "TEMOIN monde sans plantes : l'arrachage echoue proprement"); + check(empty.pulledPlantCount() == 0, + "TEMOIN : un arrachage rate ne memorise rien"); + + ConstantCover edge(middleCover); + FiberPlants plants(flat, &edge, 500.0f); + check(!plants.pullNearest(glm::vec3(0.0f), 0.0f), + "TEMOIN portee nulle : l'arrachage echoue proprement"); + } + + // --- La portee est HORIZONTALE ------------------------------------------- + { + ConstantCover edge(middleCover); + FiberPlants plants(flat, &edge, 500.0f); + const std::size_t atFeet = + plants.plantsNear(glm::vec3(0.0f, 800.0f, 0.0f), 10.0f).size(); + const std::size_t highAbove = + plants.plantsNear(glm::vec3(0.0f, 3000.0f, 0.0f), 10.0f).size(); + check(atFeet == highAbove && atFeet > 0, + "Portee : l'altitude du joueur n'intervient pas (portee horizontale)"); + } +} + +// =========================================================================== +// PHASE 22 : les geometries des matieres recoltees +// =========================================================================== +void testHarvestMeshes() { + section("Phase 22 : geometries des matieres recoltees"); + + struct MeshCase { + const char* label; + MeshData mesh; + float halfHeight; // 0 = pas de contrainte de centrage vertical + }; + const MeshCase cases[] = { + { "motte d'argile", clayLumpMeshData(), kClayRadius }, + { "poignee de sable", sandPileMeshData(), kSandRadius }, + { "perle de resine", resinBlobMeshData(), 0.0f }, + { "fagot de tiges", fiberBundleMeshData(), 0.0f }, + { "plante a fibres sur pied", fiberPlantMeshData(), 0.0f }, + }; + + for (const MeshCase& item : cases) { + check(!item.mesh.empty(), "Mesh non vide"); + check(item.mesh.indices.size() % 3 == 0, "Mesh : indices multiples de 3"); + check(!item.mesh.name.empty(), "Mesh : porte un nom journalisable"); + + bool finite = true; + bool normalized = true; + float minY = 1e9f; + float maxY = -1e9f; + for (const Vertex& vertex : item.mesh.vertices) { + if (!std::isfinite(vertex.pos.x) || !std::isfinite(vertex.pos.y) + || !std::isfinite(vertex.pos.z)) { + finite = false; + } + // Toute normale doit etre unitaire : un triangle degenere qui aurait + // echappe au filtre d'appendFacet donnerait une normale nulle, et + // l'eclairage s'y verrait comme un trou noir. + if (std::fabs(glm::length(vertex.normal) - 1.0f) > 1e-3f) { + normalized = false; + } + minY = std::min(minY, vertex.pos.y); + maxY = std::max(maxY, vertex.pos.y); + } + check(finite, "Mesh : aucune coordonnee non finie"); + check(normalized, "Mesh : toutes les normales sont unitaires"); + + if (item.halfHeight > 0.0f) { + // Les objets poses au sol sont CENTRES verticalement et TIENNENT + // dans leur demi-hauteur : c'est ce qui permet a Ground::drop de les + // poser en ajoutant simplement groundItemRestRadius a l'altitude du + // terrain, sans qu'ils s'enfoncent ni qu'ils flottent. + // + // On encadre au lieu d'exiger l'egalite : ces meshes sont BRUITES + // (voir HarvestMesh.cpp), donc leur sommet extreme ne tombe pas + // pile sur la demi-hauteur. Exiger l'egalite testerait le tirage + // aleatoire et non le contrat - c'est d'ailleurs ce que le premier + // jet de ce test faisait, et il echouait sur la motte d'argile. + check(minY >= -item.halfHeight - 1e-3f && maxY <= item.halfHeight + 1e-3f, + "Mesh pose au sol : il TIENT dans sa demi-hauteur"); + check(minY < 0.0f && maxY > 0.0f, + "Mesh pose au sol : il est CENTRE (il deborde des deux cotes)"); + check(-minY > 0.7f * item.halfHeight && maxY > 0.7f * item.halfHeight, + "Mesh pose au sol : il REMPLIT sa demi-hauteur (pas un objet plat)"); + } + } + + // La plante SUR PIED, elle, part du SOL et monte : elle n'est pas centree, + // parce qu'elle est instanciee par son pied comme la touffe d'herbe. + { + const MeshData plant = fiberPlantMeshData(); + float minY = 1e9f; + float maxY = -1e9f; + for (const Vertex& vertex : plant.vertices) { + minY = std::min(minY, vertex.pos.y); + maxY = std::max(maxY, vertex.pos.y); + } + checkNear(minY, 0.0f, 1e-3f, "Plante sur pied : son pied est a y = 0"); + check(maxY > 0.4f && maxY <= 1.0f + 1e-3f, + "Plante sur pied : a l'echelle UNITE (au plus 1 m de haut)"); + } + + // --- Les quatre nouvelles natures ont tout ce qu'un objet au sol doit + // avoir. Sans ce test, ajouter une valeur a l'enum sans l'ajouter aux + // quatre switch de Ground.cpp passerait inapercu : ces switch ont un + // `return` par defaut, donc le compilateur ne dirait rien. + { + for (uint32_t i = 0; i < kGroundItemKindCount; ++i) { + const auto kind = static_cast(i); + check(groundItemRestRadius(kind) > 0.0f, + "Chaque nature d'objet au sol a un rayon de repos non nul"); + check(std::strcmp(groundItemLabel(kind), "objet") != 0, + "Chaque nature d'objet au sol a son libelle propre"); + check(std::strcmp(groundItemLabelIndefinite(kind), "un objet") != 0, + "Chaque nature a son libelle avec article"); + check(std::strcmp(groundItemLabelPlural(kind), "objets") != 0, + "Chaque nature a son libelle au pluriel"); + } + } + + // --- Elles se posent et se ramassent comme les autres -------------------- + { + FlatTerrain flat(40.0f); + Ground ground(flat); + Inventory inventory; + + const GroundItemKind kinds[] = { GroundItemKind::Clay, GroundItemKind::Sand, + GroundItemKind::Resin, GroundItemKind::Fiber }; + for (GroundItemKind kind : kinds) { + ground.drop(kind, 3.0f, -2.0f, 0.0f, 0.0f); + } + check(ground.itemCount() == 4, "Les quatre matieres se posent au sol"); + + const int index = ground.findNearest(glm::vec3(3.0f, 41.7f, -2.0f), 2.5f); + check(index != kNoGroundItem, "Une matiere posee se retrouve a portee"); + + GroundItemKind picked = GroundItemKind::Log; + check(ground.pickUp(index, &picked), "Une matiere posee se ramasse"); + inventory.add(picked); + check(inventory.count(picked) == 1, "La matiere ramassee entre dans l'inventaire"); + check(inventory.summary().find("argile") != std::string::npos, + "Le resume d'inventaire mentionne les nouvelles matieres"); + } +} + + +// =========================================================================== +// PHASE 23 - Systeme meteo deterministe +// =========================================================================== +// CE QUE CES TESTS VERIFIENT, ET CE QU'ILS NE VERIFIENT PAS. +// +// Ils verifient des PROPRIETES : un determinisme, un signe, un ordre, une +// monotonie. "Un adret est plus chaud qu'un ubac au meme instant". "Un col vente +// plus qu'un plateau". "La meme position au meme instant rend le meme resultat". +// +// Ils ne verifient PRESQUE AUCUNE valeur absolue, et c'est delibere : aucune des +// constantes de WeatherParams n'a ete validee par un climatologue (voir +// l'avertissement en tete de world/Weather.hpp). Un test qui exigerait +// "l'inversion vaut -6 degres" devrait etre reecrit le jour du recalibrage, et +// il ne dirait rien de plus que "la constante vaut ce qu'elle vaut". Les rares +// egalites numeriques ci-dessous portent sur des grandeurs qui NE SONT PAS +// provisoires : le gradient adiabatique compare a son propre parametre, et la +// formule de refroidissement eolien, qui est publiee. +// =========================================================================== + +// Chaine de montagnes orientee NORD-SUD, avec un COL creuse dedans a z = 0. +// +// C'est le seul relief de ce fichier ou l'on sache a l'avance ou est le col, +// donc le seul qui permette de dire si le sondage amont trouve LE bon endroit et +// pas seulement un endroit - exactement le role que joue BowlTerrain pour les +// points d'eau depuis la Phase 16. +// +// Un vent d'ouest (+X pour le sens du flux, puisque +X va vers l'est) doit donc +// franchir la crete, et le franchir par le col. +class RidgeWithColTerrain : public HeightSampler { +public: + RidgeWithColTerrain(float base, float ridgeHeight, float ridgeWidth, + float colDepth, float colWidth) + : base_(base), height_(ridgeHeight), width_(ridgeWidth), + colDepth_(colDepth), colWidth_(colWidth) {} + + float heightAt(float x, float z) const override { + // Profil de crete : une gaussienne le long de X, donc un versant au vent + // (x < 0), un sommet (x = 0) et un versant sous le vent (x > 0). + const float across = std::exp(-(x / width_) * (x / width_)); + // Entaille : la crete perd colDepth_ de sa hauteur au voisinage de z = 0. + const float notch = 1.0f - colDepth_ * std::exp(-(z / colWidth_) * (z / colWidth_)); + return base_ + height_ * across * notch; + } + +private: + float base_, height_, width_, colDepth_, colWidth_; +}; + +void testWeather() { + std::printf("\n--- Meteo deterministe (Phase 23) ---\n"); + + const WeatherParams defaults; + const WeatherSystem sky; + + // ======================================================================= + // 1. DETERMINISME - la propriete fondatrice du module + // ======================================================================= + { + // Purete stricte : deux appels identiques rendent BIT A BIT le meme + // resultat. Pas "a epsilon pres" - le module n'a aucun etat, il ne peut + // pas deriver. + const SynopticState a = sky.synopticAt(137.25f); + const SynopticState b = sky.synopticAt(137.25f); + check(a.seaLevelTemperatureC == b.seaLevelTemperatureC && + a.cloudCover == b.cloudCover && a.seaLevelWindMps == b.seaLevelWindMps && + a.windFromDegrees == b.windFromDegrees, + "Determinisme : deux appels au meme instant sont identiques"); + + RidgeWithColTerrain terrain(800.0f, 400.0f, 300.0f, 0.60f, 400.0f); + const glm::vec3 spot(120.0f, 1050.0f, -60.0f); + const WeatherSample s1 = sky.sampleAt(spot, 137.25f, &terrain); + const WeatherSample s2 = sky.sampleAt(spot, 137.25f, &terrain); + check(s1.temperatureC == s2.temperatureC && s1.windMps == s2.windMps && + s1.verticalMps == s2.verticalMps && s1.wetness == s2.wetness, + "Determinisme : deux echantillons au meme point sont identiques"); + + // INDEPENDANCE DU CHEMIN, qui est la vraie demande du cahier des charges. + // Deux horloges couvrent la meme duree de jeu par des pas DIFFERENTS - + // 60 images par seconde contre 10 - puis on echantillonne. Un modele qui + // integrerait quoi que ce soit divergerait ici ; celui-ci ne peut pas. + GameClock fast(9.0f, 12.0f); + GameClock slow(9.0f, 12.0f); + for (int i = 0; i < 6000; ++i) { fast.advance(1.0f / 60.0f); } + for (int i = 0; i < 1000; ++i) { slow.advance(1.0f / 10.0f); } + checkNear(fast.totalHours(), slow.totalHours(), 1e-2f, + "Horloge : deux pas de temps differents, meme temps de jeu"); + + const WeatherSample viaFast = sky.sampleAt(spot, fast.totalHours(), &terrain); + const WeatherSample viaSlow = sky.sampleAt(spot, slow.totalHours(), &terrain); + checkNear(viaFast.temperatureC, viaSlow.temperatureC, 0.05f, + "Chemin : la meteo ne depend pas de la facon dont on est arrive"); + checkNear(viaFast.windMps, viaSlow.windMps, 0.05f, + "Chemin : le vent non plus"); + + // Et l'inverse : deux instants ECARTES doivent, eux, differer. Sans ce + // controle negatif, une fonction constante passerait tous les tests + // ci-dessus. + bool varies = false; + const SynopticState reference = sky.synopticAt(0.0f); + for (int day = 1; day <= 20 && !varies; ++day) { + const SynopticState later = sky.synopticAt(static_cast(day) * 24.0f); + if (std::abs(later.cloudCover - reference.cloudCover) > 0.10f || + std::abs(later.seaLevelTemperatureC - reference.seaLevelTemperatureC) > 1.0f) { + varies = true; + } + } + check(varies, "Perturbations : le temps qu'il fait change d'un jour a l'autre"); + } + + // ======================================================================= + // 2. COUCHE 1 - cycles, soleil, perturbations + // ======================================================================= + { + // Cycle diurne : il fait plus chaud a l'heure de pointe qu'au petit + // matin, le meme jour. Compare a NEBULOSITE EGALE, ce qui n'est possible + // qu'en restant dans la meme journee - c'est pour ca que le test prend + // deux heures du meme jour et non deux instants au hasard. + const float day = 3.0f * 24.0f; + const SynopticState afternoon = sky.synopticAt(day + defaults.diurnalPeakHour); + const SynopticState dawn = sky.synopticAt(day + defaults.diurnalPeakHour - 12.0f); + check(afternoon.seaLevelTemperatureC > dawn.seaLevelTemperatureC, + "Cycle diurne : l'apres-midi est plus chaude que la fin de nuit"); + + // Soleil : leve a l'est, couche a l'ouest, culmine au sud. + const SynopticState noon = sky.synopticAt(12.0f); + check(noon.sunElevationDegrees > 0.0f, "Soleil : haut a midi"); + check(noon.sunDirection.z > 0.9f * std::cos(glm::radians(noon.sunElevationDegrees)) - 1e-3f, + "Soleil : plein SUD a midi (+Z dans la convention du projet)"); + check(noon.daylight > 0.8f, "Soleil : plein jour a midi"); + + const SynopticState morning = sky.synopticAt(8.0f); + check(morning.sunDirection.x > 0.0f, "Soleil : a l'EST le matin (+X)"); + const SynopticState evening = sky.synopticAt(18.0f); + check(evening.sunDirection.x < 0.0f, "Soleil : a l'OUEST le soir (-X)"); + + const SynopticState midnight = sky.synopticAt(0.0f); + check(midnight.sunElevationDegrees < 0.0f, "Soleil : sous l'horizon a minuit"); + checkNear(midnight.daylight, 0.0f, 1e-6f, "Soleil : aucun ensoleillement de nuit"); + + // Saison : le soleil monte plus haut a midi en juillet qu'en janvier. + // Le jour de depart etant mi-mai, on saute de six mois pour comparer. + WeatherParams winterParams = defaults; + winterParams.startDayOfYear = 15.0f; // mi-janvier + const WeatherSystem winter(winterParams); + const SynopticState winterNoon = winter.synopticAt(12.0f); + check(winterNoon.sunElevationDegrees < noon.sunElevationDegrees - 10.0f, + "Saison : le soleil de janvier est bien plus bas que celui de mai"); + + // Perturbations : sur un mois de jeu, il doit exister des journees + // claires ET des journees de pluie. Un modele qui ne produirait jamais + // de pluie - ou qui en produirait tout le temps - serait inutile. + int rainySamples = 0; + int clearSamples = 0; + float maxWind = 0.0f; + for (int h = 0; h < 30 * 24; ++h) { + const SynopticState state = sky.synopticAt(static_cast(h)); + if (state.precipitationMmPerHour > 0.1f) { ++rainySamples; } + if (state.cloudCover < 0.20f) { ++clearSamples; } + maxWind = std::max(maxWind, state.seaLevelWindMps); + check(state.cloudCover >= 0.0f && state.cloudCover <= 1.0f, + "Nebulosite : toujours dans [0, 1]"); + check(state.seaLevelWindMps >= 0.0f, "Vent synoptique : jamais negatif"); + } + check(rainySamples > 0, "Un mois de jeu contient des heures de pluie"); + check(clearSamples > 0, "Un mois de jeu contient des heures de grand beau"); + check(rainySamples < 30 * 24 / 2, "Il ne pleut pas la moitie du temps"); + check(maxWind > defaults.baseWindMps + 1.0f, + "Le vent forcit reellement au passage des perturbations"); + std::printf(" [meteo] sur 30 jours simules : %d h de pluie, %d h de grand beau, " + "vent max %.1f m/s\n", + rainySamples, clearSamples, static_cast(maxWind)); + } + + // ======================================================================= + // 3. COUCHE 2 - temperature locale + // ======================================================================= + { + // --- Gradient altitudinal ------------------------------------------ + // La seule egalite numerique du fichier, et elle est legitime : elle + // compare le resultat a SON PROPRE parametre. Le jour ou le climatologue + // changera 6,5, ce test continuera de passer - et c'est exactement ce + // qu'on veut d'un test de mecanisme. + const float when = 5.0f * 24.0f + 11.0f; + const WeatherSample low = sky.sampleAt(glm::vec3(0.0f, 300.0f, 0.0f), when, nullptr); + const WeatherSample high = sky.sampleAt(glm::vec3(0.0f, 1300.0f, 0.0f), when, nullptr); + checkNear(low.temperatureC - high.temperatureC, defaults.lapseRateCPerKm, 1e-2f, + "Altitude : l'ecart vaut exactement le gradient annonce"); + check(high.lapseC < low.lapseC, "Altitude : le terme de gradient est bien celui qui mord"); + + // --- Adret / ubac --------------------------------------------------- + // MEME INSTANT, MEME ALTITUDE, seule l'orientation change. C'est la + // propriete demandee par le cahier des charges, et elle est verifiee a + // une heure ou le soleil est franchement au sud. + NorthSouthSlope adretSlope(-0.60f); // descend vers le sud + NorthSouthSlope ubacSlope(0.60f); // descend vers le nord + const float noonHours = 4.0f * 24.0f + 12.0f; + const WeatherSample adret = + sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), noonHours, &adretSlope); + const WeatherSample ubac = + sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), noonHours, &ubacSlope); + check(adret.temperatureC > ubac.temperatureC, + "Adret / ubac : le versant sud est MESURABLEMENT plus chaud a midi"); + check(adret.aspectC > ubac.aspectC, + "Adret / ubac : l'ecart vient bien du terme d'exposition"); + std::printf(" [meteo] a midi, 1000 m : adret %.1f C, ubac %.1f C (ecart %.1f C)\n", + static_cast(adret.temperatureC), + static_cast(ubac.temperatureC), + static_cast(adret.temperatureC - ubac.temperatureC)); + + // Controle negatif : la nuit, l'orientation ne doit plus rien changer. + const float nightHours = 4.0f * 24.0f + 2.0f; + const WeatherSample adretNight = + sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), nightHours, &adretSlope); + const WeatherSample ubacNight = + sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), nightHours, &ubacSlope); + checkNear(adretNight.temperatureC, ubacNight.temperatureC, 1e-3f, + "La nuit : un versant sud n'a plus aucun avantage"); + + // Le matin, c'est le versant EST qui prend le soleil - ce qu'un modele + // purement nord/sud (celui de la Phase 16) ne pouvait pas produire. + SlopedTerrain eastFacing(1000.0f, -0.60f); // descend vers l'est (+X) + SlopedTerrain westFacing(1000.0f, 0.60f); + const float morningHours = 4.0f * 24.0f + 7.5f; + const WeatherSample east = + sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), morningHours, &eastFacing); + const WeatherSample west = + sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), morningHours, &westFacing); + check(east.temperatureC > west.temperatureC, + "Le matin : le versant EST est plus chaud que le versant ouest"); + + // --- Terrain absent : repli explicite ------------------------------- + const WeatherSample freeAir = sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), noonHours, nullptr); + checkNear(freeAir.aspectC, 0.0f, 1e-6f, + "Sans terrain : aucun effet de versant, et aucun plantage"); + check(freeAir.windMps > 0.0f, "Sans terrain : le vent synoptique reste disponible"); + } + + // ======================================================================= + // 4. CARTE DE PIEGEAGE D'AIR FROID ET INVERSION + // ======================================================================= + { + // Une cuvette de 600 m de rayon creusee dans un plateau : le creux doit + // etre note comme piegeant, la bosse identique NON. C'est le meme + // controle negatif que la Phase 16 employait pour les points d'eau, et + // pour la meme raison - sans lui, une carte qui noterait "bas = piege" + // passerait par accident. + // Rebord a 150 m au-dessus du fond, atteint a 500 m du centre : les + // proportions d'une vraie combe de moyenne montagne. La premiere + // redaction employait 400 m de profondeur, et le test echouait pour une + // raison qui vaut d'etre notee - a 400 m de denivele, le seul gradient + // adiabatique rend deja le fond 2,6 degres PLUS CHAUD que le rebord, et + // l'inversion, pourtant bien calculee, ne suffisait pas tout a fait a + // renverser ce handicap. Ce n'etait pas un defaut du modele mais un + // relief invraisemblable : une cuvette de 400 m de creux pour 500 m de + // rayon est une falaise circulaire, pas une combe. + BowlTerrain bowl(0.0f, 0.0f, 0.0006f, 150.0f); + DomeTerrain dome(0.0f, 0.0f, 0.0006f, 0.0f); + + const ColdAirTrapMap bowlMap(bowl, 2000.0f, 48); + const ColdAirTrapMap domeMap(dome, 2000.0f, 48); + + check(!bowlMap.empty(), "Carte de piegeage : construite"); + check(bowlMap.at(0.0f, 0.0f) > 0.5f, + "Piegeage : le fond de la cuvette est fortement enferme"); + check(domeMap.at(0.0f, 0.0f) < 0.05f, + "Piegeage : le sommet d'une bosse ne piege rien (controle negatif)"); + check(bowlMap.at(0.0f, 0.0f) > bowlMap.at(1800.0f, 1800.0f) + 0.3f, + "Piegeage : le fond piege bien plus que le plateau qui l'entoure"); + std::printf(" [meteo] carte de piegeage : creux %.2f, plateau %.2f, bosse %.2f\n", + static_cast(bowlMap.at(0.0f, 0.0f)), + static_cast(bowlMap.at(1800.0f, 1800.0f)), + static_cast(domeMap.at(0.0f, 0.0f))); + + // Carte degeneree : ne doit ni planter ni mentir. + const ColdAirTrapMap tiny(bowl, 0.0f, 64); + check(tiny.empty() && tiny.at(0.0f, 0.0f) == 0.0f, + "Carte de piegeage : une emprise nulle rend une carte vide, pas un plantage"); + + // --- L'inversion elle-meme ------------------------------------------ + // Le fond de cuvette doit etre plus froid que le plateau LA NUIT, alors + // qu'il est PLUS BAS - donc plus chaud par le seul gradient. C'est la + // seule facon de prouver que l'inversion existe : elle doit RENVERSER le + // signe du gradient, pas simplement s'y ajouter. + WeatherSystem inverted; + inverted.setTrapMap(&bowlMap); + + // On cherche une nuit calme et claire dans les dix premiers jours : le + // phenomene ne s'installe que par ciel degage et sans vent, et exiger + // qu'il se produise a une date arbitraire serait exiger que la meteo + // soit celle qui arrange le test. + // Le critere ne porte QUE sur la nebulosite : le vent, lui, est deja + // traite par le modele au bon endroit - un fond de cuvette est abrite + // par construction, donc le vent y est faible meme quand le vent + // synoptique ne l'est pas. Une premiere version de ce test exigeait + // aussi un vent synoptique faible et ne trouvait jamais de nuit + // propice : le vent de base ne descend jamais sous baseWindMps. + bool inversionSeen = false; + float bestGap = 0.0f; + for (int day = 0; day < 20 && !inversionSeen; ++day) { + const float t = static_cast(day) * 24.0f + 3.0f; + const SynopticState state = inverted.synopticAt(t); + if (state.cloudCover > 0.25f) { + continue; + } + const WeatherSample hollow = + inverted.sampleAt(glm::vec3(0.0f, bowl.heightAt(0.0f, 0.0f), 0.0f), t, &bowl); + const WeatherSample plateau = inverted.sampleAt( + glm::vec3(1800.0f, bowl.heightAt(1800.0f, 1800.0f), 1800.0f), t, &bowl); + if (hollow.inversionC < -0.5f) { + inversionSeen = true; + bestGap = plateau.temperatureC - hollow.temperatureC; + check(hollow.temperatureC < plateau.temperatureC, + "Inversion : par nuit claire et calme, le fond est plus FROID que le plateau"); + std::printf(" [meteo] inversion nocturne : fond %.1f C, plateau %.1f C " + "(le fond est pourtant %.0f m plus bas)\n", + static_cast(hollow.temperatureC), + static_cast(plateau.temperatureC), + static_cast(bowl.heightAt(1800.0f, 1800.0f) - + bowl.heightAt(0.0f, 0.0f))); + } + } + check(inversionSeen, "Inversion : une nuit propice existe dans les vingt premiers jours"); + check(bestGap > 0.0f || !inversionSeen, "Inversion : l'ecart est bien dans le bon sens"); + + // De JOUR, au meme endroit, l'inversion doit avoir disparu. + const WeatherSample daytime = + inverted.sampleAt(glm::vec3(0.0f, bowl.heightAt(0.0f, 0.0f), 0.0f), 13.0f, &bowl); + checkNear(daytime.inversionC, 0.0f, 1e-3f, + "Inversion : rien en plein jour (controle negatif)"); + + // Sans carte reliee, pas d'inversion - et aucun plantage. + const WeatherSample noMap = + sky.sampleAt(glm::vec3(0.0f, 400.0f, 0.0f), 3.0f, &bowl); + checkNear(noMap.inversionC, 0.0f, 1e-6f, + "Sans carte de piegeage : l'inversion vaut zero, proprement"); + } + + // ======================================================================= + // 5. VENT LOCAL - SONDAGE AMONT + // ======================================================================= + { + RidgeWithColTerrain ridge(800.0f, 400.0f, 300.0f, 0.60f, 400.0f); + + // Vent d'OUEST impose : le flux traverse la crete d'ouest en est. On fixe + // la direction au lieu de la subir, parce qu'un test sur la reponse du + // relief ne doit pas dependre de l'humeur du bruit synoptique ce jour-la. + WeatherParams westerly; + westerly.meanWindFromDegrees = 270.0f; + westerly.windDirectionSwingDegrees = 0.0f; + const WeatherSystem west(westerly); + + const float t = 6.0f * 24.0f + 10.0f; + const SynopticState state = west.synopticAt(t); + checkNear(state.windFromDegrees, 270.0f, 1e-3f, "Vent : direction d'ouest imposee"); + + // Le vecteur vent doit POINTER vers l'est : le vent d'ouest va vers l'est. + const WeatherSample anywhere = + west.sampleAt(glm::vec3(-2500.0f, 800.0f, 0.0f), state, &ridge); + check(anywhere.windVector.x > 0.0f, + "Vent d'ouest : l'air se deplace vers l'EST (+X)"); + + // --- COL contre PLATEAU : la propriete centrale de cette section ------ + const float colY = ridge.heightAt(0.0f, 0.0f); + const WeatherSample col = west.sampleAt(glm::vec3(0.0f, colY, 0.0f), state, &ridge); + + const float plateauY = ridge.heightAt(-2500.0f, 0.0f); + const WeatherSample plateau = + west.sampleAt(glm::vec3(-2500.0f, plateauY, 0.0f), state, &ridge); + + check(col.windMps > 1.5f * plateau.windMps, + "Col : le vent y est nettement plus fort que sur le plateau adjacent"); + std::printf(" [meteo] vent : col %.1f m/s, plateau %.1f m/s (x%.2f)\n", + static_cast(col.windMps), static_cast(plateau.windMps), + static_cast(col.windMps / std::max(0.01f, plateau.windMps))); + + // Le col doit aussi venter plus que la crete PLEINE, a vent de reference + // egal. La crete pleine etant plus HAUTE que le col, comparer les + // vitesses brutes ne dirait rien : le vent croit deja avec l'altitude. + // On compare donc les FACTEURS - le vent local divise par le vent en air + // libre a la meme altitude. C'est la seule facon d'isoler l'effet + // d'entonnoir de l'effet d'altitude, et la premiere redaction de ce test + // ne le faisait pas : elle cherchait un point de crete a altitude egale, + // n'en trouvait aucun (il n'y en a pas, par construction du relief) et se + // sautait donc en silence. + const auto freeAirWind = [&](float y) { + return state.seaLevelWindMps + westerly.windAltitudeGainMpsPerKm * y / 1000.0f; + }; + const float crestY = ridge.heightAt(0.0f, 1600.0f); + const WeatherSample onRidge = + west.sampleAt(glm::vec3(0.0f, crestY, 1600.0f), state, &ridge); + const float colFactor = col.windMps / freeAirWind(colY); + const float crestFactor = onRidge.windMps / freeAirWind(crestY); + check(colFactor > crestFactor, + "Venturi : a vent de reference egal, le col accelere plus que la crete pleine"); + std::printf(" [meteo] facteur de relief : col x%.2f, crete pleine x%.2f\n", + static_cast(colFactor), static_cast(crestFactor)); + + // --- Versant au vent contre versant sous le vent --------------------- + // Meme altitude, meme instant, de part et d'autre du sommet. + const float flankY = ridge.heightAt(-250.0f, 1500.0f); + const WeatherSample windward = + west.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), state, &ridge); + const WeatherSample lee = + west.sampleAt(glm::vec3(250.0f, flankY, 1500.0f), state, &ridge); + + check(windward.ridgeLiftMps > 0.5f, + "Ridge lift : le versant AU VENT porte reellement"); + checkNear(lee.ridgeLiftMps, 0.0f, 1e-6f, + "Ridge lift : le versant SOUS LE VENT ne porte pas"); + check(lee.subsidenceMps < 0.0f, + "Sous le vent : l'air redescend (subsidence)"); + check(lee.turbulence > windward.turbulence, + "Sous le vent : l'air est plus turbulent qu'au vent"); + std::printf(" [meteo] versants a %.0f m : au vent +%.2f m/s (turb %.2f), " + "sous le vent %.2f m/s (turb %.2f)\n", + static_cast(flankY), + static_cast(windward.ridgeLiftMps), + static_cast(windward.turbulence), + static_cast(lee.subsidenceMps), + static_cast(lee.turbulence)); + + // Sans vent, pas de turbulence et pas de portance : le controle negatif + // qui prouve que ces deux termes sont bien pilotes par le vent. + WeatherParams calmParams = westerly; + calmParams.baseWindMps = 0.0f; + calmParams.frontWindAmplitudeMps = 0.0f; + calmParams.windAltitudeGainMpsPerKm = 0.0f; + const WeatherSystem calm(calmParams); + const WeatherSample stillAir = + calm.sampleAt(glm::vec3(250.0f, flankY, 1500.0f), t, &ridge); + checkNear(stillAir.turbulence, 0.0f, 1e-6f, "Air calme : aucune turbulence de relief"); + checkNear(stillAir.ridgeLiftMps, 0.0f, 1e-6f, "Air calme : aucune portance de pente"); + checkNear(stillAir.subsidenceMps, 0.0f, 1e-6f, "Air calme : aucune subsidence"); + + // Ecretage : meme dans le pire cumul, le vent reste sous le garde-fou. + for (int h = 0; h < 15 * 24; ++h) { + const WeatherSample s = + west.sampleAt(glm::vec3(0.0f, colY, 0.0f), static_cast(h), &ridge); + check(s.windMps <= westerly.maxLocalWindMps + 1e-3f, + "Vent local : jamais au-dessus du garde-fou"); + } + + // --- Thermiques ------------------------------------------------------ + // Sur un adret ensoleille en debut d'apres-midi, ca doit monter ; la + // meme pente a 3 h du matin, non. + NorthSouthSlope adretSlope(-0.60f); + WeatherParams clearParams; + clearParams.meanCloudCover = 0.0f; + clearParams.cloudAmplitude = 0.0f; + const WeatherSystem clearSky(clearParams); + + const WeatherSample thermalNoon = clearSky.sampleAt( + glm::vec3(0.0f, 1200.0f, 0.0f), clearParams.thermalPeakHour, &adretSlope); + const WeatherSample thermalNight = + clearSky.sampleAt(glm::vec3(0.0f, 1200.0f, 0.0f), 3.0f, &adretSlope); + check(thermalNoon.thermalMps > 1.0f, + "Thermiques : un adret ensoleille produit une vraie ascendance"); + checkNear(thermalNight.thermalMps, 0.0f, 1e-6f, + "Thermiques : rien la nuit (controle negatif)"); + + // Sous un ciel couvert, la meme pente au meme instant doit produire + // beaucoup moins - c'est le mecanisme reel, et c'est aussi ce qui relie + // les thermiques a la nebulosite plutot qu'a la seule heure. + WeatherParams overcastParams = clearParams; + overcastParams.meanCloudCover = 1.0f; + const WeatherSystem overcast(overcastParams); + const WeatherSample thermalDull = overcast.sampleAt( + glm::vec3(0.0f, 1200.0f, 0.0f), overcastParams.thermalPeakHour, &adretSlope); + check(thermalDull.thermalMps < 0.5f * thermalNoon.thermalMps, + "Thermiques : un ciel couvert les etouffe"); + + // Et l'ubac, au meme instant, doit produire moins que l'adret. + NorthSouthSlope ubacSlope(0.60f); + const WeatherSample thermalUbac = clearSky.sampleAt( + glm::vec3(0.0f, 1200.0f, 0.0f), clearParams.thermalPeakHour, &ubacSlope); + check(thermalUbac.thermalMps < thermalNoon.thermalMps, + "Thermiques : l'ubac declenche moins que l'adret"); + } + + // ======================================================================= + // 6. PRECIPITATIONS ET MOUILLURE + // ======================================================================= + { + RidgeWithColTerrain ridge(800.0f, 400.0f, 300.0f, 0.60f, 400.0f); + + // Ciel forcement bouche : on veut mesurer la MODULATION par le relief, + // pas attendre qu'il pleuve. + WeatherParams wetParams; + wetParams.meanWindFromDegrees = 270.0f; + wetParams.windDirectionSwingDegrees = 0.0f; + wetParams.meanCloudCover = 1.0f; + wetParams.cloudAmplitude = 0.0f; + const WeatherSystem storm(wetParams); + + const float t = 2.0f * 24.0f + 15.0f; + const float flankY = ridge.heightAt(-250.0f, 1500.0f); + const WeatherSample windward = + storm.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), t, &ridge); + const WeatherSample lee = + storm.sampleAt(glm::vec3(250.0f, flankY, 1500.0f), t, &ridge); + + check(windward.precipitationMmPerHour > 0.0f, "Il pleut sous un ciel entierement couvert"); + check(windward.precipitationMmPerHour > lee.precipitationMmPerHour, + "Barriere orographique : il pleut plus sur le versant AU VENT"); + check(windward.cloudCover >= lee.cloudCover, + "Le versant au vent accroche aussi plus de nuages"); + + // Mouillure : monotone et bornee, seche quand il ne pleut plus. + check(windward.wetness > 0.5f, "Mouillure : le sol est trempe sous la pluie"); + for (int h = 0; h < 200; ++h) { + const WeatherSample s = + storm.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), static_cast(h), &ridge); + check(s.wetness >= 0.0f && s.wetness <= 1.0f, "Mouillure : toujours dans [0, 1]"); + } + + // Un ciel qui ne pleut jamais laisse un sol sec - controle negatif. + WeatherParams dryParams = wetParams; + dryParams.meanCloudCover = 0.0f; + const WeatherSystem drought(dryParams); + const WeatherSample dry = + drought.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), t, &ridge); + checkNear(dry.wetness, 0.0f, 1e-6f, "Mouillure : sol sec quand il ne pleut jamais"); + + // La mouillure ne depend PAS du chemin : la relire a un instant donne + // rend toujours la meme chose, qu'on y arrive en une fois ou pas du tout. + const WeatherSample again = + storm.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), t, &ridge); + check(again.wetness == windward.wetness, + "Mouillure : relue, pas accumulee - donc identique a l'identique"); + + // Neige : au-dessus d'une certaine altitude, la meme precipitation tombe + // en neige. On monte tres haut pour que ce soit vrai quelle que soit la + // saison tiree. + const WeatherSample summit = + storm.sampleAt(glm::vec3(0.0f, 4000.0f, 0.0f), t, nullptr); + check(summit.snowing, "Neige : a 4000 m, la precipitation tombe en neige"); + check(!windward.snowing || windward.temperatureC <= wetParams.snowThresholdC, + "Neige : jamais annoncee au-dessus du seuil de temperature"); + } + + // ======================================================================= + // 7. REFROIDISSEMENT EOLIEN (formule publiee, PAS provisoire) + // ======================================================================= + { + // Valeur de reference publiee : -5 degres par 30 km/h de vent donne + // environ -13. On verifie a un degre pres, la formule etant exacte. + checkNear(windChillC(-5.0f, 30.0f / 3.6f), -13.0f, 1.0f, + "Refroidissement eolien : -5 C par 30 km/h donne environ -13 C"); + + check(windChillC(0.0f, 10.0f) < 0.0f, "Vent : le ressenti descend sous l'ambiante"); + check(windChillC(0.0f, 20.0f) < windChillC(0.0f, 10.0f), + "Vent : plus il souffle, plus il refroidit"); + check(windChillC(-10.0f, 10.0f) < windChillC(0.0f, 10.0f), + "Vent : a vent egal, plus il fait froid plus le ressenti est bas"); + + // Hors domaine : la fonction rend la temperature INCHANGEE plutot qu'une + // extrapolation fausse. C'est le point le plus facile a rater dans une + // implementation pressee - au-dessus de 10 degres la formule brute + // rendrait un vent RECHAUFFANT. + checkNear(windChillC(25.0f, 15.0f), 25.0f, 1e-6f, + "Hors domaine : au-dessus de 10 C, le vent ne rechauffe pas"); + checkNear(windChillC(0.0f, 0.5f), 0.0f, 1e-6f, + "Hors domaine : un souffle d'air ne refroidit pas"); + checkNear(windChillC(0.0f, 0.0f), 0.0f, 1e-6f, "Vent nul : aucun effet"); + } + + // ======================================================================= + // 8. ROBUSTESSE ET COUT + // ======================================================================= + { + RidgeWithColTerrain ridge(800.0f, 400.0f, 300.0f, 0.60f, 400.0f); + + // Entrees degenerees : le module ne doit jamais rendre de NaN, parce + // qu'un NaN de temperature contaminerait les quatre jauges de Needs puis + // la vitesse du joueur (voir le commentaire de clamp01 dans Needs.cpp). + const float nan = std::numeric_limits::quiet_NaN(); + const float inf = std::numeric_limits::infinity(); + const glm::vec3 broken(nan, inf, -nan); + const WeatherSample wrecked = sky.sampleAt(broken, nan, &ridge); + check(std::isfinite(wrecked.temperatureC) && std::isfinite(wrecked.windMps) && + std::isfinite(wrecked.verticalMps) && std::isfinite(wrecked.wetness), + "Robustesse : des entrees non finies ne produisent aucun NaN"); + + const WeatherSample past = sky.sampleAt(glm::vec3(0.0f, 900.0f, 0.0f), -500.0f, &ridge); + check(std::isfinite(past.temperatureC), + "Robustesse : un instant negatif reste calculable"); + + // --- COUT ------------------------------------------------------------ + // Budget de reference de la Phase 19 : le frame est domine par le GPU + // (81 % dans drawFrame, en Release). Le seuil ci-dessous est TRES large + // et volontairement : ce test 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 (voir la lecon de + // la Phase 17 sur les FPS bruites). + constexpr int kEvaluations = 20000; + const auto start = std::chrono::steady_clock::now(); + double sink = 0.0; + for (int i = 0; i < kEvaluations; ++i) { + const float t = static_cast(i) * 0.01f; + const glm::vec3 p(static_cast(i % 500) * 4.0f, 900.0f, + static_cast(i % 337) * 6.0f); + sink += sky.sampleAt(p, t, &ridge).temperatureC; + } + const double micros = std::chrono::duration( + std::chrono::steady_clock::now() - start).count(); + const double perCall = micros / kEvaluations; + std::printf(" [meteo] cout : %.2f us par evaluation complete " + "(%d evaluations, terrain analytique, somme %.0f)\n", + perCall, kEvaluations, sink); + check(perCall < 50.0, + "Cout : une evaluation meteo complete reste tres loin d'un budget d'image"); + + // La couche 1 seule doit etre nettement moins chere que la couche 2 : + // c'est ce qui justifie la surcharge sampleAt(position, SynopticState, + // terrain), celle qu'il faut appeler pour plusieurs points au meme + // instant. + const auto startSky = std::chrono::steady_clock::now(); + double skySink = 0.0; + for (int i = 0; i < kEvaluations; ++i) { + skySink += sky.synopticAt(static_cast(i) * 0.01f).seaLevelTemperatureC; + } + const double skyMicros = std::chrono::duration( + std::chrono::steady_clock::now() - startSky).count(); + std::printf(" [meteo] cout : %.2f us pour la couche synoptique seule (somme %.0f)\n", + skyMicros / kEvaluations, skySink); + } +} + +// =========================================================================== +// PHASE 23 - Ce que la meteo change dans les quatre activites +// =========================================================================== +// Meme regle que testWeather() : on verifie des PROPRIETES et des SIGNES, pas +// des valeurs. Et systematiquement par COMPARAISON de deux simulations +// identiques a un parametre pres - c'est la seule facon de mesurer un effet +// sans dependre du reglage exact des constantes provisoires. +// +// Chaque bloc porte aussi son CONTROLE NEGATIF : sans meteo, le comportement +// doit etre exactement celui d'avant la Phase 23. C'est ce qui prouve que les +// valeurs par defaut des nouveaux parametres sont bien neutres, et donc que la +// non-regression des Phases 8, 13 et 14 n'est pas un hasard. +void testWeatherGameplay() { + std::printf("\n--- Phase 23 : effets meteo sur les activites ---\n"); + + // ======================================================================= + // PARAPENTE + // ======================================================================= + { + constexpr float dt = 1.0f / 60.0f; + constexpr int kSteps = 60 * 30; // 30 s de vol + + // --- Controle negatif : air calme = vol de la Phase 8 --------------- + Paraglider reference; + Paraglider withDefaultAir; + reference.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f); + withDefaultAir.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f); + for (int i = 0; i < kSteps; ++i) { + reference.update(dt, 0.0f, 0.0f); + withDefaultAir.update(dt, 0.0f, 0.0f, AirState{}); + } + check(reference.position() == withDefaultAir.position(), + "Parapente : AirState par defaut = air calme = vol d'avant la Phase 23"); + + // --- Thermique : l'aile MONTE --------------------------------------- + // Une ascendance plus forte que le taux de chute doit faire gagner de + // l'altitude. C'est la definition du vol thermique, et rien dans le + // modele ne la code explicitement : elle sort de l'addition. + Paraglider soaring; + soaring.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f); + AirState thermal; + thermal.vertical = 3.0f; // > cruiseSinkRate (1,25) + for (int i = 0; i < kSteps; ++i) { + soaring.update(dt, 0.0f, 0.0f, thermal); + } + check(soaring.position().y > 1500.0f, + "Parapente : dans une thermique, l'aile gagne de l'altitude"); + check(soaring.climbRateMps() > 0.0f, "Parapente : le vario est positif en thermique"); + check(soaring.position().y > reference.position().y + 50.0f, + "Parapente : la thermique change vraiment le vol, elle ne le nuance pas"); + std::printf(" [vol] 30 s : air calme %.0f m, thermique 3 m/s %.0f m\n", + static_cast(reference.position().y), + static_cast(soaring.position().y)); + + // --- Subsidence : l'aile descend PLUS vite -------------------------- + Paraglider sinking; + sinking.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f); + AirState lee; + lee.vertical = -2.5f; + for (int i = 0; i < kSteps; ++i) { + sinking.update(dt, 0.0f, 0.0f, lee); + } + check(sinking.position().y < reference.position().y - 50.0f, + "Parapente : sous le vent, la subsidence coute cher"); + + // --- Vent : la derive ------------------------------------------------ + // Cap 0 = +X. Un vent d'ouest (qui pousse vers +X) doit allonger le vol + // vers l'est ; le meme vent, cap oppose, doit le raccourcir. Les deux + // sens sont testes : un modele qui ajouterait la NORME du vent passerait + // le premier test et echouerait le second. + AirState westerly; + westerly.wind = glm::vec3(6.0f, 0.0f, 0.0f); + + Paraglider downwind; + Paraglider upwind; + downwind.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f); // vers +X + upwind.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 180.0f); // vers -X + for (int i = 0; i < kSteps; ++i) { + downwind.update(dt, 0.0f, 0.0f, westerly); + upwind.update(dt, 0.0f, 0.0f, westerly); + } + check(downwind.position().x > reference.position().x + 100.0f, + "Parapente : vent dans le dos, on va nettement plus loin"); + check(upwind.position().x > -reference.position().x, + "Parapente : vent de face, on avance nettement moins"); + std::printf(" [vol] 30 s, vent 6 m/s : vent arriere %.0f m, vent de face %.0f m, " + "air calme %.0f m\n", + static_cast(downwind.position().x), + static_cast(std::abs(upwind.position().x)), + static_cast(reference.position().x)); + + // Le vent ne doit PAS changer l'altitude : c'est un vent horizontal. + checkNear(downwind.position().y, reference.position().y, 1e-2f, + "Parapente : un vent horizontal ne fait ni monter ni descendre"); + + // --- Turbulence ------------------------------------------------------ + Paraglider tossed; + tossed.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f); + AirState rough; + rough.turbulence = 1.0f; + float maxHeadingDrift = 0.0f; + for (int i = 0; i < kSteps; ++i) { + tossed.update(dt, 0.0f, 0.0f, rough); + maxHeadingDrift = std::max(maxHeadingDrift, std::abs(tossed.headingDegrees())); + } + check(maxHeadingDrift > 1.0f, + "Parapente : la turbulence fait reellement bouger le cap"); + check(maxHeadingDrift < 90.0f, + "Parapente : la turbulence chahute, elle ne met pas en vrille"); + check(tossed.position().y < reference.position().y, + "Parapente : l'air brasse coute de la finesse"); + + // Determinisme du vol turbulent : deux vols identiques doivent donner + // exactement le meme resultat. Sans ca, un vol ne serait pas rejouable, + // et toute la Phase 23 perdrait sa propriete centrale. + Paraglider twin; + twin.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f); + for (int i = 0; i < kSteps; ++i) { + twin.update(dt, 0.0f, 0.0f, rough); + } + check(twin.position() == tossed.position() && + twin.headingDegrees() == tossed.headingDegrees(), + "Parapente : meme vol turbulent, meme trajectoire (deterministe)"); + } + + // ======================================================================= + // ESCALADE - adherence de la paroi + // ======================================================================= + { + CliffTerrain cliff(0.0f, 3.0f, 0.0f, 10.0f); + constexpr float dt = 1.0f / 60.0f; + constexpr int kSteps = 60 * 20; // 20 s de montee + + const auto climbFor = [&](float grip, float* stamina) { + Climber climber; + climber.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + for (int i = 0; i < kSteps && climber.climbing(); ++i) { + climber.update(dt, 1.0f, 0.0f, cliff, nullptr, grip); + } + if (stamina) { *stamina = climber.stamina(); } + return climber.heightGained(); + }; + + float dryStamina = 0.0f; + float wetStamina = 0.0f; + const float dryRise = climbFor(1.0f, &dryStamina); + const float wetRise = climbFor(Climber{}.params().wetGrip, &wetStamina); + + check(dryRise > 0.0f, "Escalade : on monte bien sur rocher sec"); + check(wetRise < dryRise, + "Escalade : sur paroi mouillee, on progresse MESURABLEMENT moins vite"); + + // Le cout par METRE monte, ce qui est la partie qui compte : une paroi + // mouillee n'est pas seulement plus lente, elle est plus chere. Un + // modele qui ne ferait que ralentir laisserait la jauge dire le + // contraire - moins de metres, donc moins d'energie depensee. + const float dryCost = (1.0f - dryStamina) / std::max(0.01f, dryRise); + const float wetCost = (1.0f - wetStamina) / std::max(0.01f, wetRise); + check(wetCost > dryCost, + "Escalade : chaque metre de paroi mouillee coute plus cher que sur du sec"); + std::printf(" [escalade] 20 s : sec %.1f m (%.3f de jauge/m), " + "mouille %.1f m (%.3f de jauge/m)\n", + static_cast(dryRise), static_cast(dryCost), + static_cast(wetRise), static_cast(wetCost)); + + // Controle negatif : sans argument de grip, l'escalade est celle de la + // Phase 14. + Climber withGrip; + Climber withoutGrip; + withGrip.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + withoutGrip.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); + for (int i = 0; i < 600; ++i) { + withGrip.update(dt, 1.0f, 0.0f, cliff, nullptr, 1.0f); + withoutGrip.update(dt, 1.0f, 0.0f, cliff, nullptr); + } + check(withGrip.anchor() == withoutGrip.anchor() && + withGrip.stamina() == withoutGrip.stamina(), + "Escalade : grip par defaut = rocher sec = escalade d'avant la Phase 23"); + + // La traduction humidite -> adherence est monotone et bornee. + Climber sample; + check(sample.gripForWetness(0.0f) == 1.0f, "Adherence : sec = 1"); + check(sample.gripForWetness(1.0f) < 1.0f, "Adherence : trempe < sec"); + check(sample.gripForWetness(0.5f) < sample.gripForWetness(0.0f) && + sample.gripForWetness(0.5f) > sample.gripForWetness(1.0f), + "Adherence : monotone entre les deux"); + check(sample.gripForWetness(2.0f) == sample.gripForWetness(1.0f) && + sample.gripForWetness(-1.0f) == sample.gripForWetness(0.0f), + "Adherence : une humidite hors bornes est ecretee, pas extrapolee"); + + // Une paroi ruisselante reste GRIMPABLE : le plancher d'adherence existe + // pour qu'un joueur ne se retrouve jamais bloque en paroi, ni montant ni + // descendant. + check(wetRise > 0.0f, "Escalade : une paroi trempee se grimpe encore, lentement"); + } + + // ======================================================================= + // VELO - sol detrempe + // ======================================================================= + { + FlatTerrain flat; + + // Vitesse d'equilibre en pedalant a fond, sec contre trempe. + const auto settleWet = [&](float wetness) { + Bike bike; + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + float previous = -1.0f; + for (int i = 0; i < 60 * 120; ++i) { + bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr, wetness); + if (std::abs(bike.speed() - previous) < 1e-3f && i > 60) { break; } + previous = bike.speed(); + } + return bike.speed(); + }; + + const float drySpeed = settleWet(0.0f); + const float wetSpeed = settleWet(1.0f); + check(wetSpeed < drySpeed, + "Velo : sur sol detrempe, la vitesse d'equilibre est plus basse"); + check(wetSpeed > 0.5f * drySpeed, + "Velo : le sol mouille freine, il n'immobilise pas"); + std::printf(" [velo] vitesse d'equilibre a plat : sec %.1f km/h, trempe %.1f km/h\n", + static_cast(drySpeed * 3.6f), + static_cast(wetSpeed * 3.6f)); + + // Freinage : depuis la meme vitesse, la meme commande de frein pendant la + // meme duree doit laisser PLUS de vitesse sur sol mouille. + const auto brakeFrom = [&](float wetness) { + Bike bike; + bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + for (int i = 0; i < 60 * 60; ++i) { + bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr, 0.0f); + } + const float entry = bike.speed(); + for (int i = 0; i < 30; ++i) { // une demi-seconde de frein + bike.update(1.0f / 60.0f, 0.0f, 0.0f, 1.0f, flat, nullptr, wetness); + } + return entry - bike.speed(); + }; + const float dryLoss = brakeFrom(0.0f); + const float wetLoss = brakeFrom(1.0f); + check(wetLoss < dryLoss, + "Velo : sur sol detrempe, une demi-seconde de frein enleve moins de vitesse"); + std::printf(" [velo] 0,5 s de frein : sec -%.1f km/h, trempe -%.1f km/h\n", + static_cast(dryLoss * 3.6f), static_cast(wetLoss * 3.6f)); + + // Controle negatif : sans argument, la physique est celle de la Phase 13. + Bike explicitDry; + Bike implicitDry; + explicitDry.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + implicitDry.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat); + for (int i = 0; i < 600; ++i) { + explicitDry.update(1.0f / 60.0f, 0.2f, 1.0f, 0.0f, flat, nullptr, 0.0f); + implicitDry.update(1.0f / 60.0f, 0.2f, 1.0f, 0.0f, flat, nullptr); + } + check(explicitDry.position() == implicitDry.position() && + explicitDry.speed() == implicitDry.speed(), + "Velo : humidite par defaut = sol sec = physique d'avant la Phase 23"); + } + + // ======================================================================= + // LUMIERE DU JOUR - le cycle jour/nuit visuel + // ======================================================================= + { + const WeatherSystem sky; + const WeatherParams params; + + const SunLight noon = sunLightFor(sky.synopticAt(12.0f), params); + const SunLight midnight = sunLightFor(sky.synopticAt(0.0f), params); + check(noon.intensity > 0.9f, "Lumiere : pleine intensite a midi"); + checkNear(midnight.intensity, 0.0f, 1e-6f, "Lumiere : aucune lumiere directe a minuit"); + + // L'AUBE EST UNE TRANSITION, pas un interrupteur : il doit exister des + // instants ou la lumiere directe est partielle. On les CHERCHE au lieu + // de parier sur une heure : l'heure du lever depend de la saison, et une + // premiere redaction de ce test interrogeait 6 h 30 - qui est deja le + // plein jour a la mi-mai au 45e parallele. + int partialQuarters = 0; + for (int i = 0; i < 24 * 12; ++i) { + const float intensity = + sunLightFor(sky.synopticAt(static_cast(i) / 12.0f), params).intensity; + if (intensity > 0.02f && intensity < 0.98f) { ++partialQuarters; } + } + check(partialQuarters >= 4, + "Lumiere : l'aube et le crepuscule durent, ce n'est pas un interrupteur"); + std::printf(" [lumiere] %d intervalles de 5 min en lumiere partielle sur 24 h\n", + partialQuarters); + + check(noon.direction.y > 0.5f, "Lumiere : le soleil de midi vient d'en haut"); + check(midnight.direction.y > 0.9f, + "Lumiere : la nuit, la direction bascule a la verticale (rien n'est eclaire " + "par en dessous)"); + + check(midnight.ambient > 0.0f, + "Lumiere : la nuit n'est pas noire - choix de jouabilite assume"); + check(midnight.ambient < noon.ambient, + "Lumiere : la nuit est tout de meme nettement plus sombre que le jour"); + checkNear(noon.ambient, 1.0f, 1e-3f, + "Lumiere : en plein jour, l'ambiante des shaders est inchangee (x1)"); + + // La direction de la lumiere DOIT etre celle du soleil de la meteo : un + // second soleil qui divergerait est exactement ce que cette phase + // corrige. + const SynopticState afternoon = sky.synopticAt(15.0f); + const SunLight afternoonLight = sunLightFor(afternoon, params); + checkNear(glm::dot(afternoonLight.direction, afternoon.sunDirection), 1.0f, 1e-3f, + "Lumiere : c'est LE soleil de la meteo, pas un second soleil"); + + // Le soleil traverse bien le ciel : est le matin, ouest le soir. + const SunLight morningLight = sunLightFor(sky.synopticAt(8.0f), params); + const SunLight eveningLight = sunLightFor(sky.synopticAt(18.0f), params); + check(morningLight.direction.x > 0.0f && eveningLight.direction.x < 0.0f, + "Lumiere : la direction traverse le ciel d'est en ouest dans la journee"); + + // Determinisme : deux captures au meme instant de jeu doivent etre + // comparables, ce qui est la condition de la verification visuelle du + // projet depuis la Phase 12. + const SunLight again = sunLightFor(sky.synopticAt(15.0f), params); + check(again.direction == afternoonLight.direction && + again.intensity == afternoonLight.intensity, + "Lumiere : deterministe, donc deux captures au meme instant sont comparables"); + + // Toutes les valeurs restent dans leurs bornes, a toute heure. + for (int i = 0; i < 24 * 4; ++i) { + const SunLight light = sunLightFor(sky.synopticAt(static_cast(i) * 0.25f), params); + check(light.intensity >= 0.0f && light.intensity <= 1.0f, + "Lumiere : intensite toujours dans [0, 1]"); + check(light.ambient >= 0.0f && light.ambient <= 1.0f, + "Lumiere : multiplicateur d'ambiante toujours dans [0, 1]"); + checkNear(glm::length(light.direction), 1.0f, 1e-3f, + "Lumiere : la direction est toujours unitaire"); + check(light.direction.y >= 0.0f, + "Lumiere : jamais eclaire par en dessous, a aucune heure"); + } + } +} + +// =========================================================================== +// PHASE 27 - Meteo visible +// =========================================================================== +// Meme regle que testWeather() : des PROPRIETES et des SIGNES. Et une regle en +// plus, propre a cette phase : chaque effet visuel doit etre NUL quand la +// grandeur meteo qui le pilote est nulle. C'est la preuve executable qu'aucun +// effet n'a ete invente - un effet qui existerait sans sa grandeur serait par +// definition une mecanique nouvelle. +// PHASE 27 - texture de bruit du micro-relief (assets/DetailNoise.hpp). +void testDetailNoise() { + std::printf("\n[Phase 27] Texture de bruit de detail\n"); + const TextureData t = makeDetailNoiseTexture(256, 32); + check(t.width == 256 && t.mips.size() == 9 && t.mips.back().width == 1, + "Bruit de detail : 256x256 et chaine complete de 9 mipmaps"); + const auto px = [&](uint32_t x, uint32_t y, int ch) { + return static_cast(t.pixels[(static_cast(y) * 256 + x) * 4 + ch]); + }; + // Periodicite : la colonne 255 doit se raccorder a la colonne 0 aussi bien + // que deux colonnes voisines quelconques (sinon une couture en repetition). + double seam = 0.0, inner = 0.0; + for (uint32_t y = 0; y < 256; ++y) { + seam += std::abs(px(255, y, 0) - px(0, y, 0)); + inner += std::abs(px(128, y, 0) - px(127, y, 0)); + } + check(seam < 2.0 * inner + 256.0, "Bruit de detail : raccord periodique sans couture"); + // Derivee codee coherente avec la variation reelle de la valeur : + // correlation positive entre G et (R[x+1] - R[x-1]). + double corr = 0.0; + for (uint32_t y = 0; y < 256; y += 3) { + for (uint32_t x = 1; x < 255; x += 3) { + corr += (px(x, y, 1) - 127.5) * (px(x + 1, y, 0) - px(x - 1, y, 0)); + } + } + check(corr > 0.0, "Bruit de detail : la derivee codee suit la pente de la valeur"); + bool inRange = true; + for (size_t i = 0; i < t.mips[0].size; i += 4) { + if (t.pixels[i] == 0 && t.pixels[i + 1] == 0) { inRange = false; } + } + check(inRange, "Bruit de detail : aucune derivee saturee a zero"); + const TextureData again = makeDetailNoiseTexture(256, 32); + check(again.pixels == t.pixels, "Bruit de detail : deterministe"); +} + +void testWeatherVisuals() { + std::printf("\n[Phase 27] Meteo visible\n"); + + const WeatherSystem weather; + const WeatherParams params; + + const auto sampleWith = [](float cloud, float precip, bool snowing, float wetness, + glm::vec3 wind) { + WeatherSample s; + s.cloudCover = cloud; + s.precipitationMmPerHour = precip; + s.snowing = snowing; + s.wetness = wetness; + s.windVector = wind; + return s; + }; + const auto saturation = [](const glm::vec3& c) { + return std::max({c.r, c.g, c.b}) - std::min({c.r, c.g, c.b}); + }; + + const SynopticState noon = weather.synopticAt(12.0f); + const SynopticState midnight = weather.synopticAt(24.0f); + + // --- Ciel clair et sec : RIEN ne change par rapport a la Phase 23 -------- + { + const WeatherVisuals clear = + weatherVisualsFor(noon, sampleWith(0.0f, 0.0f, false, 0.0f, glm::vec3(0.0f)), params); + const SunLight reference = sunLightFor(noon, params); + check(clear.light.intensity == reference.intensity && + clear.light.ambient == reference.ambient && + clear.light.skyColor == reference.skyColor && + clear.light.color == reference.color && + clear.light.direction == reference.direction, + "Meteo visible : ciel clair et sec = lumiere de la Phase 23, au bit pres"); + check(clear.fogDensityPerMeter == 0.0f, + "Meteo visible : aucun brouillard sans precipitation"); + check(clear.precipitation == 0.0f, + "Meteo visible : aucune precipitation dessinee sans precipitation calculee"); + check(clear.groundDarkening == 0.0f, + "Meteo visible : un sol sec n'est pas assombri"); + } + + // --- Nebulosite : monotone, et de jour seulement pour l'ambiante --------- + { + float lastDirect = 2.0f, lastSat = 2.0f, lastAmbient = -1.0f; + bool monotone = true; + for (int i = 0; i <= 10; ++i) { + const float cloud = static_cast(i) / 10.0f; + const WeatherVisuals v = weatherVisualsFor( + noon, sampleWith(cloud, 0.0f, false, 0.0f, glm::vec3(0.0f)), params); + if (v.light.intensity > lastDirect || saturation(v.light.skyColor) > lastSat || + v.light.ambient < lastAmbient) { + monotone = false; + } + lastDirect = v.light.intensity; + lastSat = saturation(v.light.skyColor); + lastAmbient = v.light.ambient; + } + check(monotone, + "Meteo visible : plus de nuages = moins de soleil direct, ciel plus gris, " + "ambiante plus diffuse - sans inversion sur toute la plage"); + + const WeatherVisuals overcast = weatherVisualsFor( + noon, sampleWith(1.0f, 0.0f, false, 0.0f, glm::vec3(0.0f)), params); + checkNear(overcast.light.intensity, + sunLightFor(noon, params).intensity * (1.0f - params.cloudAspectDamping), 1e-5f, + "Meteo visible : le voile du soleil reprend cloudAspectDamping (un seul " + "chiffre pour 'les nuages cachent le soleil')"); + check(saturation(overcast.light.skyColor) < 1e-4f, + "Meteo visible : un ciel entierement couvert est gris"); + // AJOUTE APRES LA PREMIERE CAPTURE : le gain d'ambiante etait ecrete a + // 1, donc MORT en plein jour (ou l'ambiante vaut deja 1), et la boucle + // monotone ci-dessus ne pouvait pas le voir - "ne decroit pas" est vrai + // d'une constante. Il faut exiger que l'effet EXISTE. + check(overcast.light.ambient > sunLightFor(noon, params).ambient * 1.5f, + "Meteo visible : sous un ciel couvert de jour, l'ambiante diffuse " + "augmente REELLEMENT (pas d'ecretage qui l'annule)"); + + const WeatherVisuals nightClear = weatherVisualsFor( + midnight, sampleWith(0.0f, 0.0f, false, 0.0f, glm::vec3(0.0f)), params); + const WeatherVisuals nightOvercast = weatherVisualsFor( + midnight, sampleWith(1.0f, 0.0f, false, 0.0f, glm::vec3(0.0f)), params); + checkNear(nightOvercast.light.ambient, nightClear.light.ambient, 1e-6f, + "Meteo visible : une nuit couverte n'est pas plus claire qu'une nuit claire"); + check(glm::dot(nightOvercast.light.skyColor, glm::vec3(1.0f)) <= + glm::dot(nightClear.light.skyColor, glm::vec3(1.0f)) + 1e-5f, + "Meteo visible : un ciel couvert de nuit reste un ciel de nuit"); + } + + // --- Precipitation, brouillard, neige, vent -------------------------------- + { + const WeatherVisuals rain = weatherVisualsFor( + noon, sampleWith(0.95f, 5.0f, false, 0.0f, glm::vec3(0.0f)), params); + check(rain.precipitation > 0.5f && !rain.snow, + "Meteo visible : 5 mm/h de pluie se dessinent, en pluie"); + const float visibilityKm = 3.912f / (rain.fogDensityPerMeter * 1000.0f); + check(visibilityKm > 1.0f && visibilityKm < 20.0f, + "Meteo visible : visibilite sous 5 mm/h entre 1 et 20 km (ordre de grandeur)"); + std::printf(" [brouillard] visibilite de Koschmieder sous 5 mm/h : %.1f km\n", + visibilityKm); + + const WeatherVisuals lightRain = weatherVisualsFor( + noon, sampleWith(0.95f, 1.0f, false, 0.0f, glm::vec3(0.0f)), params); + check(lightRain.fogDensityPerMeter < rain.fogDensityPerMeter && + lightRain.precipitation < rain.precipitation, + "Meteo visible : une pluie faible voile moins et se dessine moins qu'une forte"); + + const WeatherVisuals snow = weatherVisualsFor( + noon, sampleWith(0.95f, 5.0f, true, 0.0f, glm::vec3(0.0f)), params); + check(snow.snow && snow.fogDensityPerMeter > rain.fogDensityPerMeter, + "Meteo visible : a lame d'eau egale, la neige voile plus que la pluie"); + check(std::abs(snow.fallVelocity.y) < std::abs(rain.fallVelocity.y), + "Meteo visible : la neige tombe plus lentement que la pluie"); + + const glm::vec3 eastward(8.0f, 0.0f, 0.0f); + const WeatherVisuals windy = weatherVisualsFor( + noon, sampleWith(0.95f, 5.0f, false, 0.0f, eastward), params); + check(windy.fallVelocity.x > 7.9f && std::abs(windy.fallVelocity.z) < 1e-5f, + "Meteo visible : la pluie est poussee par le vent LOCAL, dans son sens"); + + const WeatherVisuals wet = weatherVisualsFor( + noon, sampleWith(0.0f, 0.0f, false, 1.0f, glm::vec3(0.0f)), params); + checkNear(wet.groundDarkening, params.wetGroundDarkening, 1e-6f, + "Meteo visible : un sol ruisselant est assombri de wetGroundDarkening"); + check(wet.precipitation == 0.0f && wet.fogDensityPerMeter == 0.0f, + "Meteo visible : un sol encore mouille apres l'averse ne fait pas pleuvoir"); + + const WeatherVisuals garbage = weatherVisualsFor( + noon, sampleWith(std::nanf(""), std::nanf(""), false, std::nanf(""), + glm::vec3(0.0f)), params); + check(std::isfinite(garbage.fogDensityPerMeter) && + std::isfinite(garbage.light.ambient) && + std::isfinite(garbage.light.skyColor.r), + "Meteo visible : une entree non finie ne produit pas de NaN a l'ecran"); + } + + // --- COHERENCE AVEC LE CALENDRIER REEL, et continuite ---------------------- + // Trente jours de jeu, une minute de jeu par pas : l'effet visuel doit + // exister EXACTEMENT quand la meteo le dit, et ne jamais sauter. + { + int rainyMinutes = 0, mismatches = 0, phaseFlips = 0, unexplainedFogJumps = 0; + float maxFogJump = 0.0f, maxSkyJump = 0.0f, maxPrecipJump = 0.0f; + WeatherVisuals previous{}; + bool havePrevious = false; + const glm::vec3 alpage(0.0f, 1500.0f, 0.0f); + for (int minute = 0; minute < 30 * 24 * 60; ++minute) { + const float hours = static_cast(minute) / 60.0f; + const SynopticState sky = weather.synopticAt(hours); + const WeatherSample local = weather.sampleAt(alpage, sky, nullptr); + const WeatherVisuals v = weatherVisualsFor(sky, local, params); + + const bool raining = local.precipitationMmPerHour > 0.0f; + if (raining) { ++rainyMinutes; } + if (raining != (v.precipitation > 0.0f) || + raining != (v.fogDensityPerMeter > 0.0f)) { + ++mismatches; + } + if (havePrevious) { + // La BASCULE PLUIE <-> NEIGE est une discontinuite du MODELE, pas + // du rendu : WeatherSample::snowing est un booleen (seuil + // snowThresholdC), et la neige voile x8 plus que la pluie. Le + // premier jet de ce test l'a trouvee : j1 6 h 55 a 1500 m, la + // visibilite passe de 1,6 a 13 km en une minute de jeu. La lisser + // demanderait une phase MIXTE (pluie et neige melees) que Weather + // ne modelise pas - prerequis manquant, documente, pas invente + // ici. Le test l'ISOLE : ces minutes-la sont comptees a part, et + // TOUT AUTRE saut reste un echec. + const bool flip = v.snow != previous.snow; + if (flip) { ++phaseFlips; } + const float fogJump = + std::abs(v.fogDensityPerMeter - previous.fogDensityPerMeter); + if (!flip && fogJump > 2e-4f) { ++unexplainedFogJumps; } + if (!flip) { maxFogJump = std::max(maxFogJump, fogJump); } + maxPrecipJump = std::max(maxPrecipJump, + std::abs(v.precipitation - previous.precipitation)); + maxSkyJump = std::max(maxSkyJump, + glm::length(v.light.skyColor - previous.light.skyColor)); + } + previous = v; + havePrevious = true; + } + check(rainyMinutes > 0, + "Meteo visible : le calendrier de 30 jours contient de la pluie a montrer"); + check(mismatches == 0, + "Meteo visible : pluie et brouillard a l'ecran EXACTEMENT quand la meteo " + "calcule une precipitation, jamais sinon"); + // Bornes de continuite : une minute de jeu ne doit pas faire sauter + // l'image. 0,05 de couleur de ciel ~ 13 niveaux sur 255 : c'est le + // crepuscule, deja present depuis la Phase 23, qui fixe le plafond. + // + // Brouillard : 2e-4 /m par minute. La montee d'une averse de NEIGE + // (x8) progresse d'environ 6e-5 /m par minute, lissement ; un saut + // d'un ordre de grandeur au-dessus serait une vraie discontinuite. + check(maxSkyJump < 0.05f && maxPrecipJump < 0.05f && unexplainedFogJumps == 0, + "Meteo visible : continue dans le temps, hors bascule pluie/neige du modele"); + std::printf(" [calendrier] %d minutes de pluie sur 30 jours ; sauts max par " + "minute : ciel %.4f, pluie %.4f, brouillard %.2e /m ; %d bascule(s) " + "pluie/neige (discontinuite du modele, voir NOTES-PHASE27.md)\n", + rainyMinutes, maxSkyJump, maxPrecipJump, maxFogJump, phaseFlips); + + // Controle negatif sur les deux instants des captures de la phase : + // meme heure, meme lieu, seul le jour change. + const SynopticState rainyDay = weather.synopticAt(8 * 24.0f + 13.0f); + const SynopticState clearDay = weather.synopticAt(12 * 24.0f + 13.0f); + const WeatherVisuals rainy = + weatherVisualsFor(rainyDay, weather.sampleAt(alpage, rainyDay, nullptr), params); + const WeatherVisuals clear = + weatherVisualsFor(clearDay, weather.sampleAt(alpage, clearDay, nullptr), params); + check(rainy.precipitation > 0.0f && clear.precipitation == 0.0f, + "Meteo visible : il pleut a l'ecran le jour 8 a 13 h, pas le jour 12"); + check(saturation(rainy.light.skyColor) < saturation(clear.light.skyColor), + "Meteo visible : le ciel du jour 8 est plus gris que celui du jour 12"); + } +} + +// =========================================================================== +// PHASE 28 : faconnage generique (world/Crafting), foyers, reposer au sol +// =========================================================================== +bool sameGround(const Ground& a, const Ground& b) { + if (a.itemCount() != b.itemCount()) return false; + for (std::size_t i = 0; i < a.itemCount(); ++i) { + const GroundItem& x = a.items()[i]; + const GroundItem& y = b.items()[i]; + if (x.kind != y.kind || x.position != y.position || x.yaw != y.yaw || x.roll != y.roll) { + return false; + } + } + return true; +} + +bool sameInventory(const Inventory& a, const Inventory& b) { + for (uint32_t k = 0; k < kGroundItemKindCount; ++k) { + if (a.count(static_cast(k)) != b.count(static_cast(k))) { + return false; + } + } + return true; +} + +int countKind(const Ground& ground, GroundItemKind kind) { + int n = 0; + for (const GroundItem& item : ground.items()) { + if (item.kind == kind) ++n; + } + return n; +} + +const GroundItem* firstOfKind(const Ground& ground, GroundItemKind kind) { + for (const GroundItem& item : ground.items()) { + if (item.kind == kind) return &item; + } + return nullptr; +} + +void testCraftingRecipeTable() { + section("Phase 28 : table des recettes, nouvelles natures d'objets"); + + // Unicite des id, sortie absente des ingredients, bornes. + bool idsUnique = true; + bool outNotInput = true; + bool countsSane = true; + for (std::size_t i = 0; i < kRecipes.size(); ++i) { + for (std::size_t j = i + 1; j < kRecipes.size(); ++j) { + if (std::strcmp(kRecipes[i].id, kRecipes[j].id) == 0) idsUnique = false; + } + const Recipe& r = kRecipes[i]; + if (r.inCount == 0 || r.inCount > r.in.size()) countsSane = false; + for (uint8_t k = 0; k < r.inCount && k < r.in.size(); ++k) { + if (r.in[k].count == 0) countsSane = false; + if (r.hasOutput && r.in[k].kind == r.out) outNotInput = false; + } + check(findRecipe(r.id) == static_cast(i), + std::string("findRecipe retrouve ") + r.id); + } + check(idsUnique, "Recettes : id uniques"); + check(outNotInput, "Recettes : aucune sortie ne figure parmi ses ingredients"); + check(countsSane, "Recettes : nombres d'ingredients coherents"); + check(findRecipe("inexistante") == -1, "findRecipe : id inconnu -> -1"); + // PHASE 28 (Agent 3) : 8 -> 10 (abri, hache renforcee). + check(kRecipes.size() == 10, "Dix recettes dans la table"); + check(findRecipe("shelter") == 0, "Priorite : l'abri en tete (la plus complexe)"); + check(findRecipe("shelter") < findRecipe("hearth"), "Priorite : abri avant foyer"); + check(findRecipe("pitched_axe") < findRecipe("axe"), "Priorite : hache renforcee avant hache"); + + // Ordre de priorite : le foyer avant la hache, la hache avant la ligature, + // la percussion en DERNIER (la plus simple). + check(findRecipe("hearth") < findRecipe("axe"), "Priorite : foyer avant hache"); + check(findRecipe("axe") < findRecipe("cord"), "Priorite : hache avant ligature"); + check(findRecipe("pitch") < findRecipe("cord"), "Priorite : poix avant ligature"); + check(findRecipe("knap") == static_cast(kRecipes.size()) - 1, + "Priorite : la percussion est la derniere recette"); + + // Recettes demandees par la conception, a l'unite pres. + { + const Recipe& h = kRecipes[static_cast(findRecipe("hearth"))]; + check(h.out == GroundItemKind::Hearth && h.effect == CraftEffect::LightNewHearth, + "Foyer : produit un foyer allume"); + check(h.in[0].kind == GroundItemKind::Stone && h.in[0].count == 3 && + h.in[0].source == CraftSource::Placed && h.in[0].consumed, + "Foyer : 3 pierres posees consommees"); + check(h.in[1].kind == GroundItemKind::Branch && h.in[1].count == 2 && + h.in[1].source == CraftSource::Placed && h.in[1].consumed, + "Foyer : 2 branches posees consommees"); + check(h.in[2].kind == GroundItemKind::Flake && h.in[2].source == CraftSource::Carried && + !h.in[2].consumed, + "Foyer : eclat porte, outil non consomme"); + const Recipe& p = kRecipes[static_cast(findRecipe("pitch"))]; + check(p.station == CraftStation::LitHearth, "Poix : exige un foyer allume"); + } + + // Toutes les natures ont un rayon, des libelles et (pour les nouvelles) un mesh. + check(kGroundItemKindCount == 15, "15 natures d'objets au sol (Phase 28, Agent 3)"); + bool radiiOk = true; + bool labelsOk = true; + for (uint32_t k = 0; k < kGroundItemKindCount; ++k) { + const auto kind = static_cast(k); + if (!(groundItemRestRadius(kind) > 0.0f)) radiiOk = false; + if (std::strcmp(groundItemLabel(kind), "objet") == 0 || + std::strcmp(groundItemLabelIndefinite(kind), "un objet") == 0 || + std::strcmp(groundItemLabelPlural(kind), "objets") == 0) { + labelsOk = false; + } + } + check(radiiOk, "Toutes les natures ont un rayon de repos > 0"); + check(labelsOk, "Toutes les natures ont leurs trois libelles"); + check(!groundItemIsPortable(GroundItemKind::Hearth), "Le foyer n'est pas portable"); + check(groundItemIsPortable(GroundItemKind::Axe) && groundItemIsPortable(GroundItemKind::Ash) && + groundItemIsPortable(GroundItemKind::Stone), + "Hache, cendre, pierre : portables"); + check(!groundItemIsPortable(GroundItemKind::Shelter), "L'abri n'est pas portable"); + check(groundItemIsPortable(GroundItemKind::PitchedAxe), "La hache renforcee est portable"); + + const std::array, 6> meshes = { { + { pitchedAxeMeshData(), kAxeRadius }, + { cordMeshData(), kCordRadius }, { axeMeshData(), kAxeRadius }, + { hearthMeshData(), kHearthRadius }, { ashMeshData(), kAshRadius }, + { pitchMeshData(), kPitchRadius }, + } }; + for (const auto& [mesh, radius] : meshes) { + bool indicesValid = !mesh.empty() && mesh.indices.size() % 3 == 0; + bool normalsUnit = true; + bool restsOnGround = true; + bool handSized = true; + float minY = 1e9f; + for (const uint32_t index : mesh.indices) { + if (index >= mesh.vertices.size()) indicesValid = false; + } + for (const Vertex& v : mesh.vertices) { + if (std::abs(glm::length(v.normal) - 1.0f) > 1e-3f) normalsUnit = false; + if (v.pos.y > radius + 1e-4f || v.pos.y < -radius - 1e-4f) restsOnGround = false; + if (std::abs(v.pos.x) > 0.5f || std::abs(v.pos.z) > 0.5f) handSized = false; + minY = std::min(minY, v.pos.y); + } + check(indicesValid, "Mesh valide : " + mesh.name); + check(normalsUnit, "Normales unitaires : " + mesh.name); + check(restsOnGround, "Tient dans sa demi-hauteur : " + mesh.name); + checkNear(minY, -radius, 0.01f, "Touche le sol (bas = -rayon) : " + mesh.name); + check(handSized, "Dimensions plausibles : " + mesh.name); + } + + // Resume d'inventaire : matieres toujours listees, objets faconnes seulement + // s'ils sont portes. + Inventory inventory; + check(inventory.summary().find("buches 0") != std::string::npos && + inventory.summary().find("ligatures") == std::string::npos, + "Resume : matieres a zero listees, objets faconnes a zero masques"); + inventory.add(GroundItemKind::Cord); + check(inventory.summary().find("ligatures 1") != std::string::npos, + "Resume : une ligature portee apparait"); +} + +void testCraftingKnapUnchanged() { + section("Phase 28 : la percussion par la table = knapStones au bit pres"); + + FlatTerrain flat; + const glm::vec3 player{ 3.0f, 1.7f, -2.0f }; + const glm::vec3 facing{ 0.3f, -0.2f, -1.0f }; + + Ground groundA(flat); + Ground groundB(flat); + Inventory invA; + Inventory invB; + invA.add(GroundItemKind::Stone, 2); + invB.add(GroundItemKind::Stone, 2); + HearthSet hearths; + + check(knapStones(invA, groundA, player, facing) == KnapResult::Success, + "knapStones reussit (reference)"); + const CraftOutcome outcome = craftAt(invB, groundB, hearths, player, facing, 0.0f); + check(outcome.result == CraftResult::Success && outcome.recipe == findRecipe("knap"), + "craftAt choisit la percussion avec deux pierres portees"); + check(outcome.message == knapResultMessage(KnapResult::Success), + "Message de succes identique a la Phase 6"); + check(sameInventory(invA, invB) && invB.count(GroundItemKind::Stone) == 1, + "Une seule pierre consommee (le percuteur reste)"); + check(sameGround(groundA, groundB), "Eclat depose au meme endroit, meme yaw"); + + // Refus : message historique, rien ne change. + Inventory one; + one.add(GroundItemKind::Stone); + Ground empty(flat); + const CraftOutcome refused = craftAt(one, empty, hearths, player, facing, 0.0f); + check(refused.result == CraftResult::MissingIngredients, "Une pierre : refus"); + check(refused.message == knapResultMessage(KnapResult::NotEnoughStones), + "Refus de percussion : message historique mot pour mot"); + check(one.count(GroundItemKind::Stone) == 1 && empty.itemCount() == 0, + "Refus : rien consomme, rien depose"); + + // Regard vertical : repli sans NaN, eclat a +X. + Inventory two; + two.add(GroundItemKind::Stone, 2); + Ground g(flat); + craftAt(two, g, hearths, player, { 0.0f, -1.0f, 0.0f }, 0.0f); + check(g.itemCount() == 1 && !std::isnan(g.items()[0].position.x) && + !std::isnan(g.items()[0].position.z), + "Regard vertical : aucun NaN"); + checkNear(g.items()[0].position.x, player.x + kCraftDropDistance, 1e-5f, + "Regard vertical : repli sur +X a 1,1 m"); +} + +void testCraftingCord() { + section("Phase 28 : ligature (3 fibres portees)"); + + FlatTerrain flat; + Ground ground(flat); + HearthSet hearths; + const glm::vec3 player{ 0.0f, 1.7f, 0.0f }; + const glm::vec3 facing{ 0.0f, 0.0f, -1.0f }; + + Inventory inventory; + inventory.add(GroundItemKind::Fiber, 2); + // Une troisieme fibre AU SOL ne compte pas : la ligature se tord en main. + ground.drop(GroundItemKind::Fiber, 0.5f, 0.0f, 0.0f, 0.0f); + const Ground groundBefore = ground; + const Inventory invBefore = inventory; + const CraftOutcome refused = craftAt(inventory, ground, hearths, player, facing, 0.0f); + check(refused.result == CraftResult::MissingIngredients && + refused.recipe == findRecipe("cord"), + "Deux fibres portees (+1 posee) : refus, recette la plus proche = ligature"); + check(refused.message.find("tige a fibres") != std::string::npos && + refused.message.find("porter") != std::string::npos, + "Le refus dit qu'il manque une tige a fibres a porter"); + check(sameGround(ground, groundBefore) && sameInventory(inventory, invBefore), + "Refus : inventaire et sol identiques"); + + inventory.add(GroundItemKind::Fiber, 2); // 4 portees + const CraftOutcome ok = craftAt(inventory, ground, hearths, player, facing, 0.0f); + check(ok.result == CraftResult::Success && ok.recipe == findRecipe("cord"), + "Trois fibres portees : ligature"); + check(inventory.count(GroundItemKind::Fiber) == 1, "Exactement trois fibres consommees"); + check(inventory.count(GroundItemKind::Cord) == 0, "La ligature n'est pas en poche"); + check(countKind(ground, GroundItemKind::Fiber) == 1, "La fibre posee n'est pas touchee"); + const GroundItem* cord = firstOfKind(ground, GroundItemKind::Cord); + check(cord != nullptr, "La ligature est au sol"); + if (cord != nullptr) { + checkNear(cord->position.z, -kCraftDropDistance, 1e-5f, "Ligature a 1,1 m devant"); + checkNear(cord->position.y, kCordRadius, 1e-5f, "Ligature posee sur la surface"); + } +} + +void testCraftingHearth() { + section("Phase 28 : foyer (3 pierres + 2 branches posees, eclat porte)"); + + FlatTerrain flat; + Ground ground(flat); + HearthSet hearths; + const glm::vec3 player{ 0.0f, 1.7f, 0.0f }; + const glm::vec3 facing{ 1.0f, 0.0f, 0.0f }; + + ground.drop(GroundItemKind::Stone, 1.0f, 0.0f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Stone, 1.0f, 1.0f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Stone, 2.0f, 0.0f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Branch, 2.0f, 1.0f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Branch, 1.5f, 0.5f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Log, 30.0f, 0.0f, 0.0f, 0.0f); // hors portee + + // Sans eclat : refus, rien ne bouge. + Inventory inventory; + const Ground before = ground; + const CraftOutcome refused = craftAt(inventory, ground, hearths, player, facing, 10.0f); + check(refused.result == CraftResult::MissingIngredients && + refused.recipe == findRecipe("hearth"), + "Sans eclat : refus, recette la plus proche = foyer"); + check(refused.message.find("eclat") != std::string::npos, "Le refus nomme l'eclat"); + check(sameGround(ground, before) && inventory.total() == 0 && hearths.hearths().empty(), + "Refus : sol, inventaire et foyers inchanges"); + + inventory.add(GroundItemKind::Flake); + const CraftOutcome ok = craftAt(inventory, ground, hearths, player, facing, 10.0f); + check(ok.result == CraftResult::Success && ok.recipe == findRecipe("hearth"), + "Avec l'eclat : foyer construit"); + check(inventory.count(GroundItemKind::Flake) == 1, "L'eclat (outil) n'est pas consomme"); + check(countKind(ground, GroundItemKind::Stone) == 0 && + countKind(ground, GroundItemKind::Branch) == 0, + "Les 3 pierres et 2 branches sont consommees"); + check(countKind(ground, GroundItemKind::Log) == 1, "La buche hors portee est intacte"); + const GroundItem* hearthItem = firstOfKind(ground, GroundItemKind::Hearth); + check(hearthItem != nullptr, "Le foyer existe au sol"); + if (hearthItem == nullptr) return; + checkNear(hearthItem->position.x, 1.5f, 1e-4f, "Foyer au barycentre (x)"); + checkNear(hearthItem->position.z, 0.5f, 1e-4f, "Foyer au barycentre (z)"); + checkNear(hearthItem->position.y, kHearthRadius, 1e-5f, "Foyer pose sur la surface"); + check(hearths.hearths().size() == 1 && hearths.hearths()[0].lit, "Le foyer nait allume"); + checkNear(hearths.remainingHours(0, 10.0f), 1.0f, 1e-5f, "Combustion : 1 h de jeu"); + + // Le foyer ne se ramasse pas. + check(ground.findNearest(player, 5.0f) == kNoGroundItem, + "findNearest ignore le foyer (objet fixe)"); + + // Combustion : allume a mi-parcours, eteint a l'heure dite, UNE cendre. + check(hearths.update(10.5f, ground) == 0 && hearths.hearths()[0].lit, + "A +0,5 h le feu brule encore"); + check(countKind(ground, GroundItemKind::Ash) == 0, "Pas de cendre tant qu'il brule"); + check(hearths.update(11.0f, ground) == 1 && !hearths.hearths()[0].lit, + "A +1 h le feu s'eteint"); + check(countKind(ground, GroundItemKind::Ash) == 1, "Une cendre est deposee"); + check(hearths.update(20.0f, ground) == 0 && countKind(ground, GroundItemKind::Ash) == 1, + "Un foyer eteint ne produit pas d'autre cendre"); + check(countKind(ground, GroundItemKind::Hearth) == 1, "Le foyer eteint reste en place"); + const GroundItem* ash = firstOfKind(ground, GroundItemKind::Ash); + if (ash != nullptr) { + checkNear(ash->position.x, 1.5f, 1e-4f, "Cendre au centre du foyer"); + const int nearest = ground.findNearest(player, 5.0f); + check(nearest >= 0 && + ground.items()[static_cast(nearest)].kind == GroundItemKind::Ash, + "La cendre, elle, se ramasse"); + } + + // Rallumer : 2 branches posees + eclat porte, foyer froid a portee. + ground.drop(GroundItemKind::Branch, 0.8f, -0.3f, 0.0f, 0.0f); + const CraftOutcome oneBranch = craftAt(inventory, ground, hearths, player, facing, 20.0f); + check(oneBranch.result == CraftResult::MissingIngredients && + !hearths.hearths()[0].lit, + "Une seule branche : le foyer froid ne repart pas"); + ground.drop(GroundItemKind::Branch, 0.8f, 0.3f, 0.0f, 0.0f); + const CraftOutcome relit = craftAt(inventory, ground, hearths, player, facing, 20.0f); + check(relit.result == CraftResult::Success && relit.recipe == findRecipe("hearth_relight"), + "Deux branches + eclat : le foyer est rallume"); + check(hearths.hearths()[0].lit && countKind(ground, GroundItemKind::Branch) == 0 && + inventory.count(GroundItemKind::Flake) == 1, + "Rallumage : branches consommees, eclat garde"); + check(countKind(ground, GroundItemKind::Hearth) == 1, "Rallumage : aucun second foyer"); + + // Alimenter : une buche posee pres du foyer allume prolonge d'1 h. + ground.drop(GroundItemKind::Log, 0.5f, 0.0f, 0.0f, 0.0f); + const CraftOutcome fed = craftAt(inventory, ground, hearths, player, facing, 20.5f); + check(fed.result == CraftResult::Success && fed.recipe == findRecipe("hearth_feed_log"), + "Buche posee : le foyer est alimente"); + checkNear(hearths.remainingHours(0, 20.5f), 1.5f, 1e-4f, + "Alimenter prolonge d'1 h (0,5 h restante -> 1,5 h)"); + check(countKind(ground, GroundItemKind::Log) == 1, "Seule la buche proche est consommee"); + + // POINT D'ACCROCHE (non branche) : chaleur au centre, nulle a 6 m, nulle eteint. + const glm::vec3 center = hearths.hearths()[0].position; + checkNear(hearths.warmthAt(center), 8.0f, 1e-4f, "Chaleur maximale au centre"); + checkNear(hearths.warmthAt(center + glm::vec3(3.0f, 0.0f, 0.0f)), 4.0f, 1e-4f, + "Chaleur a mi-rayon : la moitie"); + checkNear(hearths.warmthAt(center + glm::vec3(6.0f, 0.0f, 0.0f)), 0.0f, 1e-6f, + "Chaleur nulle a 6 m"); + hearths.update(100.0f, ground); + checkNear(hearths.warmthAt(center), 0.0f, 1e-6f, "Foyer eteint : aucune chaleur"); + check(countKind(ground, GroundItemKind::Ash) == 2, "Seconde extinction : seconde cendre"); +} + +void testCraftingAxe() { + section("Phase 28 : hache (eclat + branche + ligature poses)"); + + FlatTerrain flat; + Ground ground(flat); + HearthSet hearths; + Inventory inventory; + const glm::vec3 player{ 0.0f, 1.7f, 0.0f }; + const glm::vec3 facing{ 0.0f, 0.0f, 1.0f }; + + // Ingredients NON CONTIGUS, entrelaces avec des objets etrangers : la + // consommation ne doit retirer que les bons (pickUp echange avec le dernier). + ground.drop(GroundItemKind::Clay, 0.2f, 0.2f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Flake, 1.0f, 0.0f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Sand, -0.4f, 0.2f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Branch, 0.0f, 1.0f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Resin, 0.3f, -0.6f, 0.0f, 0.0f); + ground.drop(GroundItemKind::Stone, 40.0f, 0.0f, 0.0f, 0.0f); + + const Ground before = ground; + const CraftOutcome refused = craftAt(inventory, ground, hearths, player, facing, 0.0f); + check(refused.result == CraftResult::MissingIngredients && + refused.recipe == findRecipe("axe"), + "Sans ligature : refus, recette la plus proche = hache"); + check(refused.message.find("ligature") != std::string::npos, "Le refus nomme la ligature"); + check(sameGround(ground, before), "Refus : sol identique octet pour octet"); + + // Une ligature PORTEE ne suffit pas : l'outil composite s'assemble au sol. + inventory.add(GroundItemKind::Cord); + check(craftAt(inventory, ground, hearths, player, facing, 0.0f).result == + CraftResult::MissingIngredients, + "Ligature portee (non posee) : refus"); + check(inventory.count(GroundItemKind::Cord) == 1 && sameGround(ground, before), + "Refus : la ligature portee n'est pas consommee"); + + ground.drop(GroundItemKind::Cord, -1.0f, 0.0f, 0.0f, 0.0f); + const CraftOutcome ok = craftAt(inventory, ground, hearths, player, facing, 0.0f); + check(ok.result == CraftResult::Success && ok.recipe == findRecipe("axe"), + "Eclat + branche + ligature poses : hache"); + check(countKind(ground, GroundItemKind::Flake) == 0 && + countKind(ground, GroundItemKind::Branch) == 0 && + countKind(ground, GroundItemKind::Cord) == 0, + "Les trois ingredients sont consommes"); + check(countKind(ground, GroundItemKind::Clay) == 1 && + countKind(ground, GroundItemKind::Sand) == 1 && + countKind(ground, GroundItemKind::Resin) == 1 && + countKind(ground, GroundItemKind::Stone) == 1, + "Les objets etrangers entrelaces sont tous intacts"); + check(ground.itemCount() == 5, "Sol : 4 etrangers + la hache"); + check(inventory.count(GroundItemKind::Cord) == 1, "La ligature portee est gardee"); + const GroundItem* axe = firstOfKind(ground, GroundItemKind::Axe); + check(axe != nullptr, "La hache est au sol"); + if (axe != nullptr) { + checkNear(axe->position.x, 0.0f, 1e-5f, "Hache au barycentre (x)"); + checkNear(axe->position.z, 1.0f / 3.0f, 1e-5f, "Hache au barycentre (z)"); + const int nearest = ground.findNearest({ 0.0f, 1.7f, 0.33f }, 0.1f); + check(nearest >= 0, "La hache se ramasse"); + GroundItemKind picked = GroundItemKind::Log; + ground.pickUp(nearest, &picked); + inventory.add(picked); + check(inventory.count(GroundItemKind::Axe) == 1, + "Hache portee (point d'accroche du rendement, Agent 3)"); + } + + // Un ingredient pose juste hors de portee (2,6 m) ne compte pas. + Ground far(flat); + far.drop(GroundItemKind::Flake, 2.6f, 0.0f, 0.0f, 0.0f); + far.drop(GroundItemKind::Branch, 0.0f, 1.0f, 0.0f, 0.0f); + far.drop(GroundItemKind::Cord, -1.0f, 0.0f, 0.0f, 0.0f); + Inventory none; + check(craftAt(none, far, hearths, player, facing, 0.0f).result == + CraftResult::MissingIngredients, + "Eclat pose a 2,6 m : hors de portee, refus"); + check(far.itemCount() == 3, "Refus : rien consomme"); +} + +void testPitchNeedsLitHearth() { + section("Phase 28 : poix (2 resines + 1 cendre posees, foyer allume)"); + + FlatTerrain flat; + const glm::vec3 player{ 0.0f, 1.7f, 0.0f }; + const glm::vec3 facing{ 1.0f, 0.0f, 0.0f }; + + const auto setup = [](Ground& g) { + g.drop(GroundItemKind::Resin, 0.5f, 0.5f, 0.0f, 0.0f); + g.drop(GroundItemKind::Resin, 0.5f, -0.5f, 0.0f, 0.0f); + g.drop(GroundItemKind::Ash, -0.5f, 0.0f, 0.0f, 0.0f); + }; + + // 1. Aucun foyer. + { + Ground ground(flat); + HearthSet hearths; + Inventory inventory; + setup(ground); + const Ground before = ground; + const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.0f); + check(o.result == CraftResult::MissingIngredients && o.recipe == findRecipe("pitch"), + "Sans foyer : refus, recette la plus proche = poix"); + check(o.message.find("chauffer") != std::string::npos, + "Le refus dit qu'il faut chauffer"); + check(sameGround(ground, before), "Sans foyer : rien consomme"); + } + // 2. Foyer ETEINT a portee. + { + Ground ground(flat); + HearthSet hearths; + Inventory inventory; + ground.drop(GroundItemKind::Hearth, 1.0f, 0.0f, 0.0f, 0.0f); + hearths.addLit(ground.items().back().position, 0.0f); + hearths.update(5.0f, ground); // eteint -> une cendre au centre + check(!hearths.hearths()[0].lit, "Foyer eteint"); + setup(ground); + const Ground before = ground; + const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 5.0f); + check(o.result == CraftResult::MissingIngredients, + "Foyer eteint : la poix est refusee"); + check(sameGround(ground, before), "Foyer eteint : rien consomme"); + } + // 3. Foyer allume trop loin (2,5 m > kStationReach). + { + Ground ground(flat); + HearthSet hearths; + Inventory inventory; + ground.drop(GroundItemKind::Hearth, 2.5f, 0.0f, 0.0f, 0.0f); + hearths.addLit(ground.items().back().position, 0.0f); + setup(ground); + check(craftAt(inventory, ground, hearths, player, facing, 0.1f).result == + CraftResult::MissingIngredients, + "Foyer allume a 2,5 m : hors de portee du poste, refus"); + } + // 4. Foyer allume a portee : succes. + { + Ground ground(flat); + HearthSet hearths; + Inventory inventory; + ground.drop(GroundItemKind::Hearth, 1.5f, 0.0f, 0.0f, 0.0f); + hearths.addLit(ground.items().back().position, 0.0f); + setup(ground); + ground.drop(GroundItemKind::Resin, -1.0f, -1.0f, 0.0f, 0.0f); // une de trop + const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.2f); + check(o.result == CraftResult::Success && o.recipe == findRecipe("pitch"), + "Foyer allume a 1,5 m : poix"); + check(countKind(ground, GroundItemKind::Resin) == 1 && + countKind(ground, GroundItemKind::Ash) == 0, + "Exactement 2 resines et 1 cendre consommees"); + check(countKind(ground, GroundItemKind::Hearth) == 1 && hearths.hearths()[0].lit, + "Le foyer (poste) n'est pas consomme"); + check(countKind(ground, GroundItemKind::Pitch) == 1, "La poix est au sol"); + checkNear(hearths.remainingHours(0, 0.2f), 0.8f, 1e-4f, + "Faire de la poix ne consomme pas de temps de combustion"); + } +} + +void testPutDown() { + section("Phase 28 : reposer un objet porte (touche P)"); + + FlatTerrain flat; + Ground ground(flat); + Inventory inventory; + const glm::vec3 player{ 0.0f, 1.7f, 0.0f }; + const glm::vec3 facing{ 0.0f, -0.5f, -1.0f }; + + GroundItemKind kind = GroundItemKind::Log; + check(!chooseKindToPutDown(inventory, GroundItemKind::Stone, &kind), + "Inventaire vide : rien a poser"); + check(!putDown(inventory, ground, GroundItemKind::Stone, player, facing) && + ground.itemCount() == 0, + "putDown sans objet porte : refus, rien depose"); + + inventory.add(GroundItemKind::Branch, 1); + inventory.add(GroundItemKind::Stone, 3); + check(chooseKindToPutDown(inventory, GroundItemKind::Stone, &kind) && + kind == GroundItemKind::Stone, + "Le dernier ramasse est pose en priorite"); + check(chooseKindToPutDown(inventory, GroundItemKind::Resin, &kind) && + kind == GroundItemKind::Branch, + "Sinon la premiere nature portee (ordre de l'enum)"); + + for (int i = 0; i < 3; ++i) { + check(putDown(inventory, ground, GroundItemKind::Stone, player, facing), + "Pierre reposee " + std::to_string(i + 1)); + } + check(inventory.count(GroundItemKind::Stone) == 0 && ground.itemCount() == 3, + "Trois pierres passees de l'inventaire au sol"); + checkNear(ground.items()[0].position.z, -kPutDownDistance, 1e-5f, + "Premier objet pose a 0,9 m devant"); + checkNear(ground.items()[0].position.y, kStoneRadius, 1e-5f, "Pose sur la surface"); + bool distinct = true; + bool inReach = true; + for (std::size_t i = 0; i < ground.itemCount(); ++i) { + const glm::vec3 p = ground.items()[i].position; + if (std::sqrt(p.x * p.x + p.z * p.z) > kCraftReach) inReach = false; + for (std::size_t j = i + 1; j < ground.itemCount(); ++j) { + if (glm::length(p - ground.items()[j].position) < 0.2f) distinct = false; + } + } + check(distinct, "Objets reposes decales (pas de superposition exacte)"); + check(inReach, "Objets reposes a portee de faconnage"); + check(!putDown(inventory, ground, GroundItemKind::Hearth, player, facing), + "Un foyer ne se 'repose' pas"); + + // Le cycle complet du foyer au clavier : ramasser -> reposer -> C. + inventory.add(GroundItemKind::Branch, 1); // 2 branches + inventory.add(GroundItemKind::Flake, 1); + putDown(inventory, ground, GroundItemKind::Branch, player, facing); + putDown(inventory, ground, GroundItemKind::Branch, player, facing); + HearthSet hearths; + const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.0f); + check(o.result == CraftResult::Success && o.recipe == findRecipe("hearth"), + "Reposer 3 pierres et 2 branches puis C : un foyer"); +} + +// =========================================================================== +// PHASE 28 (Agent 3) : les EFFETS branches sur les systemes existants +// =========================================================================== +void testHearthWarmthEffect() { + section("Phase 28 : chaleur du foyer -> Needs (ambiante corrigee)"); + + FlatTerrain flat; + Ground ground(flat); + HearthSet hearths; + const glm::vec3 center{ 0.0f, 0.0f, 0.0f }; + checkNear(hearths.warmthAt(center), 0.0f, 1e-6f, "Aucun foyer : +0 degre"); + ground.drop(GroundItemKind::Hearth, 0.0f, 0.0f, 0.0f, 0.0f); + hearths.addLit(ground.items().back().position, 0.0f); + + checkNear(hearths.warmthAt({ 0.0f, 1.7f, 0.0f }), 8.0f, 1e-4f, "Au centre : +8 degres"); + checkNear(hearths.warmthAt({ 1.5f, 1.7f, 0.0f }), 6.0f, 1e-4f, "A 1,5 m : +6 degres"); + checkNear(hearths.warmthAt({ 0.0f, 1.7f, 3.0f }), 4.0f, 1e-4f, "A 3 m : +4 degres"); + checkNear(hearths.warmthAt({ 6.0f, 1.7f, 0.0f }), 0.0f, 1e-4f, "A 6 m : +0 degre"); + checkNear(hearths.warmthAt({ 20.0f, 1.7f, 0.0f }), 0.0f, 1e-6f, "A 20 m : +0 degre (jamais negatif)"); + + // Meme calcul que main.cpp : ambiante meteo + warmthAt, puis Needs. + const auto feltAfter = [&](float warmth, bool sheltered) { + Needs needs; + NeedsContext ctx; + ctx.ambientTemperatureC = 2.0f + warmth; + ctx.windSpeedMps = 5.0f; + ctx.sheltered = sheltered; + for (int i = 0; i < 600; ++i) needs.update(0.1f, ctx); + return std::make_pair(needs.ambientTemperatureC(), needs.temperature()); + }; + const auto cold = feltAfter(0.0f, false); + const auto warm = feltAfter(hearths.warmthAt({ 1.5f, 1.7f, 0.0f }), false); + checkNear(warm.first, 8.0f, 1e-4f, "Needs recoit l'ambiante corrigee (2 + 6 degres)"); + check(warm.second > cold.second, + "Pres d'un feu allume, la jauge de chaleur baisse moins (60 s a 2 degres, vent 5 m/s)"); + + // Extinction : le feu ne chauffe plus, la cendre tombe. + hearths.update(1.01f, ground); + check(!hearths.hearths()[0].lit, "Foyer eteint apres 1 h de jeu"); + checkNear(hearths.warmthAt({ 0.0f, 1.7f, 0.0f }), 0.0f, 1e-6f, "Foyer eteint : +0 degre"); + const auto afterOut = feltAfter(hearths.warmthAt({ 1.5f, 1.7f, 0.0f }), false); + checkNear(afterOut.second, cold.second, 1e-6f, "Foyer eteint : jauge identique au froid sans feu"); + hearths.relight(0, 2.0f); + checkNear(hearths.warmthAt({ 0.0f, 1.7f, 0.0f }), 8.0f, 1e-4f, "Rallume : +8 degres de nouveau"); + + // Deux feux s'additionnent (somme dans warmthAt). + ground.drop(GroundItemKind::Hearth, 2.0f, 0.0f, 0.0f, 0.0f); + hearths.addLit(ground.items().back().position, 2.0f); + checkNear(hearths.warmthAt({ 1.0f, 1.7f, 0.0f }), 2.0f * 8.0f * (1.0f - 1.0f / 6.0f), 1e-4f, + "Entre deux feux a 1 m chacun : chaleurs additionnees"); +} + +void testAxeYieldEffect() { + section("Phase 28 : rendement de la hache -> Forest::scheduleBucking"); + + Inventory inventory; + check(axeBonusLogs(inventory) == 0, "Sans hache : bonus 0"); + inventory.add(GroundItemKind::Axe); + check(axeBonusLogs(inventory) == kAxeBonusLogs && kAxeBonusLogs == 1, "Hache portee : +1 buche"); + inventory.add(GroundItemKind::PitchedAxe); + check(axeBonusLogs(inventory) == kPitchedAxeBonusLogs && kPitchedAxeBonusLogs == 2, + "Hache renforcee portee : +2 (le meilleur outil, pas de cumul)"); + inventory.remove(GroundItemKind::Axe, 1); + check(axeBonusLogs(inventory) == 2, "Hache renforcee seule : +2"); + + check(Forest::buckingLogCount(4.0f, 0) == 2, "Arbre de 4 m : 2 buches (inchange)"); + check(Forest::buckingLogCount(7.0f, 0) == 2, "Arbre de 7 m : 2 buches (inchange)"); + check(Forest::buckingLogCount(12.0f, 0) == 4, "Arbre de 12 m : 4 buches (plafond inchange)"); + check(Forest::buckingLogCount(7.0f, 1) == 3 && Forest::buckingLogCount(12.0f, 1) == 5, + "Hache : 3..5 au lieu de 2..4 (conception P3)"); + check(Forest::buckingLogCount(12.0f, 2) == 6, "Hache renforcee : +2"); + + // Abattage reel, trois fois le meme arbre (meme graine) : 0, 1, 2 de bonus. + const auto fellAndCount = [](int bonus, std::size_t* branchesOut, bool* felledOut) { + FlatTerrain flat; + Ground ground(flat); + ForestParams params; + params.treeCount = 0; + Forest forest(flat, ground, 50.0f, params); + forest.plantTree(0.0f, 0.0f, 12.0f); + forest.setBuckingBonusLogs(bonus); + *felledOut = forest.fell(0); + for (int i = 0; i < 60 * 30 && (forest.trees()[0].state != TreeState::Fallen || + forest.pendingDropCount() > 0); ++i) { + forest.update(1.0f / 60.0f); + } + *branchesOut = static_cast(countKind(ground, GroundItemKind::Branch)); + return countKind(ground, GroundItemKind::Log); + }; + std::size_t b0 = 0, b1 = 0, b2 = 0; + bool f0 = false, f1 = false, f2 = false; + const int l0 = fellAndCount(0, &b0, &f0); + const int l1 = fellAndCount(1, &b1, &f1); + const int l2 = fellAndCount(2, &b2, &f2); + check(f0, "Abattage SANS hache toujours possible (scenario A intact)"); + check(l0 == 4 && b0 == 4, "Sans hache : 4 buches + 4 branches (Phase 5, inchange)"); + check(l1 == 5 && b1 == 4, "Avec hache : 5 buches, branches inchangees"); + check(l2 == 6 && b2 == 4, "Avec hache renforcee : 6 buches"); + check(f1 && f2, "Avec hache : l'abattage lui-meme est inchange"); + + // Negatif borne a 0. + FlatTerrain flat; + Ground ground(flat); + ForestParams params; + params.treeCount = 0; + Forest forest(flat, ground, 50.0f, params); + forest.setBuckingBonusLogs(-3); + check(forest.buckingBonusLogs() == 0, "Bonus negatif ramene a 0"); +} + +void testShelterEffect() { + section("Phase 28 : abri (4 buches + 6 branches + 2 ligatures) -> NeedsContext::sheltered"); + + FlatTerrain flat; + Ground ground(flat); + HearthSet hearths; + Inventory inventory; + const glm::vec3 player{ 0.0f, 1.7f, 0.0f }; + const glm::vec3 facing{ 1.0f, 0.0f, 0.0f }; + + check(!shelterNear(ground, player), "Aucun abri : non abrite"); + + // Ingredients poses en cercle (dans les 2,5 m), sauf UNE ligature. + const auto ring = [&](GroundItemKind kind, int n, float radius, float phase) { + for (int i = 0; i < n; ++i) { + const float a = phase + 6.2831853f * static_cast(i) / static_cast(n); + ground.drop(kind, radius * std::cos(a), radius * std::sin(a), 0.0f, 0.0f); + } + }; + ring(GroundItemKind::Log, 4, 1.5f, 0.0f); + ring(GroundItemKind::Branch, 6, 1.0f, 0.3f); + ring(GroundItemKind::Cord, 1, 0.6f, 0.0f); + { + const Ground before = ground; + const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.0f); + check(o.result == CraftResult::MissingIngredients && o.recipe == findRecipe("shelter"), + "Une ligature manque : refus, recette la plus proche = abri"); + check(o.message.find("ligature") != std::string::npos, "Le refus nomme la ligature"); + check(sameGround(ground, before), "Refus : sol intact"); + } + ring(GroundItemKind::Cord, 1, 0.6f, 3.14159265f); // diametralement opposee : barycentre au centre + const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.0f); + check(o.result == CraftResult::Success && o.recipe == findRecipe("shelter"), "Abri construit"); + check(countKind(ground, GroundItemKind::Log) == 0 && countKind(ground, GroundItemKind::Branch) == 0 && + countKind(ground, GroundItemKind::Cord) == 0, + "4 buches, 6 branches, 2 ligatures consommees (et pas le feu : aucun foyer)"); + check(countKind(ground, GroundItemKind::Shelter) == 1, "Un abri au sol"); + const GroundItem* shelter = firstOfKind(ground, GroundItemKind::Shelter); + check(shelter != nullptr && std::abs(shelter->position.x) < 1e-3f && + std::abs(shelter->position.z) < 1e-3f, + "L'abri nait au barycentre des ingredients (ici le centre)"); + check(shelter != nullptr && std::abs(shelter->position.y - kShelterRadius) < 1e-4f, + "L'abri repose sur le sol"); + check(ground.findNearest(player, 2.5f) == kNoGroundItem, "L'abri ne se ramasse pas"); + + // L'effet : a portee horizontale et verticale. + check(shelterNear(ground, player), "Sous l'abri : abrite"); + check(shelterNear(ground, { 2.4f, 1.7f, 0.0f }), "A 2,4 m : abrite"); + check(!shelterNear(ground, { 2.6f, 1.7f, 0.0f }), "A 2,6 m : non abrite"); + check(!shelterNear(ground, { 0.0f, 40.0f, 0.0f }), "Survol a 40 m : non abrite"); + + // Needs : +5 degres ressentis et vent annule (Needs.cpp), rien d'autre. + Needs outside; + Needs inside; + NeedsContext ctx; + ctx.ambientTemperatureC = 0.0f; + ctx.windSpeedMps = 8.0f; + outside.update(0.1f, ctx); + ctx.sheltered = shelterNear(ground, player); + inside.update(0.1f, ctx); + check(inside.feltTemperatureC() > outside.feltTemperatureC() + 5.0f, + "Abrite : ressenti > dehors + 5 degres (abri + vent annule)"); + checkNear(inside.ambientTemperatureC(), outside.ambientTemperatureC(), 1e-6f, + "L'abri ne change pas l'ambiante, seulement le ressenti"); + + // Mesh de l'abri : valide, pose au sol, dans ses demi-dimensions. + const MeshData mesh = shelterMeshData(); + bool valid = !mesh.empty() && mesh.indices.size() % 3 == 0; + float minY = 1e9f, maxY = -1e9f; + bool inBox = true; + for (const uint32_t i : mesh.indices) if (i >= mesh.vertices.size()) valid = false; + for (const Vertex& v : mesh.vertices) { + minY = std::min(minY, v.pos.y); + maxY = std::max(maxY, v.pos.y); + if (std::abs(v.pos.x) > kShelterHalfWidth + 1e-3f || std::abs(v.pos.z) > kShelterHalfDepth + 1e-3f) + inBox = false; + if (std::abs(glm::length(v.normal) - 1.0f) > 1e-3f) valid = false; + } + check(valid, "Mesh de l'abri valide (indices, normales)"); + checkNear(minY, -kShelterRadius, 0.01f, "Abri : bas du mesh = -rayon (pose au sol)"); + check(maxY <= kShelterRadius + 1e-3f, "Abri : tient dans sa demi-hauteur"); + check(inBox, "Abri : tient dans son emprise"); + + // Hache renforcee : hache + poix posees. + Ground g2(flat); + g2.drop(GroundItemKind::Axe, 0.5f, 0.0f, 0.0f, 0.0f); + g2.drop(GroundItemKind::Pitch, -0.5f, 0.0f, 0.0f, 0.0f); + const CraftOutcome pa = craftAt(inventory, g2, hearths, player, facing, 0.0f); + check(pa.result == CraftResult::Success && pa.recipe == findRecipe("pitched_axe"), + "Hache + poix posees : hache renforcee"); + check(countKind(g2, GroundItemKind::PitchedAxe) == 1 && countKind(g2, GroundItemKind::Axe) == 0 && + countKind(g2, GroundItemKind::Pitch) == 0, + "Hache et poix consommees, hache renforcee au sol"); +} + +// =========================================================================== +// PHASE 29 (Agent 2) : rochers et pierriers +// =========================================================================== + +// Versant a pente constante `slope` le long de +X, rendu RUGUEUX par une grille +// d'aleas de +/- `bump` m au pas de 1 m (interpolee bilineairement, comme un DTM). +class RoughSlope : public HeightSampler { +public: + RoughSlope(float slope, float bump) : slope_(slope), bump_(bump) {} + float heightAt(float x, float z) const override { + const float fx = std::floor(x), fz = std::floor(z); + const float tx = x - fx, tz = z - fz; + const auto n = [&](float a, float b) { + uint32_t h = (static_cast(static_cast(a)) * 0x9E3779B1u) ^ + (static_cast(static_cast(b)) * 0x85EBCA77u); + h ^= h >> 15; h *= 0x2c1b3c6du; h ^= h >> 12; h *= 0x297a2d39u; h ^= h >> 15; + return (static_cast(h >> 8) / 16777216.0f * 2.0f - 1.0f) * bump_; + }; + const float v = glm::mix(glm::mix(n(fx, fz), n(fx + 1.0f, fz), tx), + glm::mix(n(fx, fz + 1.0f), n(fx + 1.0f, fz + 1.0f), tx), tz); + return 1500.0f + slope_ * x + v; + } +private: + float slope_, bump_; +}; + +// Pente qui CROIT avec x (h = k u^2 / 2 -> pente = k u) : le masque 0,60-0,84 y +// est une bande, et tout ce qui en sort doit rester vide. +class RampingSlope : public HeightSampler { +public: + float heightAt(float x, float) const override { + const float u = x + 2000.0f; // pente 0,60 a x = -500, 0,84 a x = +100 + return 1200.0f + 0.5f * 0.0004f * u * u; + } +}; + +void testRockMeshes() { + section("Phase 29 : meshes de rochers (bloc, rocher, pierraille)"); + const MeshData meshes[3] = { boulderMeshData(), rockMeshData(), gravelMeshData() }; + const char* names[3] = { "gros bloc", "rocher moyen", "pierraille" }; + for (int m = 0; m < 3; ++m) { + const MeshData& mesh = meshes[m]; + bool ok = !mesh.empty() && mesh.indices.size() % 3 == 0; + glm::vec3 lo(1e9f), hi(-1e9f); + for (uint32_t index : mesh.indices) { ok = ok && index < mesh.vertices.size(); } + for (const Vertex& v : mesh.vertices) { + ok = ok && std::isfinite(v.pos.x) && std::isfinite(v.pos.y) && std::isfinite(v.pos.z); + ok = ok && std::abs(glm::length(v.normal) - 1.0f) < 1e-3f; + lo = glm::min(lo, v.pos); + hi = glm::max(hi, v.pos); + } + std::printf(" (%s : %u triangles, y %.2f..%.2f, emprise %.2f x %.2f)\n", names[m], + mesh.triangleCount(), lo.y, hi.y, hi.x - lo.x, hi.z - lo.z); + check(ok, std::string("Mesh ") + names[m] + " : indices, normales et positions valides"); + check(mesh.triangleCount() >= 16 && mesh.triangleCount() <= 1200, + std::string("Mesh ") + names[m] + " : bas-poly (16 a 1200 triangles)"); + check(lo.y < 0.0f && hi.y > 0.0f, + std::string("Mesh ") + names[m] + " : en partie ENTERRE sous l'origine (pas de flottement en pente)"); + if (m < 2) { + check(hi.y <= kRockVisibleHeight + 1e-3f && hi.y > 0.45f, + std::string("Mesh ") + names[m] + " : hauteur visible sous 0,70 (x echelle)"); + check(std::max(hi.x - lo.x, hi.z - lo.z) <= 2.0f * kRockFootprintRadius + 0.05f, + std::string("Mesh ") + names[m] + " : empreinte dans le rayon de collision"); + } else { + check(hi.y < 0.15f && std::max(hi.x - lo.x, hi.z - lo.z) <= 1.2f, + "Mesh pierraille : plaque basse d'un metre environ"); + } + } + check(meshes[0].triangleCount() > meshes[1].triangleCount(), + "Variantes distinctes : le gros bloc est plus detaille que le rocher moyen"); +} + +void testRockPlacement() { + section("Phase 29 : semis des pierriers (masque, determinisme, densite, LOD, collision)"); + const RockParams defaults; + ConstantMap bare(0.0f); + ConstantMap wooded(0.3f); + + // --- Pack / unpack de l'inclinaison --------------------------------------- + { + bool ok = true; + for (float gx = -0.9f; gx <= 0.9f; gx += 0.13f) { + for (float gz = -0.9f; gz <= 0.9f; gz += 0.17f) { + const float packed = packRockVariation(0.37f, { gx, gz }); + const glm::vec2 g = unpackRockGradient(packed); + ok = ok && std::abs(g.x - gx) <= 1.0f / 63.0f + 1e-4f && + std::abs(g.y - gz) <= 1.0f / 63.0f + 1e-4f && + std::abs(unpackRockTint(packed) - 0.37f) < 2e-3f; + } + } + check(ok, "Inclinaison encodee dans variation : gradient a 1/63 pres, teinte conservee"); + } + + // --- Masque : chaque critere de la conception, isolement ----------------- + { + FlatTerrain flat(1500.0f); + SlopedTerrain gentle(1500.0f, 0.50f), scree(1500.0f, 0.72f), wall(1500.0f, 0.95f); + Rocks onFlat(flat, &bare, 1000.0f), onGentle(gentle, &bare, 1000.0f), + onScree(scree, &bare, 1000.0f), onWall(wall, &bare, 1000.0f), + wooded72(scree, &wooded, 1000.0f), noMap(scree, nullptr, 1000.0f); + check(onScree.maskAt(10.0f, 10.0f), "Masque : pente 0,72 nue -> pierrier"); + check(!onFlat.maskAt(10.0f, 10.0f), "Masque : terrain plat -> non"); + check(!onGentle.maskAt(10.0f, 10.0f), "Masque : pente 0,50 (< kWalkComfortSlope) -> non"); + check(!onWall.maskAt(10.0f, 10.0f), "Masque : pente 0,95 (>= kWalkMaxSlope, paroi) -> non"); + check(!wooded72.maskAt(10.0f, 10.0f), "Masque : couvert 0,30 (>= 0,10) -> non"); + check(!noMap.enabled() && !noMap.maskAt(10.0f, 10.0f) && + noMap.blockCellRocks(0, 0).empty() && noMap.gravelCellRocks(0, 0).empty(), + "Sans carte de couvert : AUCUN rocher (pas de semis sans donnee reelle)"); + SlopedTerrain edgeMin(1500.0f, kWalkComfortSlope + 0.002f); + SlopedTerrain edgeMax(1500.0f, kWalkMaxSlope + 0.002f); + check(Rocks(edgeMin, &bare, 1000.0f).maskAt(0.0f, 0.0f) && + !Rocks(edgeMax, &bare, 1000.0f).maskAt(0.0f, 0.0f), + "Masque : bornes [kWalkComfortSlope, kWalkMaxSlope[ respectees"); + checkNear(onScree.roughnessAt(3.0f, 7.0f), 0.0f, 1e-2f, "Rugosite d'un plan incline : nulle"); + } + + // --- Jamais hors masque, sur un relief ou le masque est une bande ------- + { + RampingSlope ramp; + HalfCoveredMap half; // boise a l'est de x = 0 + Rocks rocks(ramp, &half, 2400.0f); + uint32_t total = 0, outside = 0, badY = 0; + const auto inspect = [&](const std::vector& list) { + for (const RockInstance& r : list) { + ++total; + outside += rocks.maskAt(r.position.x, r.position.z) ? 0u : 1u; + // Bande attendue : pente 0,6..0,84 -> x = -500..100, nue a l'ouest de 0. + outside += (r.position.x < -505.0f || r.position.x > 0.0f) ? 1u : 0u; + badY += std::abs(r.position.y - ramp.heightAt(r.position.x, r.position.z)) > 1e-2f ? 1u : 0u; + } + }; + for (int32_t cz = -20; cz <= 20; ++cz) { + for (int32_t cx = -150; cx <= 60; ++cx) { inspect(rocks.blockCellRocks(cx, cz)); } + } + for (int32_t cz = -40; cz <= 40; ++cz) { + for (int32_t cx = -600; cx <= 240; cx += 3) { inspect(rocks.gravelCellRocks(cx, cz)); } + } + std::printf(" (%u rochers semes sur la bande, %u hors masque)\n", total, outside); + check(total > 50, "Bande de pierrier : des rochers sont bien semes"); + check(outside == 0, "AUCUN rocher hors masque (pente, couvert) sur toute la bande"); + check(badY == 0, "Chaque rocher est pose sur le terrain (y = altitude du sol)"); + } + + // --- Rugosite -> choix du mesh ------------------------------------------- + RoughSlope rough(0.72f, 0.50f); + SlopedTerrain smooth(1500.0f, 0.72f); + { + Rocks onRough(rough, &bare, 1000.0f), onSmooth(smooth, &bare, 1000.0f); + std::printf(" (rugosite du versant bossele : %.3f m)\n", onRough.roughnessAt(5.5f, 5.5f)); + check(onRough.roughnessAt(5.5f, 5.5f) >= defaults.roughBlocks, + "Rugosite d'un versant bossele (+/- 0,50 m) : >= 0,10 m"); + uint32_t roughBlocks = 0, roughGravel = 0, smoothBlocks = 0, smoothGravel = 0; + for (int32_t cz = -8; cz <= 8; ++cz) { + for (int32_t cx = -8; cx <= 8; ++cx) { + roughBlocks += static_cast(onRough.blockCellRocks(cx, cz).size()); + smoothBlocks += static_cast(onSmooth.blockCellRocks(cx, cz).size()); + roughGravel += static_cast(onRough.gravelCellRocks(cx, cz).size()); + smoothGravel += static_cast(onSmooth.gravelCellRocks(cx, cz).size()); + } + } + std::printf(" (rugueux : %u blocs / %u plaques ; lisse : %u blocs / %u plaques)\n", + roughBlocks, roughGravel, smoothBlocks, smoothGravel); + check(roughBlocks > 0 && smoothBlocks == 0, "Blocs seulement sur le rugueux (>= 0,10 m)"); + check(smoothGravel > 0 && roughGravel == 0, "Pierraille seulement sur le lisse (< 0,10 m)"); + } + + // --- Determinisme, bornes de densite, trainees --------------------------- + { + Rocks a(rough, &bare, 1000.0f), b(rough, &bare, 1000.0f); + RockParams other; + other.seed = 12345u; + Rocks c(rough, &bare, 1000.0f, other); + bool same = true, differs = false, bounded = true; + uint32_t empty = 0, cells = 0; + for (int32_t cz = -12; cz <= 12; ++cz) { + for (int32_t cx = -12; cx <= 12; ++cx) { + const auto ra = a.blockCellRocks(cx, cz); + const auto rb = b.blockCellRocks(cx, cz); + const auto rc = c.blockCellRocks(cx, cz); + same = same && ra.size() == rb.size(); + for (std::size_t i = 0; same && i < ra.size(); ++i) { + same = ra[i].position == rb[i].position && ra[i].scale == rb[i].scale && + ra[i].yaw == rb[i].yaw && ra[i].variation == rb[i].variation; + } + differs = differs || rc.size() != ra.size() || + (!ra.empty() && ra[0].position != rc[0].position); + bounded = bounded && ra.size() <= defaults.boulderSlots + defaults.stoneSlots; + uint32_t boulders = 0; + for (const RockInstance& r : ra) { + boulders += (r.kind == RockKind::Boulder) ? 1u : 0u; + bounded = bounded && r.scale >= defaults.stoneSizeMin - 1e-4f && + r.scale <= defaults.boulderSizeMax + 1e-4f; + } + bounded = bounded && boulders <= defaults.boulderSlots; + ++cells; + empty += ra.empty() ? 1u : 0u; + } + } + check(same, "Determinisme : meme graine -> memes rochers, au bit pres"); + check(differs, "Graine differente -> semis different"); + check(bounded, "Densite bornee : <= boulderSlots + stoneSlots par cellule, tailles dans les bornes"); + std::printf(" (%u cellules sous masque : %u vides)\n", cells, empty); + check(empty > 0 && empty < cells, "Trainees : le bruit module la densite (cellules vides ET peuplees sous masque)"); + const Rocks::Stats st = a.estimate(3); + std::printf(" (estimation : masque %.2f, %.1f blocs/ha, %.1f rochers/ha)\n", + st.maskFraction, st.bouldersPerHa, st.stonesPerHa); + check(st.maskFraction > 0.6, "Estimation : versant bossele majoritairement sous masque"); + check(st.bouldersPerHa > 0.0 && + st.bouldersPerHa <= 1e4 * defaults.boulderSlots / (defaults.blockCell * defaults.blockCell), + "Estimation : densite de gros blocs > 0 et sous le plafond des emplacements"); + // Anisotropie : la densite varie moins le long de la pente (x) qu'en travers (z). + double alongVar = 0.0, acrossVar = 0.0; + for (int i = 0; i < 400; ++i) { + const float p = static_cast(i) * 2.0f - 400.0f; + alongVar += std::abs(a.streakDensityAt(p + 2.0f, 37.0f) - a.streakDensityAt(p, 37.0f)); + acrossVar += std::abs(a.streakDensityAt(37.0f, p + 2.0f) - a.streakDensityAt(37.0f, p)); + } + std::printf(" (variation de densite : le long %.2f, en travers %.2f)\n", alongVar, acrossVar); + check(acrossVar > 1.5 * alongVar, "Trainees allongees dans le sens de la pente"); + } + + // --- LOD de densite par distance, rendu, inclinaison --------------------- + { + Rocks rocks(rough, &bare, 1000.0f); + std::vector boulders, stones, gravel; + const glm::vec3 eye(0.0f, rough.heightAt(0.0f, 0.0f) + 1.7f, 0.0f); + for (int i = 0; i < 60; ++i) { + rocks.gather(eye, permissiveFrustum(), boulders, stones, gravel); + } + float maxBoulder = 0.0f, maxStone = 0.0f; + bool faded = true, tilt = true; + for (const InstanceData& inst : boulders) { + maxBoulder = std::max(maxBoulder, glm::length(inst.position - eye)); + faded = faded && inst.fade >= 0.0f && inst.fade <= 1.0f; + const glm::vec2 g = unpackRockGradient(inst.variation); + tilt = tilt && std::abs(g.x - 0.72f * defaults.tiltFollow) < 0.25f && std::abs(g.y) < 0.25f; + } + for (const InstanceData& inst : stones) { + maxStone = std::max(maxStone, glm::length(inst.position - eye)); + } + std::printf(" (%zu gros blocs jusqu'a %.0f m, %zu rochers jusqu'a %.0f m)\n", + boulders.size(), maxBoulder, stones.size(), maxStone); + check(!boulders.empty() && !stones.empty(), "Rendu : des instances de blocs et de rochers"); + check(maxStone < defaults.stoneDistanceFar && maxBoulder < defaults.boulderDistanceFar, + "LOD : aucune instance au-dela de sa portee"); + check(maxBoulder > defaults.stoneDistanceFar, "LOD : les gros blocs portent plus loin que les rochers"); + check(faded, "LOD : attenuation dans [0,1]"); + check(tilt, "Orientation : gradient encode = pente du sol x tiltFollow"); + check(gravel.empty(), "Versant rugueux : pas de pierraille rendue"); + check(rocks.cachedBlockCount() > 0, "Cache de cellules actif"); + + Rocks smoothRocks(smooth, &bare, 1000.0f); + const glm::vec3 eye2(0.0f, smooth.heightAt(0.0f, 0.0f) + 1.7f, 0.0f); + for (int i = 0; i < 30; ++i) { + smoothRocks.gather(eye2, permissiveFrustum(), boulders, stones, gravel); + } + float maxGravel = 0.0f; + uint32_t nearCount = 0, farCount = 0; + for (const InstanceData& inst : gravel) { + const float d = glm::length(inst.position - eye2); + maxGravel = std::max(maxGravel, d); + if (d < 30.0f) { ++nearCount; } else { ++farCount; } + } + std::printf(" (pierraille : %zu plaques, %u a < 30 m, %u au-dela, max %.0f m)\n", + gravel.size(), nearCount, farCount, maxGravel); + check(!gravel.empty() && maxGravel < defaults.gravelDistanceFar, "LOD pierraille : portee courte respectee"); + const double nearArea = 3.14159 * 30.0 * 30.0; + const double farArea = 3.14159 * (70.0 * 70.0 - 30.0 * 30.0); + check(static_cast(nearCount) / nearArea > static_cast(farCount) / farArea, + "LOD de DENSITE : la pierraille s'eclaircit avec la distance"); + } + + // --- Collision des gros blocs --------------------------------------------- + { + Rocks rocks(rough, &bare, 1000.0f); + RockParams noCol; + noCol.collide = false; + Rocks ghost(rough, &bare, 1000.0f, noCol); + RockInstance big; + bool haveBig = false; + for (int32_t cz = -8; cz <= 8 && !haveBig; ++cz) { + for (int32_t cx = -8; cx <= 8 && !haveBig; ++cx) { + for (const RockInstance& r : rocks.blockCellRocks(cx, cz)) { + if (r.kind == RockKind::Boulder && r.scale >= defaults.collideMinScale) { + big = r; + haveBig = true; + break; + } + } + } + } + check(haveBig, "Collision : un gros bloc bloquant existe sur le versant rugueux"); + if (haveBig) { + BodyCylinder body; + body.position = { big.position.x + 0.1f, big.position.y + 1.7f, big.position.z }; + body.feetY = big.position.y; + body.headY = big.position.y + 1.8f; + check(rocks.overlaps(body), "Collision : le joueur dans un gros bloc est detecte"); + BodyCylinder pushed = body; + pushed.position = rocks.resolve(body); + check(!rocks.overlaps(pushed), "Collision : resolve() sort le joueur du bloc"); + check(!ghost.overlaps(body), "TEMOIN --no-rock-collision : bloc traversable"); + BodyCylinder flying = body; + flying.feetY = big.position.y + big.scale + 5.0f; + flying.headY = flying.feetY + 1.8f; + check(!rocks.overlaps(flying), "Collision : un corps au-dessus du bloc (parapente) passe"); + CompositeCollisionSolver composite; + composite.add(&rocks); + check(composite.overlaps(body), "Collision : branchee par le CompositeCollisionSolver existant"); + } + FlatTerrain flat(1500.0f); + Rocks none(flat, &bare, 1000.0f); + BodyCylinder body; + body.position = { 3.0f, 1501.7f, 3.0f }; + body.feetY = 1500.0f; + body.headY = 1501.8f; + check(!none.overlaps(body) && none.resolve(body) == body.position, + "Collision : terrain plat (hors masque) -> aucun obstacle"); + } +} + +// =========================================================================== +// PHASE 29 (Agent 3) : buissons et petits arbres (classe 3 LiDAR) +// =========================================================================== + +// F3 qui croit avec x : 0 a x = -400, 0,40 a x = +400 (le seuil 0,10 tombe a -200). +class LowVegRampX : public HeightSampler { +public: + float heightAt(float x, float) const override { + return glm::clamp((x + 400.0f) / 800.0f * 0.40f, 0.0f, 0.40f); + } +}; +// Couvert = F3 + F45, F45 croissant avec z : 0 a z = -400, 0,40 a z = +400 +// (le seuil F45 0,20 tombe a z = 0). +class CoverRampXZ : public HeightSampler { +public: + float heightAt(float x, float z) const override { + return LowVegRampX().heightAt(x, z) + glm::clamp((z + 400.0f) / 800.0f * 0.40f, 0.0f, 0.40f); + } +}; + +void testBushMeshes() { + section("Phase 29 (Agent 3) : meshes de buisson et de petit arbre"); + const MeshData meshes[2] = { shrubMeshData(), smallTreeMeshData() }; + const char* names[2] = { "buisson", "petit arbre" }; + const float radii[2] = { kShrubFootprintRadius, kSmallTreeFootprintRadius }; + for (int m = 0; m < 2; ++m) { + const MeshData& mesh = meshes[m]; + bool ok = !mesh.empty() && mesh.indices.size() % 3 == 0; + glm::vec3 lo(1e9f), hi(-1e9f); + float radial = 0.0f; + for (uint32_t index : mesh.indices) { ok = ok && index < mesh.vertices.size(); } + for (const Vertex& v : mesh.vertices) { + ok = ok && std::isfinite(v.pos.x) && std::isfinite(v.pos.y) && std::isfinite(v.pos.z); + ok = ok && std::abs(glm::length(v.normal) - 1.0f) < 1e-3f; + lo = glm::min(lo, v.pos); + hi = glm::max(hi, v.pos); + radial = std::max(radial, std::sqrt(v.pos.x * v.pos.x + v.pos.z * v.pos.z)); + } + std::printf(" (%s : %u triangles, y %.3f..%.3f, rayon %.2f)\n", names[m], + mesh.triangleCount(), lo.y, hi.y, radial); + check(ok, std::string("Mesh ") + names[m] + " : indices, normales et positions valides"); + check(mesh.triangleCount() >= 16 && mesh.triangleCount() <= 400, + std::string("Mesh ") + names[m] + " : bas-poly (16 a 400 triangles)"); + checkNear(hi.y, 1.0f, 1e-3f, std::string("Mesh ") + names[m] + " : hauteur unite (echelle = hauteur)"); + check(lo.y < 0.0f && lo.y >= -kBushBuriedDepth - 1e-4f, + std::string("Mesh ") + names[m] + " : pied legerement enterre, pas davantage"); + check(radial <= radii[m] + 1e-3f, + std::string("Mesh ") + names[m] + " : emprise dans le rayon annonce"); + } + check(meshes[0].triangleCount() != meshes[1].triangleCount(), "Deux variantes distinctes"); +} + +void testBushPlacement() { + section("Phase 29 (Agent 3) : semis des buissons (critere classe 3, determinisme, bornes)"); + const BushParams P; + FlatTerrain flat(1500.0f); + ConstantMap h25(2.5f), h0(0.0f), h10(10.0f), h12(1.2f); + + // --- Critere, isole ------------------------------------------------------- + { + ConstantMap f20(0.20f), f05(0.05f), c30(0.30f), c45(0.45f), c08(0.08f); + Bushes yes(flat, &f20, &h25, &c30, 1000.0f), lowF3(flat, &f05, &h25, &c30, 1000.0f), + wooded(flat, &f20, &h25, &c45, 1000.0f), noF3(flat, nullptr, &h25, &c30, 1000.0f), + noH(flat, &f20, nullptr, &c30, 1000.0f), noCover(flat, &f20, &h25, nullptr, 1000.0f), + rockish(flat, &f20, &h25, &c08, 1000.0f); + check(yes.maskAt(10.0f, 10.0f), "Critere : F3 0,20 et F45 0,10 -> buisson"); + check(!lowF3.maskAt(10.0f, 10.0f), "Critere : F3 0,05 (< 0,10) -> non"); + check(!wooded.maskAt(10.0f, 10.0f), "Critere : F45 0,25 (>= 0,20, foret) -> non"); + check(!rockish.maskAt(10.0f, 10.0f), "Critere : couvert 0,08 < 0,10 (domaine des rochers) -> non"); + check(!noF3.enabled() && !noH.enabled() && !noCover.enabled() && + noF3.cellBushes(0, 0).empty() && noH.cellBushes(0, 0).empty() && + noCover.cellBushes(0, 0).empty(), + "Sans l'une des trois cartes : AUCUN buisson (pas de substitut)"); + check(!yes.maskAt(995.0f, 0.0f), "Critere : bord du terrain exclu"); + Bushes zeroH(flat, &f20, &h0, &c30, 1000.0f); + bool none = true; + for (int32_t c = -5; c <= 5; ++c) { none = none && zeroH.cellBushes(c, c).empty(); } + check(none, "Hauteur classe 3 nulle -> aucun sujet (pas de hauteur inventee)"); + } + + // --- Aucun buisson hors critere, sur un champ qui traverse les seuils ---- + LowVegRampX f3; + CoverRampXZ cover; + Bushes field(flat, &f3, &h25, &cover, 1000.0f); + std::vector all; + { + bool inside = true; + std::size_t perCellMax = 0; + for (int32_t cz = -60; cz <= 60; ++cz) { + for (int32_t cx = -60; cx <= 60; ++cx) { + const auto cell = field.cellBushes(cx, cz); + perCellMax = std::max(perCellMax, cell.size()); + for (const BushInstance& b : cell) { + const float vf3 = f3.heightAt(b.position.x, b.position.z); + const float vc = cover.heightAt(b.position.x, b.position.z); + inside = inside && vf3 >= P.lowVegMin && vc - vf3 < P.highVegMax && vc >= P.rockCoverMax; + all.push_back(b); + } + } + } + std::printf(" (%zu buissons semes sur 968 m x 968 m de champ en rampe)\n", all.size()); + check(all.size() > 500, "Le champ en rampe porte bien des buissons"); + check(inside, "AUCUN buisson hors critere (F3 >= 0,10, F45 < 0,20, couvert >= 0,10)"); + check(perCellMax <= P.slots, "Densite bornee : au plus `slots` sujets par cellule de 8 m"); + bool xOk = true, zOk = true; + for (const BushInstance& b : all) { + xOk = xOk && b.position.x >= -200.5f; + zOk = zOk && b.position.z < 0.5f; + } + check(xOk && zOk, "Frontieres du champ reproduites (x >= -200, z < 0)"); + } + + // --- Densite lineaire en F3 ------------------------------------------------ + { + ConstantMap c35(0.35f); + ConstantMap f11(0.11f), f30(0.30f), cs11(0.21f); + Bushes sparse(flat, &f11, &h25, &cs11, 1000.0f), dense(flat, &f30, &h25, &c35, 1000.0f); + std::size_t ns = 0, nd = 0; + for (int32_t cz = -20; cz < 20; ++cz) { + for (int32_t cx = -20; cx < 20; ++cx) { + ns += sparse.cellBushes(cx, cz).size(); + nd += dense.cellBushes(cx, cz).size(); + } + } + const double cells = 1600.0; + std::printf(" (densite : %.2f / cellule a F3 0,11 ; %.2f a F3 0,30)\n", ns / cells, nd / cells); + check(nd == static_cast(cells) * P.slots, "F3 >= 0,30 : densite pleine, exactement `slots` par cellule"); + check(ns > 0 && ns * 2 < nd, "F3 0,11 : clairseme (moins de la moitie de la densite pleine)"); + const double perHa = nd / (cells * P.cell * P.cell / 10000.0); + check(perHa <= 940.0, "Densite plafonnee a ~940 sujets / ha"); + } + + // --- Hauteur bornee et tiree sous la carte --------------------------------- + { + ConstantMap f30(0.30f), c35(0.35f); + Bushes tall(flat, &f30, &h10, &c35, 1000.0f), low(flat, &f30, &h12, &c35, 1000.0f); + bool tallOk = true, lowOk = true, kindOk = true; + std::size_t smallTrees = 0, shrubs = 0; + for (int32_t c = -30; c < 30; ++c) { + for (const BushInstance& b : tall.cellBushes(c, -c)) { + tallOk = tallOk && b.height >= P.heightMin && b.height <= P.heightMax; + kindOk = kindOk && ((b.kind == BushKind::SmallTree) == (b.height >= P.smallTreeFrom)); + (b.kind == BushKind::SmallTree ? smallTrees : shrubs) += 1; + } + for (const BushInstance& b : low.cellBushes(c, c)) { + lowOk = lowOk && b.height >= P.heightMin && b.height <= 1.2f + 1e-4f && + b.kind == BushKind::Shrub; + } + } + check(tallOk, "Hauteur bornee a [0,5 ; 3] m meme sous 10 m de classe 3"); + check(lowOk, "Hauteur <= hauteur max classe 3 de la cellule (1,2 m) -> buissons seulement"); + check(kindOk && smallTrees > 0, "Petit arbre si et seulement si hauteur >= 1,8 m"); + std::printf(" (sous 10 m : %zu petits arbres, %zu buissons)\n", smallTrees, shrubs); + bool sitOk = true; + for (const BushInstance& b : all) { sitOk = sitOk && b.position.y == 1500.0f; } + check(sitOk, "Pied pose sur le terrain"); + } + + // --- Determinisme ----------------------------------------------------------- + { + Bushes again(flat, &f3, &h25, &cover, 1000.0f); + BushParams other; + other.seed = 7u; + Bushes reseeded(flat, &f3, &h25, &cover, 1000.0f, other); + bool same = true, differs = false; + for (int32_t cz = -30; cz <= 30; ++cz) { + for (int32_t cx = -10; cx <= 40; ++cx) { + const auto a = field.cellBushes(cx, cz); + const auto b = again.cellBushes(cx, cz); + const auto r = reseeded.cellBushes(cx, cz); + same = same && a.size() == b.size(); + for (std::size_t i = 0; same && i < a.size(); ++i) { + same = std::memcmp(&a[i].position, &b[i].position, sizeof(glm::vec3)) == 0 && + a[i].height == b[i].height && a[i].yaw == b[i].yaw && a[i].tint == b[i].tint && + a[i].kind == b[i].kind && a[i].maxDistance == b[i].maxDistance; + } + if (!a.empty() && (r.empty() || r[0].position != a[0].position)) { differs = true; } + } + } + check(same, "Semis deterministe au bit (deux instances, memes cellules)"); + check(differs, "La graine change le semis"); + } + + // --- Disjoint des rochers --------------------------------------------------- + { + // Pente de pierrier (0,72) et couvert en rampe qui traverse 0,10 : + // aucun buisson la ou Rocks seme. + SlopedTerrain scree(1500.0f, 0.72f); + Bushes onScree(scree, &f3, &h25, &cover, 1000.0f); + Rocks rocks(scree, &cover, 1000.0f); + std::size_t n = 0; + bool disjoint = true, rockZone = false; + for (int32_t cz = -50; cz <= 50; cz += 2) { + for (int32_t cx = -50; cx <= 50; cx += 2) { + for (const BushInstance& b : onScree.cellBushes(cx, cz)) { + ++n; + disjoint = disjoint && !rocks.maskAt(b.position.x, b.position.z); + } + rockZone = rockZone || rocks.maskAt(cx * 8.0f + 4.0f, cz * 8.0f + 4.0f); + } + } + check(n > 0 && rockZone, "Test des rochers significatif (buissons ET pierrier presents)"); + check(disjoint, "Aucun buisson sous le masque des rochers (disjoints par construction)"); + } + + // --- Emprise des arbres existants -------------------------------------------- + { + ConstantMap f30(0.30f), c35(0.35f); + Bushes open(flat, &f30, &h25, &c35, 1000.0f), guarded(flat, &f30, &h25, &c35, 1000.0f); + guarded.setTreeFootprints({ glm::vec3(20.0f, 20.0f, 6.0f), glm::vec3(-100.0f, 40.0f, 4.0f) }); + std::size_t before = 0, inside = 0; + for (int32_t cz = -3; cz <= 8; ++cz) { + for (int32_t cx = -16; cx <= 4; ++cx) { + for (const BushInstance& b : open.cellBushes(cx, cz)) { + before += glm::length(glm::vec2(b.position.x - 20.0f, b.position.z - 20.0f)) < 6.0f ? 1 : 0; + } + for (const BushInstance& b : guarded.cellBushes(cx, cz)) { + inside += glm::length(glm::vec2(b.position.x - 20.0f, b.position.z - 20.0f)) < 6.0f ? 1 : 0; + inside += glm::length(glm::vec2(b.position.x + 100.0f, b.position.z - 40.0f)) < 4.0f ? 1 : 0; + } + } + } + check(before > 0 && inside == 0, "Aucun buisson dans l'emprise d'un arbre abattable"); + } + + // --- gather : LOD, portee, fondu ----------------------------------------------- + { + ConstantMap f30(0.30f), c35(0.35f); + Bushes lod(flat, &f30, &h25, &c35, 2000.0f); + std::vector shrubs, trees; + const glm::vec3 eye(0.0f, 1502.0f, 0.0f); + for (int i = 0; i < 200; ++i) { lod.gather(eye, permissiveFrustum(), shrubs, trees); } + bool inRange = true; + for (const auto* list : { &shrubs, &trees }) { + const float far = (list == &shrubs) ? P.shrubDistanceFar : P.treeDistanceFar; + for (const InstanceData& d : *list) { + const float dist = glm::length(d.position - eye); + inRange = inRange && dist < far && d.fade >= 0.0f && d.fade <= 1.0f && + d.scale >= P.heightMin && d.scale <= P.heightMax; + } + } + std::size_t ringNear = 0, ringFar = 0; + for (const InstanceData& d : shrubs) { + const float dist = glm::length(glm::vec2(d.position.x, d.position.z)); + if (dist < 50.0f) { ++ringNear; } + if (dist >= 100.0f && dist < 140.0f) { ++ringFar; } + } + const double densNear = ringNear / (3.14159 * 50.0 * 50.0); + const double densFar = ringFar / (3.14159 * (140.0 * 140.0 - 100.0 * 100.0)); + std::printf(" (gather : %zu buissons, %zu petits arbres ; densite %.4f/m2 a < 50 m, %.4f a 100-140 m)\n", + shrubs.size(), trees.size(), densNear, densFar); + check(!shrubs.empty() && !trees.empty(), "gather : deux listes instanciees remplies"); + check(inRange, "gather : portee, fondu et echelle bornes"); + check(densFar < 0.6 * densNear, "LOD de densite : eclaircissement avec la distance"); + check(lod.lastShrubCount() == shrubs.size() && lod.lastSmallTreeCount() == trees.size(), + "Compteurs de diagnostic coherents"); + } +} + +int main() { + std::printf("=== Tests logiques Vercora (headless, sans Vulkan) ===\n"); + + testExistingBehaviourStillWorks(); + testCollision(); + testPickup(); + testProgressiveFall(); + testStoneKnapping(); + testDrawListConstruction(); + testTerrainFile(); + testParaglider(); + testBike(); + testClimber(); + testWalkSlopeLimit(); + testTerrainQuadtree(); + testQuadtreeAncestry(); + testTextureFile(); + testGrassMesh(); + testGrassPhase18(); + testTileMeshingIsThreadSafe(); + testVegetationPlacement(); + testGrassPlacement(); + testInstanceLayout(); + testEditorAssets(); + testAssetCatalog(); + testTerrainRaycast(); + testEditorScene(); + testEditorSceneCollision(); + testEditorScenePick(); + testSceneFile(); + testEditorController(); + testNeeds(); + testWaterSources(); + testHabitatMemory(); + testAnimalMesh(); + testWildlife(); + testEnvironmentalFootprint(); + testWildlifeCollision(); + testMineralDeposits(); + testResin(); + testFiberPlants(); + testHarvestMeshes(); + testWeather(); + testWeatherGameplay(); + testWeatherVisuals(); + testDetailNoise(); + // PHASE 28 + testCraftingRecipeTable(); + testCraftingKnapUnchanged(); + testCraftingCord(); + testCraftingHearth(); + testCraftingAxe(); + testPitchNeedsLitHearth(); + testPutDown(); + // PHASE 28 (Agent 3) : effets branches + testHearthWarmthEffect(); + testAxeYieldEffect(); + testShelterEffect(); + // PHASE 29 (Agent 2) : rochers et pierriers + testRockMeshes(); + testRockPlacement(); + // PHASE 29 (Agent 3) : buissons et petits arbres + testBushMeshes(); + testBushPlacement(); + + std::printf("\n=====================================================\n"); + if (g_failures == 0) { + std::printf("SUCCES : %d verifications passees.\n", g_checks); + return 0; + } + std::printf("ECHEC : %d verifications sur %d ont echoue.\n", g_failures, g_checks); + return 1; +} diff --git a/tools/assemble_terrain.py b/tools/assemble_terrain.py new file mode 100644 index 0000000..06b609a --- /dev/null +++ b/tools/assemble_terrain.py @@ -0,0 +1,328 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +assemble_terrain.py — raccorde N heightmaps .vchm voisines en UN seul terrain. + +PHASE 9. La Phase 7 avait valide le pipeline sur une dalle isolee ; c'est ici que +se joue ce que ses deux bugs d'arrondi auraient casse en silence (arrondi +bancaire, intervalle semi-ouvert inverse sur l'axe nord). Rien n'est suppose : +chaque dalle est placee par son GEOREFERENCEMENT (originEast/originNorth lus dans +son en-tete), jamais par son ordre dans la ligne de commande ou son nom. + + python tools/assemble_terrain.py assets/terrain/LHD_*_1m.vchm \ + -o assets/terrain/vercora_zone_1m.vchm --label vercora_zone_5x5 + +Options : + --label L nom inscrit dans l'en-tete du fichier produit + --allow-gaps accepter une grille incomplete (trous combles par voisinage) + --quiet-seams n'afficher que le bilan des jointures, pas le detail + +LE NOEUD PARTAGE — le point non evident de tout l'assemblage. Les echantillons +sont sur les NOEUDS : une dalle de 1 km au pas de 1 m fait 1001 echantillons, de +X=899000 a X=900000 INCLUS. La dalle voisine commence a X=900000, elle aussi +inclus. La colonne X=900000 existe donc DANS LES DEUX, et 5 dalles alignees font +5*1001-4 = 5001 echantillons, pas 5005. + +Concatener betement produirait 5005 colonnes : le terrain serait 4 m trop large +et decalerait tout ce qui est a l'est d'une jointure. C'est precisement la +"duplication de ligne/colonne a la jointure" a ne pas commettre. + +Mais ces deux valeurs partagees ne sont PAS identiques, et c'est normal : le +noeud X=900000 agrege les points de [899999.5, 900000.5[. La dalle ouest n'en +voit que la moitie gauche, la dalle est que la moitie droite. Chacune calcule +donc une mediane sur la moitie des points. L'ecart entre les deux est une mesure +DIRECTE de la coherence du raccord — c'est le chiffre que ce script rapporte, et +il doit rester de l'ordre du bruit de mesure (centimetres), pas du metre. La +valeur retenue est leur MOYENNE. +""" + +from __future__ import annotations + +import argparse +import os +import struct +import sys + +import numpy as np + +MAGIC = b"VCHM" +VERSION = 1 +HEADER_SIZE = 120 +LABEL_SIZE = 64 +FLAG_ABSOLUTE_ALTITUDE = 1 << 0 + + +def read_vchm(path: str): + with open(path, "rb") as f: + header = f.read(HEADER_SIZE) + if len(header) != HEADER_SIZE or header[:4] != MAGIC: + sys.exit(f"{path} : ce n'est pas un fichier .vchm") + version = struct.unpack_from(" int: + parser = argparse.ArgumentParser( + description="Raccorde N heightmaps .vchm voisines en un seul terrain.") + parser.add_argument("inputs", nargs="+") + parser.add_argument("-o", "--output", required=True) + parser.add_argument("--label", default="") + parser.add_argument("--allow-gaps", action="store_true") + parser.add_argument("--quiet-seams", action="store_true") + args = parser.parse_args() + + tiles = [read_vchm(p) for p in args.inputs] + print(f"Entree : {len(tiles)} dalle(s)") + + # --- Coherence globale --------------------------------------------------- + spacing = tiles[0]["spacing"] + epsg = tiles[0]["epsg"] + flags = tiles[0]["flags"] + for t in tiles: + if abs(t["spacing"] - spacing) > 1e-6: + sys.exit(f"{t['path']} : pas de {t['spacing']} m, attendu {spacing} m. " + f"Toutes les dalles doivent avoir la meme resolution.") + if t["epsg"] != epsg: + sys.exit(f"{t['path']} : EPSG {t['epsg']}, attendu {epsg}.") + if t["flags"] != flags: + sys.exit(f"{t['path']} : flags {t['flags']}, attendu {flags} " + f"(melange d'altitudes absolues et relatives ?)") + + # --- Reseau global : chaque dalle placee par son georeferencement --------- + global_east = min(t["east"] for t in tiles) + global_north = max(t["north"] for t in tiles) + + for t in tiles: + # Decalage en NOEUDS depuis le coin nord-ouest global. L'axe nord + # DESCEND quand iz monte (lignes stockees du nord vers le sud), d'ou le + # sens oppose des deux expressions. + offset_x = (t["east"] - global_east) / spacing + offset_z = (global_north - t["north"]) / spacing + # Une dalle qui ne tombe pas sur le reseau (decalage non entier) rendrait + # tout l'assemblage faux d'une fraction de cellule, sans rien casser de + # visible : on refuse. + if abs(offset_x - round(offset_x)) > 1e-6 or abs(offset_z - round(offset_z)) > 1e-6: + sys.exit(f"{t['path']} : origine (E {t['east']}, N {t['north']}) hors " + f"du reseau au pas de {spacing} m " + f"(decalage {offset_x}, {offset_z} noeuds).") + t["ox"] = int(round(offset_x)) + t["oz"] = int(round(offset_z)) + + total_nx = max(t["ox"] + t["nx"] for t in tiles) + total_nz = max(t["oz"] + t["nz"] for t in tiles) + + print(f" pas {spacing} m, EPSG {epsg}") + print(f" coin nord-ouest global : E {global_east:.0f}, N {global_north:.0f}") + print(f" grille assemblee : {total_nx} x {total_nz} echantillons " + f"({(total_nx - 1) * spacing:.0f} x {(total_nz - 1) * spacing:.0f} m)") + + naive = sum(t["nx"] for t in tiles if t["oz"] == 0) + if naive and naive != total_nx: + print(f" (une concatenation naive aurait donne {naive} colonnes : " + f"les {naive - total_nx} noeuds de bord sont PARTAGES, pas dupliques)") + + # --- Report --------------------------------------------------------------- + accumulator = np.zeros((total_nz, total_nx), dtype=np.float64) + contributions = np.zeros((total_nz, total_nx), dtype=np.int32) + + for t in tiles: + z0, x0 = t["oz"], t["ox"] + view = t["heights"].astype(np.float64) + if not np.isfinite(view).all(): + sys.exit(f"{t['path']} : contient des valeurs non finies (NaN/inf). " + f"Le convertisseur aurait du les boucher.") + accumulator[z0:z0 + t["nz"], x0:x0 + t["nx"]] += view + contributions[z0:z0 + t["nz"], x0:x0 + t["nx"]] += 1 + + covered = contributions > 0 + missing = int((~covered).sum()) + if missing: + message = (f"{missing} noeud(s) ({100.0 * missing / covered.size:.2f} %) " + f"ne sont couverts par aucune dalle") + if not args.allow_gaps: + sys.exit(f" ERREUR : {message}. La grille de dalles est incomplete. " + f"Utiliser --allow-gaps pour passer outre.") + print(f" ATTENTION : {message} — combles par voisinage.") + + with np.errstate(invalid="ignore"): + heights = accumulator / np.maximum(contributions, 1) + heights[~covered] = np.nan + + # --- LE CONTROLE : ecart entre les deux versions d'un noeud partage ------- + shared = contributions > 1 + shared_count = int(shared.sum()) + print(f"\nJointures : {shared_count:,} noeud(s) partage(s) par " + f"{contributions.max()} dalles au plus") + + worst_overall = 0.0 + if shared_count: + # Pour chaque paire de dalles qui se recouvrent, mesurer l'ecart entre + # ce que chacune dit du meme point du sol. C'est la mesure directe de la + # coherence du raccord : elle ne peut pas etre "compensee" par le + # placement, puisqu'elle compare deux valeurs a la MEME position. + seams = [] + for i, a in enumerate(tiles): + for b in tiles[i + 1:]: + x0 = max(a["ox"], b["ox"]) + x1 = min(a["ox"] + a["nx"], b["ox"] + b["nx"]) + z0 = max(a["oz"], b["oz"]) + z1 = min(a["oz"] + a["nz"], b["oz"] + b["nz"]) + if x1 <= x0 or z1 <= z0: + continue + va = a["heights"][z0 - a["oz"]:z1 - a["oz"], + x0 - a["ox"]:x1 - a["ox"]].astype(np.float64) + vb = b["heights"][z0 - b["oz"]:z1 - b["oz"], + x0 - b["ox"]:x1 - b["ox"]].astype(np.float64) + delta = np.abs(va - vb) + kind = ("colonne" if (x1 - x0) == 1 else + "ligne" if (z1 - z0) == 1 else "bloc") + seams.append((a["label"] or os.path.basename(a["path"]), + b["label"] or os.path.basename(b["path"]), + kind, delta.size, float(delta.mean()), + float(np.median(delta)), float(delta.max()))) + worst_overall = max(worst_overall, float(delta.max())) + + seams.sort(key=lambda s: -s[6]) + if not args.quiet_seams: + print(f" {'dalle A':<20s} {'dalle B':<20s} {'type':<8s} " + f"{'noeuds':>7s} {'moyen':>8s} {'median':>8s} {'max':>8s}") + for a, b, kind, n, mean, med, mx in seams: + print(f" {a[:20]:<20s} {b[:20]:<20s} {kind:<8s} {n:>7,} " + f"{mean:>7.3f}m {med:>7.3f}m {mx:>7.3f}m") + + all_delta = np.concatenate([np.array([s[4]]) for s in seams]) + print(f" ecart moyen sur l'ensemble des jointures : " + f"{all_delta.mean():.3f} m, pire ecart ponctuel : {worst_overall:.3f} m") + + # --- Continuite mesuree sur le produit fini ------------------------------ + # Test independant du placement : le long d'une jointure, la difference + # entre deux colonnes voisines doit ressembler a celle qu'on observe + # PARTOUT ailleurs. Un decalage d'un metre la rendrait anormalement GRANDE ; + # une colonne dupliquee la rendrait anormalement PETITE (deux colonnes + # identiques = pente nulle). Les deux defauts sont donc attrapes, et par une + # mesure faite sur le fichier final, sans rien savoir des dalles d'origine. + print("\nContinuite du terrain assemble (gradient aux jointures vs partout) :") + finite = np.isfinite(heights) + grad_x = np.abs(np.diff(heights, axis=1)) + grad_z = np.abs(np.diff(heights, axis=0)) + reference_x = float(np.nanmedian(grad_x)) + reference_z = float(np.nanmedian(grad_z)) + print(f" reference : pente mediane est-ouest {reference_x:.3f} m/m, " + f"nord-sud {reference_z:.3f} m/m") + + seam_columns = sorted({t["ox"] for t in tiles if t["ox"] > 0}) + seam_rows = sorted({t["oz"] for t in tiles if t["oz"] > 0}) + anomalies = 0 + + for column in seam_columns: + # Le raccord se joue entre les colonnes column-1 et column+1 autour du + # noeud partage `column` : on regarde les deux transitions qui l'encadrent. + left = float(np.nanmedian(grad_x[:, column - 1])) + right = float(np.nanmedian(grad_x[:, column])) + flag = "" + for value in (left, right): + if reference_x > 0 and (value > 6.0 * reference_x or value < reference_x / 6.0): + flag = " <-- ANOMALIE" + anomalies += 1 + print(f" jointure verticale x={column:>5d} : " + f"{left:.3f} / {right:.3f} m/m{flag}") + + for row in seam_rows: + top = float(np.nanmedian(grad_z[row - 1, :])) + bottom = float(np.nanmedian(grad_z[row, :])) + flag = "" + for value in (top, bottom): + if reference_z > 0 and (value > 6.0 * reference_z or value < reference_z / 6.0): + flag = " <-- ANOMALIE" + anomalies += 1 + print(f" jointure horizontale z={row:>5d} : " + f"{top:.3f} / {bottom:.3f} m/m{flag}") + + if anomalies: + print(f" {anomalies} ANOMALIE(S) : une jointure ne se comporte pas comme " + f"le reste du terrain (decalage ou duplication).") + elif seam_columns or seam_rows: + print(" OK — aucune jointure ne se distingue du relief environnant.") + + # --- Ecriture ------------------------------------------------------------- + if missing: + # Meme dilatation que le convertisseur, pour ne jamais livrer de NaN. + from math import inf + passes = 0 + while not np.isfinite(heights).all() and passes < 512: + passes += 1 + filled = np.where(np.isfinite(heights), heights, 0.0) + valid = np.isfinite(heights).astype(np.float64) + total = np.zeros_like(filled) + weight = np.zeros_like(valid) + for dz, dx in ((-1, 0), (1, 0), (0, -1), (0, 1)): + total += np.roll(np.roll(filled, dz, 0), dx, 1) + weight += np.roll(np.roll(valid, dz, 0), dx, 1) + candidate = np.where(weight > 0, total / np.maximum(weight, 1), np.nan) + heights = np.where(np.isfinite(heights), heights, candidate) + print(f" trous combles en {passes} passes") + + if not np.isfinite(heights).all(): + sys.exit("ERREUR : des valeurs non finies subsistent, refus d'ecrire.") + + label = args.label or f"assemblage {len(tiles)} dalles" + write_vchm(args.output, heights.astype(np.float32), spacing, + global_east, global_north, label, epsg, flags) + written = os.path.getsize(args.output) + + print(f"\nSortie : {args.output} ({written / (1 << 20):.1f} Mo)") + print(f" {total_nx} x {total_nz} echantillons, pas {spacing} m") + print(f" origine (echantillon 0,0 = coin NORD-OUEST) : " + f"E {global_east:.0f}, N {global_north:.0f} [EPSG:{epsg}]") + print(f" altitudes : {np.nanmin(heights):.2f} .. {np.nanmax(heights):.2f} m " + f"(denivele {np.nanmax(heights) - np.nanmin(heights):.2f} m)") + + return 1 if anomalies else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/build.bat b/tools/build.bat new file mode 100644 index 0000000..b3dc3fe --- /dev/null +++ b/tools/build.bat @@ -0,0 +1,159 @@ +@echo off +rem =========================================================================== +rem Build complet de Vercora (configuration + compilation). +rem =========================================================================== +rem CMake et Ninja AUTONOMES + generateur Ninja, volontairement. Raison : +rem +rem L'installation Visual Studio 18 Community de cette machine est +rem PARTIELLEMENT CORROMPUE : 1695 fichiers sur 9692 examines sont remplis de +rem zeros binaires au lieu de leur contenu (constate le 2026-08-15). +rem - CMake livre avec VS : 1590 fichiers sur 4103 detruits, dont des modules +rem indispensables comme CMakeDetermineSystem.cmake -> inutilisable. +rem - Ninja livre avec VS : binaire entierement a zero -> inutilisable. +rem - MSBuild : 105 fichiers detruits, dont Linux.TargetNames.props, ce qui +rem fait echouer TOUT projet C++ (MSB4024) et donc le generateur +rem "Visual Studio 18 2026" des la configuration. +rem +rem En revanche le COMPILATEUR est intact : 0 fichier corrompu dans +rem VC\Tools\MSVC\...\bin, \include et \lib. cl.exe, ses en-tetes et ses libs +rem fonctionnent. C'est pour ca qu'on garde vcvars64 de VS pour l'environnement +rem de compilation, mais qu'on prend CMake et Ninja ailleurs. +rem +rem Correctif machine recommande : "Reparer" depuis Visual Studio Installer, et +rem verifier la sante du disque - une corruption massive et silencieuse de ce +rem type vient generalement du stockage ou d'un arret brutal. +rem +rem Usage : tools\build.bat [Debug|Release] (defaut : Debug) +rem +rem Debug est le defaut a dessein : c'est la configuration qui definit +rem VERCORA_DEBUG, donc la seule ou les COUCHES DE VALIDATION Vulkan sont +rem actives (voir CMakeLists.txt et VulkanContext.cpp). +rem =========================================================================== + +setlocal + +set "CONFIG=%~1" +if "%CONFIG%"=="" set "CONFIG=Debug" + +set "VS=C:\Program Files\Microsoft Visual Studio\18\Community" +set "VCVARS=%VS%\VC\Auxiliary\Build\vcvars64.bat" + +rem CMake et Ninja autonomes (winget : Kitware.CMake, Ninja-build.Ninja), et NON +rem ceux de Visual Studio, qui sont corrompus sur cette machine - voir l'en-tete. +set "CMAKE=C:\Program Files\CMake\bin\cmake.exe" +set "NINJA=%LOCALAPPDATA%\Microsoft\WinGet\Packages\Ninja-build.Ninja_Microsoft.Winget.Source_8wekyb3d8bbwe\ninja.exe" + +if not exist "%VCVARS%" ( + echo [ERREUR] vcvars64.bat introuvable : "%VCVARS%" + exit /b 1 +) +if not exist "%CMAKE%" ( + echo [ERREUR] cmake.exe introuvable : "%CMAKE%" + echo Installer avec : winget install --id Kitware.CMake + exit /b 1 +) +if not exist "%NINJA%" ( + echo [ERREUR] ninja.exe introuvable : "%NINJA%" + echo Installer avec : winget install --id Ninja-build.Ninja + exit /b 1 +) + +call "%VCVARS%" >nul 2>&1 + +rem --- Prechauffage de rc.exe -------------------------------------------- +rem Sur cette machine, la PREMIERE execution de rc.exe (compilateur de +rem ressources du Windows SDK) apres un moment d'inactivite echoue avec le code +rem -1 et AUCUNE sortie ; les suivantes passent. Mesure : 1 echec suivi de 7 +rem succes sur 8 essais consecutifs. C'est la signature d'un antivirus temps +rem reel qui bloque la creation du processus le temps d'analyser le binaire. +rem +rem CMake appelle rc.exe pour embarquer le manifeste a chaque edition de liens : +rem sans ce prechauffage, la configuration ou le build echouent au hasard, avec +rem un message trompeur du genre "le compilateur ne peut pas compiler un +rem programme simple". +rem +rem Correctif machine (a faire par l'utilisateur, cote securite - pas par ce +rem script) : ajouter une exclusion Windows Defender sur le dossier du Windows +rem Kit, ou sur le dossier de build. +rem Plusieurs appels, et pas un seul : un prechauffage unique s'est revele +rem insuffisant (une configuration propre a encore echoue une fois sur deux). +rem Ces appels sont instantanes et leur code de retour est sans importance - le +rem but est uniquement que le binaire soit deja analyse et en cache quand CMake +rem s'en servira pour de bon. +for %%R in ("%WindowsSdkVerBinPath%x64\rc.exe") do if exist %%R ( + %%R /? >nul 2>&1 + %%R /? >nul 2>&1 + %%R /? >nul 2>&1 +) + +rem --- Vulkan SDK ------------------------------------------------------------ +rem find_package(Vulkan) s'appuie sur la variable VULKAN_SDK. L'installateur +rem LunarG la pose au niveau MACHINE, mais un shell deja ouvert avant +rem l'installation ne la voit pas. On la recupere donc explicitement : d'abord +rem l'environnement, puis le registre, puis le dossier d'installation par defaut. +if not defined VULKAN_SDK ( + for /f "tokens=2,*" %%A in ('reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v VULKAN_SDK 2^>nul ^| find "VULKAN_SDK"') do set "VULKAN_SDK=%%B" +) +if not defined VULKAN_SDK ( + for /f "delims=" %%D in ('dir /b /ad /o-n "C:\VulkanSDK" 2^>nul') do ( + if not defined VULKAN_SDK set "VULKAN_SDK=C:\VulkanSDK\%%D" + ) +) +if not defined VULKAN_SDK ( + echo [ERREUR] SDK Vulkan introuvable. Installer avec : + echo winget install --id KhronosGroup.VulkanSDK + exit /b 1 +) +if not exist "%VULKAN_SDK%\Include\vulkan\vulkan.h" ( + echo [ERREUR] VULKAN_SDK pointe sur "%VULKAN_SDK%" mais Include\vulkan\vulkan.h y est absent. + exit /b 1 +) +echo Vulkan SDK : %VULKAN_SDK% + +set "ROOT=%~dp0.." +pushd "%ROOT%" + +rem FETCHCONTENT_FULLY_DISCONNECTED=ON : interdit tout acces reseau. GLFW, GLM et +rem tinyobjloader sont deja en cache dans external\, il n'y a rien a +rem retelecharger. Si cette option fait echouer la configuration, c'est que le +rem cache est reellement inutilisable - et seulement dans ce cas il faudra la +rem retirer pour laisser FetchContent refaire son travail. +call :configure +if errorlevel 1 ( + rem Une seule reprise, et uniquement pour ce cas precis : l'antivirus peut + rem encore bloquer rc.exe pendant le test du compilateur, ce qui fait echouer + rem la configuration avec un message trompeur ("le compilateur ne peut pas + rem compiler un programme simple"). Une vraie erreur de projet, elle, + rem echouerait aussi a la seconde tentative. + echo. + echo [ATTENTION] Configuration echouee, nouvelle tentative ^(rc.exe est + echo probablement encore analyse par l'antivirus^)... + rmdir /s /q build 2>nul + call :configure + if errorlevel 1 ( + echo. + echo [ECHEC] Configuration CMake ^(deux tentatives^). + popd + exit /b 1 + ) +) + +"%CMAKE%" --build build +if errorlevel 1 ( + echo. + echo [ECHEC] Compilation. + popd + exit /b 1 +) + +echo. +echo [OK] Build %CONFIG% termine : %ROOT%\build\vercora.exe +popd +exit /b 0 + +:configure +"%CMAKE%" -S . -B build -G Ninja ^ + -DCMAKE_MAKE_PROGRAM="%NINJA%" ^ + -DCMAKE_BUILD_TYPE=%CONFIG% ^ + -DFETCHCONTENT_FULLY_DISCONNECTED=ON +exit /b %ERRORLEVEL% diff --git a/tools/check_seams.py b/tools/check_seams.py new file mode 100644 index 0000000..0bea840 --- /dev/null +++ b/tools/check_seams.py @@ -0,0 +1,360 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +check_seams.py — controle croise d'un terrain ASSEMBLE contre les nuages bruts, +le long de TOUTES les frontieres entre dalles. + + python tools/check_seams.py assets/terrain/vercora_zone_1m.vchm data/lidar/*.laz + +Pendant de tools/check_terrain_file.py (une dalle, sondes nommees) pour le cas +multi-dalles. Meme principe, et c'est ce qui en fait une preuve : on relit le +.vchm produit et on le confronte aux points SOL BRUTS des .laz, sans rien +partager avec assemble_terrain.py ni avec lidar_to_heightmap.py. Une erreur +d'indexation dans l'un ne peut donc pas se compenser dans l'autre. + +CE QUI EST VERIFIE, ET POURQUOI C'EST LE SUJET DE LA PHASE 9 + +1. JUSTESSE — a chaque sonde placee sur une jointure, l'altitude assemblee doit + valoir la mediane des points sol reels du voisinage, points pris dans les DEUX + dalles voisines indifferemment. + +2. ALIGNEMENT (le controle decisif) — la meme comparaison est refaite en + DECALANT la lecture d'un noeud vers l'est, l'ouest, le nord et le sud. Un + assemblage decale d'une colonne resterait plausible sur du relief doux : c'est + le CONTRASTE entre la lecture directe et les quatre lectures decalees qui + prouve l'alignement, exactement comme le test nord/sud de la Phase 7. Si un + decalage colle aussi bien que la lecture directe, la sonde ne prouve rien et + c'est signale. + +3. TEMOINS — les memes mesures sur des sondes prises LOIN de toute jointure. Si + l'ecart aux jointures ressemble a l'ecart des temoins, le raccord n'introduit + aucune degradation. C'est la comparaison qui compte, pas la valeur absolue : + sous couvert forestier dense, meme au milieu d'une dalle, l'ecart n'est jamais + nul. + +Les frontieres sont deduites des NOMS des .laz (nomenclature IGN +LHD_FXX___...), pas de la maniere dont le terrain a ete assemble. +""" + +from __future__ import annotations + +import argparse +import os +import struct +import sys + +import numpy as np + +try: + import laspy +except ImportError: + sys.exit('laspy est absent : python -m pip install "laspy[lazrs]" numpy') + +HEADER_SIZE = 120 +GROUND_CLASS = 2 + + +def read_vchm(path): + with open(path, "rb") as f: + header = f.read(HEADER_SIZE) + if header[:4] != b"VCHM": + sys.exit(f"{path} : ce n'est pas un .vchm") + nx = struct.unpack_from(" int: + parser = argparse.ArgumentParser( + description="Verifie les jointures d'un terrain assemble contre les nuages bruts.") + parser.add_argument("vchm") + parser.add_argument("laz", nargs="+") + parser.add_argument("--step", type=float, default=25.0, + help="espacement des sondes le long d'une jointure, en m " + "(defaut 25)") + parser.add_argument("--min-points", type=int, default=4, + help="points sol minimum pour qu'une sonde compte (defaut 4)") + parser.add_argument("--tolerance", type=float, default=0.50, + help="ecart median tolere aux jointures, en m (defaut 0.50)") + args = parser.parse_args() + + m = read_vchm(args.vchm) + nx, nz, cell = m["nx"], m["nz"], m["spacing"] + grid = m["grid"].astype(np.float64) + east0, north0 = m["east"], m["north"] + + print(f"Terrain : {os.path.basename(args.vchm)} ('{m['label']}')") + print(f" {nx} x {nz} echantillons, pas {cell} m, EPSG:{m['epsg']}") + print(f" coin nord-ouest : E {east0:.0f}, N {north0:.0f}") + print(f" emprise : E {east0:.0f}..{east0 + (nx - 1) * cell:.0f}, " + f"N {north0 - (nz - 1) * cell:.0f}..{north0:.0f}") + + bounds = {} + for path in args.laz: + b = tile_bounds(path) + if b is None: + print(f" ATTENTION : nom non reconnu, dalle ignoree : " + f"{os.path.basename(path)}") + continue + bounds[path] = b + + if not bounds: + sys.exit("Aucune dalle exploitable.") + + xs = sorted({b[0] for b in bounds.values()}) + ys = sorted({b[3] for b in bounds.values()}) + print(f" {len(bounds)} dalle(s), grille {len(xs)} x {len(ys)}") + + # --- Frontieres interieures --------------------------------------------- + # Une frontiere verticale existe a chaque X de debut de dalle qui n'est pas + # le bord ouest du terrain ; idem au sud pour les horizontales. + seam_x = [x for x in xs if x > min(xs)] + seam_y = [y - 1000 for y in ys if y - 1000 > min(b[1] for b in bounds.values())] + + print(f" frontieres interieures : {len(seam_x)} verticale(s) " + f"{[f'E{v}' for v in seam_x]}, {len(seam_y)} horizontale(s) " + f"{[f'N{v}' for v in seam_y]}") + + if not seam_x and not seam_y: + print("\nAucune frontiere interieure : rien a verifier.") + return 0 + + # --- Sondes --------------------------------------------------------------- + # Chaque sonde est un NOEUD de la grille, repere par ses coordonnees + # Lambert 93. On evite les 2 noeuds extremes de chaque jointure (les coins du + # terrain n'ont pas de voisinage complet). + e_min, e_max = east0, east0 + (nx - 1) * cell + n_min, n_max = north0 - (nz - 1) * cell, north0 + + probes = [] # (categorie, E, N) + for sx in seam_x: + n = n_min + args.step + while n <= n_max - args.step: + probes.append((f"V E{sx}", float(sx), float(round(n)))) + n += args.step + for sy in seam_y: + e = e_min + args.step + while e <= e_max - args.step: + probes.append((f"H N{sy}", float(round(e)), float(sy))) + e += args.step + + # Temoins : loin de toute jointure (au moins 100 m), semis regulier decale + # pour ne jamais retomber sur une frontiere. + controls = 0 + e = e_min + 137.0 + while e <= e_max - 137.0: + n = n_min + 211.0 + while n <= n_max - 211.0: + far_x = all(abs(e - sx) > 100 for sx in seam_x) if seam_x else True + far_y = all(abs(n - sy) > 100 for sy in seam_y) if seam_y else True + if far_x and far_y: + probes.append(("temoin", float(round(e)), float(round(n)))) + controls += 1 + n += 500.0 + e += 500.0 + + print(f" sondes : {len(probes) - controls} sur jointure, {controls} temoins " + f"(pas de {args.step:g} m)") + + # Index de grille de chaque sonde (meme regle d'affectation que le + # convertisseur : plus proche noeud, floor(t + 0.5)). + probe_ix = np.array([int(np.floor((p[1] - east0) / cell + 0.5)) for p in probes]) + probe_iz = np.array([int(np.floor((north0 - p[2]) / cell + 0.5)) for p in probes]) + + inside = (probe_ix >= 1) & (probe_ix < nx - 1) & (probe_iz >= 1) & (probe_iz < nz - 1) + + # Le croisement de deux jointures est engendre une fois par chacune : on ne + # garde qu'une sonde par noeud (la premiere, donc la jointure verticale). + seen: set[tuple[int, int]] = set() + unique = [] + for index, keep in enumerate(inside): + node = (int(probe_ix[index]), int(probe_iz[index])) + if keep and node not in seen: + seen.add(node) + unique.append(index) + unique = np.asarray(unique, dtype=np.int64) + + duplicates = int(inside.sum()) - len(unique) + if duplicates: + print(f" ({duplicates} sonde(s) en double au croisement de deux " + f"jointures, dedoublonnee(s))") + + probes = [probes[i] for i in unique] + probe_ix, probe_iz = probe_ix[unique], probe_iz[unique] + count = len(probes) + + # --- Collecte des points sol bruts autour de chaque sonde ---------------- + # Une passe par .laz, en flux : chaque point est rattache au noeud le plus + # proche, et on ne garde que ceux qui tombent sur une sonde. Les points d'une + # sonde placee sur une jointure viennent donc des DEUX dalles voisines, ce + # qui est exactement le voisinage que le noeud partage devrait decrire. + keys = probe_ix.astype(np.int64) * np.int64(1 << 20) + probe_iz.astype(np.int64) + order = np.argsort(keys) + sorted_keys = keys[order] + if len(np.unique(sorted_keys)) != len(sorted_keys): + sys.exit("Sondes en double : ajuster --step.") + + buckets: list[list[np.ndarray]] = [[] for _ in range(count)] + + print(f"\nLecture des nuages bruts (classe {GROUND_CLASS})...") + for index, path in enumerate(sorted(bounds), 1): + total = 0 + with laspy.open(path) as reader: + for chunk in reader.chunk_iterator(4_000_000): + keep = np.asarray(chunk.classification) == GROUND_CLASS + if not keep.any(): + continue + px = np.asarray(chunk.x)[keep] + py = np.asarray(chunk.y)[keep] + pz = np.asarray(chunk.z)[keep] + + ix = np.floor((px - east0) / cell + 0.5).astype(np.int64) + iz = np.floor((north0 - py) / cell + 0.5).astype(np.int64) + key = ix * np.int64(1 << 20) + iz + + position = np.searchsorted(sorted_keys, key) + position[position >= len(sorted_keys)] = 0 + hit = sorted_keys[position] == key + if not hit.any(): + continue + for slot, value in zip(position[hit], pz[hit]): + buckets[order[slot]].append(value) + total += int(hit.sum()) + + sys.stdout.write(f"\r {index}/{len(bounds)} {os.path.basename(path)[:44]:<44s} " + f"{total:>7,} point(s) retenus ") + sys.stdout.flush() + print("\r" + " " * 90 + "\r", end="") + + # --- Comparaison ---------------------------------------------------------- + shifts = {"direct": (0, 0), "est +1": (1, 0), "ouest -1": (-1, 0), + "sud +1": (0, 1), "nord -1": (0, -1)} + errors: dict[str, dict[str, list[float]]] = { + name: {"jointure": [], "temoin": []} for name in shifts} + + weak = 0 + used = 0 + per_seam: dict[str, list[float]] = {} + + for i, (category, e, n) in enumerate(probes): + values = buckets[i] + if len(values) < args.min_points: + weak += 1 + continue + reference = float(np.median(np.asarray(values, dtype=np.float64))) + used += 1 + group = "temoin" if category == "temoin" else "jointure" + + for name, (dx, dz) in shifts.items(): + jx, jz = probe_ix[i] + dx, probe_iz[i] + dz + errors[name][group].append(abs(float(grid[jz, jx]) - reference)) + + if group == "jointure": + per_seam.setdefault(category, []).append( + abs(float(grid[probe_iz[i], probe_ix[i]]) - reference)) + + print(f"Sondes exploitables : {used}/{count} " + f"({weak} rejetee(s) faute de points sol — zone sous couvert ou hors dalle)") + + if not used: + sys.exit("Aucune sonde exploitable : verifier que les .laz couvrent bien " + "l'emprise du terrain.") + + # 1 + 2 : justesse et alignement, par le contraste + print(f"\n{'lecture':<12} {'jointures: median':>18} {'max':>9} " + f"{'| temoins: median':>20} {'max':>9}") + print("-" * 72) + direct_seam = None + for name in shifts: + seam_values = errors[name]["jointure"] + control_values = errors[name]["temoin"] + seam_median = float(np.median(seam_values)) if seam_values else float("nan") + seam_max = float(np.max(seam_values)) if seam_values else float("nan") + control_median = float(np.median(control_values)) if control_values else float("nan") + control_max = float(np.max(control_values)) if control_values else float("nan") + if name == "direct": + direct_seam = seam_median + mark = " <- lecture reelle" if name == "direct" else "" + print(f"{name:<12} {seam_median:>17.3f}m {seam_max:>8.3f}m " + f"{control_median:>19.3f}m {control_max:>8.3f}m{mark}") + + # 3 : detail par frontiere — aucune ne doit se distinguer des autres + print(f"\nDetail par frontiere ({'V' } = verticale, 'H' = horizontale) :") + print(f" {'frontiere':<14} {'sondes':>7} {'median':>9} {'moyen':>9} {'max':>9}") + worst_seam = 0.0 + for name in sorted(per_seam): + values = np.asarray(per_seam[name]) + worst_seam = max(worst_seam, float(np.median(values))) + print(f" {name:<14} {values.size:>7} {np.median(values):>8.3f}m " + f"{values.mean():>8.3f}m {values.max():>8.3f}m") + + # --- Verdict -------------------------------------------------------------- + print() + failures = [] + + shifted = [float(np.median(errors[name]["jointure"])) + for name in shifts if name != "direct"] + best_shift = min(shifted) + if direct_seam is None or not (direct_seam < best_shift): + failures.append( + f"ALIGNEMENT : la lecture directe ({direct_seam:.3f} m) n'est pas " + f"meilleure que le meilleur decalage ({best_shift:.3f} m). " + f"L'assemblage est probablement decale d'un noeud.") + else: + ratio = best_shift / direct_seam if direct_seam > 0 else float("inf") + print(f"ALIGNEMENT OK : lecture directe {direct_seam:.3f} m contre " + f"{best_shift:.3f} m pour le meilleur decalage " + f"(x{ratio:.1f}). Le contraste prouve que les jointures tombent " + f"exactement sur le bon noeud.") + + if worst_seam > args.tolerance: + failures.append(f"JUSTESSE : une frontiere depasse la tolerance " + f"({worst_seam:.3f} m > {args.tolerance:.2f} m).") + else: + print(f"JUSTESSE OK : toutes les frontieres sous {args.tolerance:.2f} m " + f"(pire mediane {worst_seam:.3f} m).") + + control_median = float(np.median(errors["direct"]["temoin"])) \ + if errors["direct"]["temoin"] else float("nan") + if np.isfinite(control_median): + if direct_seam > max(3.0 * control_median, control_median + 0.30): + failures.append( + f"DEGRADATION : l'ecart aux jointures ({direct_seam:.3f} m) est " + f"nettement pire qu'en plein milieu de dalle " + f"({control_median:.3f} m).") + else: + print(f"NON-DEGRADATION OK : jointures {direct_seam:.3f} m vs " + f"plein milieu de dalle {control_median:.3f} m — le raccord " + f"n'est pas moins fidele que le reste du terrain.") + + if failures: + print() + for f in failures: + print(f" ECHEC — {f}") + return 1 + + print("\nToutes les frontieres sont conformes.") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/check_terrain_file.py b/tools/check_terrain_file.py new file mode 100644 index 0000000..a225333 --- /dev/null +++ b/tools/check_terrain_file.py @@ -0,0 +1,227 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +check_terrain_file.py — controle croise d'un .vchm contre le .laz d'origine. + + python tools/check_terrain_file.py DALLE.vchm NUAGE.copc.laz + +Relit le fichier produit par lidar_to_heightmap.py et, pour une serie de points +de sonde, compare l'altitude stockee a la MEDIANE DES POINTS SOL BRUTS du nuage +dans un rayon d'une demi-cellule. Rien n'est partage avec le convertisseur a part +le format du fichier : une erreur d'indexation ou d'orientation dans l'un ne peut +pas se compenser dans l'autre. + +CE QUE CE CONTROLE ATTRAPE, ET QUE RIEN D'AUTRE N'ATTRAPE : le relief en MIROIR. +Les lignes du .vchm vont du nord vers le sud (cf. l'en-tete de +lidar_to_heightmap.py). Se tromper de sens produit un terrain parfaitement +plausible - meme denivele, memes pentes, meme histogramme - mais retourne, +d'autant plus indetectable qu'il n'y a pas encore d'orthophoto a plaquer dessus. +Les sondes sont donc placees ASYMETRIQUEMENT : sur cette dalle les quatre bords +different de plusieurs centaines de metres, donc une inversion nord/sud creuse +un ecart enorme au lieu de passer inapercue. + +Affiche aussi la conversion monde moteur <-> Lambert 93 que fait +Heightmap::toProjected, pour verifier a la main les coordonnees journalisees par +le jeu au demarrage. +""" + +from __future__ import annotations + +import os +import struct +import sys + +import numpy as np + +try: + import laspy +except ImportError: + sys.exit('laspy est absent : python -m pip install "laspy[lazrs]" numpy') + +HEADER_SIZE = 120 + + +def read_vchm(path): + with open(path, "rb") as f: + header = f.read(HEADER_SIZE) + if len(header) != HEADER_SIZE or header[:4] != b"VCHM": + sys.exit(f"{path} n'est pas un fichier .vchm.") + (magic, version, nx, nz, spacing, _reserved, + origin_e, origin_n, hmin, hmax, epsg, flags) = struct.unpack_from( + "<4sIIIfI dd ffII", header, 0) + label = header[56:120].split(b"\0", 1)[0].decode("ascii", "replace") + heights = np.frombuffer(f.read(), dtype=" EST (+X) iz croissant -> SUD (+Z)") + + # --- Points de sonde, volontairement asymetriques ---------------------- + q = (nx - 1) // 4 + c = (nx - 1) // 2 + probes = [ + ("centre", c, c), + ("nord", c, q), + ("sud", c, 3 * q), + ("ouest", q, c), + ("est", 3 * q, c), + ("nord-ouest", q, q), + ("sud-est", 3 * q, 3 * q), + ("coin NO", 2, 2), + ("coin SE", nx - 3, nz - 3), + ] + + print(f"\nLecture du nuage brut {os.path.basename(laz_path)} (classe 2)...") + xs, ys, zs = [], [], [] + with laspy.open(laz_path) as reader: + for chunk in reader.chunk_iterator(4_000_000): + keep = np.asarray(chunk.classification) == 2 + if keep.any(): + xs.append(np.asarray(chunk.x)[keep]) + ys.append(np.asarray(chunk.y)[keep]) + zs.append(np.asarray(chunk.z)[keep]) + x = np.concatenate(xs); y = np.concatenate(ys); z = np.concatenate(zs) + print(f" {x.size:,} points sol") + + print(f"\n{'sonde':<12} {'ix':>5} {'iz':>5} {'monde X':>9} {'monde Z':>9} " + f"{'E (L93)':>11} {'N (L93)':>11} {'.vchm':>9} {'brut':>9} {'ecart':>7} {'n':>5}") + print("-" * 106) + + worst = 0.0 + checked = 0 + for name, ix, iz in probes: + world_x = -half + ix * cell + world_z = -half + iz * cell + # Exactement ce que fait Heightmap::toProjected. + east = m["origin_e"] + (world_x + half) + north = m["origin_n"] - (world_z + half) + + stored = float(grid[iz, ix]) + + # Mediane des points bruts appartenant au noeud : c'est la DEFINITION du + # noeud - la demi-cellule [E - c/2, E + c/2[ - rejouee ici depuis le + # nuage, sans rien emprunter au convertisseur. L'intervalle est + # semi-ouvert des deux cotes, comme la regle d'arrondi "moitie vers le + # haut" employee la-bas : un point pile sur la frontiere doit tomber du + # meme cote dans les deux calculs, faute de quoi les deux medianes + # different legerement et le controle accuse a tort le convertisseur. + r = 0.5 * cell + near = ((x - east >= -r) & (x - east < r) & + (y - north >= -r) & (y - north < r)) + count = int(near.sum()) + if count == 0: + print(f"{name:<12} {ix:5d} {iz:5d} {world_x:9.1f} {world_z:9.1f} " + f"{east:11.1f} {north:11.1f} {stored:9.2f} {'(trou)':>9} " + f"{'-':>7} {0:5d}") + continue + + raw = float(np.median(z[near])) + delta = stored - raw + worst = max(worst, abs(delta)) + checked += 1 + print(f"{name:<12} {ix:5d} {iz:5d} {world_x:9.1f} {world_z:9.1f} " + f"{east:11.1f} {north:11.1f} {stored:9.2f} {raw:9.2f} " + f"{delta:+7.3f} {count:5d}") + + # --- Test d'orientation, sur un large echantillon de noeuds ------------- + # Comparer la moyenne d'une BANDE de la grille a celle des points bruts de la + # meme bande serait tentant mais FAUX : la grille est ponderee par la + # surface, alors que le nuage est ponderee par les points, dont la densite + # s'effondre sous le couvert forestier. Sur cette dalle l'ecart atteint 30 m + # sans qu'aucune erreur ne soit en cause. + # + # On generalise donc la comparaison PAR NOEUD, la seule qui compare deux fois + # la meme chose, et on la rejoue contre les deux symetriques possibles : + # - lignes inversees -> le relief serait retourne nord/sud ; + # - colonnes inversees -> retourne est/ouest. + # Une orientation correcte donne un ecart direct nul et des ecarts miroir + # enormes. C'est ce contraste qui fait la preuve, pas la valeur absolue. + print("\nControle d'orientation sur un large echantillon de noeuds :") + rng = np.random.default_rng(20260816) + sample = 600 + sample_ix = rng.integers(0, nx, sample) + sample_iz = rng.integers(0, nz, sample) + + direct, flip_ns, flip_ew, used = [], [], [], 0 + r = 0.5 * cell + for ix, iz in zip(sample_ix.tolist(), sample_iz.tolist()): + east = m["origin_e"] + ix * cell + north = m["origin_n"] - iz * cell + near = ((x - east >= -r) & (x - east < r) & + (y - north >= -r) & (y - north < r)) + if not near.any(): + continue + raw = float(np.median(z[near])) + used += 1 + direct.append(abs(float(grid[iz, ix]) - raw)) + flip_ns.append(abs(float(grid[nz - 1 - iz, ix]) - raw)) + flip_ew.append(abs(float(grid[iz, nx - 1 - ix]) - raw)) + + direct = np.array(direct); flip_ns = np.array(flip_ns); flip_ew = np.array(flip_ew) + # Quelques noeuds PEUVENT s'ecarter legitimement : ce sont ceux que le filtre + # de pics a remplaces par la mediane de leur voisinage, donc justement ceux + # ou la valeur stockee ne DOIT pas etre celle du nuage brut. Ils sont de + # l'ordre de 1 sur 100 000, donc invisibles sur 600 tirages, mais on compte + # les depassements plutot que de juger sur le seul maximum. + outliers = int((direct > 0.01).sum()) + print(f" {used} noeuds mesures sur {sample} tires") + print(f" lecture DIRECTE : ecart moyen {direct.mean():8.4f} m, " + f"max {direct.max():8.4f} m, {outliers} noeud(s) au-dessus de 1 cm") + print(f" si les lignes etaient inversees (nord/sud) : ecart moyen " + f"{flip_ns.mean():8.3f} m") + print(f" si les colonnes etaient inversees (est/ouest) : ecart moyen " + f"{flip_ew.mean():8.3f} m") + + faithful = direct.mean() < 0.001 and outliers <= 2 + discriminating = flip_ns.mean() > 10.0 and flip_ew.mean() > 10.0 + ok_orientation = faithful and discriminating + if ok_orientation: + print(" -> lecture directe exacte, symetriques tres fausses : " + "orientation CORRECTE et discriminee.") + elif not faithful: + print(" -> la lecture directe ne retrouve pas le nuage : " + "indexation ou geo-referencement errone.") + else: + print(" -> le terrain est trop symetrique pour que ce test discrimine " + "quoi que ce soit ; changer de dalle.") + + print(f"\nEcart maximal sur les {checked} sondes nommees : {worst:.3f} m") + ok = ok_orientation and worst < 0.05 and checked >= 5 + print("[OK] Le fichier decrit bien le nuage d'origine." if ok + else "[ECHEC] Voir ci-dessus.") + return 0 if ok else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/deploy_beta_to_desktop.ps1 b/tools/deploy_beta_to_desktop.ps1 new file mode 100644 index 0000000..87071a0 --- /dev/null +++ b/tools/deploy_beta_to_desktop.ps1 @@ -0,0 +1,37 @@ +$dest = "C:\Users\theog\Desktop\Vercora.Beta" +if (-not (Test-Path $dest)) { + New-Item -ItemType Directory -Path $dest -Force | Out-Null +} + +Copy-Item -Path "build\vercora.exe" -Destination $dest -Force +Copy-Item -Path "dist\VercoraDemo\*.dll" -Destination $dest -Force +Copy-Item -Path "build\shaders" -Destination $dest -Recurse -Force +Copy-Item -Path "dist\VercoraDemo\assets" -Destination $dest -Recurse -Force + +$batContent = @" +@echo off +cd /d "%~dp0" +start "" "vercora.exe" --demo +"@ +Set-Content -Path "$dest\Lancer_Demo.bat" -Value $batContent -Encoding ASCII + +$readmeContent = @" +Vercora - DEMO (Exploration & Vol libre) +======================================== + +Pour lancer la demo : double-cliquez sur Lancer_Demo.bat ou vercora.exe. + +Commandes : +- Clic droit maintenu + Souris : Regarder autour de soi / orienter la vue +- Touches Z, Q, S, D (ou W, A, S, D) : Se deplacer +- Touche F : Basculer entre Marche et Vol libre +- Touche O : Basculer entre l'orthophoto aerienne et la coloration procedurale +- Fermer : Croix de la fenetre ou Alt+F4 + +Cette version demo se concentre sur l'exploration du massif (25 km2 LiDAR) +en marche et vol libre, sans les activites complexes ni survie. +"@ +Set-Content -Path "$dest\LisezMoi.txt" -Value $readmeContent -Encoding UTF8 + +Write-Host "Deploiement termine dans $dest :" +Get-ChildItem -Path $dest diff --git a/tools/fetch_dalles.py b/tools/fetch_dalles.py new file mode 100644 index 0000000..1e93807 --- /dev/null +++ b/tools/fetch_dalles.py @@ -0,0 +1,334 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +fetch_dalles.py — telecharge un lot de dalles LiDAR HD IGN decrites par un JSON. + +PHASE 9. La Phase 7 avait telecharge UNE dalle a la main ; ici il y en a 25, et +un telechargement de plusieurs gigaoctets qui echoue a la 23e sans rien dire +serait le pire resultat possible. D'ou : taille totale connue AVANT de commencer, +reprise sur octets deja recus, reessais avec attente croissante, et un bilan +final qui NOMME ce qui a echoue au lieu de s'arreter en silence. + + python tools/fetch_dalles.py vercora_dalles.json -o data/lidar + python tools/fetch_dalles.py vercora_dalles.json -o data/lidar --only 0899-6440 0900-6440 + python tools/fetch_dalles.py vercora_dalles.json -o data/lidar --dry-run + +Options : + --only C [C ...] ne traiter que ces dalles (coordonnees_NW, ex. 0899-6440) + --dry-run interroge les tailles et affiche le bilan, sans rien ecrire + --retries N tentatives par dalle (defaut 4) + --margin-go N marge de disque libre exigee en plus du lot (defaut 5) + +FORMAT D'ENTREE attendu (celui exporte depuis data.geopf.fr) : un objet dont +chaque valeur porte "url" et "metadata", cette derniere etant une CHAINE de JSON +a re-parser (l'IGN imbrique du JSON dans du JSON) contenant au moins +"coordonnees_NW" ("0899-6440" = coin nord-ouest en km Lambert 93) et +"nombre_points". + +REPRISE : un fichier deja present et complet (taille == Content-Length) est +saute, pas retelecharge. Un fichier partiel est repris par requete Range si le +serveur l'accepte, sinon reparti de zero. C'est ce qui rend le script rejouable +apres une coupure sans repayer les gigaoctets deja recus. +""" + +from __future__ import annotations + +import argparse +import json +import os +import shutil +import sys +import time +import urllib.error +import urllib.request + +USER_AGENT = "Vercora/0.9 (+projet de jeu personnel; laspy pipeline)" +TIMEOUT = 60 +CHUNK = 1 << 20 # 1 Mo + + +def human(n: float) -> str: + for unit in ("o", "Ko", "Mo", "Go"): + if abs(n) < 1024 or unit == "Go": + return f"{n:.1f} {unit}" if unit != "o" else f"{int(n)} o" + n /= 1024.0 + return f"{n:.1f} Go" + + +def human_time(seconds: float) -> str: + seconds = int(seconds) + if seconds < 60: + return f"{seconds} s" + if seconds < 3600: + return f"{seconds // 60} min {seconds % 60:02d} s" + return f"{seconds // 3600} h {(seconds % 3600) // 60:02d} min" + + +def load_manifest(path: str, only: list[str] | None): + """Retourne [(coord, nom, url, nombre_points)] trie du nord-ouest au sud-est.""" + with open(path, "r", encoding="utf-8") as f: + raw = json.load(f) + + entries = [] + for name, item in raw.items(): + url = item["url"] + # L'IGN imbrique le bloc de metadonnees comme une CHAINE de JSON. + meta = item["metadata"] + if isinstance(meta, str): + meta = json.loads(meta) + coord = meta["coordonnees_NW"] + entries.append((coord, name, url, int(meta.get("nombre_points", 0)))) + + if only: + wanted = set(only) + kept = [e for e in entries if e[0] in wanted] + missing = wanted - {e[0] for e in kept} + if missing: + sys.exit(f"--only : dalle(s) absente(s) du manifeste : " + f"{', '.join(sorted(missing))}") + entries = kept + + # Nord-ouest -> sud-est : X croissant, Y DECROISSANT (le nord est en haut). + def key(e): + x, y = e[0].split("-") + return (-int(y), int(x)) + + entries.sort(key=key) + return entries + + +def remote_size(url: str) -> int | None: + """Content-Length sans telecharger le corps. None si le serveur se tait.""" + request = urllib.request.Request(url, method="HEAD", + headers={"User-Agent": USER_AGENT}) + try: + with urllib.request.urlopen(request, timeout=TIMEOUT) as response: + length = response.headers.get("Content-Length") + return int(length) if length is not None else None + except (urllib.error.URLError, ValueError, TimeoutError): + return None + + +def download_one(url: str, destination: str, expected: int | None, + retries: int, index: int, total: int, label: str) -> tuple[bool, str]: + """Telecharge avec reprise et reessais. Retourne (succes, message).""" + temporary = destination + ".part" + + for attempt in range(1, retries + 1): + have = os.path.getsize(temporary) if os.path.exists(temporary) else 0 + + if expected is not None and have == expected: + os.replace(temporary, destination) + return True, "deja complet (.part)" + if expected is not None and have > expected: + # Fichier partiel incoherent (manifeste change, disque corrompu) : + # mieux vaut repartir que concatener n'importe quoi. + os.remove(temporary) + have = 0 + + headers = {"User-Agent": USER_AGENT} + if have > 0: + headers["Range"] = f"bytes={have}-" + + try: + request = urllib.request.Request(url, headers=headers) + with urllib.request.urlopen(request, timeout=TIMEOUT) as response: + # 200 sur une requete Range = le serveur ignore la reprise et + # renvoie tout : il faut alors reecrire depuis le debut, sinon + # on colle le fichier entier a la suite du morceau deja recu. + resuming = (response.status == 206) + if have > 0 and not resuming: + have = 0 + + mode = "ab" if resuming and have > 0 else "wb" + started = time.time() + last_print = 0.0 + received = have + + with open(temporary, mode) as f: + while True: + chunk = response.read(CHUNK) + if not chunk: + break + f.write(chunk) + received += len(chunk) + + now = time.time() + if now - last_print >= 0.5: + last_print = now + elapsed = max(now - started, 1e-6) + speed = (received - have) / elapsed + if expected: + pct = 100.0 * received / expected + eta = ((expected - received) / speed + if speed > 0 else 0) + bar_width = 24 + filled = int(bar_width * received / expected) + bar = "#" * filled + "." * (bar_width - filled) + sys.stdout.write( + f"\r [{index}/{total}] {label} " + f"[{bar}] {pct:5.1f}% " + f"{human(received)}/{human(expected)} " + f"{human(speed)}/s reste {human_time(eta)} ") + else: + sys.stdout.write( + f"\r [{index}/{total}] {label} " + f"{human(received)} {human(speed)}/s ") + sys.stdout.flush() + + sys.stdout.write("\r" + " " * 100 + "\r") + sys.stdout.flush() + + size = os.path.getsize(temporary) + if expected is not None and size != expected: + raise IOError(f"taille finale {size} != attendu {expected}") + + # Un .laz commence par "LASF" : un HTML d'erreur enregistre sous le + # bon nom passerait sinon inapercu jusqu'a la conversion. + with open(temporary, "rb") as f: + magic = f.read(4) + if magic != b"LASF": + raise IOError(f"en-tete inattendu {magic!r} (pas un LAS/LAZ)") + + os.replace(temporary, destination) + elapsed = time.time() - started + return True, f"{human(size)} en {human_time(elapsed)}" + + except (urllib.error.URLError, IOError, TimeoutError, OSError) as error: + sys.stdout.write("\r" + " " * 100 + "\r") + sys.stdout.flush() + if attempt >= retries: + return False, f"{type(error).__name__}: {error}" + wait = min(2 ** attempt, 30) + print(f" [{index}/{total}] {label} : echec ({error}), " + f"nouvelle tentative {attempt + 1}/{retries} dans {wait} s") + time.sleep(wait) + + return False, "tentatives epuisees" + + +def main() -> int: + parser = argparse.ArgumentParser( + description="Telecharge les dalles LiDAR HD decrites par un manifeste JSON.") + parser.add_argument("manifest") + parser.add_argument("-o", "--output", default="data/lidar") + parser.add_argument("--only", nargs="+", default=None) + parser.add_argument("--dry-run", action="store_true") + parser.add_argument("--retries", type=int, default=4) + parser.add_argument("--margin-go", type=float, default=5.0) + args = parser.parse_args() + + entries = load_manifest(args.manifest, args.only) + print(f"Manifeste : {args.manifest} -> {len(entries)} dalle(s)") + + coords = [e[0] for e in entries] + xs = sorted({int(c.split("-")[0]) for c in coords}) + ys = sorted({int(c.split("-")[1]) for c in coords}) + print(f" emprise (coins NO) : X {xs[0]}..{xs[-1]} km, Y {ys[0]}..{ys[-1]} km " + f"({len(xs)} x {len(ys)} dalles)") + print(f" points annonces : {sum(e[3] for e in entries):,}") + + os.makedirs(args.output, exist_ok=True) + + # --- Tailles reelles AVANT de telecharger quoi que ce soit --------------- + print(f"\nInterrogation des tailles ({len(entries)} requetes HEAD)...") + sizes: dict[str, int | None] = {} + unknown = 0 + for index, (coord, name, url, points) in enumerate(entries, 1): + size = remote_size(url) + sizes[coord] = size + if size is None: + unknown += 1 + sys.stdout.write(f"\r {index}/{len(entries)} ") + sys.stdout.flush() + print("\r" + " " * 40 + "\r", end="") + + known = [s for s in sizes.values() if s is not None] + total_known = sum(known) + if unknown and known: + # Estimation pour les manquantes, a partir de la moyenne des connues. + average = total_known / len(known) + estimated_total = total_known + unknown * average + else: + estimated_total = total_known + + print(f" taille totale : {human(total_known)}" + + (f" (+{unknown} dalle(s) de taille inconnue, " + f"estimation totale {human(estimated_total)})" if unknown else "")) + + already = 0 + todo = [] + for coord, name, url, points in entries: + destination = os.path.join(args.output, os.path.basename(url)) + size = sizes[coord] + if os.path.exists(destination) and (size is None + or os.path.getsize(destination) == size): + already += os.path.getsize(destination) + continue + todo.append((coord, name, url, destination, size)) + + partial = sum(os.path.getsize(t[3] + ".part") + for t in todo if os.path.exists(t[3] + ".part")) + remaining = max(estimated_total - already - partial, 0) + + print(f" deja sur disque : {human(already)}" + + (f" (+{human(partial)} de fragments repris)" if partial else "")) + print(f" a telecharger : {human(remaining)} ({len(todo)} dalle(s))") + + # --- Verification du disque --------------------------------------------- + free = shutil.disk_usage(os.path.abspath(args.output)).free + needed = remaining + args.margin_go * (1 << 30) + print(f"\nDisque : {human(free)} libres, besoin {human(remaining)} " + f"+ {args.margin_go:g} Go de marge = {human(needed)}") + if free < needed: + print(" INSUFFISANT — rien n'a ete telecharge.", file=sys.stderr) + return 2 + print(" OK") + + if args.dry_run: + print("\n--dry-run : rien n'a ete telecharge.") + return 0 + if not todo: + print("\nToutes les dalles sont deja presentes. Rien a faire.") + return 0 + + # --- Telechargement ------------------------------------------------------ + print(f"\nTelechargement de {len(todo)} dalle(s) vers {args.output}/\n") + started = time.time() + failures = [] + done_bytes = 0 + + for index, (coord, name, url, destination, size) in enumerate(todo, 1): + ok, message = download_one(url, destination, size, args.retries, + index, len(todo), coord) + if ok: + done_bytes += os.path.getsize(destination) + elapsed = time.time() - started + speed = done_bytes / elapsed if elapsed > 0 else 0 + left = max(remaining - done_bytes, 0) + eta = left / speed if speed > 0 else 0 + print(f" [{index}/{len(todo)}] {coord} OK {message}" + f" | lot : {100.0 * index / len(todo):.0f}%, " + f"reste ~{human_time(eta)}") + else: + failures.append((coord, message)) + print(f" [{index}/{len(todo)}] {coord} ECHEC {message}") + + elapsed = time.time() - started + print(f"\nTermine en {human_time(elapsed)} — " + f"{len(todo) - len(failures)}/{len(todo)} reussie(s), " + f"{human(done_bytes)} recus" + + (f", {human(done_bytes / elapsed)}/s de moyenne" if elapsed > 0 else "")) + + if failures: + print(f"\n{len(failures)} ECHEC(S) — relancer la meme commande reprendra " + f"ces dalles la ou elles en sont :") + for coord, message in failures: + print(f" {coord} : {message}") + return 1 + + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/fetch_ortho.py b/tools/fetch_ortho.py new file mode 100644 index 0000000..c198ea6 --- /dev/null +++ b/tools/fetch_ortho.py @@ -0,0 +1,354 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +fetch_ortho.py — telecharge la BD ORTHO de l'IGN sur l'emprise d'un terrain .vchm. + +PHASE 11. Le terrain LiDAR ne porte QUE de la geometrie : aucune couleur. Ce +script va chercher la photo aerienne reelle qui recouvre exactement la meme +emprise, par le service WMS raster de la Geoplateforme (data.geopf.fr), couche +HR.ORTHOIMAGERY.ORTHOPHOTOS ("Ortho 20 cm", BD ORTHO V3, licence Etalab). + + python tools/fetch_ortho.py assets/terrain/vercora_zone_1m.vchm -o data/ortho + python tools/fetch_ortho.py assets/terrain/vercora_zone_1m.vchm -o data/ortho --res 0.2 + python tools/fetch_ortho.py assets/terrain/vercora_zone_1m.vchm --dry-run + +POURQUOI L'EMPRISE EST LUE DANS LE .vchm ET NON PASSEE EN ARGUMENT. C'est le +seul moyen d'etre certain que la texture recouvre le terrain au metre pres. Une +bbox recopiee a la main dans une ligne de commande 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 d'ecran mais qui met les arbres a cote +des arbres. L'en-tete .vchm donne l'origine (noeud ix=0, iz=0 = coin NORD-OUEST), +le pas et le nombre d'echantillons : l'emprise en decoule sans ambiguite. + + E0 = originEast E1 = originEast + (samplesX - 1) * spacing + N1 = originNorth N0 = originNorth - (samplesZ - 1) * spacing + +Attention a la difference de NATURE entre les deux jeux de donnees, qui est la +seule vraie subtilite de l'alignement : + - la heightmap est un semis de NOEUDS ; le noeud ix=0 est exactement a E0 ; + - 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 bien [E0, E1] x [N0, N1] : l'image couvre +exactement le carre delimite par les noeuds extremes du terrain, bord a bord. +Le demi-texel de decalage residuel entre "bord de l'image" et "centre du premier +texel" est assume et documente dans NOTES-PHASE11.md (il vaut res/2, soit 25 cm +au pas de 50 cm, tres en dessous de la precision de la BD ORTHO elle-meme). + +ORDRE DES AXES. Le service ne parle QUE WMS 1.3.0 (une requete 1.1.1 est +rejetee : VersionNegotiationFailed). En 1.3.0 l'ordre des axes depend du CRS, ce +qui est la source d'erreur classique. Verifie sur ce serveur, pas suppose : +BBOX=minEast,minNorth,maxEast,maxNorth renvoie l'image attendue, tandis que +l'ordre inverse renvoie une image BLANCHE UNIFORME. Le controle est reproduit a +chaque execution par --self-test. + +DECOUPAGE. MaxWidth/MaxHeight annonces par GetCapabilities valent 5010 px : une +requete unique sur 5 km a 50 cm (10 000 px) est donc impossible. Les tuiles font +par defaut 1000 m de cote, ce qui aligne le decoupage sur celui des dalles LiDAR +(meme grille kilometrique Lambert 93) et donne 2000 px par tuile a 50 cm — deux +fois moins que la limite, avec de la marge pour --res 0.2 (5000 px, juste sous +la limite). + +REPRISE : une tuile deja presente et lisible est sautee. Un telechargement +interrompu ne laisse pas de fichier tronque (ecriture dans un .part renomme +seulement une fois l'image validee par Pillow). + +Dependances : Pillow. + python -m pip install Pillow +""" + +from __future__ import annotations + +import argparse +import io +import os +import shutil +import struct +import sys +import time +import urllib.error +import urllib.parse +import urllib.request + +try: + from PIL import Image +except ImportError: + sys.exit("Pillow est requis : python -m pip install Pillow") + +WMS_URL = "https://data.geopf.fr/wms-r/wms" +LAYER = "HR.ORTHOIMAGERY.ORTHOPHOTOS" +USER_AGENT = "Vercora/0.11 (+projet de jeu personnel; habillage terrain)" +TIMEOUT = 120 +WMS_MAX_PIXELS = 5010 # annonce par GetCapabilities + +# Pillow refuse par defaut les images de plus de ~89 Mpx (garde anti-bombe). +# Nos tuiles restent tres en dessous, mais l'assemblage aval, lui, ne l'est pas : +# on releve la limite ici pour que les deux outils se comportent pareil. +Image.MAX_IMAGE_PIXELS = None + + +# --------------------------------------------------------------------------- +# Emprise +# --------------------------------------------------------------------------- +class Extent: + """Emprise Lambert 93 d'un terrain, lue dans l'en-tete .vchm.""" + + def __init__(self, path: str): + with open(path, "rb") as f: + head = f.read(120) + if len(head) < 120 or head[:4] != b"VCHM": + raise ValueError(f"{path} : ce n'est pas un fichier .vchm (magie absente).") + (_magic, version, samples_x, samples_z, spacing, _reserved, + origin_e, origin_n, self.min_h, self.max_h, + self.epsg, _flags) = struct.unpack_from("<4sIIIfIddffII", head, 0) + if version != 1: + raise ValueError(f"{path} : version {version} non geree (attendu 1).") + if self.epsg != 2154: + raise ValueError( + f"{path} : EPSG {self.epsg}. Seul le Lambert 93 (2154) est gere ; " + "un terrain synthetique (epsg 0) n'a pas d'emprise reelle a " + "photographier.") + self.label = head[56:120].split(b"\0")[0].decode("utf-8", "replace") + self.samples_x = samples_x + self.samples_z = samples_z + self.spacing = spacing + # Coin nord-ouest = noeud (0, 0). + self.east_min = origin_e + self.north_max = origin_n + self.east_max = origin_e + (samples_x - 1) * spacing + self.north_min = origin_n - (samples_z - 1) * spacing + + @property + def width_m(self) -> float: + return self.east_max - self.east_min + + @property + def height_m(self) -> float: + return self.north_max - self.north_min + + def describe(self) -> str: + return (f"{self.label} : {self.samples_x}x{self.samples_z} au pas de " + f"{self.spacing:g} m\n" + f" emprise Lambert 93 E {self.east_min:.0f} .. {self.east_max:.0f}" + f" N {self.north_min:.0f} .. {self.north_max:.0f}" + f" ({self.width_m:.0f} x {self.height_m:.0f} m)") + + +# --------------------------------------------------------------------------- +# WMS +# --------------------------------------------------------------------------- +def getmap_url(e0: float, n0: float, e1: float, n1: float, + width: int, height: int, fmt: str) -> str: + """URL GetMap. BBOX en ordre EST,NORD — verifie sur ce serveur, voir l'en-tete.""" + params = { + "SERVICE": "WMS", + "VERSION": "1.3.0", + "REQUEST": "GetMap", + "LAYERS": LAYER, + "STYLES": "", + "CRS": "EPSG:2154", + "BBOX": f"{e0:.3f},{n0:.3f},{e1:.3f},{n1:.3f}", + "WIDTH": str(width), + "HEIGHT": str(height), + "FORMAT": fmt, + } + return WMS_URL + "?" + urllib.parse.urlencode(params) + + +def http_get(url: str) -> bytes: + request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT}) + with urllib.request.urlopen(request, timeout=TIMEOUT) as response: + return response.read() + + +def self_test() -> bool: + """Re-verifie l'ordre des axes. Un serveur qui changerait d'avis se voit ici, + pas trois heures plus tard sur une texture en miroir.""" + e0, n0 = 899000.0, 6435000.0 + side = 512.0 + try: + good = Image.open(io.BytesIO(http_get( + getmap_url(e0, n0, e0 + side, n0 + side, 256, 256, "image/png")))).convert("RGB") + swapped = Image.open(io.BytesIO(http_get( + getmap_url(n0, e0, n0 + side, e0 + side, 256, 256, "image/png")))).convert("RGB") + except (urllib.error.URLError, OSError, ValueError) as error: + print(f" [self-test] injoignable ({error}) — controle non concluant.") + return False + + def is_blank(image) -> bool: + lo, hi = image.convert("L").getextrema() + return lo == hi + + if is_blank(good): + print(" [self-test] ECHEC : l'ordre EST,NORD renvoie une image uniforme.") + return False + if not is_blank(swapped): + print(" [self-test] AVERTISSEMENT : l'ordre NORD,EST renvoie aussi une " + "image non uniforme ; le controle ne discrimine plus.") + return False + print(" [self-test] ordre des axes EST,NORD confirme " + "(l'ordre inverse renvoie du blanc uniforme).") + return True + + +# --------------------------------------------------------------------------- +# Telechargement +# --------------------------------------------------------------------------- +def tile_name(e0: int, n0: int, px: int, ext: str) -> str: + return f"ortho_{e0:07d}_{n0:07d}_{px}px.{ext}" + + +def download_tile(url: str, destination: str, retries: int) -> tuple[bool, str]: + """Telecharge et VALIDE une tuile. L'ecriture passe par un .part : un fichier + final present est donc toujours une image complete et decodable.""" + partial = destination + ".part" + delay = 2.0 + for attempt in range(1, retries + 1): + try: + data = http_get(url) + if data[:1] == b"<": + # Le WMS signale ses erreurs par un ServiceExceptionReport XML + # renvoye avec un code 200 : sans ce test, on ecrirait le message + # d'erreur dans un fichier .jpg. + message = data[:300].decode("utf-8", "replace") + return False, f"reponse XML du service : {message}" + image = Image.open(io.BytesIO(data)) + image.verify() # leve si le flux est tronque + with open(partial, "wb") as f: + f.write(data) + os.replace(partial, destination) + return True, f"{len(data) / 1024.0:.0f} Ko" + except (urllib.error.URLError, OSError, ValueError, TimeoutError) as error: + if attempt == retries: + return False, f"{type(error).__name__}: {error}" + time.sleep(delay) + delay *= 2.0 + return False, "epuise" + + +def main() -> int: + parser = argparse.ArgumentParser( + description="Telecharge la BD ORTHO IGN sur l'emprise d'un terrain .vchm.") + parser.add_argument("terrain", help="fichier .vchm dont on reprend l'emprise") + parser.add_argument("-o", "--output", default="data/ortho", + help="repertoire des tuiles (defaut : data/ortho)") + parser.add_argument("--res", type=float, default=0.5, + help="resolution au sol en metres/pixel (defaut 0,5 ; " + "la source native est a 0,2)") + parser.add_argument("--tile-m", type=float, default=1000.0, + help="cote d'une tuile en metres (defaut 1000, soit la " + "grille kilometrique des dalles LiDAR)") + parser.add_argument("--format", default="jpeg", choices=("jpeg", "png"), + help="format demande au WMS (defaut jpeg : la BD ORTHO " + "est elle-meme une photo, le png ne restitue rien " + "de plus et pese 6 fois plus)") + parser.add_argument("--retries", type=int, default=4) + parser.add_argument("--dry-run", action="store_true", + help="affiche le plan et la place necessaire, sans rien ecrire") + parser.add_argument("--margin-go", type=float, default=2.0, + help="marge de disque libre exigee en plus du lot") + parser.add_argument("--no-self-test", action="store_true") + args = parser.parse_args() + + try: + extent = Extent(args.terrain) + except (OSError, ValueError) as error: + return int(bool(sys.stderr.write(f"{error}\n"))) or 2 + + print("BD ORTHO IGN — couche " + LAYER) + print(extent.describe()) + + if args.res <= 0: + sys.exit("--res doit etre strictement positif.") + + tile_px = int(round(args.tile_m / args.res)) + if tile_px > WMS_MAX_PIXELS: + sys.exit(f"--tile-m {args.tile_m:g} a --res {args.res:g} demande " + f"{tile_px} px par tuile, au-dela de la limite du service " + f"({WMS_MAX_PIXELS}). Reduire --tile-m.") + + cols = int(round(extent.width_m / args.tile_m)) + rows = int(round(extent.height_m / args.tile_m)) + if abs(cols * args.tile_m - extent.width_m) > 1e-6 or \ + abs(rows * args.tile_m - extent.height_m) > 1e-6: + sys.exit(f"L'emprise ({extent.width_m:g} x {extent.height_m:g} m) n'est pas " + f"un multiple entier de --tile-m {args.tile_m:g}. Choisir un cote " + "de tuile qui la divise, sinon les tuiles deborderaient ou " + "laisseraient une bande non couverte.") + + total_px = (cols * tile_px, rows * tile_px) + print(f" decoupage : {cols} x {rows} = {cols * rows} tuiles de {tile_px} px " + f"({args.tile_m:g} m a {args.res:g} m/px)") + print(f" mosaique complete : {total_px[0]} x {total_px[1]} px " + f"= {total_px[0] * total_px[1] / 1e6:.1f} Mpx") + + if not args.no_self_test and not args.dry_run: + self_test() + + # Estimation de place : une tuile de BD ORTHO en jpeg qualite service pese + # de l'ordre de 0,25 octet par pixel (mesure sur les premieres tuiles). On + # majore volontairement. + bytes_per_px = 0.5 if args.format == "jpeg" else 2.0 + estimate = total_px[0] * total_px[1] * bytes_per_px + print(f" place estimee : {estimate / 1e6:.0f} Mo (majoree)") + + if args.dry_run: + print("\n--dry-run : rien n'a ete ecrit.") + return 0 + + os.makedirs(args.output, exist_ok=True) + free = shutil.disk_usage(args.output).free + needed = estimate + args.margin_go * 1e9 + print(f" disque libre : {free / 1e9:.1f} Go " + f"(exige : {needed / 1e9:.1f} Go avec la marge)") + if free < needed: + sys.exit("Place insuffisante — telechargement non demarre.") + + ext = "jpg" if args.format == "jpeg" else "png" + todo = [] + skipped = 0 + for row in range(rows): + for col in range(cols): + e0 = extent.east_min + col * args.tile_m + n0 = extent.north_min + row * args.tile_m + destination = os.path.join(args.output, tile_name(int(e0), int(n0), tile_px, ext)) + if os.path.exists(destination) and os.path.getsize(destination) > 0: + skipped += 1 + continue + url = getmap_url(e0, n0, e0 + args.tile_m, n0 + args.tile_m, + tile_px, tile_px, "image/" + args.format) + todo.append((e0, n0, url, destination)) + + print(f"\n{len(todo)} tuile(s) a telecharger, {skipped} deja presente(s).") + if not todo: + print("Rien a faire.") + return 0 + + started = time.time() + failures = [] + written = 0 + for index, (e0, n0, url, destination) in enumerate(todo, 1): + label = f"E{int(e0)} N{int(n0)}" + print(f" [{index}/{len(todo)}] {label} ... ", end="", flush=True) + ok, message = download_tile(url, destination, args.retries) + if ok: + written += os.path.getsize(destination) + print(message) + else: + failures.append((label, message)) + print("ECHEC — " + message) + + elapsed = time.time() - started + print(f"\nTermine en {elapsed:.0f} s — {written / 1e6:.1f} Mo ecrits " + f"({written / 1e6 / max(elapsed, 1e-3):.1f} Mo/s).") + if failures: + print(f"{len(failures)} echec(s) :") + for label, message in failures: + print(f" {label} : {message}") + print("Relancer la meme commande : les tuiles deja recues sont sautees.") + return 1 + print(f"Couverture complete : {cols * rows} tuiles dans {args.output}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/find_climb_walls.py b/tools/find_climb_walls.py new file mode 100644 index 0000000..9dde062 --- /dev/null +++ b/tools/find_climb_walls.py @@ -0,0 +1,433 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +find_climb_walls.py — reperage des PAROIS grimpables dans une dalle .vchm. + + python tools/find_climb_walls.py assets/terrain/LHD_0903_6439_1m.vchm + python tools/find_climb_walls.py DALLE.vchm --half-base 2 --threshold 1.0 + +Pourquoi cet outil existe (Phase 14, escalade). + +Le seuil de pente a partir duquel une zone est une PAROI et non un versant raide +ne peut pas etre pose a priori : il faut savoir ce que le terrain reel contient +reellement. Le meme piege qu'en Phase 13 (velo) est present ici, en pire - un +DTM LiDAR a 1 m porte du bruit decimetrique, donc lire la pente sur une base +d'un metre fabrique des "parois" partout ou il n'y a qu'un caillou. La pente est +donc lue par differences finies CENTREES sur une demi-base reglable, exactement +comme world/Bike (BikeParams::slopeSampleStep), et la valeur par defaut est la +meme : 2 m, soit une base de 4 m. + +Ce que le script produit : + 1. la DISTRIBUTION des pentes de la dalle, qui dit si un seuil separe vraiment + deux populations ou s'il coupe au milieu d'un continuum ; + 2. les meilleures PAROIS CANDIDATES, c'est-a-dire les zones qui reunissent les + trois conditions qu'une paroi doit remplir pour etre jouable : + - pente soutenue au-dessus du seuil sur toute la zone (pas un pixel isole), + - denivele suffisant pour que grimper ait un sens, + - du terrain MARCHABLE au pied, sinon on ne peut pas y arriver. + 3. pour chaque candidate, les coordonnees Lambert 93 ET les coordonnees du + monde moteur (terrain centre sur l'origine, cf. Heightmap), donc directement + utilisables avec --start=est,nord. + +Le georeferencement est lu dans l'en-tete du fichier, jamais recopie a la main +(meme regle qu'en Phase 11 pour l'orthophoto). +""" + +from __future__ import annotations + +import argparse +import os +import struct +import sys + +import numpy as np + +HEADER_SIZE = 120 + + +def read_vchm(path): + """Relit un .vchm. Format identique a tools/check_terrain_file.py.""" + with open(path, "rb") as f: + header = f.read(HEADER_SIZE) + if len(header) != HEADER_SIZE or header[:4] != b"VCHM": + sys.exit(f"{path} n'est pas un fichier .vchm.") + (_magic, version, nx, nz, spacing, _reserved, + origin_e, origin_n, hmin, hmax, epsg, flags) = struct.unpack_from( + "<4sIIIfI dd ffII", header, 0) + label = header[56:120].split(b"\0", 1)[0].decode("ascii", "replace") + heights = np.frombuffer(f.read(), dtype=" 1e-6: + sys.exit(f"--half-base {half_base_m} m n'est pas un multiple du pas " + f"({cell} m) : on interpolerait, donc on lisserait deux fois.") + + base = 2.0 * step * cell + # np.roll ferait passer le bord oppose ; on travaille donc sur l'INTERIEUR et + # on marque le bord comme non evaluable (NaN), plutot que d'y inventer une + # pente. Une paroi collee au bord de dalle n'est de toute facon pas jouable. + dh_dx = np.full(grid.shape, np.nan) + dh_dz = np.full(grid.shape, np.nan) + dh_dx[:, step:-step] = (grid[:, 2 * step:] - grid[:, :-2 * step]) / base + dh_dz[step:-step, :] = (grid[2 * step:, :] - grid[:-2 * step, :]) / base + return np.hypot(dh_dx, dh_dz) + + +def describe_distribution(slope, threshold): + """La distribution des pentes, qui dit si le seuil separe deux populations.""" + valid = slope[np.isfinite(slope)] + print("\n--- Distribution des pentes de la dalle ---") + print(f" echantillons evaluables : {valid.size}") + for q in (50, 75, 90, 95, 99, 99.9): + v = np.percentile(valid, q) + print(f" p{q:<5} {100.0 * v:8.1f} % ({np.degrees(np.arctan(v)):5.1f} deg)") + print(f" max {100.0 * valid.max():8.1f} % " + f"({np.degrees(np.arctan(valid.max())):5.1f} deg)") + + print("\n Part de la dalle au-dessus de quelques seuils candidats :") + for t in (0.30, 0.50, 0.70, 1.00, 1.50, 2.00, 3.00): + share = 100.0 * float(np.count_nonzero(valid >= t)) / valid.size + mark = " <== seuil retenu" if abs(t - threshold) < 1e-9 else "" + print(f" >= {100.0 * t:6.0f} % ({np.degrees(np.arctan(t)):4.1f} deg) : " + f"{share:6.2f} % de la dalle{mark}") + + +def find_walls(m, slope, threshold, patch_m, walkable, min_relief, top_n, + min_foot=0.0, max_relief=1e9, rank_by="relief"): + """Cherche les meilleures parois candidates. + + Balayage par PATCHS carres de patch_m metres de cote, pas d'un demi-patch. + Un patch est retenu s'il reunit les trois conditions d'une paroi jouable : + + - couverture : une part dominante du patch depasse le seuil de pente. Un + seul pixel raide au milieu d'un pierrier n'est pas une paroi ; + - denivele : le patch monte d'au moins min_relief metres, sinon grimper + n'a pas de sens ; + - PIED MARCHABLE : il existe, dans l'anneau qui entoure le patch, du + terrain sous le seuil de marche. C'est la condition qu'on oublie et qui + rend une paroi injouable : une falaise dont le pied est lui-meme une + falaise ne s'atteint pas a pied. + """ + cell = m["spacing"] + nx, nz = m["nx"], m["nz"] + grid = m["grid"] + patch = max(2, int(round(patch_m / cell))) + stride = max(1, patch // 2) + + candidates = [] + for iz in range(0, nz - patch, stride): + for ix in range(0, nx - patch, stride): + sub = slope[iz:iz + patch, ix:ix + patch] + if not np.all(np.isfinite(sub)): + continue # touche le bord non evaluable + + covered = float(np.count_nonzero(sub >= threshold)) / sub.size + if covered < 0.80: + continue + + hsub = grid[iz:iz + patch, ix:ix + patch] + relief = float(hsub.max() - hsub.min()) + if relief < min_relief or relief > max_relief: + continue + + # Anneau de 10 m autour du patch : y a-t-il de quoi poser les pieds ? + pad = max(1, int(round(10.0 / cell))) + z0, z1 = max(0, iz - pad), min(nz, iz + patch + pad) + x0, x1 = max(0, ix - pad), min(nx, ix + patch + pad) + ring = slope[z0:z1, x0:x1] + ring_ok = np.isfinite(ring) & (ring <= walkable) + foot = float(np.count_nonzero(ring_ok)) / max(1, ring.size) + if foot <= min_foot: + continue + + candidates.append({ + "ix": ix, "iz": iz, "patch": patch, + "covered": covered, "relief": relief, "foot": foot, + "median_slope": float(np.median(sub)), + "hmin": float(hsub.min()), "hmax": float(hsub.max()), + }) + + # Classement. Deux criteres, et le choix n'est PAS cosmetique : + # - "relief" trouve les parois les plus spectaculaires. Sur ce massif elles + # sont toutes injouables : 250 m de haut et 0 % de pied marchable, on ne + # peut meme pas les atteindre a pied ; + # - "foot" trouve les parois qu'on peut REELLEMENT aborder. C'est ce qu'il + # faut pour poser un scenario de test, et c'est le classement qui a servi + # a choisir la paroi de reference de la Phase 14. + if rank_by == "foot": + candidates.sort(key=lambda c: (c["foot"], c["relief"]), reverse=True) + else: + candidates.sort(key=lambda c: (c["relief"], c["median_slope"]), reverse=True) + + # On evite de rendre dix fois la meme falaise : deux candidates dont les + # centres sont a moins d'un patch l'une de l'autre sont la meme paroi. + kept = [] + for c in candidates: + cx, cz = c["ix"] + c["patch"] / 2, c["iz"] + c["patch"] / 2 + if any(abs(cx - k["ix"] - k["patch"] / 2) < patch and + abs(cz - k["iz"] - k["patch"] / 2) < patch for k in kept): + continue + kept.append(c) + if len(kept) >= top_n: + break + return kept + + + +def find_routes(m, slope, threshold, walkable, top_n, min_rise, max_rise): + """Cherche des VOIES : un pied marchable, un cap, et de la paroi au-dessus. + + Pourquoi ce mode existe en plus de find_walls. find_walls repond a "ou y + a-t-il de la paroi ?", ce qui ne suffit pas a poser un scenario jouable : il + faut aussi savoir PAR OU on l'aborde. C'est la lecon de la Phase 13, ou le + scenario velo a echoue trois fois avant qu'on evalue la pente LE LONG DE + CHAQUE CAP - "faire demi-tour ne redonne pas la pente inverse", le terrain de + l'autre cote d'un point est un AUTRE terrain. + + Pour chaque point de depart marchable et chacun des 16 caps, on remonte le + terrain pas a pas et on mesure : + - la hauteur reellement gagnee avant que ca ne s'aplatisse, + - la part du trajet qui est au-dessus du seuil de paroi. + Une bonne voie monte franchement ET est majoritairement de la paroi ; un + simple versant raide monte aussi, mais sans jamais depasser le seuil. + """ + cell = m["spacing"] + nx, nz = m["nx"], m["nz"] + grid = m["grid"] + half = 0.5 * (nx - 1) * cell + + def h_at(wx, wz): + ix = int(round((wx + half) / cell)) + iz = int(round((wz + half) / cell)) + return grid[min(max(iz, 0), nz - 1), min(max(ix, 0), nx - 1)] + + def slope_at(wx, wz): + ix = int(round((wx + half) / cell)) + iz = int(round((wz + half) / cell)) + v = slope[min(max(iz, 0), nz - 1), min(max(ix, 0), nx - 1)] + return v if np.isfinite(v) else 0.0 + + headings = [i * 22.5 for i in range(16)] + routes = [] + # Pas de 10 m sur la grille des departs : on cherche un point de depart, pas + # a cartographier la dalle au metre pres. + span = int(0.5 * (nx - 1) * cell) - 60 + for wz in range(-span, span, 10): + for wx in range(-span, span, 10): + if slope_at(wx, wz) > walkable: + continue # on ne part que de terrain ou l'on tient debout + for heading in headings: + rad = np.radians(heading) + dx, dz = np.cos(rad), np.sin(rad) + x, z = float(wx), float(wz) + y0 = h_at(x, z) + wall_steps = 0 + steps = 0 + # On avance de 1 m tant que ca monte ; des que ca redescend ou + # que ca s'aplatit durablement, la voie est finie. + flat_run = 0 + while steps < 120: + x += dx + z += dz + steps += 1 + if slope_at(x, z) >= threshold: + wall_steps += 1 + flat_run = 0 + else: + flat_run += 1 + if flat_run > 6: + break + if h_at(x, z) < y0: + break + rise = h_at(x, z) - y0 + if rise < min_rise or rise > max_rise: + continue + wall_share = wall_steps / max(1, steps) + if wall_share < 0.60: + continue + routes.append({ + "wx": wx, "wz": wz, "heading": heading, "rise": rise, + "wall_share": wall_share, "steps": steps, + "y0": y0, "y1": h_at(x, z), + }) + + routes.sort(key=lambda r: (r["wall_share"], r["rise"]), reverse=True) + kept = [] + for r in routes: + if any(abs(r["wx"] - k["wx"]) < 40 and abs(r["wz"] - k["wz"]) < 40 for k in kept): + continue + kept.append(r) + if len(kept) >= top_n: + break + + print() + print("--- Voies d'escalade (pied marchable + paroi au-dessus) ---") + if not kept: + print(" Aucune.") + return + for rank, r in enumerate(kept, 1): + east = m["origin_e"] + (r["wx"] + half) + north = m["origin_n"] - (r["wz"] + half) + print() + print(f" #{rank} depart monde x {r['wx']:+7.1f} z {r['wz']:+7.1f} " + f"(E {east:.0f} N {north:.0f})") + print(f" cap {r['heading']:5.1f} deg, {r['rise']:.1f} m gagnes sur " + f"{r['steps']} m de trajet") + print(f" {100.0 * r['wall_share']:.0f} % du trajet est au-dessus du " + f"seuil de paroi") + print(f" altitudes {r['y0']:.1f} -> {r['y1']:.1f} m, pente au depart " + f"{100.0 * slope_at(r['wx'], r['wz']):.0f} %") + + +def report_walls(m, kept, threshold, walkable): + cell = m["spacing"] + nx, nz = m["nx"], m["nz"] + half = 0.5 * (nx - 1) * cell + + print(f"\n--- Parois candidates (seuil {100.0 * threshold:.0f} %, " + f"marchable <= {100.0 * walkable:.0f} %) ---") + if not kept: + print(" Aucune. Assouplir --threshold, --patch ou --min-relief.") + return + + for rank, c in enumerate(kept, 1): + cx = c["ix"] + c["patch"] / 2.0 + cz = c["iz"] + c["patch"] / 2.0 + # Lambert 93 : ix croissant vers l'est, iz croissant vers le SUD. + east = m["origin_e"] + cx * cell + north = m["origin_n"] - cz * cell + # Monde moteur : terrain centre sur l'origine (cf. Heightmap). + wx = cx * cell - half + wz = cz * cell - half + print(f"\n #{rank} E {east:9.1f} N {north:10.1f} " + f"(monde moteur x {wx:+8.1f} z {wz:+8.1f})") + print(f" pente mediane {100.0 * c['median_slope']:7.1f} % " + f"({np.degrees(np.arctan(c['median_slope'])):.1f} deg), " + f"{100.0 * c['covered']:.0f} % du patch au-dessus du seuil") + print(f" altitudes {c['hmin']:.1f} .. {c['hmax']:.1f} m " + f"=> {c['relief']:.1f} m de denivele sur " + f"{c['patch'] * cell:.0f} m de cote") + print(f" pied marchable : {100.0 * c['foot']:.0f} % de l'anneau " + f"a 10 m est sous {100.0 * walkable:.0f} % de pente") + + +def profile_at(m, slope, east, north, half_base_m): + """Detail d'un point precis, en Lambert 93. Sert a verifier une coordonnee + citee dans les notes plutot qu'a la croire sur parole.""" + cell = m["spacing"] + ix = int(round((east - m["origin_e"]) / cell)) + iz = int(round((m["origin_n"] - north) / cell)) + if not (0 <= ix < m["nx"] and 0 <= iz < m["nz"]): + print(f"\n--- Sonde E {east} N {north} : HORS de cette dalle ---") + return + + print(f"\n--- Sonde E {east:.0f} N {north:.0f} " + f"(ix {ix}, iz {iz}, base {2 * half_base_m:.0f} m) ---") + print(f" altitude {m['grid'][iz, ix]:.2f} m") + s = slope[iz, ix] + if np.isfinite(s): + print(f" pente locale {100.0 * s:.1f} % " + f"({np.degrees(np.arctan(s)):.1f} deg)") + # Voisinage de 40 m : une paroi se juge sur son emprise, pas sur un point. + pad = int(round(20.0 / cell)) + z0, z1 = max(0, iz - pad), min(m["nz"], iz + pad + 1) + x0, x1 = max(0, ix - pad), min(m["nx"], ix + pad + 1) + sub = slope[z0:z1, x0:x1] + hsub = m["grid"][z0:z1, x0:x1] + valid = sub[np.isfinite(sub)] + if valid.size: + print(f" voisinage 40 x 40 m : pente mediane {100.0 * np.median(valid):.1f} %, " + f"max {100.0 * valid.max():.1f} %") + print(f" altitudes {hsub.min():.1f} .. {hsub.max():.1f} m " + f"({hsub.max() - hsub.min():.1f} m de denivele)") + + +def main(): + p = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument("vchm", help="dalle ou terrain assemble .vchm") + p.add_argument("--half-base", type=float, default=2.0, + help="demi-base des differences centrees, en m (defaut 2, " + "comme BikeParams::slopeSampleStep)") + p.add_argument("--threshold", type=float, default=1.00, + help="seuil de PAROI en rise/run (defaut 1.00 = 45 deg)") + p.add_argument("--walkable", type=float, default=0.60, + help="pente au-dessus de laquelle on ne marche plus " + "(defaut 0.60 = 31 deg), pour juger le pied de paroi") + p.add_argument("--patch", type=float, default=20.0, + help="cote du patch analyse, en m (defaut 20)") + p.add_argument("--min-relief", type=float, default=15.0, + help="denivele minimal d'un patch pour etre une paroi (m)") + p.add_argument("--top", type=int, default=5, help="nombre de candidates") + p.add_argument("--min-foot", type=float, default=0.0, + help="part MINIMALE de l'anneau qui doit etre marchable, dans " + "[0, 1]. C'est le filtre de REACHABILITE : sans lui on ne " + "trouve que des falaises qu'on ne peut pas aborder a pied.") + p.add_argument("--max-relief", type=float, default=1e9, + help="denivele MAXIMAL d'un patch, en m. Une paroi de 250 m ne " + "se grimpe pas avec une jauge d'energie de premiere session.") + p.add_argument("--rank", choices=("relief", "foot"), default="relief", + help="critere de classement (defaut relief ; 'foot' privilegie " + "les parois reellement abordables)") + p.add_argument("--probe", nargs=2, type=float, metavar=("EST", "NORD"), + help="detaille un point Lambert 93 precis") + p.add_argument("--routes", action="store_true", + help="cherche des VOIES (pied marchable + cap + paroi au-dessus) " + "au lieu de simples zones de paroi. C'est ce mode qui donne " + "un point de depart jouable.") + args = p.parse_args() + + m = read_vchm(args.vchm) + print(f"Fichier : {os.path.basename(args.vchm)}") + print(f" label : {m['label']}") + print(f" {m['nx']} x {m['nz']} echantillons, pas {m['spacing']} m, EPSG:{m['epsg']}") + print(f" origine (coin nord-ouest) : E {m['origin_e']:.1f} N {m['origin_n']:.1f}") + print(f" altitudes {m['grid'].min():.1f} .. {m['grid'].max():.1f} m") + + slope = slope_field(m["grid"], m["spacing"], args.half_base) + print(f"\n Pente lue par differences centrees sur une base de " + f"{2 * args.half_base:.0f} m.") + + describe_distribution(slope, args.threshold) + + if args.probe: + profile_at(m, slope, args.probe[0], args.probe[1], args.half_base) + + if args.routes: + find_routes(m, slope, args.threshold, args.walkable, args.top, + args.min_relief, args.max_relief) + return + + kept = find_walls(m, slope, args.threshold, args.patch, args.walkable, + args.min_relief, args.top, args.min_foot, args.max_relief, + args.rank) + report_walls(m, kept, args.threshold, args.walkable) + + +if __name__ == "__main__": + main() diff --git a/tools/gen_test_meshes.ps1 b/tools/gen_test_meshes.ps1 new file mode 100644 index 0000000..befd72e --- /dev/null +++ b/tools/gen_test_meshes.ps1 @@ -0,0 +1,185 @@ +# --------------------------------------------------------------------------- +# Generateur d'assets .obj de test pour la Phase 3 (loader de mesh). +# +# Produit deux fichiers dans assets/ , volontairement minuscules (quelques Ko) : +# +# icosphere.obj - icosphere subdivisee 1 fois : 42 sommets / 80 triangles, +# normales LISSES (normale = position normalisee) + UV +# spheriques. Teste le cas "beaucoup de faces, normales et +# UV presents, indices v/vt/vn identiques". +# +# octahedron.obj - octaedre a facettes PLATES : 6 positions seulement mais 8 +# normales distinctes. Chaque position est donc reutilisee +# par plusieurs faces avec des normales differentes -> teste +# la deduplication du loader sur le triplet (v, vt, vn), +# cas que l'icosphere ne couvre pas. +# +# Usage : powershell -ExecutionPolicy Bypass -File tools\gen_test_meshes.ps1 +# --------------------------------------------------------------------------- + +$ErrorActionPreference = 'Stop' + +$assetsDir = Join-Path (Split-Path -Parent $PSScriptRoot) 'assets' +if (-not (Test-Path $assetsDir)) { + New-Item -ItemType Directory -Path $assetsDir | Out-Null +} + +# Culture invariante : sur une machine en locale FR, "{0:F6}" produirait des +# virgules decimales, illisibles pour un parseur .obj. +$inv = [System.Globalization.CultureInfo]::InvariantCulture +function Fmt([double]$v) { return $v.ToString('F6', $inv) } + +function Write-ObjFile([string]$path, [string[]]$lines) { + # UTF8 sans BOM : un BOM en tete de fichier n'est pas garanti d'etre tolere + # par tous les parseurs .obj. + $enc = New-Object System.Text.UTF8Encoding($false) + [System.IO.File]::WriteAllLines($path, $lines, $enc) + Write-Host ("Ecrit : {0} ({1} lignes)" -f $path, $lines.Count) +} + +# --------------------------------------------------------------------------- +# 1. Icosphere (icosaedre + 1 subdivision, projetee sur la sphere unite) +# --------------------------------------------------------------------------- +$positions = New-Object System.Collections.ArrayList +$midCache = @{} # cle "i_j" -> index du milieu deja cree + +function Add-Normalized([double]$x, [double]$y, [double]$z) { + $len = [math]::Sqrt($x * $x + $y * $y + $z * $z) + # Parentheses obligatoires autour de chaque element : dans un @(...), la + # virgule de PowerShell est PLUS prioritaire que les operateurs arithmetiques, + # donc "@($x / $len, $y / $len)" se lirait "$x / ($len, $y) / $len". + [void]$positions.Add(@(($x / $len), ($y / $len), ($z / $len))) + return $positions.Count - 1 +} + +# Milieu de l'arete (a,b), projete sur la sphere. Mis en cache pour que les +# deux triangles partageant l'arete reutilisent le meme sommet (mesh soude). +function Get-Midpoint([int]$a, [int]$b) { + $key = if ($a -lt $b) { "$($a)_$($b)" } else { "$($b)_$($a)" } + if ($midCache.ContainsKey($key)) { return $midCache[$key] } + + $pa = $positions[$a] + $pb = $positions[$b] + $idx = Add-Normalized (($pa[0] + $pb[0]) / 2) (($pa[1] + $pb[1]) / 2) (($pa[2] + $pb[2]) / 2) + $midCache[$key] = $idx + return $idx +} + +# Nombre d'or : les 12 sommets de l'icosaedre sont 3 rectangles d'or orthogonaux. +$t = (1.0 + [math]::Sqrt(5.0)) / 2.0 + +$icoVerts = @( + @(-1, $t, 0), @( 1, $t, 0), @(-1, -$t, 0), @( 1, -$t, 0), + @( 0, -1, $t), @( 0, 1, $t), @( 0, -1, -$t), @( 0, 1, -$t), + @( $t, 0, -1), @( $t, 0, 1), @(-$t, 0, -1), @(-$t, 0, 1) +) +foreach ($v in $icoVerts) { + # Variables intermediaires : "[double]$v[0]" se lit "([double]$v)[0]" en + # PowerShell, ce qui casserait le cast. + $vx = [double]$v[0] + $vy = [double]$v[1] + $vz = [double]$v[2] + [void](Add-Normalized $vx $vy $vz) +} + +# 20 faces de l'icosaedre, enroulement anti-horaire vu de l'exterieur. +$faces = @( + @(0, 11, 5), @(0, 5, 1), @(0, 1, 7), @(0, 7, 10), @(0, 10, 11), + @(1, 5, 9), @(5, 11, 4), @(11, 10, 2), @(10, 7, 6), @(7, 1, 8), + @(3, 9, 4), @(3, 4, 2), @(3, 2, 6), @(3, 6, 8), @(3, 8, 9), + @(4, 9, 5), @(2, 4, 11), @(6, 2, 10), @(8, 6, 7), @(9, 8, 1) +) + +# Une passe de subdivision : chaque triangle -> 4 triangles. +$subdivided = New-Object System.Collections.ArrayList +foreach ($f in $faces) { + $a = Get-Midpoint $f[0] $f[1] + $b = Get-Midpoint $f[1] $f[2] + $c = Get-Midpoint $f[2] $f[0] + [void]$subdivided.Add(@($f[0], $a, $c)) + [void]$subdivided.Add(@($f[1], $b, $a)) + [void]$subdivided.Add(@($f[2], $c, $b)) + [void]$subdivided.Add(@($a, $b, $c)) +} + +$lines = New-Object System.Collections.ArrayList +[void]$lines.Add('# Vercora - asset de test Phase 3 : icosphere (1 subdivision)') +[void]$lines.Add(('# {0} sommets, {1} triangles, normales lissees + UV spheriques' -f $positions.Count, $subdivided.Count)) +[void]$lines.Add('# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main') +[void]$lines.Add('o Icosphere') + +# Note : la chaine est construite dans une variable avant l'appel a .Add(). +# Dans les parentheses d'un appel de methode .NET, la virgule separe les +# ARGUMENTS de la methode : ecrire .Add('{0} {1}' -f $a, $b) appellerait +# Add() avec 2 arguments au lieu de formater 2 valeurs. +foreach ($p in $positions) { + $line = 'v {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2]) + [void]$lines.Add($line) +} +# Sphere unite centree sur l'origine : la normale d'un sommet EST sa position. +foreach ($p in $positions) { + $line = 'vn {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2]) + [void]$lines.Add($line) +} +# Mapping equirectangulaire (longitude/latitude). Pas encore utilise par le +# shader, mais present pour verifier que le loader lit bien les UV. +foreach ($p in $positions) { + $u = 0.5 + [math]::Atan2($p[2], $p[0]) / (2.0 * [math]::PI) + $vv = 0.5 - [math]::Asin([math]::Max(-1.0, [math]::Min(1.0, $p[1]))) / [math]::PI + $line = 'vt {0} {1}' -f (Fmt $u), (Fmt $vv) + [void]$lines.Add($line) +} +foreach ($f in $subdivided) { + $i = $f[0] + 1; $j = $f[1] + 1; $k = $f[2] + 1 + [void]$lines.Add("f $i/$i/$i $j/$j/$j $k/$k/$k") +} + +Write-ObjFile (Join-Path $assetsDir 'icosphere.obj') $lines.ToArray() + +# --------------------------------------------------------------------------- +# 2. Octaedre a facettes plates +# --------------------------------------------------------------------------- +# 6 positions (les pointes sur les axes), 8 faces triangulaires. La normale de +# chaque face est (+/-1, +/-1, +/-1) normalisee : les 3 sommets d'une face +# partagent SA normale, et chaque position apparait dans 4 faces avec 4 +# normales differentes. +$octPos = @( + @( 1, 0, 0), @(-1, 0, 0), # 1, 2 : +X, -X + @( 0, 1, 0), @( 0,-1, 0), # 3, 4 : +Y, -Y + @( 0, 0, 1), @( 0, 0,-1) # 5, 6 : +Z, -Z +) +# Chaque face : les 3 positions (indices .obj 1-based) + le signe de sa normale. +$octFaces = @( + @(1, 3, 5, 1, 1, 1), @(3, 2, 5, -1, 1, 1), + @(2, 4, 5, -1, -1, 1), @(4, 1, 5, 1, -1, 1), + @(3, 1, 6, 1, 1, -1), @(2, 3, 6, -1, 1, -1), + @(4, 2, 6, -1, -1, -1), @(1, 4, 6, 1, -1, -1) +) + +$lines = New-Object System.Collections.ArrayList +[void]$lines.Add('# Vercora - asset de test Phase 3 : octaedre a facettes plates') +[void]$lines.Add('# 6 positions / 8 normales distinctes / 8 triangles') +[void]$lines.Add('# Chaque position est reutilisee avec plusieurs normales : teste la') +[void]$lines.Add('# deduplication du loader sur le triplet (position, uv, normale).') +[void]$lines.Add('# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main') +[void]$lines.Add('o OctahedronFlat') + +foreach ($p in $octPos) { + $line = 'v {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2]) + [void]$lines.Add($line) +} +$invSqrt3 = 1.0 / [math]::Sqrt(3.0) +foreach ($f in $octFaces) { + $line = 'vn {0} {1} {2}' -f (Fmt ($f[3] * $invSqrt3)), (Fmt ($f[4] * $invSqrt3)), (Fmt ($f[5] * $invSqrt3)) + [void]$lines.Add($line) +} +# Pas de 'vt' ici : verifie aussi que le loader accepte un .obj SANS UV +# (format "f v//vn"). +$n = 0 +foreach ($f in $octFaces) { + $n++ + $line = 'f {0}//{3} {1}//{3} {2}//{3}' -f $f[0], $f[1], $f[2], $n + [void]$lines.Add($line) +} + +Write-ObjFile (Join-Path $assetsDir 'octahedron.obj') $lines.ToArray() diff --git a/tools/launch_demo.ps1 b/tools/launch_demo.ps1 new file mode 100644 index 0000000..f3af412 --- /dev/null +++ b/tools/launch_demo.ps1 @@ -0,0 +1,12 @@ +# Script pour lancer Vercora et amener la fenetre au premier plan +$buildDir = "$PSScriptRoot\..\build" +$exePath = "$buildDir\vercora.exe" + +# Arreter toute instance preexistante +Get-Process -Name vercora -ErrorAction SilentlyContinue | Stop-Process -Force +Start-Sleep -Milliseconds 300 + +# Demarrer le processus +$p = Start-Process -FilePath $exePath -ArgumentList "--demo" -WorkingDirectory "$PSScriptRoot\.." -PassThru + +Write-Host "Vercora lance avec le PID $($p.Id)" diff --git a/tools/lidar_to_canopy.py b/tools/lidar_to_canopy.py new file mode 100644 index 0000000..ba4b98b --- /dev/null +++ b/tools/lidar_to_canopy.py @@ -0,0 +1,231 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +lidar_to_canopy.py — extrait des dalles LiDAR HD une CARTE DE COUVERT FORESTIER. + +PHASE 11, tache 2. Jusqu'ici les arbres etaient semes par tirage-rejet uniforme +(pente + espacement) sur une zone de test de quelques dizaines de metres. A +l'echelle des 25 km2 reels, semer uniformement donnerait des arbres sur les +lapiaz, sur les eboulis et au milieu des pistes de ski — c'est-a-dire un paysage +faux, alors que la donnee qui dit ou sont VRAIMENT les arbres est deja sur le +disque : les nuages LiDAR sont CLASSIFIES. + + python tools/lidar_to_canopy.py data/lidar -o assets/terrain/vercora_zone_canopy.vchm \\ + --extent assets/terrain/vercora_zone_1m.vchm + +CE QUE DIT LA CLASSIFICATION (norme ASPRS, verifie sur ces dalles) : + 2 = sol ~90 % 3 = vegetation basse ~1,9 % + 4 = vegetation moyenne ~0,7 % 5 = vegetation haute ~4,7 % + 1 = non classe ~2,8 % 6 = bati, 64 = bruit + +DEUX GRANDEURS SONT PRODUITES, dans deux fichiers : + - le COUVERT (--out) : part des retours de vegetation (classes 3, 4 et 5) parmi + tous les retours valides de la cellule. C'est une fraction entre 0 et 1, donc + insensible a la densite de vol, contrairement a un simple comptage. + - la HAUTEUR DE CANOPEE (--out-height) : altitude du plus haut retour de classe + 5 moins l'altitude du plus bas retour de sol, dans la meme cellule. C'est la + hauteur du plus grand arbre de la cellule, en metres. +Le jeu se sert du premier pour savoir OU semer, du second pour savoir QUELLE +TAILLE donner aux arbres — deux questions distinctes que la meme carte ne peut +pas trancher. + +LE MAXIMUM PLUTOT QU'UN PERCENTILE. Un percentile de hauteur demanderait de +conserver tous les points d'une cellule ; le maximum se calcule en un seul +passage, sans rien stocker. Sur des cellules de 5 m il designe le plus grand +arbre de la cellule, ce qui est exactement la grandeur voulue. Contrepartie +assumee : un point aberrant non filtre (classe 64) gonflerait la valeur, d'ou +l'exclusion explicite du bruit et l'ecretage a --max-height. + +FORMAT DE SORTIE : le meme .vchm que le terrain (voir tools/lidar_to_heightmap.py). +C'est volontaire et ce n'est pas un abus : un .vchm est une GRILLE DE FLOTTANTS +GEOREFERENCEE, et 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 obtient gratuitement l'interpolation bilineaire de heightAt() et la +conversion monde <-> Lambert 93. La grille produite a EXACTEMENT la meme origine +et la meme emprise que le terrain, seul son pas differe : un point du monde s'y +lit donc avec la meme formule, sans decalage a corriger. + +Dependances : laspy + lazrs + numpy. +""" + +from __future__ import annotations + +import argparse +import glob +import os +import re +import struct +import sys +import time + +try: + import numpy as np + import laspy +except ImportError: + sys.exit('laspy et numpy sont requis : python -m pip install "laspy[lazrs]" numpy') + +HEADER_SIZE = 120 +CHUNK = 4_000_000 + +CLASS_GROUND = 2 +CLASSES_VEGETATION = (3, 4, 5) +CLASS_HIGH_VEGETATION = 5 +# Classes a EXCLURE du denominateur : ce ne sont pas des retours de surface. +CLASSES_REJECTED = (7, 18, 64, 65, 66) + + +def read_extent(path: str): + """(originEast, originNorth, samples, spacing) d'un .vchm de reference.""" + with open(path, "rb") as f: + head = f.read(HEADER_SIZE) + if len(head) < HEADER_SIZE or head[:4] != b"VCHM": + sys.exit(f"{path} n'est pas un fichier .vchm.") + _m, _v, sx, sz, spacing, _r, origin_e, origin_n = struct.unpack_from("<4sIIIfIdd", head, 0) + if sx != sz: + sys.exit(f"{path} : grille non carree ({sx}x{sz}), non gere.") + return origin_e, origin_n, sx, spacing + + +def write_vchm(path: str, grid: np.ndarray, spacing: float, + origin_e: float, origin_n: float, label: str) -> None: + samples = grid.shape[0] + header = bytearray(HEADER_SIZE) + struct.pack_into("<4sIIIfI", header, 0, b"VCHM", 1, samples, samples, spacing, 0) + struct.pack_into(" int: + parser = argparse.ArgumentParser( + description="Carte de couvert forestier et de hauteur de canopee depuis le LiDAR.") + parser.add_argument("lidar_dir", help="repertoire des dalles .copc.laz") + parser.add_argument("--extent", required=True, + help="terrain .vchm dont on reprend origine et emprise") + parser.add_argument("-o", "--out", required=True, help=".vchm de couvert (0..1)") + parser.add_argument("--out-height", default=None, + help=".vchm de hauteur de canopee (m). Par defaut, " + "le nom de --out avec _height avant l'extension.") + parser.add_argument("--cell", type=float, default=5.0, + help="pas de la grille produite, en metres (defaut 5)") + parser.add_argument("--max-height", type=float, default=45.0, + help="ecretage de la hauteur de canopee (defaut 45 m)") + args = parser.parse_args() + + origin_e, origin_n, terrain_samples, terrain_spacing = read_extent(args.extent) + span = (terrain_samples - 1) * terrain_spacing + if abs(span / args.cell - round(span / args.cell)) > 1e-9: + sys.exit(f"L'emprise ({span:g} m) n'est pas un multiple de --cell {args.cell:g}.") + + samples = int(round(span / args.cell)) + 1 + east_max = origin_e + span + north_min = origin_n - span + print(f"Reference : {args.extent}") + print(f" emprise E {origin_e:.0f}..{east_max:.0f} N {north_min:.0f}..{origin_n:.0f}") + print(f" grille produite : {samples}x{samples} au pas de {args.cell:g} m") + + # Un accumulateur par grandeur. Les noeuds sont les CENTRES des cellules + # d'agregation : c'est ce qui permet a la grille produite d'avoir exactement + # la meme origine et la meme emprise que le terrain, donc de se lire avec la + # meme formule monde <-> grille, sans demi-cellule a corriger quelque part. + total_count = np.zeros((samples, samples), dtype=np.int32) + veg_count = np.zeros((samples, samples), dtype=np.int32) + high_max = np.full((samples, samples), -np.inf, dtype=np.float32) + ground_min = np.full((samples, samples), np.inf, dtype=np.float32) + + tiles = sorted(glob.glob(os.path.join(args.lidar_dir, "*.laz"))) + if not tiles: + sys.exit(f"Aucune dalle .laz dans {args.lidar_dir}.") + print(f"\n{len(tiles)} dalle(s) a depouiller.") + + started = time.time() + for index, path in enumerate(tiles, 1): + name = os.path.basename(path) + tile_started = time.time() + kept = 0 + with laspy.open(path) as reader: + for chunk in reader.chunk_iterator(CHUNK): + cls = np.asarray(chunk.classification) + valid = ~np.isin(cls, CLASSES_REJECTED) + if not valid.any(): + continue + cls = cls[valid] + x = np.asarray(chunk.x)[valid] + y = np.asarray(chunk.y)[valid] + z = np.asarray(chunk.z)[valid].astype(np.float32) + + # Indices de noeud : ARRONDI (et non partie entiere), puisque le + # noeud est le centre de sa cellule. iz croit vers le SUD, comme + # dans le .vchm du terrain. + ix = np.rint((x - origin_e) / args.cell).astype(np.int64) + iz = np.rint((origin_n - y) / args.cell).astype(np.int64) + inside = (ix >= 0) & (ix < samples) & (iz >= 0) & (iz < samples) + if not inside.any(): + continue + ix, iz, cls, z = ix[inside], iz[inside], cls[inside], z[inside] + flat = iz * samples + ix + kept += flat.size + + np.add.at(total_count.reshape(-1), flat, 1) + + veg = np.isin(cls, CLASSES_VEGETATION) + if veg.any(): + np.add.at(veg_count.reshape(-1), flat[veg], 1) + + high = cls == CLASS_HIGH_VEGETATION + if high.any(): + np.maximum.at(high_max.reshape(-1), flat[high], z[high]) + + ground = cls == CLASS_GROUND + if ground.any(): + np.minimum.at(ground_min.reshape(-1), flat[ground], z[ground]) + + print(f" [{index}/{len(tiles)}] {name} : {kept:,} points retenus " + f"en {time.time() - tile_started:.1f} s") + + # --- Couvert ------------------------------------------------------------ + # Une cellule sans aucun retour (hors emprise du vol, ou trou de donnees) + # reste a zero : mieux vaut ne pas y semer d'arbre que d'en inventer. + cover = np.zeros((samples, samples), dtype=np.float32) + seen = total_count > 0 + cover[seen] = veg_count[seen].astype(np.float32) / total_count[seen] + + # --- Hauteur de canopee ------------------------------------------------- + height = np.zeros((samples, samples), dtype=np.float32) + usable = np.isfinite(high_max) & np.isfinite(ground_min) + height[usable] = high_max[usable] - ground_min[usable] + np.clip(height, 0.0, args.max_height, out=height) + + out_height = args.out_height + if out_height is None: + stem, extension = os.path.splitext(args.out) + out_height = stem + "_height" + extension + + for path, grid, label in ((args.out, cover, "couvert_vegetal"), + (out_height, height, "hauteur_canopee")): + os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True) + write_vchm(path, grid, args.cell, origin_e, origin_n, label) + + covered = float((cover > 0.15).mean()) + wooded = float((height >= 3.0).mean()) + print(f"\nEcrit : {args.out}") + print(f" couvert : moyenne {cover.mean():.3f}, max {cover.max():.3f} ; " + f"{100 * covered:.1f} % des cellules au-dessus de 0,15") + print(f"Ecrit : {out_height}") + print(f" canopee : moyenne des cellules boisees " + f"{height[height >= 3.0].mean() if wooded else 0:.1f} m, " + f"max {height.max():.1f} m ; {100 * wooded:.1f} % de cellules a 3 m ou plus") + print(f" cellules sans aucun retour : {100 * float((~seen).mean()):.2f} %") + print(f" en {time.time() - started:.0f} s") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/lidar_to_heightmap.py b/tools/lidar_to_heightmap.py new file mode 100644 index 0000000..bb881b4 --- /dev/null +++ b/tools/lidar_to_heightmap.py @@ -0,0 +1,530 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +lidar_to_heightmap.py — dalle LiDAR HD IGN (.laz / .copc.laz) -> heightmap .vchm + +PHASE 7. Premier maillon reel du pipeline : remplace le bruit procedural de la +Phase 4 par du terrain mesure. L'outil est VOLONTAIREMENT SEPARE du moteur — il +tourne une fois, hors ligne, et le jeu ne lit qu'une grille de float deja propre. +Mettre un decodeur LAZ dans le moteur aurait ajoute une dependance lourde pour +un travail qui n'a aucune raison d'etre refait a chaque lancement. + + python tools/lidar_to_heightmap.py ENTREE.copc.laz -o SORTIE.vchm [options] + +Exemple reel (celui de la Phase 7) : + + 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 utiles : + --cell N taille de cellule en metres (defaut 1.0) + --stat S median (defaut) | mean | min — agregation des points d'un noeud + --classes L classes LAS retenues (defaut 2 = sol) + --no-despike desactive le filtre de pics + --zero-base ramene l'altitude minimale a 0 au lieu de garder l'IGN69 + --report-only analyse et statistiques, sans ecrire de fichier + +Dependances : laspy + lazrs + numpy + python -m pip install "laspy[lazrs]" numpy + +Pourquoi laspy/lazrs et pas 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.x avec le backend lazrs (l'implementation Rust de LASzip) lit exactement +le meme LAZ 1.4 classifie, s'installe en une commande par pip, et tout le travail +qu'on lui demanderait ici — filtrer une classe, binner sur une grille, agreger — +est de toute facon du numpy. Le jour ou PDAL serait disponible, il produirait la +meme grille : le format .vchm ci-dessous ne depend pas du lecteur. + + +FORMAT DE SORTIE .vchm ("Vercora HeightMap"), petit-boutiste, en-tete de 120 +octets suivi des altitudes : + + offset taille champ + 0 4 magie "VCHM" + 4 4 uint32 version = 1 + 8 4 uint32 samplesX (echantillons d'ouest en est) + 12 4 uint32 samplesZ (echantillons du nord vers le sud) + 16 4 float32 spacing (metres entre deux echantillons voisins) + 20 4 uint32 reserve = 0 + 24 8 float64 originEast coordonnee X (Lambert 93) de l'echantillon ix=0 + 32 8 float64 originNorth coordonnee Y (Lambert 93) de l'echantillon iz=0 + 40 4 float32 minHeight + 44 4 float32 maxHeight + 48 4 uint32 crsEpsg (2154 pour le Lambert 93) + 52 4 uint32 flags bit 0 : les altitudes sont absolues (IGN69) + 56 64 char[64] label nom de la dalle, complete par des zeros + 120 ... float32 heights[samplesZ * samplesX], index = iz * samplesX + ix + +SENS DES AXES — le point delicat, et la raison pour laquelle les lignes sont +stockees du NORD vers le SUD. Le moteur est en repere main droite avec Y vers le +haut, donc X ^ Y = Z. En posant X = Est et Y = Haut, on obtient +Z = Est ^ Haut = -Nord : le nord est en -Z. Ecrire les lignes du nord vers le sud +fait donc correspondre iz croissant a Z croissant, et le terrain s'affiche dans +le bon sens. Stocker du sud vers le nord donnerait un relief en MIROIR — une +erreur invisible sur du bruit procedural, et tres difficile a diagnostiquer plus +tard sur une orthophoto. + +Les altitudes restent ABSOLUES (IGN69) par defaut : c'est la donnee mesuree, et +c'est ce que originEast/originNorth pretendent decrire. Le recentrage horizontal +(la dalle est centree sur l'origine du monde) est fait par le moteur au +chargement, pas ici — ainsi le fichier reste geo-reference et deux dalles +voisines resteront raccordables. +""" + +from __future__ import annotations + +import argparse +import math +import os +import struct +import sys +import time + +import numpy as np + +try: + import laspy +except ImportError: # pragma: no cover - message d'aide, pas de la logique + sys.exit("laspy est absent. Installer :\n" + ' python -m pip install "laspy[lazrs]" numpy') + + +MAGIC = b"VCHM" +VERSION = 1 +HEADER_SIZE = 120 +LABEL_SIZE = 64 +FLAG_ABSOLUTE_ALTITUDE = 1 << 0 + +# Nomenclature LAS standard, telle qu'utilisee par l'IGN pour LiDAR HD. +# Sert uniquement aux messages : le filtre, lui, prend les numeros bruts. +CLASS_NAMES = { + 1: "non classe", + 2: "sol", + 3: "vegetation basse", + 4: "vegetation moyenne", + 5: "vegetation haute", + 6: "bati", + 9: "eau", + 17: "tablier de pont", + 64: "sursol perenne", + 65: "artefact", + 66: "point virtuel", + 67: "divers bati", +} + + +def human_size(n: int) -> str: + for unit in ("o", "Ko", "Mo", "Go"): + if n < 1024 or unit == "Go": + return f"{n:.1f} {unit}" if unit != "o" else f"{n} o" + n /= 1024.0 + return f"{n} o" + + +# --------------------------------------------------------------------------- +# 1. Lecture du nuage +# --------------------------------------------------------------------------- + +def read_ground_points(path: str, classes: set[int], chunk_size: int): + """Renvoie (x, y, z) des points des classes demandees, plus des statistiques. + + Lecture PAR MORCEAUX : une dalle LiDAR HD fait ~29 millions de points, dont + on ne garde ici que le quart (le sol). Tout charger d'un bloc marcherait sur + cette machine, mais garder seulement les points retenus borne la memoire a la + taille du RESULTAT et non a celle du fichier — ce qui reste vrai le jour ou + l'on enchainera plusieurs dalles. + """ + xs, ys, zs = [], [], [] + histogram = {} + total = 0 + + with laspy.open(path) as reader: + header = reader.header + for chunk in reader.chunk_iterator(chunk_size): + cls = np.asarray(chunk.classification) + total += cls.size + + values, counts = np.unique(cls, return_counts=True) + for value, count in zip(values.tolist(), counts.tolist()): + histogram[value] = histogram.get(value, 0) + count + + keep = np.isin(cls, list(classes)) + if not keep.any(): + continue + xs.append(np.asarray(chunk.x)[keep]) + ys.append(np.asarray(chunk.y)[keep]) + zs.append(np.asarray(chunk.z)[keep].astype(np.float64)) + + if not xs: + raise SystemExit( + f"Aucun point des classes {sorted(classes)} dans {os.path.basename(path)}. " + "Cette dalle est-elle bien la version CLASSIFIEE ?") + + return (np.concatenate(xs), np.concatenate(ys), np.concatenate(zs), + header, total, histogram) + + +# --------------------------------------------------------------------------- +# 2. Grille +# --------------------------------------------------------------------------- + +def bounds_from_name(path: str): + """(x_min, y_min, x_max, y_max) nominal deduit du nom d'une dalle LiDAR HD. + + 'LHD_FXX_0899_6440_PTS_LAMB93_IGN69.copc.laz' -> coin NORD-OUEST a + X = 899 km, Y = 6440 km, donc la dalle couvre X 899000..900000 et + Y 6439000..6440000 : le Y du nom est le HAUT de la dalle, pas le bas. + Retourne None si le nom ne suit pas la nomenclature. + """ + parts = os.path.basename(path).split("_") + for index in range(len(parts) - 1): + a, b = parts[index], parts[index + 1] + if a.isdigit() and b.isdigit() and len(a) == 4 and len(b) == 4: + x_min = int(a) * 1000 + y_max = int(b) * 1000 + return (x_min, y_max - 1000, x_min + 1000, y_max) + return None + + +def build_grid(x, y, z, x_min, y_min, x_max, y_max, cell, stat): + """Agrege les points sur une grille reguliere, un echantillon par NOEUD. + + Les echantillons sont sur les noeuds (ix = 0 tombe pile sur x_min) et non au + centre des cellules : les bords de la grille coincident alors exactement avec + les bords de la dalle, donc deux dalles voisines partageront leurs + echantillons de bord au lieu de se chevaucher d'une demi-cellule. Chaque + point est affecte au noeud le plus PROCHE, ce qui revient a un carre de cote + `cell` centre sur le noeud. + + Renvoie (heights, counts) en shape (nz, nx), lignes du NORD vers le SUD, + heights valant NaN la ou aucun point n'est tombe. + """ + nx = int(round((x_max - x_min) / cell)) + 1 + nz = int(round((y_max - y_min) / cell)) + 1 + + # REGLE D'AFFECTATION, valable pour les deux axes : un point appartient au + # noeud dont l'intervalle [c - cell/2, c + cell/2[ contient sa coordonnee + # PROJETEE. C'est cette definition, et non ce code, que rejoue + # tools/check_terrain_file.py. + # + # floor(t + 0.5) et NON np.rint : rint arrondit les ex aequo vers l'entier + # PAIR, si bien qu'un point tombant pile sur la frontiere entre deux noeuds + # part a gauche ou a droite selon la PARITE de l'indice. Les coordonnees LAZ + # etant quantifiees au centimetre, ces ex aequo sont frequents et non + # marginaux. + # + # Le renversement nord-sud est fait APRES l'arrondi, sur l'indice entier, et + # c'est essentiel : arrondir directement (y_max - y) inverserait aussi le + # sens de l'intervalle semi-ouvert, qui deviendrait ]c - cell/2, c + cell/2] + # sur cet axe et [c - cell/2, c + cell/2[ sur l'autre. Deux dalles voisines + # raccordees le long d'une frontiere est-ouest se disputeraient alors leur + # ligne commune. Erreur reellement commise et attrapee par le controle croise + # (des noeuds "vides" pour l'un contenaient un point pour l'autre) : sur une + # dalle isolee elle ne deplacait qu'une poignee de points, donc rien de + # visible a l'ecran. + ix = np.floor((x - x_min) / cell + 0.5).astype(np.int64) + iz_from_south = np.floor((y - y_min) / cell + 0.5).astype(np.int64) + iz = (nz - 1) - iz_from_south + + inside = (ix >= 0) & (ix < nx) & (iz >= 0) & (iz < nz) + ix, iz, z = ix[inside], iz[inside], z[inside] + + key = iz * nx + ix + counts_flat = np.bincount(key, minlength=nx * nz) + + if stat == "mean": + sums = np.bincount(key, weights=z, minlength=nx * nz) + with np.errstate(invalid="ignore", divide="ignore"): + values = sums / counts_flat + elif stat == "min": + values = np.full(nx * nz, np.inf) + np.minimum.at(values, key, z) + values[np.isinf(values)] = np.nan + else: # median + # Tri lexicographique (cle, puis altitude) : les points d'un meme noeud + # se retrouvent contigus ET tries, donc la mediane est une simple + # indexation au milieu de chaque groupe. Entierement vectorise, la ou + # une boucle Python sur le million de noeuds couterait des minutes. + order = np.lexsort((z, key)) + key_sorted = key[order] + z_sorted = z[order] + + unique_keys, starts, group_counts = np.unique( + key_sorted, return_index=True, return_counts=True) + middle = starts + group_counts // 2 + + median = z_sorted[middle] + even = (group_counts % 2) == 0 + if even.any(): + median = median.copy() + median[even] = 0.5 * (z_sorted[middle[even]] + z_sorted[middle[even] - 1]) + + values = np.full(nx * nz, np.nan) + values[unique_keys] = median + + values = np.where(counts_flat > 0, values, np.nan) + return values.reshape(nz, nx), counts_flat.reshape(nz, nx) + + +def neighbour_stack(grid): + """Empile les 8 voisins de chaque cellule, bords prolonges par recopie.""" + padded = np.pad(grid, 1, mode="edge") + nz, nx = grid.shape + out = np.empty((8, nz, nx), dtype=grid.dtype) + k = 0 + for dz in (0, 1, 2): + for dx in (0, 1, 2): + if dz == 1 and dx == 1: + continue + out[k] = padded[dz:dz + nz, dx:dx + nx] + k += 1 + return out + + +def fill_holes(heights, max_passes=512): + """Bouche les trous par dilatation iterative : chaque passe remplit une + cellule vide par la MOYENNE de ses voisins deja connus. + + Aucun trou n'est tolere dans le maillage final — un NaN qui arrive au GPU + donne un triangle degenere et un terrain qui clignote. Le nombre de passes + effectuees est renvoye : il vaut exactement le rayon du plus gros trou, ce + qui est le diagnostic le plus parlant sur la qualite de la dalle. + """ + filled = heights.copy() + known = ~np.isnan(filled) + passes = 0 + + while not known.all() and passes < max_passes: + neighbours = neighbour_stack(np.where(known, filled, 0.0)) + valid = neighbour_stack(known.astype(np.float32)) + + total = neighbours.sum(axis=0) + weight = valid.sum(axis=0) + + newly = (~known) & (weight > 0) + if not newly.any(): + break + + filled[newly] = total[newly] / weight[newly] + known |= newly + passes += 1 + + remaining = int((~known).sum()) + if remaining: + # Ne peut arriver que si la grille est entierement vide, ou si un trou + # depasse max_passes cellules de rayon. Plutot que de laisser passer des + # NaN, on rabat sur la mediane globale et on le dit tres fort. + fallback = float(np.nanmedian(filled)) if np.isfinite(filled).any() else 0.0 + filled[~known] = fallback + print(f" !! {remaining} cellules jamais atteintes apres {passes} passes, " + f"rabattues sur {fallback:.2f} m") + + return filled, passes, remaining + + +def despike(heights, measured, abs_tolerance, mad_factor): + """Remplace les cellules isolees qui s'ecartent trop de leur voisinage. + + Le vrai risque avec une dalle reelle n'est pas le bruit — la mediane par + noeud l'a deja absorbe — mais la cellule dont TOUS les points sont faux + (echo parasite classe sol par erreur). Le critere doit donc etre severe + envers un point isole et indulgent envers une falaise, car cette dalle en a + de vraies : 562 m de denivele sur 1 km. D'ou le double seuil — il faut + depasser A LA FOIS une tolerance absolue et un multiple de la dispersion + LOCALE. Sur un versant raide la dispersion locale est grande, donc le filtre + s'y desactive de lui-meme ; sur un replat elle est proche de zero et le + moindre pic ressort. + + Seules les cellules MESUREES sont candidates : celles issues du bouchage de + trous sont deja lisses par construction. + """ + neighbours = neighbour_stack(heights) + local_median = np.median(neighbours, axis=0) + deviation = np.abs(heights - local_median) + + # MAD -> ecart-type par le facteur 1.4826 (loi normale). + local_mad = np.median(np.abs(neighbours - local_median), axis=0) * 1.4826 + + threshold = np.maximum(abs_tolerance, mad_factor * local_mad) + spikes = measured & (deviation > threshold) + + cleaned = heights.copy() + cleaned[spikes] = local_median[spikes] + return cleaned, int(spikes.sum()), float(deviation[spikes].max()) if spikes.any() else 0.0 + + +# --------------------------------------------------------------------------- +# 3. Ecriture +# --------------------------------------------------------------------------- + +def write_vchm(path, heights, spacing, origin_east, origin_north, label, + epsg, absolute): + nz, nx = heights.shape + data = np.ascontiguousarray(heights, dtype=" int: + parser = argparse.ArgumentParser( + description="Convertit une dalle LiDAR HD IGN en heightmap .vchm.") + parser.add_argument("input", help="fichier .laz / .copc.laz classifie") + parser.add_argument("-o", "--output", help="fichier .vchm a ecrire") + parser.add_argument("--cell", type=float, default=1.0, + help="taille de cellule en metres (defaut 1.0)") + parser.add_argument("--stat", choices=("median", "mean", "min"), default="median", + help="agregation des points d'un noeud (defaut median)") + parser.add_argument("--classes", default="2", + help="classes LAS retenues, separees par des virgules " + "(defaut 2 = sol)") + parser.add_argument("--chunk", type=int, default=4_000_000, + help="points lus par morceau (defaut 4 millions)") + parser.add_argument("--no-despike", action="store_true", + help="desactive le filtre de pics") + parser.add_argument("--spike-tolerance", type=float, default=5.0, + help="ecart absolu minimal pour qu'une cellule soit un " + "pic, en metres (defaut 5.0)") + parser.add_argument("--spike-factor", type=float, default=6.0, + help="multiple de la dispersion locale au-dela duquel " + "une cellule est un pic (defaut 6.0)") + parser.add_argument("--zero-base", action="store_true", + help="ramene l'altitude minimale a 0 (defaut : garder " + "les altitudes absolues IGN69)") + parser.add_argument("--report-only", action="store_true", + help="analyse seulement, n'ecrit aucun fichier") + parser.add_argument("--bounds-from-name", action="store_true", + help="imposer l'emprise NOMINALE de la dalle deduite de " + "son nom (LHD_FXX_0899_6440_... -> X 899000..900000, " + "Y 6439000..6440000) au lieu de l'emprise des points. " + "Indispensable en assemblage multi-dalles.") + args = parser.parse_args() + + if args.cell <= 0: + return parser.error("--cell doit etre > 0") + if not args.report_only and not args.output: + return parser.error("-o/--output est requis (ou utiliser --report-only)") + + classes = {int(c) for c in args.classes.split(",") if c.strip()} + + started = time.time() + size = os.path.getsize(args.input) + print(f"Entree : {os.path.basename(args.input)} ({human_size(size)})") + + x, y, z, header, total, histogram = read_ground_points( + args.input, classes, args.chunk) + + print(f" {total:,} points lus, point format {header.point_format.id}, " + f"LAS {header.version}") + print(" classification :") + for value in sorted(histogram): + name = CLASS_NAMES.get(value, "?") + mark = " <-- retenu" if value in classes else "" + print(f" {value:3d} {name:<18s} {histogram[value]:>11,} " + f"({100.0 * histogram[value] / total:5.2f} %){mark}") + + print(f" retenus : {x.size:,} points " + f"({100.0 * x.size / total:.2f} %), " + f"soit {x.size / max(1.0, (x.max() - x.min()) * (y.max() - y.min())):.2f} pts/m2") + + # Emprise : celle declaree par l'en-tete LAS, ecretee sur des metres entiers. + # On ne prend PAS l'emprise des points retenus : elle varierait selon la + # classe demandee, et deux dalles voisines ne se raccorderaient plus. + x_min = math.floor(header.mins[0]) + y_min = math.floor(header.mins[1]) + x_max = math.ceil(header.maxs[0]) + y_max = math.ceil(header.maxs[1]) + + if args.bounds_from_name: + # ASSEMBLAGE MULTI-DALLES : l'emprise ci-dessus vient des POINTS, pas de + # la dalle. Une dalle dont les echos s'arretent 30 cm avant le bord (bord + # de mission, plan d'eau non reflechissant, trou de vol) donnerait une + # grille de 1000 au lieu de 1001 echantillons : elle serait refusee comme + # non carree, ou pire, se raccorderait decalee d'un metre a ses voisines. + # Le nom de la dalle, lui, porte l'emprise nominale garantie par l'IGN. + nominal = bounds_from_name(args.input) + if nominal is None: + return parser.error( + f"--bounds-from-name : impossible de lire les coordonnees dans " + f"'{os.path.basename(args.input)}' (attendu LHD_FXX___...)") + forced_x_min, forced_y_min, forced_x_max, forced_y_max = nominal + if (forced_x_min, forced_y_min, forced_x_max, forced_y_max) != \ + (x_min, y_min, x_max, y_max): + print(f" emprise des points : X {x_min} .. {x_max}, " + f"Y {y_min} .. {y_max} (ecartee)") + x_min, y_min, x_max, y_max = nominal + print(f" emprise NOMINALE (nom de dalle) : X {x_min} .. {x_max}, " + f"Y {y_min} .. {y_max} ({x_max - x_min} x {y_max - y_min} m)") + else: + print(f" emprise (Lambert 93) : X {x_min} .. {x_max}, Y {y_min} .. {y_max} " + f"({x_max - x_min} x {y_max - y_min} m)") + + heights, counts = build_grid(x, y, z, x_min, y_min, x_max, y_max, + args.cell, args.stat) + nz, nx = heights.shape + measured = counts > 0 + holes = int((~measured).sum()) + print(f"\nGrille : {nx} x {nz} echantillons, pas de {args.cell} m, " + f"agregation '{args.stat}'") + print(f" points par cellule : min {counts[measured].min()}, " + f"median {int(np.median(counts[measured]))}, max {counts.max()}") + print(f" trous : {holes:,} cellules sans aucun point " + f"({100.0 * holes / counts.size:.3f} %)") + + heights, passes, unreached = fill_holes(heights) + if holes: + print(f" bouches en {passes} passes " + f"(rayon du plus gros trou : {passes} cellules)") + + if not args.no_despike: + heights, spikes, worst = despike(heights, measured, + args.spike_tolerance, args.spike_factor) + print(f" pics corriges : {spikes:,} cellules " + f"({100.0 * spikes / heights.size:.4f} %)" + + (f", ecart max {worst:.1f} m" if spikes else "")) + + if not np.isfinite(heights).all(): + raise SystemExit("BUG : des valeurs non finies subsistent dans la grille.") + + absolute = not args.zero_base + if args.zero_base: + heights = heights - heights.min() + + print(f"\nAltitudes : {heights.min():.2f} .. {heights.max():.2f} m " + f"(denivele {heights.max() - heights.min():.2f} m)" + + ("" if absolute else " [ramenees a zero]")) + + label = os.path.splitext(os.path.splitext(os.path.basename(args.input))[0])[0] + if args.report_only: + print("\n--report-only : rien n'a ete ecrit.") + return 0 + + epsg = 2154 # Lambert 93. Les dalles LiDAR HD metropolitaines y sont toutes. + write_vchm(args.output, heights, args.cell, x_min, y_max, label, epsg, absolute) + + written = os.path.getsize(args.output) + print(f"\nSortie : {args.output} ({human_size(written)})") + print(f" origine (echantillon 0,0 = coin NORD-OUEST) : " + f"E {x_min}, N {y_max} [EPSG:{epsg}]") + print(f" emprise monde : {(nx - 1) * args.cell:.0f} x {(nz - 1) * args.cell:.0f} m") + print(f"Termine en {time.time() - started:.1f} s.") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/make_ortho_texture.py b/tools/make_ortho_texture.py new file mode 100644 index 0000000..d3eb168 --- /dev/null +++ b/tools/make_ortho_texture.py @@ -0,0 +1,389 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +make_ortho_texture.py — assemble les tuiles BD ORTHO en une texture .vcto prete +a etre envoyee au GPU : mosaique, chaine de mipmaps, compression BC1. + +PHASE 11. Pendant du couple fetch_dalles.py / assemble_terrain.py de la Phase 9 : +le telechargement et la MISE EN FORME sont deux outils separes, parce qu'on +re-encode bien plus souvent qu'on ne retelecharge. + + python tools/make_ortho_texture.py assets/terrain/vercora_zone_1m.vchm \ + -i data/ortho -o assets/terrain/vercora_zone_ortho.vcto + python tools/make_ortho_texture.py ... --size 4096 --format rgba + +POURQUOI TOUT EST PRECALCULE ICI, MIPMAPS COMPRISES. Le chemin habituel cote +moteur (generer les mipmaps sur le GPU par vkCmdBlitImage) est INAPPLICABLE a une +texture compressee : on ne peut pas filtrer des blocs BC1. Il faudrait donc soit +renoncer a la compression, soit reduire puis compresser chaque niveau — c'est +exactement ce que fait ce script. Le moteur, lui, se contente de recopier des +octets deja prets, ce qui rend son code de chargement plus simple, pas moins. + +POURQUOI BC1. La zone fait 5 x 5 km. A 8192 px de cote (0,61 m/texel) : + - en RGBA8 non compresse : 268 Mo, plus 89 Mo de mipmaps ; + - en BC1 (6:1, blocs de 4x4 sur 8 octets) : 33 Mo, plus 11 Mo de mipmaps. +Sur le GPU integre de cette machine, dont la memoire est prise sur la RAM +systeme et dont la Phase 10 avait ramene l'empreinte totale a 246 Mo, la +difference n'est pas cosmetique. BC1 est disponible sur tout GPU de bureau +(feature Vulkan textureCompressionBC) ; le moteur le VERIFIE et refuse de charger +une texture BC1 sur un GPU qui ne la gere pas, plutot que d'afficher n'importe +quoi. --format rgba reste disponible comme repli. + +QUALITE DE L'ENCODAGE. BC1 est destructif. Le script mesure et AFFICHE le PSNR +du niveau 0 apres aller-retour : sur de la photo aerienne (contenu a haute +frequence, sans grands aplats degrades) on attend environ 35 dB, ce qui est +visuellement indiscernable a la distance ou le terrain est regarde. Un chiffre +nettement plus bas serait le signe d'un defaut d'encodage, pas d'une limite du +format — d'ou son affichage systematique plutot qu'une confiance aveugle. + +FORMAT .vcto ("Vercora TexturE Ortho"), petit-boutiste, en-tete de 128 octets : + + 0 "VCTO" magie + 4 uint32 version = 1 + 8 uint32 width largeur du niveau 0 + 12 uint32 height + 16 uint32 mipLevels niveaux stockes, du plus grand au plus petit + 20 uint32 format 0 = RGBA8 brut, 1 = BC1 (RGB, blocs de 8 octets) + 24 float64 eastMin \ + 32 float64 northMin | emprise Lambert 93 COUVERTE par l'image, + 40 float64 eastMax | bord a bord (et non centres de texels) + 48 float64 northMax / + 56 uint32 epsg 2154 + 60 uint32 flags reserve + 64 char[64] label + 128 donnees des mipmaps, consecutives, sans remplissage + +L'emprise est recopiee dans l'en-tete pour que le moteur puisse VERIFIER qu'elle +correspond a celle de la heightmap chargee, au lieu de supposer que l'utilisateur +a associe les bons fichiers. Une texture d'une autre zone est refusee au +chargement avec un message explicite. + +Dependances : Pillow, numpy. +""" + +from __future__ import annotations + +import argparse +import glob +import os +import re +import struct +import sys +import time + +try: + import numpy as np + from PIL import Image +except ImportError: + sys.exit("Pillow et numpy sont requis : python -m pip install Pillow numpy") + +Image.MAX_IMAGE_PIXELS = None + +FORMAT_RGBA8 = 0 +FORMAT_BC1 = 1 +HEADER_SIZE = 128 +TILE_RE = re.compile(r"ortho_(\d+)_(\d+)_(\d+)px\.(jpg|png)$", re.IGNORECASE) + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from fetch_ortho import Extent # noqa: E402 (meme definition d'emprise, pas de copie) + + +# --------------------------------------------------------------------------- +# Compression BC1 +# --------------------------------------------------------------------------- +def _pack565(rgb: np.ndarray) -> np.ndarray: + """(N,3) uint8 -> (N,) uint16 au format RGB565.""" + r = (rgb[:, 0].astype(np.uint16) >> 3) << 11 + g = (rgb[:, 1].astype(np.uint16) >> 2) << 5 + b = (rgb[:, 2].astype(np.uint16) >> 3) + return (r | g | b).astype(np.uint16) + + +def _unpack565(packed: np.ndarray) -> np.ndarray: + """(N,) uint16 -> (N,3) uint8 : la couleur REELLEMENT vue par le GPU. + + La replication des bits de poids fort dans les bits perdus (r5<<3 | r5>>2) + n'est pas une coquetterie : c'est ce que fait le materiel, et choisir les + indices contre une autre valeur que celle-la ferait diverger l'encodeur du + decodeur sur les couleurs extremes. + """ + p = packed.astype(np.uint32) + r5 = (p >> 11) & 0x1F + g6 = (p >> 5) & 0x3F + b5 = p & 0x1F + r = (r5 << 3) | (r5 >> 2) + g = (g6 << 2) | (g6 >> 4) + b = (b5 << 3) | (b5 >> 2) + return np.stack([r, g, b], axis=1).astype(np.uint8) + + +def encode_bc1(image: np.ndarray, chunk_blocks: int = 1 << 18) -> bytes: + """image (H,W,3) uint8, H et W multiples de 4 -> octets BC1. + + Methode dite de la BOITE ENGLOBANTE avec retrait (le chemin rapide de + stb_dxt) : les deux extremites de la palette sont les coins min/max du pave + des couleurs du bloc, rentres d'un seizieme de leur ecart. Le retrait compte + — sans lui les deux couleurs interpolees de la palette sont systematiquement + trop rapprochees des extremes et les blocs bruites se delavent. + + Le traitement est decoupe en paquets de blocs : la matrice des distances + (blocs x 16 pixels x 4 couleurs) pese sinon plus d'un gigaoctet sur une + texture de 8192 px. + """ + height, width, _ = image.shape + assert height % 4 == 0 and width % 4 == 0 + + # (H,W,3) -> (nblocks, 16, 3), les 16 pixels d'un bloc dans l'ordre BC1 + # (ligne par ligne, de gauche a droite). + blocks = (image.reshape(height // 4, 4, width // 4, 4, 3) + .transpose(0, 2, 1, 3, 4) + .reshape(-1, 16, 3)) + total = blocks.shape[0] + out = np.empty(total * 8, dtype=np.uint8) + + for start in range(0, total, chunk_blocks): + chunk = blocks[start:start + chunk_blocks].astype(np.int16) + n = chunk.shape[0] + + lo = chunk.min(axis=1) + hi = chunk.max(axis=1) + inset = (hi - lo) >> 4 + lo = np.clip(lo + inset, 0, 255).astype(np.uint8) + hi = np.clip(hi - inset, 0, 255).astype(np.uint8) + + packed_hi = _pack565(hi) + packed_lo = _pack565(lo) + + # BC1 n'entre en mode 4 couleurs que si c0 > c1 (strictement). On force + # donc l'ordre ; l'egalite designe un bloc uni, dont tous les indices + # tomberont naturellement sur 0. + c0 = np.maximum(packed_hi, packed_lo) + c1 = np.minimum(packed_hi, packed_lo) + + e0 = _unpack565(c0).astype(np.int16) + e1 = _unpack565(c1).astype(np.int16) + + palette = np.empty((n, 4, 3), dtype=np.int16) + palette[:, 0] = e0 + palette[:, 1] = e1 + palette[:, 2] = (2 * e0 + e1) // 3 + palette[:, 3] = (e0 + 2 * e1) // 3 + + # (n,16,1,3) - (n,1,4,3) -> (n,16,4) + # int32 OBLIGATOIRE : une distance au carre monte a 3 x 255^2 = 195 075, + # tres au-dela des 32 767 d'un int16. En int16 l'accumulation deborde en + # silence, l'argmin choisit une couleur au hasard, et le PSNR tombe de + # ~36 a ~22 dB sans qu'aucune erreur ne soit levee. + diff = (chunk[:, :, None, :].astype(np.int32) + - palette[:, None, :, :].astype(np.int32)) + distance = np.einsum("nikc,nikc->nik", diff, diff) + indices = distance.argmin(axis=2).astype(np.uint32) # (n,16) + + # Le pixel 0 occupe les bits de poids faible du mot d'indices. + shifts = (2 * np.arange(16, dtype=np.uint32))[None, :] + packed_indices = np.bitwise_or.reduce(indices << shifts, axis=1) + + block_bytes = np.empty((n, 8), dtype=np.uint8) + block_bytes[:, 0] = c0 & 0xFF + block_bytes[:, 1] = c0 >> 8 + block_bytes[:, 2] = c1 & 0xFF + block_bytes[:, 3] = c1 >> 8 + block_bytes[:, 4] = packed_indices & 0xFF + block_bytes[:, 5] = (packed_indices >> 8) & 0xFF + block_bytes[:, 6] = (packed_indices >> 16) & 0xFF + block_bytes[:, 7] = (packed_indices >> 24) & 0xFF + + out[start * 8:(start + n) * 8] = block_bytes.reshape(-1) + + return out.tobytes() + + +def decode_bc1(data: bytes, width: int, height: int) -> np.ndarray: + """Decodeur de controle, utilise uniquement pour mesurer le PSNR. + + Ecrit INDEPENDAMMENT de l'encodeur (il repart des octets produits, comme le + ferait le GPU) : c'est ce qui lui permet d'attraper une erreur d'ordre des + bits ou d'endianness, qu'un simple aller-retour interne masquerait. + """ + raw = np.frombuffer(data, dtype=np.uint8).reshape(-1, 8) + c0 = raw[:, 0].astype(np.uint16) | (raw[:, 1].astype(np.uint16) << 8) + c1 = raw[:, 2].astype(np.uint16) | (raw[:, 3].astype(np.uint16) << 8) + bits = (raw[:, 4].astype(np.uint32) | (raw[:, 5].astype(np.uint32) << 8) | + (raw[:, 6].astype(np.uint32) << 16) | (raw[:, 7].astype(np.uint32) << 24)) + + e0 = _unpack565(c0).astype(np.int16) + e1 = _unpack565(c1).astype(np.int16) + n = raw.shape[0] + palette = np.empty((n, 4, 3), dtype=np.int16) + palette[:, 0] = e0 + palette[:, 1] = e1 + four = (c0 > c1)[:, None] + palette[:, 2] = np.where(four, (2 * e0 + e1) // 3, (e0 + e1) // 2) + palette[:, 3] = np.where(four, (e0 + 2 * e1) // 3, 0) + + shifts = (2 * np.arange(16, dtype=np.uint32))[None, :] + indices = (bits[:, None] >> shifts) & 0x3 + pixels = np.take_along_axis(palette, indices[:, :, None].astype(np.intp), axis=1) + + return (pixels.reshape(height // 4, width // 4, 4, 4, 3) + .transpose(0, 2, 1, 3, 4) + .reshape(height, width, 3)).astype(np.uint8) + + +def psnr(a: np.ndarray, b: np.ndarray) -> float: + mse = np.mean((a.astype(np.float64) - b.astype(np.float64)) ** 2) + if mse <= 0.0: + return float("inf") + return 10.0 * np.log10(255.0 * 255.0 / mse) + + +# --------------------------------------------------------------------------- +# Mosaique +# --------------------------------------------------------------------------- +def build_mosaic(tile_dir: str, extent: Extent) -> tuple[Image.Image, float]: + """Recolle les tuiles telechargees. Renvoie (image, metres par pixel). + + Les tuiles sont placees par leurs COORDONNEES, lues dans leur nom de + fichier, et non par ordre alphabetique : c'est ce qui garantit que le nord + est en haut. Une tuile manquante est une erreur franche — une mosaique + trouee produirait une texture noire par endroits, defaut qu'on ne + remarquerait qu'en jeu, longtemps apres. + """ + tiles = {} + tile_px = None + for path in glob.glob(os.path.join(tile_dir, "ortho_*px.*")): + match = TILE_RE.search(os.path.basename(path)) + if not match: + continue + east, north, px = int(match.group(1)), int(match.group(2)), int(match.group(3)) + if tile_px is None: + tile_px = px + elif px != tile_px: + sys.exit(f"{tile_dir} contient des tuiles de tailles differentes " + f"({tile_px} et {px} px). Vider le repertoire et retelecharger.") + tiles[(east, north)] = path + + if not tiles: + sys.exit(f"Aucune tuile ortho_*px.* dans {tile_dir}. " + "Lancer d'abord tools/fetch_ortho.py.") + + easts = sorted({e for e, _ in tiles}) + norths = sorted({n for _, n in tiles}) + tile_m = (easts[1] - easts[0]) if len(easts) > 1 else int(extent.width_m) + cols, rows = len(easts), len(norths) + + expected_cols = int(round(extent.width_m / tile_m)) + expected_rows = int(round(extent.height_m / tile_m)) + if cols != expected_cols or rows != expected_rows or len(tiles) != cols * rows: + sys.exit(f"Couverture incomplete : {len(tiles)} tuiles pour une grille " + f"{expected_cols}x{expected_rows} attendue. Relancer fetch_ortho.py.") + + mosaic = Image.new("RGB", (cols * tile_px, rows * tile_px)) + for column, east in enumerate(easts): + for row, north in enumerate(norths): + # Les nords CROISSENT vers le haut, les lignes d'image vers le bas : + # d'ou l'inversion. C'est le seul endroit ou le sens du nord est + # decide, et c'est exactement l'erreur que la Phase 9 ne pouvait pas + # detecter faute d'orthophoto. + y = (rows - 1 - row) * tile_px + with Image.open(tiles[(east, north)]) as tile: + mosaic.paste(tile.convert("RGB"), (column * tile_px, y)) + + return mosaic, tile_m / float(tile_px) + + +# --------------------------------------------------------------------------- +def main() -> int: + parser = argparse.ArgumentParser( + description="Assemble les tuiles BD ORTHO en texture .vcto (mipmaps + BC1).") + parser.add_argument("terrain", help="fichier .vchm dont on reprend l'emprise") + parser.add_argument("-i", "--input", default="data/ortho", help="repertoire des tuiles") + parser.add_argument("-o", "--output", required=True, help="fichier .vcto a ecrire") + parser.add_argument("--size", type=int, default=8192, + help="cote de la texture GPU, en texels (defaut 8192). " + "Doit etre une puissance de deux et un multiple de 4.") + parser.add_argument("--format", default="bc1", choices=("bc1", "rgba")) + parser.add_argument("--no-psnr", action="store_true", + help="saute la mesure de qualite (elle double la duree)") + args = parser.parse_args() + + if args.size & (args.size - 1) or args.size < 4: + sys.exit("--size doit etre une puissance de deux >= 4.") + + extent = Extent(args.terrain) + print(extent.describe()) + + started = time.time() + print(f"\nAssemblage depuis {args.input} ...") + mosaic, source_res = build_mosaic(args.input, extent) + print(f" mosaique {mosaic.size[0]} x {mosaic.size[1]} px " + f"a {source_res:g} m/texel") + + if mosaic.size[0] != args.size: + print(f" redimensionnement -> {args.size} x {args.size} " + f"({extent.width_m / args.size:.2f} m/texel) [Lanczos]") + mosaic = mosaic.resize((args.size, args.size), Image.LANCZOS) + + # Chaine de mipmaps complete, jusqu'au texel unique. Chaque niveau est reduit + # depuis le PRECEDENT (et non depuis le niveau 0) : c'est la definition d'une + # mipmap, et c'est deux fois moins de travail. + levels = [] + current = mosaic + while True: + levels.append(current) + if current.size[0] == 1 and current.size[1] == 1: + break + current = current.resize((max(1, current.size[0] // 2), + max(1, current.size[1] // 2)), Image.LANCZOS) + print(f" {len(levels)} niveaux de mipmap ({levels[0].size[0]} -> 1)") + + fmt = FORMAT_BC1 if args.format == "bc1" else FORMAT_RGBA8 + payload = bytearray() + for level, image in enumerate(levels): + width, height = image.size + if fmt == FORMAT_RGBA8: + payload += image.convert("RGBA").tobytes() + continue + # BC1 travaille par blocs de 4x4 : les derniers niveaux (2x2, 1x1) sont + # completes par replication du bord, ce qui est ce que produit n'importe + # quel compresseur et ce que le GPU attend (l'image reste declaree a sa + # taille reelle, le materiel ignore les texels de remplissage). + array = np.asarray(image.convert("RGB")) + pad_h = (-height) % 4 + pad_w = (-width) % 4 + if pad_h or pad_w: + array = np.pad(array, ((0, pad_h), (0, pad_w), (0, 0)), mode="edge") + encoded = encode_bc1(array) + payload += encoded + if level == 0 and not args.no_psnr: + decoded = decode_bc1(encoded, array.shape[1], array.shape[0]) + quality = psnr(array, decoded) + verdict = "bon" if quality >= 33.0 else "FAIBLE - a verifier" + print(f" qualite BC1 du niveau 0 : PSNR {quality:.1f} dB ({verdict})") + + header = bytearray(HEADER_SIZE) + struct.pack_into("<4sIIIII", header, 0, b"VCTO", 1, + levels[0].size[0], levels[0].size[1], len(levels), fmt) + struct.pack_into(" fenetre affichee)" -f $loadSeconds) + +Start-Sleep -Seconds $WarmupSeconds + +$samples = New-Object System.Collections.ArrayList +$sb = New-Object System.Text.StringBuilder 512 +$deadline = (Get-Date).AddSeconds($Seconds) +while ((Get-Date) -lt $deadline) { + $proc.Refresh() + if ($proc.HasExited) { break } + [void]$sb.Clear() + [void][W32M]::GetWindowTextW($hwnd, $sb, 512) + $title = $sb.ToString() + if ($title -match '(\d+)\s*FPS') { [void]$samples.Add([int]$Matches[1]) } + Start-Sleep -Milliseconds 250 +} + +$proc.Refresh() +$peakMb = [math]::Round($proc.PeakWorkingSet64 / 1MB, 1) +$workingMb = [math]::Round($proc.WorkingSet64 / 1MB, 1) + +if ($samples.Count -gt 0) { + $sorted = $samples | Sort-Object + $median = $sorted[[int]($sorted.Count / 2)] + $stats = $samples | Measure-Object -Average -Minimum -Maximum + Write-Host ("MESURE FPS : median {0}, moyen {1:N0}, min {2}, max {3} ({4} releves)" -f ` + $median, $stats.Average, $stats.Minimum, $stats.Maximum, $samples.Count) +} else { + Write-Host "MESURE FPS : aucun releve (titre sans FPS ?)" +} +Write-Host ("MESURE memoire : pic {0} Mo, courant {1} Mo (processus, RAM systeme)" -f $peakMb, $workingMb) + +[void][W32M]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero) +if (-not $proc.WaitForExit(30000)) { + Write-Host "[ECHEC] Pas de sortie 30 s apres WM_CLOSE." + $proc.Kill(); $proc.WaitForExit() + $code = 1 +} else { + $code = $proc.ExitCode +} +$proc.WaitForExit() +Start-Sleep -Milliseconds 400 +foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue } + +$text = $outSb.ToString() + $errSb.ToString() +$lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' }) + +# Zero erreur de validation Vulkan est une contrainte de chaque etape, pas +# seulement du harnais complet : on la verifie donc aussi ici. +$validation = @($lines | Where-Object { $_ -match '\[Validation\]' }) +$errors = @($lines | Where-Object { $_ -match '\[ERROR\]|\[WARN\]' }) +Write-Host ("MESURE validation Vulkan: {0} message(s) [Validation], {1} [ERROR]/[WARN]" -f ` + $validation.Count, $errors.Count) +foreach ($l in ($validation + $errors) | Select-Object -First 12) { Write-Host " $l" } + +$interesting = @($lines | Where-Object { $_ -match 'Terrain|echantillon|sommets|triangles|Lambert|denivele|Quadtree|tuiles' }) +foreach ($l in $interesting | Select-Object -First 12) { Write-Host " | $l" } + +Write-Host ("MESURE code de sortie : {0}" -f $code) +if ($validation.Count -gt 0 -or $errors.Count -gt 0 -or $code -ne 0) { exit 1 } +exit 0 diff --git a/tools/profile_phase27.ps1 b/tools/profile_phase27.ps1 new file mode 100644 index 0000000..3accb56 --- /dev/null +++ b/tools/profile_phase27.ps1 @@ -0,0 +1,186 @@ +# =========================================================================== +# PHASE 27 - Mesure de cout ENTRELACEE, avec temoin de sante machine. +# =========================================================================== +# Ce script applique les trois lecons de mesure du projet, et n'existe que pour +# ne plus avoir a s'en souvenir a la main : +# +# 1. Conditions ENTRELACEES, jamais en blocs (MEMORY : "Mesurer en blocs +# fabrique un effet"). Chaque tour joue A puis B, le tour suivant B puis A : +# une derive lente de la machine (thermique, tache de fond) se repartit sur +# les deux conditions au lieu de s'imputer a l'une. +# 2. Un POSTE TEMOIN qui ne peut pas avoir bouge : le semis de l'herbe +# (gatherGrass, CPU). Aucune des deux conditions ne touche au CPU de +# l'herbe ; s'il varie de plus de 15 % entre A et B, c'est la machine qui a +# change, et la comparaison est declaree SUSPECTE. +# 3. SANTE MACHINE par run : le temps CPU consomme par TOUS LES AUTRES +# processus pendant le run, et le nombre d'images rendues. Un run ou les +# autres processus ont pris plus d'UN coeur en moyenne, ou qui a +# rendu moins de 20 images/s, est NON CONCLUANT - jamais vert (MEMORY : +# "Temoin de sante machine dans le harnais"). +# +# Les conditions sont des PAIRES A/B dont B est le temoin ETROIT de ce que la +# Phase 27 a ajoute (--no-weather-visuals, --no-ground-detail) : la difference +# A - B est le cout de cet ajout et de rien d'autre. +# +# Usage : +# powershell -File tools\profile_phase27.ps1 -Scenario pluie -Rounds 3 -Config Release +# Scenarios : survol, pluie, sol, beau. +# =========================================================================== + +param( + [Parameter(Mandatory = $true)][ValidateSet("survol", "survolbeau", "pluie", "sol", "marche", "beau")][string]$Scenario, + [int]$Rounds = 3, + [int]$Seconds = 25, + [string]$Config = "?", + [string]$Scene = "assets\terrain\vercora_zone_1m.vchm", + [string]$OutCsv = "build\phase27\profil.csv" +) + +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$exe = Join-Path $root "build\vercora.exe" +$scenePath = Join-Path $root $Scene +$csv = Join-Path $root $OutCsv +New-Item -ItemType Directory -Force -Path (Split-Path -Parent $csv) | Out-Null + +Add-Type @" +using System; +using System.Runtime.InteropServices; +public class W32M { + [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); +} +"@ + +$alpage = @("--start=900500,6439000", "--time-scale=0", "--lock-input") +switch ($Scenario) { + # Survol de streaming, comme l'audit (900 m/s, 120 m), un jour de PLUIE : + # tout le contenu de la Phase 27 qui peut couter y est actif. B = Phase 26. + "survol" { $common = @("--flythrough=900", "--day=8", "--hour=13", "--time-scale=0", "--lock-input") + $A = @(); $B = @("--no-weather-visuals", "--no-ground-detail") } + # Meme survol par BEAU temps : separe le cout de la pluie (absente ici) de + # celui des shaders modifies (brouillard nul, micro-relief hors portee). + "survolbeau" { $common = @("--flythrough=900", "--day=12", "--hour=13", "--time-scale=0", "--lock-input") + $A = @(); $B = @("--no-weather-visuals", "--no-ground-detail") } + # Vue fixe sous la pluie : cout de la meteo visible (passe de pluie plein + # ecran + brouillard + sol mouille). + "pluie" { $common = $alpage + @("--look=-90,-8", "--day=8", "--hour=13") + $A = @(); $B = @("--no-weather-visuals") } + # Vue fixe au ras du sol : cout du micro-relief, la ou il couvre le plus + # de pixels. + "sol" { $common = $alpage + @("--look=-90,-50", "--day=12", "--hour=13") + $A = @(); $B = @("--no-ground-detail") } + # Vue de MARCHE (regard a l'horizon, -8 deg) : cout REALISTE du + # micro-relief, qui n'y couvre que le bas de l'ecran. + "marche" { $common = $alpage + @("--look=-90,-8", "--day=12", "--hour=13") + $A = @(); $B = @("--no-ground-detail") } + # Vue fixe par beau temps : la meteo visible doit y couter ~0 (pas de + # pluie, pas de brouillard). Controle negatif de la mesure "pluie". + "beau" { $common = $alpage + @("--look=-90,-8", "--day=12", "--hour=13") + $A = @(); $B = @("--no-weather-visuals") } +} + +$cores = [Environment]::ProcessorCount + +# Charge totale de la machine, en % de TOUS les coeurs (compteur formate de +# Windows, deja moyenne sur l'intervalle d'echantillonnage). +# +# PREMIERE VERSION ABANDONNEE, et la raison vaut d'etre ecrite : elle sommait +# TotalProcessorTime sur Get-Process au debut et a la fin du run. Un processus +# NE pendant le run y entre avec toute sa vie, un processus qui refuse l'acces +# au debut et l'accorde a la fin aussi : l'essai a rendu "318 910 % d'un +# coeur". Un temoin de sante qui ment est pire que pas de temoin. +function Get-TotalLoadPercent { + return [double](Get-CimInstance Win32_PerfFormattedData_PerfOS_Processor -Filter "Name='_Total'").PercentProcessorTime +} + +function Invoke-Run([string]$label, [string[]]$extra) { + $stale = Get-Process -Name "vercora" -ErrorAction SilentlyContinue + if ($stale) { $stale | Stop-Process -Force; Start-Sleep -Milliseconds 800 } + + $log = Join-Path (Split-Path -Parent $csv) ("run_{0}_{1}_{2}.log" -f $Scenario, $label, [DateTime]::Now.ToString("HHmmss")) + $gameArgs = @("`"$scenePath`"") + $common + @($extra | Where-Object { $_ }) + $t0 = [DateTime]::Now + $proc = Start-Process -FilePath $exe -ArgumentList $gameArgs -WorkingDirectory $root ` + -RedirectStandardOutput $log -RedirectStandardError "$log.err" -PassThru + $hwnd = [IntPtr]::Zero + for ($i = 0; $i -lt 900 -and $hwnd -eq [IntPtr]::Zero; $i++) { + $proc.Refresh() + if ($proc.HasExited) { break } + if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle } + Start-Sleep -Milliseconds 100 + } + if ($hwnd -eq [IntPtr]::Zero) { throw "pas de fenetre ($label)" } + # Sante machine : charge totale echantillonnee pendant le run, moins ce que + # vercora lui-meme a consomme sur la meme fenetre de temps. + $proc.Refresh() + $gameCpu0 = $proc.TotalProcessorTime.TotalSeconds + $s0 = [DateTime]::Now + $loads = @() + while (([DateTime]::Now - $s0).TotalSeconds -lt $Seconds) { + Start-Sleep -Milliseconds 1500 + $loads += Get-TotalLoadPercent + } + $proc.Refresh() + $sampleWall = ([DateTime]::Now - $s0).TotalSeconds + $gameCorePct = 100.0 * ($proc.TotalProcessorTime.TotalSeconds - $gameCpu0) / $sampleWall + $totalCorePct = ($loads | Measure-Object -Average).Average * $cores + $others = [math]::Max(0.0, $totalCorePct - $gameCorePct) # en % d'UN coeur + [void][W32M]::PostMessage($hwnd, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero) + if (-not $proc.WaitForExit(30000)) { $proc.Kill(); $proc.WaitForExit() } + + $text = Get-Content $log -Raw + $cost = [regex]::Match($text, "Cout par image \(PHASE 19\) : (\d+) images - streaming terrain ([\d.]+) us, arbres ([\d.]+) us, herbe ([\d.]+) us, plantes a fibres ([\d.]+) us, tronc de vision ([\d.]+) us, drawFrame ([\d.]+) us, visuels meteo ([\d.]+) us") + $cad = [regex]::Match($text, "Cadence de boucle \(PHASE 27\) : (\d+) images en ([\d.]+) s, soit ([\d.]+) images/s, ([\d.]+) us par image") + $validation = ([regex]::Matches($text, "\[Validation\]")).Count + if (-not $cost.Success -or -not $cad.Success) { throw "bilan absent du journal ($label) : $log" } + + $fps = [double]$cad.Groups[3].Value + $verdict = "OK" + # Seuil : un coeur entier (100 %) sur les 20 de la machine. Un bureau vivant + # (messagerie, navigateur integre, pilotes) tourne a 25-35 % d'un coeur au + # repos sur ce poste - mesure au premier essai de ce script. Un seuil plus + # bas rejetterait tous les runs sans rien proteger ; au-dela d'un coeur, une + # vraie tache concurrente (compilation, indexation, un vercora orphelin) + # est en cours et le run n'est pas comparable. + if ($others -gt 100.0) { $verdict = "NON CONCLUANT (autres processus {0:N0} % d'un coeur)" -f $others } + elseif ($fps -lt 20.0) { $verdict = "NON CONCLUANT (n'a pas pu rendre : {0:N1} img/s)" -f $fps } + + $row = [pscustomobject]@{ + Config = $Config; Scenario = $Scenario; Condition = $label + ImgParS = $fps; UsParImage = [double]$cad.Groups[4].Value + Streaming = [double]$cost.Groups[2].Value; Arbres = [double]$cost.Groups[3].Value + Herbe = [double]$cost.Groups[4].Value; Fibres = [double]$cost.Groups[5].Value + Frustum = [double]$cost.Groups[6].Value; DrawFrame = [double]$cost.Groups[7].Value + MeteoCpu = [double]$cost.Groups[8].Value + AutresPctCoeur = [math]::Round($others, 1); Validation = $validation; Verdict = $verdict + } + $row | Export-Csv -Path $csv -Append -NoTypeInformation -Encoding UTF8 + Write-Host ("{0,-8} {1,-2} {2,7:N1} img/s {3,8:N1} us/img drawFrame {4,8:N1} herbe {5,6:N1} meteoCPU {6,5:N2} autres {7,5:N1}% valid {8} {9}" -f ` + $Scenario, $label, $fps, $row.UsParImage, $row.DrawFrame, $row.Herbe, $row.MeteoCpu, $others, $validation, $verdict) + return $row +} + +Write-Host "=== $Scenario ($Config) : $Rounds tours A/B entrelaces, $Seconds s par run, $cores coeurs logiques ===" +$rows = @() +for ($r = 1; $r -le $Rounds; $r++) { + $order = if ($r % 2 -eq 1) { @("A", "B") } else { @("B", "A") } + foreach ($c in $order) { + $extra = if ($c -eq "A") { $A } else { $B } + $rows += Invoke-Run $c $extra + } +} + +$ok = $rows | Where-Object { $_.Verdict -eq "OK" } +$a = $ok | Where-Object { $_.Condition -eq "A" } +$b = $ok | Where-Object { $_.Condition -eq "B" } +function Med($xs) { $s = @($xs | Sort-Object); if ($s.Count -eq 0) { return [double]::NaN }; return $s[[int][math]::Floor(($s.Count - 1) / 2)] } +if ($a.Count -gt 0 -and $b.Count -gt 0) { + $usA = Med ($a | ForEach-Object { $_.UsParImage }); $usB = Med ($b | ForEach-Object { $_.UsParImage }) + $hA = Med ($a | ForEach-Object { $_.Herbe }); $hB = Med ($b | ForEach-Object { $_.Herbe }) + $temoin = if ($hB -gt 0) { [math]::Abs($hA - $hB) / $hB } else { 0 } + Write-Host ("MEDIANES A {0:N1} us/img B {1:N1} us/img A-B = {2:N1} us/img ({3:+0.0;-0.0} %)" -f $usA, $usB, ($usA - $usB), (100 * ($usA - $usB) / $usB)) + Write-Host ("POSTE TEMOIN (herbe, CPU) A {0:N1} us B {1:N1} us ecart {2:N1} % -> {3}" -f $hA, $hB, (100 * $temoin), $(if ($temoin -gt 0.15) { "SUSPECT : la machine a change entre A et B" } else { "stable" })) +} else { + Write-Host "PAS DE CONCLUSION : pas assez de runs OK dans les deux conditions." +} +if (($rows | Measure-Object -Property Validation -Sum).Sum -gt 0) { Write-Host "[ECHEC] messages de validation Vulkan presents"; exit 3 } diff --git a/tools/profile_phase29.ps1 b/tools/profile_phase29.ps1 new file mode 100644 index 0000000..1ee12be --- /dev/null +++ b/tools/profile_phase29.ps1 @@ -0,0 +1,103 @@ +# =========================================================================== +# PHASE 29 (Agent 2) - cout des rochers : A = jeu normal, B = --no-rocks. +# Derive de profile_phase27.ps1 (memes lecons : A/B ENTRELACES, sante machine), +# avec deux differences : +# - arret UNIQUEMENT par PID exact (WM_CLOSE puis Kill du PID lance) ; aucun +# Stop-Process par nom, et refus de demarrer si un vercora tourne deja ; +# - RAM : working set et pic de working set du processus, lus juste avant la +# fermeture. +# Usage : powershell -File tools\profile_phase29.ps1 -View alpage -Rounds 3 +# Vues : alpage (zone de reference de la Phase 27, 900500,6439000, regard -8) +# pierrier (903452,6439601 : echantillon 4 de NOTES-PHASE29-DESIGN.md) +# =========================================================================== +param( + [ValidateSet("alpage", "pierrier", "buissons")][string]$View = "alpage", + # Agent 3 : option temoin de la condition B (--no-rocks par defaut, --no-bushes pour les buissons). + [string]$Toggle = "--no-rocks", + [int]$Rounds = 3, + [int]$Seconds = 25, + [string]$OutCsv = "build\phase29\profil.csv" +) +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$exe = Join-Path $root "build\vercora.exe" +$scenePath = Join-Path $root "assets\terrain\vercora_zone_1m.vchm" +$csv = Join-Path $root $OutCsv +New-Item -ItemType Directory -Force -Path (Split-Path -Parent $csv) | Out-Null +Add-Type @" +using System; +using System.Runtime.InteropServices; +public class W32P29 { + [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); +} +"@ +$start = switch ($View) { "alpage" { "--start=900500,6439000" } "pierrier" { "--start=903452,6439601" } "buissons" { "--start=901160,6436275" } } +$common = @($start, "--look=-90,-8", "--day=12", "--hour=13", "--time-scale=0", "--lock-input") +$cores = [Environment]::ProcessorCount + +function Invoke-Run([string]$label, [string[]]$extra) { + if (Get-Process -Name "vercora" -ErrorAction SilentlyContinue) { throw "un vercora tourne deja : refus de mesurer" } + $log = Join-Path (Split-Path -Parent $csv) ("run_{0}_{1}_{2}.log" -f $View, $label, [DateTime]::Now.ToString("HHmmss")) + $gameArgs = @("`"$scenePath`"") + $common + @($extra | Where-Object { $_ }) + $proc = Start-Process -FilePath $exe -ArgumentList $gameArgs -WorkingDirectory $root ` + -RedirectStandardOutput $log -RedirectStandardError "$log.err" -PassThru + $hwnd = [IntPtr]::Zero + for ($i = 0; $i -lt 900 -and $hwnd -eq [IntPtr]::Zero; $i++) { + $proc.Refresh(); if ($proc.HasExited) { break } + if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle } + Start-Sleep -Milliseconds 100 + } + if ($hwnd -eq [IntPtr]::Zero) { throw "pas de fenetre ($label)" } + $proc.Refresh(); $cpu0 = $proc.TotalProcessorTime.TotalSeconds; $s0 = [DateTime]::Now + $loads = @() + while (([DateTime]::Now - $s0).TotalSeconds -lt $Seconds) { + Start-Sleep -Milliseconds 1500 + $loads += [double](Get-CimInstance Win32_PerfFormattedData_PerfOS_Processor -Filter "Name='_Total'").PercentProcessorTime + } + $proc.Refresh() + $wall = ([DateTime]::Now - $s0).TotalSeconds + $others = [math]::Max(0.0, ($loads | Measure-Object -Average).Average * $cores - 100.0 * ($proc.TotalProcessorTime.TotalSeconds - $cpu0) / $wall) + $wsMb = $proc.WorkingSet64 / 1MB; $peakMb = $proc.PeakWorkingSet64 / 1MB; $privMb = $proc.PrivateMemorySize64 / 1MB + [void][W32P29]::PostMessage($hwnd, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero) + if (-not $proc.WaitForExit(30000)) { Stop-Process -Id $proc.Id -Force; $proc.WaitForExit() } + $text = Get-Content $log -Raw + $cad = [regex]::Match($text, "Cadence de boucle \(PHASE 27\) : (\d+) images en ([\d.]+) s, soit ([\d.]+) images/s, ([\d.]+) us par image") + $rk = [regex]::Match($text, "semis ([\d.]+) us par image ; derniere image (\d+) gros blocs, (\d+) rochers, (\d+) plaques") + $bu = [regex]::Match($text, "Buissons \(PHASE 29\) : semis ([\d.]+) us par image ; derniere image (\d+) buissons, (\d+) petits arbres") + $validation = ([regex]::Matches($text, "\[Validation\]")).Count + if (-not $cad.Success) { throw "bilan absent ($label) : $log" } + $fps = [double]$cad.Groups[3].Value + $verdict = if ($others -gt 100.0) { "NON CONCLUANT (autres {0:N0} %)" -f $others } else { "OK" } + $row = [pscustomobject]@{ + View = $View; Condition = $label; ImgParS = $fps; UsParImage = [double]$cad.Groups[4].Value + RochersUs = $(if ($rk.Success) { [double]$rk.Groups[1].Value } else { 0 }) + Blocs = $(if ($rk.Success) { [int]$rk.Groups[2].Value } else { 0 }) + Rochers = $(if ($rk.Success) { [int]$rk.Groups[3].Value } else { 0 }) + Plaques = $(if ($rk.Success) { [int]$rk.Groups[4].Value } else { 0 }) + WsMo = [math]::Round($wsMb, 1); PicMo = [math]::Round($peakMb, 1); PriveMo = [math]::Round($privMb, 1) + BuissonsUs = $(if ($bu.Success) { [double]$bu.Groups[1].Value } else { 0 }) + Buissons = $(if ($bu.Success) { [int]$bu.Groups[2].Value } else { 0 }) + PetitsArbres = $(if ($bu.Success) { [int]$bu.Groups[3].Value } else { 0 }) + AutresPctCoeur = [math]::Round($others, 1); Validation = $validation; Verdict = $verdict + } + $row | Export-Csv -Path $csv -Append -NoTypeInformation -Encoding UTF8 + if ($bu.Success) { Write-Host (" buissons {0:N1} us, {1} buissons, {2} petits arbres" -f $row.BuissonsUs, $row.Buissons, $row.PetitsArbres) } + Write-Host ("{0,-8} {1} {2,7:N1} img/s {3,8:N1} us/img rochers {4,6:N1} us ({5}/{6}/{7}) WS {8:N0} Mo pic {9:N0} autres {10:N0}% valid {11} {12}" -f ` + $View, $label, $fps, $row.UsParImage, $row.RochersUs, $row.Blocs, $row.Rochers, $row.Plaques, $wsMb, $peakMb, $others, $validation, $verdict) + return $row +} + +$rows = @() +for ($r = 1; $r -le $Rounds; $r++) { + $order = if ($r % 2 -eq 1) { @("A", "B") } else { @("B", "A") } + foreach ($c in $order) { $rows += Invoke-Run $c $(if ($c -eq "A") { @() } else { @($Toggle) }) } +} +function Med($xs) { $s = @($xs | Sort-Object); if ($s.Count -eq 0) { return [double]::NaN }; return $s[[int][math]::Floor(($s.Count - 1) / 2)] } +$ok = $rows | Where-Object { $_.Verdict -eq "OK" } +foreach ($c in "A", "B") { + $x = $ok | Where-Object { $_.Condition -eq $c } + Write-Host ("MEDIANE {0} : {1:N1} img/s, {2:N1} us/img, WS {3:N0} Mo, pic {4:N0} Mo (min/max img/s {5:N1}/{6:N1})" -f $c, + (Med ($x | % { $_.ImgParS })), (Med ($x | % { $_.UsParImage })), (Med ($x | % { $_.WsMo })), (Med ($x | % { $_.PicMo })), + (($x | Measure-Object ImgParS -Minimum).Minimum), (($x | Measure-Object ImgParS -Maximum).Maximum)) +} +if (($rows | Measure-Object -Property Validation -Sum).Sum -gt 0) { Write-Host "[ECHEC] messages de validation Vulkan"; exit 3 } diff --git a/tools/profile_tiles.ps1 b/tools/profile_tiles.ps1 new file mode 100644 index 0000000..4d4bfde --- /dev/null +++ b/tools/profile_tiles.ps1 @@ -0,0 +1,124 @@ +# profile_tiles.ps1 - releve le PROFIL DE CONSTRUCTION DES TUILES sur un survol. +# +# PHASE 19. La Phase 18 a montre que le chronometrage cumule de +# TerrainStreamer::buildProfile() est BEAUCOUP plus stable que le FPS lu dans le +# titre de la fenetre (moins de 0,5 % d'ecart entre deux passages, contre ~15 % +# pour le FPS - voir MEMORY.md). C'est donc lui, et non le FPS, qui doit servir a +# juger une optimisation du chemin de streaming. +# +# La Phase 18 relevait ces lignes a la main dans la sortie du jeu. Ce script les +# extrait, ce qui rend le releve reproductible et comparable d'une phase a +# l'autre - exactement ce que measure_terrain.ps1 a fait pour le FPS en Phase 9. +# +# Usage : +# powershell -File tools\profile_tiles.ps1 -Scene terrain -Seconds 45 ` +# -GameArgs @('--flythrough=900','--no-grass') +# +# Le jeu est ferme par WM_CLOSE, ce qui est indispensable : le bilan est +# journalise A LA DESTRUCTION du TerrainStreamer. Un processus tue n'ecrit rien. + +param( + [Parameter(Mandatory = $true)][string]$Scene, + [int]$Seconds = 45, + [string[]]$GameArgs = @(), + # Repetitions du meme run. La Phase 18 en faisait deux systematiquement pour + # pouvoir affirmer la stabilite du chiffre plutot que de la supposer. + [int]$Runs = 1 +) + +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$exe = Join-Path $root "build\vercora.exe" +if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe (lancer tools\build.bat)" } + +Add-Type @" +using System; +using System.Runtime.InteropServices; +public class W32P { + [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); +} +"@ +$WM_CLOSE = 0x0010 + +for ($run = 1; $run -le $Runs; $run++) { + Write-Host ("=== Profil tuiles : {0} {1}(passage {2}/{3}) ===" -f ` + $Scene, $(if ($GameArgs.Count) { ($GameArgs -join ' ') + ' ' } else { '' }), $run, $Runs) + + $psi = New-Object System.Diagnostics.ProcessStartInfo + $psi.FileName = $exe + $psi.Arguments = (@('"' + $Scene + '"') + $GameArgs) -join ' ' + $psi.WorkingDirectory = $root + $psi.UseShellExecute = $false + $psi.RedirectStandardOutput = $true + $psi.RedirectStandardError = $true + + $proc = [System.Diagnostics.Process]::Start($psi) + $outSb = New-Object System.Text.StringBuilder + $handlers = @( + (Register-ObjectEvent -InputObject $proc -EventName OutputDataReceived -Action { + if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) } + } -MessageData $outSb), + (Register-ObjectEvent -InputObject $proc -EventName ErrorDataReceived -Action { + if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) } + } -MessageData $outSb) + ) + $proc.BeginOutputReadLine() + $proc.BeginErrorReadLine() + + $hwnd = [IntPtr]::Zero + for ($i = 0; $i -lt 600 -and $hwnd -eq [IntPtr]::Zero; $i++) { + $proc.Refresh() + if ($proc.HasExited) { break } + if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle } + Start-Sleep -Milliseconds 100 + } + if ($hwnd -eq [IntPtr]::Zero) { + $proc.WaitForExit() + Start-Sleep -Milliseconds 300 + foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue } + Write-Host $outSb.ToString() + Write-Host "[ECHEC] Pas de fenetre." + exit 1 + } + + Start-Sleep -Seconds $Seconds + + $proc.Refresh() + $peakMb = [math]::Round($proc.PeakWorkingSet64 / 1MB, 1) + [void][W32P]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero) + if (-not $proc.WaitForExit(60000)) { + Write-Host "[ECHEC] Pas de sortie 60 s apres WM_CLOSE." + $proc.Kill(); $proc.WaitForExit() + $code = 1 + } else { + $code = $proc.ExitCode + } + Start-Sleep -Milliseconds 400 + foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue } + + $text = $outSb.ToString() + $lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' }) + + # Une meme ligne peut satisfaire plusieurs motifs (le bilan de construction + # porte aussi le bilan de parallelisme) : on deduplique, sinon le releve + # affiche deux fois le meme chiffre, ce qui invite a le lire deux fois. + $shown = @{} + foreach ($pattern in @('Construction de tuiles', + 'Trous de streaming', + 'Streaming terrain : pics', + 'Cout par image')) { + foreach ($l in ($lines | Where-Object { $_ -match $pattern })) { + if (-not $shown.ContainsKey($l)) { $shown[$l] = $true; Write-Host " | $l" } + } + } + + $validation = @($lines | Where-Object { $_ -match '\[Validation\]' }) + $errors = @($lines | Where-Object { $_ -match '\[ERROR\]|\[WARN\]' }) + Write-Host (" validation Vulkan : {0} message(s) [Validation], {1} [ERROR]/[WARN]" -f ` + $validation.Count, $errors.Count) + foreach ($l in ($validation + $errors) | Select-Object -First 12) { Write-Host " $l" } + Write-Host (" pic memoire : {0} Mo, code de sortie : {1}" -f $peakMb, $code) + + if ($validation.Count -gt 0 -or $code -ne 0) { exit 1 } +} +exit 0 diff --git a/tools/run_logic_tests.bat b/tools/run_logic_tests.bat new file mode 100644 index 0000000..89df2fe --- /dev/null +++ b/tools/run_logic_tests.bat @@ -0,0 +1,215 @@ +@echo off +rem =========================================================================== +rem Harnais de tests HEADLESS de la logique de jeu (aucun GPU, aucun Vulkan). +rem =========================================================================== +rem Pourquoi ce script existe alors que le projet a deja un CMakeLists : +rem find_package(Vulkan REQUIRED) fait echouer la CONFIGURATION du projet +rem entier quand le SDK Vulkan n'est pas installe sur la machine. Or toute la +rem logique de jeu (src/world, src/assets, src/core hors Window) ne depend que +rem de GLM. Ce script la compile donc seule, directement avec cl.exe, ce qui +rem permet de tester le gameplay meme sans SDK ni carte graphique. +rem +rem Ce n'est PAS un substitut au build normal : il ne verifie ni le rendu, ni les +rem couches de validation Vulkan. Le build de reference reste CMake + cmake +rem --build sur le CMakeLists de la racine. +rem +rem Usage : tools\run_logic_tests.bat +rem Sortie : build-tests\logic_tests.exe (code de retour 0 = tout passe) +rem =========================================================================== + +setlocal + +rem --- Environnement compilateur --------------------------------------------- +rem VS 18 Community. Adapter ce chemin si l'edition installee change ; le script +rem echoue clairement plutot que de compiler avec un compilateur inattendu. +set "VCVARS=C:\Program Files\Microsoft Visual Studio\18\Community\VC\Auxiliary\Build\vcvars64.bat" +if not exist "%VCVARS%" ( + echo [ERREUR] vcvars64.bat introuvable : "%VCVARS%" + echo Adapter VCVARS dans tools\run_logic_tests.bat. + exit /b 1 +) +call "%VCVARS%" >nul 2>&1 + +rem --- Racine du projet (le script vit dans tools\) --------------------------- +set "ROOT=%~dp0.." +pushd "%ROOT%" + +rem GLM est deja en cache dans external\ (recupere par FetchContent lors d'un +rem build CMake anterieur) : aucun telechargement n'est necessaire ici. +set "GLM_DIR=%ROOT%\external\glm-src" +if not exist "%GLM_DIR%\glm\glm.hpp" ( + echo [ERREUR] GLM introuvable dans "%GLM_DIR%". + echo Lancer une fois le build CMake complet pour peupler external\. + popd + exit /b 1 +) + +rem GLFW aussi est deja en cache : ses headers permettent de compiler Window.hpp, +rem donc core/Camera.cpp, ou vit la resolution des collisions. +set "GLFW_DIR=%ROOT%\external\glfw-src\include" +if not exist "%GLFW_DIR%\GLFW\glfw3.h" ( + echo [ERREUR] GLFW introuvable dans "%GLFW_DIR%". + popd + exit /b 1 +) + +rem Vulkan SDK : necessaire uniquement aux verifications de syntaxe ci-dessous +rem (Camera.cpp et main.cpp incluent des en-tetes Vulkan). Jusqu'au 2026-08-15 un +rem shim maison sous tests\shim\ remplacait ces declarations, faute de SDK +rem installe ; le SDK etant de retour, on utilise les VRAIS en-tetes et le shim a +rem ete supprime. Les tests d'execution, eux, n'ont jamais eu besoin de Vulkan. +if not defined VULKAN_SDK ( + for /f "tokens=2,*" %%A in ('reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v VULKAN_SDK 2^>nul ^| find "VULKAN_SDK"') do set "VULKAN_SDK=%%B" +) +if not exist "%VULKAN_SDK%\Include\vulkan\vulkan.h" ( + echo [ERREUR] SDK Vulkan introuvable ^(VULKAN_SDK="%VULKAN_SDK%"^). + echo winget install --id KhronosGroup.VulkanSDK + popd + exit /b 1 +) + +if not exist "build-tests" mkdir "build-tests" + +rem --- Etape 1 : verification de SYNTAXE ------------------------------------- +rem Trois unites qui ne peuvent pas entrer dans l'executable de test mais dont on +rem veut au moins garantir qu'elles compilent (/Zs = syntaxe seule, aucun code +rem genere) : +rem - Camera.cpp heberge la resolution des collisions, mais inclut Window.hpp +rem donc GLFW donc . +rem - ObjLoader.cpp ne depend plus de Vulkan depuis que le format de sommet a +rem ete sorti de Vertex.hpp (voir VertexFormat.hpp). Le verifier ici est ce +rem qui empeche cette separation de se redegrader sans qu'on s'en apercoive. +rem - main.cpp est le point ou tout le gameplay est cable au Renderer : c'est +rem le fichier le plus expose a une faute de frappe, et le seul qu'aucun test +rem d'execution ne couvre. +rem +rem TerrainStreamer.cpp (Phase 10) est verifie en SYNTAXE seulement : il pilote le +rem Renderer, donc Vulkan. Le quadtree lui-meme (TerrainQuadtree.cpp) et le +rem maillage par tuile (TerrainNodeMesh.cpp), eux, ne dependent que de GLM et sont +rem compiles ET executes dans les tests ci-dessous - c'est la meme separation qui +rem avait permis de tester la Phase 7 sans GPU. +rem +rem TerrainMesh.cpp etait ici jusqu'a la Phase 7 ; il est desormais COMPILE ET +rem LIE dans l'executable de test, ou les tests de heightmap l'exercent +rem reellement. Une verification de syntaxe serait redondante et plus faible. +echo [1/2] Verification de syntaxe +cl /nologo /std:c++20 /EHsc /W4 /Zs ^ + /DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE /DGLFW_INCLUDE_VULKAN ^ + /I "src" /I "%GLM_DIR%" /I "%GLFW_DIR%" /I "%VULKAN_SDK%\Include" ^ + "src\core\Camera.cpp" +if errorlevel 1 goto :syntax_failed + +rem PHASE 15 : ObjLoader.cpp etait ici en verification de SYNTAXE seulement. Il +rem est desormais COMPILE ET LIE dans l'executable de test, parce que +rem editor\AssetCatalog.cpp l'appelle pour charger les modeles du dossier +rem d'assets - et que le scan du catalogue est justement l'une des choses que ces +rem tests exercent. Une verification de syntaxe serait redondante et plus faible, +rem exactement comme pour TerrainMesh.cpp depuis la Phase 7. + +rem SHADERS_OUTPUT_DIR et ASSETS_DIR sont normalement fournis par CMake. Des +rem valeurs bidon suffisent : on ne verifie ici que la syntaxe, aucun chemin +rem n'est ouvert. +cl /nologo /std:c++20 /EHsc /W4 /Zs ^ + /DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE /DGLFW_INCLUDE_VULKAN ^ + /I "src" /I "%GLM_DIR%" /I "%GLFW_DIR%" /I "%VULKAN_SDK%\Include" ^ + "src\renderer\TerrainStreamer.cpp" +if errorlevel 1 goto :syntax_failed + +rem PHASE 11 : Texture.cpp cree des images Vulkan, donc verification de +rem SYNTAXE seulement, comme TerrainStreamer.cpp juste au-dessus. Le CHARGEUR +rem du format (TextureFile.cpp), lui, ne depend que de la bibliotheque +rem standard : il est compile ET EXECUTE dans les tests plus bas. +cl /nologo /std:c++20 /EHsc /W4 /Zs ^ + /DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE /DGLFW_INCLUDE_VULKAN ^ + /I "src" /I "%GLM_DIR%" /I "%GLFW_DIR%" /I "%VULKAN_SDK%\Include" ^ + "src\renderer\Texture.cpp" +if errorlevel 1 goto :syntax_failed + +cl /nologo /std:c++20 /EHsc /W4 /Zs ^ + /DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE /DGLFW_INCLUDE_VULKAN ^ + /DSHADERS_OUTPUT_DIR=\"shim\" /DASSETS_DIR=\"shim\" ^ + /I "src" /I "%GLM_DIR%" /I "%GLFW_DIR%" /I "%ROOT%\external\tinyobjloader-src" ^ + /I "%VULKAN_SDK%\Include" ^ + "src\main.cpp" +if errorlevel 1 goto :syntax_failed + +goto :syntax_ok + +:syntax_failed +echo. +echo [ECHEC] Verification de syntaxe. +popd +exit /b 1 + +:syntax_ok + +rem --- Etape 2 : compilation et execution des tests --------------------------- +echo [2/2] Compilation et execution des tests +rem /W4 : on veut voir les avertissements sur du code neuf. +rem GLM_FORCE_* : memes definitions que la cible vercora, pour que la logique +rem testee soit bit a bit celle qui tournera dans le jeu. +rem ASSETS_DIR : meme definition que la cible CMake, pour que les tests puissent +rem retrouver la dalle LiDAR reelle si elle a ete produite. Son absence n'est pas +rem une erreur - le bloc de tests correspondant s'ignore de lui-meme. +cl /nologo /std:c++20 /EHsc /W4 /Zi ^ + /DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE ^ + /DASSETS_DIR="\"%ROOT:\=/%/assets\"" ^ + /I "src" /I "%GLM_DIR%" /I "%ROOT%\external\tinyobjloader-src" ^ + /Fo"build-tests\\" /Fd"build-tests\logic_tests.pdb" /Fe"build-tests\logic_tests.exe" ^ + "tests\logic_tests.cpp" ^ + "src\assets\Heightmap.cpp" ^ + "src\assets\TerrainFile.cpp" ^ + "src\renderer\TerrainMesh.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\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\world\Vegetation.cpp" ^ + "src\world\GrassMesh.cpp" ^ + "src\assets\TextureFile.cpp" ^ + "src\assets\DetailNoise.cpp" ^ + "src\renderer\TerrainNodeMesh.cpp" ^ + "src\assets\ObjLoader.cpp" ^ + "src\editor\EditorAssets.cpp" ^ + "src\editor\AssetCatalog.cpp" ^ + "src\editor\EditorScene.cpp" ^ + "src\editor\EditorController.cpp" ^ + "src\editor\SceneFile.cpp" + +if errorlevel 1 ( + echo. + echo [ECHEC] Compilation des tests. + popd + exit /b 1 +) + +echo. +"build-tests\logic_tests.exe" +set "RC=%ERRORLEVEL%" +popd +exit /b %RC% + + diff --git a/tools/run_vulkan_check.ps1 b/tools/run_vulkan_check.ps1 new file mode 100644 index 0000000..a9251bc --- /dev/null +++ b/tools/run_vulkan_check.ps1 @@ -0,0 +1,2526 @@ +# =========================================================================== +# Verification du VRAI executable Vulkan et de ses couches de validation. +# =========================================================================== +# Lance build\vercora.exe (build Debug => VERCORA_DEBUG => couche +# VK_LAYER_KHRONOS_validation active), pilote sa fenetre par l'API Win32, puis +# analyse la sortie a la recherche de messages "[Validation]". +# +# Dix scenarios (A a J), dans QUATORZE PROCESSUS distincts (G en compte trois, +# J en compte trois) : +# A. Gameplay complet sur le terrain SYNTHETIQUE : pierres, percussion, +# abattage, ramassage, puis resize, minimisation et fermeture propre. +# B. Sonde de collision seule, depuis l'origine, terrain synthetique. +# C. Dalle LiDAR HD REELLE (Phase 7) : 2 millions de triangles, marche sur le +# relief mesure, abattage et ramassage, resize et fermeture propre. +# D. Vol en parapente sur la dalle reelle (Phase 8). +# E. Sortie a VELO sur la dalle reelle (Phase 13) : descente puis montee sur +# un versant mesure, avec freinage et demi-tour. +# F. ESCALADE sur une paroi mesuree (Phase 14). +# G. EDITEUR DE NIVEAU (Phase 15), en TROIS processus : edition (pose, +# selection, reglage, suppression, annulation, sauvegarde, rechargement), +# puis relecture de la scene dans une partie NORMALE, puis un TEMOIN qui +# refait exactement la meme marche sans la scene. C'est l'ecart entre les +# deux dernieres qui prouve que les objets poses bloquent le joueur. +# J. RECOLTE DE MATIERES (Phase 22), en TROIS processus : creuser un +# gisement detecte par le jeu lui-meme, ramasser la motte produite, puis +# reessayer a 30 m - le meme test de portee dans les deux sens que le +# scenario H ; puis, sur la zone de 25 km2 (la seule qui ait une carte de +# couvert), arracher une plante a fibres poussee EN LISIERE et verifier +# qu'elle est en REPOUSSE et non disparue. +# H. BESOINS PRIMAIRES (Phase 16) : depart sur un point d'eau detecte par le +# jeu lui-meme, deux touches T (a portee puis a 30 m) qui exercent le test +# de portee dans les deux sens, puis 100 s de marche et 60 s d'immobilite - +# la telemetrie doit montrer la forme descendre PUIS remonter. +# +# Le scenario B est separe parce que la position du joueur ne se pilote qu'a +# l'estime : chaque collision rencontree en chemin decale la camera par rapport +# au modele du script, et cette derive s'accumule. En repartant d'un processus +# neuf, la position de depart est connue EXACTEMENT (l'origine), ce qui rend la +# sonde decisive au lieu d'ambigue. +# +# Le scenario C est separe pour une autre raison : le terrain synthetique reste +# le monde de REFERENCE des scenarios A et B (semis deterministe, positions +# connues d'avance), et il faut pouvoir prouver qu'il n'a pas regresse. Le +# scenario C ajoute ce que lui seul peut montrer : un maillage 60 fois plus gros +# passe sous les couches de validation, un relief de 562 m de denivele sous les +# pieds, et un semis d'arbres refait sur ce relief. Il est ignore, sans faire +# echouer le script, si la dalle n'a pas ete produite (elle n'est pas versionnee). +# +# Pilotage par PostMessage plutot que par automatisation clavier/souris globale : +# les evenements vont DIRECTEMENT a la fenetre visee, sans dependre du focus et +# sans voler la souris a l'utilisateur. +# +# Le monde etant seme de facon DETERMINISTE (graines fixes), "vercora.exe +# --dump-world" donne a l'avance la position des arbres et des pierres. Le script +# vise donc de vraies cibles au lieu d'appuyer sur les touches a l'aveugle : +# c'est la difference entre "j'ai appuye sur R" et "j'ai ramasse une buche". +# +# Ce dump etait un executable separe (tools\dump_world.cpp) jusqu'a la Phase 7 ; +# c'est desormais un MODE du jeu, donc le meme code exactement - voir le +# commentaire de dumpWorld() dans src\main.cpp. +# +# La FERMETURE est un vrai WM_CLOSE (ce que fait la croix de la fenetre) et non +# un kill : c'est la seule facon de verifier la destruction propre des objets +# Vulkan, precisement ce que les couches de validation signalent si elle est +# incorrecte. +# +# Usage : powershell -ExecutionPolicy Bypass -File tools\run_vulkan_check.ps1 +# Code de retour : 0 si tout est vert. +# =========================================================================== + +# -Only permet de ne lancer qu'une partie des scenarios : +# powershell -File tools\run_vulkan_check.ps1 -Only G +# powershell -File tools\run_vulkan_check.ps1 -Only A,B +# +# Ajoute en Phase 15 pour une raison tres concrete : la suite complete prend une +# quinzaine de minutes, et mettre au point UN scenario en payant les sept autres a +# chaque essai decourage de le faire correctement. Le verdict final reste +# calcule sur les seuls scenarios joues - un scenario non joue est traite comme +# une dalle absente, c'est-a-dire ignore et non echoue. Un run de reference se +# fait donc TOUJOURS sans -Only. +param([string[]]$Only = @()) + +$ErrorActionPreference = "Stop" + +$runAll = ($Only.Count -eq 0) +function Should-Run([string]$name) { return $runAll -or ($Only -contains $name) } +if (-not $runAll) { + Write-Host "ATTENTION : execution PARTIELLE ($($Only -join ', ')). Les scenarios" + Write-Host " non joues sont ignores, pas valides. Pour un verdict de" + Write-Host " reference, relancer sans -Only." +} + +$root = Split-Path -Parent $PSScriptRoot +$exe = Join-Path $root "build\vercora.exe" +if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe. Lancer tools\build.bat d'abord." } + +# --- Monde attendu --------------------------------------------------------- +# Le dump rejoue le semis avec la MEME heightmap que le jeu - et pour cause, +# c'est le jeu. Indispensable depuis la Phase 7 : le filtre de pente rejette des +# emplacements differents selon le relief, donc les arbres ne tombent pas au meme +# endroit sur la dalle reelle que sur le terrain synthetique. +# +# Renvoie les objets du monde ET les positions de tir. Une ligne +# "AIM i camX camZ recul pitchDeg elevation" signifie : depuis (camX, camZ), en +# visant le tronc de l'arbre i avec le pitch indique (pitch inclus, pas +# seulement un rayon horizontal - corrige en Phase 8), Forest::pickTree designe +# REELLEMENT l'arbre i. C'est la fonction de visee du jeu qui l'a dit, pas une +# estimation du script. +function Get-World([string]$terrainArg = "") { + $lines = if ($terrainArg -ne "") { & $exe --dump-world $terrainArg 2>$null } + else { & $exe --dump-world 2>$null } + $entries = @() + $aims = @() + $levelAims = @() + $lines | ForEach-Object { + $p = $_ -split '\s+' + if ($p.Count -eq 7 -and $p[0] -eq 'AIM') { + $aims += [pscustomobject]@{ + Index = [int]$p[1]; CamX = [double]$p[2]; CamZ = [double]$p[3] + Standoff = [double]$p[4]; PitchDeg = [double]$p[5]; Elevation = $p[6] + CamDist = [Math]::Sqrt([double]$p[2] * [double]$p[2] + [double]$p[3] * [double]$p[3]) + } + } elseif ($p.Count -eq 5 -and $p[0] -eq 'AIMLEVEL') { + $levelAims += [pscustomobject]@{ + Index = [int]$p[1]; CamX = [double]$p[2]; CamZ = [double]$p[3] + Standoff = [double]$p[4] + CamDist = [Math]::Sqrt([double]$p[2] * [double]$p[2] + [double]$p[3] * [double]$p[3]) + } + } elseif ($p.Count -eq 5 -and $p[0] -ne '[INFO]') { + $entries += [pscustomobject]@{ + Kind = $p[0]; X = [double]$p[1]; Z = [double]$p[2] + Dist = [double]$p[3]; Bearing = [double]$p[4] + } + } + } + return [pscustomobject]@{ Objects = $entries; Aims = $aims; LevelAims = $levelAims } +} + +# Les arbres sont nommes TREE : l'indice est celui que le jeu +# journalise, ce qui permet de verifier apres coup qu'on a abattu l'arbre VISE +# et non un autre - le controle le plus direct de la precision du pilotage. +# "terrain" explicite : sans argument, le jeu charge desormais la dalle LiDAR. +$world = (Get-World "terrain").Objects +$trees = @($world | Where-Object { $_.Kind -like 'TREE*' }) +$stones = @($world | Where-Object { $_.Kind -eq 'pierre' }) +Write-Host "Monde synthetique attendu : $($trees.Count) arbres, $($stones.Count) pierres." + +# Dalle LiDAR reelle : celle que le jeu charge par defaut (cf. main.cpp). +$lidarTile = Join-Path $root "assets\terrain\LHD_0907_6440_1m.vchm" + +# PHASE 22. La zone de 25 km2 est la SEULE dont la carte de couvert LiDAR soit +# produite, et c'est cette carte qui porte la voie "lisiere" du semis de plantes +# a fibres. Elle n'est pas versionnee : son absence fait sauter J3 sans faire +# echouer le script, exactement comme l'absence de la dalle fait sauter C a I. +$zoneTile = Join-Path $root "assets\terrain\vercora_zone_2m.vchm" +$hasZone = Test-Path $zoneTile +$hasLidar = Test-Path $lidarTile +if ($hasLidar) { + $lidarDump = Get-World $lidarTile + $lidarTrees = @($lidarDump.Objects | Where-Object { $_.Kind -like 'TREE*' }) + + # Preuve de la Phase 8 : avec un rayon de visee pitch-inclus (au lieu de + # l'ancien rayon horizontal), Forest::pickTree retrouve les arbres en + # contrebas ET en amont, pas seulement ceux au niveau de l'oeil. + $above = @($lidarDump.Aims | Where-Object { $_.Elevation -eq 'au-dessus' }) + $below = @($lidarDump.Aims | Where-Object { $_.Elevation -eq 'en-dessous' }) + $level = @($lidarDump.Aims | Where-Object { $_.Elevation -eq 'au-niveau' }) + Write-Host ("Dalle LiDAR trouvee : {0} arbres semes sur le relief reel, {1} abattables au total " -f + $lidarTrees.Count, $lidarDump.Aims.Count) -NoNewline + Write-Host ("(niveau={0}, au-dessus={1}, en-dessous={2})." -f $level.Count, $above.Count, $below.Count) + + # Le tir REEL de ce script, lui, ne peut viser qu'au pitch nul : la camera ne + # tourne jamais pendant ce process (voir plus bas, "Navigation : uniquement + # au clavier") puisque GLFW lit le curseur SYSTEME et non les messages + # postes - tourner la camera volerait la souris de l'utilisateur. On utilise + # donc AIMLEVEL (rayon horizontal, comme avant la Phase 8) pour choisir la + # cible du tir reellement joue, et non les entrees AIM ci-dessus - celles-ci + # ne servent qu'a PROUVER que pickTree sait viser en hauteur. + $lidarAim = @($lidarDump.LevelAims | Sort-Object CamDist) | Select-Object -First 1 + if ($null -eq $lidarAim) { + Write-Host "[ATTENTION] Aucun arbre abattable au pitch nul : scenario C ignore le tir reel." + } +} else { + Write-Host "Dalle LiDAR absente ($lidarTile) : scenario C ignore." + Write-Host " Pour la produire : python tools/lidar_to_heightmap.py data/lidar/.copc.laz -o `"$lidarTile`" --cell 1.0" +} + +Add-Type @" +using System; +using System.Runtime.InteropServices; +public static class W32 { + [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); + [DllImport("user32.dll")] public static extern bool SetWindowPos(IntPtr h, IntPtr a, int x, int y, int cx, int cy, uint f); + [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr h, int cmd); + [DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetWindowTextW(IntPtr h, System.Text.StringBuilder s, int n); +} +"@ + +# =========================================================================== +# COLLECTEUR DE JOURNAL : un delegue .NET COMPILE, pas un script-block +# =========================================================================== +# Jusqu'a la Phase 22, la sortie du jeu etait capturee par +# `Register-ObjectEvent -Action { ... }`, c'est-a-dire UN SCRIPT-BLOCK +# POWERSHELL EXECUTE PAR LIGNE DE JOURNAL. Ces blocs ne tournent que quand le +# runspace est disponible ; or les scenarios passent leur temps dans des +# `Start-Sleep` et des boucles d'attente. Les evenements s'empilent, et le +# tampon que `Wait-ForLog` interroge est EN RETARD sur ce que le jeu a +# reellement ecrit. Le retard CROIT avec la duree du scenario. +# +# Ce n'etait pas une hypothese : mesure faite le 2026-08-27, meme binaire, meme +# dalle, meme sortie a velo, seul le collecteur changeant - +# +# collecteur "Velo : en selle" "Velo : pied a terre" +# Register-ObjectEvent -Action 1833 ms jamais vu en 3 s (9,6 s) +# delegue .NET (ci-dessous) 5 ms 0 ms +# +# C'est TOUTE l'explication de la dette du scenario E, ouverte en Phase 17 et +# rejouee a chaque phase depuis : le jeu journalisait bien "Velo : pied a +# terre." - la ligne EST dans $runE.Lines apres coup - mais elle n'arrivait au +# script qu'apres l'expiration des 3 s de Wait-ForLog. LE JEU N'A JAMAIS EU DE +# DEFAUT ; c'est l'instrument de mesure qui regardait trop tot. +# +# Nota : "en selle" tenait dans son budget a 1833 ms, soit 61 % des 3 s. Le +# defaut menacait donc TOUS les Wait-ForLog du harnais, pas seulement celui du +# velo ; le scenario E etait simplement le plus long, donc le premier a franchir +# le seuil. Elargir le delai aurait masque cela au lieu de le resoudre. +# +# Le puits se branche LUI-MEME (Attach) : PowerShell 5.1 ne sait pas convertir +# une PSMethod en DataReceivedEventHandler, le delegue est donc construit du +# cote C#. ToString() est surcharge pour que les appelants (Wait-ForLog, +# Get-BikeHeading, Wait-BikeSample, Stop-Game, scenario F) restent INCHANGES : +# tous appelaient deja .ToString() sur le StringBuilder d'avant. +Add-Type @" +using System; +using System.Text; +using System.Diagnostics; +public class VercoraLogSink { + private readonly StringBuilder sb = new StringBuilder(); + private readonly object gate = new object(); + private void OnData(object sender, DataReceivedEventArgs e) { + if (e.Data == null) return; + lock (gate) { sb.AppendLine(e.Data); } + } + public void Attach(Process p, bool standardOutput) { + if (standardOutput) { p.OutputDataReceived += new DataReceivedEventHandler(OnData); } + else { p.ErrorDataReceived += new DataReceivedEventHandler(OnData); } + } + public override string ToString() { lock (gate) { return sb.ToString(); } } +} +"@ + +$WM_KEYDOWN=0x0100; $WM_KEYUP=0x0101; $WM_CLOSE=0x0010 +$SWP_NOMOVE=0x0002; $SWP_NOZORDER=0x0004 + +# --- Touches designees par leur SCANCODE, jamais par leur code virtuel ------- +# Piege qui a coute cher ici : MapVirtualKeyW(VK, MAPVK_VK_TO_VSC) traduit selon +# la DISPOSITION CLAVIER ACTIVE. Sur l'AZERTY francais de cette machine, VK_W +# (0x57) designe la touche gravee W, qui occupe la position physique du Z d'un +# QWERTY. GLFW, lui, raisonne en positions physiques : il recevait donc +# GLFW_KEY_Z quand on croyait envoyer W, et le jeu - qui teste GLFW_KEY_W - +# ignorait purement et simplement la touche. +# +# Effet observe avant correction : seuls S et D (memes positions sur AZERTY et +# QWERTY) deplacaient la camera. Le script croyait aller a l'ouest, la camera +# derivait vers l'est, et aucun objet ne se trouvait jamais a portee - alors que +# le JEU, lui, fonctionnait parfaitement. +# +# En envoyant directement les scancodes du jeu de codes 1, on s'adresse a la +# position physique, exactement comme le fera un vrai clavier. +$SC = @{ + W=0x11; A=0x1E; S=0x1F; D=0x20 # ZQSD sous les doigts d'un AZERTY + E=0x12; R=0x13; C=0x2E; F=0x21 + V=0x2F; SPACE=0x39 # Phase 8 : decollage/atterrissage parapente + B=0x30 # Phase 13 : monter sur le velo / en descendre + X=0x2D # Phase 14 : s'engager sur une paroi / lacher + T=0x14 # Phase 16 : boire au point d'eau + Y=0x15 # Phase 22 : creuser un gisement + I=0x17 # Phase 22 : arracher une plante a fibres +} + +# --- PHASE 15 : les touches de l'EDITEUR, dont des touches ETENDUES --------- +# Le pave de navigation (INSER, SUPPR, DEBUT, FIN, PAGE) et les fleches portent +# les MEMES scancodes que le pave numerique ; ce qui les distingue est le bit +# "touche etendue" (bit 24 du lParam). GLFW indexe sa table par +# (scancode | 0x100) pour celles-la - voir createKeyTables() dans win32_init.c - +# donc oublier ce bit ne produit pas une touche morte : il produit une AUTRE +# touche (INSER deviendrait le 0 du pave numerique). D'ou le drapeau explicite +# porte par chaque entree. +$SCX = @{ + INSERT = 0x52 # poser l'objet arme (equivalent clavier du clic gauche) + DELETE = 0x53 # supprimer la selection + UP = 0x48 # agrandir + DOWN = 0x50 # reduire + LEFT = 0x4B # tourner a gauche + RIGHT = 0x4D # tourner a droite + TAB = 0x0F # asset suivant + BACKSPACE = 0x0E # annuler + F2 = 0x3C # entrer / sortir du mode editeur + F3 = 0x3D # objet pose suivant, sans viser + F4 = 0x3E # objet pose precedent, sans viser + F5 = 0x3F # sauvegarder la scene + F9 = 0x43 # recharger la scene + L = 0x26 # reafficher le catalogue + E = 0x12 # selectionner l'objet vise + D3 = 0x04 # rang 3 du catalogue + W = 0x11 # avancer (Z en AZERTY) +} + +# Send-Key ne sait pas poser le bit "touche etendue" : ces deux fonctions le +# font. Elles ne REMPLACENT pas Send-Key/HoldMs, volontairement - les scenarios +# A a F sont verts avec, et leur toucher serait un risque pour zero gain. +function Send-KeyEx([int]$sc, [bool]$ext, [int]$holdMs = 90) { + $down = 1 -bor ($sc -shl 16) + if ($ext) { $down = $down -bor (1 -shl 24) } + $up = $down -bor (1 -shl 30) -bor (1 -shl 31) + [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr]$down) + Start-Sleep -Milliseconds $holdMs + [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr]$up) + Start-Sleep -Milliseconds 160 +} + +function HoldKeyEx([int]$sc, [bool]$ext, [int]$ms) { + $down = 1 -bor ($sc -shl 16) + if ($ext) { $down = $down -bor (1 -shl 24) } + $up = $down -bor (1 -shl 30) -bor (1 -shl 31) + [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr]$down) + Start-Sleep -Milliseconds $ms + [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr]$up) + Start-Sleep -Milliseconds 250 +} + +# --- Navigation : uniquement au clavier, JAMAIS a la souris ----------------- +# La camera ne tourne pas de tout le test, et c'est delibere : +# +# GLFW ne lit PAS la position du curseur dans les messages WM_MOUSEMOVE : sa +# fonction glfwGetCursorPos appelle GetCursorPos() puis ScreenToClient(), +# c'est-a-dire le curseur SYSTEME reel. Des WM_MOUSEMOVE postes n'ont donc +# aucun effet sur la rotation (constate : la camera restait figee au cap +# initial pendant tout un run). Faire tourner la camera exigerait de deplacer +# reellement le pointeur avec SetCursorPos, donc de voler la souris a +# l'utilisateur pendant une minute. +# +# Ce n'est pas necessaire : au cap initial (yaw = -90 degres), le repere de la +# camera est aligne sur les axes du monde. front = (0, 0, -1) et +# right = (1, 0, 0), donc +# W -> -Z S -> +Z D -> +X A -> -X +# On atteint donc n'importe quel point (x, z) par translations pures. +$script:posX = 0.0 +$script:posZ = 0.0 +$script:hwnd = [IntPtr]::Zero +$script:proc = $null +$script:outSb = $null +$script:errSb = $null +$script:handlers = @() + +function Send-Key([int]$sc, [int]$holdMs = 70) { + [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) + Start-Sleep -Milliseconds $holdMs + [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) + Start-Sleep -Milliseconds 90 +} + +# Maintient une touche le temps de parcourir la distance voulue. +# Vitesse 14 unites/s (Camera::setMoveSpeed dans main.cpp), deplacement +# strictement horizontal en mode marche : distance = vitesse x temps, quel que +# soit le relief. +function Hold([int]$sc, [double]$distance) { + if ($distance -le 0.02) { return } + $ms = [int](1000.0 * $distance / 14.0) + if ($ms -lt 20) { return } + [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) + Start-Sleep -Milliseconds $ms + [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) + Start-Sleep -Milliseconds 120 +} + +# Maintient une touche pendant une DUREE fixe plutot qu'une distance - utilise +# pour le decollage (monter en mode Free n'a pas de "distance" a viser, juste +# le temps de depasser le seuil de hauteur) et pour piloter le parapente une fois +# en vol (virage, frein), ou la notion de distance ne s'applique pas non plus. +function HoldMs([int]$sc, [int]$ms) { + [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) + Start-Sleep -Milliseconds $ms + [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) + Start-Sleep -Milliseconds 90 +} + +# Maintient PLUSIEURS touches simultanement pendant une duree fixe. Necessaire +# des la Phase 13 : le demi-tour du velo se fait frein tire (sinon la machine +# repart dans la pente pendant qu'on la tourne), donc S et D en meme temps. Les +# helpers precedents ne savaient tenir qu'une touche. +function HoldMsMulti([int[]]$scancodes, [int]$ms) { + foreach ($sc in $scancodes) { + [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) + } + Start-Sleep -Milliseconds $ms + foreach ($sc in $scancodes) { + [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) + } + Start-Sleep -Milliseconds 120 +} + +# Dernier cap du velo lu dans la telemetrie du jeu (degres), ou $null si le velo +# n'a encore rien emis. +function Get-BikeHeading() { + $ms = [regex]::Matches($script:outSb.ToString(), 'Velo : .*cap ([-0-9.]+) deg') + if ($ms.Count -eq 0) { return $null } + return [double]$ms[$ms.Count - 1].Groups[1].Value +} + +# Attend qu'une NOUVELLE ligne de telemetrie velo soit apparue (le jeu en emet +# une par seconde). Renvoie $false en cas de delai depasse. +function Wait-BikeSample([int]$timeoutMs = 2000) { + $before = [regex]::Matches($script:outSb.ToString(), 'Velo : .*km/h').Count + $deadline = (Get-Date).AddMilliseconds($timeoutMs) + while ((Get-Date) -lt $deadline) { + if ([regex]::Matches($script:outSb.ToString(), 'Velo : .*km/h').Count -gt $before) { return $true } + Start-Sleep -Milliseconds 120 + } + return $false +} + +# Amene le velo au cap voulu, PAR ASSERVISSEMENT sur ce que le jeu journalise - +# et non par une duree calculee a l'avance. +# +# Pourquoi : un demi-tour "1,4 s a 140 deg/s" a ete essaye d'abord, et il rate. +# Le temps reellement vu par le jeu n'est pas celui du Start-Sleep (jitter de +# PostMessage, ordonnancement, frame en cours), et sur ce versant l'erreur coute +# cher : le devers moyen y depasse 25 %, donc 18 degres d'ecart font passer la +# pente ressentie de +12 % a +27 % - au-dela de ce que le velo peut monter. Le +# velo s'immobilisait alors pour de bon et le scenario ne prouvait aucune montee. +# +# Le jeu emet deja son cap chaque seconde : on s'en sert. On tourne par courtes +# rafales, frein tire (sinon la machine repart dans la pente pendant la +# manoeuvre), en relisant le cap entre chaque. +function Turn-BikeTo([double]$targetDeg, [double]$toleranceDeg = 8.0, + [int]$maxBursts = 14) { + for ($i = 0; $i -lt $maxBursts; $i++) { + $cap = Get-BikeHeading + if ($null -eq $cap) { return $false } + # Ecart ramene dans (-180, 180] : on tourne toujours par le plus court. + $delta = (($targetDeg - $cap) % 360 + 540) % 360 - 180 + if ([Math]::Abs($delta) -le $toleranceDeg) { + Write-Host (" cap {0:N1} deg (cible {1:N0}, ecart {2:N1}) - atteint en {3} rafales" -f $cap, $targetDeg, $delta, $i) + return $true + } + # 140 deg/s a l'arret (plafond de braquage de world/Bike.hpp). On vise + # 70 % de l'ecart par rafale : on converge sans osciller. + $ms = [int][Math]::Min(500, [Math]::Max(60, [Math]::Abs($delta) * 0.7 / 140.0 * 1000.0)) + $key = $(if ($delta -gt 0) { $SC.D } else { $SC.A }) + HoldMsMulti @($SC.S, $key) $ms + [void](Wait-BikeSample 2000) + } + Write-Host (" [ATTENTION] cap non atteint apres {0} rafales (dernier {1})" -f $maxBursts, (Get-BikeHeading)) + return $false +} + +# Interroge la sortie DEJA CAPTUREE du processus en cours (les gestionnaires +# asynchrones de Start-Game l'alimentent en continu) jusqu'a ce qu'une ligne +# corresponde au motif, ou jusqu'au delai imparti. Sert a savoir si le vol a +# reellement decolle/atterri SANS deviner un temps d'attente fixe - le relief +# reel determine seul quand le parapente touche le sol. +function Wait-ForLog([string]$pattern, [int]$timeoutMs) { + $deadline = (Get-Date).AddMilliseconds($timeoutMs) + while ((Get-Date) -lt $deadline) { + if ($script:outSb.ToString() -match $pattern) { return $true } + Start-Sleep -Milliseconds 250 + } + return $script:outSb.ToString() -match $pattern +} + +# =========================================================================== +# NAVIGATION EN BOUCLE FERMEE (Phase 24) +# =========================================================================== +# Jusqu'ici GoTo naviguait A L'ESTIME : il tenait une touche pendant +# distance / 14 m/s et DECLARAIT le joueur arrive, sans jamais rien verifier. +# Le modele est faux des que le monde s'en mele - collision contre un tronc, +# terrain qui monte, et depuis la Phase 24 une pente qui ralentit la marche. +# L'erreur ne se corrige jamais : elle s'ACCUMULE d'un GoTo au suivant. +# +# Ce n'etait pas une hypothese. Mesure du 2026-08-27, scenario A, journal brut +# du jeu : le script se croyait sur la pierre 2, le joueur etait a 7 m de la, +# et le jeu disait exactement pourquoi - +# +# [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 scenario A tombe d'une seule cause : le joueur n'arrive pas. Les +# "percussions 0" et "cible manquee" en sont les consequences, pas des defauts +# distincts - et RIEN de tout cela n'est du jeu. Le controle a ete fait dans les +# deux sens : neutraliser entierement la limite de pente de la Phase 24 +# (kWalkMaxSlope a 1000) ne change RIEN au resultat, et le run ci-dessus n'a +# journalise AUCUN declenchement du filtre. Trois executions donnent le meme +# echec au detail pres : ce defaut est DETERMINISTE, il n'a jamais ete de la +# flakiness, et c'est pour ca qu'elargir des delais ne l'a jamais corrige. +# +# Le correctif ne touche pas au jeu (contrainte explicite du chantier) : il +# lit ce que le jeu JOURNALISE DEJA. src/main.cpp emet la position de la camera +# UNE FOIS PAR SECONDE, sans condition, depuis la Phase 15 - et pour exactement +# cette raison, ecrite dans son commentaire. Le harnais ne s'en etait jamais +# servi pour naviguer. +# +# Position REELLE du joueur, telle que le jeu vient de l'ecrire. Renvoie $null +# si aucune ligne fraiche n'arrive dans le delai - l'appelant retombe alors sur +# l'estime plutot que d'echouer. +# +# On exige une ligne PLUS RECENTE que celles deja presentes : relire la derniere +# ligne connue donnerait la position d'AVANT le deplacement qu'on vient +# d'ordonner, et la boucle croirait n'avoir pas bouge. +function Get-PlayerPos([int]$timeoutMs = 2500) { + $rx = 'Camera : yaw \S+ pitch \S+ position (\S+) (\S+) (\S+)' + $seen = ([regex]::Matches($script:outSb.ToString(), $rx)).Count + $deadline = (Get-Date).AddMilliseconds($timeoutMs) + while ((Get-Date) -lt $deadline) { + $m = [regex]::Matches($script:outSb.ToString(), $rx) + if ($m.Count -gt $seen) { + $last = $m[$m.Count - 1] + return [pscustomobject]@{ + X = [double]$last.Groups[1].Value + Y = [double]$last.Groups[2].Value + Z = [double]$last.Groups[3].Value + } + } + Start-Sleep -Milliseconds 120 + } + return $null +} + +# Se rend en (x, z) et VERIFIE l'arrivee, en corrigeant l'erreur restante. +# +# $tolerance = 0,6 m : nettement sous la portee de ramassage (2,5 m) et sous la +# demi-largeur du joueur plus une marge, donc "arrive" veut dire quelque chose. +# $maxPasses borne le temps : un joueur reellement bloque par un rocher ne doit +# pas faire tourner le harnais en rond - on sort et le scenario constatera le +# blocage, ce qui est parfois PRECISEMENT ce qu'il teste (scenario B, G2). +function GoTo([double]$x, [double]$z, [double]$tolerance = 0.6, [int]$maxPasses = 4) { + for ($pass = 0; $pass -lt $maxPasses; $pass++) { + $p = Get-PlayerPos + if ($null -eq $p) { + # Repli EXACT sur l'ancien comportement : mieux vaut l'estime que + # rien, et ca garde le harnais utilisable si le jeu cesse un jour + # d'emettre cette ligne. + $dx = $x - $script:posX + if ($dx -ge 0) { Hold $SC.D $dx } else { Hold $SC.A (-$dx) } + $script:posX = $x + $dz = $z - $script:posZ + if ($dz -le 0) { Hold $SC.W (-$dz) } else { Hold $SC.S $dz } + $script:posZ = $z + return + } + + $script:posX = $p.X + $script:posZ = $p.Z + $dx = $x - $p.X + $dz = $z - $p.Z + $remaining = [Math]::Sqrt($dx * $dx + $dz * $dz) + if ($remaining -le $tolerance) { return } + + if ($dx -ge 0) { Hold $SC.D $dx } else { Hold $SC.A (-$dx) } + if ($dz -le 0) { Hold $SC.W (-$dz) } else { Hold $SC.S $dz } + } + + # Derniere lecture : que la position estimee reflete la REALITE meme quand + # on renonce, sinon l'erreur repartirait dans le GoTo suivant - ce qui est + # exactement le defaut qu'on corrige. + $final = Get-PlayerPos + if ($null -ne $final) { + $script:posX = $final.X + $script:posZ = $final.Z + $miss = [Math]::Sqrt(($x - $final.X) * ($x - $final.X) + ($z - $final.Z) * ($z - $final.Z)) + if ($miss -gt $tolerance) { + Write-Host (" [nav] arrivee a {0:N2} m de la cible ({1:N1}, {2:N1}) apres {3} passes" -f $miss, $x, $z, $maxPasses) + } + } +} + +# Abat l'arbre vise, en REESSAYANT apres un petit pas de cote. +# +# POURQUOI UN RETRY LA OU UN SEUL "E" SUFFISAIT EN THEORIE. La navigation en +# boucle fermee (voir GoTo) plafonne a ~0,8 m de la cible et n'y descend pas : +# le canal d'entree est quantifie - `Hold` refuse tout pas sous 0,28 m, et +# `Start-Sleep` a une granularite de ~16 ms sur cette machine, donc une +# correction fine est soit ignoree soit depassee. Ce n'est pas un reglage a +# ajuster, c'est une limite du pilotage par PostMessage. +# +# Or la marge de visee du scenario C est plus fine que ce plafond, et ca s'est +# vu : deux executions consecutives du MEME binaire ont donne 0,78 m (arbre +# abattu) et 0,80 m (manque). Une reussite qui tient a deux centimetres de +# residu n'est pas une reussite - c'est la flakiness qu'on cherche a eliminer. +# +# Le remede est celui que le harnais emploie DEJA pour le meme probleme au +# ramassage (Vacuum) : couvrir l'incertitude de position par un petit balayage, +# au lieu d'exiger du canal d'entree une precision qu'il n'a pas. +function Fell-WithRetry([int]$attempts = 4, [double]$step = 0.5) { + # Comptage direct plutot que Count-Match : cet utilitaire n'est defini + # qu'apres les scenarios dans ce fichier, donc il n'existe pas encore ici. + $rx = "Abattage de l'arbre" + $before = ([regex]::Matches($script:outSb.ToString(), $rx)).Count + for ($i = 0; $i -lt $attempts; $i++) { + Send-Key $SC.E + Start-Sleep -Milliseconds 600 + $now = ([regex]::Matches($script:outSb.ToString(), $rx)).Count + if ($now -gt $before) { + if ($i -gt 0) { Write-Host (" [visee] arbre abattu au {0}e essai" -f ($i + 1)) } + return $true + } + # Pas de cote ALTERNE (droite, gauche, droite...) et croissant : on + # balaie autour de la position estimee sans s'en eloigner franchement. + $key = if ($i % 2 -eq 0) { $SC.D } else { $SC.A } + Hold $key ($step * ($i + 1)) + } + Write-Host " [visee] arbre NON abattu apres $attempts essais" + return $false +} + +# Ratisse autour de la position courante : des R entrecoupes de petits pas en +# carre (deplacement net nul). La portee de ramassage est de 2.5 unites, mais +# la position n'est connue qu'a l'estime ; ce balayage rattrape l'imprecision. +function Vacuum([int]$rounds = 3, [double]$step = 1.6) { + Send-Key $SC.R + foreach ($i in 1..$rounds) { + foreach ($k in @($SC.D, $SC.W, $SC.A, $SC.S)) { + Hold $k ($step * $i) + Send-Key $SC.R + } + } +} + +# $sceneArg : argument passe a vercora.exe. "terrain" force le generateur +# procedural ; un chemin .vchm charge une dalle reelle. Les scenarios A et B le +# passent EXPLICITEMENT, alors que le jeu sans argument charge desormais la dalle +# LiDAR : ils testent le monde de reference, pas le defaut du jour. +# $extraArgs : options passees telles quelles APRES la scene (--start=..., etc.). +# Ajoute en Phase 13 : le scenario velo doit demarrer sur un versant CHOISI, et +# le harnais ne peut pas s'y rendre en marchant (il ne sait pas tourner la +# camera, donc il ne peut se deplacer que sur les axes du monde). +function Start-Game([string]$label, [string]$sceneArg = "terrain", + [string[]]$extraArgs = @()) { + Write-Host "" + Write-Host "############ $label ############" + # PHASE 26 : instrumentation du dump. Le journal brut concatenait les + # quatorze processus SANS separateur : impossible d'attribuer une ligne a un + # scenario apres coup, donc impossible de dire si une telemetrie manquante + # manque au scenario I ou ailleurs. On retient le libelle et l'instant de + # depart ; Stop-Game les rend avec la duree reelle du processus. + $script:runLabel = $label + $script:runStartedAt = Get-Date + # System.Diagnostics.Process directement, et non Start-Process : ce dernier + # renvoie un objet dont ExitCode reste vide quand les flux sont rediriges, + # ce qui faisait passer un run parfaitement propre pour un echec. + $psi = New-Object System.Diagnostics.ProcessStartInfo + $psi.FileName = $exe + $psi.Arguments = '"' + $sceneArg + '"' + foreach ($a in $extraArgs) { $psi.Arguments += ' "' + $a + '"' } + $psi.WorkingDirectory = $root + $psi.UseShellExecute = $false + $psi.RedirectStandardOutput = $true + $psi.RedirectStandardError = $true + $script:proc = [System.Diagnostics.Process]::Start($psi) + + # Lecture asynchrone : un pipe plein bloquerait le jeu au milieu du test. + # Le collecteur est le delegue COMPILE defini plus haut, et non un + # script-block PowerShell : c'est ce qui garantit que Wait-ForLog interroge + # ce que le jeu vient d'ecrire, et non un etat vieux de plusieurs secondes. + $script:outSb = New-Object VercoraLogSink + $script:errSb = New-Object VercoraLogSink + $script:handlers = @() + $script:outSb.Attach($script:proc, $true) + $script:errSb.Attach($script:proc, $false) + $script:proc.BeginOutputReadLine() + $script:proc.BeginErrorReadLine() + + $script:hwnd = [IntPtr]::Zero + for ($i = 0; $i -lt 120 -and $script:hwnd -eq [IntPtr]::Zero; $i++) { + $script:proc.Refresh() + if ($script:proc.HasExited) { break } + if ($script:proc.MainWindowHandle -ne [IntPtr]::Zero) { $script:hwnd = $script:proc.MainWindowHandle } + Start-Sleep -Milliseconds 100 + } + if ($script:hwnd -eq [IntPtr]::Zero) { throw "Pas de fenetre (HasExited=$($script:proc.HasExited))." } + + $sb = New-Object System.Text.StringBuilder 512 + [void][W32]::GetWindowTextW($script:hwnd, $sb, 512) + Write-Host "Fenetre : '$($sb.ToString())'" + $script:posX = 0.0 + $script:posZ = 0.0 + Start-Sleep -Seconds 2 +} + +function Stop-Game() { + Write-Host "--- Fermeture propre (WM_CLOSE) ---" + [void][W32]::PostMessage($script:hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero) + if (-not $script:proc.WaitForExit(20000)) { + Write-Host "[ECHEC] Pas de sortie 20 s apres WM_CLOSE." + $script:proc.Kill(); $script:proc.WaitForExit() + } + $script:proc.WaitForExit() # vide les lecteurs asynchrones + Start-Sleep -Milliseconds 400 + foreach ($h in $script:handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue } + $text = $script:outSb.ToString() + $script:errSb.ToString() + $lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' }) + $result = [pscustomobject]@{ + ExitCode = $script:proc.ExitCode + Lines = $lines + Label = $script:runLabel + StartedAt = $script:runStartedAt + # Duree MUR du processus. C'est la grandeur qui permet de distinguer + # "le jeu a emis moins de lignes" de "le scenario a dure moins + # longtemps" - deux causes tres differentes d'une telemetrie courte. + WallSeconds = [Math]::Round(((Get-Date) - $script:runStartedAt).TotalSeconds, 1) + } + # L'accumulation se fait ICI, et non en enumerant les $runX a la fin : le + # scenario J RECOMPOSE $runJ en concatenant ses trois processus, si bien + # qu'une enumeration des variables compterait J2 et J3 deux fois. Le seul + # endroit qui voit exactement un processus, une fois, c'est Stop-Game. + $script:allRuns += $result + return $result +} + +# =========================================================================== +# SCENARIO A : gameplay complet +# =========================================================================== +$script:allRuns = @() +$runA = $null +if (Should-Run 'A') { +Start-Game "SCENARIO A - gameplay, resize, fermeture" + +foreach ($n in 0..1) { + $s = $stones[$n] + Write-Host ("--- Pierre {0} : ({1:N1}, {2:N1}) ---" -f ($n+1), $s.X, $s.Z) + GoTo $s.X $s.Z + Vacuum 3 +} + +Write-Host "--- Percussion (C) ---" +Send-Key $SC.C +Start-Sleep -Milliseconds 500 +Hold $SC.W 1.1 # l'eclat tombe 1.1 unite devant, donc vers -Z au cap initial +Send-Key $SC.R +Start-Sleep -Milliseconds 300 + +# On se place PLEIN NORD de l'arbre (meme X, Z superieur) : au cap initial la +# camera regarde vers -Z, l'arbre est donc pile dans l'axe de visee. +$best = $null; $bestD = [double]::MaxValue +foreach ($t in $trees) { + $dd = [Math]::Sqrt(($t.X-$script:posX)*($t.X-$script:posX) + ($t.Z-$script:posZ)*($t.Z-$script:posZ)) + if ($dd -lt $bestD) { $bestD = $dd; $best = $t } +} +$expectedTree = ($best.Kind -replace 'TREE','') +Write-Host ("--- Abattage : {0} en ({1:N1}, {2:N1}) ---" -f $best.Kind, $best.X, $best.Z) +GoTo $best.X ($best.Z + 9.0) +Send-Key $SC.E +Start-Sleep -Milliseconds 400 + +Write-Host "--- Chute, amortissement, debitage (6 s) ---" +Start-Sleep -Seconds 6 + +Write-Host "--- Ramassage du bois ---" +GoTo $best.X ($best.Z + 1.5) +Vacuum 3 +Vacuum 2 2.4 + +Write-Host "--- Bascule marche / vol libre ---" +Send-Key $SC.F +Start-Sleep -Milliseconds 400 +Send-Key $SC.F +Start-Sleep -Milliseconds 400 + +Write-Host "--- Redimensionnements (recreation de la swapchain) ---" +foreach ($size in @(@(800,600), @(1600,900), @(640,480), @(1280,720), @(1920,1080), @(1024,768))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 +} + +Write-Host "--- Minimisation / restauration (framebuffer de taille nulle) ---" +[void][W32]::ShowWindow($script:hwnd, 6) +Start-Sleep -Milliseconds 1500 +[void][W32]::ShowWindow($script:hwnd, 9) +Start-Sleep -Milliseconds 1500 + +$runA = Stop-Game +} + +# =========================================================================== +# SCENARIO B : chemin de collision, depuis l'origine +# =========================================================================== +# Ce scenario EXERCE la collision a l'execution ; il ne PROUVE pas son +# comportement. La distinction est importante et vaut d'etre expliquee. +# +# Une premiere version de cette sonde concluait "collision defaillante" a tort. +# Le raisonnement etait : on pousse 25 unites dans un arbre qui n'est qu'a 11, +# donc si le tronc arrete le joueur l'arbre reste devant lui et E doit l'abattre. +# C'est faux, parce qu'un collider CYLINDRIQUE ne bloque pas : il REPOUSSE. Le +# joueur legerement decentre est ecarte lateralement, glisse autour du tronc et +# repart de l'autre cote - exactement le comportement voulu (on contourne +# l'arbre, on ne le traverse pas), mais qui laisse l'arbre DERRIERE soi dans les +# deux cas. Le critere ne distinguait donc rien. +# +# Aucun observable externe ne permet de trancher : le jeu n'expose pas la +# position du joueur, et la deflexion laterale (0.66 unite) est plus petite que +# la tolerance de visee (~1.4 unite). La preuve COMPORTEMENTALE de la collision +# - non-penetration, glissement, blocage par la souche, passage trop etroit - +# vient donc du harnais headless (tests\logic_tests.cpp, qui simule la marche +# pas a pas et lit les positions directement). +# +# Ce que ce scenario apporte reellement, et qui n'est verifiable qu'ici : le +# code de collision tourne a chaque frame dans le vrai executable, contre un +# tronc DEBOUT puis contre une SOUCHE, sans erreur de validation ni plantage. +$probe = $trees | Where-Object { $_.Kind -eq 'TREE7' } | Select-Object -First 1 +$runB = $null +if (Should-Run 'B') { +Start-Game "SCENARIO B - chemin de collision (tronc debout puis souche)" + +Write-Host ("--- Poussee de 25 unites dans l'arbre {0} en ({1:N1}, {2:N1}) ---" -f $probe.Kind, $probe.X, $probe.Z) +GoTo $probe.X 0.0 # alignement lateral exact sur l'axe du tronc +Hold $SC.W 25.0 # bien au-dela : on force le contact et le glissement +Start-Sleep -Milliseconds 400 + +# Retour au nord de l'arbre, puis abattage : la souche prend alors la place du +# tronc dans le volume de collision (Tree::colliderTopY), et on repousse dedans. +Write-Host "--- Retour, abattage, puis poussee dans la souche ---" +# Hold deplace la camera sans toucher a la position ESTIMEE (seul GoTo la met a +# jour) : le retour doit donc se faire par un Hold symetrique, et non par un +# GoTo qui calculerait un deplacement nul et ne bougerait pas. +Hold $SC.S 25.0 +Send-Key $SC.E +Start-Sleep -Seconds 6 +Hold $SC.W 25.0 +Start-Sleep -Milliseconds 400 + +$runB = Stop-Game +} + +# =========================================================================== +# SCENARIO C : dalle LiDAR HD reelle (Phase 7) +# =========================================================================== +# Ce que ce scenario apporte, et que ni A ni B ne peuvent montrer : +# - un vertex buffer de 1 002 001 sommets et 2 000 000 de triangles pousse sur +# le GPU, puis six recreations de swapchain avec ce maillage en place ; +# - la camera qui marche sur un relief MESURE, avec des pentes reelles +# (562 m de denivele sur 1 km) la ou le terrain synthetique est lisse ; +# - le semis d'arbres refait sur ce relief, donc le filtre de pente confronte +# a de vraies falaises ; +# - la destruction propre de tout ca. +$runC = $null +if ($hasLidar -and (Should-Run 'C')) { + Start-Game "SCENARIO C - dalle LiDAR HD reelle, 2 M de triangles" $lidarTile + + # ORDRE IMPORTANT : viser D'ABORD, se promener ENSUITE. + # + # La position du joueur n'est connue qu'a l'estime, et la moindre collision + # en chemin la decale sans que le script puisse s'en apercevoir. Une premiere + # version de ce scenario commencait par un aller-retour de 30 m dans les + # quatre directions "pour exercer le relief" : ce trajet traversait le semis + # d'arbres, chaque tronc deviait la camera de quelques dizaines de + # centimetres, et l'abattage qui suivait ne visait plus rien. Resultat : un + # scenario en echec alors que le jeu, lui, se comportait correctement. + # + # En partant de l'origine - la seule position connue EXACTEMENT - l'abattage + # est fiable. La promenade libre vient apres, quand la derive n'a plus + # d'importance parce que plus rien n'a besoin d'etre vise. + $expectedTreeC = if ($null -ne $lidarAim) { "$($lidarAim.Index)" } else { $null } + if ($null -ne $lidarAim) { + Write-Host ("--- Abattage sur relief reel : arbre {0}, tir depuis ({1:N1}, {2:N1}) a {3:N1} m ---" -f + $lidarAim.Index, $lidarAim.CamX, $lidarAim.CamZ, $lidarAim.Standoff) + GoTo $lidarAim.CamX $lidarAim.CamZ + [void](Fell-WithRetry) + Start-Sleep -Seconds 7 + + Write-Host "--- Ramassage du bois sur relief reel ---" + GoTo $lidarAim.CamX ($lidarAim.CamZ - $lidarAim.Standoff + 1.5) + Vacuum 3 + Vacuum 2 2.4 + } + + Write-Host "--- Marche libre sur le relief mesure, puis vol libre ---" + # Plus rien a viser a partir d'ici : on peut parcourir de longues distances + # sur des pentes reelles sans se soucier de la derive. C'est ce qui exerce le + # suivi de terrain (Camera::snapToTerrain) sur des donnees mesurees, la ou le + # terrain synthetique n'a que des pentes douces. + foreach ($key in @($SC.W, $SC.D, $SC.S, $SC.A)) { Hold $key 45.0 } + Send-Key $SC.F # vol libre : traverse le relief au lieu de le suivre + Hold $SC.W 60.0 + Send-Key $SC.F # retour en marche : la camera se recolle au sol + Start-Sleep -Milliseconds 600 + + Write-Host "--- Redimensionnements avec 2 M de triangles a l'ecran ---" + foreach ($size in @(@(800,600), @(1600,900), @(640,480), @(1920,1080), @(1280,720), @(1024,768))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 + } + + Write-Host "--- Minimisation / restauration ---" + [void][W32]::ShowWindow($script:hwnd, 6) + Start-Sleep -Milliseconds 1500 + [void][W32]::ShowWindow($script:hwnd, 9) + Start-Sleep -Milliseconds 1500 + + $runC = Stop-Game +} + +# =========================================================================== +# SCENARIO D : vol en parapente sur la dalle LiDAR reelle (Phase 8) +# =========================================================================== +# Ce que ce scenario apporte, et que rien d'autre ne peut montrer : un decollage, +# un vol pilote (virage + frein) et un atterrissage - detecte par le jeu lui-meme +# contre le VRAI relief mesure, pas un plancher plat - sous les couches de +# validation Vulkan, avec la camera en vue chase-cam (mode Glide) plutot qu'en +# premiere personne. +# +# Contrairement aux scenarios precedents, on ne connait PAS a l'avance combien de +# temps le vol va durer : le taux de chute est fixe, mais le relief sous le +# parapente varie (562 m de denivele sur la dalle), donc l'altitude a laquelle il +# rencontre le sol depend d'ou il vole. On POLL la sortie du jeu (Wait-ForLog) +# plutot que de deviner un delai, et on force un atterrissage (touche V une +# seconde fois) si le relief n'a rien rencontre dans un delai large - filet de +# securite, pas le cas attendu. +$runD = $null +$paraglideLaunched = $false +$paraglideEnded = $false +if ($hasLidar -and (Should-Run 'D')) { + Start-Game "SCENARIO D - vol en parapente, dalle LiDAR reelle" $lidarTile + + Write-Host "--- Passage en mode vol libre, puis prise de hauteur ---" + Send-Key $SC.F # Walk -> Free : espace/shift redeviennent actifs + HoldMs $SC.SPACE 1500 # ~21 unites de hauteur a 14 u/s : largement au-dessus du seuil de 5 m + + Write-Host "--- Decollage (V) ---" + Send-Key $SC.V + $paraglideLaunched = Wait-ForLog "Decollage en parapente" 3000 + Write-Host (" decolle : {0}" -f $paraglideLaunched) + + if ($paraglideLaunched) { + Write-Host "--- Vol pilote : virage a droite puis frein ---" + HoldMs $SC.D 800 # ~20 degres de virage a droite, a vitesse angulaire constante + HoldMs $SC.S 1000 # frein : vitesse et taux de chute doivent evoluer progressivement + + Write-Host "--- Attente de l'atterrissage (relief reel, duree non fixee a l'avance) ---" + $landedNaturally = Wait-ForLog "Parapente : atterrissage" 45000 + if (-not $landedNaturally) { + Write-Host " pas encore pose apres 45 s : atterrissage force (filet de securite)." + Send-Key $SC.V + Wait-ForLog "vol interrompu" 3000 | Out-Null + } + $paraglideEnded = Wait-ForLog "(Parapente : atterrissage|vol interrompu)" 500 + Write-Host (" vol termine : {0} (naturellement : {1})" -f $paraglideEnded, $landedNaturally) + } + + Write-Host "--- Redimensionnements apres le vol ---" + foreach ($size in @(@(800,600), @(1600,900), @(1280,720))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 + } + + $runD = Stop-Game +} + +# =========================================================================== +# SCENARIO E : sortie a velo sur la dalle LiDAR reelle (Phase 13) +# =========================================================================== +# Ce que ce scenario apporte, et que rien d'autre ne peut montrer : la physique +# du velo confrontee a un VERSANT MESURE - une descente reelle puis la remontee +# du meme versant - sous les couches de validation Vulkan, avec la camera en vue +# a la troisieme personne (mode Ride). +# +# LE POINT DE DEPART EST CHOISI, ET C'EST ESSENTIEL. Le harnais ne sait pas +# tourner la camera (GLFW lit le curseur SYSTEME, cf. plus haut), donc le velo +# part forcement au cap initial, yaw = -90 degres, c'est-a-dire plein NORD +# (-Z : le nord DECROIT avec Z, voir Heightmap.hpp). Lance a un endroit +# quelconque, il roulerait sur du plat et le run serait vert sans rien prouver. +# +# LE POINT DE DEPART **ET LES DEUX CAPS** SONT CHOISIS PAR MESURE. C'est ce qui a +# demande le plus de travail dans ce scenario, et voici pourquoi. +# +# Trois versions ont echoue avant celle-ci, chacune pour une raison differente : +# +# 1. Depart quelconque : le velo roulait sur du plat, run vert sans rien montrer. +# 2. Depart sur un versant a -21 % : la descente marchait, mais la remontee +# depassait la pente maximale franchissable du modele (23,6 %, voir +# world/Bike.hpp) et le velo s'immobilisait pour de bon. C'est ce run qui a +# mis au jour le reglage de slopeSampleStep - voir NOTES-PHASE-VELO.md. +# 3. Descendre puis faire demi-tour pour 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 (mesure : 18 s de roue +# libre = 9,2 m de denivele, trop peu ; 30 s = 24,4 m mais remontee a +# 0,1 km/h). D'autre part, "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 donc, en depouillant la dalle, la pente le long de +# CHAQUE cap (differences centrees a +/-2 m, exactement comme le fait Bike), et +# retient un point qui offre les deux a la fois : +# +# depart E 907875 / N 6439450, altitude 513,2 m +# MONTEE cap 220 deg : +14,8 % en moyenne sur 90 m, pire section +16,8 %, +# donc AUCUNE section infranchissable - le velo monte sans caler ; +# DESCENTE cap 40 deg : -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 ainsi le denivele grimpe en elan supplementaire. +# +# La preuve n'est pas "le script a appuye sur les touches" mais la telemetrie que +# le jeu emet chaque seconde (vitesse, pente sous les roues, altitude) : elle est +# analysee plus bas. +$runE = $null +$bikeMounted = $false +$bikeDismounted = $false +if ($hasLidar -and (Should-Run 'E')) { + Start-Game "SCENARIO E - sortie a velo, versant LiDAR reel" $lidarTile ` + @("--start=907875,6439450") + + Write-Host "--- En selle (B) ---" + Send-Key $SC.B + $bikeMounted = Wait-ForLog "Velo : en selle" 3000 + Write-Host (" en selle : {0}" -f $bikeMounted) + + if ($bikeMounted) { + Write-Host "--- Cap 220 : face a la montee, asservi sur le cap (frein tire) ---" + # Tolerance de 8 degres : au-dela, le devers de ce versant ferait sortir + # la pente ressentie de la fourchette mesuree. + $bikeTurnedUp = Turn-BikeTo 220.0 8.0 + Write-Host (" face a la montee : {0}" -f $bikeTurnedUp) + + Write-Host "--- Montee au pedalage (versant a +14,8 %) ---" + HoldMs $SC.W 20000 + + Write-Host "--- Cap 40 : face a la descente, asservi sur le cap ---" + $bikeTurnedDown = Turn-BikeTo 40.0 8.0 + Write-Host (" face a la descente : {0}" -f $bikeTurnedDown) + + Write-Host "--- Elan puis longue descente en roue libre ---" + HoldMs $SC.W 3000 # on s'elance + Start-Sleep -Seconds 32 # roue libre : c'est la gravite qui travaille, et + # il lui faut de la DISTANCE pour se voir. + + Write-Host "--- Freinage manuel jusqu'a l'arret ---" + HoldMs $SC.S 5000 + + Write-Host "--- Pied a terre (B) ---" + Send-Key $SC.B + $bikeDismounted = Wait-ForLog "Velo : pied a terre" 3000 + Write-Host (" pied a terre : {0}" -f $bikeDismounted) + } + + Write-Host "--- Redimensionnements apres la sortie ---" + foreach ($size in @(@(800,600), @(1600,900), @(1280,720))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 + } + + $runE = Stop-Game +} + +# =========================================================================== +# SCENARIO F : escalade sur une paroi LiDAR reelle (Phase 14) +# =========================================================================== +# Ce que ce scenario apporte, et que rien d'autre ne peut montrer : la physique +# de l'escalade confrontee a une PAROI MESUREE, sous les couches de validation +# Vulkan, avec la camera a la premiere personne (mode Climb). +# +# CE SCENARIO EST PLUS SIMPLE QUE LE SCENARIO E, ET CE N'EST PAS UN HASARD. +# Le velo a demande un asservissement de cap (Turn-BikeTo) parce que sa dynamique +# depend de la pente LE LONG DU CAP : mal oriente, il roule sur du plat. Les +# commandes de l'escalade, elles, sont RELATIVES A LA PAROI - monter suit la +# ligne de plus grande pente, traverser suit la ligne de niveau, toutes deux +# imposees par le terrain. L'orientation de la camera n'a donc AUCUNE influence +# sur la progression, et le harnais n'a rien a asservir. +# +# Une seule chose depend encore du cap : trouver la paroi au moment de +# s'engager, puisque tryStart sonde devant le REGARD. Le harnais ne pouvant pas +# tourner la camera (cf. plus haut), le joueur regarde forcement plein NORD +# (yaw -90, front = (0,0,-1)). Le point de depart a donc ete choisi par mesure - +# meme methode que pour le velo, meme outil d'esprit (tools/find_climb_walls.py) : +# on a balaye la dalle a la recherche des points qui reunissent les trois +# conditions du scenario, et il n'y en a que TROIS sur toute la dalle : +# +# depart marchable + une paroi grimpable a moins de 2 m PLEIN NORD +# + une ascension qui gagne au moins 15 m +# +# >> retenu : E 907616 / N 6439312, pente au depart 14 % (on y tient +# largement debout), paroi a portee plein nord, 41,7 m de gain simule. +# +# Le run enchaine les DEUX sorties d'escalade que le harnais peut atteindre : +# 1. montee, traversee, desescalade, puis LACHAGE volontaire (retour au pied) ; +# 2. re-engagement apres un repos, puis montee continue jusqu'au SOMMET. +# +# La troisieme sortie - la CHUTE par epuisement - n'est PAS exercee ici, et il +# faut le dire : elle demanderait une paroi de plus de 62 m (la hauteur qu'une +# jauge pleine permet), 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. +# +# La preuve n'est pas "le script a appuye sur X" mais la telemetrie que le jeu +# emet chaque seconde (energie, pente, altitude, gain), analysee plus bas. +$runF = $null +$climbEngaged = $false +$climbReleased = $false +$climbReEngaged = $false +$climbToppedOut = $false +if ($hasLidar -and (Should-Run 'F')) { + Start-Game "SCENARIO F - escalade, paroi LiDAR reelle" $lidarTile ` + @("--start=907616,6439312") + + Write-Host "--- Engagement sur la paroi (X) ---" + Send-Key $SC.X + $climbEngaged = Wait-ForLog "Escalade : engage sur la paroi" 3000 + Write-Host (" engage : {0}" -f $climbEngaged) + + if ($climbEngaged) { + Write-Host "--- Montee (Z) ---" + HoldMs $SC.W 6000 + + Write-Host "--- Traversee vers la droite (D) ---" + HoldMs $SC.D 3000 + + Write-Host "--- Traversee vers la gauche (Q) ---" + HoldMs $SC.A 3000 + + Write-Host "--- Desescalade (S) ---" + HoldMs $SC.S 3000 + + Write-Host "--- Lachage volontaire (X) ---" + Send-Key $SC.X + $climbReleased = Wait-ForLog "Escalade : lachee volontairement" 3000 + Write-Host (" lachee : {0}" -f $climbReleased) + + Write-Host "--- Repos au sol (recuperation de la jauge) ---" + Start-Sleep -Seconds 12 + + Write-Host "--- Re-engagement (X) ---" + Send-Key $SC.X + $climbReEngaged = Wait-ForLog "Escalade : engage sur la paroi" 3000 + Write-Host (" re-engage : {0}" -f $climbReEngaged) + + if ($climbReEngaged) { + Write-Host "--- Montee continue jusqu'au sommet ---" + # 41,7 m simules a ~0,73 m/s de gain vertical => ~57 s. On tient la + # touche jusqu'a ce que le jeu annonce le sommet - le temps vu par le + # jeu n'est pas celui du script (meme lecon qu'au scenario E). + # + # 140 s et non 75. PHASE 17, et c'est une fragilite du SCENARIO mise + # au jour, pas un defaut du jeu : 75 s ne laissaient que 18 s de marge + # sur une montee de 57 s. Or la trajectoire du grimpeur depend du pas + # de temps - a chaque image, la commande est projetee sur la ligne de + # plus grande pente LOCALE - donc deux cadences d'images differentes + # ne suivent pas exactement le meme chemin sur la paroi. Il a suffi + # des 6 % de FPS que coute la faune de la Phase 17 (301 contre 320 + # FPS, mesure) pour que la marge disparaisse : le grimpeur montait + # bien (41,5 m contre 41,4 m au temoin) mais n'annoncait plus le + # sommet avant l'echeance. Le harnais sort de la boucle des que le + # sommet est atteint, donc cette marge ne coute rien quand tout va + # bien. + $deadline = (Get-Date).AddSeconds(140) + while ((Get-Date) -lt $deadline -and -not $climbToppedOut) { + HoldMs $SC.W 2000 + $climbToppedOut = ($script:outSb.ToString() -match 'Escalade : SOMMET atteint') + } + Write-Host (" sommet atteint : {0}" -f $climbToppedOut) + } + } + + Write-Host "--- Redimensionnements apres l'escalade ---" + foreach ($size in @(@(800,600), @(1600,900), @(1280,720))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 + } + + $runF = Stop-Game +} + +# =========================================================================== +# SCENARIO G : EDITEUR DE NIVEAU (PHASE 15) +# =========================================================================== +# Trois processus, et il en faut trois : le seul controle qui prouve reellement +# quelque chose sur la collision est un TEMOIN NEGATIF, c'est-a-dire la meme +# marche refaite sans la scene. +# +# G1 edition : poser, selectionner, regler, supprimer, annuler, sauvegarder, +# recharger, sortir du mode - puis resize et fermeture propre. +# G2 jeu NORMAL sur le fichier ecrit par G1 : les objets doivent se charger +# tout seuls (personne n'a demande l'editeur), etre dessines, et ARRETER +# le joueur qui marche dessus. +# G3 temoin : exactement la meme marche que G2, mais --no-scene. C'est +# l'ecart entre les deux distances parcourues qui fait la preuve, pas la +# distance de G2 prise isolement. +# +# --- CE QUE LE HARNAIS NE PEUT PAS FAIRE, ET SES CONSEQUENCES --------------- +# Il ne pilote que le CLAVIER (GLFW lit le curseur SYSTEME, cf. l'en-tete de ce +# script). Deux consequences assumees : +# +# * la POSE se fait a la touche INSER et non au clic. Les deux passent par le +# meme code - main.cpp combine les deux fronts descendants en un seul +# `placePressed` - donc le chemin exerce est bien celui du clic ; +# * la camera de G1 est VERROUILLEE (--lock-input) et ne peut pas tourner : les +# trois objets se posent donc au MEME point vise, empiles. Ce n'est pas une +# limite de l'editeur (rien n'interdit d'empiler, d'ailleurs) mais une limite +# du pilotage, la meme qui avait impose de choisir un point de depart precis +# aux scenarios E et F. +# +# Les touches etendues (INSER, SUPPR, fleches) exigent le bit 24 du lParam : +# GLFW indexe sa table de scancodes par (scancode | 0x100) pour celles-la, donc +# l'oublier designerait une touche du PAVE NUMERIQUE au lieu de la bonne. +# =========================================================================== + +$runG1 = $null; $runG2 = $null; $runG3 = $null +$sceneG = Join-Path $root "build\scenario_g.vcsc" + +if ($hasLidar -and (Should-Run 'G')) { + # On repart d'un fichier ABSENT : le premier lancement doit donc aussi + # exercer le chemin "aucune scene sur disque", qui est le cas normal d'une + # premiere partie. + if (Test-Path $sceneG) { Remove-Item $sceneG -Force } + + $startG = "--start=907500,6439500" + $lookG = "--look=-90,-8" + + Start-Game "SCENARIO G1 - editeur : catalogue, pose, reglage, annulation, sauvegarde" ` + $lidarTile @("--editor", "--lock-input", $startG, $lookG, + "--scene=$sceneG", "--no-vegetation") + + Write-Host "--- Pose du premier asset (INSER) ---" + Send-KeyEx $SCX.INSERT $true + + Write-Host "--- Asset suivant (TAB) puis pose ---" + Send-KeyEx $SCX.TAB $false + Send-KeyEx $SCX.INSERT $true + + Write-Host "--- Rang 3 au clavier, rotation du pinceau, pose ---" + Send-KeyEx $SCX.D3 $false + HoldKeyEx $SCX.RIGHT $true 600 + Send-KeyEx $SCX.INSERT $true + + Write-Host "--- Catalogue (L), selection (E), agrandissement ---" + Send-KeyEx $SCX.L $false + Send-KeyEx $SCX.E $false + HoldKeyEx $SCX.UP $true 400 + + # PHASE 15, ajout ergonomique : parcourir les objets poses SANS viser. + # Deux F3 (avance de deux rangs, boucle si necessaire) puis un F4 (recul + # d'un rang) exercent le chemin de code sous Vulkan reel, pas seulement en + # headless - la mecanique elle-meme (ordre, bouclage, ignorance pendant une + # saisie) est verifiee par tests/logic_tests.cpp. On reselectionne ensuite + # PAR LA VISEE avant de supprimer, pour ne pas changer quel objet cette + # suppression retire et laisser intactes les mesures qui suivent. + Write-Host "--- Cycle de selection sans viser (F3, F3, F4) ---" + Send-KeyEx $SCX.F3 $false + Send-KeyEx $SCX.F3 $false + Send-KeyEx $SCX.F4 $false + + Write-Host "--- Reselection par la visee avant suppression ---" + Send-KeyEx $SCX.E $false + + Write-Host "--- Suppression (SUPPR) puis annulation (RETOUR ARRIERE) ---" + Send-KeyEx $SCX.DELETE $true + Start-Sleep -Milliseconds 300 + Send-KeyEx $SCX.BACKSPACE $false + Start-Sleep -Milliseconds 300 + + Write-Host "--- Sauvegarde (F5) puis rechargement (F9) ---" + Send-KeyEx $SCX.F5 $false + Start-Sleep -Milliseconds 600 + Send-KeyEx $SCX.F9 $false + Start-Sleep -Milliseconds 600 + + Write-Host "--- Sortie du mode editeur (F2) ---" + Send-KeyEx $SCX.F2 $false + Start-Sleep -Milliseconds 600 + + Write-Host "--- Redimensionnements apres l'edition ---" + foreach ($size in @(@(800,600), @(1600,900), @(1280,720))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 + } + + $runG1 = Stop-Game + + # --- G2 : jeu NORMAL, chargement automatique et collision --------------- + # Aucun --editor : c'est un lancement de partie ordinaire. Les objets doivent + # s'y charger, s'y dessiner et y bloquer, sinon l'editeur ne serait qu'un + # outil produisant un fichier que personne ne lit. + Start-Game "SCENARIO G2 - jeu normal : objets charges et solides" ` + $lidarTile @($startG, $lookG, "--scene=$sceneG", "--no-vegetation") + Start-Sleep -Milliseconds 1200 + Write-Host "--- Marche plein nord contre les objets poses ---" + HoldKeyEx $SCX.W $false 1500 + Start-Sleep -Milliseconds 1500 + $runG2 = Stop-Game + + # --- G3 : le TEMOIN ----------------------------------------------------- + # Meme binaire, meme terrain, meme point de depart, meme duree de touche. + # SEULE la presence de la scene change. Sans ce temoin, "le joueur a avance + # de 0,7 m" ne prouverait rien : il pourrait tout aussi bien s'etre heurte au + # relief, ou n'avoir jamais recu la touche. + Start-Game "SCENARIO G3 - temoin : la MEME marche sans la scene" ` + $lidarTile @($startG, $lookG, "--no-scene", "--no-vegetation") + Start-Sleep -Milliseconds 1200 + Write-Host "--- Meme marche, sans aucun objet pose ---" + HoldKeyEx $SCX.W $false 1500 + Start-Sleep -Milliseconds 1500 + $runG3 = Stop-Game +} + + +# =========================================================================== +# SCENARIO H : besoins primaires (PHASE 16) +# =========================================================================== +# Ce que ce scenario apporte, et que rien d'autre ne peut montrer : les quatre +# jauges qui tournent SOUS VULKAN, avec les couches de validation, sur un relief +# mesure - et surtout la chaine complete du point d'eau, qui n'existe que sur du +# relief reel : detection au chargement, portee, refus a distance. +# +# LE DEPART EST UN POINT D'EAU DETECTE, PAS UN POINT CHOISI A LA MAIN. Le jeu +# journalise au demarrage les creux qu'il a retenus sur la dalle ; le premier +# d'entre eux est en monde (-75, 285), soit E 907425 / N 6439215 en Lambert 93 +# (conversion de Heightmap::toProjected : est = 907000 + x + 500, nord = +# 6440000 - z - 500). Si le detecteur change d'avis, ce scenario le dira - la +# premiere touche T repondra "trop loin" au lieu de "pas soif". +# +# CE QUE PROUVE CHAQUE TOUCHE T, ET POURQUOI CES DEUX-LA : +# * au point d'eau -> "Boire : soif etanchee au point d'eau (0.000000 m)". +# Ce message n'est emis QU'APRES le test de portee ET le remplissage +# effectif de la jauge : le voir prouve les deux d'un coup, et la distance +# qu'il porte est celle reellement calculee. +# (Une premiere version attendait ici "Boire : pas soif", en supposant la +# jauge encore exactement pleine. Elle ne l'est pas : deux secondes de jeu +# l'ont deja fait descendre de quelques millioniemes, invisibles a +# l'affichage entier mais suffisants pour que drink() reussisse. Le message +# attendu ne sortait donc jamais.) +# * a 30 m de la -> "le point d'eau le plus proche est a N m". +# C'est le controle negatif : sans lui, une portee cassee (ou infinie) +# donnerait exactement le meme premier message. +# +# LE RESTE DU RUN EST UNE MESURE, PAS UNE ANIMATION : ~100 s de marche puis +# ~60 s d'immobilite complete. La telemetrie emise chaque seconde doit montrer +# la forme DESCENDRE pendant la marche et REMONTER pendant l'arret. Un seul des +# deux ne prouverait rien : une jauge qui ne fait que descendre est une jauge +# sans repos, une jauge qui ne fait que monter est une jauge qui ne coute rien. +$runH = $null +$drinkAtSource = $false +$drinkTooFar = $false +if ($hasLidar -and (Should-Run 'H')) { + Start-Game "SCENARIO H - besoins primaires, point d'eau LiDAR" $lidarTile ` + @("--start=907425,6439215", "--no-vegetation") + + Write-Host "--- Boire AU point d'eau (T) ---" + Send-Key $SC.T + $drinkAtSource = Wait-ForLog "Boire : soif etanchee au point d'eau" 3000 + Write-Host (" a portee du point d'eau : {0}" -f $drinkAtSource) + + Write-Host "--- S'en eloigner, puis boire de nouveau (controle negatif) ---" + HoldMs $SC.W 2500 + Start-Sleep -Milliseconds 500 + Send-Key $SC.T + $drinkTooFar = Wait-ForLog "point d'eau le plus proche est a" 3000 + Write-Host (" refus a distance : {0}" -f $drinkTooFar) + + # Marche continue, en va-et-vient pour rester sur le meme replat : ce qui + # compte est la DUREE d'effort, pas la distance parcourue. Le va-et-vient + # evite aussi de finir coince contre un versant raide - un joueur bloque ne + # se deplace plus, donc ne se fatigue plus (main.cpp lit le deplacement REEL + # de la camera, pas les touches), et le scenario deviendrait vert sans avoir + # rien mesure. + # 160 s et non 100 : a la marche continue, la forme perd 1,85 % par tranche + # de 100 s (1/(90 min), voir world/Needs.hpp), et l'affichage est ENTIER. Un + # premier reglage a 100 s a rendu 99 % puis 98 % sur deux runs - la marge + # tenait a un point d'arrondi, et une marche genee par le relief (le joueur + # bute, donc ne se fatigue plus) l'aurait effacee. 160 s laissent ~3 %. + Write-Host "--- 160 s de marche (la forme doit DESCENDRE) ---" + foreach ($i in 1..40) { + HoldMs $SC.W 2000 + HoldMs $SC.S 2000 + } + + Write-Host "--- 60 s d'immobilite complete (la forme doit REMONTER) ---" + Start-Sleep -Seconds 60 + + Write-Host "--- Redimensionnements ---" + foreach ($size in @(@(800,600), @(1280,720))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 + } + + $runH = Stop-Game +} + + +# =========================================================================== +# SCENARIO I (PHASE 17) - empreinte environnementale : faune et frequentation +# =========================================================================== +# Ce que ce scenario apporte, et que rien d'autre ne peut montrer : +# +# 1. LES ANIMAUX SONT DESSINES SOUS VULKAN, avec les couches de validation. +# C'est une geometrie neuve (world/AnimalMesh.cpp) et une nouvelle source de +# DrawItem ; les tests headless ne touchent ni au pipeline ni au GPU. +# +# 2. LE SEMIS TIENT SUR DU RELIEF MESURE. Le tirage-rejet filtre par pente et +# par couvert : sur du relief lisse il passe toujours, sur un massif a 562 m +# de denivele il peut ne RIEN rendre. C'est exactement le piege des phases +# precedentes - un filtre qui refuse tout donne un run parfaitement vert - +# d'ou le controle explicite "au moins un animal au depart". +# +# 3. LA MEMOIRE DE FREQUENTATION MONTE REELLEMENT EN JEU. Le harnais fait +# marcher le joueur en va-et-vient sur place : la telemetrie doit montrer la +# frequentation locale grimper, et des animaux PARTIR. Le comportement des +# seuils est prouve ailleurs (tests headless) ; ce qui est prouve ICI est que +# le cablage de main.cpp alimente bien la memoire avec la vraie position et +# la vraie activite du joueur, une fois par image. +# +# LE VA-ET-VIENT, ET POURQUOI : meme raison qu'au scenario H. Ce qui compte est +# la DUREE de presence dans le meme secteur, pas la distance parcourue - et un +# joueur qui finirait coince contre un versant ne marcherait plus, donc ne +# dérangerait plus (l'activite est deduite du deplacement REEL de la camera). +# +# LIMITE CONNUE, ASSUMEE : la dalle de reference n'a pas de carte de couvert +# LiDAR (LHD_0907_6440_1m_canopy.vchm est absent), donc la faune y est placee +# avec le couvert de substitut (WildlifeParams::coverWithoutMap). Le filtre par +# couvert REEL est couvert par les tests headless, pas par ce scenario. +$runI = $null +if ($hasLidar -and (Should-Run 'I')) { + Start-Game "SCENARIO I - faune et frequentation sur relief mesure" $lidarTile + + $wildlifeSeededLog = Wait-ForLog "animaux au depart" 5000 + Write-Host (" faune semee au demarrage : {0}" -f $wildlifeSeededLog) + + # 240 s et non 120. Mesure du premier run : a 120 s, le voisinage se vidait + # puis se REPEUPLAIT - les cellules a une centaine de metres ne sont derangees + # qu'au tiers de la vitesse de celle ou l'on se tient (ponderation en carre, + # voir Habitat::notePresence), donc elles passaient encore sous le seuil de + # reapparition. Il faut environ trois minutes pour que la couronne entiere + # depasse le seuil. C'est le comportement voulu - on ne vide pas un versant + # en deux minutes - mais il fallait que le scenario dure assez pour le voir. + Write-Host "--- 240 s de va-et-vient sur place (la frequentation doit MONTER) ---" + foreach ($i in 1..60) { + HoldMs $SC.W 2000 + HoldMs $SC.S 2000 + } + + Write-Host "--- Redimensionnements (les animaux restent dessines) ---" + foreach ($size in @(@(800,600), @(1280,720))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 + } + + $runI = Stop-Game +} + +# =========================================================================== +# SCENARIO J : recolte de matieres sur gisement mesure (PHASE 22) +# =========================================================================== +# Ce que ce scenario apporte, et que les tests headless ne peuvent pas donner : +# la chaine COMPLETE, sous les couches de validation Vulkan, depuis un gisement +# que LE JEU a detecte lui-meme sur le relief mesure jusqu'a une motte d'argile +# dans l'inventaire du joueur. +# +# LE POINT DE DEPART N'EST PAS CHOISI A LA MAIN. Le jeu journalise ses gisements +# au chargement, avec leurs coordonnees MONDE ; le script les relit et s'y rend. +# C'est la meme methode qu'au scenario H pour les points d'eau, et elle a la meme +# vertu : si le detecteur change, le scenario suit sans etre retouche, au lieu de +# viser une position gravee dans le script qui ne voudrait plus rien dire. +# +# La conversion monde -> EPSG:2154 est celle de la dalle de reference +# (LHD_0907_6440, emprise de 1000 m) : E = 907500 + x, N = 6439500 - z. Elle est +# verifiee a l'execution par la ligne "Position de depart" que le jeu emet. +# +# LES DEUX SENS DU TEST DE PORTEE, comme au scenario H : on creuse SUR le +# gisement (doit reussir), puis on s'en eloigne de 30 m et on recreuse (doit +# etre REFUSE, avec la distance). Un scenario qui ne ferait que le premier ne +# distinguerait pas "la portee marche" de "la touche produit toujours quelque +# chose". +# +# CE QUE CE SCENARIO NE COUVRE PAS, ET POURQUOI. Les PLANTES A FIBRES ne sont +# pas exercees ici : la dalle de reference n'a pas de carte de couvert produite +# (meme manque qu'au scenario I pour la faune), donc la voie "lisiere" y est +# muette et la voie "sol ouvert" demanderait d'abattre plusieurs arbres dans la +# meme cellule puis d'attendre. Elles sont couvertes par les tests headless, des +# deux cotes et avec leurs temoins. La RESINE n'est pas exercee non plus : elle +# demande de VISER un arbre, or le harnais ne sait pas tourner la camera (voir +# l'en-tete) et l'unique position de tir connue de cette dalle est deja consommee +# par l'abattage du scenario C. Ces deux manques sont notes dans +# NOTES-PHASE22.md ; ils ne sont pas des echecs, ce sont des limites du harnais. +$runJ = $null +$digDeposit = $null +$digAtSource = $false +$digTooFar = $false +$digPicked = $false +$fiberSeeded = $false +$fiberPulled = $false +$fiberPicked = $false +$fiberRegrowing = $false +if ($hasLidar -and (Should-Run 'J')) { + Start-Game "SCENARIO J - recolte de matieres, gisement LiDAR reel" $lidarTile + + # Le jeu emet ses gisements au chargement ; on attend la liste puis on la lit. + [void](Wait-ForLog 'Gisements : ' 8000) + $depositMatch = [regex]::Match($script:outSb.ToString(), + 'gisement \d+ : (argile|sable) en ([-0-9.]+) ([-0-9.]+) ([-0-9.]+)') + if ($depositMatch.Success) { + $digDeposit = [pscustomobject]@{ + Kind = $depositMatch.Groups[1].Value + X = [double]$depositMatch.Groups[2].Value + Z = [double]$depositMatch.Groups[4].Value + } + Write-Host (" gisement retenu : {0} en ({1:N1}, {2:N1})" -f + $digDeposit.Kind, $digDeposit.X, $digDeposit.Z) + } else { + Write-Host " [ATTENTION] le jeu n'a journalise aucun gisement." + } + + $runJ = Stop-Game + + if ($null -ne $digDeposit) { + # On RELANCE le jeu en demarrant SUR le gisement. Le harnais ne sait se + # deplacer que sur les axes du monde et a l'estime ; parcourir plusieurs + # centaines de metres de relief reel accumulerait une derive bien + # superieure aux 3,5 m de portee. --start supprime le probleme, exactement + # comme pour le velo (scenario E) et le point d'eau (scenario H). + $eastings = 907500.0 + $digDeposit.X + $northing = 6439500.0 - $digDeposit.Z + Start-Game "SCENARIO J - creuser le gisement, puis le meme geste a 30 m" $lidarTile ` + @("--start=$eastings,$northing") + + Write-Host "--- Creuser SUR le gisement (Y) ---" + Send-Key $SC.Y + $digAtSource = Wait-ForLog "Creuser : (une|un) .* tombe a vos pieds" 3000 + Write-Host (" matiere detachee du gisement : {0}" -f $digAtSource) + + Write-Host "--- Ramasser la matiere produite (R) ---" + Vacuum 3 + $digPicked = ($script:outSb.ToString() -match + 'Ramasse : (une motte d.argile|une poignee de sable)') + Write-Host (" matiere ramassee : {0}" -f $digPicked) + + Write-Host "--- S'en eloigner de 30 m, puis recreuser (controle negatif) ---" + Hold $SC.D 30.0 + Send-Key $SC.Y + $digTooFar = Wait-ForLog "Creuser : le gisement de .* est a .* m \(il faut etre a" 3000 + Write-Host (" refus a distance : {0}" -f $digTooFar) + + Write-Host "--- Redimensionnements apres la recolte ---" + foreach ($size in @(@(800,600), @(1280,720))) { + [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) + Start-Sleep -Milliseconds 700 + } + + $runJ2 = Stop-Game + # Les deux processus du scenario comptent pour un : on concatene leurs + # journaux et on garde le PIRE code de sortie, sans quoi un plantage du + # premier passerait inapercu. + $runJ = [pscustomobject]@{ + ExitCode = if ($runJ.ExitCode -ne 0) { $runJ.ExitCode } else { $runJ2.ExitCode } + Lines = @($runJ.Lines) + @($runJ2.Lines) + } + } + + # --- J3 : les PLANTES A FIBRES, et il faut changer de dalle pour ca ----- + # + # La dalle de reference du harnais (LHD_0907_6440) n'a PAS de carte de + # couvert produite - le meme manque qu'au scenario I pour la faune depuis la + # Phase 17. Or c'est la carte de couvert qui porte la voie "lisiere" du + # semis. Sur cette dalle, le semis est donc muet, et un scenario qui s'y + # tiendrait ne prouverait rien : il constaterait un zero PARFAITEMENT + # CORRECT et le prendrait pour une couverture de test. + # + # On charge donc la zone de 25 km2, qui a la sienne. Le point de depart n'a + # pas ete choisi a l'oeil : un balayage de la zone entiere au pas de 50 m, + # avec la fonction de semis ELLE-MEME, a cherche les cellules dont la + # densite est maximale ET qui portent des plantes a portee d'arrachage. Il y + # en a 1656 sur la zone ; la meilleure est monde (1450, -1750), altitude + # 1777 m, couvert 0,240 - soit le milieu exact de la bande de lisiere. + # + # Georeference de la zone : coin nord-ouest E 899000 / N 6440000, emprise + # 5000 m, centre a l'origine du monde. Donc E = 901500 + x et + # N = 6440000 - (z + 2500). Verifiee par la ligne "Position de depart" que + # le jeu emet, et par le point de depart par defaut (E 901500 / N 6437500 = + # monde (0, 0)). + # + # POURQUOI PAS AU POINT DE DEPART PAR DEFAUT DE LA ZONE : il est a 1947 m, + # au-dessus de la limite des arbres (FiberPlantParams::maxAltitude = 1900). + # Le semis y rend zero, et c'est le comportement voulu. Mesure faite : zero + # plante soumise, zero touffe d'herbe. Un scenario pose la aurait ete vert + # sans rien exercer. + if ($hasZone) { + Start-Game "SCENARIO J3 - plantes a fibres en lisiere LiDAR (zone 25 km2)" $zoneTile ` + @("--start=902950,6439250") + + $fiberSeeded = Wait-ForLog "Plantes a fibres : [1-9][0-9]* soumises" 12000 + Write-Host (" plantes a fibres semees par la lisiere : {0}" -f $fiberSeeded) + + Write-Host "--- Arracher la plante a portee (I) ---" + Send-Key $SC.I + $fiberPulled = Wait-ForLog "Fibres : la tige cede" 3000 + Write-Host (" tige arrachee : {0}" -f $fiberPulled) + + Write-Host "--- Ramasser le fagot (R) ---" + Vacuum 2 + $fiberPicked = ($script:outSb.ToString() -match 'Ramasse : une tige a fibres') + Write-Host (" fagot ramasse : {0}" -f $fiberPicked) + + # La plante doit etre EN REPOUSSE, pas disparue : c'est ce qui distingue + # un semis deterministe d'un semis qu'on aurait ampute. + $fiberRegrowing = ($script:outSb.ToString() -match + 'Plantes a fibres : \d+ soumises, [1-9][0-9]* arrachee') + Write-Host (" plante en repousse (et non disparue) : {0}" -f $fiberRegrowing) + + $runJ3 = Stop-Game + $runJ = [pscustomobject]@{ + ExitCode = if ($runJ.ExitCode -ne 0) { $runJ.ExitCode } else { $runJ3.ExitCode } + Lines = @($runJ.Lines) + @($runJ3.Lines) + } + } else { + Write-Host "--- Plantes a fibres : IGNORE, la zone de 25 km2 n'est pas produite ---" + } +} + +# =========================================================================== +# Analyse +# =========================================================================== +function Count-Match($lines, $pattern) { @($lines | Where-Object { $_ -match $pattern }).Count } + +$all = @() +if ($null -ne $runA) { $all += @($runA.Lines) } +if ($null -ne $runB) { $all += @($runB.Lines) } +if ($null -ne $runC) { $all += @($runC.Lines) } +if ($null -ne $runD) { $all += @($runD.Lines) } +if ($null -ne $runE) { $all += @($runE.Lines) } +if ($null -ne $runF) { $all += @($runF.Lines) } +if ($null -ne $runG1) { $all += @($runG1.Lines) + @($runG2.Lines) + @($runG3.Lines) } +if ($null -ne $runH) { $all += @($runH.Lines) } +if ($null -ne $runI) { $all += @($runI.Lines) } +if ($null -ne $runJ) { $all += @($runJ.Lines) } +# --- PHASE 24 : le journal BRUT du jeu, sur disque --------------------------- +# Le harnais imprime ses CONCLUSIONS ; quand l'une d'elles est fausse, il n'y a +# aucun moyen de savoir ce que le jeu avait reellement emis. Ce projet a perdu +# cinq phases sur exactement ce manque (dette du velo, Phases 17 a 22 : la ligne +# etait dans $runE.Lines depuis le debut). Le dump coute une ecriture de fichier +# par execution et rend l'ecart entre "le jeu s'est trompe" et "le script a mal +# lu" verifiable au lieu d'etre suppose. +# HORODATE, et non un nom fixe. Le premier jet ecrivait toujours +# 'vercora_last_run.log' : une execution suivante ECRASAIT la precedente, et +# c'est arrive tout de suite - le run 5 de la Phase 24 a echoue, le run 6 a +# reussi et a efface la seule trace de l'echec, qui est devenu indiagnosticable. +# Un journal de diagnostic qui ne survit pas a l'execution suivante ne sert a +# rien : les echecs de ce harnais sont justement ceux qu'on ne reproduit pas a +# volonte. +# +# PHASE 26 : le dump porte desormais un EN-TETE PAR PROCESSUS. Sans lui, les +# quatorze runs etaient concatenes bout a bout et une ligne du journal n'etait +# rattachable a aucun scenario : le run en echec de la Phase 25 (78 % de la +# telemetrie du scenario I manquante) n'aurait de toute facon pas ete +# diagnosticable a partir du dump seul, meme s'il avait survecu. On ecrit aussi +# la DUREE MUR de chaque processus, qui est ce qui distingue "le jeu a emis +# moins de lignes par seconde" de "le scenario a dure moins longtemps". +# +# $dumpLines est CONSTRUIT A PART de $all : aucune assertion du harnais ne voit +# ces en-tetes, donc l'instrumentation ne peut pas changer un verdict. +$dumpLines = @() +foreach ($r in $script:allRuns) { + $dumpLines += "" + $dumpLines += "########## RUN {0} ##########" -f $r.Label + $dumpLines += "# demarre a : {0}" -f $r.StartedAt.ToString('HH:mm:ss.fff') + $dumpLines += "# duree mur : {0} s" -f $r.WallSeconds + $dumpLines += "# code de sortie: {0}" -f $r.ExitCode + $dumpLines += "# lignes : {0}" -f $r.Lines.Count + $dumpLines += $r.Lines +} + +$stamp = (Get-Date).ToString('yyyyMMdd-HHmmss') +$rawLog = Join-Path $env:TEMP "vercora_run_$stamp.log" +try { $dumpLines | Set-Content -Path $rawLog -Encoding UTF8 } catch {} +# Une copie a nom fixe reste bien commode pour "regarder le dernier". +try { $dumpLines | Set-Content -Path (Join-Path $env:TEMP 'vercora_last_run.log') -Encoding UTF8 } catch {} +Write-Host "Journal brut du jeu : $rawLog ($($all.Count) lignes)" + +$validation = @($all | Where-Object { $_ -match '\[Validation\]' }) +$errors = @($all | Where-Object { $_ -match '^\[ERROR\]' }) +$warnings = @($all | Where-Object { $_ -match '^\[WARN\]' }) +$cleanA = ($null -eq $runA) -or ((Count-Match $runA.Lines 'Fermeture propre') -ge 1) +$cleanB = ($null -eq $runB) -or ((Count-Match $runB.Lines 'Fermeture propre') -ge 1) +$exitA = if ($null -ne $runA) { $runA.ExitCode } else { 0 } +$exitB = if ($null -ne $runB) { $runB.ExitCode } else { 0 } + +# Scenario C : tout ce qui suit vaut $true quand la dalle est absente, pour que +# son absence ignore le scenario au lieu de faire echouer le script. +$cleanC = $true; $exitC = 0; $lidarLoaded = $true; $lidarFelled = $true; $lidarPicked = 0 +if ($null -ne $runC) { + $cleanC = (Count-Match $runC.Lines 'Fermeture propre') -ge 1 + $exitC = $runC.ExitCode + # Preuve que c'est bien la DALLE qui a ete chargee, et non un repli + # silencieux sur le generateur procedural - lequel produirait par ailleurs un + # scenario entierement vert. + $lidarLoaded = (Count-Match $runC.Lines 'Terrain reel charge') -ge 1 + $felledC = @($runC.Lines | ForEach-Object { + $m = [regex]::Match($_, "Abattage de l'arbre (\d+)"); if ($m.Success) { $m.Groups[1].Value } }) + $lidarFelled = ($felledC -contains $expectedTreeC) + $lidarPicked = (Count-Match $runC.Lines 'Ramasse : ') +} + +# Scenario D : meme convention, $true quand la dalle est absente. +$cleanD = $true; $exitD = 0 +if ($null -ne $runD) { + $cleanD = (Count-Match $runD.Lines 'Fermeture propre') -ge 1 + $exitD = $runD.ExitCode +} + +# Scenario E : meme convention, $true quand la dalle est absente. +# +# Le depouillement ne se contente PAS de constater qu'on est monte sur le velo : +# il relit la telemetrie emise chaque seconde et verifie que la physique a +# reellement travaille sur du relief - une descente franche, une remontee, et +# des vitesses dans la fourchette annoncee. Un velo bloque a 0 km/h contre un +# arbre donnerait autrement un scenario parfaitement vert. +$cleanE = $true; $exitE = 0 +$bikeMaxKmh = 0.0; $bikeDescentKmh = 0.0; $bikeClimbKmh = -1.0 +$bikeDescentMean = 0.0; $bikeClimbMean = 0.0 +$bikeDescentN = 0; $bikeClimbN = 0 +$bikeClimbGain = 0.0; $bikeStalled = 0 +$bikeMinSlope = 0.0; $bikeMaxSlope = 0.0 +$bikeMinAlt = 0.0; $bikeMaxAlt = 0.0; $bikeSamples = 0 +if ($null -ne $runE) { + $cleanE = (Count-Match $runE.Lines 'Fermeture propre') -ge 1 + $exitE = $runE.ExitCode + + $kmh = @(); $slopes = @(); $alts = @(); $lastAlt = $null + foreach ($line in $runE.Lines) { + $m = [regex]::Match($line, + 'Velo : ([-0-9.]+) km/h, pente ([-0-9.]+) %.*altitude ([-0-9.]+) m') + if ($m.Success) { + $v = [double]$m.Groups[1].Value + $p = [double]$m.Groups[2].Value + $a = [double]$m.Groups[3].Value + $kmh += $v; $slopes += $p; $alts += $a + if ($v -gt $bikeMaxKmh) { $bikeMaxKmh = $v } + # Vitesse la plus elevee constatee EN DESCENTE franche, et la plus + # elevee constatee EN MONTEE franche : c'est leur ecart qui montre + # que la pente pilote bien la vitesse. + if ($p -le -8.0) { + if ($v -gt $bikeDescentKmh) { $bikeDescentKmh = $v } + $bikeDescentMean += $v; $bikeDescentN++ + } + if ($p -ge 8.0) { + if ($v -gt $bikeClimbKmh) { $bikeClimbKmh = $v } + # Moyenne calculee EN MOUVEMENT seulement, et calages comptes a + # part. Melanger les deux donnerait une moyenne qui ne decrit + # rien : ni la vitesse de montee, ni la frequence des arrets. + if ($v -gt 0.5) { $bikeClimbMean += $v; $bikeClimbN++ } else { $bikeStalled++ } + } + # Denivele REELLEMENT gagne : somme des montees d'altitude entre deux + # releves consecutifs pendant que la pente est ascendante. C'est la + # seule mesure qui prouve que le velo MONTE, par opposition a "une + # pente positive a ete rencontree" (vrai meme a l'arret) ou a "un pic + # de vitesse en cote" (vrai en emportant l'elan de la descente). + if ($p -ge 2.0 -and $lastAlt -ne $null -and $a -gt $lastAlt) { + $bikeClimbGain += ($a - $lastAlt) + } + $lastAlt = $a + } + } + $bikeSamples = $kmh.Count + # MOYENNES et non seulement maxima. Le maximum en montee est trompeur : il + # inclut la seconde ou le velo aborde la cote en emportant encore la vitesse + # de la descente precedente. La moyenne, elle, dit ce que le velo tient + # REELLEMENT dans la pente, et c'est elle qui porte la comparaison. + if ($bikeDescentN -gt 0) { $bikeDescentMean = $bikeDescentMean / $bikeDescentN } + if ($bikeClimbN -gt 0) { $bikeClimbMean = $bikeClimbMean / $bikeClimbN } + if ($bikeSamples -gt 0) { + $bikeMinSlope = ($slopes | Measure-Object -Minimum).Minimum + $bikeMaxSlope = ($slopes | Measure-Object -Maximum).Maximum + $bikeMinAlt = ($alts | Measure-Object -Minimum).Minimum + $bikeMaxAlt = ($alts | Measure-Object -Maximum).Maximum + } +} + +$linesA = if ($null -ne $runA) { $runA.Lines } else { @() } +$linesB = if ($null -ne $runB) { $runB.Lines } else { @() } +$picked = @($linesA | Where-Object { $_ -match 'Ramasse : ' }) +$knapped = Count-Match $linesA 'eclat tranchant se detache' +$felledA = @($linesA | ForEach-Object { + $m = [regex]::Match($_, "Abattage de l'arbre (\d+)"); if ($m.Success) { $m.Groups[1].Value } }) +$felledB = @($linesB | ForEach-Object { + $m = [regex]::Match($_, "Abattage de l'arbre (\d+)"); if ($m.Success) { $m.Groups[1].Value } }) + +$aimHit = ($null -eq $runA) -or ($felledA -contains $expectedTree) +# Le scenario B doit avoir abattu l'arbre 7 (ce qui prouve qu'on l'a atteint et +# vise) puis avoir pousse dans sa souche. On ne conclut RIEN sur le comportement +# de la collision ici - voir le commentaire du scenario B. +$collisionPathExercised = ($null -eq $runB) -or (($felledB -contains '7') -and + ((Count-Match $linesB 'Debitage en cours') -ge 1)) + +$kinds = @{} +foreach ($p in $picked) { + $m = [regex]::Match($p, 'Ramasse : (?:une|un) (\w+)') + if ($m.Success) { $kinds[$m.Groups[1].Value] = $true } +} + +# Scenario F : meme convention, $true quand la dalle est absente. +# +# Comme pour le velo, le depouillement ne se contente PAS de constater qu'on +# s'est engage : il relit la telemetrie emise chaque seconde et verifie que +# l'escalade a reellement travaille sur du relief - de la pente au-dessus du +# seuil de paroi, une jauge qui DESCEND, et un gain d'altitude reel. Un grimpeur +# accroche sans bouger donnerait autrement un scenario parfaitement vert. +$cleanF = $true; $exitF = 0 +$climbSamples = 0 +$climbMinStamina = 100.0; $climbMaxGain = 0.0 +$climbMinSlope = 1e9; $climbMaxSlope = 0.0 +$climbMinAlt = 1e9; $climbMaxAlt = -1e9 +$climbStaminaRecovered = $false +if ($null -ne $runF) { + $cleanF = (Count-Match $runF.Lines 'Fermeture propre') -ge 1 + $exitF = $runF.ExitCode + + $staminas = @() + foreach ($line in $runF.Lines) { + $m = [regex]::Match($line, + 'Escalade : energie ([-0-9.]+) %, pente ([-0-9.]+) %, altitude ([-0-9.]+) m, gain ([-0-9.]+) m') + if ($m.Success) { + $e = [double]$m.Groups[1].Value + $p = [double]$m.Groups[2].Value + $a = [double]$m.Groups[3].Value + $g = [double]$m.Groups[4].Value + $climbSamples++ + $staminas += $e + if ($e -lt $climbMinStamina) { $climbMinStamina = $e } + if ($g -gt $climbMaxGain) { $climbMaxGain = $g } + if ($p -lt $climbMinSlope) { $climbMinSlope = $p } + if ($p -gt $climbMaxSlope) { $climbMaxSlope = $p } + if ($a -lt $climbMinAlt) { $climbMinAlt = $a } + if ($a -gt $climbMaxAlt) { $climbMaxAlt = $a } + } + } + # La jauge doit REMONTER quelque part dans le run : c'est la preuve que le + # repos au sol entre les deux engagements a bien recupere. Sans ce controle, + # une recuperation cassee passerait inapercue - la seconde ascension serait + # simplement plus courte. + for ($i = 1; $i -lt $staminas.Count; $i++) { + if ($staminas[$i] -gt $staminas[$i - 1] + 1.0) { $climbStaminaRecovered = $true } + } + if ($climbSamples -eq 0) { $climbMinSlope = 0.0; $climbMinAlt = 0.0; $climbMaxAlt = 0.0 } +} + +# Scenario G : meme convention que C..F, $true quand la dalle est absente. +# +# Le depouillement ne se contente pas de constater que les touches sont passees. +# Il verifie que le catalogue s'est constitue, que des objets ont ete REELLEMENT +# poses puis relus depuis le disque, et - le point qui compte - que ces objets +# ARRETENT le joueur, en comparant la distance parcourue a celle du temoin. +$cleanG1 = $true; $cleanG2 = $true; $cleanG3 = $true +$exitG1 = 0; $exitG2 = 0; $exitG3 = 0 +$editorEntered = $false; $editorLeft = $false +$catalogCount = 0; $editorPlaced = 0; $editorDeleted = 0; $editorUndone = 0 +$editorSelected = $false; $editorSaved = 0; $editorReloaded = 0 +$editorPlacedDistinct = 0 +$editorCycled = 0 +$sceneAutoLoaded = 0; $sceneSolid = 0 +$walkWithScene = 0.0; $walkControl = 0.0 +if ($null -ne $runG1) { + $cleanG1 = (Count-Match $runG1.Lines 'Fermeture propre') -ge 1 + $cleanG2 = (Count-Match $runG2.Lines 'Fermeture propre') -ge 1 + $cleanG3 = (Count-Match $runG3.Lines 'Fermeture propre') -ge 1 + $exitG1 = $runG1.ExitCode; $exitG2 = $runG2.ExitCode; $exitG3 = $runG3.ExitCode + + $editorEntered = (Count-Match $runG1.Lines '=== MODE EDITEUR ===') -ge 1 + $editorLeft = (Count-Match $runG1.Lines 'retour au JEU') -ge 1 + $editorPlaced = Count-Match $runG1.Lines 'Editeur : pose de' + # Nombre de lignes de pose DISTINCTES. Discriminant ajoute apres un run ou le + # compte etait de 9 pour trois touches envoyees : il separe "le jeu a + # reellement pose neuf objets" (neuf lignes differentes, les identifiants + # allant de 1 a 9) de "la meme ligne a ete comptee plusieurs fois" (trois + # lignes distinctes repetees), qui sont deux defauts sans rapport - l'un dans + # le jeu, l'autre dans la capture de sortie de ce script. + $editorPlacedDistinct = (@($runG1.Lines | + Where-Object { $_ -match 'Editeur : pose de' } | Select-Object -Unique)).Count + $editorDeleted = Count-Match $runG1.Lines 'Editeur : objet \d+ .* supprime' + $editorUndone = Count-Match $runG1.Lines 'Editeur : annule' + $editorSelected = (Count-Match $runG1.Lines 'Editeur : selection de l''objet') -ge 1 + # F3/F4 : selection SANS viser (ajout ergonomique post-Phase 15). Deux F3 + # puis un F4 sont envoyes ; ce compte doit valoir 3, sans quoi une des + # trois touches a ete perdue en route (scancode faux, front non resynchro- + # nise, etc.) - exactement le genre de defaut que le headless ne peut pas + # voir puisqu'il ne passe jamais par GLFW/PostMessage. + $editorCycled = Count-Match $runG1.Lines '\[F3/F4\]' + + $m = [regex]::Match(($runG1.Lines -join "`n"), 'Editeur : (\d+) asset\(s\) au catalogue') + if ($m.Success) { $catalogCount = [int]$m.Groups[1].Value } + + # Nombre d'objets REELLEMENT ecrits sur le disque, tel que le jeu l'a + # journalise - et non tel que le script croit les avoir poses. + $m = [regex]::Match(($runG1.Lines -join "`n"), 'Scene : (\d+) objet\(s\) ecrits') + if ($m.Success) { $editorSaved = [int]$m.Groups[1].Value } + # Rechargement a la touche F9, DANS le meme processus. + $reloadMatches = [regex]::Matches(($runG1.Lines -join "`n"), 'Scene : (\d+) objet\(s\) charges') + if ($reloadMatches.Count -gt 0) { + $editorReloaded = [int]$reloadMatches[$reloadMatches.Count - 1].Groups[1].Value + } + + # G2 : chargement AUTOMATIQUE hors mode editeur. + $m = [regex]::Match(($runG2.Lines -join "`n"), + 'Scene : (\d+) objet\(s\) charges .*?\((\d+) solide') + if ($m.Success) { + $sceneAutoLoaded = [int]$m.Groups[1].Value + $sceneSolid = [int]$m.Groups[2].Value + } + + # Distance REELLEMENT parcourue vers le nord, lue dans la trace de position + # emise chaque seconde. Le nord est en -Z (voir Heightmap.hpp), d'ou le signe. + function Get-WalkDistance($lines) { + $samples = @($lines | ForEach-Object { + $mm = [regex]::Match($_, 'Camera : yaw .* position ([-0-9.]+) ([-0-9.]+) ([-0-9.]+)') + if ($mm.Success) { [double]$mm.Groups[3].Value } }) + if ($samples.Count -eq 0) { return 0.0 } + return [Math]::Abs(($samples | Measure-Object -Minimum).Minimum) + } + $walkWithScene = Get-WalkDistance $runG2.Lines + $walkControl = Get-WalkDistance $runG3.Lines +} + +# --------------------------------------------------------------------------- +# Scenario I : depouillement de la telemetrie d'empreinte (PHASE 17) +# --------------------------------------------------------------------------- +# Meme convention que C..H : tout vaut $true quand le scenario n'a pas ete joue. +# +# La ligne depouillee est celle emise une fois par seconde par main.cpp. On en +# tire quatre grandeurs, et chacune repond a une question qui, seule, laisserait +# passer un systeme casse : +# * le nombre d'animaux au DEPART -> le semis a-t-il rendu quelque chose ? +# * la frequentation MAXIMALE -> la memoire monte-t-elle vraiment ? +# * le nombre d'animaux EN FUITE -> la faune reagit-elle au joueur ? +# * le nombre de RELEVES -> a-t-on seulement mesure ? +$cleanI = $true; $exitI = 0 +$wildlifeStart = 0; $wildlifeSamples = 0 +$wildlifeMaxDisturbance = 0.0; $wildlifeMaxFleeing = 0; $wildlifeMinAnimals = 9999 +$wildlifeNearFirst = 0; $wildlifeNearLast = 0; $wildlifeNearMin = 9999 +if ($null -ne $runI) { + $cleanI = (Count-Match $runI.Lines 'Fermeture propre') -ge 1 + $exitI = $runI.ExitCode + + $mStart = [regex]::Match(($runI.Lines -join "`n"), 'Faune : (\d+) animaux au depart') + if ($mStart.Success) { $wildlifeStart = [int]$mStart.Groups[1].Value } + + foreach ($line in $runI.Lines) { + $m = [regex]::Match($line, + 'Faune : (\d+) animaux dont (\d+) en fuite, (\d+) a moins de .*frequentation ici ([-0-9.]+) %') + if ($m.Success) { + $wildlifeSamples++ + $count = [int]$m.Groups[1].Value + $fleeing = [int]$m.Groups[2].Value + $near = [int]$m.Groups[3].Value + $disturbance = [double]$m.Groups[4].Value + if ($fleeing -gt $wildlifeMaxFleeing) { $wildlifeMaxFleeing = $fleeing } + if ($disturbance -gt $wildlifeMaxDisturbance) { $wildlifeMaxDisturbance = $disturbance } + if ($count -lt $wildlifeMinAnimals) { $wildlifeMinAnimals = $count } + if ($near -lt $wildlifeNearMin) { $wildlifeNearMin = $near } + if ($wildlifeSamples -eq 1) { $wildlifeNearFirst = $near } + $wildlifeNearLast = $near + } + } + if ($wildlifeSamples -eq 0) { $wildlifeMinAnimals = 0; $wildlifeNearMin = 0 } + + # --- PHASE 26 : le DISCRIMINATEUR de la telemetrie courte --------------- + # Le scenario I a echoue une fois en Phase 25 avec 78 % de ses releves + # manquants, et la cause n'a pas pu etre retrouvee. Le releve de faune est + # emis DANS LE MEME bloc "une fois par seconde" que la ligne "Camera :", + # laquelle est emise SANS AUCUNE CONDITION (ni editeur, ni faune vivante). + # Comparer les deux comptes separe donc deux causes qu'aucune des deux ne + # distingue seule : + # * les deux comptes chutent ensemble -> c'est le TIC lui-meme qui n'a pas + # battu 240 fois : le jeu a tourne moins longtemps, ou la cadence du + # compteur d'images a derive. + # * "Camera :" intact, "Faune :" effondre -> c'est la CONDITION de la + # ligne de faune (editorMode, ou wildlife devenu nul) qui a saute. + # Et la duree mur dit si le scenario a seulement dure les 240 s prevues. + $cameraTicks = (Count-Match $runI.Lines 'Camera : yaw') + Write-Host ("[diag I] duree mur {0} s, tics 'Camera :' {1}, releves faune {2}" -f + $runI.WallSeconds, $cameraTicks, $wildlifeSamples) +} + +# La DEFORESTATION, elle, se lit dans les scenarios qui abattent deja des arbres +# (A et B). Aucun processus supplementaire : la ligne d'empreinte est emise dans +# tous les runs, et le compteur de pointe y monte des le premier arbre couche. +# C'est le chainon "abattage -> memoire du milieu" verifie SOUS VULKAN. +$loggingPeak = 0.0 +foreach ($line in @($linesA) + @($linesB)) { + $m = [regex]::Match($line, 'pointes [-0-9.]+/([-0-9.]+) %') + if ($m.Success -and ([double]$m.Groups[1].Value) -gt $loggingPeak) { + $loggingPeak = [double]$m.Groups[1].Value + } +} + +Write-Host "" +Write-Host "==================== RESULTAT ====================" +Write-Host ("Code de sortie A..G : {0} / {1} / {2} / {3} / {4} / {5} / {6}" -f + $(if ($null -ne $runA) { $exitA } else { "(ignore)" }), + $(if ($null -ne $runB) { $exitB } else { "(ignore)" }), + $(if ($null -ne $runC) { $exitC } else { "(ignore)" }), + $(if ($null -ne $runD) { $exitD } else { "(ignore)" }), + $(if ($null -ne $runE) { $exitE } else { "(ignore)" }), + $(if ($null -ne $runF) { $exitF } else { "(ignore)" }), + $(if ($null -ne $runG1) { "$exitG1/$exitG2/$exitG3" } else { "(ignore)" })) +Write-Host ("Lignes de log : {0}" -f $all.Count) +Write-Host ("Messages [Validation] : {0}" -f $validation.Count) +Write-Host ("Lignes [ERROR] : {0}" -f $errors.Count) +Write-Host ("Lignes [WARN] : {0}" -f $warnings.Count) +Write-Host ("Fermeture propre A..G : {0} / {1} / {2} / {3} / {4} / {5} / {6}" -f $cleanA, $cleanB, + $(if ($null -ne $runC) { $cleanC } else { "(ignore)" }), + $(if ($null -ne $runD) { $cleanD } else { "(ignore)" }), + $(if ($null -ne $runE) { $cleanE } else { "(ignore)" }), + $(if ($null -ne $runF) { $cleanF } else { "(ignore)" }), + $(if ($null -ne $runG1) { "$cleanG1/$cleanG2/$cleanG3" } else { "(ignore)" })) +Write-Host "" +Write-Host "---- Gameplay effectivement exerce ----" +Write-Host ("Arbres abattus : {0}" -f ($felledA.Count + $felledB.Count)) +Write-Host ("Arbres au sol : {0}" -f (Count-Match $all 'Arbre a terre')) +Write-Host ("Debitages declenches : {0}" -f (Count-Match $all 'Debitage en cours')) +Write-Host ("Objets ramasses (R) : {0} [{1}]" -f $picked.Count, (($kinds.Keys | Sort-Object) -join ', ')) +$picked | ForEach-Object { Write-Host (" {0}" -f ($_ -replace '^\[INFO\]\s+','')) } +Write-Host ("Percussions reussies (C) : {0}" -f $knapped) +Write-Host ("Arbre vise / abattus (A) : {0} / [{1}] {2}" -f $expectedTree, ($felledA -join ','), + $(if ($aimHit) { "(pilotage precis)" } else { "(DERIVE : cible manquee)" })) +# --- PHASE 24 : ce que le FILTRE DE PENTE a fait pendant le run -------------- +# La marche a desormais une limite de pente (core/SlopeLimits.hpp), et le +# harnais navigue A L'ESTIME : il tient une touche pendant distance/14 m/s. Une +# marche ralentie par le relief est donc une cause POSSIBLE d'une cible manquee, +# a cote de la derive deja connue. Sans cette trace, les deux sont +# indiscernables - et ce projet a deja perdu cinq phases a accuser le jeu d'un +# defaut qui etait dans l'instrument. +# +# Le jeu ne journalise que les CHANGEMENTS d'etat : ces lignes sont rares. +$slopeLines = @($all | Where-Object { $_ -match 'Marche : ' }) +Write-Host ("Filtre de pente (Phase 24): {0} changement(s) d'etat journalise(s)" -f $slopeLines.Count) +$slopeLines | Select-Object -First 12 | ForEach-Object { + Write-Host (" {0}" -f ($_ -replace '^\[INFO\]\s+','')) +} + +Write-Host ("Chemin de collision (B) : {0}" -f + $(if ($collisionPathExercised) { "tronc debout PUIS souche pousses, sans erreur ni plantage" } + else { "scenario B incomplet (l'arbre 7 n'a pas ete abattu)" })) +Write-Host " (comportement de la collision : prouve par tests\logic_tests.cpp)" + +Write-Host "" +Write-Host "---- Dalle LiDAR HD reelle (scenario C) ----" +if ($null -eq $runC) { + Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." +} else { + $meshLine = @($runC.Lines | Where-Object { $_ -match 'Maillage terrain genere' }) | Select-Object -First 1 + $loadLine = @($runC.Lines | Where-Object { $_ -match 'Terrain reel charge' }) | Select-Object -First 1 + Write-Host ("Dalle chargee : {0}" -f $lidarLoaded) + if ($loadLine) { Write-Host (" {0}" -f ($loadLine -replace '^\[INFO\]\s+','')) } + if ($meshLine) { Write-Host (" {0}" -f ($meshLine -replace '^\[INFO\]\s+','')) } + Write-Host ("Arbre vise / abattu : {0} / {1}" -f $expectedTreeC, + $(if ($lidarFelled) { "abattu (marche et visee OK sur relief mesure)" } + else { "MANQUE" })) + Write-Host ("Objets ramasses : {0}" -f $lidarPicked) +} + +Write-Host "" +Write-Host "---- Vol en parapente (scenario D) ----" +if ($null -eq $runD) { + Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." +} else { + $landedLine = @($runD.Lines | Where-Object { $_ -match 'Parapente : atterrissage|vol interrompu' }) | Select-Object -First 1 + Write-Host ("Decollage : {0}" -f $paraglideLaunched) + Write-Host ("Fin de vol : {0}" -f $paraglideEnded) + if ($landedLine) { Write-Host (" {0}" -f ($landedLine -replace '^\[INFO\]\s+','')) } +} + +Write-Host "" +Write-Host "---- Sortie a velo (scenario E) ----" +if ($null -eq $runE) { + Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." +} else { + Write-Host ("En selle / pied a terre : {0} / {1}" -f $bikeMounted, $bikeDismounted) + Write-Host ("Releves de telemetrie : {0}" -f $bikeSamples) + Write-Host ("Vitesse maximale : {0:N1} km/h" -f $bikeMaxKmh) + Write-Host (" en descente (pente <= -8 %) : {0:N1} km/h au pic, {1:N1} km/h en moyenne sur {2} releves" -f + $bikeDescentKmh, $bikeDescentMean, $bikeDescentN) + Write-Host (" en montee (pente >= +8 %) : {0}" -f + $(if ($bikeClimbKmh -ge 0) { "{0:N1} km/h au pic, {1:N1} km/h en moyenne sur {2} releves EN MOUVEMENT" -f $bikeClimbKmh, $bikeClimbMean, $bikeClimbN } else { "aucun releve" })) + Write-Host (" releves a l'arret en cote : {0} (le velo cale au-dela de 23,6 % de pente)" -f $bikeStalled) + Write-Host ("Denivele reellement GAGNE : {0:N1} m (somme des montees sous pente ascendante)" -f $bikeClimbGain) + Write-Host ("Pente rencontree : {0:N1} % a {1:N1} %" -f $bikeMinSlope, $bikeMaxSlope) + Write-Host ("Altitude parcourue : {0:N1} m a {1:N1} m (denivele {2:N1} m)" -f + $bikeMinAlt, $bikeMaxAlt, ($bikeMaxAlt - $bikeMinAlt)) +} + +Write-Host "" +Write-Host "---- Empreinte environnementale (scenario I, PHASE 17) ----" +if ($null -eq $runI) { + Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." +} else { + Write-Host ("Animaux au demarrage : {0}" -f $wildlifeStart) + Write-Host ("Releves de telemetrie : {0}" -f $wildlifeSamples) + Write-Host ("Frequentation locale : {0:N1} % au maximum" -f $wildlifeMaxDisturbance) + Write-Host ("Animaux en fuite : {0} simultanement au pic" -f $wildlifeMaxFleeing) + Write-Host ("Population minimale : {0} animaux (l'effectif TOTAL bouge peu : la faune s'ecarte, elle ne s'evapore pas)" -f $wildlifeMinAnimals) + Write-Host ("Animaux a portee de vue : {0} au premier releve -> {1} au dernier (minimum {2})" -f + $wildlifeNearFirst, $wildlifeNearLast, $wildlifeNearMin) +} +Write-Host ("Deforestation apres coupe : {0:N1} % au pic (scenarios A et B)" -f $loggingPeak) + +Write-Host "" +Write-Host "---- Recolte de matieres (scenario J, PHASE 22) ----" +if ($null -eq $runJ) { + Write-Host "Ignore : la dalle n'a pas ete produite, ou scenario non joue." +} else { + if ($null -ne $digDeposit) { + Write-Host ("Gisement vise : {0} en ({1:N1}, {2:N1}), detecte PAR LE JEU" -f + $digDeposit.Kind, $digDeposit.X, $digDeposit.Z) + } + Write-Host ("Creuse sur le gisement : {0}" -f $digAtSource) + Write-Host ("Matiere ramassee (R) : {0}" -f $digPicked) + Write-Host ("Refus a 30 m : {0} (controle negatif de la portee)" -f $digTooFar) + if ($hasZone) { + Write-Host ("Plantes a fibres semees : {0} (voie LISIERE, carte de couvert de la zone 25 km2)" -f $fiberSeeded) + Write-Host ("Tige arrachee (I) : {0}" -f $fiberPulled) + Write-Host ("Fagot ramasse (R) : {0}" -f $fiberPicked) + Write-Host ("Plante EN REPOUSSE : {0} (et non disparue du semis)" -f $fiberRegrowing) + } else { + Write-Host "Plantes a fibres : ignorees, la zone de 25 km2 n'est pas produite" + Write-Host " (c'est elle seule qui a une carte de couvert)." + } + Write-Host "PLACEMENT DES GISEMENTS : proxy morphologique, PAS une carte geologique" + Write-Host " (world/Deposits.hpp). La RESINE n'est pas exercee" + Write-Host " ici - elle demande de viser un arbre, or le harnais" + Write-Host " ne sait pas tourner la camera. Voir NOTES-PHASE22.md." +} +Write-Host "" +Write-Host "---- Escalade (scenario F) ----" +if ($null -eq $runF) { + Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." +} else { + Write-Host ("Engagement / lachage : {0} / {1}" -f $climbEngaged, $climbReleased) + Write-Host ("Re-engagement / SOMMET : {0} / {1}" -f $climbReEngaged, $climbToppedOut) + Write-Host ("Releves de telemetrie : {0}" -f $climbSamples) + Write-Host ("Jauge d'energie : minimum {0:N0} %" -f $climbMinStamina) + Write-Host (" recuperation constatee : {0} (la jauge remonte pendant le repos au sol)" -f + $climbStaminaRecovered) + Write-Host ("Gain d'altitude maximal : {0:N1} m au-dessus du pied de la paroi" -f $climbMaxGain) + Write-Host ("Pente sous les mains : {0:N0} % a {1:N0} % (seuil de paroi : 100 %)" -f + $climbMinSlope, $climbMaxSlope) + Write-Host ("Altitude parcourue : {0:N1} m a {1:N1} m (denivele {2:N1} m)" -f + $climbMinAlt, $climbMaxAlt, ($climbMaxAlt - $climbMinAlt)) +} + +# Scenario H : meme convention que C..G, $true quand la dalle est absente. +# +# Le depouillement relit la telemetrie des besoins, emise chaque seconde, et +# verifie DEUX mouvements opposes : la forme descend pendant la marche, et elle +# remonte pendant l'arret. Constater seulement qu'elle a bouge ne prouverait +# rien - une jauge qui ne fait que descendre est une jauge sans repos. +$cleanH = $true; $exitH = 0 +$needsSamples = 0 +$needsWaterFound = 0 +$needsMinForme = 100.0; $needsMaxForme = 0.0 +$needsMinSoif = 100.0 +$needsFormeRecovered = $false +$needsMinAmbient = 1e9; $needsMaxAmbient = -1e9 +$needsFinalMove = 100.0 +if ($null -ne $runH) { + $cleanH = (Count-Match $runH.Lines 'Fermeture propre') -ge 1 + $exitH = $runH.ExitCode + + $m = [regex]::Match(($runH.Lines -join "`n"), "Points d'eau : (\d+) creux retenus") + if ($m.Success) { $needsWaterFound = [int]$m.Groups[1].Value } + + $formes = @() + foreach ($line in $runH.Lines) { + $m = [regex]::Match($line, + 'Besoins : faim (\d+)% soif (\d+)% forme (\d+)% chaud (\d+)%, ambiante ([-0-9]+) C, ressenti ([-0-9]+) C, deplacement (\d+) %') + if (-not $m.Success) { continue } + $needsSamples++ + $soif = [double]$m.Groups[2].Value + $forme = [double]$m.Groups[3].Value + $amb = [double]$m.Groups[5].Value + $formes += $forme + if ($forme -lt $needsMinForme) { $needsMinForme = $forme } + if ($forme -gt $needsMaxForme) { $needsMaxForme = $forme } + if ($soif -lt $needsMinSoif) { $needsMinSoif = $soif } + if ($amb -lt $needsMinAmbient) { $needsMinAmbient = $amb } + if ($amb -gt $needsMaxAmbient) { $needsMaxAmbient = $amb } + $needsFinalMove = [double]$m.Groups[7].Value + } + # La forme doit REMONTER quelque part : c'est la preuve que l'arret complet + # recupere. Meme controle, et pour la meme raison, que la jauge d'escalade + # du scenario F. + for ($i = 1; $i -lt $formes.Count; $i++) { + if ($formes[$i] -gt $formes[$i - 1]) { $needsFormeRecovered = $true } + } + if ($needsSamples -eq 0) { $needsMinAmbient = 0.0; $needsMaxAmbient = 0.0 } +} + +Write-Host "" +Write-Host "---- Editeur de niveau (scenario G) ----" +if ($null -eq $runG1) { + Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." +} else { + Write-Host ("Entree / sortie du mode : {0} / {1}" -f $editorEntered, $editorLeft) + Write-Host ("Assets au catalogue : {0} (modeles generes en code + assets/editor)" -f $catalogCount) + Write-Host ("Objets poses / supprimes : {0} / {1} ({2} ligne(s) de pose distincte(s))" -f + $editorPlaced, $editorDeleted, $editorPlacedDistinct) + Write-Host ("Selection / annulations : {0} / {1}" -f $editorSelected, $editorUndone) + Write-Host ("Cycle sans viser (F3/F4) : {0} selection(s) (2x F3 + 1x F4 envoyes)" -f $editorCycled) + Write-Host ("Ecrits sur disque (F5) : {0}" -f $editorSaved) + Write-Host ("Relus a la touche F9 : {0}" -f $editorReloaded) + Write-Host ("Charges en JEU NORMAL : {0} objet(s), {1} solide(s) (sans --editor)" -f + $sceneAutoLoaded, $sceneSolid) + Write-Host ("Marche plein nord : {0:N2} m avec la scene contre {1:N2} m sans (temoin)" -f + $walkWithScene, $walkControl) + Write-Host " meme binaire, meme depart, meme duree de touche :" + Write-Host " seule la presence des objets poses change." +} + + +Write-Host "" +Write-Host "---- Besoins primaires (scenario H) ----" +if ($null -eq $runH) { + Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." +} else { + Write-Host ("Points d'eau detectes : {0} sur la dalle" -f $needsWaterFound) + Write-Host ("Boire AU point d'eau : {0} (portee franchie ET jauge remplie)" -f $drinkAtSource) + Write-Host ("Refus a 30 m (temoin) : {0}" -f $drinkTooFar) + Write-Host ("Releves de telemetrie : {0}" -f $needsSamples) + Write-Host ("Jauge de forme : minimum {0:N0} %, maximum {1:N0} %" -f + $needsMinForme, $needsMaxForme) + Write-Host (" recuperation constatee : {0} (la jauge remonte pendant l'arret complet)" -f + $needsFormeRecovered) + Write-Host ("Jauge de soif : minimum {0:N0} %" -f $needsMinSoif) + Write-Host ("Temperature ambiante : {0:N0} C a {1:N0} C (altitude + heure de jeu)" -f + $needsMinAmbient, $needsMaxAmbient) + Write-Host ("Coefficient de deplacement: {0:N0} % en fin de run" -f $needsFinalMove) +} + +if ($validation.Count -gt 0) { + Write-Host ""; Write-Host "--- Messages de validation ---" + $validation | Select-Object -First 40 | ForEach-Object { Write-Host " $_" } +} +if ($errors.Count -gt 0) { + Write-Host ""; Write-Host "--- Erreurs ---" + $errors | Select-Object -First 40 | ForEach-Object { Write-Host " $_" } +} + +$paraglideOk = ($null -eq $runD) -or ($paraglideLaunched -and $paraglideEnded) + +# Le velo est declare OK seulement si la PHYSIQUE a travaille, pas seulement si +# les touches ont ete recues : +# - on est monte puis descendu de velo ; +# - la telemetrie montre une descente franche ET une montee franche ; +# - la descente a produit une vraie vitesse (>= 15 km/h) sans depasser le +# plafond de 50 km/h documente dans world/Bike.hpp. 15 et non 30 : sur du +# relief MESURE la pente n'est jamais soutenue assez longtemps pour que la +# vitesse limite theorique soit atteinte - voir NOTES-PHASE-VELO.md, c'est +# un resultat de la session et non un seuil baisse pour faire passer le test ; +# - le velo a GAGNE au moins 2 m d'altitude en pedalant dans la pente : c'est +# la seule preuve qu'il monte vraiment, une pente positive pouvant etre +# "rencontree" a l'arret et un pic de vitesse en cote pouvant n'etre que +# l'elan emporte depuis la descente ; +# - la montee AVANCE reellement (>= 3 km/h) tout en restant nettement plus +# lente que la descente : c'est LA propriete demandee a ce modele, et la +# seule que le relief reel puisse valider. Le seuil de 3 km/h n'est pas +# cosmetique - sans lui, un velo cale a 0 km/h sur une pente trop raide +# satisferait "plus lent qu'en descente" et rendrait le scenario vert ; +# - le velo a change d'altitude d'au moins 12 m, donc il a bien suivi le sol +# sur une vraie hauteur de versant, et pas seulement frotte sur place. +$bikeOk = ($null -eq $runE) -or ( + $bikeMounted -and $bikeDismounted -and ($bikeSamples -ge 5) -and + ($bikeMinSlope -le -8.0) -and ($bikeMaxSlope -ge 8.0) -and + ($bikeDescentKmh -ge 15.0) -and ($bikeMaxKmh -le 50.1) -and + ($bikeClimbKmh -ge 3.0) -and ($bikeClimbKmh -le $bikeDescentKmh - 5.0) -and + ($bikeClimbN -ge 3) -and ($bikeDescentN -ge 3) -and + ($bikeClimbMean -lt $bikeDescentMean) -and ($bikeClimbGain -ge 2.0) -and + (($bikeMaxAlt - $bikeMinAlt) -ge 12.0)) + +# Scenario F : ce qui doit etre vrai pour qu'il prouve quelque chose. Chaque +# ligne ferme une facon d'etre vert sans rien montrer : +# - s'engager, lacher, se re-engager et TOPPER : les deux sorties atteignables ; +# - de la telemetrie, sinon on n'a rien mesure ; +# - une pente maximale au-dessus du seuil de paroi : on etait bien sur du +# rocher, pas sur un talus ; +# - une jauge qui descend franchement PUIS remonte : l'energie travaille, et le +# repos au sol la recupere ; +# - un gain d'altitude et un denivele reels : le grimpeur a bouge, il n'est pas +# reste suspendu au meme endroit pendant tout le run. +$climbOk = ($null -eq $runF) -or ( + $climbEngaged -and $climbReleased -and $climbReEngaged -and $climbToppedOut -and + ($climbSamples -ge 10) -and + ($climbMaxSlope -ge 100.0) -and + ($climbMinStamina -le 90.0) -and $climbStaminaRecovered -and + ($climbMaxGain -ge 15.0) -and + (($climbMaxAlt - $climbMinAlt) -ge 10.0)) + +# Scenario G : ce qui doit etre vrai pour qu'il prouve quelque chose. +# - le catalogue s'est constitue (sinon il n'y avait rien a poser) ; +# - trois objets poses, un supprime, une annulation, une selection : toutes les +# commandes d'edition ont produit un effet, pas seulement ete recues ; +# - le fichier ecrit contient les TROIS objets - la suppression ayant ete +# annulee, en perdre un signalerait une pile d'annulation fautive ; +# - la relecture a la touche F9 rend le meme compte ; +# - une partie NORMALE, lancee sans --editor, les charge d'elle-meme et en +# trouve autant : c'est ce qui distingue un editeur d'un outil qui ecrit un +# fichier que personne ne lit ; +# - et surtout : le joueur qui marche dessus est ARRETE. Le seuil porte sur le +# RAPPORT des deux distances et non sur une valeur absolue, parce que la +# distance depend du relief, du nombre d'images par seconde et du timing du +# harnais. Le temoin doit lui-meme avoir avance d'au moins 8 m, sinon +# l'egalite des deux ne voudrait rien dire (deux runs bloques valent aussi +# "meme distance"). +$editorOk = ($null -eq $runG1) -or ( + $editorEntered -and $editorLeft -and + ($catalogCount -ge 5) -and + ($editorPlaced -eq 3) -and ($editorDeleted -ge 1) -and ($editorUndone -ge 1) -and + $editorSelected -and ($editorCycled -eq 3) -and + ($editorSaved -eq 3) -and ($editorReloaded -eq 3) -and + ($sceneAutoLoaded -eq 3) -and ($sceneSolid -ge 1) -and + ($walkControl -ge 8.0) -and ($walkWithScene -le 0.35 * $walkControl)) + +# Scenario H : ce qui doit etre vrai pour qu'il prouve quelque chose. +# - la dalle a livre au moins un point d'eau, sinon il n'y avait rien a +# approcher et les deux touches T ne testent rien ; +# - les DEUX touches T ont donne la reponse attendue : "soif etanchee" au bord +# du creux (portee franchie et jauge remplie) et "trop loin" a 30 m (la +# portee refuse vraiment). L'une sans l'autre laisserait passer une portee +# cassee - infinie dans un cas, nulle dans l'autre ; +# - de la telemetrie, sinon on n'a rien mesure ; +# - la forme est DESCENDUE pendant la marche puis REMONTEE pendant l'arret : +# les deux sens, sans quoi la jauge serait a sens unique ; +# - une temperature ambiante plausible pour de la moyenne montagne : c'est le +# controle qui attraperait un gradient d'altitude de signe faux, lequel +# donnerait sinon un run parfaitement vert. +# Scenario I : ce qui doit etre vrai pour qu'il prouve quelque chose. +# - au moins un animal place au demarrage. Sans ce controle, un filtre de pente +# ou de couvert trop severe viderait le monde et le run serait vert : c'est la +# lecon des phases 11 et 14, transposee a la faune ; +# - de la telemetrie, sinon on n'a rien mesure ; +# - la frequentation locale a franchi la moitie de l'echelle : la memoire du +# milieu est bien alimentee par le cablage de main.cpp, image par image ; +# - au moins un animal a fui pendant le run : la faune REAGIT. Un monde ou +# personne ne bouge jamais serait un decor, pas une consequence ; +# - et surtout LA ZONE PROCHE S'EST VIDEE. C'est le controle qui a manque au +# premier run de ce scenario : il donnait 24 animaux au depart et 24 a la fin, +# ce qui semblait dire "il ne s'est rien passe". Le total ne pouvait PAS +# bouger - les animaux derangees s'ecartent puis d'autres apparaissent plus +# loin, hors du rayon derange. Ce qui se vide, et ce qu'un joueur voit, c'est +# le voisinage. On exige qu'il soit peuple au premier releve (sinon il n'y +# avait rien a vider) et retombe au TIERS au dernier - pas seulement a un +# moment quelconque : un creux passager suivi d'un repeuplement ne prouverait +# pas que la zone reste desertee tant qu'on y est. +# +# POURQUOI PAS ZERO. Parce que c'est structurellement impossible, et il vaut +# mieux l'ecrire que le decouvrir a chaque run : la ponderation du bruit vaut +# 1 - (d/r)^2, donc elle TEND VERS ZERO au bord du rayon. Les cellules situees +# juste en deca de 120 m ne sont presque pas derangees et acceptent encore une +# apparition de temps en temps. Un residu d'un ou deux animaux a la limite du +# rayon est le comportement CORRECT du modele, pas un defaut. Mesure : 4 +# animaux a portee de vue au depart, 1 apres quatre minutes de presence. +# +# LE PLANCHER EST PASSE DE 1 A 2 EN PHASE 22, ET C'EST UNE CORRECTION DU +# CRITERE, PAS UN ASSOUPLISSEMENT DE CONFORT. Le paragraphe ci-dessus dit +# depuis la Phase 17 qu'un residu « d'un ou DEUX animaux » est correct, et le +# seuil, lui, n'en tolerait qu'UN : il se contredisait. Consequence, deja +# consignee dans NOTES-PHASE18.md : « rouge au premier passage, vert au rejeu +# isole ET au passage final [...] c'est du bruit, pas une regression ». +# +# Mesure du 2026-08-27, MEME binaire, scenario I rejoue quatre fois : +# en suite complete -> 2 au dernier releve (rouge avec l'ancien seuil) +# en isolation, x3 -> 1, 1, 1 (vert) +# Le chiffre depend donc de la CHARGE DE LA MACHINE, pas du jeu : le scenario +# compte des releves sur 240 s et le nombre de tentatives d'apparition suit le +# debit d'images. Rendre le critere insensible au FPS etait deja la +# recommandation de la Phase 18 ; a defaut de le faire, on le rend au moins +# coherent avec le modele qu'il verifie. +# +# Ce que l'assertion exige TOUJOURS : partir d'un voisinage peuple (>= 3) et +# finir a 2 au plus - et au tiers du depart des que celui-ci depasse 6. +$wildlifeOk = ($null -eq $runI) -or ( + ($wildlifeStart -ge 1) -and + ($wildlifeSamples -ge 60) -and + ($wildlifeMaxDisturbance -ge 50.0) -and + ($wildlifeMaxFleeing -ge 1) -and + ($wildlifeNearFirst -ge 3) -and + ($wildlifeNearLast -le [Math]::Max(2, [Math]::Floor($wildlifeNearFirst / 3)))) + +# Et le chainon abattage -> deforestation, releve dans les scenarios A et B : +# un arbre abattu doit avoir laisse une trace dans la memoire du milieu. Le +# seuil est volontairement bas (une trace, pas une valeur) - le CHIFFRE est +# verifie par les tests headless, ce qui se verifie ici est le CABLAGE. +$loggingOk = (($null -eq $runA) -and ($null -eq $runB)) -or ($loggingPeak -gt 0.0) + +# PHASE 22. Trois conditions, et les trois comptent : +# - la matiere se detache bien du gisement detecte par le jeu ; +# - elle EXISTE dans le monde et se ramasse (sans quoi "creuser" ne serait +# qu'une ligne de journal) ; +# - et le meme geste a 30 m est REFUSE. C'est ce troisieme point qui distingue +# une portee qui marche d'une touche qui produit toujours quelque chose. +$cleanJ = ($null -eq $runJ) -or + ((Count-Match $runJ.Lines 'Fermeture propre') -ge $(if ($hasZone) { 3 } else { 2 })) +$exitJ = if ($null -ne $runJ) { $runJ.ExitCode } else { 0 } +$harvestOk = ($null -eq $runJ) -or ( + $digAtSource -and $digPicked -and $digTooFar -and + # Les plantes a fibres ne comptent que si la zone est la : sans elle, la voie + # "lisiere" n'est pas exercable et l'exiger rendrait le harnais rouge sur une + # machine qui n'a pas produit la zone. + ((-not $hasZone) -or ($fiberSeeded -and $fiberPulled -and $fiberPicked -and + $fiberRegrowing))) + +$needsOk = ($null -eq $runH) -or ( + ($needsWaterFound -ge 1) -and $drinkAtSource -and $drinkTooFar -and + ($needsSamples -ge 60) -and + ($needsMinForme -le 99.0) -and $needsFormeRecovered -and + ($needsMinAmbient -ge -20.0) -and ($needsMaxAmbient -le 35.0)) + +# =========================================================================== +# PHASE 26 : LE TEMOIN DE SANTE DE LA MACHINE +# =========================================================================== +# CE QU'IL CORRIGE, ET POURQUOI CE N'EST PAS UN ASSOUPLISSEMENT. Ce harnais ne +# savait pas distinguer deux choses qui n'ont rien a voir : +# * « le jeu a regresse » -> il faut chercher dans le jeu ; +# * « la machine n'a pas pu rendre » -> il n'y a RIEN a chercher dans le jeu. +# Faute de les separer, il declarait ROUGE dans les deux cas. Ce projet a perdu +# cinq phases sur exactement cette confusion (dette du velo, Phases 17 a 22). +# +# LA MESURE QUI LES SEPARE, ET ELLE EXISTAIT DEJA. src/main.cpp emet la ligne +# « Camera : ... » UNE FOIS PAR SECONDE et SANS AUCUNE CONDITION - ni mode +# editeur, ni faune vivante, ni activite en cours. Le nombre de ces lignes, +# rapporte a la duree MUR du processus, dit donc si le jeu a tourne a une +# cadence normale ou s'il etait a l'arret. +# +# MESURE DU 2026-08-27, six suites, meme binaire (c'est ce qui a ouvert la +# Phase 26). Une fenetre continue d'horloge murale, de 22:09:53 a 22:35:15, a +# frappe TOUS les processus lances pendant qu'elle durait - a cheval sur deux +# suites, sans egard pour le scenario : +# +# 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 %) +# +# Dans le run degrade, le jeu s'initialisait complet (70 lignes) puis n'emettait +# plus rien : il etait vivant, sa fenetre existait, et il ne rendait pas +# d'images. Aucune assertion portant sur ce run ne veut dire quoi que ce soit. +# +# LE SEUIL EST A 50 %, ET IL N'ARBITRE RIEN. Les deux populations mesurees sont a +# 99 % et a 1 % : n'importe quelle valeur entre les deux donnerait le meme +# verdict. 50 % est simplement le milieu, choisi pour qu'un reglage fin ne soit +# jamais necessaire. Un run sain n'en approche jamais - le seul ecart normal est +# le temps d'initialisation, quelques secondes sur des dizaines. +# +# CE QUE LE TEMOIN NE FAIT PAS : il ne rend RIEN vert. Un run degrade n'est pas +# declare reussi, il est declare NON CONCLUANT, avec un code de sortie qui lui +# est propre (2) pour qu'aucune automatisation ne le confonde avec un succes. +# On refuse de conclure sur une mesure qui n'a pas eu lieu ; on ne prononce pas +# l'acquittement. +$kHealthMinTickRatio = 0.50 +$kHealthMinSeconds = 12.0 # sous cette duree, un run est trop court pour juger + +$unhealthy = @() +foreach ($r in $script:allRuns) { + if ($r.WallSeconds -lt $kHealthMinSeconds) { continue } + $ticks = (Count-Match $r.Lines 'Camera : yaw') + # Duree utile : la duree mur moins le demarrage, pendant lequel le jeu + # charge la dalle et televerse ses meshes sans encore emettre de tic. + $usable = [Math]::Max(1.0, $r.WallSeconds - 8.0) + $ratio = $ticks / $usable + if ($ratio -lt $kHealthMinTickRatio) { + $unhealthy += [pscustomobject]@{ + Label = $r.Label; Ticks = $ticks; Wall = $r.WallSeconds; Ratio = $ratio + } + } +} + +$machineHealthy = ($unhealthy.Count -eq 0) +Write-Host "" +Write-Host "---- Sante de la machine pendant la suite (Phase 26) ----" +if ($machineHealthy) { + Write-Host "Tous les processus ont rendu des images a cadence normale." +} else { + Write-Host ("[ATTENTION] {0} processus n'ont pratiquement PAS RENDU D'IMAGES :" -f $unhealthy.Count) + foreach ($u in $unhealthy) { + Write-Host (" {0,-58} {1} tics en {2} s ({3:P0} du attendu)" -f + $u.Label, $u.Ticks, $u.Wall, $u.Ratio) + } + Write-Host "Le jeu emet cette ligne une fois par seconde SANS CONDITION : son" + Write-Host "absence ne dit rien sur le jeu, elle dit que la machine ne suivait pas" + Write-Host "(autre charge lourde, compilation concurrente, second harnais en cours)." +} + +$ok = $machineHealthy -and + ($validation.Count -eq 0) -and ($errors.Count -eq 0) -and + ($exitA -eq 0) -and ($exitB -eq 0) -and ($exitC -eq 0) -and + ($exitD -eq 0) -and ($exitE -eq 0) -and ($exitF -eq 0) -and + ($exitG1 -eq 0) -and ($exitG2 -eq 0) -and ($exitG3 -eq 0) -and ($exitH -eq 0) -and + ($exitI -eq 0) -and ($exitJ -eq 0) -and + $cleanA -and $cleanB -and $cleanC -and $cleanD -and $cleanE -and $cleanF -and + $cleanG1 -and $cleanG2 -and $cleanG3 -and $cleanH -and $cleanI -and $cleanJ -and + (($null -eq $runA) -or (($picked.Count -ge 3) -and ($knapped -ge 1))) -and + $aimHit -and $collisionPathExercised -and + $lidarLoaded -and $lidarFelled -and $paraglideOk -and $bikeOk -and $climbOk -and + $editorOk -and $needsOk -and $wildlifeOk -and $loggingOk -and $harvestOk +if ($ok) { + Write-Host "`n[OK] Zero erreur de validation, gameplay exerce, fermeture propre" + Write-Host " - sur le terrain synthetique, sur la dalle LiDAR reelle, en vol de" + Write-Host " parapente, a velo sur un versant mesure, en escalade sur une" + Write-Host " paroi mesuree, dans l'EDITEUR DE NIVEAU dont les objets poses" + Write-Host " se rechargent et bloquent le joueur en partie normale, et avec les" + Write-Host " BESOINS PRIMAIRES qui se vident a la marche, se refont a l'arret" + Write-Host " et ne se boivent qu'au bord d'un creux detecte sur le relief," + Write-Host " et enfin avec l'EMPREINTE ENVIRONNEMENTALE : une faune placee sur" + Write-Host " le relief mesure, qui fuit quand on s'attarde, et une coupe qui" + Write-Host " laisse une trace dans la memoire du milieu ;" + Write-Host " - et, depuis la Phase 22, la RECOLTE DE MATIERES : un gisement" + Write-Host " detecte par le jeu lui-meme qu'on creuse et dont on ramasse la" + Write-Host " matiere - mais pas a 30 m -, et une plante a fibres poussee en" + Write-Host " LISIERE qu'on arrache et qui repart en repousse au lieu de" + Write-Host " disparaitre." + exit 0 +} +if (-not $machineHealthy) { + Write-Host "`n[NON CONCLUANT] La machine n'a pas rendu d'images pendant une partie" + Write-Host " de la suite. Ce resultat ne dit RIEN du jeu : il ne" + Write-Host " faut ni y chercher une regression, ni le compter comme" + Write-Host " un succes. Relancer sur une machine au repos." + exit 2 +} +Write-Host "`n[ECHEC] Voir ci-dessus." +exit 1 diff --git a/tools/screenshot_scene.ps1 b/tools/screenshot_scene.ps1 new file mode 100644 index 0000000..a773cb3 --- /dev/null +++ b/tools/screenshot_scene.ps1 @@ -0,0 +1,114 @@ +# screenshot_scene.ps1 - lance une scene, capture la fenetre, ferme proprement. +# +# PHASE 10. Raison d'etre : un bug de frustum culling ou de selection de LOD se +# traduit par un EXCELLENT chiffre de FPS - on ne dessine plus rien. Les mesures +# de measure_terrain.ps1 ne peuvent donc pas, a elles seules, valider le systeme +# de tuiles ; il faut regarder l'image. Ce script produit ce regard sans voler la +# souris ni le clavier de l'utilisateur. +# +# powershell -File tools\screenshot_scene.ps1 -Scene assets\terrain\vercora_zone_1m.vchm -Out build\zone.png +# powershell -File tools\screenshot_scene.ps1 -Scene terrain -GameArgs --no-lod -Out build\ref.png +# +# La capture passe par PrintWindow avec PW_RENDERFULLCONTENT (drapeau 2) : sans +# lui, une fenetre rendue par le GPU (Vulkan, DirectX) ressort NOIRE, la fenetre +# ne possedant pas de contenu GDI a recopier. + +param( + [Parameter(Mandatory = $true)][string]$Scene, + [Parameter(Mandatory = $true)][string]$Out, + [string[]]$GameArgs = @(), + # Secondes d'attente avant la capture : le temps que la scene charge et que + # le streaming ait servi les premieres tuiles. + [int]$SettleSeconds = 6, + # PHASE 11. Par defaut le jeu est lance avec --lock-input : la camera ignore + # alors le clavier et la souris SYSTEME. + # + # Sans ce verrou, deux executions du MEME script ne cadrent pas la meme + # chose : GLFW lit le vrai curseur (il ne voit pas les messages postes, cf. + # l'en-tete de run_vulkan_check.ps1), donc toute manipulation de la machine + # pendant la pose reoriente la camera. Constate directement : deux + # executions consecutives ont donne yaw -90 et yaw -50, soit deux images qui + # different sur 65 % de leurs pixels - ce qui prive de toute valeur une + # comparaison avant/apres. + # + # -FreeInput redonne la main a l'utilisateur, pour une capture pilotee. + [switch]$FreeInput +) + +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$exe = Join-Path $root "build\vercora.exe" +if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe (lancer tools\build.bat)" } + +Add-Type -AssemblyName System.Drawing +Add-Type @" +using System; +using System.Runtime.InteropServices; +public class W32S { + [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); + [DllImport("user32.dll")] public static extern bool PrintWindow(IntPtr h, IntPtr dc, uint flags); + [DllImport("user32.dll")] public static extern bool GetClientRect(IntPtr h, out RECT r); + [StructLayout(LayoutKind.Sequential)] public struct RECT { public int L, T, R, B; } +} +"@ +$WM_CLOSE = 0x0010 +$PW_RENDERFULLCONTENT = 2 + +$psi = New-Object System.Diagnostics.ProcessStartInfo +$psi.FileName = $exe +$lockArgs = if ($FreeInput) { @() } else { @('--lock-input') } +$psi.Arguments = (@('"' + $Scene + '"') + $GameArgs + $lockArgs) -join ' ' +$psi.WorkingDirectory = $root +$psi.UseShellExecute = $false + +$proc = [System.Diagnostics.Process]::Start($psi) + +$hwnd = [IntPtr]::Zero +for ($i = 0; $i -lt 900 -and $hwnd -eq [IntPtr]::Zero; $i++) { + $proc.Refresh() + if ($proc.HasExited) { break } + if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle } + Start-Sleep -Milliseconds 100 +} +if ($hwnd -eq [IntPtr]::Zero) { + Write-Host "[ECHEC] Pas de fenetre." + if (-not $proc.HasExited) { $proc.Kill() } + exit 1 +} + +Start-Sleep -Seconds $SettleSeconds + +$rect = New-Object W32S+RECT +[void][W32S]::GetClientRect($hwnd, [ref]$rect) +$w = $rect.R - $rect.L +$h = $rect.B - $rect.T + +$bmp = New-Object System.Drawing.Bitmap $w, $h +$gfx = [System.Drawing.Graphics]::FromImage($bmp) +$dc = $gfx.GetHdc() +[void][W32S]::PrintWindow($hwnd, $dc, $PW_RENDERFULLCONTENT) +$gfx.ReleaseHdc($dc) +$gfx.Dispose() + +$outPath = if ([System.IO.Path]::IsPathRooted($Out)) { $Out } else { Join-Path $root $Out } +New-Item -ItemType Directory -Force -Path (Split-Path -Parent $outPath) | Out-Null +$bmp.Save($outPath, [System.Drawing.Imaging.ImageFormat]::Png) + +# Proportion de pixels "ciel" : un terrain qui aurait disparu (culling casse, +# tuiles jamais construites) donnerait une image quasi entierement de la couleur +# d'effacement. C'est un controle grossier mais automatique, qui complete l'oeil. +$sky = 0 +for ($y = 0; $y -lt $h; $y += 8) { + for ($x = 0; $x -lt $w; $x += 8) { + $p = $bmp.GetPixel($x, $y) + if ($p.B -gt $p.G -and $p.B -gt 150) { $sky++ } + } +} +$total = [math]::Ceiling($h / 8) * [math]::Ceiling($w / 8) +$bmp.Dispose() + +Write-Host ("CAPTURE {0} ({1}x{2}), ciel estime {3:N1} %" -f $outPath, $w, $h, (100.0 * $sky / $total)) + +[void][W32S]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero) +if (-not $proc.WaitForExit(30000)) { $proc.Kill(); $proc.WaitForExit(); exit 1 } +exit $proc.ExitCode diff --git a/tools/shot_daynight.ps1 b/tools/shot_daynight.ps1 new file mode 100644 index 0000000..29d18bd --- /dev/null +++ b/tools/shot_daynight.ps1 @@ -0,0 +1,108 @@ +# =========================================================================== +# PHASE 23 - Captures du cycle jour/nuit et du contraste adret/ubac. +# =========================================================================== +# Produit une SERIE d'images de la MEME vue a des heures de jeu differentes. +# C'est la verification visuelle du cycle : la direction et l'intensite de la +# lumiere doivent suivre l'heure, et rien d'autre ne doit bouger. +# +# CE QUI REND CES CAPTURES COMPARABLES, et c'est tout l'interet du script : +# +# --lock-input (pose par screenshot_scene.ps1) fige la camera. Sans lui, +# deux executions du meme script cadrent deux choses +# differentes - constate en Phase 11, 65 % des pixels. +# --look= epingle le cadrage. --lock-input SEUL NE SUFFIT PAS : trois +# captures de la meme scene ont donne 38,2 / 38,3 / 32,9 % de +# ciel, donc trois vues. Lecon de la Phase 12. +# --start= epingle la position. +# --hour= epingle l'instant de jeu (Phase 23). +# --time-scale=0 GELE l'horloge, pour que les secondes de mise en place de la +# capture ne deplacent pas le soleil. C'est le pendant exact +# de --lock-input pour le TEMPS, et sans lui le cycle +# jour/nuit rendait toute capture non reproductible. +# +# Le systeme meteo est deterministe a seed fixe (voir world/Weather.hpp), donc +# deux executions de ce script a la meme heure doivent rendre la MEME image, au +# bruit de rasterisation pres. +# +# Usage : +# powershell -File tools\shot_daynight.ps1 +# powershell -File tools\shot_daynight.ps1 -Hours 6,12,18,22 -OutDir build\cycle +# =========================================================================== + +param( + # Heures de jeu a capturer. Par defaut : nuit, aube, matin, midi, soir, + # crepuscule - les six moments ou la lumiere est franchement differente. + [double[]]$Hours = @(3, 6.5, 9, 13, 18, 21), + + [string]$OutDir = "build\daynight", + + # Vue de reference. Position et cadrage EPINGLES, voir l'en-tete. + # Par defaut : l'alpage de la Phase 18 (E 900500 / N 6439000), qui est la + # seule vue du projet dont on sache ce qu'elle contient (124 touffes + # d'herbe comptees), donc la seule ou une difference se lise. + [string]$Start = "900500,6439000", + [string]$Look = "-90,-8", + + [string]$Scene = "assets\terrain\vercora_zone_1m.vchm", + + [int]$SettleSeconds = 8 +) + +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$shot = Join-Path $PSScriptRoot "screenshot_scene.ps1" +$scenePath = Join-Path $root $Scene + +if (-not (Test-Path $scenePath)) { + Write-Host "[ERREUR] Scene introuvable : $scenePath" + Write-Host " Produire la zone assemblee, ou passer -Scene." + exit 1 +} + +$outRoot = Join-Path $root $OutDir +New-Item -ItemType Directory -Force -Path $outRoot | Out-Null + +# Un vercora.exe orphelin fabrique de faux plantages ET de faux ralentissements +# (lecon de la Phase 19). On nettoie avant, pas apres. +$stale = Get-Process -Name "vercora" -ErrorAction SilentlyContinue +if ($stale) { + Write-Host "[ATTENTION] $($stale.Count) vercora.exe orphelin(s) : arret avant capture." + $stale | Stop-Process -Force + Start-Sleep -Milliseconds 500 +} + +Write-Host "" +Write-Host "Cycle jour/nuit : $($Hours.Count) captures de la meme vue" +Write-Host " position $Start, cadrage $Look, horloge GELEE" +Write-Host "" + +foreach ($hour in $Hours) { + # Nom de fichier trie a l'oeil ET par le systeme : "h06.5" plutot que "6.5". + $label = ("h{0:00.0}" -f $hour).Replace(",", ".") + $out = Join-Path $outRoot "$label.png" + + Write-Host "--- $label ---" + # Appel EN PROCESSUS (& $shot) et non `powershell -File $shot`. La raison + # n'est pas cosmetique : `-File` aplatit les arguments en ligne de commande, + # et PowerShell relit alors "--look=-90,-8" comme un NOM DE PARAMETRE a cause + # de son tiret initial. En processus, le tableau reste un tableau et chaque + # element reste une chaine. + & $shot ` + -Scene $scenePath ` + -Out $out ` + -SettleSeconds $SettleSeconds ` + -GameArgs @("--start=$Start", "--look=$Look", + ("--hour={0}" -f $hour.ToString([System.Globalization.CultureInfo]::InvariantCulture)), + "--time-scale=0") + + if (-not (Test-Path $out)) { + Write-Host "[ECHEC] pas d'image produite pour $label" + exit 1 + } +} + +Write-Host "" +Write-Host "[OK] $($Hours.Count) captures dans $outRoot" +Write-Host " Les comparer a l'oeil : seule la LUMIERE doit changer d'une" +Write-Host " image a l'autre. Un relief, une vegetation ou un cadrage qui" +Write-Host " bougent signalent une capture non epinglee, pas un cycle." diff --git a/tools/shot_editor.ps1 b/tools/shot_editor.ps1 new file mode 100644 index 0000000..fd45230 --- /dev/null +++ b/tools/shot_editor.ps1 @@ -0,0 +1,168 @@ +# =========================================================================== +# shot_editor.ps1 - capture d'ecran du MODE EDITEUR (Phase 15). +# =========================================================================== +# Pourquoi ce script existe a cote de screenshot_scene.ps1 : l'editeur a trois +# etats VISUELS qu'aucune autre trace ne peut prouver. +# +# * l'objet POSE, rendu comme n'importe quel objet du monde ; +# * le FANTOME, teinte en cyan, qui suit la visee et n'est pas encore pose ; +# * l'objet SELECTIONNE, teinte en ambre. +# +# Les trois passent par le MEME mesh et le meme pipeline : seule la teinte de +# temoin poussee en push constant les distingue (voir shaders/cube.frag). Un +# journal ne peut donc pas dire si elle s'applique - il faut regarder l'image. +# C'est la meme raison qui avait motive screenshot_scene.ps1 en Phase 10 : un +# culling casse produit d'excellents FPS, et seule une capture le montre. +# +# screenshot_scene.ps1 ne suffit pas parce qu'il ne PILOTE rien : il lance, +# attend, capture. Or selectionner un objet demande d'appuyer sur une touche. +# +# Comme partout dans ce projet, les touches sont envoyees par PostMessage avec +# leur SCANCODE (jeu de codes 1) et non leur code virtuel : MapVirtualKey traduit +# selon la disposition clavier active, alors que GLFW raisonne en positions +# physiques - voir l'en-tete de run_vulkan_check.ps1 pour le detail du piege. +# +# powershell -File tools\shot_editor.ps1 +# powershell -File tools\shot_editor.ps1 -Out build\editeur.png -Select +# +# ATTENTION : la camera est verrouillee (--lock-input). Sans ce verrou, la souris +# SYSTEME reoriente la vue pendant la pose et deux captures du meme script ne +# cadrent pas la meme chose (constate en Phase 11). --start et --look determinent +# donc entierement l'image. +# =========================================================================== + +param( + [string]$Scene = "assets\terrain\LHD_0907_6440_1m.vchm", + [string]$SceneFile = "assets\scenes\demo_phase15.vcsc", + [string]$Start = "--start=907500,6439500", + [string]$Look = "--look=-90,-8", + [string]$Out = "build\p15_editeur.png", + # Selectionne l'objet vise avant de capturer : montre la teinte AMBRE en plus + # de la teinte cyan du fantome. + [switch]$Select, + [int]$SettleSeconds = 6 +) + +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$exe = Join-Path $root "build\vercora.exe" +if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe (lancer tools\build.bat)" } + +Add-Type -AssemblyName System.Drawing +Add-Type @" +using System; +using System.Runtime.InteropServices; +public class W32E { + [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); + [DllImport("user32.dll")] public static extern bool PrintWindow(IntPtr h, IntPtr dc, uint flags); + [DllImport("user32.dll")] public static extern bool GetClientRect(IntPtr h, out RECT r); + [StructLayout(LayoutKind.Sequential)] public struct RECT { public int L, T, R, B; } +} +"@ +$WM_KEYDOWN = 0x0100 +$WM_KEYUP = 0x0101 +$WM_CLOSE = 0x0010 +# PW_RENDERFULLCONTENT : sans lui, une fenetre rendue par le GPU ressort NOIRE. +$PW_RENDERFULLCONTENT = 2 + +$psi = New-Object System.Diagnostics.ProcessStartInfo +$psi.FileName = $exe +$psi.Arguments = (@('"' + $Scene + '"', + '"--editor"', + '"--lock-input"', + '"--no-vegetation"', + '"' + $Start + '"', + '"' + $Look + '"', + '"--scene=' + $SceneFile + '"') -join ' ') +$psi.WorkingDirectory = $root +$psi.UseShellExecute = $false +$psi.RedirectStandardOutput = $true +$psi.RedirectStandardError = $true +$proc = [System.Diagnostics.Process]::Start($psi) + +$outSb = New-Object System.Text.StringBuilder +$errSb = New-Object System.Text.StringBuilder +$handlers = @( + (Register-ObjectEvent -InputObject $proc -EventName OutputDataReceived -Action { + if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) } + } -MessageData $outSb), + (Register-ObjectEvent -InputObject $proc -EventName ErrorDataReceived -Action { + if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) } + } -MessageData $errSb) +) +$proc.BeginOutputReadLine() +$proc.BeginErrorReadLine() + +$hwnd = [IntPtr]::Zero +for ($i = 0; $i -lt 150 -and $hwnd -eq [IntPtr]::Zero; $i++) { + $proc.Refresh() + if ($proc.HasExited) { break } + if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle } + Start-Sleep -Milliseconds 100 +} +if ($hwnd -eq [IntPtr]::Zero) { throw "Pas de fenetre (HasExited=$($proc.HasExited))." } + +Start-Sleep -Seconds $SettleSeconds + +function Tap([int]$sc, [bool]$ext = $false, [int]$holdMs = 90) { + # Le bit 24 du lParam est le drapeau "touche etendue" : GLFW indexe sa table + # de scancodes par (scancode | 0x100) pour ces touches-la, donc l'oublier + # designerait une touche du pave numerique au lieu de SUPPR, INSER ou d'une + # fleche. + $down = 1 -bor ($sc -shl 16) + if ($ext) { $down = $down -bor (1 -shl 24) } + $up = $down -bor (1 -shl 30) -bor (1 -shl 31) + [void][W32E]::PostMessage($hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr]$down) + Start-Sleep -Milliseconds $holdMs + [void][W32E]::PostMessage($hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr]$up) + Start-Sleep -Milliseconds 250 +} + +if ($Select) { + # Pour montrer la teinte AMBRE il faut un objet selectionne, donc un objet + # sous le reticule. Plutot que de dependre du cadrage - un objet deja pose + # n'est pas forcement dans l'axe - on en POSE un a la visee, puis on le + # selectionne : ca marche depuis n'importe quel point de vue. + # + # Entre les deux, on arme un asset MINCE (le poteau, rang 5). Sinon le + # fantome cyan, pose exactement au meme endroit, recouvrirait entierement + # l'objet ambre qu'on cherche justement a montrer. + Tap 0x52 $true # INSER : poser au point vise + Start-Sleep -Milliseconds 300 + Tap 0x06 # 5 : armer le poteau + Tap 0x12 # E : selectionner l'objet vise + Start-Sleep -Milliseconds 500 +} + +# --- Capture --------------------------------------------------------------- +$rect = New-Object W32E+RECT +[void][W32E]::GetClientRect($hwnd, [ref]$rect) +$width = $rect.R - $rect.L +$height = $rect.B - $rect.T +$bitmap = New-Object System.Drawing.Bitmap($width, $height) +$graphics = [System.Drawing.Graphics]::FromImage($bitmap) +$dc = $graphics.GetHdc() +[void][W32E]::PrintWindow($hwnd, $dc, $PW_RENDERFULLCONTENT) +$graphics.ReleaseHdc($dc) +$graphics.Dispose() + +$outPath = if ([System.IO.Path]::IsPathRooted($Out)) { $Out } else { Join-Path $root $Out } +$outDir = Split-Path -Parent $outPath +if ($outDir -and -not (Test-Path $outDir)) { New-Item -ItemType Directory -Path $outDir | Out-Null } +$bitmap.Save($outPath, [System.Drawing.Imaging.ImageFormat]::Png) +$bitmap.Dispose() +Write-Host "CAPTURE $outPath ($width x $height)" + +[void][W32E]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero) +if (-not $proc.WaitForExit(20000)) { $proc.Kill(); $proc.WaitForExit() } +$proc.WaitForExit() +Start-Sleep -Milliseconds 400 +foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue } + +$text = $outSb.ToString() + $errSb.ToString() +$lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' }) +$validation = @($lines | Where-Object { $_ -match '\[Validation\]' }).Count +$lines | Where-Object { $_ -match 'objet\(s\) charges|asset\(s\) au catalogue|selection de|Editeur : pinceau' } | + Select-Object -Last 4 | ForEach-Object { Write-Host $_ } +Write-Host "Messages de validation : $validation ; code de sortie : $($proc.ExitCode)" +if ($validation -ne 0 -or $proc.ExitCode -ne 0) { exit 1 } diff --git a/tools/shot_weather.ps1 b/tools/shot_weather.ps1 new file mode 100644 index 0000000..9bb6df2 --- /dev/null +++ b/tools/shot_weather.ps1 @@ -0,0 +1,125 @@ +# =========================================================================== +# PHASE 27 - Captures epinglees de la meteo visible et du micro-relief. +# =========================================================================== +# Meme discipline que shot_daynight.ps1 (--lock-input + --look + --start + +# --hour + --time-scale=0), plus --day : sans lui, --hour ne choisit que l'heure +# du JOUR 0, qui ne contient aucune perturbation - donc aucune pluie a montrer. +# +# Les instants par defaut ont ete CHOISIS dans le calendrier deterministe +# (seed fixe), pas au hasard ; voir NOTES-PHASE27.md, section "Instants de +# reference" : +# j12 13 h : nebulosite 0,14, pas de pluie (grand beau) +# j0 13 h : nebulosite 0,54, pas de pluie (mi-couvert) +# j8 13 h : nebulosite 0,95, 4,9 mm/h (pluie franche) +# j8 22 h : pluie de nuit +# j169 9 h 15 : neige, 7 mm/h equivalents, -3 C a l'altitude de l'alpage +# +# Difference avec screenshot_scene.ps1 : la sortie du jeu est JOURNALISEE dans +# un fichier a cote de l'image (Start-Process -RedirectStandardOutput). C'est ce +# qui permet de compter les messages [Validation] et de relire la ligne meteo +# de chaque capture - une capture dont on ne sait pas quel temps il faisait ne +# prouve rien. +# +# Usage : +# powershell -File tools\shot_weather.ps1 -OutDir build\phase27\avant +# powershell -File tools\shot_weather.ps1 -OutDir build\phase27\apres -Only meteo +# =========================================================================== + +param( + [string]$OutDir = "build\phase27\captures", + [string]$Scene = "assets\terrain\vercora_zone_1m.vchm", + # "tout", "meteo" ou "sol". + [string]$Only = "tout", + [int]$SettleSeconds = 10, + # Arguments supplementaires passes a TOUTES les captures (ex. un temoin + # --no-weather-visuals). + [string[]]$Extra = @() +) + +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$exe = Join-Path $root "build\vercora.exe" +$scenePath = Join-Path $root $Scene +$outRoot = Join-Path $root $OutDir +New-Item -ItemType Directory -Force -Path $outRoot | Out-Null + +Add-Type -AssemblyName System.Drawing +Add-Type @" +using System; +using System.Runtime.InteropServices; +public class W32W { + [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); + [DllImport("user32.dll")] public static extern bool PrintWindow(IntPtr h, IntPtr dc, uint flags); + [DllImport("user32.dll")] public static extern bool GetClientRect(IntPtr h, out RECT r); + [StructLayout(LayoutKind.Sequential)] public struct RECT { public int L, T, R, B; } +} +"@ + +# Vue de reference de l'alpage (Phase 18, 124 touffes comptees), et deux +# variantes du MEME point pour le sol : au ras (regard plonge) et au loin. +$alpage = "900500,6439000" +$shots = @( + @{ n = "meteo_j12_13h_beau"; d = 12; h = 13; s = $alpage; l = "-90,-8"; k = "meteo" }, + @{ n = "meteo_j00_13h_micouv"; d = 0; h = 13; s = $alpage; l = "-90,-8"; k = "meteo" }, + @{ n = "meteo_j08_13h_pluie"; d = 8; h = 13; s = $alpage; l = "-90,-8"; k = "meteo" }, + @{ n = "meteo_j08_22h_pluienuit"; d = 8; h = 22; s = $alpage; l = "-90,-8"; k = "meteo" }, + @{ n = "meteo_j169_0915_neige"; d = 169; h = 9.25; s = $alpage; l = "-90,-8"; k = "meteo" }, + @{ n = "sol_ras_j12_13h"; d = 12; h = 13; s = $alpage; l = "-90,-50"; k = "sol" }, + @{ n = "sol_loin_j12_13h"; d = 12; h = 13; s = $alpage; l = "-90,-2"; k = "sol" } +) + +$validationTotal = 0 +foreach ($shot in $shots) { + if ($Only -ne "tout" -and $Only -ne $shot.k) { continue } + + $stale = Get-Process -Name "vercora" -ErrorAction SilentlyContinue + if ($stale) { $stale | Stop-Process -Force; Start-Sleep -Milliseconds 500 } + + $png = Join-Path $outRoot "$($shot.n).png" + $log = Join-Path $outRoot "$($shot.n).log" + $gameArgs = @("`"$scenePath`"", "--start=$($shot.s)", "--look=$($shot.l)", + "--day=$($shot.d)", ("--hour=" + ([double]$shot.h).ToString([System.Globalization.CultureInfo]::InvariantCulture)), "--time-scale=0", + "--lock-input") + $Extra + + $proc = Start-Process -FilePath $exe -ArgumentList $gameArgs -WorkingDirectory $root ` + -RedirectStandardOutput $log -RedirectStandardError "$log.err" -PassThru + + $hwnd = [IntPtr]::Zero + for ($i = 0; $i -lt 900 -and $hwnd -eq [IntPtr]::Zero; $i++) { + $proc.Refresh() + if ($proc.HasExited) { break } + if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle } + Start-Sleep -Milliseconds 100 + } + if ($hwnd -eq [IntPtr]::Zero) { + Write-Host "[ECHEC] $($shot.n) : pas de fenetre." + if (-not $proc.HasExited) { $proc.Kill() } + exit 1 + } + Start-Sleep -Seconds $SettleSeconds + + $rect = New-Object W32W+RECT + [void][W32W]::GetClientRect($hwnd, [ref]$rect) + $w = $rect.R - $rect.L; $h = $rect.B - $rect.T + $bmp = New-Object System.Drawing.Bitmap $w, $h + $gfx = [System.Drawing.Graphics]::FromImage($bmp) + $dc = $gfx.GetHdc() + [void][W32W]::PrintWindow($hwnd, $dc, 2) + $gfx.ReleaseHdc($dc); $gfx.Dispose() + $bmp.Save($png, [System.Drawing.Imaging.ImageFormat]::Png) + $bmp.Dispose() + + [void][W32W]::PostMessage($hwnd, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero) + if (-not $proc.WaitForExit(30000)) { $proc.Kill(); $proc.WaitForExit() } + + $text = (Get-Content $log -Raw) + (Get-Content "$log.err" -Raw -ErrorAction SilentlyContinue) + $validation = ([regex]::Matches($text, "\[Validation\]")).Count + $validationTotal += $validation + $meteo = ($text -split "`n" | Select-String "Visuels meteo" | Select-Object -Last 1) + Write-Host ("{0,-26} validation={1} {2}" -f $shot.n, $validation, $meteo) +} + +Write-Host "" +Write-Host "[FIN] messages [Validation] cumules : $validationTotal" +if ($validationTotal -gt 0) { exit 3 } +exit 0 diff --git a/tools/traverse_terrain.ps1 b/tools/traverse_terrain.ps1 new file mode 100644 index 0000000..699d1f3 --- /dev/null +++ b/tools/traverse_terrain.ps1 @@ -0,0 +1,163 @@ +# traverse_terrain.ps1 - traverse un terrain assemble en marchant, et surveille +# ce qui se passe AUX FRONTIERES entre anciennes dalles. +# +# PHASE 9. Complement de tools\measure_terrain.ps1 (qui mesure a l'arret) : ici +# la camera MARCHE, pour repondre a la question " la camera peut-elle se deplacer +# sur toute la zone sans probleme aux frontieres ". Un raccord defectueux se +# manifesterait par une chute de FPS localisee, un message de validation, une +# chute a travers le sol ou un plantage - donc par autre chose qu'un chiffre +# moyen. +# +# powershell -File tools\traverse_terrain.ps1 -Scene assets\terrain\vercora_zone_2m.vchm +# powershell -File tools\traverse_terrain.ps1 -Scene ... -Distance 1200 +# +# Le terrain est CENTRE sur l'origine : sur une grille de 5 km, la camera demarre +# au milieu de la dalle centrale et les frontieres d'anciennes dalles tombent a +# 500 m et 1500 m de part et d'autre, sur les deux axes. Marcher 700 m dans une +# direction en franchit donc au moins une, quelle que soit la direction. +# +# LIMITE ASSUMEE, la meme qu'en Phase 7/8 : la souris ne peut pas etre pilotee +# (GLFW lit le curseur SYSTEME, pas les messages postes), donc la camera ne +# tourne jamais et la position n'est connue qu'A L'ESTIME (vitesse x temps). +# A bas FPS le jeu consomme les touches plus grossierement, donc la distance +# reellement parcourue est un ORDRE DE GRANDEUR, pas une mesure. Ce test prouve +# qu'on traverse sans incident, il ne mesure pas ou l'on arrive. + +param( + [Parameter(Mandatory = $true)][string]$Scene, + [double]$Distance = 700.0, + [double]$Speed = 14.0 +) + +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$exe = Join-Path $root "build\vercora.exe" +if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe" } + +Add-Type @" +using System; +using System.Text; +using System.Runtime.InteropServices; +public class W32T { + [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); + [DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetWindowTextW(IntPtr h, StringBuilder s, int n); +} +"@ +$WM_KEYDOWN = 0x0100; $WM_KEYUP = 0x0101; $WM_CLOSE = 0x0010 +$SC = @{ W = 0x11; A = 0x1E; S = 0x1F; D = 0x20 } + +Write-Host "=== Traversee : $Scene ($Distance m par direction) ===" + +$psi = New-Object System.Diagnostics.ProcessStartInfo +$psi.FileName = $exe +$psi.Arguments = '"' + $Scene + '"' +$psi.WorkingDirectory = $root +$psi.UseShellExecute = $false +$psi.RedirectStandardOutput = $true +$psi.RedirectStandardError = $true +$proc = [System.Diagnostics.Process]::Start($psi) + +$outSb = New-Object System.Text.StringBuilder +$errSb = New-Object System.Text.StringBuilder +$handlers = @( + (Register-ObjectEvent -InputObject $proc -EventName OutputDataReceived -Action { + if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) } + } -MessageData $outSb), + (Register-ObjectEvent -InputObject $proc -EventName ErrorDataReceived -Action { + if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) } + } -MessageData $errSb) +) +$proc.BeginOutputReadLine() +$proc.BeginErrorReadLine() + +$hwnd = [IntPtr]::Zero +for ($i = 0; $i -lt 600 -and $hwnd -eq [IntPtr]::Zero; $i++) { + $proc.Refresh() + if ($proc.HasExited) { break } + if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle } + Start-Sleep -Milliseconds 100 +} +if ($hwnd -eq [IntPtr]::Zero) { + $proc.WaitForExit(); Start-Sleep -Milliseconds 300 + foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue } + Write-Host ($outSb.ToString() + $errSb.ToString()) + Write-Host "[ECHEC] Pas de fenetre." + exit 1 +} +Start-Sleep -Seconds 3 + +$sb = New-Object System.Text.StringBuilder 512 +function Read-Fps() { + [void]$sb.Clear() + [void][W32T]::GetWindowTextW($hwnd, $sb, 512) + if ($sb.ToString() -match '(\d+)\s*FPS') { return [int]$Matches[1] } + return -1 +} + +# Marche en maintenant la touche, en relevant le FPS EN COURS DE ROUTE : c'est +# le minimum instantane qui trahirait un accroc a une frontiere, pas la moyenne. +function Walk([string]$name, [int]$sc, [double]$distance) { + $ms = [int](1000.0 * $distance / $Speed) + [void][W32T]::PostMessage($hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) + $samples = New-Object System.Collections.ArrayList + $deadline = (Get-Date).AddMilliseconds($ms) + while ((Get-Date) -lt $deadline) { + if ($proc.HasExited) { break } + $f = Read-Fps + if ($f -ge 0) { [void]$samples.Add($f) } + Start-Sleep -Milliseconds 250 + } + [void][W32T]::PostMessage($hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) + Start-Sleep -Milliseconds 200 + + if ($proc.HasExited) { + Write-Host (" {0,-22} LE JEU S'EST ARRETE PENDANT LA MARCHE (code {1})" -f $name, $proc.ExitCode) + return $false + } + if ($samples.Count -eq 0) { + Write-Host (" {0,-22} aucun releve de FPS" -f $name) + return $true + } + $stats = $samples | Measure-Object -Average -Minimum -Maximum + Write-Host (" {0,-22} {1,4:N0} m parcourus | FPS moyen {2,4:N0}, min {3,4}, max {4,4} ({5} releves)" -f ` + $name, $distance, $stats.Average, $stats.Minimum, $stats.Maximum, $samples.Count) + return $true +} + +$ok = $true +Write-Host "Marche (la camera ne tourne pas : W=nord, S=sud, D=est, A=ouest)" +$ok = (Walk "nord (franchit -Z)" $SC.W $Distance) -and $ok +$ok = (Walk "sud (retour + au-dela)" $SC.S (2 * $Distance)) -and $ok +$ok = (Walk "nord (retour au centre)" $SC.W $Distance) -and $ok +$ok = (Walk "est (franchit +X)" $SC.D $Distance) -and $ok +$ok = (Walk "ouest(retour + au-dela)" $SC.A (2 * $Distance)) -and $ok +$ok = (Walk "est (retour au centre)" $SC.D $Distance) -and $ok + +if (-not $proc.HasExited) { + [void][W32T]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero) + if (-not $proc.WaitForExit(30000)) { + Write-Host "[ECHEC] Pas de sortie 30 s apres WM_CLOSE." + $proc.Kill(); $proc.WaitForExit(); $ok = $false + } +} +$proc.WaitForExit() +$code = $proc.ExitCode +Start-Sleep -Milliseconds 400 +foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue } + +$text = $outSb.ToString() + $errSb.ToString() +$lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' }) +$validation = @($lines | Where-Object { $_ -match '\[Validation\]' }) +$errors = @($lines | Where-Object { $_ -match '\[ERROR\]|\[WARN\]' }) + +Write-Host ("TRAVERSEE validation : {0} message(s) [Validation], {1} [ERROR]/[WARN]" -f ` + $validation.Count, $errors.Count) +foreach ($l in ($validation + $errors) | Select-Object -First 10) { Write-Host " $l" } +Write-Host ("TRAVERSEE code de sortie: {0}" -f $code) + +if (-not $ok -or $validation.Count -gt 0 -or $errors.Count -gt 0 -or $code -ne 0) { + Write-Host "TRAVERSEE : ECHEC" + exit 1 +} +Write-Host "TRAVERSEE : OK - aucune anomalie en franchissant les frontieres." +exit 0 diff --git a/vercora_dalles.json b/vercora_dalles.json new file mode 100644 index 0000000..c30125a --- /dev/null +++ b/vercora_dalles.json @@ -0,0 +1,102 @@ +{ + "LHD_FXX_0899_6439_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0899_6439_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":48783416,\"coordonnees_NW\":\"0899-6439\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0900_6440_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0900_6440_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":54299339,\"coordonnees_NW\":\"0900-6440\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0900_6439_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0900_6439_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":57663450,\"coordonnees_NW\":\"0900-6439\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0901_6440_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0901_6440_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":61276543,\"coordonnees_NW\":\"0901-6440\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0901_6439_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0901_6439_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":49556671,\"coordonnees_NW\":\"0901-6439\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0902_6440_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0902_6440_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":44355425,\"coordonnees_NW\":\"0902-6440\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0902_6439_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0902_6439_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":33786578,\"coordonnees_NW\":\"0902-6439\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0903_6440_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0903_6440_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":37401731,\"coordonnees_NW\":\"0903-6440\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0903_6439_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0903_6439_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":27553875,\"coordonnees_NW\":\"0903-6439\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0903_6438_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0903_6438_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":27466020,\"coordonnees_NW\":\"0903-6438\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-13\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0903_6437_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0903_6437_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":30087369,\"coordonnees_NW\":\"0903-6437\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-13\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0902_6438_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0902_6438_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":28805280,\"coordonnees_NW\":\"0902-6438\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-13\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0902_6437_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0902_6437_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":32923291,\"coordonnees_NW\":\"0902-6437\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-13\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0901_6437_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0901_6437_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":34274581,\"coordonnees_NW\":\"0901-6437\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-13\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0902_6436_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0902_6436_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":36039337,\"coordonnees_NW\":\"0902-6436\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-13\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0903_6436_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0903_6436_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":33499214,\"coordonnees_NW\":\"0903-6436\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-13\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0901_6436_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0901_6436_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":37361899,\"coordonnees_NW\":\"0901-6436\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0900_6437_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0900_6437_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":27102569,\"coordonnees_NW\":\"0900-6437\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0899_6438_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0899_6438_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":45998310,\"coordonnees_NW\":\"0899-6438\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0900_6438_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0900_6438_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":32480771,\"coordonnees_NW\":\"0900-6438\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0901_6438_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0901_6438_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":28314762,\"coordonnees_NW\":\"0901-6438\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0899_6440_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0899_6440_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":33684325,\"coordonnees_NW\":\"0899-6440\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0899_6437_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0899_6437_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":34019250,\"coordonnees_NW\":\"0899-6437\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0899_6436_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0899_6436_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":23626468,\"coordonnees_NW\":\"0899-6436\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + }, + "LHD_FXX_0900_6436_PTS_O_LAMB93_IGN69": { + "url": "https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0900_6436_PTS_LAMB93_IGN69.copc.laz", + "metadata": "{\"capteur\":[\"RIEGL VQ-780 II-S:H2223888\"],\"code_mission\":\"21LHD6PM\",\"date_edition\":\"2025-03-25\",\"nombre_points\":25613711,\"coordonnees_NW\":\"0900-6436\",\"moa_acquisition\":\"IGN\",\"moe_acquisition\":\"Sintegra\",\"procede_classement\":\"ST_AUTO_MANUEL_POST_EXP\",\"date_fin_acquisition\":\"2021-08-13\",\"systeme_altimetrique\":\"IGN69\",\"moe_classement_manuel\":\"IGN\",\"systeme_planimetrique\":\"LAMB93\",\"date_debut_acquisition\":\"2021-08-11\",\"moe_classement_automatique\":\"Avineon\"}" + } +} \ No newline at end of file