Skip to main content
La plupart des anciennes API d’entrée de Microsoft sont centrées sur les périphériques, ce qui signifie que le code de l’application doit d’abord trouver les périphériques d’entrée qu’il prend en charge, généralement au moyen d’un modèle d’énumération, avant de pouvoir lire la moindre entrée. Pour la plupart des jeux dont les besoins en matière d’entrée sont relativement simples, cela ajoute beaucoup de code et de complexité. L’API GameInput, en revanche, est centrée sur les entrées. Les applications trouvent d’abord l’entrée qui les intéresse, puis peuvent éventuellement interroger le périphérique qui a généré cette entrée. Cela conduit à des algorithmes plus naturels, et donc à un code plus simple.

Architecture du flux d’entrée

GameInput repose sur le concept de flux d’entrée : les entrées de tous les périphériques connectés au système sont dirigées vers un flux unique et contigu d’événements d’entrée, dans l’ordre dans lequel elles se sont produites. Lorsque plusieurs périphériques génèrent des entrées simultanément, il en résulte un entrelacement naturel des événements d’entrée. Voici un exemple de flux d’entrée provenant de plusieurs périphériques d’entrée. Exemple de flux d'entrée provenant de plusieurs périphériques d'entrée Dans cet exemple, quatre périphériques envoient des entrées simultanément. Le numéro de chaque carré représente l’ordre dans lequel l’entrée a été envoyée, et la couleur représente le périphérique qui l’a envoyée. Ainsi, dans cet exemple, la première manette envoie la première entrée, le clavier la deuxième, la souris la troisième et la seconde manette la quatrième. Chaque élément du flux d’entrée est représenté par une « lecture ». Les applications commencent par obtenir la lecture la plus récente du flux d’entrée. À partir de là, l’application peut soit continuer à obtenir périodiquement la lecture la plus récente, soit parcourir le flux d’entrée vers l’avant et vers l’arrière en examinant les lectures adjacentes. Dans les deux cas, l’application compare généralement les différences entre les lectures qui l’intéressent, puis effectue l’action appropriée. Par exemple, un jeu de tir à la première personne peut avoir uniquement besoin de savoir si un bouton est enfoncé au début de chaque image pour déterminer si l’arme du joueur doit tirer. Dans ce cas, seule la lecture la plus récente importe (et toutes les lectures intermédiaires peuvent être ignorées). En revanche, un jeu de combat compétitif peut vouloir examiner chaque changement d’état d’entrée survenu entre l’image précédente et l’image actuelle, pour l’une des raisons suivantes.
  • Un double appui sur un bouton peut correspondre à un combo ou à un mouvement différent d’un appui simple.
  • L’ordre dans lequel deux boutons ont été enfoncés peut avoir de l’importance.
  • Le temps écoulé entre deux appuis sur des boutons peut avoir de l’importance.
Lors de la récupération des lectures du flux d’entrée, les applications peuvent appliquer des filtres facultatifs, qui limitent les résultats aux lectures de types d’entrée spécifiques (comme les manettes ou les claviers) et/ou d’un périphérique spécifique. Pour plus de détails, consultez Lectures GameInput. Les applications ne peuvent demander au flux d’entrée que des lectures historiques survenues au cours de la dernière demi-seconde. La lecture la plus récente de chaque périphérique connecté est toujours accessible, quelle que soit son ancienneté.

Interfaces

L’API GameInput est exposée par le biais d’un ensemble d’interfaces associées, à l’image des API graphiques et audio, comme le montre le diagramme suivant. Diagramme de l'API GameInput exposée par le biais d'un ensemble d'interfaces associées Trois interfaces principales constituent l’essentiel de la surface de l’API GameInput.
  • IGameInput est l’interface de base obtenue en appelant la fonction de fabrique GameInputCreate. Elle contient des méthodes permettant de récupérer les lectures du flux d’entrée, d’inscrire des rappels et d’accéder à d’autres fonctionnalités globales.
  • IGameInputReading représente un élément unique du flux d’entrée. Elle contient des méthodes permettant de récupérer les données d’état d’entrée stockées dans la lecture et d’accéder au périphérique qui a généré la lecture. Les lectures servent également de points de référence dans le flux d’entrée, lors du parcours vers l’avant et vers l’arrière des autres lectures du flux.
  • IGameInputDevice représente un périphérique d’entrée unique connecté au système. Elle contient des méthodes permettant de récupérer les propriétés et l’état actuel du périphérique, ainsi que des méthodes permettant de contrôler le retour haptique et le retour de force sur le périphérique. Elle contient également des méthodes permettant d’effectuer des E/S brutes de bas niveau sur le périphérique.
Les autres interfaces sont utilisées dans des contextes spécifiques, abordés dans la section Rubriques avancées sur GameInput.
Comme les API graphiques et audio, GameInput n’est pas une véritable API COM, même s’il expose des interfaces dérivées de IUnknown. Ce style d’API est parfois appelé « COM lite » ou « nano-COM ». Bien que IUnknown soit utilisé pour le comptage de références et la réflexion, l’infrastructure du runtime COM n’est pas utilisée par GameInput. Concrètement, cela signifie ce qui suit.
  • Les applications n’appellent ni CoInitialize ni CoCreateInstance pour obtenir des instances d’objets.
  • Les fonctionnalités COM telles que l’agrégation et les implémentations d’interfaces fournies par l’appelant ne sont pas prises en charge.
  • Il n’y a pas de prise en charge du marshaling interprocessus, ni de modèle d’apartment ou de threading. Tous les objets sont agiles.
  • Les pointeurs d’interface peuvent être comparés directement pour déterminer l’identité des objets, sans passer par IUnknown.
  • Les méthodes ne sont pas tenues de retourner des codes HRESULT, ce qui conduit souvent à des signatures de fonctions plus simples.

Focus de l’application

Sur console, GameInput fournit des entrées à une application uniquement lorsqu’elle a le focus. Dans le cas contraire, l’état retourné contient des valeurs neutres ou « au repos », comme si l’utilisateur ne touchait pas du tout le périphérique. Cela évite d’avoir à écrire du code d’entrée supplémentaire pour gérer les changements de focus. Sur PC, par défaut, les entrées (y compris les boutons système) sont envoyées aux applications qui ont le focus. Ce comportement peut être modifié à l’aide de la méthode SetFocusPolicy. Tout retour haptique ou retour de force envoyé à un périphérique est désactivé lorsqu’une application perd le focus. Elle peut toujours appeler les API GameInput pour définir un nouvel état de retour, mais ce nouvel état ne sera pas envoyé au périphérique. Lorsque l’application récupère le focus, le dernier état de retour qu’elle a demandé est automatiquement envoyé au périphérique. Par conséquent, les applications n’ont aucune action particulière à effectuer en matière d’entrée ou de retour haptique/de force lorsqu’elles obtiennent ou perdent le focus. L’API GameInput fait toujours ce qu’il faut à leur place.

Documentation de référence de l’API

Voir aussi

Lectures GameInput Périphériques GameInput Rubriques avancées sur GameInput Référence de l’API GameInput
Last modified on October 6, 2026