Fichiers
vercora/src/main.cpp
T
Claude 8bb3222924 Phase 30 (1/n) : build Linux, banc de mesure des ressources, plan
- Portabilite GCC/Clang : les constructeurs a argument par defaut `= {}`
  sur une struct imbriquee (Heightmap, TerrainQuadtree, TerrainStreamer)
  deviennent des surcharges qui deleguent (CWG 1397, refuse hors MSVC).
  GLFW_INCLUDE_NONE evite d'exiger <GL/gl.h> sous Linux.
- Comptabilite de la memoire GPU : toute allocation passe par
  VulkanContext::allocateMemory / freeMemory (octets vivants, pics, blocs,
  appels vkAllocateMemory). RAM du processus lue au systeme
  (core/ProcessMemory). Bilan "Ressources (PHASE 30)" au chargement,
  toutes les 10 s et en fin de partie.
- Outils de banc : --quit-after=S (fermeture propre), --freeze-anim
  (images comparables au pixel), tools/make_bench_zone.py (zone proxy
  5001x5001 a la vraie echelle quand les donnees LiDAR sont absentes).
- NOTES-PHASE30.md : mesure de reference, revue du noyau Vulkan, plan.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
2026-10-13 22:39:35 +00:00

4036 lignes
228 KiB
C++

#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 "core/ProcessMemory.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 <glm/gtc/matrix_transform.hpp>
#include <algorithm>
#include <array>
#include <chrono>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <exception>
#include <filesystem>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
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/<terrain>.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.
//
// Plus deux options de la Phase 30, pour le BANC DE MESURE (voir NOTES-PHASE30.md) :
// vercora.exe [scene] --quit-after=S -> fermeture propre apres S secondes
// de boucle, bilans de fin compris
// vercora.exe [scene] --freeze-anim -> horloge d'animation des shaders
// figee : images comparables au
// pixel pres d'un run a l'autre
//
// 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<double>(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<Heightmap> makeTerrain(const std::string& sceneArgument,
bool useDefaultTerrain, bool demoMode) {
if (sceneArgument == kProceduralKeyword) {
logInfo("Terrain : generateur procedural (Phase 4), demande explicitement.");
return std::make_unique<Heightmap>();
}
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<Heightmap>(loadTerrainFile(kDemoTerrainFile));
}
if (std::filesystem::exists(kDemoTerrainFallback)) {
logWarn("Terrain : dalle demo 1 m absente, repli sur la 2 m (" +
kDemoTerrainFallback + ").");
return std::make_unique<Heightmap>(loadTerrainFile(kDemoTerrainFallback));
}
logWarn("Terrain : ni " + kDemoTerrainFile + " ni " + kDemoTerrainFallback +
" ne sont presents. Repli sur le terrain synthetique.");
return std::make_unique<Heightmap>();
}
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/<dalle>.copc.laz -o " + std::string(kDefaultTerrainFile) +
" --cell 1.0");
return std::make_unique<Heightmap>();
}
return std::make_unique<Heightmap>(loadTerrainFile(kDefaultTerrainFile));
}
if (sceneArgument.size() > 5 &&
sceneArgument.compare(sceneArgument.size() - 5, 5, ".vchm") == 0) {
return std::make_unique<Heightmap>(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<Entry> 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<int>(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<int>(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;
// PHASE 30 : outils de BANC DE MESURE.
// --quit-after=S ferme proprement le jeu apres S secondes de boucle,
// comme une fermeture de fenetre : tous les bilans de
// fin de partie sont ecrits. Remplace le WM_CLOSE poste
// de l'exterieur, que la Phase 26 a vu arriver en retard
// sur une machine chargee.
// --freeze-anim fige l'horloge d'ANIMATION des shaders (ondulation
// de l'herbe, chute de la pluie) a zero. Avec
// --lock-input, --look et --time-scale=0, deux images
// d'une meme scene deviennent comparables au pixel pres,
// ce qui est la condition pour prouver qu'une
// optimisation ne change pas l'image.
float quitAfterSeconds = 0.0f;
bool freezeAnimation = false;
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<uint32_t>(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<uint32_t>(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("--quit-after=", 0) == 0) {
try {
quitAfterSeconds =
std::stof(argument.substr(std::strlen("--quit-after=")));
if (!(quitAfterSeconds > 0.0f)) {
logWarn("--quit-after attend une duree positive en secondes. Ignore.");
quitAfterSeconds = 0.0f;
}
} catch (const std::exception&) {
logWarn("--quit-after : duree illisible. Ignore : " + argument);
quitAfterSeconds = 0.0f;
}
} else if (argument == "--freeze-anim") {
freezeAnimation = true;
} 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> 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> ground;
std::unique_ptr<Forest> 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<Ground>(*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<Forest>(*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> 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<TerrainStreamer>(*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<Heightmap> coverMap;
std::unique_ptr<Heightmap> canopyHeightMap;
std::unique_ptr<Vegetation> 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> 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<Heightmap>(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<Vegetation>(
*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<Wildlife>(*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<MeshHandle, kGroundItemKindCount> 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<std::size_t>(GroundItemKind::Log)] =
renderer.addMesh(logMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Branch)] =
renderer.addMesh(branchMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Stone)] =
renderer.addMesh(stoneMeshData());
groundMeshes[static_cast<std::size_t>(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<std::size_t>(GroundItemKind::Clay)] =
renderer.addMesh(clayLumpMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Sand)] =
renderer.addMesh(sandPileMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Resin)] =
renderer.addMesh(resinBlobMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Fiber)] =
renderer.addMesh(fiberBundleMeshData());
// PHASE 28 : objets faconnes, meme table, meme point de rendu.
groundMeshes[static_cast<std::size_t>(GroundItemKind::Cord)] =
renderer.addMesh(cordMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Axe)] =
renderer.addMesh(axeMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Hearth)] =
renderer.addMesh(hearthMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Ash)] =
renderer.addMesh(ashMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::Pitch)] =
renderer.addMesh(pitchMeshData());
groundMeshes[static_cast<std::size_t>(GroundItemKind::PitchedAxe)] =
renderer.addMesh(pitchedAxeMeshData());
groundMeshes[static_cast<std::size_t>(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<std::string, const AssetEntry*> 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<std::string, uint32_t> 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<float>(east - heightmap->geo().originEast) -
0.5f * heightmap->worldSize();
const float worldZ =
static_cast<float>(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<float>(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<WaterSource> 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<MineralDeposit> 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> fiberPlants;
if (terrainScene && heightmap) {
fiberPlants = std::make_unique<FiberPlants>(
*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> rocks;
MeshHandle boulderMeshHandle = kInvalidMesh;
MeshHandle rockMeshHandle = kInvalidMesh;
MeshHandle gravelMeshHandle = kInvalidMesh;
if (terrainScene && heightmap && useRocks) {
RockParams rockParams;
rockParams.collide = rockCollision;
rocks = std::make_unique<Rocks>(*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/<zone>_canopy_lowveg.vchm (F3) et
// <zone>_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<Heightmap> lowVegMap;
std::unique_ptr<Heightmap> lowVegHeightMap;
std::unique_ptr<Bushes> 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<Heightmap>(loadTerrainFile(path));
} catch (const std::exception& error) {
logWarn(std::string("Carte de vegetation basse : ") + error.what());
}
}
bushes = std::make_unique<Bushes>(*heightmap, lowVegMap.get(), lowVegHeightMap.get(),
coverMap.get(), 0.5f * heightmap->worldSize());
if (bushes->enabled()) {
if (forest) {
std::vector<glm::vec3> 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<DrawItem> drawItems;
// Reutilises d'une frame a l'autre : leur capacite se stabilise apres
// quelques images, donc plus aucune allocation en regime etabli.
std::vector<InstancedDrawItem> instancedItems;
std::vector<InstanceData> treeInstances; // resineux (PHASE 26)
std::vector<InstanceData> broadleafInstances; // feuillus (PHASE 26)
std::vector<InstanceData> grassInstances;
std::vector<InstanceData> fiberInstances; // PHASE 22
std::vector<InstanceData> boulderInstances; // PHASE 29
std::vector<InstanceData> stoneInstances; // PHASE 29
std::vector<InstanceData> gravelInstances; // PHASE 29
std::vector<InstanceData> shrubInstances; // PHASE 29 (Agent 3)
std::vector<InstanceData> 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<KeyEdge, 9> 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<int>(editorQuickKeys.size()); ++i) {
editorQuickKeys[static_cast<std::size_t>(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<uint64_t>(
std::chrono::duration_cast<std::chrono::microseconds>(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();
// PHASE 30 : bilan des ressources une fois le monde charge, avant la
// premiere image. Le meme bilan est ecrit toutes les 10 s, puis a la
// fermeture avec les pics de la session.
logInfo("Ressources apres chargement (PHASE 30) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ".");
double lastResourceLog = 0.0;
while (!window.shouldClose()) {
window.pollEvents();
const double loopSeconds =
std::chrono::duration<double>(ProfileClock::now() - loopStart).count();
if (quitAfterSeconds > 0.0f && loopSeconds >= quitAfterSeconds) {
logInfo("--quit-after : " + std::to_string(quitAfterSeconds) +
" s de boucle ecoulees, fermeture.");
break;
}
if (loopSeconds - lastResourceLog >= 10.0) {
lastResourceLog = loopSeconds;
logInfo("Ressources (PHASE 30) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ".");
}
const double now = glfwGetTime();
const float deltaTime = static_cast<float>(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<float>(now);
// PHASE 30 : horloge des SHADERS seulement (--freeze-anim). La
// logique de jeu garde elapsedSeconds.
const float animationSeconds = freezeAnimation ? 0.0f : elapsedSeconds;
// --- 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<std::size_t>(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<std::size_t>(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<float>(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<int>(editorQuickKeys.size()); ++i) {
if (editorQuickKeys[static_cast<std::size_t>(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<std::size_t>(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<std::size_t>(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<std::size_t>(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<float>(
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<InstanceData>& instances,
MeshHandle mesh) {
if (instances.empty() || mesh == kInvalidMesh) { return; }
InstancedDrawItem item;
item.mesh = mesh;
item.instances = instances.data();
item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage;
// Amplitude d'ondulation NULLE : un tronc ne plie pas.
item.params = { 0.0f, animationSeconds, 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<uint32_t>(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,
animationSeconds, 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<uint32_t>(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,
animationSeconds, 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<InstanceData>& instances,
MeshHandle mesh) {
if (instances.empty() || mesh == kInvalidMesh) { return; }
InstancedDrawItem item;
item.mesh = mesh;
item.instances = instances.data();
item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage;
item.params = { 0.0f, animationSeconds, 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<InstanceData>& instances,
MeshHandle mesh, float sway) {
if (instances.empty() || mesh == kInvalidMesh) { return; }
InstancedDrawItem item;
item.mesh = mesh;
item.instances = instances.data();
item.count = static_cast<uint32_t>(instances.size());
item.material = Material::Foliage;
item.params = { sway, animationSeconds, 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,
animationSeconds);
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();
// PHASE 30 : bilan des ressources, AVANT toute destruction - les chiffres
// "vivants" sont donc ceux du jeu en regime etabli, les pics ceux de la
// session entiere.
logInfo("Ressources en fin de partie (PHASE 30) : " + processMemoryLine() + ", " +
context.gpuMemoryLine() + ".");
if (frameProfile.frames > 0) {
const auto per = [&](uint64_t total) {
const double value = static_cast<double>(total) /
static_cast<double>(frameProfile.frames);
return std::to_string(static_cast<int>(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<double>(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<unsigned long long>(frameProfile.frames),
loopSeconds,
static_cast<double>(frameProfile.frames) / loopSeconds,
1e6 * loopSeconds / static_cast<double>(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;
}