blob: 7e31b87ce413787c753d6bb6ea619b2500ce6602 [file] [log] [blame]
/*
* Copyright 2020 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/d3d/GrD3DCommandList.h"
#include "src/core/SkTraceEvent.h"
#include "src/gpu/GrScissorState.h"
#include "src/gpu/d3d/GrD3DAttachment.h"
#include "src/gpu/d3d/GrD3DBuffer.h"
#include "src/gpu/d3d/GrD3DCommandSignature.h"
#include "src/gpu/d3d/GrD3DGpu.h"
#include "src/gpu/d3d/GrD3DPipeline.h"
#include "src/gpu/d3d/GrD3DRenderTarget.h"
#include "src/gpu/d3d/GrD3DTexture.h"
#include "src/gpu/d3d/GrD3DTextureResource.h"
#include "src/gpu/d3d/GrD3DUtil.h"
GrD3DCommandList::GrD3DCommandList(gr_cp<ID3D12CommandAllocator> allocator,
gr_cp<ID3D12GraphicsCommandList> commandList)
: fCommandList(std::move(commandList))
, fAllocator(std::move(allocator)) {
}
bool GrD3DCommandList::close() {
SkASSERT(fIsActive);
this->submitResourceBarriers();
HRESULT hr = fCommandList->Close();
SkDEBUGCODE(fIsActive = false;)
return SUCCEEDED(hr);
}
GrD3DCommandList::SubmitResult GrD3DCommandList::submit(ID3D12CommandQueue* queue) {
SkASSERT(fIsActive);
if (!this->hasWork()) {
this->callFinishedCallbacks();
return SubmitResult::kNoWork;
}
if (!this->close()) {
return SubmitResult::kFailure;
}
SkASSERT(!fIsActive);
ID3D12CommandList* ppCommandLists[] = { fCommandList.get() };
queue->ExecuteCommandLists(1, ppCommandLists);
return SubmitResult::kSuccess;
}
void GrD3DCommandList::reset() {
SkASSERT(!fIsActive);
GR_D3D_CALL_ERRCHECK(fAllocator->Reset());
GR_D3D_CALL_ERRCHECK(fCommandList->Reset(fAllocator.get(), nullptr));
this->onReset();
this->releaseResources();
SkDEBUGCODE(fIsActive = true;)
fHasWork = false;
}
void GrD3DCommandList::releaseResources() {
TRACE_EVENT0("skia.gpu", TRACE_FUNC);
if (fTrackedResources.count() == 0 && fTrackedRecycledResources.count() == 0) {
return;
}
SkASSERT(!fIsActive);
for (int i = 0; i < fTrackedRecycledResources.count(); ++i) {
auto resource = fTrackedRecycledResources[i].release();
resource->recycle();
}
fTrackedResources.reset();
fTrackedRecycledResources.reset();
fTrackedGpuBuffers.reset();
this->callFinishedCallbacks();
}
void GrD3DCommandList::addFinishedCallback(sk_sp<GrRefCntedCallback> callback) {
fFinishedCallbacks.push_back(std::move(callback));
}
////////////////////////////////////////////////////////////////////////////////
// GraphicsCommandList commands
////////////////////////////////////////////////////////////////////////////////
void GrD3DCommandList::resourceBarrier(sk_sp<GrManagedResource> resource,
int numBarriers,
const D3D12_RESOURCE_TRANSITION_BARRIER* barriers) {
SkASSERT(fIsActive);
SkASSERT(barriers);
for (int i = 0; i < numBarriers; ++i) {
// D3D will apply barriers in order so we can just add onto the end
D3D12_RESOURCE_BARRIER& newBarrier = fResourceBarriers.push_back();
newBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
newBarrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
newBarrier.Transition = barriers[i];
}
fHasWork = true;
if (resource) {
this->addResource(std::move(resource));
}
}
void GrD3DCommandList::uavBarrier(sk_sp<GrManagedResource> resource,
ID3D12Resource* uavResource) {
SkASSERT(fIsActive);
// D3D will apply barriers in order so we can just add onto the end
D3D12_RESOURCE_BARRIER& newBarrier = fResourceBarriers.push_back();
newBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
newBarrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
newBarrier.UAV.pResource = uavResource;
fHasWork = true;
if (resource) {
this->addResource(std::move(resource));
}
}
void GrD3DCommandList::aliasingBarrier(sk_sp<GrManagedResource> beforeManagedResource,
ID3D12Resource* beforeResource,
sk_sp<GrManagedResource> afterManagedResource,
ID3D12Resource* afterResource) {
SkASSERT(fIsActive);
// D3D will apply barriers in order so we can just add onto the end
D3D12_RESOURCE_BARRIER& newBarrier = fResourceBarriers.push_back();
newBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
newBarrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
newBarrier.Aliasing.pResourceBefore = beforeResource;
newBarrier.Aliasing.pResourceAfter = afterResource;
fHasWork = true;
// Aliasing barriers can accept a null pointer for one of the resources,
// but at this point we're not using that feature.
SkASSERT(beforeManagedResource);
this->addResource(std::move(beforeManagedResource));
SkASSERT(afterManagedResource);
this->addResource(std::move(afterManagedResource));
}
void GrD3DCommandList::submitResourceBarriers() {
SkASSERT(fIsActive);
if (fResourceBarriers.count()) {
fCommandList->ResourceBarrier(fResourceBarriers.count(), fResourceBarriers.begin());
fResourceBarriers.reset();
}
SkASSERT(!fResourceBarriers.count());
}
void GrD3DCommandList::copyBufferToTexture(ID3D12Resource* srcBuffer,
const GrD3DTextureResource* dstTexture,
uint32_t subresourceCount,
D3D12_PLACED_SUBRESOURCE_FOOTPRINT* bufferFootprints,
int left, int top) {
SkASSERT(fIsActive);
SkASSERT(subresourceCount == 1 || (left == 0 && top == 0));
this->addingWork();
this->addResource(dstTexture->resource());
for (uint32_t subresource = 0; subresource < subresourceCount; ++subresource) {
D3D12_TEXTURE_COPY_LOCATION src = {};
src.pResource = srcBuffer;
src.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
src.PlacedFootprint = bufferFootprints[subresource];
D3D12_TEXTURE_COPY_LOCATION dst = {};
dst.pResource = dstTexture->d3dResource();
dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
dst.SubresourceIndex = subresource;
fCommandList->CopyTextureRegion(&dst, left, top, 0, &src, nullptr);
}
}
void GrD3DCommandList::copyTextureRegionToTexture(sk_sp<GrManagedResource> dst,
const D3D12_TEXTURE_COPY_LOCATION* dstLocation,
UINT dstX, UINT dstY,
sk_sp<GrManagedResource> src,
const D3D12_TEXTURE_COPY_LOCATION* srcLocation,
const D3D12_BOX* srcBox) {
SkASSERT(fIsActive);
SkASSERT(dst);
this->addingWork();
this->addResource(dst);
this->addResource(std::move(src));
fCommandList->CopyTextureRegion(dstLocation, dstX, dstY, 0, srcLocation, srcBox);
}
void GrD3DCommandList::copyTextureRegionToBuffer(sk_sp<const GrBuffer> dst,
const D3D12_TEXTURE_COPY_LOCATION* dstLocation,
UINT dstX,
UINT dstY,
sk_sp<GrManagedResource> src,
const D3D12_TEXTURE_COPY_LOCATION* srcLocation,
const D3D12_BOX* srcBox) {
SkASSERT(fIsActive);
SkASSERT(dst);
this->addingWork();
this->addGrBuffer(std::move(dst));
this->addResource(std::move(src));
fCommandList->CopyTextureRegion(dstLocation, dstX, dstY, 0, srcLocation, srcBox);
}
void GrD3DCommandList::copyTextureToTexture(const GrD3DTexture* dst, const GrD3DTexture* src,
UINT subresourceIndex) {
SkASSERT(fIsActive);
SkASSERT(src);
SkASSERT(dst);
SkASSERT(src->width() == dst->width() && src->height() == dst->height());
this->addingWork();
ID3D12Resource* dstTexture = dst->d3dResource();
ID3D12Resource* srcTexture = src->d3dResource();
if (subresourceIndex == (UINT)-1) {
fCommandList->CopyResource(dstTexture, srcTexture);
} else {
SkASSERT(subresourceIndex < src->mipLevels() &&
subresourceIndex < dst->mipLevels());
D3D12_TEXTURE_COPY_LOCATION srcLoc = {};
srcLoc.pResource = srcTexture;
srcLoc.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
srcLoc.SubresourceIndex = subresourceIndex;
D3D12_TEXTURE_COPY_LOCATION dstLoc = {};
dstLoc.pResource = dstTexture;
dstLoc.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
dstLoc.SubresourceIndex = subresourceIndex;
fCommandList->CopyTextureRegion(&dstLoc, 0, 0, 0, &srcLoc, nullptr);
}
this->addResource(dst->resource());
this->addResource(src->resource());
}
void GrD3DCommandList::copyBufferToBuffer(sk_sp<GrD3DBuffer> dst, uint64_t dstOffset,
ID3D12Resource* srcBuffer, uint64_t srcOffset,
uint64_t numBytes) {
SkASSERT(fIsActive);
this->addingWork();
ID3D12Resource* dstBuffer = dst->d3dResource();
uint64_t dstSize = dstBuffer->GetDesc().Width;
uint64_t srcSize = srcBuffer->GetDesc().Width;
if (dstSize == srcSize && srcSize == numBytes) {
fCommandList->CopyResource(dstBuffer, srcBuffer);
} else {
fCommandList->CopyBufferRegion(dstBuffer, dstOffset, srcBuffer, srcOffset, numBytes);
}
this->addGrBuffer(std::move(dst));
}
void GrD3DCommandList::addingWork() {
this->submitResourceBarriers();
fHasWork = true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
std::unique_ptr<GrD3DDirectCommandList> GrD3DDirectCommandList::Make(GrD3DGpu* gpu) {
ID3D12Device* device = gpu->device();
gr_cp<ID3D12CommandAllocator> allocator;
GR_D3D_CALL_ERRCHECK(device->CreateCommandAllocator(
D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&allocator)));
gr_cp<ID3D12GraphicsCommandList> commandList;
GR_D3D_CALL_ERRCHECK(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT,
allocator.get(), nullptr,
IID_PPV_ARGS(&commandList)));
auto grCL = new GrD3DDirectCommandList(std::move(allocator), std::move(commandList),
gpu->d3dCaps().resolveSubresourceRegionSupport());
return std::unique_ptr<GrD3DDirectCommandList>(grCL);
}
GrD3DDirectCommandList::GrD3DDirectCommandList(gr_cp<ID3D12CommandAllocator> allocator,
gr_cp<ID3D12GraphicsCommandList> commandList,
bool resolveSubregionSupported)
: GrD3DCommandList(std::move(allocator), std::move(commandList))
, fResolveSubregionSupported(resolveSubregionSupported) {
sk_bzero(fCurrentGraphicsRootDescTable, sizeof(fCurrentGraphicsRootDescTable));
sk_bzero(fCurrentComputeRootDescTable, sizeof(fCurrentComputeRootDescTable));
}
void GrD3DDirectCommandList::onReset() {
fCurrentPipeline = nullptr;
fCurrentGraphicsRootSignature = nullptr;
fCurrentComputeRootSignature = nullptr;
fCurrentVertexBuffer = nullptr;
fCurrentVertexStride = 0;
fCurrentInstanceBuffer = nullptr;
fCurrentInstanceStride = 0;
fCurrentIndexBuffer = nullptr;
fCurrentGraphicsConstantBufferAddress = 0;
fCurrentComputeConstantBufferAddress = 0;
sk_bzero(fCurrentGraphicsRootDescTable, sizeof(fCurrentGraphicsRootDescTable));
sk_bzero(fCurrentComputeRootDescTable, sizeof(fCurrentComputeRootDescTable));
fCurrentSRVCRVDescriptorHeap = nullptr;
fCurrentSamplerDescriptorHeap = nullptr;
}
void GrD3DDirectCommandList::setPipelineState(const sk_sp<GrD3DPipeline>& pipeline) {
SkASSERT(fIsActive);
if (pipeline.get() != fCurrentPipeline) {
fCommandList->SetPipelineState(pipeline->d3dPipelineState());
this->addResource(std::move(pipeline));
fCurrentPipeline = pipeline.get();
}
}
void GrD3DDirectCommandList::setStencilRef(unsigned int stencilRef) {
SkASSERT(fIsActive);
fCommandList->OMSetStencilRef(stencilRef);
}
void GrD3DDirectCommandList::setBlendFactor(const float blendFactor[4]) {
SkASSERT(fIsActive);
fCommandList->OMSetBlendFactor(blendFactor);
}
void GrD3DDirectCommandList::setPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY primitiveTopology) {
SkASSERT(fIsActive);
fCommandList->IASetPrimitiveTopology(primitiveTopology);
}
void GrD3DDirectCommandList::setScissorRects(unsigned int numRects, const D3D12_RECT* rects) {
SkASSERT(fIsActive);
fCommandList->RSSetScissorRects(numRects, rects);
}
void GrD3DDirectCommandList::setViewports(unsigned int numViewports,
const D3D12_VIEWPORT* viewports) {
SkASSERT(fIsActive);
fCommandList->RSSetViewports(numViewports, viewports);
}
void GrD3DDirectCommandList::setGraphicsRootSignature(const sk_sp<GrD3DRootSignature>& rootSig) {
SkASSERT(fIsActive);
if (fCurrentGraphicsRootSignature != rootSig.get()) {
fCommandList->SetGraphicsRootSignature(rootSig->rootSignature());
this->addResource(rootSig);
fCurrentGraphicsRootSignature = rootSig.get();
// need to reset the current descriptor tables as well
sk_bzero(fCurrentGraphicsRootDescTable, sizeof(fCurrentGraphicsRootDescTable));
}
}
void GrD3DDirectCommandList::setComputeRootSignature(const sk_sp<GrD3DRootSignature>& rootSig) {
SkASSERT(fIsActive);
if (fCurrentComputeRootSignature != rootSig.get()) {
fCommandList->SetComputeRootSignature(rootSig->rootSignature());
this->addResource(rootSig);
fCurrentComputeRootSignature = rootSig.get();
// need to reset the current descriptor tables as well
sk_bzero(fCurrentComputeRootDescTable, sizeof(fCurrentComputeRootDescTable));
}
}
void GrD3DDirectCommandList::setVertexBuffers(unsigned int startSlot,
sk_sp<const GrBuffer> vertexBuffer,
size_t vertexStride,
sk_sp<const GrBuffer> instanceBuffer,
size_t instanceStride) {
if (fCurrentVertexBuffer != vertexBuffer.get() ||
fCurrentVertexStride != vertexStride ||
fCurrentInstanceBuffer != instanceBuffer.get() ||
fCurrentInstanceStride != instanceStride) {
fCurrentVertexBuffer = vertexBuffer.get();
fCurrentVertexStride = vertexStride;
fCurrentInstanceBuffer = instanceBuffer.get();
fCurrentInstanceStride = instanceStride;
D3D12_VERTEX_BUFFER_VIEW views[2];
int numViews = 0;
if (vertexBuffer) {
auto* d3dBuffer = static_cast<const GrD3DBuffer*>(vertexBuffer.get());
views[numViews].BufferLocation = d3dBuffer->d3dResource()->GetGPUVirtualAddress();
views[numViews].SizeInBytes = vertexBuffer->size();
views[numViews++].StrideInBytes = vertexStride;
this->addGrBuffer(std::move(vertexBuffer));
}
if (instanceBuffer) {
auto* d3dBuffer = static_cast<const GrD3DBuffer*>(instanceBuffer.get());
views[numViews].BufferLocation = d3dBuffer->d3dResource()->GetGPUVirtualAddress();
views[numViews].SizeInBytes = instanceBuffer->size();
views[numViews++].StrideInBytes = instanceStride;
this->addGrBuffer(std::move(instanceBuffer));
}
fCommandList->IASetVertexBuffers(startSlot, numViews, views);
}
}
void GrD3DDirectCommandList::setIndexBuffer(sk_sp<const GrBuffer> indexBuffer) {
if (fCurrentIndexBuffer != indexBuffer.get()) {
auto* d3dBuffer = static_cast<const GrD3DBuffer*>(indexBuffer.get());
D3D12_INDEX_BUFFER_VIEW view = {};
view.BufferLocation = d3dBuffer->d3dResource()->GetGPUVirtualAddress();
view.SizeInBytes = indexBuffer->size();
view.Format = DXGI_FORMAT_R16_UINT;
fCommandList->IASetIndexBuffer(&view);
fCurrentIndexBuffer = indexBuffer.get();
this->addGrBuffer(std::move(indexBuffer));
}
}
void GrD3DDirectCommandList::drawInstanced(unsigned int vertexCount, unsigned int instanceCount,
unsigned int startVertex, unsigned int startInstance) {
SkASSERT(fIsActive);
this->addingWork();
fCommandList->DrawInstanced(vertexCount, instanceCount, startVertex, startInstance);
}
void GrD3DDirectCommandList::drawIndexedInstanced(unsigned int indexCount,
unsigned int instanceCount,
unsigned int startIndex,
unsigned int baseVertex,
unsigned int startInstance) {
SkASSERT(fIsActive);
this->addingWork();
fCommandList->DrawIndexedInstanced(indexCount, instanceCount, startIndex, baseVertex,
startInstance);
}
void GrD3DDirectCommandList::executeIndirect(const sk_sp<GrD3DCommandSignature> commandSignature,
unsigned int maxCommandCount,
const GrD3DBuffer* argumentBuffer,
size_t argumentBufferOffset) {
SkASSERT(fIsActive);
this->addingWork();
this->addResource(commandSignature);
fCommandList->ExecuteIndirect(commandSignature->commandSignature(), maxCommandCount,
argumentBuffer->d3dResource(), argumentBufferOffset,
nullptr, 0);
this->addGrBuffer(sk_ref_sp<const GrBuffer>(argumentBuffer));
}
void GrD3DDirectCommandList::dispatch(unsigned int threadGroupCountX,
unsigned int threadGroupCountY,
unsigned int threadGroupCountZ) {
SkASSERT(fIsActive);
this->addingWork();
fCommandList->Dispatch(threadGroupCountX, threadGroupCountY, threadGroupCountZ);
}
void GrD3DDirectCommandList::clearRenderTargetView(const GrD3DRenderTarget* renderTarget,
std::array<float, 4> color,
const D3D12_RECT* rect) {
this->addingWork();
this->addResource(renderTarget->resource());
const GrD3DTextureResource* msaaTextureResource = renderTarget->msaaTextureResource();
if (msaaTextureResource && msaaTextureResource != renderTarget) {
this->addResource(msaaTextureResource->resource());
}
unsigned int numRects = rect ? 1 : 0;
fCommandList->ClearRenderTargetView(renderTarget->colorRenderTargetView(), color.data(),
numRects, rect);
}
void GrD3DDirectCommandList::clearDepthStencilView(const GrD3DAttachment* stencil,
uint8_t stencilClearValue,
const D3D12_RECT* rect) {
this->addingWork();
this->addResource(stencil->resource());
unsigned int numRects = rect ? 1 : 0;
fCommandList->ClearDepthStencilView(stencil->view(), D3D12_CLEAR_FLAG_STENCIL, 0,
stencilClearValue, numRects, rect);
}
void GrD3DDirectCommandList::setRenderTarget(const GrD3DRenderTarget* renderTarget) {
this->addingWork();
this->addResource(renderTarget->resource());
const GrD3DTextureResource* msaaTextureResource = renderTarget->msaaTextureResource();
if (msaaTextureResource && msaaTextureResource != renderTarget) {
this->addResource(msaaTextureResource->resource());
}
D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = renderTarget->colorRenderTargetView();
D3D12_CPU_DESCRIPTOR_HANDLE dsDescriptor;
D3D12_CPU_DESCRIPTOR_HANDLE* dsDescriptorPtr = nullptr;
if (auto stencil = renderTarget->getStencilAttachment()) {
GrD3DAttachment* d3dStencil = static_cast<GrD3DAttachment*>(stencil);
this->addResource(d3dStencil->resource());
dsDescriptor = d3dStencil->view();
dsDescriptorPtr = &dsDescriptor;
}
fCommandList->OMSetRenderTargets(1, &rtvDescriptor, false, dsDescriptorPtr);
}
void GrD3DDirectCommandList::resolveSubresourceRegion(const GrD3DTextureResource* dstTexture,
unsigned int dstX, unsigned int dstY,
const GrD3DTextureResource* srcTexture,
D3D12_RECT* srcRect) {
SkASSERT(dstTexture->dxgiFormat() == srcTexture->dxgiFormat());
SkASSERT(dstTexture->currentState() == D3D12_RESOURCE_STATE_RESOLVE_DEST);
SkASSERT(srcTexture->currentState() == D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
this->addingWork();
this->addResource(dstTexture->resource());
this->addResource(srcTexture->resource());
if (fResolveSubregionSupported) {
gr_cp<ID3D12GraphicsCommandList1> commandList1;
HRESULT result = fCommandList->QueryInterface(IID_PPV_ARGS(&commandList1));
if (SUCCEEDED(result)) {
commandList1->ResolveSubresourceRegion(dstTexture->d3dResource(), 0, dstX, dstY,
srcTexture->d3dResource(), 0, srcRect,
srcTexture->dxgiFormat(),
D3D12_RESOLVE_MODE_AVERAGE);
return;
}
}
fCommandList->ResolveSubresource(dstTexture->d3dResource(), 0, srcTexture->d3dResource(), 0,
srcTexture->dxgiFormat());
}
void GrD3DDirectCommandList::setGraphicsRootConstantBufferView(
unsigned int rootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS bufferLocation) {
SkASSERT(rootParameterIndex ==
(unsigned int) GrD3DRootSignature::ParamIndex::kConstantBufferView);
if (bufferLocation != fCurrentGraphicsConstantBufferAddress) {
fCommandList->SetGraphicsRootConstantBufferView(rootParameterIndex, bufferLocation);
fCurrentGraphicsConstantBufferAddress = bufferLocation;
}
}
void GrD3DDirectCommandList::setComputeRootConstantBufferView(
unsigned int rootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS bufferLocation) {
SkASSERT(rootParameterIndex ==
(unsigned int)GrD3DRootSignature::ParamIndex::kConstantBufferView);
if (bufferLocation != fCurrentComputeConstantBufferAddress) {
fCommandList->SetComputeRootConstantBufferView(rootParameterIndex, bufferLocation);
fCurrentComputeConstantBufferAddress = bufferLocation;
}
}
void GrD3DDirectCommandList::setGraphicsRootDescriptorTable(
unsigned int rootParameterIndex, D3D12_GPU_DESCRIPTOR_HANDLE baseDescriptor) {
SkASSERT(rootParameterIndex ==
(unsigned int)GrD3DRootSignature::ParamIndex::kSamplerDescriptorTable ||
rootParameterIndex ==
(unsigned int)GrD3DRootSignature::ParamIndex::kShaderViewDescriptorTable);
if (fCurrentGraphicsRootDescTable[rootParameterIndex].ptr != baseDescriptor.ptr) {
fCommandList->SetGraphicsRootDescriptorTable(rootParameterIndex, baseDescriptor);
fCurrentGraphicsRootDescTable[rootParameterIndex] = baseDescriptor;
}
}
void GrD3DDirectCommandList::setComputeRootDescriptorTable(
unsigned int rootParameterIndex, D3D12_GPU_DESCRIPTOR_HANDLE baseDescriptor) {
SkASSERT(rootParameterIndex ==
(unsigned int)GrD3DRootSignature::ParamIndex::kSamplerDescriptorTable ||
rootParameterIndex ==
(unsigned int)GrD3DRootSignature::ParamIndex::kShaderViewDescriptorTable);
if (fCurrentComputeRootDescTable[rootParameterIndex].ptr != baseDescriptor.ptr) {
fCommandList->SetComputeRootDescriptorTable(rootParameterIndex, baseDescriptor);
fCurrentComputeRootDescTable[rootParameterIndex] = baseDescriptor;
}
}
// We don't need to add these resources to the command list.
// They're added when we first allocate from a heap in a given submit.
void GrD3DDirectCommandList::setDescriptorHeaps(ID3D12DescriptorHeap* srvCrvDescriptorHeap,
ID3D12DescriptorHeap* samplerDescriptorHeap) {
if (srvCrvDescriptorHeap != fCurrentSRVCRVDescriptorHeap ||
samplerDescriptorHeap != fCurrentSamplerDescriptorHeap) {
ID3D12DescriptorHeap* heaps[2] = {
srvCrvDescriptorHeap,
samplerDescriptorHeap
};
fCommandList->SetDescriptorHeaps(2, heaps);
fCurrentSRVCRVDescriptorHeap = srvCrvDescriptorHeap;
fCurrentSamplerDescriptorHeap = samplerDescriptorHeap;
}
}
void GrD3DDirectCommandList::addSampledTextureRef(GrD3DTexture* texture) {
this->addResource(texture->resource());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
std::unique_ptr<GrD3DCopyCommandList> GrD3DCopyCommandList::Make(GrD3DGpu* gpu) {
ID3D12Device* device = gpu->device();
gr_cp<ID3D12CommandAllocator> allocator;
GR_D3D_CALL_ERRCHECK(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
IID_PPV_ARGS(&allocator)));
gr_cp<ID3D12GraphicsCommandList> commandList;
GR_D3D_CALL_ERRCHECK(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, allocator.get(),
nullptr, IID_PPV_ARGS(&commandList)));
auto grCL = new GrD3DCopyCommandList(std::move(allocator), std::move(commandList));
return std::unique_ptr<GrD3DCopyCommandList>(grCL);
}
GrD3DCopyCommandList::GrD3DCopyCommandList(gr_cp<ID3D12CommandAllocator> allocator,
gr_cp<ID3D12GraphicsCommandList> commandList)
: GrD3DCommandList(std::move(allocator), std::move(commandList)) {
}