ShaderResourceCacheWebGPU: remove m_pInlineConstantData

Author: TheMostDiligent

Graphics/GraphicsEngineWebGPU/include/ShaderResourceCacheWebGPU.hpp

@@ -95,7 +95,7 @@ class ShaderResourceCacheWebGPU : public ShaderResourceCacheBase
         // For uniform and storage buffers only
 /*16 */ Uint64                       BufferBaseOffset = 0;
 /*24 */ Uint64                       BufferRangeSize  = 0;
-        // For inline constant buffers only - points to staging data in cache tail
+        // For inline constant buffers only - pointer to the staging data
 /*32 */ void* const                  pInlineConstantData = nullptr;
         // clang-format on
 
@@ -108,7 +108,7 @@ class ShaderResourceCacheWebGPU : public ShaderResourceCacheBase
         {
             VERIFY(pInlineConstantData != nullptr, "Inline constant data pointer is not initialized");
             VERIFY(pData != nullptr, "Source data is null");
-            memcpy(static_cast<Uint32*>(pInlineConstantData) + FirstConstant, pData, NumConstants * sizeof(Uint32));
+            memcpy(static_cast<Uint8*>(pInlineConstantData) + FirstConstant * sizeof(Uint32), pData, NumConstants * sizeof(Uint32));
         }
 
         template <typename ResType>
@@ -196,7 +196,7 @@ class ShaderResourceCacheWebGPU : public ShaderResourceCacheBase
 
     bool HasInlineConstants() const
     {
-        return m_pInlineConstantData != nullptr;
+        return m_HasInlineConstants != 0;
     }
 
     ResourceCacheContentType GetContentType() const { return static_cast<ResourceCacheContentType>(m_ContentType); }
@@ -208,6 +208,16 @@ class ShaderResourceCacheWebGPU : public ShaderResourceCacheBase
                                  std::vector<uint32_t>&         Offsets,
                                  Uint32                         GroupIdx) const;
 
+    // Writes inline constant data to the staging buffer
+    void SetInlineConstants(Uint32 BindGroupIdx, Uint32 CacheOffset, const void* pConstants, Uint32 FirstConstant, Uint32 NumConstants);
+
+    // Copies inline constant data from source cache to this cache
+    void CopyInlineConstants(const ShaderResourceCacheWebGPU& SrcCache,
+                             Uint32                           BindGroupIdx,
+                             Uint32                           SrcCacheOffset,
+                             Uint32                           DstCacheOffset,
+                             Uint32                           NumConstants);
+
 #ifdef DILIGENT_DEBUG
     // For debug purposes only
     void DbgVerifyResourceInitialization() const;
@@ -221,9 +231,25 @@ class ShaderResourceCacheWebGPU : public ShaderResourceCacheBase
         return reinterpret_cast<const Resource*>(reinterpret_cast<const BindGroup*>(m_pMemory.get()) + m_NumBindGroups);
     }
 #endif
+    BindGroup* GetFirstBindGroupPtr()
+    {
+        return reinterpret_cast<BindGroup*>(m_pMemory.get());
+    }
     Resource* GetFirstResourcePtr()
     {
-        return reinterpret_cast<Resource*>(reinterpret_cast<BindGroup*>(m_pMemory.get()) + m_NumBindGroups);
+        static_assert(alignof(BindGroup) >= alignof(Resource),
+                      "BindGroup alignment is less than Resource alignment, Resource pointer may be misaligned");
+        return reinterpret_cast<Resource*>(GetFirstBindGroupPtr() + m_NumBindGroups);
+    }
+    WGPUBindGroupEntry* GetFirstWGPUEntryPtr()
+    {
+        static_assert(alignof(Resource) >= alignof(WGPUBindGroupEntry),
+                      "Resource alignment is less than WGPUBindGroupEntry alignment, WGPUBindGroupEntry pointer may be misaligned");
+        return reinterpret_cast<WGPUBindGroupEntry*>(GetFirstResourcePtr() + m_TotalResources);
+    }
+    Uint8* GetInlineConstantDataPtr(Uint32 Offset = 0)
+    {
+        return reinterpret_cast<Uint8*>(GetFirstWGPUEntryPtr() + m_TotalResources) + Offset * sizeof(Uint32);
     }
 
     BindGroup& GetBindGroup(Uint32 Index)
@@ -240,26 +266,14 @@ class ShaderResourceCacheWebGPU : public ShaderResourceCacheBase
     // The total actual number of dynamic buffers (that were created with USAGE_DYNAMIC) bound in the resource cache
     // regardless of the variable type.
     Uint16 m_NumDynamicBuffers = 0;
-    Uint32 m_TotalResources : 31;
+    Uint32 m_TotalResources : 30;
 
     // Indicates what types of resources are stored in the cache
     const Uint32 m_ContentType : 1;
 
-    // Pointer to the start of inline constant staging data in the memory tail
-    Uint32* m_pInlineConstantData = nullptr;
-
-public:
-    // Writes inline constant data to the staging buffer
-    void SetInlineConstants(Uint32 BindGroupIdx, Uint32 CacheOffset, const void* pConstants, Uint32 FirstConstant, Uint32 NumConstants);
-
-    // Copies inline constant data from source cache to this cache
-    void CopyInlineConstants(const ShaderResourceCacheWebGPU& SrcCache,
-                             Uint32                           BindGroupIdx,
-                             Uint32                           SrcCacheOffset,
-                             Uint32                           DstCacheOffset,
-                             Uint32                           NumConstants);
+    // Indicates whether the cache has inline constants
+    Uint32 m_HasInlineConstants : 1;
 
-private:
 #ifdef DILIGENT_DEBUG
     // Debug array that stores flags indicating if resources in the cache have been initialized
     std::vector<std::vector<bool>> m_DbgInitializedResources;

Graphics/GraphicsEngineWebGPU/src/ShaderResourceCacheWebGPU.cpp

@@ -112,9 +112,8 @@ void ShaderResourceCacheWebGPU::InitializeGroups(IMemoryAllocator& MemAllocator,
         };
         memset(m_pMemory.get(), 0, MemorySize);
 
-        BindGroup*          pGroups           = reinterpret_cast<BindGroup*>(m_pMemory.get());
-        Resource*           pCurrResPtr       = reinterpret_cast<Resource*>(pGroups + m_NumBindGroups);
-        WGPUBindGroupEntry* pCurrWGPUEntryPtr = reinterpret_cast<WGPUBindGroupEntry*>(pCurrResPtr + m_TotalResources);
+        Resource*           pCurrResPtr       = GetFirstResourcePtr();
+        WGPUBindGroupEntry* pCurrWGPUEntryPtr = GetFirstWGPUEntryPtr();
         for (Uint32 t = 0; t < NumGroups; ++t)
         {
             const Uint32 GroupSize = GroupSizes[t];
@@ -138,11 +137,7 @@ void ShaderResourceCacheWebGPU::InitializeGroups(IMemoryAllocator& MemAllocator,
 #endif
         }
 
-        // Set pointer to inline constant staging data at the tail of the memory block
-        if (TotalInlineConstants > 0)
-        {
-            m_pInlineConstantData = reinterpret_cast<Uint32*>(pCurrWGPUEntryPtr);
-        }
+        m_HasInlineConstants = (TotalInlineConstants > 0) ? 1u : 0u;
     }
 }
 
@@ -275,7 +270,7 @@ void ShaderResourceCacheWebGPU::InitializeResources(Uint32             GroupIdx,
         new (&Group.GetResource(Offset + res)) Resource{
             Type,
             HasImmutableSampler,
-            InlineConstantOffset != ~0u ? m_pInlineConstantData + InlineConstantOffset : nullptr,
+            InlineConstantOffset != ~0u ? GetInlineConstantDataPtr(InlineConstantOffset) : nullptr,
         };
 #ifdef DILIGENT_DEBUG
         m_DbgInitializedResources[GroupIdx][size_t{Offset} + res] = true;