Got rid of separate cache for GL base instance values

Author: Crisspl

src/nbl/video/COpenGLRenderpassIndependentPipeline.h

@@ -36,8 +36,7 @@ class COpenGLRenderpassIndependentPipeline final : public IGPURenderpassIndepend
             _vertexInputParams, _blendParams, _primAsmParams, _rasterParams
             ),
             IOpenGLPipeline(_ctxCount, _ctxID, _GLnames, _binaries),
-            m_stagePresenceMask(0u),
-            m_baseInstanceUniformIDs(core::make_refctd_dynamic_array<decltype(m_baseInstanceUniformIDs)>(_ctxCount))
+            m_stagePresenceMask(0u)
         {
             static_assert(asset::SVertexInputParams::MAX_ATTR_BUF_BINDING_COUNT == asset::SVertexInputParams::MAX_VERTEX_ATTRIB_COUNT, "This code below has to be divided into 2 loops");
             static_assert(asset::EF_UNKNOWN <= 0xffu, "All E_FORMAT values must fit in 1 byte or hash falls apart");
@@ -71,12 +70,12 @@ class COpenGLRenderpassIndependentPipeline final : public IGPURenderpassIndepend
             // only this function touches this uniform
             constexpr const char* SPIRV_CROSS_BaseInstanceUniformName = "SPIRV_Cross_BaseInstance";
 
-            GLint& value = (*m_baseInstanceUniformIDs)[_ctxID].cache;
+            GLint& value = getBaseInstanceState(_ctxID)->cache;
             if (value == _baseInstance)
                 return;
 
             const GLuint programID = getShaderGLnameForCtx(ESSI_VERTEX_SHADER_IX, _ctxID);
-            GLint& uid = (*m_baseInstanceUniformIDs)[_ctxID].id;
+            GLint& uid = getBaseInstanceState(_ctxID)->id;
             if (uid == -1)
             {
                 uid = COpenGLExtensionHandler::extGlGetUniformLocation(programID, SPIRV_CROSS_BaseInstanceUniformName);
@@ -315,16 +314,6 @@ class COpenGLRenderpassIndependentPipeline final : public IGPURenderpassIndepend
         SVAOHash m_vaoHashval;
         uint32_t m_stagePresenceMask;
         mutable uint32_t m_lastUpdateStamp[SHADER_STAGE_COUNT];
-
-        // needed for spirv-cross-based workaround of GL's behaviour of gl_InstanceID
-        struct SBaseInstance
-        {
-            GLint cache = 0;
-            GLint id = -1;
-        };
-        // per-context ID of SPIRV_Cross_BaseInstance uniform
-        // (only present in case of absence of GL_ARB_shader_draw_parameters)
-        mutable core::smart_refctd_dynamic_array<SBaseInstance> m_baseInstanceUniformIDs;
 };
 
 }

src/nbl/video/IOpenGLPipeline.h

@@ -17,6 +17,34 @@ namespace video
 template<size_t _STAGE_COUNT>
 class IOpenGLPipeline
 {
+    protected:
+        // needed for spirv-cross-based workaround of GL's behaviour of gl_InstanceID
+        struct SBaseInstance
+        {
+            GLint cache = 0;
+            GLint id = -1;
+        };
+
+    private:
+        using base_instance_cache_t = SBaseInstance;
+
+        _NBL_STATIC_INLINE_CONSTEXPR bool       IsComputePipelineBase =             (_STAGE_COUNT == 1u);
+        _NBL_STATIC_INLINE_CONSTEXPR uint32_t   BaseInstancePerContextCacheSize =   IsComputePipelineBase ? 0ull : sizeof(base_instance_cache_t);
+        _NBL_STATIC_INLINE_CONSTEXPR uint32_t   UniformsPerContextCacheSize =       _STAGE_COUNT*IGPUMeshBuffer::MAX_PUSH_CONSTANT_BYTESIZE + BaseInstancePerContextCacheSize;
+
+        static uint32_t baseInstanceCacheByteoffsetForCtx(uint32_t _ctxId)
+        {
+            return UniformsPerContextCacheSize*_ctxId;
+        }
+        static uint32_t uniformsCacheByteoffsetForCtx(uint32_t _ctxId)
+        {
+            return baseInstanceCacheByteoffsetForCtx(_ctxId) + BaseInstancePerContextCacheSize;
+        }
+        static uint32_t uniformsCacheByteoffsetForCtxAndStage(uint32_t _ctxId, uint32_t _stage)
+        {
+            return uniformsCacheByteoffsetForCtx(_ctxId) + _stage*IGPUMeshBuffer::MAX_PUSH_CONSTANT_BYTESIZE;
+        }
+
     public:
         IOpenGLPipeline(uint32_t _ctxCount, uint32_t _ctxID, const GLuint _GLnames[_STAGE_COUNT], const COpenGLSpecializedShader::SProgramBinary _binaries[_STAGE_COUNT]) : 
             m_GLprograms(core::make_refctd_dynamic_array<decltype(m_GLprograms)>(_ctxCount*_STAGE_COUNT))
@@ -34,8 +62,10 @@ class IOpenGLPipeline
                     (*m_GLprograms)[i*_STAGE_COUNT+j].GLname = GLname;
                 }
 
-            const size_t uVals_sz = _STAGE_COUNT*_ctxCount*IGPUMeshBuffer::MAX_PUSH_CONSTANT_BYTESIZE;
+            const size_t uVals_sz = UniformsPerContextCacheSize * _ctxCount;
             m_uniformValues = reinterpret_cast<uint8_t*>(_NBL_ALIGNED_MALLOC(uVals_sz, 128));
+            for (uint32_t i = 0u; i < _ctxCount; ++i)
+                getBaseInstanceState(i)[0] = base_instance_cache_t{};
         }
         ~IOpenGLPipeline()
         {
@@ -46,7 +76,8 @@ class IOpenGLPipeline
             _NBL_ALIGNED_FREE(m_uniformValues);
         }
 
-        uint8_t* getPushConstantsStateForStage(uint32_t _stageIx, uint32_t _ctxID) const { return const_cast<uint8_t*>(m_uniformValues + ((_STAGE_COUNT*_ctxID + _stageIx)*IGPUMeshBuffer::MAX_PUSH_CONSTANT_BYTESIZE)); }
+        uint8_t* getPushConstantsStateForStage(uint32_t _stageIx, uint32_t _ctxID) const { return const_cast<uint8_t*>(m_uniformValues + uniformsCacheByteoffsetForCtxAndStage(_ctxID, _stageIx)); }
+        base_instance_cache_t* getBaseInstanceState(uint32_t _ctxID) const { return const_cast<base_instance_cache_t*>(m_uniformValues + baseInstanceCacheByteoffsetForCtx(_ctxID)); }
 
     protected:
         void setUniformsImitatingPushConstants(uint32_t _stageIx, uint32_t _ctxID, const uint8_t* _pcData, const core::SRange<const COpenGLSpecializedShader::SUniform>& _uniforms, const core::SRange<const GLint>& _locations) const
@@ -80,6 +111,7 @@ class IOpenGLPipeline
                 {
                     // 1N for scalar types, 2N for gvec2, 4N for gvec3 and gvec4
                     // N==sizeof(float)
+                    // WARNING / TODO : need some touch in case when we want to support `double` push constants
                     if (is_scalar_or_vec())
                         arrayStride = (m.mtxRowCnt==1u) ? m.size : core::roundUpToPoT(m.mtxRowCnt)*sizeof(float);
                     // same as size in case of matrices