#include <queue>
// INTERNAL INCLUDES
+#include <dali/integration-api/graphics-sync-abstraction.h>
#include <dali/internal/graphics/common/graphics-interface.h>
-#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 <dali/internal/graphics/gles-impl/gles-context.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-buffer.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-command-buffer.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-framebuffer.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-pipeline-cache.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-pipeline.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-reflection.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-sampler.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-shader.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-texture.h>
+#include <dali/internal/graphics/gles-impl/gles-graphics-types.h>
+#include <dali/internal/graphics/gles-impl/gles2-graphics-memory.h>
namespace Dali
{
namespace Integration
{
class GlAbstraction;
-class GlSyncAbstraction;
class GlContextHelperAbstraction;
} // namespace Integration
*
* 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:
/**
*
* 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()
{
// 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();
+ }
+ }
}
/**
Graphics::UniquePtr<RenderTarget> CreateRenderTarget(const RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<RenderTarget>&& oldRenderTarget) override;
/**
+ * @copydoc Dali::Graphics::CreateSyncObject()
+ */
+ Graphics::UniquePtr<SyncObject> CreateSyncObject(const SyncObjectCreateInfo& syncObjectCreateInfo,
+ Graphics::UniquePtr<SyncObject>&& oldSyncObject) override;
+
+ /**
* @copydoc Dali::Graphics::MapBufferRange()
*/
Graphics::UniquePtr<Memory> MapBufferRange(const MapBufferInfo& mapInfo) override;
}
/**
+ * @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.
}
/**
+ * @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,
*/
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();
}
/**
- * @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<class U, class T>
void ProcessDiscardQueue(T& queue)
}
/**
+ * @brief Processes a discard queue for pipeline
+ *
+ * @param[in,out] queue Reference to the create queue
+ */
+ void ProcessDiscardQueue(std::queue<GLES::Pipeline*>& queue)
+ {
+ while(!queue.empty())
+ {
+ auto* object = const_cast<GLES::Pipeline*>(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();
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
*/
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<GLES::Texture*> mCreateTextureQueue; ///< Create queue for texture resource
std::queue<GLES::Texture*> mDiscardTextureQueue; ///< Discard queue for texture resource
std::queue<GLES::Program*> mDiscardProgramQueue; ///< Discard queue for program resource
std::queue<GLES::Pipeline*> mDiscardPipelineQueue; ///< Discard queue of pipelines
+ std::queue<GLES::RenderPass*> mDiscardRenderPassQueue; ///< Discard queue for renderpass resource
+ std::queue<GLES::RenderTarget*> mDiscardRenderTargetQueue; ///< Discard queue for rendertarget resource
std::queue<GLES::Shader*> mDiscardShaderQueue; ///< Discard queue of shaders
std::queue<GLES::Sampler*> mDiscardSamplerQueue; ///< Discard queue of samplers
std::queue<const GLES::CommandBuffer*> mDiscardCommandBufferQueue; ///< Discard queue of command buffers
std::unique_ptr<GLES::PipelineCache> 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<const GLES::CommandBuffer*> mPresentationCommandBuffers{}; ///< Queue of reusable command buffers used by presentation engine
};
} // namespace Graphics
projects / platform / core / uifw / dali-adaptor.git / blobdiff