Fichiers
2026-10-11 01:54:18 +02:00

Brut Lien permanent Annotations Historique

Vercora — Phase 9 : la vraie zone de jeu, 25 dalles assemblées en un terrain

Session du 2026-08-20/21. Objectif : passer de la dalle unique de validation (Phase 7) à la zone de jeu réelle choisie avec l'utilisateur et son père — 25 dalles LiDAR HD, grille 5 × 5 km, Lambert 93 X 899–903 / Y 6436–6440.

C'est la session où se jouait ce que les deux bugs d'arrondi de la Phase 7 (arrondi bancaire, intervalle semi-ouvert inversé sur l'axe nord) auraient cassé en silence. Ils avaient été corrigés mais jamais éprouvés en conditions réelles. Ils le sont maintenant : les 8 frontières intérieures sont vérifiées contre les nuages bruts, alignement prouvé par contraste ×14,5.

Numérotation. La consigne de session parlait de « Phase 8 ». La Phase 8 existe déjà dans MEMORY.md (visée sur relief + base du parapente, même journée) : cette session est donc numérotée Phase 9 partout, y compris dans l'en-tête des nouveaux outils.


Résultat en une page

Dalles téléchargées 25 / 25, 4,99 Go, 73 s (~85 Mo/s)
Conversion 1 m 25 × 1001×1001, ~6 s/dalle, ~2,5 min au total
Terrain assemblé 1 m 5001 × 5001, 95,4 Mo, 5000 × 5000 m, dénivelé 1256 m (1028,8 → 2285,2 m)
Continuité aux frontières conforme sur les 8 frontières (détail plus bas)
Chargé dans le moteur oui — 25 M sommets, 50 M triangles, 0 erreur de validation
Jouable à 1 m ? non — 12 FPS. Le 2 m (46 FPS) est le repli utilisable
Verdict le streaming par tuiles devient nécessaire maintenant, cf. §6

1. Téléchargement — tools/fetch_dalles.py (nouveau)

Le manifeste annoncé à la racine sous le nom vercora_dalles.json n'y était pas : il se trouvait dans Downloads sous le nom metadonnees.json (avec un doublon metadonnees(1).json, strictement identique — même MD5). Contenu conforme à l'annonce : 25 entrées, grille 5 × 5 complète, 925 974 185 points. Copié à la racine sous le nom attendu.

python tools/fetch_dalles.py vercora_dalles.json -o data/lidar --dry-run
python tools/fetch_dalles.py vercora_dalles.json -o data/lidar

Le script fait d'abord 25 requêtes HEAD pour connaître la taille réelle du lot avant d'écrire quoi que ce soit (4,99 Go), la compare à l'espace libre (281,6 Go) avec une marge, puis télécharge. Reprise par Range sur fichier partiel, 4 tentatives avec attente croissante, vérification de la taille finale et de la signature LASF — un HTML d'erreur enregistré sous un nom en .laz passerait sinon inaperçu jusqu'à la conversion. Bilan final nommant les échecs.

Résultat : 25/25, aucune reprise, aucun échec. 73 s en deux lots (4 puis 21).

À noter pour l'utilisateur : le téléchargement par navigateur lancé en parallèle tournait à ~1,5 Mo/s, contre ~85 Mo/s pour le script — soit plus d'une heure contre une minute pour le même lot.

2. Conversion — tools/lidar_to_heightmap.py (une option ajoutée)

Résolution 1 m, inchangée depuis la Phase 7, et pour les mêmes raisons (la densité de points sol la supporte). Un jeu 2 m est produit en plus, pas à la place — voir §5.

Une seule modification, mais elle est structurante pour l'assemblage :

--bounds-from-name. L'emprise de la grille était déduite de header.mins/maxs, c'est-à-dire de l'étendue des points, arrondie au mètre. Sur les 25 dalles ça tombe juste — mais ce n'est pas garanti : une dalle dont les échos s'arrêtent 30 cm avant le bord (bord de mission, plan d'eau, trou de vol) aurait donné 1000 échantillons au lieu de 1001. Elle aurait alors été refusée comme non carrée, ou pire, se serait raccordée décalée d'un mètre. L'option impose l'emprise nominale lue dans le nom de la dalle, qui est celle que l'IGN garantit. Utilisée pour les 25.

Résultats : 25 dalles, toutes en 1001 × 1001, ~6 s chacune. Les trous varient énormément d'une dalle à l'autre — de 0,26 % (0901_6438) à 47,3 % (0901_6436, sous couvert dense) — et sont bouchés par dilatation comme en Phase 7.

Un piège rencontré, et qui vaut d'être noté. La première passe de conversion en a silencieusement sauté 3 : le motif shell LHD_FXX_09* ne correspond pas aux dalles de la colonne X = 899, dont le nom commence par LHD_FXX_0899 — donc par 08, pas 09. Erreur de ma part, pas de l'outil. Elle n'a pas pu aller plus loin parce que assemble_terrain.py refuse une grille incomplète (--allow-gaps est explicite) : le filet a joué son rôle.

3. Assemblage — tools/assemble_terrain.py (nouveau)

python tools/assemble_terrain.py assets/terrain/LHD_09*_1m.vchm \
    -o assets/terrain/vercora_zone_1m.vchm --label vercora_zone_5x5_1m

Chaque dalle est placée par son géoréférencement (originEast/originNorth de son en-tête), jamais par son nom ni son ordre sur la ligne de commande. Une origine qui ne tombe pas sur le réseau au pas courant est refusée.

Le nœud partagé — le point non évident

Les échantillons sont sur les nœuds : une dalle de 1 km au pas de 1 m fait 1001 échantillons, de X=899000 à X=900000 inclus. La voisine commence à X=900000, inclus elle aussi. La colonne est donc dans les deux fichiers.

5 dalles alignées font 5 × 1001 − 4 = 5001 échantillons, pas 5005. Une concaténation naïve aurait produit 5005 colonnes : terrain 4 m trop large et tout ce qui est à l'est d'une jointure décalé — la « duplication de ligne/colonne à la jointure » à ne pas commettre. Le script le signale explicitement dans sa sortie.

Mais les deux valeurs partagées ne sont pas identiques, et c'est normal : le nœud X=900000 agrège les points de [899999,5 ; 900000,5[. La dalle ouest n'en voit que la moitié gauche, la dalle est que la moitié droite. L'écart entre les deux mesure directement la cohérence du raccord. La valeur retenue est leur moyenne.

Écart entre les deux versions d'un nœud partagé (40 040 nœuds, 1 m)

Médiane 0,170 m
Moyenne 0,359 m
p99 2,78 m
> 10 m 73 nœuds (0,18 %)
> 50 m 15 nœuds (0,037 %)
Maximum 79,23 m

Les 79 m ont été cherchés et expliqués, pas laissés de côté. Le pire nœud est à E 903844 / N 6439000 : 1728,66 m selon la dalle nord, 1807,89 m selon la dalle sud. Vérification dans les nuages bruts : les deux dalles ont des points là (28 et 22 dans la cellule), et dans une fenêtre de 10 × 10 m autour, les altitudes sol vont de 1682 à 1827 m — une paroi quasi verticale.

La corrélation est nette sur l'ensemble :

Écart au nœud partagé Nœuds Relief local médian (amplitude sur 5 m)
≤ 0,5 m 34 569 1,62 m
0,5 – 2 m 4 742 2,31 m
2 – 10 m 656 2,41 m
10 – 50 m 58 34,13 m
> 50 m 15 59,71 m

Ce n'est pas un défaut d'assemblage mais la limite d'une heightmap 2,5D sur une falaise : sur une paroi verticale, « l'altitude du sol en (x, y) » n'a pas de valeur unique, et la médiane d'une cellule de 1 m² y est instable par nature. 79 % des nœuds à plus de 10 m d'écart sont sur du relief à plus de 20 m d'amplitude sur 5 m. À garder en tête le jour où la collision devra gérer ces parois.

4. Vérification des frontières — tools/check_seams.py (nouveau)

tools/check_terrain_file.py est resté inchangé : deux arguments positionnels et des sondes nommées en dur, taillés pour une dalle isolée. Le pendant multi-dalles est un outil frère, qui applique le même principe — relire le .vchm produit et le confronter aux points sol bruts, sans rien partager avec le producteur, pour qu'une erreur d'indexation ne puisse pas se compenser.

python tools/check_seams.py assets/terrain/vercora_zone_1m.vchm data/lidar/*.laz

1 676 sondes (1 592 réparties tous les 25 m le long des 8 frontières, 100 témoins loin de toute jointure), dont 1 360 exploitables — les 316 autres sont rejetées faute de points sol, sous couvert dense.

Résultat (terrain 1 m, 25 dalles)

lecture       jointures: median       max    | temoins: median       max
direct                   0.020m   80.840m               0.000m    0.080m   <- lecture reelle
est +1                   0.300m   42.605m               0.290m    3.430m
ouest -1                 0.300m   85.420m               0.305m    2.105m
sud +1                   0.290m   77.540m               0.260m    1.885m
nord -1                  0.295m   86.930m               0.280m    1.595m

C'est le contraste qui fait la preuve, comme pour le test nord/sud de la Phase 7 : la lecture directe vaut 0,020 m contre 0,290 m pour le meilleur décalage d'un nœud, soit ×14,5. Un assemblage décalé d'une colonne resterait plausible sur du relief doux ; il ne peut pas produire ce contraste.

Détail des 8 frontières — aucune ne se distingue :

Frontière Sondes Médiane Max
H N6436000 109 0,030 m 12,49 m
H N6437000 167 0,025 m 11,66 m
H N6438000 171 0,020 m 0,53 m
H N6439000 175 0,017 m 12,72 m
V E900000 175 0,022 m 1,87 m
V E901000 164 0,015 m 0,27 m
V E902000 152 0,017 m 80,84 m
V E903000 160 0,020 m 0,39 m

Les maxima isolés sont les falaises du §3 (mêmes nœuds, même cause). Les médianes, elles, sont toutes ≤ 0,030 m, et les témoins en plein milieu de dalle sont à 0,000 m : le raccord n'est pas moins fidèle que le reste du terrain.

Deuxième contrôle, indépendant, dans assemble_terrain.py

Mesure faite sur le produit fini, sans rien savoir des dalles d'origine : le long d'une jointure, la différence entre deux colonnes voisines doit ressembler à celle observée partout ailleurs. Un décalage la rendrait anormalement grande, une colonne dupliquée anormalement petite (deux colonnes identiques = pente nulle). Les deux défauts sont donc attrapés.

reference : pente mediane est-ouest 0.300 m/m, nord-sud 0.265 m/m
jointure verticale   x=1000 : 0.393 / 0.397    x=2000 : 0.253 / 0.250
                     x=3000 : 0.270 / 0.267    x=4000 : 0.318 / 0.315
jointure horizontale z=1000 : 0.235 / 0.235    z=2000 : 0.250 / 0.248
                     z=3000 : 0.388 / 0.390    z=4000 : 0.403 / 0.398
OK - aucune jointure ne se distingue du relief environnant.

Système de coordonnées

Inchangé et conforme à la Phase 7 : le .vchm garde son géoréférencement en double dans l'en-tête (coin nord-ouest E 899000 / N 6440000, EPSG:2154) et des altitudes absolues IGN69 ; c'est le moteur qui recentre le terrain sur l'origine du monde au chargement. Les sommets ne portent donc jamais de coordonnées Lambert 93 — à 6,4 millions, l'écart entre deux float32 vaut déjà 0,5 m. Sur 5 km, le monde va de −2500 à +2500 en X et en Z, et les anciennes frontières de dalles tombent à ±500 et ±1500 m.

5. Chargement dans le moteur et performances

Mesures reproductibles via tools/measure_terrain.ps1 (nouveau) : FPS lu dans le titre de la fenêtre, mémoire par PeakWorkingSet64. Rien n'a été ajouté au moteur pour mesurer — c'est exactement le binaire qui tourne en vrai.

Le GPU a changé depuis la Phase 7. Cette machine n'a plus de GTX 960 : elle tourne sur l'Intel UHD 770 intégrée (confirmé par l'utilisateur, ce n'est pas un défaut de détection). Les 848 FPS de la Phase 7 ne sont donc pas comparables aux chiffres ci-dessous. La dalle de Phase 7 a été re-mesurée sur ce GPU pour servir de repère honnête. i5-14600K, 64 Go de RAM, build Debug avec couches de validation, comme en Phase 7.

Scène Sommets Triangles FPS Pic RAM Chargement
Procédural (Phase 4) 16 384 32 258 1381 108 Mo 0,2 s
1 dalle 1 m (Phase 7) 1 002 001 2 000 000 247 302 Mo 0,6 s
2 × 2 dalles 1 m (4 km²) 4 004 001 8 000 000 67 805 Mo 1,8 s
5 × 5 dalles 2 m (25 km²) 6 255 001 12 500 000 46 1 083 Mo 2,8 s
5 × 5 dalles 1 m (25 km²) 25 010 001 50 000 000 12 4 014 Mo 10,2 s

Zéro message [Validation], zéro [ERROR]/[WARN], code de sortie 0 sur les cinq scènes. Le terrain de 25 km² à 1 m charge et fonctionne — il n'est simplement pas jouable.

Déplacement sur toute la zone — tools/traverse_terrain.ps1 (nouveau)

La caméra marche 5,6 km en franchissant les anciennes frontières à ±500 m et ±1500 m sur les deux axes, avec relevé du FPS en cours de route : un accroc à une jointure se verrait comme une chute localisée, pas dans une moyenne.

Terrain FPS moyen min max Validation Sortie
5 × 5 à 2 m 46–47 43 47 0 propre
5 × 5 à 1 m 12 9 12 0 propre

Aucune chute localisée au franchissement d'une frontière, aucune chute à travers le sol, aucun blocage, fermeture propre. Le FPS est le même au milieu d'une ancienne dalle et à cheval sur une jointure.

Limite assumée, la même qu'en Phase 7/8 : la souris ne peut pas être pilotée (GLFW lit le curseur système), donc la caméra ne tourne pas de tout le test et la position n'est connue qu'à l'estime. Le test prouve qu'on traverse sans incident ; il ne mesure pas où l'on arrive.

Non-régression

  • Terrain procédural (vercora.exe terrain) : 1381 FPS, intact.
  • Dalle unique de la Phase 7 (vercora.exe assets\terrain\LHD_0907_6440_1m.vchm) : 247 FPS, intacte. Elle reste la scène par défaut — voir §6.
  • 185 assertions headless (tools\run_logic_tests.bat) : toutes passent.
  • tools\run_vulkan_check.ps1, 4 scénarios : voir le tableau de MEMORY.md.

6. Le verdict qu'il faut entendre : le streaming devient nécessaire

Le facteur limitant n'est pas la mémoire (4 Go sur une machine qui en a 64, et le GPU intégré puise dans la RAM système) ni le disque (5,2 Go sur 281 Go libres) ni la conversion (2,5 min pour 25 dalles). C'est le débit géométrique.

Le moteur envoie un seul maillage, en entier, à chaque image, sans LOD ni culling par morceaux. Le coût est donc proportionnel à la surface, et il l'est très proprement : 247 → 67 → 12 FPS pour 1 → 4 → 25 km² à 1 m. Or le joueur ne voit à aucun moment plus d'un très petit pourcentage de ces 50 M de triangles.

Réponse à la question posée : oui, un système de streaming par tuiles devient nécessaire maintenant, et non plus tard. À l'échelle de la Phase 7 tout passait en force ; à 25 km² ce n'est plus vrai, et la donnée finale est là pour rester. Sans découpage, chaque agrandissement futur de la zone divisera encore le FPS.

Ce qui est déjà acquis pour ça : les 25 heightmaps individuelles sont conservées (assets/terrain/LHD_<X>_<Y>_1m.vchm), le géoréférencement de chacune est exact, et l'assemblage est prouvé cohérent. Le découpage en tuiles n'aura donc rien à redécouper — il consommera directement les dalles existantes.

Ce qui manque côté moteur, par ordre d'importance : charger/décharger des morceaux de terrain selon la position de la caméra ; un LOD par distance (une tuile lointaine n'a pas besoin du pas de 1 m) ; un frustum culling par tuile. La contrainte « grilles carrées uniquement » de TerrainFile devra aussi tomber, puisqu'elle n'a survécu ici que parce que 5 × 5 est carré.

En attendant : le 2 m est le repli utilisable

assets/terrain/vercora_zone_2m.vchm (2501 × 2501, 25 Mo) couvre la même zone de 25 km² à 46 FPS et 1 Go — soit 4× moins de triangles pour un pas qui reste très fin à l'échelle d'une montagne. La Phase 7 avait déjà généré le 2 m en prévoyant exactement ce cas (« pour une future carte multi-dalles »).

Ce n'est pas un substitut au 1 m : le fichier 1 m est produit, vérifié et livré, et c'est lui qui alimentera le streaming. C'est un repli pour continuer à travailler sur la vraie zone d'ici là.

7. Ce qui n'a pas été fait / vérifié — à dire franchement

  • La scène par défaut n'a pas été changée. vercora.exe sans argument charge toujours la dalle de Phase 7. Faire de la zone 25 km² le défaut alors qu'elle tourne à 12 FPS aurait donné l'impression d'une régression du moteur ; le choix du défaut revient à l'utilisateur, une fois le streaming décidé. Les deux terrains assemblés se chargent par chemin explicite.
  • Aucun test headless n'a été ajouté pour l'assemblage : la vérification est entièrement en Python (assemble_terrain.py + check_seams.py), pas dans les 185 assertions C++. Un test C++ qui chargerait vercora_zone_1m.vchm supposerait un fichier de 95 Mo non versionné.
  • Aucun scénario n'a été ajouté à run_vulkan_check.ps1 pour la zone assemblée : le pilotage par PostMessage est calibré en distance/temps à vitesse 14 m/s, et à 12 FPS le jeu consomme les touches trop grossièrement pour que le tir sur cible reste fiable. traverse_terrain.ps1 couvre le déplacement ; l'abattage/ramassage sur la nouvelle zone reste à vérifier.
  • Rien n'a été vérifié à la manette / à l'œil. L'orientation du relief est prouvée par la donnée (contraste ×14,5), pas par un contrôle visuel : il n'y a toujours pas d'orthophoto plaquée. C'est toujours la recommandation n°2 de la Phase 7.
  • Les falaises du §3 ne sont pas traitées, seulement caractérisées.
  • --bounds-from-name n'a pas été éprouvée sur une dalle réellement tronquée, puisque les 25 tombaient juste. C'est un filet, pas une correction constatée.

8. Où sont les choses

Chemin Quoi
vercora_dalles.json manifeste des 25 dalles (copié depuis Downloads/metadonnees.json)
data/lidar/*.copc.laz 25 dalles brutes, 5,2 Go (avec celle de Phase 7) — non versionnées
assets/terrain/LHD_<X>_<Y>_1m.vchm 25 heightmaps individuelles, 3,82 Mo chacune
assets/terrain/LHD_<X>_<Y>_2m.vchm idem au pas de 2 m
assets/terrain/vercora_zone_1m.vchm terrain assemblé 5001², 95,4 Mo
assets/terrain/vercora_zone_2m.vchm terrain assemblé 2501², 25 Mo (repli jouable)
assets/terrain/test_2x2_1m.vchm bloc de validation 2 × 2, gardé comme cas de test

Nouveaux outils : tools/fetch_dalles.py, tools/assemble_terrain.py, tools/check_seams.py, tools/measure_terrain.ps1, tools/traverse_terrain.ps1. Modifié : tools/lidar_to_heightmap.py (option --bounds-from-name). Aucun fichier de src/ n'a été modifié dans cette session.

Prochaines étapes suggérées

  1. Streaming par tuiles + LOD (§6) — le vrai sujet de la prochaine session.
  2. Orthophoto BD ORTHO sur l'emprise E 899000–904000 / N 6435000–6440000 : premier contrôle visuel de l'orientation, toujours en attente depuis la Phase 7.
  3. Décider de la scène par défaut une fois le streaming en place.
  4. Exploiter la classification (classe 5) pour semer les arbres là où il y en a vraiment — la variation de couvert entre dalles (0,26 % à 47,3 % de trous) est une carte de forêt gratuite.