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-reflection.h"
  22 #include "test-graphics-sampler.h"
  23 #include "test-graphics-shader.h"
  24 #include "test-graphics-texture.h"
  25
  26 #include <dali/integration-api/gl-defines.h>
  27 #include <cstdio>
  28 #include <iostream>
  29 #include <sstream>
  30
  31 namespace Dali
  32 {
  33 template<typename T>
  34 T* Uncast(const Graphics::CommandBuffer* object)
  35 {
  36   return const_cast<T*>(static_cast<const T*>(object));
  37 }
  38
  39 template<typename T>
  40 T* Uncast(const Graphics::Texture* object)
  41 {
  42   return const_cast<T*>(static_cast<const T*>(object));
  43 }
  44
  45 template<typename T>
  46 T* Uncast(const Graphics::Sampler* object)
  47 {
  48   return const_cast<T*>(static_cast<const T*>(object));
  49 }
  50
  51 template<typename T>
  52 T* Uncast(const Graphics::Buffer* object)
  53 {
  54   return const_cast<T*>(static_cast<const T*>(object));
  55 }
  56
  57 template<typename T>
  58 T* Uncast(const Graphics::Shader* object)
  59 {
  60   return const_cast<T*>(static_cast<const T*>(object));
  61 }
  62
  63 std::ostream& operator<<(std::ostream& o, const Graphics::BufferCreateInfo& bufferCreateInfo)
  64 {
  65   return o << "usage:" << std::hex << bufferCreateInfo.usage << ", size:" << std::dec << bufferCreateInfo.size;
  66 }
  67
  68 std::ostream& operator<<(std::ostream& o, const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo)
  69 {
  70   return o << "level:" << (commandBufferCreateInfo.level == Graphics::CommandBufferLevel::PRIMARY ? "PRIMARY" : "SECONDARY")
  71            << ", fixedCapacity:" << std::dec << commandBufferCreateInfo.fixedCapacity;
  72 }
  73
  74 std::ostream& operator<<(std::ostream& o, const Graphics::TextureType& textureType)
  75 {
  76   switch(textureType)
  77   {
  78     case Graphics::TextureType::TEXTURE_2D:
  79       o << "TEXTURE_2D";
  80       break;
  81     case Graphics::TextureType::TEXTURE_3D:
  82       o << "TEXTURE_3D";
  83       break;
  84     case Graphics::TextureType::TEXTURE_CUBEMAP:
  85       o << "TEXTURE_CUBEMAP";
  86       break;
  87   }
  88   return o;
  89 }
  90
  91 std::ostream& operator<<(std::ostream& o, const Graphics::Extent2D extent)
  92 {
  93   o << "width:" << extent.width << ", height:" << extent.height;
  94   return o;
  95 }
  96
  97 std::ostream& operator<<(std::ostream& o, const Graphics::TextureCreateInfo& createInfo)
  98 {
  99   o << "textureType:" << createInfo.textureType
 100     << " size:" << createInfo.size
 101     << " format:" << static_cast<uint32_t>(createInfo.format)
 102     << " mipMapFlag:" << createInfo.mipMapFlag
 103     << " layout:" << (createInfo.layout == Graphics::TextureLayout::LINEAR ? "LINEAR" : "OPTIMAL")
 104     << " usageFlags:" << std::hex << createInfo.usageFlags
 105     << " data:" << std::hex << createInfo.data
 106     << " dataSize:" << std::dec << createInfo.dataSize
 107     << " nativeImagePtr:" << std::hex << createInfo.nativeImagePtr;
 108   return o;
 109 }
 110
 111 std::ostream& operator<<(std::ostream& o, Graphics::SamplerAddressMode addressMode)
 112 {
 113   switch(addressMode)
 114   {
 115     case Graphics::SamplerAddressMode::REPEAT:
 116       o << "REPEAT";
 117       break;
 118     case Graphics::SamplerAddressMode::MIRRORED_REPEAT:
 119       o << "MIRRORED_REPEAT";
 120       break;
 121     case Graphics::SamplerAddressMode::CLAMP_TO_EDGE:
 122       o << "CLAMP_TO_EDGE";
 123       break;
 124     case Graphics::SamplerAddressMode::CLAMP_TO_BORDER:
 125       o << "CLAMP_TO_BORDER";
 126       break;
 127     case Graphics::SamplerAddressMode::MIRROR_CLAMP_TO_EDGE:
 128       o << "MIRROR_CLAMP_TO_EDGE";
 129       break;
 130   }
 131   return o;
 132 }
 133
 134 std::ostream& operator<<(std::ostream& o, Graphics::SamplerFilter filterMode)
 135 {
 136   switch(filterMode)
 137   {
 138     case Graphics::SamplerFilter::LINEAR:
 139       o << "LINEAR";
 140       break;
 141     case Graphics::SamplerFilter::NEAREST:
 142       o << "NEAREST";
 143       break;
 144   }
 145   return o;
 146 }
 147
 148 std::ostream& operator<<(std::ostream& o, Graphics::SamplerMipmapMode mipmapMode)
 149 {
 150   switch(mipmapMode)
 151   {
 152     case Graphics::SamplerMipmapMode::NONE:
 153       o << "NONE";
 154       break;
 155     case Graphics::SamplerMipmapMode::LINEAR:
 156       o << "LINEAR";
 157       break;
 158     case Graphics::SamplerMipmapMode::NEAREST:
 159       o << "NEAREST";
 160       break;
 161   }
 162   return o;
 163 }
 164
 165 std::ostream& operator<<(std::ostream& o, const Graphics::SamplerCreateInfo& createInfo)
 166 {
 167   o << "minFilter:" << createInfo.minFilter
 168     << " magFilter:" << createInfo.magFilter
 169     << " wrapModeU:" << createInfo.addressModeU
 170     << " wrapModeV:" << createInfo.addressModeV
 171     << " wrapModeW:" << createInfo.addressModeW
 172     << " mipMapMode:" << createInfo.mipMapMode;
 173   return o;
 174 }
 175
 176 class TestGraphicsMemory : public Graphics::Memory
 177 {
 178 public:
 179   TestGraphicsMemory(TraceCallStack& callStack, TestGraphicsBuffer& buffer, uint32_t mappedOffset, uint32_t mappedSize)
 180   : mCallStack(callStack),
 181     mBuffer(buffer),
 182     mMappedOffset(mappedOffset),
 183     mMappedSize(mappedSize)
 184   {
 185   }
 186
 187   void* LockRegion(uint32_t offset, uint32_t size) override
 188   {
 189     std::ostringstream o;
 190     o << offset << ", " << size;
 191     mCallStack.PushCall("Memory::LockRegion", o.str());
 192
 193     if(offset > mMappedOffset + mMappedSize ||
 194        size + offset > mMappedOffset + mMappedSize)
 195     {
 196       fprintf(stderr, "TestGraphics.Memory::LockRegion() Out of bounds");
 197       mBuffer.memory.resize(mMappedOffset + offset + size); // Grow to prevent memcpy from crashing
 198     }
 199     mLockedOffset = offset;
 200     mLockedSize   = size;
 201     return &mBuffer.memory[mMappedOffset + offset];
 202   }
 203
 204   void Unlock(bool flush) override
 205   {
 206     mCallStack.PushCall("Memory::Unlock", (flush ? "Flush" : "NoFlush"));
 207     if(flush)
 208     {
 209       Flush();
 210     }
 211   }
 212
 213   void Flush() override
 214   {
 215     mCallStack.PushCall("Memory::Flush", "");
 216     mBuffer.Bind();
 217     mBuffer.Upload(mMappedOffset + mLockedOffset, mLockedSize);
 218     mBuffer.Unbind();
 219   }
 220
 221   TraceCallStack&     mCallStack;
 222   TestGraphicsBuffer& mBuffer;
 223   uint32_t            mMappedOffset;
 224   uint32_t            mMappedSize;
 225   uint32_t            mLockedOffset;
 226   uint32_t            mLockedSize;
 227 };
 228
 229 TestGraphicsController::TestGraphicsController()
 230 : mCallStack(true, "TestGraphicsController."),
 231   mCommandBufferCallStack(true, "TestCommandBuffer.")
 232 {
 233   mCallStack.Enable(true);
 234   mCommandBufferCallStack.Enable(true);
 235   auto& trace = mGl.GetTextureTrace();
 236   trace.Enable(true);
 237   trace.EnableLogging(true);
 238 }
 239
 240 int GetNumComponents(Graphics::VertexInputFormat vertexFormat)
 241 {
 242   switch(vertexFormat)
 243   {
 244     case Graphics::VertexInputFormat::UNDEFINED:
 245     case Graphics::VertexInputFormat::FLOAT:
 246     case Graphics::VertexInputFormat::INTEGER:
 247       return 1;
 248     case Graphics::VertexInputFormat::IVECTOR2:
 249     case Graphics::VertexInputFormat::FVECTOR2:
 250       return 2;
 251     case Graphics::VertexInputFormat::IVECTOR3:
 252     case Graphics::VertexInputFormat::FVECTOR3:
 253       return 3;
 254     case Graphics::VertexInputFormat::FVECTOR4:
 255     case Graphics::VertexInputFormat::IVECTOR4:
 256       return 4;
 257   }
 258   return 1;
 259 }
 260
 261 GLint GetSize(Graphics::VertexInputFormat vertexFormat)
 262 {
 263   switch(vertexFormat)
 264   {
 265     case Graphics::VertexInputFormat::UNDEFINED:
 266       return 1u;
 267     case Graphics::VertexInputFormat::INTEGER:
 268     case Graphics::VertexInputFormat::IVECTOR2:
 269     case Graphics::VertexInputFormat::IVECTOR3:
 270     case Graphics::VertexInputFormat::IVECTOR4:
 271       return 2u;
 272     case Graphics::VertexInputFormat::FLOAT:
 273     case Graphics::VertexInputFormat::FVECTOR2:
 274     case Graphics::VertexInputFormat::FVECTOR3:
 275     case Graphics::VertexInputFormat::FVECTOR4:
 276       return 4u;
 277   }
 278   return 1u;
 279 }
 280
 281 GLint GetGlType(Graphics::VertexInputFormat vertexFormat)
 282 {
 283   switch(vertexFormat)
 284   {
 285     case Graphics::VertexInputFormat::UNDEFINED:
 286       return GL_BYTE;
 287     case Graphics::VertexInputFormat::INTEGER:
 288     case Graphics::VertexInputFormat::IVECTOR2:
 289     case Graphics::VertexInputFormat::IVECTOR3:
 290     case Graphics::VertexInputFormat::IVECTOR4:
 291       return GL_SHORT;
 292     case Graphics::VertexInputFormat::FLOAT:
 293     case Graphics::VertexInputFormat::FVECTOR2:
 294     case Graphics::VertexInputFormat::FVECTOR3:
 295     case Graphics::VertexInputFormat::FVECTOR4:
 296       return GL_FLOAT;
 297   }
 298   return GL_BYTE;
 299 }
 300
 301 GLenum GetTopology(Graphics::PrimitiveTopology topology)
 302 {
 303   switch(topology)
 304   {
 305     case Graphics::PrimitiveTopology::POINT_LIST:
 306       return GL_POINTS;
 307
 308     case Graphics::PrimitiveTopology::LINE_LIST:
 309       return GL_LINES;
 310
 311     case Graphics::PrimitiveTopology::LINE_LOOP:
 312       return GL_LINE_LOOP;
 313
 314     case Graphics::PrimitiveTopology::LINE_STRIP:
 315       return GL_LINE_STRIP;
 316
 317     case Graphics::PrimitiveTopology::TRIANGLE_LIST:
 318       return GL_TRIANGLES;
 319
 320     case Graphics::PrimitiveTopology::TRIANGLE_STRIP:
 321       return GL_TRIANGLE_STRIP;
 322
 323     case Graphics::PrimitiveTopology::TRIANGLE_FAN:
 324       return GL_TRIANGLE_FAN;
 325   }
 326   return GL_TRIANGLES;
 327 }
 328
 329 GLenum GetCullFace(Graphics::CullMode cullMode)
 330 {
 331   switch(cullMode)
 332   {
 333     case Graphics::CullMode::NONE:
 334       return GL_NONE;
 335     case Graphics::CullMode::FRONT:
 336       return GL_FRONT;
 337     case Graphics::CullMode::BACK:
 338       return GL_BACK;
 339     case Graphics::CullMode::FRONT_AND_BACK:
 340       return GL_FRONT_AND_BACK;
 341   }
 342   return GL_NONE;
 343 }
 344
 345 GLenum GetFrontFace(Graphics::FrontFace frontFace)
 346 {
 347   if(frontFace == Graphics::FrontFace::CLOCKWISE)
 348   {
 349     return GL_CW;
 350   }
 351   return GL_CCW;
 352 }
 353
 354 GLenum GetBlendFactor(Graphics::BlendFactor blendFactor)
 355 {
 356   GLenum glFactor = GL_ZERO;
 357
 358   switch(blendFactor)
 359   {
 360     case Graphics::BlendFactor::ZERO:
 361       glFactor = GL_ZERO;
 362       break;
 363     case Graphics::BlendFactor::ONE:
 364       glFactor = GL_ONE;
 365       break;
 366     case Graphics::BlendFactor::SRC_COLOR:
 367       glFactor = GL_SRC_COLOR;
 368       break;
 369     case Graphics::BlendFactor::ONE_MINUS_SRC_COLOR:
 370       glFactor = GL_ONE_MINUS_SRC_COLOR;
 371       break;
 372     case Graphics::BlendFactor::DST_COLOR:
 373       glFactor = GL_DST_COLOR;
 374       break;
 375     case Graphics::BlendFactor::ONE_MINUS_DST_COLOR:
 376       glFactor = GL_ONE_MINUS_DST_COLOR;
 377       break;
 378     case Graphics::BlendFactor::SRC_ALPHA:
 379       glFactor = GL_SRC_ALPHA;
 380       break;
 381     case Graphics::BlendFactor::ONE_MINUS_SRC_ALPHA:
 382       glFactor = GL_ONE_MINUS_SRC_ALPHA;
 383       break;
 384     case Graphics::BlendFactor::DST_ALPHA:
 385       glFactor = GL_DST_ALPHA;
 386       break;
 387     case Graphics::BlendFactor::ONE_MINUS_DST_ALPHA:
 388       glFactor = GL_ONE_MINUS_DST_ALPHA;
 389       break;
 390     case Graphics::BlendFactor::CONSTANT_COLOR:
 391       glFactor = GL_CONSTANT_COLOR;
 392       break;
 393     case Graphics::BlendFactor::ONE_MINUS_CONSTANT_COLOR:
 394       glFactor = GL_ONE_MINUS_CONSTANT_COLOR;
 395       break;
 396     case Graphics::BlendFactor::CONSTANT_ALPHA:
 397       glFactor = GL_CONSTANT_ALPHA;
 398       break;
 399     case Graphics::BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
 400       glFactor = GL_ONE_MINUS_CONSTANT_ALPHA;
 401       break;
 402     case Graphics::BlendFactor::SRC_ALPHA_SATURATE:
 403       glFactor = GL_SRC_ALPHA_SATURATE;
 404       break;
 405       // GLES doesn't appear to have dual source blending.
 406     case Graphics::BlendFactor::SRC1_COLOR:
 407       glFactor = GL_SRC_COLOR;
 408       break;
 409     case Graphics::BlendFactor::ONE_MINUS_SRC1_COLOR:
 410       glFactor = GL_ONE_MINUS_SRC_COLOR;
 411       break;
 412     case Graphics::BlendFactor::SRC1_ALPHA:
 413       glFactor = GL_SRC_ALPHA;
 414       break;
 415     case Graphics::BlendFactor::ONE_MINUS_SRC1_ALPHA:
 416       glFactor = GL_ONE_MINUS_SRC_ALPHA;
 417       break;
 418   }
 419   return glFactor;
 420 }
 421
 422 GLenum GetBlendOp(Graphics::BlendOp blendOp)
 423 {
 424   GLenum op = GL_FUNC_ADD;
 425   switch(blendOp)
 426   {
 427     case Graphics::BlendOp::ADD:
 428       op = GL_FUNC_ADD;
 429       break;
 430     case Graphics::BlendOp::SUBTRACT:
 431       op = GL_FUNC_SUBTRACT;
 432       break;
 433     case Graphics::BlendOp::REVERSE_SUBTRACT:
 434       op = GL_FUNC_REVERSE_SUBTRACT;
 435       break;
 436     case Graphics::BlendOp::MIN:
 437       op = GL_MIN;
 438       break;
 439     case Graphics::BlendOp::MAX:
 440       op = GL_MAX;
 441       break;
 442
 443       // @todo Add advanced blend equations
 444   }
 445   return op;
 446 }
 447
 448 void TestGraphicsController::SubmitCommandBuffers(const Graphics::SubmitInfo& submitInfo)
 449 {
 450   TraceCallStack::NamedParams namedParams;
 451   namedParams["submitInfo"] << "cmdBuffer[" << submitInfo.cmdBuffer.size()
 452                             << "], flags:" << std::hex << submitInfo.flags;
 453
 454   mCallStack.PushCall("SubmitCommandBuffers", "", namedParams);
 455
 456   mSubmitStack.emplace_back(submitInfo);
 457
 458   for(auto& graphicsCommandBuffer : submitInfo.cmdBuffer)
 459   {
 460     auto commandBuffer = Uncast<TestGraphicsCommandBuffer>(graphicsCommandBuffer);
 461     for(auto& binding : commandBuffer->mTextureBindings)
 462     {
 463       if(binding.texture)
 464       {
 465         auto texture = Uncast<TestGraphicsTexture>(binding.texture);
 466
 467         texture->Bind(binding.binding);
 468
 469         if(binding.sampler)
 470         {
 471           auto sampler = Uncast<TestGraphicsSampler>(binding.sampler);
 472           if(sampler)
 473           {
 474             sampler->Apply(texture->GetTarget());
 475           }
 476         }
 477
 478         texture->Prepare(); // Ensure native texture is ready
 479       }
 480     }
 481
 482     // IndexBuffer binding,
 483     auto& indexBufferBinding = commandBuffer->mIndexBufferBinding;
 484     if(indexBufferBinding.buffer)
 485     {
 486       auto buffer = Uncast<TestGraphicsBuffer>(indexBufferBinding.buffer);
 487       buffer->Bind();
 488     }
 489
 490     // VertexBuffer binding,
 491     for(auto graphicsBuffer : commandBuffer->mVertexBufferBindings.buffers)
 492     {
 493       auto vertexBuffer = Uncast<TestGraphicsBuffer>(graphicsBuffer);
 494       vertexBuffer->Bind();
 495     }
 496
 497     // Pipeline attribute setup
 498     auto& vi = commandBuffer->mPipeline->vertexInputState;
 499     for(auto& attribute : vi.attributes)
 500     {
 501       mGl.EnableVertexAttribArray(attribute.location);
 502       uint32_t attributeOffset = attribute.offset;
 503       GLsizei  stride          = vi.bufferBindings[attribute.binding].stride;
 504
 505       mGl.VertexAttribPointer(attribute.location,
 506                               GetNumComponents(attribute.format),
 507                               GetGlType(attribute.format),
 508                               GL_FALSE, // Not normalized
 509                               stride,
 510                               reinterpret_cast<void*>(attributeOffset));
 511     }
 512
 513     // Cull face setup
 514     auto& rasterizationState = commandBuffer->mPipeline->rasterizationState;
 515     if(rasterizationState.cullMode == Graphics::CullMode::NONE)
 516     {
 517       mGl.Disable(GL_CULL_FACE);
 518     }
 519     else
 520     {
 521       mGl.Enable(GL_CULL_FACE);
 522       mGl.CullFace(GetCullFace(rasterizationState.cullMode));
 523     }
 524
 525     mGl.FrontFace(GetFrontFace(rasterizationState.frontFace));
 526     // We don't modify glPolygonMode in our context/abstraction from GL_FILL (the GL default),
 527     // so it isn't present in the API (and won't have any tests!)
 528
 529     // Blending setup
 530     auto& colorBlendState = commandBuffer->mPipeline->colorBlendState;
 531     if(colorBlendState.blendEnable)
 532     {
 533       mGl.Enable(GL_BLEND);
 534
 535       mGl.BlendFuncSeparate(GetBlendFactor(colorBlendState.srcColorBlendFactor),
 536                             GetBlendFactor(colorBlendState.dstColorBlendFactor),
 537                             GetBlendFactor(colorBlendState.srcAlphaBlendFactor),
 538                             GetBlendFactor(colorBlendState.dstAlphaBlendFactor));
 539       if(colorBlendState.colorBlendOp != colorBlendState.alphaBlendOp)
 540       {
 541         mGl.BlendEquationSeparate(GetBlendOp(colorBlendState.colorBlendOp), GetBlendOp(colorBlendState.alphaBlendOp));
 542       }
 543       else
 544       {
 545         mGl.BlendEquation(GetBlendOp(colorBlendState.colorBlendOp));
 546       }
 547       mGl.BlendColor(colorBlendState.blendConstants[0],
 548                      colorBlendState.blendConstants[1],
 549                      colorBlendState.blendConstants[2],
 550                      colorBlendState.blendConstants[3]);
 551     }
 552     else
 553     {
 554       mGl.Disable(GL_BLEND);
 555     }
 556
 557     // draw call
 558     auto topology = commandBuffer->mPipeline->inputAssemblyState.topology;
 559
 560     if(commandBuffer->drawCommand.drawType == TestGraphicsCommandBuffer::Draw::DrawType::Indexed)
 561     {
 562       mGl.DrawElements(GetTopology(topology),
 563                        static_cast<GLsizei>(commandBuffer->drawCommand.u.indexedDraw.indexCount),
 564                        GL_UNSIGNED_SHORT,
 565                        reinterpret_cast<void*>(commandBuffer->drawCommand.u.indexedDraw.firstIndex));
 566     }
 567     else
 568     {
 569       mGl.DrawArrays(GetTopology(topology), 0, commandBuffer->drawCommand.u.unindexedDraw.vertexCount);
 570     }
 571
 572     // attribute clear
 573     for(auto& attribute : vi.attributes)
 574     {
 575       mGl.DisableVertexAttribArray(attribute.location);
 576     }
 577   }
 578 }
 579
 580 /**
 581  * @brief Presents render target
 582  * @param renderTarget render target to present
 583  */
 584 void TestGraphicsController::PresentRenderTarget(Graphics::RenderTarget* renderTarget)
 585 {
 586   TraceCallStack::NamedParams namedParams;
 587   namedParams["renderTarget"] << std::hex << renderTarget;
 588   mCallStack.PushCall("PresentRenderTarget", "", namedParams);
 589 }
 590
 591 /**
 592  * @brief Waits until the GPU is idle
 593  */
 594 void TestGraphicsController::WaitIdle()
 595 {
 596   mCallStack.PushCall("WaitIdle", "");
 597 }
 598
 599 /**
 600  * @brief Lifecycle pause event
 601  */
 602 void TestGraphicsController::Pause()
 603 {
 604   mCallStack.PushCall("Pause", "");
 605 }
 606
 607 /**
 608  * @brief Lifecycle resume event
 609  */
 610 void TestGraphicsController::Resume()
 611 {
 612   mCallStack.PushCall("Resume", "");
 613 }
 614
 615 void TestGraphicsController::UpdateTextures(const std::vector<Graphics::TextureUpdateInfo>&       updateInfoList,
 616                                             const std::vector<Graphics::TextureUpdateSourceInfo>& sourceList)
 617 {
 618   TraceCallStack::NamedParams namedParams;
 619   namedParams["updateInfoList"] << "[" << updateInfoList.size() << "]:";
 620   namedParams["sourceList"] << "[" << sourceList.size() << "]:";
 621
 622   mCallStack.PushCall("UpdateTextures", "", namedParams);
 623
 624   // Call either TexImage2D or TexSubImage2D
 625   for(unsigned int i = 0; i < updateInfoList.size(); ++i)
 626   {
 627     auto& updateInfo = updateInfoList[i];
 628     auto& source     = sourceList[i];
 629
 630     auto texture = static_cast<TestGraphicsTexture*>(updateInfo.dstTexture);
 631     texture->Bind(0); // Use first texture unit during resource update
 632     texture->Update(updateInfo, source);
 633   }
 634 }
 635
 636 bool TestGraphicsController::EnableDepthStencilBuffer(bool enableDepth, bool enableStencil)
 637 {
 638   TraceCallStack::NamedParams namedParams;
 639   namedParams["enableDepth"] << (enableDepth ? "T" : "F");
 640   namedParams["enableStencil"] << (enableStencil ? "T" : "F");
 641   mCallStack.PushCall("EnableDepthStencilBuffer", "", namedParams);
 642   return false;
 643 }
 644
 645 void TestGraphicsController::RunGarbageCollector(size_t numberOfDiscardedRenderers)
 646 {
 647   TraceCallStack::NamedParams namedParams;
 648   namedParams["numberOfDiscardedRenderers"] << numberOfDiscardedRenderers;
 649   mCallStack.PushCall("RunGarbageCollector", "", namedParams);
 650 }
 651
 652 void TestGraphicsController::DiscardUnusedResources()
 653 {
 654   mCallStack.PushCall("DiscardUnusedResources", "");
 655 }
 656
 657 bool TestGraphicsController::IsDiscardQueueEmpty()
 658 {
 659   mCallStack.PushCall("IsDiscardQueueEmpty", "");
 660   return isDiscardQueueEmptyResult;
 661 }
 662
 663 /**
 664  * @brief Test if the graphics subsystem has resumed & should force a draw
 665  *
 666  * @return true if the graphics subsystem requires a re-draw
 667  */
 668 bool TestGraphicsController::IsDrawOnResumeRequired()
 669 {
 670   mCallStack.PushCall("IsDrawOnResumeRequired", "");
 671   return isDrawOnResumeRequiredResult;
 672 }
 673
 674 Graphics::UniquePtr<Graphics::Buffer> TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& createInfo, Graphics::UniquePtr<Graphics::Buffer>&& oldBuffer)
 675 {
 676   std::ostringstream oss;
 677   oss << "bufferCreateInfo:" << createInfo;
 678   mCallStack.PushCall("CreateBuffer", oss.str());
 679   return Graphics::MakeUnique<TestGraphicsBuffer>(mCallStack, mGl, createInfo.size, createInfo.usage);
 680 }
 681
 682 Graphics::UniquePtr<Graphics::CommandBuffer> TestGraphicsController::CreateCommandBuffer(const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr<Graphics::CommandBuffer>&& oldCommandBuffer)
 683 {
 684   std::ostringstream oss;
 685   oss << "commandBufferCreateInfo:" << commandBufferCreateInfo;
 686   mCallStack.PushCall("CreateCommandBuffer", oss.str());
 687   return Graphics::MakeUnique<TestGraphicsCommandBuffer>(mCommandBufferCallStack, mGl);
 688 }
 689
 690 Graphics::UniquePtr<Graphics::RenderPass> TestGraphicsController::CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<Graphics::RenderPass>&& oldRenderPass)
 691 {
 692   mCallStack.PushCall("CreateRenderPass", "");
 693   return nullptr;
 694 }
 695
 696 Graphics::UniquePtr<Graphics::Texture> TestGraphicsController::CreateTexture(const Graphics::TextureCreateInfo& textureCreateInfo, Graphics::UniquePtr<Graphics::Texture>&& oldTexture)
 697 {
 698   TraceCallStack::NamedParams namedParams;
 699   namedParams["textureCreateInfo"] << textureCreateInfo;
 700   mCallStack.PushCall("CreateTexture", namedParams.str(), namedParams);
 701
 702   return Graphics::MakeUnique<TestGraphicsTexture>(mGl, textureCreateInfo);
 703 }
 704
 705 Graphics::UniquePtr<Graphics::Framebuffer> TestGraphicsController::CreateFramebuffer(const Graphics::FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Graphics::Framebuffer>&& oldFramebuffer)
 706 {
 707   mCallStack.PushCall("CreateFramebuffer", "");
 708   return nullptr;
 709 }
 710
 711 Graphics::UniquePtr<Graphics::Pipeline> TestGraphicsController::CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline)
 712 {
 713   mCallStack.PushCall("CreatePipeline", "");
 714   return std::make_unique<TestGraphicsPipeline>(mGl, pipelineCreateInfo);
 715 }
 716
 717 Graphics::UniquePtr<Graphics::Program> TestGraphicsController::CreateProgram(const Graphics::ProgramCreateInfo& programCreateInfo, Graphics::UniquePtr<Graphics::Program>&& oldProgram)
 718 {
 719   mCallStack.PushCall("CreateProgram", "");
 720
 721   for(auto cacheEntry : mProgramCache)
 722   {
 723     bool found = true;
 724     for(auto& shader : *(programCreateInfo.shaderState))
 725     {
 726       auto graphicsShader = Uncast<TestGraphicsShader>(shader.shader);
 727       if(memcmp(cacheEntry.shaders[shader.pipelineStage], graphicsShader->mCreateInfo.sourceData, graphicsShader->mCreateInfo.sourceSize))
 728       {
 729         found = false;
 730         break;
 731       }
 732     }
 733     if(found)
 734     {
 735       return Graphics::MakeUnique<TestGraphicsProgram>(cacheEntry.programImpl);
 736     }
 737   }
 738
 739   mProgramCache.emplace_back();
 740   mProgramCache.back().programImpl = new TestGraphicsProgramImpl(mGl, programCreateInfo, mVertexFormats);
 741   for(auto& shader : *(programCreateInfo.shaderState))
 742   {
 743     auto graphicsShader                                = Uncast<TestGraphicsShader>(shader.shader);
 744     mProgramCache.back().shaders[shader.pipelineStage] = graphicsShader->mCreateInfo.sourceData;
 745   }
 746   return Graphics::MakeUnique<TestGraphicsProgram>(mProgramCache.back().programImpl);
 747 }
 748
 749 Graphics::UniquePtr<Graphics::Shader> TestGraphicsController::CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Graphics::Shader>&& oldShader)
 750 {
 751   mCallStack.PushCall("CreateShader", "");
 752   return Graphics::MakeUnique<TestGraphicsShader>(mGl, shaderCreateInfo);
 753 }
 754
 755 Graphics::UniquePtr<Graphics::Sampler> TestGraphicsController::CreateSampler(const Graphics::SamplerCreateInfo& samplerCreateInfo, Graphics::UniquePtr<Graphics::Sampler>&& oldSampler)
 756 {
 757   TraceCallStack::NamedParams namedParams;
 758   namedParams["samplerCreateInfo"] << samplerCreateInfo;
 759   mCallStack.PushCall("CreateSampler", namedParams.str(), namedParams);
 760
 761   return Graphics::MakeUnique<TestGraphicsSampler>(mGl, samplerCreateInfo);
 762 }
 763
 764 Graphics::UniquePtr<Graphics::RenderTarget> TestGraphicsController::CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget)
 765 {
 766   mCallStack.PushCall("CreateRenderTarget", "");
 767   return nullptr;
 768 }
 769
 770 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
 771 {
 772   mCallStack.PushCall("MapBufferRange", "");
 773
 774   auto buffer = static_cast<TestGraphicsBuffer*>(mapInfo.buffer);
 775   buffer->memory.resize(mapInfo.offset + mapInfo.size); // For initial testing, allow writes past capacity
 776
 777   return std::make_unique<TestGraphicsMemory>(mCallStack, *buffer, mapInfo.offset, mapInfo.size);
 778 }
 779
 780 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapTextureRange(const Graphics::MapTextureInfo& mapInfo)
 781 {
 782   mCallStack.PushCall("MapTextureRange", "");
 783   return nullptr;
 784 }
 785
 786 void TestGraphicsController::UnmapMemory(Graphics::UniquePtr<Graphics::Memory> memory)
 787 {
 788   mCallStack.PushCall("UnmapMemory", "");
 789 }
 790
 791 Graphics::MemoryRequirements TestGraphicsController::GetTextureMemoryRequirements(Graphics::Texture& texture) const
 792 {
 793   mCallStack.PushCall("GetTextureMemoryRequirements", "");
 794   return Graphics::MemoryRequirements{};
 795 }
 796
 797 Graphics::MemoryRequirements TestGraphicsController::GetBufferMemoryRequirements(Graphics::Buffer& buffer) const
 798 {
 799   mCallStack.PushCall("GetBufferMemoryRequirements", "");
 800   return Graphics::MemoryRequirements{};
 801 }
 802
 803 const Graphics::TextureProperties& TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture)
 804 {
 805   static Graphics::TextureProperties textureProperties{};
 806   mCallStack.PushCall("GetTextureProperties", "");
 807
 808   return textureProperties;
 809 }
 810
 811 const Graphics::Reflection& TestGraphicsController::GetProgramReflection(const Graphics::Program& program)
 812 {
 813   mCallStack.PushCall("GetProgramReflection", "");
 814
 815   return static_cast<const TestGraphicsProgram*>(&program)->GetReflection();
 816 }
 817
 818 bool TestGraphicsController::PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const
 819 {
 820   mCallStack.PushCall("PipelineEquals", "");
 821   return false;
 822 }
 823
 824 bool TestGraphicsController::GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData)
 825 {
 826   mCallStack.PushCall("GetProgramParameter", "");
 827   auto graphicsProgram = Uncast<TestGraphicsProgram>(&program);
 828   return graphicsProgram->GetParameter(parameterId, outData);
 829 }
 830
 831 } // namespace Dali