820 lignes
42 KiB
Markdown
820 lignes
42 KiB
Markdown
# Phase 15 (2026-08-23) : éditeur de niveau interne
|
||
|
||
Outil de **développement**, pas de jeu. La consigne demandait explicitement de
|
||
privilégier la complétude et le contrôle sur l'ergonomie : il n'y a donc aucune
|
||
interface graphique, le catalogue est une liste texte dans le journal, et l'état
|
||
courant de l'outil s'affiche sur une ligne de log. En revanche tout ce qui est
|
||
demandé fonctionne de bout en bout — poser, régler, déplacer, supprimer,
|
||
annuler, sauvegarder, recharger — et **les objets posés font partie du monde** :
|
||
une partie normale les charge d'elle-même, les dessine et s'y cogne.
|
||
|
||
Note de numérotation : il n'existe pas de `NOTES-PHASE14.md`. La Phase 14
|
||
(escalade) est documentée dans `NOTES-PHASE-ESCALADE.md`, comme la Phase 13 l'est
|
||
dans `NOTES-PHASE-VELO.md`.
|
||
|
||
---
|
||
|
||
## 1. Ce qui a été livré
|
||
|
||
| Demande de la consigne | État |
|
||
|---|---|
|
||
| Mode éditeur, bascule depuis le jeu | **fait** — touche `F2`, ou `--editor` au lancement |
|
||
| Caméra de vol libre, sans collision ni gravité | **fait** — `CameraMode::Free` verrouillé, vitesse réglable à la molette (2 à 600 m/s) |
|
||
| Catalogue scanné depuis un dossier | **fait** — `assets/editor/`, plus 5 modèles générés en code |
|
||
| Extension d'`ObjLoader` au glTF | **NON FAIT**, documenté en §8 |
|
||
| Liste texte avec sélection au clavier | **fait** — `TAB`, `PAGE_PREC`/`PAGE_SUIV`, rangs `1`..`9` |
|
||
| Fantôme suivant la visée | **fait** — teinté cyan, au point exact où le regard rencontre le sol |
|
||
| Pose au clic, à la position visée | **fait** — clic gauche, ou `INSER` au clavier |
|
||
| Déplacer / pivoter / redimensionner | **fait** — saisie à la visée (`G`), flèches, `DEBUT`/`FIN` |
|
||
| Sélectionner et supprimer | **fait** — `E` puis `SUPPR` |
|
||
| Sérialisation dans un fichier texte | **fait** — format `.vcsc`, §4 |
|
||
| Chargement automatique en jeu normal | **fait** — vérifié sous Vulkan, §7 |
|
||
| Undo | **fait** — pile de 128 actions, regroupement des retouches |
|
||
| Premier lot d'assets de test | **fait** — 5 modèles générés en code + 1 `.obj` témoin |
|
||
| Collision des objets posés | **fait** — cylindre englobant, réglable par objet ; limite en §8 |
|
||
|
||
---
|
||
|
||
## 2. Architecture
|
||
|
||
Nouveau dossier `src/editor/`, plus deux en-têtes ajoutés à `src/core/`.
|
||
|
||
```
|
||
src/core/TerrainRay.hpp intersection rayon / surface du terrain
|
||
src/core/CompositeCollisionSolver.hpp plusieurs sources d'obstacles, un solveur
|
||
src/editor/EditorAssets.{hpp,cpp} les 5 modèles générés en code
|
||
src/editor/AssetCatalog.{hpp,cpp} catalogue : builtins + scan de dossier
|
||
src/editor/PlacedObject.hpp un objet posé (donnée pure)
|
||
src/editor/EditorScene.{hpp,cpp} la liste, la visée, la collision, l'undo
|
||
src/editor/EditorController.{hpp,cpp} la machine à états de l'outil
|
||
src/editor/SceneFile.{hpp,cpp} lecture / écriture du .vcsc
|
||
```
|
||
|
||
**Aucun de ces fichiers ne connaît Vulkan.** C'est le même découpage que celui
|
||
des quatre activités : `Paraglider`, `Bike` et `Climber` ne dépendent que de GLM
|
||
et sont donc *exécutés* dans les tests headless. Ici tout l'éditeur sauf le
|
||
dessin l'est aussi — catalogue, raycast, scène, pile d'annulation, collision,
|
||
format de fichier, et la machine à états complète.
|
||
|
||
### Ce qui rend la machine à états testable
|
||
|
||
`EditorController` **ne lit pas le clavier**. Il reçoit une structure
|
||
`EditorInput` déjà dépouillée par `main.cpp`. Trois raisons, la dernière étant la
|
||
vraie :
|
||
|
||
1. il ne dépend alors ni de GLFW ni de `Window` ;
|
||
2. les touches restent décrites en un seul endroit, à côté de celles du jeu ;
|
||
3. **le harnais automatisé ne peut pas piloter la souris** — GLFW lit le curseur
|
||
*système* et non les messages postés (limite connue depuis la Phase 8). Un
|
||
contrôleur qui lirait lui-même les entrées ne serait donc testable qu'à la
|
||
main.
|
||
|
||
### Les trois cibles de réglage, et leur ordre
|
||
|
||
```
|
||
SAISIE > SÉLECTION > PINCEAU
|
||
```
|
||
|
||
* **Saisie** : un objet décroché suit la visée. **La scène n'est pas modifiée
|
||
tant qu'il est en main** — c'est seulement en le reposant qu'une *unique*
|
||
action annulable est empilée. Sans ça, déplacer un rocher de trente mètres
|
||
empilerait une annulation par image.
|
||
* **Sélection** : les retouches l'atteignent directement, et celles qui
|
||
s'enchaînent à moins de 0,75 s l'une de l'autre sont **regroupées** en une
|
||
seule annulation. Sans ce regroupement, tourner un rocher d'un quart de tour
|
||
laisserait six annulations et « annuler » ne rendrait jamais l'état d'avant la
|
||
manipulation — la seule chose qu'on veuille.
|
||
* **Pinceau** : l'asset armé et *ses* réglages (cap, échelle, hauteur,
|
||
solidité), **conservés d'une pose à l'autre**.
|
||
|
||
### La pose ne sélectionne pas — corrigé après essai sous Vulkan
|
||
|
||
La première version sélectionnait l'objet qu'on venait de poser, par analogie
|
||
avec les éditeurs 3D. Le premier essai réel a montré que c'était le mauvais
|
||
choix **ici** : les réglages visant la sélection en priorité, poser un objet
|
||
détournait silencieusement les flèches du *pinceau* vers l'objet posé. Régler une
|
||
fois puis poser dix blocs alignés — le geste le plus courant de l'outil —
|
||
devenait impossible sans désélectionner entre chaque. Corrigé et figé par test.
|
||
|
||
Dans la foulée, la ligne d'état a été corrigée aussi : elle n'affichait que le
|
||
cap du *pinceau*, donc tourner un objet sélectionné affichait `cap 0 deg` pendant
|
||
que l'objet tournait. Elle décrit maintenant la cible réelle des réglages.
|
||
|
||
Une troisième incohérence, trouvée à la relecture : reposer un objet à la touche
|
||
de saisie écrivait la prévisualisation de l'image **précédente**, alors que le
|
||
reposer au clic écrivait celle de l'image **courante** — deux gestes censés faire
|
||
la même chose n'avaient donc pas exactement le même résultat. Le début de saisie
|
||
et la repose sont maintenant séparés de part et d'autre du calcul de
|
||
prévisualisation, et les deux gestes passent par le même code.
|
||
|
||
Enfin, le mode éditeur se voit dans le **titre de la fenêtre** (`[EDITEUR]`) :
|
||
c'est le seul retour permanent à l'écran, rien dans la vue elle-même ne
|
||
distinguant une caméra d'édition d'un simple vol libre.
|
||
|
||
### Le raycast terrain
|
||
|
||
`Forest::pickTree` (Phase 5) intersecte un rayon avec des **cylindres**, ce qui a
|
||
une solution analytique. La surface du terrain n'est pas une primitive : c'est
|
||
une grille bilinéaire de plusieurs millions de cellules. `core/TerrainRay.hpp`
|
||
marche donc le long du rayon, à **pas croissant** (0,5 m près de l'œil, plafonné
|
||
à 8 m), puis dichotomie sur 24 itérations dès que le signe de
|
||
`hauteurDuRayon − hauteurDuTerrain` s'inverse. Environ 150 échantillons pour
|
||
400 m de portée, une fois par image.
|
||
|
||
Deux points qui comptent :
|
||
|
||
* **L'emprise doit être passée explicitement.** `HeightSampler::heightAt` est
|
||
*totale* par contrat — hors des données elle prolonge le bord. Sans le
|
||
paramètre `halfExtent`, un rayon partant vers l'extérieur accrocherait une
|
||
étagère plate infinie. Vérifié par un test qui compare les deux cas.
|
||
* **Limite assumée** : une marche à pas fini peut *enjamber* une arête plus fine
|
||
que le pas courant (une crête vue de loin et par-dessus). Le remède exact — un
|
||
parcours cellule par cellule façon DDA — exigerait de connaître la grille,
|
||
donc de renoncer à l'interface `HeightSampler`.
|
||
|
||
### La collision : la première fois que l'interface de la Phase 6 sert vraiment
|
||
|
||
Le monde avait jusqu'ici **une seule** source d'obstacles (`Forest`), et
|
||
`Camera::setCollisionSolver` prenait un pointeur unique.
|
||
`CompositeCollisionSolver` implémente le même contrat et le délègue à une liste ;
|
||
les répoussements sont **chaînés** et non moyennés (sortir d'un tronc peut faire
|
||
entrer dans un rocher).
|
||
|
||
**Ni `Camera`, ni `Bike`, ni `Climber` n'ont été modifiés pour ça** — seul
|
||
l'objet qu'on leur passe a changé. C'est exactement ce que l'interface de la
|
||
Phase 6 permettait, et c'est la première fois qu'on s'en sert.
|
||
|
||
---
|
||
|
||
## 3. Le fantôme est teinté, pas transparent
|
||
|
||
Trois états du **même** maillage doivent se distinguer : l'objet posé, le
|
||
fantôme qui suit la visée, l'objet sélectionné. Ils passent tous par le même
|
||
pipeline ; seule une **teinte témoin** poussée en push constant les sépare
|
||
(`params.x` = force, `params.yzw` = couleur, lu par `shaders/cube.frag`).
|
||
|
||
Une teinte plutôt qu'une transparence — pourtant le rendu habituel d'un fantôme —
|
||
parce que le mélange alpha impose de trier les objets par profondeur à chaque
|
||
image. C'est le choix que le projet a déjà fait deux fois pour la même raison :
|
||
la végétation de la Phase 11 fond ses arbres par **rétrécissement**, et l'herbe
|
||
est faite de quads **opaques**. Conséquence : ni second pipeline, ni état de
|
||
blending, ni tri — et **une force nulle laisse le rendu bit à bit identique à
|
||
celui d'avant la Phase 15**, ce qui est ce qui autorisait à toucher au shader du
|
||
matériau `Object` sans risquer les phases précédentes.
|
||
|
||
Cyan pour le fantôme, ambre pour la sélection : deux couleurs qu'aucun asset de
|
||
cette session ne porte (tous gris, bruns ou ocres) et que le terrain ne porte pas
|
||
non plus.
|
||
|
||
---
|
||
|
||
## 4. Le format de scène `.vcsc`
|
||
|
||
Fichier **texte**, une directive par ligne, champs séparés par des espaces,
|
||
commentaires après `#`. Documentation de référence : `src/editor/SceneFile.hpp`.
|
||
|
||
```
|
||
# Vercora scene v1 - genere par l'editeur (Phase 15).
|
||
version 1
|
||
terrain LHD_0907_6440_1m.vchm
|
||
crs 2154
|
||
object rocher 907500.000 6439501.840 0.000 0.000 1.0000 1
|
||
object cairn 907503.500 6439505.000 0.000 0.000 1.0000 1
|
||
```
|
||
|
||
| directive | rôle |
|
||
|---|---|
|
||
| `version <n>` | obligatoire, **en premier**. 1 pour cette session. |
|
||
| `terrain <nom>` | **informatif** : ne sert jamais à refuser un chargement. |
|
||
| `crs <epsg>` | `2154` = les objets portent des coordonnées **projetées** ; `0` = terrain sans référence géographique, coordonnées locales. |
|
||
| `object …` | sept champs : `asset`, `est`, `nord`, `dz`, `cap` (deg), `échelle`, `solide` (0/1). |
|
||
|
||
### Deux décisions qui font tout l'intérêt du format
|
||
|
||
**Coordonnées projetées, pas locales.** Le repère du moteur est *centré sur le
|
||
terrain chargé* : une position locale ne veut rien dire sans savoir quelle
|
||
emprise était chargée. Cette zone existe déjà sous quatre emprises différentes
|
||
(la dalle de Phase 7, la zone de 25 km², chacune à 1 m et à 2 m). Du Lambert 93
|
||
rend la scène indépendante de tout ça : un rocher posé sur la dalle isolée se
|
||
retrouve au même endroit du massif quand on charge la zone entière.
|
||
|
||
**Altitude relative au terrain (`dz`), pas absolue.** Même raisonnement sur la
|
||
verticale. La surface au pas de 2 m n'est pas exactement celle au pas de 1 m, et
|
||
le repli sur l'ancêtre du quadtree (Phase 12) peut afficher une tuile plus
|
||
grossière le temps d'une image. Une altitude absolue ferait flotter ou enterrer
|
||
chaque objet à la moindre variation. `dz = 0` veut dire « posé au sol », et ça
|
||
reste vrai partout. **Test headless dédié** : la même scène rechargée sur le même
|
||
endroit échantillonné à 2 m garde ses objets au sol au demi-centimètre près, et
|
||
l'objet volontairement surélevé de 2,5 m garde ses 2,5 m.
|
||
|
||
### Ce que le format ne stocke pas
|
||
|
||
* **Les identifiants d'objet** : ils sont attribués au chargement. C'est une
|
||
identité de *session* (sélection, annulation), pas une propriété de la scène ;
|
||
la stocker rendrait tout déplacement de ligne visible dans un diff sans rien
|
||
apporter.
|
||
* **La géométrie** : la scène ne contient que des références d'assets. Un fichier
|
||
de scène fait quelques centaines d'octets et se relit à l'œil.
|
||
|
||
### Robustesse
|
||
|
||
Une directive inconnue est **ignorée avec un avertissement** plutôt que fatale :
|
||
un fichier plus récent restera partiellement lisible. Une ligne `object` mal
|
||
formée est **comptée et sautée** — perdre un objet vaut mieux que perdre la
|
||
scène. L'écriture passe par un fichier temporaire renommé à la fin : une coupure
|
||
en pleine sauvegarde ne détruit pas ce qu'on était en train de sauvegarder. La
|
||
lecture et l'écriture forcent la **locale C** — dans une locale française le
|
||
séparateur décimal est la virgule, et `907512.250` se relirait comme `907512`.
|
||
|
||
### Où vivent les fichiers
|
||
|
||
* **Scènes** : `assets/scenes/<terrain sans suffixe de résolution>.vcsc`.
|
||
Même convention que l'orthophoto et pour la même raison : 1 m et 2 m sont deux
|
||
échantillonnages du *même endroit*, ils partagent leur scène.
|
||
* **Modèles** : `assets/editor/`.
|
||
|
||
Les deux sont sous `assets/`, donc **versionnés** (contrairement à `data/`, que
|
||
le `.gitignore` exclut). Une scène composée à la main est du contenu : la perdre
|
||
coûterait le temps de la refaire, alors qu'une heightmap se régénère en quatre
|
||
secondes depuis le `.laz`.
|
||
|
||
`assets/scenes/demo_phase15.vcsc` est **écrite à la main** — c'est ce qui prouve
|
||
que le format est réellement éditable sans lancer le jeu.
|
||
|
||
---
|
||
|
||
## 5. Les touches
|
||
|
||
Le mode éditeur est **exclusif** : tant qu'il est actif, aucune touche de jeu
|
||
n'est lue, et réciproquement. C'est ce qui autorise l'éditeur à reprendre des
|
||
lettres déjà prises (`E` abat un arbre en jeu, sélectionne un objet en édition).
|
||
|
||
À chaque bascule, **tous** les fronts descendants sont resynchronisés
|
||
(`syncAllKeyEdges`) : sans ça, entrer en édition avec `E` enfoncé sélectionnerait
|
||
un objet, et en sortir avec `E` enfoncé abattrait un arbre.
|
||
|
||
| touche | effet |
|
||
|---|---|
|
||
| `F2` | entrer / sortir du mode éditeur |
|
||
| `ZQSD` + `espace` / `maj-gauche` | voler (caméra libre) |
|
||
| molette | vitesse de vol, × ou ÷ 1,25 par cran (2 à 600 m/s) |
|
||
| clic droit maintenu | regarder |
|
||
| **clic gauche** ou `INSER` | poser au point visé / reposer l'objet en main |
|
||
| `E` | sélectionner l'objet visé |
|
||
| `G` | saisir / reposer la sélection |
|
||
| `SUPPR` | supprimer la sélection |
|
||
| `ECHAP` | abandonner la saisie, puis la sélection |
|
||
| `TAB` ou `PAGE_SUIV` / `PAGE_PREC` | asset suivant / précédent (cyclique) |
|
||
| `1`..`9` | rang direct dans la page courante du catalogue |
|
||
| `←` `→` | tourner (90 °/s) |
|
||
| `↑` `↓` | échelle (× 1,8 par seconde, **multiplicative**) |
|
||
| `DEBUT` / `FIN` | monter / descendre par rapport au sol (0,6 m/s) |
|
||
| `K` | solide ↔ traversable |
|
||
| `CTRL gauche` | pas fin (divise les trois vitesses par 8) |
|
||
| `RETOUR ARRIÈRE` | annuler |
|
||
| `F5` | sauvegarder |
|
||
| `F9` | recharger depuis le disque |
|
||
| `L` | réafficher le catalogue |
|
||
|
||
**Choix des touches.** GLFW raisonne en positions physiques façon QWERTY US (note
|
||
clavier de `core/Camera.hpp`). Les touches de réglage sont donc prises parmi
|
||
celles qui occupent la **même position physique** en AZERTY et en QWERTY :
|
||
flèches, pavé de navigation, rangée de fonctions, `Tab`, `Retour arrière`,
|
||
`Échap`, rangée des chiffres. Les seules lettres utilisées — `E`, `G`, `K` —
|
||
sont à la même place sur les deux.
|
||
|
||
**Pourquoi `INSER` en plus du clic** : à l'usage, on règle aux flèches puis on
|
||
pose sans ramener la main sur la souris. Mais surtout, le harnais automatisé ne
|
||
peut piloter que le clavier : sans cette touche, la pose serait la seule fonction
|
||
de l'éditeur qu'aucun test ne pourrait exercer sous Vulkan. Les deux voies
|
||
passent par le même `placePressed`, donc le chemin exercé est bien celui du clic.
|
||
|
||
### Options de ligne de commande
|
||
|
||
```
|
||
vercora.exe [scene] --editor démarre directement en mode édition
|
||
vercora.exe [scene] --scene=chemin.vcsc fichier de scène explicite
|
||
vercora.exe [scene] --no-scene ni catalogue, ni objets, ni éditeur
|
||
vercora.exe [scene] --editor-assets=rep dossier de modèles à scanner
|
||
```
|
||
|
||
`--no-scene` reproduit **exactement** le comportement d'avant la Phase 15 : c'est
|
||
le témoin de toute mesure avant/après.
|
||
|
||
---
|
||
|
||
## 6. Les assets de test
|
||
|
||
Cinq modèles **générés en code**, même parti pris que l'arbre (Phase 5), la
|
||
pierre (Phase 6) et l'herbe (Phase 11) : aucun fichier, aucun téléchargement,
|
||
aucune licence à vérifier.
|
||
|
||
| id | description | hauteur | rayon de collision |
|
||
|---|---|---:|---:|
|
||
| `rocher` | bloc arrondi facetté (octaèdre subdivisé, bruité par hachage) | 1,71 m | 1,47 m |
|
||
| `bloc` | dalle basculée anguleuse, trois boîtes imbriquées | 2,97 m | 1,48 m |
|
||
| `cairn` | quatre pierres empilées | 1,08 m | 0,64 m |
|
||
| `abri` | abri de pierre à deux pentes, **avec porte** | 2,60 m | 2,35 m |
|
||
| `poteau` | poteau de balisage avec plaque | 2,02 m | 0,52 m |
|
||
|
||
Plus `assets/editor/octaedre.obj`, seul asset venant d'un **fichier** : c'est le
|
||
seul qui prouve que ce chemin fonctionne dans une partie réelle.
|
||
|
||
### Le bruit est un hachage, pas un générateur à état
|
||
|
||
Les déformations du rocher sont tirées d'un **hachage de l'indice de sommet** —
|
||
la leçon de la Phase 11 sur le semis de végétation. Un `mt19937` rend une suite
|
||
qui dépend de l'*ordre* des appels ; deux constructions du même mesh dans un
|
||
ordre différent donneraient deux géométries. Ça compte ici parce que l'empreinte
|
||
de **collision** est déduite de la boîte englobante du mesh : une géométrie qui
|
||
varierait donnerait une collision qui varie, et une scène sauvegardée ne se
|
||
rechargerait pas à l'identique. Figé par test (comparaison bit à bit).
|
||
|
||
### Ancrage n'est pas centrage
|
||
|
||
Convention commune : dimensions **absolues** en mètres, **pied à `y = 0`**,
|
||
ancrage horizontal à l'origine.
|
||
|
||
Mais l'ancrage n'est pas forcément le centre de la boîte englobante, et c'est
|
||
délibéré : le poteau de balisage a son **mât** à l'origine, sa plaque débordant
|
||
vers +X. Planter un panneau, c'est planter le mât au point visé, pas y placer le
|
||
milieu de l'ensemble mât + panneau, qui n'existe nulle part physiquement.
|
||
|
||
Un asset **chargé depuis un fichier** ne dit rien de son intention : son origine
|
||
est où l'auteur l'a laissée. Faute de mieux, `normalizeAssetMesh` le **recentre
|
||
de force** sur sa boîte englobante et pose son point le plus bas à zéro. C'est le
|
||
défaut le moins mauvais, pas une règle générale.
|
||
|
||
La propriété que *tous* respectent, et que le test vérifie, est plus faible et
|
||
plus utile : **l'ancrage tombe dans l'empreinte horizontale de l'objet**, et pas
|
||
au bord. Un objet posé entoure donc toujours le point visé.
|
||
|
||
*(Le test initial exigeait un centrage exact et a échoué sur trois assets sur
|
||
cinq. C'est la convention qui était fausse, pas la géométrie.)*
|
||
|
||
### Ordre du catalogue
|
||
|
||
Builtins d'abord, puis les fichiers **triés par nom**. Pas par goût de l'ordre :
|
||
les touches `1`..`9` désignent des rangs dans cette liste, et
|
||
`std::filesystem::directory_iterator` ne garantit aucun ordre — sans le tri, la
|
||
même touche poserait un modèle différent d'une exécution à l'autre.
|
||
|
||
Un fichier illisible est **signalé et sauté**, il n'interrompt pas le scan. Un
|
||
modèle hors des bornes 5 cm – 200 m est signalé (première cause : un `.obj`
|
||
exporté en centimètres) mais reste plaçable.
|
||
|
||
---
|
||
|
||
## 7. Ce qui a été vérifié
|
||
|
||
### Tests headless
|
||
|
||
**650 assertions** (425 avant la Phase 15, **+225**), sans GPU ni Vulkan.
|
||
`tools\run_logic_tests.bat`. Nouveaux blocs :
|
||
|
||
* assets générés — convention d'ancrage, normales unitaires, déterminisme bit à
|
||
bit ;
|
||
* catalogue — builtins, doublons refusés, scan d'un dossier temporaire avec un
|
||
`.obj` valide, un `.obj` cassé et un fichier d'extension inconnue, tri par nom,
|
||
normalisation d'un modèle chargé, dossier absent non fatal ;
|
||
* raycast terrain — distance exacte sur plan (14,142 m à 45°), regard vers le
|
||
ciel, **hors emprise contre emprise non déclarée**, œil sous la surface, pente
|
||
réelle, normale de surface ;
|
||
* scène éditable — suppression au milieu puis annulation **reprenant son
|
||
indice**, regroupement des retouches (20 rotations = 1 annulation), retouches
|
||
espacées = 2 annulations, invariants de `transform()`, renumérotation par
|
||
`replaceAll`, pile bornée qui jette la plus ancienne ;
|
||
* collision — répoussement hors du cylindre, **position repoussée réellement
|
||
libre**, recouvrement vertical, objet traversable, asset absent du catalogue,
|
||
et le **solveur composite** (forêt + éditeur bloquent tous les deux, composite
|
||
vide totalement transparent) ;
|
||
* visée — le plus proche des deux, hors de portée, rayon passant au-dessus ;
|
||
* format `.vcsc` — aller-retour exact, **indépendance vis-à-vis de la
|
||
résolution**, fichier partiellement fautif, en-tête obligatoire, terrain non
|
||
géoréférencé, objets hors emprise conservés mais comptés, convention de chemin,
|
||
aller-retour `toProjected`/`fromProjected` ;
|
||
* contrôleur — fantôme au point visé, viser le ciel ne pose rien, réglages du
|
||
pinceau conservés entre deux poses, pas fin, **saisie n'écrivant pas dans la
|
||
scène** et ne laissant qu'une annulation, sélection puis suppression puis
|
||
annulation, parcours cyclique du catalogue, drapeaux d'E/S consommés une fois,
|
||
`resetInteraction`.
|
||
|
||
### Sous Vulkan, couches de validation actives
|
||
|
||
`tools\run_vulkan_check.ps1` — **scénario G ajouté**, en trois processus :
|
||
|
||
* **G1** — édition : catalogue, trois poses d'assets différents, rotation du
|
||
pinceau, sélection, agrandissement, suppression, annulation, `F5`, `F9`,
|
||
sortie du mode, redimensionnements, fermeture propre.
|
||
* **G2** — partie **normale** (aucun `--editor`) sur le fichier écrit par G1 :
|
||
les objets doivent se charger seuls, être dessinés, et arrêter le joueur.
|
||
* **G3** — **témoin** : exactement la même marche que G2, mais `--no-scene`.
|
||
|
||
C'est l'écart entre G2 et G3 qui fait la preuve, pas la distance de G2 prise
|
||
isolément — sinon « le joueur a avancé de 0,7 m » pourrait tout aussi bien
|
||
vouloir dire qu'il s'est heurté au relief ou qu'il n'a jamais reçu la touche.
|
||
|
||
### L'indépendance vis-à-vis de l'emprise, sur la vraie zone de 25 km²
|
||
|
||
La propriété centrale du format ne vaut que si elle tient sur les vrais fichiers,
|
||
pas seulement sur un terrain de test. `assets/scenes/demo_zone25.vcsc` — six
|
||
objets écrits à la main en Lambert 93 — a été chargée sur
|
||
`vercora_zone_1m.vchm` **et** `vercora_zone_2m.vchm`, même point de vue :
|
||
|
||
| | 1 m | 2 m |
|
||
|---|---|---|
|
||
| objets chargés | 6 (5 solides) | 6 (5 solides) |
|
||
| hors emprise | 0 | 0 |
|
||
| altitude du sol au point de départ | 1781,64 m | 1781,66 m |
|
||
| `[Validation]` | 0 | 0 |
|
||
|
||
Les deux captures (`build\p15_zone_1m.png`, `build\p15_zone_2m.png`) sont
|
||
superposables : mêmes objets aux mêmes positions à l'écran, seul le relief fin
|
||
diffère. Les 2 cm d'écart d'altitude du sol entre les deux échantillonnages sont
|
||
exactement ce contre quoi le `dz` relatif protège — une altitude absolue aurait
|
||
laissé les objets enterrés ou flottants d'autant.
|
||
|
||
Cette scène ne porte **pas** le nom d'auto-chargement (`vercora_zone.vcsc`) : la
|
||
zone de jeu par défaut reste vierge, la scène ne se charge qu'avec `--scene=`.
|
||
|
||
### La mesure de collision
|
||
|
||
Sonde dédiée, trois processus, même binaire, même point de départ, même durée de
|
||
touche maintenue — **seule la présence de la scène change** :
|
||
|
||
| | distance parcourue vers le nord |
|
||
|---|---:|
|
||
| avec un rocher posé devant | **0,69 m** |
|
||
| témoin, sans la scène | **21,17 m** |
|
||
|
||
Et le chiffre est **prédit** : le rocher a été posé à 2,51 m devant le joueur,
|
||
son rayon de collision vaut 1,47 m, celui du corps 0,35 m — donc l'arrêt attendu
|
||
est à 2,51 − 1,82 = **0,69 m**. C'est ce qui distingue « ça a l'air de bloquer »
|
||
de « ça bloque là où le modèle le dit ».
|
||
|
||
### Le défaut que seul le harnais complet a révélé
|
||
|
||
**La première exécution complète du harnais a échoué**, et c'est le seul vrai
|
||
défaut de la session. Le scénario G rapportait **9 objets posés pour 3 touches
|
||
envoyées**, alors que le même scénario joué seul en posait 3, et que rejouer la
|
||
séquence exacte à la main — même touches, même timing — en posait 3 aussi. Ni le
|
||
code ni le rythme n'étaient en cause.
|
||
|
||
**La cause** : la suite complète dure huit minutes, chaque scénario ouvre une
|
||
fenêtre qui prend le focus, et **l'éditeur lit la souris *système***. Les clics
|
||
réels de l'utilisateur, destinés à d'autres fenêtres, atterrissaient dans celle
|
||
du jeu et posaient des objets.
|
||
|
||
C'est *exactement* le problème de la Phase 11 — « le jeu lit le clavier et la
|
||
souris SYSTÈME » — qui avait donné `--lock-input`. Sauf que ce verrou ne couvrait
|
||
que la **caméra** : l'éditeur n'existait pas encore.
|
||
|
||
**La nuance GLFW qui rendait le défaut invisible.** La position du curseur vient
|
||
de `GetCursorPos()` : un `WM_MOUSEMOVE` posté n'a aucun effet, limite connue et
|
||
documentée depuis la Phase 8. Mais **l'état des boutons, lui, est mis en cache
|
||
depuis les messages de fenêtre**. Les boutons sont donc atteignables là où le
|
||
curseur ne l'est pas. Raisonner « la souris ne passe pas » était vrai pour le
|
||
curseur et faux pour les clics.
|
||
|
||
**Reproduit à la demande, puis corrigé, avec contrôle négatif** — trois
|
||
`WM_LBUTTONDOWN` postés dans une fenêtre lancée avec `--lock-input` :
|
||
|
||
| | objets posés |
|
||
|---|---:|
|
||
| avant correction | **3** sur 3 clics |
|
||
| après correction | **0** sur 3 clics |
|
||
|
||
`--lock-input` coupe désormais la pose au clic. **Seulement la souris** : le
|
||
clavier doit rester vivant pour qu'un scénario puisse piloter l'éditeur caméra
|
||
figée — c'est la raison d'être de la touche `INSER`.
|
||
|
||
*Limite qui subsiste* : une vraie frappe clavier de l'utilisateur peut toujours
|
||
perturber un run, exactement comme pour les scénarios A à F. C'est la flakiness
|
||
déjà documentée dans `MEMORY.md`, et elle n'a pas de remède simple tant que le
|
||
jeu lit le clavier système.
|
||
|
||
*Au passage* : le harnais a gagné un paramètre `-Only` (`-Only G`, `-Only A,B`).
|
||
Mettre au point un scénario en payant les six autres à chaque essai décourage de
|
||
le faire correctement. Un scénario non joué est **ignoré, pas validé** ; un run
|
||
de référence se fait toujours sans `-Only`.
|
||
|
||
### Contrôle d'image
|
||
|
||
Trois captures (`tools\shot_editor.ps1`, nouveau) : un journal ne peut pas dire
|
||
si la teinte témoin s'applique — les trois états passent par le même mesh et le
|
||
même pipeline. Il faut regarder l'image. Même raison qui avait motivé
|
||
`screenshot_scene.ps1` en Phase 10.
|
||
|
||
* `build\p15_avec_objets.png` — les huit objets de la scène de démonstration
|
||
dessinés dans une partie **normale** (13,5 % de ciel contre 20,0 % pour le
|
||
témoin `--no-scene` : ils occultent réellement).
|
||
* `build\p15_editeur.png` — vol libre au-dessus de la scène, `[EDITEUR]` dans le
|
||
titre de la fenêtre.
|
||
* `build\p15_editeur_fantome.png` — le fantôme en **cyan**, posé au point exact
|
||
où le regard rencontre le sol.
|
||
* `build\p15_editeur_selection.png` — l'abri en **ambre** : la teinte de
|
||
sélection s'applique bien, et se distingue sans ambiguïté de celle du fantôme.
|
||
* `build\p15_zone_1m.png` / `build\p15_zone_2m.png` — la scène de contrôle sur
|
||
la zone de 25 km², aux deux résolutions (voir juste au-dessus).
|
||
|
||
### Non-régression
|
||
|
||
Voir §11 pour le relevé du run de référence et la liste des fichiers de phases
|
||
précédentes touchés.
|
||
|
||
---
|
||
|
||
## 8. Ce qui reste à améliorer
|
||
|
||
### 1. glTF — **non fait**, et c'est la principale limite de la session
|
||
|
||
`AssetCatalog::supportedExtensions()` ne connaît que `.obj`.
|
||
|
||
**Pourquoi** : un loader glTF 2.0 honnête demande un analyseur JSON, la gestion
|
||
du conteneur binaire `.glb` et des `.bin` externes, le décodage des accesseurs
|
||
(types de composants, entrelacement, `byteStride`), les modes de primitive, et
|
||
l'aplatissement de la hiérarchie de nœuds avec leurs transformations. C'est de
|
||
l'ordre de 600 à 800 lignes neuves — une session à part entière, et une session
|
||
dont le risque est réel alors que la consigne exigeait par ailleurs zéro erreur
|
||
de validation et une non-régression complète. Le choix a été de livrer l'éditeur
|
||
**complet** plutôt que l'éditeur et un loader à moitié.
|
||
|
||
**Ce que ça coûte** : les bibliothèques d'assets libres de droits distribuent
|
||
majoritairement du glTF. En pratique il faut aujourd'hui convertir en `.obj`
|
||
(Blender, `assimp`) avant de déposer dans `assets/editor/`.
|
||
|
||
**Où l'ajouter** : `supportedExtensions()` est le seul point d'extension. Le
|
||
reste de la chaîne — normalisation d'ancrage, empreinte de collision, catalogue,
|
||
placement, sérialisation — est déjà agnostique et n'aura pas une ligne à changer.
|
||
C'est le premier chantier à reprendre.
|
||
|
||
### 2. Collision par cylindre englobant
|
||
|
||
Exacte pour un rocher ou un cairn — ce que l'éditeur sert d'abord à poser — et
|
||
**fausse pour tout objet à intérieur** : l'abri de pierre a une porte, mais son
|
||
cylindre est plein, donc on ne peut pas y entrer. Le remède immédiat est le
|
||
drapeau par objet (`K` : traversable). La vraie réponse — collision par volumes
|
||
composés, ou par maillage — est un chantier à part.
|
||
|
||
Le cylindre est **contenant** et non inscrit (rayon = demi-diagonale
|
||
horizontale) : un obstacle un peu trop gros se contourne, un obstacle trop petit
|
||
se traverse par les coins, et traverser un rocher est bien plus visible que le
|
||
raser d'un demi-mètre.
|
||
|
||
### 3. Aucun frustum culling sur les objets posés
|
||
|
||
Un `DrawItem` par objet, à chaque image, qu'il soit visible ou non. Le culling de
|
||
la Phase 10 vit dans le quadtree du terrain, celui de la Phase 11 dans la
|
||
végétation instanciée ; aucun des deux ne s'applique ici. Sans conséquence à
|
||
l'échelle d'une scène d'éditeur (des dizaines d'objets), à reprendre le jour où
|
||
une scène en comptera des milliers. Le `Frustum` existe déjà et se brancherait en
|
||
quelques lignes.
|
||
|
||
### 4. Le catalogue est figé au démarrage
|
||
|
||
Déposer un `.obj` dans `assets/editor/` demande de relancer le jeu. Un rescan à
|
||
chaud serait facile côté catalogue, mais suppose de téléverser de nouvelles
|
||
géométries en cours de partie.
|
||
|
||
### 5. Pas de sauvegarde automatique
|
||
|
||
`F5` est explicite, et sortir du mode éditeur ne sauvegarde pas — le message de
|
||
sortie le rappelle. C'est volontaire (rien n'est écrit sans qu'on le demande),
|
||
mais un travail long peut être perdu à la fermeture.
|
||
|
||
### 6. Aucune aide au placement
|
||
|
||
Ni grille, ni magnétisme, ni alignement sur la normale du terrain : un objet posé
|
||
sur une forte pente reste vertical et flotte d'un côté. `terrainNormalAt()` est
|
||
déjà écrit et testé dans `core/TerrainRay.hpp` — il ne manque qu'une décision de
|
||
conception (un rocher épouse la pente, un poteau reste vertical), qui demande de
|
||
porter cette information dans l'asset.
|
||
|
||
### 7. Pas de rotation libre ni d'échelle non uniforme
|
||
|
||
Contrainte du contrat de `DrawItem` : le vertex shader utilise `mat3(model)`
|
||
comme normal matrix, ce qui n'est exact que pour une rotation suivie d'une
|
||
échelle **uniforme**. Autoriser plus imposerait de calculer et de pousser une
|
||
vraie normal matrix — possible (il reste 48 octets de push constant), non fait.
|
||
|
||
### 8. Pas de sélection multiple, pas de copier-coller
|
||
|
||
Une seule sélection à la fois. Poser dix rochers alignés se fait à la main.
|
||
|
||
### 9. Les objets posés n'interagissent avec rien
|
||
|
||
Ils bloquent, et c'est tout : pas d'abattage, pas de ramassage, pas d'ombre
|
||
portée (limite ouverte depuis la Phase 11), et l'éditeur ne peut ni déplacer ni
|
||
supprimer les arbres de `Forest` ou les pierres de `Ground`, qui restent semés
|
||
proceduralement.
|
||
|
||
### 10. Rien n'empêche d'empiler deux objets au même endroit
|
||
|
||
Voulu (on peut vouloir un tas), mais aucun signal ne prévient qu'on vient de
|
||
poser un rocher dans un autre.
|
||
|
||
---
|
||
|
||
## 9. Ce qu'il faudrait pour une version destinée aux joueurs
|
||
|
||
Cette session a délibérément écarté l'ergonomie. Si l'éditeur devait un jour
|
||
sortir du domaine du développeur, voici ce qui manque — classé par ce qui bloque
|
||
le plus, pas par difficulté.
|
||
|
||
1. **Tout le retour d'information passe par le journal.** L'état de l'outil,
|
||
le catalogue, les messages d'erreur : rien n'est à l'écran sauf `[EDITEUR]`
|
||
dans le titre. Un joueur ne lit pas une console. Il faut au minimum un
|
||
affichage tête haute : l'asset armé, ses réglages, la sélection, et le
|
||
réticule — **il n'y a même pas de réticule dessiné aujourd'hui**, on vise le
|
||
centre de l'écran sans repère.
|
||
2. **Le catalogue est une liste texte.** Il faudrait des vignettes, une
|
||
recherche, et des catégories dès que le dossier dépasse une dizaine de
|
||
modèles. Les touches `1`..`9` ne passent pas à l'échelle.
|
||
3. **Aucune confirmation, aucune protection.** `SUPPR` supprime sans demander
|
||
(l'annulation existe, mais il faut savoir qu'elle existe), et quitter sans
|
||
`F5` perd tout en silence.
|
||
4. **Les gizmos 3D manquent vraiment.** Régler au clavier convient à qui connaît
|
||
les touches ; poser une passerelle entre deux rochers à la flèche et à l'œil
|
||
est pénible. C'est le point où l'écart avec un vrai éditeur se creuse le plus.
|
||
5. **Rien n'est rebindable**, et la liste des touches n'est visible qu'une fois,
|
||
au moment d'entrer dans le mode.
|
||
6. **Aucune notion de projet ni de calques** : une seule scène par terrain, pas
|
||
de groupes, pas de nommage d'objets, pas de sélection multiple.
|
||
7. **Le format de scène n'a pas de garde-fou de version côté écriture** : un
|
||
exécutable ancien relisant un fichier plus récent perd silencieusement les
|
||
champs qu'il ne connaît pas dès la prochaine sauvegarde. Acceptable entre
|
||
développeur et lui-même, pas pour du contenu de joueur.
|
||
|
||
## 10. Ce qui n'a pas pu être vérifié
|
||
|
||
* **Le comportement de la souris en usage réel.** Le harnais ne peut pas piloter
|
||
le curseur ; la pose au clic, la molette de vitesse de vol et la rotation au
|
||
clic droit n'ont donc été exercées qu'à la main. Le *chemin de code* de la
|
||
pose, lui, est couvert : le clic et la touche `INSER` aboutissent au même
|
||
`placePressed`.
|
||
* **Un vrai fichier glTF** — le loader n'existe pas.
|
||
* **Un `.obj` volumineux ou exotique** : le catalogue n'a été scanné qu'avec des
|
||
modèles minuscules (un tétraèdre en test, un octaèdre en jeu). Les
|
||
avertissements d'unités suspectes ne sont exercés que par le test headless.
|
||
* **Une scène de plusieurs centaines d'objets** : ni les performances de dessin
|
||
(un `DrawItem` par objet), ni celles de la collision (balayage linéaire de tous
|
||
les objets à chaque déplacement) n'ont été mesurées au-delà de la dizaine.
|
||
Les deux sont linéaires et devront être indexées le jour où ça comptera.
|
||
|
||
## 11. Non-régression
|
||
|
||
### Run de référence, suite complète
|
||
|
||
`tools\run_vulkan_check.ps1` sans `-Only`, sur le binaire livré :
|
||
|
||
```
|
||
Code de sortie A..G : 0 / 0 / 0 / 0 / 0 / 0 / 0/0/0
|
||
Lignes de log : 2472
|
||
Messages [Validation] : 0
|
||
Lignes [ERROR] : 0
|
||
Lignes [WARN] : 0
|
||
Fermeture propre A..G : True x9
|
||
```
|
||
|
||
Les six scénarios antérieurs sont inchangés et verts : 2 arbres abattus, 3
|
||
débitages, 7 objets ramassés des quatre natures, 1 percussion, vol de parapente
|
||
avec atterrissage naturel, sortie à vélo (50,0 km/h au pic en descente, 5,4 km/h
|
||
de moyenne en montée sur 20 relevés en mouvement, 96,9 m de dénivelé suivi),
|
||
escalade (sommet à 41,6 m avec 14 % de jauge, 75 relevés).
|
||
|
||
**650 assertions headless** (425 avant, **+225**), zéro avertissement de
|
||
compilation en `/W4`.
|
||
|
||
### Sur la flakiness
|
||
|
||
Trois exécutions complètes ont été nécessaires. La première a échoué sur le
|
||
défaut souris décrit en §7 — un vrai défaut, corrigé. La deuxième a échoué sur le
|
||
**scénario F**, rejoué seul immédiatement après et vert (41,5 m, sommet atteint,
|
||
0 validation) : c'est la flakiness `PostMessage` déjà documentée dans
|
||
`MEMORY.md`, et non une régression. La troisième est le run de référence
|
||
ci-dessus.
|
||
|
||
### Fichiers de phases précédentes touchés, et pourquoi :
|
||
|
||
| fichier | modification |
|
||
|---|---|
|
||
| `src/core/Camera.hpp/.cpp` | `setModeLocked()` (2 lignes dans `update`), `moveSpeed()` |
|
||
| `src/core/Window.hpp/.cpp` | accumulateur de molette (`consumeScroll`) |
|
||
| `src/assets/Heightmap.hpp/.cpp` | `fromProjected()`, l'inverse de `toProjected()` |
|
||
| `src/renderer/DrawItem.hpp` | documentation de `params` par matériau |
|
||
| `shaders/cube.vert/.frag` | teinte témoin — **inerte à force nulle** |
|
||
| `src/main.cpp` | câblage du mode éditeur, solveur composite, position dans le journal |
|
||
|
||
`Heightmap::fromProjected` mérite un mot : la formule **existait déjà**, recopiée
|
||
à la main dans `main.cpp` pour l'option `--start` de la Phase 11, et l'éditeur en
|
||
avait besoin une troisième fois. Deux copies d'une convention d'axes dont une
|
||
seule serait corrigée le jour où elle changerait — exactement le piège que le
|
||
commentaire de `toProjected` décrivait. La conversion vit désormais dans les deux
|
||
sens au même endroit, et `main.cpp` l'utilise.
|
||
|
||
Le changement de shader est le seul qui touche le rendu. Il est **inerte** pour
|
||
tout `DrawItem` dont `params.x` vaut zéro, c'est-à-dire pour tout le jeu : la
|
||
branche n'est même pas prise.
|
||
|
||
---
|
||
|
||
## 12. Suite de session (2026-08-23) : sélection au clavier sans viser (F3/F4)
|
||
|
||
Reprise après vérification que la session initiale tenait toujours : build
|
||
propre, **650/650** assertions headless, puis `run_vulkan_check.ps1` complet -
|
||
zéro validation, six scénarios antérieurs verts, scénario G vert. Une seule
|
||
anomalie, le **scénario F** en échec sur la fermeture propre ; rejoué seul
|
||
immédiatement après (`-Only F`), il passe (sommet atteint, 41,1 m de dénivelé,
|
||
0 validation) - c'est la flakiness `PostMessage` déjà documentée dans
|
||
`MEMORY.md` pour les scénarios A/B/F, pas une régression.
|
||
|
||
### Le choix : ergonomie clavier, pas glTF
|
||
|
||
La consigne proposait trois pistes : l'annulation (déjà livrée en §1), le glTF,
|
||
ou l'ergonomie clavier. Le glTF reste **la plus grosse limite documentée**
|
||
(§8.1), mais c'est précisément pour ça qu'il a été écarté ici : la session
|
||
initiale l'a chiffré à 600-800 lignes neuves (analyseur JSON, conteneur
|
||
binaire `.glb`, décodage d'accesseurs, aplatissement de hiérarchie de nœuds) et
|
||
a choisi explicitement de livrer un éditeur **complet** plutôt qu'un éditeur et
|
||
un loader à moitié, alors que la consigne exige **zéro erreur de validation et
|
||
une non-régression complète**. Retenter ce chantier dans une passe de suite de
|
||
session, sans le temps d'un loader testé aussi rigoureusement que le reste de
|
||
l'éditeur, aurait repris exactement le risque que ce choix initial évitait -
|
||
sans même gagner en confort d'usage tant qu'aucune bibliothèque de modèles
|
||
`.gltf` n'est effectivement déposée dans `assets/editor/`.
|
||
|
||
L'ergonomie clavier, elle, correspond à une lacune concrète et déjà nommée en
|
||
§9.4 : *"il n'y a même pas de réticule dessiné aujourd'hui"* et, plus large,
|
||
l'absence de toute aide à la manipulation en dehors des flèches et de la
|
||
visée. Un défaut precis et bien scope s'en degage : **`pickPressed` (touche
|
||
E) exige que la visée touche l'objet.** Retrouver un objet posé loin du regard
|
||
courant n'a donc qu'une voie - revenir dessus à la souris/au vol - ce qui va
|
||
à l'encontre de l'esprit "outil clavier" documenté en §5. C'est un changement
|
||
petit, testable intégralement en headless, et sans surface de régression sur
|
||
le rendu ou la synchronisation GPU (aucun shader, aucun DrawItem touché).
|
||
|
||
### Ce qui a été ajouté
|
||
|
||
`EditorInput::cycleNextPressed` / `cyclePrevPressed` (nouveaux champs, faux par
|
||
défaut - **aucun code existant n'est affecté tant qu'ils ne sont pas levés**).
|
||
`EditorController::update` les traite juste avant le bloc de saisie, avec la
|
||
même garde que `pickPressed` : ignorés pendant qu'un objet est en main, sinon
|
||
on changerait la cible des réglages **sous** l'objet suivi par la visée.
|
||
|
||
- Rien sélectionné + "suivant" -> premier objet de la scène (ordre
|
||
d'insertion, celui que `EditorScene::objects()` expose) ; "précédent" ->
|
||
dernier. Même convention que `selectBrush(-1)` depuis le rang 0.
|
||
- Un objet sélectionné + "suivant"/"précédent" -> avance/recule d'un rang,
|
||
**cyclique** dans les deux sens (modulo positif, comme le parcours du
|
||
catalogue).
|
||
- Scène vide -> aucune sélection, message journalisé, pas d'erreur.
|
||
|
||
Touches choisies : **F3** (suivant) / **F4** (précédent) - libres, adjacentes
|
||
à F2 (bascule éditeur) et F5 (sauvegarde) déjà pris, et **physiquement
|
||
identiques en AZERTY et QWERTY** (rangée de fonctions), donc conformes à la
|
||
convention de touches posée en §5. Ligne d'aide (`kEditorHelp`, journalisée à
|
||
l'entrée en mode éditeur) mise à jour en conséquence.
|
||
|
||
### Vérifié
|
||
|
||
- **9 nouvelles assertions headless** (650 -> **659**) dans
|
||
`tests/logic_tests.cpp`, section *"Cycle F3/F4 parmi les objets posés"* :
|
||
parcours dans les deux sens, bouclage aux deux extrémités, scène vide,
|
||
et surtout **le cas qui aurait pu casser silencieusement** - le cycle est
|
||
bien ignoré pendant une saisie, et la saisie en cours n'est pas interrompue.
|
||
- **Sous Vulkan réel**, `tools\run_vulkan_check.ps1` (scénario G1) envoie
|
||
désormais deux `F3` puis un `F4` par `PostMessage` (le harnais ne pilote que
|
||
le clavier, voir §5) avant de reviser l'objet **par la visée** pour ne pas
|
||
changer quel objet la suite du scénario supprime. Une mesure dédiée compte
|
||
les lignes de journal `[F3/F4]` et **exige exactement 3** (une par touche
|
||
envoyée) dans le critère de réussite du scénario G - un défaut de front
|
||
descendant (touche perdue, ou comptée deux fois) ferait donc échouer le run
|
||
plutôt que de passer inaperçu.
|
||
- Run cible (`-Only G`) : **`Cycle sans viser (F3/F4) : 3 selection(s)`**,
|
||
0 `[Validation]`, fermeture propre des trois processus G1/G2/G3, mêmes
|
||
compte d'objets et même distance de collision (0,27-0,28 m) qu'avant ce
|
||
changement - la modification du scénario ne perturbe pas les mesures qui
|
||
suivent.
|
||
- Run complet (`run_vulkan_check.ps1`, sans `-Only`) : voir le relevé de
|
||
référence en tête de cette section.
|
||
|
||
### Fichiers touchés
|
||
|
||
| fichier | modification |
|
||
|---|---|
|
||
| `src/editor/EditorController.hpp` | deux champs `EditorInput` |
|
||
| `src/editor/EditorController.cpp` | bloc de cycle, avant la saisie |
|
||
| `src/main.cpp` | deux touches F3/F4, deux `KeyEdge`, aide journalisée |
|
||
| `tests/logic_tests.cpp` | 9 assertions nouvelles |
|
||
| `tools/run_vulkan_check.ps1` | scénario G1 exerce F3/F4, mesure et gate dédiés |
|
||
|
||
Aucun fichier de rendu (shaders, `Renderer`, `DrawItem`) n'est touché : ce
|
||
changement ne modifie que la machine à états de l'éditeur et l'entrée
|
||
clavier, jamais ce qui se dessine.
|
||
|
||
### Ce que ça ne résout pas
|
||
|
||
Le réticule manquant (§9.1), les gizmos 3D (§9.4) et le glTF (§8.1) restent
|
||
entiers. Cette passe referme UNE lacune d'ergonomie clavier précisément
|
||
scopée ; les autres limites listées en §8 et §9 sont inchangées.
|