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
 462     auto value = commandBuffer->GetCommandsByType(0 | CommandType::BIND_TEXTURES);
 463     if(!value.empty())
 464     {
 465       // must be fixed
 466       for (auto &binding : value[0]->bindTextures.textureBindings)
 467       {
 468         if (binding.texture)
 469         {
 470           auto texture = Uncast<TestGraphicsTexture>(binding.texture);
 471
 472           texture->Bind(binding.binding);
 473
 474           if (binding.sampler)
 475           {
 476             auto sampler = Uncast<TestGraphicsSampler>(binding.sampler);
 477             if (sampler)
 478             {
 479               sampler->Apply(texture->GetTarget());
 480             }
 481           }
 482
 483           texture->Prepare(); // Ensure native texture is ready
 484         }
 485       }
 486     }
 487
 488     // IndexBuffer binding,
 489     auto bindIndexBufferCmds = commandBuffer->GetCommandsByType(0 | CommandType::BIND_INDEX_BUFFER);
 490     if (!bindIndexBufferCmds.empty())
 491     {
 492       auto &indexBufferBinding = bindIndexBufferCmds[0]->bindIndexBuffer;
 493       if (indexBufferBinding.buffer)
 494       {
 495         auto buffer = Uncast<TestGraphicsBuffer>(indexBufferBinding.buffer);
 496         buffer->Bind();
 497       }
 498     }
 499
 500     // VertexBuffer binding,
 501     auto bindVertexBufferCmds = commandBuffer->GetCommandsByType(0 | CommandType::BIND_VERTEX_BUFFERS);
 502     if (!bindVertexBufferCmds.empty())
 503     {
 504       for (auto &binding : bindVertexBufferCmds[0]->bindVertexBuffers.vertexBufferBindings)
 505       {
 506         auto graphicsBuffer = binding.buffer;
 507         auto vertexBuffer   = Uncast<TestGraphicsBuffer>(graphicsBuffer);
 508         vertexBuffer->Bind();
 509       }
 510     }
 511     // Pipeline attribute setup
 512     auto bindPipelineCmds     = commandBuffer->GetCommandsByType(0 | CommandType::BIND_PIPELINE);
 513     if (!bindPipelineCmds.empty())
 514     {
 515       auto      pipeline = bindPipelineCmds[0]->bindPipeline.pipeline;
 516       auto      &vi      = pipeline->vertexInputState;
 517       for (auto &attribute : vi.attributes)
 518       {
 519         mGl.EnableVertexAttribArray(attribute.location);
 520         uint32_t attributeOffset = attribute.offset;
 521         GLsizei  stride          = vi.bufferBindings[attribute.binding].stride;
 522
 523         mGl.VertexAttribPointer(attribute.location,
 524                                 GetNumComponents(attribute.format),
 525                                 GetGlType(attribute.format),
 526                                 GL_FALSE, // Not normalized
 527                                 stride,
 528                                 reinterpret_cast<void *>(attributeOffset));
 529       }
 530       // Cull face setup
 531       auto &rasterizationState = pipeline->rasterizationState;
 532       if (rasterizationState.cullMode == Graphics::CullMode::NONE)
 533       {
 534         mGl.Disable(GL_CULL_FACE);
 535       }
 536       else
 537       {
 538         mGl.Enable(GL_CULL_FACE);
 539         mGl.CullFace(GetCullFace(rasterizationState.cullMode));
 540       }
 541
 542       mGl.FrontFace(GetFrontFace(rasterizationState.frontFace));
 543       // We don't modify glPolygonMode in our context/abstraction from GL_FILL (the GL default),
 544       // so it isn't present in the API (and won't have any tests!)
 545
 546       // Blending setup
 547       auto &colorBlendState = pipeline->colorBlendState;
 548       if (colorBlendState.blendEnable)
 549       {
 550         mGl.Enable(GL_BLEND);
 551
 552         mGl.BlendFuncSeparate(GetBlendFactor(colorBlendState.srcColorBlendFactor),
 553                               GetBlendFactor(colorBlendState.dstColorBlendFactor),
 554                               GetBlendFactor(colorBlendState.srcAlphaBlendFactor),
 555                               GetBlendFactor(colorBlendState.dstAlphaBlendFactor));
 556         if (colorBlendState.colorBlendOp != colorBlendState.alphaBlendOp)
 557         {
 558           mGl.BlendEquationSeparate(GetBlendOp(colorBlendState.colorBlendOp), GetBlendOp(colorBlendState.alphaBlendOp));
 559         }
 560         else
 561         {
 562           mGl.BlendEquation(GetBlendOp(colorBlendState.colorBlendOp));
 563         }
 564         mGl.BlendColor(colorBlendState.blendConstants[0],
 565                        colorBlendState.blendConstants[1],
 566                        colorBlendState.blendConstants[2],
 567                        colorBlendState.blendConstants[3]);
 568       }
 569       else
 570       {
 571         mGl.Disable(GL_BLEND);
 572       }
 573
 574       // draw call
 575       auto topology = pipeline->inputAssemblyState.topology;
 576
 577       // UniformBuffer binding (once we know pipeline)
 578       auto bindUniformBuffersCmds = commandBuffer->GetCommandsByType(0 | CommandType::BIND_UNIFORM_BUFFER);
 579       if (!bindUniformBuffersCmds.empty())
 580       {
 581         auto buffer = bindUniformBuffersCmds[0]->bindUniformBuffers.standaloneUniformsBufferBinding;
 582
 583         // based on reflection, issue gl calls
 584         buffer.buffer->BindAsUniformBuffer( static_cast<const TestGraphicsProgram*>(pipeline->programState.program) );
 585       }
 586
 587       auto drawCmds = commandBuffer->GetCommandsByType( 0 |
 588         CommandType::DRAW |
 589         CommandType::DRAW_INDEXED_INDIRECT |
 590         CommandType::DRAW_INDEXED );
 591
 592       if(!drawCmds.empty())
 593       {
 594         if (drawCmds[0]->draw.type == DrawCallDescriptor::Type::DRAW_INDEXED )
 595         {
 596           mGl.DrawElements(GetTopology(topology),
 597                            static_cast<GLsizei>(drawCmds[0]->draw.drawIndexed.indexCount),
 598                            GL_UNSIGNED_SHORT,
 599                            reinterpret_cast<void *>(drawCmds[0]->draw.drawIndexed.firstIndex));
 600         }
 601         else
 602         {
 603           mGl.DrawArrays(GetTopology(topology), 0, drawCmds[0]->draw.draw.vertexCount);
 604         }
 605       }
 606       // attribute clear
 607       for (auto &attribute : vi.attributes)
 608       {
 609         mGl.DisableVertexAttribArray(attribute.location);
 610       }
 611     }
 612   }
 613 }
 614
 615 /**
 616  * @brief Presents render target
 617  * @param renderTarget render target to present
 618  */
 619 void TestGraphicsController::PresentRenderTarget(Graphics::RenderTarget* renderTarget)
 620 {
 621   TraceCallStack::NamedParams namedParams;
 622   namedParams["renderTarget"] << std::hex << renderTarget;
 623   mCallStack.PushCall("PresentRenderTarget", "", namedParams);
 624 }
 625
 626 /**
 627  * @brief Waits until the GPU is idle
 628  */
 629 void TestGraphicsController::WaitIdle()
 630 {
 631   mCallStack.PushCall("WaitIdle", "");
 632 }
 633
 634 /**
 635  * @brief Lifecycle pause event
 636  */
 637 void TestGraphicsController::Pause()
 638 {
 639   mCallStack.PushCall("Pause", "");
 640 }
 641
 642 /**
 643  * @brief Lifecycle resume event
 644  */
 645 void TestGraphicsController::Resume()
 646 {
 647   mCallStack.PushCall("Resume", "");
 648 }
 649
 650 void TestGraphicsController::UpdateTextures(const std::vector<Graphics::TextureUpdateInfo>&       updateInfoList,
 651                                             const std::vector<Graphics::TextureUpdateSourceInfo>& sourceList)
 652 {
 653   TraceCallStack::NamedParams namedParams;
 654   namedParams["updateInfoList"] << "[" << updateInfoList.size() << "]:";
 655   namedParams["sourceList"] << "[" << sourceList.size() << "]:";
 656
 657   mCallStack.PushCall("UpdateTextures", "", namedParams);
 658
 659   // Call either TexImage2D or TexSubImage2D
 660   for(unsigned int i = 0; i < updateInfoList.size(); ++i)
 661   {
 662     auto& updateInfo = updateInfoList[i];
 663     auto& source     = sourceList[i];
 664
 665     auto texture = static_cast<TestGraphicsTexture*>(updateInfo.dstTexture);
 666     texture->Bind(0); // Use first texture unit during resource update
 667     texture->Update(updateInfo, source);
 668   }
 669 }
 670
 671 bool TestGraphicsController::EnableDepthStencilBuffer(bool enableDepth, bool enableStencil)
 672 {
 673   TraceCallStack::NamedParams namedParams;
 674   namedParams["enableDepth"] << (enableDepth ? "T" : "F");
 675   namedParams["enableStencil"] << (enableStencil ? "T" : "F");
 676   mCallStack.PushCall("EnableDepthStencilBuffer", "", namedParams);
 677   return false;
 678 }
 679
 680 void TestGraphicsController::RunGarbageCollector(size_t numberOfDiscardedRenderers)
 681 {
 682   TraceCallStack::NamedParams namedParams;
 683   namedParams["numberOfDiscardedRenderers"] << numberOfDiscardedRenderers;
 684   mCallStack.PushCall("RunGarbageCollector", "", namedParams);
 685 }
 686
 687 void TestGraphicsController::DiscardUnusedResources()
 688 {
 689   mCallStack.PushCall("DiscardUnusedResources", "");
 690 }
 691
 692 bool TestGraphicsController::IsDiscardQueueEmpty()
 693 {
 694   mCallStack.PushCall("IsDiscardQueueEmpty", "");
 695   return isDiscardQueueEmptyResult;
 696 }
 697
 698 /**
 699  * @brief Test if the graphics subsystem has resumed & should force a draw
 700  *
 701  * @return true if the graphics subsystem requires a re-draw
 702  */
 703 bool TestGraphicsController::IsDrawOnResumeRequired()
 704 {
 705   mCallStack.PushCall("IsDrawOnResumeRequired", "");
 706   return isDrawOnResumeRequiredResult;
 707 }
 708
 709 Graphics::UniquePtr<Graphics::Buffer> TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& createInfo, Graphics::UniquePtr<Graphics::Buffer>&& oldBuffer)
 710 {
 711   std::ostringstream oss;
 712   oss << "bufferCreateInfo:" << createInfo;
 713   mCallStack.PushCall("CreateBuffer", oss.str());
 714   return Graphics::MakeUnique<TestGraphicsBuffer>(mCallStack, mGl, createInfo.size, createInfo.usage);
 715 }
 716
 717 Graphics::UniquePtr<Graphics::CommandBuffer> TestGraphicsController::CreateCommandBuffer(const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr<Graphics::CommandBuffer>&& oldCommandBuffer)
 718 {
 719   std::ostringstream oss;
 720   oss << "commandBufferCreateInfo:" << commandBufferCreateInfo;
 721   mCallStack.PushCall("CreateCommandBuffer", oss.str());
 722   return Graphics::MakeUnique<TestGraphicsCommandBuffer>(mCommandBufferCallStack, mGl);
 723 }
 724
 725 Graphics::UniquePtr<Graphics::RenderPass> TestGraphicsController::CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<Graphics::RenderPass>&& oldRenderPass)
 726 {
 727   mCallStack.PushCall("CreateRenderPass", "");
 728   return nullptr;
 729 }
 730
 731 Graphics::UniquePtr<Graphics::Texture> TestGraphicsController::CreateTexture(const Graphics::TextureCreateInfo& textureCreateInfo, Graphics::UniquePtr<Graphics::Texture>&& oldTexture)
 732 {
 733   TraceCallStack::NamedParams namedParams;
 734   namedParams["textureCreateInfo"] << textureCreateInfo;
 735   mCallStack.PushCall("CreateTexture", namedParams.str(), namedParams);
 736
 737   return Graphics::MakeUnique<TestGraphicsTexture>(mGl, textureCreateInfo);
 738 }
 739
 740 Graphics::UniquePtr<Graphics::Framebuffer> TestGraphicsController::CreateFramebuffer(const Graphics::FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Graphics::Framebuffer>&& oldFramebuffer)
 741 {
 742   mCallStack.PushCall("CreateFramebuffer", "");
 743   return nullptr;
 744 }
 745
 746 Graphics::UniquePtr<Graphics::Pipeline> TestGraphicsController::CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline)
 747 {
 748   mCallStack.PushCall("CreatePipeline", "");
 749   return std::make_unique<TestGraphicsPipeline>(mGl, pipelineCreateInfo);
 750 }
 751
 752 Graphics::UniquePtr<Graphics::Program> TestGraphicsController::CreateProgram(const Graphics::ProgramCreateInfo& programCreateInfo, Graphics::UniquePtr<Graphics::Program>&& oldProgram)
 753 {
 754   mCallStack.PushCall("CreateProgram", "");
 755
 756   for(auto cacheEntry : mProgramCache)
 757   {
 758     bool found = true;
 759     for(auto& shader : *(programCreateInfo.shaderState))
 760     {
 761       auto graphicsShader = Uncast<TestGraphicsShader>(shader.shader);
 762       if(memcmp(cacheEntry.shaders[shader.pipelineStage], graphicsShader->mCreateInfo.sourceData, graphicsShader->mCreateInfo.sourceSize))
 763       {
 764         found = false;
 765         break;
 766       }
 767     }
 768     if(found)
 769     {
 770       return Graphics::MakeUnique<TestGraphicsProgram>(cacheEntry.programImpl);
 771     }
 772   }
 773
 774   mProgramCache.emplace_back();
 775   mProgramCache.back().programImpl = new TestGraphicsProgramImpl(mGl, programCreateInfo, mVertexFormats, mCustomUniforms);
 776   for(auto& shader : *(programCreateInfo.shaderState))
 777   {
 778     auto graphicsShader                                = Uncast<TestGraphicsShader>(shader.shader);
 779     mProgramCache.back().shaders[shader.pipelineStage] = graphicsShader->mCreateInfo.sourceData;
 780   }
 781   return Graphics::MakeUnique<TestGraphicsProgram>(mProgramCache.back().programImpl);
 782 }
 783
 784 Graphics::UniquePtr<Graphics::Shader> TestGraphicsController::CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Graphics::Shader>&& oldShader)
 785 {
 786   mCallStack.PushCall("CreateShader", "");
 787   return Graphics::MakeUnique<TestGraphicsShader>(mGl, shaderCreateInfo);
 788 }
 789
 790 Graphics::UniquePtr<Graphics::Sampler> TestGraphicsController::CreateSampler(const Graphics::SamplerCreateInfo& samplerCreateInfo, Graphics::UniquePtr<Graphics::Sampler>&& oldSampler)
 791 {
 792   TraceCallStack::NamedParams namedParams;
 793   namedParams["samplerCreateInfo"] << samplerCreateInfo;
 794   mCallStack.PushCall("CreateSampler", namedParams.str(), namedParams);
 795
 796   return Graphics::MakeUnique<TestGraphicsSampler>(mGl, samplerCreateInfo);
 797 }
 798
 799 Graphics::UniquePtr<Graphics::RenderTarget> TestGraphicsController::CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget)
 800 {
 801   mCallStack.PushCall("CreateRenderTarget", "");
 802   return nullptr;
 803 }
 804
 805 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
 806 {
 807   mCallStack.PushCall("MapBufferRange", "");
 808
 809   auto buffer = static_cast<TestGraphicsBuffer*>(mapInfo.buffer);
 810   buffer->memory.resize(mapInfo.offset + mapInfo.size); // For initial testing, allow writes past capacity
 811
 812   return std::make_unique<TestGraphicsMemory>(mCallStack, *buffer, mapInfo.offset, mapInfo.size);
 813 }
 814
 815 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapTextureRange(const Graphics::MapTextureInfo& mapInfo)
 816 {
 817   mCallStack.PushCall("MapTextureRange", "");
 818   return nullptr;
 819 }
 820
 821 void TestGraphicsController::UnmapMemory(Graphics::UniquePtr<Graphics::Memory> memory)
 822 {
 823   mCallStack.PushCall("UnmapMemory", "");
 824 }
 825
 826 Graphics::MemoryRequirements TestGraphicsController::GetTextureMemoryRequirements(Graphics::Texture& texture) const
 827 {
 828   mCallStack.PushCall("GetTextureMemoryRequirements", "");
 829   return Graphics::MemoryRequirements{};
 830 }
 831
 832 Graphics::MemoryRequirements TestGraphicsController::GetBufferMemoryRequirements(Graphics::Buffer& buffer) const
 833 {
 834   mCallStack.PushCall("GetBufferMemoryRequirements", "");
 835   return Graphics::MemoryRequirements{};
 836 }
 837
 838 const Graphics::TextureProperties& TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture)
 839 {
 840   static Graphics::TextureProperties textureProperties{};
 841   mCallStack.PushCall("GetTextureProperties", "");
 842
 843   return textureProperties;
 844 }
 845
 846 const Graphics::Reflection& TestGraphicsController::GetProgramReflection(const Graphics::Program& program)
 847 {
 848   mCallStack.PushCall("GetProgramReflection", "");
 849
 850   return static_cast<const TestGraphicsProgram*>(&program)->GetReflection();
 851 }
 852
 853 bool TestGraphicsController::PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const
 854 {
 855   mCallStack.PushCall("PipelineEquals", "");
 856   return false;
 857 }
 858
 859 bool TestGraphicsController::GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData)
 860 {
 861   mCallStack.PushCall("GetProgramParameter", "");
 862   auto graphicsProgram = Uncast<TestGraphicsProgram>(&program);
 863   return graphicsProgram->GetParameter(parameterId, outData);
 864 }
 865
 866 } // namespace Dali