Step: 1.5) Fix ArraySize in GetDefaultSignatureDesc for inline constants

Author: hzqst

Graphics/GraphicsEngineOpenGL/include/ShaderResourcesGL.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");
@@ -147,19 +147,31 @@ class ShaderResourcesGL
                           SHADER_TYPE           _ShaderStages,
                           SHADER_RESOURCE_TYPE  _ResourceType,
                           Uint32                _ArraySize,
-                          GLuint                _UBIndex)noexcept :
+                          GLuint                _UBIndex,
+                          Uint32                _BufferSize = 0)noexcept :
             GLResourceAttribs{_Name, _ShaderStages, _ResourceType, PIPELINE_RESOURCE_FLAG_NONE, _ArraySize},
-            UBIndex          {_UBIndex}
+            UBIndex          {_UBIndex},
+            BufferSize       {_BufferSize}
         {}
 
         UniformBufferInfo(const UniformBufferInfo& UB,
                           StringPool&              NamesPool)noexcept :
             GLResourceAttribs{UB, NamesPool},
-            UBIndex          {UB.UBIndex   }
+            UBIndex          {UB.UBIndex    },
+            BufferSize       {UB.BufferSize }
         {}
         // clang-format on
 
         const GLuint UBIndex;
+        const Uint32 BufferSize; // Buffer size in bytes
+
+        /// Returns the number of 32-bit constants in the buffer.
+        /// This is used for inline constants where ArraySize represents
+        /// the number of constants, not the UBO array size.
+        Uint32 GetInlineConstantCount() const
+        {
+            return BufferSize / sizeof(Uint32);
+        }
     };
     static_assert((sizeof(UniformBufferInfo) % sizeof(void*)) == 0, "sizeof(UniformBufferInfo) must be multiple of sizeof(void*)");
 

Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.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");
@@ -130,12 +130,48 @@ PipelineResourceSignatureDescWrapper PipelineStateGLImpl::GetDefaultSignatureDes
         }
     };
 
+    // Specialized handler for uniform buffers to handle inline constants correctly
+    const auto HandleUniformBuffer = [&](const ShaderResourcesGL::UniformBufferInfo& UB) //
+    {
+        const ShaderResourceVariableDesc VarDesc     = FindPipelineResourceLayoutVariable(ResourceLayout, UB.Name, UB.ShaderStages, nullptr);
+        const auto                       it_assigned = UniqueResources.emplace(ShaderResourceHashKey{VarDesc.ShaderStages, UB.Name}, UB);
+        if (it_assigned.second)
+        {
+            const PIPELINE_RESOURCE_FLAGS Flags = UB.ResourceFlags | ShaderVariableFlagsToPipelineResourceFlags(VarDesc.Flags);
+
+            // For inline constants, use the constant count instead of the UBO array size
+            Uint32 ArraySize = UB.ArraySize;
+            if (Flags & PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS)
+            {
+                VERIFY(Flags == PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS, "INLINE_CONSTANTS flag cannot be combined with other flags.");
+                ArraySize = UB.GetInlineConstantCount();
+                if (ArraySize == 0)
+                {
+                    LOG_ERROR_AND_THROW("Inline constants resource '", UB.Name, "' has zero buffer size. "
+                                        "Make sure the shader was compiled with constant buffer reflection enabled.");
+                }
+                if (ArraySize > MAX_INLINE_CONSTANTS)
+                {
+                    LOG_ERROR_AND_THROW("Inline constants resource '", UB.Name, "' has ",
+                                        ArraySize, " constants. The maximum supported number of inline constants is ",
+                                        MAX_INLINE_CONSTANTS, '.');
+                }
+            }
+
+            SignDesc.AddResource(VarDesc.ShaderStages, UB.Name, ArraySize, UB.ResourceType, VarDesc.Type, Flags);
+        }
+        else
+        {
+            VerifyResourceMerge(m_Desc, it_assigned.first->second, UB);
+        }
+    };
+
     if (m_IsProgramPipelineSupported)
     {
         for (size_t i = 0; i < ShaderStages.size(); ++i)
         {
             ShaderGLImpl* pShaderGL = ShaderStages[i];
-            pShaderGL->GetShaderResources()->ProcessConstResources(HandleResource, HandleResource, HandleResource, HandleResource);
+            pShaderGL->GetShaderResources()->ProcessConstResources(HandleUniformBuffer, HandleResource, HandleResource, HandleResource);
         }
     }
     else
@@ -153,7 +189,7 @@ PipelineResourceSignatureDescWrapper PipelineStateGLImpl::GetDefaultSignatureDes
                 SamplerResFlag,
                 pImmediateCtx->GetContextState());
         }
-        m_GLPrograms[0]->GetResources()->ProcessConstResources(HandleResource, HandleResource, HandleResource, HandleResource);
+        m_GLPrograms[0]->GetResources()->ProcessConstResources(HandleUniformBuffer, HandleResource, HandleResource, HandleResource);
 
         if (ResourceLayout.NumImmutableSamplers > 0)
         {

Graphics/GraphicsEngineOpenGL/src/ShaderResourcesGL.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");
@@ -754,12 +754,18 @@ void ShaderResourcesGL::LoadUniforms(const LoadUniformsAttribs& Attribs)
 
         if (IsNewBlock)
         {
+            // Get the buffer size for this uniform block
+            GLint BufferSize = 0;
+            glGetActiveUniformBlockiv(GLProgram, UniformBlockIndex, GL_UNIFORM_BLOCK_DATA_SIZE, &BufferSize);
+            DEV_CHECK_GL_ERROR("Failed to get the value of the GL_UNIFORM_BLOCK_DATA_SIZE parameter");
+
             UniformBlocks.emplace_back(
                 NamesPool.emplace(Name.data()).first->c_str(),
                 Attribs.ShaderStages,
                 SHADER_RESOURCE_TYPE_CONSTANT_BUFFER,
                 static_cast<Uint32>(ArraySize),
-                UniformBlockIndex //
+                UniformBlockIndex,
+                static_cast<Uint32>(BufferSize) //
             );
         }
     }