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.

26 files changed, 801 insertions, 930 deletions

diff --git a/build/visual-studio/gfx/gfx.vcxproj b/build/visual-studio/gfx/gfx.vcxproj
index 2bf81058f..313125919 100644
--- a/build/visual-studio/gfx/gfx.vcxproj
+++ b/build/visual-studio/gfx/gfx.vcxproj
@@ -195,6 +195,7 @@
     <ClInclude Include="..\..\..\tools\gfx\nvapi\nvapi-util.h" />
     <ClInclude Include="..\..\..\tools\gfx\open-gl\render-gl.h" />
     <ClInclude Include="..\..\..\tools\gfx\renderer-shared.h" />
+    <ClInclude Include="..\..\..\tools\gfx\resource-desc-utils.h" />
     <ClInclude Include="..\..\..\tools\gfx\simple-render-pass-layout.h" />
     <ClInclude Include="..\..\..\tools\gfx\simple-transient-resource-heap.h" />
     <ClInclude Include="..\..\..\tools\gfx\slang-context.h" />
@@ -221,6 +222,7 @@
     <ClCompile Include="..\..\..\tools\gfx\open-gl\render-gl.cpp" />
     <ClCompile Include="..\..\..\tools\gfx\render.cpp" />
     <ClCompile Include="..\..\..\tools\gfx\renderer-shared.cpp" />
+    <ClCompile Include="..\..\..\tools\gfx\resource-desc-utils.cpp" />
     <ClCompile Include="..\..\..\tools\gfx\simple-render-pass-layout.cpp" />
     <ClCompile Include="..\..\..\tools\gfx\vulkan\render-vk.cpp" />
     <ClCompile Include="..\..\..\tools\gfx\vulkan\vk-api.cpp" />
diff --git a/build/visual-studio/gfx/gfx.vcxproj.filters b/build/visual-studio/gfx/gfx.vcxproj.filters
index 4b79d826d..9065b785f 100644
--- a/build/visual-studio/gfx/gfx.vcxproj.filters
+++ b/build/visual-studio/gfx/gfx.vcxproj.filters
@@ -57,6 +57,9 @@
     <ClInclude Include="..\..\..\tools\gfx\renderer-shared.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\..\tools\gfx\resource-desc-utils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\..\tools\gfx\simple-render-pass-layout.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -131,6 +134,9 @@
     <ClCompile Include="..\..\..\tools\gfx\renderer-shared.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\..\tools\gfx\resource-desc-utils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\..\tools\gfx\simple-render-pass-layout.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
diff --git a/examples/example-base/example-base.cpp b/examples/example-base/example-base.cpp
index 09891e555..a75ddf247 100644
--- a/examples/example-base/example-base.cpp
+++ b/examples/example-base/example-base.cpp
@@ -105,16 +105,16 @@ void WindowedAppBase::createSwapchainFramebuffers()
     for (uint32_t i = 0; i < kSwapchainImageCount; i++)
     {
         gfx::ITextureResource::Desc depthBufferDesc;
-        depthBufferDesc.setDefaults(gfx::IResource::Usage::DepthWrite);
-        depthBufferDesc.init2D(
-            gfx::IResource::Type::Texture2D,
-            gfx::Format::D_Float32,
-            gSwapchain->getDesc().width,
-            gSwapchain->getDesc().height,
-            0);
-
-        ComPtr<gfx::ITextureResource> depthBufferResource = gDevice->createTextureResource(
-            gfx::IResource::Usage::DepthWrite, depthBufferDesc, nullptr);
+        depthBufferDesc.type = IResource::Type::Texture2D;
+        depthBufferDesc.size.width = gSwapchain->getDesc().width;
+        depthBufferDesc.size.height = gSwapchain->getDesc().height;
+        depthBufferDesc.size.depth = 1;
+        depthBufferDesc.format = gfx::Format::D_Float32;
+        depthBufferDesc.defaultState = ResourceState::DepthWrite;
+        depthBufferDesc.allowedStates = ResourceStateSet(ResourceState::DepthWrite);
+        
+        ComPtr<gfx::ITextureResource> depthBufferResource =
+            gDevice->createTextureResource(depthBufferDesc, nullptr);
         ComPtr<gfx::ITextureResource> colorBuffer;
         gSwapchain->getImage(i, colorBuffer.writeRef());
 
diff --git a/examples/gpu-printing/main.cpp b/examples/gpu-printing/main.cpp
index 265b4c5ff..11a1553a3 100644
--- a/examples/gpu-printing/main.cpp
+++ b/examples/gpu-printing/main.cpp
@@ -103,11 +103,14 @@ Result execute()
     size_t printBufferSize = 4 * 1024; // use a small-ish (4KB) buffer for print output
 
     IBufferResource::Desc printBufferDesc;
-    printBufferDesc.init(printBufferSize);
+    printBufferDesc.type = IResource::Type::Buffer;
+    printBufferDesc.sizeInBytes = printBufferSize;
     printBufferDesc.elementSize = sizeof(uint32_t);
+    printBufferDesc.defaultState = ResourceState::UnorderedAccess;
+    printBufferDesc.allowedStates = ResourceStateSet(
+        ResourceState::CopySource, ResourceState::CopyDestination, ResourceState::UnorderedAccess);
     printBufferDesc.cpuAccessFlags = IResource::AccessFlag::Read; // | Resource::AccessFlag::Write;
-    auto printBuffer =
-        gDevice->createBufferResource(IResource::Usage::UnorderedAccess, printBufferDesc);
+    auto printBuffer = gDevice->createBufferResource(printBufferDesc);
 
     IResourceView::Desc printBufferViewDesc;
     printBufferViewDesc.type = IResourceView::Type::UnorderedAccess;
diff --git a/examples/shader-object/main.cpp b/examples/shader-object/main.cpp
index 6efe2f97d..72ab265c6 100644
--- a/examples/shader-object/main.cpp
+++ b/examples/shader-object/main.cpp
@@ -165,13 +165,16 @@ int main()
     bufferDesc.sizeInBytes = numberCount * sizeof(float);
     bufferDesc.format = gfx::Format::Unknown;
     bufferDesc.elementSize = sizeof(float);
-    bufferDesc.bindFlags = gfx::IResource::BindFlag::NonPixelShaderResource |
-                           gfx::IResource::BindFlag::UnorderedAccess;
+    bufferDesc.allowedStates = ResourceStateSet(
+        ResourceState::ShaderResource,
+        ResourceState::UnorderedAccess,
+        ResourceState::CopyDestination,
+        ResourceState::CopySource);
+    bufferDesc.defaultState = ResourceState::UnorderedAccess;
     bufferDesc.cpuAccessFlags = IResource::AccessFlag::Write | IResource::AccessFlag::Read;
 
     ComPtr<gfx::IBufferResource> numbersBuffer;
     SLANG_RETURN_ON_FAIL(device->createBufferResource(
-        gfx::IResource::Usage::UnorderedAccess,
         bufferDesc,
         (void*)initialData,
         numbersBuffer.writeRef()));
diff --git a/examples/shader-toy/main.cpp b/examples/shader-toy/main.cpp
index d94d629ba..c41bd71ca 100644
--- a/examples/shader-toy/main.cpp
+++ b/examples/shader-toy/main.cpp
@@ -290,10 +290,10 @@ Result initialize()
     if(!inputLayout) return SLANG_FAIL;
 
     IBufferResource::Desc vertexBufferDesc;
-    vertexBufferDesc.init(FullScreenTriangle::kVertexCount * sizeof(FullScreenTriangle::Vertex));
-    vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer);
+    vertexBufferDesc.type = IResource::Type::Buffer;
+    vertexBufferDesc.sizeInBytes = FullScreenTriangle::kVertexCount * sizeof(FullScreenTriangle::Vertex);
+    vertexBufferDesc.defaultState = ResourceState::VertexBuffer;
     gVertexBuffer = gDevice->createBufferResource(
-        IResource::Usage::VertexBuffer,
         vertexBufferDesc,
         &FullScreenTriangle::kVertices[0]);
     if(!gVertexBuffer) return SLANG_FAIL;
diff --git a/examples/triangle/main.cpp b/examples/triangle/main.cpp
index 6b9104072..0f6c31809 100644
--- a/examples/triangle/main.cpp
+++ b/examples/triangle/main.cpp
@@ -236,12 +236,10 @@ Slang::Result initialize()
     // vertex data.
     //
     IBufferResource::Desc vertexBufferDesc;
-    vertexBufferDesc.init(kVertexCount * sizeof(Vertex));
-    vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer);
-    gVertexBuffer = gDevice->createBufferResource(
-        IResource::Usage::VertexBuffer,
-        vertexBufferDesc,
-        &kVertexData[0]);
+    vertexBufferDesc.type = IResource::Type::Buffer;
+    vertexBufferDesc.sizeInBytes = kVertexCount * sizeof(Vertex);
+    vertexBufferDesc.defaultState = ResourceState::VertexBuffer;
+    gVertexBuffer = gDevice->createBufferResource(vertexBufferDesc, &kVertexData[0]);
     if(!gVertexBuffer) return SLANG_FAIL;
 
     // Now we will use our `loadShaderProgram` function to load
diff --git a/slang-gfx.h b/slang-gfx.h
index 6693809a3..a8234f6bb 100644
--- a/slang-gfx.h
+++ b/slang-gfx.h
@@ -165,6 +165,51 @@ enum class PrimitiveTopology
     TriangleList,
 };
 
+enum class ResourceState
+{
+    Undefined,
+    VertexBuffer,
+    IndexBuffer,
+    ConstantBuffer,
+    StreamOutput,
+    ShaderResource,
+    UnorderedAccess,
+    RenderTarget,
+    DepthRead,
+    DepthWrite,
+    Present,
+    CopySource,
+    CopyDestination,
+    ResolveSource,
+    ResolveDestination,
+    _Count
+};
+
+struct ResourceStateSet
+{
+public:
+    void add(ResourceState state) { m_bitFields |= (1LL << (uint32_t)state); }
+    template <typename... TResourceState> void add(ResourceState s, TResourceState... states)
+    {
+        add(s);
+        add(states...);
+    }
+    bool contains(ResourceState state) const { return (m_bitFields & (1LL << (uint32_t)state)) != 0; }
+    ResourceStateSet()
+        : m_bitFields(0)
+    {}
+    ResourceStateSet(const ResourceStateSet& other) = default;
+    ResourceStateSet(ResourceState state) { add(state); }
+    template <typename... TResourceState> ResourceStateSet(TResourceState... states)
+    {
+        add(states...);
+    }
+
+private:
+    uint64_t m_bitFields = 0;
+    void add() {}
+};
+
 class IResource: public ISlangUnknown
 {
 public:
@@ -181,44 +226,6 @@ public:
         CountOf,
     };
 
-        /// Describes how a resource is to be used
-    enum class Usage
-    {
-        Unknown = 0,
-        VertexBuffer,
-        IndexBuffer,
-        ConstantBuffer,
-        StreamOutput,
-        RenderTarget,
-        DepthRead,
-        DepthWrite,
-        UnorderedAccess,
-        PixelShaderResource,
-        NonPixelShaderResource,
-        ShaderResource,
-        GenericRead,
-        CopySource,
-        CopyDest,
-        CountOf,
-    };
-
-        /// Binding flags describe all of the ways a resource can be bound - and therefore used
-    struct BindFlag
-    {
-        enum Enum
-        {
-            VertexBuffer            = 0x001,
-            IndexBuffer             = 0x002,
-            ConstantBuffer          = 0x004,
-            StreamOutput            = 0x008,
-            RenderTarget            = 0x010,
-            DepthStencil            = 0x020,
-            UnorderedAccess         = 0x040,
-            PixelShaderResource     = 0x080,
-            NonPixelShaderResource  = 0x100,
-        };
-    };
-
         /// Combinations describe how a resource can be accessed (typically by the host/cpu)
     struct AccessFlag
     {
@@ -232,53 +239,14 @@ public:
         /// Base class for Descs
     struct DescBase
     {
-        bool canBind(BindFlag::Enum bindFlag) const { return (bindFlags & bindFlag) != 0; }
         bool hasCpuAccessFlag(AccessFlag::Enum accessFlag) { return (cpuAccessFlags & accessFlag) != 0; }
 
         Type type = Type::Unknown;
-
-        int bindFlags = 0;          ///< Combination of Resource::BindFlag or 0 (and will use initialUsage to set)
+        ResourceState defaultState = ResourceState::Undefined;
+        ResourceStateSet allowedStates = ResourceStateSet();
         int cpuAccessFlags = 0;     ///< Combination of Resource::AccessFlag
     };
 
-    inline static BindFlag::Enum getDefaultBindFlagsFromUsage(IResource::Usage usage)
-    {
-        switch (usage)
-        {
-        case Usage::VertexBuffer:
-            return BindFlag::VertexBuffer;
-        case Usage::IndexBuffer:
-            return BindFlag::IndexBuffer;
-        case Usage::ConstantBuffer:
-            return BindFlag::ConstantBuffer;
-        case Usage::StreamOutput:
-            return BindFlag::StreamOutput;
-        case Usage::RenderTarget:
-            return BindFlag::RenderTarget;
-        case Usage::DepthRead:
-        case Usage::DepthWrite:
-            return BindFlag::DepthStencil;
-        case Usage::UnorderedAccess:
-            return BindFlag::Enum(BindFlag::UnorderedAccess | BindFlag::PixelShaderResource |
-                BindFlag::NonPixelShaderResource);
-        case Usage::PixelShaderResource:
-            return BindFlag::PixelShaderResource;
-        case Usage::NonPixelShaderResource:
-            return BindFlag::NonPixelShaderResource;
-        case Usage::ShaderResource:
-        case Usage::GenericRead:
-            return BindFlag::Enum(
-                BindFlag::PixelShaderResource |
-                BindFlag::NonPixelShaderResource);
-        case Usage::CopySource:
-            return BindFlag::Enum(0);
-        case Usage::CopyDest:
-            return BindFlag::Enum(0);
-        default:
-            return BindFlag::Enum(-1);
-        }
-    }
-
     virtual SLANG_NO_THROW Type SLANG_MCALL getType() = 0;
 };
 #define SLANG_UUID_IResource                                                           \
@@ -291,22 +259,9 @@ class IBufferResource: public IResource
 public:
     struct Desc: public DescBase
     {
-        void init(size_t sizeInBytesIn)
-        {
-            sizeInBytes = sizeInBytesIn;
-            elementSize = 0;
-            format = Format::Unknown;
-        }
-        void setDefaults(Usage initialUsage)
-        {
-            if (bindFlags == 0)
-            {
-                bindFlags = getDefaultBindFlagsFromUsage(initialUsage);
-            }
-        }
-        size_t sizeInBytes;     ///< Total size in bytes
-        int elementSize;        ///< Get the element stride. If > 0, this is a structured buffer
-        Format format;
+        size_t sizeInBytes = 0;     ///< Total size in bytes
+        int elementSize = 0;        ///< Get the element stride. If > 0, this is a structured buffer
+        Format format = Format::Unknown;
     };
     virtual SLANG_NO_THROW Desc* SLANG_MCALL getDesc() = 0;
 };
@@ -315,32 +270,6 @@ public:
         0x1b274efe, 0x5e37, 0x492b, { 0x82, 0x6e, 0x7e, 0xe7, 0xe8, 0xf5, 0xa4, 0x9b } \
     }
 
-template <typename T> T _slang_gfx_max(T v0, T v1) { return v0 > v1 ? v0 : v1; }
-
-static inline unsigned int _slang_gfx_ones32(unsigned int x)
-{
-    /* 32-bit recursive reduction using SWAR...
-            but first step is mapping 2-bit values
-            into sum of 2 1-bit values in sneaky way
-    */
-    x -= ((x >> 1) & 0x55555555);
-    x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
-    x = (((x >> 4) + x) & 0x0f0f0f0f);
-    x += (x >> 8);
-    x += (x >> 16);
-    return (x & 0x0000003f);
-}
-
-static inline unsigned int _slang_gfx_log2Floor(unsigned int x)
-{
-    x |= (x >> 1);
-    x |= (x >> 2);
-    x |= (x >> 4);
-    x |= (x >> 8);
-    x |= (x >> 16);
-    return (_slang_gfx_ones32(x >> 1));
-}
-
 struct DepthStencilClearValue
 {
     float depth = 1.0f;
@@ -362,234 +291,27 @@ class ITextureResource: public IResource
 public:
     struct SampleDesc
     {
-        void init()
-        {
-            numSamples = 1;
-            quality = 0;
-        }
-        int numSamples;                     ///< Number of samples per pixel
-        int quality;                        ///< The quality measure for the samples
+        int numSamples = 1;                     ///< Number of samples per pixel
+        int quality = 0;                        ///< The quality measure for the samples
     };
 
     struct Size
     {
-        void init()
-        {
-            width = height = depth = 1;
-        }
-        void init(int widthIn, int heightIn = 1, int depthIn = 1)
-        {
-            width = widthIn;
-            height = heightIn;
-            depth = depthIn;
-        }
-            /// Given the type works out the maximum dimension size
-        int calcMaxDimension(Type type) const
-        {
-            switch (type)
-            {
-            case IResource::Type::Texture1D:
-                return this->width;
-            case IResource::Type::Texture3D:
-                return _slang_gfx_max(_slang_gfx_max(this->width, this->height), this->depth);
-            case IResource::Type::TextureCube: // fallthru
-            case IResource::Type::Texture2D:
-                {
-                    return _slang_gfx_max(this->width, this->height);
-                }
-            default:
-                return 0;
-            }
-        }
-
-        SLANG_FORCE_INLINE static int calcMipSize(int width, int mipLevel)
-        {
-            width = width >> mipLevel;
-            return width > 0 ? width : 1;
-        }
-            /// Given a size, calculates the size at a mip level
-        Size calcMipSize(int mipLevel) const
-        {
-            Size size;
-            size.width = calcMipSize(this->width, mipLevel);
-            size.height = calcMipSize(this->height, mipLevel);
-            size.depth = calcMipSize(this->depth, mipLevel);
-            return size;
-        }
-
-        int width;              ///< Width in pixels
-        int height;             ///< Height in pixels (if 2d or 3d)
-        int depth;              ///< Depth (if 3d)
+        int width = 0;              ///< Width in pixels
+        int height = 0;             ///< Height in pixels (if 2d or 3d)
+        int depth = 0;              ///< Depth (if 3d)
     };
 
     struct Desc: public DescBase
     {
-            /// Initialize with default values
-        void init(Type typeIn)
-        {
-            this->type = typeIn;
-            this->size.init();
-
-            this->format = Format::Unknown;
-            this->arraySize = 0;
-            this->numMipLevels = 0;
-            this->sampleDesc.init();
-
-            this->bindFlags = 0;
-            this->cpuAccessFlags = 0;
-        }
-            /// Initialize different dimensions. For cubemap, use init2D
-        void init1D(Format formatIn, int widthIn, int numMipMapsIn = 0)
-        {
-            this->type = Type::Texture1D;
-            this->size.init(widthIn);
-
-            this->format = formatIn;
-            this->arraySize = 0;
-            this->numMipLevels = numMipMapsIn;
-            this->sampleDesc.init();
-
-            this->bindFlags = 0;
-            this->cpuAccessFlags = 0;
-        }
-
-        void init2D(Type typeIn, Format formatIn, int widthIn, int heightIn, int numMipMapsIn = 0)
-        {
-            assert(typeIn == Type::Texture2D || typeIn == Type::TextureCube);
-
-            this->type = typeIn;
-            this->size.init(widthIn, heightIn);
-
-            this->format = formatIn;
-            this->arraySize = 0;
-            this->numMipLevels = numMipMapsIn;
-            this->sampleDesc.init();
-
-            this->bindFlags = 0;
-            this->cpuAccessFlags = 0;
-        }
-
-        void init3D(Format formatIn, int widthIn, int heightIn, int depthIn, int numMipMapsIn = 0)
-        {
-            this->type = Type::Texture3D;
-            this->size.init(widthIn, heightIn, depthIn);
-
-            this->format = formatIn;
-            this->arraySize = 0;
-            this->numMipLevels = numMipMapsIn;
-            this->sampleDesc.init();
-
-            this->bindFlags = 0;
-            this->cpuAccessFlags = 0;
-        }
-
-            /// Given the type, calculates the number of mip maps. 0 on error
-        int calcNumMipLevels() const
-        {
-            const int maxDimensionSize = this->size.calcMaxDimension(type);
-            return (maxDimensionSize > 0) ? (_slang_gfx_log2Floor(maxDimensionSize) + 1) : 0;
-        }
-            /// Calculate the total number of sub resources. 0 on error.
-        int calcNumSubResources() const
-        {
-            const int numMipMaps =
-                (this->numMipLevels > 0) ? this->numMipLevels : calcNumMipLevels();
-            const int arrSize = (this->arraySize > 0) ? this->arraySize : 1;
-
-            switch (type)
-            {
-            case IResource::Type::Texture1D:
-            case IResource::Type::Texture2D:
-            case IResource::Type::Texture3D:
-                {
-                    return numMipMaps * arrSize;
-                }
-            case IResource::Type::TextureCube:
-                {
-                    // There are 6 faces to a cubemap
-                    return numMipMaps * arrSize * 6;
-                }
-            default:
-                return 0;
-            }
-        }
-
-            /// Calculate the effective array size - in essence the amount if mip map sets needed.
-            /// In practice takes into account if the arraySize is 0 (it's not an array, but it will still have at least one mip set)
-            /// and if the type is a cubemap (multiplies the amount of mip sets by 6)
-        int calcEffectiveArraySize() const
-        {
-            const int arrSize = (this->arraySize > 0) ? this->arraySize : 1;
-
-            switch (type)
-            {
-            case IResource::Type::Texture1D: // fallthru
-            case IResource::Type::Texture2D:
-                {
-                    return arrSize;
-                }
-            case IResource::Type::TextureCube:
-                return arrSize * 6;
-            case IResource::Type::Texture3D:
-                return 1;
-            default:
-                return 0;
-            }
-        }
-
-            /// Use type to fix the size values (and array size).
-            /// For example a 1d texture, should have height and depth set to 1.
-        void fixSize()
-        {
-            switch (type)
-            {
-            case IResource::Type::Texture1D:
-                {
-                    this->size.height = 1;
-                    this->size.depth = 1;
-                    break;
-                }
-            case IResource::Type::TextureCube:
-            case IResource::Type::Texture2D:
-                {
-                    this->size.depth = 1;
-                    break;
-                }
-            case IResource::Type::Texture3D:
-                {
-                    // Can't have an array
-                    this->arraySize = 0;
-                    break;
-                }
-            default:
-                break;
-            }
-        }
-
-            /// Set up default parameters based on type and usage
-        void setDefaults(Usage usage)
-        {
-            this->initialUsage = usage;
-            fixSize();
-            if (this->bindFlags == 0)
-            {
-                this->bindFlags = getDefaultBindFlagsFromUsage(initialUsage);
-            }
-            if (this->numMipLevels <= 0)
-            {
-                this->numMipLevels = calcNumMipLevels();
-            }
-        }
-
         Size size;
 
-        int arraySize;          ///< Array size
+        int arraySize = 0;          ///< Array size
 
-        int numMipLevels;       ///< Number of mip levels - if 0 will create all mip levels
-        Format format;          ///< The resources format
-        SampleDesc sampleDesc;  ///< How the resource is sampled
+        int numMipLevels = 0;       ///< Number of mip levels - if 0 will create all mip levels
+        Format format;              ///< The resources format
+        SampleDesc sampleDesc;      ///< How the resource is sampled
         ClearValue optimalClearValue;
-        Usage initialUsage;
     };
 
         /// Data for a single subresource of a texture.
@@ -1041,21 +763,6 @@ struct WindowHandle
     }
 };
 
-enum class ResourceState
-{
-    Undefined,
-    ShaderResource,
-    UnorderedAccess,
-    RenderTarget,
-    DepthRead,
-    DepthWrite,
-    Present,
-    CopySource,
-    CopyDestination,
-    ResolveSource,
-    ResolveDestination,
-};
-
 struct FaceMask
 {
     enum Enum
@@ -1426,36 +1133,32 @@ public:
         ///     effectiveElementCount = (isArray ? arrayElementCount : 1) * (isCube ? 6 : 1);
         ///
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
-        IResource::Usage initialUsage,
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData,
         ITextureResource** outResource) = 0;
 
         /// Create a texture resource. initData holds the initialize data to set the contents of the texture when constructed.
     inline SLANG_NO_THROW ComPtr<ITextureResource> createTextureResource(
-        IResource::Usage initialUsage,
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData = nullptr)
     {
         ComPtr<ITextureResource> resource;
-        SLANG_RETURN_NULL_ON_FAIL(createTextureResource(initialUsage, desc, initData, resource.writeRef()));
+        SLANG_RETURN_NULL_ON_FAIL(createTextureResource(desc, initData, resource.writeRef()));
         return resource;
     }
 
         /// Create a buffer resource
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
-        IResource::Usage initialUsage,
         const IBufferResource::Desc& desc,
         const void* initData,
         IBufferResource** outResource) = 0;
 
     inline SLANG_NO_THROW ComPtr<IBufferResource> createBufferResource(
-        IResource::Usage initialUsage,
         const IBufferResource::Desc& desc,
         const void* initData = nullptr)
     {
         ComPtr<IBufferResource> resource;
-        SLANG_RETURN_NULL_ON_FAIL(createBufferResource(initialUsage, desc, initData, resource.writeRef()));
+        SLANG_RETURN_NULL_ON_FAIL(createBufferResource(desc, initData, resource.writeRef()));
         return resource;
     }
 
diff --git a/tools/gfx/cpu/render-cpu.cpp b/tools/gfx/cpu/render-cpu.cpp
index 8dd1ccae6..af1641e60 100644
--- a/tools/gfx/cpu/render-cpu.cpp
+++ b/tools/gfx/cpu/render-cpu.cpp
@@ -1196,13 +1196,11 @@ public:
     }
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
-        IResource::Usage initialUsage,
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData,
         ITextureResource** outResource) override
     {
-        TextureResource::Desc srcDesc(desc);
-        srcDesc.setDefaults(initialUsage);
+        TextureResource::Desc srcDesc = fixupTextureDesc(desc);
 
         RefPtr<CPUTextureResource> texture = new CPUTextureResource(srcDesc);
 
@@ -1213,11 +1211,11 @@ public:
     }
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
-        IResource::Usage initialUsage,
-        const IBufferResource::Desc& desc,
+        const IBufferResource::Desc& descIn,
         const void* initData,
         IBufferResource** outResource) override
     {
+        auto desc = fixupBufferDesc(descIn);
         RefPtr<CPUBufferResource> resource = new CPUBufferResource(desc);
         SLANG_RETURN_ON_FAIL(resource->init());
         if (initData)
diff --git a/tools/gfx/cuda/render-cuda.cpp b/tools/gfx/cuda/render-cuda.cpp
index 9d6b08122..14699915b 100644
--- a/tools/gfx/cuda/render-cuda.cpp
+++ b/tools/gfx/cuda/render-cuda.cpp
@@ -457,11 +457,14 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL initBuffer(IDevice* device, size_t bufferSize)
     {
         BufferResource::Desc bufferDesc;
-        bufferDesc.init(bufferSize);
+        bufferDesc.type = IResource::Type::Buffer;
+        bufferDesc.defaultState = ResourceState::ConstantBuffer;
+        bufferDesc.allowedStates =
+            ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination);
+        bufferDesc.sizeInBytes = bufferSize;
         bufferDesc.cpuAccessFlags |= IResource::AccessFlag::Write;
         ComPtr<IBufferResource> constantBuffer;
-        SLANG_RETURN_ON_FAIL(device->createBufferResource(
-            IResource::Usage::ConstantBuffer, bufferDesc, nullptr, constantBuffer.writeRef()));
+        SLANG_RETURN_ON_FAIL(device->createBufferResource(bufferDesc, nullptr, constantBuffer.writeRef()));
         bufferResource = static_cast<MemoryCUDAResource*>(constantBuffer.get());
         return SLANG_OK;
     }
@@ -1379,13 +1382,11 @@ public:
     }
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
-        IResource::Usage initialUsage,
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData,
         ITextureResource** outResource) override
     {
-        TextureResource::Desc srcDesc(desc);
-        srcDesc.setDefaults(initialUsage);
+        TextureResource::Desc srcDesc = fixupTextureDesc(desc);
 
         RefPtr<TextureCUDAResource> tex = new TextureCUDAResource(srcDesc);
         tex->m_cudaContext = m_context;
@@ -1568,183 +1569,180 @@ public:
         }
 
         // Work space for holding data for uploading if it needs to be rearranged
-        List<uint8_t> workspace;
-        for (int mipLevel = 0; mipLevel < desc.numMipLevels; ++mipLevel)
+        if (initData)
         {
-            int mipWidth = width >> mipLevel;
-            int mipHeight = height >> mipLevel;
-            int mipDepth = depth >> mipLevel;
-
-            mipWidth = (mipWidth == 0) ? 1 : mipWidth;
-            mipHeight = (mipHeight == 0) ? 1 : mipHeight;
-            mipDepth = (mipDepth == 0) ? 1 : mipDepth;
-
-            // If it's a cubemap then the depth is always 6
-            if (desc.type == IResource::Type::TextureCube)
+            List<uint8_t> workspace;
+            for (int mipLevel = 0; mipLevel < desc.numMipLevels; ++mipLevel)
             {
-                mipDepth = 6;
-            }
+                int mipWidth = width >> mipLevel;
+                int mipHeight = height >> mipLevel;
+                int mipDepth = depth >> mipLevel;
 
-            auto dstArray = tex->m_cudaArray;
-            if (tex->m_cudaMipMappedArray)
-            {
-                // Get the array for the mip level
-                SLANG_CUDA_RETURN_ON_FAIL(
-                    cuMipmappedArrayGetLevel(&dstArray, tex->m_cudaMipMappedArray, mipLevel));
-            }
-            SLANG_ASSERT(dstArray);
+                mipWidth = (mipWidth == 0) ? 1 : mipWidth;
+                mipHeight = (mipHeight == 0) ? 1 : mipHeight;
+                mipDepth = (mipDepth == 0) ? 1 : mipDepth;
 
-            // Check using the desc to see if it's plausible
-            {
-                CUDA_ARRAY_DESCRIPTOR arrayDesc;
-                SLANG_CUDA_RETURN_ON_FAIL(cuArrayGetDescriptor(&arrayDesc, dstArray));
+                // If it's a cubemap then the depth is always 6
+                if (desc.type == IResource::Type::TextureCube)
+                {
+                    mipDepth = 6;
+                }
 
-                SLANG_ASSERT(mipWidth == arrayDesc.Width);
-                SLANG_ASSERT(
-                    mipHeight == arrayDesc.Height || (mipHeight == 1 && arrayDesc.Height == 0));
-            }
+                auto dstArray = tex->m_cudaArray;
+                if (tex->m_cudaMipMappedArray)
+                {
+                    // Get the array for the mip level
+                    SLANG_CUDA_RETURN_ON_FAIL(
+                        cuMipmappedArrayGetLevel(&dstArray, tex->m_cudaMipMappedArray, mipLevel));
+                }
+                SLANG_ASSERT(dstArray);
 
-            const void* srcDataPtr = nullptr;
+                // Check using the desc to see if it's plausible
+                {
+                    CUDA_ARRAY_DESCRIPTOR arrayDesc;
+                    SLANG_CUDA_RETURN_ON_FAIL(cuArrayGetDescriptor(&arrayDesc, dstArray));
 
-            if (desc.arraySize > 1)
-            {
-                SLANG_ASSERT(
-                    desc.type == IResource::Type::Texture1D ||
-                    desc.type == IResource::Type::Texture2D ||
-                    desc.type == IResource::Type::TextureCube);
+                    SLANG_ASSERT(mipWidth == arrayDesc.Width);
+                    SLANG_ASSERT(
+                        mipHeight == arrayDesc.Height || (mipHeight == 1 && arrayDesc.Height == 0));
+                }
 
-                // TODO(JS): Here I assume that arrays are just held contiguously within a 'face'
-                // This seems reasonable and works with the Copy3D.
-                const size_t faceSizeInBytes = elementSize * mipWidth * mipHeight;
+                const void* srcDataPtr = nullptr;
 
-                Index faceCount = desc.arraySize;
-                if (desc.type == IResource::Type::TextureCube)
+                if (desc.arraySize > 1)
                 {
-                    faceCount *= 6;
-                }
+                    SLANG_ASSERT(
+                        desc.type == IResource::Type::Texture1D ||
+                        desc.type == IResource::Type::Texture2D ||
+                        desc.type == IResource::Type::TextureCube);
 
-                const size_t mipSizeInBytes = faceSizeInBytes * faceCount;
-                workspace.setCount(mipSizeInBytes);
+                    // TODO(JS): Here I assume that arrays are just held contiguously within a
+                    // 'face' This seems reasonable and works with the Copy3D.
+                    const size_t faceSizeInBytes = elementSize * mipWidth * mipHeight;
 
-                // We need to add the face data from each mip
-                // We iterate over face count so we copy all of the cubemap faces
-                if (initData)
-                {
-                    for (Index j = 0; j < faceCount; j++)
+                    Index faceCount = desc.arraySize;
+                    if (desc.type == IResource::Type::TextureCube)
                     {
-                        const auto srcData = initData[mipLevel + j * desc.numMipLevels].data;
-                        // Copy over to the workspace to make contiguous
-                        ::memcpy(
-                            workspace.begin() + faceSizeInBytes * j, srcData,
-                            faceSizeInBytes);
+                        faceCount *= 6;
                     }
-                }
-
-                srcDataPtr = workspace.getBuffer();
-            }
-            else
-            {
-                if (desc.type == IResource::Type::TextureCube)
-                {
-                    size_t faceSizeInBytes = elementSize * mipWidth * mipHeight;
 
-                    workspace.setCount(faceSizeInBytes * 6);
+                    const size_t mipSizeInBytes = faceSizeInBytes * faceCount;
+                    workspace.setCount(mipSizeInBytes);
 
-                    // Copy the data over to make contiguous
-                    for (Index j = 0; j < 6; j++)
+                    // We need to add the face data from each mip
+                    // We iterate over face count so we copy all of the cubemap faces
+                    for (Index j = 0; j < faceCount; j++)
                     {
-                        const auto srcData =
-                            initData[mipLevel + j * desc.numMipLevels].data;
+                        const auto srcData = initData[mipLevel + j * desc.numMipLevels].data;
+                        // Copy over to the workspace to make contiguous
                         ::memcpy(
-                            workspace.getBuffer() + faceSizeInBytes * j, srcData,
-                            faceSizeInBytes);
+                            workspace.begin() + faceSizeInBytes * j, srcData, faceSizeInBytes);
                     }
 
                     srcDataPtr = workspace.getBuffer();
                 }
                 else
                 {
-                    const auto srcData = initData[mipLevel].data;
-                    srcDataPtr = srcData;
+                    if (desc.type == IResource::Type::TextureCube)
+                    {
+                        size_t faceSizeInBytes = elementSize * mipWidth * mipHeight;
+
+                        workspace.setCount(faceSizeInBytes * 6);
+                        // Copy the data over to make contiguous
+                        for (Index j = 0; j < 6; j++)
+                        {
+                            const auto srcData =
+                                initData[mipLevel + j * desc.numMipLevels].data;
+                            ::memcpy(
+                                workspace.getBuffer() + faceSizeInBytes * j,
+                                srcData,
+                                faceSizeInBytes);
+                        }
+                        srcDataPtr = workspace.getBuffer();
+                    }
+                    else
+                    {
+                        const auto srcData = initData[mipLevel].data;
+                        srcDataPtr = srcData;
+                    }
                 }
-            }
-
-            if (desc.arraySize > 1)
-            {
-                SLANG_ASSERT(
-                    desc.type == IResource::Type::Texture1D ||
-                    desc.type == IResource::Type::Texture2D ||
-                    desc.type == IResource::Type::TextureCube);
-
-                CUDA_MEMCPY3D copyParam;
-                memset(&copyParam, 0, sizeof(copyParam));
-
-                copyParam.dstMemoryType = CU_MEMORYTYPE_ARRAY;
-                copyParam.dstArray = dstArray;
-
-                copyParam.srcMemoryType = CU_MEMORYTYPE_HOST;
-                copyParam.srcHost = srcDataPtr;
-                copyParam.srcPitch = mipWidth * elementSize;
-                copyParam.WidthInBytes = copyParam.srcPitch;
-                copyParam.Height = mipHeight;
-                // Set the depth to the array length
-                copyParam.Depth = desc.arraySize;
 
-                if (desc.type == IResource::Type::TextureCube)
+                if (desc.arraySize > 1)
                 {
-                    copyParam.Depth *= 6;
-                }
+                    SLANG_ASSERT(
+                        desc.type == IResource::Type::Texture1D ||
+                        desc.type == IResource::Type::Texture2D ||
+                        desc.type == IResource::Type::TextureCube);
 
-                SLANG_CUDA_RETURN_ON_FAIL(cuMemcpy3D(&copyParam));
-            }
-            else
-            {
-                switch (desc.type)
-                {
-                case IResource::Type::Texture1D:
-                case IResource::Type::Texture2D:
-                    {
-                        CUDA_MEMCPY2D copyParam;
-                        memset(&copyParam, 0, sizeof(copyParam));
-                        copyParam.dstMemoryType = CU_MEMORYTYPE_ARRAY;
-                        copyParam.dstArray = dstArray;
-                        copyParam.srcMemoryType = CU_MEMORYTYPE_HOST;
-                        copyParam.srcHost = srcDataPtr;
-                        copyParam.srcPitch = mipWidth * elementSize;
-                        copyParam.WidthInBytes = copyParam.srcPitch;
-                        copyParam.Height = mipHeight;
-                        SLANG_CUDA_RETURN_ON_FAIL(cuMemcpy2D(&copyParam));
-                        break;
-                    }
-                case IResource::Type::Texture3D:
-                case IResource::Type::TextureCube:
-                    {
-                        CUDA_MEMCPY3D copyParam;
-                        memset(&copyParam, 0, sizeof(copyParam));
+                    CUDA_MEMCPY3D copyParam;
+                    memset(&copyParam, 0, sizeof(copyParam));
 
-                        copyParam.dstMemoryType = CU_MEMORYTYPE_ARRAY;
-                        copyParam.dstArray = dstArray;
+                    copyParam.dstMemoryType = CU_MEMORYTYPE_ARRAY;
+                    copyParam.dstArray = dstArray;
 
-                        copyParam.srcMemoryType = CU_MEMORYTYPE_HOST;
-                        copyParam.srcHost = srcDataPtr;
-                        copyParam.srcPitch = mipWidth * elementSize;
-                        copyParam.WidthInBytes = copyParam.srcPitch;
-                        copyParam.Height = mipHeight;
-                        copyParam.Depth = mipDepth;
+                    copyParam.srcMemoryType = CU_MEMORYTYPE_HOST;
+                    copyParam.srcHost = srcDataPtr;
+                    copyParam.srcPitch = mipWidth * elementSize;
+                    copyParam.WidthInBytes = copyParam.srcPitch;
+                    copyParam.Height = mipHeight;
+                    // Set the depth to the array length
+                    copyParam.Depth = desc.arraySize;
 
-                        SLANG_CUDA_RETURN_ON_FAIL(cuMemcpy3D(&copyParam));
-                        break;
+                    if (desc.type == IResource::Type::TextureCube)
+                    {
+                        copyParam.Depth *= 6;
                     }
 
-                default:
+                    SLANG_CUDA_RETURN_ON_FAIL(cuMemcpy3D(&copyParam));
+                }
+                else
+                {
+                    switch (desc.type)
                     {
-                        SLANG_ASSERT(!"Not implemented");
-                        break;
+                    case IResource::Type::Texture1D:
+                    case IResource::Type::Texture2D:
+                        {
+                            CUDA_MEMCPY2D copyParam;
+                            memset(&copyParam, 0, sizeof(copyParam));
+                            copyParam.dstMemoryType = CU_MEMORYTYPE_ARRAY;
+                            copyParam.dstArray = dstArray;
+                            copyParam.srcMemoryType = CU_MEMORYTYPE_HOST;
+                            copyParam.srcHost = srcDataPtr;
+                            copyParam.srcPitch = mipWidth * elementSize;
+                            copyParam.WidthInBytes = copyParam.srcPitch;
+                            copyParam.Height = mipHeight;
+                            SLANG_CUDA_RETURN_ON_FAIL(cuMemcpy2D(&copyParam));
+                            break;
+                        }
+                    case IResource::Type::Texture3D:
+                    case IResource::Type::TextureCube:
+                        {
+                            CUDA_MEMCPY3D copyParam;
+                            memset(&copyParam, 0, sizeof(copyParam));
+
+                            copyParam.dstMemoryType = CU_MEMORYTYPE_ARRAY;
+                            copyParam.dstArray = dstArray;
+
+                            copyParam.srcMemoryType = CU_MEMORYTYPE_HOST;
+                            copyParam.srcHost = srcDataPtr;
+                            copyParam.srcPitch = mipWidth * elementSize;
+                            copyParam.WidthInBytes = copyParam.srcPitch;
+                            copyParam.Height = mipHeight;
+                            copyParam.Depth = mipDepth;
+
+                            SLANG_CUDA_RETURN_ON_FAIL(cuMemcpy3D(&copyParam));
+                            break;
+                        }
+
+                    default:
+                        {
+                            SLANG_ASSERT(!"Not implemented");
+                            break;
+                        }
                     }
                 }
             }
         }
-
         // Set up texture sampling parameters, and create final texture obj
 
         {
@@ -1772,7 +1770,7 @@ public:
             // time we create a resource, and then allocate the surface or
             // texture objects as part of view creation.
             //
-            if( desc.bindFlags & IResource::BindFlag::UnorderedAccess )
+            if (desc.allowedStates.contains(ResourceState::UnorderedAccess))
             {
                 SLANG_CUDA_RETURN_ON_FAIL(cuSurfObjectCreate(&tex->m_cudaSurfObj, &resDesc));
             }
@@ -1796,11 +1794,11 @@ public:
     }
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
-        IResource::Usage initialUsage,
-        const IBufferResource::Desc& desc,
+        const IBufferResource::Desc& descIn,
         const void* initData,
         IBufferResource** outResource) override
     {
+        auto desc = fixupBufferDesc(descIn);
         RefPtr<MemoryCUDAResource> resource = new MemoryCUDAResource(desc);
         resource->m_cudaContext = m_context;
         SLANG_CUDA_RETURN_ON_FAIL(cudaMallocManaged(&resource->m_cudaMemory, desc.sizeInBytes));
diff --git a/tools/gfx/d3d11/render-d3d11.cpp b/tools/gfx/d3d11/render-d3d11.cpp
index a011f2760..bbc213bb6 100644
--- a/tools/gfx/d3d11/render-d3d11.cpp
+++ b/tools/gfx/d3d11/render-d3d11.cpp
@@ -75,12 +75,10 @@ public:
     virtual void setStencilReference(uint32_t referenceValue) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
-        IResource::Usage initialUsage,
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData,
         ITextureResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
-        IResource::Usage initialUsage,
         const IBufferResource::Desc& desc,
         const void* initData,
         IBufferResource** outResource) override;
@@ -177,14 +175,12 @@ protected:
 	public:
         typedef BufferResource Parent;
 
-        BufferResourceImpl(const IBufferResource::Desc& desc, IResource::Usage initialUsage):
-            Parent(desc),
-            m_initialUsage(initialUsage)
+        BufferResourceImpl(const IBufferResource::Desc& desc):
+            Parent(desc)
         {
         }
 
         MapFlavor m_mapFlavor;
-        Usage m_initialUsage;
         ComPtr<ID3D11Buffer> m_buffer;
         ComPtr<ID3D11Buffer> m_staging;
     };
@@ -193,12 +189,10 @@ protected:
     public:
         typedef TextureResource Parent;
 
-        TextureResourceImpl(const Desc& desc, Usage initialUsage) :
-            Parent(desc),
-            m_initialUsage(initialUsage)
+        TextureResourceImpl(const Desc& desc)
+            : Parent(desc)
         {
         }
-        Usage m_initialUsage;
         ComPtr<ID3D11Resource> m_resource;
 
     };
@@ -314,10 +308,19 @@ protected:
             ComPtr<ID3D11Resource> d3dResource;
             m_swapChain->GetBuffer(0, IID_PPV_ARGS(d3dResource.writeRef()));
             ITextureResource::Desc imageDesc = {};
-            imageDesc.init2D(
-                IResource::Type::Texture2D, m_desc.format, m_desc.width, m_desc.height, 0);
-            RefPtr<TextureResourceImpl> image =
-                new TextureResourceImpl(imageDesc, IResource::Usage::RenderTarget);
+            imageDesc.type = IResource::Type::Texture2D;
+            imageDesc.arraySize = 0;
+            imageDesc.numMipLevels = 1;
+            imageDesc.size.width = m_desc.width;
+            imageDesc.size.height = m_desc.height;
+            imageDesc.size.depth = 1;
+            imageDesc.format = m_desc.format;
+            imageDesc.defaultState = ResourceState::Present;
+            imageDesc.allowedStates = ResourceStateSet(
+                ResourceState::Present,
+                ResourceState::CopyDestination,
+                ResourceState::RenderTarget);
+            RefPtr<TextureResourceImpl> image = new TextureResourceImpl(imageDesc);
             image->m_resource = d3dResource;
             for (uint32_t i = 0; i < m_desc.imageCount; i++)
             {
@@ -1199,11 +1202,15 @@ protected:
             //
 
             ComPtr<IBufferResource> bufferResourcePtr;
-            IBufferResource::Desc bufferDesc;
-            bufferDesc.init(specializedOrdinaryDataSize);
+            IBufferResource::Desc bufferDesc = {};
+            bufferDesc.type = IResource::Type::Buffer;
+            bufferDesc.sizeInBytes = specializedOrdinaryDataSize;
+            bufferDesc.defaultState = ResourceState::ConstantBuffer;
+            bufferDesc.allowedStates =
+                ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination);
             bufferDesc.cpuAccessFlags |= IResource::AccessFlag::Write;
-            SLANG_RETURN_ON_FAIL(device->createBufferResource(
-                IResource::Usage::ConstantBuffer, bufferDesc, nullptr, bufferResourcePtr.writeRef()));
+            SLANG_RETURN_ON_FAIL(
+                device->createBufferResource(bufferDesc, nullptr, bufferResourcePtr.writeRef()));
             m_ordinaryDataBuffer = static_cast<BufferResourceImpl*>(bufferResourcePtr.get());
 
             // Once the buffer is allocated, we can use `_writeOrdinaryData` to fill it in.
@@ -1896,33 +1903,40 @@ SlangResult D3D11Device::readTextureResource(
     }
 }
 
-static D3D11_BIND_FLAG _calcResourceFlag(IResource::BindFlag::Enum bindFlag)
+static D3D11_BIND_FLAG _calcResourceFlag(ResourceState state)
 {
-    typedef IResource::BindFlag BindFlag;
-    switch (bindFlag)
-    {
-        case BindFlag::VertexBuffer:            return D3D11_BIND_VERTEX_BUFFER;
-        case BindFlag::IndexBuffer:             return D3D11_BIND_INDEX_BUFFER;
-        case BindFlag::ConstantBuffer:          return D3D11_BIND_CONSTANT_BUFFER;
-        case BindFlag::StreamOutput:            return D3D11_BIND_STREAM_OUTPUT;
-        case BindFlag::RenderTarget:            return D3D11_BIND_RENDER_TARGET;
-        case BindFlag::DepthStencil:            return D3D11_BIND_DEPTH_STENCIL;
-        case BindFlag::UnorderedAccess:         return D3D11_BIND_UNORDERED_ACCESS;
-        case BindFlag::PixelShaderResource:     return D3D11_BIND_SHADER_RESOURCE;
-        case BindFlag::NonPixelShaderResource:  return D3D11_BIND_SHADER_RESOURCE;
-        default:                                return D3D11_BIND_FLAG(0);
+    switch (state)
+    {
+    case ResourceState::VertexBuffer:
+        return D3D11_BIND_VERTEX_BUFFER;
+    case ResourceState::IndexBuffer:
+        return D3D11_BIND_INDEX_BUFFER;
+    case ResourceState::ConstantBuffer:
+        return D3D11_BIND_CONSTANT_BUFFER;
+    case ResourceState::StreamOutput:
+        return D3D11_BIND_STREAM_OUTPUT;
+    case ResourceState::RenderTarget:
+        return D3D11_BIND_RENDER_TARGET;
+    case ResourceState::DepthRead:
+    case ResourceState::DepthWrite:
+        return D3D11_BIND_DEPTH_STENCIL;
+    case ResourceState::UnorderedAccess:
+        return D3D11_BIND_UNORDERED_ACCESS;
+    case ResourceState::ShaderResource:
+        return D3D11_BIND_SHADER_RESOURCE;
+    default:
+        return D3D11_BIND_FLAG(0);
     }
 }
 
-static int _calcResourceBindFlags(int bindFlags)
+static int _calcResourceBindFlags(ResourceStateSet allowedStates)
 {
     int dstFlags = 0;
-    while (bindFlags)
+    for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++)
     {
-        int lsb = bindFlags & -bindFlags;
-
-        dstFlags |= _calcResourceFlag(IResource::BindFlag::Enum(lsb));
-        bindFlags &= ~lsb;
+        auto state = (ResourceState)i;
+        if (allowedStates.contains(state))
+            dstFlags |= _calcResourceFlag(state);
     }
     return dstFlags;
 }
@@ -1940,12 +1954,11 @@ static int _calcResourceAccessFlags(int accessFlags)
     }
 }
 
-Result D3D11Device::createTextureResource(IResource::Usage initialUsage, const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource)
+Result D3D11Device::createTextureResource(const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource)
 {
-    TextureResource::Desc srcDesc(descIn);
-    srcDesc.setDefaults(initialUsage);
+    TextureResource::Desc srcDesc = fixupTextureDesc(descIn);
 
-    const int effectiveArraySize = srcDesc.calcEffectiveArraySize();
+    const int effectiveArraySize = calcEffectiveArraySize(srcDesc);
 
     const DXGI_FORMAT format = D3DUtil::getMapFormat(srcDesc.format);
     if (format == DXGI_FORMAT_UNKNOWN)
@@ -1953,7 +1966,7 @@ Result D3D11Device::createTextureResource(IResource::Usage initialUsage, const I
         return SLANG_FAIL;
     }
 
-    const int bindFlags = _calcResourceBindFlags(srcDesc.bindFlags);
+    const int bindFlags = _calcResourceBindFlags(srcDesc.allowedStates);
 
     // Set up the initialize data
     List<D3D11_SUBRESOURCE_DATA> subRes;
@@ -1967,7 +1980,7 @@ Result D3D11Device::createTextureResource(IResource::Usage initialUsage, const I
             {
                 for (int j = 0; j < srcDesc.numMipLevels; j++)
                 {
-                    const int mipHeight = ITextureResource::Size::calcMipSize(srcDesc.size.height, j);
+                    const int mipHeight = calcMipSize(srcDesc.size.height, j);
 
                     D3D11_SUBRESOURCE_DATA& data = subRes[subResourceIndex];
                     auto& srcData = initData[subResourceIndex];
@@ -1985,7 +1998,7 @@ Result D3D11Device::createTextureResource(IResource::Usage initialUsage, const I
 
     const int accessFlags = _calcResourceAccessFlags(srcDesc.cpuAccessFlags);
 
-    RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(srcDesc, initialUsage));
+    RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(srcDesc));
     
     switch (srcDesc.type)
     {
@@ -2062,12 +2075,11 @@ Result D3D11Device::createTextureResource(IResource::Usage initialUsage, const I
     return SLANG_OK;
 }
 
-Result D3D11Device::createBufferResource(IResource::Usage initialUsage, const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource)
+Result D3D11Device::createBufferResource(const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource)
 {
-    IBufferResource::Desc srcDesc(descIn);
-    srcDesc.setDefaults(initialUsage);
+    IBufferResource::Desc srcDesc = fixupBufferDesc(descIn);
 
-    auto d3dBindFlags = _calcResourceBindFlags(srcDesc.bindFlags);
+    auto d3dBindFlags = _calcResourceBindFlags(srcDesc.allowedStates);
 
     size_t alignedSizeInBytes = srcDesc.sizeInBytes;
 
@@ -2096,14 +2108,14 @@ Result D3D11Device::createBufferResource(IResource::Usage initialUsage, const IB
 
     // If written by CPU, make it dynamic
     if ((descIn.cpuAccessFlags & IResource::AccessFlag::Write) &&
-        ((descIn.bindFlags & IResource::BindFlag::UnorderedAccess) == 0))
+        !descIn.allowedStates.contains(ResourceState::UnorderedAccess))
     {
         bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
     }
 
-    switch (initialUsage)
+    switch (descIn.defaultState)
     {
-    case IResource::Usage::ConstantBuffer:
+    case ResourceState::ConstantBuffer:
         {
             // We'll just assume ConstantBuffers are dynamic for now
             bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
@@ -2134,7 +2146,7 @@ Result D3D11Device::createBufferResource(IResource::Usage initialUsage, const IB
     D3D11_SUBRESOURCE_DATA subResourceData = { 0 };
     subResourceData.pSysMem = initData;
 
-    RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(srcDesc, initialUsage));
+    RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(srcDesc));
 
     SLANG_RETURN_ON_FAIL(m_device->CreateBuffer(&bufferDesc, initData ? &subResourceData : nullptr, buffer->m_buffer.writeRef()));
 
diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp
index fd1121d1b..a752222d6 100644
--- a/tools/gfx/d3d12/render-d3d12.cpp
+++ b/tools/gfx/d3d12/render-d3d12.cpp
@@ -63,8 +63,6 @@ struct ID3D12GraphicsCommandList1 {};
 namespace gfx {
 using namespace Slang;
 
-static D3D12_RESOURCE_STATES _calcResourceState(IResource::Usage usage);
-
 class D3D12Device : public RendererBase
 {
 public:
@@ -81,12 +79,10 @@ public:
         ISwapchain** outSwapchain) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
-        IResource::Usage initialUsage,
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData,
         ITextureResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
-        IResource::Usage initialUsage,
         const IBufferResource::Desc& desc,
         const void* initData,
         IBufferResource** outResource) override;
@@ -189,16 +185,15 @@ public:
     public:
         typedef BufferResource Parent;
 
-        BufferResourceImpl(IResource::Usage initialUsage, const Desc& desc):
-            Parent(desc), m_initialUsage(initialUsage)
-            , m_defaultState(_calcResourceState(initialUsage))
+        BufferResourceImpl(const Desc& desc)
+            : Parent(desc)
+            , m_defaultState(D3DUtil::translateResourceState(desc.defaultState))
         {
         }
 
         D3D12Resource m_resource;           ///< The resource typically in gpu memory
         D3D12Resource m_uploadResource;     ///< If the resource can be written to, and is in gpu memory (ie not Memory backed), will have upload resource
 
-        Usage m_initialUsage;
         D3D12_RESOURCE_STATES m_defaultState;
     };
 
@@ -207,10 +202,10 @@ public:
     public:
         typedef TextureResource Parent;
 
-        TextureResourceImpl(const Desc& desc):
-            Parent(desc)
+        TextureResourceImpl(const Desc& desc)
+            : Parent(desc)
+            , m_defaultState(D3DUtil::translateResourceState(desc.defaultState))
         {
-            m_defaultState = _calcResourceState(desc.initialUsage);
         }
 
         D3D12Resource m_resource;
@@ -528,10 +523,13 @@ public:
             {
                 ComPtr<IBufferResource> bufferResourcePtr;
                 IBufferResource::Desc bufferDesc;
-                bufferDesc.init(desc.constantBufferSize);
+                bufferDesc.type = IResource::Type::Buffer;
+                bufferDesc.defaultState = ResourceState::ConstantBuffer;
+                bufferDesc.allowedStates =
+                    ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination);
+                bufferDesc.sizeInBytes = desc.constantBufferSize;
                 bufferDesc.cpuAccessFlags |= IResource::AccessFlag::Write;
                 SLANG_RETURN_ON_FAIL(device->createBufferResource(
-                    IResource::Usage::ConstantBuffer,
                     bufferDesc,
                     nullptr,
                     bufferResourcePtr.writeRef()));
@@ -2796,10 +2794,6 @@ public:
                 for (UInt i = 0; i < slotCount; i++)
                 {
                     BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(buffers[i]);
-                    if (buffer)
-                    {
-                        assert(buffer->m_initialUsage == IResource::Usage::VertexBuffer);
-                    }
 
                     BoundVertexBuffer& boundBuffer = m_boundVertexBuffers[startSlot + i];
                     boundBuffer.m_buffer = buffer;
@@ -3210,9 +3204,18 @@ public:
                 ComPtr<ID3D12Resource> d3dResource;
                 m_swapChain->GetBuffer(i, IID_PPV_ARGS(d3dResource.writeRef()));
                 ITextureResource::Desc imageDesc = {};
-                imageDesc.setDefaults(IResource::Usage::RenderTarget);
-                imageDesc.init2D(
-                    IResource::Type::Texture2D, m_desc.format, m_desc.width, m_desc.height, 0);
+                imageDesc.allowedStates = ResourceStateSet(
+                    ResourceState::Present,
+                    ResourceState::RenderTarget,
+                    ResourceState::CopyDestination);
+                imageDesc.type = IResource::Type::Texture2D;
+                imageDesc.arraySize = 0;
+                imageDesc.format = m_desc.format;
+                imageDesc.size.width = m_desc.width;
+                imageDesc.size.height = m_desc.height;
+                imageDesc.size.depth = 1;
+                imageDesc.numMipLevels = 1;
+                imageDesc.defaultState = ResourceState::Present;
                 RefPtr<TextureResourceImpl> image = new TextureResourceImpl(imageDesc);
                 image->m_resource.setResource(d3dResource.get());
                 image->m_defaultState = D3D12_RESOURCE_STATE_PRESENT;
@@ -4033,53 +4036,32 @@ SlangResult D3D12Device::readTextureResource(
         outPixelSize);
 }
 
-static D3D12_RESOURCE_STATES _calcResourceState(IResource::Usage usage)
+static D3D12_RESOURCE_FLAGS _calcResourceFlag(ResourceState state)
 {
-    typedef IResource::Usage Usage;
-    switch (usage)
+    switch (state)
     {
-        case Usage::VertexBuffer:           return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
-        case Usage::IndexBuffer:            return D3D12_RESOURCE_STATE_INDEX_BUFFER;
-        case Usage::ConstantBuffer:         return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
-        case Usage::StreamOutput:           return D3D12_RESOURCE_STATE_STREAM_OUT;
-        case Usage::RenderTarget:           return D3D12_RESOURCE_STATE_RENDER_TARGET;
-        case Usage::DepthWrite:             return D3D12_RESOURCE_STATE_DEPTH_WRITE;
-        case Usage::DepthRead:              return D3D12_RESOURCE_STATE_DEPTH_READ;
-        case Usage::UnorderedAccess:        return D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
-        case Usage::PixelShaderResource:    return D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
-        case Usage::NonPixelShaderResource: return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
-        case Usage::ShaderResource:         return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE |
-                                                   D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
-        case Usage::GenericRead:            return D3D12_RESOURCE_STATE_GENERIC_READ;
-        case Usage::CopySource:             return D3D12_RESOURCE_STATE_COPY_SOURCE;
-        case Usage::CopyDest:               return D3D12_RESOURCE_STATE_COPY_DEST;
-        default: return D3D12_RESOURCE_STATES(0);
-    }
-}
-
-static D3D12_RESOURCE_FLAGS _calcResourceFlag(IResource::BindFlag::Enum bindFlag)
-{
-    typedef IResource::BindFlag BindFlag;
-    switch (bindFlag)
-    {
-        case BindFlag::RenderTarget:        return D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
-        case BindFlag::DepthStencil:        return D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
-        case BindFlag::UnorderedAccess:     return D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
-        default:                            return D3D12_RESOURCE_FLAG_NONE;
+    case ResourceState::RenderTarget:
+        return D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+    case ResourceState::DepthRead:
+    case ResourceState::DepthWrite:
+        return D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+    case ResourceState::UnorderedAccess:
+        return D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+    default:
+        return D3D12_RESOURCE_FLAG_NONE;
     }
 }
 
-static D3D12_RESOURCE_FLAGS _calcResourceBindFlags(IResource::Usage initialUsage, int bindFlags)
+static D3D12_RESOURCE_FLAGS _calcResourceFlags(ResourceStateSet states)
 {
     int dstFlags = 0;
-    while (bindFlags)
+    for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++)
     {
-        int lsb = bindFlags & -bindFlags;
-
-        dstFlags |= _calcResourceFlag(IResource::BindFlag::Enum(lsb));
-        bindFlags &= ~lsb;
+        auto state = (ResourceState)i;
+        if (states.contains(state))
+            dstFlags |= _calcResourceFlag(state);
     }
-    return D3D12_RESOURCE_FLAGS(dstFlags);
+    return (D3D12_RESOURCE_FLAGS)dstFlags;
 }
 
 static D3D12_RESOURCE_DIMENSION _calcResourceDimension(IResource::Type type)
@@ -4098,13 +4080,12 @@ static D3D12_RESOURCE_DIMENSION _calcResourceDimension(IResource::Type type)
     }
 }
 
-Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource)
+Result D3D12Device::createTextureResource(const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource)
 {
     // Description of uploading on Dx12
     // https://msdn.microsoft.com/en-us/library/windows/desktop/dn899215%28v=vs.85%29.aspx
 
-    TextureResource::Desc srcDesc(descIn);
-    srcDesc.setDefaults(initialUsage);
+    TextureResource::Desc srcDesc = fixupTextureDesc(descIn);
 
     const DXGI_FORMAT pixelFormat = D3DUtil::getMapFormat(srcDesc.format);
     if (pixelFormat == DXGI_FORMAT_UNKNOWN)
@@ -4112,7 +4093,7 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I
         return SLANG_FAIL;
     }
 
-    const int arraySize = srcDesc.calcEffectiveArraySize();
+    const int arraySize = calcEffectiveArraySize(srcDesc);
 
     const D3D12_RESOURCE_DIMENSION dimension = _calcResourceDimension(srcDesc.type);
     if (dimension == D3D12_RESOURCE_DIMENSION_UNKNOWN)
@@ -4138,20 +4119,7 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I
     resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
     resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
 
-    switch (initialUsage)
-    {
-    case IResource::Usage::RenderTarget:
-        resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
-        break;
-    case IResource::Usage::DepthWrite:
-        resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
-        break;
-    case IResource::Usage::UnorderedAccess:
-        resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
-        break;
-    default:
-        break;
-    }
+    resourceDesc.Flags |= _calcResourceFlags(srcDesc.allowedStates);
 
     resourceDesc.Alignment = 0;
 
@@ -4251,7 +4219,7 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I
                 const D3D12_PLACED_SUBRESOURCE_FOOTPRINT& layout = layouts[j];
                 const D3D12_SUBRESOURCE_FOOTPRINT& footprint = layout.Footprint;
 
-                const TextureResource::Size mipSize = srcDesc.size.calcMipSize(j);
+                const TextureResource::Size mipSize = calcMipSize(srcDesc.size, j);
 
                 assert(footprint.Width == mipSize.width && footprint.Height == mipSize.height && footprint.Depth == mipSize.depth);
 
@@ -4314,10 +4282,10 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I
     }
     {
         auto encodeInfo = encodeResourceCommands();
-        const D3D12_RESOURCE_STATES finalState = _calcResourceState(initialUsage);
         {
             D3D12BarrierSubmitter submitter(encodeInfo.d3dCommandList);
-            texture->m_resource.transition(D3D12_RESOURCE_STATE_COPY_DEST, finalState, submitter);
+            texture->m_resource.transition(
+                D3D12_RESOURCE_STATE_COPY_DEST, texture->m_defaultState, submitter);
         }
         submitResourceCommandsAndWait(encodeInfo);
     }
@@ -4326,10 +4294,9 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I
     return SLANG_OK;
 }
 
-Result D3D12Device::createBufferResource(IResource::Usage initialUsage, const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource)
+Result D3D12Device::createBufferResource(const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource)
 {
-    BufferResource::Desc srcDesc(descIn);
-    srcDesc.setDefaults(initialUsage);
+    BufferResource::Desc srcDesc = fixupBufferDesc(descIn);
 
     // Always align up to 256 bytes, since that is required for constant buffers.
     //
@@ -4337,14 +4304,14 @@ Result D3D12Device::createBufferResource(IResource::Usage initialUsage, const IB
     //
     const size_t alignedSizeInBytes = D3DUtil::calcAligned(srcDesc.sizeInBytes, 256);
 
-    RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(initialUsage, srcDesc));
+    RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(srcDesc));
 
     D3D12_RESOURCE_DESC bufferDesc;
     _initBufferResourceDesc(alignedSizeInBytes, bufferDesc);
 
-    bufferDesc.Flags = _calcResourceBindFlags(initialUsage, srcDesc.bindFlags);
+    bufferDesc.Flags |= _calcResourceFlags(srcDesc.allowedStates);
 
-    const D3D12_RESOURCE_STATES initialState = _calcResourceState(initialUsage);
+    const D3D12_RESOURCE_STATES initialState = buffer->m_defaultState;
     SLANG_RETURN_ON_FAIL(createBuffer(bufferDesc, initData, srcDesc.sizeInBytes, buffer->m_uploadResource, initialState, buffer->m_resource));
 
     returnComPtr(outResource, buffer);
diff --git a/tools/gfx/open-gl/render-gl.cpp b/tools/gfx/open-gl/render-gl.cpp
index fb8502485..d5735add5 100644
--- a/tools/gfx/open-gl/render-gl.cpp
+++ b/tools/gfx/open-gl/render-gl.cpp
@@ -108,12 +108,10 @@ public:
     virtual void setStencilReference(uint32_t referenceValue) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
-        IResource::Usage initialUsage,
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData,
         ITextureResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
-        IResource::Usage initialUsage,
         const IBufferResource::Desc& desc,
         const void* initData,
         IBufferResource** outResource) override;
@@ -213,11 +211,10 @@ public:
 		public:
         typedef BufferResource Parent;
 
-        BufferResourceImpl(Usage initialUsage, const Desc& desc, WeakSink<GLDevice>* renderer, GLuint id, GLenum target):
+        BufferResourceImpl(const Desc& desc, WeakSink<GLDevice>* renderer, GLuint id, GLenum target):
             Parent(desc),
 			m_renderer(renderer),
 			m_handle(id),
-            m_initialUsage(initialUsage),
             m_target(target),
             m_size(desc.sizeInBytes)
 		{}
@@ -229,7 +226,6 @@ public:
 			}
 		}
 
-        Usage m_initialUsage;
 		RefPtr<WeakSink<GLDevice>> m_renderer;
 		GLuint m_handle;
         GLenum m_target;
@@ -241,9 +237,8 @@ public:
         public:
         typedef TextureResource Parent;
 
-        TextureResourceImpl(Usage initialUsage, const Desc& desc, WeakSink<GLDevice>* renderer):
+        TextureResourceImpl(const Desc& desc, WeakSink<GLDevice>* renderer):
             Parent(desc),
-            m_initialUsage(initialUsage),
             m_renderer(renderer)
         {
             m_target = 0;
@@ -258,7 +253,6 @@ public:
             }
          }
 
-        Usage m_initialUsage;
         RefPtr<WeakSink<GLDevice>> m_renderer;
         GLenum m_target;
         GLuint m_handle;
@@ -471,15 +465,21 @@ public:
                 m_images.clear();
                 for (uint32_t i = 0; i < m_desc.imageCount; i++)
                 {
-                    ITextureResource::Desc texDesc = {};
-                    texDesc.init2D(
-                        IResource::Type::Texture2D,
-                        gfx::Format::RGBA_Unorm_UInt8,
-                        m_desc.width,
-                        m_desc.height,
-                        1);
-                    RefPtr<TextureResourceImpl> tex = new TextureResourceImpl(
-                        IResource::Usage::RenderTarget, texDesc, m_renderer);
+                    ITextureResource::Desc imageDesc = {};
+                    imageDesc.allowedStates = ResourceStateSet(
+                        ResourceState::Present,
+                        ResourceState::RenderTarget,
+                        ResourceState::CopyDestination);
+                    imageDesc.type = IResource::Type::Texture2D;
+                    imageDesc.arraySize = 0;
+                    imageDesc.format = m_desc.format;
+                    imageDesc.size.width = m_desc.width;
+                    imageDesc.size.height = m_desc.height;
+                    imageDesc.size.depth = 1;
+                    imageDesc.numMipLevels = 1;
+                    imageDesc.defaultState = ResourceState::Present;
+                    RefPtr<TextureResourceImpl> tex =
+                        new TextureResourceImpl(imageDesc, m_renderer);
                     tex->m_handle = m_backBuffer;
                     m_images.add(tex);
                 }
@@ -1414,10 +1414,14 @@ public:
 
             ComPtr<IBufferResource> bufferResourcePtr;
             IBufferResource::Desc bufferDesc;
-            bufferDesc.init(specializedOrdinaryDataSize);
+            bufferDesc.type = IResource::Type::Buffer;
+            bufferDesc.sizeInBytes = specializedOrdinaryDataSize;
+            bufferDesc.defaultState = ResourceState::ConstantBuffer;
+            bufferDesc.allowedStates =
+                ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination);
             bufferDesc.cpuAccessFlags |= IResource::AccessFlag::Write;
-            SLANG_RETURN_ON_FAIL(device->createBufferResource(
-                IResource::Usage::ConstantBuffer, bufferDesc, nullptr, bufferResourcePtr.writeRef()));
+            SLANG_RETURN_ON_FAIL(
+                device->createBufferResource(bufferDesc, nullptr, bufferResourcePtr.writeRef()));
             m_ordinaryDataBuffer = static_cast<BufferResourceImpl*>(bufferResourcePtr.get());
 
             // Once the buffer is allocated, we can use `_writeOrdinaryData` to fill it in.
@@ -2373,13 +2377,11 @@ SLANG_NO_THROW Result SLANG_MCALL GLDevice::readTextureResource(
 }
 
 SLANG_NO_THROW Result SLANG_MCALL GLDevice::createTextureResource(
-    IResource::Usage initialUsage,
     const ITextureResource::Desc& descIn,
     const ITextureResource::SubresourceData* initData,
     ITextureResource** outResource)
 {
-    TextureResource::Desc srcDesc(descIn);
-    srcDesc.setDefaults(initialUsage);
+    TextureResource::Desc srcDesc = fixupTextureDesc(descIn);
 
     GlPixelFormat pixelFormat = _getGlPixelFormat(srcDesc.format);
     if (pixelFormat == GlPixelFormat::Unknown)
@@ -2393,13 +2395,13 @@ SLANG_NO_THROW Result SLANG_MCALL GLDevice::createTextureResource(
     const GLenum format = info.format;
     const GLenum formatType = info.formatType;
 
-    RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(initialUsage, srcDesc, m_weakRenderer));
+    RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(srcDesc, m_weakRenderer));
 
     GLenum target = 0;
     GLuint handle = 0;
     glGenTextures(1, &handle);
 
-    const int effectiveArraySize = srcDesc.calcEffectiveArraySize();
+    const int effectiveArraySize = calcEffectiveArraySize(srcDesc);
 
     // Set on texture so will be freed if failure
     texture->m_handle = handle;
@@ -2575,38 +2577,37 @@ SLANG_NO_THROW Result SLANG_MCALL GLDevice::createTextureResource(
     return SLANG_OK;
 }
 
-static GLenum _calcUsage(IResource::Usage usage)
+static GLenum _calcUsage(ResourceState state)
 {
-    typedef IResource::Usage Usage;
-    switch (usage)
+    switch (state)
     {
-        case Usage::ConstantBuffer:     return GL_DYNAMIC_DRAW;
-        default:                        return GL_STATIC_READ;
+    case ResourceState::ConstantBuffer:
+        return GL_DYNAMIC_DRAW;
+    default:
+        return GL_STATIC_READ;
     }
 }
 
-static GLenum _calcTarget(IResource::Usage usage)
+static GLenum _calcTarget(ResourceState state)
 {
-    typedef IResource::Usage Usage;
-    switch (usage)
+    switch (state)
     {
-        case Usage::ConstantBuffer:     return GL_UNIFORM_BUFFER;
-        default:                        return GL_SHADER_STORAGE_BUFFER;
+    case ResourceState::ConstantBuffer:
+        return GL_UNIFORM_BUFFER;
+    default:
+        return GL_SHADER_STORAGE_BUFFER;
     }
 }
 
 SLANG_NO_THROW Result SLANG_MCALL GLDevice::createBufferResource(
-    IResource::Usage initialUsage,
     const IBufferResource::Desc& descIn,
     const void* initData,
     IBufferResource** outResource)
 {
-    BufferResource::Desc desc(descIn);
-    desc.setDefaults(initialUsage);
+    BufferResource::Desc desc = fixupBufferDesc(descIn);
 
-    const GLenum target = _calcTarget(initialUsage);
-    // TODO: should derive from desc...
-    const GLenum usage = _calcUsage(initialUsage);
+    const GLenum target = _calcTarget(desc.defaultState);
+    const GLenum usage = _calcUsage(desc.defaultState);
 
     GLuint bufferID = 0;
     glGenBuffers(1, &bufferID);
@@ -2614,7 +2615,7 @@ SLANG_NO_THROW Result SLANG_MCALL GLDevice::createBufferResource(
 
     glBufferData(target, descIn.sizeInBytes, initData, usage);
 
-    RefPtr<BufferResourceImpl> resourceImpl = new BufferResourceImpl(initialUsage, desc, m_weakRenderer, bufferID, target);
+    RefPtr<BufferResourceImpl> resourceImpl = new BufferResourceImpl(desc, m_weakRenderer, bufferID, target);
     returnComPtr(outResource, resourceImpl);
     return SLANG_OK;
 }
diff --git a/tools/gfx/renderer-shared.h b/tools/gfx/renderer-shared.h
index b19e0539b..ed045c617 100644
--- a/tools/gfx/renderer-shared.h
+++ b/tools/gfx/renderer-shared.h
@@ -5,6 +5,8 @@
 #include "core/slang-basic.h"
 #include "core/slang-com-object.h"
 
+#include "resource-desc-utils.h"
+
 namespace gfx
 {
 
diff --git a/tools/gfx/resource-desc-utils.cpp b/tools/gfx/resource-desc-utils.cpp
new file mode 100644
index 000000000..93609cd0e
--- /dev/null
+++ b/tools/gfx/resource-desc-utils.cpp
@@ -0,0 +1,20 @@
+#include "resource-desc-utils.h"
+
+namespace gfx
+{
+IBufferResource::Desc fixupBufferDesc(const IBufferResource::Desc& desc)
+{
+    IBufferResource::Desc result = desc;
+    result.allowedStates.add(result.defaultState);
+    return result;
+}
+
+ITextureResource::Desc fixupTextureDesc(const ITextureResource::Desc& desc)
+{
+    ITextureResource::Desc rs = desc;
+    if (desc.numMipLevels == 0)
+        rs.numMipLevels = calcNumMipLevels(desc.type, desc.size);
+    rs.allowedStates.add(rs.defaultState);
+    return rs;
+}
+}
diff --git a/tools/gfx/resource-desc-utils.h b/tools/gfx/resource-desc-utils.h
new file mode 100644
index 000000000..11150ce2a
--- /dev/null
+++ b/tools/gfx/resource-desc-utils.h
@@ -0,0 +1,99 @@
+#pragma once
+
+#include "slang-gfx.h"
+#include "core/slang-math.h"
+
+namespace gfx
+{
+
+inline int calcMipSize(int size, int level)
+{
+    size = size >> level;
+    return size > 0 ? size : 1;
+}
+
+inline ITextureResource::Size calcMipSize(ITextureResource::Size size, int mipLevel)
+{
+    ITextureResource::Size rs;
+    rs.width = calcMipSize(size.width, mipLevel);
+    rs.height = calcMipSize(size.height, mipLevel);
+    rs.depth = calcMipSize(size.depth, mipLevel);
+    return rs;
+}
+
+/// Calculate the effective array size - in essence the amount if mip map sets needed.
+/// In practice takes into account if the arraySize is 0 (it's not an array, but it will still have
+/// at least one mip set) and if the type is a cubemap (multiplies the amount of mip sets by 6)
+inline int calcEffectiveArraySize(const ITextureResource::Desc& desc)
+{
+    const int arrSize = (desc.arraySize > 0) ? desc.arraySize : 1;
+
+    switch (desc.type)
+    {
+    case IResource::Type::Texture1D: // fallthru
+    case IResource::Type::Texture2D:
+        {
+            return arrSize;
+        }
+    case IResource::Type::TextureCube:
+        return arrSize * 6;
+    case IResource::Type::Texture3D:
+        return 1;
+    default:
+        return 0;
+    }
+}
+
+/// Given the type works out the maximum dimension size
+inline int calcMaxDimension(ITextureResource::Size size, IResource::Type type)
+{
+    switch (type)
+    {
+    case IResource::Type::Texture1D:
+        return size.width;
+    case IResource::Type::Texture3D:
+        return Slang::Math::Max(Slang::Math::Max(size.width, size.height), size.depth);
+    case IResource::Type::TextureCube: // fallthru
+    case IResource::Type::Texture2D:
+        {
+            return Slang::Math::Max(size.width, size.height);
+        }
+    default:
+        return 0;
+    }
+}
+
+/// Given the type, calculates the number of mip maps. 0 on error
+inline int calcNumMipLevels(IResource::Type type, ITextureResource::Size size)
+{
+    const int maxDimensionSize = calcMaxDimension(size, type);
+    return (maxDimensionSize > 0) ? (Slang::Math::Log2Floor(maxDimensionSize) + 1) : 0;
+}
+/// Calculate the total number of sub resources. 0 on error.
+inline int calcNumSubResources(const ITextureResource::Desc& desc)
+{
+    const int numMipMaps =
+        (desc.numMipLevels > 0) ? desc.numMipLevels : calcNumMipLevels(desc.type, desc.size);
+    const int arrSize = (desc.arraySize > 0) ? desc.arraySize : 1;
+
+    switch (desc.type)
+    {
+    case IResource::Type::Texture1D:
+    case IResource::Type::Texture2D:
+    case IResource::Type::Texture3D:
+        {
+            return numMipMaps * arrSize;
+        }
+    case IResource::Type::TextureCube:
+        {
+            // There are 6 faces to a cubemap
+            return numMipMaps * arrSize * 6;
+        }
+    default:
+        return 0;
+    }
+}
+
+IBufferResource::Desc fixupBufferDesc(const IBufferResource::Desc& desc);
+ITextureResource::Desc fixupTextureDesc(const ITextureResource::Desc& desc);
+}
diff --git a/tools/gfx/simple-transient-resource-heap.h b/tools/gfx/simple-transient-resource-heap.h
index 55731ddd0..d8ab3517d 100644
--- a/tools/gfx/simple-transient-resource-heap.h
+++ b/tools/gfx/simple-transient-resource-heap.h
@@ -31,11 +31,13 @@ public:
     {
         m_device = device;
         IBufferResource::Desc bufferDesc = {};
-        bufferDesc.setDefaults(IResource::Usage::ConstantBuffer);
+        bufferDesc.type = IResource::Type::Buffer;
+        bufferDesc.allowedStates = ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination);
+        bufferDesc.defaultState = ResourceState::ConstantBuffer;
         bufferDesc.sizeInBytes = desc.constantBufferSize;
         bufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
-        SLANG_RETURN_ON_FAIL(device->createBufferResource(
-            IResource::Usage::ConstantBuffer, bufferDesc, nullptr, m_constantBuffer.writeRef()));
+        SLANG_RETURN_ON_FAIL(
+            device->createBufferResource(bufferDesc, nullptr, m_constantBuffer.writeRef()));
         return SLANG_OK;
     }
     virtual SLANG_NO_THROW Result SLANG_MCALL
diff --git a/tools/gfx/transient-resource-heap-base.h b/tools/gfx/transient-resource-heap-base.h
index 769f63f54..ef8a61616 100644
--- a/tools/gfx/transient-resource-heap-base.h
+++ b/tools/gfx/transient-resource-heap-base.h
@@ -41,11 +41,13 @@ public:
             Slang::ComPtr<IBufferResource> bufferPtr;
             IBufferResource::Desc bufferDesc;
             bufferDesc.type = IResource::Type::Buffer;
-            bufferDesc.setDefaults(IResource::Usage::ConstantBuffer);
-            bufferDesc.init(desc.constantBufferSize);
+            bufferDesc.defaultState = ResourceState::ConstantBuffer;
+            bufferDesc.allowedStates =
+                ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination);
+            bufferDesc.sizeInBytes = desc.constantBufferSize;
             bufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
-            SLANG_RETURN_ON_FAIL(m_device->createBufferResource(
-                IResource::Usage::ConstantBuffer, bufferDesc, nullptr, bufferPtr.writeRef()));
+            SLANG_RETURN_ON_FAIL(
+                m_device->createBufferResource(bufferDesc, nullptr, bufferPtr.writeRef()));
             m_constantBuffers.add(static_cast<TBufferResource*>(bufferPtr.get()));
         }
 
@@ -85,17 +87,19 @@ public:
             Slang::ComPtr<IBufferResource> bufferPtr;
             IBufferResource::Desc bufferDesc;
             bufferDesc.type = IResource::Type::Buffer;
-            bufferDesc.setDefaults(IResource::Usage::ConstantBuffer);
+            bufferDesc.defaultState = ResourceState::ConstantBuffer;
+            bufferDesc.allowedStates =
+                ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination);
             bufferDesc.cpuAccessFlags |= IResource::AccessFlag::Write;
             size_t lastConstantBufferSize = 0;
             if (m_constantBuffers.getCount())
             {
                 lastConstantBufferSize = m_constantBuffers.getLast()->getDesc()->sizeInBytes;
             }
-            bufferDesc.init(Slang::Math::Max(
-                lastConstantBufferSize * 2, Slang::Math::Max(size, size_t(4 << 20))));
-            SLANG_RETURN_ON_FAIL(m_device->createBufferResource(
-                IResource::Usage::ConstantBuffer, bufferDesc, nullptr, bufferPtr.writeRef()));
+            bufferDesc.sizeInBytes = Slang::Math::Max(
+                lastConstantBufferSize * 2, Slang::Math::Max(size, size_t(4 << 20)));
+            SLANG_RETURN_ON_FAIL(
+                m_device->createBufferResource(bufferDesc, nullptr, bufferPtr.writeRef()));
             bufferId = m_constantBuffers.getCount();
             bufferAllocOffset = 0;
             m_constantBuffers.add(static_cast<TBufferResource*>(bufferPtr.get()));
diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp
index 389b46c8e..55d0f2ee6 100644
--- a/tools/gfx/vulkan/render-vk.cpp
+++ b/tools/gfx/vulkan/render-vk.cpp
@@ -67,12 +67,10 @@ public:
         const IRenderPassLayout::Desc& desc,
         IRenderPassLayout** outRenderPassLayout) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
-        IResource::Usage initialUsage,
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData,
         ITextureResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
-        IResource::Usage initialUsage,
         const IBufferResource::Desc& desc,
         const void* initData,
         IBufferResource** outResource) override;
@@ -165,15 +163,13 @@ public:
     public:
         typedef BufferResource Parent;
 
-        BufferResourceImpl(IResource::Usage initialUsage, const IBufferResource::Desc& desc, VKDevice* renderer):
-            Parent(desc),
-            m_renderer(renderer),
-            m_initialUsage(initialUsage)
+        BufferResourceImpl(const IBufferResource::Desc& desc, VKDevice* renderer)
+            : Parent(desc)
+            , m_renderer(renderer)
         {
             assert(renderer);
         }
 
-        IResource::Usage m_initialUsage;
         RefPtr<VKDevice> m_renderer;
         Buffer m_buffer;
         Buffer m_uploadBuffer;
@@ -183,10 +179,9 @@ public:
     {
     public:
         typedef TextureResource Parent;
-        TextureResourceImpl(const Desc& desc, Usage initialUsage, VKDevice* device) :
-            Parent(desc),
-            m_initialUsage(initialUsage),
-            m_device(device)
+        TextureResourceImpl(const Desc& desc, VKDevice* device)
+            : Parent(desc)
+            , m_device(device)
         {
         }
         ~TextureResourceImpl()
@@ -199,8 +194,6 @@ public:
             }
         }
 
-        Usage m_initialUsage;
-
         VkImage m_image = VK_NULL_HANDLE;
         VkFormat m_vkformat = VK_FORMAT_R8G8B8A8_UNORM;
         VkDeviceMemory m_imageMemory = VK_NULL_HANDLE;
@@ -3005,11 +2998,6 @@ public:
                 for (Index i = 0; i < Index(slotCount); i++)
                 {
                     BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(buffers[i]);
-                    if (buffer)
-                    {
-                        assert(buffer->m_initialUsage == IResource::Usage::VertexBuffer);
-                    }
-
                     BoundVertexBuffer& boundBuffer = m_boundVertexBuffers[startSlot + i];
                     boundBuffer.m_buffer = buffer;
                     boundBuffer.m_stride = int(strides[i]);
@@ -3618,11 +3606,19 @@ public:
             for (uint32_t i = 0; i < m_desc.imageCount; i++)
             {
                 ITextureResource::Desc imageDesc = {};
-
-                imageDesc.init2D(
-                    IResource::Type::Texture2D, m_desc.format, m_desc.width, m_desc.height, 1);
-                RefPtr<TextureResourceImpl> image = new TextureResourceImpl(
-                    imageDesc, gfx::IResource::Usage::RenderTarget, m_renderer);
+                imageDesc.allowedStates = ResourceStateSet(
+                    ResourceState::Present,
+                    ResourceState::RenderTarget,
+                    ResourceState::CopyDestination);
+                imageDesc.type = IResource::Type::Texture2D;
+                imageDesc.arraySize = 0;
+                imageDesc.format = m_desc.format;
+                imageDesc.size.width = m_desc.width;
+                imageDesc.size.height = m_desc.height;
+                imageDesc.size.depth = 1;
+                imageDesc.numMipLevels = 1;
+                imageDesc.defaultState = ResourceState::Present;
+                RefPtr<TextureResourceImpl> image = new TextureResourceImpl(imageDesc, m_renderer);
                 image->m_image = vkImages[i];
                 image->m_imageMemory = 0;
                 image->m_vkformat = m_vkformat;
@@ -4604,56 +4600,69 @@ SlangResult VKDevice::readBufferResource(
     return SLANG_OK;
 }
 
-static VkBufferUsageFlagBits _calcBufferUsageFlags(IResource::BindFlag::Enum bind)
+static VkBufferUsageFlagBits _calcBufferUsageFlags(ResourceState state)
 {
-    typedef IResource::BindFlag BindFlag;
-
-    switch (bind)
+    switch (state)
     {
-        case BindFlag::VertexBuffer:            return VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-        case BindFlag::IndexBuffer:             return VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
-        case BindFlag::ConstantBuffer:          return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
-        case BindFlag::StreamOutput:
-        case BindFlag::RenderTarget:
-        case BindFlag::DepthStencil:
-        {
-            assert(!"Not supported yet");
+    case ResourceState::VertexBuffer:
+        return VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
+    case ResourceState::IndexBuffer:
+        return VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
+    case ResourceState::ConstantBuffer:
+        return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+    case ResourceState::StreamOutput:
+        return VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
+    case ResourceState::RenderTarget:
+    case ResourceState::DepthRead:
+    case ResourceState::DepthWrite:
+        {
+            assert(!"Invalid resource state for buffer resource.");
             return VkBufferUsageFlagBits(0);
         }
-        case BindFlag::UnorderedAccess:         return VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
-        case BindFlag::PixelShaderResource:     return VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-        case BindFlag::NonPixelShaderResource:  return VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-        default:                                return VkBufferUsageFlagBits(0);
+    case ResourceState::UnorderedAccess:
+        return VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
+    case ResourceState::ShaderResource:
+        return VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+    case ResourceState::CopySource:
+        return VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+    case ResourceState::CopyDestination:
+        return VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+    default:
+        return VkBufferUsageFlagBits(0);
     }
 }
 
-static VkBufferUsageFlagBits _calcBufferUsageFlags(int bindFlags)
+static VkBufferUsageFlagBits _calcBufferUsageFlags(ResourceStateSet states)
 {
     int dstFlags = 0;
-    while (bindFlags)
+    for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++)
     {
-        int lsb = bindFlags & -bindFlags;
-        dstFlags |= _calcBufferUsageFlags(IResource::BindFlag::Enum(lsb));
-        bindFlags &= ~lsb;
+        auto state = (ResourceState)i;
+        if (states.contains(state))
+            dstFlags |= _calcBufferUsageFlags(state);
     }
     return VkBufferUsageFlagBits(dstFlags);
 }
 
-static VkImageUsageFlagBits _calcImageUsageFlags(IResource::BindFlag::Enum bind)
+static VkImageUsageFlagBits _calcImageUsageFlags(ResourceState state)
 {
-    typedef IResource::BindFlag BindFlag;
-
-    switch (bind)
+    switch (state)
     {
-        case BindFlag::RenderTarget:            return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-        case BindFlag::DepthStencil:            return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
-        case BindFlag::NonPixelShaderResource:
-        case BindFlag::PixelShaderResource:
-        {
-            // Ignore
-            return VkImageUsageFlagBits(0);
-        }
-        default:
+    case ResourceState::RenderTarget:
+        return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    case ResourceState::DepthWrite:
+        return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+    case ResourceState::DepthRead:
+        return VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+    case ResourceState::ShaderResource:
+        return VK_IMAGE_USAGE_SAMPLED_BIT;
+    case ResourceState::UnorderedAccess:
+        return VK_IMAGE_USAGE_STORAGE_BIT;
+    case ResourceState::CopySource:
+        return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    case ResourceState::CopyDestination:
+        return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    default:
         {
             assert(!"Unsupported");
             return VkImageUsageFlagBits(0);
@@ -4661,29 +4670,25 @@ static VkImageUsageFlagBits _calcImageUsageFlags(IResource::BindFlag::Enum bind)
     }
 }
 
-static VkImageUsageFlagBits _calcImageUsageFlags(int bindFlags)
+static VkImageUsageFlagBits _calcImageUsageFlags(ResourceStateSet states)
 {
     int dstFlags = 0;
-    while (bindFlags)
+    for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++)
     {
-        int lsb = bindFlags & -bindFlags;
-        dstFlags |= _calcImageUsageFlags(IResource::BindFlag::Enum(lsb));
-        bindFlags &= ~lsb;
+        auto state = (ResourceState)i;
+        if (states.contains(state))
+            dstFlags |= _calcImageUsageFlags(state);
     }
     return VkImageUsageFlagBits(dstFlags);
 }
 
-static VkImageUsageFlags _calcImageUsageFlags(int bindFlags, int cpuAccessFlags, const void* initData)
+static VkImageUsageFlags _calcImageUsageFlags(
+    ResourceStateSet states,
+    int cpuAccessFlags,
+    const void* initData)
 {
-    VkImageUsageFlags usage = _calcImageUsageFlags(bindFlags);
-
-    usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+    VkImageUsageFlags usage = _calcImageUsageFlags(states);
 
-    if (cpuAccessFlags & IResource::AccessFlag::Read)
-    {
-        // If it can be read from, set this
-        usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-    }
     if ((cpuAccessFlags & IResource::AccessFlag::Write) || initData)
     {
         usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
@@ -4826,10 +4831,9 @@ size_t calcNumRows(Format format, int height)
     return (size_t)height;
 }
 
-Result VKDevice::createTextureResource(IResource::Usage initialUsage, const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource)
+Result VKDevice::createTextureResource(const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource)
 {
-    TextureResource::Desc desc(descIn);
-    desc.setDefaults(initialUsage);
+    TextureResource::Desc desc = fixupTextureDesc(descIn);
 
     const VkFormat format = VulkanUtil::getVkFormat(desc.format);
     if (format == VK_FORMAT_UNDEFINED)
@@ -4838,9 +4842,9 @@ Result VKDevice::createTextureResource(IResource::Usage initialUsage, const ITex
         return SLANG_FAIL;
     }
 
-    const int arraySize = desc.calcEffectiveArraySize();
+    const int arraySize = calcEffectiveArraySize(desc);
 
-    RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(desc, initialUsage, this));
+    RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(desc, this));
     texture->m_vkformat = format;
     // Create the image
     {
@@ -4888,7 +4892,7 @@ Result VKDevice::createTextureResource(IResource::Usage initialUsage, const ITex
         imageInfo.format = format;
 
         imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
-        imageInfo.usage = _calcImageUsageFlags(desc.bindFlags, desc.cpuAccessFlags, initData);
+        imageInfo.usage = _calcImageUsageFlags(desc.allowedStates, desc.cpuAccessFlags, initData);
         imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
         imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
@@ -4934,7 +4938,7 @@ Result VKDevice::createTextureResource(IResource::Usage initialUsage, const ITex
         // Calculate how large an array entry is
         for (int j = 0; j < numMipMaps; ++j)
         {
-            const TextureResource::Size mipSize = desc.size.calcMipSize(j);
+            const TextureResource::Size mipSize = calcMipSize(desc.size, j);
 
             auto rowSizeInBytes = calcRowSize(desc.format, mipSize.width);
             auto numRows = calcNumRows(desc.format, mipSize.height);
@@ -5042,30 +5046,25 @@ Result VKDevice::createTextureResource(IResource::Usage initialUsage, const ITex
                 }
             }
         }
-        _transitionImageLayout(texture->m_image, format, *texture->getDesc(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+        auto defaultLayout = VulkanUtil::getImageLayoutFromState(desc.defaultState);
+        _transitionImageLayout(
+            texture->m_image,
+            format,
+            *texture->getDesc(),
+            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            defaultLayout);
     }
     else
     {
-        switch (initialUsage)
+        auto defaultLayout = VulkanUtil::getImageLayoutFromState(desc.defaultState);
+        if (defaultLayout != VK_IMAGE_LAYOUT_UNDEFINED)
         {
-        case IResource::Usage::RenderTarget:
             _transitionImageLayout(
                 texture->m_image,
                 format,
                 *texture->getDesc(),
                 VK_IMAGE_LAYOUT_UNDEFINED,
-                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
-            break;
-        case IResource::Usage::DepthWrite:
-            _transitionImageLayout(
-                texture->m_image,
-                format,
-                *texture->getDesc(),
-                VK_IMAGE_LAYOUT_UNDEFINED,
-                VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
-            break;
-        default:
-            break;
+                defaultLayout);
         }
     }
     m_deviceQueue.flushAndWait();
@@ -5073,29 +5072,27 @@ Result VKDevice::createTextureResource(IResource::Usage initialUsage, const ITex
     return SLANG_OK;
 }
 
-Result VKDevice::createBufferResource(IResource::Usage initialUsage, const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource)
+Result VKDevice::createBufferResource(const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource)
 {
-    BufferResource::Desc desc(descIn);
-    desc.setDefaults(initialUsage);
+    BufferResource::Desc desc = fixupBufferDesc(descIn);
 
     const size_t bufferSize = desc.sizeInBytes;
 
     VkMemoryPropertyFlags reqMemoryProperties = 0;
 
-    VkBufferUsageFlags usage = _calcBufferUsageFlags(desc.bindFlags) |
-                               VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+    VkBufferUsageFlags usage = _calcBufferUsageFlags(desc.allowedStates);
 
-    switch (initialUsage)
+    if (initData)
     {
-        case IResource::Usage::ConstantBuffer:
-        {
-            reqMemoryProperties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-            break;
-        }
-        default: break;
+        usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+    }
+
+    if (desc.allowedStates.contains(ResourceState::ConstantBuffer))
+    {
+        reqMemoryProperties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
     }
 
-    RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(initialUsage, desc, this));
+    RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(desc, this));
     SLANG_RETURN_ON_FAIL(buffer->m_buffer.init(m_api, desc.sizeInBytes, usage, reqMemoryProperties));
 
     if ((desc.cpuAccessFlags & IResource::AccessFlag::Write) || initData)
diff --git a/tools/gfx/vulkan/vk-util.cpp b/tools/gfx/vulkan/vk-util.cpp
index 46ffb01fd..135fe3732 100644
--- a/tools/gfx/vulkan/vk-util.cpp
+++ b/tools/gfx/vulkan/vk-util.cpp
@@ -77,6 +77,36 @@ VkPipelineBindPoint VulkanUtil::getPipelineBindPoint(PipelineType pipelineType)
     }
 }
 
+VkImageLayout VulkanUtil::getImageLayoutFromState(ResourceState state)
+{
+    switch (state)
+    {
+    case ResourceState::ShaderResource:
+        return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    case ResourceState::UnorderedAccess:
+        return VK_IMAGE_LAYOUT_GENERAL;
+    case ResourceState::Present:
+        return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+    case ResourceState::CopySource:
+        return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    case ResourceState::CopyDestination:
+        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    case ResourceState::RenderTarget:
+        return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    case ResourceState::DepthWrite:
+        return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+    case ResourceState::DepthRead:
+        return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+    case ResourceState::ResolveSource:
+        return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    case ResourceState::ResolveDestination:
+        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    default:
+        return VK_IMAGE_LAYOUT_UNDEFINED;
+    }
+    return VkImageLayout();
+}
+
 /* static */Slang::Result VulkanUtil::handleFail(VkResult res)
 {
     if (res != VK_SUCCESS)
diff --git a/tools/gfx/vulkan/vk-util.h b/tools/gfx/vulkan/vk-util.h
index 0b14f7f84..a39fe5115 100644
--- a/tools/gfx/vulkan/vk-util.h
+++ b/tools/gfx/vulkan/vk-util.h
@@ -42,6 +42,8 @@ struct VulkanUtil
     static VkShaderStageFlags getShaderStage(SlangStage stage);
 
     static VkPipelineBindPoint getPipelineBindPoint(PipelineType pipelineType);
+
+    static VkImageLayout getImageLayoutFromState(ResourceState state);
 };
 
 } // renderer_test
diff --git a/tools/platform/gui.cpp b/tools/platform/gui.cpp
index 63cf3d51b..ba6fc35f8 100644
--- a/tools/platform/gui.cpp
+++ b/tools/platform/gui.cpp
@@ -139,16 +139,23 @@ GUI::GUI(
     io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
 
     {
-        gfx::ITextureResource::Desc desc;
-        desc.init2D(IResource::Type::Texture2D, Format::RGBA_Unorm_UInt8, width, height, 1);
-        desc.setDefaults(IResource::Usage::PixelShaderResource);
+        gfx::ITextureResource::Desc desc = {};
+        desc.type = IResource::Type::Texture2D;
+        desc.format = Format::RGBA_Unorm_UInt8;
+        desc.arraySize = 0;
+        desc.size.width = width;
+        desc.size.height = height;
+        desc.size.depth = 1;
+        desc.numMipLevels = 1;
+        desc.defaultState = ResourceState::ShaderResource;
+        desc.allowedStates =
+            ResourceStateSet(ResourceState::ShaderResource, ResourceState::CopyDestination);
 
         ITextureResource::SubresourceData initData = {};
         initData.data = pixels;
         initData.strideY = width * 4 * sizeof(unsigned char);
 
-        auto texture =
-            device->createTextureResource(IResource::Usage::PixelShaderResource, desc, &initData);
+        auto texture = device->createTextureResource(desc, &initData);
 
         gfx::IResourceView::Desc viewDesc;
         viewDesc.format = desc.format;
@@ -204,19 +211,22 @@ void GUI::endFrame(ITransientResourceHeap* transientHeap, IFramebuffer* framebuf
     // Allocate transient vertex/index buffers to hold the data for this frame.
 
     gfx::IBufferResource::Desc vertexBufferDesc;
-    vertexBufferDesc.init(vertexCount * sizeof(ImDrawVert));
-    vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer);
+    vertexBufferDesc.type = IResource::Type::Buffer;
+    vertexBufferDesc.defaultState = ResourceState::VertexBuffer;
+    vertexBufferDesc.allowedStates =
+        ResourceStateSet(ResourceState::VertexBuffer, ResourceState::CopyDestination);
+    vertexBufferDesc.sizeInBytes = vertexCount * sizeof(ImDrawVert);
     vertexBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
-    auto vertexBuffer =
-        device->createBufferResource(IResource::Usage::VertexBuffer, vertexBufferDesc);
+    auto vertexBuffer = device->createBufferResource(vertexBufferDesc);
 
     gfx::IBufferResource::Desc indexBufferDesc;
-    indexBufferDesc.init(indexCount * sizeof(ImDrawIdx));
-    indexBufferDesc.setDefaults(IResource::Usage::IndexBuffer);
+    indexBufferDesc.type = IResource::Type::Buffer;
+    indexBufferDesc.sizeInBytes = indexCount * sizeof(ImDrawIdx);
+    indexBufferDesc.allowedStates =
+        ResourceStateSet(ResourceState::IndexBuffer, ResourceState::CopyDestination);
+    indexBufferDesc.defaultState = ResourceState::IndexBuffer;
     indexBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
-    auto indexBuffer = device->createBufferResource(
-        IResource::Usage::IndexBuffer,
-        indexBufferDesc);
+    auto indexBuffer = device->createBufferResource(indexBufferDesc);
     auto cmdBuf = transientHeap->createCommandBuffer();
     auto encoder = cmdBuf->encodeResourceCommands();
     {
@@ -238,11 +248,13 @@ void GUI::endFrame(ITransientResourceHeap* transientHeap, IFramebuffer* framebuf
 
     // Allocate a transient constant buffer for projection matrix
     gfx::IBufferResource::Desc constantBufferDesc;
-    constantBufferDesc.init(sizeof(glm::mat4x4));
-    constantBufferDesc.setDefaults(IResource::Usage::ConstantBuffer);
+    constantBufferDesc.type = IResource::Type::Buffer;
+    constantBufferDesc.allowedStates =
+        ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination);
+    constantBufferDesc.defaultState = ResourceState::ConstantBuffer;
+    constantBufferDesc.sizeInBytes = sizeof(glm::mat4x4);
     constantBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
-    auto constantBuffer =
-        device->createBufferResource(IResource::Usage::ConstantBuffer, constantBufferDesc);
+    auto constantBuffer = device->createBufferResource(constantBufferDesc);
 
     {
         float L = draw_data->DisplayPos.x;
diff --git a/tools/platform/model.cpp b/tools/platform/model.cpp
index fadfcc0e2..57acf9ecd 100644
--- a/tools/platform/model.cpp
+++ b/tools/platform/model.cpp
@@ -189,12 +189,16 @@ ComPtr<ITextureResource> loadTextureImage(
 
     int mipCount = (int) subresourceInitData.size();
 
-    ITextureResource::Desc desc;
-    desc.init2D(IResource::Type::Texture2D, format, extentX, extentY, mipCount);
-
-    auto texture =
-        device->createTextureResource(IResource::Usage::PixelShaderResource, desc, subresourceInitData.data());
-
+    ITextureResource::Desc desc = {};
+    desc.type = IResource::Type::Texture2D;
+    desc.defaultState = ResourceState::ShaderResource;
+    desc.allowedStates = ResourceStateSet(ResourceState::ShaderResource);
+    desc.format = format;
+    desc.size.width = extentX;
+    desc.size.height = extentY;
+    desc.size.depth = 1;
+    desc.numMipLevels = mipCount;
+    auto texture = device->createTextureResource(desc, subresourceInitData.data());
     free(data);
 
     return texture;
@@ -542,23 +546,23 @@ SlangResult ModelLoader::load(
     modelData.meshes = meshes.data();
 
     IBufferResource::Desc vertexBufferDesc;
-    vertexBufferDesc.init(modelData.vertexCount * sizeof(Vertex));
-    vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer);
+    vertexBufferDesc.type = IResource::Type::Buffer;
+    vertexBufferDesc.sizeInBytes = modelData.vertexCount * sizeof(Vertex);
+    vertexBufferDesc.allowedStates =
+        ResourceStateSet(ResourceState::VertexBuffer, ResourceState::CopyDestination);
+    vertexBufferDesc.defaultState = ResourceState::VertexBuffer;
 
-    modelData.vertexBuffer = device->createBufferResource(
-        IResource::Usage::VertexBuffer,
-        vertexBufferDesc,
-        flatVertices.data());
+    modelData.vertexBuffer = device->createBufferResource(vertexBufferDesc, flatVertices.data());
     if(!modelData.vertexBuffer) return SLANG_FAIL;
 
     IBufferResource::Desc indexBufferDesc;
-    indexBufferDesc.init(modelData.indexCount * sizeof(Index));
-    vertexBufferDesc.setDefaults(IResource::Usage::IndexBuffer);
+    indexBufferDesc.type = IResource::Type::Buffer;
+    indexBufferDesc.sizeInBytes = modelData.indexCount * sizeof(Index);
+    indexBufferDesc.allowedStates =
+        ResourceStateSet(ResourceState::IndexBuffer, ResourceState::CopyDestination);
+    indexBufferDesc.defaultState = ResourceState::IndexBuffer;
 
-    modelData.indexBuffer = device->createBufferResource(
-        IResource::Usage::IndexBuffer,
-        indexBufferDesc,
-        flatIndices.data());
+    modelData.indexBuffer = device->createBufferResource(indexBufferDesc, flatIndices.data());
     if(!modelData.indexBuffer) return SLANG_FAIL;
 
     *outModel = callbacks->createModel(modelData);
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);