Jeu réactif

Cette rubrique explique comment gérer la latence de bout en bout de votre jeu afin de garantir une expérience de jeu réactive.

Ces informations étaient à jour en novembre 2019. Plusieurs fonctionnalités ont pu être modifiées ou mises à jour depuis.

Latence de bout en bout

Les joueurs perçoivent la latence comme le temps qui s’écoule 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. En dessous de 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 créée.

La figure 2 présente une version simplifiée de la création d’une image.

Le système envoie l’état de la manette au jeu.
Le jeu lit les informations et met à jour la simulation.
Les résultats de la simulation produisent le rendu d’une nouvelle image.
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 les entrées de la manette sont idéalement lues aussi près que possible de l’étape de simulation lors du rendu à 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 des entrées de manette en trois étapes

Le problème des entrées de manette se décompose en plusieurs étapes.

Entrées pertinentes de la manette : obtenir les entrées du joueur le plus rapidement possible.
Synchronisation efficace : traiter les modifications de l’état du jeu et effectuer le rendu des résultats le plus efficacement possible.
Affichages réactifs : dessiner l’affichage du joueur le plus rapidement possible.

Entrées pertinentes de la manette

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 périphériques
- Sécurité
Surcharge du système/système d’exploitation :
- Identification
- Analyse
- Présentation

Manettes filaires et manettes 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 représente 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 phase des entrées de manette

Les fréquences d’échantillonnage peuvent également poser des problèmes lorsque les entrées échantillonnées se déphasent par rapport à votre jeu. Figure 5. Fréquences d’échantillonnage et phase des entrées.

La figure 5 montre l’exemple d’une manette qui effectue des échantillonnages à 125 hertz. Cela garantit qu’il y aura deux lectures de la manette au sein d’une même image. Toutefois, cet échantillonnage entraîne également des écarts où vous pourriez obtenir une lecture avant le moment voulu. À d’autres moments, vous pourriez obtenir une lecture après. Dans la figure 5, la latence varie de manière irrégulière entre 0 ms et 8 ms. Les solutions dans lesquelles la manette est interrogée à la vitesse maximale présentent leurs propres problèmes.

Consommation de la batterie : interroger la manette mille fois par seconde épuise rapidement la batterie.
Surcharge processeur plus élevée : 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 maximale, utilisez Dynamic Latency Input, également appelée entrée synchronisée. Cette fonctionnalité optimise automatiquement la synchronisation des entrées de la manette et effectue les opérations suivantes :

Surveille la cadence des requêtes d’entrée.
Surveille les performances sans fil et filaires.
Garantit que l’entrée la plus récente est analysée et disponible lorsqu’elle est demandée.
Suit les heures 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 heures 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 désactiver cette fonctionnalité. Elle n’est disponible que sur XBOX Series X|S.

Améliorations du système

Plusieurs modifications du système contribuent à améliorer la réactivité des entrées et la latence globale. Elles comprennent les suivantes :

Une nouvelle conception basée sur l’accès direct à la mémoire (DMA) pour réduire au minimum l’intervention du système d’exploitation.
Une API GameInput qui collecte des informations historiques à partir des périphériques d’entrée connectés.
Les appuis sur les boutons des manettes filaires 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 des entrées 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 spécifie la vitesse à laquelle 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 de 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 d’actualisation de l’écran (VSync). Cela devient compliqué avec les écrans actuels, car leur fréquence d’actualisation change avec une fonctionnalité comme la fréquence d’actualisation 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 de 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.

HRESULT SetFrameIntervalX(
        IDXGIOutput* pOutputSyncTarget,
        UINT LengthInMicroseconds,
        UINT PeriodInIntervals,
        D3D12XBOX_FRAME_INTERVAL_FLAGS Flags)

Le code SetFrameIntervalX utilisé dans la figure 9 est le suivant.

pd3dDevice->SetFrameIntervalX(
        nullptr,
        16667, //D3D12XBOX_FRAME_INTERVAL_60_HZ
        2,
        D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);

Dans l’exemple de code, notez les points suivants :

LengthInMicroseconds est défini sur 16 667 microsecondes.
PeriodInIntervals est défini sur 2.
Les intervalles d’image courants disposent de leurs propres définitions. Dans cet exemple, la définition est D3D12XBOX_FRAME_INTERVAL_60_HZ.

Planification des images de 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 afin que vos intervalles soient plus rapprochés. Avec PresentX, vous déclarez explicitement votre attente. La limitation implicite à l’exécution effectuée par le pilote graphique dans Present a disparu. Vous disposez d’une planification basée sur les événements et pilotée par les interruptions pour la production de nouvelles images à afficher. Définissez l’heure d’origine de votre image au sein d’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.

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.

pd3dDevice->ScheduleFrameEventX(
        D3D12XBOX_FRAME_EVENT_ORIGIN,
        5556,
        nullptr,
        D3D12XBOX_SCHEDULE_FRAME_EVENT_FLAG_NONE);

Appelez ID3D12Device::ScheduleFrameEventX pour établir le moment, au sein d’un intervalle d’image, où limiter le processeur. Spécifiez un Type 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 au sein de l’intervalle se soit écoulée. Maintenant qu’un événement se déclenche au démarrage de l’image, interrogez ou bloquez sur l’événement ORIGIN du pipeline de cette image. Le jeton de pipeline qui identifie l’image est désormais créé par WaitFrameEventX. Ce jeton est transmis à PresentX. L’exemple de code suivant montre l’API WaitFrameEventX.

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.

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 défini sur 0. Le jeton de pipeline apparaît à la fin.

Présentation avec PresentX

Une nouvelle fonctionnalité de l’API PresentX est la possibilité d’obtenir une latence de double mise en mémoire tampon, même si le rendu en triple mise en mémoire tampon est configuré. Cela signifie que, même si vous pouvez configurer la triple mise en mémoire tampon, si les images se terminent à temps, la double mise en mémoire tampon est conservée jusqu’à ce que vous dépassiez le temps d’image et ayez besoin de trois tampons d’image. Cet appel nécessite le D3D12XBOX_FRAME_PIPELINE_TOKEN dans le cadre de D3D12XBOX_PRESENT_PLANE_PARAMETERS pour suivre la latence de bout en bout. PresentX prend également en charge la présentation à partir de files d’attente de calcul asynchrone. Pour plus d’informations, consultez la présentation Xfest 19 sur le portage des graphismes vers XBOX Series X|S.

Processus pas à pas des statistiques d’image

Figure 10. GetFrameStatisticsX.

La figure 10 montre l’API GetFrameStatisticsX. Ce code se concentre 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 c’est utile. Figure 11. Statistiques d’image : début de l’image.

La figure 11 montre où commence le traitement de l’image dans le pipeline graphique. Figure 12. Statistiques d’image : signalement de l’origine de l’image.

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.

Statistiques d'image : D3D12XBOX_FRAME_EVENT_STATISTICS

La figure 13 montre où les statistiques d’événement d’image deviennent disponibles. Pour plus d’informations, consultez D3D12XBOX_FRAME_EVENT_STATISTICS. Figure 14. Statistiques d’image : requête d’entrée.

La figure 14 montre où se situe la requête d’entrée. La simulation est maintenant prête à s’exécuter. Figure 15. Statistiques d’image : D3D12XBOX_INPUT_STATISTICS.

Statistiques d'image : D3D12XBOX_INPUT_STATISTICS

La figure 15 montre où le jeton de pipeline d’entrée est traité. Pour plus d’informations, consultez D3D12XBOX_INPUT_STATISTICS. Figure 16. Statistiques d’image : la simulation est terminée.

Statistiques d'image : fin de la simulation

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.

Statistiques d'image : fonction 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.

Statistiques d'image : le GPU atteint la dernière transition ResourceBarrier

La figure 19 montre où le GPU atteint la dernière transition ResourceBarrier depuis l’état d’écriture des ressources d’échange utilisées dans PresentX. Figure 20. Statistiques d’image : D3D12XBOX_RENDER_STATISTICS.

Statistiques d'image : D3D12XBOX_RENDER_STATISTICS

La figure 20 montre où le GPU a terminé l’écriture d’après les statistiques de rendu. Pour plus d’informations, consultez D3D12XBOX_RENDER_STATISTICS. Figure 21. Statistiques d’image : déclenchement du GPU.

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ù les informations peuvent être récupérées par le processeur. Pour plus d’informations, consultez D3D12XBOX_PRESENT_STATISTICS. Figure 23. Statistiques d’image : interruption VBLANK.

Statistiques d'image : interruption VBLANK

La figure 23 montre l’interruption VBLANK suivante, 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.

Statistiques d'image : D3D12XBOX_DISPLAY_STATISTICS

La figure 24 montre les statistiques d’affichage. Pour plus d’informations, consultez D3D12XBOX_DISPLAY_STATISTICS. Figure 25. Statistiques d’image : D3D12XBOX_FRAME_INTERVAL_STATISTICS.

Statistiques d'image : D3D12XBOX_FRAME_INTERVAL_STATISTICS

La figure 25 montre les statistiques d’intervalle d’image. Pour plus d’informations, consultez 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.

Affichages réactifs

Les écrans modernes ajoutent une latence supplémentaire pour les raisons suivantes :

La surcharge de transmission, c’est-à-dire 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’indiquer à tous les composants compatibles de passer en mode faible latence. Les écrans qui utilisent ALLM réduisent le traitement d’image afin de minimiser les délais avant de présenter 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 d’actualisation de l’écran sont intrinsèquement liés.

Fréquence d’actualisation de l’écran	Durée de transmission HDMI	Durée du 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 plusieurs fois. Sur un écran 60 Hz, cette saccade peut durer jusqu’à 16,6 ms. Si votre jeu manque un VBLANK sur un écran 120 Hz (en raison de la fréquence d’actualisation plus rapide), la saccade peut être de la moitié de 16,6 ms, soit jusqu’à 8,3 ms. Figure 26. Manquer un VBLANK à 60 Hz et à 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 également plus vite, et la latence ajoutée est considérablement réduite par rapport à un écran 60 Hz.

Jeu à 120 FPS

Grâce aux écrans 120 Hz disponibles, le jeu à 120 FPS est possible sur XBOX Series X|S. Le code suivant montre comment faire passer votre jeu en mode 120 Hz en définissant la durée de l’intervalle d’image sur 8 333 microsecondes.

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 une actualisation fluide de l’écran dans sa plage prise en charge, par exemple de 30 Hz à 120 Hz, plutôt qu’une cadence imposée à 60 Hz. Vous n’avez rien à faire pour utiliser VRR, mais vous pouvez le désactiver dans les situations où une actualisation stable est nécessaire, par exemple dans les menus, les écrans 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 manière fluide des images qui durent environ 4 ms de plus.

Fréquences d’actualisation 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 indiqué précédemment, un VBLANK manqué peut entraîner jusqu’à 16,6 ms de saccade avec 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 temps de retard du VBLANK, plutôt qu’à une durée fixe d’actualisation de l’écran. Figure 27. Manquer un VBLANK avec VRR.

La figure 27 compare le niveau de saccade d’un jeu sur un écran 60 Hz avec celui d’un jeu pour lequel VRR est activé.

Jeu à 40 FPS

Le jeu à 40 FPS est possible avec les écrans 120 Hz. Le système transmet la même image rendue trois fois à la fréquence d’actualisation de 120 Hz. Autrement dit, à 40 FPS, le temps d’image est de 25 ms, et le système transmet cette image trois fois à la fréquence d’actualisation 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 définir la durée de l’intervalle d’image sur 25 000 microsecondes pour un jeu à 40 FPS.

pd3dDevice->SetFrameIntervalX(
        nullptr,
        25000,
        2,
        D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);

Résumé

Les améliorations de la latence des entrées de manette se traduisent par :

Des mises à jour de la manette plus rapides et plus pertinentes.
Une surcharge réduite du système d’exploitation.

Les améliorations de la planification des images se traduisent par :

Un contrôle plus direct de la synchronisation.
De meilleures statistiques d’image et un suivi PIX amélioré pour les entrées et les graphismes.

Les améliorations de la latence de sortie du jeu se traduisent par :

De nouvelles normes d’affichage.
Des fréquences d’actualisation plus rapides.

Pour plus d’informations sur le jeu réactif, consultez les exemples suivants.

Étapes suivantes

Si vous souhaitez consulter les informations des supports de présentation liés à cette vue d’ensemble, téléchargez les fichiers suivants à partir de XBOX Developer Download Secure Data Storage (SDS).

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

Accédez à Téléchargements du Game Development Kit (GDK).
Sous Select file type, sélectionnez Conference Materials, puis Confirm.
Sous Select build/version number, choisissez l’une des présentations graphiques suivantes.
- Xfest 2019 Graphics Track PowerPoints
- Xfest 2019 Graphics Track Videos
Sélectionnez Download Now, puis attendez la fin du téléchargement du fichier .zip.
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

Accédez à Téléchargements du Game Development Kit (GDK).
Sous Select file type, sélectionnez GDK, puis Confirm.
Sous Select build/version number, choisissez l’option Microsoft GDKX (Sample only) la plus récente.
Sélectionnez Download Now, puis attendez la fin du téléchargement du fichier .zip.
Accédez à votre dossier Téléchargements local, puis décompressez (extrayez) les fichiers du dossier compressé.
Sélectionnez GDKSamples > Graphics, puis recherchez l’exemple.

Voir aussi

Rubriques avancées de GameInput (sommaire) Dynamic Latency Input de GameInput Présentation approfondie de la compensation de latence en streaming de jeux Planification et présentation des images sur XBOX One Vues d’ensemble des fonctionnalités graphiques de XBOX Series X|S PIX Intégration PIX

Introduction

Onboarding & Access

Setup & Install

Build Your First Title

Latence de bout en bout

Le problème des entrées de manette en trois étapes

Entrées pertinentes de la manette

Manettes filaires et manettes sans fil

Fréquences d’échantillonnage et phase des entrées de manette

Fonctionnalité Dynamic Latency Input

Améliorations du système

Synchronisation efficace

Cadence des images de PresentX

Planification des images de PresentX

Présentation avec PresentX

Processus pas à pas des statistiques d’image

Affichages réactifs

Mode faible latence automatique

Écrans 120 Hz

Manquer un VBLANK

Jeu à 120 FPS

VRR

Fréquences d’actualisation prises en charge par XBOX Series X|S

Manquer un VBLANK avec VRR

Jeu à 40 FPS

Résumé

Étapes suivantes

Télécharger les présentations Microsoft PowerPoint et les vidéos

Télécharger les exemples pour console du Microsoft Game Development Kit mentionnés dans cet article

Voir aussi

​Latence de bout en bout

​Le problème des entrées de manette en trois étapes

​Entrées pertinentes de la manette

​Manettes filaires et manettes sans fil

​Fréquences d’échantillonnage et phase des entrées de manette

​Fonctionnalité Dynamic Latency Input

​Améliorations du système

​Synchronisation efficace

​Cadence des images de PresentX

​Planification des images de PresentX

​Présentation avec PresentX

​Processus pas à pas des statistiques d’image

​Affichages réactifs

​Mode faible latence automatique

​Écrans 120 Hz

​Manquer un VBLANK

​Jeu à 120 FPS

​VRR

​Fréquences d’actualisation prises en charge par XBOX Series X|S

​Manquer un VBLANK avec VRR

​Jeu à 40 FPS

​Résumé

​Étapes suivantes

​Télécharger les présentations Microsoft PowerPoint et les vidéos

​Télécharger les exemples pour console du Microsoft Game Development Kit mentionnés dans cet article

​Voir aussi

Latence de bout en bout

Le problème des entrées de manette en trois étapes

Entrées pertinentes de la manette

Manettes filaires et manettes sans fil

Fréquences d’échantillonnage et phase des entrées de manette

Fonctionnalité Dynamic Latency Input

Améliorations du système

Synchronisation efficace

Cadence des images de PresentX

Planification des images de PresentX

Présentation avec PresentX

Processus pas à pas des statistiques d’image

Affichages réactifs

Mode faible latence automatique

Écrans 120 Hz

Manquer un VBLANK

Jeu à 120 FPS

VRR

Fréquences d’actualisation prises en charge par XBOX Series X|S

Manquer un VBLANK avec VRR

Jeu à 40 FPS

Résumé

Étapes suivantes

Télécharger les présentations Microsoft PowerPoint et les vidéos

Télécharger les exemples pour console du Microsoft Game Development Kit mentionnés dans cet article

Voir aussi