X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fgraphics%2Fgles-impl%2Fegl-graphics-controller.h;h=ec6c894c34857ab682f5ff68c7ea92a04399b72f;hb=c46a424c403d15c92079713d9370bd2888dce374;hp=18ea2183960a4a4a596a8286b14a1b0b91125559;hpb=c04c0b8250c1b92b81a0e26794d4ca085c2bdd7e;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 18ea218..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 @@ -58,7 +58,7 @@ class PipelineCache; * * Temporarily holds the old GL abstractions whilst dali-core is migrated to the new API. */ -DALI_IMPORT_API class EglGraphicsController : public Graphics::Controller +class EglGraphicsController : public Graphics::Controller { public: /** @@ -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(); + } + } } /** @@ -144,6 +167,11 @@ public: const std::vector& sourceList) override; /** + * @copydoc Dali::Graphics::GenerateTextureMipmaps() + */ + void GenerateTextureMipmaps(const Texture& texture) override; + + /** * @copydoc Dali::Graphics::EnableDepthStencilBuffer() */ bool EnableDepthStencilBuffer(bool enableDepth, bool enableStencil) override @@ -232,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; @@ -368,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. @@ -416,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, @@ -423,16 +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 updates + ProcessTextureUpdateQueue(); + + // Process texture mipmap generation requests + ProcessTextureMipmapGenerationQueue(); - // Process creations - ProcessCreateQueues(); + // Process main command queue + ProcessCommandQueues(); + } - // Process updates - ProcessTextureUpdateQueue(); + // Reset texture cache in the contexts while destroying textures + ResetTextureCache(); - // Process main command queue - ProcessCommandQueues(); + // Reset buffer cache in the contexts while destroying buffers + ResetBufferCache(); // Process discards ProcessDiscardQueues(); @@ -469,16 +566,16 @@ 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) { while(!queue.empty()) { - auto* object = queue.front(); + auto* object = const_cast(queue.front()); // Destroy object->DestroyResource(); @@ -502,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(); @@ -517,6 +661,11 @@ public: void ProcessTextureUpdateQueue(); /** + * @brief Executes all pending texture mipmap generation + */ + void ProcessTextureMipmapGenerationQueue(); + + /** * @brief Returns program custom parameter * * This function can be used as a backdoor in order to retrieve @@ -543,9 +692,17 @@ public: */ GLES::GLESVersion GetGLESVersion() const { - // TODO: return proper version but for now we can - // test fallbacks - return GLES::GLESVersion::GLES_20; + return mGLESVersion; + } + + /** + * @brief Sets runtime supported GLES version + * + * @param[in] glesVersion The runtime supported GLES version + */ + void SetGLESVersion(GLES::GLESVersion glesVersion) + { + mGLESVersion = glesVersion; } bool IsShuttingDown() const @@ -553,7 +710,45 @@ public: return mIsShuttingDown; } - void ProcessCommandBuffer(GLES::CommandBuffer& commandBuffer); + /** + * @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 void ResolvePresentRenderTarget(GLES::RenderTarget* renderTarget); @@ -584,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 @@ -597,19 +802,23 @@ private: std::queue mCreateBufferQueue; ///< Create queue for buffer resource std::queue mDiscardBufferQueue; ///< Discard queue for buffer resource - std::queue mDiscardProgramQueue; ///< Discard queue for program resource - std::queue mDiscardPipelineQueue; ///< Discard queue of pipelines - std::queue mDiscardShaderQueue; ///< Discard queue of shaders - std::queue mDiscardSamplerQueue; ///< Discard queue of samplers - std::queue mDiscardCommandBufferQueue; ///< Discard queue of command buffers - std::queue mCreateFramebufferQueue; ///< Create queue for framebuffer resource - std::queue mDiscardFramebufferQueue; ///< Discard queue for framebuffer resource + 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 + std::queue mCreateFramebufferQueue; ///< Create queue for framebuffer resource + std::queue mDiscardFramebufferQueue; ///< Discard queue for framebuffer resource std::queue mCommandQueue; ///< we may have more in the future using TextureUpdateRequest = std::pair; std::queue mTextureUpdateRequests; + std::queue mTextureMipmapGenerationRequests; ///< Queue for texture mipmap generation requests + GLES::Context* mCurrentContext{nullptr}; ///< The current context std::unique_ptr mContext{nullptr}; ///< Context object handling command buffers execution using SurfaceContextPair = std::pair>; @@ -617,10 +826,12 @@ private: std::unique_ptr mPipelineCache{nullptr}; ///< Internal pipeline cache + GLES::GLESVersion mGLESVersion{GLES::GLESVersion::GLES_20}; ///< Runtime supported GLES version + uint32_t mTextureUploadTotalCPUMemoryUsed{0u}; + 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