hmi Namespace Reference

Classes
class	AudioEngine
	Lecture d'échantillons courts à faible latence, avec volume global et repli muet. More...
class	SoundCatalog
	Catalogue des sons : nom d'événement → fichier (relatif à Source/Elements/Audio/). More...
struct	SoundCatalogResult
	Résultat d'une lecture de catalogue : soit un SoundCatalog, soit une erreur décrite. More...
class	AssetFileOperations
	Opérations sur les fichiers d'un dossier d'assets, sans dépendance Qt/GPU. More...
struct	AssetReference
	Une référence nommée à un asset : dans quel jeu de skins, pour quel type de tuile. More...
class	AssetThumbnailView
	Grille de vignettes d'un dossier d'assets, avec recherche, sélection et gestion des fichiers (importer/renommer/dupliquer/supprimer). More...
class	EditContextTarget
	Interface pure implémentée par le contexte d'édition actif. More...
struct	LevelStatusInfo
	État affiché pour un niveau en cours d'édition (barre d'état, EX-EDIT-013/EX-EDIT-012). More...
struct	PlaneEditStatusInfo
	Ce qu'un plan pictural ajoute à la barre d'état, quand le canevas en peint un (EX-EDIT-046, EX-NFR-043, LOT-69 TACHE-08). More...
struct	PixelEditStatusInfo
	État affiché pour un asset en cours d'édition dans l'atelier pixel art (barre d'état, LOT-54 TACHE-04, EX-IHM-060). More...
struct	EditorStatusContext
	Contexte d'édition dont la barre d'état décide l'affichage. More...
struct	EditorStatusLines
	Lignes à afficher pour la barre d'état de l'éditeur, à un instant donné. More...
struct	FileOperationResult
	Succès (avec le chemin résultant) ou échec (avec un message lisible). More...
class	LevelBrowserPanel
	Panneau de gestion des niveaux : liste filtrable + créer/renommer/dupliquer/supprimer. More...
class	LevelFileOperations
	Opérations sur les fichiers de niveaux d'un dossier, sans dépendance Qt/GPU. More...
struct	LinkSegment
	Segment reliant le centre d'un déclencheur au centre de sa cible, en unités monde. More...
struct	ArrowHead
	Les deux ailes de la pointe d'une flèche, à son extrémité. More...
struct	LinkRow
	Une ligne du panneau « Liens » (ou une entrée à dessiner dans le viewport). More...
struct	PendingLink
	Case en attente d'appariement (premier clic de l'outil « Lien »), avec son type courant. More...
struct	LinkGestureDecision
	Décision résultant de resolveLinkClick : action à appliquer et paramètres associés. More...
class	LinkPanel
	Vue tabulaire des liaisons (Mechanism) du brouillon courant (EX-IHM-031). More...
struct	MechanismAnimationRow
	Une ligne de la section « Animations » : une famille de mécanisme, l'asset qui lui sert d'apparence par défaut, et le diagnostic de clips manquants pour cet asset. More...
struct	PaletteThumbnail
	Vignette à afficher pour un type de tuile : d'où la lire, et quelle région y prendre. More...
class	PalettePanel
	Palette de tuiles en arbre (QTreeView) : catégories → sous-groupes → tuiles. More...
struct	PanelFocusEntry
	Une entrée de la table : l'outil tool met en avant le panneau panel. More...
struct	PixelPanelFocusEntry
	Une entrée de la table équivalente pour les outils du canevas pixel art (LOT-54 TACHE-04) : l'outil tool met en avant le panneau panel. More...
class	PixelCanvas
	Widget affichant l'image en cours d'édition et transformant les gestes de souris en appels aux opérations pures de hmi::PixelOperations (TACHE-02). More...
struct	PixelCanvasView
	État de la vue du canevas : zoom entier et décalage de défilement, en pixels image. More...
struct	PixelScreenRect
	Rectangle écran (pixels logiques, relatifs au coin haut-gauche du widget) d'un pixel image. More...
struct	PixelCanvasRealSize
	Taille en pixels réels de l'image entière affichée (largeur/hauteur image × zoom, à l'échelle d'affichage réelle). More...
struct	PixelHistoryEntry
	Une entrée d'historique : la région affectée, son contenu avant et après l'opération. More...
class	PixelHistory
	Pile d'annulation/rétablissement nommée d'un canevas pixel art. More...
class	PixelHistoryPanel
	Liste ordonnée des opérations nommées de l'historique du canevas pixel art actif. More...
struct	PixelRegion
	Rectangle de pixels modifié par une opération (bornes incluses). More...
struct	PixelClipboard
	Contenu copié depuis un tampon (presse-papiers de l'atelier, LOT-54 TACHE-06). More...
struct	PixelPaletteEntry
	Une entrée nommée de la palette de projet. More...
class	PixelPalette
	Palette de couleurs nommées du projet, lue/écrite dans Assets/palettes.json. More...
struct	PixelPaletteExtractionEntry
	Une couleur extraite, avec son nombre d'occurrences dans l'image. More...
class	PixelPalettePanel
	Liste éditable de la palette de projet (hmi::PixelPalette), avec le réglage « contraindre à la palette ». More...
struct	PlanePixelSize
	Dimensions, en pixels, du PNG d'un plan. More...
struct	PlaneLayer
	Un plan à aplatir sous (ou sur) celui qu'on peint. More...
class	PlanesPanel
	Liste ordonnée des plans d'un niveau, avec leurs réglages. More...
struct	SkinRow
	Une ligne du panneau : un type de tuile et l'apparence qui lui est assignée, s'il y en a une. More...
struct	SkinSection
	Un groupe de lignes, correspondant à une catégorie de la palette. More...
struct	TextureAssignDecision
	Décision résultant de resolveTextureAssignClick. More...
class	TexturePanel
	Panneau d'habillage, organisé en sections extensibles (EX-EDIT-042, EX-EDIT-024). More...
struct	TileEntry
	Une tuile sélectionnable : son type et son libellé affiché. More...
struct	TileSubgroup
	Un sous-groupe : une famille de variantes (formes/tailles/orientations) sous une catégorie. More...
struct	TileCategory
	Une catégorie de premier niveau : ses tuiles directes + ses sous-groupes repliables. More...
class	CombatMode
	Le second mode de jeu : le combat se déroule sur la carte d'exploration, mais l'exploration, elle, ne tourne plus. More...
class	FrameRateAverage
	Moyenne glissante de la cadence de rendu, sur une fenêtre courte. More...
struct	DiagnosticsMeasurements
	Valeurs mesurées pour une image de diagnostic (LOT-62 TACHE-02). More...
class	ExplorationMode
	Le mode par défaut : le personnage parcourt la carte, les mécanismes répondent, la caméra suit, l'issue du niveau est évaluée à chaque pas. More...
struct	MechanismEventState
	État « porte ouverte » de chaque mécanisme, même index que core::MechanismController::mechanisms(). More...
class	GameSession
	Simule et rend un seul niveau (déjà validé, en mémoire), indépendamment de toute infrastructure d'écran. More...
class	GameViewport
	Widget de rendu (QRhiWidget) où la scène est dessinée, composé avec le reste de l'interface. More...
class	GameViewportItem
	Surface QRhi du jeu, composée avec le reste de l'interface QML. More...
class	IGameModePasses
	Les passes d'un pas fixe, telles que l'orchestrateur les offre à un mode de jeu. More...
class	IGameMode
	Un mode de jeu : l'ordre dans lequel les passes d'un pas fixe s'enchaînent. More...
struct	AnimationDescription
	Description d'animation d'un asset : disposition de sa spritesheet et ses clips. More...
struct	AnimationDescriptionResult
	Résultat d'une lecture de description : soit une AnimationDescription, soit une erreur décrite. More...
class	AnimationCatalog
	Lecture, validation et traduction en région de texture du format nom-asset.anim.json. More...
struct	AssetDimensionContract
	Dimensions attendues d'une famille d'assets. More...
struct	AssetValidation
	Verdict de validation d'un asset, avec son message exploitable. More...
class	AssetPaths
	Résout des noms d'assets logiques vers des chemins de fichiers, dans un dossier donné. More...
struct	BackgroundFit
	Recadrage UV d'un fond, calculé pour préserver son ratio d'aspect (LOT-44). More...
struct	BackgroundTexture
	Texture de fond déjà résolue, prête à être composée. More...
class	BitmapFont
	Police bitmap chargée depuis Assets/Fonts/, avec repli procédural (EX-NFR-040). More...
class	CacheRegistry
	Mémoïsation par clé logique : charge au premier accès, retient aussi un échec, et s'invalide par clé ou entièrement. More...
struct	ScreenShakeState
	État déterministe d'une secousse d'écran en cours de décroissance vers zéro. More...
class	Camera2D
	Caméra 2D orthographique : projette le monde vers l'écran pour le rendu. More...
struct	ComposedQuad
	Une primitive prête à soumettre, avec tout ce qui détermine quand la dessiner. More...
struct	SceneStatistics
	Compteurs d'une image composée, pour l'observabilité du volume soumis (EX-NFR-005). More...
class	ComposedScene
	Liste ordonnée des primitives d'une image, indépendante de Direct3D. More...
struct	LinkOverlayState
	État d'affichage des liens de mécanismes (LOT-37), fourni par le viewport à chaque rendu. More...
class	DraftRenderer
	Dessine la grille d'un core::LevelDraft en cours d'édition. More...
struct	FollowCameraState
	État déterministe de la caméra de suivi, avancé une fois par pas fixe. More...
class	LayerVisibility
	Jeu de visibilités par calque, pour le mode d'inspection « définition des textures » (LOT-51). More...
struct	MechanismVisualState
	État de présentation d'un mécanisme animé, par instance (LOT-47 TACHE-02). More...
class	PlaneVisibility
	Jeu de visibilités des plans picturaux d'un niveau, adressé par rang. More...
struct	PlaneTexture
	Texture d'un plan déjà résolue, prête à être composée. More...
struct	PlaneParallax
	Cadrage courant et échelle, pour le décalage de parallaxe des plans (EX-DEC-043). More...
struct	PlayerSpriteQuad
	Position et taille du quad d'affichage du personnage, en unités monde, relatives au coin haut-gauche de sa hitbox (Transform::position). More...
struct	PlayerSpriteTag
	Apparence du personnage en RenderMode::Texture, résolue chaque image (GameSession::refreshPlayerSprite) — même patron que hmi::TileSkinTag pour les tuiles : le composant restitue côté présentation ce que core::Sprite/core::Transform (partagés avec la physique) ne peuvent pas porter sans coupler simulation et rendu. More...
struct	PreviousPosition
	Position d'une entité au pas de simulation précédent, pour l'interpolation de rendu (EX-ARCH-031). More...
struct	ProceduralAtlasImage
	Pixels d'un atlas généré en mémoire, au format R8G8B8A8_UNORM (ordre mémoire R,G,B,A). More...
struct	GlyphMetrics
	Position, taille et avance horizontale d'un glyphe dans l'atlas de police, en pixels. More...
struct	FontMetrics
	Métriques d'une police bitmap : région et avance de chaque point de code couvert. More...
struct	TextExtent
	Dimensions mesurées d'un texte, en pixels (à l'échelle demandée). More...
struct	ProceduralFontImage
	Pixels d'un atlas de police généré en mémoire, au format R8G8B8A8_UNORM (ordre mémoire R,G,B,A), ligne par ligne (haut en bas). More...
struct	ProceduralFont
	Atlas de police procédural complet : ses pixels et les métriques qui les décrivent. More...
struct	FontMetricsResult
	Résultat d'une lecture de métriques : soit des FontMetrics, soit une erreur décrite. More...
struct	SpriteQuad
	Un quad texturé à dessiner : rectangle en unités monde, région de texture (coordonnées normalisées) et teinte. More...
struct	LineQuad
	Un segment épais à dessiner : deux extrémités en unités monde, une épaisseur (perpendiculaire au segment, unités monde) et une teinte. More...
class	QuadRecorder
	Capture la liste des primitives d'une image et répond aux questions qu'un test se pose. More...
struct	RenderLayerTag
	Composant de présentation fixant le calque de dessin d'une entité. More...
struct	RhiContext
	Le QRhi courant et le lot de téléversements de l'image en cours. More...
struct	RoomBounds
	Rectangle (en cases) d'une salle, borné aux dimensions réelles du niveau. More...
class	RoomGrid
	Partitionne une grille de niveau en un tableau de salles de taille fixe, façon Celeste (LOT-32). More...
class	SceneResources
	Lot de sprites, atlas, police bitmap, registre de textures et catalogue de skins — créés ensemble, libérés ensemble, dans le bon ordre. More...
struct	SkinEntry
	Apparence assignée à un type de tuile : le fichier à utiliser et son découpage. More...
class	SkinCatalog
	Catalogue des jeux de skins : (jeu, type de tuile) → { asset, mode }. More...
struct	SkinCatalogResult
	Résultat d'une lecture de catalogue : soit un SkinCatalog, soit une erreur décrite. More...
class	SpriteBatch
	Dessine des quads texturés au travers de QRhi, avec transparence et échantillonnage nearest (pixel art). More...
class	SpriteRenderer
	Pont ECS → écran : dessine chaque entité affichable, triée par calque puis par texture. More...
struct	TextAnchor
	Point d'ancrage d'un texte : quel coin/bord de sa boîte englobante coïncide avec la position passée à hmi::composeText — centrer un texte sans devoir le mesurer soi-même. More...
class	TextureAtlas
	Texture d'atlas et table de régions, chargée depuis un fichier image avec repli procédural (EX-REN-041/EX-REN-042). More...
class	TextureCache
	Charge, valide et met en cache des textures GPU désignées par leur nom de fichier logique. More...
struct	DecodedImage
	Pixels RGBA décodés d'un fichier image, alpha non prémultiplié (cohérent avec le mélange du pipeline de SpriteBatch, SrcAlpha/OneMinusSrcAlpha), au format RGBA8. More...
struct	LoadedTexture
	Texture GPU chargée (RAII). More...
struct	TileAppearance
	Apparence résolue d'une primitive : quelle texture lier, et quelle région y échantillonner. More...
struct	SkinTexture
	Skin déjà chargé, prêt à être lié par la composition. More...
struct	SceneTextures
	Textures liables par la composition d'une scène, et de quoi choisir laquelle lier. More...
struct	AutotileCell
	Position d'une case dans la planche de raccords, en cases (origine haut-gauche). More...
struct	TileSkinTag
	Type de tuile et voisinage solide d'une entité affichée, pour la résolution de son skin. More...
class	EditorKeyBindings
	Association action d'éditeur -> touche, avec persistance JSON (EX-CTRL-012, LOT-29). More...
class	GameKeyBindings
	Association action de jeu -> touche, avec persistance JSON (EX-CTRL-012, LOT-29). More...
class	GamepadBindings
	Association action de jeu (GameAction, partagée avec GameKeyBindings) -> bouton manette, avec persistance JSON (LOT-30). More...
class	GamepadPoller
	Sonde la manette (XInput, joueur 0) et fusionne son état dans un InputState. More...
class	InputState
	État des entrées d'une frame, avec détection des fronts (pressée / relâchée). More...
struct	EditorActionSpec
	Description d'une action, indépendante de Qt : de quoi construire un QAction complet (icône, libellé, raccourci, caractère cochable) sans dupliquer sa définition ailleurs. More...
struct	KeyBindingIconEntry
	Correspondance entre une action d'éditeur remappable (hmi::EditorAction, EditorKeyBindings.h) et l'identifiant d'action du catalogue qui la rend effective (LOT-57 TACHE-04, EX-IHM-062). More...
struct	DesignColor
	Couleur RVBA pure (indépendante de Qt), convertible en chaîne CSS pour la feuille de style et directement décomposable pour construire une QColor/QPalette. More...
struct	ColorTokens
	Rôles de couleur, communs aux deux portées d'habillage. More...
struct	SpacingTokens
	Échelle d'espacement, en pixels logiques. More...
struct	TypographyLevel
	Un niveau de l'échelle typographique : taille en points et graisse (QFont::Weight, 1-1000). More...
struct	TypographyTokens
	Échelle typographique, par rôle — jamais de taille ponctuelle en dehors de cette échelle. More...
struct	SizeTokens
	Tailles d'icônes, de vignettes et de contrôles usuels, en pixels logiques (avant mise à l'échelle d'affichage, LOT-56 TACHE-05). More...
struct	DesignTokens
	Jeu complet de jetons de design d'une portée (identité invariante ou châssis variable). More...
struct	IdentityBaseScale
	Grandeurs de la portée identité, exprimées en pixels à l'échelle 1 (LOT-68, EX-IHM-070). More...
class	EditorActions
	Construit et possède les QAction du catalogue (HMI/Interface/ActionCatalog.h) : chaque outil et chaque commande principale n'existe qu'une fois, placée simultanément dans la barre d'outils, un menu et un menu contextuel sans duplication. More...
class	EditorKeybindingsWidget
	Widget de remappage des touches d'éditeur (EditorKeyBindings), destiné à l'onglet « Éditeur » de la page Options. More...
struct	WorkspaceDressing
	Ce qu'un espace affiche, hors panneaux (voir workspacesForPanel). More...
struct	FontFamilyResolution
	Résultat de la résolution : la police embarquée si elle a pu être enregistrée auprès de Qt, sinon aucun nom de famille – jamais un second nom codé en dur. More...
class	GamepadBindingsWidget
	Widget de remappage des boutons manette (GamepadBindings), onglet « Commande manette » de la page Options. More...
struct	IconPoint
	Un point en espace normalisé [0,1] x [0,1] (origine en haut à gauche). More...
struct	IconStroke
	Un trait de l'icône : polyligne ouverte, ou polygone fermé (éventuellement rempli), d'une seule couleur. More...
struct	IconGeometry
	Géométrie complète d'une icône : liste ordonnée de traits. More...
class	KeybindingsWidget
	Widget de remappage des touches de jeu (GameKeyBindings), destiné à l'onglet « Commande clavier » de la page Options. More...
class	MainWindow
	Fenêtre principale de l'application Qt : poste de travail d'éditeur à panneaux dockables autour du viewport Direct3D 11. More...
struct	StyleSheetSubstitutionResult
	Résultat d'une substitution : succès et texte produit, ou échec et message d'erreur — jamais un résultat produit silencieusement avec un trou (marqueur inconnu non substitué). More...
class	Localization
	Catalogue de traduction (i18n) : associe des clés stables à des chaînes selon la langue active, avec repli sur la langue par défaut. More...
class	CharacterSheetModel
	Vue-modèle de la fiche : ce que le jeu sait dire d'un personnage. More...
struct	CharacterSheetContext
	Traduit une fiche de personnage en valeurs affichables, indexées par l'identifiant que l'ossature de l'écran déclare (hmi::RpgField::valueId). More...
struct	DemonstrationCharacter
	Ce qu'un chargement du personnage de démonstration produit, prêt à être publié au QML. More...
class	InventoryModel
	Vue-modèle de l'inventaire : les seize emplacements, la bourse, la charge et le sac. More...
struct	InventoryContext
	Traduit un inventaire en valeurs affichables, indexées par l'identifiant que la table de la planche 2 déclare (hmi::PlateField::valueId). More...
struct	KeyHint
	Une paire touche → action, déjà traduite par l'appelant (EX-REN-033). More...
struct	BackdropQuad
	Un pavé plein, en pixels, relatif au coin haut-gauche de la surface décorée. More...
class	OptionsModel
	Vue-modèle des options : lit et persiste les réglages, et publie leur changement. More...
class	PendingData
	Le point unique vers lequel pointe tout ce qui n'a pas encore de source. More...
struct	RpgField
	Une ligne « libellé → valeur » d'un bloc Fields. More...
struct	RpgContentBlock
	Un bloc de l'ossature d'un écran. More...
struct	RpgScreenLayout
	Ossature d'un écran : deux colonnes de blocs. More...
struct	RpgScreenDescriptor
	Comment un écran est rendu (LOT-38). More...
struct	ScreenDressing
	Habillage de fenêtre associé à un écran : ce que chaque showXxx() répétait à la main (bascule du QStackedWidget, docks, barre de menu, barres d'outils, navigation manette). More...
struct	ScreenState
	État complet de la machine. More...
class	ScreenRouter
	Pilote la machine à états des écrans, et publie l'écran courant. More...
struct	SheetRow
	Une ligne : ce qu'elle désigne, comment on l'appelle, ce qu'elle vaut. More...
class	SheetRowModel
	Liste de lignes libellé/valeur, pour un Repeater ou une ListView. More...

Typedefs
using	TextureHandle = void*
	Identité opaque d'une texture liée, du point de vue de la composition.
using	EditorWorkspaceMask = unsigned
	Ensemble d'espaces, un bit par valeur de hmi::EditorWorkspace.

Enumerations
enum class	SoundCatalogError {   None , FileNotFound , ParseError , UnsupportedVersion ,   MalformedStructure }
	Catégorie d'échec de lecture d'un sounds.json (même patron que hmi::SkinCatalogError/hmi::AnimationCatalogError). More...
enum class	EditorTool {   Paint , Rectangle , Selection , Link ,   TextureAssign , CameraZone }
	Outil actif dans la grille de l'éditeur, changé via Tab ou la barre d'outils (hmi::EditorActions). More...
enum class	LinkKind { Mechanism }
	Nature d'une liaison affichée (couleur/libellé distincts dans le panneau et le rendu). More...
enum class	LinkGestureAction {   Ignore , SetPending , ReplacePending , Link ,   Unlink }
	Action à appliquer sur le brouillon/l'état d'édition suite à un clic de l'outil « Lien ». More...
enum class	PaletteThumbnailSource { Atlas , Skin , MissingTexture }
	D'où provient la vignette affichée par la palette pour un type de tuile. More...
enum class	PanelId {   Palette , Levels , Links , Textures ,   Planes , PixelCanvas , PixelHistory , PixelPalette }
	Panneau dockable de l'éditeur. More...
enum class	PixelOperationKind {   Brush , Eraser , Fill , Move ,   FlipHorizontal , FlipVertical , RotateClockwise , RotateCounterClockwise ,   Paste }
	Type d'une opération d'historique — détermine sa clé de traduction (EX-REN-033). More...
enum class	PixelTool {   Brush , Eraser , Fill , Eyedropper ,   Selection }
	Outil actif du canevas pixel art — détermine ce que produisent les gestes de souris (hmi::PixelCanvas) et forme un groupe exclusif distinct de hmi::EditorTool (hmi::EditorActions, TACHE-04). More...
enum class	TextureAssignAction { Ignore , Assign , Remove }
	Action à appliquer sur le brouillon suite à un clic de l'outil « Texture par instance ». More...
enum class	GameEvent {   Jumped , Landed , Dashed , WallContactEnter ,   SwitchToggled , DoorOpened , DoorClosed , PressurePlatePressed ,   PressurePlateReleased , BlockPushed , Died , ExitReached ,   MenuNavigate , MenuConfirm , MenuBack , PauseOpened }
	Événement discret survenu sur un pas de simulation ou une action d'interface. More...
enum class	AnimationCatalogError {   None , FileNotFound , ParseError , UnsupportedVersion ,   MalformedStructure , IncoherentFrameSize }
	Catégorie d'échec de lecture d'une description d'animation (même esprit que hmi::SkinCatalogError/core::LevelValidationError). More...
enum class	AssetFamily {   Atlas , TileSkin , AutotileSheet , Background ,   Object , CharacterSheet , Font }
	Famille d'un asset graphique, qui détermine les dimensions attendues du fichier image. More...
enum class	QuadKind { Sprite , Line }
	Nature d'une primitive composée : rectangle aligné aux axes, ou segment épais orienté. More...
enum class	PlayerClipKind { Idle , Run , Jump }
	Identité des trois clips historiques du personnage, côté présentation seulement. More...
enum class	FontMetricsError {   None , FileNotFound , ParseError , UnsupportedVersion ,   MalformedStructure }
	Catégorie d'échec de lecture d'un fichier de métriques (même esprit que hmi::AnimationCatalogError). More...
enum class	RenderLayer : std::int32_t {   Background = 0 , Plane , Shadow , Tile ,   Object , Player , Foreground , UI ,   EditorOverlay }
	Calques de dessin, du plus arrière au plus avant (EX-REN-014, EX-DEC-002). More...
enum class	RenderMode { Physique , Texture }
	Mode de rendu de la scène : lecture directe des collisions, ou habillage. More...
enum class	SkinMode { Single , Bitmask16 }
	Manière dont l'asset d'un type de tuile est découpé à l'affichage (EX-EDIT-025). More...
enum class	SkinCatalogError {   None , FileNotFound , ParseError , UnsupportedVersion ,   MalformedStructure }
	Catégorie d'échec de lecture d'un skins.json (même esprit que core::LevelValidationError). More...
enum class	TextHorizontalAnchor { Left , Center , Right }
	Ancrage horizontal d'un texte composé (hmi::composeText). More...
enum class	TextVerticalAnchor { Top , Middle , Bottom }
	Ancrage vertical d'un texte composé (hmi::composeText). More...
enum class	AppearanceSource { Atlas , MissingTexture , Skin , Override }
	Texture d'où provient l'apparence résolue. More...
enum	NeighborBits : std::uint8_t { NEIGHBOR_UP = 1u << 0 , NEIGHBOR_RIGHT = 1u << 1 , NEIGHBOR_DOWN = 1u << 2 , NEIGHBOR_LEFT = 1u << 3 }
	Bits du masque de voisinage, un par voisin orthogonal solide. More...
enum class	EditorAction {   Save , Undo , Redo , Copy ,   Paste , Playtest , ToggleGrid , ToggleHelp ,   Rename , TextureAssignTool }
	Action d'éditeur logique, remappable indépendamment de la touche physique. More...
enum class	GameAction {   MoveLeft , MoveRight , AimUp , AimDown ,   Jump , Dash , Interact }
	Action de jeu logique, remappable indépendamment de la touche physique qui la déclenche. More...
enum class	GamepadButton {   Up , Down , Left , Right ,   A , B , X , Y ,   LeftShoulder , RightShoulder }
	Bouton (ou direction) manette remappable à une action de jeu (EX-CTRL-002, LOT-30). More...
enum class	Key : std::uint16_t {   Backspace = 0x08 , Tab = 0x09 , Enter = 0x0D , Shift = 0x10 ,   Control = 0x11 , Escape = 0x1B , Space = 0x20 , Left = 0x25 ,   Up = 0x26 , Right = 0x27 , Down = 0x28 , D0 = 0x30 ,   A = 0x41 , C = 0x43 , D = 0x44 , E = 0x45 ,   P = 0x50 , Q = 0x51 , R = 0x52 , S = 0x53 ,   T = 0x54 , V = 0x56 , W = 0x57 , Y = 0x59 ,   Z = 0x5A , F1 = 0x70 , F2 = 0x71 , F10 = 0x79 }
	Touche du clavier, identifiée par son code virtuel Win32. More...
enum class	MouseButton : std::uint8_t { Left = 0 , Right = 1 , Middle = 2 , Count = 3 }
	Bouton de la souris suivi par l'InputState. More...
enum class	EditorActionGroup { None , LevelTools , PixelTools , PixelCommands }
	Groupe d'exclusivité d'une action : les outils d'édition forment un groupe exclusif (un seul actif à la fois) ; les commandes n'appartiennent à aucun groupe. More...
enum class	ActionSurface { ToolBarAndMenu , MenuOnly }
	Surface d'une action (LOT-68, EX-IHM-074). More...
enum class	FontRole { Ui , Identity }
	Famille de police d'une portée (LOT-68, EX-IHM-070). More...
enum class	EditorWorkspace { Level , Planes , PixelArt }
	Espace de travail actif. Ils s'excluent : aucun état intermédiaire n'existe. More...
enum class	IconId {   ToolPaint , ToolRectangle , ToolSelection , ToolLink ,   ToolTextureAssign , ToolCameraZone , Save , Playtest ,   Undo , Redo , ToggleGrid , ResetCamera ,   ToggleRenderMode , Copy , Paste , Rename ,   ShortcutsOverview , PixelBrush , PixelEraser , PixelFill ,   PixelEyedropper , PixelOpen , PixelCreate , PixelSave ,   PixelSaveAs , PixelSelectionTool , PixelFlipHorizontal , PixelFlipVertical ,   PixelRotateClockwise , PixelRotateCounterClockwise }
	Identifiant d'une icône : un par outil d'édition et par commande principale. More...
enum class	IconColorRole { Foreground , Accent }
	Rôle de couleur d'un trait, résolu depuis les jetons de design au moment du rendu (recoloration automatique avec le thème, y compris après une bascule TACHE-06). More...
enum class	EditorThemeSetting { System , Light , Dark }
	Réglage choisi par l'utilisateur (menu Affichage de l'éditeur, persisté entre sessions). More...
enum class	EditorThemeMode { Light , Dark }
	Thème effectivement appliqué au châssis d'édition. More...
enum class	BackdropRole {   SkyHigh , SkyMid , SkyLow , Star ,   StarDim , Moon , MoonCrater , Silhouette ,   Hill , Ground , GroundEdge , Veil }
	Rôle de couleur d'un pavé du décor, résolu depuis les jetons au moment du rendu. More...
enum class	RpgScreenId {   CharacterSheet , Inventory , QuestJournal , WorldMap ,   Dialogue , Merchant , GuildBoard , CombatHud ,   TeamSheet }
	Les huit écrans du RPG. More...
enum class	RpgSuperposition { PausesGame , WhileWalking }
	Règle de superposition d'un écran (EX-IHM-091) : ce qui met le jeu en pause et ce qui se consulte en marchant. More...
enum class	RpgBlockKind {   Fields , Grid , List , Prose ,   Portrait , Track , ActionBar }
	Genres de blocs que le châssis sait peindre. More...
enum class	ScreenId {   Menu , Editor , Game , Options ,   Pause , Credits , RpgScreen }
	Écran actuellement affiché par la fenêtre principale. More...
enum class	ScreenEvent {   OpenMenu , OpenEditor , OpenGame , OpenOptions ,   CloseOptions , OpenPause , ResumePause , QuitPauseToMenu ,   OpenCredits , CloseCredits , OpenRpgScreen , CloseRpgScreen }
	Événement pouvant déclencher une transition d'écran. More...
enum class	Ability
	Une des six caractéristiques d'un personnage ou d'une créature (EX-DND-010). More...

Functions
std::optional< std::string >	soundForEvent (GameEvent event)
	Associe un hmi::GameEvent à un identifiant de hmi::SoundCatalog.
std::string	serializeSessionLog (const std::vector< core::MemoryLogSink::Entry > &entries)
	Assemble les messages de log en un texte (une ligne par message).
bool	saveSessionLog (const std::vector< core::MemoryLogSink::Entry > &entries, const std::filesystem::path &path)
	Enregistre les messages de log de la session dans un fichier.
std::vector< std::string >	listAssetFiles (const std::filesystem::path &directory, const std::string &filterText={})
	Liste les fichiers image d'un dossier, filtrés par un texte de recherche.
std::vector< AssetReference >	findSkinCatalogReferences (const SkinCatalog &catalog, const std::string &fileName)
	Repère toutes les entrées de skins.json qui citent un fichier donné.
std::string	describeReferences (const std::vector< AssetReference > &references)
	Message d'avertissement listant des références, une par jeu de skins.
EditorStatusLines	editorStatusLines (const EditorStatusContext &context, const Localization &localization)
	Décide le contenu de la barre d'état de l'éditeur pour context.
bool	isValidLevelName (const std::string &name)
	Indique si name peut servir de nom de niveau (donc de nom de fichier Windows).
std::string	trimLevelName (const std::string &name)
	Retire les espaces de bord de name (le nom réellement utilisé une fois confirmé).
LinkSegment	linkSegment (core::GridPosition trigger, core::GridPosition target, int fanIndex=0, int fanCount=1) noexcept
	Calcule le segment reliant le centre de la case trigger au centre de la case target, avec un éventuel décalage perpendiculaire anti-superposition de l'extrémité cible.
ArrowHead	arrowHead (core::Vector2 from, core::Vector2 to) noexcept
	Calcule les deux ailes de la pointe d'une flèche allant de from vers to.
std::vector< LinkRow >	buildLinkRows (const core::LevelDraft &draft)
	Construit la liste des liaisons d'un brouillon, dans un ordre déterministe.
constexpr bool	isTriggerTile (core::TileType type) noexcept
constexpr bool	isLinkTargetTile (core::TileType type) noexcept
LinkGestureDecision	resolveLinkClick (std::optional< PendingLink > pending, core::GridPosition clickedCell, core::TileType clickedTileType, bool alreadyLinked) noexcept
	Résout le clic de l'outil « Lien » sur clickedCell selon l'attente courante.
std::vector< MechanismAnimationRow >	buildMechanismAnimationRows (const SkinCatalog &catalog, std::string_view setName, const std::filesystem::path &skinsDirectory)
	Construit les lignes de la section « Animations », diagnostic de clips manquants compris.
PaletteThumbnail	paletteThumbnail (RenderMode mode, core::TileType type, const core::AtlasRegion &physicalRegion, const SkinCatalog *catalog, std::string_view setName)
	Choisit la vignette à afficher pour un type de tuile dans la palette.
const std::array< PanelFocusEntry, PANEL_FOCUS_CATALOG_COUNT > &	panelFocusCatalog ()
std::optional< PanelId >	panelForTool (EditorTool tool)
const std::array< PixelPanelFocusEntry, PIXEL_PANEL_FOCUS_CATALOG_COUNT > &	pixelPanelFocusCatalog ()
std::optional< PanelId >	panelForPixelTool (PixelTool tool)
std::vector< std::pair< int, int > >	validAssetSizes (AssetFamily family)
	Tailles proposées à la création d'un asset de la famille donnée.
bool	isBitmask16Candidate (const DecodedImage &image, int tileSize) noexcept
	true si image a exactement les dimensions d'une planche à raccords bitmask16.
std::optional< AutotileCell >	bitmaskCellAtPixel (const DecodedImage &image, int tileSize, int x, int y) noexcept
	Case de la planche sous un pixel donné.
DecodedImage	buildAutotileAssemblyPreview (const DecodedImage &sheet, int tileSize)
	Construit l'aperçu d'assemblage 3×3 démonstratif à partir de la planche en cours.
PixelScreenRect	imagePixelScreenRect (const PixelCanvasView &view, int x, int y) noexcept
	Rectangle écran du pixel image (x, y), au zoom et décalage de vue donnés.
std::optional< std::pair< int, int > >	screenToImagePixel (const PixelCanvasView &view, int imageWidth, int imageHeight, double screenX, double screenY) noexcept
	Pixel image sous une position écran donnée.
PixelCanvasRealSize	pixelCanvasRealSize (int imageWidth, int imageHeight, int zoom, double scaleFactor) noexcept
	Taille en pixels réels du canevas entier à un facteur d'échelle d'affichage donné.
PixelCanvasRealSize	pixelCanvasRealSize (int imageWidth, int imageHeight, const PixelCanvasView &view, double scaleFactor) noexcept
	Taille en pixels réels du canevas entier, à l'échelle rationnelle d'une vue.
constexpr int	clampPixelCanvasZoom (int zoom) noexcept
	Zoom borné à [PIXEL_CANVAS_MIN_ZOOM, PIXEL_CANVAS_MAX_ZOOM].
constexpr int	pixelCanvasZoomIn (int zoom) noexcept
	Zoom suivant (plus grand), borné — toujours entier.
constexpr int	pixelCanvasZoomOut (int zoom) noexcept
	Zoom précédent (plus petit), borné — toujours entier.
constexpr bool	pixelCanvasGridVisible (int zoom) noexcept
	true si la grille de pixels doit être dessinée à ce zoom (PIXEL_CANVAS_GRID_VISIBLE_MIN_ZOOM).
constexpr bool	isValidPixelCanvasDenominator (int denominator) noexcept
constexpr double	pixelCanvasScale (const PixelCanvasView &view) noexcept
	Échelle effective d'une vue : numérateur / dénominateur.
constexpr PixelCanvasView	pixelCanvasZoomIn (const PixelCanvasView &view) noexcept
	Vue agrandie d'un cran, en remontant l'échelle rationnelle.
constexpr PixelCanvasView	pixelCanvasZoomOut (const PixelCanvasView &view) noexcept
	Vue réduite d'un cran, en descendant l'échelle rationnelle — sous le 1:1 si besoin.
constexpr bool	pixelCanvasGridVisible (const PixelCanvasView &view) noexcept
	true si la grille de pixels doit être dessinée pour cette vue : jamais sous le 1:1, où elle couvrirait plus de surface que les pixels qu'elle sépare.
std::string_view	pixelOperationTranslationKey (PixelOperationKind kind) noexcept
	Clé de traduction décrivant une opération.
PixelRegion	setPixel (DecodedImage &image, int x, int y, std::uint32_t color)
	Pose un pixel d'une couleur donnée.
PixelRegion	erasePixel (DecodedImage &image, int x, int y)
	Efface un pixel (alpha nul), sans changer sa couleur RVB.
PixelRegion	drawLine (DecodedImage &image, int x0, int y0, int x1, int y1, std::uint32_t color)
	Trace une ligne pleine entre deux positions (algorithme de Bresenham).
PixelRegion	eraseLine (DecodedImage &image, int x0, int y0, int x1, int y1)
	Efface une ligne pleine entre deux positions (même tracé que drawLine, alpha nul plutôt qu'une couleur posée).
PixelRegion	floodFill (DecodedImage &image, int x, int y, std::uint32_t color)
	Remplit, de proche en proche, la zone connexe (4-connexité) de même couleur que le pixel de départ.
std::optional< std::uint32_t >	pickColor (const DecodedImage &image, int x, int y) noexcept
	Couleur du pixel à une position donnée (outil pipette).
std::vector< std::uint32_t >	readRegion (const DecodedImage &image, const PixelRegion &region)
	Copie les pixels d'une région, ligne par ligne — capture le « avant » ou l'« après » d'une entrée d'historique (hmi::PixelHistory).
void	writeRegion (DecodedImage &image, const PixelRegion &region, const std::vector< std::uint32_t > &data)
	Écrit des pixels dans une région — inverse de readRegion, utilisé par hmi::PixelHistory pour restaurer un instantané annulé/rétabli.
PixelRegion	flipHorizontal (DecodedImage &image, const PixelRegion &region)
	Retourne une région horizontalement (miroir gauche-droite), en place.
PixelRegion	flipVertical (DecodedImage &image, const PixelRegion &region)
	Retourne une région verticalement (miroir haut-bas), en place.
PixelRegion	rotateClockwise (DecodedImage &image, const PixelRegion &region)
	Pivote le contenu d'une région d'un quart de tour, sens horaire.
PixelRegion	rotateCounterClockwise (DecodedImage &image, const PixelRegion &region)
	Pivote le contenu d'une région d'un quart de tour, sens antihoraire (trois quarts de tour horaires, pour ne pas dupliquer la logique de rotation).
PixelRegion	moveRegion (DecodedImage &image, const PixelRegion &region, int dx, int dy)
	Déplace le contenu d'une région d'un décalage donné.
PixelClipboard	copyRegion (const DecodedImage &image, const PixelRegion &region)
	Copie les pixels d'une région dans un presse-papiers autonome (ne référence plus image).
PixelRegion	pasteClipboard (DecodedImage &image, const PixelClipboard &clipboard, int x, int y)
	Colle un presse-papiers dans l'image, coin haut-gauche à (x, y).
constexpr bool	pixelInBounds (int width, int height, int x, int y) noexcept
constexpr PixelRegion	unionPixelRegion (const PixelRegion &a, const PixelRegion &b) noexcept
	Union de deux régions (la plus petite région couvrant les deux).
std::vector< PixelPaletteExtractionEntry >	extractPalette (const DecodedImage &image)
	Couleurs effectivement présentes dans une image, dans un ordre déterministe.
std::uint32_t	nearestPaletteColor (std::uint32_t color, const std::vector< std::uint32_t > &palette) noexcept
	Couleur de palette la plus proche de color (mode « contraindre à la palette »).
PlanePixelSize	planePixelSize (int widthUnits, int heightUnits, int pixelsPerUnit) noexcept
	Dimensions, en pixels, du PNG d'un plan.
std::string	sanitizePlaneBaseName (const std::string &name)
	Réduit un nom libre à ce qu'un nom de fichier de plan accepte.
std::string	uniquePlaneFileName (const std::string &levelName, const std::vector< std::string > &existing)
	Compose un nom de fichier de plan unique pour un niveau donné.
std::uint32_t	alphaOver (std::uint32_t below, std::uint32_t above) noexcept
	Compose un pixel au-dessus d'un autre (alpha-over, alpha non prémultiplié).
DecodedImage	resamplePlane (const DecodedImage &image, int fromPixelsPerUnit, int toPixelsPerUnit)
	Rééchantillonne une image d'une densité à une autre, par ratio entier.
DecodedImage	buildTileOnionSkin (const core::LevelDraft &draft, int pixelsPerUnit)
	Construit la pelure d'oignon des tuiles : une couleur plate par type, aux dimensions d'un plan de la densité donnée.
DecodedImage	flattenPlanes (const std::vector< PlaneLayer > &layers, int pixelsPerUnit, int widthUnits, int heightUnits)
	Aplatit des plans en une seule image, par alpha-over dans l'ordre donné.
std::vector< SkinSection >	buildSkinRows (const SkinCatalog &catalog, std::string_view setName)
	Construit les lignes du panneau pour un jeu de skins donné.
std::vector< std::string >	listSkinAssets (const std::filesystem::path &skinsDirectory)
	Liste les fichiers de skins disponibles, par balayage d'un dossier.
void	applySkinAssignment (SkinCatalog &catalog, std::string_view setName, core::TileType type, const std::string &asset, SkinMode mode)
	Applique une assignation à un catalogue, ou la retire.
std::string	taxonomyLabelKey (const std::string &label)
	Clé de traduction d'un libellé de la taxonomie.
std::string	localizedTaxonomyLabel (const Localization *loc, const std::string &label)
	Libellé de taxonomie traduit dans la langue active.
TextureAssignDecision	resolveTextureAssignClick (core::GridPosition clickedCell, core::TileType clickedTileType, const std::optional< std::string > &existingOverride, const std::optional< std::string > &selectedAsset, bool rightClick) noexcept
	Résout le clic de l'outil « Texture par instance » sur clickedCell.
int	thumbnailPixelSize (int logicalSize, double scaleFactor) noexcept
	Taille en pixels réels pour une taille logique et un facteur d'échelle d'affichage donnés.
std::vector< TileCategory >	tileTaxonomy ()
	Taxonomie complète des types de tuiles peignables, en catégories/sous-groupes.
std::vector< std::string >	composeDiagnosticsHudLines (const DiagnosticsMeasurements &measurements, const Localization &localization)
	Compose les lignes du compteur de diagnostic à partir de valeurs déjà mesurées.
std::vector< GameEvent >	detectMechanismEvents (const MechanismEventState &previous, const MechanismEventState &current, const std::vector< bool > &isContinuous)
	Détecte les transitions des mécanismes entre deux pas de simulation consécutifs.
std::optional< GameEvent >	detectOutcomeEvent (core::LevelOutcome outcome)
	Traduit l'issue d'un pas de simulation en événement.
std::vector< std::string >	gameHudLines (const std::string &levelName, const Localization &localization, bool overlappingKey=false)
	Lignes à afficher pour l'affichage tête haute d'un pas de simulation donné.
const char *	assetFamilyName (AssetFamily family) noexcept
	Nom lisible d'une famille d'assets, utilisé dans les messages de journalisation.
AssetDimensionContract	assetDimensionContract (AssetFamily family) noexcept
	Contrat de dimensions d'une famille d'assets.
std::string	describeContract (const AssetDimensionContract &contract)
	Description en français des dimensions attendues (« 16×16 px », « multiple de 16 px… »).
AssetValidation	validateAsset (AssetFamily family, const std::string &fileName, int width, int height)
	Valide les dimensions d'un asset décodé contre le contrat de sa famille (EX-REN-007).
BackgroundFit	computeBackgroundFit (float imageWidth, float imageHeight, float targetWidth, float targetHeight) noexcept
	Calcule le recadrage UV d'une image pour couvrir un rectangle cible sans déformation.
void	composeBackground (ComposedScene &scene, const BackgroundTexture &background, int levelWidth, int levelHeight, RenderMode mode)
	Compose le fond du niveau sur RenderLayer::Background, s'il y a lieu.
void	triggerScreenShake (ScreenShakeState &state, float amplitudePixels, float duration) noexcept
	Déclenche (ou relance) une secousse d'écran.
void	advanceScreenShake (ScreenShakeState &state, float fixedDelta) noexcept
	Avance une secousse d'écran d'un pas fixe.
core::Vector2	screenShakeOffset (const ScreenShakeState &state) noexcept
	Décalage courant d'une secousse d'écran, en pixels entiers (EX-ARCH-022).
std::optional< std::size_t >	activeCameraZoneIndex (const std::vector< core::CameraZone > &zones, core::GridPosition position) noexcept
	Indice de la zone active de zones à position.
std::int32_t	depthSortOrder (float footWorldY) noexcept
	Ordre de profondeur d'une primitive, à partir du pied de son quad.
std::string	formatSceneStatistics (const SceneStatistics &statistics)
	Résumé des compteurs d'une image, pour la journalisation de diagnostic (EX-NFR-005).
core::Rect	spriteQuadBounds (const SpriteQuad &quad) noexcept
	Boîte englobante d'un rectangle texturé, en unités monde.
core::Rect	lineQuadBounds (const LineQuad &quad) noexcept
	Boîte englobante d'un segment épais, en unités monde.
void	composeWorldSprites (ComposedScene &scene, core::World &world, RenderMode mode, const SceneTextures &textures, float interpolationAlpha, const LayerVisibility &visibility=LayerVisibility{})
	Compose les entités affichables d'un monde ECS en primitives.
FollowCameraState	advanceFollowCamera (const FollowCameraState &previous, core::Vector2 characterPosition, core::Vector2 facing, const core::Rect &levelBounds, core::Vector2 viewHalfExtent, float fixedDelta) noexcept
	Avance la caméra de suivi d'un pas fixe.
bool	isStatefulMechanism (core::TileType type) noexcept
	Indique si un type de tuile est un mécanisme à état, dont l'apparence dépend d'une donnée lue en lecture seule dans Core (EX-ARCH-012).
std::optional< std::string >	mechanismTargetClip (core::TileType type, bool active) noexcept
	Nom du clip d'état cible d'un mécanisme, d'après son type et son état logique courant.
std::optional< std::string >	mechanismTransitionClip (core::TileType type, bool wasActive, bool isActive) noexcept
	Nom du clip de transition joué une fois lors d'un changement d'état (LOT-47 TACHE-02), s'il y a lieu.
std::vector< std::string >	mechanismExpectedClips (core::TileType type)
	Noms de clip attendus par la correspondance pour un type de mécanisme, dans l'ordre du tableau ci-dessus (utilisé par le diagnostic du panneau « Textures », LOT-47 TACHE-04).
core::AtlasRegion	advanceMechanismVisual (MechanismVisualState &state, const AnimationDescription &description, core::TileType type, bool active, const std::string &assetKey, float fixedDelta, std::set< std::string > &warnedMissingClips)
	Fait progresser l'animation d'une instance de mécanisme d'un pas fixe : détecte un changement d'état, choisit le clip approprié (transition ou état cible, avec repli sur clip manquant), avance l'image courante, et renvoie la région à afficher (LOT-47 TACHE-02).
float	mechanismDiagnosticAlpha (RenderMode mode, bool active, float activeAlpha, float inactiveAlpha) noexcept
	Alpha de diagnostic, réservé au mode Physique (LOT-47 TACHE-03).
ProceduralAtlasImage	buildMissingTextureImage (int size=MISSING_TEXTURE_SIZE)
	Génère, en mémoire, la texture de repli « asset manquant » : un damier magenta/noir.
std::string	missingTextureWarning (const std::string &fileName)
	Message d'avertissement émis lorsqu'un asset attendu est introuvable ou refusé.
core::Vector2	parallaxRenderPosition (core::Vector2 modelPosition, core::Vector2 factor, const core::Rect &cameraBounds) noexcept
	Calcule la position de rendu d'un contenu, décalée par sa parallaxe.
core::Vector2	parallaxModelPosition (core::Vector2 renderPosition, core::Vector2 factor, const core::Rect &cameraBounds) noexcept
	Inverse de parallaxRenderPosition : retrouve la position modèle équivalente à un point exprimé en espace de rendu (LOT-50 TACHE-02).
core::Vector2	clampPlaneOffset (core::Vector2 offset, const core::Rect &planeBounds, const core::Rect &cameraBounds) noexcept
	Borne le décalage d'un plan pour qu'il couvre toujours le cadrage.
core::Vector2	roundToScreenPixel (core::Vector2 worldPosition, float pixelsPerWorldUnit) noexcept
	Arrondit une position monde au pixel écran le plus proche, pour un zoom pixel art net.
constexpr bool	planeParallaxActive (core::CameraFramingMode mode, bool levelFlag) noexcept
	Décide si la parallaxe des plans s'applique, selon le mode de cadrage et le drapeau du niveau (EX-DEC-043, EX-REN-016).
void	composeParticles (ComposedScene &scene, core::World &world, RenderMode mode, const SceneTextures &textures)
	Compose un quad par particule vivante, teinté selon la durée de vie restante et le calque de son effet.
RenderLayer	planeRenderLayer (core::PlaneDepth depth) noexcept
	Projette la profondeur d'un plan sur le calque de rendu correspondant.
void	composePlanes (ComposedScene &scene, const std::vector< core::Plane > &planes, const std::vector< PlaneTexture > &textures, int levelWidth, int levelHeight, RenderMode mode, const PlaneVisibility &visibility=PlaneVisibility{}, const PlaneParallax &parallax=PlaneParallax{})
	Compose les plans picturaux d'un niveau, dans l'ordre déclaré.
std::size_t	planeTextureMemoryBytes (const core::Plane &plane, int levelWidth, int levelHeight) noexcept
	Mémoire de texture qu'un plan exige du format, en octets (EX-NFR-043).
std::size_t	planesTextureMemoryBytes (const std::vector< core::Plane > &planes, int levelWidth, int levelHeight) noexcept
	Somme de hmi::planeTextureMemoryBytes sur tous les plans d'un niveau.
std::vector< PlaneTexture >	resolvePlaneTextures (TextureCache &cache, const std::filesystem::path &directory, const std::vector< core::Plane > &planes)
	Résout les images des plans d'un niveau (accès disque/GPU), dans l'ordre de la liste.
PlayerSpriteQuad	computePlayerSpriteQuad (core::Vector2 imageSizePixels, core::Vector2 hitboxSize)
	Calcule le quad d'affichage du personnage à partir de la taille de l'image et de la hitbox, par ancrage centre-bas (LOT-48 TACHE-01).
const std::vector< std::string > &	proceduralPlayerClipNames ()
	Noms des clips que l'atlas procédural sait dessiner (Idle/Run/Jump, LOT-18) : seule source de vérité, partagée avec hmi::PlayerClipKind — traitée comme une « spritesheet » n'en déclarant que trois par hmi::resolveDeclaredPlayerClip.
std::string	resolveDeclaredPlayerClip (const std::vector< std::string > &declaredNames, std::string_view requested)
	Résout un nom de clip demandé vers le plus proche déclaré dans un jeu partiel (LOT-48 TACHE-01/TACHE-02).
int	flatPlayerFrameIndex (PlayerClipKind clip, int frameIndex)
	Index à plat (0-based) d'une image dans la grille sous les tuiles : Idle (0..PLAYER_IDLE_FRAME_COUNT-1), puis Run, puis Jump.
ProceduralAtlasImage	buildProceduralAtlasImage ()
	Génère, en mémoire, l'atlas procédural historique (grille de tuiles + images du personnage), de façon déterministe.
char32_t	nextUtf8CodePoint (std::string_view text, std::size_t &index) noexcept
	Décode le point de code UTF-8 suivant d'une chaîne.
TextExtent	measureText (const FontMetrics &metrics, std::string_view text, float scale=1.0f) noexcept
	Largeur et hauteur qu'occuperait text avec metrics, à l'échelle scale.
ProceduralFont	buildProceduralFont ()
	Génère, en mémoire, une police bitmap minimale et déterministe (repli sans asset).
FontMetricsResult	loadFontMetricsFromString (std::string_view json)
	Lit des métriques de police depuis une chaîne JSON.
FontMetricsResult	loadFontMetricsFromFile (const std::filesystem::path &path)
	Lit des métriques de police depuis un fichier.
AssetValidation	validateFontMetricsAgainstTexture (const FontMetrics &metrics, const std::string &fileName, int textureWidth, int textureHeight)
	Valide la cohérence entre des métriques et les dimensions décodées du PNG associé.
constexpr bool	sortsByDepth (RenderLayer layer) noexcept
	Le calque appartient-il à la bande de profondeur ?
constexpr std::int32_t	renderBand (RenderLayer layer) noexcept
	Bande de tri d'un calque : Object et Player en partagent une seule.
constexpr const char *	renderLayerName (RenderLayer layer) noexcept
	Nom lisible d'un calque, pour la journalisation et les messages d'échec de test.
const char *	renderModeName (RenderMode mode) noexcept
	Nom persisté d'un mode de rendu (valeur écrite dans les préférences).
RenderMode	renderModeFromName (const std::string &name) noexcept
	Mode de rendu correspondant à un nom persisté.
void	composeShadows (ComposedScene &scene, core::World &world, RenderMode mode, const SceneTextures &textures, float interpolationAlpha, const core::TileMap *doorCollision=nullptr)
	Compose une ombre décalée pour chaque tuile physique visible, sur RenderLayer::Shadow.
const char *	skinModeName (SkinMode mode) noexcept
	Nom persisté d'un mode de skin (valeur écrite dans skins.json).
std::optional< SkinMode >	skinModeFromName (std::string_view name) noexcept
	Mode de skin correspondant à un nom lu dans un fichier.
void	submitComposedScene (SpriteBatch &batch, const DirectX::XMFLOAT4X4 &projection, const ComposedScene &scene)
	Soumet une scène composée au pipeline de dessin, une passe par groupe de texture.
SceneTextures	sceneTextures (const TextureAtlas &atlas, TextureCache &cache, const SkinCatalog *skins=nullptr, const std::string &skinSet={}, const std::vector< core::TileTextureOverride > &textureOverrides={}, const std::unordered_map< std::string, core::Animation > &tileAnimations={})
	Textures liables par la composition d'une scène : atlas, damier de repli et skins.
BackgroundTexture	resolveBackgroundTexture (const std::optional< std::string > &background, TextureCache &cache)
	Résout la texture de fond d'un niveau (accès TextureCache/GPU, LOT-44).
void	advanceTileAnimations (const SkinCatalog *skins, const std::string &skinSet, TextureCache &cache, float deltaSeconds, std::unordered_map< std::string, core::Animation > &tileAnimations, std::set< std::string > &warnedExclusions)
	Avance l'horloge d'animation partagée des tuiles animées d'un jeu de skins courant (LOT-46 TACHE-05).
DirectX::XMFLOAT4X4	screenProjectionMatrix (int viewportWidth, int viewportHeight) noexcept
	Construit la projection écran → clip du calque UI, indépendante de Camera2D.
void	composeText (ComposedScene &scene, const FontMetrics &metrics, TextureHandle texture, int textureWidth, int textureHeight, std::string_view text, float x, float y, float scale, const core::Color &tint, TextAnchor anchor={}, std::int32_t sortOrder=0)
	Compose une chaîne en quads sur le calque UI, ancrée à une position écran.
void	composeText (ComposedScene &scene, const BitmapFont &font, std::string_view text, float x, float y, float scale, const core::Color &tint, TextAnchor anchor={}, std::int32_t sortOrder=0)
	Raccourci de hmi::composeText prenant directement une hmi::BitmapFont.
const LoadedTexture *	resolveOrPlaceholder (TextureCache &cache, const std::string &fileName, AssetFamily family)
	Obtient la texture d'un asset, ou le repli en damier magenta à défaut.
std::optional< DecodedImage >	decodeImageFile (const std::filesystem::path &path)
	Décode un fichier image (PNG au minimum) en pixels RGBA.
bool	encodeImageFile (const std::filesystem::path &path, const DecodedImage &image)
	Écrit un fichier PNG depuis des pixels RGBA déjà en mémoire — symétrique de decodeImageFile.
std::optional< LoadedTexture >	createTexture (const RhiContext &context, int width, int height, const std::vector< std::uint32_t > &pixels)
	Crée une texture GPU à partir de pixels RGBA déjà décodés.
std::optional< LoadedTexture >	loadTextureFromFile (const RhiContext &context, const std::filesystem::path &path)
	Décode un fichier image puis crée la texture GPU correspondante.
std::optional< TileAppearance >	resolveTileAppearance (RenderMode mode, const core::AtlasRegion &physicalRegion, const TileSkinTag *tag, const SceneTextures &textures, bool skinVisible=true, bool overrideVisible=true) noexcept
	Résout l'apparence d'une entité affichée selon le mode de rendu courant.
bool	animationExcludedForTile (SkinMode mode, core::TileType type) noexcept
	Indique si la combinaison (mode de skin, type de tuile) exclut l'animation (LOT-46 TACHE-05).
std::uint8_t	solidNeighborMask (const core::TileMap &tiles, int column, int row) noexcept
	Calcule le masque de voisinage solide d'une case de la grille.
AutotileCell	autotileCell (std::uint8_t mask) noexcept
	Case de la planche 4×4 correspondant à un masque de voisinage.
AutotileCell	autotileRepresentativeCell () noexcept
	Case représentative d'une planche : l'intérieur plein (quatre voisins solides).
std::string_view	autotileConfigurationLabelKey (std::uint8_t mask) noexcept
	Clé de traduction décrivant la configuration de voisinage d'un masque, pour l'atelier pixel art (LOT-54 TACHE-08, EX-REN-033).
std::array< std::uint8_t, 9 >	autotileAssemblyMasks () noexcept
	Masques des neuf cases d'un assemblage 3×3 démonstratif (LOT-54 TACHE-08).
bool	hasSilhouette (core::TileType type) noexcept
	Indique si type a une silhouette, c'est-à-dire une matière qui n'occupe pas toute la case et qu'il faut détourer à l'affichage.
bool	isInsideSilhouette (core::TileType type, int localX, int localY, int tileSize) noexcept
	Indique si le pixel (localX, localY) d'une case appartient à la matière de type.
void	applySilhouetteMask (core::TileType type, int width, int height, std::vector< std::uint32_t > &pixels)
	Applique la silhouette d'un type à une image carrée, en rendant transparent l'extérieur.
core::AtlasRegion	regionForTile (core::TileType type)
	Région d'atlas (couleur procédurale) associée à un type de tuile.
std::optional< std::string >	textureOverrideAt (const std::vector< core::TileTextureOverride > &overrides, core::GridPosition position)
	Cherche la surcharge de texture assignée à une case précise (EX-EDIT-043, LOT-45).
std::string	gamepadButtonDisplayName (GamepadButton button)
	Nom lisible d'un bouton manette, pour l'affichage dans l'écran de remappage.
std::optional< GamepadButton >	capturedGamepadButton (const InputState &input)
	Cherche le premier bouton manette pressé cette frame, pour la capture d'un remappage.
constexpr bool	gamepadProbeDue (bool wasConnected, std::chrono::steady_clock::duration sinceLastProbe) noexcept
	Faut-il re-sonder XInput maintenant ?
std::string	keyDisplayName (Key key)
	Nom lisible d'une touche, pour l'affichage dans les écrans de remappage (LOT-29) et le panneau d'aide de l'éditeur (EX-EDIT-015).
std::optional< Key >	capturedKey (const InputState &input)
	Cherche la première touche pressée cette frame, pour la capture d'un remappage.
core::PlayerInput	toPlayerInput (const InputState &input, const GameKeyBindings &gameKeyBindings, const GamepadBindings &gamepadBindings)
	Traduit l'état d'entrée en core::PlayerInput, dissocié des touches/boutons physiques (EX-CTRL-010, EX-CTRL-012).
std::optional< hmi::Key >	qtKeyToHmiKey (int qtKey)
	Traduit un code Qt::Key en hmi::Key.
int	hmiKeyToQtKey (hmi::Key key)
	Traduit un hmi::Key en code Qt::Key, inverse de qtKeyToHmiKey (LOT-57 TACHE-04).
const std::array< EditorActionSpec, EDITOR_ACTION_CATALOG_COUNT > &	editorActionCatalog ()
const EditorActionSpec &	editorActionSpec (IconId id)
std::optional< EditorTool >	editorActionTool (IconId id)
IconId	editorActionForTool (EditorTool tool)
std::optional< PixelTool >	editorActionPixelTool (IconId id)
IconId	editorActionForPixelTool (PixelTool tool)
const std::array< KeyBindingIconEntry, KEY_BINDING_ICON_COUNT > &	keyBindingIconCatalog ()
IconId	iconForKeyBindingAction (EditorAction action)
std::optional< EditorAction >	keyBindingActionForIcon (IconId id)
void	applyApplicationStyle ()
	Choisit explicitement le style Qt de l'application (non natif, condition pour que la palette et la feuille de style s'appliquent à l'ensemble des contrôles).
QPalette	buildApplicationPalette (const DesignTokens &tokens)
	Construit une QPalette complète — groupes actif, inactif et désactivé — à partir d'un jeu de jetons.
std::string	resolvedFontFamily (FontRole role)
	Nom de famille effectivement enregistré pour la police de corps de role, ou une chaîne vide si l'enregistrement a échoué (l'appelant emploie alors une famille générique).
void	applyStyleSheet (const DesignTokens &editorTokens)
	Charge le modèle de feuille de style du châssis d'édition (:/resources/theme-editor.qss), le substitue avec editorTokens et l'applique à l'application.
void	applyFont ()
	Enregistre les polices embarquées auprès de Qt et applique la famille du châssis d'édition comme police par défaut de l'application (Assets/Fonts/) :
EditorThemeSetting	editorThemeSetting ()
void	setEditorThemeSetting (EditorThemeSetting setting)
	Persiste setting (QSettings), relu au démarrage suivant.
bool	systemPrefersDarkTheme ()
const DesignTokens &	currentEditorTokens ()
void	applyEditorTheme ()
	Applique le thème complet du châssis d'édition (portée variable) : police, palette puis feuille de style, tous dérivés des jetons actuellement effectifs (currentEditorTokens()).
void	reapplyEditorTheme ()
	Réapplique la palette et la feuille de style (mais pas la police, inchangée par le thème) depuis currentEditorTokens() — bascule à chaud (LOT-56 TACHE-06), sans reconstruire les widgets.
DesignColor	mixColor (DesignColor from, DesignColor to, float ratio) noexcept
const IdentityBaseScale &	identityBaseScale () noexcept
const char *	genericCssFamily (FontRole role) noexcept
const DesignTokens &	identityTokens () noexcept
	Jetons de l'identité du jeu (menu principal, écran Options, jeu) : invariants, ne suivent jamais aucun réglage d'affichage (EX-IHM-050).
const DesignTokens &	editorDarkTokens () noexcept
	Jetons du châssis d'édition en thème sombre (défaut) : variables, editorLightTokens() (LOT-56 TACHE-06) en fournit un second jeu.
const DesignTokens &	editorLightTokens () noexcept
	Jetons du châssis d'édition en thème clair (LOT-56 TACHE-06) : mêmes rôles, mêmes échelles que editorDarkTokens() — seules les couleurs diffèrent, et pas par simple inversion (les écarts de luminosité entre bordures/lignes alternées/fond diffèrent en clair et en sombre).
DesignColor	viewportClearColor (bool editorMode, const DesignTokens &activeEditorTokens) noexcept
	Couleur d'effacement du viewport (GameViewport), dérivée des jetons plutôt que d'une valeur littérale locale : fond de la portée variable en édition (suivant le thème actif de l'éditeur, LOT-56 TACHE-06), fond de la portée invariante en jeu et en essai — la seule surface qui appartient tour à tour aux deux portées.
std::string	toCssColor (DesignColor color)
	Conversion pure : couleur -> chaîne CSS hexadécimale "#rrggbb" (minuscules, sans alpha — les feuilles de style Qt n'acceptent l'alpha que via rgba()).
std::string	toCssRgba (DesignColor color)
	Conversion pure : couleur -> chaîne CSS "rgba(r, g, b, a)", composantes entières 0-255 (les feuilles de style Qt expriment l'alpha sur la même échelle que les autres composantes).
double	relativeLuminance (DesignColor color) noexcept
	Luminance relative WCAG d'une couleur (0 = noir, 1 = blanc), pour le calcul de contraste.
double	contrastRatio (DesignColor a, DesignColor b) noexcept
	Rapport de contraste WCAG entre deux couleurs (1 = aucun contraste, 21 = noir sur blanc).
std::unordered_map< std::string, std::string >	buildStyleSheetValues (const DesignTokens &editorTokens, int identityScale=1)
	Table de substitution marqueur -> valeur pour le modèle de feuille de style (LOT-56 TACHE-02), à partir d'un jeu de jetons du châssis d'édition (portée variable) ; les marqueurs de préfixe "identity." sont toujours résolus depuis identityTokens() (portée invariante).
WorkspaceDressing	dressingForWorkspace (EditorWorkspace workspace) noexcept
EditorWorkspaceMask	workspacesForPanel (PanelId panel) noexcept
	Espaces dans lesquels panel est affiché.
EditorWorkspace	workspaceForTool (EditorTool) noexcept
EditorWorkspace	workspaceForPixelTool (PixelTool) noexcept
constexpr EditorWorkspaceMask	workspaceBit (EditorWorkspace workspace) noexcept
constexpr bool	workspaceMaskContains (EditorWorkspaceMask mask, EditorWorkspace workspace) noexcept
FontFamilyResolution	resolveFontFamily (bool fontRegistered, const std::string &embeddedFamilyName)
	Choisit la famille de police à employer pour le corps de l'IHM.
IconGeometry	iconGeometry (IconId id)
	Décrit la géométrie d'une icône, en espace normalisé.
StyleSheetSubstitutionResult	substituteStyleSheetTemplate (const std::string &templateText, const std::unordered_map< std::string, std::string > &values)
	Remplace chaque marqueur dollar-accolade de templateText par sa valeur dans values.
QIcon	themeIcon (IconId id, int pixelSize, const DesignTokens &tokens)
	Peint une icône à la taille demandée, recolorée depuis les jetons.
EditorThemeMode	resolveEffectiveEditorTheme (EditorThemeSetting setting, bool systemPrefersDark) noexcept
	Résout le thème effectif à appliquer.
std::filesystem::path	executableDirectory ()
	Dossier contenant l'exécutable en cours, pour localiser les ressources copiées à côté (niveaux, catalogues de traduction, logs).
std::map< std::string, std::string >	characterSheetValues (const CharacterSheetContext &context)
DemonstrationCharacter	loadDemonstrationValues ()
	Charge le personnage de démonstration livré en donnée, et calcule ses deux tables.
int	identityScaleFor (int windowLogicalHeight) noexcept
	Facteur d'agrandissement des écrans du jeu pour une hauteur de fenêtre donnée.
int	identityScaleForDisplay (int windowLogicalHeight, int availableLogicalHeight) noexcept
	Facteur d'agrandissement borné par la zone d'affichage réellement disponible (EX-IHM-081).
void	splitPurse (int copper, int &gold, int &silver, int &rest)
	Répartit une somme en pièces de cuivre entre or, argent et cuivre.
std::map< std::string, std::string >	inventoryValues (const InventoryContext &context)
std::string	keyHintText (const std::vector< KeyHint > &hints, const DesignTokens &tokens, int scale)
	Compose la ligne de rappels en texte enrichi.
std::vector< BackdropQuad >	menuBackdropQuads (int width, int height, int scale)
	Pavés du décor, dans l'ordre de dessin (les derniers recouvrent les premiers).
std::span< const RpgScreenDescriptor >	rpgScreens () noexcept
const RpgScreenDescriptor &	rpgScreenDescriptor (RpgScreenId screen) noexcept
RpgScreenId	nextRpgScreen (RpgScreenId screen) noexcept
RpgScreenId	previousRpgScreen (RpgScreenId screen) noexcept
bool	pausesGame (RpgScreenId screen) noexcept
std::string	ruleLabel (std::string_view key, const std::string &language)
	Nom lisible d'un terme de règle — caractéristique, emplacement d'équipement, condition.
std::string	activeLanguage ()
ScreenDressing	dressingFor (ScreenId screen) noexcept
std::optional< ScreenState >	resolveTransition (const ScreenState &current, ScreenEvent event) noexcept
	Résout une transition d'écran à partir de l'état courant et d'un événement.
	TEST (MechanismTransitionsTest, PremierCalculRejointEtatCibleSansTransition)
	Le tout premier calcul rejoint directement l'état cible, sans jouer de transition : une porte déjà ouverte au chargement du niveau doit apparaître ouverte, pas s'ouvrir sous les yeux du joueur comme si un interrupteur venait d'être actionné.
	TEST (MechanismTransitionsTest, ChangementDetatDeclencheLaTransitionUneSeuleFois)
	Un changement d'état déclenche la transition une seule fois : les pas suivants la font progresser jusqu'à l'état cible au lieu de la relancer depuis sa première image.
	TEST (MechanismTransitionsTest, ClipDeTransitionAbsentBasculeDirectementSansAvertissement)
	Un asset qui ne fournit que les deux états, sans clips de transition, bascule directement et en silence : n'animer que les états est un choix d'artiste légitime, pas une erreur à signaler.
	TEST (MechanismTransitionsTest, ClipDEtatAbsentReplieEtJournaliseUneSeuleFois)
	Un clip d'état manquant, lui, se replie et se journalise — mais une seule fois par couple (asset, clip manquant), pas par instance : un niveau posant cinquante portes du même asset incomplet produirait sinon cinquante fois le même message.
	TEST (MechanismTransitionsTest, AucunChangementNeReinitialisePasLimageEnCours)
	À état inchangé, un appel supplémentaire ne remet pas l'image courante à zéro : c'est l'invariant qui rend le calcul appelable à chaque frame de rendu sans figer l'animation.
	TEST (MechanismTransitionsTest, SeuleLaPorteTransitionneLesAutresBasculentDirectement)
	Seule la porte a des clips de transition ; un interrupteur bascule directement entre ses deux états, silencieusement.

Variables
constexpr std::size_t	EDITOR_TOOL_COUNT = 6
	Nombre d'outils d'édition, déclaré au plus près de l'énumération qu'il compte.
constexpr core::TileType	MECHANISM_ANIMATION_TYPES []
	Les familles de mécanismes à état dont l'apparence est pilotée par un clip (LOT-47), dans l'ordre où elles sont proposées par la section « Animations ».
constexpr std::size_t	PANEL_COUNT = 8
	Nombre de panneaux, declare au plus pres de l'enumeration qu'il compte.
constexpr int	PANEL_FOCUS_CATALOG_COUNT = 2
	Nombre d'entrées de la table (tous les outils n'ont pas de panneau dédié).
constexpr int	PIXEL_PANEL_FOCUS_CATALOG_COUNT = 5
	Nombre d'entrées de la table des outils de canevas (les cinq outils du canevas mettent tous en avant le même panneau : on édite toujours en le voyant).
constexpr int	PIXEL_CANVAS_MIN_ZOOM = 1
	Zoom minimal (1 pixel image = 1 pixel écran) et maximal admis par les commandes de zoom du canevas — toujours entier, pour que les pixels restent carrés (EX-ARCH-022).
constexpr int	PIXEL_CANVAS_MAX_ZOOM = 32
constexpr int	PIXEL_CANVAS_GRID_VISIBLE_MIN_ZOOM = 4
	Facteur de zoom à partir duquel la grille de pixels est dessinée : en-deçà, elle ne ferait que du bruit visuel sur des pixels trop petits pour la distinguer du contenu.
constexpr int	PIXEL_CANVAS_MAX_DENOMINATOR = 8
	Dénominateur de zoom maximal : au-delà, un pixel image occuperait moins d'un huitième de pixel écran, et le repère cesserait d'être lisible.
const std::string	PLANE_FILE_EXTENSION = ".png"
	Extension des fichiers de plan. Un plan est une image, toujours écrite en PNG.
constexpr float	DIAGNOSTICS_FPS_WINDOW_SECONDS = 0.5f
	Fenêtre de la moyenne glissante de cadence, en secondes : assez courte pour rester réactive à une vraie dégradation, assez longue pour lisser le bruit d'une image à l'autre.
constexpr int	GAME_EVENT_COUNT = static_cast<int>(GameEvent::PauseOpened) + 1
	Nombre de valeurs de GameEvent — pour les tests d'exhaustivité (parcours de l'énumération).
const std::string	FONTS_SUBDIRECTORY = "Fonts/"
	Sous-dossier des assets de police, relatif au dossier d'assets (LOT-52).
constexpr float	LANDING_SHAKE_AMPLITUDE_PIXELS = 2.0f
	Amplitude conservatrice de la secousse d'écran à un atterrissage lourd (LOT-53 TACHE-03) : discrète, un jeu de plateforme précis devient injouable si l'écran bouge trop.
constexpr float	DEATH_SHAKE_AMPLITUDE_PIXELS = 3.0f
	Amplitude de la secousse à la mort du personnage : légèrement plus marquée que l'atterrissage.
constexpr float	SCREEN_SHAKE_DURATION = 0.2f
	Durée de toute secousse d'écran, en secondes – brève par construction.
constexpr float	DEPTH_SUBDIVISIONS_PER_UNIT = 16.0f
	Sous-divisions de profondeur par unité monde, pour la quantification du tri par Y.
constexpr float	FOLLOW_DEAD_ZONE_HALF_WIDTH_UNITS = 1.5f
	Demi-taille de la zone morte, en unités monde : le personnage se déplace librement dans ce carré centré sur le point suivi sans faire bouger la caméra – ce qui supprime le tremblement permanent d'une caméra qui collerait exactement au personnage.
constexpr float	FOLLOW_DEAD_ZONE_HALF_HEIGHT_UNITS = 1.5f
constexpr float	FOLLOW_ANTICIPATION_DISTANCE_UNITS = 2.5f
	Distance d'anticipation dans le sens du déplacement, en unités monde.
constexpr float	FOLLOW_SMOOTHING_TIME_CONSTANT_SECONDS = 0.15f
	Temps de réponse (lissage exponentiel) du centre retenu vers sa cible, en secondes.
constexpr float	FOLLOW_ANTICIPATION_TIME_CONSTANT_SECONDS = 0.25f
	Temps de réponse de l'inversion de l'anticipation au changement de sens, en secondes – plus lent que le lissage principal, pour que l'inversion se voie comme un mouvement, pas un saut.
constexpr std::size_t	RENDER_LAYER_COUNT
	Nombre de valeurs de hmi::RenderLayer — dimensionne un tableau indexé par la valeur plutôt que par une liste de champs écrite à la main (voir hmi::LayerVisibility).
constexpr const char *	MECHANISM_CLIP_DOOR_CLOSED = "closed"
	Noms de clip conventionnels, documentés dans Source/Elements/Assets/README.md — c'est le contrat qu'un auteur d'asset doit respecter pour que son animation soit reconnue.
constexpr const char *	MECHANISM_CLIP_DOOR_OPENING = "opening"
constexpr const char *	MECHANISM_CLIP_DOOR_OPEN = "open"
constexpr const char *	MECHANISM_CLIP_DOOR_CLOSING = "closing"
constexpr const char *	MECHANISM_CLIP_SWITCH_INACTIVE = "inactive"
constexpr const char *	MECHANISM_CLIP_SWITCH_ACTIVE = "active"
constexpr const char *	MECHANISM_CLIP_PLATE_RELEASED = "released"
constexpr const char *	MECHANISM_CLIP_PLATE_PRESSED = "pressed"
constexpr const char *	MECHANISM_CLIP_KEY_PRESENT = "present"
constexpr const char *	MECHANISM_CLIP_KEY_COLLECTED = "collected"
constexpr const char *	MECHANISM_CLIP_LOCKED_DOOR_CLOSED = "closed"
constexpr const char *	MECHANISM_CLIP_LOCKED_DOOR_OPEN = "open"
constexpr int	MISSING_TEXTURE_SIZE = 16
	Côté, en pixels, du damier de repli généré par défaut (une case, EX-ARCH-021).
constexpr int	MISSING_TEXTURE_CHECKER_SIZE = 4
	Côté, en pixels, d'un carreau du damier : quatre carreaux par côté, motif lisible même réduit.
constexpr float	PARALLAX_FACTOR_NONE = 1.0f
	Facteur neutre : le contenu est solidaire du niveau et ne subit aucun décalage.
constexpr float	PARTICLE_QUAD_SIZE = 0.12f
	Côté du carré teinté d'une particule, en unités monde (LOT-53 TACHE-03 : « un simple carré teinté suffit pour un premier jet », pas d'asset dédié).
const std::string	PLANES_SUBDIRECTORY = "Plans/"
	Sous-dossier des images de plans, relatif au dossier des niveaux — un plan est une donnée de niveau, pas un asset réutilisable : il ne vit pas sous Assets/.
constexpr std::size_t	PLANE_TEXTURE_BYTES_PER_PIXEL = 4
	Octets par texel d'une texture de plan : R8G8B8A8_UNORM, comme toute texture du projet.
const std::string	PLAYER_SUBDIRECTORY = "Player/"
	Sous-dossier de la spritesheet du personnage, relatif au dossier d'assets (LOT-48).
const std::string	PLAYER_SHEET_FILE_NAME = "player.png"
	Nom logique de la spritesheet du personnage (LOT-48).
constexpr int	PLAYER_IDLE_FRAME_COUNT = 2
	Nombre d'images du clip Idle.
constexpr int	PLAYER_RUN_FRAME_COUNT = 4
	Nombre d'images du clip Run.
constexpr int	PLAYER_JUMP_FRAME_COUNT = 1
	Nombre d'images du clip Jump (pose unique, jamais animée).
constexpr int	FONT_METRICS_FORMAT_VERSION = 1
	Version du format de métriques écrite dans le fichier, et plus élevée qui soit lue (hmi::loadFontMetricsFromString).
constexpr RenderLayer	DEFAULT_RENDER_LAYER = RenderLayer::Tile
	Calque appliqué à une entité dépourvue de hmi::RenderLayerTag.
constexpr RenderMode	DEFAULT_RENDER_MODE = RenderMode::Texture
	Mode appliqué au premier lancement et à défaut de préférence exploitable.
constexpr float	SHADOW_OFFSET_X = 1.0f / 16.0f
	Décalage de l'ombre par rapport à sa tuile, en unités monde (1 pixel à 16 px/unité).
constexpr float	SHADOW_OFFSET_Y = 1.0f / 16.0f
constexpr float	SHADOW_OPACITY = 0.4f
	Opacité de l'ombre (constante, cf. décisions de cadrage du LOT-55 : pas de réglage designer).
const std::string	SKINS_SUBDIRECTORY = "Skins/"
	Sous-dossier des skins de tuiles, relatif au dossier d'assets (LOT-42).
const std::string	BACKGROUNDS_SUBDIRECTORY = "Backgrounds/"
	Sous-dossier des fonds de niveau, relatif au dossier d'assets (LOT-44).
const std::string	OBJECTS_SUBDIRECTORY = "Objects/"
	Sous-dossier des textures d'objets interactifs, relatif au dossier d'assets (LOT-45).
constexpr int	AUTOTILE_SHEET_SIDE = 4
	Nombre de cases par côté de la planche de raccords (4×4 = seize configurations).
constexpr int	AUTOTILE_CONFIGURATION_COUNT = AUTOTILE_SHEET_SIDE * AUTOTILE_SHEET_SIDE
	Nombre de configurations de voisinage distinctes.
constexpr std::array< core::TileType, 0 >	SILHOUETTE_TILE_TYPES {}
	Types de tuile dont la matière n'occupe pas toute la case, et qui doivent donc être détourées à l'affichage plutôt que dessinées en carré plein.
constexpr int	SILHOUETTE_TILE_TYPE_COUNT = static_cast<int>(SILHOUETTE_TILE_TYPES.size())
	Nombre de types de tuile à silhouette (voir SILHOUETTE_TILE_TYPES).
constexpr int	EDITOR_ACTION_COUNT = 10
	Nombre d'actions d'éditeur remappables (EditorAction).
constexpr int	GAME_ACTION_COUNT = 7
	Nombre d'actions de jeu remappables (GameAction).
constexpr int	GAMEPAD_BUTTON_COUNT = 10
	Nombre de boutons manette remappables (GamepadButton).
constexpr std::chrono::milliseconds	GAMEPAD_DISCONNECTED_PROBE_PERIOD {2000}
	Délai minimal entre deux sondages XInput d'un slot resté déconnecté (anti-saccade).
constexpr int	EDITOR_ACTION_CATALOG_COUNT = 30
	Nombre total d'actions du catalogue (six outils de niveau, cinq outils de canevas pixel art, onze commandes principales, quatre commandes de fichier de l'atelier, quatre commandes de région de l'atelier).
constexpr int	TOOLBAR_COMMAND_BUDGET = 5
	Nombre d'actions hors sélection d'outil admises dans une barre d'outils (LOT-68).
constexpr int	KEY_BINDING_ICON_COUNT = 9
	Nombre d'actions d'éditeur remappables ayant une commande effective (EDITOR_ACTION_COUNT moins TextureAssignTool).
constexpr std::size_t	EDITOR_WORKSPACE_COUNT = 3
	Nombre d'espaces, déclaré au plus près de l'énumération qu'il compte.
constexpr int	IDENTITY_BASE_HEIGHT = 360
	Hauteur, en pixels logiques, de la maquette à l'échelle 1.
constexpr int	IDENTITY_MAX_SCALE = 3
	Plus grand facteur admis.
constexpr float	BACKDROP_VEIL_WIDTH_RATIO = 0.55f
	Part de la largeur couverte par le voile de lisibilité, sous le titre et les entrées de menu.
constexpr int	BACKDROP_VEIL_STEPS = 6
	Nombre de bandes du voile.
constexpr std::size_t	RPG_SCREEN_COUNT = 9
	Nombre d'écrans du catalogue.

Typedef Documentation

EditorWorkspaceMask

using hmi::EditorWorkspaceMask = unsigned

Ensemble d'espaces, un bit par valeur de hmi::EditorWorkspace.

TextureHandle

using hmi::TextureHandle = void*

Identité opaque d'une texture liée, du point de vue de la composition.

La composition du rendu ne fait que comparer et regrouper des textures ; elle n'a jamais besoin d'en connaître le type Direct3D. Ce typage volontairement opaque permet de la garder libre de toute dépendance GPU (et donc testable sans carte, EX-NFR-004) : côté soumission, hmi::SpriteBatch reconvertit la valeur en QRhiTexture*, seule couche qui en connaisse le type réel. Une valeur nulle désigne « aucune texture liée ».

Enumeration Type Documentation

Ability

enum class core::Ability

strong

Une des six caractéristiques d'un personnage ou d'une créature (EX-DND-010).

Ensemble fermé : six valeurs, fixées par les règles. Les noms textuels sont ceux du lexique (LOT-30) et de common.schema.json, et scripts/check_rpg_data.py vérifie que les trois listes coïncident.

ActionSurface

enum class hmi::ActionSurface

strong

Surface d'une action (LOT-68, EX-IHM-074).

EX-IHM-055 posait qu'une commande placée à plusieurs endroits reste une seule définition ; il restait à arbitrer lesquelles méritent une place permanente à l'écran.

La barre d'outils ne porte que ce qui se déclenche au fil du geste : sélection d'outil, enregistrement, annulation, essai. Tout le reste vit au menu — atteignable, découvrable (EX-EDIT-015), mais sans occuper l'écran en permanence. C'est la même QAction dans les deux cas : le champ décide de sa présentation, jamais de son existence.

Enumerator
ToolBarAndMenu	Barre d'outils et menu : usage continu.
MenuOnly	Menu seul (plus son raccourci) : usage ponctuel.

AnimationCatalogError

enum class hmi::AnimationCatalogError

strong

Catégorie d'échec de lecture d'une description d'animation (même esprit que hmi::SkinCatalogError/core::LevelValidationError).

Enumerator
None	Pas d'erreur.
FileNotFound	Fichier absent. Cas légitime (image fixe), pas une anomalie.
ParseError	JSON malformé, ou racine qui n'est pas un objet.
UnsupportedVersion	Numéro de version supérieur à AnimationCatalog::FORMAT_VERSION.
MalformedStructure	Structure inattendue (clip sans « frames », next inexistant…).
IncoherentFrameSize	Taille d'image déclarée incohérente avec les dimensions du PNG.

AppearanceSource

enum class hmi::AppearanceSource

strong

Texture d'où provient l'apparence résolue.

Enumerator
Atlas	Atlas du jeu : couleur plate par type de tuile, images du personnage, aides d'édition.
MissingTexture	Damier magenta de repli : texture attendue mais pas encore disponible (EX-NFR-040).
Skin	Skin assigné au type de tuile, désigné par hmi::TileAppearance::skinIndex (LOT-42).
Override	Texture assignée par instance à la case, désignée par hmi::TileAppearance::skinIndex (index dans hmi::SceneTextures::objects) — prioritaire sur Skin (EX-EDIT-043, LOT-45).

AssetFamily

enum class hmi::AssetFamily

strong

Famille d'un asset graphique, qui détermine les dimensions attendues du fichier image.

Chaque famille correspond à un usage du programme d'habillage (LOT-40 → LOT-55) : ce n'est pas une classification esthétique mais le contrat que le fichier doit respecter pour être découpable par le rendu.

Enumerator
Atlas	Atlas historique du jeu (Assets/atlas.png) : grille de tuiles carrées + images du personnage sous la grille (LOT-39).
TileSkin	Skin d'une tuile isolée : exactement une case (LOT-42).
AutotileSheet	Planche à raccords automatiques : grille de cases entières, au moins 4×4 (LOT-42).
Background	Image de fond de niveau : dimensions libres, l'étirement est fait au rendu (LOT-44).
Object	Texture d'un objet interactif (interrupteur, porte, danger) : grille de cases (LOT-45).
CharacterSheet	Spritesheet du personnage : grille d'images carrées de la taille d'une case (LOT-48).
Font	Atlas de glyphes d'une police bitmap : dimensions libres, découpées par ses métriques (LOT-52), pas par une grille de cases.

BackdropRole

enum class hmi::BackdropRole

strong

Rôle de couleur d'un pavé du décor, résolu depuis les jetons au moment du rendu.

Enumerator
SkyHigh	Haut du ciel, la valeur la plus sombre.
SkyMid	Bande intermédiaire.
SkyLow	Bande proche de l'horizon, la plus claire du ciel.
Star	Étoile vive.
StarDim	Étoile en retrait.
Moon	Disque lunaire.
MoonCrater	Cratère, une nuance sous le disque.
Silhouette	Bâtiments lointains, à l'horizon.
Hill	Collines de plan intermédiaire.
Ground	Sol de premier plan.
GroundEdge	Liseré supérieur du sol, qui lui donne son épaisseur.
Veil	Voile de lisibilité, posé par bandes sous le texte.

EditorAction

enum class hmi::EditorAction

strong

Action d'éditeur logique, remappable indépendamment de la touche physique.

Sous-ensemble significatif des raccourcis de l'éditeur (hmi::GameViewport, mode édition), pas exhaustif (décision de cadrage LOT-29) : navigation de menu, redimensionnement par flèches, Ctrl+R, "0", Tab, Maj+clic restent câblés en dur. Le modificateur Ctrl de Save/Undo/Redo/Copy/Paste reste lui-même câblé en dur ; seule la touche-lettre associée est ici remappable.

Enumerator
Save
Undo
Redo
Copy
Paste
Playtest
ToggleGrid
ToggleHelp
Rename
TextureAssignTool	Sélectionne l'outil « Texture par instance » (LOT-45, EX-EDIT-043).

EditorActionGroup

enum class hmi::EditorActionGroup

strong

Groupe d'exclusivité d'une action : les outils d'édition forment un groupe exclusif (un seul actif à la fois) ; les commandes n'appartiennent à aucun groupe.

PixelTools (LOT-54 TACHE-04) est un second groupe exclusif, distinct de LevelTools : les outils du canevas pixel art et ceux du niveau ne s'excluent jamais entre eux, seulement au sein de leur propre groupe. PixelCommands (LOT-54 TACHE-05) n'est pas exclusif (comme None) mais reste tagué séparément : ces commandes vivent dans la barre d'outils du canevas, jamais dans celle du niveau.

Enumerator
None
LevelTools
PixelTools
PixelCommands

EditorThemeMode

enum class hmi::EditorThemeMode

strong

Thème effectivement appliqué au châssis d'édition.

Enumerator
Light
Dark

EditorThemeSetting

enum class hmi::EditorThemeSetting

strong

Réglage choisi par l'utilisateur (menu Affichage de l'éditeur, persisté entre sessions).

Enumerator
System
Light
Dark

EditorTool

enum class hmi::EditorTool

strong

Outil actif dans la grille de l'éditeur, changé via Tab ou la barre d'outils (hmi::EditorActions).

Paint peint case par case au clic/glisser (comportement LOT-14, inchangé). Rectangle peint un rectangle entier au relâchement d'un glisser. Selection définit une zone (glisser) dont le contenu peut être copié (Ctrl+C) puis collé ailleurs (Ctrl+V), sans peindre directement. Link (LOT-37, EX-IHM-030) lie/délie un mécanisme : cliquer un déclencheur (interrupteur/ plaque) passe en attente de cible, cliquer une cible (porte/danger commuté) crée la liaison ; refaire la même paire la supprime (bascule) — voir hmi::resolveLinkClick. Échap annule une attente en cours (revient à aucune case sélectionnée), sans toucher au brouillon. TextureAssign (LOT-45, EX-EDIT-043) assigne une texture par instance à une case : clic gauche assigne/remplace l'asset sélectionné dans la bibliothèque, reclic du même asset ou clic droit retire l'assignation — voir hmi::resolveTextureAssignClick. CameraZone (LOT-64, EX-LVL-007, EX-EDIT-029) dessine une zone de caméra du mode par salle : un glisser (comme Rectangle) définit un rectangle de cases, ajouté à core::CameraFramingConfig::zones au relâchement (core::LevelDraft::addCameraZone) ; les zones existantes se retirent depuis le tableau de la section « Cadrage » du panneau Textures, pas depuis le canevas.

Enumerator
Paint
Rectangle
Selection
Link
TextureAssign
CameraZone

EditorWorkspace

enum class hmi::EditorWorkspace

strong

Espace de travail actif. Ils s'excluent : aucun état intermédiaire n'existe.

Enumerator
Level	Édition de niveau.
Planes	Mode création : peinture des plans picturaux (LOT-69, EX-EDIT-046).
PixelArt	Atelier pixel art.

FontMetricsError

enum class hmi::FontMetricsError

strong

Catégorie d'échec de lecture d'un fichier de métriques (même esprit que hmi::AnimationCatalogError).

Enumerator
None	Pas d'erreur.
FileNotFound	Fichier absent. Cas attendu (repli procédural), pas une anomalie.
ParseError	JSON malformé, ou racine qui n'est pas un objet.
UnsupportedVersion	Numéro de version supérieur à FONT_METRICS_FORMAT_VERSION.
MalformedStructure	Structure inattendue (glyphe sans région, point de code invalide…).

FontRole

enum class hmi::FontRole

strong

Famille de police d'une portée (LOT-68, EX-IHM-070).

La distinction est un rôle, pas un nom de police : Identity reste Identity le jour où la police pixel embarquée change.

Enumerator
Ui	Châssis d'édition : police de travail, lisible en petit et en tableau dense.
Identity	Écrans du jeu : police bitmap, rendue sans lissage à échelle entière.

GameAction

enum class hmi::GameAction

strong

Action de jeu logique, remappable indépendamment de la touche physique qui la déclenche.

Miroir des sept lectures de PlayerInputMapper.cpp. Chaque action a une touche unique et pleinement remappable — aucun alias fixe : un alias câblé en dur sur une touche donnée entrerait en collision dès qu'une autre action est remappée sur cette même touche, les deux se déclenchant à la fois (silencieusement annulé pour une paire opposée comme Gauche/Droite, voir PlayerInputMapper.cpp).

Enumerator
MoveLeft
MoveRight
AimUp
AimDown
Jump
Dash
Interact

GameEvent

enum class hmi::GameEvent

strong

Événement discret survenu sur un pas de simulation ou une action d'interface.

Unifie les transitions de jeu (personnage, mécanismes) et d'interface (menus, écrans du LOT-59) sous une seule énumération : c'est ce qui permet à hmi::SoundTriggers de leur associer un son par une table exhaustive unique, et à LOT-53 de réutiliser la même énumération pour ses particules sans dupliquer la détection.

Enumerator
Jumped
Landed
Dashed
WallContactEnter
SwitchToggled
DoorOpened
DoorClosed
PressurePlatePressed
PressurePlateReleased
BlockPushed
Died
ExitReached	La sortie de la carte a été atteinte. Ne termine plus rien depuis le LOT-67 : le bac à sable n'a pas de tableau à finir. Elle redeviendra une transition vers la carte que le graphe du LOT-09 désignera.
MenuNavigate
MenuConfirm
MenuBack
PauseOpened

GamepadButton

enum class hmi::GamepadButton

strong

Bouton (ou direction) manette remappable à une action de jeu (EX-CTRL-002, LOT-30).

Up/Down/Left/Right fusionnent le D-pad et le stick gauche en une seule notion logique par direction — le joueur ne perçoit pas la différence entre les deux, et Window::pollGamepad les a toujours traités comme équivalents. Start/Back, les clics de stick et les gâchettes analogiques ne sont pas représentés : conventions globales ou hors périmètre (voir l'épic du lot).

Enumerator
Up
Down
Left
Right
A
B
X
Y
LeftShoulder
RightShoulder

IconColorRole

enum class hmi::IconColorRole

strong

Rôle de couleur d'un trait, résolu depuis les jetons de design au moment du rendu (recoloration automatique avec le thème, y compris après une bascule TACHE-06).

Enumerator
Foreground
Accent

IconId

enum class hmi::IconId

strong

Identifiant d'une icône : un par outil d'édition et par commande principale.

Enumerator
ToolPaint
ToolRectangle
ToolSelection
ToolLink
ToolTextureAssign
ToolCameraZone
Save
Playtest
Undo
Redo
ToggleGrid
ResetCamera
ToggleRenderMode
Copy
Paste
Rename
ShortcutsOverview
PixelBrush
PixelEraser
PixelFill
PixelEyedropper
PixelOpen
PixelCreate
PixelSave
PixelSaveAs
PixelSelectionTool
PixelFlipHorizontal
PixelFlipVertical
PixelRotateClockwise
PixelRotateCounterClockwise

Key

enum class hmi::Key : std::uint16_t

strong

Touche du clavier, identifiée par son code virtuel Win32.

Les valeurs coïncident volontairement avec les codes VK_* de Win32, ce qui permet à la couche de capture (Window) de convertir directement un WPARAM en Key par un simple static_cast, sans table de correspondance. Seules les touches utiles au menu et à la navigation sont nommées ici ; l'InputState stocke néanmoins n'importe quel code, si bien qu'ajouter une touche revient à ajouter un énumérateur (aucune autre modification).

Enumerator
Backspace
Tab
Enter
Shift
Control
Escape
Space
Left
Up
Right
Down
D0
A
C
D
E
P
Q
R
S
T
V
W
Y
Z
F1
F2
F10

LinkGestureAction

enum class hmi::LinkGestureAction

strong

Action à appliquer sur le brouillon/l'état d'édition suite à un clic de l'outil « Lien ».

Enumerator
Ignore	Case cliquée ni déclencheur ni cible : sans effet.
SetPending	Aucune attente valide : la case cliquée devient l'attente.
ReplacePending	Attente de même catégorie que le clic : remplacée par la case cliquée.
Link	Catégories complémentaires, pas encore liées : créer la liaison.
Unlink	Catégories complémentaires, déjà liées : supprimer la liaison (bascule).

LinkKind

enum class hmi::LinkKind

strong

Nature d'une liaison affichée (couleur/libellé distincts dans le panneau et le rendu).

Enumerator
Mechanism

MouseButton

enum class hmi::MouseButton : std::uint8_t

strong

Bouton de la souris suivi par l'InputState.

Count n'est pas un bouton : c'est la sentinelle donnant le nombre de boutons suivis (dimension des tableaux d'état).

Enumerator
Left
Right
Middle
Count

NeighborBits

enum hmi::NeighborBits : std::uint8_t

Bits du masque de voisinage, un par voisin orthogonal solide.

Quatre voisins et non huit : seize configurations couvrent bords et coins concaves, et demandent à l'auteur une planche de seize cases plutôt que quarante-sept — proportionné à un jeu dont les assets sont dessinés à la main. Le champ mode de hmi::SkinEntry permettra d'ajouter un bitmask47 sans refonte si ce rendu s'avère insuffisant.

Enumerator
NEIGHBOR_UP	Voisin du dessus solide.
NEIGHBOR_RIGHT	Voisin de droite solide.
NEIGHBOR_DOWN	Voisin du dessous solide.
NEIGHBOR_LEFT	Voisin de gauche solide.

PaletteThumbnailSource

enum class hmi::PaletteThumbnailSource

strong

D'où provient la vignette affichée par la palette pour un type de tuile.

Enumerator
Atlas	Couleur plate de l'atlas : mode Physique, ou repli si l'atlas fait foi.
Skin	Fichier de skin, dans le dossier Assets/Skins/.
MissingTexture	Damier magenta : le type n'est pas encore habillé (EX-NFR-040).

PanelId

enum class hmi::PanelId

strong

Panneau dockable de l'éditeur.

Couvre les neuf docks depuis le LOT-69 : la mise en avant automatique (EX-IHM-061) n'en concerne toujours qu'une partie, mais la répartition par espace de travail (EX-IHM-073) les concerne tous, et une énumération partielle laisserait des panneaux sans espace.

Enumerator
Palette
Levels
Links
Textures
Planes
PixelCanvas
PixelHistory
PixelPalette

PixelOperationKind

enum class hmi::PixelOperationKind

strong

Type d'une opération d'historique — détermine sa clé de traduction (EX-REN-033).

Ce nom sert deux fois : dans le libellé de l'action « Annuler … » (TACHE-04) et dans le panneau d'historique visuel. D'autres membres rejoignent cette énumération aux tâches suivantes (déplacement de région, symétries, rotations, coller — TACHE-06).

Enumerator
Brush
Eraser
Fill
Move
FlipHorizontal
FlipVertical
RotateClockwise
RotateCounterClockwise
Paste

PixelTool

enum class hmi::PixelTool

strong

Outil actif du canevas pixel art — détermine ce que produisent les gestes de souris (hmi::PixelCanvas) et forme un groupe exclusif distinct de hmi::EditorTool (hmi::EditorActions, TACHE-04).

Enumerator
Brush
Eraser
Fill
Eyedropper
Selection	Sélection rectangulaire (LOT-54 TACHE-06) : glisser hors d'une sélection existante en définit une nouvelle ; glisser à l'intérieur la déplace (hmi::moveRegion).

PlayerClipKind

enum class hmi::PlayerClipKind

strong

Identité des trois clips historiques du personnage, côté présentation seulement.

Distinct de core::AnimationClip (donnée générique, LOT-46) : l'atlas procédural reste le repli et la référence visuelle du personnage (LOT-39), peint « en dur » à partir de trois poses connues à la compilation — Core n'a, depuis LOT-46, plus aucune connaissance de ces trois clips en particulier (EX-ARCH-012). L'ordre des valeurs est celui de core::playerClipSet() (Core/Ecs/Systems/AnimationSystem.h, PLAYER_CLIP_IDLE/_RUN/ _JUMP) : c'est HMI (GameSession::refreshPlayerSprite) qui fait le pont entre l'index de clip résolu par Core et cette énumération.

Enumerator
Idle
Run
Jump

QuadKind

enum class hmi::QuadKind

strong

Nature d'une primitive composée : rectangle aligné aux axes, ou segment épais orienté.

Enumerator
Sprite	hmi::SpriteQuad : rectangle aligné sur les axes.
Line	hmi::LineQuad : segment épais, orienté librement.

RenderLayer

enum class hmi::RenderLayer : std::int32_t

strong

Calques de dessin, du plus arrière au plus avant (EX-REN-014, EX-DEC-002).

L'ordre de déclaration est l'ordre de dessin : une valeur déclarée plus bas est dessinée par-dessus les précédentes. C'est le seul ordonnancement de calques du projet — aucun lot ne doit en inventer un concurrent, sous peine de rendre l'ordre visuel dépendant de qui dessine en dernier (EX-REN-014).

Toutes les valeurs sont réservées dès LOT-40, même celles qu'aucun code n'utilise encore (Background en LOT-44, Plane/Foreground en LOT-49, Shadow en LOT-55, Object en LOT-45, UI en LOT-52) : c'est précisément cette anticipation qui évite qu'un lot suivant réinvente son propre empilement. Seules Tile, Player et EditorOverlay sont utilisées à ce jour, et elles reproduisent exactement l'ordre d'avant le lot (tuiles sous personnage, aides d'édition au-dessus de tout).

Foreground est au-dessus de Player par construction : c'est le contrat de lecture « ce qui passe devant le personnage n'est pas physique » (EX-DEC-042).

Le nombre de plans picturaux d'un niveau est libre (LOT-69), mais aucun n'ajoute de valeur ici : les plans occupent Plane ou Foreground selon leur profondeur, et leur rang dans la liste du niveau les ordonne à l'intérieur du calque. Donner une valeur d'énumération à chaque plan figerait dans le rendu ce que le format déclare variable, et ferait enfler RENDER_LAYER_COUNT, donc hmi::LayerVisibility.

Notion de présentation (HMI) : Core l'ignore et continue de ne connaître que core::Sprite::layer, entier de tri fin à l'intérieur d'un calque (EX-NFR-011).

Enumerator
Background	Image de fond du niveau (LOT-44, EX-REN-044).
Plane	Plans picturaux derrière les tuiles, éventuellement en parallaxe (LOT-69, EX-DEC-042). Nommé Decor jusqu'au LOT-69 : laisser un calque porter le nom d'un système retiré serait exactement la dette que EX-REN-014 cherche à éviter.
Shadow	Ombres portées des tuiles solides (LOT-55, EX-REN-045).
Tile	Tuiles physiques du niveau — le seul calque peuplé avant LOT-42.
Object	Objets interactifs (interrupteurs, portes, dangers) et décor traversé : tout ce qui partage la profondeur du personnage (LOT-45/LOT-47, LOT-07).
Player	Personnage joueur. Même bande de profondeur que Object depuis le LOT-07 : les deux s'ordonnent entre eux par le Y de leur pied, pas par leur rang de calque.
Foreground	Plans picturaux devant le personnage (LOT-69, EX-DEC-042).
UI	Texte et interface en scène (LOT-52, EX-REN-031).
EditorOverlay	Aides d'édition : grille de repère, liens de mécanismes, aperçu de sélection.

RenderMode

enum class hmi::RenderMode

strong

Mode de rendu de la scène : lecture directe des collisions, ou habillage.

Deux valeurs, jamais trois : la superposition et le contrôle fin par calque relèvent de LOT-51 et sont délibérément une autre notion. La bascule est purement visuelle — elle ne touche ni la simulation, ni la scène ECS, seulement la résolution de l'apparence (hmi::resolveTileAppearance).

Enumerator
Physique	Couleur plate par type de tuile : la géométrie de collision se lit directement à l'écran.
Texture	Habillage par textures, construit lot après lot à partir de LOT-42. Tant qu'aucun skin n'existe, tout s'affiche avec le damier de repli — c'est le comportement attendu, pas un défaut (EX-NFR-040).

RpgBlockKind

enum class hmi::RpgBlockKind

strong

Genres de blocs que le châssis sait peindre.

Volontairement peu nombreux : sept formes suffisent aux huit écrans, et un genre ajouté pour un seul écran est le premier pas vers huit écrans écrits à la main.

Enumerator
Fields	Lignes « libellé → valeur ». labelKeys en donne les libellés.
Grid	Grille de cases vides (sac, caractéristiques) : columns x rows.
List	Liste d'entrées vides (quêtes, marchandises) : rows lignes.
Prose	Bloc de texte suivi (réplique, description de contrat).
Portrait	Cadre d'illustration carré (interlocuteur, blason).
Track	Suite horizontale de jetons (ordre d'initiative) : columns jetons.
ActionBar	Barre d'actions : columns cases larges, alignées en bas.

RpgScreenId

enum class hmi::RpgScreenId

strong

Les huit écrans du RPG.

L'ordre est celui du cycle de navigation (nextRpgScreen/previousRpgScreen) et celui de la table de rpgScreens().

Enumerator
CharacterSheet	Fiche de personnage (remplie par le LOT-38).
Inventory	Inventaire et équipement (LOT-14).
QuestJournal	Journal de quêtes (LOT-16).
WorldMap	Carte du monde (LOT-42).
Dialogue	Dialogue avec un PNJ (LOT-15).
Merchant	Marchand (LOT-26).
GuildBoard	Tableau de la Guilde des Aventuriers (LOT-45).
CombatHud	Affichage tête haute de combat (LOT-24).
TeamSheet	Feuille d'équipe (planche 5 de la maquette Tanares, LOT-38) : renommée, blason, quartier général. Remplie par la Guilde (LOT-45, LOT-83).

RpgSuperposition

enum class hmi::RpgSuperposition

strong

Règle de superposition d'un écran (EX-IHM-091) : ce qui met le jeu en pause et ce qui se consulte en marchant.

Portée par la description de l'écran, jamais par le code qui l'ouvre : une règle décidée à l'ouverture se contredit d'un point d'appel à l'autre, et personne ne peut la relire d'un coup d'œil.

Enumerator
PausesGame	La simulation est suspendue tant que l'écran est ouvert : on ne lit pas sa fiche en esquivant un gobelin.
WhileWalking	L'écran se consulte en marchant : la simulation continue derrière lui.

ScreenEvent

enum class hmi::ScreenEvent

strong

Événement pouvant déclencher une transition d'écran.

Un seul événement OpenOptions/ CloseOptions sert Menu et Pause : c'est ScreenState::optionsReturnTo (pas l'événement) qui porte la différence, cf. plus bas.

Enumerator
OpenMenu
OpenEditor
OpenGame
OpenOptions
CloseOptions
OpenPause
ResumePause
QuitPauseToMenu
OpenCredits
CloseCredits
OpenRpgScreen	Ouvre un écran du RPG. Un seul événement pour les huit, et depuis trois écrans (Menu, Game, Pause) : c'est ScreenState::rpgReturnTo qui porte la différence, comme optionsReturnTo le fait pour Options.
CloseRpgScreen

ScreenId

enum class hmi::ScreenId

strong

Écran actuellement affiché par la fenêtre principale.

Enumerator
Menu
Editor
Game
Options
Pause
Credits
RpgScreen	Un écran du RPG est ouvert (LOT-68, EX-IHM-090). Lequel des huit n'est pas la question de cette table : c'est celle de hmi::RpgScreenHost, qui les héberge tous sur une seule page. Les y déclarer un par un aurait multiplié par huit les transitions à écrire pour n'exprimer, huit fois, que la même règle.

SkinCatalogError

enum class hmi::SkinCatalogError

strong

Catégorie d'échec de lecture d'un skins.json (même esprit que core::LevelValidationError).

Complète le message technique d'un code programmatique, pour qu'un appelant puisse réagir sans analyser le texte du message — une comparaison de sous-chaînes se casserait à la première reformulation.

Enumerator
None	Pas d'erreur.
FileNotFound	Fichier absent. Cas légitime, pas une anomalie (voir ci-dessous).
ParseError	JSON malformé, ou racine qui n'est pas un objet.
UnsupportedVersion	Numéro de version supérieur à SkinCatalog::FORMAT_VERSION.
MalformedStructure	Structure inattendue (« jeux » absent, entrée sans « asset »…).

SkinMode

enum class hmi::SkinMode

strong

Manière dont l'asset d'un type de tuile est découpé à l'affichage (EX-EDIT-025).

Le mode est porté par type, jamais par jeu : un même jeu contient des types à raccords (les solides) et des types à image unique (dangers, mécanismes). Un mode global forcerait des exceptions dans le code de rendu.

Enumerator
Single	Image unique, utilisée telle quelle. Seul mode qui ait un sens pour un type dont le voisinage n'en a pas : dangers, interrupteurs, portes, blocs, pentes et arrondis.
Bitmask16	Planche de 4×4 cases, dont celle affichée est choisie selon les quatre voisins solides (hmi::autotileCell). Dé-répétition et bords distincts de l'intérieur.

SoundCatalogError

enum class hmi::SoundCatalogError

strong

Catégorie d'échec de lecture d'un sounds.json (même patron que hmi::SkinCatalogError/hmi::AnimationCatalogError).

Enumerator
None	Pas d'erreur.
FileNotFound	Fichier absent. Cas légitime (catalogue vide), pas une anomalie.
ParseError	JSON malformé, ou racine qui n'est pas un objet.
UnsupportedVersion	Numéro de version supérieur à SoundCatalog::FORMAT_VERSION.
MalformedStructure	Structure inattendue (« sons » absent, entrée invalide…).

TextHorizontalAnchor

enum class hmi::TextHorizontalAnchor

strong

Ancrage horizontal d'un texte composé (hmi::composeText).

Enumerator
Left
Center
Right

TextureAssignAction

enum class hmi::TextureAssignAction

strong

Action à appliquer sur le brouillon suite à un clic de l'outil « Texture par instance ».

Enumerator
Ignore	Case vide, ou aucun asset sélectionné dans la bibliothèque : sans effet.
Assign	Assigne (ou remplace) l'override de la case avec l'asset sélectionné.
Remove	Retire l'override existant de la case.

TextVerticalAnchor

enum class hmi::TextVerticalAnchor

strong

Ancrage vertical d'un texte composé (hmi::composeText).

Enumerator
Top
Middle
Bottom

Function Documentation

activeCameraZoneIndex()

std::optional< std::size_t > hmi::activeCameraZoneIndex ( const std::vector< core::CameraZone > & zones, core::GridPosition position )

nodiscardnoexcept

Indice de la zone active de zones à position.

Fonction pure, testable sans GPU (EX-NFR-004), même patron que hmi::RoomGrid pour le découpage automatique. La première zone de la liste qui contient position est retenue : l'ordre porte donc la priorité en cas de chevauchement — pas de règle de résolution supplémentaire à inventer.

Parameters

zones	Zones de caméra du niveau (core::CameraFramingConfig::zones).
position	Position (case) dont on cherche la zone de caméra active.

Returns

L'indice dans zones de la première zone contenant position ; std::nullopt si aucune zone ne la contient (repli sur le cadrage niveau entier, côté appelant).

activeLanguage()

std::string hmi::activeLanguage ( )

nodiscard

Returns

La langue de l'IHM telle que les réglages la persistent (« fr » par défaut).

advanceFollowCamera()

FollowCameraState hmi::advanceFollowCamera ( const FollowCameraState & previous, core::Vector2 characterPosition, core::Vector2 facing, const core::Rect & levelBounds, core::Vector2 viewHalfExtent, float fixedDelta )

nodiscardnoexcept

Avance la caméra de suivi d'un pas fixe.

Fonction pure : mêmes entrées, même résultat (EX-NFR-002, testable sans GPU). N'affecte jamais la simulation (EX-ARCH-012) – elle ne fait que lire une position déjà simulée.

Parameters

previous	État du pas précédent (FollowCameraState{} par défaut au premier appel après un chargement de niveau).
characterPosition	Position simulée du personnage (centre de sa boîte), en unités monde.
facing	Direction de marche du personnage (core::Actor::facing), vecteur de norme au plus 1 ; le vecteur nul conserve la dernière anticipation (immobile, rien à réviser).
levelBounds	Rectangle du niveau, en unités monde (coin haut-gauche + dimensions).
viewHalfExtent	Demi-largeur/demi-hauteur de la zone visible par la caméra, en unités monde – détermine la marge de bornage aux limites du niveau.
fixedDelta	Durée du pas fixe, en secondes (EX-REN-021) – jamais un delta de rendu, sous peine de dépendre de la fréquence d'affichage.

Returns

Le nouvel état, dont center est prêt à l'usage (borné, pas encore aligné au pixel).

advanceMechanismVisual()

core::AtlasRegion hmi::advanceMechanismVisual ( MechanismVisualState & state, const AnimationDescription & description, core::TileType type, bool active, const std::string & assetKey, float fixedDelta, std::set< std::string > & warnedMissingClips )

nodiscard

Fait progresser l'animation d'une instance de mécanisme d'un pas fixe : détecte un changement d'état, choisit le clip approprié (transition ou état cible, avec repli sur clip manquant), avance l'image courante, et renvoie la région à afficher (LOT-47 TACHE-02).

Logique pure (core::Animation/core::ClipSet/hmi::AnimationDescription uniquement, aucun GPU/Qt/ECS), testable en isolation. Ne redéclenche jamais de transition tant que l'état logique ne change pas — comparaison au pas précédent, portée par state. Au tout premier appel pour une instance (state.initialized == false, typiquement juste après un chargement/rechargement de niveau), rejoint directement le clip d'état cible, sans transition. Un clip de transition absent bascule directement sur le clip d'état cible, sans avertissement (cas légitime) ; un clip d'état absent journalise un avertissement, une seule fois par combinaison (asset, clip), puis replie sur le premier clip disponible.

Parameters

state	État de présentation de cette instance, muté en place.
description	Description de l'asset effectivement lié à cette instance.
type	Type de tuile du mécanisme.
active	État logique courant (voir mechanismTargetClip).
assetKey	Identifiant de l'asset (typiquement son chemin), pour dédoublonner le journal d'avertissements.
fixedDelta	Durée du pas de simulation, en secondes.
warnedMissingClips	Combinaisons (asset, clip d'état) déjà signalées manquantes, mutées en place — un seul message par combinaison pour toute la session.

Returns

La région de la spritesheet à afficher pour l'image courante.

advanceScreenShake()

void hmi::advanceScreenShake ( ScreenShakeState & state, float fixedDelta )

noexcept

Avance une secousse d'écran d'un pas fixe.

Parameters

state	État à avancer ; sans effet si déjà terminée (elapsed >= duration).
fixedDelta	Durée du pas, en secondes.

advanceTileAnimations()

void hmi::advanceTileAnimations	(	const SkinCatalog *	skins,
		const std::string &	skinSet,
		TextureCache &	cache,
		float	deltaSeconds,
		std::unordered_map< std::string, core::Animation > &	tileAnimations,
		std::set< std::string > &	warnedExclusions )

Avance l'horloge d'animation partagée des tuiles animées d'un jeu de skins courant (LOT-46 TACHE-05).

Facteur commun à hmi::GameSession (pas fixe, déterministe, EX-NFR-002) et hmi::DraftRenderer (temps réel de l'aperçu d'édition — la détermination n'a pas de sens hors simulation) : découvre les assets animés du jeu de skins courant (mode Single, sans silhouette — bitmask16 et silhouette détourée excluent l'animation, hmi::animationExcludedForTile, signalé une fois par asset via warnedExclusions) et avance leur horloge partagée d'un pas. Une entrée par asset, jamais par tuile : toutes les tuiles d'un même type animé restent ainsi en phase, sans coût par case.

Parameters

skins	Catalogue de skins courant, ou nullptr (rien à faire).
skinSet	Nom du jeu courant ; vide pour le jeu par défaut du catalogue.
cache	Cache de textures (résolution de l'asset et de sa description).
deltaSeconds	Durée à avancer.
tileAnimations	Horloge partagée, mise à jour en place.
warnedExclusions	Assets déjà signalés pour une combinaison exclue (mémorisation, pour ne jamais journaliser à chaque image).

alphaOver()

std::uint32_t hmi::alphaOver ( std::uint32_t below, std::uint32_t above )

nodiscardnoexcept

Compose un pixel au-dessus d'un autre (alpha-over, alpha non prémultiplié).

Exposée pour être testée directement : l'associativité de l'alpha-over est ce qui garantit qu'aplatir trois plans d'un coup donne le même résultat que deux fois deux.

Parameters

below	Pixel de dessous (RGBA, R en poids faible).
above	Pixel de dessus.

Returns

Le pixel composé.

animationExcludedForTile()

bool hmi::animationExcludedForTile ( SkinMode mode, core::TileType type )

nodiscardnoexcept

Indique si la combinaison (mode de skin, type de tuile) exclut l'animation (LOT-46 TACHE-05).

SkinMode::Bitmask16 (la case dépend du voisinage solide) et une silhouette détourée (pente/arrondi, hmi::hasSilhouette) choisissent déjà la case à échantillonner dans l'image ; l'animation en ajouterait une seconde façon, jamais implémentée — limite assumée plutôt que silencieuse (voir l'epic LOT-46). Fonction pure, testable sans GPU : c'est elle que GameSession::updateTileAnimations interroge pour décider de signaler la combinaison au lieu de l'ignorer.

Parameters

mode	Mode de découpage du skin assigné.
type	Type de tuile concerné.

Returns

true si l'animation doit être ignorée pour cette combinaison.

applyApplicationStyle()

void hmi::applyApplicationStyle

(

)

Choisit explicitement le style Qt de l'application (non natif, condition pour que la palette et la feuille de style s'appliquent à l'ensemble des contrôles).

À appeler avant la création du moindre widget : un style appliqué après ne se propage pas aux widgets déjà construits.

applyEditorTheme()

void hmi::applyEditorTheme

(

)

Applique le thème complet du châssis d'édition (portée variable) : police, palette puis feuille de style, tous dérivés des jetons actuellement effectifs (currentEditorTokens()).

À appeler avant la construction de MainWindow.

applyFont()

void hmi::applyFont

(

)

Enregistre les polices embarquées auprès de Qt et applique la famille du châssis d'édition comme police par défaut de l'application (Assets/Fonts/) :

• Inter-{Regular,Bold}.ttf — FontRole::Ui, le châssis d'édition ;
• PixelifySans-{Regular,Bold}.ttf et PressStart2P-Regular.ttf — FontRole::Identity, les écrans du jeu (LOT-68, EX-IHM-070), la seconde étant réservée aux titres d'écran.

Repli explicite et par famille si un fichier est absent ou refusé par Qt : famille générique (QFont::StyleHint ici, mot-clé CSS générique dans la feuille de style), jamais un second nom de police codé en dur, et jamais la famille d'un autre rôle — une police d'écran manquante ne doit pas faire retomber le jeu sur la police de l'éditeur. Avertissement journalisé.

applySilhouetteMask()

void hmi::applySilhouetteMask	(	core::TileType	type,
		int	width,
		int	height,
		std::vector< std::uint32_t > &	pixels )

Applique la silhouette d'un type à une image carrée, en rendant transparent l'extérieur.

L'artiste peint un carré plein ; le moteur le découpe à la forme exacte de la hitbox. Le résultat est mis en cache (hmi::TextureCache) plutôt que recalculé à chaque image.

Sans effet si type n'a pas de silhouette, ou si l'image n'est pas carrée — un skin destiné à un type carré ne doit pas être découpé par accident.

Parameters

type	Type de tuile dont on applique la silhouette.
width	Largeur de l'image, en pixels.
height	Hauteur de l'image, en pixels.
pixels	Pixels R8G8B8A8_UNORM, modifiés sur place ; taille attendue width * height.

applySkinAssignment()

void hmi::applySkinAssignment	(	SkinCatalog &	catalog,
		std::string_view	setName,
		core::TileType	type,
		const std::string &	asset,
		SkinMode	mode )

Applique une assignation à un catalogue, ou la retire.

Point unique de la modification, pour que le panneau n'ait pas à décider lui-même ce que signifie « aucun skin » — un asset vide retire l'assignation, et le type redevient non skinné plutôt que d'être associé à un fichier de nom vide.

Parameters

catalog	Catalogue modifié.
setName	Jeu concerné ; vide pour le jeu par défaut du catalogue.
type	Type de tuile.
asset	Fichier à assigner, ou chaîne vide pour retirer l'assignation.
mode	Mode de découpage appliqué si asset est renseigné.

applyStyleSheet()

void hmi::applyStyleSheet

(

const DesignTokens &

editorTokens

)

Charge le modèle de feuille de style du châssis d'édition (:/resources/theme-editor.qss), le substitue avec editorTokens et l'applique à l'application.

Repli explicite : fichier absent/illisible ou marqueur inconnu -> avertissement journalisé, l'application reste utilisable sans feuille de style (comportement historique de main.cpp, non régressé).

Ne porte plus la portée identité depuis le LOT-73 (EX-IHM-082) : celle-ci se pose sur la pile d'écrans (identityStyleSheet). Les deux vivaient dans la même feuille applicative, si bien qu'un changement de facteur d'agrandissement — préoccupation des seuls écrans du jeu — repolissait les 862 widgets de l'application, cinq secondes durant en Debug.

arrowHead()

ArrowHead hmi::arrowHead ( core::Vector2 from, core::Vector2 to )

nodiscardnoexcept

Calcule les deux ailes de la pointe d'une flèche allant de from vers to.

Parameters

from	Origine du trait (sert seulement à orienter la pointe).
to	Extrémité du trait (sommet de la pointe).

Returns

Les deux points d'aile ; to deux fois si le segment est dégénéré (from == to).

assetDimensionContract()

AssetDimensionContract hmi::assetDimensionContract ( AssetFamily family )

nodiscardnoexcept

Contrat de dimensions d'une famille d'assets.

Parameters

family

Famille dont on veut le contrat.

Returns

Les dimensions attendues pour cette famille.

assetFamilyName()

const char * hmi::assetFamilyName ( AssetFamily family )

nodiscardnoexcept

Nom lisible d'une famille d'assets, utilisé dans les messages de journalisation.

Parameters

family

Famille à nommer.

Returns

Le nom de la famille (chaîne statique, jamais nulle).

autotileAssemblyMasks()

std::array< std::uint8_t, 9 > hmi::autotileAssemblyMasks ( )

nodiscardnoexcept

Masques des neuf cases d'un assemblage 3×3 démonstratif (LOT-54 TACHE-08).

Un bloc 3×3 plein, flottant (aucun voisin hors du bloc n'est considéré solide) : chaque case ne voit que ses voisines internes, ce qui donne un panorama représentatif — coins, bords et intérieur — de la façon dont la planche en cours se raccorde à elle-même. C'est l'assemblage, pas les repères, qui répond à « le résultat tient-il ? ».

Returns

Les neuf masques, en ordre de lecture (ligne par ligne, gauche à droite, haut en bas).

autotileCell()

AutotileCell hmi::autotileCell ( std::uint8_t mask )

nodiscardnoexcept

Case de la planche 4×4 correspondant à un masque de voisinage.

La correspondance est une constante figée, documentée configuration par configuration dans l'implémentation, et vérifiée exhaustivement sur les seize valeurs.

Parameters

mask	Masque de voisinage (seuls les quatre bits de poids faible sont lus).

Returns

La case à échantillonner dans la planche.

autotileConfigurationLabelKey()

std::string_view hmi::autotileConfigurationLabelKey ( std::uint8_t mask )

nodiscardnoexcept

Clé de traduction décrivant la configuration de voisinage d'un masque, pour l'atelier pixel art (LOT-54 TACHE-08, EX-REN-033).

Les seize valeurs correspondent exactement aux seize entrées de la table canonique CELL_BY_MASK (TileAutotile.cpp) — dessiner une planche sans savoir ce que représente chaque case est une source d'erreurs garantie ; ce n'est jamais une seconde table, seulement sa description en langage naturel.

Parameters

mask	Masque de voisinage (seuls les quatre bits de poids faible sont lus).

Returns

La clé (existe dans les deux catalogues, fr.lang/en.lang).

autotileRepresentativeCell()

AutotileCell hmi::autotileRepresentativeCell ( )

nodiscardnoexcept

Case représentative d'une planche : l'intérieur plein (quatre voisins solides).

Utilisée là où une seule image doit résumer un skin à raccords — la vignette de la palette de l'éditeur (EX-EDIT-027). L'intérieur plein est le motif de fond du skin ; la case zéro, elle, serait la tuile isolée, un cas particulier peu représentatif.

Returns

La case d'intérieur plein.

bitmaskCellAtPixel()

std::optional< AutotileCell > hmi::bitmaskCellAtPixel ( const DecodedImage & image, int tileSize, int x, int y )

nodiscardnoexcept

Case de la planche sous un pixel donné.

Parameters

image	Image consultée.
tileSize	Côté d'une case, en pixels.
x	Colonne du pixel.
y	Ligne du pixel.

Returns

La case, ou std::nullopt si image n'est pas une planche bitmask16 (isBitmask16Candidate) ou si (x, y) est hors bornes.

buildApplicationPalette()

QPalette hmi::buildApplicationPalette ( const DesignTokens & tokens )

nodiscard

Construit une QPalette complète — groupes actif, inactif et désactivé — à partir d'un jeu de jetons.

Le groupe désactivé est explicitement dérivé du texte atténué : c'est celui qu'on oublie le plus souvent, et celui qui trahit le plus vite un thème incomplet.

buildAutotileAssemblyPreview()

DecodedImage hmi::buildAutotileAssemblyPreview ( const DecodedImage & sheet, int tileSize )

nodiscard

Construit l'aperçu d'assemblage 3×3 démonstratif à partir de la planche en cours.

Les repères disent à quoi sert chaque case ; seul cet assemblage dit si le résultat tient (epic.md) — composé avec hmi::autotileAssemblyMasks/hmi::autotileCell, la même table que le rendu du niveau, jamais une seconde.

Parameters

sheet	Planche en cours d'édition.
tileSize	Côté d'une case, en pixels.

Returns

Une image de 3 * tileSize de côté ; une case qui déborderait de sheet (planche plus petite que prévu) reste transparente plutôt que de lire hors bornes.

buildLinkRows()

std::vector< LinkRow > hmi::buildLinkRows ( const core::LevelDraft & draft )

nodiscard

Construit la liste des liaisons d'un brouillon, dans un ordre déterministe.

Alimente à la fois le panneau « Liens » (hmi::LinkPanel) et le rendu (hmi::DraftRenderer) — source unique, aucune duplication (EX-EDIT-010). Ordre : celui de draft.mechanisms().

Parameters

draft

Brouillon dont on liste les liaisons.

Returns

Les liaisons, dans un ordre stable.

buildMechanismAnimationRows()

std::vector< MechanismAnimationRow > hmi::buildMechanismAnimationRows ( const SkinCatalog & catalog, std::string_view setName, const std::filesystem::path & skinsDirectory )

nodiscard

Construit les lignes de la section « Animations », diagnostic de clips manquants compris.

Logique pure (std::filesystem + hmi::AnimationCatalog, aucune dépendance Qt/GPU), testable en isolation (EX-NFR-010). Stockage identique à un skin de type (hmi::SkinCatalog, LOT-42) : ce n'est pas une seconde configuration, seulement une vue dédiée à six types particuliers, avec un diagnostic que la section « Skins » n'offre pas.

Parameters

catalog	Catalogue interrogé pour l'assignation courante de chaque famille.
setName	Jeu de skins consulté ; vide pour le jeu par défaut du catalogue.
skinsDirectory	Dossier des skins, pour lire le descripteur d'animation de l'asset assigné (<asset>.anim.json).

Returns

Une ligne par famille de MECHANISM_ANIMATION_TYPES, dans cet ordre.

buildMissingTextureImage()

ProceduralAtlasImage hmi::buildMissingTextureImage ( int size = MISSING_TEXTURE_SIZE )

nodiscard

Génère, en mémoire, la texture de repli « asset manquant » : un damier magenta/noir.

Sœur de hmi::buildProceduralAtlasImage : logique pure et déterministe, sans dépendance Direct3D (EX-NFR-010). Le repli est volontairement opaque et magenta : il doit être impossible de le confondre avec un asset réel (aucune palette du jeu n'utilise le magenta) ni avec un trou de rendu (une zone transparente passerait inaperçue). Un asset manquant doit se voir, pas se deviner.

Parameters

size	Côté de l'image générée, en pixels (> 0 ; MISSING_TEXTURE_SIZE par défaut).

Returns

L'image générée (dimensions et pixels R8G8B8A8_UNORM).

buildProceduralAtlasImage()

ProceduralAtlasImage hmi::buildProceduralAtlasImage ( )

nodiscard

Génère, en mémoire, l'atlas procédural historique (grille de tuiles + images du personnage), de façon déterministe.

Logique pure (EX-NFR-010), sans dépendance Direct3D/Qt : utilisée à la fois par hmi::TextureAtlas (repli si l'asset fichier est absent/illisible, EX-NFR-040) et par l'export ponctuel de l'atlas de base en fichier (--export-atlas, cf. main.cpp), pour que les deux chemins restent l'unique source de vérité de ce contenu.

Returns

L'image générée (dimensions et pixels).

buildProceduralFont()

ProceduralFont hmi::buildProceduralFont ( )

nodiscard

Génère, en mémoire, une police bitmap minimale et déterministe (repli sans asset).

Couvre l'ASCII imprimable (0x20-0x7E) et les lettres accentuées du français (é è à ç ù ê î ô û et majuscules), en glyphes 5×7 pixels blancs sur fond transparent (colorables par la teinte du quad, comme hmi::buildProceduralAtlasImage, LOT-39). Chasse fixe (une seule avance pour tous les glyphes) : simple et suffisant pour un repli de secours. Aucune dépendance fichier/GPU : le jeu reste lisible même sans aucun asset de police (EX-NFR-040).

Returns

L'image générée et ses métriques, prêtes pour hmi::BitmapFont.

buildSkinRows()

std::vector< SkinSection > hmi::buildSkinRows ( const SkinCatalog & catalog, std::string_view setName )

nodiscard

Construit les lignes du panneau pour un jeu de skins donné.

Réutilise la taxonomie de la palette (hmi::tileTaxonomy) plutôt que d'énumérer les trente types à plat : une liste plate serait inutilisable, et deux organisations différentes entre la palette et ce panneau obligeraient le level designer à réapprendre où trouver chaque tuile.

Les sous-groupes de la taxonomie sont aplatis dans leur catégorie : le panneau n'a pas de sélection à opérer, seulement une assignation par type, et un troisième niveau de repli n'apporterait rien.

core::TileType::Empty est exclu : une case vide n'affiche rien, elle n'a pas d'apparence à assigner.

Logique pure (aucune dépendance Qt/GPU), testable en isolation (EX-NFR-010).

Parameters

catalog	Catalogue interrogé pour l'assignation courante de chaque type.
setName	Nom du jeu de skins consulté ; vide pour le jeu par défaut du catalogue.

Returns

Les sections, dans l'ordre de la taxonomie.

buildStyleSheetValues()

std::unordered_map< std::string, std::string > hmi::buildStyleSheetValues ( const DesignTokens & editorTokens, int identityScale = 1 )

nodiscard

Table de substitution marqueur -> valeur pour le modèle de feuille de style (LOT-56 TACHE-02), à partir d'un jeu de jetons du châssis d'édition (portée variable) ; les marqueurs de préfixe "identity." sont toujours résolus depuis identityTokens() (portée invariante).

Fonction pure : ne dépend que des jetons, jamais de l'état de l'application.

buildTileOnionSkin()

DecodedImage hmi::buildTileOnionSkin ( const core::LevelDraft & draft, int pixelsPerUnit )

nodiscard

Construit la pelure d'oignon des tuiles : une couleur plate par type, aux dimensions d'un plan de la densité donnée.

Réutilise la palette du mode Physique (hmi::buildProceduralAtlasImage), qui est déjà « la lecture des collisions sans distraction » : inventer un second jeu de couleurs pour l'éditeur ferait diverger deux vues du même niveau. Les cases vides restent transparentes — c'est un repère qu'on peint par-dessus, pas un fond.

Parameters

draft	Brouillon dont on lit la grille de tuiles.
pixelsPerUnit	Densité du plan peint (4, 8 ou 16).

Returns

L'image du repère, vide si pixelsPerUnit est invalide ou la grille dégénérée.

capturedGamepadButton()

std::optional< GamepadButton > hmi::capturedGamepadButton ( const InputState & input )

nodiscard

Cherche le premier bouton manette pressé cette frame, pour la capture d'un remappage.

Parameters

input

État des entrées de la frame (piste manette brute, InputState:: gamepadButtonPressed).

Returns

Le bouton capturé, ou std::nullopt si aucun n'est pressé cette frame.

capturedKey()

std::optional< Key > hmi::capturedKey ( const InputState & input )

nodiscard

Cherche la première touche pressée cette frame, pour la capture d'un remappage.

Scrute l'ensemble des codes suivis par InputState (aucune touche nommée par Key n'est privilégiée : n'importe quelle touche du clavier peut être liée à une action). Échap et Entrée sont exclus — réservés à la navigation globale, jamais assignables — leur pression seule ne renvoie rien, la capture doit rester ouverte.

Parameters

input

État des entrées de la frame.

Returns

La touche capturée, ou std::nullopt si aucune touche assignable n'est pressée.

characterSheetValues()

std::map< std::string, std::string > hmi::characterSheetValues ( const CharacterSheetContext & context )

nodiscard

Returns

Les valeurs de la fiche, prêtes à être posées par hmi::RpgScreenFrame::setValues. Un contexte incomplet (fiche absente) rend une table vide, jamais des zéros : l'écran garde alors ses tirets, ce qui est la vérité.

clampPixelCanvasZoom()

int hmi::clampPixelCanvasZoom ( int zoom )

nodiscardconstexprnoexcept

Zoom borné à [PIXEL_CANVAS_MIN_ZOOM, PIXEL_CANVAS_MAX_ZOOM].

clampPlaneOffset()

core::Vector2 hmi::clampPlaneOffset ( core::Vector2 offset, const core::Rect & planeBounds, const core::Rect & cameraBounds )

nodiscardnoexcept

Borne le décalage d'un plan pour qu'il couvre toujours le cadrage.

Un plan couvre exactement le niveau ; le translater découvre donc son bord, et une bande vide apparaîtrait au bout du décalage. L'alternative « que l'artiste peigne des marges » est un piège : la marge nécessaire dépend du facteur et de la taille de salle — personne ne la calculera juste, et l'erreur ne se verrait qu'au bord d'un niveau, en jeu.

Le bornage est fait par axe, indépendamment. Si le plan est plus petit que le cadrage sur un axe (aucune translation ne peut le couvrir), le décalage y est ramené à zéro : le plan reste aligné sur le niveau, ce qui est le moindre mal et reste stable.

Parameters

offset	Décalage souhaité, en unités monde.
planeBounds	Rectangle couvert par le plan avant décalage (typiquement le niveau).
cameraBounds	Rectangle cadré par la caméra, à couvrir.

Returns

Le décalage effectivement applicable.

composeBackground()

void hmi::composeBackground	(	ComposedScene &	scene,
		const BackgroundTexture &	background,
		int	levelWidth,
		int	levelHeight,
		RenderMode	mode )

Compose le fond du niveau sur RenderLayer::Background, s'il y a lieu.

Fonction pure (aucun accès disque/GPU), testable via hmi::QuadRecorder (EX-NFR-004). Trois cas distincts (LOT-44), à ne pas confondre :

• background.texture == nullptr (aucun fond désigné) → rien n'est émis, aucune anomalie ;
• fond désigné et chargeable → un quad est émis, étiré sur les bornes du niveau, ratio préservé (computeBackgroundFit) ;
• fond désigné mais introuvable/invalide → background.texture porte déjà le damier de repli (résolu par resolveBackgroundTexture) : un quad de repli est émis identiquement.

Rien n'est jamais émis en mode RenderMode::Physique (EX-REN-046) : la lecture des collisions reste sans distraction. Le quad, en espace niveau, est soumis au culling par boîte englobante comme toute autre primitive de hmi::ComposedScene (EX-NFR-005).

Parameters

scene	Scène composée, cible de l'ajout.
background	Texture de fond déjà résolue (resolveBackgroundTexture).
levelWidth	Largeur du niveau, en unités monde (une case = une unité).
levelHeight	Hauteur du niveau, en unités monde.
mode	Mode de rendu courant ; sans effet hors RenderMode::Texture.

composeDiagnosticsHudLines()

std::vector< std::string > hmi::composeDiagnosticsHudLines ( const DiagnosticsMeasurements & measurements, const Localization & localization )

nodiscard

Compose les lignes du compteur de diagnostic à partir de valeurs déjà mesurées.

Fonction pure (EX-NFR-010), sur le patron de hmi::gameHudLines : le calcul (quelles lignes, quel texte) est testable sans rendu ; seul le dessin (hmi::composeText, à l'appelant) ne l'est pas.

Parameters

measurements	Valeurs mesurées pour l'image courante.
localization	Catalogue de traduction, pour les libellés (EX-REN-033) — aucune chaîne en dur.

Returns

Les lignes à afficher, dans l'ordre : cadence, primitives (composées puis soumises), passes de dessin, pas de simulation.

composeParticles()

void hmi::composeParticles	(	ComposedScene &	scene,
		core::World &	world,
		RenderMode	mode,
		const SceneTextures &	textures )

Compose un quad par particule vivante, teinté selon la durée de vie restante et le calque de son effet.

Parcourt les entités portant un core::Particle (LOT-53 TACHE-01/02) et empile un hmi::SpriteQuad centré sur chacune, échantillonnant une région opaque unie de l'atlas (hmi::TextureAtlas::tile(0, 0), même patron que les segments unis de hmi::DraftRenderer) : aucun asset dédié n'est introduit, la teinte porte entièrement l'apparence de l'effet. L'opacité vaut life / maxLife (core::Particle) : une particule fraîchement émise est pleine, elle s'estompe jusqu'à disparaître avec la simulation. Le calque dépend de l'effet (core::ParticleKind) : une traînée de dash passe derrière le personnage (RenderLayer::Object), une bouffée de poussière ou un éclat de mort devant (RenderLayer::Foreground), conformément au périmètre du lot.

Lecture seule de l'ECS (EX-ARCH-012), sans effet en dehors de RenderMode::Texture (EX-REN-046) — le mode Physique reste la lecture nue des collisions, sans effet visuel.

Parameters

scene	Scène à remplir (non vidée : la composition peut être cumulative).
world	Monde dont on lit core::Particle.
mode	Mode de rendu courant.
textures	Textures liables (seul hmi::SceneTextures::atlas est utilisé).

composePlanes()

void hmi::composePlanes	(	ComposedScene &	scene,
		const std::vector< core::Plane > &	planes,
		const std::vector< PlaneTexture > &	textures,
		int	levelWidth,
		int	levelHeight,
		RenderMode	mode,
		const PlaneVisibility &	visibility = PlaneVisibility{},
		const PlaneParallax &	parallax = PlaneParallax{} )

Compose les plans picturaux d'un niveau, dans l'ordre déclaré.

Fonction pure (aucun accès disque/GPU), testable via hmi::QuadRecorder (EX-NFR-004). Émet un quad par plan, couvrant exactement [0,0]–[levelWidth, levelHeight] en unités monde, UV pleines. Trois propriétés méritent d'être connues :

• La densité ne change pas la géométrie. Un plan à 8 px/unité couvre le même rectangle, avec les mêmes UV, qu'un plan natif : seule sa texture est deux fois plus petite, donc plus grossière à l'écran. C'est le sens même du réglage (EX-DEC-041) — un compromis de mémoire, pas de cadrage.
• L'ordre de composition porte l'ordre de dessin. hmi::ComposedScene::sort() intercale le rang de première apparition de texture entre le calque et le sortOrder ; chaque plan portant sa propre image, ce sont donc les rangs de texture qui les ordonnent. La propriété « les plans ressortent dans l'ordre du niveau » n'est vraie que parce qu'ils sont composés en premier et dans l'ordre. Elle est invisible à la lecture : un test la fige.
• Rien n'est émis en RenderMode::Physique, comme pour le fond : la lecture des collisions reste sans distraction (EX-REN-046).

Le coût est constant en taille de niveau : un quad et une passe par plan, quelles que soient les dimensions — contrairement aux tuiles. C'est ce que TACHE-09 mesure.

Parameters

scene	Scène composée, cible de l'ajout (non vidée : la composition est cumulative).
planes	Plans du niveau, dans l'ordre déclaré.
textures	Textures résolues, alignées sur planes ; une entrée sans texture n'émet rien.
levelWidth	Largeur du niveau, en unités monde (une case = une unité).
levelHeight	Hauteur du niveau, en unités monde.
mode	Mode de rendu courant ; sans effet hors RenderMode::Texture.
visibility	Visibilité par rang (aide d'édition) : tout visible par défaut, donc sans effet en jeu.
parallax	Cadrage et échelle pour le décalage de parallaxe ; inactif par défaut, le plan est alors composé exactement sur les bornes du niveau.

composeShadows()

void hmi::composeShadows	(	ComposedScene &	scene,
		core::World &	world,
		RenderMode	mode,
		const SceneTextures &	textures,
		float	interpolationAlpha,
		const core::TileMap *	doorCollision = nullptr )

Compose une ombre décalée pour chaque tuile physique visible, sur RenderLayer::Shadow.

Parcourt les mêmes entités que hmi::composeWorldSprites (core::Transform + hmi:: TileSkinTag) mais n'en retient que les tuiles qui projettent une ombre : pleines (core::isSolid, EX-GP-001) ou à silhouette inclinée/courbe (hmi::hasSilhouette, LOT-42). La forme échantillonnée est celle de hmi::regionForTile — le même atlas procédural que le mode Physique et que le masque de silhouette (hmi::isInsideSilhouette) : une case carrée pleine ou arrondi/pente est déjà, dans cet atlas, opaque exactement là où la matière est présente et transparente ailleurs (hmi::isInsideSilhouette, hmi:: buildProceduralAtlasImage). Teinter cette région en noir semi-transparent donne donc l'ombre à sa forme réelle sans réimplémenter la géométrie, et sans le moindre nouveau prédicat de solidité dans Core — un bloc réduit (BlockHalf/BlockQuarter) hérite de la même façon de sa taille réelle via core::Transform::scale (core::tileVisualScale), déjà porté par l'entité comme pour son propre sprite.

Une porte (core::TileType::Door) n'est jamais solide au sens de core::isSolid — sa solidité réelle dépend de l'état du mécanisme qui la commande, jamais reflété par hmi:: TileSkinTag::type (figé au chargement). doorCollision, quand fourni, tranche donc son ombre d'après l'état courant (core::MechanismController::collisionMap) plutôt que d'après le type statique — une porte fermée projette une ombre, une porte ouverte n'en projette plus. nullptr (l'éditeur, qui ne simule aucun mécanisme) exclut simplement les portes de l'ombrage.

Un bloc poussable (EX-GP-022) suit son ombre automatiquement : son entité porte la même position interpolée (hmi::PreviousPosition, EX-ARCH-031) que celle utilisée pour son propre sprite, jamais recalculée ici.

Parameters

scene	Scène à remplir (non vidée : la composition peut être cumulative).
world	Monde dont on lit Transform, TileSkinTag, PreviousPosition.
mode	Mode de rendu courant : sans effet en dehors de RenderMode::Texture (EX-REN-046) — le mode Physique reste la lecture nue des collisions.
textures	Textures liables (seul hmi::SceneTextures::atlas est utilisé : l'ombre n'est jamais celle d'un skin, toujours celle de l'atlas procédural).
interpolationAlpha	Facteur d'interpolation [0, 1[ (EX-ARCH-031), identique à celui de hmi::composeWorldSprites.
doorCollision	Grille de collision courante des mécanismes (core::MechanismController:: collisionMap), ou nullptr pour ignorer les portes (aucune simulation de mécanisme, comme dans l'éditeur).

composeText() [1/2]

void hmi::composeText	(	ComposedScene &	scene,
		const BitmapFont &	font,
		std::string_view	text,
		float	x,
		float	y,
		float	scale,
		const core::Color &	tint,
		TextAnchor	anchor = {},
		std::int32_t	sortOrder = 0 )

Raccourci de hmi::composeText prenant directement une hmi::BitmapFont.

Parameters

scene	Scène composée (mêmes contraintes que la surcharge ci-dessus).
font	Police chargée (fournit métriques et texture).
text	Texte à composer, en UTF-8.
x	Abscisse écran du point d'ancrage, en pixels.
y	Ordonnée écran du point d'ancrage, en pixels.
scale	Facteur d'échelle appliqué aux glyphes.
tint	Teinte appliquée aux quads.
anchor	Point de la boîte englobante du texte qui coïncide avec (x, y).
sortOrder	Tri fin à l'intérieur du calque UI et de la texture de police.

composeText() [2/2]

void hmi::composeText	(	ComposedScene &	scene,
		const FontMetrics &	metrics,
		TextureHandle	texture,
		int	textureWidth,
		int	textureHeight,
		std::string_view	text,
		float	x,
		float	y,
		float	scale,
		const core::Color &	tint,
		TextAnchor	anchor = {},
		std::int32_t	sortOrder = 0 )

Compose une chaîne en quads sur le calque UI, ancrée à une position écran.

Émet un hmi::SpriteQuad par point de code couvert par metrics (substitution déterministe d'un caractère non couvert, EX-NFR-040 — jamais un caractère ignoré silencieusement, sauf l'espace, jamais dessinée : elle n'a aucun pixel visible, l'émettre serait un quad pour rien). Positions arrondies au pixel écran entier (netteté, EX-ARCH-022) ; un retour à la ligne (\n) revient à l'abscisse d'ancrage, une lineHeight plus bas.

Warning

scene ne doit avoir aucun cadrage de culling actif (hmi::ComposedScene::isCullingEnabled() == false, l'état par défaut) : le texte est en espace écran, sans position monde — le tester contre un cadrage caméra (unités monde) écarterait systématiquement les quads composés ici (EX-NFR-005 ne s'applique pas au calque UI). Composer le HUD dans une ComposedScene dédiée, jamais partagée avec la scène monde soumise par hmi::SpriteRenderer.

Parameters

scene	Scène composée, remplie (pas vidée : la composition peut être cumulative).
metrics	Métriques de la police utilisée (hmi::BitmapFont::metrics).
texture	Texture de l'atlas de glyphes (hmi::BitmapFont::textureHandle).
textureWidth	Largeur de l'atlas de glyphes, en pixels (normalisation UV).
textureHeight	Hauteur de l'atlas de glyphes, en pixels (normalisation UV).
text	Texte à composer, encodé en UTF-8.
x	Abscisse écran du point d'ancrage, en pixels.
y	Ordonnée écran du point d'ancrage, en pixels.
scale	Facteur d'échelle appliqué aux glyphes (entier recommandé, netteté pixel art).
tint	Teinte appliquée aux quads (le nuanceur multiplie texture × couleur).
anchor	Point de la boîte englobante du texte qui coïncide avec (x, y).
sortOrder	Tri fin à l'intérieur du calque UI et de la texture de police.

composeWorldSprites()

void hmi::composeWorldSprites	(	ComposedScene &	scene,
		core::World &	world,
		RenderMode	mode,
		const SceneTextures &	textures,
		float	interpolationAlpha,
		const LayerVisibility &	visibility = LayerVisibility{} )

Compose les entités affichables d'un monde ECS en primitives.

Parcourt les entités portant un core::Transform et un core::Sprite, résout la région d'atlas en coordonnées de texture normalisées, applique l'interpolation de rendu (hmi::PreviousPosition) et empile un hmi::SpriteQuad par entité. Lecture seule de l'ECS (EX-ARCH-012) : ni la simulation ni l'interpolation ne sont affectées, y compris pour une entité écartée par le culling (elle reste simulée, elle n'est simplement pas dessinée).

Le calque de chaque entité vient de son hmi::RenderLayerTag, ou vaut hmi::DEFAULT_RENDER_LAYER en son absence ; core::Sprite::layer reste le tri fin à l'intérieur de ce calque.

L'apparence de chaque entité — texture liée et région échantillonnée — est résolue ici, à la composition, par hmi::resolveTileAppearance (LOT-41) : changer de mode de rendu ne reconstruit donc jamais la scène ECS.

Parameters

scene	Scène à remplir (non vidée : la composition peut être cumulative).
world	Monde dont on lit Transform, Sprite, PreviousPosition, RenderLayerTag.
mode	Mode de rendu courant (EX-REN-046).
textures	Textures liables et leurs dimensions (atlas et damier de repli).
interpolationAlpha	Facteur d'interpolation [0, 1[ entre le pas de simulation précédent et le pas courant (EX-ARCH-031) ; 0 reproduit le rendu non interpolé.
visibility	Jeu de visibilités par calque du mode d'inspection de l'éditeur (hmi::LayerVisibility, LOT-51, EX-EDIT-044) : tout visible par défaut, donc sans effet pour hmi::GameSession qui ne le fournit jamais.

computeBackgroundFit()

BackgroundFit hmi::computeBackgroundFit ( float imageWidth, float imageHeight, float targetWidth, float targetHeight )

nodiscardnoexcept

Calcule le recadrage UV d'une image pour couvrir un rectangle cible sans déformation.

Fonction pure, testable sans GPU (EX-NFR-010) : ratio d'aspect préservé, recadrage par le centre plutôt qu'étirement libre (décision de cadrage LOT-44) — l'image déborde sur la dimension excédentaire. Équivalent du motif CSS background-size: cover, exprimé en coordonnées UV plutôt qu'en pixels écran. Aucun recadrage (UV [0,1] complet) quand les deux ratios coïncident.

Parameters

imageWidth	Largeur de l'image source, en pixels (> 0).
imageHeight	Hauteur de l'image source, en pixels (> 0).
targetWidth	Largeur du rectangle à couvrir, unités cohérentes avec targetHeight (> 0).
targetHeight	Hauteur du rectangle à couvrir (> 0).

Returns

Les UV [u0,v0]-[u1,v1] à échantillonner dans l'image.

computePlayerSpriteQuad()

PlayerSpriteQuad hmi::computePlayerSpriteQuad ( core::Vector2 imageSizePixels, core::Vector2 hitboxSize )

nodiscard

Calcule le quad d'affichage du personnage à partir de la taille de l'image et de la hitbox, par ancrage centre-bas (LOT-48 TACHE-01).

Fonction pure, testable sans GPU (EX-NFR-010) : le centre-bas de l'image est aligné sur le centre-bas de la hitbox (core::playerSize()), indépendamment de la taille de l'image — une image plus grande ou plus large que la hitbox ne déplace donc jamais celle-ci (EX-ARCH-012, la hitbox elle-même n'est jamais lue ni modifiée ici, seulement sa taille). L'ancrage est symétrique horizontalement : le retournement (LOT-48 TACHE-03) n'a besoin d'aucune correction de position, seulement d'un échange des coordonnées de texture.

Parameters

imageSizePixels	Taille de l'image à afficher (une image de la spritesheet, ou de l'image procédurale, toujours carrée), en pixels.
hitboxSize	Taille de la boîte de collision (core::playerSize()), en unités monde.

Returns

Le décalage et la taille du quad, en unités monde, relatifs au coin haut-gauche de la hitbox.

contrastRatio()

double hmi::contrastRatio ( DesignColor a, DesignColor b )

nodiscardnoexcept

Rapport de contraste WCAG entre deux couleurs (1 = aucun contraste, 21 = noir sur blanc).

copyRegion()

PixelClipboard hmi::copyRegion ( const DecodedImage & image, const PixelRegion & region )

nodiscard

Copie les pixels d'une région dans un presse-papiers autonome (ne référence plus image).

Parameters

image	Image consultée.
region	Région copiée ; un presse-papiers vide si region est vide.

createTexture()

std::optional< LoadedTexture > hmi::createTexture ( const RhiContext & context, int width, int height, const std::vector< std::uint32_t > & pixels )

nodiscard

Crée une texture GPU à partir de pixels RGBA déjà décodés.

Le téléversement des pixels est différé : il est déposé dans le lot de mises à jour de l'image en cours (hmi::RhiContext::updates), que l'appelant soumet avant d'ouvrir sa passe de rendu. C'est la contrainte de QRhi qui l'impose, pas un choix d'optimisation — un téléversement ne peut pas avoir lieu au milieu d'une passe.

Parameters

context	Interface de rendu et lot de mises à jour de l'image courante.
width	Largeur en pixels (doit être strictement positive).
height	Hauteur en pixels (doit être strictement positive).
pixels	Pixels RGBA8, taille attendue width * height.

Returns

La texture chargée, ou std::nullopt en cas d'échec de création côté GPU.

currentEditorTokens()

const DesignTokens & hmi::currentEditorTokens ( )

nodiscard

Returns

Les jetons du châssis d'édition actuellement effectifs : résolution du réglage persisté et, si Système, du réglage courant du système d'exploitation (hmi::resolveEffectiveEditorTheme).

decodeImageFile()

std::optional< DecodedImage > hmi::decodeImageFile ( const std::filesystem::path & path )

nodiscard

Décode un fichier image (PNG au minimum) en pixels RGBA.

Parameters

path	Chemin du fichier image.

Returns

L'image décodée, ou std::nullopt si le fichier est absent/illisible/format non supporté (erreur récupérable, EX-NFR-040 — jamais d'exception ici).

depthSortOrder()

std::int32_t hmi::depthSortOrder ( float footWorldY )

nodiscardnoexcept

Ordre de profondeur d'une primitive, à partir du pied de son quad.

Le pied — le bord bas — et non le coin haut : c'est le point de contact avec le sol qui décide de la profondeur. Deux sprites de hauteurs différentes posés sur la même case doivent s'ordonner de la même façon, ce que leur coin haut ne dit pas (EX-REN-018).

Fonction pure, sans GPU. Un Y plus grand (plus bas à l'écran, y vers le bas) donne un ordre plus grand, donc un dessin plus tard, donc au-dessus.

Parameters

footWorldY

Ordonnée du bord bas du quad, en unités monde.

Returns

L'ordre de tri correspondant.

describeContract()

std::string hmi::describeContract ( const AssetDimensionContract & contract )

nodiscard

Description en français des dimensions attendues (« 16×16 px », « multiple de 16 px… »).

Parameters

contract

Contrat à décrire.

Returns

La description, telle qu'elle apparaît dans le message d'un asset refusé.

describeReferences()

std::string hmi::describeReferences ( const std::vector< AssetReference > & references )

nodiscard

Message d'avertissement listant des références, une par jeu de skins.

Parameters

references

Références à décrire (typiquement le résultat de findSkinCatalogReferences).

Returns

Le message en français, ou une chaîne vide si references est vide.

detectMechanismEvents()

std::vector< GameEvent > hmi::detectMechanismEvents ( const MechanismEventState & previous, const MechanismEventState & current, const std::vector< bool > & isContinuous )

nodiscard

Détecte les transitions des mécanismes entre deux pas de simulation consécutifs.

Un même mécanisme (isDoorOpen) sert à la fois de déclencheur et de porte : une seule transition produit un seul événement (celui du déclencheur), jamais un second pour la porte — sans quoi une simple activation jouerait deux sons superposés.

Parameters

previous	État des mécanismes au pas précédent.
current	État des mécanismes au pas courant.
isContinuous	Pour chaque mécanisme (même index que previous / current) : true = plaque de pression (joue « pressée »/« relâchée »), false = interrupteur à bascule (joue « basculé »). Un désaccord de taille entre les trois vecteurs ignore l'index en trop plutôt que d'accéder hors bornes.

detectOutcomeEvent()

std::optional< GameEvent > hmi::detectOutcomeEvent ( core::LevelOutcome outcome )

nodiscard

Traduit l'issue d'un pas de simulation en événement.

Parameters

outcome

Issue renvoyée par core::evaluateOutcome / core::GameSession::update.

Returns

Died pour Lost, ExitReached pour Won, std::nullopt pour Playing.

drawLine()

PixelRegion hmi::drawLine	(	DecodedImage &	image,
		int	x0,
		int	y0,
		int	x1,
		int	y1,
		std::uint32_t	color )

Trace une ligne pleine entre deux positions (algorithme de Bresenham).

Sans elle, un glisser rapide de souris entre deux positions successives d'un même geste laisse des pixels isolés au lieu d'un trait continu — le défaut le plus visible d'un canevas pixel art fait naïvement.

Parameters

image	Image modifiée en place.
x0	Colonne de départ.
y0	Ligne de départ.
x1	Colonne d'arrivée.
y1	Ligne d'arrivée.
color	Couleur posée sur chaque pixel du tracé.

Returns

La région englobante des pixels effectivement posés (vide si tout le segment est hors bornes).

dressingFor()

ScreenDressing hmi::dressingFor ( ScreenId screen )

nodiscardnoexcept

Returns

L'habillage de fenêtre attendu pour screen.

dressingForWorkspace()

WorkspaceDressing hmi::dressingForWorkspace ( EditorWorkspace workspace )

nodiscardnoexcept

Returns

Les barres et menus visibles dans workspace. Jamais les deux barres d'outils à la fois : c'est la propriété que le lot existe pour établir.

editorActionCatalog()

const std::array< EditorActionSpec, EDITOR_ACTION_CATALOG_COUNT > & hmi::editorActionCatalog ( )

nodiscard

Returns

Le catalogue complet, dans l'ordre d'affichage voulu de la barre d'outils : les huit outils de niveau (ordre de la palette/du panneau Outils historique), les outils de canevas pixel art (LOT-54 TACHE-04), puis les commandes.

editorActionForPixelTool()

IconId hmi::editorActionForPixelTool ( PixelTool tool )

nodiscard

Returns

L'identifiant d'action portant l'outil de canevas pixel art tool.

editorActionForTool()

IconId hmi::editorActionForTool ( EditorTool tool )

nodiscard

Returns

L'identifiant d'action portant l'outil tool.

editorActionPixelTool()

std::optional< PixelTool > hmi::editorActionPixelTool ( IconId id )

nodiscard

Returns

L'outil de canevas pixel art associé à l'action id, si elle appartient au groupe PixelTools ; std::nullopt sinon (LOT-54 TACHE-04).

editorActionSpec()

const EditorActionSpec & hmi::editorActionSpec ( IconId id )

nodiscard

Returns

La spécification de l'action id.

editorActionTool()

std::optional< EditorTool > hmi::editorActionTool ( IconId id )

nodiscard

Returns

L'outil associé à l'action id, si elle appartient au groupe LevelTools ; std::nullopt pour une commande ou un outil de canevas pixel art.

editorDarkTokens()

const DesignTokens & hmi::editorDarkTokens ( )

nodiscardnoexcept

Jetons du châssis d'édition en thème sombre (défaut) : variables, editorLightTokens() (LOT-56 TACHE-06) en fournit un second jeu.

editorLightTokens()

const DesignTokens & hmi::editorLightTokens ( )

nodiscardnoexcept

Jetons du châssis d'édition en thème clair (LOT-56 TACHE-06) : mêmes rôles, mêmes échelles que editorDarkTokens() — seules les couleurs diffèrent, et pas par simple inversion (les écarts de luminosité entre bordures/lignes alternées/fond diffèrent en clair et en sombre).

editorStatusLines()

EditorStatusLines hmi::editorStatusLines ( const EditorStatusContext & context, const Localization & localization )

nodiscard

Décide le contenu de la barre d'état de l'éditeur pour context.

Fonction pure (EX-NFR-010) : ne lit que ce qu'on lui passe, aucune dépendance Qt/GPU — même patron que hmi::gameHudLines (LOT-52). Le rendu (MainWindow) n'a plus qu'à afficher ce que cette fonction décide, et à la rappeler après l'expiration d'un message transitoire pour restaurer l'aide affichée.

Parameters

context	Contexte d'édition courant ; context.level absent (aucun niveau ouvert) produit des zones et une aide vides.
localization	Catalogue de traduction (EX-REN-033) — aucune chaîne en dur.

Returns

Les zones permanentes et l'aide contextuelle à afficher.

editorThemeSetting()

EditorThemeSetting hmi::editorThemeSetting ( )

nodiscard

Returns

Le réglage de thème persisté (QSettings), Système par défaut.

encodeImageFile()

bool hmi::encodeImageFile ( const std::filesystem::path & path, const DecodedImage & image )

nodiscard

Écrit un fichier PNG depuis des pixels RGBA déjà en mémoire — symétrique de decodeImageFile.

Écriture atomique : les pixels sont d'abord écrits dans un fichier temporaire du même dossier, puis ce fichier remplace path en une seule opération (std::filesystem::rename). Une interruption (crash, disque plein en cours d'écriture) laisse donc soit l'ancien fichier intact, soit le nouveau complet, jamais un fichier tronqué — ce qui importe d'autant plus que le rechargement à chaud (LOT-43) peut lire pendant l'écriture. Le fichier temporaire ne subsiste ni après un succès ni après un échec.

Le format en mémoire reste Format_RGBA8888 (alpha non prémultiplié), comme au décodage : décoder puis réencoder restitue exactement les mêmes pixels, canal alpha compris.

Parameters

path	Chemin du fichier PNG à écrire.
image	Image à encoder (dimensions strictement positives, pixels.size() == width * height).

Returns

true en cas de succès, false sinon (dossier de destination absent, image invalide, échec d'écriture — jamais d'exception, EX-NFR-040).

eraseLine()

PixelRegion hmi::eraseLine	(	DecodedImage &	image,
		int	x0,
		int	y0,
		int	x1,
		int	y1 )

Efface une ligne pleine entre deux positions (même tracé que drawLine, alpha nul plutôt qu'une couleur posée).

Pendant de drawLine pour la gomme : un glisser rapide avec la gomme doit laisser une trace continue effacée, pas des pixels effacés isolés — même défaut, même correction.

Parameters

image	Image modifiée en place.
x0	Colonne de départ.
y0	Ligne de départ.
x1	Colonne d'arrivée.
y1	Ligne d'arrivée.

Returns

La région englobante des pixels effectivement effacés (vide si tout le segment est hors bornes).

erasePixel()

PixelRegion hmi::erasePixel	(	DecodedImage &	image,
		int	x,
		int	y )

Efface un pixel (alpha nul), sans changer sa couleur RVB.

Alpha nul, RVB conservé plutôt que mis à zéro : un pixel effacé puis re-coloré sans jamais changer sa teinte reproduit l'attente naturelle d'une gomme.

Parameters

image	Image modifiée en place.
x	Colonne (0-based).
y	Ligne (0-based).

Returns

La région modifiée (le seul pixel (x, y)), vide si (x, y) est hors bornes.

executableDirectory()

std::filesystem::path hmi::executableDirectory ( )

nodiscard

Dossier contenant l'exécutable en cours, pour localiser les ressources copiées à côté (niveaux, catalogues de traduction, logs).

Returns

Le chemin du dossier de l'exécutable.

extractPalette()

std::vector< PixelPaletteExtractionEntry > hmi::extractPalette ( const DecodedImage & image )

nodiscard

Couleurs effectivement présentes dans une image, dans un ordre déterministe.

Fonction pure. Un pixel totalement transparent (alpha nul) n'est jamais une couleur — c'est la gomme, pas une entrée de palette (même règle que hmi::constrainToPalette ci-dessous) : une image entièrement transparente produit donc une liste vide. L'ordre (première apparition, balayage ligne par ligne) est stable d'un appel à l'autre sur la même image.

Parameters

image

Image consultée.

Returns

Les couleurs présentes, chacune avec son nombre d'occurrences.

findSkinCatalogReferences()

std::vector< AssetReference > hmi::findSkinCatalogReferences ( const SkinCatalog & catalog, const std::string & fileName )

nodiscard

Repère toutes les entrées de skins.json qui citent un fichier donné.

Les références aux assets se font par nom de fichier : sans cette détection, renommer ou supprimer un asset casse silencieusement les jeux de skins qui le citent (LOT-43 TACHE-02).

Portée actuelle : seul hmi::SkinCatalog peut référencer un asset aujourd'hui — core::Level ne porte encore aucun champ de ce type (le fond de niveau, la désignation d'un jeu de skins par un niveau, etc. sont posés à partir de LOT-44). Cette fonction est le point d'extension déjà en place : les lots suivants y ajouteront la détection des niveaux sur disque sans changer sa signature ni celle de describeReferences.

Logique pure (aucune dépendance Qt/GPU/fichier), testable en isolation (EX-NFR-010).

Parameters

catalog	Catalogue interrogé (tous les jeux, pas seulement le courant).
fileName	Nom de fichier recherché, comparé exactement (pas de sous-chaîne : un nom proche mais différent ne doit jamais déclencher de faux positif).

Returns

Les références trouvées, dans l'ordre des jeux puis des types du catalogue ; vide si aucune.

flatPlayerFrameIndex()

int hmi::flatPlayerFrameIndex ( PlayerClipKind clip, int frameIndex )

nodiscard

Index à plat (0-based) d'une image dans la grille sous les tuiles : Idle (0..PLAYER_IDLE_FRAME_COUNT-1), puis Run, puis Jump.

Seule source de vérité de cet ordre, partagée par buildProceduralAtlasImage (placement des images) et par TextureAtlas::playerFrameRegion (résolution de la même région) — les dupliquer aux deux endroits risquerait de les laisser diverger silencieusement.

Parameters

clip	Clip d'animation du personnage.
frameIndex	Index de l'image dans le clip (0-based).

Returns

L'index à plat de cette image dans la grille.

flattenPlanes()

DecodedImage hmi::flattenPlanes ( const std::vector< PlaneLayer > & layers, int pixelsPerUnit, int widthUnits, int heightUnits )

nodiscard

Aplatit des plans en une seule image, par alpha-over dans l'ordre donné.

Les couches masquées sont ignorées — c'est ce qui rend l'isolement (hmi::PlaneVisibility) effectif dans le repère aussi, et pas seulement à l'écran de jeu. Chaque couche est ramenée à la densité cible par resamplePlane avant d'être composée : une couche de densité incompatible est ignorée plutôt que déformée.

Parameters

layers	Couches à aplatir, de la plus lointaine à la plus proche.
pixelsPerUnit	Densité cible (celle du plan peint).
widthUnits	Largeur du niveau, en unités monde.
heightUnits	Hauteur du niveau, en unités monde.

Returns

L'image aplatie, entièrement transparente si aucune couche visible ne subsiste.

flipHorizontal()

PixelRegion hmi::flipHorizontal	(	DecodedImage &	image,
		const PixelRegion &	region )

Retourne une région horizontalement (miroir gauche-droite), en place.

Involutive : appliquer deux fois de suite restitue exactement le contenu d'origine.

Parameters

image	Image modifiée en place.
region	Région retournée ; sans effet si vide.

Returns

region telle quelle si non vide, sinon une région vide — jamais d'entrée d'historique pour une région vide (à la charge de l'appelant de ne pas en pousser une).

flipVertical()

PixelRegion hmi::flipVertical	(	DecodedImage &	image,
		const PixelRegion &	region )

Retourne une région verticalement (miroir haut-bas), en place.

Involutive, comme flipHorizontal.

floodFill()

PixelRegion hmi::floodFill	(	DecodedImage &	image,
		int	x,
		int	y,
		std::uint32_t	color )

Remplit, de proche en proche, la zone connexe (4-connexité) de même couleur que le pixel de départ.

Itératif (file explicite), jamais récursif : une récursion sur une grande zone déborderait la pile. Sans effet — et sans parcourir quoi que ce soit — si (x, y) est hors bornes ou si la couleur de départ est déjà color, ce qui évite à la fois une opération d'historique vide et une boucle sans fin sur une image déjà uniforme.

Parameters

image	Image modifiée en place.
x	Colonne du point de départ.
y	Ligne du point de départ.
color	Couleur de remplissage.

Returns

La région englobante des pixels effectivement remplis (vide si sans effet).

formatSceneStatistics()

std::string hmi::formatSceneStatistics ( const SceneStatistics & statistics )

nodiscard

Résumé des compteurs d'une image, pour la journalisation de diagnostic (EX-NFR-005).

Parameters

statistics

Compteurs à formater.

Returns

Une ligne lisible : composées, écartées, soumises, passes.

gameHudLines()

std::vector< std::string > hmi::gameHudLines ( const std::string & levelName, const Localization & localization, bool overlappingKey = false )

nodiscard

Lignes à afficher pour l'affichage tête haute d'un pas de simulation donné.

Fonction pure (EX-NFR-010) : ne lit que ce qu'on lui passe, aucun accès GPU/fichier. C'est ce qui rend le contenu du HUD assertable sans rendu — la brique de texte (hmi::composeText, TACHE-02) n'a plus qu'à afficher ce que cette fonction décide.

Les budgets de sauts et de dashs ont disparu avec eux (LOT-06) : ils comptaient les ressources d'un personnage de plateforme, que le déplacement en vue de dessus n'a plus. Ne reste que ce qui a encore un sens — l'invite contextuelle et le nom du tableau.

Parameters

levelName	Nom du tableau en cours (core::Level::name), affiché tel quel (donnée, pas un libellé traduit).
localization	Catalogue de traduction des libellés (EX-REN-033) — aucune chaîne en dur, y compris les libellés courts.
overlappingKey	Le personnage touche-t-il une clé non ramassée (EX-GP-023) ? Si oui, une invite rappelle l'action « Interagir » (EX-CTRL-022). Ramasser une clé exige le contact et cette action — la seule entrée du jeu qu'aucun autre tableau ne demande. Sans invite, un joueur qui l'ignore reste bloqué devant la porte verrouillée sans aucun retour, ce qu'interdit la conception des niveaux (niveaux.md, Sec. 3). Le tutoriel restant « sans texte », c'est la seule exception, et elle est contextuelle. Faux par défaut : un tableau sans clé n'affiche jamais rien.

Returns

Les lignes à afficher, dans l'ordre : invite « Interagir » le cas échéant, puis le nom du tableau.

gamepadButtonDisplayName()

std::string hmi::gamepadButtonDisplayName ( GamepadButton button )

nodiscard

Nom lisible d'un bouton manette, pour l'affichage dans l'écran de remappage.

Parameters

button

Bouton à nommer.

Returns

Un nom court (« A », « Épaule droite », « Flèche gauche »…).

gamepadProbeDue()

bool hmi::gamepadProbeDue ( bool wasConnected, std::chrono::steady_clock::duration sinceLastProbe )

nodiscardconstexprnoexcept

Faut-il re-sonder XInput maintenant ?

XInputGetState est notablement coûteux sur un slot vide (le pilote énumère les périphériques à chaque appel) : sonder sans relâche une manette absente provoque des micro-saccades chez un joueur clavier (LOT-33). L'espacement est donc décidé en temps réel, jamais en nombre d'appels : le sondage est déclenché tantôt par la boucle de rendu (une fois par image), tantôt par un temporisateur d'interface (150 ms pour la navigation de menu, 500 ms pour l'onglet des options). Un compteur d'appels ferait dépendre le délai de détection de l'appelant, dans un rapport de plus de cent entre le plus rapide et le plus lent : c'est la cadence en secondes qui doit être garantie, pas un nombre de tours.

Fonction pure (EX-NFR-010) : décidée ici, testable sans manette ni fenêtre.

Parameters

wasConnected	État de connexion du dernier sondage effectif.
sinceLastProbe	Temps écoulé depuis ce sondage.

Returns

true si le sondage doit avoir lieu : toujours quand une manette est présente, sinon une fois par hmi::GAMEPAD_DISCONNECTED_PROBE_PERIOD.

genericCssFamily()

const char * hmi::genericCssFamily ( FontRole role )

nodiscardnoexcept

Returns

Le mot-clé de famille générique CSS correspondant à role (monospace pour l'identité à empattements, sans-serif pour le châssis d'édition). C'est le repli de la feuille de style quand aucune police embarquée n'a pu être enregistrée : un mot-clé générique, jamais un second nom de police codé en dur (EX-IHM-052).

hasSilhouette()

bool hmi::hasSilhouette ( core::TileType type )

nodiscardnoexcept

Indique si type a une silhouette, c'est-à-dire une matière qui n'occupe pas toute la case et qu'il faut détourer à l'affichage.

Parameters

type	Type de tuile.

Returns

true si type figure dans SILHOUETTE_TILE_TYPES — donc jamais tant que cette liste est vide.

hmiKeyToQtKey()

int hmi::hmiKeyToQtKey ( hmi::Key key )

nodiscard

Traduit un hmi::Key en code Qt::Key, inverse de qtKeyToHmiKey (LOT-57 TACHE-04).

Sert à faire refléter un remappage (EditorKeyBindings/GameKeyBindings) sur le raccourci effectif d'un QAction (hmi::EditorActions::applyShortcuts). Comme l'aller, les lettres et chiffres partagent déjà la même valeur entre Qt et Win32 — conversion directe pour tout code non explicitement nommé.

Parameters

key	Touche à traduire.

Returns

Le code Qt::Key correspondant.

iconForKeyBindingAction()

IconId hmi::iconForKeyBindingAction ( EditorAction action )

nodiscard

Returns

L'identifiant de commande rendant action effective.

iconGeometry()

IconGeometry hmi::iconGeometry ( IconId id )

nodiscard

Décrit la géométrie d'une icône, en espace normalisé.

Fonction pure : mêmes entrées, même sortie, aucune dépendance à Qt ni au GPU. Les formes visent des silhouettes distinctes plutôt qu'un détail fin : elles doivent rester lisibles à la plus petite taille d'icône des jetons (SizeTokens::iconSmall).

identityBaseScale()

const IdentityBaseScale & hmi::identityBaseScale ( )

nodiscardnoexcept

Returns

L'échelle de base de la portée identité (LOT-68).

identityScaleFor()

int hmi::identityScaleFor ( int windowLogicalHeight )

nodiscardnoexcept

Facteur d'agrandissement des écrans du jeu pour une hauteur de fenêtre donnée.

La hauteur attendue est celle en pixels logiques, pas en pixels réels : la mise à l'échelle du système d'exploitation est appliquée par Qt par-dessus ce facteur, sur une disposition exprimée en unités logiques. Multiplier une seconde fois par devicePixelRatio ici produirait une interface deux fois trop grande sur un écran réglé à 200 %.

Le résultat est toujours un entier d'au moins 1, même pour une fenêtre plus petite que la maquette : une fenêtre étroite doit rogner l'écran, jamais le rendre à une échelle fractionnaire.

Parameters

windowLogicalHeight

Hauteur de la fenêtre, en pixels logiques.

Returns

Le facteur entier, dans [1, IDENTITY_MAX_SCALE].

identityScaleForDisplay()

int hmi::identityScaleForDisplay ( int windowLogicalHeight, int availableLogicalHeight )

nodiscardnoexcept

Facteur d'agrandissement borné par la zone d'affichage réellement disponible (EX-IHM-081).

identityScaleFor seule ne connaît que la fenêtre, et c'est insuffisant : le facteur grossit les grandeurs d'habillage, qui grossissent la taille minimale des écrans, qui grossit celle de la fenêtre — laquelle relance le calcul un cran plus haut. Rien ne redescend jamais, la fenêtre ne pouvant pas passer sous son propre minimum : c'est un cliquet, et il n'a d'issue que si le facteur cesse de dépendre d'une hauteur que lui-même fait croître.

La zone disponible, elle, ne dépend de rien que l'application décide. La borner ferme la boucle : une fenêtre que Qt a été contraint d'agrandir au-delà de l'écran ne gagne plus de facteur pour autant.

Parameters

windowLogicalHeight	Hauteur de la fenêtre, en pixels logiques.
availableLogicalHeight	Hauteur utile de l'écran hébergeant la fenêtre (hors barre des tâches), en pixels logiques. Une valeur nulle ou négative signifie « écran inconnu » et laisse la seule hauteur de fenêtre décider.

Returns

Le facteur entier, dans [1, IDENTITY_MAX_SCALE], jamais supérieur à celui que la zone disponible admet.

identityTokens()

const DesignTokens & hmi::identityTokens ( )

nodiscardnoexcept

Jetons de l'identité du jeu (menu principal, écran Options, jeu) : invariants, ne suivent jamais aucun réglage d'affichage (EX-IHM-050).

imagePixelScreenRect()

PixelScreenRect hmi::imagePixelScreenRect ( const PixelCanvasView & view, int x, int y )

nodiscardnoexcept

Rectangle écran du pixel image (x, y), au zoom et décalage de vue donnés.

Fonction pure : ne dépend que de view, jamais des bornes de l'image — c'est elle qui garantit que la grille, le pixel survolé et le tracé de sélection (TACHE-06) s'accordent toujours exactement, puisqu'ils l'appellent tous.

inventoryValues()

std::map< std::string, std::string > hmi::inventoryValues ( const InventoryContext & context )

nodiscard

Returns

Les valeurs de l'inventaire, prêtes pour hmi::RpgScreenFrame::setValues. Un contexte sans inventaire rend une table vide : l'écran garde alors ses tirets.

isBitmask16Candidate()

bool hmi::isBitmask16Candidate ( const DecodedImage & image, int tileSize )

nodiscardnoexcept

true si image a exactement les dimensions d'une planche à raccords bitmask16.

Parameters

image	Image consultée.
tileSize	Côté d'une case, en pixels (TextureAtlas::TILE_SIZE).

isInsideSilhouette()

bool hmi::isInsideSilhouette ( core::TileType type, int localX, int localY, int tileSize )

nodiscardnoexcept

Indique si le pixel (localX, localY) d'une case appartient à la matière de type.

Point de vérité unique de la silhouette, partagé par l'atlas procédural et le détourage des skins : deux implémentations de la même forme finiraient par diverger, et un skin découpé autrement que l'atlas se verrait immédiatement.

Parameters

type	Type de tuile.
localX	Abscisse du pixel dans la case, 0-based.
localY	Ordonnée du pixel dans la case, 0-based.
tileSize	Côté de la case, en pixels.

Returns

true si le pixel est dans la matière. Un type sans silhouette remplit toute la case : la réponse est alors toujours true.

isLinkTargetTile()

bool hmi::isLinkTargetTile ( core::TileType type )

nodiscardconstexprnoexcept

Returns

true si type est une cible de liaison (porte ou porte verrouillée, EX-GP-023).

isStatefulMechanism()

bool hmi::isStatefulMechanism ( core::TileType type )

nodiscardnoexcept

Indique si un type de tuile est un mécanisme à état, dont l'apparence dépend d'une donnée lue en lecture seule dans Core (EX-ARCH-012).

Parameters

type	Type de tuile.

Returns

true pour Door, Switch, PressurePlate, Key, LockedDoor (EX-GP-023, LOT-63) ; false pour tout autre type (aucune demande de clip à produire).

isTriggerTile()

bool hmi::isTriggerTile ( core::TileType type )

nodiscardconstexprnoexcept

Returns

true si type est un déclencheur de liaison (interrupteur, plaque de pression ou clé, EX-GP-023).

isValidLevelName()

bool hmi::isValidLevelName ( const std::string & name )

nodiscard

Indique si name peut servir de nom de niveau (donc de nom de fichier Windows).

Liste noire minimale (pas une liste blanche restrictive : les accents et l'Unicode restent autorisés, EX-NFR-010 n'impose rien de plus) : un nom valide n'est pas vide une fois les espaces de bord retirés, et ne contient aucun des caractères interdits par le système de fichiers Windows (antislash, barre oblique, deux-points, astérisque, point d'interrogation, guillemet droit, chevrons ouvrant/fermant, barre verticale).

Parameters

name	Nom saisi, tel quel (non retiré de ses espaces de bord).

Returns

true si name peut être utilisé comme nom de niveau.

isValidPixelCanvasDenominator()

bool hmi::isValidPixelCanvasDenominator ( int denominator )

nodiscardconstexprnoexcept

Returns

true si denominator est une valeur acceptée (1, 2, 4 ou 8).

keyBindingActionForIcon()

std::optional< EditorAction > hmi::keyBindingActionForIcon ( IconId id )

nodiscard

Returns

L'action remappable dont id est la commande effective, si elle en a une.

keyBindingIconCatalog()

const std::array< KeyBindingIconEntry, KEY_BINDING_ICON_COUNT > & hmi::keyBindingIconCatalog ( )

nodiscard

Returns

La table complète action remappable -> commande du catalogue.

keyDisplayName()

std::string hmi::keyDisplayName ( Key key )

nodiscard

Nom lisible d'une touche, pour l'affichage dans les écrans de remappage (LOT-29) et le panneau d'aide de l'éditeur (EX-EDIT-015).

Parameters

key	Touche à nommer (n'importe quel code, pas seulement les énumérateurs nommés).

Returns

Un nom court : celui des touches nommées de Key (flèches, Espace, Maj…), le caractère lui-même pour une lettre/un chiffre non nommé explicitement, sinon un repli hexadécimal.

keyHintText()

std::string hmi::keyHintText ( const std::vector< KeyHint > & hints, const DesignTokens & tokens, int scale )

nodiscard

Compose la ligne de rappels en texte enrichi.

Les couleurs viennent des jetons et ne sont jamais littérales (EX-IHM-051) : la ligne suit la palette comme le reste de l'écran.

Parameters

hints	Rappels à afficher, dans l'ordre. Une liste vide produit une chaîne vide, jamais un cadre orphelin.
tokens	Jetons de la portée à employer (identité pour les écrans du jeu).
scale	Facteur d'agrandissement entier (hmi::identityScaleFor), appliqué au rembourrage et à la taille du texte.

Returns

Le fragment HTML à poser dans un libellé.

lineQuadBounds()

core::Rect hmi::lineQuadBounds ( const LineQuad & quad )

nodiscardnoexcept

Boîte englobante d'un segment épais, en unités monde.

Englobe les deux extrémités et l'épaisseur (élargie d'une demi-épaisseur de chaque côté) : un segment horizontal ou vertical aurait sinon une boîte d'aire nulle, systématiquement écartée par le culling.

Parameters

quad	Primitive à borner.

Returns

Son rectangle englobant.

linkSegment()

LinkSegment hmi::linkSegment ( core::GridPosition trigger, core::GridPosition target, int fanIndex = 0, int fanCount = 1 )

nodiscardnoexcept

Calcule le segment reliant le centre de la case trigger au centre de la case target, avec un éventuel décalage perpendiculaire anti-superposition de l'extrémité cible.

Quand plusieurs liens partagent le même déclencheur, fanIndex/fanCount (index de ce lien parmi ses frères, nombre total de frères) écartent les cibles les unes des autres perpendiculairement à leur direction, pour rester lisibles (EX-IHM-030) — en éventail : l'extrémité a (centre du déclencheur) reste la même pour tous les frères, seule l'extrémité b (cible) se décale. Un décalage des deux extrémités produirait des traits parallèles empilés, moins lisible qu'un éventail partant d'une base commune.

Parameters

trigger	Case du déclencheur (origine du segment).
target	Case de la cible (extrémité du segment).
fanIndex	Index de ce lien parmi les liens partageant le même déclencheur (0-based).
fanCount	Nombre total de liens partageant ce déclencheur (>= 1).

Returns

Le segment (centres de case), décalé si fanCount > 1.

listAssetFiles()

std::vector< std::string > hmi::listAssetFiles ( const std::filesystem::path & directory, const std::string & filterText = {} )

nodiscard

Liste les fichiers image d'un dossier, filtrés par un texte de recherche.

Logique pure (aucune dépendance Qt/GPU), testable en isolation (EX-NFR-010) : c'est la balayage qui alimente hmi::AssetThumbnailView, réutilisable tel quel par toutes les sections du panneau « Textures » (Skins, puis Fond, Objets, Animations, Décors).

Parameters

directory	Dossier balayé (typiquement un sous-dossier de Assets/).
filterText	Sous-chaîne recherchée dans le nom de fichier, comparaison insensible à la casse ; vide pour ne filtrer sur rien.

Returns

Les noms de fichiers image correspondants, triés par ordre alphabétique ; vide si le dossier est absent — un état de départ légitime, pas une erreur.

listSkinAssets()

std::vector< std::string > hmi::listSkinAssets ( const std::filesystem::path & skinsDirectory )

nodiscard

Liste les fichiers de skins disponibles, par balayage d'un dossier.

Le level designer choisit dans cette liste : aucune saisie de chemin, qui serait à la fois pénible et source de configurations invalides.

Parameters

skinsDirectory

Dossier balayé (typiquement executableDirectory()/Assets/Skins).

Returns

Les noms de fichiers image, triés par ordre alphabétique ; vide si le dossier est absent — un état de départ légitime, pas une erreur.

loadDemonstrationValues()

DemonstrationCharacter hmi::loadDemonstrationValues ( )

nodiscard

Charge le personnage de démonstration livré en donnée, et calcule ses deux tables.

ÉCHAFAUDAGE, et il est écrit comme tel. Il n'existe encore ni groupe ni sauvegarde d'où tirer un personnage réel, et des écrans qui n'affichent aucun personnage ne se relisent pas. Le jour où une partie en fournira un, c'est cette fonction qui change — pas les écrans, qui ne consomment que des valeurs nommées, d'où qu'elles viennent.

Pourquoi une fonction partagée. La fiche et l'inventaire décrivent le même personnage : charger deux fois les huit catalogues aurait doublé le travail et, surtout, permis aux deux écrans de diverger — la classe d'armure de la fiche vient de ce que l'inventaire contient, et deux chargements séparés auraient pu ne pas voir le même équipement.

Une donnée manquante n'interrompt rien : l'erreur est journalisée en nommant son fichier (EX-CNT-010) et les tables sont partielles. Un écran partiel garde ses tirets, ce qui est la vérité — et vaut mieux qu'un écran vide.

Note

Nommee loadDemonstrationValues et non …Character : les vues-modeles exposent au QML une methode loadDemonstrationCharacter, et deux noms identiques auraient fait que la methode s'appelle elle-meme – la recherche de nom trouve le membre avant la fonction libre.

loadFontMetricsFromFile()

FontMetricsResult hmi::loadFontMetricsFromFile ( const std::filesystem::path & path )

nodiscard

Lit des métriques de police depuis un fichier.

Parameters

path	Chemin du fichier.

Returns

Les métriques, ou une erreur décrite (FileNotFound pour un fichier absent, cas attendu qui ne doit produire aucun avertissement côté appelant). Ne lève jamais.

loadFontMetricsFromString()

FontMetricsResult hmi::loadFontMetricsFromString ( std::string_view json )

nodiscard

Lit des métriques de police depuis une chaîne JSON.

Format : {"version":1,"lineHeight":10,"replacement":"?","glyphs":[{"char":"A","x":0,"y":0, "width":6,"height":10,"advance":6}, ...]}. "replacement" est optionnel (? par défaut).

Parameters

json	Contenu JSON.

Returns

Les métriques, ou une erreur décrite. Ne lève jamais.

loadTextureFromFile()

std::optional< LoadedTexture > hmi::loadTextureFromFile ( const RhiContext & context, const std::filesystem::path & path )

nodiscard

Décode un fichier image puis crée la texture GPU correspondante.

Parameters

context	Interface de rendu et lot de mises à jour de l'image courante.
path	Chemin du fichier image.

Returns

La texture chargée, ou std::nullopt si le décodage ou la création GPU échoue.

localizedTaxonomyLabel()

std::string hmi::localizedTaxonomyLabel ( const Localization * loc, const std::string & label )

nodiscard

Libellé de taxonomie traduit dans la langue active.

Parameters

loc	Catalogue de traduction, ou nullptr avant la première retraduction.
label	Libellé issu de la taxonomie.

Returns

Le libellé traduit, ou le libellé source à défaut de catalogue ou de clé.

measureText()

TextExtent hmi::measureText ( const FontMetrics & metrics, std::string_view text, float scale = 1.0f )

nodiscardnoexcept

Largeur et hauteur qu'occuperait text avec metrics, à l'échelle scale.

Fonction pure, sans GPU (EX-NFR-010) : c'est ce qui permet de cadrer un affichage sans le dessiner (ancrage, hmi::TextRenderer). Un retour à la ligne (\n) revient à une largeur nulle et ajoute une lineHeight ; un caractère non couvert (même après substitution) n'avance pas.

Parameters

metrics	Métriques de la police mesurée.
text	Texte UTF-8 mesuré.
scale	Facteur d'échelle appliqué aux dimensions.

Returns

La largeur de la ligne la plus longue et la hauteur totale (au moins une ligne).

mechanismDiagnosticAlpha()

float hmi::mechanismDiagnosticAlpha ( RenderMode mode, bool active, float activeAlpha, float inactiveAlpha )

nodiscardnoexcept

Alpha de diagnostic, réservé au mode Physique (LOT-47 TACHE-03).

Le mode Physique n'a pas d'assets animés et doit conserver un moyen de distinguer un mécanisme actif d'un mécanisme inactif ; le mode Texture, lui, montre désormais l'état au clip, jamais à l'alpha — la teinte y redevient un pur ajustement colorimétrique (EX-REN-046). Fonction pure, testable sans GPU : hmi::GameSession ne fait que lui fournir le mode courant, l'état et la paire d'alpha propre à la famille de mécanisme concernée (porte : ouverte plus transparente ; danger : actif plus opaque — deux sens opposés, jamais une formule unique).

Parameters

mode	Mode de rendu courant.
active	État logique du mécanisme.
activeAlpha	Alpha appliqué quand active vaut true, en mode Physique.
inactiveAlpha	Alpha appliqué quand active vaut false, en mode Physique.

Returns

1.0f en mode Texture (toujours) ; activeAlpha ou inactiveAlpha en mode Physique.

mechanismExpectedClips()

std::vector< std::string > hmi::mechanismExpectedClips ( core::TileType type )

nodiscard

Noms de clip attendus par la correspondance pour un type de mécanisme, dans l'ordre du tableau ci-dessus (utilisé par le diagnostic du panneau « Textures », LOT-47 TACHE-04).

Parameters

type	Type de tuile.

Returns

Les noms de clip attendus, dans un ordre stable ; vide si type n'est pas un mécanisme à état.

mechanismTargetClip()

std::optional< std::string > hmi::mechanismTargetClip ( core::TileType type, bool active )

nodiscardnoexcept

Nom du clip d'état cible d'un mécanisme, d'après son type et son état logique courant.

Fonction pure : ni GPU, ni Qt, ni ECS — seulement la table de correspondance (LOT-47 TACHE-01). Un type sans état renvoie std::nullopt : c'est à l'appelant de ne rien demander, plutôt qu'à cette fonction d'inventer une réponse.

Parameters

type	Type de tuile.
active	État logique courant : porte ouverte, interrupteur/plaque actionné, danger commuté actif. Sans effet pour les types sans état (un seul clip, l'état est porté par la position, pas par ce booléen).

Returns

Le nom du clip d'état cible, ou std::nullopt si type n'est pas un mécanisme à état.

mechanismTransitionClip()

std::optional< std::string > hmi::mechanismTransitionClip ( core::TileType type, bool wasActive, bool isActive )

nodiscardnoexcept

Nom du clip de transition joué une fois lors d'un changement d'état (LOT-47 TACHE-02), s'il y a lieu.

Seule Door transitionne visiblement (closed → opening → open, open → closing → closed) ; les autres familles basculent directement sur leur clip d'état cible (mechanismTargetClip). Fonction pure, ne consulte aucun catalogue d'asset : c'est à l'appelant de vérifier que le clip retourné existe réellement dans le jeu de clips de l'asset assigné, et de replier sur mechanismTargetClip sinon (LOT-47 TACHE-02, repli sur clip manquant).

Parameters

type	Type de tuile.
wasActive	État logique au pas précédent.
isActive	État logique au pas courant.

Returns

Le nom du clip de transition, ou std::nullopt si type ne transitionne pas ou que l'état n'a pas changé.

menuBackdropQuads()

std::vector< BackdropQuad > hmi::menuBackdropQuads ( int width, int height, int scale )

nodiscard

Pavés du décor, dans l'ordre de dessin (les derniers recouvrent les premiers).

Les proportions suivent la surface : le décor se recompose à toute taille de fenêtre plutôt que d'être calé sur une définition de référence. Le pas de la grille suit scale, de sorte que les blocs du sol restent alignés sur celui du jeu.

Parameters

width	Largeur de la surface, en pixels.
height	Hauteur de la surface, en pixels.
scale	Facteur d'agrandissement entier (hmi::identityScaleFor).

Returns

Les pavés à peindre ; vide si la surface est trop petite pour porter un décor.

missingTextureWarning()

std::string hmi::missingTextureWarning ( const std::string & fileName )

nodiscard

Message d'avertissement émis lorsqu'un asset attendu est introuvable ou refusé.

Fonction pure, séparée de la journalisation elle-même pour être assertable sans GPU : le message doit nommer l'asset attendu, seule information qui permette à l'auteur de savoir quoi créer.

Parameters

fileName

Nom logique de l'asset attendu.

Returns

Le message d'avertissement, en français.

mixColor()

DesignColor hmi::mixColor ( DesignColor from, DesignColor to, float ratio )

nodiscardnoexcept

Returns

Le mélange de from et to, à la proportion ratio (0 = from, 1 = to). Sert à dériver une nuance d'un jeton plutôt qu'à en écrire une nouvelle en dur : une teinte littérale ne suivrait pas un changement de palette (EX-IHM-051). ratio est borné à [0, 1].

moveRegion()

PixelRegion hmi::moveRegion	(	DecodedImage &	image,
		const PixelRegion &	region,
		int	dx,
		int	dy )

Déplace le contenu d'une région d'un décalage donné.

La région de départ devient transparente ; le contenu est reposé au décalage donné, tronqué au cadre de l'image. Un déplacement entièrement hors cadre efface la région de départ sans rien reposer de visible — jamais d'écriture hors bornes, jamais de tampon corrompu.

Parameters

image	Image modifiée en place.
region	Région déplacée ; sans effet si vide.
dx	Décalage horizontal, en pixels.
dy	Décalage vertical, en pixels.

Returns

L'union de la région quittée et de la région reposée (pour l'historique).

nearestPaletteColor()

std::uint32_t hmi::nearestPaletteColor ( std::uint32_t color, const std::vector< std::uint32_t > & palette )

nodiscardnoexcept

Couleur de palette la plus proche de color (mode « contraindre à la palette »).

Fonction pure, distance euclidienne sur les seuls canaux RVB (l'alpha d'origine est toujours préservé, voir ci-dessous). Le départage entre couleurs équidistantes retient la première rencontrée dans palette — déterministe et stable, pour qu'un même geste sur une même image produise toujours le même résultat.

Un pixel totalement transparent (alpha nul) est renvoyé inchangé : ce n'est pas une couleur mais l'état « gomme », qui doit rester accessible même en mode contraint. Une palette vide laisse également la couleur inchangée plutôt que de produire une couleur indéfinie.

Parameters

color	Couleur posée par le geste courant.
palette	Couleurs de la palette (généralement PixelPalette::entries(), projetées sur leur seul champ color).

Returns

La couleur contrainte, alpha d'origine préservé.

nextRpgScreen()

RpgScreenId hmi::nextRpgScreen ( RpgScreenId screen )

nodiscardnoexcept

Returns

L'écran suivant dans le cycle ; du dernier on revient au premier. C'est ce qui permet d'atteindre n'importe quel écran depuis n'importe quel autre sans repasser par le menu (EX-IHM-090).

nextUtf8CodePoint()

char32_t hmi::nextUtf8CodePoint ( std::string_view text, std::size_t & index )

nodiscardnoexcept

Décode le point de code UTF-8 suivant d'une chaîne.

La mesure et la composition du texte (hmi::TextRenderer) doivent parcourir des points de code, pas des octets : un caractère accentué du catalogue de traduction (EX-REN-033) occupe plusieurs octets en UTF-8.

Parameters

text	Chaîne UTF-8 parcourue.
index	Décalage en octets ; avancé jusqu'au début du point de code suivant.

Returns

Le point de code décodé ; 0xFFFD (caractère de remplacement Unicode) sur une séquence invalide ou tronquée (avance alors d'un seul octet, jamais de plantage).

paletteThumbnail()

PaletteThumbnail hmi::paletteThumbnail ( RenderMode mode, core::TileType type, const core::AtlasRegion & physicalRegion, const SkinCatalog * catalog, std::string_view setName )

nodiscard

Choisit la vignette à afficher pour un type de tuile dans la palette.

INVARIANT : ce que la palette montre est ce que le canevas posera. Dès lors que le canevas affiche des textures, une palette qui montrerait encore des pastilles de couleur ferait choisir « la tuile violette » à l'aveugle.

Applique exactement la même priorité que le canevas (hmi::resolveTileAppearance) — mode Physique → couleur plate ; sinon skin assigné ; sinon damier. Les deux ne peuvent diverger que si l'on duplique la décision, d'où cette fonction unique plutôt qu'un choix pris dans le widget.

Un type en mode bitmask16 rend la case représentative de la planche (l'intérieur plein) : la planche entière serait illisible en vignette, et la case zéro — la tuile isolée — serait un cas particulier peu représentatif du motif.

Logique pure (aucune dépendance Qt/GPU), testable en isolation (EX-NFR-010).

Parameters

mode	Mode de rendu courant (EX-REN-046).
type	Type de tuile dont on veut la vignette.
physicalRegion	Région d'atlas du type en mode Physique (hmi::regionForTile).
catalog	Catalogue des skins, ou nullptr si aucun n'est chargé.
setName	Jeu de skins courant ; vide pour le jeu par défaut du catalogue.

Returns

La vignette à afficher.

panelFocusCatalog()

const std::array< PanelFocusEntry, PANEL_FOCUS_CATALOG_COUNT > & hmi::panelFocusCatalog ( )

nodiscard

Returns

La table complète outil → panneau.

panelForPixelTool()

std::optional< PanelId > hmi::panelForPixelTool ( PixelTool tool )

nodiscard

Returns

Le panneau à mettre en avant pour l'outil de canevas tool.

panelForTool()

std::optional< PanelId > hmi::panelForTool ( EditorTool tool )

nodiscard

Returns

Le panneau à mettre en avant pour tool, ou std::nullopt si cet outil n'en a pas (ses contrôles vivent ailleurs, ou son panneau n'est tabifié avec aucun autre – une mise en avant n'y aurait aucun effet).

parallaxModelPosition()

core::Vector2 hmi::parallaxModelPosition ( core::Vector2 renderPosition, core::Vector2 factor, const core::Rect & cameraBounds )

nodiscardnoexcept

Inverse de parallaxRenderPosition : retrouve la position modèle équivalente à un point exprimé en espace de rendu (LOT-50 TACHE-02).

Nécessaire à l'éditeur : le curseur converti par hmi::Camera2D::screenToWorld est comparable à la position de rendu d'un contenu parallaxé (c'est elle qui occupe l'écran), jamais directement à sa position modèle dès que le facteur diffère de 1.0. Cette fonction ramène donc un point d'écran dans l'espace modèle, pour que ce qu'on manipule reste visuellement « collé » au curseur quel que soit son facteur de parallaxe.

Parameters

renderPosition	Position en espace de rendu, en unités monde.
factor	Facteur de parallaxe par axe.
cameraBounds	Même rectangle caméra que celui utilisé pour parallaxRenderPosition.

Returns

La position modèle correspondante ; l'axe est laissé inchangé si son facteur est nul (robustesse — un facteur nul n'est pas inversible).

parallaxRenderPosition()

core::Vector2 hmi::parallaxRenderPosition ( core::Vector2 modelPosition, core::Vector2 factor, const core::Rect & cameraBounds )

nodiscardnoexcept

Calcule la position de rendu d'un contenu, décalée par sa parallaxe.

Fonction pure, sans état (LOT-49 TACHE-03) : le décalage est calculé relativement au centre de la salle courante (cameraBounds, le rectangle cadré par la caméra — solidaire de la salle, EX-REN-015) et non en espace niveau absolu. Formulation : la position de rendu est le centre de la salle, plus le déplacement du contenu par rapport à ce centre, mis à l'échelle du facteur — de sorte qu'à facteur 1.0 (PARALLAX_FACTOR_NONE) la position est inchangée, et que deux contenus à la même position relative dans deux salles différentes se retrouvent au même endroit à l'écran, quelle que soit la position absolue de chaque salle.

C'est le seul comportement cohérent avec une caméra à coupure nette entre salles (EX-REN-015, LOT-32) : un décalage absolu en espace niveau ferait sauter le contenu à chaque bascule (artefact visible) ; ce décalage-ci se replace au moment exact où toute l'image change déjà (invisible). Un décalage absolu a été envisagé au cadrage du LOT-69, au motif qu'un plan continu n'a pas de repère ponctuel ; il a été écarté pour cette raison précise.

Parameters

modelPosition	Position en espace modèle, en unités monde — jamais modifiée par cette fonction : la parallaxe est purement visuelle (EX-ARCH-012).
factor	Facteur de parallaxe par axe (core::Plane::parallaxX/parallaxY).
cameraBounds	Rectangle cadré par la caméra (hmi::Camera2D::visibleBounds), en unités monde.

Returns

La position à utiliser pour le rendu (et le culling) de ce contenu.

pasteClipboard()

PixelRegion hmi::pasteClipboard	(	DecodedImage &	image,
		const PixelClipboard &	clipboard,
		int	x,
		int	y )

Colle un presse-papiers dans l'image, coin haut-gauche à (x, y).

Tronqué au cadre de l'image : coller près d'un bord n'écrit jamais hors bornes (chaque pixel passe par setPixel, qui ignore silencieusement les positions hors bornes).

Parameters

image	Image modifiée en place.
clipboard	Contenu à coller ; sans effet si vide.
x	Colonne du coin haut-gauche du contenu collé.
y	Ligne du coin haut-gauche du contenu collé.

Returns

La région effectivement écrite (peut être plus petite que clipboard si tronquée).

pausesGame()

bool hmi::pausesGame ( RpgScreenId screen )

nodiscardnoexcept

Returns

true si screen suspend la simulation (EX-IHM-091).

pickColor()

std::optional< std::uint32_t > hmi::pickColor ( const DecodedImage & image, int x, int y )

nodiscardnoexcept

Couleur du pixel à une position donnée (outil pipette).

Parameters

image	Image consultée.
x	Colonne.
y	Ligne.

Returns

La couleur du pixel, ou std::nullopt si (x, y) est hors bornes.

pixelCanvasGridVisible() [1/2]

bool hmi::pixelCanvasGridVisible ( const PixelCanvasView & view )

nodiscardconstexprnoexcept

true si la grille de pixels doit être dessinée pour cette vue : jamais sous le 1:1, où elle couvrirait plus de surface que les pixels qu'elle sépare.

pixelCanvasGridVisible() [2/2]

bool hmi::pixelCanvasGridVisible ( int zoom )

nodiscardconstexprnoexcept

true si la grille de pixels doit être dessinée à ce zoom (PIXEL_CANVAS_GRID_VISIBLE_MIN_ZOOM).

pixelCanvasRealSize() [1/2]

PixelCanvasRealSize hmi::pixelCanvasRealSize ( int imageWidth, int imageHeight, const PixelCanvasView & view, double scaleFactor )

nodiscardnoexcept

Taille en pixels réels du canevas entier, à l'échelle rationnelle d'une vue.

Parameters

imageWidth	Largeur de l'image, en pixels.
imageHeight	Hauteur de l'image, en pixels.
view	Vue courante (numérateur, dénominateur).
scaleFactor	Facteur d'échelle du support d'affichage (devicePixelRatio).

pixelCanvasRealSize() [2/2]

PixelCanvasRealSize hmi::pixelCanvasRealSize ( int imageWidth, int imageHeight, int zoom, double scaleFactor )

nodiscardnoexcept

Taille en pixels réels du canevas entier à un facteur d'échelle d'affichage donné.

Réutilise directement hmi::thumbnailPixelSize (LOT-56 TACHE-05) — jamais réécrite : c'est la même fonction qui dimensionne les vignettes de la bibliothèque et du panneau Textures, pour que le canevas ne redevienne pas flou à 125 %/150 % le jour où elle évolue sans lui.

Parameters

imageWidth	Largeur de l'image, en pixels.
imageHeight	Hauteur de l'image, en pixels.
zoom	Facteur de zoom entier du canevas.
scaleFactor	Facteur d'échelle du support d'affichage (devicePixelRatio).

pixelCanvasScale()

double hmi::pixelCanvasScale ( const PixelCanvasView & view )

nodiscardconstexprnoexcept

Échelle effective d'une vue : numérateur / dénominateur.

Les pixels restent carrés par construction — une seule échelle, appliquée aux deux axes (EX-ARCH-022). Il n'y a jamais eu, et il ne peut pas y avoir, d'échelle par axe ici.

Parameters

view	Vue courante.

Returns

Le nombre de pixels écran par pixel image ; 0 si la vue est dégénérée.

pixelCanvasZoomIn() [1/2]

PixelCanvasView hmi::pixelCanvasZoomIn ( const PixelCanvasView & view )

nodiscardconstexprnoexcept

Vue agrandie d'un cran, en remontant l'échelle rationnelle.

L'échelle parcourt 1/8, 1/4, 1/2, 1, 2, 3, … : on remonte d'abord les dénominateurs jusqu'à 1, puis les numérateurs. Le décalage de vue est conservé tel quel.

Parameters

view	Vue courante.

Returns

La vue au cran suivant.

pixelCanvasZoomIn() [2/2]

int hmi::pixelCanvasZoomIn ( int zoom )

nodiscardconstexprnoexcept

Zoom suivant (plus grand), borné — toujours entier.

pixelCanvasZoomOut() [1/2]

PixelCanvasView hmi::pixelCanvasZoomOut ( const PixelCanvasView & view )

nodiscardconstexprnoexcept

Vue réduite d'un cran, en descendant l'échelle rationnelle — sous le 1:1 si besoin.

Parameters

view	Vue courante.

Returns

La vue au cran précédent.

pixelCanvasZoomOut() [2/2]

int hmi::pixelCanvasZoomOut ( int zoom )

nodiscardconstexprnoexcept

Zoom précédent (plus petit), borné — toujours entier.

pixelInBounds()

bool hmi::pixelInBounds ( int width, int height, int x, int y )

nodiscardconstexprnoexcept

Returns

true si (x, y) est dans les bornes d'une image width x height.

pixelOperationTranslationKey()

std::string_view hmi::pixelOperationTranslationKey ( PixelOperationKind kind )

nodiscardnoexcept

Clé de traduction décrivant une opération.

Parameters

kind	Type d'opération.

Returns

La clé (existe dans les deux catalogues, fr.lang/en.lang).

pixelPanelFocusCatalog()

const std::array< PixelPanelFocusEntry, PIXEL_PANEL_FOCUS_CATALOG_COUNT > & hmi::pixelPanelFocusCatalog ( )

nodiscard

Returns

La table complète outil de canevas → panneau.

planeParallaxActive()

bool hmi::planeParallaxActive ( core::CameraFramingMode mode, bool levelFlag )

nodiscardconstexprnoexcept

Décide si la parallaxe des plans s'applique, selon le mode de cadrage et le drapeau du niveau (EX-DEC-043, EX-REN-016).

Table pure, plutôt qu'une condition disséminée dans la session de jeu :

• Follow → active. Seul mode où la caméra défile, donc le seul où la parallaxe se lit. Inverse la décision du LOT-64, qui l'avait coupée parce qu'un décor est un objet collé au contenu et paraissait « suivre » la caméra ; un plan est un fond, l'argument tombe.
• PerRoom → active. Formule relative à la salle, donc sans saut à la bascule (EX-REN-015).
• WholeLevel → neutralisée. La caméra ne bouge pas : le décalage serait une constante, donc un simple désalignement du plan par rapport aux tuiles.

Le drapeau est par niveau, mais la neutralisation en WholeLevel est une règle du moteur : un level designer qui coche « parallaxe » sur un niveau WholeLevel ne verrait rien. L'interface grise donc la case dans ce mode et l'explique (TACHE-08), sinon c'est un défaut perçu.

Parameters

mode	Mode de cadrage du niveau.
levelFlag	Drapeau parallax déclaré par le niveau (core::Level::parallaxEnabled).

Returns

true si le décalage doit être appliqué aux plans.

planePixelSize()

PlanePixelSize hmi::planePixelSize ( int widthUnits, int heightUnits, int pixelsPerUnit )

nodiscardnoexcept

Dimensions, en pixels, du PNG d'un plan.

Le format borne déjà le produit taille × densité au chargement (EX-DEC-044) : cette fonction ne re-valide rien, elle dérive. Sa raison d'être est qu'un seul endroit décide de ces dimensions — la création du fichier, le changement de densité et le contrôle de cohérence (TACHE-10) doivent tomber d'accord, et trois calculs séparés finiraient par diverger.

Parameters

widthUnits	Largeur du niveau, en cases.
heightUnits	Hauteur du niveau, en cases.
pixelsPerUnit	Densité du plan (4, 8 ou 16).

Returns

Les dimensions attendues ; {0, 0} si un paramètre est invalide.

planeRenderLayer()

RenderLayer hmi::planeRenderLayer ( core::PlaneDepth depth )

nodiscardnoexcept

Projette la profondeur d'un plan sur le calque de rendu correspondant.

Core ne connaît pas hmi::RenderLayer (EX-NFR-011) : la projection est le travail de HMI, et elle vit ici, en un point unique. Deux profondeurs, deux calques déjà réservés par LOT-40 — aucune valeur d'énumération n'est ajoutée, et RENDER_LAYER_COUNT ne bouge pas, alors même que le nombre de plans est libre : c'est le rang dans la liste qui les ordonne à l'intérieur d'un calque, pas une valeur de calque par plan (EX-REN-014).

Parameters

depth

Côté de l'ordonnancement déclaré par le plan.

Returns

RenderLayer::Plane derrière les tuiles, RenderLayer::Foreground devant le personnage.

planesTextureMemoryBytes()

std::size_t hmi::planesTextureMemoryBytes ( const std::vector< core::Plane > & planes, int levelWidth, int levelHeight )

nodiscardnoexcept

Somme de hmi::planeTextureMemoryBytes sur tous les plans d'un niveau.

Parameters

planes	Plans du niveau.
levelWidth	Largeur du niveau, en cases.
levelHeight	Hauteur du niveau, en cases.

Returns

Le poids total en octets.

planeTextureMemoryBytes()

std::size_t hmi::planeTextureMemoryBytes ( const core::Plane & plane, int levelWidth, int levelHeight )

nodiscardnoexcept

Mémoire de texture qu'un plan exige du format, en octets (EX-NFR-043).

Dérivée de la taille du niveau et de la densité (hmi::planePixelSize) — donc de ce que le niveau déclare, jamais de ce qui se trouve sur le disque. C'est le sens utile pour un budget : un plan dont l'image manque coûterait le damier de repli, ce qui masquerait précisément le coût qu'on veut plafonner.

Le budget du LOT-62 plafonne des primitives par niveau. Les plans le prennent à contre-pied : ils ajoutent un seul quad chacun, mais occupent une texture à l'échelle du niveau. Un plafond exprimé en primitives laisserait donc passer un niveau 200 × 100 à densité native, à 20 Mo par plan. D'où ce second axe.

Parameters

plane	Plan mesuré.
levelWidth	Largeur du niveau, en cases.
levelHeight	Hauteur du niveau, en cases.

Returns

Son poids en octets ; 0 si la densité ou les dimensions sont hors format.

previousRpgScreen()

RpgScreenId hmi::previousRpgScreen ( RpgScreenId screen )

nodiscardnoexcept

Returns

L'écran précédent dans le cycle ; du premier on revient au dernier.

proceduralPlayerClipNames()

const std::vector< std::string > & hmi::proceduralPlayerClipNames ( )

nodiscard

Noms des clips que l'atlas procédural sait dessiner (Idle/Run/Jump, LOT-18) : seule source de vérité, partagée avec hmi::PlayerClipKind — traitée comme une « spritesheet » n'en déclarant que trois par hmi::resolveDeclaredPlayerClip.

qtKeyToHmiKey()

std::optional< hmi::Key > hmi::qtKeyToHmiKey ( int qtKey )

nodiscard

Traduit un code Qt::Key en hmi::Key.

Les lettres/chiffres/espace partagent déjà la même valeur entre Qt et Win32 (Qt::Key_A == VK 'A' == 0x41) ; seules les touches spéciales (flèches, Échap, Tab, Maj, Ctrl, F1/F2/F10) passent par une correspondance explicite. nullopt pour une touche non suivie.

readRegion()

std::vector< std::uint32_t > hmi::readRegion ( const DecodedImage & image, const PixelRegion & region )

nodiscard

Copie les pixels d'une région, ligne par ligne — capture le « avant » ou l'« après » d'une entrée d'historique (hmi::PixelHistory).

Parameters

image	Image consultée.
region	Région à copier (doit être contenue dans les bornes de image).

Returns

Les pixels de la région, taille region.width() * region.height() ; vide si region est vide.

reapplyEditorTheme()

void hmi::reapplyEditorTheme

(

)

Réapplique la palette et la feuille de style (mais pas la police, inchangée par le thème) depuis currentEditorTokens() — bascule à chaud (LOT-56 TACHE-06), sans reconstruire les widgets.

Les icônes et vignettes ne suivent pas automatiquement : leurs propriétaires (EditorActions::refreshIcons, caches de vignettes) doivent être resynchronisés séparément.

regionForTile()

core::AtlasRegion hmi::regionForTile ( core::TileType type )

nodiscard

Région d'atlas (couleur procédurale) associée à un type de tuile.

Unique correspondance type → région, utilisée par GameSession (rendu d'un niveau joué), hmi::DraftRenderer (canevas de l'éditeur) et la palette de l'éditeur (hmi::PalettePanel) : le canevas de l'éditeur est un aperçu fidèle de ce que le joueur verra en jouant le niveau (P), sans simplification qui pourrait induire en erreur pendant l'édition. Ne dépend que de la géométrie de grille de hmi::TextureAtlas (constantes et découpage statiques), jamais d'une texture chargée : la palette de l'éditeur peut donc l'appeler sans device Direct3D, ce qu'un widget Qt ne doit de toute façon jamais exiger.

Parameters

type	Type de tuile (Empty renvoie une région arbitraire, jamais dessinée en pratique — les cases vides ne sont pas rendues par l'appelant).

Returns

La région d'atlas à échantillonner pour ce type.

relativeLuminance()

double hmi::relativeLuminance ( DesignColor color )

nodiscardnoexcept

Luminance relative WCAG d'une couleur (0 = noir, 1 = blanc), pour le calcul de contraste.

renderBand()

std::int32_t hmi::renderBand ( RenderLayer layer )

nodiscardconstexprnoexcept

Bande de tri d'un calque : Object et Player en partagent une seule.

Sans cela, le rang de calque trancherait avant la profondeur et le personnage passerait toujours devant un objet, quelle que soit sa position — exactement ce que le tri par Y doit corriger. Tous les autres calques restent leur propre bande : un plan pictural ne se mélange jamais au décor, et les aides d'édition restent au-dessus de tout (EX-REN-014).

renderLayerName()

const char * hmi::renderLayerName ( RenderLayer layer )

nodiscardconstexprnoexcept

Nom lisible d'un calque, pour la journalisation et les messages d'échec de test.

Parameters

layer

Calque à nommer.

Returns

Le nom du calque (chaîne statique, jamais nulle).

renderModeFromName()

RenderMode hmi::renderModeFromName ( const std::string & name )

nodiscardnoexcept

Mode de rendu correspondant à un nom persisté.

Fonction pure (aucune dépendance Qt ni GPU), donc testable en isolation : une préférence absente, vide ou corrompue est un cas attendu, pas une erreur — elle retombe silencieusement sur hmi::DEFAULT_RENDER_MODE plutôt que de refuser de démarrer.

Parameters

name	Nom lu dans les préférences (comparaison insensible à la casse).

Returns

Le mode correspondant, ou hmi::DEFAULT_RENDER_MODE si name n'en désigne aucun.

renderModeName()

const char * hmi::renderModeName ( RenderMode mode )

nodiscardnoexcept

Nom persisté d'un mode de rendu (valeur écrite dans les préférences).

Parameters

mode	Mode à nommer.

Returns

Le nom stable du mode (chaîne statique, jamais nulle).

resamplePlane()

DecodedImage hmi::resamplePlane ( const DecodedImage & image, int fromPixelsPerUnit, int toPixelsPerUnit )

nodiscard

Rééchantillonne une image d'une densité à une autre, par ratio entier.

Jamais d'interpolation : 16 → 8 garde un pixel sur deux, 8 → 16 en duplique chacun. Un filtrage moyennerait des couleurs voisines et introduirait des teintes que l'artiste n'a pas posées — inacceptable en pixel art, et contraire à EX-ARCH-022.

Sert deux besoins : aplatir des plans de densités différentes sur un même repère (flattenPlanes) et changer la densité d'un plan depuis le panneau (TACHE-08), auquel cas la perte est réelle et assumée — descendre puis remonter ne restitue pas l'original.

Parameters

image	Image source.
fromPixelsPerUnit	Densité de image (> 0).
toPixelsPerUnit	Densité voulue (> 0).

Returns

L'image rééchantillonnée ; une copie de image si les deux densités sont égales, une image vide si l'une est invalide ou si leur rapport n'est pas entier dans un sens ou dans l'autre.

resolveBackgroundTexture()

BackgroundTexture hmi::resolveBackgroundTexture ( const std::optional< std::string > & background, TextureCache & cache )

nodiscard

Résout la texture de fond d'un niveau (accès TextureCache/GPU, LOT-44).

Point de résolution unique du repli en damier pour le fond (hmi::resolveOrPlaceholder, EX-NFR-040) : un asset absent ou invalide bascule sur le damier magenta, après l'avertissement déjà journalisé par le cache. Aucun accès cache n'a lieu si background est absent — même séparation résolution/composition que hmi::sceneTextures vis-à-vis de hmi::composeWorldSprites.

Parameters

background	Nom de l'asset de fond du niveau (core::Level::background), ou absent.
cache	Cache de textures, résout l'asset (et son repli en damier).

Returns

La texture à composer (hmi::composeBackground) ; texture == nullptr si aucun fond n'est désigné.

resolveDeclaredPlayerClip()

std::string hmi::resolveDeclaredPlayerClip ( const std::vector< std::string > & declaredNames, std::string_view requested )

nodiscard

Résout un nom de clip demandé vers le plus proche déclaré dans un jeu partiel (LOT-48 TACHE-01/TACHE-02).

Une spritesheet externe — ou l'atlas procédural, qui n'en déclare que trois (hmi::proceduralPlayerClipNames) — peut ne pas fournir tous les clips que core::AnimationSystem projette (fall, land, wallslide, dash). Chaîne de repli fixe, documentée ici comme seule source de vérité : fall → jump, land → idle, wallslide → jump, dash → run, run → idle, jump → idle ; idle est le dernier recours (toujours supposé déclaré). Fonction pure, testable sans GPU.

Parameters

declaredNames	Noms de clips effectivement fournis par la source consultée.
requested	Nom de clip demandé (résolu par core::AnimationSystem).

Returns

Le nom du clip à effectivement afficher : requested s'il est déclaré, sinon le premier nom de la chaîne de repli qui l'est ; "idle" en dernier recours.

resolvedFontFamily()

std::string hmi::resolvedFontFamily ( FontRole role )

nodiscard

Nom de famille effectivement enregistré pour la police de corps de role, ou une chaîne vide si l'enregistrement a échoué (l'appelant emploie alors une famille générique).

Renseigné par applyFont() ; vide tant qu'elle n'a pas été appelée.

resolveEffectiveEditorTheme()

EditorThemeMode hmi::resolveEffectiveEditorTheme ( EditorThemeSetting setting, bool systemPrefersDark )

nodiscardnoexcept

Résout le thème effectif à appliquer.

Fonction pure : System + système clair -> Light ; System + système sombre -> Dark ; Light/Dark forcé -> ignore le réglage système.

Parameters

setting	Réglage utilisateur courant.
systemPrefersDark	Le système d'exploitation préfère-t-il un thème sombre.

Returns

Le thème à appliquer au châssis d'édition (jamais à l'identité du jeu, invariante).

resolveFontFamily()

FontFamilyResolution hmi::resolveFontFamily ( bool fontRegistered, const std::string & embeddedFamilyName )

nodiscard

Choisit la famille de police à employer pour le corps de l'IHM.

Parameters

fontRegistered	true si le fichier de police embarquée a pu être enregistré auprès de QFontDatabase (les deux graisses, régulière et grasse).
embeddedFamilyName	Nom de famille rapporté par Qt pour la police embarquée (ex. "Inter").

Returns

La police embarquée si fontRegistered vaut true ; sinon un résultat sans nom de famille, signalant à l'appelant de retomber sur une famille générique.

resolveLinkClick()

LinkGestureDecision hmi::resolveLinkClick ( std::optional< PendingLink > pending, core::GridPosition clickedCell, core::TileType clickedTileType, bool alreadyLinked )

nodiscardnoexcept

Résout le clic de l'outil « Lien » sur clickedCell selon l'attente courante.

Reproduit le geste de liaison de l'éditeur (clic déclencheur → attente de cible, clic cible → liaison créée ; refaire la même paire la supprime) : case ni déclencheur ni cible → ignorée ; pas d'attente valide → la case cliquée devient l'attente ; attente de même catégorie que le clic (deux déclencheurs ou deux cibles) → remplace l'attente ; catégories complémentaires → crée ou retire la liaison (bascule) selon alreadyLinked. Une attente dont le type a changé entretemps (case repeinte) n'est plus ni déclencheur ni cible : traitée comme aucune attente.

Parameters

pending	Case en attente d'appariement, si une a été posée par un clic précédent.
clickedCell	Case visée par le clic courant.
clickedTileType	Type de tuile à clickedCell au moment du clic.
alreadyLinked	true si la paire (déclencheur, cible) résolue est déjà liée dans le brouillon — non pertinent (ignoré) si les catégories ne se complètent pas encore.

Returns

La décision à appliquer.

resolveOrPlaceholder()

const LoadedTexture * hmi::resolveOrPlaceholder ( TextureCache & cache, const std::string & fileName, AssetFamily family )

nodiscard

Obtient la texture d'un asset, ou le repli en damier magenta à défaut.

Point de résolution unique du repli : tous les lots d'habillage (LOT-42, LOT-44, LOT-45, LOT-49) passent par ici plutôt que de réimplémenter chacun son propre comportement de secours — c'est la seule façon de garantir qu'un asset manquant se voie toujours de la même manière et soit toujours journalisé (EX-NFR-040, EX-REN-007).

Parameters

cache	Cache interrogé (et propriétaire du damier partagé).
fileName	Nom logique de l'asset attendu, repris dans l'avertissement journalisé.
family	Famille de l'asset, qui fixe les dimensions attendues.

Returns

La texture de l'asset si elle est disponible, sinon le damier de repli ; nullptr seulement si même le damier n'a pas pu être créé.

resolvePlaneTextures()

std::vector< PlaneTexture > hmi::resolvePlaneTextures ( TextureCache & cache, const std::filesystem::path & directory, const std::vector< core::Plane > & planes )

nodiscard

Résout les images des plans d'un niveau (accès disque/GPU), dans l'ordre de la liste.

Repli en damier sur image absente ou illisible (EX-NFR-040) : un plan pointant un fichier disparu reste un niveau valide (Core ne vérifie pas l'existence, EX-NFR-011) — c'est ici que le manque devient visible plutôt que silencieux.

Parameters

cache	Cache de textures (propriétaire du damier partagé et de la mémoïsation).
directory	Dossier des images de plans (typiquement Levels/Plans).
planes	Plans du niveau, dans l'ordre déclaré.

Returns

Une entrée par plan, **alignée sur planes**.

resolveTextureAssignClick()

TextureAssignDecision hmi::resolveTextureAssignClick ( core::GridPosition clickedCell, core::TileType clickedTileType, const std::optional< std::string > & existingOverride, const std::optional< std::string > & selectedAsset, bool rightClick )

nodiscardnoexcept

Résout le clic de l'outil « Texture par instance » sur clickedCell.

Ne modifie rien par lui-même : décrit l'action, l'appelant l'applique au brouillon (même séparation que hmi::resolveLinkClick). Une case Empty est toujours ignorée — l'usage est purement visuel, mais une case vide n'a rien à habiller. Un clic droit retire l'override existant (sans effet si la case n'en a pas) ; un clic gauche sur l'asset déjà assigné retire aussi l'override (bascule, évite un clic droit pour le cas courant) ; un clic gauche sans asset sélectionné dans la bibliothèque est ignoré (rien à assigner).

Parameters

clickedCell	Case visée par le clic.
clickedTileType	Type de tuile à clickedCell au moment du clic.
existingOverride	Nom de l'asset déjà assigné à clickedCell, si elle en a un.
selectedAsset	Asset actuellement sélectionné dans la bibliothèque « Objets », si un l'est.
rightClick	true si le clic est un clic droit (retrait explicite).

Returns

La décision à appliquer.

resolveTileAppearance()

std::optional< TileAppearance > hmi::resolveTileAppearance ( RenderMode mode, const core::AtlasRegion & physicalRegion, const TileSkinTag * tag, const SceneTextures & textures, bool skinVisible = true, bool overrideVisible = true )

nodiscardnoexcept

Résout l'apparence d'une entité affichée selon le mode de rendu courant.

Point d'appel unique de cette décision, partagé par le jeu et l'éditeur : c'est ce qui garantit que le canevas de l'éditeur montre exactement ce que le joueur verra. Fonction pure (aucune dépendance GPU), appelée à la composition et non à la construction de la scène : basculer de mode ne reconstruit donc jamais l'ECS, seule la résolution change.

Ordre de priorité en mode Texture : surcharge par instance, puis skin de tuile, puis damier (LOT-45 et LOT-42).

• RenderMode::Physique → la région d'atlas déjà portée par le core::Sprite, c'est-à-dire le résultat de hmi::regionForTile — comportement strictement inchangé, quel que soit le reste ;
• RenderMode::Texture + entité portant une surcharge (hmi::TileSkinTag::overrideAsset) chargée → l'image entière de la surcharge (EX-EDIT-043) ; une surcharge posée mais dont l'asset est introuvable retombe directement sur le damier, jamais sur le skin du type (sinon l'auteur croit son assignation prise en compte alors qu'elle est cassée) ;
• RenderMode::Texture + entité habillable (sans surcharge) dont le type est skinné et dont le skin est chargé → la case du skin (l'image entière en mode single, la case choisie par les raccords en mode bitmask16) ;
• tout autre cas (entité sans hmi::TileSkinTag, type non skinné, asset absent ou refusé) → le damier magenta en entier. C'est un état normal du programme d'habillage tant que tous les types ne sont pas habillés, pas un défaut (EX-NFR-040).

skinVisible et overrideVisible pilotent le mode d'inspection « définition des textures » de l'éditeur (hmi::LayerVisibility, LOT-51, EX-EDIT-044) : à true tous les deux (le défaut), le comportement ci-dessus est exactement celui de LOT-45, sans repli différent. Dès que l'un des deux vaut false, la résolution isole — plus de repli sur le damier pour l'axe masqué :

• une surcharge dont l'axe (overrideVisible) est masqué ne s'affiche pas du tout ;
• un skin dont l'axe (skinVisible) est masqué ne s'affiche pas du tout ;
• une entité sans surcharge, quand overrideVisible seul est masqué, s'affiche normalement (le skin n'a pas besoin de la surcharge pour être signifiant) ;
• une entité sans surcharge ni skin (chargé) n'affiche rien dès que skinVisible est actif seul (pas de damier : ce n'est pas ce qu'on isole) — alors qu'en mode composé (les deux true), elle affiche le damier comme avant.

  Parameters

  mode	Mode de rendu courant.
  physicalRegion	Région d'atlas de l'entité en mode Physique (core::Sprite::region).
  tag	Type et voisinage de la tuile, ou nullptr pour une entité non habillable (personnage, aides d'édition) — qui reste alors au damier en mode Texture.
  textures	Textures liables, catalogue et jeu de skins courant.
  skinVisible	Axe « skin de type » visible (LOT-51) ; true par défaut (comportement LOT-45 inchangé pour tout appelant qui ignore cet axe).
  overrideVisible	Axe « surcharge par instance » visible (LOT-51) ; true par défaut.

  Returns

  L'apparence à utiliser pour composer la primitive, ou std::nullopt si rien ne doit être composé pour cette entité (calque masqué, ou axe isolé sans rien à montrer, LOT-51).

resolveTransition()

std::optional< ScreenState > hmi::resolveTransition ( const ScreenState & current, ScreenEvent event )

nodiscardnoexcept

Résout une transition d'écran à partir de l'état courant et d'un événement.

Returns

Le nouvel état, ou std::nullopt si event est interdit depuis current.screen – l'appelant garde alors l'état courant inchangé, jamais de bascule silencieuse (EX-GP-041).

rotateClockwise()

PixelRegion hmi::rotateClockwise	(	DecodedImage &	image,
		const PixelRegion &	region )

Pivote le contenu d'une région d'un quart de tour, sens horaire.

La région d'origine est effacée (alpha nul), puis le contenu pivoté (largeur/hauteur échangées) est écrit ancré au même coin haut-gauche — sur une région non carrée, le nouveau contour déborde donc du contour d'origine ; ce débordement est tronqué au cadre de l'image, jamais agrandi (setPixel ignore silencieusement tout pixel hors bornes).

Parameters

image	Image modifiée en place.
region	Région pivotée ; sans effet si vide.

Returns

L'union de la région effacée et de la région écrite (pour l'historique).

rotateCounterClockwise()

PixelRegion hmi::rotateCounterClockwise	(	DecodedImage &	image,
		const PixelRegion &	region )

Pivote le contenu d'une région d'un quart de tour, sens antihoraire (trois quarts de tour horaires, pour ne pas dupliquer la logique de rotation).

Mêmes règles de troncature que rotateClockwise.

roundToScreenPixel()

core::Vector2 hmi::roundToScreenPixel ( core::Vector2 worldPosition, float pixelsPerWorldUnit )

nodiscardnoexcept

Arrondit une position monde au pixel écran le plus proche, pour un zoom pixel art net.

Un décalage de parallaxe fractionnaire produirait une image floue ou tremblante : le zoom de la caméra est entier quand c'est possible (EX-ARCH-022), mais un décalage de parallaxe quelconque, lui, ne l'est pas — cette fonction referme cet écart, après application de la parallaxe et de son bornage. Fonction pure, sans dépendance GPU.

Parameters

worldPosition	Position à arrondir, en unités monde.
pixelsPerWorldUnit	Échelle courante (hmi::Camera2D::PIXELS_PER_UNIT * zoom) ; worldPosition est renvoyée inchangée si cette valeur n'est pas strictement positive (robustesse).

Returns

La position arrondie au pixel écran entier le plus proche.

rpgScreenDescriptor()

const RpgScreenDescriptor & hmi::rpgScreenDescriptor ( RpgScreenId screen )

nodiscardnoexcept

Returns

La description de screen.

rpgScreens()

std::span< const RpgScreenDescriptor > hmi::rpgScreens ( )

nodiscardnoexcept

Returns

La table des écrans, dans l'ordre du cycle de navigation.

ruleLabel()

std::string hmi::ruleLabel ( std::string_view key, const std::string & language )

nodiscard

Nom lisible d'un terme de règle — caractéristique, emplacement d'équipement, condition.

Pourquoi ceux-là ne passent pas par qsTr

La chrome des écrans (« Points de vie », « Nouvelle partie ») s'écrit en français dans le fichier QML, et Qt la traduit par sa source. Ces libellés-ci ne le peuvent pas : leur clé est calculée (rpg.ability. + l'identifiant que le modèle rend), et qsTr exige une chaîne littérale — c'est ce qui permet à lupdate de l'extraire sans exécuter le programme.

Ce n'est pas qu'une contrainte technique. Ces termes sont un lexique : rpg.glossary.csv garantit une seule traduction par terme de règle dans tout le jeu, et scripts/check_glossary.py le vérifie. Les disperser en littéraux dans les écrans casserait précisément cette garantie.

Parameters

key	Clé du catalogue (« rpg.ability.strength »).
language	Langue demandée (« fr », « en »).

Returns

Le libellé traduit ; la clé elle-même si le catalogue ne la porte pas — jamais une chaîne vide, qui donnerait un écran troué sans dire pourquoi.

sanitizePlaneBaseName()

std::string hmi::sanitizePlaneBaseName ( const std::string & name )

nodiscard

Réduit un nom libre à ce qu'un nom de fichier de plan accepte.

Mêmes caractères que les noms de niveau (hmi::isValidLevelName) : lettres, chiffres, tiret, tiret bas et espace, ce dernier ramené au tiret. Tout le reste est retiré plutôt que remplacé — un nom qui perd ses accents reste lisible, un nom truffé de tirets de substitution ne l'est plus.

Parameters

name	Nom libre.

Returns

Le nom assaini, éventuellement vide.

saveSessionLog()

bool hmi::saveSessionLog ( const std::vector< core::MemoryLogSink::Entry > & entries, const std::filesystem::path & path )

nodiscard

Enregistre les messages de log de la session dans un fichier.

Parameters

entries	Messages accumulés.
path	Chemin du fichier de destination (les dossiers parents sont créés).

Returns

true si le fichier a été écrit ; false (récupérable) en cas d'échec d'écriture.

sceneTextures()

SceneTextures hmi::sceneTextures ( const TextureAtlas & atlas, TextureCache & cache, const SkinCatalog * skins = nullptr, const std::string & skinSet = {}, const std::vector< core::TileTextureOverride > & textureOverrides = {}, const std::unordered_map< std::string, core::Animation > & tileAnimations = {} )

nodiscard

Textures liables par la composition d'une scène : atlas, damier de repli et skins.

Point d'assemblage unique, partagé par le jeu et l'éditeur (LOT-41) : le damier est résolu à la demande auprès du cache, donc créé seulement si un rendu en mode Texture a lieu. Les skins du jeu courant sont chargés par le même cache, qui ne relit le disque qu'au premier accès et mémorise aussi les échecs — appeler cette fonction à chaque image reste donc bon marché.

Parameters

atlas	Atlas du jeu.
cache	Cache de textures, propriétaire du damier partagé et des skins.
skins	Catalogue des jeux de skins, ou nullptr si aucun n'est chargé (LOT-42).
skinSet	Nom du jeu de skins courant ; vide pour le jeu par défaut du catalogue.
textureOverrides	Surcharges de texture par instance du niveau courant (EX-EDIT-043, LOT-45) ; chaque asset distinct est chargé une fois (hmi::SceneTextures:: objects), un asset déjà chargé ou introuvable étant silencieusement ignoré (la résolution retombe sur le damier, avertissement déjà journalisé par le cache).
tileAnimations	Horloge d'animation partagée par asset de tuile (LOT-46 TACHE-05, GameSession::updateTileAnimations, avancée au pas fixe) : un skin en mode SkinMode::Single, sans silhouette, dont l'asset est animé et présent dans cette table échantillonne l'image courante plutôt que l'image entière.

Returns

Les textures et leurs dimensions, prêtes pour hmi::composeWorldSprites.

screenProjectionMatrix()

DirectX::XMFLOAT4X4 hmi::screenProjectionMatrix ( int viewportWidth, int viewportHeight )

nodiscardnoexcept

Construit la projection écran → clip du calque UI, indépendante de Camera2D.

Le HUD ne doit ni tourner ni changer de taille avec le zoom de la caméra du monde (EX-ARCH-022) : cette projection ne dépend que des dimensions du viewport, en pixels écran (origine haut-gauche, Y vers le bas — même convention que le reste du rendu).

Parameters

viewportWidth	Largeur de la surface de rendu, en pixels.
viewportHeight	Hauteur de la surface de rendu, en pixels.

Returns

La matrice de projection, à passer à hmi::submitComposedScene pour la passe UI.

screenShakeOffset()

core::Vector2 hmi::screenShakeOffset ( const ScreenShakeState & state )

nodiscardnoexcept

Décalage courant d'une secousse d'écran, en pixels entiers (EX-ARCH-022).

Décroît linéairement de amplitudePixels à zéro sur duration, sur l'axe vertical uniquement – une discrétion volontaire (cf. epic.md) plutôt qu'une oscillation qui ajouterait un axe de plus à lire. Nul une fois la secousse terminée.

Parameters

state

Secousse dont on lit le décalage courant.

Returns

Le décalage à appliquer à la projection de rendu uniquement (jamais à _center, ni à la logique de cadrage par salle, ni à une position simulée).

screenToImagePixel()

std::optional< std::pair< int, int > > hmi::screenToImagePixel ( const PixelCanvasView & view, int imageWidth, int imageHeight, double screenX, double screenY )

nodiscardnoexcept

Pixel image sous une position écran donnée.

Parameters

view	Vue courante (zoom, décalage).
imageWidth	Largeur de l'image, en pixels.
imageHeight	Hauteur de l'image, en pixels.
screenX	Position écran, en pixels logiques (ex. QMouseEvent::position().x()).
screenY	Position écran, en pixels logiques.

Returns

La position (colonne, ligne), ou std::nullopt si elle tombe hors de l'image — jamais un indice tronqué au bord.

serializeSessionLog()

std::string hmi::serializeSessionLog ( const std::vector< core::MemoryLogSink::Entry > & entries )

nodiscard

Assemble les messages de log en un texte (une ligne par message).

Parameters

entries

Messages accumulés (chacun déjà formaté par le journaliseur).

Returns

Le texte complet, terminé par un saut de ligne (vide si aucun message).

setEditorThemeSetting()

void hmi::setEditorThemeSetting

(

EditorThemeSetting

setting

)

Persiste setting (QSettings), relu au démarrage suivant.

setPixel()

PixelRegion hmi::setPixel	(	DecodedImage &	image,
		int	x,
		int	y,
		std::uint32_t	color )

Pose un pixel d'une couleur donnée.

Parameters

image	Image modifiée en place.
x	Colonne (0-based).
y	Ligne (0-based).
color	Couleur R8G8B8A8_UNORM posée.

Returns

La région modifiée (le seul pixel (x, y)), vide si (x, y) est hors bornes.

skinModeFromName()

std::optional< SkinMode > hmi::skinModeFromName ( std::string_view name )

nodiscardnoexcept

Mode de skin correspondant à un nom lu dans un fichier.

Parameters

name

Nom lu.

Returns

Le mode correspondant, ou std::nullopt si name n'en désigne aucun — un mode inconnu est une donnée invalide à signaler, jamais un mode deviné.

skinModeName()

const char * hmi::skinModeName ( SkinMode mode )

nodiscardnoexcept

Nom persisté d'un mode de skin (valeur écrite dans skins.json).

Parameters

mode	Mode à nommer.

Returns

"single" ou "bitmask16" (chaîne statique, jamais nulle).

solidNeighborMask()

std::uint8_t hmi::solidNeighborMask ( const core::TileMap & tiles, int column, int row )

nodiscardnoexcept

Calcule le masque de voisinage solide d'une case de la grille.

L'extérieur de la grille compte comme solide. Convention explicite et non implicite : un mur de bordure afficherait sinon un contour sur sa face invisible, hors du niveau, ce qui donne l'impression que le décor s'arrête en plein vide. Le revers — un niveau ouvert sur l'extérieur ne montre pas de bord franc à sa limite — est sans conséquence, la caméra ne dépassant pas les bornes du niveau.

Le voisinage est celui de la solidité, pas du type : Solid et les trois tailles de Block se raccordent entre eux (core::isSolid). Se raccorder au seul type identique laisserait une couture visible partout où un bloc jouxte un mur, alors que les deux forment visuellement la même matière. Les pentes et arrondis ne sont jamais solides : ils ne participent donc pas au voisinage et restent en mode single, avec leur masque de silhouette.

La grille passée doit être celle du niveau, jamais la grille de collision d'un core::MechanismController : une porte qui s'ouvre ne doit pas changer l'habillage des murs qui l'entourent.

Fonction pure, testable sans GPU (EX-NFR-010).

Parameters

tiles	Grille du niveau.
column	Colonne de la case examinée.
row	Ligne de la case examinée.

Returns

Le masque des quatre voisins solides (combinaison de hmi::NeighborBits, 0 à 15).

sortsByDepth()

bool hmi::sortsByDepth ( RenderLayer layer )

nodiscardconstexprnoexcept

Le calque appartient-il à la bande de profondeur ?

Dans une vue de dessus, « devant » et « derrière » ne se décident plus par un rang de calque fixe mais par la position : le personnage passe devant ce qui est au-dessus de lui à l'écran, derrière ce qui est en dessous. Les primitives d'une bande de profondeur s'ordonnent donc entre elles par leur sortOrder — le Y de leur pied (hmi::depthSortOrder) — avant tout regroupement de texture.

C'est le prix à payer, et il est assumé : regrouper par texture d'abord ferait passer tout le décor devant le personnage, ou tout derrière, selon l'ordre d'apparition des textures. Un personnage et un arbre n'ayant jamais la même texture, il n'existe aucun ordre de calque qui rende les deux cas justes — seule la profondeur le peut, au prix de passes de dessin supplémentaires (EX-REN-018).

soundForEvent()

std::optional< std::string > hmi::soundForEvent ( GameEvent event )

nodiscard

Associe un hmi::GameEvent à un identifiant de hmi::SoundCatalog.

Fonction pure, exhaustive (switch sans default : un événement ajouté sans entrée casse la compilation). Distincte de la détection (HMI/Game/GameEvents.h) : ce qui est arrivé et ce que ça produit sont deux questions séparées, pour que LOT-53 puisse brancher des particules sur la même détection sans la modifier.

Parameters

event

Événement survenu.

Returns

L'identifiant à passer à hmi::SoundCatalog::resolve, ou std::nullopt si cet événement ne produit intentionnellement aucun son — un silence documenté, pas un oubli (ex. WallContactEnter, BlockPushed : aucun bruitage dédié dans ce lot).

splitPurse()

void hmi::splitPurse	(	int	copper,
		int &	gold,
		int &	silver,
		int &	rest )

Répartit une somme en pièces de cuivre entre or, argent et cuivre.

Le modèle ne connaît qu'une unité — le cuivre — parce qu'une seule unité interne supprime les conversions dispersées (LOT-32). La feuille, elle, a trois médaillons de monnaie gravés : la répartition est donc une règle d'affichage, et elle vit ici plutôt que dans le modèle.

Parameters

copper	Somme totale, en pièces de cuivre.
gold	Reçoit le nombre de pièces d'or.
silver	Reçoit le nombre de pièces d'argent.
rest	Reçoit ce qui demeure, en pièces de cuivre.

spriteQuadBounds()

core::Rect hmi::spriteQuadBounds ( const SpriteQuad & quad )

nodiscardnoexcept

Boîte englobante d'un rectangle texturé, en unités monde.

Parameters

quad	Primitive à borner.

Returns

Son rectangle englobant.

submitComposedScene()

void hmi::submitComposedScene	(	SpriteBatch &	batch,
		const DirectX::XMFLOAT4X4 &	projection,
		const ComposedScene &	scene )

Soumet une scène composée au pipeline de dessin, une passe par groupe de texture.

Seul endroit du rendu qui reconvertit une hmi::TextureHandle en ressource Direct3D : c'est la frontière entre la composition (pure, testable sans GPU) et la soumission. Émet un SpriteBatch::begin/end par groupe contigu de même texture, dans l'ordre de la scène — donc dans l'ordre des calques, que ComposedScene::sort() a rendu prioritaire (EX-REN-043). Le contrat public de hmi::SpriteBatch est strictement inchangé.

Parameters

batch	Pipeline de quads texturés (non possédé).
projection	Matrice de projection monde → clip (fournie par la caméra).
scene	Scène déjà triée (ComposedScene::sort()).

substituteStyleSheetTemplate()

StyleSheetSubstitutionResult hmi::substituteStyleSheetTemplate ( const std::string & templateText, const std::unordered_map< std::string, std::string > & values )

nodiscard

Remplace chaque marqueur dollar-accolade de templateText par sa valeur dans values.

Fonction pure : mêmes entrées, même sortie, aucun effet de bord, aucune dépendance à un fichier ou une instance d'application.

Parameters

templateText	Texte du modèle, contenant zéro ou plusieurs marqueurs.
values	Table nom de marqueur -> valeur de substitution.

Returns

ok=true avec le texte substitué ; ok=false avec un message nommant le premier marqueur absent de values — jamais un résultat partiellement substitué.

systemPrefersDarkTheme()

bool hmi::systemPrefersDarkTheme ( )

nodiscard

Returns

true si le système d'exploitation est actuellement réglé sur un thème sombre (QStyleHints::colorScheme).

taxonomyLabelKey()

std::string hmi::taxonomyLabelKey ( const std::string & label )

nodiscard

Clé de traduction d'un libellé de la taxonomie.

hmi::tileTaxonomy reste une logique pure, sans dépendance i18n : elle porte des libellés français, qui servent aussi de clés de correspondance ici. Cette table est le point unique de la conversion, partagé par tous les panneaux qui affichent des types de tuiles — la palette (LOT-35) et le panneau « Textures » (LOT-42). Deux copies divergeraient au premier libellé ajouté, et un panneau afficherait alors du français au milieu d'une interface anglaise.

Parameters

label

Libellé issu de la taxonomie.

Returns

La clé de traduction, ou une chaîne vide si le libellé n'en a pas.

TEST() [1/6]

hmi::TEST	(	MechanismTransitionsTest	,
		AucunChangementNeReinitialisePasLimageEnCours	)

À état inchangé, un appel supplémentaire ne remet pas l'image courante à zéro : c'est l'invariant qui rend le calcul appelable à chaque frame de rendu sans figer l'animation.

Cas de test : À état inchangé, un appel supplémentaire ne réinitialise pas l'image en cours.
Categorie : Unitaire · Transitions de mécanismes
Criticite : Critique
Etapes :
1. Mettre en place le contexte du test (arrangement).
2. Executer le scenario et verifier les assertions.

TEST() [2/6]

hmi::TEST	(	MechanismTransitionsTest	,
		ChangementDetatDeclencheLaTransitionUneSeuleFois	)

Un changement d'état déclenche la transition une seule fois : les pas suivants la font progresser jusqu'à l'état cible au lieu de la relancer depuis sa première image.

Un redéclenchement par pas figerait l'ouverture sur son premier quart, indéfiniment. Cas de test : Un changement d'état déclenche la transition une seule fois, puis la laisse aboutir.
Categorie : Unitaire · Transitions de mécanismes
Criticite : Critique
Etapes :
1. Mettre en place le contexte du test (arrangement).
2. Executer le scenario et verifier les assertions.

TEST() [3/6]

hmi::TEST	(	MechanismTransitionsTest	,
		ClipDEtatAbsentReplieEtJournaliseUneSeuleFois	)

Un clip d'état manquant, lui, se replie et se journalise — mais une seule fois par couple (asset, clip manquant), pas par instance : un niveau posant cinquante portes du même asset incomplet produirait sinon cinquante fois le même message.

Cas de test : Un clip d'état absent se replie et n'est journalisé qu'une fois par asset.
Categorie : Unitaire · Transitions de mécanismes
Criticite : Majeur
Etapes :
1. Mettre en place le contexte du test (arrangement).
2. Executer le scenario et verifier les assertions.

TEST() [4/6]

hmi::TEST	(	MechanismTransitionsTest	,
		ClipDeTransitionAbsentBasculeDirectementSansAvertissement	)

Un asset qui ne fournit que les deux états, sans clips de transition, bascule directement et en silence : n'animer que les états est un choix d'artiste légitime, pas une erreur à signaler.

Cas de test : Un clip de transition absent fait basculer directement, sans avertissement.
Categorie : Unitaire · Transitions de mécanismes
Criticite : Majeur
Etapes :
1. Mettre en place le contexte du test (arrangement).
2. Executer le scenario et verifier les assertions.

TEST() [5/6]

hmi::TEST	(	MechanismTransitionsTest	,
		PremierCalculRejointEtatCibleSansTransition	)

Le tout premier calcul rejoint directement l'état cible, sans jouer de transition : une porte déjà ouverte au chargement du niveau doit apparaître ouverte, pas s'ouvrir sous les yeux du joueur comme si un interrupteur venait d'être actionné.

Cas de test : Le premier calcul rejoint l'état cible sans jouer de transition.
Categorie : Unitaire · Transitions de mécanismes
Criticite : Majeur
Etapes :
1. Mettre en place le contexte du test (arrangement).
2. Executer le scenario et verifier les assertions.

TEST() [6/6]

hmi::TEST	(	MechanismTransitionsTest	,
		SeuleLaPorteTransitionneLesAutresBasculentDirectement	)

Seule la porte a des clips de transition ; un interrupteur bascule directement entre ses deux états, silencieusement.

Chercher une transition pour tous les mécanismes produirait des avertissements pour des assets pourtant complets. Cas de test : Un interrupteur bascule directement entre ses deux états, sans avertissement.
Categorie : Unitaire · Transitions de mécanismes
Criticite : Majeur
Etapes :
1. Mettre en place le contexte du test (arrangement).
2. Executer le scenario et verifier les assertions.

textureOverrideAt()

std::optional< std::string > hmi::textureOverrideAt ( const std::vector< core::TileTextureOverride > & overrides, core::GridPosition position )

nodiscard

Cherche la surcharge de texture assignée à une case précise (EX-EDIT-043, LOT-45).

Recherche linéaire : le nombre de surcharges d'un niveau reste modeste (donnée purement visuelle, posée à la main), et cette fonction n'est appelée qu'à la construction de la scène (une fois par tuile), jamais à chaque image — même principe que solidNeighborMask.

Parameters

overrides	Surcharges du niveau (core::Level::textureOverrides/core::LevelDraft::textureOverrides).
position	Position de la case cherchée.

Returns

Le nom de l'asset assigné à cette case, ou std::nullopt si elle n'en a pas.

themeIcon()

QIcon hmi::themeIcon ( IconId id, int pixelSize, const DesignTokens & tokens )

nodiscard

Peint une icône à la taille demandée, recolorée depuis les jetons.

Parameters

id	Icône à peindre (hmi::iconGeometry).
pixelSize	Côté du carré, en pixels réels (déjà multiplié par le facteur d'échelle d'affichage par l'appelant, LOT-56 TACHE-05) : le tracé reste net à toute échelle.
tokens	Jetons de la portée courante (châssis d'édition) : résout les rôles de couleur de la géométrie, de sorte que l'icône suive le thème actif (TACHE-06).

Returns

Une QIcon couvrant l'unique taille demandée.

thumbnailPixelSize()

int hmi::thumbnailPixelSize ( int logicalSize, double scaleFactor )

nodiscardnoexcept

Taille en pixels réels pour une taille logique et un facteur d'échelle d'affichage donnés.

Ne produit jamais zéro, même pour un facteur non entier (125 %, 150 %) appliqué à la plus petite taille d'icône des jetons : un défaut d'arrondi produirait sinon une vignette invisible plutôt que simplement floue.

Parameters

logicalSize	Taille demandée, en pixels logiques (jetons de design, SizeTokens).
scaleFactor	Facteur d'échelle du support d'affichage (devicePixelRatio).

Returns

round(logicalSize * scaleFactor), borné à 1 au minimum.

tileTaxonomy()

std::vector< TileCategory > hmi::tileTaxonomy ( )

nodiscard

Taxonomie complète des types de tuiles peignables, en catégories/sous-groupes.

Logique pure (aucune dépendance Qt/GPU), testable (EX-NFR-010) : sert de source unique à la palette QTreeView de l'éditeur (EX-EDIT-018, EX-IHM-010). Chaque core::TileType y figure exactement une fois, dans un ordre déterministe (invariant vérifié par les tests). Reprend l'organisation de la palette historique (LOT-27).

toCssColor()

std::string hmi::toCssColor ( DesignColor color )

nodiscard

Conversion pure : couleur -> chaîne CSS hexadécimale "#rrggbb" (minuscules, sans alpha — les feuilles de style Qt n'acceptent l'alpha que via rgba()).

toCssRgba()

std::string hmi::toCssRgba ( DesignColor color )

nodiscard

Conversion pure : couleur -> chaîne CSS "rgba(r, g, b, a)", composantes entières 0-255 (les feuilles de style Qt expriment l'alpha sur la même échelle que les autres composantes).

toPlayerInput()

core::PlayerInput hmi::toPlayerInput ( const InputState & input, const GameKeyBindings & gameKeyBindings, const GamepadBindings & gamepadBindings )

nodiscard

Traduit l'état d'entrée en core::PlayerInput, dissocié des touches/boutons physiques (EX-CTRL-010, EX-CTRL-012).

Le reste du moteur ne connaît que l'intention (moveX), pas les touches ni les boutons. Chaque action est déclenchée par deux sources indépendantes, chacune remappable séparément : la touche clavier liée dans gameKeyBindings (Options → Touches de jeu) ou le bouton manette lié dans gamepadBindings (Options → Touches de la manette) — l'une des deux suffit, aucune des deux n'est prioritaire sur l'autre.

Gauche et droite simultanées se neutralisent (moveX == 0). Fonction pure, testable avec un InputState injecté (EX-NFR-010) ; appelée une fois par frame en amont de la logique (EX-CTRL-020, EX-CTRL-021).

Parameters

input	État clavier/manette échantillonné de la frame.
gameKeyBindings	Association action de jeu -> touche clavier courante.
gamepadBindings	Association action de jeu -> bouton manette courant.

Returns

L'intention de déplacement correspondante.

triggerScreenShake()

void hmi::triggerScreenShake ( ScreenShakeState & state, float amplitudePixels, float duration )

noexcept

Déclenche (ou relance) une secousse d'écran.

Parameters

state	État à réarmer.
amplitudePixels	Amplitude au déclenchement, en pixels écran (constante nommée côté appelant, ex. LANDING_SHAKE_AMPLITUDE_PIXELS).
duration	Durée totale, en secondes (ex. SCREEN_SHAKE_DURATION).

trimLevelName()

std::string hmi::trimLevelName ( const std::string & name )

nodiscard

Retire les espaces de bord de name (le nom réellement utilisé une fois confirmé).

Parameters

name	Nom saisi.

Returns

name sans ses espaces de début/fin.

unionPixelRegion()

PixelRegion hmi::unionPixelRegion ( const PixelRegion & a, const PixelRegion & b )

nodiscardconstexprnoexcept

Union de deux régions (la plus petite région couvrant les deux).

Une région vide n'affecte pas l'union : sert à accumuler la région touchée par un geste complet (hmi::PixelCanvas, TACHE-03) à partir des régions renvoyées par chacune de ses sous-opérations (ex. plusieurs drawLine successifs pendant un glisser).

uniquePlaneFileName()

std::string hmi::uniquePlaneFileName ( const std::string & levelName, const std::vector< std::string > & existing )

nodiscard

Compose un nom de fichier de plan unique pour un niveau donné.

Le nom dérive de celui du niveau, suffixé d'un numéro : foret.png, foret-2.png, … Le suffixe est incrémenté jusqu'à sortir de existing — jamais un identifiant aléatoire, pour qu'un dossier de plans reste lisible à l'œil et qu'un plan se retrouve sans ouvrir l'éditeur.

Parameters

levelName	Nom du niveau (sans extension), tel que saisi.
existing	Noms déjà pris dans le dossier des plans, extension comprise.

Returns

Le nom de fichier à créer, ou une chaîne vide si levelName ne donne aucun nom utilisable (vide, ou fait uniquement de caractères refusés).

validAssetSizes()

std::vector< std::pair< int, int > > hmi::validAssetSizes ( AssetFamily family )

nodiscard

Tailles proposées à la création d'un asset de la famille donnée.

Fonction pure (EX-NFR-010) : dérivée de hmi::assetDimensionContract, jamais une seconde description des mêmes règles — une création à une taille non conforme ne doit pas être possible du tout, plutôt que refusée après coup au chargement (hmi::validateAsset).

Chaque taille renvoyée passe hmi::validateAsset pour sa famille. Une famille à dimensions libres (fond, décor, police) renvoie une liste vide : il n'existe alors aucune progression de tailles pertinente, l'appelant doit permettre une saisie libre (strictement positive).

Parameters

family

Famille de l'asset à créer.

Returns

Une courte progression de tailles conformes (croissante), ou vide si les dimensions sont libres.

validateAsset()

AssetValidation hmi::validateAsset ( AssetFamily family, const std::string & fileName, int width, int height )

nodiscard

Valide les dimensions d'un asset décodé contre le contrat de sa famille (EX-REN-007).

Fonction pure : elle ne lit aucun fichier et ne touche pas au GPU — c'est ce qui la rend testable en isolation (EX-NFR-010), et ce qui impose de l'appeler entre le décodage et l'upload. Sans elle, un PNG aux mauvaises dimensions ne produit aucune erreur mais des artefacts de filtrage silencieux (échantillonnage nearest, sans mipmap, EX-ARCH-022).

Parameters

family	Famille de l'asset, qui fixe les dimensions attendues.
fileName	Nom logique du fichier, repris tel quel dans le message d'erreur.
width	Largeur décodée, en pixels.
height	Hauteur décodée, en pixels.

Returns

Le verdict, accompagné d'un message nommant le fichier, le trouvé et l'attendu si l'asset est refusé.

validateFontMetricsAgainstTexture()

AssetValidation hmi::validateFontMetricsAgainstTexture ( const FontMetrics & metrics, const std::string & fileName, int textureWidth, int textureHeight )

nodiscard

Valide la cohérence entre des métriques et les dimensions décodées du PNG associé.

Séparée de la lecture JSON : les dimensions réelles ne sont connues qu'après décodage du PNG, en aval (même frontière que hmi::AnimationCatalog::validateAgainstTexture).

Parameters

metrics	Métriques déjà lues.
fileName	Nom logique de l'asset, repris dans le message d'erreur.
textureWidth	Largeur décodée du PNG, en pixels.
textureHeight	Hauteur décodée du PNG, en pixels.

Returns

Le verdict, avec un message exploitable si non conforme (une région de glyphe hors des bornes de la texture, ou une hauteur de ligne non positive).

viewportClearColor()

DesignColor hmi::viewportClearColor ( bool editorMode, const DesignTokens & activeEditorTokens )

nodiscardnoexcept

Couleur d'effacement du viewport (GameViewport), dérivée des jetons plutôt que d'une valeur littérale locale : fond de la portée variable en édition (suivant le thème actif de l'éditeur, LOT-56 TACHE-06), fond de la portée invariante en jeu et en essai — la seule surface qui appartient tour à tour aux deux portées.

Parameters

editorMode	true en édition, false en jeu/essai.
activeEditorTokens	Jetons du châssis d'édition actuellement effectifs (thème clair ou sombre) ; ignorés si editorMode est faux.

workspaceBit()

EditorWorkspaceMask hmi::workspaceBit ( EditorWorkspace workspace )

nodiscardconstexprnoexcept

Returns

Le masque ne contenant que workspace.

workspaceForPixelTool()

EditorWorkspace hmi::workspaceForPixelTool ( PixelTool tool )

nodiscardnoexcept

Returns

L'espace auquel appartient tool — toujours PixelArt.

workspaceForTool()

EditorWorkspace hmi::workspaceForTool ( EditorTool tool )

nodiscardnoexcept

Returns

L'espace auquel appartient tool — toujours Level, les deux groupes d'outils étant disjoints par construction. Existe pour que MainWindow bascule d'espace en suivant une table plutôt qu'une condition écrite en dur.

workspaceMaskContains()

bool hmi::workspaceMaskContains ( EditorWorkspaceMask mask, EditorWorkspace workspace )

nodiscardconstexprnoexcept

Returns

true si mask contient workspace.

workspacesForPanel()

EditorWorkspaceMask hmi::workspacesForPanel ( PanelId panel )

nodiscardnoexcept

Espaces dans lesquels panel est affiché.

Un masque, pas une valeur unique (LOT-69 TACHE-08) : un panneau peut servir à plusieurs espaces à la fois — le canevas, l'historique et la palette appartiennent aussi bien à l'atelier pixel art qu'au mode création. Les dupliquer par espace coûterait deux canevas, deux historiques et deux états à tenir synchronisés.

GARDE DE COMPLÉTUDE : le masque d'un panneau n'est jamais vide. Un panneau sans espace resterait affiché partout, ce qui viderait la séparation de son sens — et ne se verrait qu'à l'écran, jamais en relecture.

Parameters

panel

Panneau interrogé.

Returns

Le masque des espaces qui l'affichent ; jamais vide.

writeRegion()

void hmi::writeRegion	(	DecodedImage &	image,
		const PixelRegion &	region,
		const std::vector< std::uint32_t > &	data )

Écrit des pixels dans une région — inverse de readRegion, utilisé par hmi::PixelHistory pour restaurer un instantané annulé/rétabli.

Parameters

image	Image modifiée en place.
region	Région ciblée (doit être contenue dans les bornes de image).
data	Pixels à écrire, taille attendue region.width() * region.height().

Variable Documentation

AUTOTILE_CONFIGURATION_COUNT

int hmi::AUTOTILE_CONFIGURATION_COUNT = AUTOTILE_SHEET_SIDE * AUTOTILE_SHEET_SIDE

inlineconstexpr

Nombre de configurations de voisinage distinctes.

AUTOTILE_SHEET_SIDE

int hmi::AUTOTILE_SHEET_SIDE = 4

inlineconstexpr

Nombre de cases par côté de la planche de raccords (4×4 = seize configurations).

BACKDROP_VEIL_STEPS

int hmi::BACKDROP_VEIL_STEPS = 6

inlineconstexpr

Nombre de bandes du voile.

Un dégradé serait plus doux, mais la charte du LOT-66 pose ses lavis en passes plates, à la manière des feuilles de Tanares : des paliers francs. La raison invoquée jusque-là — le pixel art ne s'accommode pas d'une transition continue — est tombée avec l'identité pixel art ; le choix, lui, reste celui de la charte.

BACKDROP_VEIL_WIDTH_RATIO

float hmi::BACKDROP_VEIL_WIDTH_RATIO = 0.55f

inlineconstexpr

Part de la largeur couverte par le voile de lisibilité, sous le titre et les entrées de menu.

BACKGROUNDS_SUBDIRECTORY

const std::string hmi::BACKGROUNDS_SUBDIRECTORY = "Backgrounds/"

inline

Sous-dossier des fonds de niveau, relatif au dossier d'assets (LOT-44).

DEATH_SHAKE_AMPLITUDE_PIXELS

float hmi::DEATH_SHAKE_AMPLITUDE_PIXELS = 3.0f

inlineconstexpr

Amplitude de la secousse à la mort du personnage : légèrement plus marquée que l'atterrissage.

DEFAULT_RENDER_LAYER

RenderLayer hmi::DEFAULT_RENDER_LAYER = RenderLayer::Tile

inlineconstexpr

Calque appliqué à une entité dépourvue de hmi::RenderLayerTag.

DEFAULT_RENDER_MODE

RenderMode hmi::DEFAULT_RENDER_MODE = RenderMode::Texture

inlineconstexpr

Mode appliqué au premier lancement et à défaut de préférence exploitable.

Texture dans toutes les configurations de build (EX-REN-046) : deux binaires du même code ne doivent jamais afficher un rendu différent par défaut, sous peine de rendre ambiguë toute capture d'écran ou vérification visuelle.

DEPTH_SUBDIVISIONS_PER_UNIT

float hmi::DEPTH_SUBDIVISIONS_PER_UNIT = 16.0f

inlineconstexpr

Sous-divisions de profondeur par unité monde, pour la quantification du tri par Y.

Le rendu est du pixel art à 16 px/unité (EX-ARCH-021) : deux sprites dont les pieds sont distants de moins d'un pixel ne peuvent pas se départager à l'écran, et les départager dans le tri ne ferait que les faire scintiller au gré des arrondis flottants. Quantifier au pixel est donc à la fois suffisant et stabilisateur.

DIAGNOSTICS_FPS_WINDOW_SECONDS

float hmi::DIAGNOSTICS_FPS_WINDOW_SECONDS = 0.5f

inlineconstexpr

Fenêtre de la moyenne glissante de cadence, en secondes : assez courte pour rester réactive à une vraie dégradation, assez longue pour lisser le bruit d'une image à l'autre.

Une cadence instantanée (1 / dt sur une seule image) saute dans tous les sens et n'informerait sur rien (cf. epic.md, points d'attention).

EDITOR_ACTION_CATALOG_COUNT

int hmi::EDITOR_ACTION_CATALOG_COUNT = 30

constexpr

Nombre total d'actions du catalogue (six outils de niveau, cinq outils de canevas pixel art, onze commandes principales, quatre commandes de fichier de l'atelier, quatre commandes de région de l'atelier).

EDITOR_ACTION_COUNT

int hmi::EDITOR_ACTION_COUNT = 10

constexpr

Nombre d'actions d'éditeur remappables (EditorAction).

EDITOR_TOOL_COUNT

std::size_t hmi::EDITOR_TOOL_COUNT = 6

inlineconstexpr

Nombre d'outils d'édition, déclaré au plus près de l'énumération qu'il compte.

Sert de garde de complétude : le catalogue d'actions doit exposer exactement autant d'outils de niveau (hmi::editorActionCatalog), ce qu'un test vérifie — sans quoi un outil ajouté à l'énumération peut apparaître dans la barre d'outils sans jamais être relié au viewport.

EDITOR_WORKSPACE_COUNT

std::size_t hmi::EDITOR_WORKSPACE_COUNT = 3

inlineconstexpr

Nombre d'espaces, déclaré au plus près de l'énumération qu'il compte.

FOLLOW_ANTICIPATION_DISTANCE_UNITS

float hmi::FOLLOW_ANTICIPATION_DISTANCE_UNITS = 2.5f

inlineconstexpr

Distance d'anticipation dans le sens du déplacement, en unités monde.

FOLLOW_ANTICIPATION_TIME_CONSTANT_SECONDS

float hmi::FOLLOW_ANTICIPATION_TIME_CONSTANT_SECONDS = 0.25f

inlineconstexpr

Temps de réponse de l'inversion de l'anticipation au changement de sens, en secondes – plus lent que le lissage principal, pour que l'inversion se voie comme un mouvement, pas un saut.

FOLLOW_DEAD_ZONE_HALF_HEIGHT_UNITS

float hmi::FOLLOW_DEAD_ZONE_HALF_HEIGHT_UNITS = 1.5f

inlineconstexpr

FOLLOW_DEAD_ZONE_HALF_WIDTH_UNITS

float hmi::FOLLOW_DEAD_ZONE_HALF_WIDTH_UNITS = 1.5f

inlineconstexpr

Demi-taille de la zone morte, en unités monde : le personnage se déplace librement dans ce carré centré sur le point suivi sans faire bouger la caméra – ce qui supprime le tremblement permanent d'une caméra qui collerait exactement au personnage.

Deux constantes scalaires plutôt qu'un core::Vector2 : son constructeur n'est pas constexpr.

Carrée depuis le LOT-07 (1,5 sur les deux axes, contre 1,5 × 1,0 auparavant) : un jeu de plateforme court latéralement et saute brièvement, ce qui justifiait une zone plus large que haute ; en vue de dessus, marcher vers le haut est un déplacement comme un autre (EX-EXP-001), et une zone morte plus courte verticalement ferait décrocher la caméra plus tôt dans cette direction — un biais visible sans qu'aucune règle ne le justifie.

FOLLOW_SMOOTHING_TIME_CONSTANT_SECONDS

float hmi::FOLLOW_SMOOTHING_TIME_CONSTANT_SECONDS = 0.15f

inlineconstexpr

Temps de réponse (lissage exponentiel) du centre retenu vers sa cible, en secondes.

FONT_METRICS_FORMAT_VERSION

int hmi::FONT_METRICS_FORMAT_VERSION = 1

inlineconstexpr

Version du format de métriques écrite dans le fichier, et plus élevée qui soit lue (hmi::loadFontMetricsFromString).

FONTS_SUBDIRECTORY

const std::string hmi::FONTS_SUBDIRECTORY = "Fonts/"

inline

Sous-dossier des assets de police, relatif au dossier d'assets (LOT-52).

GAME_ACTION_COUNT

int hmi::GAME_ACTION_COUNT = 7

constexpr

Nombre d'actions de jeu remappables (GameAction).

GAME_EVENT_COUNT

int hmi::GAME_EVENT_COUNT = static_cast<int>(GameEvent::PauseOpened) + 1

inlineconstexpr

Nombre de valeurs de GameEvent — pour les tests d'exhaustivité (parcours de l'énumération).

GAMEPAD_BUTTON_COUNT

int hmi::GAMEPAD_BUTTON_COUNT = 10

constexpr

Nombre de boutons manette remappables (GamepadButton).

GAMEPAD_DISCONNECTED_PROBE_PERIOD

std::chrono::milliseconds hmi::GAMEPAD_DISCONNECTED_PROBE_PERIOD {2000}

inlineconstexpr

Délai minimal entre deux sondages XInput d'un slot resté déconnecté (anti-saccade).

IDENTITY_BASE_HEIGHT

int hmi::IDENTITY_BASE_HEIGHT = 360

inlineconstexpr

Hauteur, en pixels logiques, de la maquette à l'échelle 1.

Les écrans sont dessinés pour cette hauteur ; tout le reste en est un multiple entier.

IDENTITY_MAX_SCALE

int hmi::IDENTITY_MAX_SCALE = 3

inlineconstexpr

Plus grand facteur admis.

Au-delà, les écrans cessent de gagner en lisibilité et commencent à perdre en contenu visible : trois entrées de menu par écran ne rendent service à personne.

KEY_BINDING_ICON_COUNT

int hmi::KEY_BINDING_ICON_COUNT = 9

constexpr

Nombre d'actions d'éditeur remappables ayant une commande effective (EDITOR_ACTION_COUNT moins TextureAssignTool).

LANDING_SHAKE_AMPLITUDE_PIXELS

float hmi::LANDING_SHAKE_AMPLITUDE_PIXELS = 2.0f

inlineconstexpr

Amplitude conservatrice de la secousse d'écran à un atterrissage lourd (LOT-53 TACHE-03) : discrète, un jeu de plateforme précis devient injouable si l'écran bouge trop.

MECHANISM_ANIMATION_TYPES

core::TileType hmi::MECHANISM_ANIMATION_TYPES[]

inlineconstexpr

Initial value:

                                                          = {
    core::TileType::Door, core::TileType::Switch,     core::TileType::PressurePlate,
    core::TileType::Key,  core::TileType::LockedDoor,
}

Les familles de mécanismes à état dont l'apparence est pilotée par un clip (LOT-47), dans l'ordre où elles sont proposées par la section « Animations ».

MECHANISM_CLIP_DOOR_CLOSED

const char* hmi::MECHANISM_CLIP_DOOR_CLOSED = "closed"

inlineconstexpr

Noms de clip conventionnels, documentés dans Source/Elements/Assets/README.md — c'est le contrat qu'un auteur d'asset doit respecter pour que son animation soit reconnue.

MECHANISM_CLIP_DOOR_CLOSING

const char* hmi::MECHANISM_CLIP_DOOR_CLOSING = "closing"

inlineconstexpr

MECHANISM_CLIP_DOOR_OPEN

const char* hmi::MECHANISM_CLIP_DOOR_OPEN = "open"

inlineconstexpr

MECHANISM_CLIP_DOOR_OPENING

const char* hmi::MECHANISM_CLIP_DOOR_OPENING = "opening"

inlineconstexpr

MECHANISM_CLIP_KEY_COLLECTED

const char* hmi::MECHANISM_CLIP_KEY_COLLECTED = "collected"

inlineconstexpr

MECHANISM_CLIP_KEY_PRESENT

const char* hmi::MECHANISM_CLIP_KEY_PRESENT = "present"

inlineconstexpr

MECHANISM_CLIP_LOCKED_DOOR_CLOSED

const char* hmi::MECHANISM_CLIP_LOCKED_DOOR_CLOSED = "closed"

inlineconstexpr

MECHANISM_CLIP_LOCKED_DOOR_OPEN

const char* hmi::MECHANISM_CLIP_LOCKED_DOOR_OPEN = "open"

inlineconstexpr

MECHANISM_CLIP_PLATE_PRESSED

const char* hmi::MECHANISM_CLIP_PLATE_PRESSED = "pressed"

inlineconstexpr

MECHANISM_CLIP_PLATE_RELEASED

const char* hmi::MECHANISM_CLIP_PLATE_RELEASED = "released"

inlineconstexpr

MECHANISM_CLIP_SWITCH_ACTIVE

const char* hmi::MECHANISM_CLIP_SWITCH_ACTIVE = "active"

inlineconstexpr

MECHANISM_CLIP_SWITCH_INACTIVE

const char* hmi::MECHANISM_CLIP_SWITCH_INACTIVE = "inactive"

inlineconstexpr

MISSING_TEXTURE_CHECKER_SIZE

int hmi::MISSING_TEXTURE_CHECKER_SIZE = 4

inlineconstexpr

Côté, en pixels, d'un carreau du damier : quatre carreaux par côté, motif lisible même réduit.

MISSING_TEXTURE_SIZE

int hmi::MISSING_TEXTURE_SIZE = 16

inlineconstexpr

Côté, en pixels, du damier de repli généré par défaut (une case, EX-ARCH-021).

OBJECTS_SUBDIRECTORY

const std::string hmi::OBJECTS_SUBDIRECTORY = "Objects/"

inline

Sous-dossier des textures d'objets interactifs, relatif au dossier d'assets (LOT-45).

PANEL_COUNT

std::size_t hmi::PANEL_COUNT = 8

inlineconstexpr

Nombre de panneaux, declare au plus pres de l'enumeration qu'il compte.

Sert de garde de completude a la repartition par espace de travail (hmi::workspacesForPanel, LOT-68) : un panneau ajoute sans espace resterait affiche dans les deux, ce qu'un test interdit.

PANEL_FOCUS_CATALOG_COUNT

int hmi::PANEL_FOCUS_CATALOG_COUNT = 2

constexpr

Nombre d'entrées de la table (tous les outils n'ont pas de panneau dédié).

PARALLAX_FACTOR_NONE

float hmi::PARALLAX_FACTOR_NONE = 1.0f

inlineconstexpr

Facteur neutre : le contenu est solidaire du niveau et ne subit aucun décalage.

PARTICLE_QUAD_SIZE

float hmi::PARTICLE_QUAD_SIZE = 0.12f

inlineconstexpr

Côté du carré teinté d'une particule, en unités monde (LOT-53 TACHE-03 : « un simple carré teinté suffit pour un premier jet », pas d'asset dédié).

PIXEL_CANVAS_GRID_VISIBLE_MIN_ZOOM

int hmi::PIXEL_CANVAS_GRID_VISIBLE_MIN_ZOOM = 4

inlineconstexpr

Facteur de zoom à partir duquel la grille de pixels est dessinée : en-deçà, elle ne ferait que du bruit visuel sur des pixels trop petits pour la distinguer du contenu.

PIXEL_CANVAS_MAX_DENOMINATOR

int hmi::PIXEL_CANVAS_MAX_DENOMINATOR = 8

inlineconstexpr

Dénominateur de zoom maximal : au-delà, un pixel image occuperait moins d'un huitième de pixel écran, et le repère cesserait d'être lisible.

PIXEL_CANVAS_MAX_ZOOM

int hmi::PIXEL_CANVAS_MAX_ZOOM = 32

inlineconstexpr

PIXEL_CANVAS_MIN_ZOOM

int hmi::PIXEL_CANVAS_MIN_ZOOM = 1

inlineconstexpr

Zoom minimal (1 pixel image = 1 pixel écran) et maximal admis par les commandes de zoom du canevas — toujours entier, pour que les pixels restent carrés (EX-ARCH-022).

PIXEL_PANEL_FOCUS_CATALOG_COUNT

int hmi::PIXEL_PANEL_FOCUS_CATALOG_COUNT = 5

constexpr

Nombre d'entrées de la table des outils de canevas (les cinq outils du canevas mettent tous en avant le même panneau : on édite toujours en le voyant).

PLANE_FILE_EXTENSION

const std::string hmi::PLANE_FILE_EXTENSION = ".png"

inline

Extension des fichiers de plan. Un plan est une image, toujours écrite en PNG.

PLANE_TEXTURE_BYTES_PER_PIXEL

std::size_t hmi::PLANE_TEXTURE_BYTES_PER_PIXEL = 4

inlineconstexpr

Octets par texel d'une texture de plan : R8G8B8A8_UNORM, comme toute texture du projet.

PLANES_SUBDIRECTORY

const std::string hmi::PLANES_SUBDIRECTORY = "Plans/"

inline

Sous-dossier des images de plans, relatif au dossier des niveaux — un plan est une donnée de niveau, pas un asset réutilisable : il ne vit pas sous Assets/.

PLAYER_IDLE_FRAME_COUNT

int hmi::PLAYER_IDLE_FRAME_COUNT = 2

constexpr

Nombre d'images du clip Idle.

Seule source de vérité (LOT-18, migré côté HMI par LOT-46 puisque seul l'atlas procédural en a encore besoin pour son placement fixe).

PLAYER_JUMP_FRAME_COUNT

int hmi::PLAYER_JUMP_FRAME_COUNT = 1

constexpr

Nombre d'images du clip Jump (pose unique, jamais animée).

PLAYER_RUN_FRAME_COUNT

int hmi::PLAYER_RUN_FRAME_COUNT = 4

constexpr

Nombre d'images du clip Run.

PLAYER_SHEET_FILE_NAME

const std::string hmi::PLAYER_SHEET_FILE_NAME = "player.png"

inline

Nom logique de la spritesheet du personnage (LOT-48).

PLAYER_SUBDIRECTORY

const std::string hmi::PLAYER_SUBDIRECTORY = "Player/"

inline

Sous-dossier de la spritesheet du personnage, relatif au dossier d'assets (LOT-48).

RENDER_LAYER_COUNT

std::size_t hmi::RENDER_LAYER_COUNT

inlineconstexpr

Initial value:

                                            =
static_cast<std::size_t>(RenderLayer::EditorOverlay) + 1

Nombre de valeurs de hmi::RenderLayer — dimensionne un tableau indexé par la valeur plutôt que par une liste de champs écrite à la main (voir hmi::LayerVisibility).

RPG_SCREEN_COUNT

std::size_t hmi::RPG_SCREEN_COUNT = 9

inlineconstexpr

Nombre d'écrans du catalogue.

SCREEN_SHAKE_DURATION

float hmi::SCREEN_SHAKE_DURATION = 0.2f

inlineconstexpr

Durée de toute secousse d'écran, en secondes – brève par construction.

SHADOW_OFFSET_X

float hmi::SHADOW_OFFSET_X = 1.0f / 16.0f

inlineconstexpr

Décalage de l'ombre par rapport à sa tuile, en unités monde (1 pixel à 16 px/unité).

SHADOW_OFFSET_Y

float hmi::SHADOW_OFFSET_Y = 1.0f / 16.0f

inlineconstexpr

SHADOW_OPACITY

float hmi::SHADOW_OPACITY = 0.4f

inlineconstexpr

Opacité de l'ombre (constante, cf. décisions de cadrage du LOT-55 : pas de réglage designer).

SILHOUETTE_TILE_TYPE_COUNT

int hmi::SILHOUETTE_TILE_TYPE_COUNT = static_cast<int>(SILHOUETTE_TILE_TYPES.size())

inlineconstexpr

Nombre de types de tuile à silhouette (voir SILHOUETTE_TILE_TYPES).

SILHOUETTE_TILE_TYPES

std::array<core::TileType, 0> hmi::SILHOUETTE_TILE_TYPES {}

inlineconstexpr

Types de tuile dont la matière n'occupe pas toute la case, et qui doivent donc être détourées à l'affichage plutôt que dessinées en carré plein.

Note

Actuellement vide. Le LOT-01 a retiré les pentes, arrondis et concaves du jeu de plateforme, seuls types qui peuplaient cette liste. Le mécanisme est conservé — il est partagé par l'atlas procédural, le détourage des skins (hmi::TextureCache) et les vignettes de la palette (hmi::PaletteAppearance), et le vocabulaire de tuiles du RPG (LOT-08 : falaises, bords d'eau, ponts) le repeuplera. Le vider plutôt que le supprimer évite de reconstruire trois chaînes d'appel qui fonctionnent.

SKINS_SUBDIRECTORY

const std::string hmi::SKINS_SUBDIRECTORY = "Skins/"

inline

Sous-dossier des skins de tuiles, relatif au dossier d'assets (LOT-42).

TOOLBAR_COMMAND_BUDGET

int hmi::TOOLBAR_COMMAND_BUDGET = 5

constexpr

Nombre d'actions hors sélection d'outil admises dans une barre d'outils (LOT-68).

Sert de plafond vérifié par test : c'est le nombre au-delà duquel la barre redevient le fourre-tout que ce lot supprime, et un plafond qu'on relève sans y penser ne protège de rien.