gfx: add coverage for more resource commands. (#2020)

* gfx: specify SubresourceRange for resource view creation.

* Add gfx method for `resolveResource`.

* Fix compile error.

* `copyTextureToBuffer` and `textureSubresourceBarrier`.

* Fix vulkan bug.

* Fix test cras;h.

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

9 files changed, 446 insertions, 60 deletions

diff --git a/tools/gfx/cuda/render-cuda.cpp b/tools/gfx/cuda/render-cuda.cpp
index be3379c71..a3c288ab0 100644
--- a/tools/gfx/cuda/render-cuda.cpp
+++ b/tools/gfx/cuda/render-cuda.cpp
@@ -1044,10 +1044,10 @@ public:
 
             virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
                 ITextureResource* dst,
-                ITextureResource::SubresourceRange dstSubresource,
+                SubresourceRange dstSubresource,
                 ITextureResource::Offset3D dstOffset,
                 ITextureResource* src,
-                ITextureResource::SubresourceRange srcSubresource,
+                SubresourceRange srcSubresource,
                 ITextureResource::Offset3D srcOffset,
                 ITextureResource::Size extent) override
             {
@@ -1063,7 +1063,7 @@ public:
 
             virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
                 ITextureResource* dst,
-                ITextureResource::SubresourceRange subResourceRange,
+                SubresourceRange subResourceRange,
                 ITextureResource::Offset3D offset,
                 ITextureResource::Offset3D extent,
                 ITextureResource::SubresourceData* subResourceData,
@@ -1088,6 +1088,51 @@ public:
                 SLANG_UNUSED(flags);
                 SLANG_UNIMPLEMENTED_X("clearResourceView");
             }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
+                ITextureResource* source,
+                SubresourceRange sourceRange,
+                ITextureResource* dest,
+                SubresourceRange destRange) override
+            {
+                SLANG_UNUSED(source);
+                SLANG_UNUSED(sourceRange);
+                SLANG_UNUSED(dest);
+                SLANG_UNUSED(destRange);
+                SLANG_UNIMPLEMENTED_X("resolveResource");
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
+                IBufferResource* dst,
+                size_t dstOffset,
+                size_t dstSize,
+                ITextureResource* src,
+                SubresourceRange srcSubresource,
+                ITextureResource::Offset3D srcOffset,
+                ITextureResource::Size extent) override
+            {
+                SLANG_UNUSED(dst);
+                SLANG_UNUSED(dstOffset);
+                SLANG_UNUSED(dstSize);
+                SLANG_UNUSED(src);
+                SLANG_UNUSED(srcSubresource);
+                SLANG_UNUSED(srcOffset);
+                SLANG_UNUSED(extent);
+                SLANG_UNIMPLEMENTED_X("copyTextureToBuffer");
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
+                ITextureResource* texture,
+                SubresourceRange subresourceRange,
+                ResourceState src,
+                ResourceState dst) override
+            {
+                SLANG_UNUSED(texture);
+                SLANG_UNUSED(subresourceRange);
+                SLANG_UNUSED(src);
+                SLANG_UNUSED(dst);
+                SLANG_UNIMPLEMENTED_X("textureSubresourceBarrier");
+            }
         };
 
         ResourceCommandEncoderImpl m_resourceCommandEncoder;
diff --git a/tools/gfx/d3d/d3d-util.cpp b/tools/gfx/d3d/d3d-util.cpp
index e2083d39e..afd4d068b 100644
--- a/tools/gfx/d3d/d3d-util.cpp
+++ b/tools/gfx/d3d/d3d-util.cpp
@@ -635,6 +635,36 @@ int D3DUtil::getShaderModelFromProfileName(const char* name)
     return 0;
 }
 
+uint32_t D3DUtil::getPlaneSlice(DXGI_FORMAT format, TextureAspect aspect)
+{
+    switch (aspect)
+    {
+    case TextureAspect::Default:
+    case TextureAspect::Color:
+        return 0;
+    case TextureAspect::Depth:
+        return 0;
+    case TextureAspect::Stencil:
+        switch (format)
+        {
+        case DXGI_FORMAT_D24_UNORM_S8_UINT:
+        case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
+            return 1;
+        default:
+            return 0;
+        }
+    case TextureAspect::Plane0:
+        return 0;
+    case TextureAspect::Plane1:
+        return 1;
+    case TextureAspect::Plane2:
+        return 2;
+    default:
+        SLANG_ASSERT_FAILURE("Unknown texture aspect.");
+        return 0;
+    }
+}
+
 /* static */SlangResult D3DUtil::findAdapters(DeviceCheckFlags flags, const UnownedStringSlice& adapterName, IDXGIFactory* dxgiFactory, List<ComPtr<IDXGIAdapter>>& outDxgiAdapters)
 {
     Slang::String lowerAdapterName = Slang::String(adapterName).toLower();
diff --git a/tools/gfx/d3d/d3d-util.h b/tools/gfx/d3d/d3d-util.h
index 4bca89612..7ce922b21 100644
--- a/tools/gfx/d3d/d3d-util.h
+++ b/tools/gfx/d3d/d3d-util.h
@@ -96,6 +96,8 @@ class D3DUtil
 
     static int getShaderModelFromProfileName(const char* profile);
 
+    static uint32_t getPlaneSlice(DXGI_FORMAT format, TextureAspect aspect);
+
 };
 
 #if SLANG_GFX_HAS_DXR_SUPPORT
diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp
index 0d9c94710..5fbe0d4a6 100644
--- a/tools/gfx/d3d12/render-d3d12.cpp
+++ b/tools/gfx/d3d12/render-d3d12.cpp
@@ -3559,10 +3559,10 @@ public:
             }
             virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
                 ITextureResource* dst,
-                ITextureResource::SubresourceRange dstSubresource,
+                SubresourceRange dstSubresource,
                 ITextureResource::Offset3D dstOffset,
                 ITextureResource* src,
-                ITextureResource::SubresourceRange srcSubresource,
+                SubresourceRange srcSubresource,
                 ITextureResource::Offset3D srcOffset,
                 ITextureResource::Size extent) override
             {
@@ -3578,7 +3578,7 @@ public:
 
             virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
                 ITextureResource* dst,
-                ITextureResource::SubresourceRange subResourceRange,
+                SubresourceRange subResourceRange,
                 ITextureResource::Offset3D offset,
                 ITextureResource::Offset3D extent,
                 ITextureResource::SubresourceData* subResourceData,
@@ -3603,6 +3603,51 @@ public:
                 SLANG_UNUSED(flags);
                 SLANG_UNIMPLEMENTED_X("clearResourceView");
             }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
+                ITextureResource* source,
+                SubresourceRange sourceRange,
+                ITextureResource* dest,
+                SubresourceRange destRange) override
+            {
+                SLANG_UNUSED(source);
+                SLANG_UNUSED(sourceRange);
+                SLANG_UNUSED(dest);
+                SLANG_UNUSED(destRange);
+                SLANG_UNIMPLEMENTED_X("resolveResource");
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
+                IBufferResource* dst,
+                size_t dstOffset,
+                size_t dstSize,
+                ITextureResource* src,
+                SubresourceRange srcSubresource,
+                ITextureResource::Offset3D srcOffset,
+                ITextureResource::Size extent) override
+            {
+                SLANG_UNUSED(dst);
+                SLANG_UNUSED(dstOffset);
+                SLANG_UNUSED(dstSize);
+                SLANG_UNUSED(src);
+                SLANG_UNUSED(srcSubresource);
+                SLANG_UNUSED(srcOffset);
+                SLANG_UNUSED(extent);
+                SLANG_UNIMPLEMENTED_X("copyTextureToBuffer");
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
+                ITextureResource* texture,
+                SubresourceRange subresourceRange,
+                ResourceState src,
+                ResourceState dst) override
+            {
+                SLANG_UNUSED(texture);
+                SLANG_UNUSED(subresourceRange);
+                SLANG_UNUSED(src);
+                SLANG_UNUSED(dst);
+                SLANG_UNIMPLEMENTED_X("textureSubresourceBarrier");
+            }
         };
 
         ResourceCommandEncoderImpl m_resourceCommandEncoder;
@@ -4090,7 +4135,13 @@ SlangResult SLANG_MCALL createD3D12Device(const IDevice::Desc* desc, IDevice** o
 
 D3D12Device::~D3D12Device() { m_shaderObjectLayoutCache = decltype(m_shaderObjectLayoutCache)(); }
 
-static void _initSrvDesc(IResource::Type resourceType, const ITextureResource::Desc& textureDesc, const D3D12_RESOURCE_DESC& desc, DXGI_FORMAT pixelFormat, D3D12_SHADER_RESOURCE_VIEW_DESC& descOut)
+static void _initSrvDesc(
+    IResource::Type resourceType,
+    const ITextureResource::Desc& textureDesc,
+    const D3D12_RESOURCE_DESC& desc,
+    DXGI_FORMAT pixelFormat,
+    SubresourceRange subresourceRange,
+    D3D12_SHADER_RESOURCE_VIEW_DESC& descOut)
 {
     // create SRV
     descOut = D3D12_SHADER_RESOURCE_VIEW_DESC();
@@ -4107,9 +4158,11 @@ static void _initSrvDesc(IResource::Type resourceType, const ITextureResource::D
             default: assert(!"Unknown dimension");
         }
 
-        descOut.Texture2D.MipLevels = desc.MipLevels;
-        descOut.Texture2D.MostDetailedMip = 0;
-        descOut.Texture2D.PlaneSlice = 0;
+        descOut.Texture2D.MipLevels =
+            subresourceRange.mipLevelCount == 0 ? desc.MipLevels : subresourceRange.mipLevelCount;
+        descOut.Texture2D.MostDetailedMip = subresourceRange.mipLevel;
+        descOut.Texture2D.PlaneSlice =
+            D3DUtil::getPlaneSlice(descOut.Format, subresourceRange.aspectMask);
         descOut.Texture2D.ResourceMinLODClamp = 0.0f;
     }
     else if (resourceType == IResource::Type::TextureCube)
@@ -4118,18 +4171,24 @@ static void _initSrvDesc(IResource::Type resourceType, const ITextureResource::D
         {
             descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
 
-            descOut.TextureCubeArray.NumCubes = textureDesc.arraySize;
-            descOut.TextureCubeArray.First2DArrayFace = 0;
-            descOut.TextureCubeArray.MipLevels = desc.MipLevels;
-            descOut.TextureCubeArray.MostDetailedMip = 0;
+            descOut.TextureCubeArray.NumCubes = subresourceRange.layerCount == 0
+                                                    ? textureDesc.arraySize
+                                                    : subresourceRange.layerCount / 6;
+            descOut.TextureCubeArray.First2DArrayFace = subresourceRange.baseArrayLayer;
+            descOut.TextureCubeArray.MipLevels = subresourceRange.mipLevelCount == 0
+                                                     ? desc.MipLevels
+                                                     : subresourceRange.mipLevelCount;
+            descOut.TextureCubeArray.MostDetailedMip = subresourceRange.mipLevel;
             descOut.TextureCubeArray.ResourceMinLODClamp = 0;
         }
         else
         {
             descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
 
-            descOut.TextureCube.MipLevels = desc.MipLevels;
-            descOut.TextureCube.MostDetailedMip = 0;
+            descOut.TextureCube.MipLevels = subresourceRange.mipLevelCount == 0
+                                                ? desc.MipLevels
+                                                : subresourceRange.mipLevelCount;
+            descOut.TextureCube.MostDetailedMip = subresourceRange.mipLevel;
             descOut.TextureCube.ResourceMinLODClamp = 0;
         }
     }
@@ -4146,11 +4205,14 @@ static void _initSrvDesc(IResource::Type resourceType, const ITextureResource::D
             default: assert(!"Unknown dimension");
         }
 
-        descOut.Texture2DArray.ArraySize = desc.DepthOrArraySize;
-        descOut.Texture2DArray.MostDetailedMip = 0;
-        descOut.Texture2DArray.MipLevels = desc.MipLevels;
-        descOut.Texture2DArray.FirstArraySlice = 0;
-        descOut.Texture2DArray.PlaneSlice = 0;
+        descOut.Texture2DArray.ArraySize =
+            subresourceRange.layerCount == 0 ? desc.DepthOrArraySize : subresourceRange.layerCount;
+        descOut.Texture2DArray.MostDetailedMip = subresourceRange.mipLevel;
+        descOut.Texture2DArray.MipLevels =
+            subresourceRange.mipLevelCount == 0 ? desc.MipLevels : subresourceRange.mipLevelCount;
+        descOut.Texture2DArray.FirstArraySlice = subresourceRange.baseArrayLayer;
+        descOut.Texture2DArray.PlaneSlice =
+            D3DUtil::getPlaneSlice(descOut.Format, subresourceRange.aspectMask);
         descOut.Texture2DArray.ResourceMinLODClamp = 0;
     }
 }
@@ -5238,6 +5300,7 @@ Result D3D12Device::createTextureView(ITextureResource* texture, IResourceView::
     RefPtr<ResourceViewImpl> viewImpl = new ResourceViewImpl();
     viewImpl->m_resource = resourceImpl;
     viewImpl->m_desc = desc;
+    bool isArray = resourceImpl->getDesc()->arraySize != 0;
     switch (desc.type)
     {
     default:
@@ -5252,13 +5315,27 @@ Result D3D12Device::createTextureView(ITextureResource* texture, IResourceView::
             switch (desc.renderTarget.shape)
             {
             case IResource::Type::Texture1D:
-                rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE1D;
+                rtvDesc.ViewDimension = isArray ? D3D12_RTV_DIMENSION_TEXTURE1DARRAY
+                                                : D3D12_RTV_DIMENSION_TEXTURE1D;
                 rtvDesc.Texture1D.MipSlice = desc.renderTarget.mipSlice;
                 break;
             case IResource::Type::Texture2D:
-                rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
-                rtvDesc.Texture2D.MipSlice = desc.renderTarget.mipSlice;
-                rtvDesc.Texture2D.PlaneSlice = desc.renderTarget.planeIndex;
+                if (resourceImpl->getDesc()->sampleDesc.numSamples > 1)
+                {
+                    rtvDesc.ViewDimension = isArray ? D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY
+                                                    : D3D12_RTV_DIMENSION_TEXTURE2DMS;
+                    rtvDesc.Texture2DMSArray.ArraySize = desc.renderTarget.arraySize;
+                    rtvDesc.Texture2DMSArray.FirstArraySlice = desc.renderTarget.arrayIndex;
+                }
+                else
+                {
+                    rtvDesc.ViewDimension = isArray ? D3D12_RTV_DIMENSION_TEXTURE2DARRAY
+                                                    : D3D12_RTV_DIMENSION_TEXTURE2D;
+                    rtvDesc.Texture2D.MipSlice = desc.renderTarget.mipSlice;
+                    rtvDesc.Texture2D.PlaneSlice = desc.renderTarget.planeIndex;
+                    rtvDesc.Texture2DArray.ArraySize = desc.renderTarget.arraySize;
+                    rtvDesc.Texture2DArray.FirstArraySlice = desc.renderTarget.arrayIndex;
+                }
                 break;
             case IResource::Type::Texture3D:
                 rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE3D;
@@ -5305,7 +5382,49 @@ Result D3D12Device::createTextureView(ITextureResource* texture, IResourceView::
 
             SLANG_RETURN_ON_FAIL(m_cpuViewHeap->allocate(&viewImpl->m_descriptor));
             viewImpl->m_allocator = m_cpuViewHeap;
-            m_device->CreateUnorderedAccessView(resourceImpl->m_resource, nullptr, nullptr, viewImpl->m_descriptor.cpuHandle);
+            D3D12_UNORDERED_ACCESS_VIEW_DESC d3d12desc = {};
+            auto& resourceDesc = *resourceImpl->getDesc();
+            d3d12desc.Format = gfxIsTypelessFormat(texture->getDesc()->format)
+                                   ? D3DUtil::getMapFormat(desc.format)
+                                   : D3DUtil::getMapFormat(texture->getDesc()->format);
+            switch (resourceImpl->getDesc()->type)
+            {
+            case IResource::Type::Texture1D:
+                d3d12desc.ViewDimension = resourceDesc.arraySize == 0
+                                              ? D3D12_UAV_DIMENSION_TEXTURE1D
+                                              : D3D12_UAV_DIMENSION_TEXTURE1DARRAY;
+                d3d12desc.Texture1D.MipSlice = desc.subresourceRange.mipLevel;
+                d3d12desc.Texture1DArray.ArraySize = desc.subresourceRange.layerCount == 0
+                                                         ? resourceDesc.arraySize
+                                                         : desc.subresourceRange.layerCount;
+                d3d12desc.Texture1DArray.FirstArraySlice = desc.subresourceRange.baseArrayLayer;
+
+                break;
+            case IResource::Type::Texture2D:
+                d3d12desc.ViewDimension = resourceDesc.arraySize == 0
+                                              ? D3D12_UAV_DIMENSION_TEXTURE2D
+                                              : D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
+                d3d12desc.Texture2D.MipSlice = desc.subresourceRange.mipLevel;
+                d3d12desc.Texture2D.PlaneSlice =
+                    D3DUtil::getPlaneSlice(d3d12desc.Format, desc.subresourceRange.aspectMask);
+                d3d12desc.Texture2DArray.ArraySize = desc.subresourceRange.layerCount == 0
+                                                         ? resourceDesc.arraySize
+                                                         : desc.subresourceRange.layerCount;
+                d3d12desc.Texture2DArray.FirstArraySlice = desc.subresourceRange.baseArrayLayer;
+                break;
+            case IResource::Type::Texture3D:
+                d3d12desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D;
+                d3d12desc.Texture3D.MipSlice = desc.subresourceRange.mipLevel;
+                d3d12desc.Texture3D.FirstWSlice = desc.subresourceRange.baseArrayLayer;
+                d3d12desc.Texture3D.WSize = desc.subresourceRange.layerCount == 0
+                                                ? resourceDesc.size.depth
+                                                : desc.subresourceRange.layerCount;
+                break;
+            default:
+                return SLANG_FAIL;
+            }
+            m_device->CreateUnorderedAccessView(
+                resourceImpl->m_resource, nullptr, &d3d12desc, viewImpl->m_descriptor.cpuHandle);
         }
         break;
 
@@ -5321,7 +5440,13 @@ Result D3D12Device::createTextureView(ITextureResource* texture, IResourceView::
                 gfxIsTypelessFormat(texture->getDesc()->format) ? D3DUtil::getMapFormat(desc.format) : resourceDesc.Format;
 
             D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc;
-            _initSrvDesc(resourceImpl->getType(), *resourceImpl->getDesc(), resourceDesc, pixelFormat, srvDesc);
+            _initSrvDesc(
+                resourceImpl->getType(),
+                *resourceImpl->getDesc(),
+                resourceDesc,
+                pixelFormat,
+                desc.subresourceRange,
+                srvDesc);
 
             m_device->CreateShaderResourceView(resourceImpl->m_resource, &srvDesc, viewImpl->m_descriptor.cpuHandle);
         }
@@ -5351,24 +5476,33 @@ Result D3D12Device::createBufferView(IBufferResource* buffer, IResourceView::Des
             D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
             uavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
             uavDesc.Format = D3DUtil::getMapFormat(desc.format);
-            uavDesc.Buffer.FirstElement = 0;
+            uavDesc.Buffer.FirstElement = desc.bufferRange.firstElement;
 
-            if(resourceDesc.elementSize)
+            if (resourceDesc.elementSize)
             {
                 uavDesc.Buffer.StructureByteStride = resourceDesc.elementSize;
-                uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / resourceDesc.elementSize);
+                uavDesc.Buffer.NumElements =
+                    desc.bufferRange.elementCount == 0
+                        ? UINT(resourceDesc.sizeInBytes / resourceDesc.elementSize)
+                        : desc.bufferRange.elementCount;
             }
             else if(desc.format == Format::Unknown)
             {
                 uavDesc.Buffer.Flags |= D3D12_BUFFER_UAV_FLAG_RAW;
                 uavDesc.Format = DXGI_FORMAT_R32_TYPELESS;
-                uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / 4);
+                uavDesc.Buffer.NumElements = desc.bufferRange.elementCount == 0
+                                                 ? UINT(resourceDesc.sizeInBytes / 4)
+                                                 : desc.bufferRange.elementCount / 4;
             }
             else
             {
                 FormatInfo sizeInfo;
                 gfxGetFormatInfo(desc.format, &sizeInfo);
-                uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / (sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock));
+                assert(sizeInfo.pixelsPerBlock == 1);
+                uavDesc.Buffer.NumElements =
+                    desc.bufferRange.elementCount == 0
+                        ? UINT(resourceDesc.sizeInBytes / sizeInfo.blockSizeInBytes)
+                        : desc.bufferRange.elementCount;
             }
 
 
@@ -5387,24 +5521,34 @@ Result D3D12Device::createBufferView(IBufferResource* buffer, IResourceView::Des
             srvDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
             srvDesc.Format = D3DUtil::getMapFormat(desc.format);
             srvDesc.Buffer.StructureByteStride = 0;
-            srvDesc.Buffer.FirstElement = 0;
+            srvDesc.Buffer.FirstElement = desc.bufferRange.firstElement;
             srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
             if(resourceDesc.elementSize)
             {
                 srvDesc.Buffer.StructureByteStride = resourceDesc.elementSize;
-                srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / resourceDesc.elementSize);
+                srvDesc.Buffer.NumElements =
+                    desc.bufferRange.elementCount == 0
+                        ? UINT(resourceDesc.sizeInBytes / resourceDesc.elementSize)
+                        : desc.bufferRange.elementCount;
             }
             else if(desc.format == Format::Unknown)
             {
                 srvDesc.Buffer.Flags |= D3D12_BUFFER_SRV_FLAG_RAW;
                 srvDesc.Format = DXGI_FORMAT_R32_TYPELESS;
-                srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / 4);
+                srvDesc.Buffer.NumElements = desc.bufferRange.elementCount == 0
+                                                 ? UINT(resourceDesc.sizeInBytes / 4)
+                                                 : desc.bufferRange.elementCount / 4;
+                
             }
             else
             {
                 FormatInfo sizeInfo;
                 gfxGetFormatInfo(desc.format, &sizeInfo);
-                srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / (sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock));
+                assert(sizeInfo.pixelsPerBlock == 1);
+                srvDesc.Buffer.NumElements =
+                    desc.bufferRange.elementCount == 0
+                        ? UINT(resourceDesc.sizeInBytes / sizeInfo.blockSizeInBytes)
+                        : desc.bufferRange.elementCount;
             }
 
             SLANG_RETURN_ON_FAIL(m_cpuViewHeap->allocate(&viewImpl->m_descriptor));
diff --git a/tools/gfx/debug-layer.cpp b/tools/gfx/debug-layer.cpp
index 99eaf5c00..0fff101ad 100644
--- a/tools/gfx/debug-layer.cpp
+++ b/tools/gfx/debug-layer.cpp
@@ -1220,10 +1220,10 @@ void DebugResourceCommandEncoder::bufferBarrier(
 
 void DebugResourceCommandEncoder::copyTexture(
     ITextureResource* dst,
-    ITextureResource::SubresourceRange dstSubresource,
+    SubresourceRange dstSubresource,
     ITextureResource::Offset3D dstOffset,
     ITextureResource* src,
-    ITextureResource::SubresourceRange srcSubresource,
+    SubresourceRange srcSubresource,
     ITextureResource::Offset3D srcOffset,
     ITextureResource::Size extent)
 {
@@ -1240,7 +1240,7 @@ void DebugResourceCommandEncoder::copyTexture(
 
 void DebugResourceCommandEncoder::uploadTextureData(
     ITextureResource* dst,
-    ITextureResource::SubresourceRange subResourceRange,
+    SubresourceRange subResourceRange,
     ITextureResource::Offset3D offset,
     ITextureResource::Offset3D extent,
     ITextureResource::SubresourceData* subResourceData,
@@ -1258,6 +1258,40 @@ void DebugResourceCommandEncoder::clearResourceView(
     baseObject->clearResourceView(getInnerObj(view), clearValue, flags);
 }
 
+void DebugResourceCommandEncoder::resolveResource(
+    ITextureResource* source,
+    SubresourceRange sourceRange,
+    ITextureResource* dest,
+    SubresourceRange destRange)
+{
+    SLANG_GFX_API_FUNC;
+    baseObject->resolveResource(getInnerObj(source), sourceRange, getInnerObj(dest), destRange);
+}
+
+void DebugResourceCommandEncoder::copyTextureToBuffer(
+    IBufferResource* dst,
+    size_t dstOffset,
+    size_t dstSize,
+    ITextureResource* src,
+    SubresourceRange srcSubresource,
+    ITextureResource::Offset3D srcOffset,
+    ITextureResource::Size extent)
+{
+    SLANG_GFX_API_FUNC;
+    baseObject->copyTextureToBuffer(
+        getInnerObj(dst), dstOffset, dstSize, getInnerObj(src), srcSubresource, srcOffset, extent);
+}
+
+void DebugResourceCommandEncoder::textureSubresourceBarrier(
+    ITextureResource* texture,
+    SubresourceRange subresourceRange,
+    ResourceState src,
+    ResourceState dst)
+{
+    SLANG_GFX_API_FUNC;
+    baseObject->textureSubresourceBarrier(getInnerObj(texture), subresourceRange, src, dst);
+}
+
 void DebugRayTracingCommandEncoder::endEncoding()
 {
     SLANG_GFX_API_FUNC;
diff --git a/tools/gfx/debug-layer.h b/tools/gfx/debug-layer.h
index 7ff5e02d5..e7894b390 100644
--- a/tools/gfx/debug-layer.h
+++ b/tools/gfx/debug-layer.h
@@ -398,16 +398,16 @@ public:
         ResourceState dst) override;
     virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
         ITextureResource* dst,
-        ITextureResource::SubresourceRange dstSubresource,
+        SubresourceRange dstSubresource,
         ITextureResource::Offset3D dstOffset,
         ITextureResource* src,
-        ITextureResource::SubresourceRange srcSubresource,
+        SubresourceRange srcSubresource,
         ITextureResource::Offset3D srcOffset,
         ITextureResource::Size extent) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
         ITextureResource* dst,
-        ITextureResource::SubresourceRange subResourceRange,
+        SubresourceRange subResourceRange,
         ITextureResource::Offset3D offset,
         ITextureResource::Offset3D extent,
         ITextureResource::SubresourceData* subResourceData,
@@ -418,6 +418,27 @@ public:
         ClearValue* clearValue,
         ClearResourceViewFlags::Enum flags) override;
 
+    virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
+        ITextureResource* source,
+        SubresourceRange sourceRange,
+        ITextureResource* dest,
+        SubresourceRange destRange) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
+        IBufferResource* dst,
+        size_t dstOffset,
+        size_t dstSize,
+        ITextureResource* src,
+        SubresourceRange srcSubresource,
+        ITextureResource::Offset3D srcOffset,
+        ITextureResource::Size extent) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
+        ITextureResource* texture,
+        SubresourceRange subresourceRange,
+        ResourceState src,
+        ResourceState dst) override;
+
 public:
     DebugCommandBuffer* commandBuffer;
     bool isOpen = false;
diff --git a/tools/gfx/immediate-renderer-base.cpp b/tools/gfx/immediate-renderer-base.cpp
index 95f683744..b4763a881 100644
--- a/tools/gfx/immediate-renderer-base.cpp
+++ b/tools/gfx/immediate-renderer-base.cpp
@@ -313,10 +313,10 @@ public:
 
         virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
             ITextureResource* dst,
-            ITextureResource::SubresourceRange dstSubresource,
+            SubresourceRange dstSubresource,
             ITextureResource::Offset3D dstOffset,
             ITextureResource* src,
-            ITextureResource::SubresourceRange srcSubresource,
+            SubresourceRange srcSubresource,
             ITextureResource::Offset3D srcOffset,
             ITextureResource::Size extent) override
         {
@@ -332,7 +332,7 @@ public:
 
         virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
             ITextureResource* dst,
-            ITextureResource::SubresourceRange subResourceRange,
+            SubresourceRange subResourceRange,
             ITextureResource::Offset3D offset,
             ITextureResource::Offset3D extend,
             ITextureResource::SubresourceData* subResourceData,
@@ -357,6 +357,51 @@ public:
             SLANG_UNUSED(flags);
             SLANG_UNIMPLEMENTED_X("clearResourceView");
         }
+
+        virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
+            ITextureResource* source,
+            SubresourceRange sourceRange,
+            ITextureResource* dest,
+            SubresourceRange destRange) override
+        {
+            SLANG_UNUSED(source);
+            SLANG_UNUSED(sourceRange);
+            SLANG_UNUSED(dest);
+            SLANG_UNUSED(destRange);
+            SLANG_UNIMPLEMENTED_X("resolveResource");
+        }
+
+        virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
+            IBufferResource* dst,
+            size_t dstOffset,
+            size_t dstSize,
+            ITextureResource* src,
+            SubresourceRange srcSubresource,
+            ITextureResource::Offset3D srcOffset,
+            ITextureResource::Size extent) override
+        {
+            SLANG_UNUSED(dst);
+            SLANG_UNUSED(dstOffset);
+            SLANG_UNUSED(dstSize);
+            SLANG_UNUSED(src);
+            SLANG_UNUSED(srcSubresource);
+            SLANG_UNUSED(srcOffset);
+            SLANG_UNUSED(extent);
+            SLANG_UNIMPLEMENTED_X("copyTextureToBuffer");
+        }
+
+        virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
+            ITextureResource* texture,
+            SubresourceRange subresourceRange,
+            ResourceState src,
+            ResourceState dst) override
+        {
+            SLANG_UNUSED(texture);
+            SLANG_UNUSED(subresourceRange);
+            SLANG_UNUSED(src);
+            SLANG_UNUSED(dst);
+            SLANG_UNIMPLEMENTED_X("textureSubresourceBarrier");
+        }
     };
 
     ResourceCommandEncoderImpl m_resourceCommandEncoder;
diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp
index ce553f0c4..7dde2b712 100644
--- a/tools/gfx/vulkan/render-vk.cpp
+++ b/tools/gfx/vulkan/render-vk.cpp
@@ -4330,10 +4330,10 @@ public:
 
             virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
                 ITextureResource* dst,
-                ITextureResource::SubresourceRange dstSubresource,
+                SubresourceRange dstSubresource,
                 ITextureResource::Offset3D dstOffset,
                 ITextureResource* src,
-                ITextureResource::SubresourceRange srcSubresource,
+                SubresourceRange srcSubresource,
                 ITextureResource::Offset3D srcOffset,
                 ITextureResource::Size extent) override
             {
@@ -4349,7 +4349,7 @@ public:
 
             virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
                 ITextureResource* dst,
-                ITextureResource::SubresourceRange subResourceRange,
+                SubresourceRange subResourceRange,
                 ITextureResource::Offset3D offset,
                 ITextureResource::Offset3D extend,
                 ITextureResource::SubresourceData* subResourceData,
@@ -4374,6 +4374,51 @@ public:
                 SLANG_UNUSED(flags);
                 SLANG_UNIMPLEMENTED_X("clearResourceView");
             }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
+                ITextureResource* source,
+                SubresourceRange sourceRange,
+                ITextureResource* dest,
+                SubresourceRange destRange) override
+            {
+                SLANG_UNUSED(source);
+                SLANG_UNUSED(sourceRange);
+                SLANG_UNUSED(dest);
+                SLANG_UNUSED(destRange);
+                SLANG_UNIMPLEMENTED_X("resolveResource");
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
+                IBufferResource* dst,
+                size_t dstOffset,
+                size_t dstSize,
+                ITextureResource* src,
+                SubresourceRange srcSubresource,
+                ITextureResource::Offset3D srcOffset,
+                ITextureResource::Size extent) override
+            {
+                SLANG_UNUSED(dst);
+                SLANG_UNUSED(dstOffset);
+                SLANG_UNUSED(dstSize);
+                SLANG_UNUSED(src);
+                SLANG_UNUSED(srcSubresource);
+                SLANG_UNUSED(srcOffset);
+                SLANG_UNUSED(extent);
+                SLANG_UNIMPLEMENTED_X("copyTextureToBuffer");
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
+                ITextureResource* texture,
+                SubresourceRange subresourceRange,
+                ResourceState src,
+                ResourceState dst) override
+            {
+                SLANG_UNUSED(texture);
+                SLANG_UNUSED(subresourceRange);
+                SLANG_UNUSED(src);
+                SLANG_UNUSED(dst);
+                SLANG_UNIMPLEMENTED_X("textureSubresourceBarrier");
+            }
         };
 
         RefPtr<ResourceCommandEncoder> m_resourceCommandEncoder;
@@ -7183,10 +7228,14 @@ Result VKDevice::createTextureView(ITextureResource* texture, IResourceView::Des
         break;
     }
     createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-    createInfo.subresourceRange.baseArrayLayer = 0;
-    createInfo.subresourceRange.baseMipLevel = 0;
-    createInfo.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
-    createInfo.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
+    createInfo.subresourceRange.baseArrayLayer = desc.subresourceRange.baseArrayLayer;
+    createInfo.subresourceRange.baseMipLevel = desc.subresourceRange.mipLevel;
+    createInfo.subresourceRange.layerCount = desc.subresourceRange.layerCount == 0
+                                                 ? VK_REMAINING_ARRAY_LAYERS
+                                                 : desc.subresourceRange.layerCount;
+    createInfo.subresourceRange.levelCount = desc.subresourceRange.mipLevelCount == 0
+                                                 ? VK_REMAINING_MIP_LEVELS
+                                                 : desc.subresourceRange.mipLevelCount;
     switch (desc.type)
     {
     case IResourceView::Type::DepthStencil:
@@ -7236,8 +7285,24 @@ Result VKDevice::createBufferView(IBufferResource* buffer, IResourceView::Desc c
     auto resourceImpl = (BufferResourceImpl*) buffer;
 
     // TODO: These should come from the `ResourceView::Desc`
-    VkDeviceSize offset = 0;
-    VkDeviceSize size = resourceImpl->getDesc()->sizeInBytes;
+    auto stride = resourceImpl->getDesc()->elementSize;
+    if (stride == 0)
+    {
+        if (desc.format == Format::Unknown)
+        {
+            stride = 1;
+        }
+        else
+        {
+            FormatInfo info;
+            gfxGetFormatInfo(desc.format, &info);
+            stride = info.blockSizeInBytes;
+            assert(info.pixelsPerBlock == 1);
+        }
+    }
+    VkDeviceSize offset = (VkDeviceSize)desc.bufferRange.firstElement * stride;
+    VkDeviceSize size = desc.bufferRange.elementCount == 0 ? resourceImpl->getDesc()->sizeInBytes
+                                                           : (VkDeviceSize)desc.bufferRange.elementCount * stride;
 
     // There are two different cases we need to think about for buffers.
     //
@@ -7274,7 +7339,7 @@ Result VKDevice::createBufferView(IBufferResource* buffer, IResourceView::Desc c
             // require a view in Vulkan.
             RefPtr<PlainBufferResourceViewImpl> viewImpl = new PlainBufferResourceViewImpl(this);
             viewImpl->m_buffer = resourceImpl;
-            viewImpl->offset = 0;
+            viewImpl->offset = offset;
             viewImpl->size = size;
             viewImpl->m_desc = desc;
 
diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp
index a3cde1c0a..1cb25bebb 100644
--- a/tools/render-test/render-test-main.cpp
+++ b/tools/render-test/render-test-main.cpp
@@ -202,7 +202,7 @@ struct AssignValsFromLayoutContext
         ComPtr<IBufferResource> bufferResource;
         SLANG_RETURN_ON_FAIL(ShaderRendererUtil::createBufferResource(srcBuffer, /*entry.isOutput,*/ bufferSize, bufferData.getBuffer(), device, bufferResource));
 
-        IResourceView::Desc viewDesc;
+        IResourceView::Desc viewDesc = {};
         viewDesc.type = IResourceView::Type::UnorderedAccess;
         viewDesc.format = srcBuffer.format;
         auto bufferView = device->createBufferView(
@@ -225,7 +225,7 @@ struct AssignValsFromLayoutContext
 
         auto sampler = _createSamplerState(device, samplerEntry->samplerDesc);
 
-        IResourceView::Desc viewDesc;
+        IResourceView::Desc viewDesc = {};
         viewDesc.type = IResourceView::Type::ShaderResource;
         auto textureView = device->createTextureView(
             texture,
@@ -252,7 +252,7 @@ struct AssignValsFromLayoutContext
         SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource(
             srcVal->textureDesc, defaultState, device, texture));
 
-        IResourceView::Desc viewDesc;
+        IResourceView::Desc viewDesc = {};
         viewDesc.type = viewType;
         viewDesc.format = texture->getDesc()->format;
         auto textureView = device->createTextureView(
@@ -618,7 +618,7 @@ void RenderTestApp::_initializeRenderPass()
     colorBufferDesc.allowedStates = ResourceState::RenderTarget;
     m_colorBuffer = m_device->createTextureResource(colorBufferDesc, nullptr);
 
-    gfx::IResourceView::Desc colorBufferViewDesc;
+    gfx::IResourceView::Desc colorBufferViewDesc = {};
     memset(&colorBufferViewDesc, 0, sizeof(colorBufferViewDesc));
     colorBufferViewDesc.format = gfx::Format::R8G8B8A8_UNORM;
     colorBufferViewDesc.renderTarget.shape = gfx::IResource::Type::Texture2D;
@@ -626,7 +626,7 @@ void RenderTestApp::_initializeRenderPass()
     ComPtr<gfx::IResourceView> rtv =
         m_device->createTextureView(m_colorBuffer.get(), colorBufferViewDesc);
 
-    gfx::IResourceView::Desc depthBufferViewDesc;
+    gfx::IResourceView::Desc depthBufferViewDesc = {};
     memset(&depthBufferViewDesc, 0, sizeof(depthBufferViewDesc));
     depthBufferViewDesc.format = gfx::Format::D32_FLOAT;
     depthBufferViewDesc.renderTarget.shape = gfx::IResource::Type::Texture2D;