dali/internal/graphics/gles-impl/egl-graphics-controller.h

   1 #ifndef DALI_EGL_GRAPHICS_CONTROLLER_H
   2 #define DALI_EGL_GRAPHICS_CONTROLLER_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 // EXTERNAL INCLUDES
  21 #include <dali/graphics-api/graphics-controller.h>
  22 #include <queue>
  23
  24 // INTERNAL INCLUDES
  25 #include "gles-graphics-buffer.h"
  26 #include "gles-graphics-memory.h"
  27 #include "gles-graphics-texture.h"
  28
  29 namespace Dali
  30 {
  31 namespace Integration
  32 {
  33 class GlAbstraction;
  34 class GlSyncAbstraction;
  35 class GlContextHelperAbstraction;
  36 } // namespace Integration
  37
  38 namespace Graphics
  39 {
  40 namespace GLES
  41 {
  42 class CommandBuffer;
  43 }
  44
  45 /**
  46  * EGL Implementation of the graphics controller.
  47  *
  48  * Temporarily holds the old GL abstractions whilst dali-core is migrated to the new API.
  49  */
  50 DALI_IMPORT_API class EglGraphicsController : public Graphics::Controller
  51 {
  52 public:
  53   /**
  54    * @brief Deault constructor
  55    */
  56   EglGraphicsController() = default;
  57
  58   /**
  59    * @brief Destructor
  60    */
  61   ~EglGraphicsController() override = default;
  62
  63   /**
  64    * Initialize the GLES abstraction. This can be called from the main thread.
  65    */
  66   void InitializeGLES(Integration::GlAbstraction& glAbstraction);
  67
  68   /**
  69    * Initialize with a reference to the GL abstractions.
  70    *
  71    * Note, this is now executed in the render thread, after core initialization
  72    */
  73   void Initialize(Integration::GlSyncAbstraction&          glSyncAbstraction,
  74                   Integration::GlContextHelperAbstraction& glContextHelperAbstraction);
  75
  76   Integration::GlAbstraction&              GetGlAbstraction() override;
  77   Integration::GlSyncAbstraction&          GetGlSyncAbstraction() override;
  78   Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() override;
  79
  80   /**
  81    * @copydoc Dali::Graphics::SubmitCommandBuffers()
  82    */
  83   void SubmitCommandBuffers(const SubmitInfo& submitInfo) override;
  84
  85   /**
  86    * @copydoc Dali::Graphics::PresentRenderTarget()
  87    */
  88   void PresentRenderTarget(RenderTarget* renderTarget) override
  89   {
  90   }
  91
  92   /**
  93    * @copydoc Dali::Graphics::WaitIdle()
  94    */
  95   void WaitIdle() override
  96   {
  97   }
  98
  99   /**
 100    * @copydoc Dali::Graphics::Pause()
 101    */
 102   void Pause() override
 103   {
 104   }
 105
 106   /**
 107    * @copydoc Dali::Graphics::Resume()
 108    */
 109   void Resume() override
 110   {
 111   }
 112
 113   /**
 114    * @copydoc Dali::Graphics::UpdateTextures()
 115    */
 116   void UpdateTextures(const std::vector<TextureUpdateInfo>&       updateInfoList,
 117                       const std::vector<TextureUpdateSourceInfo>& sourceList) override;
 118
 119   /**
 120    * @copydoc Dali::Graphics::EnableDepthStencilBuffer()
 121    */
 122   bool EnableDepthStencilBuffer(bool enableDepth, bool enableStencil) override
 123   {
 124     return {};
 125   }
 126
 127   /**
 128    * @copydoc Dali::Graphics::RunGarbageCollector()
 129    */
 130   void RunGarbageCollector(size_t numberOfDiscardedRenderers) override
 131   {
 132   }
 133
 134   /**
 135    * @copydoc Dali::Graphics::DiscardUnusedResources()
 136    */
 137   void DiscardUnusedResources() override
 138   {
 139   }
 140
 141   /**
 142    * @copydoc Dali::Graphics::IsDiscardQueueEmpty()
 143    */
 144   bool IsDiscardQueueEmpty() override
 145   {
 146     return {};
 147   }
 148
 149   /**
 150    * @copydoc Dali::Graphics::IsDrawOnResumeRequired()
 151    */
 152   bool IsDrawOnResumeRequired() override
 153   {
 154     return {};
 155   }
 156
 157   /**
 158    * @copydoc Dali::Graphics::CreateBuffer()
 159    */
 160   Graphics::UniquePtr<Buffer> CreateBuffer(const BufferCreateInfo& bufferCreateInfo, Graphics::UniquePtr<Buffer>&& oldBuffer) override;
 161
 162   /**
 163    * @copydoc Dali::Graphics::CreateCommandBuffer()
 164    */
 165   Graphics::UniquePtr<CommandBuffer> CreateCommandBuffer(const CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr<CommandBuffer>&& oldCommandBuffer) override;
 166
 167   /**
 168    * @copydoc Dali::Graphics::CreateRenderPass()
 169    */
 170   Graphics::UniquePtr<RenderPass> CreateRenderPass(const RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<RenderPass>&& oldRenderPass) override
 171   {
 172     return nullptr;
 173   }
 174
 175   /**
 176    * @copydoc Dali::Graphics::CreateTexture()
 177    */
 178   Graphics::UniquePtr<Texture> CreateTexture(const TextureCreateInfo& textureCreateInfo, Graphics::UniquePtr<Texture>&& oldTexture) override;
 179
 180   /**
 181    * @copydoc Dali::Graphics::CreateFramebuffer()
 182    */
 183   Graphics::UniquePtr<Framebuffer> CreateFramebuffer(const FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Framebuffer>&& oldFramebuffer) override
 184   {
 185     return nullptr;
 186   }
 187
 188   /**
 189    * @copydoc Dali::Graphics::CreatePipeline()
 190    */
 191   Graphics::UniquePtr<Pipeline> CreatePipeline(const PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Pipeline>&& oldPipeline) override
 192   {
 193     return nullptr;
 194   }
 195
 196   /**
 197    * @copydoc Dali::Graphics::CreateShader()
 198    */
 199   Graphics::UniquePtr<Shader> CreateShader(const ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Shader>&& oldShader) override
 200   {
 201     return nullptr;
 202   }
 203
 204   /**
 205    * @copydoc Dali::Graphics::CreateSampler()
 206    */
 207   Graphics::UniquePtr<Sampler> CreateSampler(const SamplerCreateInfo& samplerCreateInfo, Graphics::UniquePtr<Sampler>&& oldSampler) override
 208   {
 209     return nullptr;
 210   }
 211
 212   /**
 213    * @copydoc Dali::Graphics::CreateRenderTarget()
 214    */
 215   Graphics::UniquePtr<RenderTarget> CreateRenderTarget(const RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<RenderTarget>&& oldRenderTarget) override
 216   {
 217     return nullptr;
 218   }
 219
 220   /**
 221    * @copydoc Dali::Graphics::MapBufferRange()
 222    */
 223   Graphics::UniquePtr<Memory> MapBufferRange(const MapBufferInfo& mapInfo) override;
 224
 225   /**
 226    * @copydoc Dali::Graphics::MapTextureRange()
 227    */
 228   Graphics::UniquePtr<Memory> MapTextureRange(const MapTextureInfo& mapInfo) override
 229   {
 230     return nullptr;
 231   }
 232
 233   /**
 234    * @copydoc Dali::Graphics::UnmapMemory()
 235    */
 236   void UnmapMemory(Graphics::UniquePtr<Memory> memory) override
 237   {
 238   }
 239   /**
 240    * @copydoc Dali::Graphics::GetTextureMemoryRequirements()
 241    */
 242   MemoryRequirements GetTextureMemoryRequirements(Texture& texture) const override
 243   {
 244     return {};
 245   }
 246
 247   /**
 248    * @copydoc Dali::Graphics::GetBufferMemoryRequirements()
 249    */
 250   MemoryRequirements GetBufferMemoryRequirements(Buffer& buffer) const override
 251   {
 252     return {};
 253   }
 254
 255   /**
 256    * @copydoc Dali::Graphics::GetTextureProperties()
 257    */
 258   const TextureProperties& GetTextureProperties(const Texture& texture) override
 259   {
 260     // for compiler not to moan
 261     static TextureProperties dummy{};
 262     return dummy;
 263   }
 264
 265   /**
 266    * @copydoc Dali::Graphics::PipelineEquals()
 267    */
 268   [[nodiscard]] bool PipelineEquals(const Pipeline& pipeline0, const Pipeline& pipeline1) const override
 269   {
 270     return {};
 271   }
 272
 273   [[nodiscard]] Integration::GlAbstraction* GetGL() const
 274   {
 275     return mGlAbstraction;
 276   }
 277
 278   // Internal
 279   void AddTexture(GLES::Texture& texture);
 280
 281   /**
 282    * @brief Adds buffer to the creation queue
 283    * @param buffer
 284    */
 285   void AddBuffer(GLES::Buffer& buffer);
 286
 287   /**
 288    * @brief Pushes Bufer to the discard queue
 289    *
 290    * Function is called from the UniquePtr custom deleter.
 291    *
 292    * @param[in] texture Pointer to the texture
 293    */
 294   void DiscardResource(GLES::Texture* texture)
 295   {
 296     mDiscardTextureQueue.push(texture);
 297   }
 298
 299   /**
 300    * @brief Pushes Buffer to the discard queue
 301    *
 302    * Function is called from the UniquePtr custom deleter.
 303    *
 304    * @param[in] texture Pointer to the texture
 305    */
 306   void DiscardResource(GLES::Buffer* texture)
 307   {
 308     mDiscardBufferQueue.push(texture);
 309   }
 310
 311   /**
 312    * @brief Flushes all pending updates
 313    *
 314    * Function flushes all pending resource constructions,
 315    * executes command buffers and empties discard queues.
 316    */
 317   void Flush()
 318   {
 319     // Process creations
 320     ProcessCreateQueues();
 321
 322     // Process updates
 323     ProcessTextureUpdateQueue();
 324
 325     // Process discards
 326     ProcessDiscardQueues();
 327
 328     // Process main command queue
 329     ProcessCommandQueues();
 330   }
 331
 332   // Test update to tick controller, usually it will run own thread
 333   void ProcessDiscardQueues();
 334
 335   /**
 336    * @brief Processes a create queue for type specified
 337    *
 338    * @param[in,out] queue Reference to the create queue
 339    */
 340   template<class T>
 341   void ProcessCreateQueue(T& queue)
 342   {
 343     while(!queue.empty())
 344     {
 345       auto* object = queue.front();
 346       queue.pop();
 347
 348       // Initialize texture
 349       if(!object->InitializeResource())
 350       {
 351         // TODO: handle error
 352       }
 353     }
 354   }
 355
 356   /**
 357    * @brief Processes a create queue for type specified
 358    *
 359    * @param[in,out] queue Reference to the create queue
 360    */
 361   template<class U, class T>
 362   void ProcessDiscardQueue(T& queue)
 363   {
 364     while(!queue.empty())
 365     {
 366       auto* object = queue.front();
 367
 368       // Destroy
 369       object->DestroyResource();
 370
 371       // Free
 372       auto* clbk = object->GetCreateInfo().allocationCallbacks;
 373       if(clbk)
 374       {
 375         // Call destructor
 376         object->~U();
 377
 378         // Free memory
 379         clbk->freeCallback(object, clbk->userData);
 380       }
 381       else
 382       {
 383         delete object;
 384       }
 385       queue.pop();
 386     }
 387   }
 388
 389   /**
 390    * @brief Processes all resource create queues
 391    */
 392   void ProcessCreateQueues();
 393
 394   /**
 395    * @brief Process command queues and buffers
 396    */
 397   void ProcessCommandQueues();
 398
 399   /**
 400    * @brief Executes all pending texture updates
 401    */
 402   void ProcessTextureUpdateQueue();
 403
 404 private:
 405   Integration::GlAbstraction*              mGlAbstraction{nullptr};
 406   Integration::GlSyncAbstraction*          mGlSyncAbstraction{nullptr};
 407   Integration::GlContextHelperAbstraction* mGlContextHelperAbstraction{nullptr};
 408
 409   std::queue<GLES::Texture*> mCreateTextureQueue;  ///< Create queue for texture resource
 410   std::queue<GLES::Texture*> mDiscardTextureQueue; ///< Discard queue for texture resource
 411
 412   std::queue<GLES::Buffer*> mCreateBufferQueue;  ///< Create queue for buffer resource
 413   std::queue<GLES::Buffer*> mDiscardBufferQueue; ///< Discard queue for buffer resource
 414
 415   std::queue<GLES::CommandBuffer*> mCommandQueue; ///< we may have more in the future
 416
 417   using TextureUpdateRequest = std::pair<TextureUpdateInfo, TextureUpdateSourceInfo>;
 418   std::queue<TextureUpdateRequest> mTextureUpdateRequests;
 419 };
 420
 421 } // namespace Graphics
 422
 423 } // namespace Dali
 424
 425 #endif //DALI_EGL_GRAPHICS_CONTROLLER_H