WebGPU: Added support for formats without storage flag in mip generator (close #590)

Author: MikhailGorobets

Graphics/GraphicsEngineWebGPU/include/DeviceContextWebGPUImpl.hpp

@@ -382,6 +382,7 @@ class DeviceContextWebGPUImpl final : public DeviceContextBase<EngineWebGPUImplT
 
 private:
     friend class QueryManagerWebGPU;
+    friend class GenerateMipsHelperWebGPU;
 
     struct WebGPUEncoderState
     {

Graphics/GraphicsEngineWebGPU/include/GenerateMipsHelperWebGPU.hpp

@@ -48,11 +48,34 @@ class GenerateMipsHelperWebGPU
     GenerateMipsHelperWebGPU& operator = (      GenerateMipsHelperWebGPU&&) = delete;
     // clang-format on
 
-    void GenerateMips(WGPUComputePassEncoder wgpuCmdEncoder, DeviceContextWebGPUImpl* pDeviceContext, TextureViewWebGPUImpl* pTexView);
+    void GenerateMips(DeviceContextWebGPUImpl* pDeviceContext, TextureViewWebGPUImpl* pTexView);
 
 private:
     using UAVFormats = std::array<TEXTURE_FORMAT, 4>;
 
+    struct ShaderModuleCacheKey
+    {
+        struct Hasher
+        {
+            size_t operator()(const ShaderModuleCacheKey& Key) const;
+        };
+
+        ShaderModuleCacheKey(const UAVFormats& _Formats, SHADER_TYPE _ShaderType) :
+            Formats{_Formats},
+            ShaderType{_ShaderType}
+        {}
+
+        bool operator==(const ShaderModuleCacheKey& rhs) const;
+
+        size_t GetHash() const;
+
+        UAVFormats  Formats    = {};
+        SHADER_TYPE ShaderType = {};
+
+    private:
+        mutable size_t Hash = 0;
+    };
+
     struct ComputePipelineHashKey
     {
         struct Hasher
@@ -76,41 +99,43 @@ class GenerateMipsHelperWebGPU
         mutable size_t Hash = 0;
     };
 
-    struct ShaderModuleCacheKey
+    struct RenderPipelineHashKey
     {
         struct Hasher
         {
-            size_t operator()(const ShaderModuleCacheKey& Key) const;
+            size_t operator()(const RenderPipelineHashKey& Key) const;
         };
 
-        ShaderModuleCacheKey(const UAVFormats& Formats) :
-            Formats{Formats}
-        {}
+        RenderPipelineHashKey(TEXTURE_FORMAT _Format) :
+            Format{_Format} {};
 
-        bool operator==(const ShaderModuleCacheKey& rhs) const;
+        bool operator==(const RenderPipelineHashKey& rhs) const;
 
-        size_t GetHash() const;
-
-        UAVFormats Formats = {};
-
-    private:
-        mutable size_t Hash = 0;
+        TEXTURE_FORMAT Format = {};
     };
 
     using ComputePipelineGroupLayout = std::pair<WebGPUComputePipelineWrapper, WebGPUBindGroupLayoutWrapper>;
-    using ComputePipelineCache       = std::unordered_map<ComputePipelineHashKey, ComputePipelineGroupLayout, ComputePipelineHashKey::Hasher>;
+    using RenderPipelineGroupLayout  = std::pair<WebGPURenderPipelineWrapper, WebGPUBindGroupLayoutWrapper>;
     using ShaderModuleCache          = std::unordered_map<ShaderModuleCacheKey, WebGPUShaderModuleWrapper, ShaderModuleCacheKey::Hasher>;
+    using ComputePipelineCache       = std::unordered_map<ComputePipelineHashKey, ComputePipelineGroupLayout, ComputePipelineHashKey::Hasher>;
+    using RenderPipelineCache        = std::unordered_map<RenderPipelineHashKey, RenderPipelineGroupLayout, RenderPipelineHashKey::Hasher>;
 
     void InitializeConstantBuffer();
 
     void InitializeSampler();
 
     void InitializePlaceholderTextures();
 
-    WebGPUShaderModuleWrapper& GetShaderModule(const UAVFormats& Formats);
+    WebGPUShaderModuleWrapper& GetShaderModule(const UAVFormats& Formats, SHADER_TYPE ShaderType);
 
     ComputePipelineGroupLayout& GetComputePipelineAndGroupLayout(const UAVFormats& Formats, Uint32 PowerOfTwo);
 
+    RenderPipelineGroupLayout& GetRenderPipelineAndGroupLayout(TEXTURE_FORMAT Format);
+
+    void GenerateMips(WGPUComputePassEncoder wgpuCmdEncoder, DeviceContextWebGPUImpl* pDeviceContext, TextureViewWebGPUImpl* pTexView);
+
+    void GenerateMips(WGPUCommandEncoder wgpuCmdEncoder, DeviceContextWebGPUImpl* pDeviceContext, TextureViewWebGPUImpl* pTexView);
+
 private:
     static constexpr TEXTURE_FORMAT PlaceholderTextureFormat = TEX_FORMAT_RGBA8_UNORM;
     static constexpr Uint32         SizeofUniformBuffer      = 16u;
@@ -121,10 +146,9 @@ class GenerateMipsHelperWebGPU
     RefCntAutoPtr<IBuffer>                   m_pBuffer;
     std::vector<RefCntAutoPtr<ITextureView>> m_PlaceholderTextureViews;
 
-    ComputePipelineCache m_PipelineLayoutCache;
+    ComputePipelineCache m_ComputePipelineLayoutCache;
+    RenderPipelineCache  m_RenderPipelineLayoutCache;
     ShaderModuleCache    m_ShaderModuleCache;
-
-    bool m_IsInitializedResources = false;
 };
 
 } // namespace Diligent

Graphics/GraphicsEngineWebGPU/include/TextureViewWebGPUImpl.hpp

@@ -61,6 +61,10 @@ class TextureViewWebGPUImpl final : public TextureViewBase<EngineWebGPUImplTrait
 
     WGPUTextureView GetMipLevelSRV(Uint32 Mip);
 
+    WGPUTextureView GetMipLevelRTV(Uint32 Slice, Uint32 Mip);
+
+    WGPUTextureView GetMipLevelSRV(Uint32 Slice, Uint32 Mip);
+
 private:
     WebGPUTextureViewWrapper              m_wgpuTextureView;
     std::vector<WebGPUTextureViewWrapper> m_wgpuTextureMipSRVs;

Graphics/GraphicsEngineWebGPU/src/DeviceContextWebGPUImpl.cpp

@@ -1577,8 +1577,7 @@ void DeviceContextWebGPUImpl::GenerateMips(ITextureView* pTexView)
     }
 
     GenerateMipsHelperWebGPU& MipGenerator = m_pDevice->GetMipsGenerator();
-    WGPUComputePassEncoder    CmdEncoder   = GetComputePassCommandEncoder();
-    MipGenerator.GenerateMips(CmdEncoder, this, ClassPtrCast<TextureViewWebGPUImpl>(pTexView));
+    MipGenerator.GenerateMips(this, ClassPtrCast<TextureViewWebGPUImpl>(pTexView));
 }
 
 void DeviceContextWebGPUImpl::FinishFrame()