ID3D12GraphicsCommandList ::ResolveQueryData, méthode (d3d12.h)

Extrait des données d’une requête. ResolveQueryData fonctionne avec tous les types de tas (par défaut, chargement et lecture).

Syntaxe

void ResolveQueryData(
  [in] ID3D12QueryHeap  *pQueryHeap,
  [in] D3D12_QUERY_TYPE Type,
  [in] UINT             StartIndex,
  [in] UINT             NumQueries,
  [in] ID3D12Resource   *pDestinationBuffer,
  [in] UINT64           AlignedDestinationBufferOffset
);

Paramètres

[in] pQueryHeap

Type : ID3D12QueryHeap*

Spécifie l’ID3D12QueryHeap contenant les requêtes à résoudre.

[in] Type

Type : D3D12_QUERY_TYPE

Spécifie le type de requête, un membre de D3D12_QUERY_TYPE.

[in] StartIndex

Type : UINT

Spécifie un index de la première requête à résoudre.

[in] NumQueries

Type : UINT

Spécifie le nombre de requêtes à résoudre.

[in] pDestinationBuffer

Type : ID3D12Resource*

Spécifie une mémoire tampon de destination ID3D12Resource , qui doit être à l’état D3D12_RESOURCE_STATE_COPY_DEST.

[in] AlignedDestinationBufferOffset

Type : UINT64

Spécifie un décalage d’alignement dans la mémoire tampon de destination. Doit être un multiple de 8 octets.

Valeur de retour

None

Remarques

ResolveQueryData effectue une opération par lot qui écrit des données de requête dans une mémoire tampon de destination. Les données de requête sont écrites de manière contiguë dans la mémoire tampon de destination et le paramètre.

ResolveQueryData transforme les données de requête opaques d’application dans un tas de requête opaque d’application en valeurs indépendantes de l’adaptateur utilisables par votre application. La résolution des requêtes dans un tas qui n’ont pas été terminées (id3D12GraphicsCommandList ::BeginQuery a donc été appelé pour elles, mais pas ID3D12GraphicsCommandList ::EndQuery), ou qui ont été non initialisées, entraîne un comportement non défini et peut entraîner des blocages ou la suppression de l’appareil. La couche de débogage émet une erreur si elle détecte qu’une application a résolu des requêtes incomplètes ou non initialisées.

Les requêtes d’occlusion binaire écrivent 64 bits par requête. Le bit le moins significatif est 0 (l’objet a été entièrement obstrué) ou 1 (au moins 1 échantillon de l’objet aurait été dessiné). Le reste des bits est 0. Les requêtes d’occlusion écrivent 64 bits par requête. La valeur correspond au nombre d’exemples qui ont réussi le test. Les requêtes d’horodatage écrivent 64 bits par requête, ce qui est une valeur de coche qui doit être comparée à la fréquence de file d’attente de commandes respective (voir Minutage).

Les requêtes de statistiques de pipeline écrivent une structure D3D12_QUERY_DATA_PIPELINE_STATISTICS par requête. Toutes les requêtes de statistiques de flux sortant écrivent une structure D3D12_QUERY_DATA_SO_STATISTICS par requête.

Le runtime de base valide ce qui suit.

• StartIndex et NumQueries se trouvent dans la plage.
• AlignedDestinationBufferOffset est un multiple de 8 octets.
• DestinationBuffer est une mémoire tampon.
• Les données écrites ne dépassent pas la mémoire tampon de sortie.
• Le type de requête doit être pris en charge par le type de liste de commandes.
• Le type de requête doit être pris en charge par le tas de requête.

La couche de débogage émet un avertissement si la mémoire tampon de destination n’est pas à l’état D3D12_RESOURCE_STATE_COPY_DEST ou si les requêtes en cours de résolution n’ont pas été appelées id3D12GraphicsCommandList ::EndQuery .

Exemples

L’exemple D3D12PredicationQueries utilise ID3D12GraphicsCommandList ::ResolveQueryData comme suit :

// Fill the command list with all the render commands and dependent state.
void D3D12PredicationQueries::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_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_commandList->Reset(m_commandAllocators[m_frameIndex].Get(), m_pipelineState.Get()));

    // Set necessary state.
    m_commandList->SetGraphicsRootSignature(m_rootSignature.Get());

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

    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);
    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);

    // Draw the quads and perform the occlusion query.
    {
        CD3DX12_GPU_DESCRIPTOR_HANDLE cbvFarQuad(m_cbvHeap->GetGPUDescriptorHandleForHeapStart(), m_frameIndex * CbvCountPerFrame, m_cbvSrvDescriptorSize);
        CD3DX12_GPU_DESCRIPTOR_HANDLE cbvNearQuad(cbvFarQuad, m_cbvSrvDescriptorSize);

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

        // Draw the far quad conditionally based on the result of the occlusion query
        // from the previous frame.
        m_commandList->SetGraphicsRootDescriptorTable(0, cbvFarQuad);
        m_commandList->SetPredication(m_queryResult.Get(), 0, D3D12_PREDICATION_OP_EQUAL_ZERO);
        m_commandList->DrawInstanced(4, 1, 0, 0);

        // Disable predication and always draw the near quad.
        m_commandList->SetPredication(nullptr, 0, D3D12_PREDICATION_OP_EQUAL_ZERO);
        m_commandList->SetGraphicsRootDescriptorTable(0, cbvNearQuad);
        m_commandList->DrawInstanced(4, 1, 4, 0);

        // Run the occlusion query with the bounding box quad.
        m_commandList->SetGraphicsRootDescriptorTable(0, cbvFarQuad);
        m_commandList->SetPipelineState(m_queryState.Get());
        m_commandList->BeginQuery(m_queryHeap.Get(), D3D12_QUERY_TYPE_BINARY_OCCLUSION, 0);
        m_commandList->DrawInstanced(4, 1, 8, 0);
        m_commandList->EndQuery(m_queryHeap.Get(), D3D12_QUERY_TYPE_BINARY_OCCLUSION, 0);

        // Resolve the occlusion query and store the results in the query result buffer
        // to be used on the subsequent frame.
        m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_queryResult.Get(), D3D12_RESOURCE_STATE_PREDICATION, D3D12_RESOURCE_STATE_COPY_DEST));
        m_commandList->ResolveQueryData(m_queryHeap.Get(), D3D12_QUERY_TYPE_BINARY_OCCLUSION, 0, 1, m_queryResult.Get(), 0);
        m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_queryResult.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PREDICATION));
    }

    // 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());
}

Consultez l’exemple de code dans la référence D3D12.

Configuration requise

Voir aussi

ID3D12GraphicsCommandList