dali/internal/graphics/gles-impl/gles-context.cpp

   1 /*
   2  * Copyright (c) 2023 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
  18 #include "gles-context.h"
  19 #include <dali/integration-api/adaptor-framework/render-surface-interface.h>
  20 #include <dali/integration-api/debug.h>
  21 #include <dali/integration-api/gl-abstraction.h>
  22 #include <dali/integration-api/gl-defines.h>
  23 #include <dali/internal/graphics/common/graphics-interface.h>
  24 #include <dali/public-api/math/math-utils.h>
  25
  26 #include "egl-graphics-controller.h"
  27 #include "gles-graphics-buffer.h"
  28 #include "gles-graphics-pipeline.h"
  29 #include "gles-graphics-program.h"
  30 #include "gles-graphics-render-pass.h"
  31 #include "gles-graphics-render-target.h"
  32 #include "gles-texture-dependency-checker.h"
  33
  34 #include <EGL/egl.h>
  35 #include <EGL/eglext.h>
  36 #include <map>
  37 #include <unordered_map>
  38
  39 namespace Dali::Graphics::GLES
  40 {
  41 struct Context::Impl
  42 {
  43   explicit Impl(EglGraphicsController& controller)
  44   : mController(controller)
  45   {
  46   }
  47
  48   ~Impl() = default;
  49
  50   /**
  51    * Binds (and creates) VAO
  52    *
  53    * VAO is fixed per program so it has to be created only once assuming
  54    * that VertexInputState has been set correctly for the pipeline.
  55    *
  56    */
  57   void BindProgramVAO(const GLES::ProgramImpl* program, const VertexInputState& vertexInputState)
  58   {
  59     // Calculate attributes location hash unordered.
  60     std::size_t hash = 0;
  61     for(const auto& attr : vertexInputState.attributes)
  62     {
  63       hash ^= std::hash<uint32_t>{}(attr.location);
  64     }
  65
  66     auto& gl   = *mController.GetGL();
  67     auto  iter = mProgramVAOMap.find(program);
  68     if(iter != mProgramVAOMap.end())
  69     {
  70       auto attributeIter = iter->second.find(hash);
  71       if(attributeIter != iter->second.end())
  72       {
  73         if(mProgramVAOCurrentState != attributeIter->second)
  74         {
  75           mProgramVAOCurrentState = attributeIter->second;
  76           gl.BindVertexArray(attributeIter->second);
  77
  78           // Binding VAO seems to reset the index buffer binding so the cache must be reset
  79           mGlStateCache.mBoundElementArrayBufferId = 0;
  80         }
  81         return;
  82       }
  83     }
  84
  85     uint32_t vao;
  86     gl.GenVertexArrays(1, &vao);
  87     gl.BindVertexArray(vao);
  88
  89     // Binding VAO seems to reset the index buffer binding so the cache must be reset
  90     mGlStateCache.mBoundElementArrayBufferId = 0;
  91
  92     mProgramVAOMap[program][hash] = vao;
  93     for(const auto& attr : vertexInputState.attributes)
  94     {
  95       gl.EnableVertexAttribArray(attr.location);
  96     }
  97
  98     mProgramVAOCurrentState = vao;
  99   }
 100
 101   /**
 102    * Sets the initial GL state.
 103    */
 104   void InitializeGlState()
 105   {
 106     auto& gl = *mController.GetGL();
 107
 108     mGlStateCache.mClearColorSet        = false;
 109     mGlStateCache.mColorMask            = true;
 110     mGlStateCache.mStencilMask          = 0xFF;
 111     mGlStateCache.mBlendEnabled         = false;
 112     mGlStateCache.mDepthBufferEnabled   = false;
 113     mGlStateCache.mDepthMaskEnabled     = false;
 114     mGlStateCache.mScissorTestEnabled   = false;
 115     mGlStateCache.mStencilBufferEnabled = false;
 116
 117     gl.Disable(GL_DITHER);
 118
 119     mGlStateCache.mBoundArrayBufferId        = 0;
 120     mGlStateCache.mBoundElementArrayBufferId = 0;
 121     mGlStateCache.mActiveTextureUnit         = 0;
 122
 123     mGlStateCache.mBlendFuncSeparateSrcRGB   = BlendFactor::ONE;
 124     mGlStateCache.mBlendFuncSeparateDstRGB   = BlendFactor::ZERO;
 125     mGlStateCache.mBlendFuncSeparateSrcAlpha = BlendFactor::ONE;
 126     mGlStateCache.mBlendFuncSeparateDstAlpha = BlendFactor::ZERO;
 127
 128     // initial state is GL_FUNC_ADD for both RGB and Alpha blend modes
 129     mGlStateCache.mBlendEquationSeparateModeRGB   = BlendOp::ADD;
 130     mGlStateCache.mBlendEquationSeparateModeAlpha = BlendOp::ADD;
 131
 132     mGlStateCache.mCullFaceMode = CullMode::NONE; //By default cullface is disabled, front face is set to CCW and cull face is set to back
 133
 134     //Initialze vertex attribute cache
 135     memset(&mGlStateCache.mVertexAttributeCachedState, 0, sizeof(mGlStateCache.mVertexAttributeCachedState));
 136     memset(&mGlStateCache.mVertexAttributeCurrentState, 0, sizeof(mGlStateCache.mVertexAttributeCurrentState));
 137
 138     //Initialize bound 2d texture cache
 139     memset(&mGlStateCache.mBoundTextureId, 0, sizeof(mGlStateCache.mBoundTextureId));
 140
 141     mGlStateCache.mFrameBufferStateCache.Reset();
 142
 143     GLint maxTextures;
 144     gl.GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextures);
 145     DALI_LOG_RELEASE_INFO("GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: %d\n", maxTextures);
 146   }
 147
 148   /**
 149    * Flushes vertex attribute location changes to the driver
 150    */
 151   void FlushVertexAttributeLocations()
 152   {
 153     auto& gl = *mController.GetGL();
 154
 155     for(unsigned int i = 0; i < MAX_ATTRIBUTE_CACHE_SIZE; ++i)
 156     {
 157       // see if the cached state is different to the actual state
 158       if(mGlStateCache.mVertexAttributeCurrentState[i] != mGlStateCache.mVertexAttributeCachedState[i])
 159       {
 160         // it's different so make the change to the driver and update the cached state
 161         mGlStateCache.mVertexAttributeCurrentState[i] = mGlStateCache.mVertexAttributeCachedState[i];
 162
 163         if(mGlStateCache.mVertexAttributeCurrentState[i])
 164         {
 165           gl.EnableVertexAttribArray(i);
 166         }
 167         else
 168         {
 169           gl.DisableVertexAttribArray(i);
 170         }
 171       }
 172     }
 173   }
 174
 175   /**
 176    * Either enables or disables a vertex attribute location in the cache
 177    * The cahnges won't take affect until FlushVertexAttributeLocations is called
 178    * @param location attribute location
 179    * @param state attribute state
 180    */
 181   void SetVertexAttributeLocation(unsigned int location, bool state)
 182   {
 183     auto& gl = *mController.GetGL();
 184
 185     if(location >= MAX_ATTRIBUTE_CACHE_SIZE)
 186     {
 187       // not cached, make the gl call through context
 188       if(state)
 189       {
 190         gl.EnableVertexAttribArray(location);
 191       }
 192       else
 193       {
 194         gl.DisableVertexAttribArray(location);
 195       }
 196     }
 197     else
 198     {
 199       // set the cached state, it will be set at the next draw call
 200       // if it's different from the current driver state
 201       mGlStateCache.mVertexAttributeCachedState[location] = state;
 202     }
 203   }
 204
 205   EglGraphicsController& mController;
 206
 207   const GLES::PipelineImpl* mCurrentPipeline{nullptr}; ///< Currently bound pipeline
 208   const GLES::PipelineImpl* mNewPipeline{nullptr};     ///< New pipeline to be set on flush
 209
 210   std::vector<Graphics::TextureBinding> mCurrentTextureBindings{};
 211   std::vector<Graphics::SamplerBinding> mCurrentSamplerBindings{};
 212   GLES::IndexBufferBindingDescriptor    mCurrentIndexBufferBinding{};
 213
 214   struct VertexBufferBinding
 215   {
 216     GLES::Buffer* buffer{nullptr};
 217     uint32_t      offset{0u};
 218   };
 219
 220   // Currently bound buffers
 221   std::vector<VertexBufferBindingDescriptor> mCurrentVertexBufferBindings{};
 222
 223   // Currently bound UBOs (check if it's needed per program!)
 224   std::vector<UniformBufferBindingDescriptor> mCurrentUBOBindings{};
 225   UniformBufferBindingDescriptor              mCurrentStandaloneUBOBinding{};
 226
 227   // Current render pass and render target
 228   const GLES::RenderTarget* mCurrentRenderTarget{nullptr};
 229   const GLES::RenderPass*   mCurrentRenderPass{nullptr};
 230
 231   // Each context must have own VAOs as they cannot be shared
 232   std::unordered_map<const GLES::ProgramImpl*, std::map<std::size_t, uint32_t>> mProgramVAOMap;              ///< GL program-VAO map
 233   uint32_t                                                                      mProgramVAOCurrentState{0u}; ///< Currently bound VAO
 234   GLStateCache                                                                  mGlStateCache{};             ///< GL status cache
 235
 236   bool mGlContextCreated{false};    ///< True if the OpenGL context has been created
 237   bool mVertexBuffersChanged{true}; ///< True if BindVertexBuffers changed any buffer bindings
 238
 239   EGLContext mNativeDrawContext{0u}; ///< Native rendering EGL context compatible with window context
 240
 241   EGLSurface mCacheDrawReadSurface{0u};    ///< cached 'read' surface
 242   EGLSurface mCacheDrawWriteSurface{0u};   ///< cached 'write' surface
 243   EGLContext mCacheEGLGraphicsContext{0u}; ///< cached window context
 244 };
 245
 246 Context::Context(EglGraphicsController& controller)
 247 {
 248   mImpl = std::make_unique<Impl>(controller);
 249 }
 250
 251 Context::~Context()
 252 {
 253   // Destroy native rendering context if one exists
 254   if(mImpl->mNativeDrawContext)
 255   {
 256     eglDestroyContext(eglGetCurrentDisplay(), mImpl->mNativeDrawContext);
 257     mImpl->mNativeDrawContext = EGL_NO_CONTEXT;
 258   }
 259 }
 260
 261 void Context::Flush(bool reset, const GLES::DrawCallDescriptor& drawCall, GLES::TextureDependencyChecker& dependencyChecker)
 262 {
 263   auto& gl = *mImpl->mController.GetGL();
 264
 265   static const bool hasGLES3(mImpl->mController.GetGLESVersion() >= GLESVersion::GLES_30);
 266
 267   // early out if neither current nor new pipelines are set
 268   // this behaviour may be valid so no assert
 269   if(!mImpl->mCurrentPipeline && !mImpl->mNewPipeline)
 270   {
 271     return;
 272   }
 273
 274   // Execute states if pipeline is changed
 275   const auto currentProgram = mImpl->mCurrentPipeline ? static_cast<const GLES::Program*>(mImpl->mCurrentPipeline->GetCreateInfo().programState->program) : nullptr;
 276
 277   // case when new pipeline has been set
 278   const GLES::Program* newProgram = nullptr;
 279
 280   if(mImpl->mNewPipeline)
 281   {
 282     newProgram = static_cast<const GLES::Program*>(mImpl->mNewPipeline->GetCreateInfo().programState->program);
 283   }
 284
 285   if(!currentProgram && !newProgram)
 286   {
 287     // Early out if we have no program for this pipeline.
 288     DALI_LOG_ERROR("No program defined for pipeline\n");
 289     return;
 290   }
 291
 292   // If this draw uses a different pipeline _AND_ the pipeline has a different GL Program,
 293   // Then bind the new program. Ensure vertex atrributes are set.
 294
 295   bool programChanged = false;
 296   if(mImpl->mNewPipeline && mImpl->mCurrentPipeline != mImpl->mNewPipeline)
 297   {
 298     if(!currentProgram || currentProgram->GetImplementation()->GetGlProgram() != newProgram->GetImplementation()->GetGlProgram())
 299     {
 300       mImpl->mNewPipeline->Bind(newProgram->GetImplementation()->GetGlProgram());
 301       programChanged = true;
 302     }
 303
 304     // Blend state
 305     ResolveBlendState();
 306
 307     // Resolve rasterization state
 308     ResolveRasterizationState();
 309   }
 310
 311   // Resolve uniform buffers
 312   ResolveUniformBuffers();
 313
 314   // Bind textures
 315   // Map binding# to sampler location
 316   const auto& reflection = !newProgram ? currentProgram->GetReflection() : newProgram->GetReflection();
 317   const auto& samplers   = reflection.GetSamplers();
 318
 319   uint32_t currentSampler = 0;
 320   uint32_t currentElement = 0;
 321
 322   // @warning Assume that binding.binding is strictly linear in the same order as mCurrentTextureBindings
 323   // elements. This avoids having to sort the bindings.
 324   for(const auto& binding : mImpl->mCurrentTextureBindings)
 325   {
 326     auto texture = const_cast<GLES::Texture*>(static_cast<const GLES::Texture*>(binding.texture));
 327
 328     // Texture may not have been initialized yet...(tbm_surface timing issue?)
 329     if(!texture->GetGLTexture())
 330     {
 331       texture->InitializeResource();
 332     }
 333
 334     // Warning, this may cause glWaitSync to occur on the GPU.
 335     dependencyChecker.CheckNeedsSync(this, texture);
 336     texture->Bind(binding);
 337     texture->Prepare();
 338
 339     if(programChanged)
 340     {
 341       // @warning Assume that location of array elements is sequential.
 342       // @warning GL does not guarantee this, but in practice, it is.
 343       gl.Uniform1i(samplers[currentSampler].location + currentElement,
 344                    samplers[currentSampler].offset + currentElement);
 345       ++currentElement;
 346       if(currentElement >= samplers[currentSampler].elementCount)
 347       {
 348         ++currentSampler;
 349         currentElement = 0;
 350       }
 351     }
 352     if(currentSampler >= samplers.size())
 353     {
 354       // Don't bind more textures than there are active samplers.
 355       break;
 356     }
 357   }
 358
 359   const auto& pipelineState    = mImpl->mNewPipeline ? mImpl->mNewPipeline->GetCreateInfo() : mImpl->mCurrentPipeline->GetCreateInfo();
 360   const auto& vertexInputState = pipelineState.vertexInputState;
 361
 362   // for each attribute bind vertices, unless the pipeline+buffer is the same
 363   if(programChanged || mImpl->mVertexBuffersChanged)
 364   {
 365     if(hasGLES3)
 366     {
 367       mImpl->BindProgramVAO(static_cast<const GLES::Program*>(pipelineState.programState->program)->GetImplementation(), *vertexInputState);
 368     }
 369
 370     for(const auto& attr : vertexInputState->attributes)
 371     {
 372       // Enable location
 373       if(!hasGLES3)
 374       {
 375         mImpl->SetVertexAttributeLocation(attr.location, true);
 376       }
 377
 378       const auto& bufferSlot    = mImpl->mCurrentVertexBufferBindings[attr.binding];
 379       const auto& bufferBinding = vertexInputState->bufferBindings[attr.binding];
 380
 381       auto glesBuffer = bufferSlot.buffer->GetGLBuffer();
 382
 383       BindBuffer(GL_ARRAY_BUFFER, glesBuffer); // Cached
 384
 385       if(attr.format == VertexInputFormat::FLOAT ||
 386          attr.format == VertexInputFormat::FVECTOR2 ||
 387          attr.format == VertexInputFormat::FVECTOR3 ||
 388          attr.format == VertexInputFormat::FVECTOR4)
 389       {
 390         gl.VertexAttribPointer(attr.location, // Not cached...
 391                                GLVertexFormat(attr.format).size,
 392                                GLVertexFormat(attr.format).format,
 393                                GL_FALSE,
 394                                bufferBinding.stride,
 395                                reinterpret_cast<void*>(attr.offset));
 396       }
 397       else
 398       {
 399         gl.VertexAttribIPointer(attr.location,
 400                                 GLVertexFormat(attr.format).size,
 401                                 GLVertexFormat(attr.format).format,
 402                                 bufferBinding.stride,
 403                                 reinterpret_cast<void*>(attr.offset));
 404       }
 405
 406       switch(bufferBinding.inputRate)
 407       {
 408         case Graphics::VertexInputRate::PER_VERTEX:
 409         {
 410           gl.VertexAttribDivisor(attr.location, 0);
 411           break;
 412         }
 413         case Graphics::VertexInputRate::PER_INSTANCE:
 414         {
 415           //@todo Get actual instance rate...
 416           gl.VertexAttribDivisor(attr.location, 1);
 417           break;
 418         }
 419       }
 420     }
 421   }
 422
 423   // Resolve topology
 424   const auto& ia = pipelineState.inputAssemblyState;
 425
 426   // Resolve draw call
 427   switch(drawCall.type)
 428   {
 429     case DrawCallDescriptor::Type::DRAW:
 430     {
 431       mImpl->mGlStateCache.mFrameBufferStateCache.DrawOperation(mImpl->mGlStateCache.mColorMask,
 432                                                                 mImpl->mGlStateCache.DepthBufferWriteEnabled(),
 433                                                                 mImpl->mGlStateCache.StencilBufferWriteEnabled());
 434       // For GLES3+ we use VAO, for GLES2 internal cache
 435       if(!hasGLES3)
 436       {
 437         mImpl->FlushVertexAttributeLocations();
 438       }
 439
 440       if(drawCall.draw.instanceCount == 0)
 441       {
 442         gl.DrawArrays(GLESTopology(ia->topology),
 443                       drawCall.draw.firstVertex,
 444                       drawCall.draw.vertexCount);
 445       }
 446       else
 447       {
 448         gl.DrawArraysInstanced(GLESTopology(ia->topology),
 449                                drawCall.draw.firstVertex,
 450                                drawCall.draw.vertexCount,
 451                                drawCall.draw.instanceCount);
 452       }
 453       break;
 454     }
 455     case DrawCallDescriptor::Type::DRAW_INDEXED:
 456     {
 457       const auto& binding = mImpl->mCurrentIndexBufferBinding;
 458       BindBuffer(GL_ELEMENT_ARRAY_BUFFER, binding.buffer->GetGLBuffer());
 459
 460       mImpl->mGlStateCache.mFrameBufferStateCache.DrawOperation(mImpl->mGlStateCache.mColorMask,
 461                                                                 mImpl->mGlStateCache.DepthBufferWriteEnabled(),
 462                                                                 mImpl->mGlStateCache.StencilBufferWriteEnabled());
 463
 464       // For GLES3+ we use VAO, for GLES2 internal cache
 465       if(!hasGLES3)
 466       {
 467         mImpl->FlushVertexAttributeLocations();
 468       }
 469
 470       auto indexBufferFormat = GLIndexFormat(binding.format).format;
 471       if(drawCall.drawIndexed.instanceCount == 0)
 472       {
 473         gl.DrawElements(GLESTopology(ia->topology),
 474                         drawCall.drawIndexed.indexCount,
 475                         indexBufferFormat,
 476                         reinterpret_cast<void*>(binding.offset));
 477       }
 478       else
 479       {
 480         gl.DrawElementsInstanced(GLESTopology(ia->topology),
 481                                  drawCall.drawIndexed.indexCount,
 482                                  indexBufferFormat,
 483                                  reinterpret_cast<void*>(binding.offset),
 484                                  drawCall.drawIndexed.instanceCount);
 485       }
 486       break;
 487     }
 488     case DrawCallDescriptor::Type::DRAW_INDEXED_INDIRECT:
 489     {
 490       break;
 491     }
 492   }
 493
 494   ClearState();
 495
 496   // Change pipeline
 497   if(mImpl->mNewPipeline)
 498   {
 499     mImpl->mCurrentPipeline = mImpl->mNewPipeline;
 500     mImpl->mNewPipeline     = nullptr;
 501   }
 502 }
 503
 504 void Context::BindTextures(const Graphics::TextureBinding* bindings, uint32_t count)
 505 {
 506   // for each texture allocate slot
 507   for(auto i = 0u; i < count; ++i)
 508   {
 509     auto& binding = bindings[i];
 510
 511     // Resize binding array if needed
 512     if(mImpl->mCurrentTextureBindings.size() <= binding.binding)
 513     {
 514       mImpl->mCurrentTextureBindings.resize(binding.binding + 1);
 515     }
 516     // Store the binding details
 517     mImpl->mCurrentTextureBindings[binding.binding] = binding;
 518   }
 519 }
 520
 521 void Context::BindVertexBuffers(const GLES::VertexBufferBindingDescriptor* bindings, uint32_t count)
 522 {
 523   if(count > mImpl->mCurrentVertexBufferBindings.size())
 524   {
 525     mImpl->mCurrentVertexBufferBindings.resize(count);
 526   }
 527   // Copy only set slots
 528   mImpl->mVertexBuffersChanged = false;
 529   auto toIter                  = mImpl->mCurrentVertexBufferBindings.begin();
 530   for(auto fromIter = bindings, end = bindings + count; fromIter != end; ++fromIter)
 531   {
 532     if(fromIter->buffer != nullptr)
 533     {
 534       if(toIter->buffer != fromIter->buffer || toIter->offset != fromIter->offset)
 535       {
 536         mImpl->mVertexBuffersChanged = true;
 537       }
 538       *toIter++ = *fromIter;
 539     }
 540   }
 541 }
 542
 543 void Context::BindIndexBuffer(const IndexBufferBindingDescriptor& indexBufferBinding)
 544 {
 545   mImpl->mCurrentIndexBufferBinding = indexBufferBinding;
 546 }
 547
 548 void Context::BindPipeline(const GLES::Pipeline* newPipeline)
 549 {
 550   DALI_ASSERT_ALWAYS(newPipeline && "Invalid pipeline");
 551   mImpl->mNewPipeline = &newPipeline->GetPipeline();
 552 }
 553
 554 void Context::BindUniformBuffers(const UniformBufferBindingDescriptor* uboBindings,
 555                                  uint32_t                              uboCount,
 556                                  const UniformBufferBindingDescriptor& standaloneBindings)
 557 {
 558   if(standaloneBindings.buffer)
 559   {
 560     mImpl->mCurrentStandaloneUBOBinding = standaloneBindings;
 561   }
 562
 563   if(uboCount >= mImpl->mCurrentUBOBindings.size())
 564   {
 565     mImpl->mCurrentUBOBindings.resize(uboCount + 1);
 566   }
 567
 568   auto it = uboBindings;
 569   for(auto i = 0u; i < uboCount; ++i)
 570   {
 571     if(it->buffer)
 572     {
 573       mImpl->mCurrentUBOBindings[i] = *it;
 574     }
 575   }
 576 }
 577
 578 void Context::ResolveBlendState()
 579 {
 580   const auto& currentBlendState = mImpl->mCurrentPipeline ? mImpl->mCurrentPipeline->GetCreateInfo().colorBlendState : nullptr;
 581   const auto& newBlendState     = mImpl->mNewPipeline->GetCreateInfo().colorBlendState;
 582
 583   // TODO: prevent leaking the state
 584   if(!newBlendState)
 585   {
 586     return;
 587   }
 588
 589   auto& gl = *mImpl->mController.GetGL();
 590
 591   if(!currentBlendState || currentBlendState->blendEnable != newBlendState->blendEnable)
 592   {
 593     if(newBlendState->blendEnable != mImpl->mGlStateCache.mBlendEnabled)
 594     {
 595       mImpl->mGlStateCache.mBlendEnabled = newBlendState->blendEnable;
 596       newBlendState->blendEnable ? gl.Enable(GL_BLEND) : gl.Disable(GL_BLEND);
 597     }
 598   }
 599
 600   if(!newBlendState->blendEnable)
 601   {
 602     return;
 603   }
 604
 605   BlendFactor newSrcRGB(newBlendState->srcColorBlendFactor);
 606   BlendFactor newDstRGB(newBlendState->dstColorBlendFactor);
 607   BlendFactor newSrcAlpha(newBlendState->srcAlphaBlendFactor);
 608   BlendFactor newDstAlpha(newBlendState->dstAlphaBlendFactor);
 609
 610   if(!currentBlendState ||
 611      currentBlendState->srcColorBlendFactor != newSrcRGB ||
 612      currentBlendState->dstColorBlendFactor != newDstRGB ||
 613      currentBlendState->srcAlphaBlendFactor != newSrcAlpha ||
 614      currentBlendState->dstAlphaBlendFactor != newDstAlpha)
 615   {
 616     if((mImpl->mGlStateCache.mBlendFuncSeparateSrcRGB != newSrcRGB) ||
 617        (mImpl->mGlStateCache.mBlendFuncSeparateDstRGB != newDstRGB) ||
 618        (mImpl->mGlStateCache.mBlendFuncSeparateSrcAlpha != newSrcAlpha) ||
 619        (mImpl->mGlStateCache.mBlendFuncSeparateDstAlpha != newDstAlpha))
 620     {
 621       mImpl->mGlStateCache.mBlendFuncSeparateSrcRGB   = newSrcRGB;
 622       mImpl->mGlStateCache.mBlendFuncSeparateDstRGB   = newDstRGB;
 623       mImpl->mGlStateCache.mBlendFuncSeparateSrcAlpha = newSrcAlpha;
 624       mImpl->mGlStateCache.mBlendFuncSeparateDstAlpha = newDstAlpha;
 625
 626       if(newSrcRGB == newSrcAlpha && newDstRGB == newDstAlpha)
 627       {
 628         gl.BlendFunc(GLBlendFunc(newSrcRGB), GLBlendFunc(newDstRGB));
 629       }
 630       else
 631       {
 632         gl.BlendFuncSeparate(GLBlendFunc(newSrcRGB), GLBlendFunc(newDstRGB), GLBlendFunc(newSrcAlpha), GLBlendFunc(newDstAlpha));
 633       }
 634     }
 635   }
 636
 637   if(!currentBlendState ||
 638      currentBlendState->colorBlendOp != newBlendState->colorBlendOp ||
 639      currentBlendState->alphaBlendOp != newBlendState->alphaBlendOp)
 640   {
 641     if(mImpl->mGlStateCache.mBlendEquationSeparateModeRGB != newBlendState->colorBlendOp ||
 642        mImpl->mGlStateCache.mBlendEquationSeparateModeAlpha != newBlendState->alphaBlendOp)
 643     {
 644       mImpl->mGlStateCache.mBlendEquationSeparateModeRGB   = newBlendState->colorBlendOp;
 645       mImpl->mGlStateCache.mBlendEquationSeparateModeAlpha = newBlendState->alphaBlendOp;
 646
 647       if(newBlendState->colorBlendOp == newBlendState->alphaBlendOp)
 648       {
 649         gl.BlendEquation(GLBlendOp(newBlendState->colorBlendOp));
 650         if(newBlendState->colorBlendOp >= Graphics::ADVANCED_BLEND_OPTIONS_START)
 651         {
 652           gl.BlendBarrier();
 653         }
 654       }
 655       else
 656       {
 657         gl.BlendEquationSeparate(GLBlendOp(newBlendState->colorBlendOp), GLBlendOp(newBlendState->alphaBlendOp));
 658       }
 659     }
 660   }
 661 }
 662
 663 void Context::ResolveRasterizationState()
 664 {
 665   const auto& currentRasterizationState = mImpl->mCurrentPipeline ? mImpl->mCurrentPipeline->GetCreateInfo().rasterizationState : nullptr;
 666   const auto& newRasterizationState     = mImpl->mNewPipeline->GetCreateInfo().rasterizationState;
 667
 668   // TODO: prevent leaking the state
 669   if(!newRasterizationState)
 670   {
 671     return;
 672   }
 673
 674   auto& gl = *mImpl->mController.GetGL();
 675
 676   if(!currentRasterizationState ||
 677      currentRasterizationState->cullMode != newRasterizationState->cullMode)
 678   {
 679     if(mImpl->mGlStateCache.mCullFaceMode != newRasterizationState->cullMode)
 680     {
 681       mImpl->mGlStateCache.mCullFaceMode = newRasterizationState->cullMode;
 682       if(newRasterizationState->cullMode == CullMode::NONE)
 683       {
 684         gl.Disable(GL_CULL_FACE);
 685       }
 686       else
 687       {
 688         gl.Enable(GL_CULL_FACE);
 689         gl.CullFace(GLCullMode(newRasterizationState->cullMode));
 690       }
 691     }
 692   }
 693   // TODO: implement polygon mode (fill, line, points)
 694   //       seems like we don't support it (no glPolygonMode())
 695 }
 696
 697 void Context::ResolveUniformBuffers()
 698 {
 699   // Resolve standalone uniforms if we have binding
 700   if(mImpl->mCurrentStandaloneUBOBinding.buffer)
 701   {
 702     ResolveStandaloneUniforms();
 703   }
 704 }
 705
 706 void Context::ResolveStandaloneUniforms()
 707 {
 708   // Find reflection for program
 709   const GLES::Program* program{nullptr};
 710
 711   if(mImpl->mNewPipeline)
 712   {
 713     program = static_cast<const GLES::Program*>(mImpl->mNewPipeline->GetCreateInfo().programState->program);
 714   }
 715   else if(mImpl->mCurrentPipeline)
 716   {
 717     program = static_cast<const GLES::Program*>(mImpl->mCurrentPipeline->GetCreateInfo().programState->program);
 718   }
 719
 720   if(program)
 721   {
 722     const auto ptr = reinterpret_cast<const char*>(mImpl->mCurrentStandaloneUBOBinding.buffer->GetCPUAllocatedAddress()) + mImpl->mCurrentStandaloneUBOBinding.offset;
 723     // Update program uniforms
 724     program->GetImplementation()->UpdateStandaloneUniformBlock(ptr);
 725   }
 726 }
 727
 728 void Context::BeginRenderPass(const BeginRenderPassDescriptor& renderPassBegin)
 729 {
 730   auto& renderPass   = *renderPassBegin.renderPass;
 731   auto& renderTarget = *renderPassBegin.renderTarget;
 732
 733   const auto& targetInfo = renderTarget.GetCreateInfo();
 734
 735   auto& gl = *mImpl->mController.GetGL();
 736
 737   if(targetInfo.surface)
 738   {
 739     // Bind surface FB
 740     BindFrameBuffer(GL_FRAMEBUFFER, 0);
 741   }
 742   else if(targetInfo.framebuffer)
 743   {
 744     // bind framebuffer and swap.
 745     auto framebuffer = renderTarget.GetFramebuffer();
 746     framebuffer->Bind();
 747   }
 748
 749   // clear (ideally cache the setup)
 750
 751   // In GL we assume that the last attachment is depth/stencil (we may need
 752   // to cache extra information inside GLES RenderTarget if we want to be
 753   // more specific in case of MRT)
 754
 755   const auto& attachments = *renderPass.GetCreateInfo().attachments;
 756   const auto& color0      = attachments[0];
 757   GLuint      mask        = 0;
 758
 759   if(color0.loadOp == AttachmentLoadOp::CLEAR)
 760   {
 761     mask |= GL_COLOR_BUFFER_BIT;
 762
 763     // Set clear color
 764     // Something goes wrong here if Alpha mask is GL_TRUE
 765     ColorMask(true);
 766
 767     const auto clearValues = renderPassBegin.clearValues.Ptr();
 768
 769     if(!Dali::Equals(mImpl->mGlStateCache.mClearColor.r, clearValues[0].color.r) ||
 770        !Dali::Equals(mImpl->mGlStateCache.mClearColor.g, clearValues[0].color.g) ||
 771        !Dali::Equals(mImpl->mGlStateCache.mClearColor.b, clearValues[0].color.b) ||
 772        !Dali::Equals(mImpl->mGlStateCache.mClearColor.a, clearValues[0].color.a) ||
 773        !mImpl->mGlStateCache.mClearColorSet)
 774     {
 775       gl.ClearColor(clearValues[0].color.r,
 776                     clearValues[0].color.g,
 777                     clearValues[0].color.b,
 778                     clearValues[0].color.a);
 779
 780       mImpl->mGlStateCache.mClearColorSet = true;
 781       mImpl->mGlStateCache.mClearColor    = Vector4(clearValues[0].color.r,
 782                                                  clearValues[0].color.g,
 783                                                  clearValues[0].color.b,
 784                                                  clearValues[0].color.a);
 785     }
 786   }
 787
 788   // check for depth stencil
 789   if(attachments.size() > 1)
 790   {
 791     const auto& depthStencil = attachments.back();
 792     if(depthStencil.loadOp == AttachmentLoadOp::CLEAR)
 793     {
 794       if(!mImpl->mGlStateCache.mDepthMaskEnabled)
 795       {
 796         mImpl->mGlStateCache.mDepthMaskEnabled = true;
 797         gl.DepthMask(true);
 798       }
 799       mask |= GL_DEPTH_BUFFER_BIT;
 800     }
 801     if(depthStencil.stencilLoadOp == AttachmentLoadOp::CLEAR)
 802     {
 803       if(mImpl->mGlStateCache.mStencilMask != 0xFF)
 804       {
 805         mImpl->mGlStateCache.mStencilMask = 0xFF;
 806         gl.StencilMask(0xFF);
 807       }
 808       mask |= GL_STENCIL_BUFFER_BIT;
 809     }
 810   }
 811
 812   SetScissorTestEnabled(true);
 813   gl.Scissor(renderPassBegin.renderArea.x, renderPassBegin.renderArea.y, renderPassBegin.renderArea.width, renderPassBegin.renderArea.height);
 814   ClearBuffer(mask, true);
 815   SetScissorTestEnabled(false);
 816
 817   mImpl->mCurrentRenderPass   = &renderPass;
 818   mImpl->mCurrentRenderTarget = &renderTarget;
 819 }
 820
 821 void Context::EndRenderPass(GLES::TextureDependencyChecker& dependencyChecker)
 822 {
 823   if(mImpl->mCurrentRenderTarget)
 824   {
 825     GLES::Framebuffer* framebuffer = mImpl->mCurrentRenderTarget->GetFramebuffer();
 826     if(framebuffer)
 827     {
 828       auto& gl = *mImpl->mController.GetGL();
 829       gl.Flush();
 830
 831       /* @todo Full dependency checking would need to store textures in Begin, and create
 832        * fence objects here; but we're going to draw all fbos on shared context in serial,
 833        * so no real need (yet). Might want to consider ensuring order of render passes,
 834        * but that needs doing in the controller, and would need doing before ProcessCommandQueues.
 835        *
 836        * Currently up to the client to create render tasks in the right order.
 837        */
 838
 839       /* Create fence sync objects. Other contexts can then wait on these fences before reading
 840        * textures.
 841        */
 842       dependencyChecker.AddTextures(this, framebuffer);
 843     }
 844   }
 845 }
 846
 847 void Context::ClearState()
 848 {
 849   mImpl->mCurrentTextureBindings.clear();
 850 }
 851
 852 void Context::ColorMask(bool enabled)
 853 {
 854   if(enabled != mImpl->mGlStateCache.mColorMask)
 855   {
 856     mImpl->mGlStateCache.mColorMask = enabled;
 857
 858     auto& gl = *mImpl->mController.GetGL();
 859     gl.ColorMask(enabled, enabled, enabled, enabled);
 860   }
 861 }
 862
 863 void Context::ClearStencilBuffer()
 864 {
 865   ClearBuffer(GL_STENCIL_BUFFER_BIT, false);
 866 }
 867
 868 void Context::ClearDepthBuffer()
 869 {
 870   ClearBuffer(GL_DEPTH_BUFFER_BIT, false);
 871 }
 872
 873 void Context::ClearBuffer(uint32_t mask, bool forceClear)
 874 {
 875   mask = mImpl->mGlStateCache.mFrameBufferStateCache.GetClearMask(mask, forceClear, mImpl->mGlStateCache.mScissorTestEnabled);
 876   if(mask > 0)
 877   {
 878     auto& gl = *mImpl->mController.GetGL();
 879     gl.Clear(mask);
 880   }
 881 }
 882
 883 void Context::InvalidateDepthStencilBuffers()
 884 {
 885   auto& gl = *mImpl->mController.GetGL();
 886
 887   GLenum attachments[] = {GL_DEPTH, GL_STENCIL};
 888   gl.InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
 889 }
 890
 891 void Context::SetScissorTestEnabled(bool scissorEnabled)
 892 {
 893   if(mImpl->mGlStateCache.mScissorTestEnabled != scissorEnabled)
 894   {
 895     mImpl->mGlStateCache.mScissorTestEnabled = scissorEnabled;
 896
 897     auto& gl = *mImpl->mController.GetGL();
 898     if(scissorEnabled)
 899     {
 900       gl.Enable(GL_SCISSOR_TEST);
 901     }
 902     else
 903     {
 904       gl.Disable(GL_SCISSOR_TEST);
 905     }
 906   }
 907 }
 908
 909 void Context::SetStencilTestEnable(bool stencilEnable)
 910 {
 911   if(stencilEnable != mImpl->mGlStateCache.mStencilBufferEnabled)
 912   {
 913     mImpl->mGlStateCache.mStencilBufferEnabled = stencilEnable;
 914
 915     auto& gl = *mImpl->mController.GetGL();
 916     if(stencilEnable)
 917     {
 918       gl.Enable(GL_STENCIL_TEST);
 919     }
 920     else
 921     {
 922       gl.Disable(GL_STENCIL_TEST);
 923     }
 924   }
 925 }
 926
 927 void Context::StencilMask(uint32_t writeMask)
 928 {
 929   if(writeMask != mImpl->mGlStateCache.mStencilMask)
 930   {
 931     mImpl->mGlStateCache.mStencilMask = writeMask;
 932
 933     auto& gl = *mImpl->mController.GetGL();
 934     gl.StencilMask(writeMask);
 935   }
 936 }
 937
 938 void Context::StencilFunc(Graphics::CompareOp compareOp,
 939                           uint32_t            reference,
 940                           uint32_t            compareMask)
 941 {
 942   if(compareOp != mImpl->mGlStateCache.mStencilFunc ||
 943      reference != mImpl->mGlStateCache.mStencilFuncRef ||
 944      compareMask != mImpl->mGlStateCache.mStencilFuncMask)
 945   {
 946     mImpl->mGlStateCache.mStencilFunc     = compareOp;
 947     mImpl->mGlStateCache.mStencilFuncRef  = reference;
 948     mImpl->mGlStateCache.mStencilFuncMask = compareMask;
 949
 950     auto& gl = *mImpl->mController.GetGL();
 951     gl.StencilFunc(GLCompareOp(compareOp).op, reference, compareMask);
 952   }
 953 }
 954
 955 void Context::StencilOp(Graphics::StencilOp failOp,
 956                         Graphics::StencilOp depthFailOp,
 957                         Graphics::StencilOp passOp)
 958 {
 959   if(failOp != mImpl->mGlStateCache.mStencilOpFail ||
 960      depthFailOp != mImpl->mGlStateCache.mStencilOpDepthFail ||
 961      passOp != mImpl->mGlStateCache.mStencilOpDepthPass)
 962   {
 963     mImpl->mGlStateCache.mStencilOpFail      = failOp;
 964     mImpl->mGlStateCache.mStencilOpDepthFail = depthFailOp;
 965     mImpl->mGlStateCache.mStencilOpDepthPass = passOp;
 966
 967     auto& gl = *mImpl->mController.GetGL();
 968     gl.StencilOp(GLStencilOp(failOp).op, GLStencilOp(depthFailOp).op, GLStencilOp(passOp).op);
 969   }
 970 }
 971
 972 void Context::SetDepthCompareOp(Graphics::CompareOp compareOp)
 973 {
 974   if(compareOp != mImpl->mGlStateCache.mDepthFunction)
 975   {
 976     mImpl->mGlStateCache.mDepthFunction = compareOp;
 977     auto& gl                            = *mImpl->mController.GetGL();
 978     gl.DepthFunc(GLCompareOp(compareOp).op);
 979   }
 980 }
 981
 982 void Context::SetDepthTestEnable(bool depthTestEnable)
 983 {
 984   if(depthTestEnable != mImpl->mGlStateCache.mDepthBufferEnabled)
 985   {
 986     mImpl->mGlStateCache.mDepthBufferEnabled = depthTestEnable;
 987
 988     auto& gl = *mImpl->mController.GetGL();
 989     if(depthTestEnable)
 990     {
 991       gl.Enable(GL_DEPTH_TEST);
 992     }
 993     else
 994     {
 995       gl.Disable(GL_DEPTH_TEST);
 996     }
 997   }
 998 }
 999
1000 void Context::SetDepthWriteEnable(bool depthWriteEnable)
1001 {
1002   if(depthWriteEnable != mImpl->mGlStateCache.mDepthMaskEnabled)
1003   {
1004     mImpl->mGlStateCache.mDepthMaskEnabled = depthWriteEnable;
1005
1006     auto& gl = *mImpl->mController.GetGL();
1007     gl.DepthMask(depthWriteEnable);
1008   }
1009 }
1010
1011 void Context::ActiveTexture(uint32_t textureBindingIndex)
1012 {
1013   if(mImpl->mGlStateCache.mActiveTextureUnit != textureBindingIndex)
1014   {
1015     mImpl->mGlStateCache.mActiveTextureUnit = textureBindingIndex;
1016
1017     auto& gl = *mImpl->mController.GetGL();
1018     gl.ActiveTexture(GL_TEXTURE0 + textureBindingIndex);
1019   }
1020 }
1021
1022 void Context::BindTexture(GLenum target, BoundTextureType textureTypeId, uint32_t textureId)
1023 {
1024   uint32_t typeId = static_cast<uint32_t>(textureTypeId);
1025   if(mImpl->mGlStateCache.mBoundTextureId[mImpl->mGlStateCache.mActiveTextureUnit][typeId] != textureId)
1026   {
1027     mImpl->mGlStateCache.mBoundTextureId[mImpl->mGlStateCache.mActiveTextureUnit][typeId] = textureId;
1028
1029     auto& gl = *mImpl->mController.GetGL();
1030     gl.BindTexture(target, textureId);
1031   }
1032 }
1033
1034 void Context::GenerateMipmap(GLenum target)
1035 {
1036   auto& gl = *mImpl->mController.GetGL();
1037   gl.GenerateMipmap(target);
1038 }
1039
1040 bool Context::BindBuffer(GLenum target, uint32_t bufferId)
1041 {
1042   switch(target)
1043   {
1044     case GL_ARRAY_BUFFER:
1045     {
1046       if(mImpl->mGlStateCache.mBoundArrayBufferId == bufferId)
1047       {
1048         return false;
1049       }
1050       mImpl->mGlStateCache.mBoundArrayBufferId = bufferId;
1051       break;
1052     }
1053     case GL_ELEMENT_ARRAY_BUFFER:
1054     {
1055       if(mImpl->mGlStateCache.mBoundElementArrayBufferId == bufferId)
1056       {
1057         return false;
1058       }
1059       mImpl->mGlStateCache.mBoundElementArrayBufferId = bufferId;
1060       break;
1061     }
1062   }
1063
1064   // Cache miss. Bind buffer.
1065   auto& gl = *mImpl->mController.GetGL();
1066   gl.BindBuffer(target, bufferId);
1067   return true;
1068 }
1069
1070 void Context::DrawBuffers(uint32_t count, const GLenum* buffers)
1071 {
1072   mImpl->mGlStateCache.mFrameBufferStateCache.DrawOperation(mImpl->mGlStateCache.mColorMask,
1073                                                             mImpl->mGlStateCache.DepthBufferWriteEnabled(),
1074                                                             mImpl->mGlStateCache.StencilBufferWriteEnabled());
1075
1076   auto& gl = *mImpl->mController.GetGL();
1077   gl.DrawBuffers(count, buffers);
1078 }
1079
1080 void Context::BindFrameBuffer(GLenum target, uint32_t bufferId)
1081 {
1082   mImpl->mGlStateCache.mFrameBufferStateCache.SetCurrentFrameBuffer(bufferId);
1083
1084   auto& gl = *mImpl->mController.GetGL();
1085   gl.BindFramebuffer(target, bufferId);
1086 }
1087
1088 void Context::GenFramebuffers(uint32_t count, uint32_t* framebuffers)
1089 {
1090   auto& gl = *mImpl->mController.GetGL();
1091   gl.GenFramebuffers(count, framebuffers);
1092
1093   mImpl->mGlStateCache.mFrameBufferStateCache.FrameBuffersCreated(count, framebuffers);
1094 }
1095
1096 void Context::DeleteFramebuffers(uint32_t count, uint32_t* framebuffers)
1097 {
1098   mImpl->mGlStateCache.mFrameBufferStateCache.FrameBuffersDeleted(count, framebuffers);
1099
1100   auto& gl = *mImpl->mController.GetGL();
1101   gl.DeleteFramebuffers(count, framebuffers);
1102 }
1103
1104 GLStateCache& Context::GetGLStateCache()
1105 {
1106   return mImpl->mGlStateCache;
1107 }
1108
1109 void Context::GlContextCreated()
1110 {
1111   if(!mImpl->mGlContextCreated)
1112   {
1113     mImpl->mGlContextCreated = true;
1114
1115     // Set the initial GL state
1116     mImpl->InitializeGlState();
1117   }
1118 }
1119
1120 void Context::GlContextDestroyed()
1121 {
1122   mImpl->mGlContextCreated = false;
1123 }
1124
1125 void Context::InvalidateCachedPipeline(GLES::Pipeline* pipeline)
1126 {
1127   // Since the pipeline is deleted, invalidate the cached pipeline.
1128   if(mImpl->mCurrentPipeline == &pipeline->GetPipeline())
1129   {
1130     mImpl->mCurrentPipeline = nullptr;
1131   }
1132
1133   // Remove cached VAO map
1134   auto* gl = mImpl->mController.GetGL();
1135   if(gl)
1136   {
1137     const auto* program = pipeline->GetCreateInfo().programState->program;
1138     if(program)
1139     {
1140       const auto* programImpl = static_cast<const GLES::Program*>(program)->GetImplementation();
1141       if(programImpl)
1142       {
1143         auto iter = mImpl->mProgramVAOMap.find(programImpl);
1144         if(iter != mImpl->mProgramVAOMap.end())
1145         {
1146           for(auto& attributeHashPair : iter->second)
1147           {
1148             auto vao = attributeHashPair.second;
1149             gl->DeleteVertexArrays(1, &vao);
1150             if(mImpl->mProgramVAOCurrentState == vao)
1151             {
1152               mImpl->mProgramVAOCurrentState = 0u;
1153             }
1154           }
1155           mImpl->mProgramVAOMap.erase(iter);
1156         }
1157       }
1158     }
1159   }
1160 }
1161
1162 void Context::PrepareForNativeRendering()
1163 {
1164   // this should be pretty much constant
1165   auto display     = eglGetCurrentDisplay();
1166   auto drawSurface = eglGetCurrentSurface(EGL_DRAW);
1167   auto readSurface = eglGetCurrentSurface(EGL_READ);
1168   auto context     = eglGetCurrentContext();
1169
1170   // push the surface and context data to the impl
1171   // It's needed to restore context
1172   if(!mImpl->mCacheEGLGraphicsContext)
1173   {
1174     mImpl->mCacheDrawWriteSurface   = drawSurface;
1175     mImpl->mCacheDrawReadSurface    = readSurface;
1176     mImpl->mCacheEGLGraphicsContext = context;
1177   }
1178
1179   if(!mImpl->mNativeDrawContext)
1180   {
1181     EGLint configId{0u};
1182     eglQueryContext(display, mImpl->mController.GetSharedContext(), EGL_CONFIG_ID, &configId);
1183
1184     EGLint configAttribs[3];
1185     configAttribs[0] = EGL_CONFIG_ID;
1186     configAttribs[1] = configId;
1187     configAttribs[2] = EGL_NONE;
1188
1189     EGLConfig config;
1190     EGLint    numConfigs;
1191     if(eglChooseConfig(display, configAttribs, &config, 1, &numConfigs) != EGL_TRUE)
1192     {
1193       DALI_LOG_ERROR("eglChooseConfig failed!\n");
1194       return;
1195     }
1196
1197     auto version = int(mImpl->mController.GetGLESVersion());
1198
1199     std::vector<EGLint> attribs;
1200     attribs.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR);
1201     attribs.push_back(version / 10);
1202     attribs.push_back(EGL_CONTEXT_MINOR_VERSION_KHR);
1203     attribs.push_back(version % 10);
1204     attribs.push_back(EGL_NONE);
1205
1206     mImpl->mNativeDrawContext = eglCreateContext(display, config, mImpl->mController.GetSharedContext(), attribs.data());
1207     if(mImpl->mNativeDrawContext == EGL_NO_CONTEXT)
1208     {
1209       DALI_LOG_ERROR("eglCreateContext failed!\n");
1210       return;
1211     }
1212   }
1213
1214   eglMakeCurrent(display, drawSurface, readSurface, mImpl->mNativeDrawContext);
1215 }
1216
1217 void Context::RestoreFromNativeRendering()
1218 {
1219   auto display = eglGetCurrentDisplay();
1220
1221   // bring back original context
1222   eglMakeCurrent(display, mImpl->mCacheDrawWriteSurface, mImpl->mCacheDrawReadSurface, mImpl->mCacheEGLGraphicsContext);
1223 }
1224
1225 } // namespace Dali::Graphics::GLES