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

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "test-graphics-controller.h"
  18
  19 #include "test-graphics-buffer.h"
  20 #include "test-graphics-command-buffer.h"
  21 #include "test-graphics-framebuffer.h"
  22 #include "test-graphics-reflection.h"
  23 #include "test-graphics-render-pass.h"
  24 #include "test-graphics-render-target.h"
  25 #include "test-graphics-sampler.h"
  26 #include "test-graphics-shader.h"
  27 #include "test-graphics-texture.h"
  28
  29 #include <dali/integration-api/gl-defines.h>
  30 #include <cstdio>
  31 #include <iostream>
  32 #include <sstream>
  33
  34 namespace Dali
  35 {
  36 std::ostream& operator<<(std::ostream& o, const Graphics::BufferCreateInfo& bufferCreateInfo)
  37 {
  38   return o << "usage:" << std::hex << bufferCreateInfo.usage << ", size:" << std::dec << bufferCreateInfo.size;
  39 }
  40
  41 std::ostream& operator<<(std::ostream& o, const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo)
  42 {
  43   return o << "level:" << (commandBufferCreateInfo.level == Graphics::CommandBufferLevel::PRIMARY ? "PRIMARY" : "SECONDARY")
  44            << ", fixedCapacity:" << std::dec << commandBufferCreateInfo.fixedCapacity;
  45 }
  46
  47 std::ostream& operator<<(std::ostream& o, const Graphics::TextureType& textureType)
  48 {
  49   switch(textureType)
  50   {
  51     case Graphics::TextureType::TEXTURE_2D:
  52       o << "TEXTURE_2D";
  53       break;
  54     case Graphics::TextureType::TEXTURE_3D:
  55       o << "TEXTURE_3D";
  56       break;
  57     case Graphics::TextureType::TEXTURE_CUBEMAP:
  58       o << "TEXTURE_CUBEMAP";
  59       break;
  60   }
  61   return o;
  62 }
  63
  64 std::ostream& operator<<(std::ostream& o, const Graphics::Extent2D extent)
  65 {
  66   o << "width:" << extent.width << ", height:" << extent.height;
  67   return o;
  68 }
  69
  70 std::ostream& operator<<(std::ostream& o, const Graphics::TextureCreateInfo& createInfo)
  71 {
  72   o << "textureType:" << createInfo.textureType
  73     << " size:" << createInfo.size
  74     << " format:" << static_cast<uint32_t>(createInfo.format)
  75     << " mipMapFlag:" << createInfo.mipMapFlag
  76     << " layout:" << (createInfo.layout == Graphics::TextureLayout::LINEAR ? "LINEAR" : "OPTIMAL")
  77     << " usageFlags:" << std::hex << createInfo.usageFlags
  78     << " data:" << std::hex << createInfo.data
  79     << " dataSize:" << std::dec << createInfo.dataSize
  80     << " nativeImagePtr:" << std::hex << createInfo.nativeImagePtr;
  81   return o;
  82 }
  83
  84 std::ostream& operator<<(std::ostream& o, Graphics::SamplerAddressMode addressMode)
  85 {
  86   switch(addressMode)
  87   {
  88     case Graphics::SamplerAddressMode::REPEAT:
  89       o << "REPEAT";
  90       break;
  91     case Graphics::SamplerAddressMode::MIRRORED_REPEAT:
  92       o << "MIRRORED_REPEAT";
  93       break;
  94     case Graphics::SamplerAddressMode::CLAMP_TO_EDGE:
  95       o << "CLAMP_TO_EDGE";
  96       break;
  97     case Graphics::SamplerAddressMode::CLAMP_TO_BORDER:
  98       o << "CLAMP_TO_BORDER";
  99       break;
 100     case Graphics::SamplerAddressMode::MIRROR_CLAMP_TO_EDGE:
 101       o << "MIRROR_CLAMP_TO_EDGE";
 102       break;
 103   }
 104   return o;
 105 }
 106
 107 std::ostream& operator<<(std::ostream& o, Graphics::SamplerFilter filterMode)
 108 {
 109   switch(filterMode)
 110   {
 111     case Graphics::SamplerFilter::LINEAR:
 112       o << "LINEAR";
 113       break;
 114     case Graphics::SamplerFilter::NEAREST:
 115       o << "NEAREST";
 116       break;
 117   }
 118   return o;
 119 }
 120
 121 std::ostream& operator<<(std::ostream& o, Graphics::SamplerMipmapMode mipmapMode)
 122 {
 123   switch(mipmapMode)
 124   {
 125     case Graphics::SamplerMipmapMode::NONE:
 126       o << "NONE";
 127       break;
 128     case Graphics::SamplerMipmapMode::LINEAR:
 129       o << "LINEAR";
 130       break;
 131     case Graphics::SamplerMipmapMode::NEAREST:
 132       o << "NEAREST";
 133       break;
 134   }
 135   return o;
 136 }
 137
 138 std::ostream& operator<<(std::ostream& o, const Graphics::SamplerCreateInfo& createInfo)
 139 {
 140   o << "minFilter:" << createInfo.minFilter
 141     << " magFilter:" << createInfo.magFilter
 142     << " wrapModeU:" << createInfo.addressModeU
 143     << " wrapModeV:" << createInfo.addressModeV
 144     << " wrapModeW:" << createInfo.addressModeW
 145     << " mipMapMode:" << createInfo.mipMapMode;
 146   return o;
 147 }
 148
 149 std::ostream& operator<<(std::ostream& o, const Graphics::ColorAttachment& colorAttachment)
 150 {
 151   o << "attachmentId:" << colorAttachment.attachmentId
 152     << " layerId:" << colorAttachment.layerId
 153     << " levelId:" << colorAttachment.levelId
 154     << " texture:" << colorAttachment.texture;
 155   return o;
 156 }
 157
 158 std::ostream& operator<<(std::ostream& o, const Graphics::DepthStencilAttachment& depthStencilAttachment)
 159 {
 160   o << "depthTexture:" << depthStencilAttachment.depthTexture
 161     << "depthLevel:" << depthStencilAttachment.depthLevel
 162     << "stencilTexture:" << depthStencilAttachment.stencilTexture
 163     << "stencilLevel:" << depthStencilAttachment.stencilLevel;
 164   return o;
 165 }
 166
 167 std::ostream& operator<<(std::ostream& o, const Graphics::FramebufferCreateInfo& createInfo)
 168 {
 169   o << "colorAttachments:";
 170   for(auto i = 0u; i < createInfo.colorAttachments.size(); ++i)
 171   {
 172     o << "[" << i << "]=" << createInfo.colorAttachments[i] << "  ";
 173   }
 174   o << "depthStencilAttachment:" << createInfo.depthStencilAttachment;
 175   o << "size: " << createInfo.size;
 176   return o;
 177 }
 178
 179 int GetNumComponents(Graphics::VertexInputFormat vertexFormat)
 180 {
 181   switch(vertexFormat)
 182   {
 183     case Graphics::VertexInputFormat::UNDEFINED:
 184     case Graphics::VertexInputFormat::FLOAT:
 185     case Graphics::VertexInputFormat::INTEGER:
 186       return 1;
 187     case Graphics::VertexInputFormat::IVECTOR2:
 188     case Graphics::VertexInputFormat::FVECTOR2:
 189       return 2;
 190     case Graphics::VertexInputFormat::IVECTOR3:
 191     case Graphics::VertexInputFormat::FVECTOR3:
 192       return 3;
 193     case Graphics::VertexInputFormat::FVECTOR4:
 194     case Graphics::VertexInputFormat::IVECTOR4:
 195       return 4;
 196   }
 197   return 1;
 198 }
 199
 200 GLint GetSize(Graphics::VertexInputFormat vertexFormat)
 201 {
 202   switch(vertexFormat)
 203   {
 204     case Graphics::VertexInputFormat::UNDEFINED:
 205       return 1u;
 206     case Graphics::VertexInputFormat::INTEGER:
 207     case Graphics::VertexInputFormat::IVECTOR2:
 208     case Graphics::VertexInputFormat::IVECTOR3:
 209     case Graphics::VertexInputFormat::IVECTOR4:
 210       return 2u;
 211     case Graphics::VertexInputFormat::FLOAT:
 212     case Graphics::VertexInputFormat::FVECTOR2:
 213     case Graphics::VertexInputFormat::FVECTOR3:
 214     case Graphics::VertexInputFormat::FVECTOR4:
 215       return 4u;
 216   }
 217   return 1u;
 218 }
 219
 220 GLint GetGlType(Graphics::VertexInputFormat vertexFormat)
 221 {
 222   switch(vertexFormat)
 223   {
 224     case Graphics::VertexInputFormat::UNDEFINED:
 225       return GL_BYTE;
 226     case Graphics::VertexInputFormat::INTEGER:
 227     case Graphics::VertexInputFormat::IVECTOR2:
 228     case Graphics::VertexInputFormat::IVECTOR3:
 229     case Graphics::VertexInputFormat::IVECTOR4:
 230       return GL_SHORT;
 231     case Graphics::VertexInputFormat::FLOAT:
 232     case Graphics::VertexInputFormat::FVECTOR2:
 233     case Graphics::VertexInputFormat::FVECTOR3:
 234     case Graphics::VertexInputFormat::FVECTOR4:
 235       return GL_FLOAT;
 236   }
 237   return GL_BYTE;
 238 }
 239
 240 GLenum GetTopology(Graphics::PrimitiveTopology topology)
 241 {
 242   switch(topology)
 243   {
 244     case Graphics::PrimitiveTopology::POINT_LIST:
 245       return GL_POINTS;
 246
 247     case Graphics::PrimitiveTopology::LINE_LIST:
 248       return GL_LINES;
 249
 250     case Graphics::PrimitiveTopology::LINE_LOOP:
 251       return GL_LINE_LOOP;
 252
 253     case Graphics::PrimitiveTopology::LINE_STRIP:
 254       return GL_LINE_STRIP;
 255
 256     case Graphics::PrimitiveTopology::TRIANGLE_LIST:
 257       return GL_TRIANGLES;
 258
 259     case Graphics::PrimitiveTopology::TRIANGLE_STRIP:
 260       return GL_TRIANGLE_STRIP;
 261
 262     case Graphics::PrimitiveTopology::TRIANGLE_FAN:
 263       return GL_TRIANGLE_FAN;
 264   }
 265   return GL_TRIANGLES;
 266 }
 267
 268 GLenum GetCullFace(Graphics::CullMode cullMode)
 269 {
 270   switch(cullMode)
 271   {
 272     case Graphics::CullMode::NONE:
 273       return GL_NONE;
 274     case Graphics::CullMode::FRONT:
 275       return GL_FRONT;
 276     case Graphics::CullMode::BACK:
 277       return GL_BACK;
 278     case Graphics::CullMode::FRONT_AND_BACK:
 279       return GL_FRONT_AND_BACK;
 280   }
 281   return GL_NONE;
 282 }
 283
 284 GLenum GetFrontFace(Graphics::FrontFace frontFace)
 285 {
 286   if(frontFace == Graphics::FrontFace::CLOCKWISE)
 287   {
 288     return GL_CW;
 289   }
 290   return GL_CCW;
 291 }
 292
 293 GLenum GetBlendFactor(Graphics::BlendFactor blendFactor)
 294 {
 295   GLenum glFactor = GL_ZERO;
 296
 297   switch(blendFactor)
 298   {
 299     case Graphics::BlendFactor::ZERO:
 300       glFactor = GL_ZERO;
 301       break;
 302     case Graphics::BlendFactor::ONE:
 303       glFactor = GL_ONE;
 304       break;
 305     case Graphics::BlendFactor::SRC_COLOR:
 306       glFactor = GL_SRC_COLOR;
 307       break;
 308     case Graphics::BlendFactor::ONE_MINUS_SRC_COLOR:
 309       glFactor = GL_ONE_MINUS_SRC_COLOR;
 310       break;
 311     case Graphics::BlendFactor::DST_COLOR:
 312       glFactor = GL_DST_COLOR;
 313       break;
 314     case Graphics::BlendFactor::ONE_MINUS_DST_COLOR:
 315       glFactor = GL_ONE_MINUS_DST_COLOR;
 316       break;
 317     case Graphics::BlendFactor::SRC_ALPHA:
 318       glFactor = GL_SRC_ALPHA;
 319       break;
 320     case Graphics::BlendFactor::ONE_MINUS_SRC_ALPHA:
 321       glFactor = GL_ONE_MINUS_SRC_ALPHA;
 322       break;
 323     case Graphics::BlendFactor::DST_ALPHA:
 324       glFactor = GL_DST_ALPHA;
 325       break;
 326     case Graphics::BlendFactor::ONE_MINUS_DST_ALPHA:
 327       glFactor = GL_ONE_MINUS_DST_ALPHA;
 328       break;
 329     case Graphics::BlendFactor::CONSTANT_COLOR:
 330       glFactor = GL_CONSTANT_COLOR;
 331       break;
 332     case Graphics::BlendFactor::ONE_MINUS_CONSTANT_COLOR:
 333       glFactor = GL_ONE_MINUS_CONSTANT_COLOR;
 334       break;
 335     case Graphics::BlendFactor::CONSTANT_ALPHA:
 336       glFactor = GL_CONSTANT_ALPHA;
 337       break;
 338     case Graphics::BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
 339       glFactor = GL_ONE_MINUS_CONSTANT_ALPHA;
 340       break;
 341     case Graphics::BlendFactor::SRC_ALPHA_SATURATE:
 342       glFactor = GL_SRC_ALPHA_SATURATE;
 343       break;
 344       // GLES doesn't appear to have dual source blending.
 345     case Graphics::BlendFactor::SRC1_COLOR:
 346       glFactor = GL_SRC_COLOR;
 347       break;
 348     case Graphics::BlendFactor::ONE_MINUS_SRC1_COLOR:
 349       glFactor = GL_ONE_MINUS_SRC_COLOR;
 350       break;
 351     case Graphics::BlendFactor::SRC1_ALPHA:
 352       glFactor = GL_SRC_ALPHA;
 353       break;
 354     case Graphics::BlendFactor::ONE_MINUS_SRC1_ALPHA:
 355       glFactor = GL_ONE_MINUS_SRC_ALPHA;
 356       break;
 357   }
 358   return glFactor;
 359 }
 360
 361 GLenum GetBlendOp(Graphics::BlendOp blendOp)
 362 {
 363   GLenum op = GL_FUNC_ADD;
 364   switch(blendOp)
 365   {
 366     case Graphics::BlendOp::ADD:
 367       op = GL_FUNC_ADD;
 368       break;
 369     case Graphics::BlendOp::SUBTRACT:
 370       op = GL_FUNC_SUBTRACT;
 371       break;
 372     case Graphics::BlendOp::REVERSE_SUBTRACT:
 373       op = GL_FUNC_REVERSE_SUBTRACT;
 374       break;
 375     case Graphics::BlendOp::MIN:
 376       op = GL_MIN;
 377       break;
 378     case Graphics::BlendOp::MAX:
 379       op = GL_MAX;
 380       break;
 381
 382       // @todo Add advanced blend equations
 383   }
 384   return op;
 385 }
 386
 387 class TestGraphicsMemory : public Graphics::Memory
 388 {
 389 public:
 390   TestGraphicsMemory(TraceCallStack& callStack, TestGraphicsBuffer& buffer, uint32_t mappedOffset, uint32_t mappedSize)
 391   : mCallStack(callStack),
 392     mBuffer(buffer),
 393     mMappedOffset(mappedOffset),
 394     mMappedSize(mappedSize),
 395     mLockedOffset(0u),
 396     mLockedSize(0u)
 397   {
 398   }
 399
 400   void* LockRegion(uint32_t offset, uint32_t size) override
 401   {
 402     std::ostringstream o;
 403     o << offset << ", " << size;
 404     mCallStack.PushCall("Memory::LockRegion", o.str());
 405
 406     if(offset > mMappedOffset + mMappedSize ||
 407        size + offset > mMappedOffset + mMappedSize)
 408     {
 409       fprintf(stderr, "TestGraphics.Memory::LockRegion() Out of bounds");
 410       mBuffer.memory.resize(mMappedOffset + offset + size); // Grow to prevent memcpy from crashing
 411     }
 412     mLockedOffset = offset;
 413     mLockedSize   = size;
 414     return &mBuffer.memory[mMappedOffset + offset];
 415   }
 416
 417   void Unlock(bool flush) override
 418   {
 419     mCallStack.PushCall("Memory::Unlock", (flush ? "Flush" : "NoFlush"));
 420     if(flush)
 421     {
 422       Flush();
 423     }
 424   }
 425
 426   void Flush() override
 427   {
 428     mCallStack.PushCall("Memory::Flush", "");
 429     mBuffer.Bind();
 430     mBuffer.Upload(mMappedOffset + mLockedOffset, mLockedSize);
 431     mBuffer.Unbind();
 432   }
 433
 434   TraceCallStack&     mCallStack;
 435   TestGraphicsBuffer& mBuffer;
 436   uint32_t            mMappedOffset;
 437   uint32_t            mMappedSize;
 438   uint32_t            mLockedOffset;
 439   uint32_t            mLockedSize;
 440 };
 441
 442 TestGraphicsController::TestGraphicsController()
 443 : mCallStack(true, "TestGraphicsController."),
 444   mCommandBufferCallStack(true, "TestCommandBuffer."),
 445   mFrameBufferCallStack(true, "TestFrameBuffer.")
 446 {
 447   mCallStack.Enable(true);
 448   mCommandBufferCallStack.Enable(true);
 449   auto& trace = mGl.GetTextureTrace();
 450   trace.Enable(true);
 451   trace.EnableLogging(true);
 452 }
 453
 454 void TestGraphicsController::SubmitCommandBuffers(const Graphics::SubmitInfo& submitInfo)
 455 {
 456   TraceCallStack::NamedParams namedParams;
 457   namedParams["submitInfo"] << "cmdBuffer[" << submitInfo.cmdBuffer.size()
 458                             << "], flags:" << std::hex << submitInfo.flags;
 459
 460   mCallStack.PushCall("SubmitCommandBuffers", "", namedParams);
 461
 462   mSubmitStack.emplace_back(submitInfo);
 463
 464   for(auto& graphicsCommandBuffer : submitInfo.cmdBuffer)
 465   {
 466     auto commandBuffer = Uncast<TestGraphicsCommandBuffer>(graphicsCommandBuffer);
 467     ProcessCommandBuffer(*commandBuffer);
 468   }
 469 }
 470
 471 void TestGraphicsController::ProcessCommandBuffer(TestGraphicsCommandBuffer& commandBuffer)
 472 {
 473   bool                     scissorEnabled = false;
 474   TestGraphicsFramebuffer* currentFramebuffer{nullptr};
 475   TestGraphicsPipeline*    currentPipeline{nullptr};
 476
 477   for(auto& cmd : commandBuffer.GetCommands())
 478   {
 479     // process command
 480     switch(cmd.type)
 481     {
 482       case CommandType::FLUSH:
 483       {
 484         // Nothing to do here
 485         break;
 486       }
 487       case CommandType::BIND_TEXTURES:
 488       {
 489         for(auto& binding : cmd.data.bindTextures.textureBindings)
 490         {
 491           if(binding.texture)
 492           {
 493             auto texture = Uncast<TestGraphicsTexture>(binding.texture);
 494             texture->Bind(binding.binding);
 495
 496             if(binding.sampler)
 497             {
 498               auto sampler = Uncast<TestGraphicsSampler>(binding.sampler);
 499               if(sampler)
 500               {
 501                 sampler->Apply(texture->GetTarget());
 502               }
 503             }
 504
 505             texture->Prepare(); // Ensure native texture is ready
 506           }
 507         }
 508         break;
 509       }
 510       case CommandType::BIND_VERTEX_BUFFERS:
 511       {
 512         for(auto& binding : cmd.data.bindVertexBuffers.vertexBufferBindings)
 513         {
 514           auto graphicsBuffer = binding.buffer;
 515           auto vertexBuffer   = Uncast<TestGraphicsBuffer>(graphicsBuffer);
 516           vertexBuffer->Bind();
 517         }
 518         break;
 519       }
 520       case CommandType::BIND_INDEX_BUFFER:
 521       {
 522         auto& indexBufferBinding = cmd.data.bindIndexBuffer;
 523         if(indexBufferBinding.buffer)
 524         {
 525           auto buffer = Uncast<TestGraphicsBuffer>(indexBufferBinding.buffer);
 526           buffer->Bind();
 527         }
 528         break;
 529       }
 530       case CommandType::BIND_UNIFORM_BUFFER:
 531       {
 532         auto& bindings = cmd.data.bindUniformBuffers;
 533         auto  buffer   = bindings.standaloneUniformsBufferBinding;
 534
 535         // based on reflection, issue gl calls
 536         buffer.buffer->BindAsUniformBuffer(static_cast<const TestGraphicsProgram*>(currentPipeline->programState.program));
 537         break;
 538       }
 539       case CommandType::BIND_SAMPLERS:
 540       {
 541         break;
 542       }
 543       case CommandType::BIND_PIPELINE:
 544       {
 545         currentPipeline = Uncast<TestGraphicsPipeline>(cmd.data.bindPipeline.pipeline);
 546
 547         // Bind framebuffer if different. @todo Move to RenderPass
 548         auto framebuffer = currentPipeline->framebufferState.framebuffer;
 549         if(framebuffer && framebuffer != currentFramebuffer)
 550         {
 551           auto graphicsFramebuffer = Uncast<TestGraphicsFramebuffer>(framebuffer);
 552           graphicsFramebuffer->Bind();
 553         }
 554         else
 555         {
 556           if(currentFramebuffer)
 557             currentFramebuffer->Bind();
 558           else
 559             mGl.BindFramebuffer(GL_FRAMEBUFFER, 0);
 560         }
 561         BindPipeline(currentPipeline);
 562         break;
 563       }
 564       case CommandType::DRAW:
 565       {
 566         mGl.DrawArrays(GetTopology(currentPipeline->inputAssemblyState.topology),
 567                        0,
 568                        cmd.data.draw.draw.vertexCount);
 569         break;
 570       }
 571       case CommandType::DRAW_INDEXED:
 572       {
 573         mGl.DrawElements(GetTopology(currentPipeline->inputAssemblyState.topology),
 574                          static_cast<GLsizei>(cmd.data.draw.drawIndexed.indexCount),
 575                          GL_UNSIGNED_SHORT,
 576                          reinterpret_cast<void*>(cmd.data.draw.drawIndexed.firstIndex));
 577         break;
 578       }
 579       case CommandType::DRAW_INDEXED_INDIRECT:
 580       {
 581         mGl.DrawElements(GetTopology(currentPipeline->inputAssemblyState.topology),
 582                          static_cast<GLsizei>(cmd.data.draw.drawIndexed.indexCount),
 583                          GL_UNSIGNED_SHORT,
 584                          reinterpret_cast<void*>(cmd.data.draw.drawIndexed.firstIndex));
 585         break;
 586       }
 587       case CommandType::SET_SCISSOR:
 588       {
 589         if(scissorEnabled)
 590         {
 591           auto& rect = cmd.data.scissor.region;
 592           mGl.Scissor(rect.x, rect.y, rect.width, rect.height);
 593         }
 594         break;
 595       }
 596       case CommandType::SET_SCISSOR_TEST:
 597       {
 598         if(cmd.data.scissorTest.enable)
 599         {
 600           mGl.Enable(GL_SCISSOR_TEST);
 601           scissorEnabled = true;
 602         }
 603         else
 604         {
 605           mGl.Disable(GL_SCISSOR_TEST);
 606           scissorEnabled = false;
 607         }
 608         break;
 609       }
 610       case CommandType::SET_VIEWPORT_TEST:
 611       {
 612         break;
 613       }
 614       case CommandType::SET_VIEWPORT: // @todo Consider correcting for orientation here?
 615       {
 616         auto& rect = cmd.data.viewport.region;
 617         mGl.Viewport(rect.x, rect.y, rect.width, rect.height);
 618         break;
 619       }
 620       case CommandType::EXECUTE_COMMAND_BUFFERS:
 621       {
 622         // Process secondary command buffers
 623         for(auto& buf : cmd.data.executeCommandBuffers.buffers)
 624         {
 625           ProcessCommandBuffer(*static_cast<TestGraphicsCommandBuffer*>(buf));
 626         }
 627         break;
 628       }
 629       case CommandType::BEGIN_RENDER_PASS:
 630       {
 631         auto renderTarget = Uncast<TestGraphicsRenderTarget>(cmd.data.beginRenderPass.renderTarget);
 632
 633         if(renderTarget)
 634         {
 635           auto fb = renderTarget->mCreateInfo.framebuffer;
 636           if(fb)
 637           {
 638             if(currentFramebuffer != fb)
 639             {
 640               currentFramebuffer = Uncast<TestGraphicsFramebuffer>(fb);
 641               currentFramebuffer->Bind();
 642             }
 643           }
 644           else
 645           {
 646             mGl.BindFramebuffer(GL_FRAMEBUFFER, 0);
 647           }
 648         }
 649         else
 650         {
 651           mGl.BindFramebuffer(GL_FRAMEBUFFER, 0);
 652         }
 653
 654         auto& clearValues = cmd.data.beginRenderPass.clearValues;
 655         if(clearValues.size() > 0)
 656         {
 657           const auto renderPass = static_cast<TestGraphicsRenderPass*>(cmd.data.beginRenderPass.renderPass);
 658           if(renderPass)
 659           {
 660             const auto& color0 = renderPass->attachments[0];
 661             GLuint      mask   = 0;
 662             if(color0.loadOp == Graphics::AttachmentLoadOp::CLEAR)
 663             {
 664               mask |= GL_COLOR_BUFFER_BIT;
 665
 666               // Set clear color (todo: cache it!)
 667               // Something goes wrong here if Alpha mask is GL_TRUE
 668               mGl.ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
 669               mGl.ClearColor(clearValues[0].color.r,
 670                              clearValues[0].color.g,
 671                              clearValues[0].color.b,
 672                              clearValues[0].color.a);
 673             }
 674
 675             // check for depth stencil
 676             if(renderPass->attachments.size() > 1)
 677             {
 678               const auto& depthStencil = renderPass->attachments.back();
 679               if(depthStencil.loadOp == Graphics::AttachmentLoadOp::CLEAR)
 680               {
 681                 mask |= GL_DEPTH_BUFFER_BIT;
 682               }
 683               if(depthStencil.stencilLoadOp == Graphics::AttachmentLoadOp::CLEAR)
 684               {
 685                 mask |= GL_STENCIL_BUFFER_BIT;
 686               }
 687             }
 688
 689             if(mask != 0)
 690             {
 691               // Test scissor area and RT size
 692               const auto& area = cmd.data.beginRenderPass.renderArea;
 693               if(area.x == 0 &&
 694                  area.y == 0 &&
 695                  area.width == renderTarget->mCreateInfo.extent.width &&
 696                  area.height == renderTarget->mCreateInfo.extent.height)
 697               {
 698                 mGl.Disable(GL_SCISSOR_TEST);
 699                 mGl.Clear(mask);
 700               }
 701               else
 702               {
 703                 mGl.Enable(GL_SCISSOR_TEST);
 704                 mGl.Scissor(cmd.data.beginRenderPass.renderArea.x, cmd.data.beginRenderPass.renderArea.y, cmd.data.beginRenderPass.renderArea.width, cmd.data.beginRenderPass.renderArea.height);
 705                 mGl.Clear(mask);
 706                 mGl.Disable(GL_SCISSOR_TEST);
 707               }
 708             }
 709           }
 710           else
 711           {
 712             DALI_ASSERT_DEBUG(0 && "BeginRenderPass has no render pass");
 713           }
 714         }
 715         break;
 716       }
 717       case CommandType::END_RENDER_PASS:
 718       {
 719         break;
 720       }
 721     }
 722   }
 723 }
 724
 725 void TestGraphicsController::BindPipeline(TestGraphicsPipeline* pipeline)
 726 {
 727   auto& vi = pipeline->vertexInputState;
 728   for(auto& attribute : vi.attributes)
 729   {
 730     mGl.EnableVertexAttribArray(attribute.location);
 731     uint32_t attributeOffset = attribute.offset;
 732     GLsizei  stride          = vi.bufferBindings[attribute.binding].stride;
 733
 734     mGl.VertexAttribPointer(attribute.location,
 735                             GetNumComponents(attribute.format),
 736                             GetGlType(attribute.format),
 737                             GL_FALSE, // Not normalized
 738                             stride,
 739                             reinterpret_cast<void*>(attributeOffset));
 740   }
 741
 742   // Cull face setup
 743   auto& rasterizationState = pipeline->rasterizationState;
 744   if(rasterizationState.cullMode == Graphics::CullMode::NONE)
 745   {
 746     mGl.Disable(GL_CULL_FACE);
 747   }
 748   else
 749   {
 750     mGl.Enable(GL_CULL_FACE);
 751     mGl.CullFace(GetCullFace(rasterizationState.cullMode));
 752   }
 753
 754   mGl.FrontFace(GetFrontFace(rasterizationState.frontFace));
 755
 756   // Blending setup
 757   auto& colorBlendState = pipeline->colorBlendState;
 758   if(colorBlendState.blendEnable)
 759   {
 760     mGl.Enable(GL_BLEND);
 761
 762     mGl.BlendFuncSeparate(GetBlendFactor(colorBlendState.srcColorBlendFactor),
 763                           GetBlendFactor(colorBlendState.dstColorBlendFactor),
 764                           GetBlendFactor(colorBlendState.srcAlphaBlendFactor),
 765                           GetBlendFactor(colorBlendState.dstAlphaBlendFactor));
 766     if(colorBlendState.colorBlendOp != colorBlendState.alphaBlendOp)
 767     {
 768       mGl.BlendEquationSeparate(GetBlendOp(colorBlendState.colorBlendOp), GetBlendOp(colorBlendState.alphaBlendOp));
 769     }
 770     else
 771     {
 772       mGl.BlendEquation(GetBlendOp(colorBlendState.colorBlendOp));
 773     }
 774     mGl.BlendColor(colorBlendState.blendConstants[0],
 775                    colorBlendState.blendConstants[1],
 776                    colorBlendState.blendConstants[2],
 777                    colorBlendState.blendConstants[3]);
 778   }
 779   else
 780   {
 781     mGl.Disable(GL_BLEND);
 782   }
 783
 784   auto* program = static_cast<const TestGraphicsProgram*>(pipeline->programState.program);
 785   mGl.UseProgram(program->mImpl->mId);
 786 }
 787
 788 /**
 789  * @brief Presents render target
 790  * @param renderTarget render target to present
 791  */
 792 void TestGraphicsController::PresentRenderTarget(Graphics::RenderTarget* renderTarget)
 793 {
 794   TraceCallStack::NamedParams namedParams;
 795   namedParams["renderTarget"] << std::hex << renderTarget;
 796   mCallStack.PushCall("PresentRenderTarget", "", namedParams);
 797 }
 798
 799 /**
 800  * @brief Waits until the GPU is idle
 801  */
 802 void TestGraphicsController::WaitIdle()
 803 {
 804   mCallStack.PushCall("WaitIdle", "");
 805 }
 806
 807 /**
 808  * @brief Lifecycle pause event
 809  */
 810 void TestGraphicsController::Pause()
 811 {
 812   mCallStack.PushCall("Pause", "");
 813 }
 814
 815 /**
 816  * @brief Lifecycle resume event
 817  */
 818 void TestGraphicsController::Resume()
 819 {
 820   mCallStack.PushCall("Resume", "");
 821 }
 822
 823 void TestGraphicsController::Shutdown()
 824 {
 825   mCallStack.PushCall("Shutdown", "");
 826 }
 827
 828 void TestGraphicsController::Destroy()
 829 {
 830   mCallStack.PushCall("Destroy", "");
 831 }
 832
 833 void TestGraphicsController::UpdateTextures(const std::vector<Graphics::TextureUpdateInfo>&       updateInfoList,
 834                                             const std::vector<Graphics::TextureUpdateSourceInfo>& sourceList)
 835 {
 836   TraceCallStack::NamedParams namedParams;
 837   namedParams["updateInfoList"] << "[" << updateInfoList.size() << "]:";
 838   namedParams["sourceList"] << "[" << sourceList.size() << "]:";
 839
 840   mCallStack.PushCall("UpdateTextures", "", namedParams);
 841
 842   // Call either TexImage2D or TexSubImage2D
 843   for(unsigned int i = 0; i < updateInfoList.size(); ++i)
 844   {
 845     auto& updateInfo = updateInfoList[i];
 846     auto& source     = sourceList[i];
 847
 848     auto texture = static_cast<TestGraphicsTexture*>(updateInfo.dstTexture);
 849     texture->Bind(0); // Use first texture unit during resource update
 850     texture->Update(updateInfo, source);
 851   }
 852 }
 853
 854 bool TestGraphicsController::EnableDepthStencilBuffer(bool enableDepth, bool enableStencil)
 855 {
 856   TraceCallStack::NamedParams namedParams;
 857   namedParams["enableDepth"] << (enableDepth ? "T" : "F");
 858   namedParams["enableStencil"] << (enableStencil ? "T" : "F");
 859   mCallStack.PushCall("EnableDepthStencilBuffer", "", namedParams);
 860   return false;
 861 }
 862
 863 void TestGraphicsController::RunGarbageCollector(size_t numberOfDiscardedRenderers)
 864 {
 865   TraceCallStack::NamedParams namedParams;
 866   namedParams["numberOfDiscardedRenderers"] << numberOfDiscardedRenderers;
 867   mCallStack.PushCall("RunGarbageCollector", "", namedParams);
 868 }
 869
 870 void TestGraphicsController::DiscardUnusedResources()
 871 {
 872   mCallStack.PushCall("DiscardUnusedResources", "");
 873 }
 874
 875 bool TestGraphicsController::IsDiscardQueueEmpty()
 876 {
 877   mCallStack.PushCall("IsDiscardQueueEmpty", "");
 878   return isDiscardQueueEmptyResult;
 879 }
 880
 881 /**
 882  * @brief Test if the graphics subsystem has resumed & should force a draw
 883  *
 884  * @return true if the graphics subsystem requires a re-draw
 885  */
 886 bool TestGraphicsController::IsDrawOnResumeRequired()
 887 {
 888   mCallStack.PushCall("IsDrawOnResumeRequired", "");
 889   return isDrawOnResumeRequiredResult;
 890 }
 891
 892 Graphics::UniquePtr<Graphics::Buffer> TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& createInfo, Graphics::UniquePtr<Graphics::Buffer>&& oldBuffer)
 893 {
 894   std::ostringstream oss;
 895   oss << "bufferCreateInfo:" << createInfo;
 896   mCallStack.PushCall("CreateBuffer", oss.str());
 897   return Graphics::MakeUnique<TestGraphicsBuffer>(mCallStack, mGl, createInfo.size, createInfo.usage);
 898 }
 899
 900 Graphics::UniquePtr<Graphics::CommandBuffer> TestGraphicsController::CreateCommandBuffer(const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr<Graphics::CommandBuffer>&& oldCommandBuffer)
 901 {
 902   std::ostringstream oss;
 903   oss << "commandBufferCreateInfo:" << commandBufferCreateInfo;
 904   mCallStack.PushCall("CreateCommandBuffer", oss.str());
 905   return Graphics::MakeUnique<TestGraphicsCommandBuffer>(mCommandBufferCallStack, mGl);
 906 }
 907
 908 Graphics::UniquePtr<Graphics::RenderPass> TestGraphicsController::CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<Graphics::RenderPass>&& oldRenderPass)
 909 {
 910   mCallStack.PushCall("CreateRenderPass", "");
 911   return Graphics::MakeUnique<TestGraphicsRenderPass>(mGl, renderPassCreateInfo);
 912 }
 913
 914 Graphics::UniquePtr<Graphics::Texture> TestGraphicsController::CreateTexture(const Graphics::TextureCreateInfo& textureCreateInfo, Graphics::UniquePtr<Graphics::Texture>&& oldTexture)
 915 {
 916   TraceCallStack::NamedParams namedParams;
 917   namedParams["textureCreateInfo"] << textureCreateInfo;
 918   mCallStack.PushCall("CreateTexture", namedParams.str(), namedParams);
 919
 920   return Graphics::MakeUnique<TestGraphicsTexture>(mGl, textureCreateInfo);
 921 }
 922
 923 Graphics::UniquePtr<Graphics::Framebuffer> TestGraphicsController::CreateFramebuffer(
 924   const Graphics::FramebufferCreateInfo&       createInfo,
 925   Graphics::UniquePtr<Graphics::Framebuffer>&& oldFramebuffer)
 926 {
 927   TraceCallStack::NamedParams namedParams;
 928   namedParams["framebufferCreateInfo"] << createInfo;
 929   mCallStack.PushCall("Controller::CreateFramebuffer", namedParams.str(), namedParams);
 930
 931   return Graphics::MakeUnique<TestGraphicsFramebuffer>(mFrameBufferCallStack, mGl, createInfo);
 932 }
 933
 934 Graphics::UniquePtr<Graphics::Pipeline> TestGraphicsController::CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline)
 935 {
 936   mCallStack.PushCall("CreatePipeline", "");
 937   return std::make_unique<TestGraphicsPipeline>(mGl, pipelineCreateInfo);
 938 }
 939
 940 Graphics::UniquePtr<Graphics::Program> TestGraphicsController::CreateProgram(const Graphics::ProgramCreateInfo& programCreateInfo, Graphics::UniquePtr<Graphics::Program>&& oldProgram)
 941 {
 942   mCallStack.PushCall("CreateProgram", "");
 943
 944   for(auto cacheEntry : mProgramCache)
 945   {
 946     bool found = true;
 947     for(auto& shader : *(programCreateInfo.shaderState))
 948     {
 949       auto                 graphicsShader = Uncast<TestGraphicsShader>(shader.shader);
 950       std::vector<uint8_t> source;
 951       source.resize(graphicsShader->mCreateInfo.sourceSize);
 952       memcpy(&source[0], graphicsShader->mCreateInfo.sourceData, graphicsShader->mCreateInfo.sourceSize);
 953
 954       if(!std::equal(source.begin(), source.end(), cacheEntry.shaders[shader.pipelineStage].begin()))
 955       {
 956         found = false;
 957         break;
 958       }
 959     }
 960     if(found)
 961     {
 962       return Graphics::MakeUnique<TestGraphicsProgram>(cacheEntry.programImpl);
 963     }
 964   }
 965
 966   mProgramCache.emplace_back();
 967   mProgramCache.back().programImpl = new TestGraphicsProgramImpl(mGl, programCreateInfo, mVertexFormats, mCustomUniforms);
 968   for(auto& shader : *(programCreateInfo.shaderState))
 969   {
 970     auto graphicsShader = Uncast<TestGraphicsShader>(shader.shader);
 971     mProgramCache.back().shaders[shader.pipelineStage].resize(graphicsShader->mCreateInfo.sourceSize);
 972     memcpy(&mProgramCache.back().shaders[shader.pipelineStage][0], graphicsShader->mCreateInfo.sourceData, graphicsShader->mCreateInfo.sourceSize);
 973   }
 974   return Graphics::MakeUnique<TestGraphicsProgram>(mProgramCache.back().programImpl);
 975 }
 976
 977 Graphics::UniquePtr<Graphics::Shader> TestGraphicsController::CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Graphics::Shader>&& oldShader)
 978 {
 979   mCallStack.PushCall("CreateShader", "");
 980   return Graphics::MakeUnique<TestGraphicsShader>(mGl, shaderCreateInfo);
 981 }
 982
 983 Graphics::UniquePtr<Graphics::Sampler> TestGraphicsController::CreateSampler(const Graphics::SamplerCreateInfo& samplerCreateInfo, Graphics::UniquePtr<Graphics::Sampler>&& oldSampler)
 984 {
 985   TraceCallStack::NamedParams namedParams;
 986   namedParams["samplerCreateInfo"] << samplerCreateInfo;
 987   mCallStack.PushCall("CreateSampler", namedParams.str(), namedParams);
 988
 989   return Graphics::MakeUnique<TestGraphicsSampler>(mGl, samplerCreateInfo);
 990 }
 991
 992 Graphics::UniquePtr<Graphics::RenderTarget> TestGraphicsController::CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget)
 993 {
 994   mCallStack.PushCall("CreateRenderTarget", "");
 995   return Graphics::MakeUnique<TestGraphicsRenderTarget>(mGl, renderTargetCreateInfo);
 996 }
 997
 998 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
 999 {
1000   mCallStack.PushCall("MapBufferRange", "");
1001
1002   auto buffer = static_cast<TestGraphicsBuffer*>(mapInfo.buffer);
1003   buffer->memory.resize(mapInfo.offset + mapInfo.size); // For initial testing, allow writes past capacity
1004
1005   return std::make_unique<TestGraphicsMemory>(mCallStack, *buffer, mapInfo.offset, mapInfo.size);
1006 }
1007
1008 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapTextureRange(const Graphics::MapTextureInfo& mapInfo)
1009 {
1010   mCallStack.PushCall("MapTextureRange", "");
1011   return nullptr;
1012 }
1013
1014 void TestGraphicsController::UnmapMemory(Graphics::UniquePtr<Graphics::Memory> memory)
1015 {
1016   mCallStack.PushCall("UnmapMemory", "");
1017 }
1018
1019 Graphics::MemoryRequirements TestGraphicsController::GetTextureMemoryRequirements(Graphics::Texture& texture) const
1020 {
1021   mCallStack.PushCall("GetTextureMemoryRequirements", "");
1022   return Graphics::MemoryRequirements{};
1023 }
1024
1025 Graphics::MemoryRequirements TestGraphicsController::GetBufferMemoryRequirements(Graphics::Buffer& buffer) const
1026 {
1027   mCallStack.PushCall("GetBufferMemoryRequirements", "");
1028   return Graphics::MemoryRequirements{};
1029 }
1030
1031 const Graphics::TextureProperties& TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture)
1032 {
1033   static Graphics::TextureProperties textureProperties{};
1034   mCallStack.PushCall("GetTextureProperties", "");
1035
1036   return textureProperties;
1037 }
1038
1039 const Graphics::Reflection& TestGraphicsController::GetProgramReflection(const Graphics::Program& program)
1040 {
1041   mCallStack.PushCall("GetProgramReflection", "");
1042
1043   return static_cast<const TestGraphicsProgram*>(&program)->GetReflection();
1044 }
1045
1046 bool TestGraphicsController::PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const
1047 {
1048   mCallStack.PushCall("PipelineEquals", "");
1049   return false;
1050 }
1051
1052 bool TestGraphicsController::GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData)
1053 {
1054   mCallStack.PushCall("GetProgramParameter", "");
1055   auto graphicsProgram = Uncast<TestGraphicsProgram>(&program);
1056   return graphicsProgram->GetParameter(parameterId, outData);
1057 }
1058
1059 } // namespace Dali