Inputs — clavier

Les inputs sur macOS passent par NSEvent — les événements système qu'AppKit distribue à la fenêtre active — il n'existe pas de wrapper C++. L'architecture propre isole ces événements dans une structure InputState C++ que le Renderer consomme chaque frame, sans jamais toucher à ObjC dans la logique de jeu. Pour les manettes on utilise GCController du Framework GameController

Architecture — le flux de données

Afin d'avoir une application codée en langage C++ au maximum, nous avons vu comment appeler nos fonctions draw() et resize() depuis ObjC, le point de départ de l'exécution. Ici, dans un premier temps tu vas récupérer l'état des touches (0 = false, 1 = true) via les notifications mise en place par le système macOS.

Une structure partagée Objective-C / C++

Définie dans notre nouveau fichier InputState.h, partagée via un include simple — pas de cast, pas de bridge.

/// C++ — includes/SharedAPP/InputState.h — update:18/05/26
#ifndef InputState_h
#define InputState_h

#include "simd/simd.h"

struct InputState
{   // État continu : reconstruit intégralement à chaque frame,
    // donc rien à remettre à false soi-même
    bool keyLeft  = false;
    bool keyRight = false;
    bool keySpace = false;
    bool keyA     = false;
    bool keyZ     = false;
    bool keyE     = false;
    bool keyQ     = false;
    bool keyS     = false;
    bool keyD     = false;

    // Multiplicateur continu : 1.0 au repos
    float         speedMultiplier = 1.0f;
};

#endif /* InputState_h */

RenderWindow — capturer les événements

RenderWindow est notre sous-classe de NSWindow. Elle maintient un NSMutableSet des touches enfoncées et accumule le delta souris entre deux appels à pollInputState().

On déclare une fonction ici nommée pollInputState qui renvoie nos inputs sous forme de structure nommée ici InputState

/// Objective-C++ — AppViewController.mm — update:18/05/26 — RenderWindow
#include "../includes/SharedAPP/InputState.h"

@interface RenderWindow : NSWindow

@property (weak) ApplicationController* appCoordinator;

- (InputState)pollInputState; // Ajout à notre objet/class RenderWindow

@end

/// Objective-C++ — AppViewController.mm — update:18/05/26 — RenderWindow
@implementation RenderWindow // Constructeur RenderWindow
{   // déclaration de ivars
    NSMutableSet<NSNumber*>* _pressedKeys;   // touches actuellement enfoncées
    BOOL _commandWasDown;                // pour rattraper les keyUp: perdus (voir plus bas)
}

/// Objective-C++ — AppViewController.mm — update:18/05/26 — RenderWindow
- (instancetype)initWithContentRect:(NSRect)rect
                          styleMask:(NSWindowStyleMask)mask
                            backing:(NSBackingStoreType)backing
                              defer:(BOOL)flag
                             screen:(NSScreen*)screen
{
    self = [super initWithContentRect:rect styleMask:mask backing:backing defer:flag screen:screen];
    if (self) { _pressedKeys = [NSMutableSet new]; }
    return self;
}

/// Objective-C++ — AppViewController.mm — update:18/05/26
// Requis pour recevoir les événements clavier (les 3)
- (BOOL)acceptsFirstResponder               { return YES; }
- (BOOL)canBecomeKeyWindow                  { return YES; }
- (BOOL)canBecomeMainWindow                 { return YES; }
// Requis pour recevoir les événements souris
- (BOOL)acceptsFirstMouse:(NSEvent *)event  { return YES; }

keyDown / keyUp — le set de touches

Le pattern NSMutableSet est la façon correcte de gérer les touches : on ajoute dans keyDown, on retire dans keyUp — à chaque événement, pas à chaque frame. Le set reflète en permanence l'état réel du clavier ; pollInputState() se contente de le lire une fois par frame. Deux touches enfoncées en même temps = deux entrées dans le set, sans effort.

/// Objective-C++ — AppViewController.mm — update:18/05/26 — RenderWindow
- (void)keyDown:(NSEvent *)event
{   // isARepeat = YES (true) quand macOS répète une touche maintenue
    if (!event.isARepeat)
        [_pressedKeys addObject:@(event.keyCode)];
}

- (void)keyUp:(NSEvent *)event
{
    [_pressedKeys removeObject:@(event.keyCode)];
}

flagsChanged — Shift et Ctrl

Les touches modificatrices (⇧ Shift, ⌃ Ctrl, ⌥ Option, ⌘ Command) ne déclenchent jamais keyDown — elles utilisent flagsChanged(). On les mappe sur des keycodes virtuels (0x80, 0x81) pour les inclure dans le même set.

Pourquoi 0x80 et au-dessus ? Parce que les keycodes matériels de macOS s'arrêtent à 0x7E (flèche haut) : tout ce qui est >= 0x80 est libre, aucune collision possible avec une vraie touche. Et pourquoi un code par modificateur plutôt qu'un par touche physique ? Parce que modifierFlags ne dit pas quel Shift est enfoncé — pour ça il faudrait tester le keyCode de l'événement (0x38 ou 0x3C).

/// Objective-C++ — AppViewController.mm — update:18/05/26 — RenderWindow
// Petit utilitaire : pose ou retire un code selon un booléen
- (void)setKey:(uint16_t)code held:(BOOL)held
{
    if (held) [_pressedKeys addObject:@(code)];
    else      [_pressedKeys removeObject:@(code)];
}

- (void)flagsChanged:(NSEvent *)event
{
    NSEventModifierFlags f = event.modifierFlags;

    [self setKey:0x80 held:(f & NSEventModifierFlagShift)   != 0];  // ⇧
    [self setKey:0x81 held:(f & NSEventModifierFlagControl) != 0];  // ⌃
    [self setKey:0x82 held:(f & NSEventModifierFlagOption)  != 0];  // ⌥
    [self setKey:0x83 held:(f & NSEventModifierFlagCommand) != 0];  // ⌘

    // ⌘ vient d'être relâché : les keyUp: avalés pendant ce temps
    // n'arriveront jamais, on relâche tout à la main (voir ci-dessous)
    BOOL cmd = (f & NSEventModifierFlagCommand) != 0;
    if (_commandWasDown && !cmd) [self releaseAllHardwareKeys];
    _commandWasDown = cmd;
}

/// Objective-C++ — AppViewController.mm — update:18/05/26 — RenderWindow
- (void)flagsChanged:(NSEvent *)event
{
    if (event.modifierFlags & NSEventModifierFlagShift)
        [_pressedKeys addObject:@(0x80)];
    else
        [_pressedKeys removeObject:@(0x80)];

    if (event.modifierFlags & NSEventModifierFlagControl)
        [_pressedKeys addObject:@(0x81)];
    else
        [_pressedKeys removeObject:@(0x81)];
}

Le piège du ⌘ — des touches qui restent coincées

Deux situations font perdre des keyUp : tant que ⌘ Command est enfoncé, macOS ne délivre pas les keyUp des autres touches ; et une fenêtre qui perd le focus (⌘-Tab) cesse de recevoir des événements clavier. Dans les deux cas le set garde des touches « enfoncées » à vie — le personnage part tout seul vers la gauche pour toujours. Le correctif tient en deux méthodes.

/// Objective-C++ — AppViewController.mm — RenderWindow
// On ne relâche que les vraies touches : les codes virtuels >= 0x80
// restent gérés par flagsChanged, qui lui continue d'être appelé
- (void)releaseAllHardwareKeys
{
    NSMutableSet<NSNumber*>* keep = [NSMutableSet new];
    for (NSNumber* k in _pressedKeys)
        if (k.unsignedShortValue >= 0x80) [keep addObject:k];
    [_pressedKeys setSet:keep];
}

// La fenêtre perd le focus : plus aucun keyUp: ne viendra, on vide tout
- (void)resignKeyWindow
{
    [super resignKeyWindow];
    [_pressedKeys removeAllObjects];
    _commandWasDown = NO;
}

pollInputState() — snapshot par frame

Appelée une fois par frame dans drawInMTKView:, elle construit un InputState propre depuis l'état courant du set de touches.

/// Objective-C++ — AppViewController.mm — update:18/05/26 — RenderWindow
- (InputState)pollInputState
{
    InputState state; // tout est déjà à false / 1.0f
    if ([_pressedKeys containsObject:@(0x7B)]) { state.keyLeft  = true; }
    if ([_pressedKeys containsObject:@(0x7C)]) { state.keyRight = true; }
    if ([_pressedKeys containsObject:@(0x31)]) { state.keySpace = true; }
    if ([_pressedKeys containsObject:@(0x80)]) { state.speedMultiplier = 1.89f; }
    if ([_pressedKeys containsObject:@(0x81)]) { /* Do something */ }
    if ([_pressedKeys containsObject:@(0x35)]) { [[NSApplication sharedApplication] terminate:nil]; }
    return state;
}

Esc dans notre cas va chercher le sélecteur terminate de notre application afin de stopper la boucle.

drawInMTKView — consommer l'état

C'est ici que l'état est appliqué à la caméra et transmis au GameCoordinator. L'intégration avec le delta time rend le mouvement frame-rate indépendant.

/// Objective-C++ — AppViewController.mm — update:18/05/26 — ApplicationController
- (void)drawInMTKView:(nonnull MTKView *)view
{   // Delta time — cappé à 100ms pour éviter les sauts après suspend
    static CFTimeInterval lastTime = CACurrentMediaTime();
    CFTimeInterval now = CACurrentMediaTime();
    float delta = (float)(now - lastTime);
    lastTime = now;
    delta = fminf(delta, 0.1f);
    // Snapshot des inputs
    InputState input = [_window pollInputState];
    _renderer->m_input = input;
    _renderer->draw((__bridge MTK::View *)view, now, delta);
}

Ta classe principale :

/// C++ — Renderer.hpp — update:18/05/26
#include "../includes/SharedGPU/Renderer_shared.h"
#include "../includes/SharedAPP/InputState.h" // ← inclus

public: // ← en public
    ~Renderer();
    InputState m_input;

Table des keycodes macOS

Les keycodes sont des valeurs matérielles — ils ne changent pas selon la langue du clavier. Indépendants de la disposition AZERTY/QWERTY.

Change la langue du site en anglais pour les Keycodes QWERTY.

Table des keycodes macOS — AZERTY

Un keycode désigne une position physique sur le clavier, jamais le caractère imprimé dessus. La touche à droite du Tab renvoie 0x0C qu'on soit en AZERTY, en QWERTY ou en Dvorak — seule la lettre gravée change. Les constantes correspondantes vivent dans <Carbon/HIToolbox/Events.h> et sont nommées d'après le QWERTY US : kVK_ANSI_Q vaut 0x0C, c'est-à-dire le A d'un AZERTY.

Colonne AZERTY = ce qui est gravé sur un clavier français Apple ; le caractère en gris est celui obtenu avec ⇧ Shift. La colonne QWERTY donne la même touche physique vue par un clavier US.

Vérifier un code en trois lignes

La table couvre le clavier standard, mais le plus rapide reste de faire parler la machine : ajoute temporairement un NSLog dans keyDown et appuie sur la touche qui t'intéresse.

/// Objective-C++ — debug — à retirer ensuite
- (void)keyDown:(NSEvent *)event
{
    NSLog(@"keyCode = 0x%02X   caractère = %@",
          event.keyCode, event.charactersIgnoringModifiers);
}

Du keycode au libellé à afficher

Un écran de configuration des touches ne peut pas afficher « 0x0C » à l'utilisateur, ni écrire « Q » en dur : il faut demander au système ce que cette position produit sur le clavier actuellement actif. C'est le rôle de UCKeyTranslate, dans le framework Carbon (à ajouter aux Link Binary With Libraries).

/// Objective-C++ — keycode → libellé affichable
#import <Carbon/Carbon.h>

NSString* LabelForKeyCode(uint16_t keyCode)
{
    TISInputSourceRef src    = TISCopyCurrentKeyboardLayoutInputSource();
    CFDataRef         data   = (CFDataRef)TISGetInputSourceProperty(src, kTISPropertyUnicodeKeyLayoutData);
    const UCKeyboardLayout* layout = (const UCKeyboardLayout*)CFDataGetBytePtr(data);

    UInt32       deadKeyState = 0;
    UniChar      chars[4];
    UniCharCount length = 0;

    UCKeyTranslate(layout, keyCode, kUCKeyActionDisplay, 0,
                   LMGetKbdType(), kUCKeyTranslateNoDeadKeysBit,
                   &deadKeyState, sizeof(chars) / sizeof(chars[0]), &length, chars);

    CFRelease(src);
    return [[NSString stringWithCharacters:chars length:length] uppercaseString];
}
// LabelForKeyCode(0x0C) → "A" sur un AZERTY, "Q" sur un QWERTY