automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.h

   1 #ifndef TEST_GRAPHICS_CONTROLLER_H
   2 #define TEST_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 #include <dali/graphics-api/graphics-controller.h>
  21 #include "test-gl-abstraction.h"
  22 #include "test-gl-context-helper-abstraction.h"
  23 #include "test-gl-sync-abstraction.h"
  24 #include "test-graphics-command-buffer.h"
  25 #include "test-graphics-program.h"
  26 #include "test-graphics-reflection.h"
  27
  28 namespace Dali
  29 {
  30 std::ostream& operator<<(std::ostream& o, const Graphics::BufferCreateInfo& bufferCreateInfo);
  31 std::ostream& operator<<(std::ostream& o, const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo);
  32 std::ostream& operator<<(std::ostream& o, const Graphics::TextureType& textureType);
  33 std::ostream& operator<<(std::ostream& o, const Graphics::Extent2D extent);
  34 std::ostream& operator<<(std::ostream& o, const Graphics::TextureCreateInfo& createInfo);
  35 std::ostream& operator<<(std::ostream& o, Graphics::SamplerAddressMode addressMode);
  36 std::ostream& operator<<(std::ostream& o, Graphics::SamplerFilter filterMode);
  37 std::ostream& operator<<(std::ostream& o, Graphics::SamplerMipmapMode mipmapMode);
  38 std::ostream& operator<<(std::ostream& o, const Graphics::SamplerCreateInfo& createInfo);
  39
  40 template<typename T>
  41 T* Uncast(const Graphics::CommandBuffer* object)
  42 {
  43   return const_cast<T*>(static_cast<const T*>(object));
  44 }
  45
  46 template<typename T>
  47 T* Uncast(const Graphics::Texture* object)
  48 {
  49   return const_cast<T*>(static_cast<const T*>(object));
  50 }
  51
  52 template<typename T>
  53 T* Uncast(const Graphics::Sampler* object)
  54 {
  55   return const_cast<T*>(static_cast<const T*>(object));
  56 }
  57
  58 template<typename T>
  59 T* Uncast(const Graphics::Buffer* object)
  60 {
  61   return const_cast<T*>(static_cast<const T*>(object));
  62 }
  63
  64 template<typename T>
  65 T* Uncast(const Graphics::Shader* object)
  66 {
  67   return const_cast<T*>(static_cast<const T*>(object));
  68 }
  69
  70 template<typename T>
  71 T* Uncast(const Graphics::Framebuffer* object)
  72 {
  73   return const_cast<T*>(static_cast<const T*>(object));
  74 }
  75
  76 template<typename T>
  77 T* Uncast(const Graphics::Pipeline* object)
  78 {
  79   return const_cast<T*>(static_cast<const T*>(object));
  80 }
  81
  82 template<typename T>
  83 T* Uncast(const Graphics::RenderTarget* object)
  84 {
  85   return const_cast<T*>(static_cast<const T*>(object));
  86 }
  87
  88 class TestGraphicsController : public Dali::Graphics::Controller
  89 {
  90 public:
  91   TestGraphicsController();
  92
  93   virtual ~TestGraphicsController() = default;
  94
  95   void Initialize()
  96   {
  97     mGl.Initialize();
  98   }
  99
 100   Integration::GlAbstraction& GetGlAbstraction() override
 101   {
 102     return mGl;
 103   }
 104
 105   Integration::GlSyncAbstraction& GetGlSyncAbstraction() override
 106   {
 107     return mGlSyncAbstraction;
 108   }
 109
 110   Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() override
 111   {
 112     return mGlContextHelperAbstraction;
 113   }
 114
 115   void SubmitCommandBuffers(const Graphics::SubmitInfo& submitInfo) override;
 116
 117   /**
 118    * @brief Presents render target
 119    * @param renderTarget render target to present
 120    */
 121   void PresentRenderTarget(Graphics::RenderTarget* renderTarget) override;
 122
 123   /**
 124    * @brief Waits until the GPU is idle
 125    */
 126   void WaitIdle() override;
 127
 128   /**
 129    * @brief Lifecycle pause event
 130    */
 131   void Pause() override;
 132
 133   /**
 134    * @brief Lifecycle resume event
 135    */
 136   void Resume() override;
 137
 138   /**
 139    * @brief Lifecycle shutdown event
 140    */
 141   void Shutdown() override;
 142
 143   /**
 144    * @brief Lifecycle destroy event
 145    */
 146   void Destroy() override;
 147
 148   /**
 149    * @brief Executes batch update of textures
 150    *
 151    * This function may perform full or partial update of many textures.
 152    * The data source may come from:
 153    * - CPU memory (client side)
 154    * - GPU memory (another Texture or Buffer)
 155    *
 156    * UpdateTextures() is the only way to update unmappable Texture objects.
 157    * It is recommended to batch updates as it may help with optimizing
 158    * memory transfers based on dependencies.
 159    *
 160    */
 161   void UpdateTextures(const std::vector<Graphics::TextureUpdateInfo>&       updateInfoList,
 162                       const std::vector<Graphics::TextureUpdateSourceInfo>& sourceList) override;
 163
 164   /**
 165    * TBD: do we need those functions in the new implementation?
 166    */
 167   bool EnableDepthStencilBuffer(bool enableDepth, bool enableStencil) override;
 168
 169   void RunGarbageCollector(size_t numberOfDiscardedRenderers) override;
 170
 171   void DiscardUnusedResources() override;
 172
 173   bool IsDiscardQueueEmpty() override;
 174
 175   /**
 176    * @brief Test if the graphics subsystem has resumed & should force a draw
 177    *
 178    * @return true if the graphics subsystem requires a re-draw
 179    */
 180   bool IsDrawOnResumeRequired() override;
 181
 182   /**
 183    * @brief Creates new Buffer object
 184    *
 185    * The Buffer object is created with underlying memory. The Buffer
 186    * specification is immutable. Based on the BufferCreateInfo::usage,
 187    * the memory may be client-side mappable or not.
 188    *
 189    * The old buffer may be passed as BufferCreateInfo::oldbuffer, however,
 190    * it's up to the implementation whether the object will be reused or
 191    * discarded and replaced by the new one.
 192    *
 193    * @param[in] bufferCreateInfo The valid BufferCreateInfo structure
 194    * @return pointer to the Buffer object
 195    */
 196   Graphics::UniquePtr<Graphics::Buffer> CreateBuffer(const Graphics::BufferCreateInfo& bufferCreateInfo, Graphics::UniquePtr<Graphics::Buffer>&& oldBuffer) override;
 197
 198   /**
 199    * @brief Creates new CommandBuffer object
 200    *
 201    * @param[in] bufferCreateInfo The valid BufferCreateInfo structure
 202    * @return pointer to the CommandBuffer object
 203    */
 204   Graphics::UniquePtr<Graphics::CommandBuffer> CreateCommandBuffer(const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr<Graphics::CommandBuffer>&& oldCommandBuffer) override;
 205
 206   /**
 207    * @brief Creates new RenderPass object
 208    *
 209    * @param[in] renderPassCreateInfo The valid RenderPassCreateInfo structure
 210    * @return pointer to the RenderPass object
 211    */
 212   Graphics::UniquePtr<Graphics::RenderPass> CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<Graphics::RenderPass>&& oldRenderPass) override;
 213
 214   /**
 215    * @brief Creates new Texture object
 216    *
 217    * @param[in] textureCreateInfo The valid TextureCreateInfo structure
 218    * @return pointer to the TextureCreateInfo object
 219    */
 220   Graphics::UniquePtr<Graphics::Texture> CreateTexture(const Graphics::TextureCreateInfo& textureCreateInfo, Graphics::UniquePtr<Graphics::Texture>&& oldTexture) override;
 221
 222   /**
 223    * @brief Creates new Framebuffer object
 224    *
 225    * @param[in] framebufferCreateInfo The valid FramebufferCreateInfo structure
 226    * @return pointer to the Framebuffer object
 227    */
 228   Graphics::UniquePtr<Graphics::Framebuffer> CreateFramebuffer(const Graphics::FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Graphics::Framebuffer>&& oldFramebuffer) override;
 229
 230   /**
 231    * @brief Creates new Pipeline object
 232    *
 233    * @param[in] pipelineCreateInfo The valid PipelineCreateInfo structure
 234    * @return pointer to the Pipeline object
 235    */
 236   Graphics::UniquePtr<Graphics::Pipeline> CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline) override;
 237
 238   /**
 239    * @brief Creates new Program object
 240    *
 241    * @param[in] programCreateInfo The valid ProgramCreateInfo structure
 242    * @return pointer to the Program object
 243    */
 244   Graphics::UniquePtr<Graphics::Program> CreateProgram(const Graphics::ProgramCreateInfo& programCreateInfo, Graphics::UniquePtr<Graphics::Program>&& oldProgram) override;
 245
 246   /**
 247    * @brief Creates new Shader object
 248    *
 249    * @param[in] shaderCreateInfo The valid ShaderCreateInfo structure
 250    * @return pointer to the Shader object
 251    */
 252   Graphics::UniquePtr<Graphics::Shader> CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Graphics::Shader>&& oldShader) override;
 253
 254   /**
 255    * @brief Creates new Sampler object
 256    *
 257    * @param[in] samplerCreateInfo The valid SamplerCreateInfo structure
 258    * @return pointer to the Sampler object
 259    */
 260   Graphics::UniquePtr<Graphics::Sampler> CreateSampler(const Graphics::SamplerCreateInfo& samplerCreateInfo, Graphics::UniquePtr<Graphics::Sampler>&& oldSampler) override;
 261
 262   /**
 263    * @brief Creates new RenderTarget object
 264    *
 265    * @param[in] renderTargetCreateInfo The valid RenderTargetCreateInfo structure
 266    * @return pointer to the RenderTarget object
 267    */
 268   Graphics::UniquePtr<Graphics::RenderTarget> CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget) override;
 269
 270   /**
 271    * @brief Maps memory associated with Buffer object
 272    *
 273    * @param[in] mapInfo Filled details of mapped resource
 274    *
 275    * @return Returns pointer to Memory object or Graphicsnullptr on error
 276    */
 277   Graphics::UniquePtr<Graphics::Memory> MapBufferRange(const Graphics::MapBufferInfo& mapInfo) override;
 278
 279   /**
 280    * @brief Maps memory associated with the texture.
 281    *
 282    * Only Texture objects that are backed with linear memory (staging memory) can be mapped.
 283    * Example:
 284    * 1) GLES implementation may create PBO object as staging memory and couple it
 285    * with the texture. Texture can be mapped and the memory can be read/write on demand.
 286    *
 287    * 2) Vulkan implementation may allocate DeviceMemory and use linear layout.
 288    *
 289    * @param[in] mapInfo Filled details of mapped resource
 290    *
 291    * @return Valid Memory object or nullptr on error
 292    */
 293   Graphics::UniquePtr<Graphics::Memory> MapTextureRange(const Graphics::MapTextureInfo& mapInfo) override;
 294
 295   /**
 296    * @brief Unmaps memory and discards Memory object
 297    *
 298    * This function automatically removes lock if Memory has been
 299    * previously locked.
 300    *
 301    * @param[in] memory Valid and previously mapped Memory object
 302    */
 303   void UnmapMemory(Graphics::UniquePtr<Graphics::Memory> memory) override;
 304
 305   /**
 306    * @brief Returns memory requirements of the Texture object.
 307    *
 308    * Call this function whenever it's necessary to know how much memory
 309    * is needed to store all the texture data and what memory alignment
 310    * the data should follow.
 311    *
 312    * @return Returns memory requirements of Texture
 313    */
 314   Graphics::MemoryRequirements GetTextureMemoryRequirements(Graphics::Texture& texture) const override;
 315
 316   /**
 317    * @brief Returns memory requirements of the Buffer object.
 318    *
 319    * Call this function whenever it's necessary to know how much memory
 320    * is needed to store all the buffer data and what memory alignment
 321    * the data should follow.
 322    *
 323    * @return Returns memory requirements of Buffer
 324    */
 325   Graphics::MemoryRequirements GetBufferMemoryRequirements(Graphics::Buffer& buffer) const override;
 326
 327   /**
 328    * @brief Returns specification of the Texture object
 329    *
 330    * Function obtains specification of the Texture object. It may retrieve
 331    * implementation dependent details like ie. whether the texture is
 332    * emulated (for example, RGB emulated on RGBA), compressed etc.
 333    *
 334    * @return Returns the TextureProperties object
 335    */
 336   const Graphics::TextureProperties& GetTextureProperties(const Graphics::Texture& texture) override;
 337
 338   /**
 339    * @brief Returns the reflection of the given program
 340    *
 341    * @param[in] program The program
 342    * @return The reflection of the program
 343    */
 344   const Graphics::Reflection& GetProgramReflection(const Graphics::Program& program) override;
 345
 346   /**
 347    * @brief Tests whether two Pipelines are the same.
 348    *
 349    * On the higher level, this function may help wit creating pipeline cache.
 350    *
 351    * @return true if pipeline objects match
 352    */
 353   bool PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const override;
 354
 355 public: // Test Functions
 356   void SetVertexFormats(Property::Array& vfs)
 357   {
 358     mVertexFormats = vfs;
 359   }
 360
 361   void AddCustomUniforms(std::vector<UniformData>& customUniforms)
 362   {
 363     mCustomUniforms = customUniforms;
 364   }
 365
 366   void ClearSubmitStack()
 367   {
 368     mSubmitStack.clear();
 369   }
 370
 371   /**
 372    * @brief Retrieves program parameters
 373    *
 374    * This function can be used to retrieve data from internal implementation
 375    *
 376    * @param[in] program Valid program object
 377    * @param[in] parameterId Integer parameter id
 378    * @param[out] outData Pointer to output memory
 379    * @return True on success
 380    */
 381   bool GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData) override;
 382
 383   void ProcessCommandBuffer(TestGraphicsCommandBuffer& commandBuffer);
 384
 385   void BindPipeline(TestGraphicsPipeline* pipeline);
 386
 387 public:
 388   mutable TraceCallStack                    mCallStack;
 389   mutable TraceCallStack                    mCommandBufferCallStack;
 390   mutable TraceCallStack                    mFrameBufferCallStack;
 391   mutable std::vector<Graphics::SubmitInfo> mSubmitStack;
 392
 393   TestGlAbstraction              mGl;
 394   TestGlSyncAbstraction          mGlSyncAbstraction;
 395   TestGlContextHelperAbstraction mGlContextHelperAbstraction;
 396
 397   bool isDiscardQueueEmptyResult{true};
 398   bool isDrawOnResumeRequiredResult{true};
 399
 400   Property::Array mVertexFormats;
 401
 402   struct ProgramCache
 403   {
 404     std::map<Graphics::PipelineStage, std::vector<uint8_t>> shaders;
 405     TestGraphicsProgramImpl*                                programImpl;
 406   };
 407   std::vector<ProgramCache> mProgramCache;
 408
 409   struct PipelineCache
 410   {
 411   };
 412
 413   std::vector<UniformData> mCustomUniforms;
 414 };
 415
 416 } // namespace Dali
 417
 418 #endif //TEST_GRAPHICS_CONTROLLER_H