> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Lectures GameInput > Lectures GameInput Les paquets d'entrée bruts reçus de chaque périphérique sont encapsulés dans des objets « lecture ». Les lectures contiennent les données brutes d'origine du paquet et (généralement) une ou plusieurs transformations de ces données brutes en formats de plus haut niveau. En plus de leur rôle de conteneurs de données, les lectures servent également d'identificateurs qui référencent une position précise dans le flux d'entrée. ## Acquisition des lectures L'API GameInput offre deux moyens d'acquérir des lectures. Le plus courant consiste à y accéder directement à partir du flux d'entrée, via les méthodes de l'interface [IGameInput](/fr/reference/input/gameinput/interfaces/igameinput/igameinput). ```c++ theme={null} HRESULT GetCurrentReading( _In_ GameInputKind inputKind, _In_opt_ IGameInputDevice * device, _COM_Outptr_ IGameInputReading ** reading); ``` L'appel de [GetCurrentReading](/fr/reference/input/gameinput/interfaces/igameinput/methods/igameinput_getcurrentreading) récupère la lecture la plus récente du flux d'entrée. Un filtre [GameInputKind](/fr/reference/input/gameinput/enums/gameinputkind) facultatif peut être transmis pour limiter les lectures retournées à des types d'entrée spécifiques, comme une manette ou un clavier. Un filtre [IGameInputDevice](/fr/reference/input/gameinput/interfaces/igameinputdevice/igameinputdevice) facultatif peut également être transmis pour limiter les lectures retournées à celles générées par le périphérique spécifié. Ces filtres peuvent être appliqués individuellement ou ensemble. Les instances de [IGameInputReading](/fr/reference/input/gameinput/interfaces/igameinputreading/igameinputreading) sont des singletons avec comptage de références. La récupération d'une lecture est une opération extrêmement rapide et légère : aucune allocation de mémoire ni copie n'est effectuée, et l'appel d'API est sans verrou et sans transition en mode noyau. Comme les lectures sont des singletons, une application peut comparer l'égalité des pointeurs de lecture pour savoir si deux appels à [GetCurrentReading](/fr/reference/input/gameinput/interfaces/igameinput/methods/igameinput_getcurrentreading) ont retourné la même lecture (ce qui signifie qu'aucune nouvelle entrée n'a été générée). Les jeux dont les besoins en matière d'entrée sont moins complexes peuvent simplement interroger les nouvelles entrées une fois par image et comparer l'état stocké dans les deux lectures pour détecter des différences (s'il ne s'agit pas de la même lecture). Les jeux aux besoins plus complexes, en revanche, peuvent avoir besoin de parcourir le flux d'entrée pour obtenir une vue complète de tous les changements d'état d'entrée survenus depuis l'image précédente. Cela est rendu possible par les méthodes [GetNextReading](/fr/reference/input/gameinput/interfaces/igameinput/methods/igameinput_getnextreading) et [GetPreviousReading](/fr/reference/input/gameinput/interfaces/igameinput/methods/igameinput_getpreviousreading), qui acceptent les mêmes filtres que [GetCurrentReading](/fr/reference/input/gameinput/interfaces/igameinput/methods/igameinput_getcurrentreading). Le flux d'entrée conserve dans sa mémoire tampon les lectures historiques de la dernière demi-seconde. ```c++ theme={null} HRESULT GetNextReading( _In_ IGameInputReading * referenceReading, _In_ GameInputKind inputKind, _In_opt_ IGameInputDevice * device, _COM_Outptr_ IGameInputReading ** reading); HRESULT GetPreviousReading( _In_ IGameInputReading * referenceReading, _In_ GameInputKind inputKind, _In_opt_ IGameInputDevice * device, _COM_Outptr_ IGameInputReading ** reading); ``` Les applications peuvent également inscrire un rappel qui est appelé chaque fois qu'une entrée est générée. Comme pour les méthodes synchrones précédentes, plusieurs filtres peuvent être appliqués pour contrôler les types de lectures retournées et les périphériques dont elles proviennent. Pour plus d'informations, consultez [Rappels GameInput](/fr/build/core-features/common/input/advanced/input-callbacks) dans la section Rubriques avancées sur GameInput. ## Obtention des données des lectures Si chaque lecture contient les données brutes du paquet d'entrée provenant du périphérique, les lectures contiennent aussi généralement une ou plusieurs transformations de haut niveau de ces données. Par exemple, les entrées reçues d'une manette sont également analysées dans une structure standard à format fixe dotée d'identificateurs connus pour les boutons et les sticks. Les lectures contiennent souvent plusieurs représentations différentes des mêmes données d'entrée brutes, ce qui permet aux applications de choisir le format le mieux adapté à leurs besoins. Les applications peuvent connaître les types de données contenus dans une lecture en appelant sa méthode [GetInputKind](/fr/reference/input/gameinput/interfaces/igameinputreading/methods/igameinputreading_getinputkind). Celle-ci retourne une ou plusieurs valeurs d'indicateur de l'énumération [GameInputKind](/fr/reference/input/gameinput/enums/gameinputkind). ```c++ theme={null} typedef enum GameInputKind { GameInputKindUnknown = 0x00000000, GameInputKindRawDeviceReport = 0x00000001, GameInputKindController = 0x00000002, GameInputKindKeyboard = 0x00000004, GameInputKindMouse = 0x00000008, GameInputKindTouch = 0x00000100, GameInputKindMotion = 0x00001000, GameInputKindArcadeStick = 0x00010000, GameInputKindFlightStick = 0x00020000, GameInputKindGamepad = 0x00040000, GameInputKindRacingWheel = 0x00080000, GameInputKindUiNavigation = 0x01000000 } GameInputKind; ``` Les types de données disponibles dans une lecture dépendent du périphérique d'entrée et de ses propriétés physiques. Par exemple, une lecture provenant d'un clavier standard peut ne contenir que des données de clavier, tandis qu'une lecture provenant d'un clavier doté d'une boule de commande intégrée peut contenir à la fois des données de clavier et de souris. Presque tous les contrôleurs de jeu produisent des lectures contenant des données génériques de « contrôleur », qui ne sont qu'un ensemble d'états d'axes et de boutons anonymes. Cela permet une large prise en charge des périphériques pour les applications dotées d'une interface utilisateur de mappage des entrées. Cependant, de nombreux contrôleurs de jeu (comme les manettes) exposent également dans leurs lectures un état familier à format fixe, beaucoup plus facile à exploiter pour les jeux classiques. ```c++ theme={null} typedef struct GameInputGamepadState { GameInputGamepadButtons buttons; float leftTrigger; float rightTrigger; float leftThumbstickX; float leftThumbstickY; float rightThumbstickX; float rightThumbstickY; } GameInputGamepadState; ``` L'interface [IGameInputReading](/fr/reference/input/gameinput/interfaces/igameinputreading/igameinputreading) contient des méthodes permettant de récupérer l'état dans n'importe lequel des formats pris en charge par la lecture. Toutes les différentes représentations disponibles dans les lectures sont précalculées ; ces méthodes se contentent donc de copier quelques octets de données et de retourner. ## Une boucle d'entrée de manette simple L'exemple de code suivant illustre une boucle d'entrée entièrement fonctionnelle pour les manettes. On remarquera qu'il n'y a dans cet exemple aucune énumération explicite des périphériques. [IGameInputDevice](/fr/reference/input/gameinput/interfaces/igameinputdevice/igameinputdevice) n'est utilisé que comme identificateur de périphérique. Aucune de ses méthodes n'est jamais appelée. Cela illustre la nature centrée sur les entrées de l'API GameInput, et la manière dont elle peut simplifier le code pour les scénarios d'entrée courants. ```c++ theme={null} IGameInput* g_gameInput = nullptr; IGameInputDevice* g_gamepad = nullptr; HRESULT InitializeInput() { return GameInputCreate(&g_gameInput); } void ShutdownInput() { if (g_gamepad) g_gamepad->Release(); if (g_gameInput) g_gameInput->Release(); } void PollGamepadInput() { // Ask for the latest reading from devices that provide fixed-format // gamepad state. If a device has been assigned to g_gamepad, filter // readings to just the ones coming from that device. Otherwise, if // g_gamepad is null, it will allow readings from any device. IGameInputReading * reading; if (SUCCEEDED(g_gameInput->GetCurrentReading(GameInputKindGamepad, g_gamepad, &reading))) { // If no device has been assigned to g_gamepad yet, set it // to the first device we receive input from. (This must be // the one the player is using because it's generating input.) if (!g_gamepad) reading->GetDevice(&g_gamepad); // Retrieve the fixed-format gamepad state from the reading. GameInputGamepadState state; reading->GetGamepadState(&state); reading->Release(); // Application-specific code to process the gamepad state goes here. } // If an error is returned from GetCurrentReading(), it means the // gamepad we were reading from has disconnected. Reset the // device pointer, and go back to looking for an active gamepad. else if (g_gamepad) { g_gamepad->Release(); g_gamepad = nullptr; } } ``` ## Documentation de référence de l'API * [GameInput (contenu de l'API)](/fr/reference/input/gameinput/gameinput_members) ## Voir aussi [Notions fondamentales de GameInput](/fr/build/core-features/common/input/overviews/input-fundamentals) [Rubriques avancées sur GameInput](/fr/build/core-features/common/input/advanced/input-advanced-topics) [Référence de l'API GameInput](/fr/reference/input/gc-reference-input-toc) ## Related topics - [Guides de portage vers le GDK XBOX](/fr/home/build-first-title/porting-guides.md) - [Guides de portage vers le XBOX GDK](/fr-CA/home/build-first-title/porting-guides.md) - [GameInput](/reference/input/gameinput/gameinput_members.md) - [Overview of GameInput](/build/core-features/common/input/overviews/input-overview.md) - [GameInput fundamentals](/build/core-features/common/input/overviews/input-fundamentals.md)