WebGPU: Added support of multi view formats (close #587, close #612)

Author: MikhailGorobets

Graphics/GraphicsEngineWebGPU/CMakeLists.txt

@@ -36,6 +36,7 @@ set(INCLUDE
     include/WebGPUObjectWrappers.hpp
     include/WebGPUTypeConversions.hpp
     include/WebGPUResourceBase.hpp
+    include/WebGPUStubs.hpp
 )
 
 set(INTERFACE 

Graphics/GraphicsEngineWebGPU/include/WebGPUStubs.hpp

@@ -0,0 +1,49 @@
+/*
+ *  Copyright 2024 Diligent Graphics LLC
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  In no event and under no legal theory, whether in tort (including negligence),
+ *  contract, or otherwise, unless required by applicable law (such as deliberate
+ *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
+ *  liable for any damages, including any direct, indirect, special, incidental,
+ *  or consequential damages of any character arising as a result of this License or
+ *  out of the use or inability to use the software (including but not limited to damages
+ *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and
+ *  all other commercial damages or losses), even if such Contributor has been advised
+ *  of the possibility of such damages.
+ */
+
+#pragma once
+
+#if PLATFORM_EMSCRIPTEN
+
+inline constexpr WGPUFeatureName WGPUFeatureName_ChromiumExperimentalTimestampQueryInsidePasses = static_cast<WGPUFeatureName>(0x000003EE);
+
+inline constexpr WGPUFeatureName WGPUFeatureName_Unorm16TextureFormats = static_cast<WGPUFeatureName>(0x000003FB);
+
+inline constexpr WGPUFeatureName WGPUFeatureName_Snorm16TextureFormats = static_cast<WGPUFeatureName>(0x000003FC);
+
+inline constexpr WGPUTextureFormat WGPUTextureFormat_R16Unorm = static_cast<WGPUTextureFormat>(0x00000060);
+
+inline constexpr WGPUTextureFormat WGPUTextureFormat_R16Snorm = static_cast<WGPUTextureFormat>(0x00000063);
+
+inline constexpr WGPUTextureFormat WGPUTextureFormat_RG16Unorm = static_cast<WGPUTextureFormat>(0x00000061);
+
+inline constexpr WGPUTextureFormat WGPUTextureFormat_RG16Snorm = static_cast<WGPUTextureFormat>(0x00000064);
+
+inline constexpr WGPUTextureFormat WGPUTextureFormat_RGBA16Unorm = static_cast<WGPUTextureFormat>(0x00000062);
+
+inline constexpr WGPUTextureFormat WGPUTextureFormat_RGBA16Snorm = static_cast<WGPUTextureFormat>(0x00000065);
+
+#endif

Graphics/GraphicsEngineWebGPU/src/EngineFactoryWebGPU.cpp

@@ -35,6 +35,7 @@
 #include "ShaderResourceCacheWebGPU.hpp"
 #include "FenceWebGPUImpl.hpp"
 #include "DearchiverWebGPUImpl.hpp"
+#include "WebGPUStubs.hpp"
 
 #include "StringTools.hpp"
 #include "GraphicsAccessories.hpp"
@@ -47,6 +48,7 @@
 #    include <emscripten.h>
 #endif
 
+
 namespace Diligent
 {
 
@@ -195,9 +197,8 @@ WebGPUDeviceWrapper CreateDeviceForAdapter(EngineWebGPUCreateInfo const& EngineC
         if (EngineCI.Features.TimestampQueries && wgpuAdapterHasFeature(wgpuAdapter, WGPUFeatureName_TimestampQuery))
             Features.push_back(WGPUFeatureName_TimestampQuery);
 
-        //  WGPUFeatureName_ChromiumExperimentalTimestampQueryInsidePasses = 0x000003EE,
-        if (EngineCI.Features.TimestampQueries && wgpuAdapterHasFeature(wgpuAdapter, static_cast<WGPUFeatureName>(0x000003EE)))
-            Features.push_back(static_cast<WGPUFeatureName>(0x000003EE));
+        if (EngineCI.Features.TimestampQueries && wgpuAdapterHasFeature(wgpuAdapter, WGPUFeatureName_ChromiumExperimentalTimestampQueryInsidePasses))
+            Features.push_back(WGPUFeatureName_ChromiumExperimentalTimestampQueryInsidePasses);
 
         if (EngineCI.Features.TextureCompressionBC && wgpuAdapterHasFeature(wgpuAdapter, WGPUFeatureName_TextureCompressionBC))
             Features.push_back(WGPUFeatureName_TextureCompressionBC);
@@ -219,6 +220,12 @@ WebGPUDeviceWrapper CreateDeviceForAdapter(EngineWebGPUCreateInfo const& EngineC
 
         if (wgpuAdapterHasFeature(wgpuAdapter, WGPUFeatureName_BGRA8UnormStorage))
             Features.push_back(WGPUFeatureName_BGRA8UnormStorage);
+
+        if (wgpuAdapterHasFeature(wgpuAdapter, WGPUFeatureName_Unorm16TextureFormats))
+            Features.push_back(WGPUFeatureName_Unorm16TextureFormats);
+
+        if (wgpuAdapterHasFeature(wgpuAdapter, WGPUFeatureName_Snorm16TextureFormats))
+            Features.push_back(WGPUFeatureName_Snorm16TextureFormats);
     }
 
     struct CallbackUserData

Graphics/GraphicsEngineWebGPU/src/GenerateMipsHelperWebGPU.cpp

@@ -711,7 +711,7 @@ void GenerateMipsHelperWebGPU::GenerateMips(WGPUCommandEncoder wgpuCmdEncoder, D
     VERIFY_EXPR(m_DeviceWebGPU.GetNumImmediateContexts() == 1);
 
     InitializeSampler();
-    pDeviceContext->EndCommandEncoders(DeviceContextWebGPUImpl::COMMAND_ENCODER_FLAG_ALL & ~DeviceContextWebGPUImpl::COMMAND_ENCODER_FLAG_RENDER);
+    pDeviceContext->EndCommandEncoders(DeviceContextWebGPUImpl::COMMAND_ENCODER_FLAG_ALL);
 
     const auto& ViewDesc = pTexView->GetDesc();
 

Graphics/GraphicsEngineWebGPU/src/RenderDeviceWebGPUImpl.cpp

@@ -42,6 +42,7 @@
 #include "FenceWebGPUImpl.hpp"
 #include "QueryWebGPUImpl.hpp"
 #include "AttachmentCleanerWebGPU.hpp"
+#include "WebGPUStubs.hpp"
 
 #if !DILIGENT_NO_GLSLANG
 #    include "GLSLangUtils.hpp"
@@ -421,6 +422,8 @@ void RenderDeviceWebGPUImpl::FindSupportedTextureFormats()
     const bool RG11B10UfloatRenderableSupported = wgpuDeviceHasFeature(m_wgpuDevice, WGPUFeatureName_RG11B10UfloatRenderable);
     const bool Depth32FloatStencil8Supported    = wgpuDeviceHasFeature(m_wgpuDevice, WGPUFeatureName_Depth32FloatStencil8);
     const bool TextureCompressionBCSupported    = wgpuDeviceHasFeature(m_wgpuDevice, WGPUFeatureName_TextureCompressionBC);
+    const bool R16UnormSupported                = wgpuDeviceHasFeature(m_wgpuDevice, WGPUFeatureName_Unorm16TextureFormats);
+    const bool R16SnormSupported                = wgpuDeviceHasFeature(m_wgpuDevice, WGPUFeatureName_Snorm16TextureFormats);
 
     // https://www.w3.org/TR/webgpu/#texture-format-caps
 
@@ -456,7 +459,7 @@ void RenderDeviceWebGPUImpl::FindSupportedTextureFormats()
     SetTexFormatInfo({TEX_FORMAT_R32_FLOAT}, BIND_SRU, Float32FilterableSupported ? FMT_FLAG_FILTER | FMT_FLAG_MSAA : FMT_FLAG_MSAA);
 
     SetTexFormatInfo({TEX_FORMAT_RG32_UINT, TEX_FORMAT_RG32_SINT, TEX_FORMAT_RG32_TYPELESS}, BIND_SRU, FMT_FLAG_NONE);
-    SetTexFormatInfo({TEX_FORMAT_RG32_FLOAT}, BIND_SR, Float32FilterableSupported ? FMT_FLAG_FILTER : FMT_FLAG_NONE);
+    SetTexFormatInfo({TEX_FORMAT_RG32_FLOAT}, BIND_SRU, Float32FilterableSupported ? FMT_FLAG_FILTER : FMT_FLAG_NONE);
 
     SetTexFormatInfo({TEX_FORMAT_RGBA32_UINT, TEX_FORMAT_RGBA32_SINT, TEX_FORMAT_RGBA32_TYPELESS}, BIND_SRU, FMT_FLAG_NONE);
     SetTexFormatInfo({TEX_FORMAT_RGBA32_FLOAT}, BIND_SRU, Float32FilterableSupported ? FMT_FLAG_FILTER : FMT_FLAG_NONE);
@@ -502,6 +505,20 @@ void RenderDeviceWebGPUImpl::FindSupportedTextureFormats()
                           TEX_FORMAT_BC7_UNORM_SRGB},
                          BIND_S, FMT_FLAG_FILTER);
     }
+
+    if (R16UnormSupported)
+    {
+        SetTexFormatInfo({TEX_FORMAT_R16_UNORM}, BIND_SR, FMT_FLAG_FILTER | FMT_FLAG_MSAA);
+        SetTexFormatInfo({TEX_FORMAT_RG16_UNORM}, BIND_SR, FMT_FLAG_FILTER | FMT_FLAG_MSAA);
+        SetTexFormatInfo({TEX_FORMAT_RGBA16_UNORM}, BIND_SR, FMT_FLAG_FILTER | FMT_FLAG_MSAA);
+    }
+
+    if (R16SnormSupported)
+    {
+        SetTexFormatInfo({TEX_FORMAT_R16_SNORM}, BIND_SR, FMT_FLAG_FILTER | FMT_FLAG_MSAA);
+        SetTexFormatInfo({TEX_FORMAT_RG16_SNORM}, BIND_SR, FMT_FLAG_FILTER | FMT_FLAG_MSAA);
+        SetTexFormatInfo({TEX_FORMAT_RGBA16_SNORM}, BIND_SR, FMT_FLAG_FILTER | FMT_FLAG_MSAA);
+    }
 }
 
 } // namespace Diligent

Graphics/GraphicsEngineWebGPU/src/TextureWebGPUImpl.cpp

@@ -38,8 +38,9 @@ namespace Diligent
 namespace
 {
 
-WGPUTextureDescriptor TextureDescToWGPUTextureDescriptor(const TextureDesc&      Desc,
-                                                         RenderDeviceWebGPUImpl* pRenderDevice) noexcept
+WGPUTextureDescriptor TextureDescToWGPUTextureDescriptor(const TextureDesc&              Desc,
+                                                         RenderDeviceWebGPUImpl*         pRenderDevice,
+                                                         std::vector<WGPUTextureFormat>& TextureViewFormats) noexcept
 {
     WGPUTextureDescriptor wgpuTextureDesc{};
 
@@ -48,7 +49,7 @@ WGPUTextureDescriptor TextureDescToWGPUTextureDescriptor(const TextureDesc&
     if (Desc.Type == RESOURCE_DIM_TEX_CUBE_ARRAY)
         DEV_CHECK_ERR(Desc.ArraySize % 6 == 0, "Cube texture arrays are expected to have a number of array slices that is a multiple of 6");
 
-    const auto& FmtInfo = pRenderDevice->GetTextureFormatInfoExt(SRGBFormatToUnorm(Desc.Format));
+    const TextureFormatInfoExt& FmtInfo = pRenderDevice->GetTextureFormatInfoExt(SRGBFormatToUnorm(Desc.Format));
 
     if (Desc.IsArray())
         wgpuTextureDesc.size.depthOrArrayLayers = Desc.ArraySize;
@@ -86,16 +87,53 @@ WGPUTextureDescriptor TextureDescToWGPUTextureDescriptor(const TextureDesc&
             LOG_ERROR_AND_THROW("Automatic mipmap generation isn't supported for ", GetTextureFormatAttribs(Desc.Format).Name, " as the format doesn't support linear filtering");
     }
 
-    if (IsSRGBFormat(Desc.Format) && wgpuTextureDesc.usage & WGPUTextureUsage_StorageBinding)
-        wgpuTextureDesc.format = TextureFormatToWGPUFormat(SRGBFormatToUnorm(Desc.Format));
-    else
-        wgpuTextureDesc.format = TextureFormatToWGPUFormat(Desc.Format);
+    const TextureFormatAttribs& FmtAttribs = GetTextureFormatAttribs(Desc.Format);
+
+    std::unordered_set<TEXTURE_FORMAT> ViewFormatSet;
+    if (FmtAttribs.IsTypeless)
+    {
+        auto InsertViewFormat = [&](TEXTURE_VIEW_TYPE ViewType) {
+            TEXTURE_FORMAT Format = GetDefaultTextureViewFormat(Desc, ViewType);
+            ViewFormatSet.insert(Format);
+            if (ViewType == TEXTURE_VIEW_RENDER_TARGET || ViewType == TEXTURE_VIEW_SHADER_RESOURCE)
+                ViewFormatSet.insert(UnormFormatToSRGB(Format));
+        };
+
+        if (Desc.BindFlags & BIND_DEPTH_STENCIL)
+            LOG_ERROR_AND_THROW("Depth-stencil textures must have a specific format and cannot be typeless in WebGPU");
+        if (Desc.BindFlags & BIND_UNORDERED_ACCESS)
+            InsertViewFormat(TEXTURE_VIEW_UNORDERED_ACCESS);
+        if (Desc.BindFlags & BIND_RENDER_TARGET)
+            InsertViewFormat(TEXTURE_VIEW_RENDER_TARGET);
+        if (Desc.BindFlags & BIND_SHADER_RESOURCE)
+            InsertViewFormat(TEXTURE_VIEW_SHADER_RESOURCE);
+    }
+
+    const bool IsSRGBWithMipsAndStorageBinding =
+        IsSRGBFormat(Desc.Format) &&
+        (Desc.MiscFlags & MISC_TEXTURE_FLAG_GENERATE_MIPS) &&
+        (wgpuTextureDesc.usage & WGPUTextureUsage_StorageBinding);
 
-    wgpuTextureDesc.mipLevelCount = Desc.MipLevels;
-    wgpuTextureDesc.sampleCount   = Desc.SampleCount;
-    wgpuTextureDesc.size.width    = Desc.GetWidth();
-    wgpuTextureDesc.size.height   = Desc.GetHeight();
-    wgpuTextureDesc.label         = Desc.Name;
+    wgpuTextureDesc.format = IsSRGBWithMipsAndStorageBinding ?
+        TextureFormatToWGPUFormat(SRGBFormatToUnorm(Desc.Format)) :
+        TextureFormatToWGPUFormat(Desc.Format);
+
+    if (IsSRGBWithMipsAndStorageBinding)
+    {
+        ViewFormatSet.insert(Desc.Format);
+        ViewFormatSet.insert(SRGBFormatToUnorm(Desc.Format));
+    }
+
+    for (const auto& TextureViewFmt : ViewFormatSet)
+        TextureViewFormats.push_back(TextureFormatToWGPUFormat(TextureViewFmt));
+
+    wgpuTextureDesc.viewFormats     = TextureViewFormats.data();
+    wgpuTextureDesc.viewFormatCount = TextureViewFormats.size();
+    wgpuTextureDesc.mipLevelCount   = Desc.MipLevels;
+    wgpuTextureDesc.sampleCount     = Desc.SampleCount;
+    wgpuTextureDesc.size.width      = Desc.GetWidth();
+    wgpuTextureDesc.size.height     = Desc.GetHeight();
+    wgpuTextureDesc.label           = Desc.Name;
 
     return wgpuTextureDesc;
 }
@@ -120,6 +158,8 @@ WGPUTextureViewDescriptor TextureViewDescToWGPUTextureViewDescriptor(const Textu
     wgpuTextureViewDesc.dimension     = ResourceDimensionToWGPUTextureViewDimension(ViewDesc.TextureDim);
     wgpuTextureViewDesc.baseMipLevel  = ViewDesc.MostDetailedMip;
     wgpuTextureViewDesc.mipLevelCount = ViewDesc.NumMipLevels;
+    if (!(TexDesc.BindFlags & BIND_DEPTH_STENCIL))
+        wgpuTextureViewDesc.format = TextureFormatToWGPUFormat(ViewDesc.Format);
 
     if (IsTextureArray(ViewDesc))
     {
@@ -133,7 +173,6 @@ WGPUTextureViewDescriptor TextureViewDescToWGPUTextureViewDescriptor(const Textu
     }
 
     const TextureFormatAttribs& FmtAttribs = GetTextureFormatAttribs(ViewDesc.Format);
-
     if (ViewDesc.ViewType == TEXTURE_VIEW_DEPTH_STENCIL || ViewDesc.ViewType == TEXTURE_VIEW_READ_ONLY_DEPTH_STENCIL)
     {
         if (FmtAttribs.ComponentType == COMPONENT_TYPE_DEPTH)
@@ -263,7 +302,8 @@ TextureWebGPUImpl::TextureWebGPUImpl(IReferenceCounters*        pRefCounters,
 
     if (m_Desc.Usage == USAGE_IMMUTABLE || m_Desc.Usage == USAGE_DEFAULT || m_Desc.Usage == USAGE_DYNAMIC)
     {
-        WGPUTextureDescriptor wgpuTextureDesc = TextureDescToWGPUTextureDescriptor(m_Desc, pDevice);
+        std::vector<WGPUTextureFormat> TextureViewFormats;
+        WGPUTextureDescriptor          wgpuTextureDesc = TextureDescToWGPUTextureDescriptor(m_Desc, pDevice, TextureViewFormats);
         m_wgpuTexture.Reset(wgpuDeviceCreateTexture(pDevice->GetWebGPUDevice(), &wgpuTextureDesc));
         if (!m_wgpuTexture)
             LOG_ERROR_AND_THROW("Failed to create WebGPU texture ", " '", m_Desc.Name ? m_Desc.Name : "", '\'');