Método ID3D12GraphicsCommandList::ExecuteIndirect (d3d12.h)

Artigo
08/23/2023

Os aplicativos executam sorteios/expedições indiretos usando o método ExecuteIndirect .

Sintaxe

void ExecuteIndirect(
  [in]           ID3D12CommandSignature *pCommandSignature,
  [in]           UINT                   MaxCommandCount,
  [in]           ID3D12Resource         *pArgumentBuffer,
  [in]           UINT64                 ArgumentBufferOffset,
  [in, optional] ID3D12Resource         *pCountBuffer,
  [in]           UINT64                 CountBufferOffset
);

Parâmetros

[in] pCommandSignature

Tipo: ID3D12CommandSignature*

Especifica um ID3D12CommandSignature. Os dados referenciados por pArgumentBuffer serão interpretados dependendo do conteúdo da assinatura de comando. Consulte Desenho Indireto para as APIs usadas para criar uma assinatura de comando.

[in] MaxCommandCount

Tipo: UINT

Há duas maneiras pelas quais as contagens de comandos podem ser especificadas:

Se pCountBuffer não for NULL, MaxCommandCount especificará o número máximo de operações que serão executadas. O número real de operações a serem executadas é definido pelo mínimo desse valor e um inteiro sem sinal de 32 bits contido em pCountBuffer (no deslocamento de bytes especificado por CountBufferOffset).
Se pCountBuffer for NULL, MaxCommandCount especificará o número exato de operações que serão executadas.

[in] pArgumentBuffer

Tipo: ID3D12Resource*

Especifica um ou mais objetos ID3D12Resource , contendo os argumentos de comando.

[in] ArgumentBufferOffset

Tipo: UINT64

Especifica um deslocamento em pArgumentBuffer para identificar o primeiro argumento de comando.

[in, optional] pCountBuffer

Tipo: ID3D12Resource*

Especifica um ponteiro para um ID3D12Resource.

[in] CountBufferOffset

Tipo: UINT64

Especifica um UINT64 que é o deslocamento para pCountBuffer, identificando a contagem de argumentos.

Valor retornado

Nenhum

Comentários

A semântica dessa API é definida com o seguinte pseudocódigo:

PCountBuffer não NULL:

// Read draw count out of count buffer
UINT CommandCount = pCountBuffer->ReadUINT32(CountBufferOffset);

CommandCount = min(CommandCount, MaxCommandCount)

// Get pointer to first Commanding argument
BYTE* Arguments = pArgumentBuffer->GetBase() + ArgumentBufferOffset;

for(UINT CommandIndex = 0; CommandIndex < CommandCount; CommandIndex++)
{
  // Interpret the data contained in *Arguments
  // according to the command signature
  pCommandSignature->Interpret(Arguments);

  Arguments += pCommandSignature->GetByteStride();
}

NULL pCountBuffer:

// Get pointer to first Commanding argument
BYTE* Arguments = pArgumentBuffer->GetBase() + ArgumentBufferOffset;

for(UINT CommandIndex = 0; CommandIndex < MaxCommandCount; CommandIndex++)
{
  // Interpret the data contained in *Arguments
  // according to the command signature
  pCommandSignature->Interpret(Arguments);

  Arguments += pCommandSignature->GetByteStride();
}

A camada de depuração emitirá um erro se o buffer de contagem ou o buffer de argumento não estiverem no estado D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT. O runtime principal validará:

CountBufferOffset e ArgumentBufferOffset estão alinhados em 4 bytes
pCountBuffer e pArgumentBuffer são recursos de buffer (qualquer tipo de heap)
O deslocamento implícito por MaxCommandCount, ArgumentBufferOffset e o stride do programa de desenho não excedem os limites de pArgumentBuffer (da mesma forma para o buffer de contagem)
A lista de comandos é uma lista de comandos direta ou uma lista de comandos de computação (não uma lista de comandos de código JPEG ou cópia)
A assinatura raiz da lista de comandos corresponde à assinatura raiz da assinatura de comando

A funcionalidade de duas APIs de versões anteriores do Direct3D, DrawInstancedIndirect e DrawIndexedInstancedIndirect, são englobadas por ExecuteIndirect.

Pacotes

ID3D12GraphicsCommandList::ExecuteIndirect é permitido dentro de listas de comandos de pacote somente se todos os seguintes forem verdadeiros:

CountBuffer é NULL (somente contagem especificada pela CPU).
A assinatura de comando contém exatamente uma operação. Isso implica que a assinatura de comando não contém alterações de argumentos raiz, nem contém alterações de associação VB/IB.

Obtendo endereços virtuais de buffer

O método ID3D12Resource::GetGPUVirtualAddress permite que um aplicativo recupere o endereço virtual da GPU de um buffer.

Os aplicativos são livres para aplicar deslocamentos de bytes a endereços virtuais antes de colocá-los em um buffer de argumento indireto. Observe que todos os requisitos de alinhamento D3D12 para VB/IB/CB ainda se aplicam ao endereço virtual de GPU resultante.

Exemplos

O exemplo D3D12ExecuteIndirect usa ID3D12GraphicsCommandList::ExecuteIndirect da seguinte maneira:

// Data structure to match the command signature used for ExecuteIndirect.
struct IndirectCommand
{
    D3D12_GPU_VIRTUAL_ADDRESS cbv;
    D3D12_DRAW_ARGUMENTS drawArguments;
};

A chamada para ExecuteIndirect está perto do final desta listagem, abaixo do comentário "Desenhar os triângulos que não foram eliminados".

// Fill the command list with all the render commands and dependent state.
void D3D12ExecuteIndirect::PopulateCommandLists()
{
    // Command list allocators can only be reset when the associated 
    // command lists have finished execution on the GPU; apps should use 
    // fences to determine GPU execution progress.
    ThrowIfFailed(m_computeCommandAllocators[m_frameIndex]->Reset());
    ThrowIfFailed(m_commandAllocators[m_frameIndex]->Reset());

    // However, when ExecuteCommandList() is called on a particular command 
    // list, that command list can then be reset at any time and must be before 
    // re-recording.
    ThrowIfFailed(m_computeCommandList->Reset(m_computeCommandAllocators[m_frameIndex].Get(), m_computeState.Get()));
    ThrowIfFailed(m_commandList->Reset(m_commandAllocators[m_frameIndex].Get(), m_pipelineState.Get()));

    // Record the compute commands that will cull triangles and prevent them from being processed by the vertex shader.
    if (m_enableCulling)
    {
        UINT frameDescriptorOffset = m_frameIndex * CbvSrvUavDescriptorCountPerFrame;
        D3D12_GPU_DESCRIPTOR_HANDLE cbvSrvUavHandle = m_cbvSrvUavHeap->GetGPUDescriptorHandleForHeapStart();

        m_computeCommandList->SetComputeRootSignature(m_computeRootSignature.Get());

        ID3D12DescriptorHeap* ppHeaps[] = { m_cbvSrvUavHeap.Get() };
        m_computeCommandList->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps);

        m_computeCommandList->SetComputeRootDescriptorTable(
            SrvUavTable,
            CD3DX12_GPU_DESCRIPTOR_HANDLE(cbvSrvUavHandle, CbvSrvOffset + frameDescriptorOffset, m_cbvSrvUavDescriptorSize));

        m_computeCommandList->SetComputeRoot32BitConstants(RootConstants, 4, reinterpret_cast<void*>(&m_csRootConstants), 0);

        // Reset the UAV counter for this frame.
        m_computeCommandList->CopyBufferRegion(m_processedCommandBuffers[m_frameIndex].Get(), CommandBufferSizePerFrame, m_processedCommandBufferCounterReset.Get(), 0, sizeof(UINT));

        D3D12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition(m_processedCommandBuffers[m_frameIndex].Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
        m_computeCommandList->ResourceBarrier(1, &barrier);

        m_computeCommandList->Dispatch(static_cast<UINT>(ceil(TriangleCount / float(ComputeThreadBlockSize))), 1, 1);
    }

    ThrowIfFailed(m_computeCommandList->Close());

    // Record the rendering commands.
    {
        // Set necessary state.
        m_commandList->SetGraphicsRootSignature(m_rootSignature.Get());

        ID3D12DescriptorHeap* ppHeaps[] = { m_cbvSrvUavHeap.Get() };
        m_commandList->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps);

        m_commandList->RSSetViewports(1, &m_viewport);
        m_commandList->RSSetScissorRects(1, m_enableCulling ? &m_cullingScissorRect : &m_scissorRect);

        // Indicate that the command buffer will be used for indirect drawing
        // and that the back buffer will be used as a render target.
        D3D12_RESOURCE_BARRIER barriers[2] = {
            CD3DX12_RESOURCE_BARRIER::Transition(
                m_enableCulling ? m_processedCommandBuffers[m_frameIndex].Get() : m_commandBuffer.Get(),
                m_enableCulling ? D3D12_RESOURCE_STATE_UNORDERED_ACCESS : D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,
                D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT),
            CD3DX12_RESOURCE_BARRIER::Transition(
                m_renderTargets[m_frameIndex].Get(),
                D3D12_RESOURCE_STATE_PRESENT,
                D3D12_RESOURCE_STATE_RENDER_TARGET)
        };

        m_commandList->ResourceBarrier(_countof(barriers), barriers);

        CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart(), m_frameIndex, m_rtvDescriptorSize);
        CD3DX12_CPU_DESCRIPTOR_HANDLE dsvHandle(m_dsvHeap->GetCPUDescriptorHandleForHeapStart());
        m_commandList->OMSetRenderTargets(1, &rtvHandle, FALSE, &dsvHandle);

        // Record commands.
        const float clearColor[] = { 0.0f, 0.2f, 0.4f, 1.0f };
        m_commandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr);
        m_commandList->ClearDepthStencilView(dsvHandle, D3D12_CLEAR_FLAG_DEPTH, 1.0f, 0, 0, nullptr);

        m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
        m_commandList->IASetVertexBuffers(0, 1, &m_vertexBufferView);

        if (m_enableCulling)
        {
            // Draw the triangles that have not been culled.
            m_commandList->ExecuteIndirect(
                m_commandSignature.Get(),
                TriangleCount,
                m_processedCommandBuffers[m_frameIndex].Get(),
                0,
                m_processedCommandBuffers[m_frameIndex].Get(),
                CommandBufferSizePerFrame);
        }
        else
        {
            // Draw all of the triangles.
            m_commandList->ExecuteIndirect(
                m_commandSignature.Get(),
                TriangleCount,
                m_commandBuffer.Get(),
                CommandBufferSizePerFrame * m_frameIndex,
                nullptr,
                0);
        }

        // Indicate that the command buffer may be used by the compute shader
        // and that the back buffer will now be used to present.
        barriers[0].Transition.StateBefore = D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
        barriers[0].Transition.StateAfter = m_enableCulling ? D3D12_RESOURCE_STATE_COPY_DEST : D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
        barriers[1].Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
        barriers[1].Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;

        m_commandList->ResourceBarrier(_countof(barriers), barriers);

        ThrowIfFailed(m_commandList->Close());
    }
}

Consulte Código de exemplo na referência D3D12.

Requisitos


Plataforma de Destino	Windows
Cabeçalho	d3d12.h
Biblioteca	D3d12.lib
DLL	D3d12.dll

Confira também

ID3D12GraphicsCommandList

Desenho indireto

Compartilhar via

Método ID3D12GraphicsCommandList::ExecuteIndirect (d3d12.h)

Sintaxe

Parâmetros

Valor retornado

Comentários

Pacotes

Obtendo endereços virtuais de buffer

Exemplos

Requisitos

Confira também

Comentários

Recursos adicionais