Implement instanced and indirect draw calls (#2053)

* Added implementations of drawInstanced, drawIndexedInstanced, drawIndirect, and drawIndexedIndirect to both render-d3d12 and render-vk

* drawInstanced test WIP

* Draw calls implemented, working on debugging test

* Added new test and accompanying shader file

* Fixes.

* Fixes.

Co-authored-by: Yong He <yhe@nvidia.com>
Co-authored-by: Yong He <yonghe@outlook.com>

5 files changed, 285 insertions, 5 deletions

diff --git a/tools/gfx-unit-test/draw-instanced-test.cpp b/tools/gfx-unit-test/draw-instanced-test.cpp
new file mode 100644
index 000000000..e15e6beda
--- /dev/null
+++ b/tools/gfx-unit-test/draw-instanced-test.cpp
@@ -0,0 +1,156 @@
+#include "tools/unit-test/slang-unit-test.h"
+
+#include "slang-gfx.h"
+#include "gfx-test-util.h"
+#include "tools/gfx-util/shader-cursor.h"
+#include "source/core/slang-basic.h"
+
+using namespace gfx;
+
+namespace gfx_test
+{
+    struct Vertex
+    {
+        float position[3];
+        float color[3];
+    };
+
+    static const int kVertexCount = 3;
+    static const Vertex kVertexData[kVertexCount] =
+    {
+        { { -1, -1, 0.5 }, { 1, 0, 0 } },
+        { { -1,  3, 0.5 }, { 1, 0, 0 } },
+        { {  3, -1, 0.5 }, { 1, 0, 0 } },
+    };
+
+    void drawInstancedTestImpl(IDevice* device, UnitTestContext* context)
+    {
+        Slang::ComPtr<ITransientResourceHeap> transientHeap;
+        ITransientResourceHeap::Desc transientHeapDesc = {};
+        transientHeapDesc.constantBufferSize = 4096;
+        GFX_CHECK_CALL_ABORT(
+            device->createTransientResourceHeap(transientHeapDesc, transientHeap.writeRef()));
+
+        ComPtr<IShaderProgram> shaderProgram;
+        slang::ProgramLayout* slangReflection;
+        GFX_CHECK_CALL_ABORT(loadGraphicsProgram(device, shaderProgram, "graphics-smoke", "vertexMain", "fragmentMain", slangReflection));
+
+        Format format = Format::R32G32B32A32_FLOAT;
+
+        InputElementDesc inputElements[] = {
+            { "POSITION", 0, Format::R32G32B32_FLOAT, offsetof(Vertex, position) },
+            { "COLOR",    0, Format::R32G32B32_FLOAT, offsetof(Vertex, color) },
+        };
+        ComPtr<gfx::IInputLayout> inputLayout = device->createInputLayout(inputElements, 2);
+        SLANG_CHECK_ABORT(inputLayout != nullptr);
+
+        IBufferResource::Desc vertexBufferDesc;
+        vertexBufferDesc.type = IResource::Type::Buffer;
+        vertexBufferDesc.sizeInBytes = kVertexCount * sizeof(Vertex);
+        vertexBufferDesc.defaultState = ResourceState::VertexBuffer;
+        vertexBufferDesc.allowedStates = ResourceState::VertexBuffer;
+        ComPtr<IBufferResource> vertexBuffer = device->createBufferResource(vertexBufferDesc, &kVertexData[0]);
+        SLANG_CHECK_ABORT(vertexBuffer != nullptr);
+
+        IFramebufferLayout::AttachmentLayout attachmentLayout;
+        attachmentLayout.format = format;
+        attachmentLayout.sampleCount = 1;
+
+        IFramebufferLayout::Desc framebufferLayoutDesc;
+        framebufferLayoutDesc.renderTargetCount = 1;
+        framebufferLayoutDesc.renderTargets = &attachmentLayout;
+        ComPtr<gfx::IFramebufferLayout> framebufferLayout = device->createFramebufferLayout(framebufferLayoutDesc);
+
+        GraphicsPipelineStateDesc pipelineDesc = {};
+        pipelineDesc.program = shaderProgram.get();
+        pipelineDesc.inputLayout = inputLayout;
+        pipelineDesc.framebufferLayout = framebufferLayout;
+        pipelineDesc.depthStencil.depthTestEnable = false;
+        pipelineDesc.depthStencil.depthWriteEnable = false;
+        ComPtr<gfx::IPipelineState> pipelineState;
+        GFX_CHECK_CALL_ABORT(
+            device->createGraphicsPipelineState(pipelineDesc, pipelineState.writeRef()));
+
+        ICommandQueue::Desc queueDesc = { ICommandQueue::QueueType::Graphics };
+        auto queue = device->createCommandQueue(queueDesc);
+        auto commandBuffer = transientHeap->createCommandBuffer();
+
+        IRenderPassLayout::Desc renderPassDesc = {};
+        renderPassDesc.framebufferLayout = framebufferLayout;
+        renderPassDesc.renderTargetCount = 1;
+        IRenderPassLayout::AttachmentAccessDesc renderTargetAccess = {};
+        renderTargetAccess.loadOp = IRenderPassLayout::AttachmentLoadOp::Clear;
+        renderTargetAccess.storeOp = IRenderPassLayout::AttachmentStoreOp::Store;
+        renderTargetAccess.initialState = ResourceState::Undefined;
+        renderTargetAccess.finalState = ResourceState::CopySource;
+        renderPassDesc.renderTargetAccess = &renderTargetAccess;
+        ComPtr<IRenderPassLayout> renderPass = device->createRenderPassLayout(renderPassDesc);
+
+        const int width = 2;
+        const int height = 2;
+
+        gfx::ITextureResource::Desc colorBufferDesc;
+        colorBufferDesc.type = IResource::Type::Texture2D;
+        colorBufferDesc.size.width = width;
+        colorBufferDesc.size.height = height;
+        colorBufferDesc.size.depth = 1;
+        colorBufferDesc.numMipLevels = 1;
+        colorBufferDesc.format = format;
+        colorBufferDesc.defaultState = ResourceState::RenderTarget;
+        colorBufferDesc.allowedStates = { ResourceState::RenderTarget, ResourceState::CopySource };
+        ComPtr<ITextureResource> colorBuffer = device->createTextureResource(colorBufferDesc, nullptr);
+
+        gfx::IResourceView::Desc colorBufferViewDesc;
+        memset(&colorBufferViewDesc, 0, sizeof(colorBufferViewDesc));
+        colorBufferViewDesc.format = format;
+        colorBufferViewDesc.renderTarget.shape = gfx::IResource::Type::Texture2D;
+        colorBufferViewDesc.type = gfx::IResourceView::Type::RenderTarget;
+        ComPtr<gfx::IResourceView> rtv =
+            device->createTextureView(colorBuffer.get(), colorBufferViewDesc);
+
+        gfx::IFramebuffer::Desc framebufferDesc;
+        framebufferDesc.renderTargetCount = 1;
+        framebufferDesc.depthStencilView = nullptr;
+        framebufferDesc.renderTargetViews = rtv.readRef();
+        framebufferDesc.layout = framebufferLayout;
+        ComPtr<gfx::IFramebuffer> framebuffer = device->createFramebuffer(framebufferDesc);
+
+        auto encoder = commandBuffer->encodeRenderCommands(renderPass, framebuffer);
+        auto rootObject = encoder->bindPipeline(pipelineState);
+
+        UInt vertexCount = 3;
+        UInt instanceCount = 1;
+        UInt startVertex = 0;
+        UInt startInstanceLocation = 0;
+
+        gfx::Viewport viewport = {};
+        viewport.maxZ = 1.0f;
+        viewport.extentX = width;
+        viewport.extentY = height;
+        encoder->setViewportAndScissor(viewport);
+
+        encoder->setVertexBuffer(0, vertexBuffer, sizeof(Vertex));
+        encoder->setPrimitiveTopology(PrimitiveTopology::TriangleList);
+        encoder->drawInstanced(vertexCount, instanceCount, startVertex, startInstanceLocation);
+        encoder->endEncoding();
+        commandBuffer->close();
+        queue->executeCommandBuffer(commandBuffer);
+        queue->waitOnHost();
+
+        float expectedResult[] = { 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
+                                   1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f };
+        compareComputeResult(device, colorBuffer, ResourceState::CopySource, expectedResult, 32, 2);
+    }
+
+    SLANG_UNIT_TEST(drawInstancedD3D12)
+    {
+        runTestImpl(drawInstancedTestImpl, unitTestContext, Slang::RenderApiFlag::D3D12);
+    }
+
+#if 0
+    SLANG_UNIT_TEST(drawInstancedVulkan)
+    {
+        runTestImpl(drawInstancedTestImpl, unitTestContext, Slang::RenderApiFlag::Vulkan);
+    }
+#endif
+    }
diff --git a/tools/gfx-unit-test/gfx-test-util.cpp b/tools/gfx-unit-test/gfx-test-util.cpp
index e1da919d8..619d2feb0 100644
--- a/tools/gfx-unit-test/gfx-test-util.cpp
+++ b/tools/gfx-unit-test/gfx-test-util.cpp
@@ -65,7 +65,61 @@ namespace gfx_test
         return SLANG_OK;
     }
 
-    void compareComputeResult(gfx::IDevice* device, gfx::ITextureResource* texture, gfx::ResourceState state, float* expectedResult, size_t expectedBufferSize)
+    Slang::Result loadGraphicsProgram(
+        gfx::IDevice* device,
+        Slang::ComPtr<gfx::IShaderProgram>& outShaderProgram,
+        const char* shaderModuleName,
+        const char* vertexEntryPointName,
+        const char* fragmentEntryPointName,
+        slang::ProgramLayout*& slangReflection)
+    {
+        Slang::ComPtr<slang::ISession> slangSession;
+        SLANG_RETURN_ON_FAIL(device->getSlangSession(slangSession.writeRef()));
+        Slang::ComPtr<slang::IBlob> diagnosticsBlob;
+        slang::IModule* module = slangSession->loadModule(shaderModuleName, diagnosticsBlob.writeRef());
+        diagnoseIfNeeded(diagnosticsBlob);
+        if (!module)
+            return SLANG_FAIL;
+
+        ComPtr<slang::IEntryPoint> vertexEntryPoint;
+        SLANG_RETURN_ON_FAIL(
+            module->findEntryPointByName(vertexEntryPointName, vertexEntryPoint.writeRef()));
+
+        ComPtr<slang::IEntryPoint> fragmentEntryPoint;
+        SLANG_RETURN_ON_FAIL(
+            module->findEntryPointByName(fragmentEntryPointName, fragmentEntryPoint.writeRef()));
+
+        Slang::List<slang::IComponentType*> componentTypes;
+        componentTypes.add(module);
+        componentTypes.add(vertexEntryPoint);
+        componentTypes.add(fragmentEntryPoint);
+
+        Slang::ComPtr<slang::IComponentType> composedProgram;
+        SlangResult result = slangSession->createCompositeComponentType(
+            componentTypes.getBuffer(),
+            componentTypes.getCount(),
+            composedProgram.writeRef(),
+            diagnosticsBlob.writeRef());
+        diagnoseIfNeeded(diagnosticsBlob);
+        SLANG_RETURN_ON_FAIL(result);
+        slangReflection = composedProgram->getLayout();
+
+        gfx::IShaderProgram::Desc programDesc = {};
+        programDesc.slangProgram = composedProgram.get();
+
+        auto shaderProgram = device->createProgram(programDesc);
+
+        outShaderProgram = shaderProgram;
+        return SLANG_OK;
+    }
+
+    void compareComputeResult(
+        gfx::IDevice* device,
+        gfx::ITextureResource* texture,
+        gfx::ResourceState state,
+        float* expectedResult,
+        size_t expectedResultRowPitch,
+        size_t rowCount)
     {
         // Read back the results.
         ComPtr<ISlangBlob> resultBlob;
@@ -73,10 +127,16 @@ namespace gfx_test
         size_t pixelSize = 0;
         GFX_CHECK_CALL_ABORT(device->readTextureResource(
             texture, state, resultBlob.writeRef(), &rowPitch, &pixelSize));
-        SLANG_CHECK(resultBlob->getBufferSize() == expectedBufferSize);
         auto result = (float*)resultBlob->getBufferPointer();
         // Compare results.
-        SLANG_CHECK(memcmp(resultBlob->getBufferPointer(), expectedResult, expectedBufferSize) == 0);
+        for (size_t row = 0; row < rowCount; row++)
+        {
+            SLANG_CHECK(
+                memcmp(
+                    (uint8_t*)resultBlob->getBufferPointer() + rowPitch * row,
+                    (uint8_t*)expectedResult + expectedResultRowPitch * row,
+                    expectedResultRowPitch) == 0);
+        }
     }
 
     void compareComputeResult(gfx::IDevice* device, gfx::IBufferResource* buffer, uint8_t* expectedResult, size_t expectedBufferSize)
diff --git a/tools/gfx-unit-test/gfx-test-util.h b/tools/gfx-unit-test/gfx-test-util.h
index 07513c39a..addcb151b 100644
--- a/tools/gfx-unit-test/gfx-test-util.h
+++ b/tools/gfx-unit-test/gfx-test-util.h
@@ -18,6 +18,14 @@ namespace gfx_test
         const char* entryPointName,
         slang::ProgramLayout*& slangReflection);
 
+    Slang::Result loadGraphicsProgram(
+        gfx::IDevice* device,
+        Slang::ComPtr<gfx::IShaderProgram>& outShaderProgram,
+        const char* shaderModuleName,
+        const char* vertexEntryPointName,
+        const char* fragmentEntryPointName,
+        slang::ProgramLayout*& slangReflection);
+
         /// Reads back the content of `buffer` and compares it against `expectedResult`.
     void compareComputeResult(
         gfx::IDevice* device,
@@ -31,7 +39,8 @@ namespace gfx_test
         gfx::ITextureResource* texture,
         gfx::ResourceState state,
         float* expectedResult,
-        size_t expectedBufferSize);
+        size_t expectedResultRowPitch,
+        size_t rowCount);
 
         /// Reads back the content of `buffer` and compares it against `expectedResult` with a set tolerance.
     void compareComputeResultFuzzy(
diff --git a/tools/gfx-unit-test/graphics-smoke.slang b/tools/gfx-unit-test/graphics-smoke.slang
new file mode 100644
index 000000000..145b83a62
--- /dev/null
+++ b/tools/gfx-unit-test/graphics-smoke.slang
@@ -0,0 +1,54 @@
+// graphics-smoke.slang
+
+// Per-vertex attributes to be assembled from bound vertex buffers.
+struct AssembledVertex
+{
+    float3	position : POSITION;
+    float3	color    : COLOR;
+};
+
+// Output of the vertex shader, and input to the fragment shader.
+struct CoarseVertex
+{
+    float3 color;
+};
+
+// Output of the fragment shader
+struct Fragment
+{
+    float4 color;
+};
+
+// Vertex  Shader
+
+struct VertexStageOutput
+{
+    CoarseVertex    coarseVertex    : CoarseVertex;
+    float4          sv_position     : SV_Position;
+};
+
+[shader("vertex")]
+VertexStageOutput vertexMain(
+    AssembledVertex assembledVertex)
+{
+    VertexStageOutput output;
+
+    float3 position = assembledVertex.position;
+    float3 color    = assembledVertex.color;
+
+    output.coarseVertex.color = color;
+    output.sv_position = float4(position, 1.0);
+
+    return output;
+}
+
+// Fragment Shader
+
+[shader("fragment")]
+float4 fragmentMain(
+    CoarseVertex coarseVertex : CoarseVertex) : SV_Target
+{
+    float3 color = coarseVertex.color;
+
+    return float4(color, 1.0);
+}
diff --git a/tools/gfx-unit-test/shared-textures-tests.cpp b/tools/gfx-unit-test/shared-textures-tests.cpp
index 896d6d6e6..d32a8493e 100644
--- a/tools/gfx-unit-test/shared-textures-tests.cpp
+++ b/tools/gfx-unit-test/shared-textures-tests.cpp
@@ -184,7 +184,8 @@ namespace gfx_test
                 dstTexture,
                 ResourceState::ShaderResource,
                 texData,
-                sizeof(texData));
+                32,
+                2);
 
             auto texView = createTexView(dstDevice, dstTexture);
             setUpAndRunShader(dstDevice, dstTexture, texView, floatBufferView, "copyTexFloat4");