Finish Step 6): Add commit path in DeviceContextGLImpl (graphics + compute)

Author: hzqst

Graphics/GraphicsEngineOpenGL/include/DeviceContextGLImpl.hpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2025 Diligent Graphics LLC
+ *  Copyright 2019-2026 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -325,7 +325,7 @@ class DeviceContextGLImpl final : public DeviceContextBase<EngineGLImplTraits>
     __forceinline void PostDraw();
 
     using TBindings = PipelineResourceSignatureGLImpl::TBindings;
-    void BindProgramResources(Uint32 BindSRBMask);
+    void BindProgramResources(Uint32 BindSRBMask, bool DynamicBuffersIntact = false, bool InlineConstantsIntact = false);
 
 #ifdef DILIGENT_DEVELOPMENT
     void DvpValidateCommittedShaderResources();

Graphics/GraphicsEngineOpenGL/include/PipelineResourceSignatureGLImpl.hpp

@@ -141,6 +141,10 @@ class PipelineResourceSignatureGLImpl final : public PipelineResourceSignatureBa
     // Make the base class method visible
     using TPipelineResourceSignatureBase::CopyStaticResources;
 
+    // Updates inline constant buffers by mapping the shared dynamic UBOs and copying
+    // data from the CPU-side staging buffer in the resource cache.
+    void UpdateInlineConstantBuffers(const ShaderResourceCacheGL& ResourceCache, class GLContextState& CtxState) const;
+
     bool HasInlineConstants() const
     {
         return m_NumInlineConstantBuffers != 0;

Graphics/GraphicsEngineOpenGL/src/DeviceContextGLImpl.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2025 Diligent Graphics LLC
+ *  Copyright 2019-2026 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -698,7 +698,7 @@ void DeviceContextGLImpl::DvpValidateCommittedShaderResources()
 }
 #endif
 
-void DeviceContextGLImpl::BindProgramResources(Uint32 BindSRBMask)
+void DeviceContextGLImpl::BindProgramResources(Uint32 BindSRBMask, bool DynamicBuffersIntact, bool InlineConstantsIntact)
 {
     VERIFY_EXPR(BindSRBMask != 0);
     //if (m_CommittedResourcesTentativeBarriers != 0)
@@ -721,16 +721,55 @@ void DeviceContextGLImpl::BindProgramResources(Uint32 BindSRBMask)
 
         const ShaderResourceCacheImplType* pResourceCache = m_BindInfo.ResourceCaches[sign];
         DEV_CHECK_ERR(pResourceCache != nullptr, "Resource cache at index ", sign, " is null");
-        if (m_BindInfo.StaleSRBMask & SignBit)
+
+        const bool SRBStale = (m_BindInfo.StaleSRBMask & SignBit) != 0;
+        if (SRBStale)
+        {
             pResourceCache->BindResources(GetContextState(), BaseBindings, m_BoundWritableTextures, m_BoundWritableBuffers);
+        }
         else
         {
-            VERIFY((m_BindInfo.DynamicSRBMask & SignBit) != 0,
-                   "When bit in StaleSRBMask is not set, the same bit in DynamicSRBMask must be set. Check GetCommitMask().");
-            DEV_CHECK_ERR(pResourceCache->HasDynamicResources(),
-                          "Bit in DynamicSRBMask is set, but the cache does not contain dynamic resources. This may indicate that resources "
-                          "in the cache have changed, but the SRB has not been committed before the draw/dispatch command.");
-            pResourceCache->BindDynamicBuffers(GetContextState(), BaseBindings);
+            VERIFY(((m_BindInfo.DynamicSRBMask | m_BindInfo.InlineConstantsSRBMask) & SignBit) != 0,
+                   "When bit in StaleSRBMask is not set, the same bit in either DynamicSRBMask or InlineConstantsSRBMask must be set. Check GetCommitMask().");
+
+            if ((m_BindInfo.DynamicSRBMask & SignBit) != 0)
+            {
+                DEV_CHECK_ERR(pResourceCache->HasDynamicResources(),
+                              "Bit in DynamicSRBMask is set, but the cache does not contain dynamic resources. This may indicate that resources "
+                              "in the cache have changed, but the SRB has not been committed before the draw/dispatch command.");
+                if (!DynamicBuffersIntact)
+                {
+                    pResourceCache->BindDynamicBuffers(GetContextState(), BaseBindings);
+                }
+            }
+        }
+
+        // Update inline constant buffers if needed
+        if ((m_BindInfo.InlineConstantsSRBMask & SignBit) != 0)
+        {
+            VERIFY(pResourceCache->HasInlineConstants(),
+                   "Shader resource cache does not contain inline constants, but the corresponding bit in InlineConstantsSRBMask is set. "
+                   "This may be a bug because inline constants flag in the cache never changes after SRB creation, "
+                   "while m_BindInfo.InlineConstantsSRBMask is initialized when SRB is committed.");
+            // Always update inline constant buffers if the SRB is stale
+            if (SRBStale || !InlineConstantsIntact)
+            {
+                if (PipelineResourceSignatureGLImpl* pSign = m_pPipelineState->GetResourceSignature(sign))
+                {
+                    pSign->UpdateInlineConstantBuffers(*pResourceCache, GetContextState());
+                }
+                else
+                {
+                    UNEXPECTED("Pipeline resource signature is null for signature index ", sign);
+                }
+            }
+        }
+        else
+        {
+            VERIFY(!pResourceCache->HasInlineConstants(),
+                   "Shader resource cache contains inline constants, but the corresponding bit in InlineConstantsSRBMask is not set. "
+                   "This may be a bug because inline constants flag in the cache never changes after SRB creation, "
+                   "while m_BindInfo.InlineConstantsSRBMask is initialized when SRB is committed.");
         }
     }
     m_BindInfo.StaleSRBMask &= ~m_BindInfo.ActiveSRBMask;
@@ -797,9 +836,11 @@ void DeviceContextGLImpl::PrepareForDraw(DRAW_FLAGS Flags, bool IsIndexed, GLenu
     // The program might have changed since the last SetPipelineState call if a shader was
     // created after the call (ShaderResourcesGL needs to bind a program to load uniforms).
     m_pPipelineState->CommitProgram(m_ContextState);
-    if (Uint32 BindSRBMask = m_BindInfo.GetCommitMask(Flags & DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT, Flags & DRAW_FLAG_INLINE_CONSTANTS_INTACT))
+    const bool DynamicBuffersIntact  = (Flags & DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT) != 0;
+    const bool InlineConstantsIntact = (Flags & DRAW_FLAG_INLINE_CONSTANTS_INTACT) != 0;
+    if (Uint32 BindSRBMask = m_BindInfo.GetCommitMask(DynamicBuffersIntact, InlineConstantsIntact))
     {
-        BindProgramResources(BindSRBMask);
+        BindProgramResources(BindSRBMask, DynamicBuffersIntact, InlineConstantsIntact);
     }
 
 #ifdef DILIGENT_DEVELOPMENT

Graphics/GraphicsEngineOpenGL/src/PipelineResourceSignatureGLImpl.cpp

@@ -33,6 +33,8 @@
 #include <functional>
 
 #include "RenderDeviceGLImpl.hpp"
+#include "BufferGLImpl.hpp"
+#include "GLContextState.hpp"
 
 namespace Diligent
 {
@@ -576,6 +578,25 @@ void PipelineResourceSignatureGLImpl::CopyStaticResources(ShaderResourceCacheGL&
 #endif
 }
 
+void PipelineResourceSignatureGLImpl::UpdateInlineConstantBuffers(const ShaderResourceCacheGL& ResourceCache, GLContextState& CtxState) const
+{
+    for (Uint32 i = 0; i < m_NumInlineConstantBuffers; ++i)
+    {
+        const InlineConstantBufferAttribsGL& InlineCBAttr = GetInlineConstantBuffer(i);
+        VERIFY_EXPR(InlineCBAttr.pBuffer);
+
+        const ShaderResourceCacheGL::CachedUB& InlineCB = ResourceCache.GetConstUB(InlineCBAttr.CacheOffset);
+        VERIFY(InlineCBAttr.NumConstants * sizeof(Uint32) == InlineCB.RangeSize, "Inline constant buffer size mismatch");
+        VERIFY(InlineCB.pInlineConstantData != nullptr, "Inline constant data pointer is null");
+
+        // Map the shared buffer and copy the data
+        PVoid pMappedData = nullptr;
+        InlineCBAttr.pBuffer->Map(CtxState, MAP_WRITE, MAP_FLAG_DISCARD, pMappedData);
+        memcpy(pMappedData, InlineCB.pInlineConstantData, InlineCBAttr.NumConstants * sizeof(Uint32));
+        InlineCBAttr.pBuffer->Unmap(CtxState);
+    }
+}
+
 void PipelineResourceSignatureGLImpl::InitSRBResourceCache(ShaderResourceCacheGL& ResourceCache)
 {
     ResourceCache.Initialize(m_BindingCount, m_SRBMemAllocator.GetResourceCacheDataAllocator(0), m_DynamicUBOMask, m_DynamicSSBOMask, m_TotalInlineConstants);