// INTERNAL INCLUDES
#include "gles-context.h"
#include "gles-graphics-buffer.h"
-#include "gles-graphics-memory.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"
namespace Dali
{
/**
* @brief Destructor
*/
- ~EglGraphicsController() override = default;
+ ~EglGraphicsController() override;
/**
* Initialize the GLES abstraction. This can be called from the main thread.
}
/**
+ * @copydoc Dali::Graphics::Shutdown()
+ */
+ void Shutdown() override
+ {
+ mIsShuttingDown = true;
+ }
+
+ /**
+ * @copydoc Dali::Graphics::Destroy()
+ */
+ void Destroy() override
+ {
+ // Final flush
+ Flush();
+ }
+
+ /**
* @copydoc Dali::Graphics::UpdateTextures()
*/
void UpdateTextures(const std::vector<TextureUpdateInfo>& updateInfoList,
/**
* @copydoc Dali::Graphics::CreateFramebuffer()
*/
- Graphics::UniquePtr<Framebuffer> CreateFramebuffer(const FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Framebuffer>&& oldFramebuffer) override
- {
- return nullptr;
- }
+ Graphics::UniquePtr<Framebuffer> CreateFramebuffer(const FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Framebuffer>&& oldFramebuffer) override;
/**
* @copydoc Dali::Graphics::CreatePipeline()
Graphics::UniquePtr<Pipeline> CreatePipeline(const PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Pipeline>&& oldPipeline) override;
/**
+ * @copydoc Dali::Graphics::CreateProgram()
+ */
+ Graphics::UniquePtr<Program> CreateProgram(const ProgramCreateInfo& programCreateInfo, UniquePtr<Program>&& oldProgram) override;
+
+ /**
* @copydoc Dali::Graphics::CreateShader()
*/
- Graphics::UniquePtr<Shader> CreateShader(const ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Shader>&& oldShader) override
- {
- return nullptr;
- }
+ Graphics::UniquePtr<Shader> CreateShader(const ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Shader>&& oldShader) override;
/**
* @copydoc Dali::Graphics::CreateSampler()
*/
- Graphics::UniquePtr<Sampler> CreateSampler(const SamplerCreateInfo& samplerCreateInfo, Graphics::UniquePtr<Sampler>&& oldSampler) override
- {
- return nullptr;
- }
+ Graphics::UniquePtr<Sampler> CreateSampler(const SamplerCreateInfo& samplerCreateInfo, Graphics::UniquePtr<Sampler>&& oldSampler) override;
/**
* @copydoc Dali::Graphics::CreateRenderTarget()
}
/**
+ * @copydoc Dali::Graphics::Controller::GetPipelineReflection()
+ */
+
+ [[nodiscard]] const Reflection& GetProgramReflection(const Graphics::Program& program) override;
+
+ /**
* @copydoc Dali::Graphics::PipelineEquals()
*/
[[nodiscard]] bool PipelineEquals(const Pipeline& pipeline0, const Pipeline& pipeline1) const override
[[nodiscard]] Integration::GlAbstraction* GetGL() const
{
+ if(mIsShuttingDown)
+ {
+ return nullptr;
+ }
return mGlAbstraction;
}
void AddBuffer(GLES::Buffer& buffer);
/**
+ * @brief Adds framebuffer to the creation queue
+ * @param buffer
+ */
+ void AddFramebuffer(GLES::Framebuffer& framebuffer);
+
+ /**
* @brief Pushes Bufer to the discard queue
*
* Function is called from the UniquePtr custom deleter.
*
* Function is called from the UniquePtr custom deleter.
*
- * @param[in] texture Pointer to the texture
+ * @param[in] buffer Pointer to the buffer object
+ */
+ void DiscardResource(GLES::Buffer* buffer)
+ {
+ mDiscardBufferQueue.push(buffer);
+ }
+
+ /**
+ * @brief Pushes framebuffer to the discard queue
+ *
+ * Function is called from the UniquePtr custom deleter.
+ *
+ * @param[in] framebuffer Pointer to the framebuffer object
+ */
+ void DiscardResource(GLES::Framebuffer* framebuffer)
+ {
+ mDiscardFramebufferQueue.push(framebuffer);
+ }
+
+ /**
+ * @brief Pushes Program to the discard queue
+ *
+ * Function is called from the UniquePtr custom deleter.
+ *
+ * @param[in] program Pointer to the program
+ */
+ void DiscardResource(GLES::Program* program)
+ {
+ mDiscardProgramQueue.push(program);
+ }
+
+ /**
+ * @brief Pushes Shader to the discard queue
+ *
+ * Function is called from the UniquePtr custom deleter.
+ *
+ * @param[in] program Pointer to the Shader
+ */
+ void DiscardResource(GLES::Shader* shader)
+ {
+ mDiscardShaderQueue.push(shader);
+ }
+
+ /**
+ * @brief Pushes CommandBuffer to the discard queue
+ *
+ * Function is called from the UniquePtr custom deleter.
+ *
+ * @param[in] program Pointer to the CommandBuffer
+ */
+ void DiscardResource(GLES::CommandBuffer* commandBuffer)
+ {
+ mDiscardCommandBufferQueue.push(commandBuffer);
+ }
+
+ /**
+ * @brief Pushes Sampler to the discard queue
+ *
+ * Function is called from the UniquePtr custom deleter.
+ *
+ * @param[in] program Pointer to the Sampler
+ */
+ void DiscardResource(GLES::Sampler* sampler)
+ {
+ mDiscardSamplerQueue.push(sampler);
+ }
+
+ /**
+ * @brief Pushes Pipeline to the discard queue
+ *
+ * Function is called from the UniquePtr custom deleter.
+ *
+ * @param[in] program Pointer to the pipeline
*/
- void DiscardResource(GLES::Buffer* texture)
+ void DiscardResource(GLES::Pipeline* pipeline)
{
- mDiscardBufferQueue.push(texture);
+ mDiscardPipelineQueue.push(pipeline);
}
/**
// Process updates
ProcessTextureUpdateQueue();
+ // Process main command queue
+ ProcessCommandQueues();
+
// Process discards
ProcessDiscardQueues();
- // Process main command queue
- ProcessCommandQueues();
+ // Flush pipeline cache to remove unused pipelines
+ if(mPipelineCache)
+ {
+ mPipelineCache->FlushCache();
+ }
}
// Test update to tick controller, usually it will run own thread
*/
void ProcessTextureUpdateQueue();
+ /**
+ * @brief Returns program custom parameter
+ *
+ * This function can be used as a backdoor in order to retrieve
+ * certain data out of implementation
+ *
+ * @param[in] program Valid Program object
+ * @param parameterId Integer id of parameter
+ * @param outData Output data
+ * @return True if parameter retrieved
+ */
+ bool GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData) override;
+
+ /**
+ * @brief Returns pipeline cache object
+ *
+ * @return Valid pipeline cache object
+ */
+ [[nodiscard]] GLES::PipelineCache& GetPipelineCache() const;
+
+ /**
+ * @brief Returns runtime supported GLES version
+ *
+ * @return GLES version enum
+ */
+ GLES::GLESVersion GetGLESVersion() const
+ {
+ // TODO: return proper version but for now we can
+ // test fallbacks
+ return GLES::GLESVersion::GLES_20;
+ }
+
+ bool IsShuttingDown() const
+ {
+ return mIsShuttingDown;
+ }
+
private:
Integration::GlAbstraction* mGlAbstraction{nullptr};
Integration::GlSyncAbstraction* mGlSyncAbstraction{nullptr};
std::queue<GLES::Buffer*> mCreateBufferQueue; ///< Create queue for buffer resource
std::queue<GLES::Buffer*> mDiscardBufferQueue; ///< Discard queue for buffer resource
+ std::queue<GLES::Program*> mDiscardProgramQueue; ///< Discard queue for program resource
+ std::queue<GLES::Pipeline*> mDiscardPipelineQueue; ///< Discard queue of pipelines
+ std::queue<GLES::Shader*> mDiscardShaderQueue; ///< Discard queue of shaders
+ std::queue<GLES::Sampler*> mDiscardSamplerQueue; ///< Discard queue of samplers
+ std::queue<GLES::CommandBuffer*> mDiscardCommandBufferQueue; ///< Discard queue of command buffers
+ std::queue<GLES::Framebuffer*> mCreateFramebufferQueue; ///< Create queue for framebuffer resource
+ std::queue<GLES::Framebuffer*> mDiscardFramebufferQueue; ///< Discard queue for framebuffer resource
+
std::queue<GLES::CommandBuffer*> mCommandQueue; ///< we may have more in the future
using TextureUpdateRequest = std::pair<TextureUpdateInfo, TextureUpdateSourceInfo>;
std::unique_ptr<GLES::Context> mContext{nullptr}; ///< Context object handling command buffers execution
std::unique_ptr<GLES::PipelineCache> mPipelineCache{nullptr}; ///< Internal pipeline cache
+
+ bool mIsShuttingDown{false}; ///< Indicates whether the controller is shutting down
};
} // namespace Graphics