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.

Le système envoie l’état de la manette au jeu.
Le jeu lit l’information et met à jour la simulation.
Les résultats de la simulation servent au 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, 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.

Entrée de manette pertinente : obtenir l’entrée du joueur le plus rapidement possible.
Synchronisation efficace : traiter les changements de l’état du jeu et effectuer le rendu des résultats le plus efficacement possible.
É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

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.

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 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.

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, 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.

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 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 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.

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’information, consultez 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.

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. 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 à partir de 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 selon les statistiques de rendu. Pour plus d’information, 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ù l’information est disponible pour que le processeur la récupère. Pour plus d’information, consultez D3D12XBOX_PRESENT_STATISTICS. Figure 23. Statistiques d’image : interruption VBLANK.

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.

Statistiques d'image : D3D12XBOX_DISPLAY_STATISTICS

La figure 24 montre les statistiques d’affichage. Pour plus d’information, 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’information, 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.

É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.

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.

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.

É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).

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 aux téléchargements du Game Development Kit (GDK).
Sous Select file type, sélectionnez Conference Materials, puis sélectionnez 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 aux téléchargements du Game Development Kit (GDK).
Sous Select file type, sélectionnez GDK, puis sélectionnez 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 sur GameInput (table des matières) Dynamic Latency Input de GameInput Analyse approfondie de la compensation de latence en diffusion de jeux en continu Planification et présentation des images sur XBOX One Vues d’ensemble des fonctionnalités graphiques 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 d’entrée de manette en trois étapes

Entrée de manette pertinente

Manettes filaires et sans fil

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

Fonctionnalité Dynamic Latency Input

Améliorations du système

Synchronisation efficace

Cadence des images avec PresentX

Planification des images avec PresentX

Présentation avec PresentX

Processus étape par étape des statistiques d’image

Écrans réactifs

Mode faible latence automatique

Écrans 120 Hz

Manquer un VBLANK

Jeu à 120 FPS

VRR

Fréquences de rafraîchissement 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 d’entrée de manette en trois étapes

​Entrée de manette pertinente

​Manettes filaires et sans fil

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

​Fonctionnalité Dynamic Latency Input

​Améliorations du système

​Synchronisation efficace

​Cadence des images avec PresentX

​Planification des images avec PresentX

​Présentation avec PresentX

​Processus étape par étape des statistiques d’image

​Écrans réactifs

​Mode faible latence automatique

​Écrans 120 Hz

​Manquer un VBLANK

​Jeu à 120 FPS

​VRR

​Fréquences de rafraîchissement 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 d’entrée de manette en trois étapes

Entrée de manette pertinente

Manettes filaires et sans fil

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

Fonctionnalité Dynamic Latency Input

Améliorations du système

Synchronisation efficace

Cadence des images avec PresentX

Planification des images avec PresentX

Présentation avec PresentX

Processus étape par étape des statistiques d’image

Écrans réactifs

Mode faible latence automatique

Écrans 120 Hz

Manquer un VBLANK

Jeu à 120 FPS

VRR

Fréquences de rafraîchissement 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