> ## 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.
# Jeu réactif
> Jeu réactif
Cette rubrique décrit comment gérer la latence de bout en bout de votre jeu afin d'assurer une expérience de jeu réactive.
Ces renseignements étaient à jour en date de novembre 2019. Plusieurs fonctionnalités pourraient avoir changé ou avoir été mises à jour depuis.
## Latence de bout en bout
Les joueurs perçoivent la latence comme le délai entre le moment où ils appuient sur un bouton de la manette et le moment où quelque chose se produit à l'écran.
**Figure 1. Capacité à détecter la latence.**
La figure 1 présente les résultats d'une étude sur la détection de la latence. À 175 ms, tous les participants pouvaient la détecter. À 75 ms, un peu plus de la moitié des participants pouvaient la détecter. Sous 75 ms, la détection devient de plus en plus difficile. Avec une latence de 60 ms, quelques participants pouvaient la détecter. Un jeu dont la latence est de 60 ms est défini comme réactif.
**Figure 2. Comment une image est produite.**
La figure 2 présente une version simplifiée de la façon dont une image est produite.
1. Le système envoie l'état de la manette au jeu.
2. Le jeu lit l'information et met à jour la simulation.
3. Les résultats de la simulation servent au rendu d'une nouvelle image.
4. Le système envoie l'image nouvellement rendue à l'écran.
**Figure 3. Zones de latence potentielle.**
La figure 3 montre les zones où une latence peut survenir et rendre votre jeu peu réactif.
**Figure 4. Conditions idéales.**
La figure 4 montre que, idéalement, l'entrée de la manette est lue le plus près possible de l'étape de simulation lors du rendu vers l'écran. Le système suit le moment où l'image a été envoyée et celui où elle a atteint l'écran.
### Le problème d'entrée de manette en trois étapes
Le problème d'entrée de manette se décompose en étapes suivantes.
1. Entrée de manette pertinente : obtenir l'entrée du joueur le plus rapidement possible.
2. Synchronisation efficace : traiter les changements de l'état du jeu et effectuer le rendu des résultats le plus efficacement possible.
3. Écrans réactifs : dessiner l'affichage du joueur le plus rapidement possible.
## Entrée de manette pertinente
Les manettes se sont améliorées et deviennent plus complexes. Cette complexité a ajouté de la latence au fil du temps. Les manettes ajoutent de la latence en raison des problèmes suivants.
* Transmission sans fil :
* Trafic
* Fiabilité des données
* Surcharge de l'interface :
* Gestion des appareils
* Sécurité
* Surcharge du système/SE :
* Identification
* Analyse
* Présentation
### Manettes filaires et sans fil
La plupart des manettes XBOX sont utilisées sans fil. Toutefois, cette utilisation présente les problèmes potentiels suivants.
* La manette peut partager le spectre sans fil avec d'autres appareils, comme un téléphone.
* Comme les manettes sans fil nécessitent des piles, leur consommation pose un défi.
* Des données peuvent être perdues. Les jeux doivent tenir compte des transmissions retardées.
* La surcharge d'une manette filaire n'ajoute que 1 ms de latence grâce à l'interrogation USB rapide.
* La surcharge d'une manette sans fil peut ajouter jusqu'à 3 ms de latence.
### Fréquences d'échantillonnage et déphasage des entrées de manette
Les fréquences d'échantillonnage peuvent aussi causer des problèmes lorsque l'entrée échantillonnée se déphase par rapport à votre jeu.
**Figure 5. Fréquences d'échantillonnage et déphasage des entrées.**
La figure 5 montre l'exemple d'une manette qui échantillonne à 125 hertz. Cela garantit qu'il y aura deux lectures de la manette dans une même image. Toutefois, cet échantillonnage entraîne aussi des écarts où vous pourriez obtenir une lecture avant le moment souhaité. À d'autres moments, vous pourriez obtenir une lecture après. Dans la figure 5, la latence varie de façon irrégulière entre 0 ms et 8 ms.
Les solutions où la manette interroge à la vitesse maximale comportent leur propre lot de problèmes.
* Consommation des piles : interroger mille fois par seconde épuise rapidement les piles.
* Surcharge accrue du processeur : toutes les entrées de données interrogées doivent être analysées et traitées.
### Fonctionnalité Dynamic Latency Input
Au lieu de l'approche d'interrogation maximisée, utilisez Dynamic Latency Input, aussi appelée *entrée synchronisée*. Cette fonctionnalité optimise automatiquement la synchronisation des entrées de manette et effectue ce qui suit :
* Surveille la cadence des requêtes d'entrée.
* Surveille les performances sans fil et filaires.
* S'assure que l'entrée la plus récente est analysée et disponible lorsqu'elle est demandée.
* Suit les moments de présentation des images rendues.
* Maintient un niveau de « confiance » basé sur la cadence des requêtes d'entrée, les performances sans fil/filaires et les moments de présentation.
* Fournit le niveau de confiance dans PIX pour les analyses de performances.
Utilisez le niveau de confiance pour décider d'activer ou de désactiver cette fonctionnalité.
De plus, vous pouvez marquer manuellement les lectures importantes ou refuser cette fonctionnalité. Elle n'est disponible que sur XBOX Series X|S.
### Améliorations du système
Plusieurs changements au système contribuent à la réactivité des entrées et à la latence globale. Ils comprennent les suivants :
* Une nouvelle conception basée sur l'accès direct à la mémoire (DMA) pour réduire au minimum l'intervention du SE.
* Une API `GameInput` qui recueille l'historique des appareils d'entrée connectés.
* Les appuis sur les boutons d'une manette filaire déclenchent des mises à jour. Dynamic Latency Input reste utile pour les entrées analogiques.
* Une résilience améliorée des données sans fil.
* Le suivi de la synchronisation par rapport au temps d'image graphique.
Les objectifs visés pour la latence des entrées sont les suivants.
* Une réduction de plus de 50 % de la latence des entrées sans fil.
* Une réduction de plus de 75 % de la latence des entrées filaires.
* Une latence moyenne d'entrée de manette filaire d'environ 1 ms.
## Synchronisation efficace
**Figure 6. Cadence des images.**
La figure 6 montre comment les images sont générées en parallèle avec d'autres images en cours de traitement.
**Figure 7. Durée de l'intervalle d'image.**
La figure 7 montre la durée de l'intervalle d'image. La longueur de l'*intervalle d'image* détermine la fréquence de présentation et précise le rythme auquel les images sont rendues et envoyées à l'écran.
**Figure 8. Période d'image.**
La figure 8 montre la *période d'image* avec une valeur de 2. Cela signifie que l'image a commencé dans un intervalle et s'est terminée dans l'intervalle suivant.
### Cadence des images avec [PresentX](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12commandqueue/methods/id3d12commandqueue_presentx)
`PresentX` modifie la cadence des images en faisant abstraction de l'expression de la fréquence de rendu et de présentation.
Auparavant, le temps d'image était basé sur la fréquence de rafraîchissement de l'écran (VSync). Cela se complique avec les écrans actuels, car leur fréquence de rafraîchissement change avec une fonctionnalité comme la fréquence de rafraîchissement variable (VRR). De plus, la période d'image était auparavant calculée comme une fonction indirecte du nombre de tampons de la chaîne d'échange du jeu.
En revanche, `PresentX` utilise une durée pour calculer le temps d'image et une profondeur de pipeline définie pour la période d'image.
**Figure 9. Cadence des images avec PresentX : cible de 60 Hz.**
La figure 9 montre une cadence d'images `PresentX` simplifiée qui cible une fréquence d'images de 60 Hz.
L'exemple de code suivant montre l'API [SetFrameIntervalX](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_setframeintervalx).
```cpp theme={null}
HRESULT SetFrameIntervalX(
IDXGIOutput* pOutputSyncTarget,
UINT LengthInMicroseconds,
UINT PeriodInIntervals,
D3D12XBOX_FRAME_INTERVAL_FLAGS Flags)
```
Le code `SetFrameIntervalX` utilisé dans la figure 9 est le suivant.
```cpp theme={null}
pd3dDevice->SetFrameIntervalX(
nullptr,
16667, //D3D12XBOX_FRAME_INTERVAL_60_HZ
2,
D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);
```
Dans l'exemple de code, notez ce qui suit :
* `LengthInMicroseconds` est réglé à 16 667 microsecondes.
* `PeriodInIntervals` est réglé à 2.
* Les intervalles d'image courants ont leurs propres définitions. Dans cet exemple, la définition est D3D12XBOX\_FRAME\_INTERVAL\_60\_HZ.
### Planification des images avec PresentX
`PresentX` vous donne un contrôle formel sur la limitation du processeur. L'utilisation de la planification des images sur chaque image ajuste la synchronisation de sorte que vos intervalles soient plus rapprochés. Avec `PresentX`, vous déclarez explicitement votre attente. La limitation implicite à l'exécution par le pilote graphique dans `Present` est supprimée.
Vous disposez d'une planification événementielle, pilotée par interruptions, pour la production de nouvelles images à afficher. Définissez le moment d'origine de votre image dans un intervalle d'image et effectuez des mises à jour continues de l'origine en fonction de la charge de travail tirée des statistiques.
L'exemple de code suivant montre l'API [ScheduleFrameEventX](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_scheduleframeeventx).
```cpp theme={null}
HRESULT ScheduleFrameEventX(
D3D12XBOX_FRAME_EVENT_TYPE Type,
UINT IntervalOffsetInMicroseconds,
D3D12XBOX_SCHEDULE_FRAME_OBJECT_LIST* pAncillarySignalList,
D3D12XBOX_SCHEDULE_FRAME_EVENT_FLAGS Flags)
```
Le code `ScheduleFrameEventX` utilisé dans la figure 9 est le suivant.
```cpp theme={null}
pd3dDevice->ScheduleFrameEventX(
D3D12XBOX_FRAME_EVENT_ORIGIN,
5556,
nullptr,
D3D12XBOX_SCHEDULE_FRAME_EVENT_FLAG_NONE);
```
Appelez ID3D12Device::ScheduleFrameEventX pour établir le moment, dans un intervalle d'image, où limiter le processeur. Indiquez un Type de D3D12XBOX\_FRAME\_EVENT\_ORIGIN et un décalage temporel IntervalOffsetInMicroseconds pour planifier l'événement d'origine des images. Le processeur est limité jusqu'à ce que la durée IntervalOffsetInMicroseconds spécifiée dans l'intervalle soit écoulée.
Maintenant qu'un événement se déclenche au début de l'image, interrogez l'événement `ORIGIN` du pipeline de cette image ou bloquez sur celui-ci. Le jeton de pipeline qui identifie l'image est maintenant créé par `WaitFrameEventX`. Ce jeton est transmis à `PresentX`.
L'exemple de code suivant montre l'API [WaitFrameEventX](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_waitframeeventx).
```cpp theme={null}
HRESULT WaitFrameEventX(
D3D12XBOX_FRAME_EVENT_TYPE Type,
UINT TimeOutInMs,
D3D12XBOX_WAIT_FRAME_OBJECT_LIST* pAncillaryWaitList,
D3D12XBOX_WAIT_FRAME_EVENT_FLAGS Flags,
D3D12XBOX_FRAME_PIPELINE_TOKEN* pToken)
```
D'après l'exemple de la figure 9, le code `WaitFrameEventX` est le suivant.
```cpp theme={null}
pd3dDevice->WaitFrameEventX(
D3D12XBOX_FRAME_EVENT_ORIGIN,
0,
nullptr,
D3D12XBOX_WAIT_FRAME_EVENT_FLAG_NONE,
&token);
```
Cet exemple de code montre que le délai d'expiration est réglé à 0. Le jeton de pipeline apparaît à la fin.
### Présentation avec PresentX
Une nouvelle fonctionnalité de l'API `PresentX` est la possibilité d'une latence en double mise en mémoire tampon, même si un rendu en triple mise en mémoire tampon est configuré. Cela signifie que, même si vous configurez la triple mise en mémoire tampon, la double mise en mémoire tampon est maintenue tant que les images se terminent à temps, jusqu'à ce que vous dépassiez le temps d'image et ayez besoin de trois tampons d'image.
Cet appel nécessite [D3D12XBOX\_FRAME\_PIPELINE\_TOKEN](/fr-CA/reference/graphics/d3d12_x/enums/d3d12xbox_frame_pipeline_token) dans `D3D12XBOX_PRESENT_PLANE_PARAMETERS` afin de suivre la latence de bout en bout. `PresentX` prend aussi en charge la présentation à partir de files de calcul asynchrone.
Pour plus d'information, consultez la présentation Xfest 19 sur le portage des graphiques vers XBOX Series X|S.
### Processus étape par étape des statistiques d'image
**Figure 10. GetFrameStatisticsX.**
La figure 10 montre l'API `GetFrameStatisticsX`.
Ce code porte sur les éléments suivants :
* `D3D12XBOX_FRAME_STATISTICS_TYPE_FRAME_INPUT`
* `D3D12XBOX_FRAME_STATISTICS_TYPE_FRAME_INTERVAL`
* `D3D12XBOX_FRAME_STATISTICS_TYPE_FRAME_EVENT`
* `D3D12XBOX_FRAME_STATISTICS_TYPE_RENDER`
* `D3D12XBOX_FRAME_STATISTICS_TYPE_PRESENT`
* `D3D12XBOX_FRAME_STATISTICS_TYPE_DISPLAY`
Ce processus commence par une image, montre où elle est utilisée, puis explique pourquoi elle est utile.
**Figure 11. Statistiques d'image : début de l'image.**
La figure 11 montre où l'image commence à être traitée dans le pipeline graphique.
**Figure 12. Statistiques d'image : signalement de l'origine de l'image.**
La figure 12 montre d'où l'`ORIGIN` de l'image est signalée et quand `WaitFrameEventX` est appelée.
**Figure 13. Statistiques d'image : D3D12XBOX\_FRAME\_EVENT\_STATISTICS.**
La figure 13 montre où les statistiques d'événement d'image deviennent disponibles. Pour plus d'information, consultez [D3D12XBOX\_FRAME\_EVENT\_STATISTICS](/fr-CA/reference/graphics/d3d12_x/structs/d3d12xbox_frame_event_statistics).
**Figure 14. Statistiques d'image : requête d'entrée.**
La figure 14 montre où se fait la requête d'entrée. La simulation est maintenant prête à s'exécuter.
**Figure 15. Statistiques d'image : D3D12XBOX\_INPUT\_STATISTICS.**
La figure 15 montre où le jeton de pipeline d'entrée est traité.
Pour plus d'information, consultez [D3D12XBOX\_INPUT\_STATISTICS](/fr-CA/reference/graphics/d3d12_x/structs/d3d12xbox_input_statistics).
**Figure 16. Statistiques d'image : la simulation est terminée.**
La figure 16 montre le moment où la simulation est terminée.
**Figure 17. Statistiques d'image : rendu de l'image.**
La figure 17 montre où le processeur commence à enregistrer et à exécuter les listes de commandes pour effectuer le rendu de l'image. Le GPU commence ensuite à traiter les listes de commandes pour effectuer le rendu de l'image.
**Figure 18. Statistiques d'image : PresentX.**
La figure 18 montre l'appel à `PresentX` lorsque le processeur termine le rendu de l'image.
**Figure 19. Statistiques d'image : le GPU atteint la dernière transition ResourceBarrier.**
La figure 19 montre où le GPU atteint la dernière transition [ResourceBarrier](/fr-CA/reference/graphics/d3d12/interfaces/id3d12graphicscommandlist/methods/id3d12graphicscommandlist_resourcebarrier_public) à partir de l'état d'écriture des ressources d'échange utilisées dans `PresentX`.
**Figure 20. Statistiques d'image : D3D12XBOX\_RENDER\_STATISTICS.**
La figure 20 montre où le GPU a terminé l'écriture selon les statistiques de rendu. Pour plus d'information, consultez [D3D12XBOX\_RENDER\_STATISTICS](/fr-CA/reference/graphics/d3d12_x/structs/d3d12xbox_render_statistics).
**Figure 21. Statistiques d'image : déclenchement du GPU.**
La figure 21 montre où le GPU est déclenché pour la présentation.
**Figure 22. Statistiques d'image : D3D12XBOX\_PRESENT\_STATISTICS.**
La figure 22 montre les statistiques de présentation à la fin du rendu GPU et le moment où l'information est disponible pour que le processeur la récupère. Pour plus d'information, consultez [D3D12XBOX\_PRESENT\_STATISTICS](/fr-CA/reference/graphics/d3d12_x/structs/d3d12xbox_present_statistics).
**Figure 23. Statistiques d'image : interruption VBLANK.**
La figure 23 montre la prochaine interruption VBLANK qui coïncide avec la fin de l'intervalle d'image. Les ressources d'échange présentées sont basculées vers l'écran.
**Figure 24. Statistiques d'image : D3D12XBOX\_DISPLAY\_STATISTICS.**
La figure 24 montre les statistiques d'affichage. Pour plus d'information, consultez [D3D12XBOX\_DISPLAY\_STATISTICS](/fr-CA/reference/graphics/d3d12_x/structs/d3d12xbox_display_statistics).
**Figure 25. Statistiques d'image : D3D12XBOX\_FRAME\_INTERVAL\_STATISTICS.**
La figure 25 montre les statistiques d'intervalle d'image. Pour plus d'information, consultez [D3D12XBOX\_FRAME\_INTERVAL\_STATISTICS](/fr-CA/reference/graphics/d3d12_x/structs/d3d12xbox_frame_interval_statistics).
Ce processus fournit des données de latence exploitables, d'une image à l'autre, afin que vous puissiez ajuster et réduire l'écart de temps entre le moment où le joueur appuie sur un bouton de la manette et le moment où quelque chose se produit à l'écran.
## Écrans réactifs
Les écrans modernes ajoutent de la latence en raison des éléments suivants :
* La surcharge de transmission, soit le temps nécessaire pour recevoir les données du câble HDMI.
* Le temps nécessaire pour traiter des images 4K ou plus grandes, y compris les améliorations d'image propres au fabricant.
* Le temps nécessaire pour mettre une image à l'échelle de la résolution native de l'écran.
* Le temps nécessaire pour dessiner l'image à l'écran.
* Le temps nécessaire pour dessiner les superpositions des menus, des commandes de volume ou de tout autre élément dont le joueur pourrait avoir besoin pour contrôler son écran.
### Mode faible latence automatique
Le mode faible latence automatique (ALLM) est une fonctionnalité définie dans la spécification HDMI 2.1. ALLM permet à la source vidéo (dans ces exemples, la console XBOX) d'ordonner à tous les composants compatibles de passer en mode faible latence. Les écrans qui utilisent ALLM réduisent le traitement d'image afin de réduire au minimum les délais avant la présentation de l'image. Il s'agit d'une fonctionnalité au niveau du système, semblable à VRR. Vous n'avez rien à faire, mais les joueurs doivent s'assurer qu'ALLM est activé dans les paramètres d'affichage de la console. Cette fonctionnalité est prise en charge sur XBOX One et XBOX Series X|S.
### Écrans 120 Hz
XBOX prend en charge les écrans 120 Hz. Les jeux à 60 images par seconde (FPS) en tirent des avantages, car le débit de transmission HDMI et la fréquence de rafraîchissement de l'écran sont intrinsèquement liés.
| Fréquence de rafraîchissement de l'écran | Temps de transmission HDMI | Durée VBLANK | Total |
| - | - | - | - |
| 60 Hz | 16 ms | 0,67 ms | 16,67 ms |
| 120 Hz | 8 ms | 0,33 ms | 8,33 ms |
| Différence | 8 ms | 0,33 ms | 8,33 ms |
### Manquer un VBLANK
Si votre jeu manque un VBLANK, le joueur le perçoit probablement comme une saccade, car la même image rendue est affichée plus d'une fois. Sur un écran 60 Hz, cette saccade pourrait durer jusqu'à 16,6 ms. Si votre jeu manque un VBLANK sur un écran 120 Hz (en raison de la fréquence de rafraîchissement plus rapide), la saccade pourrait être deux fois moindre que 16,6 ms, soit jusqu'à 8,3 ms.
**Figure 26. Manquer un VBLANK à 60 Hz par rapport à 120 Hz.**
La figure 26 compare le fait de manquer un VBLANK à 60 Hz et à 120 Hz. Lorsqu'un VBLANK est manqué, une saccade se produit et une image de latence est ajoutée. Sur un écran 120 Hz, les VBLANK se produisent plus rapidement. L'image suivante arrive aussi plus vite, et la latence ajoutée est grandement réduite par rapport à un écran 60 Hz.
### Jeu à 120 FPS
Avec la disponibilité des écrans 120 Hz, le jeu à 120 FPS est possible sur XBOX Series X|S. Le code suivant montre comment mettre votre jeu en mode 120 Hz en réglant la durée de l'intervalle d'image à 8 333 microsecondes.
```cpp theme={null}
pd3dDevice->SetFrameIntervalX(
nullptr,
8333, //D3D12XBOX_FRAME_INTERVAL_120_HZ
2,
D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);
```
### VRR
VRR est une fonctionnalité définie dans HDMI 2.1. Utilisez VRR pour un rafraîchissement d'écran fluide dans la plage prise en charge, par exemple de 30 Hz à 120 Hz plutôt qu'une cadence forcée à 60 Hz. Vous n'avez rien à faire pour utiliser VRR, mais vous pouvez le désactiver dans les situations où un rafraîchissement stable est nécessaire, par exemple dans les menus, les scènes de chargement ou les cinématiques. XBOX prend actuellement en charge HDMI VRR et AMD FreeSync. XBOX One prend en charge la plage de 40 à 60 Hz, mais les écrans peuvent avoir des capacités VRR différentes. En pratique, le système peut présenter de façon fluide des images qui durent environ 4 ms de plus.
### Fréquences de rafraîchissement prises en charge par XBOX Series X|S
* 120 Hz
* 60 Hz
* 40 Hz
* 30 Hz
* 20 Hz
* 15 Hz
### Manquer un VBLANK avec VRR
Comme mentionné précédemment, un VBLANK manqué peut entraîner jusqu'à 16,6 ms de saccade sur un écran 60 Hz et jusqu'à 8,3 ms de saccade sur un écran 120 Hz. Toutefois, avec VRR, aucune saccade n'est observée, car le VBLANK de l'écran est retardé jusqu'à ce que l'image rendue soit terminée. La seule latence supplémentaire correspond au délai du VBLANK, plutôt qu'à une durée fixe de rafraîchissement de l'écran.
**Figure 27. Manquer un VBLANK avec VRR.**
La figure 27 compare la quantité de saccades d'un jeu sur un écran 60 Hz avec celle d'un jeu où VRR est activé.
### Jeu à 40 FPS
Le jeu à 40 FPS est possible avec les écrans 120 Hz. Le système transmettra la même image rendue trois fois à la fréquence de rafraîchissement de 120 Hz. Autrement dit, à 40 FPS, le temps d'image est de 25 ms, et le système transmettra cette image trois fois à la fréquence de rafraîchissement de 8,3 ms, soit 25 ms. Nous vous recommandons de prendre en charge le jeu à 40 FPS, car la latence est réduite de 8,3 ms par rapport à 30 FPS.
L'exemple de code suivant montre comment régler la durée de l'intervalle d'image à 25 000 microsecondes pour le jeu à 40 FPS.
```cpp theme={null}
pd3dDevice->SetFrameIntervalX(
nullptr,
25000,
2,
D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);
```
## Résumé
Les améliorations de la latence des entrées de manette entraînent :
* Des mises à jour de manette plus rapides et plus pertinentes.
* Une surcharge du SE réduite.
Les améliorations de la planification des images entraînent :
* Un contrôle plus direct de la synchronisation.
* De meilleures statistiques d'image et un suivi amélioré dans PIX pour les entrées et les graphiques.
Les améliorations de la latence de sortie du jeu entraînent :
* De nouvelles normes d'affichage.
* Des fréquences de rafraîchissement plus rapides.
Pour plus d'information sur le jeu réactif, consultez les exemples suivants.
* [ResponsivenessSample](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/development-downloads/gdk-samples-list#graphics)
* [Simple120Hz](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/development-downloads/gdk-samples-list#graphics)
## Étapes suivantes
Si vous souhaitez consulter l'information des documents de présentation liés à cette vue d'ensemble, téléchargez les fichiers suivants à partir du [stockage sécurisé des données de téléchargement pour les développeurs XBOX (SDS)](https://www.microsoft.com/en-us/software-download/gdk).
* Diaporama : XF2019\_Graphics\_04\_Day1\_Responsive\_Gaming.pptx dans Xfest 2019 Graphics Track PowerPoints (\[2019.11]-Xfest2019GraphicsTrackPowerPoints.ZIP)
* Présentation vidéo : XF2019\_Graphics\_04\_Day1\_Responsive\_Gaming.mp4 dans Xfest 2019 Graphics Track Videos (\[2019.11]-Xfest2019GraphicsTrackVideos.ZIP)
### Télécharger les présentations Microsoft PowerPoint et les vidéos
1. Accédez aux [téléchargements du Game Development Kit (GDK)](https://www.microsoft.com/en-us/software-download/gdk).
2. Sous Select file type, sélectionnez **Conference Materials**, puis sélectionnez **Confirm**.
3. Sous Select build/version number, choisissez l'une des présentations graphiques suivantes.
* Xfest 2019 Graphics Track PowerPoints
* Xfest 2019 Graphics Track Videos
4. Sélectionnez Download Now, puis attendez la fin du téléchargement du fichier .zip.
5. Accédez à votre dossier Téléchargements local, puis décompressez (extrayez) les fichiers du dossier compressé.
### Télécharger les exemples pour console du Microsoft Game Development Kit mentionnés dans cet article
1. Accédez aux [téléchargements du Game Development Kit (GDK)](https://www.microsoft.com/en-us/software-download/gdk).
2. Sous Select file type, sélectionnez **GDK**, puis sélectionnez **Confirm**.
3. Sous Select build/version number, choisissez l'option **Microsoft GDKX (Sample only)** la plus récente.
4. Sélectionnez Download Now, puis attendez la fin du téléchargement du fichier .zip.
5. Accédez à votre dossier Téléchargements local, puis décompressez (extrayez) les fichiers du dossier compressé.
6. Sélectionnez **GDKSamples** > **Graphics**, puis recherchez l'exemple.
## Voir aussi
[Rubriques avancées sur GameInput (table des matières)](/fr-CA/build/core-features/common/input/advanced/input-advanced-topics)
[Dynamic Latency Input de GameInput](/fr-CA/build/core-features/common/input/advanced/input-synchronization)
[Analyse approfondie de la compensation de latence en diffusion de jeux en continu](/fr-CA/build/core-features/common/game-streaming/game-streaming-latency-compensation-deep-dive)
[Planification et présentation des images sur XBOX One](/fr-CA/build/core-features/graphics/directx/frame-scheduling-and-presentation)
[Vues d'ensemble des fonctionnalités graphiques XBOX Series X|S](/fr-CA/build/core-features/graphics/graphics-newfeatures-toc)
[PIX](/fr-CA/tools/tools-console/pix/pix)
[Intégration PIX](/fr-CA/tools/tools-console/pix/pix-input-sync)
## Related topics
- [XBOX Requirements pour les jeux XBOX](/fr/publishing/certification/xbox-requirements.md)
- [Exigences XBOX pour les jeux XBOX](/fr-CA/publishing/certification/xbox-requirements.md)
- [Exigences XBOX testées lors de la certification pour les jeux sur console XBOX](/fr-CA/publishing/certification/console-cert-tested-requirements.md)
- [XR001 Stabilité du titre](/fr-CA/publishing/certification/fma/xr-001.md)
- [XR-001 Stabilité du titre](/fr-CA/publishing/certification/xr/xr-001.md)