Various gfx fixes. (#2132)

* Various gfx fixes.

* Fix test case.

* Fix crash.

* Trigger build

* Trigger build 2

* Fix vulkan unit tests.

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

1 files changed, 160 insertions, 0 deletions

diff --git a/tools/gfx-unit-test/sampler-array.cpp b/tools/gfx-unit-test/sampler-array.cpp
new file mode 100644
index 000000000..58e48e13d
--- /dev/null
+++ b/tools/gfx-unit-test/sampler-array.cpp
@@ -0,0 +1,160 @@
+#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
+{
+    static ComPtr<IBufferResource> createBuffer(IDevice* device, uint32_t content)
+    {
+        ComPtr<IBufferResource> buffer;
+        IBufferResource::Desc bufferDesc = {};
+        bufferDesc.sizeInBytes = sizeof(uint32_t);
+        bufferDesc.format = gfx::Format::Unknown;
+        bufferDesc.elementSize = sizeof(float);
+        bufferDesc.allowedStates = ResourceStateSet(
+            ResourceState::ShaderResource,
+            ResourceState::UnorderedAccess,
+            ResourceState::CopyDestination,
+            ResourceState::CopySource);
+        bufferDesc.defaultState = ResourceState::UnorderedAccess;
+        bufferDesc.memoryType = MemoryType::DeviceLocal;
+
+        ComPtr<IBufferResource> numbersBuffer;
+        GFX_CHECK_CALL_ABORT(
+            device->createBufferResource(bufferDesc, (void*)&content, buffer.writeRef()));
+
+        return buffer;
+    }
+    void samplerArrayTestImpl(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(loadComputeProgram(device, shaderProgram, "sampler-array", "computeMain", slangReflection));
+
+        ComputePipelineStateDesc pipelineDesc = {};
+        pipelineDesc.program = shaderProgram.get();
+        ComPtr<gfx::IPipelineState> pipelineState;
+        GFX_CHECK_CALL_ABORT(
+            device->createComputePipelineState(pipelineDesc, pipelineState.writeRef()));
+
+        Slang::List<ComPtr<ISamplerState>> samplers;
+        Slang::List<ComPtr<IResourceView>> srvs;
+        ComPtr<IResourceView> uav;
+        ComPtr<ITextureResource> texture;
+        ComPtr<IBufferResource> buffer = createBuffer(device, 0);
+
+        {
+            IResourceView::Desc viewDesc = {};
+            viewDesc.type = IResourceView::Type::UnorderedAccess;
+            viewDesc.format = Format::Unknown;
+            GFX_CHECK_CALL_ABORT(
+                device->createBufferView(buffer, nullptr, viewDesc, uav.writeRef()));
+        }
+        {
+            ITextureResource::Desc textureDesc = {};
+            textureDesc.type = IResource::Type::Texture2D;
+            textureDesc.format = Format::R8G8B8A8_UNORM;
+            textureDesc.size.width = 2;
+            textureDesc.size.height = 2;
+            textureDesc.size.depth = 1;
+            textureDesc.numMipLevels = 2;
+            textureDesc.memoryType = MemoryType::DeviceLocal;
+            textureDesc.defaultState = ResourceState::ShaderResource;
+            textureDesc.allowedStates.add(ResourceState::CopyDestination);
+            uint32_t data[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
+            ITextureResource::SubresourceData subResourceData[2] = {{data, 8, 16}, {data, 8, 16}};
+            GFX_CHECK_CALL_ABORT(
+                device->createTextureResource(textureDesc, subResourceData, texture.writeRef()));
+        }
+        for (uint32_t i = 0; i < 32; i++)
+        {
+            ComPtr<IResourceView> srv;
+            IResourceView::Desc viewDesc = {};
+            viewDesc.type = IResourceView::Type::ShaderResource;
+            viewDesc.format = Format::R8G8B8A8_UNORM;
+            viewDesc.subresourceRange.layerCount = 1;
+            viewDesc.subresourceRange.mipLevelCount = 1;
+            GFX_CHECK_CALL_ABORT(
+                device->createTextureView(texture, viewDesc, srv.writeRef()));
+            srvs.add(srv);
+        }
+
+        for (uint32_t i = 0; i < 32; i++)
+        {
+            ISamplerState::Desc desc = {};
+            ComPtr<ISamplerState> sampler;
+            GFX_CHECK_CALL_ABORT(device->createSamplerState(desc, sampler.writeRef()));
+            samplers.add(sampler);
+        }
+
+        ComPtr<IShaderObject> rootObject;
+        device->createMutableRootShaderObject(shaderProgram, rootObject.writeRef());
+
+        ComPtr<IShaderObject> g;
+        device->createMutableShaderObject(
+            slangReflection->findTypeByName("S0"), ShaderObjectContainerType::None, g.writeRef());
+
+        ComPtr<IShaderObject> s1;
+        device->createMutableShaderObject(
+            slangReflection->findTypeByName("S1"), ShaderObjectContainerType::None, s1.writeRef());
+
+        {
+            auto cursor = ShaderCursor(s1);
+            for (uint32_t i = 0; i < 32; i++)
+            {
+                cursor["samplers"][i].setSampler(samplers[i]);
+                cursor["tex"][i].setResource(srvs[i]);
+            }
+            cursor["data"].setData(1.0f);
+        }
+
+        {
+            auto cursor = ShaderCursor(g);
+            cursor["s"].setObject(s1);
+            cursor["data"].setData(2.0f);
+        }
+
+        {
+            auto cursor = ShaderCursor(rootObject);
+            cursor["g"].setObject(g);
+            cursor["buffer"].setResource(uav);
+        }
+
+        {
+            ICommandQueue::Desc queueDesc = { ICommandQueue::QueueType::Graphics };
+            auto queue = device->createCommandQueue(queueDesc);
+
+            auto commandBuffer = transientHeap->createCommandBuffer();
+            {
+                auto encoder = commandBuffer->encodeComputeCommands();
+                auto root = encoder->bindPipeline(pipelineState);
+                root->copyFrom(rootObject, transientHeap);
+                encoder->dispatchCompute(1, 1, 1);
+                encoder->endEncoding();
+            }
+
+            commandBuffer->close();
+            queue->executeCommandBuffer(commandBuffer);
+            queue->waitOnHost();
+        }
+
+        compareComputeResult(
+            device, buffer, Slang::makeArray<float>(4.0f));
+    }
+
+    SLANG_UNIT_TEST(samplerArrayVulkan)
+    {
+        runTestImpl(samplerArrayTestImpl, unitTestContext, Slang::RenderApiFlag::Vulkan);
+    }
+}