GL backend: some code improvements

11 files changed, 238 insertions, 233 deletions

diff --git a/Graphics/GraphicsEngineOpenGL/include/GLTypeConversions.hpp b/Graphics/GraphicsEngineOpenGL/include/GLTypeConversions.hpp
index 03602439..395f53f6 100644
--- a/Graphics/GraphicsEngineOpenGL/include/GLTypeConversions.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/GLTypeConversions.hpp
@@ -379,4 +379,6 @@ TEXTURE_FORMAT GLInternalTexFormatToTexFormat(GLenum GlFormat);
 NativePixelAttribs GetNativePixelTransferAttribs(TEXTURE_FORMAT TexFormat);
 GLenum             TypeToGLTexFormat(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized);
 
+void GLTextureTypeToResourceDim(GLenum TextureType, RESOURCE_DIMENSION& ResDim, bool& IsMS);
+
 } // namespace Diligent
diff --git a/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp b/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
index ded87435..08b98d6e 100644
--- a/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
@@ -76,9 +76,9 @@ private:
     template <typename PSOCreateInfoType>
     void InitInternalObjects(const PSOCreateInfoType& CreateInfo, const TShaderStages& ShaderStages);
 
-    void InitResourceLayouts(const PipelineStateCreateInfo& CreateInfo,
-                             const TShaderStages&           ShaderStages,
-                             SHADER_TYPE                    ActiveStages);
+    void InitResourceLayout(const PipelineStateCreateInfo& CreateInfo,
+                            const TShaderStages&           ShaderStages,
+                            SHADER_TYPE                    ActiveStages);
 
     RefCntAutoPtr<PipelineResourceSignatureGLImpl> CreateDefaultSignature(
         const PipelineStateCreateInfo& CreateInfo,
@@ -103,9 +103,9 @@ private:
 
     std::vector<std::pair<GLContext::NativeGLContextType, GLObjectWrappers::GLPipelineObj>> m_GLProgPipelines;
 
-    Uint8                      m_NumPrograms                = 0;
-    bool                       m_IsProgramPipelineSupported = false;
-    std::array<SHADER_TYPE, 5> m_ShaderTypes                = {};
+    Uint8        m_NumPrograms                = 0;
+    bool         m_IsProgramPipelineSupported = false;
+    SHADER_TYPE* m_ShaderTypes                = nullptr; // [m_NumPrograms]
 
 #ifdef DILIGENT_DEVELOPMENT
     // Shader resources for all shaders in all shader stages in the pipeline.
diff --git a/Graphics/GraphicsEngineOpenGL/include/RenderPassGLImpl.hpp b/Graphics/GraphicsEngineOpenGL/include/RenderPassGLImpl.hpp
index cbfea449..227cbec4 100644
--- a/Graphics/GraphicsEngineOpenGL/include/RenderPassGLImpl.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/RenderPassGLImpl.hpp
@@ -36,9 +36,7 @@
 namespace Diligent
 {
 
-class FixedBlockMemoryAllocator;
-
-/// Render pass implementation in Direct3D11 backend.
+/// Render pass implementation in OpenGL backend.
 class RenderPassGLImpl final : public RenderPassBase<EngineGLImplTraits>
 {
 public:
diff --git a/Graphics/GraphicsEngineOpenGL/include/ShaderVariableManagerGL.hpp b/Graphics/GraphicsEngineOpenGL/include/ShaderVariableManagerGL.hpp
index 78e5d195..e028f566 100644
--- a/Graphics/GraphicsEngineOpenGL/include/ShaderVariableManagerGL.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/ShaderVariableManagerGL.hpp
@@ -275,7 +275,10 @@ public:
 
     IObject& GetOwner() { return m_Owner; }
 
-    Uint32 GetVariableCount() const;
+    Uint32 GetVariableCount() const
+    {
+        return GetNumUBs() + GetNumTextures() + GetNumImages() + GetNumStorageBuffers();
+    }
 
     // clang-format off
     Uint32 GetNumUBs()            const { return (m_TextureOffset       - m_UBOffset)            / sizeof(UniformBuffBindInfo);    }
@@ -304,11 +307,10 @@ private:
         Uint32 NumImages        = 0;
         Uint32 NumStorageBlocks = 0;
     };
-    static void CountResources(const PipelineResourceSignatureGLImpl& Signature,
-                               const SHADER_RESOURCE_VARIABLE_TYPE*   AllowedVarTypes,
-                               Uint32                                 NumAllowedTypes,
-                               SHADER_TYPE                            ShaderType,
-                               ResourceCounters&                      Counters);
+    static ResourceCounters CountResources(const PipelineResourceSignatureGLImpl& Signature,
+                                           const SHADER_RESOURCE_VARIABLE_TYPE*   AllowedVarTypes,
+                                           Uint32                                 NumAllowedTypes,
+                                           SHADER_TYPE                            ShaderType);
 
     // Offsets in bytes
     using OffsetType = Uint16;
diff --git a/Graphics/GraphicsEngineOpenGL/src/GLTypeConversions.cpp b/Graphics/GraphicsEngineOpenGL/src/GLTypeConversions.cpp
index fda07605..ed37ebb7 100644
--- a/Graphics/GraphicsEngineOpenGL/src/GLTypeConversions.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/GLTypeConversions.cpp
@@ -561,4 +561,149 @@ GLenum TypeToGLTexFormat(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNorma
     }
 }
 
+
+void GLTextureTypeToResourceDim(GLenum TextureType, RESOURCE_DIMENSION& ResDim, bool& IsMS)
+{
+    IsMS   = false;
+    ResDim = RESOURCE_DIM_UNDEFINED;
+    switch (TextureType)
+    {
+        case GL_SAMPLER_1D:
+        case GL_SAMPLER_1D_SHADOW:
+        case GL_INT_SAMPLER_1D:
+        case GL_UNSIGNED_INT_SAMPLER_1D:
+            ResDim = RESOURCE_DIM_TEX_1D;
+            return;
+
+        case GL_SAMPLER_2D:
+        case GL_SAMPLER_2D_SHADOW:
+        case GL_INT_SAMPLER_2D:
+        case GL_UNSIGNED_INT_SAMPLER_2D:
+        case GL_SAMPLER_EXTERNAL_OES:
+            ResDim = RESOURCE_DIM_TEX_2D;
+            return;
+
+        case GL_SAMPLER_3D:
+        case GL_INT_SAMPLER_3D:
+        case GL_UNSIGNED_INT_SAMPLER_3D:
+            ResDim = RESOURCE_DIM_TEX_3D;
+            return;
+
+        case GL_SAMPLER_CUBE:
+        case GL_SAMPLER_CUBE_SHADOW:
+        case GL_INT_SAMPLER_CUBE:
+        case GL_UNSIGNED_INT_SAMPLER_CUBE:
+            ResDim = RESOURCE_DIM_TEX_CUBE;
+            return;
+
+        case GL_SAMPLER_1D_ARRAY:
+        case GL_SAMPLER_1D_ARRAY_SHADOW:
+        case GL_INT_SAMPLER_1D_ARRAY:
+        case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
+            ResDim = RESOURCE_DIM_TEX_1D_ARRAY;
+            return;
+
+        case GL_SAMPLER_2D_ARRAY:
+        case GL_SAMPLER_2D_ARRAY_SHADOW:
+        case GL_INT_SAMPLER_2D_ARRAY:
+        case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
+            ResDim = RESOURCE_DIM_TEX_2D_ARRAY;
+            return;
+
+        case GL_SAMPLER_CUBE_MAP_ARRAY:
+        case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
+        case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
+        case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
+            ResDim = RESOURCE_DIM_TEX_CUBE_ARRAY;
+            return;
+
+        case GL_SAMPLER_2D_MULTISAMPLE:
+        case GL_INT_SAMPLER_2D_MULTISAMPLE:
+        case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+            ResDim = RESOURCE_DIM_TEX_2D;
+            IsMS   = true;
+            return;
+
+        case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
+        case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+        case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+            ResDim = RESOURCE_DIM_TEX_2D_ARRAY;
+            IsMS   = true;
+            return;
+
+        case GL_SAMPLER_BUFFER:
+        case GL_INT_SAMPLER_BUFFER:
+        case GL_UNSIGNED_INT_SAMPLER_BUFFER:
+            ResDim = RESOURCE_DIM_BUFFER;
+            return;
+
+#if GL_ARB_shader_image_load_store
+        case GL_IMAGE_1D:
+        case GL_INT_IMAGE_1D:
+        case GL_UNSIGNED_INT_IMAGE_1D:
+            ResDim = RESOURCE_DIM_TEX_1D;
+            return;
+
+        case GL_IMAGE_2D:
+        case GL_IMAGE_2D_RECT:
+        case GL_INT_IMAGE_2D:
+        case GL_INT_IMAGE_2D_RECT:
+        case GL_UNSIGNED_INT_IMAGE_2D:
+        case GL_UNSIGNED_INT_IMAGE_2D_RECT:
+            ResDim = RESOURCE_DIM_TEX_2D;
+            return;
+
+        case GL_IMAGE_3D:
+        case GL_INT_IMAGE_3D:
+        case GL_UNSIGNED_INT_IMAGE_3D:
+            ResDim = RESOURCE_DIM_TEX_3D;
+            return;
+
+        case GL_IMAGE_CUBE:
+        case GL_INT_IMAGE_CUBE:
+        case GL_UNSIGNED_INT_IMAGE_CUBE:
+            ResDim = RESOURCE_DIM_TEX_CUBE;
+            return;
+
+        case GL_IMAGE_BUFFER:
+        case GL_INT_IMAGE_BUFFER:
+        case GL_UNSIGNED_INT_IMAGE_BUFFER:
+            ResDim = RESOURCE_DIM_BUFFER;
+            return;
+
+        case GL_IMAGE_1D_ARRAY:
+        case GL_INT_IMAGE_1D_ARRAY:
+        case GL_UNSIGNED_INT_IMAGE_1D_ARRAY:
+            ResDim = RESOURCE_DIM_TEX_1D_ARRAY;
+            return;
+
+        case GL_IMAGE_2D_ARRAY:
+        case GL_INT_IMAGE_2D_ARRAY:
+        case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
+            ResDim = RESOURCE_DIM_TEX_2D_ARRAY;
+            return;
+
+        case GL_IMAGE_CUBE_MAP_ARRAY:
+        case GL_INT_IMAGE_CUBE_MAP_ARRAY:
+        case GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY:
+            ResDim = RESOURCE_DIM_TEX_CUBE_ARRAY;
+            return;
+
+        case GL_IMAGE_2D_MULTISAMPLE:
+        case GL_INT_IMAGE_2D_MULTISAMPLE:
+        case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE:
+            ResDim = RESOURCE_DIM_TEX_2D;
+            IsMS   = true;
+            return;
+
+        case GL_IMAGE_2D_MULTISAMPLE_ARRAY:
+        case GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
+        case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
+            ResDim = RESOURCE_DIM_TEX_2D_ARRAY;
+            IsMS   = true;
+            return;
+#endif
+    }
+}
+
 } // namespace Diligent
diff --git a/Graphics/GraphicsEngineOpenGL/src/PipelineResourceSignatureGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/PipelineResourceSignatureGLImpl.cpp
index 01865da4..f48f82e5 100644
--- a/Graphics/GraphicsEngineOpenGL/src/PipelineResourceSignatureGLImpl.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/PipelineResourceSignatureGLImpl.cpp
@@ -180,7 +180,7 @@ void PipelineResourceSignatureGLImpl::CreateLayout()
             auto SamplerIdx      = ResourceAttribs::InvalidSamplerInd;
             if (ResDesc.ResourceType == SHADER_RESOURCE_TYPE_TEXTURE_SRV)
             {
-                // Do not use combined sampler suffix - in OpenGL immutable samplers should be defined defined for textures directly
+                // Do not use combined sampler suffix - in OpenGL immutable samplers should be defined for textures directly
                 ImtblSamplerIdx = Diligent::FindImmutableSampler(m_Desc.ImmutableSamplers, m_Desc.NumImmutableSamplers,
                                                                  ResDesc.ShaderStages, ResDesc.Name, nullptr);
                 if (ImtblSamplerIdx != InvalidImmutableSamplerIndex)
diff --git a/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
index a07d68a5..716626e7 100644
--- a/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
@@ -42,6 +42,25 @@
 namespace Diligent
 {
 
+static void VerifyResourceMerge(const PipelineStateDesc&                    PSODesc,
+                                const ShaderResourcesGL::GLResourceAttribs& ExistingRes,
+                                const ShaderResourcesGL::GLResourceAttribs& NewResAttribs)
+{
+#define LOG_RESOURCE_MERGE_ERROR_AND_THROW(PropertyName)                                                          \
+    LOG_ERROR_AND_THROW("Shader variable '", NewResAttribs.Name,                                                  \
+                        "' is shared between multiple shaders in pipeline '", (PSODesc.Name ? PSODesc.Name : ""), \
+                        "', but its " PropertyName " varies. A variable shared between multiple shaders "         \
+                        "must be defined identically in all shaders. Either use separate variables for "          \
+                        "different shader stages, change resource name or make sure that " PropertyName " is consistent.");
+
+    if (ExistingRes.ResourceType != NewResAttribs.ResourceType)
+        LOG_RESOURCE_MERGE_ERROR_AND_THROW("type");
+
+    if (ExistingRes.ArraySize != NewResAttribs.ArraySize)
+        LOG_RESOURCE_MERGE_ERROR_AND_THROW("array size");
+#undef LOG_RESOURCE_MERGE_ERROR_AND_THROW
+}
+
 RefCntAutoPtr<PipelineResourceSignatureGLImpl> PipelineStateGLImpl::CreateDefaultSignature(
     const PipelineStateCreateInfo& CreateInfo,
     const TShaderStages&           ShaderStages,
@@ -98,10 +117,7 @@ RefCntAutoPtr<PipelineResourceSignatureGLImpl> PipelineStateGLImpl::CreateDefaul
         }
         else
         {
-            DEV_CHECK_ERR(IterAndAssigned.first->Attribs.ResourceType == Attribs.ResourceType,
-                          "Shader variable '", Attribs.Name,
-                          "' exists in multiple shaders from the same shader stage, but its type is not consistent between "
-                          "shaders. All variables with the same name from the same shader stage must have the same type.");
+            VerifyResourceMerge(CreateInfo.PSODesc, IterAndAssigned.first->Attribs, Attribs);
         }
     };
     const auto HandleUB = [&](const ShaderResourcesGL::UniformBufferInfo& Attribs) {
@@ -165,9 +181,9 @@ RefCntAutoPtr<PipelineResourceSignatureGLImpl> PipelineStateGLImpl::CreateDefaul
     return pSignature;
 }
 
-void PipelineStateGLImpl::InitResourceLayouts(const PipelineStateCreateInfo& CreateInfo,
-                                              const TShaderStages&           ShaderStages,
-                                              SHADER_TYPE                    ActiveStages)
+void PipelineStateGLImpl::InitResourceLayout(const PipelineStateCreateInfo& CreateInfo,
+                                             const TShaderStages&           ShaderStages,
+                                             SHADER_TYPE                    ActiveStages)
 {
     if (m_UsingImplicitSignature)
     {
@@ -237,15 +253,19 @@ void PipelineStateGLImpl::InitInternalObjects(const PSOCreateInfoType& CreateInf
     VERIFY(deviceCaps.DevType != RENDER_DEVICE_TYPE_UNDEFINED, "Device caps are not initialized");
 
     m_IsProgramPipelineSupported = deviceCaps.Features.SeparablePrograms != DEVICE_FEATURE_STATE_DISABLED;
+    m_NumPrograms                = m_IsProgramPipelineSupported ? static_cast<Uint8>(ShaderStages.size()) : 1;
 
     FixedLinearAllocator MemPool{GetRawAllocator()};
 
     ReserveSpaceForPipelineDesc(CreateInfo, MemPool);
-    MemPool.AddSpace<GLProgramObj>(m_IsProgramPipelineSupported ? ShaderStages.size() : 1);
+    MemPool.AddSpace<GLProgramObj>(m_NumPrograms);
+    MemPool.AddSpace<SHADER_TYPE>(m_NumPrograms);
 
     MemPool.Reserve();
 
     InitializePipelineDesc(CreateInfo, MemPool);
+    m_GLPrograms  = MemPool.ConstructArray<GLProgramObj>(m_NumPrograms, false);
+    m_ShaderTypes = MemPool.ConstructArray<SHADER_TYPE>(m_NumPrograms, SHADER_TYPE_UNKNOWN);
 
     // Get active shader stages.
     SHADER_TYPE ActiveStages = SHADER_TYPE_UNKNOWN;
@@ -259,25 +279,20 @@ void PipelineStateGLImpl::InitInternalObjects(const PSOCreateInfoType& CreateInf
     // Create programs.
     if (m_IsProgramPipelineSupported)
     {
-        VERIFY_EXPR(m_ShaderTypes.size() >= ShaderStages.size());
-        m_GLPrograms = MemPool.ConstructArray<GLProgramObj>(ShaderStages.size(), false);
         for (size_t i = 0; i < ShaderStages.size(); ++i)
         {
             auto* pShaderGL  = ShaderStages[i];
             m_GLPrograms[i]  = GLProgramObj{ShaderGLImpl::LinkProgram(&ShaderStages[i], 1, true)};
             m_ShaderTypes[i] = pShaderGL->GetDesc().ShaderType;
         }
-        m_NumPrograms = static_cast<Uint8>(ShaderStages.size());
     }
     else
     {
-        m_GLPrograms     = MemPool.ConstructArray<GLProgramObj>(1, false);
         m_GLPrograms[0]  = ShaderGLImpl::LinkProgram(ShaderStages.data(), static_cast<Uint32>(ShaderStages.size()), false);
         m_ShaderTypes[0] = ActiveStages;
-        m_NumPrograms    = 1;
     }
 
-    InitResourceLayouts(CreateInfo, ShaderStages, ActiveStages);
+    InitResourceLayout(CreateInfo, ShaderStages, ActiveStages);
 }
 
 PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*                    pRefCounters,
@@ -369,6 +384,7 @@ void PipelineStateGLImpl::Destruct()
         m_GLPrograms = nullptr;
     }
 
+    m_ShaderTypes = nullptr;
     m_NumPrograms = 0;
 
     TPipelineStateBase::Destruct();
@@ -505,7 +521,7 @@ void PipelineStateGLImpl::DvpVerifySRBResources(ShaderResourceBindingGLImpl* pSR
     for (Uint32 sign = 0; sign < SignCount; ++sign)
     {
         // Get resource signature from the root signature
-        const auto& pSignature = GetResourceSignature(sign);
+        const auto* pSignature = GetResourceSignature(sign);
         if (pSignature == nullptr || pSignature->GetTotalResourceCount() == 0)
             continue; // Skip null and empty signatures
 
@@ -556,23 +572,26 @@ void PipelineStateGLImpl::DvpVerifySRBResources(ShaderResourceBindingGLImpl* pSR
                 }
 
                 const auto& SRBCache = ppSRBs[attrib_it->SignatureIndex]->GetResourceCache();
-                attrib_it->pSignature->DvpValidateCommittedResource(Attribs, ResDim, IsMS, attrib_it->ResourceIndex, SRBCache, PSO.m_ShaderNames[shader_ind].c_str(), PSO.m_Desc.Name);
+                attrib_it->pSignature->DvpValidateCommittedResource(Attribs, ResDim, IsMS, attrib_it->ResourceIndex,
+                                                                    SRBCache, PSO.m_ShaderNames[shader_ind].c_str(), PSO.m_Desc.Name);
             }
             ++attrib_it;
         }
 
-        void operator()(const ShaderResourcesGL::GLResourceAttribs& Attribs) { Validate(Attribs, RESOURCE_DIM_UNDEFINED, false); }
+        void operator()(const ShaderResourcesGL::StorageBlockInfo& Attribs) { Validate(Attribs, RESOURCE_DIM_BUFFER, false); }
+        void operator()(const ShaderResourcesGL::UniformBufferInfo& Attribs) { Validate(Attribs, RESOURCE_DIM_BUFFER, false); }
         void operator()(const ShaderResourcesGL::TextureInfo& Attribs) { Validate(Attribs, Attribs.ResourceDim, Attribs.IsMultisample); }
         void operator()(const ShaderResourcesGL::ImageInfo& Attribs) { Validate(Attribs, Attribs.ResourceDim, Attribs.IsMultisample); }
     };
 
-    Uint32               i = 0;
-    HandleResourceHelper HandleResource{*this, pSRBs, NumSRBs, m_ResourceAttibutions.begin(), i};
+    Uint32               ShaderInd = 0;
+    HandleResourceHelper HandleResource{*this, pSRBs, NumSRBs, m_ResourceAttibutions.begin(), ShaderInd};
 
     VERIFY_EXPR(m_ShaderResources.size() == m_ShaderNames.size());
-    for (; i < m_ShaderResources.size(); ++i)
+    for (; ShaderInd < m_ShaderResources.size(); ++ShaderInd)
     {
-        m_ShaderResources[i]->ProcessConstResources(std::ref(HandleResource), std::ref(HandleResource), std::ref(HandleResource), std::ref(HandleResource));
+        m_ShaderResources[ShaderInd]->ProcessConstResources(std::ref(HandleResource), std::ref(HandleResource),
+                                                            std::ref(HandleResource), std::ref(HandleResource));
     }
     VERIFY_EXPR(HandleResource.attrib_it == m_ResourceAttibutions.end());
 }
diff --git a/Graphics/GraphicsEngineOpenGL/src/ShaderResourcesGL.cpp b/Graphics/GraphicsEngineOpenGL/src/ShaderResourcesGL.cpp
index 84211c2c..8a27e3cd 100644
--- a/Graphics/GraphicsEngineOpenGL/src/ShaderResourcesGL.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/ShaderResourcesGL.cpp
@@ -35,159 +35,11 @@
 #include "GLContextState.hpp"
 #include "ShaderResourceVariableBase.hpp"
 #include "Align.hpp"
+#include "GLTypeConversions.hpp"
 
 namespace Diligent
 {
 
-namespace
-{
-
-void GLTextureTypeToResourceDim(GLenum TextureType, RESOURCE_DIMENSION& ResDim, bool& IsMS)
-{
-    IsMS   = false;
-    ResDim = RESOURCE_DIM_UNDEFINED;
-    switch (TextureType)
-    {
-        case GL_SAMPLER_1D:
-        case GL_SAMPLER_1D_SHADOW:
-        case GL_INT_SAMPLER_1D:
-        case GL_UNSIGNED_INT_SAMPLER_1D:
-            ResDim = RESOURCE_DIM_TEX_1D;
-            return;
-
-        case GL_SAMPLER_2D:
-        case GL_SAMPLER_2D_SHADOW:
-        case GL_INT_SAMPLER_2D:
-        case GL_UNSIGNED_INT_SAMPLER_2D:
-        case GL_SAMPLER_EXTERNAL_OES:
-            ResDim = RESOURCE_DIM_TEX_2D;
-            return;
-
-        case GL_SAMPLER_3D:
-        case GL_INT_SAMPLER_3D:
-        case GL_UNSIGNED_INT_SAMPLER_3D:
-            ResDim = RESOURCE_DIM_TEX_3D;
-            return;
-
-        case GL_SAMPLER_CUBE:
-        case GL_SAMPLER_CUBE_SHADOW:
-        case GL_INT_SAMPLER_CUBE:
-        case GL_UNSIGNED_INT_SAMPLER_CUBE:
-            ResDim = RESOURCE_DIM_TEX_CUBE;
-            return;
-
-        case GL_SAMPLER_1D_ARRAY:
-        case GL_SAMPLER_1D_ARRAY_SHADOW:
-        case GL_INT_SAMPLER_1D_ARRAY:
-        case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
-            ResDim = RESOURCE_DIM_TEX_1D_ARRAY;
-            return;
-
-        case GL_SAMPLER_2D_ARRAY:
-        case GL_SAMPLER_2D_ARRAY_SHADOW:
-        case GL_INT_SAMPLER_2D_ARRAY:
-        case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
-            ResDim = RESOURCE_DIM_TEX_2D_ARRAY;
-            return;
-
-        case GL_SAMPLER_CUBE_MAP_ARRAY:
-        case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
-        case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
-        case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
-            ResDim = RESOURCE_DIM_TEX_CUBE_ARRAY;
-            return;
-
-        case GL_SAMPLER_2D_MULTISAMPLE:
-        case GL_INT_SAMPLER_2D_MULTISAMPLE:
-        case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
-            ResDim = RESOURCE_DIM_TEX_2D;
-            IsMS   = true;
-            return;
-
-        case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
-        case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
-        case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
-            ResDim = RESOURCE_DIM_TEX_2D_ARRAY;
-            IsMS   = true;
-            return;
-
-        case GL_SAMPLER_BUFFER:
-        case GL_INT_SAMPLER_BUFFER:
-        case GL_UNSIGNED_INT_SAMPLER_BUFFER:
-            ResDim = RESOURCE_DIM_BUFFER;
-            return;
-
-#if GL_ARB_shader_image_load_store
-        case GL_IMAGE_1D:
-        case GL_INT_IMAGE_1D:
-        case GL_UNSIGNED_INT_IMAGE_1D:
-            ResDim = RESOURCE_DIM_TEX_1D;
-            return;
-
-        case GL_IMAGE_2D:
-        case GL_IMAGE_2D_RECT:
-        case GL_INT_IMAGE_2D:
-        case GL_INT_IMAGE_2D_RECT:
-        case GL_UNSIGNED_INT_IMAGE_2D:
-        case GL_UNSIGNED_INT_IMAGE_2D_RECT:
-            ResDim = RESOURCE_DIM_TEX_2D;
-            return;
-
-        case GL_IMAGE_3D:
-        case GL_INT_IMAGE_3D:
-        case GL_UNSIGNED_INT_IMAGE_3D:
-            ResDim = RESOURCE_DIM_TEX_3D;
-            return;
-
-        case GL_IMAGE_CUBE:
-        case GL_INT_IMAGE_CUBE:
-        case GL_UNSIGNED_INT_IMAGE_CUBE:
-            ResDim = RESOURCE_DIM_TEX_CUBE;
-            return;
-
-        case GL_IMAGE_BUFFER:
-        case GL_INT_IMAGE_BUFFER:
-        case GL_UNSIGNED_INT_IMAGE_BUFFER:
-            ResDim = RESOURCE_DIM_BUFFER;
-            return;
-
-        case GL_IMAGE_1D_ARRAY:
-        case GL_INT_IMAGE_1D_ARRAY:
-        case GL_UNSIGNED_INT_IMAGE_1D_ARRAY:
-            ResDim = RESOURCE_DIM_TEX_1D_ARRAY;
-            return;
-
-        case GL_IMAGE_2D_ARRAY:
-        case GL_INT_IMAGE_2D_ARRAY:
-        case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
-            ResDim = RESOURCE_DIM_TEX_2D_ARRAY;
-            return;
-
-        case GL_IMAGE_CUBE_MAP_ARRAY:
-        case GL_INT_IMAGE_CUBE_MAP_ARRAY:
-        case GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY:
-            ResDim = RESOURCE_DIM_TEX_CUBE_ARRAY;
-            return;
-
-        case GL_IMAGE_2D_MULTISAMPLE:
-        case GL_INT_IMAGE_2D_MULTISAMPLE:
-        case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE:
-            ResDim = RESOURCE_DIM_TEX_2D;
-            IsMS   = true;
-            return;
-
-        case GL_IMAGE_2D_MULTISAMPLE_ARRAY:
-        case GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
-        case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
-            ResDim = RESOURCE_DIM_TEX_2D_ARRAY;
-            IsMS   = true;
-            return;
-#endif
-    }
-}
-
-} // namespace
-
 ShaderResourcesGL::ShaderResourcesGL(ShaderResourcesGL&& Program) noexcept :
     // clang-format off
     m_ShaderStages     {Program.m_ShaderStages         },
diff --git a/Graphics/GraphicsEngineOpenGL/src/ShaderVariableManagerGL.cpp b/Graphics/GraphicsEngineOpenGL/src/ShaderVariableManagerGL.cpp
index 29786c30..4294f2e8 100644
--- a/Graphics/GraphicsEngineOpenGL/src/ShaderVariableManagerGL.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/ShaderVariableManagerGL.cpp
@@ -39,12 +39,14 @@
 namespace Diligent
 {
 
-void ShaderVariableManagerGL::CountResources(const PipelineResourceSignatureGLImpl& Signature,
-                                             const SHADER_RESOURCE_VARIABLE_TYPE*   AllowedVarTypes,
-                                             Uint32                                 NumAllowedTypes,
-                                             const SHADER_TYPE                      ShaderType,
-                                             ResourceCounters&                      Counters)
+ShaderVariableManagerGL::ResourceCounters ShaderVariableManagerGL::CountResources(
+    const PipelineResourceSignatureGLImpl& Signature,
+    const SHADER_RESOURCE_VARIABLE_TYPE*   AllowedVarTypes,
+    Uint32                                 NumAllowedTypes,
+    const SHADER_TYPE                      ShaderType)
 {
+    ResourceCounters Counters;
+
     Signature.ProcessResources(
         AllowedVarTypes, NumAllowedTypes, ShaderType,
         [&](const PipelineResourceDesc& ResDesc, Uint32) //
@@ -65,6 +67,8 @@ void ShaderVariableManagerGL::CountResources(const PipelineResourceSignatureGLIm
                     UNEXPECTED("Unsupported resource type.");
             }
         });
+
+    return Counters;
 }
 
 size_t ShaderVariableManagerGL::GetRequiredMemorySize(const PipelineResourceSignatureGLImpl& Signature,
@@ -72,8 +76,7 @@ size_t ShaderVariableManagerGL::GetRequiredMemorySize(const PipelineResourceSign
                                                       Uint32                                 NumAllowedTypes,
                                                       SHADER_TYPE                            ShaderType)
 {
-    ResourceCounters Counters;
-    CountResources(Signature, AllowedVarTypes, NumAllowedTypes, ShaderType, Counters);
+    auto Counters = CountResources(Signature, AllowedVarTypes, NumAllowedTypes, ShaderType);
 
     // clang-format off
     size_t RequiredSize = Counters.NumUBs           * sizeof(UniformBuffBindInfo)   + 
@@ -94,8 +97,7 @@ void ShaderVariableManagerGL::Initialize(const PipelineResourceSignatureGLImpl&
     m_pDbgAllocator = &Allocator;
 #endif
 
-    ResourceCounters Counters;
-    CountResources(Signature, AllowedVarTypes, NumAllowedTypes, ShaderType, Counters);
+    auto Counters = CountResources(Signature, AllowedVarTypes, NumAllowedTypes, ShaderType);
 
     m_pSignature = &Signature;
 
@@ -215,7 +217,7 @@ void ShaderVariableManagerGL::UniformBuffBindInfo::BindResource(IDeviceObject* p
 
     // We cannot use ValidatedCast<> here as the resource retrieved from the
     // resource mapping can be of wrong type
-    RefCntAutoPtr<BufferGLImpl> pBuffGLImpl(pBuffer, IID_BufferGL);
+    RefCntAutoPtr<BufferGLImpl> pBuffGLImpl{pBuffer, IID_BufferGL};
 #ifdef DILIGENT_DEVELOPMENT
     {
         const auto& CachedUB = ResourceCache.GetConstUB(Attr.CacheOffset + ArrayIndex);
@@ -243,16 +245,16 @@ void ShaderVariableManagerGL::TextureBindInfo::BindResource(IDeviceObject* pView
         // resource mapping can be of wrong type
         RefCntAutoPtr<TextureViewGLImpl> pViewGL{pView, IID_TextureViewGL};
 
-        const auto ImmutableSamplerAssigned = m_ParentManager.m_pSignature->GetImmutableSamplerIdx(Attr) != InvalidImmutableSamplerIndex;
+        const auto ImmutableSamplerAssigned = (m_ParentManager.m_pSignature->GetImmutableSamplerIdx(Attr) != InvalidImmutableSamplerIndex);
 #ifdef DILIGENT_DEVELOPMENT
         {
-            auto& CachedTexSampler = ResourceCache.GetConstTexture(Attr.CacheOffset + ArrayIndex);
+            const auto& CachedTexSampler = ResourceCache.GetConstTexture(Attr.CacheOffset + ArrayIndex);
             VerifyResourceViewBinding(Desc.Name, Desc.ArraySize, Desc.VarType, ArrayIndex,
                                       pView, pViewGL.RawPtr(), {TEXTURE_VIEW_SHADER_RESOURCE},
                                       RESOURCE_DIM_UNDEFINED, false, CachedTexSampler.pView.RawPtr());
             if (ImmutableSamplerAssigned && ResourceCache.GetContentType() == ResourceCacheContentType::SRB)
             {
-                VERIFY(CachedTexSampler.pSampler != nullptr, "Immutable samplers must be initialized by PipelineResourceSignatureGLImpl::InitializeSRBResourceCache!");
+                VERIFY(CachedTexSampler.pSampler != nullptr, "Immutable samplers must be initialized in the SRB cache by PipelineResourceSignatureGLImpl::InitializeSRBResourceCache!");
             }
             if (Desc.ResourceType == SHADER_RESOURCE_TYPE_INPUT_ATTACHMENT)
             {
@@ -266,10 +268,10 @@ void ShaderVariableManagerGL::TextureBindInfo::BindResource(IDeviceObject* pView
     {
         // We cannot use ValidatedCast<> here as the resource retrieved from the
         // resource mapping can be of wrong type
-        RefCntAutoPtr<BufferViewGLImpl> pViewGL(pView, IID_BufferViewGL);
+        RefCntAutoPtr<BufferViewGLImpl> pViewGL{pView, IID_BufferViewGL};
 #ifdef DILIGENT_DEVELOPMENT
         {
-            auto& CachedBuffSampler = ResourceCache.GetConstTexture(Attr.CacheOffset + ArrayIndex);
+            const auto& CachedBuffSampler = ResourceCache.GetConstTexture(Attr.CacheOffset + ArrayIndex);
             VerifyResourceViewBinding(Desc.Name, Desc.ArraySize, Desc.VarType, ArrayIndex,
                                       pView, pViewGL.RawPtr(), {BUFFER_VIEW_SHADER_RESOURCE},
                                       RESOURCE_DIM_BUFFER, false, CachedBuffSampler.pView.RawPtr());
@@ -277,7 +279,7 @@ void ShaderVariableManagerGL::TextureBindInfo::BindResource(IDeviceObject* pView
             {
                 const auto& ViewDesc = pViewGL->GetDesc();
                 const auto& BuffDesc = pViewGL->GetBuffer()->GetDesc();
-                if (!((BuffDesc.Mode == BUFFER_MODE_FORMATTED && ViewDesc.Format.ValueType != VT_UNDEFINED) || BuffDesc.Mode == BUFFER_MODE_RAW))
+                if (!(BuffDesc.Mode == BUFFER_MODE_FORMATTED && ViewDesc.Format.ValueType != VT_UNDEFINED))
                 {
                     LOG_ERROR_MESSAGE("Error binding buffer view '", ViewDesc.Name, "' of buffer '", BuffDesc.Name, "' to shader variable '",
                                       Desc.Name, ": formatted buffer view is expected.");
@@ -307,10 +309,10 @@ void ShaderVariableManagerGL::ImageBindInfo::BindResource(IDeviceObject* pView,
     {
         // We cannot use ValidatedCast<> here as the resource retrieved from the
         // resource mapping can be of wrong type
-        RefCntAutoPtr<TextureViewGLImpl> pViewGL(pView, IID_TextureViewGL);
+        RefCntAutoPtr<TextureViewGLImpl> pViewGL{pView, IID_TextureViewGL};
 #ifdef DILIGENT_DEVELOPMENT
         {
-            auto& CachedUAV = ResourceCache.GetConstImage(Attr.CacheOffset + ArrayIndex);
+            const auto& CachedUAV = ResourceCache.GetConstImage(Attr.CacheOffset + ArrayIndex);
             VerifyResourceViewBinding(Desc.Name, Desc.ArraySize, Desc.VarType, ArrayIndex,
                                       pView, pViewGL.RawPtr(), {TEXTURE_VIEW_UNORDERED_ACCESS},
                                       RESOURCE_DIM_UNDEFINED, false, CachedUAV.pView.RawPtr());
@@ -322,7 +324,7 @@ void ShaderVariableManagerGL::ImageBindInfo::BindResource(IDeviceObject* pView,
     {
         // We cannot use ValidatedCast<> here as the resource retrieved from the
         // resource mapping can be of wrong type
-        RefCntAutoPtr<BufferViewGLImpl> pViewGL(pView, IID_BufferViewGL);
+        RefCntAutoPtr<BufferViewGLImpl> pViewGL{pView, IID_BufferViewGL};
 #ifdef DILIGENT_DEVELOPMENT
         {
             auto& CachedUAV = ResourceCache.GetConstImage(Attr.CacheOffset + ArrayIndex);
@@ -333,7 +335,7 @@ void ShaderVariableManagerGL::ImageBindInfo::BindResource(IDeviceObject* pView,
             {
                 const auto& ViewDesc = pViewGL->GetDesc();
                 const auto& BuffDesc = pViewGL->GetBuffer()->GetDesc();
-                if (!((BuffDesc.Mode == BUFFER_MODE_FORMATTED && ViewDesc.Format.ValueType != VT_UNDEFINED) || BuffDesc.Mode == BUFFER_MODE_RAW))
+                if (!(BuffDesc.Mode == BUFFER_MODE_FORMATTED && ViewDesc.Format.ValueType != VT_UNDEFINED))
                 {
                     LOG_ERROR_MESSAGE("Error binding buffer view '", ViewDesc.Name, "' of buffer '", BuffDesc.Name, "' to shader variable '",
                                       Desc.Name, ": formatted buffer view is expected.");
@@ -365,7 +367,7 @@ void ShaderVariableManagerGL::StorageBufferBindInfo::BindResource(IDeviceObject*
 
     // We cannot use ValidatedCast<> here as the resource retrieved from the
     // resource mapping can be of wrong type
-    RefCntAutoPtr<BufferViewGLImpl> pViewGL(pView, IID_BufferViewGL);
+    RefCntAutoPtr<BufferViewGLImpl> pViewGL{pView, IID_BufferViewGL};
 #ifdef DILIGENT_DEVELOPMENT
     {
         auto& CachedSSBO = ResourceCache.GetConstSSBO(Attr.CacheOffset + ArrayIndex);
@@ -448,11 +450,6 @@ IShaderResourceVariable* ShaderVariableManagerGL::GetVariable(const Char* Name)
     return nullptr;
 }
 
-Uint32 ShaderVariableManagerGL::GetVariableCount() const
-{
-    return GetNumUBs() + GetNumTextures() + GetNumImages() + GetNumStorageBuffers();
-}
-
 class ShaderVariableLocator
 {
 public:
diff --git a/Graphics/GraphicsEngineOpenGL/src/TextureViewGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/TextureViewGLImpl.cpp
index a95ccf35..f4199a20 100644
--- a/Graphics/GraphicsEngineOpenGL/src/TextureViewGLImpl.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/TextureViewGLImpl.cpp
@@ -64,26 +64,16 @@ IMPLEMENT_QUERY_INTERFACE(TextureViewGLImpl, IID_TextureViewGL, TTextureViewBase
 
 const GLObjectWrappers::GLTextureObj& TextureViewGLImpl::GetHandle()
 {
-    if (m_ViewTexGLHandle)
-        return m_ViewTexGLHandle;
-    else
-    {
-        auto* pTexture = GetTexture();
-        CHECK_DYNAMIC_TYPE(TextureBaseGL, pTexture);
-        return static_cast<TextureBaseGL*>(pTexture)->GetGLHandle();
-    }
+    return m_ViewTexGLHandle ?
+        m_ViewTexGLHandle :
+        GetTexture<TextureBaseGL>()->GetGLHandle();
 }
 
 GLenum TextureViewGLImpl::GetBindTarget()
 {
-    if (m_ViewTexGLHandle)
-        return m_ViewTexBindTarget;
-    else
-    {
-        auto* pTexture = GetTexture();
-        CHECK_DYNAMIC_TYPE(TextureBaseGL, pTexture);
-        return static_cast<TextureBaseGL*>(pTexture)->GetBindTarget();
-    }
+    return m_ViewTexGLHandle ?
+        m_ViewTexBindTarget :
+        GetTexture<TextureBaseGL>()->GetBindTarget();
 }
 
 } // namespace Diligent
diff --git a/Graphics/GraphicsEngineOpenGL/src/VAOCache.cpp b/Graphics/GraphicsEngineOpenGL/src/VAOCache.cpp
index 240b739b..a238aa9a 100644
--- a/Graphics/GraphicsEngineOpenGL/src/VAOCache.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/VAOCache.cpp
@@ -93,11 +93,11 @@ const GLObjectWrappers::GLVertexArrayObj& VAOCache::GetVAO(IPipelineState*
         VertexBuffers[s] = nullptr;
 
     // Get layout
-    auto*                pPSOGL         = ValidatedCast<PipelineStateGLImpl>(pPSO);
-    auto*                pIndexBufferGL = ValidatedCast<BufferGLImpl>(pIndexBuffer);
-    const auto&          InputLayout    = pPSOGL->GetGraphicsPipelineDesc().InputLayout;
-    const LayoutElement* LayoutElems    = InputLayout.LayoutElements;
-    Uint32               NumElems       = InputLayout.NumElements;
+    const auto* pPSOGL         = ValidatedCast<const PipelineStateGLImpl>(pPSO);
+    auto*       pIndexBufferGL = ValidatedCast<BufferGLImpl>(pIndexBuffer);
+    const auto& InputLayout    = pPSOGL->GetGraphicsPipelineDesc().InputLayout;
+    const auto* LayoutElems    = InputLayout.LayoutElements;
+    const auto  NumElems       = InputLayout.NumElements;
     // Construct the key
     VAOCacheKey Key(pPSOGL->GetUniqueID(), pIndexBufferGL ? pIndexBufferGL->GetUniqueID() : 0);