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

Notifica o driver de que ele precisa sincronizar vários acessos aos recursos.

Sintaxe

void ResourceBarrier(
  [in] UINT                         NumBarriers,
  [in] const D3D12_RESOURCE_BARRIER *pBarriers
);

Parâmetros

[in] NumBarriers

Tipo: UINT

O número de descrições de barreira enviadas.

[in] pBarriers

Tipo: const D3D12_RESOURCE_BARRIER*

Ponteiro para uma matriz de descrições de barreira.

Valor retornado

Nenhum

Comentários

Há três tipos de descrições de barreira:

• D3D12_RESOURCE_TRANSITION_BARRIER – as barreiras de transição indicam que um conjunto de sub-recursos faz a transição entre diferentes usos. O chamador deve especificar os usos antes e depois dos sub-recursos. O sinalizador D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES é usado para fazer a transição de todos os sub-recursos em um recurso ao mesmo tempo.
• D3D12_RESOURCE_ALIASING_BARRIER – as barreiras de alias indicam uma transição entre os usos de dois recursos diferentes que têm mapeamentos para o mesmo heap. O aplicativo pode especificar o recurso antes e depois. Observe que um ou ambos os recursos podem ser NULL (indicando que qualquer recurso lado a lado pode causar alias).
• D3D12_RESOURCE_UAV_BARRIER – as barreiras de exibição de acesso não ordenadas indicam que todos os acessos UAV (leitura ou gravação) em um recurso específico devem ser concluídos antes que qualquer acesso UAV futuro (leitura ou gravação) possa começar. O recurso especificado pode ser NULL. Não é necessário inserir uma barreira UAV entre duas chamadas de desenho ou expedição que somente leem um UAV. Além disso, não é necessário inserir uma barreira UAV entre duas chamadas de desenho ou expedição que gravam no mesmo UAV se o aplicativo souber que é seguro executar os acessos UAV em qualquer ordem. O recurso pode ser NULL (indicando que qualquer acesso UAV pode exigir a barreira).

Quando ID3D12GraphicsCommandList::ResourceBarrier é passada uma matriz de descrições de barreira de recursos, a API se comporta como se fosse chamada N vezes (1 para cada elemento de matriz), na ordem especificada. As transições devem ser agrupadas em lote em uma única chamada à API quando possível, como uma otimização de desempenho.

Para obter descrições dos estados de uso em que um sub-recurso pode estar, consulte a enumeração D3D12_RESOURCE_STATES e a seção Usando barreiras de recursos para sincronizar estados de recursos no Direct3D 12 .

Todos os sub-recursos em um recurso devem estar no estado RENDER_TARGET, ou DEPTH_WRITE estado, para renderizar destinos/recursos de estêncil de profundidade, respectivamente, quando ID3D12GraphicsCommandList::D iscardResource é chamado.

Quando um buffer de fundo é apresentado, ele deve estar no estado D3D12_RESOURCE_STATE_PRESENT. Se IDXGISwapChain1::P resent1 for chamado em um recurso que não está no estado PRESENT, um aviso de camada de depuração será emitido.

Os bits de uso do recurso são agrupados em duas categorias, somente leitura e leitura/gravação.

Os bits de uso a seguir são somente leitura:

• D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER
• D3D12_RESOURCE_STATE_INDEX_BUFFER
• D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE
• D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE
• D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT
• D3D12_RESOURCE_STATE_COPY_SOURCE
• D3D12_RESOURCE_STATE_DEPTH_READ

Os bits de uso a seguir são leitura/gravação:

• D3D12_RESOURCE_STATE_UNORDERED_ACCESS
• D3D12_RESOURCE_STATE_DEPTH_WRITE

Os bits de uso a seguir são somente gravação:

• D3D12_RESOURCE_STATE_COPY_DEST
• D3D12_RESOURCE_STATE_RENDER_TARGET
• D3D12_RESOURCE_STATE_STREAM_OUT

No máximo, um bit de gravação pode ser definido. Se qualquer bit de gravação estiver definido, nenhum bit de leitura poderá ser definido. Se nenhum bit de gravação estiver definido, qualquer número de bits de leitura poderá ser definido.

A qualquer momento, um sub-recurso está exatamente em um estado (determinado por um conjunto de sinalizadores). O aplicativo deve garantir que os estados sejam correspondidos ao fazer uma sequência de chamadas ResourceBarrier . Em outras palavras, os estados antes e depois em chamadas consecutivas para ResourceBarrier devem concordar.

Para fazer a transição de todos os sub-recursos dentro de um recurso, o aplicativo pode definir o índice de sub-recurso como D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, o que implica que todos os sub-recursos são alterados.

Para melhorar o desempenho, os aplicativos devem usar barreiras divididas (consulte Sincronização de vários mecanismos). Seu aplicativo também deve agrupar várias transições em uma única chamada sempre que possível.

Validação de runtime

O runtime validará se os valores de tipo de barreira são membros válidos da enumeração D3D12_RESOURCE_BARRIER_TYPE .

Além disso, o runtime verifica o seguinte:

• O ponteiro do recurso não é NULL.
• O índice de sub-recurso é válido
• Os estados antes e depois têm suporte dos sinalizadores D3D12_RESOURCE_BINDING_TIER e D3D12_RESOURCE_FLAGS do recurso.
• Os bits reservados nas máscaras de estado não estão definidos.
• Os estados antes e depois são diferentes.
• O conjunto de bits nos estados antes e depois são válidos.
• Se o D3D12_RESOURCE_STATE_RESOLVE_SOURCE bit estiver definido, a contagem de exemplos de recursos deverá ser maior que 1.
• Se o D3D12_RESOURCE_STATE_RESOLVE_DEST bit estiver definido, a contagem de exemplos de recursos deverá ser igual a 1.

Para barreiras de alias, o runtime validará que, se um dos ponteiros de recurso não for NULL, ele se referirá a um recurso lado a lado.

Para barreiras UAV, o runtime validará que, se o recurso não for NULL, o recurso terá o sinalizador de associação D3D12_RESOURCE_STATE_UNORDERED_ACCESS definido.

A falha de validação faz com que ID3D12GraphicsCommandList::Close retorne E_INVALIDARG.

Camada de depuração

A camada de depuração normalmente emite erros em que a validação de runtime falha:

• Se uma transição de sub-recurso em uma lista de comandos for inconsistente com as transições anteriores na mesma lista de comandos.
• Se um recurso for usado sem primeiro chamar ResourceBarrier para colocar o recurso no estado correto.
• Se um recurso estiver ilegalmente associado para leitura e gravação ao mesmo tempo.
• Se os estados anteriores passados para o ResourceBarrier não corresponderem aos estados posteriores de chamadas anteriores para ResourceBarrier, incluindo o caso de alias.

Enquanto a camada de depuração tenta validar as regras de runtime, ela opera de forma conservadora para que erros de camada de depuração sejam erros reais e, em alguns casos, erros reais podem não produzir erros de camada de depuração.

A camada de depuração emitirá avisos nos seguintes casos:

• Todos os casos em que a camada de depuração D3D12 emitiria avisos para ID3D12GraphicsCommandList::ResourceBarrier.
• Se um buffer de profundidade for usado em um modo não somente leitura enquanto o recurso tiver o D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE bit de uso definido.

Exemplos

O exemplo D3D12HelloTriangle usa ID3D12GraphicsCommandList::ResourceBarrier da seguinte maneira:

D3D12_VIEWPORT m_viewport;
D3D12_RECT m_scissorRect;
ComPtr<IDXGISwapChain3> m_swapChain;
ComPtr<ID3D12Device> m_device;
ComPtr<ID3D12Resource> m_renderTargets[FrameCount];
ComPtr<ID3D12CommandAllocator> m_commandAllocator;
ComPtr<ID3D12CommandQueue> m_commandQueue;
ComPtr<ID3D12RootSignature> m_rootSignature;
ComPtr<ID3D12DescriptorHeap> m_rtvHeap;
ComPtr<ID3D12PipelineState> m_pipelineState;
ComPtr<ID3D12GraphicsCommandList> m_commandList;
UINT m_rtvDescriptorSize;

void D3D12HelloTriangle::PopulateCommandList()
{
    // 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_commandAllocator->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_commandList->Reset(m_commandAllocator.Get(), m_pipelineState.Get()));

    // Set necessary state.
    m_commandList->SetGraphicsRootSignature(m_rootSignature.Get());
    m_commandList->RSSetViewports(1, &m_viewport);
    m_commandList->RSSetScissorRects(1, &m_scissorRect);

    // Indicate that the back buffer will be used as a render target.
    m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_renderTargets[m_frameIndex].Get(), D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET));

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

    // Record commands.
    const float clearColor[] = { 0.0f, 0.2f, 0.4f, 1.0f };
    m_commandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr);
    m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    m_commandList->IASetVertexBuffers(0, 1, &m_vertexBufferView);
    m_commandList->DrawInstanced(3, 1, 0, 0);

    // Indicate that the back buffer will now be used to present.
    m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_renderTargets[m_frameIndex].Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT));

    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

Como usar barreiras de recursos para sincronizar estados de recursos no Direct3D 12