> ## 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. # Diferenças do Direct3D 12: PC com Windows vs. Game OS do GDK > Diferenças entre o Direct3D 12 em um PC com Windows e o Game OS do Microsoft GDK O Direct3D 12 no Game OS do Microsoft GDK (Direct3D 12.x) tem algumas diferenças notáveis em relação ao Direct3D 12 no PC com Windows (Direct3D 12/PC). ## Diferenças gerais * O Game OS do Microsoft GDK oferece suporte à serialização/desserialização de objetos de estado de pipeline (PSO) para evitar os custos de construção de PSO em runtime no driver. Essa funcionalidade é a mesma que existia na ERA. O Game OS do Microsoft GDK aceitará shaders pré-compilados, shaders não pré-compilados, shaders derivados e PSOs serializados como entradas válidas. Recomendamos o uso de PSOs serializados para obter velocidade, economia de espaço e melhor controle do usuário. * O XBOX fornece ESRAM, permitindo que buffers e recursos de textura sejam usados na memória mais rápida possível. Maximizar o uso da ESRAM é fundamental para o alto desempenho. Em [Gerenciamento de recursos nativos para XBOX One](/pt-BR/build/core-features/graphics/directx/native-resource-management), confira a subseção "Especificando memória ESRAM rápida para um buffer ou textura" e confira [Visão geral da memória XG](/pt-BR/build/core-features/graphics/d3d12x/xg-memory-overview). * As filas de comandos no Game OS do Microsoft GDK não são thread-safe. É responsabilidade do título sincronizar explicitamente o acesso em threads às filas de comandos de gráficos, computação e cópia/DMA. Não fazer isso pode levar à corrupção dos comandos emitidos na fila e a subsequentes travamentos ou falhas da GPU. * Somente uma fila de comandos de cada tipo pode ser criada no XBOX, a menos que a extensão CreateCommandQueueX seja usada para selecionar explicitamente um pipe/mecanismo e (para computação) um índice de fila para a fila de comandos. Somente uma única fila de comandos de gráficos pode ser criada, independentemente da API usada. Uma fila de computação ou de cópia/DMA pode ser criada por pipe/mecanismo de GPU e índice de fila disponíveis. * As barreiras de recursos do Game OS do Microsoft GDK incentivam o uso amplo das transições D3D12\_RESOURCE\_BARRIER\_FLAG\_BEGIN\_ONLY e D3D12\_RESOURCE\_BARRIER\_FLAG\_END\_ONLY, e é recomendável especificar sinalizadores D3D12XBOX\_RESOURCE\_FLAG\_PREFER\* adicionais na criação de determinados tipos de recursos (confira [D3D12\_RESOURCE\_FLAGS](/pt-BR/reference/graphics/d3d12_x/enums/d3d12_resource_flags)). Confira a seção "Barreiras de recursos" abaixo e [D3D12\_RESOURCE\_BARRIER\_FLAGS](/pt-BR/reference/graphics/d3d12_x/enums/d3d12_resource_barrier_flags). * O Game OS do Microsoft GDK oferece suporte a um modelo de apresentação diferente do sistema de **Present**s de cadeia de troca do Direct3D 12 no PC. Para saber mais sobre o novo modelo de apresentação, confira [Agendamento e apresentação de quadros no XBOX One](/pt-BR/build/core-features/graphics/directx/frame-scheduling-and-presentation). * O Game OS do Microsoft GDK incentiva o acesso a destinos de renderização com várias amostras em um estado compactado para melhorar o desempenho e também incentiva recursos de profundidade/estêncil compactados. Na seção Barreiras de recursos a seguir, confira Trabalhando diretamente com recursos compactados. * O Game OS do Microsoft GDK oferece suporte a várias extensões de hardware específicas da GPU. * As extensões do Direct3D 12.x do Game OS do Microsoft GDK fornecem o seguinte: * Tipos adicionais de heap de descritores * Manipulação direta de descritores * Composição de assinaturas raiz e variantes de difusão * Execução assíncrona de listas de comandos (executar antes de fechar) * É responsabilidade do título garantir que a GPU tenha concluído todo o acesso a um recurso antes de destruí-lo. Um título deve inserir limites (fences) após a conclusão do acesso ao recurso e aguardar que esses limites sejam ultrapassados antes de reduzir as contagens de referência do objeto de recurso a 0. * O Game OS do Microsoft GDK não oferece suporte ao uso do tipo de lista de comandos COPY ([D3D12\_COMMAND\_LIST\_TYPE\_COPY](/pt-BR/reference/graphics/d3d12_x/enums/d3d12_command_list_type)) com a interface padrão [ID3D12GraphicsCommandList](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12graphicscommandlist/id3d12graphicscommandlist). Em vez disso, o Game OS do Microsoft GDK fornece uma interface dedicada para cópia ([ID3D12XboxDmaCommandList](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12xboxdmacommandlist/id3d12xboxdmacommandlist)). Essa interface inclui a funcionalidade de cópia padrão de **ID3D12GraphicsCommandList**, bem como extensões para o hardware do mecanismo DMA do XBOX, como compactação/descompactação LZ e decodificação JPEG. Se você planeja escrever código multiplataforma para listas de comandos de cópia do Direct3D 12, recomendamos usar um `typedef` para a interface da lista de comandos de cópia, que seria definido como **ID3D12XboxDmaCommandList** no Game OS do Microsoft GDK e como **ID3D12GraphicsCommandList** no PC. ## Drivers de varejo, instrumentados e de depuração Com o Gaming eXtensions Development Kit (GXDK), três drivers podem ser usados para ajudar a testar e depurar um título. **Driver de varejo:** otimizado para desempenho, não para instrumentação ou depuração. Não verifica a exatidão dos parâmetros. Parâmetros incorretos passados ao driver de varejo provavelmente causarão corrupção, falhas ou travamentos da GPU. Os títulos só podem ser lançados com o driver de varejo. Os outros drivers (instrumentado e de depuração) estão presentes somente em kits de desenvolvimento. **Driver instrumentado:** habilita a instrumentação do PIX. Razoavelmente leve. Pode ser usado para ajudar a depurar problemas de sincronização e outros problemas de tempo. Não verifica a exatidão dos parâmetros. **Driver de depuração:** executa testes de validação nos parâmetros passados às chamadas de API, o que pode ajudar a depurar problemas de exatidão e desempenho. No entanto, bugs de tempo podem não ser reproduzidos ao usar o driver de depuração, porque o processamento da validação afeta o desempenho em runtime. Para ajustar o nível de validação, chame [ID3D12Device::SetDebugFlagsX](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_setdebugflagsx). Para selecionar qual driver é usado, chame um dos métodos a seguir. * [D3D12XboxSetProcessDebugFlags](/pt-BR/reference/graphics/d3d12_x/functions/d3d12xboxsetprocessdebugflags) * [ID3D12Debug::SetProcessDebugFlags](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12debug/methods/id3d12debug_setprocessdebugflags) * [ID3D12Debug::EnableDebugLayer](https://msdn.microsoft.com/library/windows/desktop/dn986877\(v=vs.85\).aspx) ## Objetos de estado de pipeline (PSOs) offline e derivados Um objeto de estado de pipeline (PSO) offline permite melhorias de desempenho consideráveis em relação à criação do estado de pipeline em runtime, encapsulando o estado de pipeline (incluindo shaders) em um único objeto que pode ser carregado e definido rapidamente. Um PSO offline armazena o estado para shaders pré-compilados, destino de renderização e estêncil de profundidade. Os objetos PSO offline são armazenados em disco e posteriormente carregados pelo aplicativo quando necessário. No PC, existe um sistema semelhante, mas não idêntico, chamado *cache de PSO*. Para criar objetos PSO offline, use a ferramenta PSO (fornecida como um exemplo do Microsoft Game Development Kit (GDK) localizado na pasta `\bin` do GXDK) ou escreva sua própria ferramenta que use as APIs de serialização de estado de pipeline, listadas a seguir. ### APIs para PSOs offline As APIs a seguir manipulam PSOs offline. * [ID3D12Device::SerializeGraphicsPipelineStateX](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_serializegraphicspipelinestatex): este método serializa um PSO como forma de permitir um carregamento eficiente em runtime. Ele deve ser chamado como parte de um processo de criação de conteúdo offline, executado em um PC (com suporte do driver `umd12_pc.dll` ou `xgs12_pc_xs.dll`), e não deve ser chamado em runtime de um título. * [ID3D12Device::DeserializeGraphicsPipelineStateX](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_deserializegraphicspipelinestatex): este método desserializa (carrega) um PSO gráfico serializado anteriormente. Este método nunca invoca a compilação de shaders em runtime, embora, em casos raros, invoque um erro informando que PSOs mais antigos precisam ser recompilados. * [D3D12XBOX\_SERIALIZE\_SHADER](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_serialize_shader): esta struct contém ponteiros para as instruções de GPU do shader serializado e, possivelmente, metadados serializados. * [D3D12XBOX\_DESERIALIZE\_SHADER](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_deserialize_shader): esta struct contém ponteiros para as instruções de GPU brutas do shader desserializado e metadados desserializados. * [D3D12XBOX\_SERIALIZE\_FLAGS](/pt-BR/reference/graphics/d3d12_x/enums/d3d12xbox_serialize_flags): este enum define sinalizadores de serialização. * [D3D12XBOX\_SERIALIZE\_GRAPHICS\_PIPELINE\_STATE](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_serialize_graphics_pipeline_state): esta struct contém o estado de pipeline serializado. * [D3D12XBOX\_DESERIALIZE\_GRAPHICS\_PIPELINE\_STATE](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_deserialize_graphics_pipeline_state): esta struct contém o estado de pipeline desserializado. ### PSOs derivados  Considerando o número de alterações de estado de pipeline maior do que um aplicativo provavelmente exige, não faz sentido criar PSOs offline para cada variação. Em vez disso, crie um PSO offline para um estado básico usado com frequência e, em seguida, use PSOs derivados para fazer modificações limitadas no PSO offline. As modificações feitas no PSO offline não podem envolver alterações no shader ou no destino de renderização. Para um jogo típico, a maioria dos objetos PSO deve ser criada offline, com permutações feitas em runtime usando as APIs a seguir. * [ID3D12Device::CreateDerivedGraphicsPipelineStateX](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_createderivedgraphicspipelinestatex): este método fornece uma forma eficiente de criar uma variação de um PSO gráfico derivada de um PSO gráfico de origem. Este método garante que nenhuma recompilação ou aplicação de patch de shader seja feita como parte do processo de criação. * [D3D12XBOX\_DERIVED\_GRAPHICS\_STATE\_TYPE](/pt-BR/reference/graphics/d3d12_x/enums/d3d12xbox_derived_graphics_state_type): este enum identifica o estado que pode ser alterado (profundidade/estêncil, rasterização, mesclagem e máscara de amostra). * [D3D12XBOX\_DERIVED\_GRAPHICS\_STATE\_DESC](/pt-BR/reference/graphics/d3d12_x/structs/d3d12xbox_derived_graphics_state_desc): esta struct contém as descrições do novo estado necessário. Se o PSO de origem foi criado chamando [ID3D12Device::DeserializeGraphicsPipelineStateX](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_deserializegraphicspipelinestatex), é responsabilidade do aplicativo garantir que as instruções de GPU persistam durante o tempo de vida tanto do objeto original quanto do objeto derivado. Se o PSO de origem foi criado usando o método padrão do Direct3D 12 [ID3D12Device::CreateGraphicsPipelineState](https://msdn.microsoft.com/library/windows/desktop/dn788663%28v=vs.85%29.aspx), o Direct3D 12.x adiciona automaticamente uma contagem de referência ao objeto de origem para garantir que suas instruções de GPU persistam durante o tempo de vida do objeto derivado. ### Exemplos que demonstram PSOs offline e PSOs derivados O exemplo Deferred Context do Direct3D 12.x usa PSOs offline e PSOs derivados. Os exemplos do Direct3D 12.x a seguir usam PSOs offline. * Bokeh Effect * Compute Particles * Deferred Particles * Draw Bundles * Dynamic Cube Map * ESRAM * Mesh Rendering * Simple Bezier * Simple Instancing * Simple Lighting * Simple Triangle Para obter mais informações, confira o tópico [Lista de exemplos do Microsoft Game Development Kit](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/development-downloads/gdk-samples-list). ## Heaps de descritores No PC com Windows, heaps de descritores criados com [D3D12\_DESCRIPTOR\_HEAP\_FLAG\_SHADER\_VISIBLE](https://msdn.microsoft.com/library/windows/desktop/Dn859378\(v=VS.85\).aspx) não podem ser usados como origem para cópias de descritores. No Microsoft Game Development Kit (GDK), as cópias de descritores criadas com [ID3D12Device::CopyDescriptors](https://msdn.microsoft.com/library/windows/desktop/dn899176\(v=vs.85\).aspx) e [ID3D12Device::CopyDescriptorsSimple](https://msdn.microsoft.com/library/windows/desktop/dn899177\(v=vs.85\).aspx) oferecem suporte a todos os heaps de descritores como heap de origem, e a cópia é realizada por meio de uma exibição somente leitura eficiente e armazenada em cache para o heap de origem. ## Criação de recursos Os recursos de argumentos indiretos devem especificar D3D12XBOX\_RESOURCE\_FLAG\_ALLOW\_INDIRECT\_BUFFER no momento da criação do recurso. Os recursos com esse sinalizador devem ser transicionados para o estado de recurso D3D12\_RESOURCE\_STATE\_INDIRECT\_ARGUMENT. D3D12\_RESOURCE\_STATE\_INDIRECT\_ARGUMENT não está incluído no estado de recurso de combinação D3D12\_RESOURCE\_STATE\_GENERIC\_READ no Game OS do Microsoft GDK. No Game OS do Microsoft GDK, D3D12\_RESOURCE\_STATE\_GENERIC\_READ é declarado da seguinte maneira: ```cpp theme={null} D3D12_RESOURCE_STATE_GENERIC_READ = D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER | D3D12_RESOURCE_STATE_INDEX_BUFFER | D3D12_RESOURCE_STATE_COPY_SOURCE | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE ``` Por outro lado, no Direct3D 12/PC, D3D12\_RESOURCE\_STATE\_GENERIC\_READ é declarado de forma a incluir D3D12\_RESOURCE\_STATE\_INDIRECT\_ARGUMENT, além dos valores mencionados anteriormente. Para obter mais informações, confira [D3D12\_RESOURCE\_FLAGS](/pt-BR/reference/graphics/d3d12_x/enums/d3d12_resource_flags) e [D3D12\_RESOURCE\_STATES](/pt-BR/reference/graphics/d3d12_x/enums/d3d12_resource_states). ## Barreiras de recursos Uma barreira de recursos notifica o driver de que pode ser necessária a sincronização de vários acessos a um único recurso, como a sincronização de leitura e gravação na mesma textura. A versão do GXDK do Game OS do Microsoft GDK de [ID3D12GraphicsCommandList::ResourceBarrier](https://msdn.microsoft.com/library/windows/desktop/dn903898\(v=vs.85\).aspx) oferece suporte à combinação dos sinalizadores D3D12\_RESOURCE\_STATE\_COPY\_SOURCE e D3D12\_RESOURCE\_STATE\_COPY\_DEST, para que cópias intrarrecurso sejam suportadas. Cópias intrarrecurso são aquelas em que a origem e o destino estão no mesmo sub-recurso do mesmo recurso. * [APIs para barreiras de recursos](#ID4EFGAC) * [Barreiras de recursos em transições de uso](#ID4EHHAC) * [Trabalhando diretamente com recursos compactados](#ID4EFIAC) * [Barreiras para transição entre estados de uso que incluem e não incluem acesso de gravação](#ID4EQJAC) ### APIs para barreiras de recursos No Game OS do Microsoft GDK, as barreiras de recursos são implementadas chamando os métodos a seguir. * **ID3D12GraphicsCommandList::ResourceBarrier**. Este método notifica o driver de que ele precisa sincronizar vários acessos a recursos. Este método está documentado em detalhes (para uso no PC) no Microsoft Docs: [ID3D12GraphicsCommandList::ResourceBarrier](https://msdn.microsoft.com/library/windows/desktop/dn903898\(v=vs.85\).aspx). Os métodos exclusivos do XBOX de [ID3D12GraphicsCommandList](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12graphicscommandlist/id3d12graphicscommandlist) estão documentados no GDK. * [ID3D12XboxDmaCommandList::ResourceBarrier](/pt-BR/reference/graphics/d3d12_x/interfaces/id3d12xboxdmacommandlist/methods/id3d12xboxdmacommandlist_resourcebarrier) ### Barreiras de recursos em transições de uso No PC com Windows, as barreiras de recursos podem executar ociosidades conservadoras da GPU e liberação/invalidação de caches. Por outro lado, no Game OS do Microsoft GDK, as barreiras de recursos executam sincronização, invalidação e descompactação conservadoras em transições de uso. Como parte dessa diferença, há sinalizadores de criação de recursos específicos do XBOX recomendados, mas não essenciais. * D3D12XBOX\_RESOURCE\_FLAG\_PREFER\_INDEX\_BUFFER * D3D12XBOX\_RESOURCE\_FLAG\_PREFER\_INDIRECT\_BUFFER * D3D12XBOX\_RESOURCE\_FLAG\_PREFER\_PREDICATION\_BUFFER * D3D12XBOX\_RESOURCE\_FLAG\_PREFER\_STREAM\_OUTPUT * D3D12XBOX\_RESOURCE\_FLAG\_DENY\_COMPRESSION\_DATA Esses sinalizadores são extensões do Direct3D 12.x do Game OS do Microsoft GDK, como constantes da enumeração [D3D12\_RESOURCE\_FLAGS](/pt-BR/reference/graphics/d3d12_x/enums/d3d12_resource_flags). ### Trabalhando diretamente com recursos compactados Os tipos de uso de recursos a seguir inibem a descompactação em transições de barreira de recursos e permitem que os recursos sejam consumidos em um estado compactado. * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_COMPRESSED\_COLOR * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_COMPRESSED\_DEPTH * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_COMPRESSED\_STENCIL * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_COMPRESSED\_DEPTH\_STENCIL * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_INDIRECT\_COLOR\_CLEAR * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_SCATTERED\_COLOR\_FMASK Há um conjunto correspondente de sinalizadores PRESERVE\_EXPANDED que, como contrapartes dos sinalizadores PRESERVE\_COMPRESSED, servem para manter os recursos em um estado descompactado após uma transição que normalmente reabilitaria a compactação neles. * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_EXPANDED\_COLOR * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_EXPANDED\_DEPTH * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_EXPANDED\_STENCIL * D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_EXPANDED\_DEPTH\_STENCIL Por exemplo, D3D12XBOX\_RESOURCE\_STATE\_PRESERVE\_EXPANDED\_COLOR pode ser usado ao alternar de um estado de leitura em um recurso com várias amostras para um estado D3D12\_RESOURCE\_STATE\_RENDER\_TARGET, como forma de impedir que novas gravações no destino sejam armazenadas compactadas. Ambos os conjuntos de sinalizadores são extensões do Direct3D 12.x do Game OS do Microsoft GDK, como constantes da enumeração [D3D12\_RESOURCE\_STATES](/pt-BR/reference/graphics/d3d12_x/enums/d3d12_resource_states) específicas do Game OS do Microsoft GDK. ### Barreiras para transição entre estados de uso que incluem e não incluem acesso de gravação No Game OS do Microsoft GDK, a abordagem recomendada para executar transições de barreira, além da abordagem do Direct3D 12/PC, é identificar as barreiras que envolvem a transição de estados de uso que incluem acesso de gravação para estados de uso que não incluem acesso de gravação. Essas barreiras, quando executadas em D3D12\_RESOURCE\_BARRIER\_ALL\_SUBRESOURCES, devem ser divididas em uma barreira dividida, com uma chamada BEGIN\_ONLY e uma END\_ONLY, quando houver trabalho de GPU independente disponível para execução, da seguinte maneira. 1. D3D12\_RESOURCE\_BARRIER\_FLAG\_BEGIN\_ONLY é usado para iniciar uma transição de barreira para um novo estado (mas não concluí-la), colocando o recurso em uma condição temporária sem acesso. 2. Adicione o trabalho independente à lista de comandos. 3. D3D12\_RESOURCE\_BARRIER\_FLAG\_END\_ONLY é usado em uma chamada **ResourceBarrier** subsequente para concluir a transição e passar da condição temporária sem acesso e do estado antigo para o acesso ativo no novo estado. Os sinalizadores BEGIN/END podem ser usados com o tipo [D3D12\_RESOURCE\_BARRIER\_TYPE\_UAV](https://msdn.microsoft.com/library/windows/desktop/Dn770393\(v=VS.85\).aspx). D3D12\_RESOURCE\_BARRIER\_ALL\_SUBRESOURCES, mencionado anteriormente, é um valor `#define` para o Direct3D 12.x e o Direct3D 12/PC. Confira [D3D12\_RESOURCE\_BARRIER\_FLAGS](/pt-BR/reference/graphics/d3d12_x/enums/d3d12_resource_barrier_flags). ## Diferenças de alinhamento O alinhamento do passo de linha (row pitch) no Game OS do Microsoft GDK é de 1024 bytes, e não de 512 bytes como no PC (isso é definido configurando D3D12XBOX\_TEXTURE\_DATA\_PITCH\_ALIGNMENT como 1024). Além disso, o requisito do PC de que os buffers sejam alinhados a 64 KB/4 MB não se aplica ao XBOX, embora o código de validação ainda possa mostrar um erro se esses alinhamentos não forem respeitados. O alinhamento padrão para buffers de constantes é de 16 bytes, em vez dos 256 bytes no PC. Esse alinhamento é especificado pela constante D3D12\_CONSTANT\_BUFFER\_DATA\_PLACEMENT\_ALIGNMENT. ## Confira também [d3d12x](/pt-BR/reference/graphics/d3d12_x/d3d12_x_members) ## Related topics - [Guia de programação do Direct3D 12](/pt-BR/build/gdk-and-engines/guides/directx-12-programming-guide.md) - [Advanced Shader Delivery](/pt-BR/build/gdk-and-engines/guides/advanced-shader-delivery.md) - [Diretório de tópicos NDA: links ativos do Microsoft Learn](/pt-BR/nda/nda-topic-directory.md) - [Compile e execute seu primeiro título de console com o GDKX](/pt-BR/home/build-first-title/first-console-title-walkthrough.md) - [Desenvolva um novo título GDK](/pt-BR/home/build-first-title/developing-new-titles.md)