Remove resource `Usage` from `gfx` interface. (#1813)

* Fix `model-viewer` crash when using Vulkan.

Fixing an issue in shader object layout creation for to make sure a correct descriptor set layout is calculated for types that need an implicit constant buffer.

* Fix formatting.

* Fixes.

* Fix memory leak in vulkan.

* Remove resource `Usage` from `gfx` interface.

3 files changed, 68 insertions, 60 deletions

diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp
index 43273acf6..d3c0ef1a9 100644
--- a/tools/render-test/render-test-main.cpp
+++ b/tools/render-test/render-test-main.cpp
@@ -213,7 +213,7 @@ struct AssignValsFromLayoutContext
 
         ComPtr<ITextureResource> texture;
         SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource(
-            textureEntry->textureDesc, textureBindFlags, device, texture));
+            textureEntry->textureDesc, ResourceState::ShaderResource, device, texture));
 
         auto sampler = _createSamplerState(device, samplerEntry->samplerDesc);
 
@@ -229,13 +229,11 @@ struct AssignValsFromLayoutContext
         return SLANG_OK;
     }
 
-    static const int textureBindFlags = IResource::BindFlag::NonPixelShaderResource | IResource::BindFlag::PixelShaderResource;
-
     SlangResult assignTexture(ShaderCursor const& dstCursor, ShaderInputLayout::TextureVal* srcVal)
     {
         ComPtr<ITextureResource> texture;
         SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource(
-            srcVal->textureDesc, textureBindFlags, device, texture));
+            srcVal->textureDesc, ResourceState::ShaderResource, device, texture));
 
         // TODO: support UAV textures...
 
@@ -494,10 +492,13 @@ SlangResult RenderTestApp::initialize(
                     inputElements, SLANG_COUNT_OF(inputElements), inputLayout.writeRef()));
 
                 IBufferResource::Desc vertexBufferDesc;
-                vertexBufferDesc.init(kVertexCount * sizeof(Vertex));
+                vertexBufferDesc.type = IResource::Type::Buffer;
+                vertexBufferDesc.sizeInBytes = kVertexCount * sizeof(Vertex);
+                vertexBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
+                vertexBufferDesc.defaultState = ResourceState::VertexBuffer;
+                vertexBufferDesc.allowedStates = ResourceStateSet(ResourceState::VertexBuffer);
 
                 SLANG_RETURN_ON_FAIL(device->createBufferResource(
-                    IResource::Usage::VertexBuffer,
                     vertexBufferDesc,
                     kVertexData,
                     m_vertexBuffer.writeRef()));
@@ -537,27 +538,28 @@ void RenderTestApp::_initializeRenderPass()
     m_queue = m_device->createCommandQueue(queueDesc);
     
     gfx::ITextureResource::Desc depthBufferDesc;
-    depthBufferDesc.setDefaults(gfx::IResource::Usage::DepthWrite);
-    depthBufferDesc.init2D(
-        gfx::IResource::Type::Texture2D,
-        gfx::Format::D_Float32,
-        gWindowWidth,
-        gWindowHeight,
-        0);
-
-    ComPtr<gfx::ITextureResource> depthBufferResource = m_device->createTextureResource(
-        gfx::IResource::Usage::DepthWrite, depthBufferDesc, nullptr);
+    depthBufferDesc.type = IResource::Type::Texture2D;
+    depthBufferDesc.size.width = gWindowWidth;
+    depthBufferDesc.size.height = gWindowHeight;
+    depthBufferDesc.size.depth = 1;
+    depthBufferDesc.numMipLevels = 1;
+    depthBufferDesc.format = Format::D_Float32;
+    depthBufferDesc.defaultState = ResourceState::DepthWrite;
+    depthBufferDesc.allowedStates = ResourceState::DepthWrite;
+
+    ComPtr<gfx::ITextureResource> depthBufferResource =
+        m_device->createTextureResource(depthBufferDesc, nullptr);
 
     gfx::ITextureResource::Desc colorBufferDesc;
-    colorBufferDesc.setDefaults(gfx::IResource::Usage::RenderTarget);
-    colorBufferDesc.init2D(
-        gfx::IResource::Type::Texture2D,
-        gfx::Format::RGBA_Unorm_UInt8,
-        gWindowWidth,
-        gWindowHeight,
-        0);
-    m_colorBuffer = m_device->createTextureResource(
-        gfx::IResource::Usage::RenderTarget, colorBufferDesc, nullptr);
+    colorBufferDesc.type = IResource::Type::Texture2D;
+    colorBufferDesc.size.width = gWindowWidth;
+    colorBufferDesc.size.height = gWindowHeight;
+    colorBufferDesc.size.depth = 1;
+    colorBufferDesc.numMipLevels = 1;
+    colorBufferDesc.format = Format::RGBA_Unorm_UInt8;
+    colorBufferDesc.defaultState = ResourceState::RenderTarget;
+    colorBufferDesc.allowedStates = ResourceState::RenderTarget;
+    m_colorBuffer = m_device->createTextureResource(colorBufferDesc, nullptr);
 
     gfx::IResourceView::Desc colorBufferViewDesc;
     memset(&colorBufferViewDesc, 0, sizeof(colorBufferViewDesc));
@@ -677,10 +679,12 @@ Result RenderTestApp::writeBindingOutput(const char* fileName)
 
                 auto stagingBufferDesc = bufferDesc;
                 stagingBufferDesc.cpuAccessFlags = IResource::AccessFlag::Read;
-                stagingBufferDesc.bindFlags = 0;
+                stagingBufferDesc.allowedStates =
+                    ResourceStateSet(ResourceState::CopyDestination, ResourceState::CopySource);
+                stagingBufferDesc.defaultState = ResourceState::CopyDestination;
 
                 ComPtr<IBufferResource> stagingBuffer;
-                SLANG_RETURN_ON_FAIL(m_device->createBufferResource(IResource::Usage::CopyDest, stagingBufferDesc, nullptr, stagingBuffer.writeRef()));
+                SLANG_RETURN_ON_FAIL(m_device->createBufferResource(stagingBufferDesc, nullptr, stagingBuffer.writeRef()));
 
                 ComPtr<ICommandBuffer> commandBuffer;
                 SLANG_RETURN_ON_FAIL(
diff --git a/tools/render-test/shader-renderer-util.cpp b/tools/render-test/shader-renderer-util.cpp
index d6441d3ac..6775b4142 100644
--- a/tools/render-test/shader-renderer-util.cpp
+++ b/tools/render-test/shader-renderer-util.cpp
@@ -2,6 +2,8 @@
 
 #include "shader-renderer-util.h"
 
+#include "tools/gfx/resource-desc-utils.h"
+
 namespace renderer_test {
 
 using namespace Slang;
@@ -9,24 +11,23 @@ using Slang::Result;
 
 /* static */ Result ShaderRendererUtil::generateTextureResource(
     const InputTextureDesc& inputDesc,
-    int bindFlags,
+    ResourceState defaultState,
     IDevice* device,
     ComPtr<ITextureResource>& textureOut)
 {
     TextureData texData;
     generateTextureData(texData, inputDesc);
-    return createTextureResource(inputDesc, texData, bindFlags, device, textureOut);
+    return createTextureResource(inputDesc, texData, defaultState, device, textureOut);
 }
 
 /* static */ Result ShaderRendererUtil::createTextureResource(
     const InputTextureDesc& inputDesc,
     const TextureData& texData,
-    int bindFlags,
+    ResourceState defaultState,
     IDevice* device,
     ComPtr<ITextureResource>& textureOut)
 {
-    ITextureResource::Desc textureResourceDesc;
-    textureResourceDesc.init(IResource::Type::Unknown);
+    ITextureResource::Desc textureResourceDesc = {};
 
     // Default to RGBA_Unorm_UInt8
     const Format format = (inputDesc.format == Format::Unknown) ? Format::RGBA_Unorm_UInt8 : inputDesc.format;
@@ -34,7 +35,9 @@ using Slang::Result;
     textureResourceDesc.format = format;
     textureResourceDesc.numMipLevels = texData.mipLevels;
     textureResourceDesc.arraySize = inputDesc.arrayLength;
-    textureResourceDesc.bindFlags = bindFlags;
+    textureResourceDesc.allowedStates =
+        ResourceStateSet(defaultState, ResourceState::CopyDestination, ResourceState::CopySource);
+    textureResourceDesc.defaultState = defaultState;
 
     // It's the same size in all dimensions
     switch (inputDesc.dimension)
@@ -42,27 +45,32 @@ using Slang::Result;
         case 1:
         {
             textureResourceDesc.type = IResource::Type::Texture1D;
-            textureResourceDesc.size.init(inputDesc.size);
+            textureResourceDesc.size.width = inputDesc.size;
+            textureResourceDesc.size.height = 1;
+            textureResourceDesc.size.depth = 1;
+
             break;
         }
         case 2:
         {
             textureResourceDesc.type = inputDesc.isCube ? IResource::Type::TextureCube : IResource::Type::Texture2D;
-            textureResourceDesc.size.init(inputDesc.size, inputDesc.size);
+            textureResourceDesc.size.width = inputDesc.size;
+            textureResourceDesc.size.height = inputDesc.size;
+            textureResourceDesc.size.depth = 1;
             break;
         }
         case 3:
         {
             textureResourceDesc.type = IResource::Type::Texture3D;
-            textureResourceDesc.size.init(inputDesc.size, inputDesc.size, inputDesc.size);
+            textureResourceDesc.size.width = inputDesc.size;
+            textureResourceDesc.size.height = inputDesc.size;
+            textureResourceDesc.size.depth = inputDesc.size;
             break;
         }
     }
 
-    const int effectiveArraySize = textureResourceDesc.calcEffectiveArraySize();
-    const int numSubResources = textureResourceDesc.calcNumSubResources();
-
-    IResource::Usage initialUsage = IResource::Usage::GenericRead;
+    const int effectiveArraySize = calcEffectiveArraySize(textureResourceDesc);
+    const int numSubResources = calcNumSubResources(textureResourceDesc);
 
     List<ITextureResource::SubresourceData> initSubresources;
     int subResourceCounter = 0;
@@ -71,8 +79,8 @@ using Slang::Result;
         for( int m = 0; m < textureResourceDesc.numMipLevels; ++m )
         {
             int subResourceIndex = subResourceCounter++;
-            const int mipWidth = ITextureResource::Size::calcMipSize(textureResourceDesc.size.width, m);
-            const int mipHeight = ITextureResource::Size::calcMipSize(textureResourceDesc.size.width, m);
+            const int mipWidth = calcMipSize(textureResourceDesc.size.width, m);
+            const int mipHeight = calcMipSize(textureResourceDesc.size.height, m);
 
             auto strideY = mipWidth * sizeof(uint32_t);
             auto strideZ = mipHeight * strideY;
@@ -86,7 +94,7 @@ using Slang::Result;
         }
     }
 
-    textureOut = device->createTextureResource(IResource::Usage::GenericRead, textureResourceDesc, initSubresources.getBuffer());
+    textureOut = device->createTextureResource(textureResourceDesc, initSubresources.getBuffer());
 
     return textureOut ? SLANG_OK : SLANG_FAIL;
 }
@@ -98,23 +106,19 @@ using Slang::Result;
     IDevice* device,
     Slang::ComPtr<IBufferResource>& bufferOut)
 {
-    IResource::Usage initialUsage = IResource::Usage::GenericRead;
-
     IBufferResource::Desc srcDesc;
-    srcDesc.init(bufferSize);
+    srcDesc.type = IResource::Type::Buffer;
+    srcDesc.sizeInBytes = bufferSize;
     srcDesc.format = inputDesc.format;
-
-    int bindFlags = 0;
-    {
-        bindFlags |= IResource::BindFlag::UnorderedAccess | IResource::BindFlag::PixelShaderResource | IResource::BindFlag::NonPixelShaderResource;
-        srcDesc.elementSize = inputDesc.stride;
-        initialUsage = IResource::Usage::UnorderedAccess;
-    }
-
-    srcDesc.bindFlags = bindFlags;
-
-    ComPtr<IBufferResource> bufferResource =
-        device->createBufferResource(initialUsage, srcDesc, initData);
+    srcDesc.elementSize = inputDesc.stride;
+    srcDesc.defaultState = ResourceState::UnorderedAccess;
+    srcDesc.allowedStates = ResourceStateSet(
+        ResourceState::CopyDestination,
+        ResourceState::CopySource,
+        ResourceState::UnorderedAccess,
+        ResourceState::ShaderResource);
+
+    ComPtr<IBufferResource> bufferResource = device->createBufferResource(srcDesc, initData);
     if (!bufferResource)
     {
         return SLANG_FAIL;
diff --git a/tools/render-test/shader-renderer-util.h b/tools/render-test/shader-renderer-util.h
index b4028fd06..1a1edf997 100644
--- a/tools/render-test/shader-renderer-util.h
+++ b/tools/render-test/shader-renderer-util.h
@@ -16,7 +16,7 @@ struct ShaderRendererUtil
         /// Generate a texture using the InputTextureDesc and construct a TextureResource using the Renderer with the contents
     static Slang::Result generateTextureResource(
         const InputTextureDesc& inputDesc,
-        int bindFlags,
+        ResourceState defaultState,
         IDevice* device,
         ComPtr<ITextureResource>& textureOut);
 
@@ -24,7 +24,7 @@ struct ShaderRendererUtil
     static Slang::Result createTextureResource(
         const InputTextureDesc& inputDesc,
         const TextureData& texData,
-        int bindFlags,
+        ResourceState defaultState,
         IDevice* device,
         ComPtr<ITextureResource>& textureOut);