X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fgraphics%2Fgles-impl%2Fegl-graphics-controller.h;h=ec6c894c34857ab682f5ff68c7ea92a04399b72f;hb=refs%2Ftags%2Fsubmit%2Ftizen%2F20220503.090411;hp=6d84995dbe49651e8f025afc52f774d8cdc424ad;hpb=2799cdcc2768a59f3001f3a0e89da960ccbb74a2;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/dali/internal/graphics/gles-impl/egl-graphics-controller.h b/dali/internal/graphics/gles-impl/egl-graphics-controller.h index 6d84995..ec6c894 100644 --- a/dali/internal/graphics/gles-impl/egl-graphics-controller.h +++ b/dali/internal/graphics/gles-impl/egl-graphics-controller.h @@ -22,26 +22,26 @@ #include // INTERNAL INCLUDES +#include #include -#include "gles-context.h" -#include "gles-graphics-buffer.h" -#include "gles-graphics-command-buffer.h" -#include "gles-graphics-framebuffer.h" -#include "gles-graphics-pipeline-cache.h" -#include "gles-graphics-pipeline.h" -#include "gles-graphics-reflection.h" -#include "gles-graphics-sampler.h" -#include "gles-graphics-shader.h" -#include "gles-graphics-texture.h" -#include "gles-graphics-types.h" -#include "gles2-graphics-memory.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include namespace Dali { namespace Integration { class GlAbstraction; -class GlSyncAbstraction; class GlContextHelperAbstraction; } // namespace Integration @@ -81,13 +81,13 @@ public: * * Note, this is now executed in the render thread, after core initialization */ - void Initialize(Integration::GlSyncAbstraction& glSyncAbstraction, + void Initialize(Integration::GraphicsSyncAbstraction& syncImplementation, Integration::GlContextHelperAbstraction& glContextHelperAbstraction, Internal::Adaptor::GraphicsInterface& graphicsInterface); - Integration::GlAbstraction& GetGlAbstraction() override; - Integration::GlSyncAbstraction& GetGlSyncAbstraction() override; - Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() override; + Integration::GlAbstraction& GetGlAbstraction() override; + Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() override; + Internal::Adaptor::EglSyncImplementation& GetEglSyncImplementation(); /** * @copydoc Dali::Graphics::SubmitCommandBuffers() @@ -135,6 +135,29 @@ public: { // Final flush Flush(); + + ClearTextureUpdateQueue(); + + // Remove all create queue and command queue. + // Note that all memory are already deallocated at Final flush. + mCreateTextureQueue = {}; + mCreateBufferQueue = {}; + mCreateFramebufferQueue = {}; + mTextureMipmapGenerationRequests = {}; + mCommandQueue = {}; + + if(mContext) + { + mContext->GlContextDestroyed(); + } + + for(auto&& context : mSurfaceContexts) + { + if(context.second) + { + context.second->GlContextDestroyed(); + } + } } /** @@ -237,6 +260,12 @@ public: Graphics::UniquePtr CreateRenderTarget(const RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr&& oldRenderTarget) override; /** + * @copydoc Dali::Graphics::CreateSyncObject() + */ + Graphics::UniquePtr CreateSyncObject(const SyncObjectCreateInfo& syncObjectCreateInfo, + Graphics::UniquePtr&& oldSyncObject) override; + + /** * @copydoc Dali::Graphics::MapBufferRange() */ Graphics::UniquePtr MapBufferRange(const MapBufferInfo& mapInfo) override; @@ -373,6 +402,30 @@ public: } /** + * @brief Pushes RenderPass to the discard queue + * + * Function is called from the UniquePtr custom deleter. + * + * @param[in] program Pointer to the RenderPass + */ + void DiscardResource(GLES::RenderPass* renderPass) + { + mDiscardRenderPassQueue.push(renderPass); + } + + /** + * @brief Pushes RenderTarget to the discard queue + * + * Function is called from the UniquePtr custom deleter. + * + * @param[in] program Pointer to the RenderTarget + */ + void DiscardResource(GLES::RenderTarget* renderTarget) + { + mDiscardRenderTargetQueue.push(renderTarget); + } + + /** * @brief Pushes Shader to the discard queue * * Function is called from the UniquePtr custom deleter. @@ -421,6 +474,26 @@ public: } /** + * @brief Clears the texture update queue + */ + void ClearTextureUpdateQueue() + { + // Remove remained CPU-allocated texture memory + while(!mTextureUpdateRequests.empty()) + { + auto& request = mTextureUpdateRequests.front(); + auto& source = request.second; + + if(source.sourceType == Graphics::TextureUpdateSourceInfo::Type::MEMORY) + { + // free staging memory + free(source.memorySource.memory); + } + mTextureUpdateRequests.pop(); + } + } + + /** * @brief Flushes all pending updates * * Function flushes all pending resource constructions, @@ -428,19 +501,35 @@ public: */ void Flush() { - mGraphics->ActivateResourceContext(); + if(DALI_LIKELY(!mIsShuttingDown)) + { + if(!mCreateTextureQueue.empty() || + !mCreateBufferQueue.empty() || + !mCreateFramebufferQueue.empty() || + !mTextureUpdateRequests.empty() || + !mTextureMipmapGenerationRequests.empty()) + { + mGraphics->ActivateResourceContext(); + } - // Process creations - ProcessCreateQueues(); + // Process creations + ProcessCreateQueues(); - // Process updates - ProcessTextureUpdateQueue(); + // Process updates + ProcessTextureUpdateQueue(); - // Process texture mipmap generation requests - ProcessTextureMipmapGenerationQueue(); + // Process texture mipmap generation requests + ProcessTextureMipmapGenerationQueue(); - // Process main command queue - ProcessCommandQueues(); + // Process main command queue + ProcessCommandQueues(); + } + + // Reset texture cache in the contexts while destroying textures + ResetTextureCache(); + + // Reset buffer cache in the contexts while destroying buffers + ResetBufferCache(); // Process discards ProcessDiscardQueues(); @@ -477,9 +566,9 @@ public: } /** - * @brief Processes a create queue for type specified + * @brief Processes a discard queue for type specified * - * @param[in,out] queue Reference to the create queue + * @param[in,out] queue Reference to the discard queue */ template void ProcessDiscardQueue(T& queue) @@ -510,6 +599,53 @@ public: } /** + * @brief Processes a discard queue for pipeline + * + * @param[in,out] queue Reference to the create queue + */ + void ProcessDiscardQueue(std::queue& queue) + { + while(!queue.empty()) + { + auto* object = const_cast(queue.front()); + + // Inform the contexts to invalidate the pipeline if cached + if(mContext) + { + mContext->InvalidateCachedPipeline(object); + } + + for(auto&& context : mSurfaceContexts) + { + if(context.second) + { + context.second->InvalidateCachedPipeline(object); + } + } + + // Destroy + object->DestroyResource(); + + // Free + auto* clbk = object->GetCreateInfo().allocationCallbacks; + if(clbk) + { + // Call destructor + using GLESPipeline = GLES::Pipeline; + object->~GLESPipeline(); + + // Free memory + clbk->freeCallback(object, clbk->userData); + } + else + { + delete object; + } + queue.pop(); + } + } + + /** * @brief Processes all resource create queues */ void ProcessCreateQueues(); @@ -574,6 +710,44 @@ public: return mIsShuttingDown; } + /** + * @brief Reset texture cache in the contexts + */ + void ResetTextureCache() + { + if(mContext) + { + mContext->GetGLStateCache().ResetTextureCache(); + } + + for(auto& context : mSurfaceContexts) + { + if(context.second) + { + context.second->GetGLStateCache().ResetTextureCache(); + } + } + } + + /** + * @brief Reset buffer cache in the contexts + */ + void ResetBufferCache() + { + if(mContext) + { + mContext->GetGLStateCache().ResetBufferCache(); + } + + for(auto& context : mSurfaceContexts) + { + if(context.second) + { + context.second->GetGLStateCache().ResetBufferCache(); + } + } + } + void ProcessCommandBuffer(const GLES::CommandBuffer& commandBuffer); // Resolves presentation @@ -605,12 +779,22 @@ public: */ void ActivateSurfaceContext(Dali::RenderSurfaceInterface* surface); + /** + * @brief Returns the current context + * + * @return the current context + */ + GLES::Context* GetCurrentContext() const + { + return mCurrentContext; + } + private: Integration::GlAbstraction* mGlAbstraction{nullptr}; - Integration::GlSyncAbstraction* mGlSyncAbstraction{nullptr}; Integration::GlContextHelperAbstraction* mGlContextHelperAbstraction{nullptr}; - Internal::Adaptor::GraphicsInterface* mGraphics{nullptr}; + Internal::Adaptor::EglSyncImplementation* mEglSyncImplementation{nullptr}; + Internal::Adaptor::GraphicsInterface* mGraphics{nullptr}; // Pointer to owning structure via interface. std::queue mCreateTextureQueue; ///< Create queue for texture resource std::queue mDiscardTextureQueue; ///< Discard queue for texture resource @@ -620,6 +804,8 @@ private: std::queue mDiscardProgramQueue; ///< Discard queue for program resource std::queue mDiscardPipelineQueue; ///< Discard queue of pipelines + std::queue mDiscardRenderPassQueue; ///< Discard queue for renderpass resource + std::queue mDiscardRenderTargetQueue; ///< Discard queue for rendertarget resource std::queue mDiscardShaderQueue; ///< Discard queue of shaders std::queue mDiscardSamplerQueue; ///< Discard queue of samplers std::queue mDiscardCommandBufferQueue; ///< Discard queue of command buffers @@ -645,8 +831,7 @@ private: bool mIsShuttingDown{false}; ///< Indicates whether the controller is shutting down - // todo: to be removed after renderpass - const Graphics::Framebuffer* currentFramebuffer{nullptr}; + std::queue mPresentationCommandBuffers{}; ///< Queue of reusable command buffers used by presentation engine }; } // namespace Graphics