Add indirect draws to D3D.

Adds GrD3D12CommandSignature, needed to pass to ExecuteIndirect().

Change-Id: I24aa395d710414eba0464aa4e2cb0a87721bcb12
Bug: skia:10482
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/301378
Reviewed-by: Chris Dalton <[email protected]>
Commit-Queue: Jim Van Verth <[email protected]>

Author: jvanverth

gn/gpu.gni

@@ -764,6 +764,8 @@ skia_direct3d_sources = [
   "$_src/gpu/d3d/GrD3DCaps.h",
   "$_src/gpu/d3d/GrD3DCommandList.cpp",
   "$_src/gpu/d3d/GrD3DCommandList.h",
+  "$_src/gpu/d3d/GrD3DCommandSignature.cpp",
+  "$_src/gpu/d3d/GrD3DCommandSignature.h",
   "$_src/gpu/d3d/GrD3DConstantRingBuffer.cpp",
   "$_src/gpu/d3d/GrD3DConstantRingBuffer.h",
   "$_src/gpu/d3d/GrD3DCpuDescriptorManager.cpp",

src/gpu/d3d/GrD3DBuffer.cpp

@@ -263,7 +263,7 @@ void GrD3DBuffer::validate() const {
     SkASSERT(!fResource ||
              this->intendedType() == GrGpuBufferType::kVertex ||
              this->intendedType() == GrGpuBufferType::kIndex ||
-             //this->intendedType() == GrGpuBufferType::kDrawIndirect ||
+             this->intendedType() == GrGpuBufferType::kDrawIndirect ||
              this->intendedType() == GrGpuBufferType::kXferCpuToGpu ||
              this->intendedType() == GrGpuBufferType::kXferGpuToCpu);
     SkASSERT(!fMappedResource || !fResource ||

src/gpu/d3d/GrD3DCaps.cpp

@@ -33,6 +33,7 @@ GrD3DCaps::GrD3DCaps(const GrContextOptions& contextOptions, IDXGIAdapter1* adap
     fGpuTracingSupport = false; //TODO: figure this out
     fOversizedStencilSupport = false; //TODO: figure this out
     fDrawInstancedSupport = true;
+    fNativeDrawIndirectSupport = true;
 
     fSemaphoreSupport = true;
     fFenceSyncSupport = true;

src/gpu/d3d/GrD3DCommandList.cpp

@@ -9,6 +9,7 @@
 
 #include "src/gpu/GrScissorState.h"
 #include "src/gpu/d3d/GrD3DBuffer.h"
+#include "src/gpu/d3d/GrD3DCommandSignature.h"
 #include "src/gpu/d3d/GrD3DGpu.h"
 #include "src/gpu/d3d/GrD3DPipelineState.h"
 #include "src/gpu/d3d/GrD3DRenderTarget.h"
@@ -338,6 +339,19 @@ void GrD3DDirectCommandList::drawIndexedInstanced(unsigned int indexCount,
                                        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);
+    this->addResource(argumentBuffer->resource());
+    fCommandList->ExecuteIndirect(commandSignature->commandSignature(), maxCommandCount,
+                                  argumentBuffer->d3dResource(), argumentBufferOffset,
+                                  nullptr, 0);
+}
+
 void GrD3DDirectCommandList::clearRenderTargetView(const GrD3DRenderTarget* renderTarget,
                                                    const SkPMColor4f& color,
                                                    const D3D12_RECT* rect) {
@@ -382,7 +396,7 @@ void GrD3DDirectCommandList::setRenderTarget(const GrD3DRenderTarget* renderTarg
 }
 
 void GrD3DDirectCommandList::resolveSubresourceRegion(const GrD3DTextureResource* dstTexture,
-                                                      UINT dstX, UINT dstY,
+                                                      unsigned int dstX, unsigned int dstY,
                                                       const GrD3DTextureResource* srcTexture,
                                                       D3D12_RECT* srcRect) {
     SkASSERT(dstTexture->dxgiFormat() == srcTexture->dxgiFormat());

src/gpu/d3d/GrD3DCommandList.h

@@ -18,6 +18,7 @@
 
 class GrD3DGpu;
 class GrD3DBuffer;
+class GrD3DCommandSignature;
 class GrD3DConstantRingBuffer;
 class GrD3DPipelineState;
 class GrD3DRenderTarget;
@@ -149,14 +150,16 @@ class GrD3DDirectCommandList : public GrD3DCommandList {
     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 clearRenderTargetView(const GrD3DRenderTarget* renderTarget, const SkPMColor4f& color,
                                const D3D12_RECT* rect);
     void clearDepthStencilView(const GrD3DStencilAttachment*, uint8_t stencilClearValue,
                                const D3D12_RECT* rect);
     void setRenderTarget(const GrD3DRenderTarget* renderTarget);
     void resolveSubresourceRegion(const GrD3DTextureResource* dstTexture,
-                                  UINT dstX, UINT dstY,
+                                  unsigned int dstX, unsigned int dstY,
                                   const GrD3DTextureResource* srcTexture,
                                   D3D12_RECT* srcRect);
 

src/gpu/d3d/GrD3DCommandSignature.cpp

@@ -0,0 +1,37 @@
+/*
+ * 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/GrD3DCommandSignature.h"
+
+#include "src/gpu/d3d/GrD3DGpu.h"
+
+sk_sp<GrD3DCommandSignature> GrD3DCommandSignature::Make(GrD3DGpu* gpu, ForIndexed forIndexed,
+                                                         unsigned int slot) {
+    bool indexed = (forIndexed == ForIndexed::kYes);
+    D3D12_INDIRECT_ARGUMENT_DESC argumentDesc = {};
+    argumentDesc.Type = indexed ? D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED
+                                : D3D12_INDIRECT_ARGUMENT_TYPE_DRAW;
+    argumentDesc.VertexBuffer.Slot = slot;
+
+    D3D12_COMMAND_SIGNATURE_DESC commandSigDesc = {};
+    commandSigDesc.ByteStride = indexed ? sizeof(D3D12_DRAW_INDEXED_ARGUMENTS)
+                                        : sizeof(D3D12_DRAW_ARGUMENTS);
+    commandSigDesc.NumArgumentDescs = 1;
+    commandSigDesc.pArgumentDescs = &argumentDesc;
+    commandSigDesc.NodeMask = 0;
+
+    gr_cp<ID3D12CommandSignature> commandSig;
+    HRESULT hr = gpu->device()->CreateCommandSignature(&commandSigDesc, nullptr,
+                                                       IID_PPV_ARGS(&commandSig));
+    if (!SUCCEEDED(hr)) {
+        SkDebugf("Failed to create command signature.\n");
+        return nullptr;
+    }
+
+    return sk_sp<GrD3DCommandSignature>(new GrD3DCommandSignature(std::move(commandSig),
+                                                                  forIndexed, slot));
+}

src/gpu/d3d/GrD3DCommandSignature.h

@@ -0,0 +1,55 @@
+/*
+ * 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 GrD3DCommandSignature_DEFINED
+#define GrD3DCommandSignature_DEFINED
+
+#include "include/gpu/d3d/GrD3DTypes.h"
+#include "src/gpu/GrManagedResource.h"
+
+class GrD3DGpu;
+
+class GrD3DCommandSignature : public GrManagedResource {
+public:
+    enum class ForIndexed : bool {
+        kYes = true,
+        kNo = false
+    };
+    static sk_sp<GrD3DCommandSignature> Make(GrD3DGpu* gpu, ForIndexed indexed, unsigned int slot);
+
+    bool isCompatible(ForIndexed indexed, unsigned int slot) const {
+        return (fIndexed == indexed && fSlot == slot);
+    }
+
+    ID3D12CommandSignature* commandSignature() const { return fCommandSignature.get(); }
+
+#ifdef SK_TRACE_MANAGED_RESOURCES
+    /** Output a human-readable dump of this resource's information
+    */
+    void dumpInfo() const override {
+        SkDebugf("GrD3DCommandSignature: %p, (%d refs)\n",
+                 fCommandSignature.get(), this->getRefCnt());
+    }
+#endif
+
+private:
+    GrD3DCommandSignature(gr_cp<ID3D12CommandSignature> commandSignature, ForIndexed indexed,
+                          unsigned int slot)
+        : fCommandSignature(commandSignature)
+        , fIndexed(indexed)
+        , fSlot(slot) {}
+
+    // This will be called right before this class is destroyed and there is no reason to explicitly
+    // release the fCommandSignature cause the gr_cp will handle that in the dtor.
+    void freeGPUData() const override {}
+
+    gr_cp<ID3D12CommandSignature> fCommandSignature;
+    ForIndexed fIndexed;
+    unsigned int fSlot;
+};
+
+#endif

src/gpu/d3d/GrD3DOpsRenderPass.cpp

@@ -13,6 +13,7 @@
 #include "src/gpu/GrRenderTargetPriv.h"
 #include "src/gpu/GrStencilSettings.h"
 #include "src/gpu/d3d/GrD3DBuffer.h"
+#include "src/gpu/d3d/GrD3DCommandSignature.h"
 #include "src/gpu/d3d/GrD3DGpu.h"
 #include "src/gpu/d3d/GrD3DPipelineState.h"
 #include "src/gpu/d3d/GrD3DPipelineStateBuilder.h"
@@ -259,6 +260,26 @@ void GrD3DOpsRenderPass::onDrawIndexedInstanced(int indexCount, int baseIndex, i
     fGpu->stats()->incNumDraws();
 }
 
+void GrD3DOpsRenderPass::onDrawIndirect(const GrBuffer* buffer, size_t offset, int drawCount) {
+    constexpr unsigned int kSlot = 0;
+    sk_sp<GrD3DCommandSignature> cmdSig = fGpu->resourceProvider().findOrCreateCommandSignature(
+            GrD3DCommandSignature::ForIndexed::kNo, kSlot);
+    fGpu->currentCommandList()->executeIndirect(cmdSig, drawCount,
+                                                static_cast<const GrD3DBuffer*>(buffer), offset);
+    fGpu->stats()->incNumDraws();
+}
+
+void GrD3DOpsRenderPass::onDrawIndexedIndirect(const GrBuffer* buffer, size_t offset,
+                                               int drawCount) {
+    constexpr unsigned int kSlot = 0;
+    sk_sp<GrD3DCommandSignature> cmdSig = fGpu->resourceProvider().findOrCreateCommandSignature(
+            GrD3DCommandSignature::ForIndexed::kYes, kSlot);
+    fGpu->currentCommandList()->executeIndirect(cmdSig, drawCount,
+                                                static_cast<const GrD3DBuffer*>(buffer), offset);
+    fGpu->stats()->incNumDraws();
+}
+
+
 static D3D12_RECT scissor_to_d3d_clear_rect(const GrScissorState& scissor,
                                             const GrSurface* surface,
                                             GrSurfaceOrigin origin) {

src/gpu/d3d/GrD3DOpsRenderPass.h

@@ -53,8 +53,8 @@ class GrD3DOpsRenderPass : public GrOpsRenderPass {
                          int baseVertex) override;
     void onDrawIndexedInstanced(int indexCount, int baseIndex, int instanceCount, int baseInstance,
                                 int baseVertex) override;
-    void onDrawIndirect(const GrBuffer*, size_t offset, int drawCount) override {}
-    void onDrawIndexedIndirect(const GrBuffer*, size_t offset, int drawCount) override {}
+    void onDrawIndirect(const GrBuffer*, size_t offset, int drawCount) override;
+    void onDrawIndexedIndirect(const GrBuffer*, size_t offset, int drawCount) override;
 
     void onClear(const GrScissorState& scissor, const SkPMColor4f& color) override;
 

src/gpu/d3d/GrD3DResourceProvider.cpp

@@ -59,6 +59,21 @@ sk_sp<GrD3DRootSignature> GrD3DResourceProvider::findOrCreateRootSignature(int n
     return rootSig;
 }
 
+sk_sp<GrD3DCommandSignature> GrD3DResourceProvider::findOrCreateCommandSignature(
+        GrD3DCommandSignature::ForIndexed indexed, unsigned int slot) {
+    for (int i = 0; i < fCommandSignatures.count(); ++i) {
+        if (fCommandSignatures[i]->isCompatible(indexed, slot)) {
+            return fCommandSignatures[i];
+        }
+    }
+
+    auto commandSig = GrD3DCommandSignature::Make(fGpu, indexed, slot);
+    if (!commandSig) {
+        return nullptr;
+    }
+    fCommandSignatures.push_back(commandSig);
+    return commandSig;
+}
 
 GrD3DDescriptorHeap::CPUHandle GrD3DResourceProvider::createRenderTargetView(
         ID3D12Resource* textureResource) {

src/gpu/d3d/GrD3DResourceProvider.h

@@ -13,13 +13,15 @@
 #include "include/private/SkTHash.h"
 #include "src/core/SkLRUCache.h"
 #include "src/gpu/GrProgramDesc.h"
+#include "src/gpu/d3d/GrD3DCommandSignature.h"
 #include "src/gpu/d3d/GrD3DConstantRingBuffer.h"
 #include "src/gpu/d3d/GrD3DCpuDescriptorManager.h"
 #include "src/gpu/d3d/GrD3DDescriptorTableManager.h"
 #include "src/gpu/d3d/GrD3DRootSignature.h"
 
 #include <memory>
 
+class GrD3DCommandSignature;
 class GrD3DDirectCommandList;
 class GrD3DGpu;
 class GrD3DPipelineState;
@@ -37,6 +39,9 @@ class GrD3DResourceProvider {
 
     sk_sp<GrD3DRootSignature> findOrCreateRootSignature(int numTextureSamplers);
 
+    sk_sp<GrD3DCommandSignature> findOrCreateCommandSignature(GrD3DCommandSignature::ForIndexed,
+                                                              unsigned int slot);
+
     GrD3DDescriptorHeap::CPUHandle createRenderTargetView(ID3D12Resource* textureResource);
     void recycleRenderTargetView(const GrD3DDescriptorHeap::CPUHandle&);
 
@@ -108,6 +113,7 @@ class GrD3DResourceProvider {
 
     SkSTArray<4, std::unique_ptr<GrD3DDirectCommandList>> fAvailableDirectCommandLists;
     SkSTArray<4, sk_sp<GrD3DRootSignature>> fRootSignatures;
+    SkSTArray<2, sk_sp<GrD3DCommandSignature>> fCommandSignatures;
 
     GrD3DCpuDescriptorManager fCpuDescriptorManager;
     GrD3DDescriptorTableManager fDescriptorTableManager;

src/gpu/d3d/GrD3DRootSignature.h

@@ -43,7 +43,6 @@ class GrD3DRootSignature : public GrManagedResource {
     // release the fRootSignature cause the gr_cp will handle that in the dtor.
     void freeGPUData() const override {}
 
-    // mutable needed so we can release the resource in freeGPUData
     gr_cp<ID3D12RootSignature> fRootSignature;
     int fNumTextureSamplers;
 };