405 lignes
20 KiB
Markdown
405 lignes
20 KiB
Markdown
# Vercora — Phase 7 : pipeline LiDAR HD réel, de bout en bout
|
||
|
||
Session du 2026-08-16, non supervisée. Objectif : valider la **chaîne technique**
|
||
complète, d'une vraie dalle IGN jusqu'au terrain sur lequel la caméra marche.
|
||
Ce n'est **pas** le choix de la zone finale du jeu, qui reste à définir.
|
||
|
||
Jusqu'ici le terrain était toujours synthétique (bruit fractal, Phase 4). Il ne
|
||
l'est plus : `vercora.exe` sans argument charge désormais une vraie dalle. Le
|
||
générateur procédural reste disponible (`vercora.exe terrain`) et sert toujours
|
||
de monde de référence aux tests — voir « Ce qui n'a pas changé » plus bas.
|
||
|
||
---
|
||
|
||
## État : vérifié, zéro erreur de validation Vulkan
|
||
|
||
```bash
|
||
tools\build.bat # compile
|
||
tools\run_logic_tests.bat # 169 assertions headless (121 avant la Phase 7)
|
||
tools\run_vulkan_check.ps1 # le VRAI exe, 3 scenarios, sous validation layers
|
||
```
|
||
|
||
**Les trois passent.** `run_vulkan_check.ps1` : 0 message `[Validation]`,
|
||
0 `[ERROR]`, 0 `[WARN]`, codes de sortie 0/0/0, fermeture propre sur les trois
|
||
scénarios — dont le nouveau **scénario C**, qui joue sur la dalle réelle
|
||
(2 000 000 de triangles) : chargement, marche sur le relief mesuré, abattage,
|
||
ramassage, vol libre, 6 redimensionnements, minimisation/restauration, `WM_CLOSE`.
|
||
|
||
Non-régression : les scénarios A et B tournent toujours sur le terrain
|
||
synthétique, avec exactement la même couverture qu'en Phase 6.
|
||
|
||
---
|
||
|
||
## 1. La dalle utilisée
|
||
|
||
| | |
|
||
|---|---|
|
||
| Nom | `LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz` |
|
||
| Emprise | Lambert 93, X 907000–908000, Y 6439000–6440000 (1 km × 1 km) |
|
||
| WGS84 (centre) | **45,0236 N — 5,6349 E** |
|
||
| Lieu | **Le Gua, Isère (38450)** — bordure orientale du Vercors |
|
||
| Bloc / mission | `PM`, mission `21LHD6PM`, acquisition du 06 au 13/08/2021 |
|
||
| Classement | `ST_AUTO_MANUEL_POST_EXP` (auto Avineon + reprise manuelle IGN) |
|
||
| Points | 28 739 937, format LAS 1.4 point format 6 |
|
||
| Taille | **175 350 922 octets (167,2 Mo)** |
|
||
| Licence | Etalab 2.0 (open data) |
|
||
|
||
URL de téléchargement :
|
||
|
||
```
|
||
https://data.geopf.fr/telechargement/download/LiDARHD-NUALID/NUALHD_1-0__LAZ_LAMB93_PM_2025-03-25/LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz
|
||
```
|
||
|
||
**Comment on la trouve** — et c'est le point non évident. `geoservices.ign.fr`
|
||
redirige vers `cartes.gouv.fr`, une application web dont les liens ne
|
||
s'extraient pas d'une page. L'index des dalles est en revanche exposé en **WFS**,
|
||
et chaque tuile y porte son URL de téléchargement :
|
||
|
||
```bash
|
||
curl "https://data.geopf.fr/wfs/ows?SERVICE=WFS&VERSION=2.0.0&REQUEST=GetFeature&TYPENAMES=IGNF_NUAGES-DE-POINTS-LIDAR-HD:dalle&COUNT=3&OUTPUTFORMAT=application/json&SRSNAME=EPSG:2154&BBOX=908000,6440000,913000,6445000,EPSG:2154"
|
||
```
|
||
|
||
La propriété `url` de chaque *feature* est le lien direct ; `metadata` donne le
|
||
nombre de points, les dates d'acquisition et le procédé de classement. Le service
|
||
limite à 1 requête/seconde. L'ancienne forme
|
||
`storage.sbg.cloud.ovh.net/.../ppk-lidar/...`, encore citée un peu partout, n'est
|
||
plus la source de référence.
|
||
|
||
**Pourquoi cette dalle.** Zone de couverture confirmée (livrée dès 2021), et
|
||
surtout un relief qui met le pipeline à l'épreuve plutôt que de le flatter :
|
||
**562 m de dénivelé sur 1 km²** (420 → 982 m), donc de vraies falaises, et
|
||
**67 % de végétation haute**, donc de vrais trous de données sous le couvert. Un
|
||
plateau agricole aurait tout fait passer sans rien prouver.
|
||
|
||
Espace disque vérifié avant téléchargement : 294 Go libres sur C:.
|
||
|
||
---
|
||
|
||
## 2. L'outil de conversion — `tools/lidar_to_heightmap.py`
|
||
|
||
```bash
|
||
python -m pip install "laspy[lazrs]" numpy
|
||
python tools/lidar_to_heightmap.py data/lidar/LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz -o assets/terrain/LHD_0907_6440_1m.vchm --cell 1.0
|
||
```
|
||
|
||
Options : `--cell`, `--stat median|mean|min`, `--classes`, `--no-despike`,
|
||
`--zero-base`, `--report-only`. L'en-tête du script documente tout.
|
||
|
||
**laspy + lazrs plutôt que PDAL.** PDAL est bien le standard du domaine, mais sur
|
||
Windows il ne se livre en pratique que par conda, absent de cette machine.
|
||
laspy 2.7 avec le backend lazrs (l'implémentation Rust de LASzip) lit exactement
|
||
le même LAZ 1.4 classifié, s'installe en une commande pip — y compris sur le
|
||
Python 3.14 de cette machine, ce qui n'allait pas de soi — et tout le reste du
|
||
travail est du numpy de toute façon. Le format de sortie ne dépend pas du lecteur :
|
||
PDAL produirait le même fichier.
|
||
|
||
**Pourquoi un outil séparé du moteur.** Un `.laz` est un nuage compressé et non
|
||
trié ; en tirer une grille demande un décodeur LASzip, un tri, une agrégation,
|
||
un bouchage de trous et un filtrage — 3,6 s et 167 Mo de lecture, pour un
|
||
résultat toujours identique. C'est de la *préparation*, pas du chargement. Le jeu
|
||
lit 4 Mo de float déjà propres. Même frontière que les shaders, compilés en
|
||
SPIR-V par le build et non en GLSL à l'exécution.
|
||
|
||
### Résultats de la conversion
|
||
|
||
| | 1 m (**retenu**) | 2 m |
|
||
|---|---|---|
|
||
| Échantillons | 1001 × 1001 | 501 × 501 |
|
||
| Fichier `.vchm` | **4 008 124 o (3,82 Mo)** | 1 004 124 o (0,96 Mo) |
|
||
| Points sol par cellule (médiane) | 7 | 20 |
|
||
| Cellules sans aucun point | **21,58 %** | 6,64 % |
|
||
| Rayon du plus gros trou | 6 cellules (6 m) | 3 cellules (6 m) |
|
||
| Pics corrigés | 13 (0,0013 %) | 5 (0,0020 %) |
|
||
| Sommets / triangles | 1 002 001 / 2 000 000 | 251 001 / 500 000 |
|
||
| FPS (GTX 960, Debug) | **848** | 1876 |
|
||
| Pic mémoire du processus | **185 Mo** | 102 Mo |
|
||
| Durée de conversion | 3,6 s | 3,2 s |
|
||
|
||
**Le 1 m est retenu**, pour trois raisons : la densité de points sol (7,10 pts/m²)
|
||
le supporte réellement — descendre à 20 cm inventerait du détail que la donnée
|
||
n'a pas ; 848 FPS sur une GTX 960 de 2015 laisse une marge considérable ; et
|
||
185 Mo de pic mémoire sont sans commune mesure avec les 64 Go disponibles. Le 2 m
|
||
reste généré et utilisable (`vercora.exe chemin\vers\..._2m.vchm`) comme repli
|
||
pour une machine plus modeste ou pour une future carte multi-dalles.
|
||
|
||
### Le format `.vchm`
|
||
|
||
En-tête de 120 octets petit-boutiste puis `samplesZ * samplesX` float32.
|
||
Définition complète en tête de `tools/lidar_to_heightmap.py`, redite dans
|
||
`src/assets/TerrainFile.hpp`. Les altitudes restent **absolues (IGN69)** et le
|
||
géoréférencement (coin nord-ouest en Lambert 93 + code EPSG) est conservé dans
|
||
l'en-tête : le fichier reste raccordable à ses voisins.
|
||
|
||
---
|
||
|
||
## 3. Intégration dans le moteur
|
||
|
||
`TerrainMesh`, les shaders et la caméra n'ont **pas été touchés**. C'était tout
|
||
l'intérêt d'avoir fait passer le terrain par `Heightmap` dès la Phase 4, et ça
|
||
s'est vérifié : la classe a simplement reçu un second constructeur qui adopte une
|
||
grille déjà construite.
|
||
|
||
- `src/assets/TerrainFile.{hpp,cpp}` — lecture et validation du `.vchm`.
|
||
- `src/assets/Heightmap.{hpp,cpp}` — constructeur « grille toute faite »,
|
||
`GeoReference`, `toProjected()`, validation factorisée dans `finalize()`.
|
||
- `src/main.cpp` — sélection de la scène, repli sur le procédural.
|
||
|
||
### Scènes disponibles
|
||
|
||
```
|
||
vercora.exe -> dalle LiDAR reelle (defaut)
|
||
vercora.exe terrain -> terrain synthetique (Phase 4)
|
||
vercora.exe chemin\dalle.vchm -> une autre heightmap reelle
|
||
vercora.exe cube -> cube code en dur (Phase 1)
|
||
vercora.exe modele.obj -> mesh charge depuis un fichier
|
||
```
|
||
|
||
Si la dalle par défaut est absente (elle n'est pas versionnée), le jeu **se replie
|
||
sur le terrain synthétique** avec un message expliquant comment la produire. Un
|
||
chemin donné *explicitement* qui n'existe pas est en revanche une erreur : obtenir
|
||
du bruit fractal à la place de la dalle demandée sans s'en apercevoir serait pire
|
||
que planter.
|
||
|
||
---
|
||
|
||
## 4. Les problèmes rencontrés avec les vraies données
|
||
|
||
### 4.1 Trous — 21,6 % des cellules au pas de 1 m
|
||
|
||
Cause : 67 % de végétation haute. Sous un couvert dense, aucun écho ne redescend
|
||
jusqu'au sol. Le plus gros trou fait **6 cellules de rayon**.
|
||
|
||
Traitement : dilatation itérative — chaque passe remplit une cellule vide par la
|
||
moyenne de ses voisines déjà connues, jusqu'à ce qu'il n'en reste aucune. Le
|
||
nombre de passes est journalisé et vaut exactement le rayon du plus gros trou :
|
||
c'est le diagnostic le plus parlant sur la qualité d'une dalle. Aucun `NaN` ne
|
||
doit atteindre le GPU — il produirait un triangle dégénéré et un terrain
|
||
clignotant, sans le moindre message d'erreur. `Heightmap::finalize()` refuse donc
|
||
aussi toute valeur non finie, en seconde barrière.
|
||
|
||
### 4.2 Valeurs aberrantes — 13 cellules sur 1 002 001
|
||
|
||
La médiane par nœud absorbe déjà le bruit ponctuel. Le risque résiduel est la
|
||
cellule dont *tous* les points sont faux. Le filtre doit donc être sévère envers
|
||
un pic isolé et **indulgent envers une falaise**, car cette dalle en a de vraies.
|
||
D'où un double seuil : il faut dépasser **à la fois** 5 m d'écart absolu **et**
|
||
6 × la dispersion locale (MAD du voisinage 3×3). Sur un versant raide la
|
||
dispersion locale est grande et le filtre se désactive de lui-même ; sur un
|
||
replat elle est proche de zéro et le moindre pic ressort. Résultat : 13 cellules
|
||
touchées, écart maximal 25,2 m — des blunders francs, pas du relief.
|
||
|
||
### 4.3 Coordonnées Lambert 93 — recentrage obligatoire
|
||
|
||
Les coordonnées IGN valent ~907 000 en X et ~6 440 000 en Y. À 6,4 millions,
|
||
l'écart entre deux `float32` consécutifs vaut déjà **0,5 m** : porter ces valeurs
|
||
dans les sommets ferait trembler la géométrie et ruinerait le depth buffer.
|
||
|
||
Le terrain est donc **recentré sur l'origine du monde** (ce que `Heightmap`
|
||
faisait déjà), et le géoréférencement est conservé **en `double`, à côté de la
|
||
grille**, jamais dans les sommets. `Heightmap::toProjected()` refait le chemin
|
||
inverse ; le jeu journalise au démarrage la position Lambert 93 du point de
|
||
départ (E 907500, N 6439500, altitude 605,38 m), ce qui permet de retrouver
|
||
l'endroit sur une carte à partir d'un simple log de partie.
|
||
|
||
### 4.4 Le piège de l'orientation — le relief en miroir
|
||
|
||
Le moteur est en repère main droite avec Y vers le haut, donc X ∧ Y = Z. En
|
||
posant X = Est, on obtient **Z = Est ∧ Haut = −Nord** : le nord est en −Z. Les
|
||
lignes du `.vchm` sont donc rangées **du nord vers le sud**.
|
||
|
||
Se tromper de sens produit un terrain parfaitement plausible — même dénivelé,
|
||
mêmes pentes, même histogramme — mais **retourné**, et d'autant plus indétectable
|
||
qu'il n'y a pas encore d'orthophoto à plaquer dessus. C'est le genre d'erreur
|
||
qu'on découvre trois phases plus tard.
|
||
|
||
D'où `tools/check_terrain_file.py`, qui relit le `.vchm` et le confronte au nuage
|
||
brut sans rien partager avec le convertisseur :
|
||
|
||
```bash
|
||
python tools/check_terrain_file.py assets/terrain/LHD_0907_6440_1m.vchm data/lidar/LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz
|
||
```
|
||
|
||
Résultat sur les deux résolutions :
|
||
|
||
```
|
||
lecture DIRECTE : ecart moyen 0.0000 m, max 0.0000 m
|
||
si les lignes etaient inversees (nord/sud) : ecart moyen 64.3 m
|
||
si les colonnes etaient inversees (est/ouest): ecart moyen 221.1 m
|
||
```
|
||
|
||
C'est le **contraste** qui fait la preuve, pas la valeur absolue.
|
||
|
||
### 4.5 Deux erreurs réellement commises, et attrapées par ce contrôle
|
||
|
||
1. **Arrondi bancaire.** `np.rint` arrondit les ex æquo vers l'entier *pair* : un
|
||
point tombant pile sur la frontière entre deux nœuds partait à gauche ou à
|
||
droite selon la **parité** de l'indice. Les coordonnées LAZ étant quantifiées
|
||
au centimètre, ces ex æquo sont fréquents. Remplacé par `floor(t + 0.5)`.
|
||
|
||
2. **Intervalle inversé sur l'axe nord.** En arrondissant directement
|
||
`(y_max − y)`, le sens de l'intervalle semi-ouvert s'inversait avec le signe :
|
||
`[c−½, c+½[` sur l'axe est, mais `]c−½, c+½]` sur l'axe nord. Deux dalles
|
||
voisines raccordées le long d'une frontière est-ouest se seraient disputé leur
|
||
ligne commune. Le renversement nord-sud se fait désormais **après** l'arrondi,
|
||
sur l'indice entier.
|
||
|
||
Aucune des deux n'était visible à l'écran : elles ne déplaçaient qu'une poignée
|
||
de points sur une dalle isolée. Elles auraient explosé au premier assemblage
|
||
multi-dalles.
|
||
|
||
### 4.6 Le relief casse la visée horizontale — et donc le script de test
|
||
|
||
Symptôme : le scénario C échouait à abattre l'arbre visé, alors que le jeu
|
||
fonctionnait parfaitement.
|
||
|
||
`Forest::pickTree` lance un rayon **horizontal** depuis l'œil (la souris ne peut
|
||
pas être pilotée par messages Win32 — voir l'en-tête de `run_vulkan_check.ps1`),
|
||
et vérifie que le point touché est entre le pied et la cime. Sur le terrain
|
||
synthétique, assez lisse, un arbre à 9 m au nord est toujours dans l'axe : **les
|
||
16 arbres sur 16 sont abattables**. Sur le relief mesuré, un arbre en contrebas
|
||
passe entièrement sous le rayon et un arbre en amont entièrement au-dessus :
|
||
**seuls 6 sur 16 le sont**.
|
||
|
||
Plutôt que de réimplémenter ce raisonnement en PowerShell, `vercora.exe
|
||
--dump-world` interroge la **vraie** fonction de visée du jeu, avec la vraie
|
||
heightmap, pour chaque recul plausible, et émet des lignes
|
||
`AIM <indice> <camX> <camZ> <recul>`. Le script vise le plus proche des arbres
|
||
*réellement* abattables. Ce n'est pas une estimation : c'est la réponse de
|
||
`Forest::pickTree`.
|
||
|
||
C'est un vrai constat de gameplay, pas seulement un problème de test : **sur du
|
||
relief réel, on ne peut abattre qu'un tiers des arbres sans pouvoir viser en
|
||
hauteur.** Le pitch de la caméra existe pourtant — c'est le script qui ne peut
|
||
pas s'en servir. À confirmer manette en main.
|
||
|
||
### 4.7 `dump_world` replié dans le jeu — et Smart App Control
|
||
|
||
`tools/dump_world.cpp` et `tools/build_dump_world.bat` sont **supprimés**. Le dump
|
||
est désormais un mode du jeu :
|
||
|
||
```
|
||
vercora.exe --dump-world # dalle par defaut
|
||
vercora.exe --dump-world terrain # terrain synthetique
|
||
vercora.exe --dump-world chemin\dalle.vchm # une autre dalle
|
||
```
|
||
|
||
Deux raisons, dans cet ordre d'importance :
|
||
|
||
1. **La duplication était un piège.** `dump_world.cpp` *recopiait* la construction
|
||
du monde de `main.cpp` en comptant sur le fait que les deux resteraient dans le
|
||
même ordre — le semis étant déterministe, un ordre différent aurait donné un
|
||
monde différent, et le script aurait visé à côté sans que rien ne le signale.
|
||
Le dump traverse maintenant exactement le code du jeu, par construction.
|
||
|
||
2. **Smart App Control est actif sur cette machine** (`VerifiedAndReputablePolicyState = 1`).
|
||
Il a bloqué à l'exécution le `dump_world.exe` fraîchement recompilé —
|
||
« Une stratégie de contrôle d'application a bloqué ce fichier » — alors que le
|
||
binaire *précédent*, issu des mêmes sources, tournait. Le verdict porte sur
|
||
l'empreinte du fichier : il est donc imprévisible pour tout binaire non signé
|
||
nouvellement produit. Recopier le fichier sous un autre nom ne change rien, et
|
||
attendre 2 minutes non plus. `vercora.exe` et `logic_tests.exe` passent, eux.
|
||
|
||
*Rien n'a été désactivé* : SAC est un réglage de sécurité de la machine. Si le
|
||
problème réapparaît sur un autre binaire, c'est à l'utilisateur de décider
|
||
(Sécurité Windows → Contrôle d'application intelligent). Une raison de plus de
|
||
n'avoir qu'un seul exécutable. À classer avec les autres particularités de
|
||
cette machine (VS corrompu, `rc.exe` bloqué au premier appel), cf.
|
||
NOTES-PHASE6.md.
|
||
|
||
### 4.8 Ordre des opérations dans le pilotage
|
||
|
||
Première version du scénario C : promenade de 30 m dans les quatre directions
|
||
« pour exercer le relief », *puis* abattage. Le trajet traversait le semis
|
||
d'arbres, chaque tronc déviait la caméra de quelques dizaines de centimètres, et
|
||
la position à l'estime n'était plus bonne. Corrigé : **viser d'abord depuis
|
||
l'origine** — la seule position connue exactement — **se promener ensuite**,
|
||
quand la dérive n'a plus d'importance. C'est exactement la leçon que l'en-tête du
|
||
scénario B documentait déjà.
|
||
|
||
---
|
||
|
||
## 5. Vérification
|
||
|
||
### Tests headless — 169 assertions (121 avant)
|
||
|
||
`TerrainFile.cpp` et `TerrainMesh.cpp` ne dépendent ni de Vulkan ni de GLFW : ils
|
||
sont désormais **compilés et liés** dans l'exécutable de test (`TerrainMesh.cpp`
|
||
n'était que vérifié syntaxiquement). Le nouveau bloc couvre :
|
||
|
||
- écriture puis relecture d'un `.vchm` construit octet par octet dans le test,
|
||
avec une grille **asymétrique sur les deux axes** (sans quoi une inversion
|
||
passerait inaperçue) ;
|
||
- résolution, pas, emprise déduite, bornes, label, `heightAt` aux nœuds et en
|
||
milieu de cellule ;
|
||
- `toProjected` aux quatre coins, y compris la règle des signes opposés (aller à
|
||
l'est **augmente** l'abscisse projetée, aller au sud **diminue** l'ordonnée) ;
|
||
- `terrainMeshData` sur la grille chargée : un sommet par échantillon, altitudes
|
||
identiques ;
|
||
- **refus** d'un fichier à magie fausse, version inconnue, grille non carrée, pas
|
||
nul, grille d'un seul échantillon, fichier tronqué, altitude `NaN`, fichier
|
||
absent ;
|
||
- la **vraie dalle** si elle est présente (bloc ignoré sinon) : 1001², pas de 1 m,
|
||
EPSG 2154, dénivelé > 500 m, et surtout `heightAt(0,0) == 605,38 m` — valeur
|
||
relevée indépendamment sur le nuage brut par `check_terrain_file.py`.
|
||
|
||
### Vulkan réel — 3 scénarios
|
||
|
||
| | Scénario A | Scénario B | Scénario C |
|
||
|---|---|---|---|
|
||
| Terrain | synthétique | synthétique | **dalle LiDAR** |
|
||
| Couvre | gameplay complet, resize, minimisation | collision tronc puis souche | 2 M triangles, marche sur relief mesuré, abattage, ramassage, vol libre, 6 resize, minimisation |
|
||
| Résultat | 0 validation, sortie 0 | 0 validation, sortie 0 | 0 validation, sortie 0 |
|
||
|
||
---
|
||
|
||
## Ce qui n'a pas changé
|
||
|
||
- **Le terrain synthétique reste le monde de référence des tests.** Semis
|
||
déterministe, positions connues d'avance, arbres tous abattables : c'est ce qui
|
||
rend les scénarios A et B décisifs. Il n'est pas près d'être supprimé.
|
||
- **Les arbres et les pierres restent procéduraux.** La classification LiDAR
|
||
contient bien la végétation (67 % de la dalle), mais en extraire des arbres
|
||
individuels — segmentation de houppiers — est un sujet à part entière.
|
||
- **`TerrainMesh`, les shaders, `Camera`, `Forest`, `Ground` : aucune
|
||
modification.** `Camera.hpp` n'a reçu qu'une constante nommée
|
||
(`kDefaultEyeHeight`), pour que le dump puisse prédire ce que voit le joueur.
|
||
|
||
## Outils
|
||
|
||
| Script | Rôle |
|
||
|---|---|
|
||
| `tools\build.bat` | configure + compile (Debug par défaut, donc validation layers) |
|
||
| `tools\run_logic_tests.bat` | 169 assertions de comportement, sans GPU |
|
||
| `tools\run_vulkan_check.ps1` | lance le vrai jeu (3 scénarios) et traque les erreurs de validation |
|
||
| `tools\lidar_to_heightmap.py` | dalle `.laz` IGN → heightmap `.vchm` |
|
||
| `tools\check_terrain_file.py` | confronte un `.vchm` au nuage brut (détecte le miroir) |
|
||
| `vercora.exe --dump-world` | imprime le monde semé et les reculs de tir (remplace `tools\dump_world.cpp`) |
|
||
|
||
## Limites assumées
|
||
|
||
- **Grilles carrées uniquement.** `Heightmap` et `TerrainMesh` n'exposent qu'une
|
||
résolution. Une dalle IGN étant un carré de 1 km, ça ne coûte rien aujourd'hui ;
|
||
ça devra tomber au premier assemblage multi-dalles. Un fichier rectangulaire est
|
||
**refusé avec un message explicite**, pas chargé de travers.
|
||
- **Une seule dalle à la fois**, chargée entièrement en mémoire. Pas de streaming,
|
||
pas de LOD, pas de pavage.
|
||
- **Pas de texture.** Le terrain est coloré par altitude et par pente, comme en
|
||
Phase 4. Les UV du maillage sont prêts pour une orthophoto (`data.geopf.fr`
|
||
diffuse la BD ORTHO sur la même emprise).
|
||
- **Le nord est en −Z**, ce qui est correct mais peu intuitif. À garder en tête au
|
||
moment de plaquer la première orthophoto.
|
||
|
||
## Prochaines étapes suggérées
|
||
|
||
1. **Essayer manette en main** — notamment la remarque 4.6 : est-ce que viser en
|
||
hauteur suffit à rendre tous les arbres abattables sur du vrai relief ?
|
||
2. **Orthophoto BD ORTHO** sur la même emprise, plaquée via les UV existants.
|
||
C'est le premier vrai contrôle visuel de l'orientation.
|
||
3. **Assemblage multi-dalles** : supporter les grilles rectangulaires, raccorder
|
||
les bords (les nœuds de bord sont déjà partagés par construction), et décider
|
||
d'une origine monde commune.
|
||
4. **Exploiter la classification** : la classe 5 (végétation haute) donne une
|
||
carte de densité de forêt, de quoi semer les arbres là où il y en a vraiment.
|
||
5. **Choisir la zone du jeu.** Le pipeline est prêt ; n'importe quelle dalle de
|
||
France se charge maintenant en deux commandes.
|