> ## 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.
# Jogos responsivos
> Jogos responsivos
Este tópico descreve como gerenciar a latência de ponta a ponta do seu jogo para garantir uma experiência de jogo responsiva.
Estas informações eram atuais em novembro de 2019. Vários recursos podem ter sido alterados ou atualizados desde então.
## Latência de ponta a ponta
Os jogadores percebem a latência como o tempo entre o momento em que pressionam um botão no controle e o momento em que algo acontece na tela.
**Figura 1. Capacidade de detectar latência.**
A Figura 1 mostra os resultados de um estudo de detecção de latência. Quando ela chegou a 175 ms, todos os participantes conseguiram detectá-la. Em 75 ms, pouco mais da metade dos participantes conseguiu detectá-la. Abaixo de 75 ms, detectá-la torna-se cada vez mais difícil. Com latência de 60 ms, alguns participantes conseguiram detectá-la. Um jogo com latência de 60 ms é definido como responsivo.
**Figura 2. Como um quadro é criado.**
A Figura 2 mostra uma simplificação de como um quadro é criado.
1. O sistema envia o estado do controle para o jogo.
2. O jogo lê as informações e atualiza a simulação.
3. Os resultados da simulação renderizam um novo quadro.
4. O sistema envia o quadro recém-renderizado para a tela.
**Figura 3. Áreas de possível latência.**
A Figura 3 mostra áreas em que pode ocorrer latência que torna seu jogo não responsivo.
**Figura 4. Condições ideais.**
A Figura 4 mostra que, idealmente, a entrada do controle é lida o mais próximo possível da etapa de simulação ao renderizar para a tela. O sistema rastreia quando o quadro foi enviado e quando chegou à tela.
### O problema de entrada do controle em três etapas
O problema de entrada do controle se divide nas etapas a seguir.
1. Entrada relevante do controle: obter a entrada do jogador o mais rápido possível.
2. Temporização eficaz: processar as alterações no estado do jogo e renderizar os resultados da forma mais eficiente possível.
3. Telas responsivas: desenhar a tela do jogador o mais rápido possível.
## Entrada relevante do controle
Os controles melhoraram e estão se tornando mais complexos. Essa complexidade adicionou latência ao longo do tempo. Os controles adicionam latência devido aos seguintes problemas.
* Transmissão sem fio:
* Tráfego
* Confiabilidade dos dados
* Sobrecarga de interface:
* Gerenciamento de dispositivos
* Segurança
* Sobrecarga do sistema/SO:
* Identificação
* Análise
* Apresentação
### Controles com fio vs. sem fio
A maioria dos controles XBOX é usada sem fio. No entanto, esse uso tem os seguintes problemas potenciais.
* O controle pode compartilhar o espectro sem fio com outros dispositivos, como um telefone.
* Como os controles sem fio exigem baterias, o consumo delas representa um desafio.
* Dados podem ser perdidos. Os jogos precisam levar em conta a transmissão atrasada.
* A sobrecarga do controle com fio adiciona apenas 1 ms de latência devido à sondagem USB rápida.
* A sobrecarga do controle sem fio pode adicionar até 3 ms de latência.
### Taxas de amostragem e defasagem da entrada do controle
As taxas de amostragem também podem causar problemas quando a entrada amostrada fica fora de fase em relação ao seu jogo.
**Figura 5. Taxas de amostragem e defasagem da entrada.**
A Figura 5 mostra um exemplo de um controle que coleta amostras a 125 Hertz. Isso garante que haverá duas leituras do controle em um único quadro. No entanto, essa amostragem também resulta em lacunas nas quais você pode obter uma leitura antes do desejado. Em outros momentos, você pode obter uma leitura depois. Na Figura 5, a latência varia de forma inconsistente de 0 ms a 8 ms.
Soluções em que o controle faz a sondagem na velocidade máxima têm seu próprio conjunto de problemas.
* Uso da bateria: fazer a sondagem mil vezes por segundo esgota rapidamente a bateria.
* Maior sobrecarga da CPU: todas as entradas de dados sondadas precisam ser analisadas e processadas.
### Recurso Dynamic Latency Input
Em vez da abordagem de sondagem maximizada, use o Dynamic Latency Input, também conhecido como *Entrada sincronizada*. Esse recurso otimiza automaticamente a temporização da entrada do controle e faz o seguinte:
* Monitora a cadência das consultas de entrada.
* Monitora o desempenho com fio e sem fio.
* Garante que a entrada mais recente seja analisada e esteja disponível quando for solicitada.
* Rastreia os tempos de apresentação dos quadros renderizados.
* Mantém um nível de "confiança" com base na cadência das consultas de entrada, no desempenho com fio/sem fio e nos tempos de apresentação.
* Fornece o nível de confiança no PIX para investigações de desempenho.
Use o nível de confiança para decidir se deseja habilitar ou desativar esse recurso.
Além disso, sinalize manualmente leituras importantes ou desative esse recurso. Ele está disponível somente no XBOX Series X|S.
### Melhorias do sistema
Houve várias alterações no sistema que ajudam na capacidade de resposta da entrada e na latência geral. Elas incluem o seguinte:
* Um novo design baseado em acesso direto à memória (DMA) para minimizar o envolvimento do SO.
* Uma API `GameInput` que coleta informações históricas de dispositivos de entrada conectados.
* Os pressionamentos de botão do controle com fio causam atualizações. O Dynamic Latency Input ainda é útil para entradas analógicas.
* Maior resiliência dos dados sem fio.
* Rastreia a temporização em relação ao tempo de quadro gráfico.
As metas definidas para a latência de entrada são as seguintes.
* Uma redução de mais de 50% na latência de entrada sem fio.
* Uma redução de mais de 75% na latência de entrada com fio.
* Uma latência média de entrada do controle com fio de cerca de 1 ms.
## Temporização eficaz
**Figura 6. Cadência de quadros.**
A Figura 6 mostra como os quadros são gerados enquanto são executados em paralelo com outros quadros que estão sendo processados.
**Figura 7. Tempo do intervalo de quadros.**
A Figura 7 mostra o tempo do intervalo de quadros. A duração do *intervalo de quadros* determina a frequência de apresentação e especifica a taxa na qual os quadros são renderizados e enviados para a tela.
**Figura 8. Período de quadros.**
A Figura 8 mostra o *período de quadros* com um valor de 2. Isso significa que o quadro começou em um intervalo e terminou no intervalo seguinte.
### Cadência de quadros do [PresentX](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12commandqueue/methods/id3d12commandqueue_presentx)
`PresentX` altera a cadência de quadros abstraindo a expressão da frequência de renderização e de apresentação.
Antes, o tempo de quadro era baseado na taxa de atualização da tela (VSync). Isso se torna complicado com as telas atuais, pois suas taxas de atualização mudam com um recurso como a taxa de atualização variável (VRR). Além disso, o período de quadros era calculado antes como uma função indireta da contagem da cadeia de troca do jogo.
Por outro lado, `PresentX` usa a duração de tempo para calcular o tempo de quadro e uma profundidade de pipeline definida para o período de quadros.
**Figura 9. Cadência de quadros do PresentX: visando 60 Hz.**
A Figura 9 mostra uma cadência de quadros simplificada do `PresentX` que visa uma taxa de quadros de 60 Hz.
O exemplo de código a seguir mostra a API [SetFrameIntervalX](/pt-BR/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)
```
O código `SetFrameIntervalX` usado na Figura 9 é o seguinte.
```cpp theme={null}
pd3dDevice->SetFrameIntervalX(
nullptr,
16667, //D3D12XBOX_FRAME_INTERVAL_60_HZ
2,
D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);
```
No exemplo de código, observe o seguinte:
* `LengthInMicroseconds` é definido como 16.667 microssegundos.
* `PeriodInIntervals` é definido como 2.
* Os intervalos de quadros comuns têm suas próprias definições. Neste exemplo, a definição é D3D12XBOX\_FRAME\_INTERVAL\_60\_HZ.
### Agendamento de quadros do PresentX
`PresentX` oferece controle formal sobre a limitação da CPU. Usar o agendamento de quadros em cada quadro ajusta a temporização para que seus intervalos fiquem mais próximos. Com `PresentX`, você declara explicitamente sua espera. A limitação implícita em tempo de execução feita pelo driver gráfico em `Present` deixou de existir.
Você tem um agendamento baseado em eventos e orientado por interrupções para a produção de novos quadros para exibição. Defina o tempo de origem do quadro em um intervalo de quadros e faça atualizações contínuas da origem com base na carga de trabalho a partir das estatísticas.
O exemplo de código a seguir mostra a API [ScheduleFrameEventX](/pt-BR/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)
```
O código `ScheduleFrameEventX` usado na Figura 9 é o seguinte.
```cpp theme={null}
pd3dDevice->ScheduleFrameEventX(
D3D12XBOX_FRAME_EVENT_ORIGIN,
5556,
nullptr,
D3D12XBOX_SCHEDULE_FRAME_EVENT_FLAG_NONE);
```
Chame ID3D12Device::ScheduleFrameEventX para estabelecer o momento, dentro de um intervalo de quadros, em que a CPU será limitada. Especifique um Type de D3D12XBOX\_FRAME\_EVENT\_ORIGIN e um deslocamento de tempo IntervalOffsetInMicroseconds para agendar o evento de origem dos quadros. A CPU é limitada até que o tempo IntervalOffsetInMicroseconds especificado dentro do intervalo tenha decorrido.
Agora que existe um evento que é disparado quando o quadro começa, faça a sondagem ou o bloqueio no evento `ORIGIN` do pipeline desse quadro. O token de pipeline que identifica o quadro agora é criado por `WaitFrameEventX`. Esse token é repassado para `PresentX`.
O exemplo de código a seguir mostra a API [WaitFrameEventX](/pt-BR/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)
```
No exemplo da Figura 9, o código `WaitFrameEventX` é o seguinte.
```cpp theme={null}
pd3dDevice->WaitFrameEventX(
D3D12XBOX_FRAME_EVENT_ORIGIN,
0,
nullptr,
D3D12XBOX_WAIT_FRAME_EVENT_FLAG_NONE,
&token);
```
Este código de exemplo mostra que o tempo limite está definido como 0. O token de pipeline aparece no final.
### Apresentação do PresentX
Um novo recurso da API `PresentX` é a possibilidade de latência com buffer duplo, mesmo que a renderização com buffer triplo esteja configurada. Isso significa que, embora você possa configurar o buffer triplo, se os quadros forem concluídos a tempo, o buffer duplo será mantido até que você exceda o tempo de quadro e precise de três buffers de quadro.
Essa chamada exige o [D3D12XBOX\_FRAME\_PIPELINE\_TOKEN](/pt-BR/reference/graphics/d3d12_x/enums/d3d12xbox_frame_pipeline_token) como parte de `D3D12XBOX_PRESENT_PLANE_PARAMETERS` para rastrear a latência de ponta a ponta. `PresentX` também dá suporte à apresentação a partir de filas de computação assíncrona.
Para obter mais informações, confira a apresentação do Xfest 19 sobre Portabilidade de gráficos para o XBOX Series X|S.
### Processo passo a passo das estatísticas de quadros
**Figura 10. GetFrameStatisticsX.**
A Figura 10 mostra a API `GetFrameStatisticsX`.
Este código se concentra no seguinte:
* `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`
Esse processo começa com um quadro, mostra onde ele é usado e, em seguida, mostra por que ele é valioso.
**Figura 11. Estatísticas de quadros: o quadro começa.**
A Figura 11 mostra onde o quadro começa a ser processado no pipeline gráfico.
**Figura 12. Estatísticas de quadros: origem do quadro sinalizada.**
A Figura 12 mostra DE onde o `ORIGIN` do quadro é sinalizado e quando `WaitFrameEventX` é chamado.
**Figura 13. Estatísticas de quadros: D3D12XBOX\_FRAME\_EVENT\_STATISTICS.**
A Figura 13 mostra onde as estatísticas de eventos de quadro ficam disponíveis. Para obter mais informações, confira [D3D12XBOX\_FRAME\_EVENT\_STATISTICS](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_frame_event_statistics).
**Figura 14. Estatísticas de quadros: consulta da entrada.**
A Figura 14 mostra onde ocorre a consulta da entrada. A simulação agora está pronta para ser executada.
**Figura 15. Estatísticas de quadros: D3D12XBOX\_INPUT\_STATISTICS.**
A Figura 15 mostra onde o token de pipeline de entrada é processado.
Para obter mais informações, confira [D3D12XBOX\_INPUT\_STATISTICS](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_input_statistics).
**Figura 16. Estatísticas de quadros: a simulação foi concluída.**
A Figura 16 mostra quando a simulação é concluída.
**Figura 17. Estatísticas de quadros: renderização do quadro.**
A Figura 17 mostra onde a CPU começa a gravar e executar as listas de comandos para renderizar o quadro. Em seguida, a GPU começa a processar as listas de comandos para renderizar o quadro.
**Figura 18. Estatísticas de quadros: PresentX.**
A Figura 18 mostra a chamada `PresentX` quando a CPU termina de renderizar o quadro.
**Figura 19. Estatísticas de quadros: a GPU atinge a última transição de ResourceBarrier.**
A Figura 19 mostra onde a GPU atinge a última transição de [ResourceBarrier](/pt-BR/reference/graphics/d3d12/interfaces/id3d12graphicscommandlist/methods/id3d12graphicscommandlist_resourcebarrier_public) a partir do estado de gravação dos recursos de troca usados em `PresentX`.
**Figura 20. Estatísticas de quadros: D3D12XBOX\_RENDER\_STATISTICS.**
A Figura 20 mostra onde a GPU conclui a gravação de acordo com as estatísticas de renderização. Para obter mais informações, confira [D3D12XBOX\_RENDER\_STATISTICS](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_render_statistics).
**Figura 21. Estatísticas de quadros: GPU acionada.**
A Figura 21 mostra onde a GPU é acionada para apresentar.
**Figura 22. Estatísticas de quadros: D3D12XBOX\_PRESENT\_STATISTICS.**
A Figura 22 mostra as estatísticas de apresentação no final da renderização da GPU e quando as informações ficam disponíveis para a CPU recuperar. Para obter mais informações, confira [D3D12XBOX\_PRESENT\_STATISTICS](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_present_statistics).
**Figura 23. Estatísticas de quadros: interrupção de VBLANK.**
A Figura 23 mostra a próxima interrupção de VBLANK, que coincide com o final do intervalo de quadros. Os recursos de troca apresentados são invertidos para a tela.
**Figura 24. Estatísticas de quadros: D3D12XBOX\_DISPLAY\_STATISTICS.**
A Figura 24 mostra as estatísticas de exibição. Para obter mais informações, confira [D3D12XBOX\_DISPLAY\_STATISTICS](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_display_statistics).
**Figura 25. Estatísticas de quadros: D3D12XBOX\_FRAME\_INTERVAL\_STATISTICS.**
A Figura 25 mostra as estatísticas de intervalo de quadros. Para obter mais informações, confira [D3D12XBOX\_FRAME\_INTERVAL\_STATISTICS](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_frame_interval_statistics).
Esse processo fornece dados de latência acionáveis, de quadro a quadro, para que você possa ajustar e diminuir o intervalo de tempo entre o momento em que o jogador pressiona um botão no controle e o momento em que algo acontece na tela.
## Telas responsivas
As telas modernas adicionam latência extra devido ao seguinte:
* Sobrecarga de transmissão ou o tempo necessário para receber dados do cabo HDMI.
* O tempo necessário para processar imagens 4K ou maiores, incluindo aprimoramentos de imagem específicos do fabricante.
* O tempo necessário para dimensionar uma imagem para a resolução nativa da tela.
* O tempo necessário para desenhar o quadro na tela.
* O tempo necessário para desenhar sobreposições de menus, controles de volume ou qualquer outra coisa que o jogador possa precisar para controlar a tela.
### Modo automático de baixa latência
O modo automático de baixa latência (ALLM) é um recurso definido na especificação HDMI 2.1. O ALLM permite que a fonte de vídeo (nestes exemplos, o console XBOX) instrua todos os componentes compatíveis a entrar no modo de baixa latência. As telas que usam ALLM reduzem o processamento de imagem para minimizar atrasos antes de apresentar a imagem. Esse é um recurso no nível do sistema, semelhante ao VRR. Você não precisa fazer nada, mas os jogadores precisam garantir que o ALLM esteja habilitado nas configurações de Tela do console. Esse recurso tem suporte no XBOX One e no XBOX Series X|S.
### Telas de 120 Hz
O XBOX dá suporte a telas de 120 Hz. Há benefícios para jogos de 60 quadros por segundo (FPS), pois a taxa de transmissão HDMI e a taxa de atualização da tela estão intrinsecamente associadas.
| Taxa de atualização da tela | Tempo de transmissão HDMI | Duração do VBLANK | Total |
| - | - | - | - |
| 60 Hz | 16 ms | 0,67 ms | 16,67 ms |
| 120 Hz | 8 ms | 0,33 ms | 8,33 ms |
| Diferença | 8 ms | 0,33 ms | 8,33 ms |
### Perda de um VBLANK
Se o seu jogo perder um VBLANK, o jogador provavelmente o perceberá como uma travada, pois o mesmo quadro renderizado é exibido mais de uma vez. Em uma tela de 60 Hz, essa travada pode durar até 16,6 ms. Se o seu jogo perder um VBLANK em uma tela de 120 Hz (devido à taxa de atualização mais rápida da tela), a travada poderá ser metade de 16,6 ms, ou até 8,3 ms.
**Figura 26. Perda de um VBLANK a 60 Hz vs. 120 Hz.**
A Figura 26 compara a perda de um VBLANK a 60 Hz e a 120 Hz. Quando um VBLANK é perdido, ocorre uma travada e um quadro de latência é adicionado. Em uma tela de 120 Hz, os VBLANKs ocorrem mais rapidamente. O próximo quadro também é mais rápido, e a quantidade de latência adicionada é bastante reduzida em comparação com uma tela de 60 Hz.
### Jogos a 120 FPS
Com telas de 120 Hz disponíveis, jogos a 120 FPS são uma possibilidade no XBOX Series X|S. O código a seguir mostra como colocar seu jogo no modo de 120 Hz definindo o tempo do intervalo de quadros como 8.333 microssegundos.
```cpp theme={null}
pd3dDevice->SetFrameIntervalX(
nullptr,
8333, //D3D12XBOX_FRAME_INTERVAL_120_HZ
2,
D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);
```
### VRR
O VRR é um recurso definido no HDMI 2.1. Use o VRR para uma atualização contínua da tela dentro do intervalo com suporte; por exemplo, de 30 Hz a 120 Hz, em vez de uma cadência forçada de 60 Hz. Você não precisa fazer nada para usar o VRR, embora ele possa ser desativado em situações em que uma atualização estável é necessária; por exemplo, em menus, cenas de carregamento ou cinemáticas. Atualmente, o XBOX dá suporte a HDMI VRR e AMD FreeSync. O XBOX One dá suporte ao intervalo de 40-60 Hz, mas as telas podem ter diferentes recursos de VRR. Na prática, o sistema consegue apresentar suavemente quadros que se estendem por cerca de 4 ms a mais.
### Taxas de atualização com suporte no XBOX Series X|S
* 120 Hz
* 60 Hz
* 40 Hz
* 30 Hz
* 20 Hz
* 15 Hz
### Perda de um VBLANK com VRR
Conforme mencionado anteriormente, um VBLANK perdido pode causar até 16,6 ms de travada em uma tela de 60 Hz e até 8,3 ms de travada em uma tela de 120 Hz. No entanto, com o VRR, nenhuma travada é observada, pois o VBLANK da tela é atrasado até que o quadro renderizado seja concluído. A única latência extra é o tempo pelo qual o VBLANK foi atrasado, em vez de um tempo fixo de atualização da tela.
**Figura 27. Perda de um VBLANK com VRR.**
A Figura 27 compara a quantidade de travadas em um jogo com uma tela de 60 Hz com um jogo que tem o VRR habilitado.
### Jogos a 40 FPS
Jogos a 40 FPS são possíveis com telas de 120 Hz. O sistema transmitirá o mesmo quadro renderizado três vezes na taxa de atualização de 120 Hz. Em outras palavras, a 40 FPS, o tempo de quadro é de 25 ms, e o sistema transmitirá esse quadro três vezes na taxa de atualização de 8,3 ms - 25 ms. Recomendamos que você dê suporte a jogos a 40 FPS, pois a latência é reduzida em 8,3 ms em comparação com 30 FPS.
O exemplo de código a seguir mostra como definir o tempo do intervalo de quadros como 25.000 microssegundos para jogos a 40 FPS.
```cpp theme={null}
pd3dDevice->SetFrameIntervalX(
nullptr,
25000,
2,
D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);
```
## Resumo
As melhorias na latência de entrada do controle resultam em:
* Atualizações do controle mais rápidas e mais relevantes.
* Menor sobrecarga do SO.
As melhorias no agendamento de quadros resultam em:
* Controle mais direto da temporização.
* Melhores estatísticas de quadros e rastreamento aprimorado no PIX para entrada e gráficos.
As melhorias na latência de saída do jogo resultam em:
* Novos padrões de tela.
* Taxas de atualização mais rápidas.
Para obter mais informações sobre jogos responsivos, confira os exemplos a seguir.
* [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)
## Próximas etapas
Se quiser revisar as informações dos materiais da apresentação relacionados a esta visão geral, baixe os seguintes arquivos do [XBOX Developer Download Secure Data Storage (SDS)](https://www.microsoft.com/en-us/software-download/gdk).
* Apresentação de slides: XF2019\_Graphics\_04\_Day1\_Responsive\_Gaming.pptx em Xfest 2019 Graphics Track PowerPoints (\[2019.11]-Xfest2019GraphicsTrackPowerPoints.ZIP)
* Apresentação em vídeo: XF2019\_Graphics\_04\_Day1\_Responsive\_Gaming.mp4 em Xfest 2019 Graphics Track Videos (\[2019.11]-Xfest2019GraphicsTrackVideos.ZIP)
### Baixar as apresentações e os vídeos do Microsoft PowerPoint
1. Acesse [Downloads do Game Development Kit (GDK)](https://www.microsoft.com/en-us/software-download/gdk).
2. Em Select file type, selecione **Conference Materials** e, em seguida, selecione **Confirm**.
3. Em Select build/version number, escolha uma das seguintes apresentações de gráficos.
* Xfest 2019 Graphics Track PowerPoints
* Xfest 2019 Graphics Track Videos
4. Selecione Download Now e aguarde a conclusão do download do arquivo .zip.
5. Acesse sua pasta local Downloads e descompacte (extraia) os arquivos da pasta compactada.
### Baixar os exemplos de console do Microsoft Game Development Kit mencionados neste artigo
1. Acesse [Downloads do Game Development Kit (GDK)](https://www.microsoft.com/en-us/software-download/gdk).
2. Em Select file type, selecione **GDK** e, em seguida, selecione **Confirm**.
3. Em Select build/version number, escolha a opção **Microsoft GDKX (Sample only)** mais recente.
4. Selecione Download Now e aguarde a conclusão do download do arquivo .zip.
5. Acesse sua pasta local Downloads e descompacte (extraia) os arquivos da pasta compactada.
6. Selecione **GDKSamples** > **Graphics** e procure o exemplo.
## Confira também
[Tópicos avançados do GameInput (conteúdo)](/pt-BR/build/core-features/common/input/advanced/input-advanced-topics)
[Dynamic Latency Input do GameInput](/pt-BR/build/core-features/common/input/advanced/input-synchronization)
[Análise detalhada da compensação de latência do streaming de jogos](/pt-BR/build/core-features/common/game-streaming/game-streaming-latency-compensation-deep-dive)
[Agendamento e apresentação de quadros no XBOX One](/pt-BR/build/core-features/graphics/directx/frame-scheduling-and-presentation)
[Visões gerais dos recursos gráficos do XBOX Series X|S](/pt-BR/build/core-features/graphics/graphics-newfeatures-toc)
[PIX](/pt-BR/tools/tools-console/pix/pix)
[Integração com o PIX](/pt-BR/tools/tools-console/pix/pix-input-sync)
## Related topics
- [Xfest2019](/pt-BR/build/core-features/graphics/overviews/presentations/xfest2019/index.md)
- [Requisitos do XBOX para jogos do XBOX](/pt-BR/publishing/certification/xbox-requirements.md)
- [Requisitos XBOX testados na certificação para jogos XBOX](/pt-BR/publishing/certification/console-cert-tested-requirements.md)
- [XR-001 Estabilidade do título](/pt-BR/publishing/certification/xr/xr-001.md)
- [Estatísticas com PlayStream e telemetria](/pt-BR/services/playfab/player-progression/statistics/statistics-with-playstream-and-telemetry.md)