gfx ShaderObject interface update, getTextureAllocationInfo() (#2019)

* gfx ShaderObject interface update, getTextureAllocationInfo()

* Fix render-vk compiler warnings and errors.

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

1 files changed, 104 insertions, 31 deletions

diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp
index 836e4e19e..ce553f0c4 100644
--- a/tools/gfx/vulkan/render-vk.cpp
+++ b/tools/gfx/vulkan/render-vk.cpp
@@ -140,7 +140,11 @@ public:
         const IAccelerationStructure::CreateDesc& desc,
         IAccelerationStructure** outView) override;
 
+    virtual SLANG_NO_THROW Result SLANG_MCALL getTextureAllocationInfo(
+        const ITextureResource::Desc& desc, size_t* outSize, size_t* outAlignment) override;
+
     void waitForGpu();
+
     virtual SLANG_NO_THROW const DeviceInfo& SLANG_MCALL getDeviceInfo() const override
     {
         return m_info;
@@ -2345,6 +2349,16 @@ public:
             return SLANG_OK;
         }
 
+        virtual SLANG_NO_THROW const void* SLANG_MCALL getRawData() override
+        {
+            return m_data.getBuffer();
+        }
+
+        virtual SLANG_NO_THROW size_t SLANG_MCALL getSize() override
+        {
+            return (size_t)m_data.getCount();
+        }
+
         SLANG_NO_THROW Result SLANG_MCALL
             setData(ShaderOffset const& inOffset, void const* data, size_t inSize) SLANG_OVERRIDE
         {
@@ -4213,7 +4227,7 @@ public:
                 size_t count,
                 ITextureResource* const* textures,
                 ResourceState src,
-                ResourceState dst)
+                ResourceState dst) override
             {
                 List<VkImageMemoryBarrier> barriers;
                 barriers.setCount(count);
@@ -4228,7 +4242,12 @@ public:
                     barrier.image = image->m_image;
                     barrier.oldLayout = translateImageLayout(src);
                     barrier.newLayout = translateImageLayout(dst);
-                    barrier.subresourceRange.aspectMask;
+                    if (VulkanUtil::isDepthFormat(image->m_vkformat))
+                        barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+                    if (VulkanUtil::isStencilFormat(image->m_vkformat))
+                        barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
+                    if (barrier.subresourceRange.aspectMask == 0)
+                        barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                     barrier.subresourceRange.baseArrayLayer = 0;
                     barrier.subresourceRange.baseMipLevel = 0;
                     barrier.subresourceRange.layerCount = desc->arraySize;
@@ -4248,7 +4267,7 @@ public:
                 size_t count,
                 IBufferResource* const* buffers,
                 ResourceState src,
-                ResourceState dst)
+                ResourceState dst) override
             {
                 List<VkBufferMemoryBarrier> barriers;
                 barriers.reserve(count);
@@ -6455,32 +6474,6 @@ static VkImageUsageFlags _calcImageUsageFlags(
     return usage;
 }
 
-bool isDepthFormat(VkFormat format)
-{
-    switch (format)
-    {
-    case VK_FORMAT_D16_UNORM:
-    case VK_FORMAT_D24_UNORM_S8_UINT:
-    case VK_FORMAT_X8_D24_UNORM_PACK32:
-    case VK_FORMAT_D32_SFLOAT:
-    case VK_FORMAT_D32_SFLOAT_S8_UINT:
-        return true;
-    }
-    return false;
-}
-
-bool isStencilFormat(VkFormat format)
-{
-    switch (format)
-    {
-    case VK_FORMAT_S8_UINT:
-    case VK_FORMAT_D24_UNORM_S8_UINT:
-    case VK_FORMAT_D32_SFLOAT_S8_UINT:
-        return true;
-    }
-    return false;
-}
-
 void VKDevice::_transitionImageLayout(VkImage image, VkFormat format, const TextureResource::Desc& desc, VkImageLayout oldLayout, VkImageLayout newLayout)
 {
     VkImageMemoryBarrier barrier = {};
@@ -6491,9 +6484,9 @@ void VKDevice::_transitionImageLayout(VkImage image, VkFormat format, const Text
     barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
     barrier.image = image;
 
-    if (isDepthFormat(format))
+    if (VulkanUtil::isDepthFormat(format))
         barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-    if (isStencilFormat(format))
+    if (VulkanUtil::isStencilFormat(format))
         barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
     if (barrier.subresourceRange.aspectMask == 0)
         barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@@ -6605,6 +6598,86 @@ size_t calcNumRows(Format format, int height)
     return (size_t)(height + sizeInfo.blockHeight - 1) / sizeInfo.blockHeight;
 }
 
+Result VKDevice::getTextureAllocationInfo(
+    const ITextureResource::Desc& descIn, size_t* outSize, size_t* outAlignment)
+{
+    TextureResource::Desc desc = fixupTextureDesc(descIn);
+
+    const VkFormat format = VulkanUtil::getVkFormat(desc.format);
+    if (format == VK_FORMAT_UNDEFINED)
+    {
+        assert(!"Unhandled image format");
+        return SLANG_FAIL;
+    }
+    const int arraySize = calcEffectiveArraySize(desc);
+
+    VkImageCreateInfo imageInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
+    switch (desc.type)
+    {
+    case IResource::Type::Texture1D:
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_1D;
+            imageInfo.extent = VkExtent3D{uint32_t(descIn.size.width), 1, 1};
+            break;
+        }
+    case IResource::Type::Texture2D:
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_2D;
+            imageInfo.extent =
+                VkExtent3D{uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1};
+            break;
+        }
+    case IResource::Type::TextureCube:
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_2D;
+            imageInfo.extent =
+                VkExtent3D{uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1};
+            imageInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+            break;
+        }
+    case IResource::Type::Texture3D:
+        {
+            // Can't have an array and 3d texture
+            assert(desc.arraySize <= 1);
+
+            imageInfo.imageType = VK_IMAGE_TYPE_3D;
+            imageInfo.extent = VkExtent3D{
+                uint32_t(descIn.size.width),
+                uint32_t(descIn.size.height),
+                uint32_t(descIn.size.depth)};
+            break;
+        }
+    default:
+        {
+            assert(!"Unhandled type");
+            return SLANG_FAIL;
+        }
+    }
+
+    imageInfo.mipLevels = desc.numMipLevels;
+    imageInfo.arrayLayers = arraySize;
+
+    imageInfo.format = format;
+
+    imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+    imageInfo.usage = _calcImageUsageFlags(desc.allowedStates, desc.cpuAccessFlags, nullptr);
+    imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+    imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+
+    VkImage image;
+    SLANG_VK_RETURN_ON_FAIL(m_api.vkCreateImage(m_device, &imageInfo, nullptr, &image));
+
+    VkMemoryRequirements memRequirements;
+    m_api.vkGetImageMemoryRequirements(m_device, image, &memRequirements);
+
+    *outSize = memRequirements.size;
+    *outAlignment = memRequirements.alignment;
+
+    m_api.vkDestroyImage(m_device, image, nullptr);
+    return SLANG_OK;
+}
+
 Result VKDevice::createTextureResource(const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource)
 {
     TextureResource::Desc desc = fixupTextureDesc(descIn);