Rysunek pośredni i uśrednianie procesora GPU
W przykładzie D3D12ExecuteIndirect pokazano, jak rysować zawartość za pomocą poleceń pośrednich. Pokazuje również, jak te polecenia można manipulować na procesorze GPU w cieniowania obliczeń przed ich wystawieniem.
- Definiowanie poleceń pośrednich
- Tworzenie grafiki i obliczeniowego podpisu głównego
- Tworzenie widoku zasobów cieniowania (SRV) dla cieniowania zasobów obliczeniowych
- Tworzenie poleceń pośrednich
- Tworzenie wirtualnych interfejsów użytkownika zasobów obliczeniowych
- rysunek ramki
- Uruchom przykładową
- Tematy pokrewne
Przykład tworzy bufor poleceń, który opisuje wywołania 1024 rysowania. Każde wywołanie rysowania renderuje trójkąt z losowym kolorem, położeniem i szybkością. Trójkąty animują się bez końca na ekranie. W tym przykładzie istnieją dwa tryby. W pierwszym trybie cieniowanie obliczeniowe sprawdza polecenia pośrednie i decyduje, czy dodać to polecenie do widoku dostępu nieuporządkowanego (UAV) opisującego polecenia, które powinny być wykonywane. W drugim trybie wszystkie polecenia są po prostu wykonywane. Naciśnięcie paska spacji spowoduje przełączenie między trybami.
Definiowanie poleceń pośrednich
Zaczynamy od zdefiniowania, jak powinny wyglądać polecenia pośrednie. W tym przykładzie polecenia, które chcemy wykonać, to:
- 1. Zaktualizuj widok stałego buforu (CBV).
2. Rysuj trójkąt.
Te polecenia rysunku są reprezentowane przez następującą strukturę w D3D12ExecuteIndirect definicji klasy. Polecenia są wykonywane sekwencyjnie w kolejności, w której są zdefiniowane w tej strukturze.
// Data structure to match the command signature used for ExecuteIndirect.
struct IndirectCommand
{
D3D12_GPU_VIRTUAL_ADDRESS cbv;
D3D12_DRAW_ARGUMENTS drawArguments;
};
| Przepływ wywołań | Parametry |
|---|---|
| D3D12_GPU_VIRTUAL_ADDRESS (po prostu UINT64) | |
| D3D12_DRAW_ARGUMENTS |
Aby towarzyszyć strukturze danych, tworzony jest również podpis polecenia, który instruuje procesor GPU, jak interpretować dane przekazywane do interfejsu API ExecuteIndirect. Jest to i większość poniższego kodu jest dodawana do metody LoadAssets.
// Create the command signature used for indirect drawing.
{
// Each command consists of a CBV update and a DrawInstanced call.
D3D12_INDIRECT_ARGUMENT_DESC argumentDescs[2] = {};
argumentDescs[0].Type = D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW;
argumentDescs[0].ConstantBufferView.RootParameterIndex = Cbv;
argumentDescs[1].Type = D3D12_INDIRECT_ARGUMENT_TYPE_DRAW;
D3D12_COMMAND_SIGNATURE_DESC commandSignatureDesc = {};
commandSignatureDesc.pArgumentDescs = argumentDescs;
commandSignatureDesc.NumArgumentDescs = _countof(argumentDescs);
commandSignatureDesc.ByteStride = sizeof(IndirectCommand);
ThrowIfFailed(m_device->CreateCommandSignature(&commandSignatureDesc, m_rootSignature.Get(), IID_PPV_ARGS(&m_commandSignature)));
}
| Przepływ wywołań | Parametry |
|---|---|
| D3D12_INDIRECT_ARGUMENT_DESC | D3D12_INDIRECT_ARGUMENT_TYPE |
| D3D12_COMMAND_SIGNATURE_DESC | |
| CreateCommandSignature |
Tworzenie grafiki i podpisu głównego obliczeń
Tworzymy również grafikę i podpis główny obliczeń. Podpis główny grafiki definiuje tylko główny cbv. Pamiętaj, że mapujemy indeks tego parametru głównego w D3D12_INDIRECT_ARGUMENT_DESC (pokazanym powyżej), gdy jest zdefiniowany podpis polecenia. Podpis główny obliczeń definiuje:
- Wspólna tabela deskryptora z trzema miejscami (dwa sRV i jeden UAV):
- Jeden serwer SRV uwidacznia stałe w cieniatorze obliczeniowym
- Jeden serwer SRV uwidacznia bufor poleceń cieniatorowi obliczeniowemu
- UAV to miejsce, w którym cieniator obliczeniowy zapisuje polecenia dla widocznych trójkątów
- Cztery stałe główne:
- Połowa szerokości jednego boku trójkąta
- Położenie z wierzchołków trójkąta
- Przesunięcie +/- x płaszczyzny uboju w jednogenicznej przestrzeni [-1,1]
- Liczba poleceń pośrednich w buforze poleceń
// Create the root signatures.
{
CD3DX12_ROOT_PARAMETER rootParameters[GraphicsRootParametersCount];
rootParameters[Cbv].InitAsConstantBufferView(0, 0, D3D12_SHADER_VISIBILITY_VERTEX);
CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc;
rootSignatureDesc.Init(_countof(rootParameters), rootParameters, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
ThrowIfFailed(D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error));
ThrowIfFailed(m_device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&m_rootSignature)));
// Create compute signature.
CD3DX12_DESCRIPTOR_RANGE ranges[2];
ranges[0].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 2, 0);
ranges[1].Init(D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 1, 0);
CD3DX12_ROOT_PARAMETER computeRootParameters[ComputeRootParametersCount];
computeRootParameters[SrvUavTable].InitAsDescriptorTable(2, ranges);
computeRootParameters[RootConstants].InitAsConstants(4, 0);
CD3DX12_ROOT_SIGNATURE_DESC computeRootSignatureDesc;
computeRootSignatureDesc.Init(_countof(computeRootParameters), computeRootParameters);
ThrowIfFailed(D3D12SerializeRootSignature(&computeRootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error));
ThrowIfFailed(m_device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&m_computeRootSignature)));
}
Tworzenie widoku zasobów cieniowania (SRV) dla cieniowania zasobów obliczeniowych
Po utworzeniu obiektów stanu potoku wierzchołków, wzornik głębokości i stałe próbka tworzy widok zasobów cieniowania (SRV) stałego buforu, aby cieniować dane w buforze stałym.
// Create shader resource views (SRV) of the constant buffers for the
// compute shader to read from.
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.Format = DXGI_FORMAT_UNKNOWN;
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
srvDesc.Buffer.NumElements = TriangleCount;
srvDesc.Buffer.StructureByteStride = sizeof(ConstantBufferData);
srvDesc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
CD3DX12_CPU_DESCRIPTOR_HANDLE cbvSrvHandle(m_cbvSrvUavHeap->GetCPUDescriptorHandleForHeapStart(), CbvSrvOffset, m_cbvSrvUavDescriptorSize);
for (UINT frame = 0; frame < FrameCount; frame++)
{
srvDesc.Buffer.FirstElement = frame * TriangleCount;
m_device->CreateShaderResourceView(m_constantBuffer.Get(), &srvDesc, cbvSrvHandle);
cbvSrvHandle.Offset(CbvSrvUavDescriptorCountPerFrame, m_cbvSrvUavDescriptorSize);
}
| Przepływ wywołań | Parametry |
|---|---|
| D3D12_SHADER_RESOURCE_VIEW_DESC | |
| CD3DX12_CPU_DESCRIPTOR_HANDLE | GetCPUDescriptorHandleForHeapStart |
| createShaderResourceView |
Tworzenie poleceń pośrednich
Następnie utworzymy pośrednie poleceń i zdefiniujmy ich zawartość przy użyciu następującego kodu. Rysujemy te same wierzchołki trójkątów 1024 razy, ale wskazujemy inną stałą lokalizację buforu z każdym wywołaniem rysowania.
D3D12_GPU_VIRTUAL_ADDRESS gpuAddress = m_constantBuffer->GetGPUVirtualAddress();
UINT commandIndex = 0;
for (UINT frame = 0; frame < FrameCount; frame++)
{
for (UINT n = 0; n < TriangleCount; n++)
{
commands[commandIndex].cbv = gpuAddress;
commands[commandIndex].drawArguments.VertexCountPerInstance = 3;
commands[commandIndex].drawArguments.InstanceCount = 1;
commands[commandIndex].drawArguments.StartVertexLocation = 0;
commands[commandIndex].drawArguments.StartInstanceLocation = 0;
commandIndex++;
gpuAddress += sizeof(ConstantBufferData);
}
}
| Przepływ wywołań | Parametry |
|---|---|
| D3D12_GPU_VIRTUAL_ADDRESS | GetGPUVirtualAddress |
Po przekazaniu poleceń do procesora GPU utworzymy również SRV dla modułu cieniowania obliczeniowego do odczytu. Jest to bardzo podobne do SRV utworzonego buforu stałego.
// Create SRVs for the command buffers.
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.Format = DXGI_FORMAT_UNKNOWN;
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
srvDesc.Buffer.NumElements = TriangleCount;
srvDesc.Buffer.StructureByteStride = sizeof(IndirectCommand);
srvDesc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
CD3DX12_CPU_DESCRIPTOR_HANDLE commandsHandle(m_cbvSrvUavHeap->GetCPUDescriptorHandleForHeapStart(), CommandsOffset, m_cbvSrvUavDescriptorSize);
for (UINT frame = 0; frame < FrameCount; frame++)
{
srvDesc.Buffer.FirstElement = frame * TriangleCount;
m_device->CreateShaderResourceView(m_commandBuffer.Get(), &srvDesc, commandsHandle);
commandsHandle.Offset(CbvSrvUavDescriptorCountPerFrame, m_cbvSrvUavDescriptorSize);
}
| Przepływ wywołań | Parametry |
|---|---|
| D3D12_SHADER_RESOURCE_VIEW_DESC | |
| CD3DX12_CPU_DESCRIPTOR_HANDLE | GetCPUDescriptorHandleForHeapStart |
| createShaderResourceView |
Tworzenie wirtualnych interfejsów użytkownika zasobów obliczeniowych
Musimy utworzyć widoki UAV, które będą przechowywać wyniki pracy obliczeniowej. Gdy trójkąt zostanie uznany za widoczny dla obiektu docelowego renderowania przez moduł cieniowania zasobów obliczeniowych, zostanie on dołączony do tej funkcji UAV, a następnie użyty przez interfejs API ExecuteIndirect.
CD3DX12_CPU_DESCRIPTOR_HANDLE processedCommandsHandle(m_cbvSrvUavHeap->GetCPUDescriptorHandleForHeapStart(), ProcessedCommandsOffset, m_cbvSrvUavDescriptorSize);
for (UINT frame = 0; frame < FrameCount; frame++)
{
// Allocate a buffer large enough to hold all of the indirect commands
// for a single frame as well as a UAV counter.
commandBufferDesc = CD3DX12_RESOURCE_DESC::Buffer(CommandBufferSizePerFrame + sizeof(UINT), D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
CD3DX12_HEAP_PROPERTIES heapProps(D3D12_HEAP_TYPE_DEFAULT);
ThrowIfFailed(m_device->CreateCommittedResource(
&heapProps,
D3D12_HEAP_FLAG_NONE,
&commandBufferDesc,
D3D12_RESOURCE_STATE_COPY_DEST,
nullptr,
IID_PPV_ARGS(&m_processedCommandBuffers[frame])));
D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
uavDesc.Format = DXGI_FORMAT_UNKNOWN;
uavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
uavDesc.Buffer.FirstElement = 0;
uavDesc.Buffer.NumElements = TriangleCount;
uavDesc.Buffer.StructureByteStride = sizeof(IndirectCommand);
uavDesc.Buffer.CounterOffsetInBytes = CommandBufferSizePerFrame;
uavDesc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
m_device->CreateUnorderedAccessView(
m_processedCommandBuffers[frame].Get(),
m_processedCommandBuffers[frame].Get(),
&uavDesc,
processedCommandsHandle);
processedCommandsHandle.Offset(CbvSrvUavDescriptorCountPerFrame, m_cbvSrvUavDescriptorSize);
}
Rysowanie ramki
Jeśli nadszedł czas, aby narysować ramkę, jeśli jesteśmy w trybie wywoływania cieniowania obliczeniowego, a polecenia pośrednie są przetwarzane przez procesor GPU, najpierw Dispatch, które działają w celu wypełnienia buforu poleceń dla ExecuteIndirect. Następujące fragmenty kodu są dodawane do metody PopulateCommandLists.
// 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());
Następnie wykonamy polecenia w trybie UAV (włączonym uścisku procesora GPU) lub pełnym buforem poleceń (wyłączonym uściskiem procesora GPU).
// 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());
}
Jeśli jesteśmy w trybie uścisku procesora GPU, będziemy mieć kolejkę poleceń grafiki czekać na zakończenie pracy obliczeniowej przed rozpoczęciem wykonywania poleceń pośrednich. W metodzie OnRender zostanie dodany następujący fragment kodu.
// Execute the compute work.
if (m_enableCulling)
{
ID3D12CommandList* ppCommandLists[] = { m_computeCommandList.Get() };
m_computeCommandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);
m_computeCommandQueue->Signal(m_computeFence.Get(), m_fenceValues[m_frameIndex]);
// Execute the rendering work only when the compute work is complete.
m_commandQueue->Wait(m_computeFence.Get(), m_fenceValues[m_frameIndex]);
}
// Execute the rendering work.
ID3D12CommandList* ppCommandLists[] = { m_commandList.Get() };
m_commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);
| Przepływ wywołań | Parametry |
|---|---|
| ID3D12CommandList | |
| ExecuteCommandLists | |
| signal | |
| oczekiwania | |
| ID3D12CommandList | |
| ExecuteCommandLists |
Uruchamianie przykładu
Przykład z pierwotnym ubojem procesora GPU.
procesora GPU
Przykład bez pierwotnego uboju procesora GPU.
procesora GPU
Tematy pokrewne
-
przewodniki kodu D3D12
-
samouczki wideo uczenia zaawansowanego DirectX: wykonywanie pośredniego i asynchronicznego procesora GPU