> ## 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. # Construtores de BVH > Construtores de BVH Atualmente, o XDXR utiliza o algoritmo LBVH seguido de reconstrução de treelets para builds de BVH em runtime, e o construtor de BVH Embree para builds de BVH offline. ## Construtor offline O XDXR permite que BVHs sejam construídas offline, opcionalmente compactadas e carregadas do disco em runtime. Isso pode produzir BVHs de maior qualidade para um melhor desempenho de travessia e requer muito menos tempo de GPU em comparação com o construtor de runtime. Atualmente, o construtor de BVH offline oferece suporte apenas a builds de BLAS, incluindo BLASes atualizáveis e BLASes estáticas. Espera-se que um jogo típico construa a maioria das BLASes offline e execute apenas builds de TLAS e atualizações de BLAS durante um quadro em runtime. O construtor offline pode realizar a divisão de triângulos para evitar os custos de triângulos longos, finos e inclinados, que podem ter caixas delimitadoras significativamente maiores do que sua área de superfície. Além disso, ele pode realizar uma melhor "quadificação" de triângulos nos nós folha; consulte a seção "Quads" abaixo. Consulte o exemplo [OfflineRT](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/development-downloads/gdk-samples-list#graphics) para obter informações sobre como construir BVHs offline, bem como sobre serialização, desserialização e compactação de BVHs offline. Além disso, consulte a página [Compactação de BVH do XDXR](/pt-BR/build/core-features/graphics/newfeatures/raytracing/rt-compression) para obter mais detalhes. Observe que as BVHs construídas offline são válidas apenas para a versão do GDK com a qual foram construídas. As BVHs precisarão ser reconstruídas após a atualização de versões do GDK. ## Builds em lote O XDXR oferece suporte a builds de BVH "em lote". Construir ou atualizar várias BVHs em paralelo pode ser de 10 a 25 vezes mais rápido do que fazê-lo sequencialmente. Consulte [BuildRaytracingAccelerationStructureBatched2X](/pt-BR/reference/graphics/d3d12_xs/interfaces/ID3D12GraphicsCommandList6/methods/id3d12graphicscommandlist6_buildraytracingaccelerationstructurebatched2x). Além disso, considere usar computação assíncrona para sobrepor os builds de BVH a cargas de trabalho como sombras. Talvez seja possível compensar todo o custo do build ou habilitar opções adicionais de qualidade de build para uma travessia mais rápida. ## FP16 O teste de interseção de BVH da RDNA2 oferece suporte a dois tipos de nós AABB: variedades de float de 32 bits e de 16 bits. Os nós de caixa FP16 só podem ser usados quando as extensões da AABB estiverem dentro do intervalo representável por FP16. Para permitir mais oportunidades de economia de memória, a geometria pode ser redimensionada por potências de dois para caber no intervalo de FP16. Esse recurso pode ser habilitado com `D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY`. Embora as caixas FP16 sejam menores, elas podem degradar o desempenho da travessia, pois a precisão é reduzida, fazendo com que as AABBs se inflem. Uma heurística de inflação de caixas é usada para determinar quando a inflação é aceitável. Para substituir a heurística padrão, especifique `D3D12XBOX_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_PARAMS1:: FP16BoxInflationThreshold`. Um valor maior que `10.0f` forçará todas as AABBs a usar FP16 e reduzirá alocações pessimistas de BVH. Um valor menor que `1.0f` forçará todas as AABBs a usar FP32. Isso também pode ser obtido especificando `D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE` e não `D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY`. ## TAPU O XDXR compartilha as mesmas práticas recomendadas de desempenho e armadilhas da maioria dos outros construtores de BVH de dois níveis (TLAS + BLAS). Uma área de preocupação comum são caixas delimitadoras de BLAS grandes, cheias de espaço vazio ou com muita interseção com outras instâncias de BLAS. Se duas instâncias tiverem caixas delimitadoras que se cruzam, talvez seja impossível para a travessia determinar a posição de acerto mais próxima sem percorrer ambas as instâncias. Isso fica ainda pior quando mais instâncias se sobrepõem ou quando a origem do raio está dentro das caixas delimitadoras, caso em que nenhuma ordenação pode ser realizada. Exemplos de objetos particularmente ruins são coisas como fios de energia pendurados, que provavelmente têm caixas delimitadoras muito grandes em comparação com o volume da malha original e tendem a cobrir grandes áreas da cena. Outro exemplo é quando vários objetos pequenos são combinados em uma única BLAS: os limites serão estendidos para conter cada malha, mas provavelmente haverá grandes áreas de espaço vazio entre elas. Às vezes, a solução mais adequada para esses problemas é dividir ou combinar objetos durante as fases de criação ou edição de conteúdo. No entanto, isso pode ser difícil ou impossível ao adicionar efeitos de ray tracing a títulos existentes ou em etapas posteriores do pipeline de criação do jogo. Para permitir algum grau de controle nesse caso, o XDXR implementa a opção "TAPU" (TLAS-Pull-Up) em nosso construtor de BVH. Isso permite que o usuário marque instâncias individuais como exigindo "pull-up" para a TLAS. Ao especificar o flag `D3D12XBOX_RAYTRACING_INSTANCE_FLAG_TAPU4` ou `D3D12XBOX_RAYTRACING_INSTANCE_FLAG_TAPU16` em uma desc de instância, o construtor fará o "pull-up" do primeiro (TAPU4) ou do segundo (TAPU16) nível da hierarquia da BLAS diretamente para a TLAS. Isso permite efetivamente dividir uma instância de BLAS grande em 4 ou 16 nós, que podem ser particionados de forma mais eficaz na hierarquia da TLAS, removendo áreas de espaço vazio. Para obter informações sobre "Instance Splitting" ou "Rebraiding", que é uma versão automatizada do TAPU, consulte [D3D12XBOX\_BUILD\_RAYTRACING\_ACCELERATION\_STRUCTURE\_PARAMS3](/pt-BR/reference/graphics/d3d12_xs/structs/d3d12xbox_build_raytracing_acceleration_structure_params3). Além de especificar o flag TAPU, nós extras devem ser alocados na TLAS. Veja um exemplo de código a seguir. ```cpp theme={null} D3D12_RAYTRACING_INSTANCE_DESC desc[3] = {}; // This example enables TAPU4 on every instance, this probably will not help performance, and will have a memory cost. // You'll want a more targeted solution, such as marking up problematic instances manually by name, // or enabling based on world-space-size or volume. for (unsigned i=0; i < _countof(desc); ++i) { desc[i].AccelerationStructure = blas->GetGPUVirtualAddress(); // Use TAPU16 to break up the object by a further level. desc[i].Flags = D3D12XBOX_RAYTRACING_INSTANCE_FLAG_TAPU4; desc[i].InstanceMask = 0xff; desc[i].InstanceContributionToHitGroupIndex = 0; desc[i].Transform[0][0] = desc[i].Transform[1][1] = desc[i].Transform[2][2] = 1.0f; } ComPtr pInstanceDescs; UploadBuffer(desc, sizeof(desc), &pInstanceDescs); // Set special options struct { D3D12XBOX_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_PARAMS1 params1; D3D12XBOX_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_PARAMS2 params2; } options; D3D12XboxMakeDefault_D3D12XBOX_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_PARAMS1(&options.params1); D3D12XboxMakeDefault_D3D12XBOX_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_PARAMS2(&options.params2); // Access via a batched build D3D12XBOX_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_BATCHED_DESC2 tlasBatchedBuild {}; tlasBatchedBuild.NumPostbuildInfoDescs = 0; tlasBatchedBuild.pPostbuildInfoDescs = nullptr; tlasBatchedBuild.ExtraOptions.SizeInBytes = sizeof(options); tlasBatchedBuild.ExtraOptions.pXdxrStreamDesc = &options; // Tell the builder that this is how many outputs slots it can rely on! // This should be the total number of instance nodes in your build. // E.G. instances without a TAPU flag take up 1 element, instances with TAPU4 take up 4 elements, and instances with TAPU16 take up 16 elements. options.params2.NumberOfElementsAllocated = _countof(desc) * 4; D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC buildDesc {}; D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS &topLevelInputs = buildDesc.Inputs; topLevelInputs.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY; topLevelInputs.Flags = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE; // This is the number of instance descs, NOT multiplied by the TAPU factor. topLevelInputs.NumDescs = _countof(desc); topLevelInputs.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL; topLevelInputs.InstanceDescs = pInstanceDescs->GetGPUVirtualAddress(); // Get total size required including additional nodes for TAPU. D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO topLevelPrebuildInfo; m_pDxrDevice->GetRaytracingAccelerationStructurePrebuildInfoX(&topLevelInputs, &tlasBatchedBuild.ExtraOptions, &topLevelPrebuildInfo); ComPtr pScratchResource; ComPtr tlas; AllocateRawUAVBuffer(topLevelPrebuildInfo.ScratchDataSizeInBytes, &pScratchResource); auto tlasPointer = AllocateAccelerationStructureBuffer(topLevelPrebuildInfo.ResultDataMaxSizeInBytes, &tlas); buildDesc.DestAccelerationStructureData = tlasPointer; buildDesc.ScratchAccelerationStructureData = pScratchResource->GetGPUVirtualAddress(); // Make sure the number of incoming instances is clearly communicated! tlasBatchedBuild.Desc = buildDesc; // Build acceleration structure. ((ID3D12GraphicsCommandList6*)m_CommandList.Get())->BuildRaytracingAccelerationStructureBatched2X(1, &tlasBatchedBuild); ``` ## Opções e flags de build Além de oferecer suporte aos flags normais do construtor DXR, como `D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE`, o XDXR oferece uma API para especificar opções adicionais aos construtores de BVH. Consulte [D3D12XBOX\_BUILD\_RAYTRACING\_ACCELERATION\_STRUCTURE\_PARAMS1](/pt-BR/reference/graphics/d3d12_xs/structs/d3d12xbox_build_raytracing_acceleration_structure_params1), [D3D12XBOX\_BUILD\_RAYTRACING\_ACCELERATION\_STRUCTURE\_PARAMS2](/pt-BR/reference/graphics/d3d12_xs/structs/d3d12xbox_build_raytracing_acceleration_structure_params2), [D3D12XBOX\_BUILD\_RAYTRACING\_ACCELERATION\_STRUCTURE\_PARAMS3](/pt-BR/reference/graphics/d3d12_xs/structs/d3d12xbox_build_raytracing_acceleration_structure_params3). Pode ser vantajoso trocar tempo de build da TLAS por desempenho de travessia, especialmente se o build da TLAS puder ser executado em computação assíncrona. Consulte o Exemplo 1 na seção Comentários de [BuildRaytracingAccelerationStructureBatched2X](/pt-BR/reference/graphics/d3d12_xs/interfaces/ID3D12GraphicsCommandList6/methods/id3d12graphicscommandlist6_buildraytracingaccelerationstructurebatched2x) para ver um exemplo de código que aumenta o número de iterações de treelets durante o build da TLAS. Isso pode melhorar significativamente o desempenho da travessia, ao custo de tempos de build da TLAS muito mais longos. ## Quads Os nós folha de BVH do XDXR contêm até dois triângulos. Esses triângulos podem ter dois nós AABB de caixa delimitadora separados ou podem ser combinados em uma única AABB delimitadora e considerados um "quad". Tanto o construtor de runtime quanto o offline podem gerar quads procurando triângulos vizinhos que compartilham uma aresta e têm uma caixa delimitadora combinada dentro de uma inflação de tamanho aceitável em relação à caixa delimitadora individual de cada triângulo. Uma boa "quadificação" é desejável e melhora o uso de memória e o desempenho. O construtor offline consegue produzir mais quads devido a um espaço de pesquisa maior para vizinhos. O construtor de runtime só consegue emparelhar o 1º e o 2º triângulos adjacentes em uma tri-list, não o 2º e o 3º. O visualizador de BVH do PIX descrito em [Visualizador de BVH do PIX](/pt-BR/tools/tools-console/pix/gpu/pix-bvh-viewer) pode exibir estatísticas sobre quads. ## k-DOP Ao construir uma BLAS, construir um k-DOP pode melhorar o desempenho da travessia. Trata-se de trocar memória por desempenho. O k-DOP atua como uma tabela de pesquisa para construir rapidamente AABBs conservadoras de instâncias no espaço do mundo. Consulte a [documentação de k-DOP](/pt-BR/build/core-features/graphics/newfeatures/raytracing/rt-kdop) para obter mais informações. ## Requisitos de memória da BVH Os requisitos de memória da BVH do XDXR são maiores que os de alguns fornecedores de PC. Atualmente, são necessários de 120 a 140 bytes por triângulo, considerando cabeçalho, AABBs, dados de triângulos e metadados. Isso vale para BVHs construídas offline e para BVHs construídas em runtime após a compactação, e é improvável que mude significativamente devido aos formatos de nós do hardware. Para reduzir o tamanho compactado na memória de BLASes construídas com o construtor de runtime, é recomendável usar um index buffer otimizado para "reutilização de cache de vértices". Isso ordenará os triângulos de forma que triângulos consecutivos tenham maior probabilidade de compartilhar uma aresta. Isso facilita a formação de quads, reduzindo tanto a contagem de folhas quanto a de nós internos. Para reduzir o tamanho em disco, consulte [Compactação de BVH do XDXR](/pt-BR/build/core-features/graphics/newfeatures/raytracing/rt-compression). Isso pode proporcionar uma redução de **3,5x a 6,6x** no tamanho em disco e pode ser combinado com ZLIB para reduções adicionais de tamanho. Isso não reduzirá o tamanho na memória. ## Confira também [Compactação de BVH do XDXR](/pt-BR/build/core-features/graphics/newfeatures/raytracing/rt-compression) [D3D12XBOX\_BUILD\_RAYTRACING\_ACCELERATION\_STRUCTURE\_PARAMS1](/pt-BR/reference/graphics/d3d12_xs/structs/d3d12xbox_build_raytracing_acceleration_structure_params1) [D3D12XBOX\_BUILD\_RAYTRACING\_ACCELERATION\_STRUCTURE\_PARAMS2](/pt-BR/reference/graphics/d3d12_xs/structs/d3d12xbox_build_raytracing_acceleration_structure_params2) [D3D12XBOX\_BUILD\_RAYTRACING\_ACCELERATION\_STRUCTURE\_PARAMS3](/pt-BR/reference/graphics/d3d12_xs/structs/d3d12xbox_build_raytracing_acceleration_structure_params3) [BuildRaytracingAccelerationStructureBatched2X](/pt-BR/reference/graphics/d3d12_xs/interfaces/ID3D12GraphicsCommandList6/methods/id3d12graphicscommandlist6_buildraytracingaccelerationstructurebatched2x) [Visão geral de ray tracing (e DXR)](/pt-BR/build/core-features/graphics/newfeatures/raytracing/rt-overview) ## Related topics - [Ray tracing no XBOX Series X|S com XDXR](/pt-BR/build/core-features/graphics/newfeatures/raytracing/index.md) - [Índice de tópicos sob NDA para desenvolvimento de console com o XBOX GDK](/pt-BR/nda/nda-overview.md) - [Diretório de tópicos NDA: links ativos do Microsoft Learn](/pt-BR/nda/nda-topic-directory.md) - [Classe PFEntityKey](/pt-BR/services/playfab/multiplayer/lobby/unity-multiplayer-api-reference/PlayFab.Multiplayer/PFEntityKey/overview.md) - [Notas de versão do PlayFab 2017](/pt-BR/services/playfab/release-notes/2017.md)