blob: 2765bc74fe42537cbf795aa59fb68461c4408b23 [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.
*/
#ifndef GrD3DCommandList_DEFINED
#define GrD3DCommandList_DEFINED
#include "include/gpu/GrTypes.h"
#include "include/gpu/d3d/GrD3DTypes.h"
#include "src/gpu/ganesh/GrManagedResource.h"
#include "src/gpu/ganesh/GrRingBuffer.h"
#include "src/gpu/ganesh/d3d/GrD3DRootSignature.h"
#include <memory>
class GrD3DGpu;
class GrD3DBuffer;
class GrD3DCommandSignature;
class GrD3DConstantRingBuffer;
class GrD3DPipeline;
class GrD3DRenderTarget;
class GrD3DRootSignature;
class GrD3DAttachment;
class GrD3DTexture;
class GrD3DTextureResource;
class GrScissorState;
class GrD3DCommandList {
public:
virtual ~GrD3DCommandList() {
this->releaseResources();
}
enum class SubmitResult {
kNoWork,
kSuccess,
kFailure,
};
SubmitResult submit(ID3D12CommandQueue* queue);
bool close();
void reset();
////////////////////////////////////////////////////////////////////////////
// GraphicsCommandList commands
////////////////////////////////////////////////////////////////////////////
// All barriers should reference subresources of managedResource
void resourceBarrier(sk_sp<GrManagedResource> managedResource,
int numBarriers,
const D3D12_RESOURCE_TRANSITION_BARRIER* barriers);
void uavBarrier(sk_sp<GrManagedResource> managedResource,
ID3D12Resource* uavResource);
void aliasingBarrier(sk_sp<GrManagedResource> beforeManagedResource,
ID3D12Resource* beforeResource,
sk_sp<GrManagedResource> afterManagedResource,
ID3D12Resource* afterResource);
// Helper method that calls copyTextureRegion multiple times, once for each subresource
// The srcBuffer comes from a staging buffer so we don't need to take any refs to it. Instead,
// we ref the whole buffer during sumbit.
void copyBufferToTexture(ID3D12Resource* srcBuffer,
const GrD3DTextureResource* dstTexture,
uint32_t subresourceCount,
D3D12_PLACED_SUBRESOURCE_FOOTPRINT* bufferFootprints,
int left, int top);
void 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);
void 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);
void copyTextureToTexture(const GrD3DTexture* dst,
const GrD3DTexture* src,
UINT subresourceIndex = -1);
// We don't take a ref to the src buffer because we assume the src buffer is coming from a
// staging buffer which will get ref'd during submit.
void copyBufferToBuffer(sk_sp<GrD3DBuffer> dstBuffer, uint64_t dstOffset,
ID3D12Resource* srcBuffer, uint64_t srcOffset,
uint64_t numBytes);
void addGrBuffer(sk_sp<const GrBuffer> buffer) {
fTrackedGpuBuffers.push_back(std::move(buffer));
}
// Add ref-counted resource that will be tracked and released when this command buffer finishes
// execution. When it is released, it will signal that the resource can be recycled for reuse.
void addRecycledResource(sk_sp<GrRecycledResource> resource) {
fTrackedRecycledResources.push_back(std::move(resource));
}
void releaseResources();
bool hasWork() const { return fHasWork; }
void addFinishedCallback(sk_sp<skgpu::RefCntedCallback> callback);
private:
static const int kInitialTrackedResourcesCount = 32;
protected:
GrD3DCommandList(gr_cp<ID3D12CommandAllocator> allocator,
gr_cp<ID3D12GraphicsCommandList> commandList);
// Add ref-counted resource that will be tracked and released when this command buffer finishes
// execution
void addResource(sk_sp<GrManagedResource> resource) {
SkASSERT(resource);
fTrackedResources.push_back(std::move(resource));
}
void addingWork();
virtual void onReset() {}
void submitResourceBarriers();
gr_cp<ID3D12GraphicsCommandList> fCommandList;
SkSTArray<kInitialTrackedResourcesCount, sk_sp<GrManagedResource>> fTrackedResources;
SkSTArray<kInitialTrackedResourcesCount, sk_sp<GrRecycledResource>> fTrackedRecycledResources;
SkSTArray<kInitialTrackedResourcesCount, sk_sp<const GrBuffer>> fTrackedGpuBuffers;
// When we create a command list it starts in an active recording state
SkDEBUGCODE(bool fIsActive = true;)
bool fHasWork = false;
private:
void callFinishedCallbacks() { fFinishedCallbacks.clear(); }
gr_cp<ID3D12CommandAllocator> fAllocator;
SkSTArray<4, D3D12_RESOURCE_BARRIER> fResourceBarriers;
SkTArray<sk_sp<skgpu::RefCntedCallback>> fFinishedCallbacks;
};
class GrD3DDirectCommandList : public GrD3DCommandList {
public:
static std::unique_ptr<GrD3DDirectCommandList> Make(GrD3DGpu* gpu);
~GrD3DDirectCommandList() override = default;
void setPipelineState(const sk_sp<GrD3DPipeline>& pipeline);
void setStencilRef(unsigned int stencilRef);
void setBlendFactor(const float blendFactor[4]);
void setPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY primitiveTopology);
void setScissorRects(unsigned int numRects, const D3D12_RECT* rects);
void setViewports(unsigned int numViewports, const D3D12_VIEWPORT* viewports);
void setGraphicsRootSignature(const sk_sp<GrD3DRootSignature>& rootSignature);
void setComputeRootSignature(const sk_sp<GrD3DRootSignature>& rootSignature);
void setVertexBuffers(unsigned int startSlot,
sk_sp<const GrBuffer> vertexBuffer, size_t vertexStride,
sk_sp<const GrBuffer> instanceBuffer, size_t instanceStride);
void setIndexBuffer(sk_sp<const GrBuffer> indexBuffer);
void drawInstanced(unsigned int vertexCount, unsigned int instanceCount,
unsigned int startVertex, unsigned int startInstance);
void drawIndexedInstanced(unsigned int indexCount, unsigned int instanceCount,
unsigned int startIndex, unsigned int baseVertex,
unsigned int startInstance);
void executeIndirect(const sk_sp<GrD3DCommandSignature> commandSig, unsigned int maxCommandCnt,
const GrD3DBuffer* argumentBuffer, size_t argumentBufferOffset);
void dispatch(unsigned int threadGroupCountX, unsigned int threadGroupCountY,
unsigned int threadGroupCountZ = 1);
void clearRenderTargetView(const GrD3DRenderTarget* renderTarget,
std::array<float, 4> color,
const D3D12_RECT* rect);
void clearDepthStencilView(const GrD3DAttachment*,
uint8_t stencilClearValue,
const D3D12_RECT* rect);
void setRenderTarget(const GrD3DRenderTarget* renderTarget);
void resolveSubresourceRegion(const GrD3DTextureResource* dstTexture,
unsigned int dstX, unsigned int dstY,
const GrD3DTextureResource* srcTexture,
D3D12_RECT* srcRect);
void setGraphicsRootConstantBufferView(unsigned int rootParameterIndex,
D3D12_GPU_VIRTUAL_ADDRESS bufferLocation);
void setGraphicsRootDescriptorTable(unsigned int rootParameterIndex,
D3D12_GPU_DESCRIPTOR_HANDLE bufferLocation);
void setComputeRootConstantBufferView(unsigned int rootParameterIndex,
D3D12_GPU_VIRTUAL_ADDRESS bufferLocation);
void setComputeRootDescriptorTable(unsigned int rootParameterIndex,
D3D12_GPU_DESCRIPTOR_HANDLE bufferLocation);
void setDescriptorHeaps(ID3D12DescriptorHeap* srvDescriptorHeap,
ID3D12DescriptorHeap* samplerDescriptorHeap);
void addSampledTextureRef(GrD3DTexture*);
private:
GrD3DDirectCommandList(gr_cp<ID3D12CommandAllocator> allocator,
gr_cp<ID3D12GraphicsCommandList> commandList,
bool resolveSubregionSupported);
void onReset() override;
const GrD3DPipeline* fCurrentPipeline = nullptr;
const GrD3DRootSignature* fCurrentGraphicsRootSignature = nullptr;
const GrD3DRootSignature* fCurrentComputeRootSignature = nullptr;
const GrBuffer* fCurrentVertexBuffer = nullptr;
size_t fCurrentVertexStride = 0;
const GrBuffer* fCurrentInstanceBuffer = nullptr;
size_t fCurrentInstanceStride = 0;
const GrBuffer* fCurrentIndexBuffer = nullptr;
D3D12_GPU_VIRTUAL_ADDRESS fCurrentGraphicsConstantBufferAddress = 0;
D3D12_GPU_VIRTUAL_ADDRESS fCurrentComputeConstantBufferAddress = 0;
D3D12_GPU_DESCRIPTOR_HANDLE fCurrentGraphicsRootDescTable[GrD3DRootSignature::kParamIndexCount];
D3D12_GPU_DESCRIPTOR_HANDLE fCurrentComputeRootDescTable[GrD3DRootSignature::kParamIndexCount];
const ID3D12DescriptorHeap* fCurrentSRVCRVDescriptorHeap = nullptr;
const ID3D12DescriptorHeap* fCurrentSamplerDescriptorHeap = nullptr;
bool fResolveSubregionSupported;
};
class GrD3DCopyCommandList : public GrD3DCommandList {
public:
static std::unique_ptr<GrD3DCopyCommandList> Make(GrD3DGpu* gpu);
private:
GrD3DCopyCommandList(gr_cp<ID3D12CommandAllocator> allocator,
gr_cp<ID3D12GraphicsCommandList> commandList);
};
#endif