compatability_cast and OpenGL Device Object casts

Erfan-Ahmadi · Erfan-Ahmadi · commit cb0fb231b1cb · 2022-02-02T19:56:00.000+03:30
diff --git a/include/nbl/video/decl/IBackendObject.h b/include/nbl/video/decl/IBackendObject.h
@@ -23,23 +23,27 @@ class IBackendObject
         bool isCompatibleDevicewise(const IBackendObject* other) const;
 
         bool wasCreatedBy(const ILogicalDevice* device) const;
-        
+
+        // returns nullptr if `base` is not compatible with device
         template<typename derived_t_ptr, typename base_t_ptr>
-        static inline derived_t_ptr cast(base_t_ptr base, const ILogicalDevice* device)
+        static inline derived_t_ptr device_compatibility_cast(base_t_ptr base, const ILogicalDevice* device)
         {
             using base_t = std::remove_pointer_t<base_t_ptr>;
             using derived_t = std::remove_pointer_t<derived_t_ptr>;
             static_assert(std::is_base_of_v<IBackendObject, base_t>,"base_t should be derived from IBackendObject");
             static_assert(std::is_base_of_v<base_t,derived_t>,"derived_t should be derived from base_t");
-            if (!base->wasCreatedBy(device))
+            if (base && !base->wasCreatedBy(device))
                 return nullptr;
             return static_cast<derived_t_ptr>(base);
         }
         
+        // returns nullptr if `base` is not compatible with `other`
         template<typename derived_t_ptr, typename base_t_ptr, typename other_t_ptr>
-        static inline derived_t_ptr cast(base_t_ptr base, const other_t_ptr& compatibleWith)
+        static inline derived_t_ptr compatibility_cast(base_t_ptr base, const other_t_ptr& compatibleWith)
         {
-          return cast<derived_t_ptr,base_t_ptr>(base,compatibleWith->getOriginDevice());
+            using other_t = std::remove_pointer_t<other_t_ptr>;
+            static_assert(std::is_base_of_v<IBackendObject, other_t>,"other_t_ptr should be derived from IBackendObject");
+            return device_compatibility_cast<derived_t_ptr,base_t_ptr>(base,compatibleWith->getOriginDevice());
         }
 
         const ILogicalDevice* getOriginDevice() const;
diff --git a/src/nbl/video/COpenGLBufferView.h b/src/nbl/video/COpenGLBufferView.h
@@ -27,9 +27,9 @@ class COpenGLBufferView : public IGPUBufferView
 			m_GLformat = getSizedOpenGLFormatFromOurFormat(gl, m_format);
 
 			if (m_offset==0u && m_size==m_buffer->getSize())
-				gl->extGlTextureBuffer(m_textureName, m_GLformat, static_cast<COpenGLBuffer*>(m_buffer.get())->getOpenGLName());
+				gl->extGlTextureBuffer(m_textureName, m_GLformat, IBackendObject::compatibility_cast<COpenGLBuffer*>(m_buffer.get(), this)->getOpenGLName());
 			else
-				gl->extGlTextureBufferRange(m_textureName, m_GLformat, static_cast<COpenGLBuffer*>(m_buffer.get())->getOpenGLName(), m_offset, m_size);
+				gl->extGlTextureBufferRange(m_textureName, m_GLformat, IBackendObject::compatibility_cast<COpenGLBuffer*>(m_buffer.get(), this)->getOpenGLName(), m_offset, m_size);
 
 			m_textureSize = m_size / asset::getTexelOrBlockBytesize(m_format);
 		}
diff --git a/src/nbl/video/COpenGLCommandBuffer.h b/src/nbl/video/COpenGLCommandBuffer.h
@@ -1199,7 +1199,7 @@ class COpenGLCommandBuffer final : public IGPUCommandBuffer
             if (pDescriptorSets[i])
             {
                 cmd.descriptorSets[cmd.dsCount++] = core::smart_refctd_ptr<const IGPUDescriptorSet>(pDescriptorSets[i]);
-                const auto count = static_cast<const COpenGLDescriptorSet*>(pDescriptorSets[i])->getDynamicOffsetCount();
+                const auto count = IBackendObject::compatibility_cast<const COpenGLDescriptorSet*>(pDescriptorSets[i], this)->getDynamicOffsetCount();
                 std::copy_n(dynamicOffsetsIt,count,cmd.dynamicOffsets+cmd.dynamicOffsetCount);
                 cmd.dynamicOffsetCount += count;
                 dynamicOffsetsIt += count;
diff --git a/src/nbl/video/COpenGLComputePipeline.h b/src/nbl/video/COpenGLComputePipeline.h
@@ -59,8 +59,8 @@ class COpenGLComputePipeline : public IGPUComputePipeline, public IOpenGLPipelin
             uint32_t stampValue = _pcState.getStamp(IGPUShader::ESS_COMPUTE);
             if (stampValue>m_lastUpdateStamp)
             {
-                auto uniforms = static_cast<COpenGLSpecializedShader*>(m_shader.get())->getUniforms();
-                auto locations = static_cast<COpenGLSpecializedShader*>(m_shader.get())->getLocations();
+                auto uniforms = IBackendObject::compatibility_cast<COpenGLSpecializedShader*>(m_shader.get(), this)->getUniforms();
+                auto locations = IBackendObject::compatibility_cast<COpenGLSpecializedShader*>(m_shader.get(), this)->getLocations();
                 if (uniforms.size())
                     IOpenGLPipeline<1>::setUniformsImitatingPushConstants(gl, 0u, _ctxID, _pcState.data, uniforms, locations);
                 m_lastUpdateStamp = stampValue;
diff --git a/src/nbl/video/COpenGLFramebuffer.h b/src/nbl/video/COpenGLFramebuffer.h
@@ -165,7 +165,7 @@ class COpenGLFramebuffer final : public IGPUFramebuffer
                 const auto& att = attachments[a];
                 const auto& d = descriptions[a];
 
-                auto* glatt = static_cast<COpenGLImageView*>(att.get());
+                auto* glatt = IBackendObject::compatibility_cast<COpenGLImageView*>(att.get(), this);
                 const GLuint glname = glatt->getOpenGLName();
                 //gl->glTexture.pglBindTexture(GL_TEXTURE_2D, glname); // what was it for???
                 const GLenum textarget = COpenGLImageView::ViewTypeToGLenumTarget[glatt->getCreationParameters().viewType];
@@ -179,7 +179,7 @@ class COpenGLFramebuffer final : public IGPUFramebuffer
         if (sub.depthStencilAttachment)
         {
             const auto& att = attachments[sub.depthStencilAttachment->attachment];
-            auto* glatt = static_cast<COpenGLImageView*>(att.get());
+            auto* glatt = IBackendObject::compatibility_cast<COpenGLImageView*>(att.get(), this);
             const GLuint glname = glatt->getOpenGLName();
             const GLenum textarget = COpenGLImageView::ViewTypeToGLenumTarget[glatt->getCreationParameters().viewType];
 
diff --git a/src/nbl/video/COpenGLImageView.h b/src/nbl/video/COpenGLImageView.h
@@ -58,7 +58,7 @@ class COpenGLImageView final : public IGPUImageView
 			//GL_INVALID_OPERATION is generated if texture has already been bound or otherwise given a target.
 			//thus we cannot create a name for view with glCreateTextures
 			gl->glTexture.pglGenTextures(1, &name);
-			gl->extGlTextureView(	name, target, static_cast<COpenGLImage*>(params.image.get())->getOpenGLName(), internalFormat, 
+			gl->extGlTextureView(	name, target, IBackendObject::compatibility_cast<COpenGLImage*>(params.image.get(), this)->getOpenGLName(), internalFormat, 
 														params.subresourceRange.baseMipLevel, params.subresourceRange.levelCount,
 														params.subresourceRange.baseArrayLayer, params.subresourceRange.layerCount);
 
diff --git a/src/nbl/video/COpenGLPipelineCache.h b/src/nbl/video/COpenGLPipelineCache.h
@@ -41,11 +41,11 @@ class COpenGLPipelineCache final : public IGPUPipelineCache
 		for (uint32_t i = 0u; i < _count; ++i)
 		{
 			{
-				const auto& src = static_cast<const COpenGLPipelineCache*>(_srcCaches[i])->m_cache;
+				const auto& src = IBackendObject::compatibility_cast<const COpenGLPipelineCache*>(_srcCaches[i], this)->m_cache;
 				m_cache.insert(src.begin(), src.end());
 			}
 			{
-				const auto& src = static_cast<const COpenGLPipelineCache*>(_srcCaches[i])->m_parsedSpirvs;
+				const auto& src = IBackendObject::compatibility_cast<const COpenGLPipelineCache*>(_srcCaches[i], this)->m_parsedSpirvs;
 				m_parsedSpirvs.insert(src.begin(), src.end());
 			}
 		}
diff --git a/src/nbl/video/COpenGLRenderpassIndependentPipeline.h b/src/nbl/video/COpenGLRenderpassIndependentPipeline.h
@@ -133,8 +133,8 @@ class COpenGLRenderpassIndependentPipeline final : public IGPURenderpassIndepend
                 uint32_t stampValue = _pcState.getStamp(stage);
                 if (stampValue>m_lastUpdateStamp[i])
                 {
-                    auto uniforms = static_cast<COpenGLSpecializedShader*>(m_shaders[i].get())->getUniforms();
-                    auto locations = static_cast<COpenGLSpecializedShader*>(m_shaders[i].get())->getLocations();
+                    auto uniforms = IBackendObject::compatibility_cast<COpenGLSpecializedShader*>(m_shaders[i].get(), this)->getUniforms();
+                    auto locations = IBackendObject::compatibility_cast<COpenGLSpecializedShader*>(m_shaders[i].get(), this)->getLocations();
                     if (uniforms.size())
                         IOpenGLPipeline<SHADER_STAGE_COUNT>::setUniformsImitatingPushConstants(gl, i, _ctxID, _pcState.data, uniforms, locations);
                     m_lastUpdateStamp[i] = stampValue;
diff --git a/src/nbl/video/COpenGL_LogicalDevice.h b/src/nbl/video/COpenGL_LogicalDevice.h
@@ -302,7 +302,7 @@ class COpenGL_LogicalDevice : public IOpenGL_LogicalDevice
     bool resetFences(uint32_t _count, IGPUFence*const * _fences) override final
     {
         for (uint32_t i = 0u; i < _count; ++i)
-            static_cast<COpenGLFence*>(_fences[i])->reset();
+            IBackendObject::device_compatibility_cast<COpenGLFence*>(_fences[i], this)->reset();
         return true;
     }
 
@@ -570,7 +570,7 @@ class COpenGL_LogicalDevice : public IOpenGL_LogicalDevice
     }
     core::smart_refctd_ptr<IGPUSpecializedShader> createGPUSpecializedShader_impl(const IGPUShader* _unspecialized, const asset::ISpecializedShader::SInfo& _specInfo, const asset::ISPIRVOptimizer* _spvopt = nullptr) override final
     {
-        const COpenGLShader* glUnspec = static_cast<const COpenGLShader*>(_unspecialized);
+        const COpenGLShader* glUnspec = IBackendObject::device_compatibility_cast<const COpenGLShader*>(_unspecialized, this);
 
         const std::string& EP = _specInfo.entryPoint;
         const asset::IShader::E_SHADER_STAGE stage = _unspecialized->getStage();
diff --git a/src/nbl/video/COpenGL_Queue.h b/src/nbl/video/COpenGL_Queue.h
@@ -210,7 +210,7 @@ class COpenGL_Queue final : public IGPUQueue
                     for (uint32_t i = 0; i < submit.waitSemaphoreCount; ++i)
                     {
                         IGPUSemaphore* sem = submit.pWaitSemaphores[i].get();
-                        COpenGLSemaphore* glsem = static_cast<COpenGLSemaphore*>(sem);
+                        COpenGLSemaphore* glsem = IBackendObject::device_compatibility_cast<COpenGLSemaphore*>(sem, m_device);
                         glsem->wait(&gl);
                     }
                     
@@ -231,7 +231,7 @@ class COpenGL_Queue final : public IGPUQueue
                         // also: we can limit flushing to bindings (especially buffers and textures): vertex, index, SSBO, UBO, indirect, ...
                         ctxlocal.flushStateGraphics(&gl, SOpenGLContextLocalCache::GSB_ALL, m_ctxid);
                         ctxlocal.flushStateCompute(&gl, SOpenGLContextLocalCache::GSB_ALL, m_ctxid);
-                        auto* cmdbuf = static_cast<COpenGLCommandBuffer*>(submit.commandBuffers[i].get());
+                        auto* cmdbuf = IBackendObject::device_compatibility_cast<COpenGLCommandBuffer*>(submit.commandBuffers[i].get(), m_device);
                         cmdbuf->executeAll(&gl, &_state.ctxlocal, m_ctxid);
                     }
 
@@ -341,7 +341,7 @@ class COpenGL_Queue final : public IGPUQueue
                 params.commandBufferCount = submit.commandBufferCount;
                 for (uint32_t i = 0u; i < submit.signalSemaphoreCount; ++i)
                 {
-                    COpenGLSemaphore* sem = static_cast<COpenGLSemaphore*>(submit.pSignalSemaphores[i]);
+                    COpenGLSemaphore* sem = IBackendObject::device_compatibility_cast<COpenGLSemaphore*>(submit.pSignalSemaphores[i], m_originDevice);
                     sem->associateGLSync(core::smart_refctd_ptr(sync));
                 }
                 core::smart_refctd_ptr<IGPUSemaphore>* waitSems = nullptr;
@@ -382,7 +382,7 @@ class COpenGL_Queue final : public IGPUQueue
 
             if (_fence)
             {
-                COpenGLFence* glfence = static_cast<COpenGLFence*>(_fence);
+                COpenGLFence* glfence = IBackendObject::device_compatibility_cast<COpenGLFence*>(_fence, m_originDevice);
                 glfence->associateGLSync(std::move(sync)); // associate sync used for signal semaphores in last submit
             }
             
diff --git a/src/nbl/video/COpenGL_Swapchain.h b/src/nbl/video/COpenGL_Swapchain.h
@@ -78,9 +78,11 @@ class COpenGL_Swapchain final : public ISwapchain
 
     E_ACQUIRE_IMAGE_RESULT acquireNextImage(uint64_t timeout, IGPUSemaphore* semaphore, IGPUFence* fence, uint32_t* out_imgIx) override
     {
-        if (semaphore && !this->isCompatibleDevicewise(semaphore))
+        COpenGLSemaphore* glSem = IBackendObject::compatibility_cast<COpenGLSemaphore*>(semaphore, this);
+        COpenGLFence* glFen = IBackendObject::compatibility_cast<COpenGLFence*>(fence, this);
+        if (semaphore && !glSem)
             return EAIR_ERROR;
-        if (fence && this->isCompatibleDevicewise(fence))
+        if (fence && !glFen)
             return EAIR_ERROR;
 
         // TODO currently completely ignoring `timeout`
@@ -91,16 +93,10 @@ class COpenGL_Swapchain final : public ISwapchain
         if (semaphore || fence)
         {
             core::smart_refctd_ptr<COpenGLSync> sync = m_threadHandler.getSyncForImgIx(m_imgIx);
-            if (semaphore)
-            {
-                COpenGLSemaphore* sem = static_cast<COpenGLSemaphore*>(semaphore);
-                sem->associateGLSync(core::smart_refctd_ptr(sync));
-            }
-            if (fence)
-            {
-                COpenGLFence* fen = static_cast<COpenGLFence*>(fence);
-                fen->associateGLSync(core::smart_refctd_ptr(sync));
-            }
+            if (glSem)
+                glSem->associateGLSync(core::smart_refctd_ptr(sync));
+            if (glFen)
+                glFen->associateGLSync(core::smart_refctd_ptr(sync));
         }
 
         assert(out_imgIx);
@@ -185,7 +181,7 @@ class COpenGL_Swapchain final : public ISwapchain
                 request.sems.reserve(semCount);
             for (uint32_t i = 0u; i < semCount; ++i)
             {
-                COpenGLSemaphore* sem = static_cast<COpenGLSemaphore*>(sems[i]);
+                COpenGLSemaphore* sem = IBackendObject::device_compatibility_cast<COpenGLSemaphore*>(sems[i], m_device);
                 request.sems.push_back(core::smart_refctd_ptr<COpenGLSemaphore>(sem));
             }
         }
@@ -230,8 +226,8 @@ class COpenGL_Swapchain final : public ISwapchain
             {
                 auto& img = images.begin()[i];
                 GLuint texture = m_texViews[i];
-                GLuint origtexture = static_cast<COpenGLImage*>(img.get())->getOpenGLName();
-                GLenum format = static_cast<COpenGLImage*>(img.get())->getOpenGLSizedFormat();
+                GLuint origtexture = IBackendObject::device_compatibility_cast<COpenGLImage*>(img.get(), m_device)->getOpenGLName();
+                GLenum format = IBackendObject::device_compatibility_cast<COpenGLImage*>(img.get(), m_device)->getOpenGLSizedFormat();
                 static_cast<IOpenGL_FunctionTable&>(gl).extGlTextureView(texture, GL_TEXTURE_2D, origtexture, format, 0, 1, 0, 1);
             }
             
diff --git a/src/nbl/video/IOpenGL_LogicalDevice.h b/src/nbl/video/IOpenGL_LogicalDevice.h
@@ -668,7 +668,7 @@ class IOpenGL_LogicalDevice : public ILogicalDevice, protected impl::IOpenGL_Log
             case ERT_GET_QUERY_POOL_RESULTS:
             {
                 auto& p = std::get<SRequestGetQueryPoolResults>(req.params_variant);
-                const COpenGLQueryPool* qp = static_cast<const COpenGLQueryPool*>(p.queryPool.get());
+                const COpenGLQueryPool* qp = IBackendObject::device_compatibility_cast<const COpenGLQueryPool*>(p.queryPool.get(), device);
                 auto queryPoolQueriesCount = qp->getCreationParameters().queryCount;
                 auto queriesRange = qp->getQueries(); // queriesRange.size() is a multiple of queryPoolQueriesCount
                 auto queries = queriesRange.begin();
@@ -743,7 +743,7 @@ class IOpenGL_LogicalDevice : public ILogicalDevice, protected impl::IOpenGL_Log
             case ERT_GET_FENCE_STATUS:
             {
                 auto& p = std::get<SRequestGetFenceStatus>(req.params_variant);
-                auto* glfence = static_cast<COpenGLFence*>(p.fence);
+                auto* glfence = IBackendObject::device_compatibility_cast<COpenGLFence*>(p.fence, device);
                 IGPUFence::E_STATUS* retval = reinterpret_cast<IGPUFence::E_STATUS*>(req.pretval);
 
                 retval[0] = glfence->getStatus(&gl);
@@ -849,11 +849,11 @@ class IOpenGL_LogicalDevice : public ILogicalDevice, protected impl::IOpenGL_Log
                 needClipControlWorkaround = !gl.getFeatures()->isFeatureAvailable(COpenGLFeatureMap::NBL_EXT_clip_control);
             }
 
-            COpenGLPipelineCache* cache = static_cast<COpenGLPipelineCache*>(_pipelineCache);
-            COpenGLPipelineLayout* gllayout = static_cast<COpenGLPipelineLayout*>(layout.get());
+            COpenGLPipelineCache* cache = IBackendObject::device_compatibility_cast<COpenGLPipelineCache*>(_pipelineCache, device);
+            COpenGLPipelineLayout* gllayout = IBackendObject::device_compatibility_cast<COpenGLPipelineLayout*>(layout.get(), device);
             for (auto shdr = shaders.begin(); shdr != shaders.end(); ++shdr)
             {
-                const auto* glshdr = static_cast<const COpenGLSpecializedShader*>(*shdr);
+                const auto* glshdr = IBackendObject::device_compatibility_cast<const COpenGLSpecializedShader*>(*shdr, device);
 
                 auto stage = glshdr->getStage();
                 uint32_t ix = core::findLSB<uint32_t>(stage);

Original file line number	Diff line number	Diff line change
`@@ -1199,7 +1199,7 @@ class COpenGLCommandBuffer final : public IGPUCommandBuffer`
`1199`	`1199`	`if (pDescriptorSets[i])`
`1200`	`1200`	`{`
`1201`	`1201`	`cmd.descriptorSets[cmd.dsCount++] = core::smart_refctd_ptr<const IGPUDescriptorSet>(pDescriptorSets[i]);`
`1202`		`- const auto count = static_cast<const COpenGLDescriptorSet*>(pDescriptorSets[i])->getDynamicOffsetCount();`
	`1202`	`+ const auto count = IBackendObject::compatibility_cast<const COpenGLDescriptorSet*>(pDescriptorSets[i], this)->getDynamicOffsetCount();`
`1203`	`1203`	`std::copy_n(dynamicOffsetsIt,count,cmd.dynamicOffsets+cmd.dynamicOffsetCount);`
`1204`	`1204`	`cmd.dynamicOffsetCount += count;`
`1205`	`1205`	`dynamicOffsetsIt += count;`
Original file line number	Diff line number	Diff line change
`@@ -41,11 +41,11 @@ class COpenGLPipelineCache final : public IGPUPipelineCache`
`41`	`41`	`for (uint32_t i = 0u; i < _count; ++i)`
`42`	`42`	`{`
`43`	`43`	`{`
`44`		`- const auto& src = static_cast<const COpenGLPipelineCache*>(_srcCaches[i])->m_cache;`
	`44`	`+ const auto& src = IBackendObject::compatibility_cast<const COpenGLPipelineCache*>(_srcCaches[i], this)->m_cache;`
`45`	`45`	`m_cache.insert(src.begin(), src.end());`
`46`	`46`	`}`
`47`	`47`	`{`
`48`		`- const auto& src = static_cast<const COpenGLPipelineCache*>(_srcCaches[i])->m_parsedSpirvs;`
	`48`	`+ const auto& src = IBackendObject::compatibility_cast<const COpenGLPipelineCache*>(_srcCaches[i], this)->m_parsedSpirvs;`
`49`	`49`	`m_parsedSpirvs.insert(src.begin(), src.end());`
`50`	`50`	`}`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -302,7 +302,7 @@ class COpenGL_LogicalDevice : public IOpenGL_LogicalDevice`
`302`	`302`	`bool resetFences(uint32_t _count, IGPUFenceconst _fences) override final`
`303`	`303`	`{`
`304`	`304`	`for (uint32_t i = 0u; i < _count; ++i)`
`305`		`- static_cast<COpenGLFence*>(_fences[i])->reset();`
	`305`	`+ IBackendObject::device_compatibility_cast<COpenGLFence*>(_fences[i], this)->reset();`
`306`	`306`	`return true;`
`307`	`307`	`}`
`308`	`308`
`@@ -570,7 +570,7 @@ class COpenGL_LogicalDevice : public IOpenGL_LogicalDevice`
`570`	`570`	`}`
`571`	`571`	`core::smart_refctd_ptr<IGPUSpecializedShader> createGPUSpecializedShader_impl(const IGPUShader* _unspecialized, const asset::ISpecializedShader::SInfo& _specInfo, const asset::ISPIRVOptimizer* _spvopt = nullptr) override final`
`572`	`572`	`{`
`573`		`- const COpenGLShader* glUnspec = static_cast<const COpenGLShader*>(_unspecialized);`
	`573`	`+ const COpenGLShader* glUnspec = IBackendObject::device_compatibility_cast<const COpenGLShader*>(_unspecialized, this);`
`574`	`574`
`575`	`575`	`const std::string& EP = _specInfo.entryPoint;`
`576`	`576`	`const asset::IShader::E_SHADER_STAGE stage = _unspecialized->getStage();`
Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,7 @@ class COpenGL_Queue final : public IGPUQueue`
`210`	`210`	`for (uint32_t i = 0; i < submit.waitSemaphoreCount; ++i)`
`211`	`211`	`{`
`212`	`212`	`IGPUSemaphore* sem = submit.pWaitSemaphores[i].get();`
`213`		`- COpenGLSemaphore* glsem = static_cast<COpenGLSemaphore*>(sem);`
	`213`	`+ COpenGLSemaphore* glsem = IBackendObject::device_compatibility_cast<COpenGLSemaphore*>(sem, m_device);`
`214`	`214`	`glsem->wait(&gl);`
`215`	`215`	`}`
`216`	`216`
`@@ -231,7 +231,7 @@ class COpenGL_Queue final : public IGPUQueue`
`231`	`231`	`// also: we can limit flushing to bindings (especially buffers and textures): vertex, index, SSBO, UBO, indirect, ...`
`232`	`232`	`ctxlocal.flushStateGraphics(&gl, SOpenGLContextLocalCache::GSB_ALL, m_ctxid);`
`233`	`233`	`ctxlocal.flushStateCompute(&gl, SOpenGLContextLocalCache::GSB_ALL, m_ctxid);`
`234`		`- auto* cmdbuf = static_cast<COpenGLCommandBuffer*>(submit.commandBuffers[i].get());`
	`234`	`+ auto* cmdbuf = IBackendObject::device_compatibility_cast<COpenGLCommandBuffer*>(submit.commandBuffers[i].get(), m_device);`
`235`	`235`	`cmdbuf->executeAll(&gl, &_state.ctxlocal, m_ctxid);`
`236`	`236`	`}`
`237`	`237`
`@@ -341,7 +341,7 @@ class COpenGL_Queue final : public IGPUQueue`
`341`	`341`	`params.commandBufferCount = submit.commandBufferCount;`
`342`	`342`	`for (uint32_t i = 0u; i < submit.signalSemaphoreCount; ++i)`
`343`	`343`	`{`
`344`		`- COpenGLSemaphore* sem = static_cast<COpenGLSemaphore*>(submit.pSignalSemaphores[i]);`
	`344`	`+ COpenGLSemaphore* sem = IBackendObject::device_compatibility_cast<COpenGLSemaphore*>(submit.pSignalSemaphores[i], m_originDevice);`
`345`	`345`	`sem->associateGLSync(core::smart_refctd_ptr(sync));`
`346`	`346`	`}`
`347`	`347`	`core::smart_refctd_ptr<IGPUSemaphore>* waitSems = nullptr;`
`@@ -382,7 +382,7 @@ class COpenGL_Queue final : public IGPUQueue`
`382`	`382`
`383`	`383`	`if (_fence)`
`384`	`384`	`{`
`385`		`- COpenGLFence* glfence = static_cast<COpenGLFence*>(_fence);`
	`385`	`+ COpenGLFence* glfence = IBackendObject::device_compatibility_cast<COpenGLFence*>(_fence, m_originDevice);`
`386`	`386`	`glfence->associateGLSync(std::move(sync)); // associate sync used for signal semaphores in last submit`
`387`	`387`	`}`
`388`	`388`