Expanded gfx::Format to include additional formats (#1982)

* Format list updated with additional formats supported by both D3D and Vulkan; D3DUtil::getMapFormat() and VkUtil::getVkFormat() updated to include additional formats; GFX_FORMAT() updated with all additional formats (BC compression unfinished)

* Finished updating GFX_FORMAT with newly added formats and sizes; Pixel size is now tracked using the FormatPixelSize struct containing the values for bytes per block and pixels per block to accomodate BC formats; Updated gfxGetFormatSize and associated sub-calls to return FormatPixelSize instead of uint8_t; Most calls to gfxGetFormatSize() updated to reflect changes, a couple calls still unupdated

* Changes to accommodate new formats finished, debugging slang-literal unit test

* First format unit test working

* One test added for BC1Unorm and RGBA8Unorm_SRGB, both passing

* Refactored format testing code to merge BC1Unorm and RGBA8Unorm SRGB into a single file

* All unit tests added for BC and Srgb formats

* Most tests added and working; Added five additional formats (still need tests) and made the appropriate changes to support these; createTextureView() modified for D3D11, D3D12, and Vulkan to take into account the format specified in the texture view desc when the texture's format is typeless

* Format enums renamed to more closely match their D3D counterparts; Added a universal float and uint buffer and buffer view for use across all Format tests

* Remaining tests added; D3D12 tests pass, but Vulkan crashes in BC1_UNORM and D3D11 spits out a bunch of D3D11 Errors (but supposedly passes)

* re-run premake

* Added Sint versions of test shaders; Vulkan and D3D11 tests also pass

* Size struct for format unit tests no longer use initializer lists

* Fixed a Size struct missed in the previous pass

* Fixed minor bugs causing tests to fail

* Added documentation detailing all currently unsupported formats

* Skip tests causing unsupported format warnings due to swiftshader

* updated several test using old Format enum names

* Revert change to compareComputeResult() that was added for debugging purposes

* DEBUGGING: Added prints to identify which formats are failing on CI

* Reverted attempted debugging changes; Fixed texture2d-gather.hlsl to use updated Format enums

* Fixed incorrect array sizes in d3d11 _initSrvDesc()

* Commented out further tests that produce unexpected results when tested for Vulkan with swiftshader

* Revert "Merge branch 'expanded-format-support' of https://github.com/lucy96chen/slang into expanded-format-support"

This reverts commit 20008f0d3ecc3b1405ecac8c138edaa3cd37ed6b, reversing
changes made to 6081e95827315fee50e18409394d5abd62fac787.

* Added a fuzzy comparison function for use with floats

* submodule update

* Revert messed up changes caused by previous revert after automatically merging on github

1 files changed, 19 insertions, 16 deletions

diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp
index 03f193ca6..3a1557a3c 100644
--- a/tools/gfx/vulkan/render-vk.cpp
+++ b/tools/gfx/vulkan/render-vk.cpp
@@ -3800,10 +3800,10 @@ public:
             {
                 switch (indexFormat)
                 {
-                case Format::R_UInt16:
+                case Format::R16_UINT:
                     m_boundIndexFormat = VK_INDEX_TYPE_UINT16;
                     break;
-                case Format::R_UInt32:
+                case Format::R32_UINT:
                     m_boundIndexFormat = VK_INDEX_TYPE_UINT32;
                     break;
                 default:
@@ -5026,7 +5026,7 @@ public:
             List<VkFormat> formats;
             formats.add(VulkanUtil::getVkFormat(desc.format));
             // HACK! To check for a different format if couldn't be found
-            if (desc.format == Format::RGBA_Unorm_UInt8)
+            if (desc.format == Format::R8G8B8A8_UNORM)
             {
                 formats.add(VK_FORMAT_B8G8R8A8_UNORM);
             }
@@ -5047,10 +5047,10 @@ public:
 
             // Save the desc
             m_desc = desc;
-            if (m_desc.format == Format::RGBA_Unorm_UInt8 &&
+            if (m_desc.format == Format::R8G8B8A8_UNORM &&
                 m_vkformat == VK_FORMAT_B8G8R8A8_UNORM)
             {
-                m_desc.format = Format::BGRA_Unorm_UInt8;
+                m_desc.format = Format::B8G8R8A8_UNORM;
             }
 
             SLANG_RETURN_ON_FAIL(createSwapchainAndImages());
@@ -5763,7 +5763,6 @@ Result VKDevice::initVulkanInstanceAndDevice(const NativeHandle handles, bool us
             deviceExtensions.add(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME);
             m_features.add("shader-subgroup-extended-types");
         }
-
         if (extendedFeatures.accelerationStructureFeatures.accelerationStructure)
         {
             extendedFeatures.accelerationStructureFeatures.pNext = (void*)deviceCreateInfo.pNext;
@@ -5781,7 +5780,6 @@ Result VKDevice::initVulkanInstanceAndDevice(const NativeHandle handles, bool us
             m_features.add("ray-query");
             m_features.add("ray-tracing");
         }
-
         if (extendedFeatures.bufferDeviceAddressFeatures.bufferDeviceAddress)
         {
             extendedFeatures.bufferDeviceAddressFeatures.pNext = (void*)deviceCreateInfo.pNext;
@@ -6373,17 +6371,16 @@ void VKDevice::_transitionImageLayout(VkImage image, VkFormat format, const Text
 
 size_t calcRowSize(Format format, int width)
 {
-    size_t pixelSize = gfxGetFormatSize(format);
-    if (pixelSize == 0)
-    {
-        return 0;
-    }
-    return size_t(pixelSize * width);
+    FormatInfo sizeInfo;
+    gfxGetFormatInfo(format, &sizeInfo);
+    return size_t((width + sizeInfo.blockWidth - 1) / sizeInfo.blockWidth * sizeInfo.blockSizeInBytes);
 }
 
 size_t calcNumRows(Format format, int height)
 {
-    return (size_t)height;
+    FormatInfo sizeInfo;
+    gfxGetFormatInfo(format, &sizeInfo);
+    return (size_t)(height + sizeInfo.blockHeight - 1) / sizeInfo.blockHeight;
 }
 
 Result VKDevice::createTextureResource(const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource)
@@ -6516,6 +6513,8 @@ Result VKDevice::createTextureResource(const ITextureResource::Desc& descIn, con
 
             uint8_t* dstData;
             m_api.vkMapMemory(m_device, uploadBuffer.m_memory, 0, bufferSize, 0, (void**)&dstData);
+            uint8_t* dstDataStart;
+            dstDataStart = dstData;
 
             size_t dstSubresourceOffset = 0;
             for (int i = 0; i < arraySize; ++i)
@@ -6822,6 +6821,8 @@ Result VKDevice::createSamplerState(ISamplerState::Desc const& desc, ISamplerSta
     samplerInfo.compareEnable = desc.reductionOp == TextureReductionOp::Comparison;
     samplerInfo.compareOp = translateComparisonFunc(desc.comparisonFunc);
     samplerInfo.mipmapMode = translateMipFilterMode(desc.mipFilter);
+    samplerInfo.minLod = Math::Max(0.0f, desc.minLOD);
+    samplerInfo.maxLod = Math::Clamp(desc.maxLOD, samplerInfo.minLod, VK_LOD_CLAMP_NONE);
 
     VkSampler sampler;
     SLANG_VK_RETURN_ON_FAIL(m_api.vkCreateSampler(m_device, &samplerInfo, nullptr, &sampler));
@@ -6840,7 +6841,7 @@ Result VKDevice::createTextureView(ITextureResource* texture, IResourceView::Des
     VkImageViewCreateInfo createInfo = {};
     createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
     createInfo.flags = 0;
-    createInfo.format = resourceImpl->m_vkformat;
+    createInfo.format = gfxIsTypelessFormat(texture->getDesc()->format) ? VulkanUtil::getVkFormat(desc.format) : resourceImpl->m_vkformat;
     createInfo.image = resourceImpl->m_image;
     createInfo.components = VkComponentMapping{ VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G,VK_COMPONENT_SWIZZLE_B,VK_COMPONENT_SWIZZLE_A };
     bool isArray = resourceImpl->getDesc()->arraySize != 0;
@@ -7013,7 +7014,9 @@ Result VKDevice::createInputLayout(const InputElementDesc* elements, UInt numEle
 
         dstDesc.offset = uint32_t(srcDesc.offset);
 
-        const size_t elementSize = gfxGetFormatSize(srcDesc.format);
+        FormatInfo sizeInfo;
+        gfxGetFormatInfo(srcDesc.format, &sizeInfo);
+        const size_t elementSize = sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock;
         assert(elementSize > 0);
         const size_t endElement = srcDesc.offset + elementSize;