dali/internal/graphics/gles/gl-implementation.h

   1 #ifndef DALI_INTERNAL_GL_IMPLEMENTATION_H
   2 #define DALI_INTERNAL_GL_IMPLEMENTATION_H
   3
   4 /*
   5  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <GLES2/gl2.h>
  23 #include <GLES2/gl2ext.h>
  24 #include <dali/devel-api/threading/conditional-wait.h>
  25 #include <dali/integration-api/gl-abstraction.h>
  26 #include <dali/internal/graphics/common/egl-include.h>
  27 #include <dali/public-api/common/vector-wrapper.h>
  28 #include <cstdlib>
  29 #include <cstring>
  30 #include <memory>
  31
  32 // INTERNAL INCLUDES
  33 #include <dali/internal/graphics/gles/gl-extensions-support.h>
  34 #include <dali/internal/graphics/gles/gles-abstraction.h>
  35 #include <dali/internal/graphics/gles/gles2-implementation.h>
  36 #include <dali/internal/graphics/gles/gles3-implementation.h>
  37
  38 namespace Dali
  39 {
  40 namespace Internal
  41 {
  42 namespace Adaptor
  43 {
  44 namespace
  45 {
  46 static constexpr int32_t INITIAL_GLES_VERSION                         = 30;
  47 static constexpr int32_t GLES_VERSION_SUPPORT_BLEND_EQUATION_ADVANCED = 32;
  48
  49 static constexpr int32_t MINIMUM_GLES_VERSION_GET_MAXIMUM_MULTISAMPLES_TO_TEXTURE = 30;
  50
  51 static constexpr const char* LEGACY_SHADING_LANGUAGE_VERSION = "100";
  52
  53 static constexpr const char* DEFAULT_SAMPLER_TYPE = "sampler2D";
  54
  55 static constexpr const char* FRAGMENT_SHADER_ADVANCED_BLEND_EQUATION_PREFIX =
  56   "#ifdef GL_KHR_blend_equation_advanced\n"
  57   "#extension GL_KHR_blend_equation_advanced : enable\n"
  58   "#endif\n"
  59
  60   "#if defined(GL_KHR_blend_equation_advanced) || __VERSION__>=320\n"
  61   "  layout(blend_support_all_equations) out;\n"
  62   "#endif\n";
  63
  64 static constexpr const char* FRAGMENT_SHADER_OUTPUT_COLOR_STRING =
  65   "out mediump vec4 fragColor;\n";
  66
  67 static constexpr const char* OES_EGL_IMAGE_EXTERNAL_STRING = "#extension GL_OES_EGL_image_external:require\n";
  68
  69 static constexpr const char* OES_EGL_IMAGE_EXTERNAL_STRING_ESSL3 = "#extension GL_OES_EGL_image_external_essl3:require\n";
  70
  71 } // namespace
  72
  73 /**
  74  * GlImplementation is a concrete implementation for GlAbstraction.
  75  * The class provides an OpenGL-ES 2.0 or 3.0 implementation.
  76  * The class is provided when creating the Integration::Core object.
  77  */
  78 class GlImplementation : public Dali::Integration::GlAbstraction
  79 {
  80 public:
  81   GlImplementation()
  82   : mGlExtensionSupportedCacheList(),
  83     mContextCreatedWaitCondition(),
  84     mMaxTextureSize(0),
  85     mMaxTextureSamples(0),
  86     mVertexShaderPrefix(""),
  87     mGlesVersion(INITIAL_GLES_VERSION),
  88     mShadingLanguageVersion(100),
  89     mShadingLanguageVersionCached(false),
  90     mIsSurfacelessContextSupported(false),
  91     mIsContextCreated(false)
  92   {
  93     mImpl.reset(new Gles3Implementation());
  94   }
  95
  96   virtual ~GlImplementation()
  97   {
  98   }
  99
 100   void PreRender() override
 101   {
 102     /* Do nothing in main implementation */
 103   }
 104
 105   void PostRender() override
 106   {
 107     /* Do nothing in main implementation */
 108   }
 109
 110   void ContextCreated()
 111   {
 112     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
 113
 114     // Since gles 2.0 didn't return well for GL_MAJOR_VERSION and GL_MINOR_VERSION,
 115     // Only change gles version for the device that support above gles 3.0.
 116     if(mGlesVersion >= INITIAL_GLES_VERSION)
 117     {
 118       GLint majorVersion, minorVersion;
 119       glGetIntegerv(GL_MAJOR_VERSION, &majorVersion);
 120       glGetIntegerv(GL_MINOR_VERSION, &minorVersion);
 121       mGlesVersion = majorVersion * 10 + minorVersion;
 122     }
 123
 124     if(mGlesVersion >= GLES_VERSION_SUPPORT_BLEND_EQUATION_ADVANCED)
 125     {
 126       SetIsAdvancedBlendEquationSupported(true);
 127     }
 128
 129     if(mGlExtensionSupportedCacheList.NeedFullCheck())
 130     {
 131       // fully check gl extensions if we miss some extension supported
 132       mGlExtensionSupportedCacheList.EnsureGlExtensionSupportedCheck();
 133     }
 134
 135     if(IsMultisampledRenderToTextureSupported())
 136     {
 137       mMaxTextureSamples = 0;
 138
 139       if(mGlesVersion >= MINIMUM_GLES_VERSION_GET_MAXIMUM_MULTISAMPLES_TO_TEXTURE)
 140       {
 141         // Try to get maximum FBO MSAA sampling level from GL_RENDERBUFFER first.
 142         // If false, than ask again to GL_MAX_SAMPLES_EXT.
 143         GetInternalformativ(GL_RENDERBUFFER, GL_RGBA8, GL_SAMPLES, 1, &mMaxTextureSamples);
 144       }
 145       if(mMaxTextureSamples == 0)
 146       {
 147         glGetIntegerv(GL_MAX_SAMPLES_EXT, &mMaxTextureSamples);
 148       }
 149     }
 150
 151     if(!mShadingLanguageVersionCached)
 152     {
 153       std::istringstream shadingLanguageVersionStream(reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION)));
 154       std::string        token;
 155       uint32_t           tokenCount = 0;
 156       while(std::getline(shadingLanguageVersionStream, token, ' '))
 157       {
 158         if(tokenCount == 3 && token == "ES")
 159         {
 160           std::getline(shadingLanguageVersionStream, token, '.');
 161           mShadingLanguageVersion = std::atoi(token.c_str());
 162           mShadingLanguageVersion *= 100;
 163           std::getline(shadingLanguageVersionStream, token, '.');
 164           mShadingLanguageVersion += std::atoi(token.c_str());
 165           break;
 166         }
 167         tokenCount++;
 168       }
 169     }
 170
 171     {
 172       ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition);
 173       mIsContextCreated = true;
 174       mContextCreatedWaitCondition.Notify(lock);
 175     }
 176   }
 177
 178   void SetGlesVersion(const int32_t glesVersion)
 179   {
 180     if(mGlesVersion / 10 != glesVersion / 10)
 181     {
 182       mGlesVersion = glesVersion;
 183       if(mGlesVersion >= 30)
 184       {
 185         mImpl.reset(new Gles3Implementation());
 186       }
 187       else
 188       {
 189         mImpl.reset(new Gles2Implementation());
 190       }
 191     }
 192   }
 193
 194   void SetIsSurfacelessContextSupported(const bool isSupported)
 195   {
 196     mIsSurfacelessContextSupported = isSupported;
 197   }
 198
 199   bool IsSurfacelessContextSupported() const override
 200   {
 201     return mIsSurfacelessContextSupported;
 202   }
 203
 204   void SetIsAdvancedBlendEquationSupported(const bool isSupported)
 205   {
 206     mGlExtensionSupportedCacheList.SetSupported(GlExtensionCache::GlExtensionCheckerType::BLEND_EQUATION_ADVANCED, isSupported);
 207   }
 208
 209   bool IsAdvancedBlendEquationSupported()
 210   {
 211     ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition);
 212
 213     const auto type = GlExtensionCache::GlExtensionCheckerType::BLEND_EQUATION_ADVANCED;
 214     if(!mIsContextCreated && !mGlExtensionSupportedCacheList.GetCached(type))
 215     {
 216       mContextCreatedWaitCondition.Wait(lock);
 217     }
 218     return mGlExtensionSupportedCacheList.GetSupported(type);
 219   }
 220
 221   void SetIsMultisampledRenderToTextureSupported(const bool isSupported)
 222   {
 223     mGlExtensionSupportedCacheList.SetSupported(GlExtensionCache::GlExtensionCheckerType::MULTISAMPLED_RENDER_TO_TEXTURE, isSupported);
 224   }
 225
 226   bool IsMultisampledRenderToTextureSupported()
 227   {
 228     ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition);
 229
 230     const auto type = GlExtensionCache::GlExtensionCheckerType::MULTISAMPLED_RENDER_TO_TEXTURE;
 231     if(!mIsContextCreated && !mGlExtensionSupportedCacheList.GetCached(type))
 232     {
 233       mContextCreatedWaitCondition.Wait(lock);
 234     }
 235     return mGlExtensionSupportedCacheList.GetSupported(type);
 236   }
 237
 238   bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation)
 239   {
 240     switch(blendEquation)
 241     {
 242       case DevelBlendEquation::ADD:
 243       case DevelBlendEquation::SUBTRACT:
 244       case DevelBlendEquation::REVERSE_SUBTRACT:
 245       {
 246         return true;
 247       }
 248       case DevelBlendEquation::MIN:
 249       case DevelBlendEquation::MAX:
 250       {
 251         return (GetGlesVersion() >= 30);
 252       }
 253       case DevelBlendEquation::MULTIPLY:
 254       case DevelBlendEquation::SCREEN:
 255       case DevelBlendEquation::OVERLAY:
 256       case DevelBlendEquation::DARKEN:
 257       case DevelBlendEquation::LIGHTEN:
 258       case DevelBlendEquation::COLOR_DODGE:
 259       case DevelBlendEquation::COLOR_BURN:
 260       case DevelBlendEquation::HARD_LIGHT:
 261       case DevelBlendEquation::SOFT_LIGHT:
 262       case DevelBlendEquation::DIFFERENCE:
 263       case DevelBlendEquation::EXCLUSION:
 264       case DevelBlendEquation::HUE:
 265       case DevelBlendEquation::SATURATION:
 266       case DevelBlendEquation::COLOR:
 267       case DevelBlendEquation::LUMINOSITY:
 268       {
 269         return IsAdvancedBlendEquationSupported();
 270       }
 271
 272       default:
 273       {
 274         return false;
 275       }
 276     }
 277
 278     return false;
 279   }
 280
 281   std::string GetShaderVersionPrefix()
 282   {
 283     if(mShaderVersionPrefix == "")
 284     {
 285       mShaderVersionPrefix = "#version " + std::to_string(GetShadingLanguageVersion());
 286       if(GetShadingLanguageVersion() < 300)
 287       {
 288         mShaderVersionPrefix += "\n";
 289       }
 290       else
 291       {
 292         mShaderVersionPrefix += " es\n";
 293       }
 294     }
 295     return mShaderVersionPrefix;
 296   }
 297
 298   std::string GetVertexShaderPrefix()
 299   {
 300     if(mVertexShaderPrefix == "")
 301     {
 302       mVertexShaderPrefix = GetShaderVersionPrefix();
 303
 304       if(GetShadingLanguageVersion() < 300)
 305       {
 306         mVertexShaderPrefix += "#define INPUT attribute\n";
 307         mVertexShaderPrefix += "#define OUTPUT varying\n";
 308       }
 309       else
 310       {
 311         mVertexShaderPrefix += "#define INPUT in\n";
 312         mVertexShaderPrefix += "#define OUTPUT out\n";
 313       }
 314     }
 315     return mVertexShaderPrefix;
 316   }
 317
 318   std::string GetFragmentShaderPrefix()
 319   {
 320     if(mFragmentShaderPrefix == "")
 321     {
 322       mFragmentShaderPrefix = GetShaderVersionPrefix();
 323
 324       if(GetShadingLanguageVersion() < 300)
 325       {
 326         mFragmentShaderPrefix += "#define INPUT varying\n";
 327         mFragmentShaderPrefix += "#define OUT_COLOR gl_FragColor\n";
 328         mFragmentShaderPrefix += "#define TEXTURE texture2D\n";
 329       }
 330       else
 331       {
 332         mFragmentShaderPrefix += "#define INPUT in\n";
 333         mFragmentShaderPrefix += "#define OUT_COLOR fragColor\n";
 334         mFragmentShaderPrefix += "#define TEXTURE texture\n";
 335
 336         if(IsAdvancedBlendEquationSupported())
 337         {
 338           mFragmentShaderPrefix += FRAGMENT_SHADER_ADVANCED_BLEND_EQUATION_PREFIX;
 339         }
 340
 341         mFragmentShaderPrefix += FRAGMENT_SHADER_OUTPUT_COLOR_STRING;
 342       }
 343     }
 344     return mFragmentShaderPrefix;
 345   }
 346
 347   bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override
 348   {
 349     bool convert = ((imageGlFormat == GL_RGB) && (textureGlFormat == GL_RGBA));
 350     if(mGlesVersion >= 30)
 351     {
 352       // Don't convert manually from RGB to RGBA if GLES >= 3.0 and a sub-image is uploaded.
 353       convert = (convert && !isSubImage);
 354     }
 355     return convert;
 356   }
 357
 358   int GetMaxTextureSize()
 359   {
 360     ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition);
 361     if(!mIsContextCreated)
 362     {
 363       mContextCreatedWaitCondition.Wait(lock);
 364     }
 365     return mMaxTextureSize;
 366   }
 367
 368   int GetMaxTextureSamples()
 369   {
 370     ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition);
 371     if(!mIsContextCreated)
 372     {
 373       mContextCreatedWaitCondition.Wait(lock);
 374     }
 375     return mMaxTextureSamples;
 376   }
 377
 378   int32_t GetGlesVersion()
 379   {
 380     ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition);
 381     if(!mIsContextCreated)
 382     {
 383       mContextCreatedWaitCondition.Wait(lock);
 384     }
 385     return mGlesVersion;
 386   }
 387
 388   void SetShadingLanguageVersion(int shadingLanguageVersion)
 389   {
 390     mShadingLanguageVersion       = shadingLanguageVersion;
 391     mShadingLanguageVersionCached = true;
 392   }
 393
 394   int GetShadingLanguageVersion()
 395   {
 396     ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition);
 397     if(!mIsContextCreated && !mShadingLanguageVersionCached)
 398     {
 399       mContextCreatedWaitCondition.Wait(lock);
 400     }
 401     return mShadingLanguageVersion;
 402   }
 403
 404   bool ApplyNativeFragmentShader(std::string& shader, const char* customSamplerType)
 405   {
 406     bool        modified        = false;
 407     std::string versionString   = "#version";
 408     size_t      versionPosition = shader.find(versionString);
 409     if(versionPosition != std::string::npos)
 410     {
 411       std::string extensionString;
 412       size_t      shadingLanguageVersionPosition = shader.find_first_not_of(" \t", versionPosition + versionString.length());
 413       if(shadingLanguageVersionPosition != std::string::npos &&
 414          shader.substr(shadingLanguageVersionPosition, 3) == LEGACY_SHADING_LANGUAGE_VERSION)
 415       {
 416         extensionString = OES_EGL_IMAGE_EXTERNAL_STRING;
 417       }
 418       else
 419       {
 420         extensionString = OES_EGL_IMAGE_EXTERNAL_STRING_ESSL3;
 421       }
 422
 423       if(shader.find(extensionString) == std::string::npos)
 424       {
 425         modified                 = true;
 426         size_t extensionPosition = shader.find_first_of("\n", versionPosition) + 1;
 427         shader.insert(extensionPosition, extensionString);
 428       }
 429     }
 430     else
 431     {
 432       if(shader.find(OES_EGL_IMAGE_EXTERNAL_STRING) == std::string::npos)
 433       {
 434         modified = true;
 435         shader   = OES_EGL_IMAGE_EXTERNAL_STRING + shader;
 436       }
 437     }
 438
 439     if(shader.find(customSamplerType) == std::string::npos)
 440     {
 441       size_t pos = shader.find(DEFAULT_SAMPLER_TYPE);
 442       if(pos != std::string::npos)
 443       {
 444         modified = true;
 445         shader.replace(pos, strlen(DEFAULT_SAMPLER_TYPE), customSamplerType);
 446       }
 447     }
 448
 449     return modified;
 450   }
 451
 452   /* OpenGL ES 2.0 */
 453
 454   void ActiveTexture(GLenum texture) override
 455   {
 456     glActiveTexture(texture);
 457   }
 458
 459   void AttachShader(GLuint program, GLuint shader) override
 460   {
 461     glAttachShader(program, shader);
 462   }
 463
 464   void BindAttribLocation(GLuint program, GLuint index, const char* name) override
 465   {
 466     glBindAttribLocation(program, index, name);
 467   }
 468
 469   void BindBuffer(GLenum target, GLuint buffer) override
 470   {
 471     glBindBuffer(target, buffer);
 472   }
 473
 474   void BindFramebuffer(GLenum target, GLuint framebuffer) override
 475   {
 476     glBindFramebuffer(target, framebuffer);
 477   }
 478
 479   void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
 480   {
 481     glBindRenderbuffer(target, renderbuffer);
 482   }
 483
 484   void BindTexture(GLenum target, GLuint texture) override
 485   {
 486     glBindTexture(target, texture);
 487   }
 488
 489   void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
 490   {
 491     glBlendColor(red, green, blue, alpha);
 492   }
 493
 494   void BlendEquation(GLenum mode) override
 495   {
 496     glBlendEquation(mode);
 497   }
 498
 499   void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) override
 500   {
 501     glBlendEquationSeparate(modeRGB, modeAlpha);
 502   }
 503
 504   void BlendFunc(GLenum sfactor, GLenum dfactor) override
 505   {
 506     glBlendFunc(sfactor, dfactor);
 507   }
 508
 509   void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
 510   {
 511     glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 512   }
 513
 514   void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
 515   {
 516     glBufferData(target, size, data, usage);
 517   }
 518
 519   void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
 520   {
 521     glBufferSubData(target, offset, size, data);
 522   }
 523
 524   GLenum CheckFramebufferStatus(GLenum target) override
 525   {
 526     return glCheckFramebufferStatus(target);
 527   }
 528
 529   void Clear(GLbitfield mask) override
 530   {
 531     glClear(mask);
 532   }
 533
 534   void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
 535   {
 536     glClearColor(red, green, blue, alpha);
 537   }
 538
 539   void ClearDepthf(GLclampf depth) override
 540   {
 541     glClearDepthf(depth);
 542   }
 543
 544   void ClearStencil(GLint s) override
 545   {
 546     glClearStencil(s);
 547   }
 548
 549   void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
 550   {
 551     glColorMask(red, green, blue, alpha);
 552   }
 553
 554   void CompileShader(GLuint shader) override
 555   {
 556     glCompileShader(shader);
 557   }
 558
 559   void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
 560   {
 561     glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 562   }
 563
 564   void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
 565   {
 566     glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 567   }
 568
 569   void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
 570   {
 571     glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 572   }
 573
 574   void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
 575   {
 576     glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 577   }
 578
 579   GLuint CreateProgram(void) override
 580   {
 581     return glCreateProgram();
 582   }
 583
 584   GLuint CreateShader(GLenum type) override
 585   {
 586     return glCreateShader(type);
 587   }
 588
 589   void CullFace(GLenum mode) override
 590   {
 591     glCullFace(mode);
 592   }
 593
 594   void DeleteBuffers(GLsizei n, const GLuint* buffers) override
 595   {
 596     glDeleteBuffers(n, buffers);
 597   }
 598
 599   void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
 600   {
 601     glDeleteFramebuffers(n, framebuffers);
 602   }
 603
 604   void DeleteProgram(GLuint program) override
 605   {
 606     glDeleteProgram(program);
 607   }
 608
 609   void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
 610   {
 611     glDeleteRenderbuffers(n, renderbuffers);
 612   }
 613
 614   void DeleteShader(GLuint shader) override
 615   {
 616     glDeleteShader(shader);
 617   }
 618
 619   void DeleteTextures(GLsizei n, const GLuint* textures) override
 620   {
 621     glDeleteTextures(n, textures);
 622   }
 623
 624   void DepthFunc(GLenum func) override
 625   {
 626     glDepthFunc(func);
 627   }
 628
 629   void DepthMask(GLboolean flag) override
 630   {
 631     glDepthMask(flag);
 632   }
 633
 634   void DepthRangef(GLclampf zNear, GLclampf zFar) override
 635   {
 636     glDepthRangef(zNear, zFar);
 637   }
 638
 639   void DetachShader(GLuint program, GLuint shader) override
 640   {
 641     glDetachShader(program, shader);
 642   }
 643
 644   void Disable(GLenum cap) override
 645   {
 646     glDisable(cap);
 647   }
 648
 649   void DisableVertexAttribArray(GLuint index) override
 650   {
 651     glDisableVertexAttribArray(index);
 652   }
 653
 654   void DrawArrays(GLenum mode, GLint first, GLsizei count) override
 655   {
 656     glDrawArrays(mode, first, count);
 657   }
 658
 659   void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
 660   {
 661     glDrawElements(mode, count, type, indices);
 662   }
 663
 664   void Enable(GLenum cap) override
 665   {
 666     glEnable(cap);
 667   }
 668
 669   void EnableVertexAttribArray(GLuint index) override
 670   {
 671     glEnableVertexAttribArray(index);
 672   }
 673
 674   void Finish(void) override
 675   {
 676     glFinish();
 677   }
 678
 679   void Flush(void) override
 680   {
 681     glFlush();
 682   }
 683
 684   void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
 685   {
 686     glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 687   }
 688
 689   void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
 690   {
 691     glFramebufferTexture2D(target, attachment, textarget, texture, level);
 692   }
 693
 694   void FrontFace(GLenum mode) override
 695   {
 696     glFrontFace(mode);
 697   }
 698
 699   void GenBuffers(GLsizei n, GLuint* buffers) override
 700   {
 701     glGenBuffers(n, buffers);
 702   }
 703
 704   void GenerateMipmap(GLenum target) override
 705   {
 706     glGenerateMipmap(target);
 707   }
 708
 709   void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
 710   {
 711     glGenFramebuffers(n, framebuffers);
 712   }
 713
 714   void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
 715   {
 716     glGenRenderbuffers(n, renderbuffers);
 717   }
 718
 719   void GenTextures(GLsizei n, GLuint* textures) override
 720   {
 721     glGenTextures(n, textures);
 722   }
 723
 724   void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
 725   {
 726     glGetActiveAttrib(program, index, bufsize, length, size, type, name);
 727   }
 728
 729   void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
 730   {
 731     glGetActiveUniform(program, index, bufsize, length, size, type, name);
 732   }
 733
 734   void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
 735   {
 736     glGetAttachedShaders(program, maxcount, count, shaders);
 737   }
 738
 739   int GetAttribLocation(GLuint program, const char* name) override
 740   {
 741     return glGetAttribLocation(program, name);
 742   }
 743
 744   void GetBooleanv(GLenum pname, GLboolean* params) override
 745   {
 746     glGetBooleanv(pname, params);
 747   }
 748
 749   void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
 750   {
 751     glGetBufferParameteriv(target, pname, params);
 752   }
 753
 754   GLenum GetError(void) override
 755   {
 756     return glGetError();
 757   }
 758
 759   void GetFloatv(GLenum pname, GLfloat* params) override
 760   {
 761     glGetFloatv(pname, params);
 762   }
 763
 764   void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
 765   {
 766     glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 767   }
 768
 769   void GetIntegerv(GLenum pname, GLint* params) override
 770   {
 771     glGetIntegerv(pname, params);
 772   }
 773
 774   void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
 775   {
 776     glGetProgramiv(program, pname, params);
 777   }
 778
 779   void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
 780   {
 781     glGetProgramInfoLog(program, bufsize, length, infolog);
 782   }
 783
 784   void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
 785   {
 786     glGetRenderbufferParameteriv(target, pname, params);
 787   }
 788
 789   void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
 790   {
 791     glGetShaderiv(shader, pname, params);
 792   }
 793
 794   void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
 795   {
 796     glGetShaderInfoLog(shader, bufsize, length, infolog);
 797   }
 798
 799   void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
 800   {
 801     glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 802   }
 803
 804   void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
 805   {
 806     glGetShaderSource(shader, bufsize, length, source);
 807   }
 808
 809   const GLubyte* GetString(GLenum name) override
 810   {
 811     return glGetString(name);
 812   }
 813
 814   void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
 815   {
 816     glGetTexParameterfv(target, pname, params);
 817   }
 818
 819   void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
 820   {
 821     glGetTexParameteriv(target, pname, params);
 822   }
 823
 824   void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
 825   {
 826     glGetUniformfv(program, location, params);
 827   }
 828
 829   void GetUniformiv(GLuint program, GLint location, GLint* params) override
 830   {
 831     glGetUniformiv(program, location, params);
 832   }
 833
 834   int GetUniformLocation(GLuint program, const char* name) override
 835   {
 836     return glGetUniformLocation(program, name);
 837   }
 838
 839   void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
 840   {
 841     glGetVertexAttribfv(index, pname, params);
 842   }
 843
 844   void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
 845   {
 846     glGetVertexAttribiv(index, pname, params);
 847   }
 848
 849   void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
 850   {
 851     glGetVertexAttribPointerv(index, pname, pointer);
 852   }
 853
 854   void Hint(GLenum target, GLenum mode) override
 855   {
 856     glHint(target, mode);
 857   }
 858
 859   GLboolean IsBuffer(GLuint buffer) override
 860   {
 861     return glIsBuffer(buffer);
 862   }
 863
 864   GLboolean IsEnabled(GLenum cap) override
 865   {
 866     return glIsEnabled(cap);
 867   }
 868
 869   GLboolean IsFramebuffer(GLuint framebuffer) override
 870   {
 871     return glIsFramebuffer(framebuffer);
 872   }
 873
 874   GLboolean IsProgram(GLuint program) override
 875   {
 876     return glIsProgram(program);
 877   }
 878
 879   GLboolean IsRenderbuffer(GLuint renderbuffer) override
 880   {
 881     return glIsRenderbuffer(renderbuffer);
 882   }
 883
 884   GLboolean IsShader(GLuint shader) override
 885   {
 886     return glIsShader(shader);
 887   }
 888
 889   GLboolean IsTexture(GLuint texture) override
 890   {
 891     return glIsTexture(texture);
 892   }
 893
 894   void LineWidth(GLfloat width) override
 895   {
 896     glLineWidth(width);
 897   }
 898
 899   void LinkProgram(GLuint program) override
 900   {
 901     glLinkProgram(program);
 902   }
 903
 904   void PixelStorei(GLenum pname, GLint param) override
 905   {
 906     glPixelStorei(pname, param);
 907   }
 908
 909   void PolygonOffset(GLfloat factor, GLfloat units) override
 910   {
 911     glPolygonOffset(factor, units);
 912   }
 913
 914   void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
 915   {
 916     glReadPixels(x, y, width, height, format, type, pixels);
 917   }
 918
 919   void ReleaseShaderCompiler(void) override
 920   {
 921     glReleaseShaderCompiler();
 922   }
 923
 924   void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
 925   {
 926     glRenderbufferStorage(target, internalformat, width, height);
 927   }
 928
 929   void SampleCoverage(GLclampf value, GLboolean invert) override
 930   {
 931     glSampleCoverage(value, invert);
 932   }
 933
 934   void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
 935   {
 936     glScissor(x, y, width, height);
 937   }
 938
 939   void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
 940   {
 941     glShaderBinary(n, shaders, binaryformat, binary, length);
 942   }
 943
 944   void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
 945   {
 946     glShaderSource(shader, count, string, length);
 947   }
 948
 949   void StencilFunc(GLenum func, GLint ref, GLuint mask) override
 950   {
 951     glStencilFunc(func, ref, mask);
 952   }
 953
 954   void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
 955   {
 956     glStencilFuncSeparate(face, func, ref, mask);
 957   }
 958
 959   void StencilMask(GLuint mask) override
 960   {
 961     glStencilMask(mask);
 962   }
 963
 964   void StencilMaskSeparate(GLenum face, GLuint mask) override
 965   {
 966     glStencilMaskSeparate(face, mask);
 967   }
 968
 969   void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
 970   {
 971     glStencilOp(fail, zfail, zpass);
 972   }
 973
 974   void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
 975   {
 976     glStencilOpSeparate(face, fail, zfail, zpass);
 977   }
 978
 979   void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
 980   {
 981     glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 982   }
 983
 984   void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
 985   {
 986     glTexParameterf(target, pname, param);
 987   }
 988
 989   void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
 990   {
 991     glTexParameterfv(target, pname, params);
 992   }
 993
 994   void TexParameteri(GLenum target, GLenum pname, GLint param) override
 995   {
 996     glTexParameteri(target, pname, param);
 997   }
 998
 999   void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
1000   {
1001     glTexParameteriv(target, pname, params);
1002   }
1003
1004   void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
1005   {
1006     glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
1007   }
1008
1009   void Uniform1f(GLint location, GLfloat x) override
1010   {
1011     glUniform1f(location, x);
1012   }
1013
1014   void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
1015   {
1016     glUniform1fv(location, count, v);
1017   }
1018
1019   void Uniform1i(GLint location, GLint x) override
1020   {
1021     glUniform1i(location, x);
1022   }
1023
1024   void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
1025   {
1026     glUniform1iv(location, count, v);
1027   }
1028
1029   void Uniform2f(GLint location, GLfloat x, GLfloat y) override
1030   {
1031     glUniform2f(location, x, y);
1032   }
1033
1034   void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
1035   {
1036     glUniform2fv(location, count, v);
1037   }
1038
1039   void Uniform2i(GLint location, GLint x, GLint y) override
1040   {
1041     glUniform2i(location, x, y);
1042   }
1043
1044   void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
1045   {
1046     glUniform2iv(location, count, v);
1047   }
1048
1049   void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
1050   {
1051     glUniform3f(location, x, y, z);
1052   }
1053
1054   void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
1055   {
1056     glUniform3fv(location, count, v);
1057   }
1058
1059   void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
1060   {
1061     glUniform3i(location, x, y, z);
1062   }
1063
1064   void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
1065   {
1066     glUniform3iv(location, count, v);
1067   }
1068
1069   void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1070   {
1071     glUniform4f(location, x, y, z, w);
1072   }
1073
1074   void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
1075   {
1076     glUniform4fv(location, count, v);
1077   }
1078
1079   void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
1080   {
1081     glUniform4i(location, x, y, z, w);
1082   }
1083
1084   void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
1085   {
1086     glUniform4iv(location, count, v);
1087   }
1088
1089   void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1090   {
1091     glUniformMatrix2fv(location, count, transpose, value);
1092   }
1093
1094   void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1095   {
1096     glUniformMatrix3fv(location, count, transpose, value);
1097   }
1098
1099   void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1100   {
1101     glUniformMatrix4fv(location, count, transpose, value);
1102   }
1103
1104   void UseProgram(GLuint program) override
1105   {
1106     glUseProgram(program);
1107   }
1108
1109   void ValidateProgram(GLuint program) override
1110   {
1111     glValidateProgram(program);
1112   }
1113
1114   void VertexAttrib1f(GLuint indx, GLfloat x) override
1115   {
1116     glVertexAttrib1f(indx, x);
1117   }
1118
1119   void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
1120   {
1121     glVertexAttrib1fv(indx, values);
1122   }
1123
1124   void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
1125   {
1126     glVertexAttrib2f(indx, x, y);
1127   }
1128
1129   void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
1130   {
1131     glVertexAttrib2fv(indx, values);
1132   }
1133
1134   void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
1135   {
1136     glVertexAttrib3f(indx, x, y, z);
1137   }
1138
1139   void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
1140   {
1141     glVertexAttrib3fv(indx, values);
1142   }
1143
1144   void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
1145   {
1146     glVertexAttrib4f(indx, x, y, z, w);
1147   }
1148
1149   void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
1150   {
1151     glVertexAttrib4fv(indx, values);
1152   }
1153
1154   void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
1155   {
1156     glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
1157   }
1158
1159   void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
1160   {
1161     glViewport(x, y, width, height);
1162   }
1163
1164   /* OpenGL ES 3.0 */
1165
1166   void ReadBuffer(GLenum mode) override
1167   {
1168     mImpl->ReadBuffer(mode);
1169   }
1170
1171   void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
1172   {
1173     mImpl->DrawRangeElements(mode, start, end, count, type, indices);
1174   }
1175
1176   void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) override
1177   {
1178     mImpl->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
1179   }
1180
1181   void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels) override
1182   {
1183     mImpl->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
1184   }
1185
1186   void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
1187   {
1188     mImpl->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
1189   }
1190
1191   void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
1192   {
1193     mImpl->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
1194   }
1195
1196   void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) override
1197   {
1198     mImpl->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
1199   }
1200
1201   void GenQueries(GLsizei n, GLuint* ids) override
1202   {
1203     mImpl->GenQueries(n, ids);
1204   }
1205
1206   void DeleteQueries(GLsizei n, const GLuint* ids) override
1207   {
1208     mImpl->DeleteQueries(n, ids);
1209   }
1210
1211   GLboolean IsQuery(GLuint id) override
1212   {
1213     return mImpl->IsQuery(id);
1214   }
1215
1216   void BeginQuery(GLenum target, GLuint id) override
1217   {
1218     mImpl->BeginQuery(target, id);
1219   }
1220
1221   void EndQuery(GLenum target) override
1222   {
1223     mImpl->EndQuery(target);
1224   }
1225
1226   void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
1227   {
1228     mImpl->GetQueryiv(target, pname, params);
1229   }
1230
1231   void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
1232   {
1233     mImpl->GetQueryObjectuiv(id, pname, params);
1234   }
1235
1236   GLboolean UnmapBuffer(GLenum target) override
1237   {
1238     return mImpl->UnmapBuffer(target);
1239   }
1240
1241   void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
1242   {
1243     mImpl->GetBufferPointerv(target, pname, params);
1244   }
1245
1246   void DrawBuffers(GLsizei n, const GLenum* bufs) override
1247   {
1248     mImpl->DrawBuffers(n, bufs);
1249   }
1250
1251   void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1252   {
1253     mImpl->UniformMatrix2x3fv(location, count, transpose, value);
1254   }
1255
1256   void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1257   {
1258     mImpl->UniformMatrix3x2fv(location, count, transpose, value);
1259   }
1260
1261   void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1262   {
1263     mImpl->UniformMatrix2x4fv(location, count, transpose, value);
1264   }
1265
1266   void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1267   {
1268     mImpl->UniformMatrix4x2fv(location, count, transpose, value);
1269   }
1270
1271   void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1272   {
1273     mImpl->UniformMatrix3x4fv(location, count, transpose, value);
1274   }
1275
1276   void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
1277   {
1278     mImpl->UniformMatrix4x3fv(location, count, transpose, value);
1279   }
1280
1281   void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
1282   {
1283     mImpl->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
1284   }
1285
1286   void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
1287   {
1288     mImpl->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
1289   }
1290
1291   void FramebufferTexture2DMultisample(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) override
1292   {
1293     mImpl->FramebufferTexture2DMultisample(target, attachment, textarget, texture, level, samples);
1294   }
1295
1296   void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
1297   {
1298     mImpl->FramebufferTextureLayer(target, attachment, texture, level, layer);
1299   }
1300
1301   GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
1302   {
1303     return mImpl->MapBufferRange(target, offset, length, access);
1304   }
1305
1306   void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
1307   {
1308     mImpl->FlushMappedBufferRange(target, offset, length);
1309   }
1310
1311   void BindVertexArray(GLuint array) override
1312   {
1313     mImpl->BindVertexArray(array);
1314   }
1315
1316   void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
1317   {
1318     mImpl->DeleteVertexArrays(n, arrays);
1319   }
1320
1321   void GenVertexArrays(GLsizei n, GLuint* arrays) override
1322   {
1323     mImpl->GenVertexArrays(n, arrays);
1324   }
1325
1326   GLboolean IsVertexArray(GLuint array) override
1327   {
1328     return mImpl->IsVertexArray(array);
1329   }
1330
1331   void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
1332   {
1333     mImpl->GetIntegeri_v(target, index, data);
1334   }
1335
1336   void BeginTransformFeedback(GLenum primitiveMode) override
1337   {
1338     mImpl->BeginTransformFeedback(primitiveMode);
1339   }
1340
1341   void EndTransformFeedback(void) override
1342   {
1343     mImpl->EndTransformFeedback();
1344   }
1345
1346   void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
1347   {
1348     mImpl->BindBufferRange(target, index, buffer, offset, size);
1349   }
1350
1351   void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
1352   {
1353     mImpl->BindBufferBase(target, index, buffer);
1354   }
1355
1356   void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
1357   {
1358     mImpl->TransformFeedbackVaryings(program, count, varyings, bufferMode);
1359   }
1360
1361   void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
1362   {
1363     mImpl->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
1364   }
1365
1366   void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
1367   {
1368     mImpl->VertexAttribIPointer(index, size, type, stride, pointer);
1369   }
1370
1371   void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
1372   {
1373     mImpl->GetVertexAttribIiv(index, pname, params);
1374   }
1375
1376   void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
1377   {
1378     mImpl->GetVertexAttribIuiv(index, pname, params);
1379   }
1380
1381   void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
1382   {
1383     mImpl->VertexAttribI4i(index, x, y, z, w);
1384   }
1385
1386   void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
1387   {
1388     mImpl->VertexAttribI4ui(index, x, y, z, w);
1389   }
1390
1391   void VertexAttribI4iv(GLuint index, const GLint* v) override
1392   {
1393     mImpl->VertexAttribI4iv(index, v);
1394   }
1395
1396   void VertexAttribI4uiv(GLuint index, const GLuint* v) override
1397   {
1398     mImpl->VertexAttribI4uiv(index, v);
1399   }
1400
1401   void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
1402   {
1403     mImpl->GetUniformuiv(program, location, params);
1404   }
1405
1406   GLint GetFragDataLocation(GLuint program, const GLchar* name) override
1407   {
1408     return mImpl->GetFragDataLocation(program, name);
1409   }
1410
1411   void Uniform1ui(GLint location, GLuint v0) override
1412   {
1413     mImpl->Uniform1ui(location, v0);
1414   }
1415
1416   void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
1417   {
1418     mImpl->Uniform2ui(location, v0, v1);
1419   }
1420
1421   void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
1422   {
1423     mImpl->Uniform3ui(location, v0, v1, v2);
1424   }
1425
1426   void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
1427   {
1428     mImpl->Uniform4ui(location, v0, v1, v2, v3);
1429   }
1430
1431   void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
1432   {
1433     mImpl->Uniform1uiv(location, count, value);
1434   }
1435
1436   void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
1437   {
1438     mImpl->Uniform2uiv(location, count, value);
1439   }
1440
1441   void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
1442   {
1443     mImpl->Uniform3uiv(location, count, value);
1444   }
1445
1446   void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
1447   {
1448     mImpl->Uniform4uiv(location, count, value);
1449   }
1450
1451   void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
1452   {
1453     mImpl->ClearBufferiv(buffer, drawbuffer, value);
1454   }
1455
1456   void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
1457   {
1458     mImpl->ClearBufferuiv(buffer, drawbuffer, value);
1459   }
1460
1461   void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
1462   {
1463     mImpl->ClearBufferfv(buffer, drawbuffer, value);
1464   }
1465
1466   void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
1467   {
1468     mImpl->ClearBufferfi(buffer, drawbuffer, depth, stencil);
1469   }
1470
1471   const GLubyte* GetStringi(GLenum name, GLuint index) override
1472   {
1473     return mImpl->GetStringi(name, index);
1474   }
1475
1476   void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
1477   {
1478     mImpl->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
1479   }
1480
1481   void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
1482   {
1483     mImpl->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
1484   }
1485
1486   void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
1487   {
1488     mImpl->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
1489   }
1490
1491   GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
1492   {
1493     return mImpl->GetUniformBlockIndex(program, uniformBlockName);
1494   }
1495
1496   void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
1497   {
1498     mImpl->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1499   }
1500
1501   void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
1502   {
1503     mImpl->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
1504   }
1505
1506   void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
1507   {
1508     mImpl->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
1509   }
1510
1511   void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
1512   {
1513     mImpl->DrawArraysInstanced(mode, first, count, instanceCount);
1514   }
1515
1516   void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
1517   {
1518     mImpl->DrawElementsInstanced(mode, count, type, indices, instanceCount);
1519   }
1520
1521   GLsync FenceSync(GLenum condition, GLbitfield flags) override
1522   {
1523     return mImpl->FenceSync(condition, flags);
1524   }
1525
1526   GLboolean IsSync(GLsync sync) override
1527   {
1528     return mImpl->IsSync(sync);
1529   }
1530
1531   void DeleteSync(GLsync sync) override
1532   {
1533     mImpl->DeleteSync(sync);
1534   }
1535
1536   GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1537   {
1538     return mImpl->ClientWaitSync(sync, flags, timeout);
1539   }
1540
1541   void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
1542   {
1543     mImpl->WaitSync(sync, flags, timeout);
1544   }
1545
1546   void GetInteger64v(GLenum pname, GLint64* params) override
1547   {
1548     mImpl->GetInteger64v(pname, params);
1549   }
1550
1551   void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
1552   {
1553     mImpl->GetSynciv(sync, pname, bufSize, length, values);
1554   }
1555
1556   void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
1557   {
1558     mImpl->GetInteger64i_v(target, index, data);
1559   }
1560
1561   void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
1562   {
1563     mImpl->GetBufferParameteri64v(target, pname, params);
1564   }
1565
1566   void GenSamplers(GLsizei count, GLuint* samplers) override
1567   {
1568     mImpl->GenSamplers(count, samplers);
1569   }
1570
1571   void DeleteSamplers(GLsizei count, const GLuint* samplers) override
1572   {
1573     mImpl->DeleteSamplers(count, samplers);
1574   }
1575
1576   GLboolean IsSampler(GLuint sampler) override
1577   {
1578     return mImpl->IsSampler(sampler);
1579   }
1580
1581   void BindSampler(GLuint unit, GLuint sampler) override
1582   {
1583     mImpl->BindSampler(unit, sampler);
1584   }
1585
1586   void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
1587   {
1588     mImpl->SamplerParameteri(sampler, pname, param);
1589   }
1590
1591   void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
1592   {
1593     mImpl->SamplerParameteriv(sampler, pname, param);
1594   }
1595
1596   void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
1597   {
1598     mImpl->SamplerParameterf(sampler, pname, param);
1599   }
1600
1601   void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
1602   {
1603     mImpl->SamplerParameterfv(sampler, pname, param);
1604   }
1605
1606   void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
1607   {
1608     mImpl->GetSamplerParameteriv(sampler, pname, params);
1609   }
1610
1611   void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
1612   {
1613     mImpl->GetSamplerParameterfv(sampler, pname, params);
1614   }
1615
1616   void VertexAttribDivisor(GLuint index, GLuint divisor) override
1617   {
1618     mImpl->VertexAttribDivisor(index, divisor);
1619   }
1620
1621   void BindTransformFeedback(GLenum target, GLuint id) override
1622   {
1623     mImpl->BindTransformFeedback(target, id);
1624   }
1625
1626   void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
1627   {
1628     mImpl->DeleteTransformFeedbacks(n, ids);
1629   }
1630
1631   void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
1632   {
1633     mImpl->GenTransformFeedbacks(n, ids);
1634   }
1635
1636   GLboolean IsTransformFeedback(GLuint id) override
1637   {
1638     return mImpl->IsTransformFeedback(id);
1639   }
1640
1641   void PauseTransformFeedback(void) override
1642   {
1643     mImpl->PauseTransformFeedback();
1644   }
1645
1646   void ResumeTransformFeedback(void) override
1647   {
1648     mImpl->ResumeTransformFeedback();
1649   }
1650
1651   void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
1652   {
1653     mImpl->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
1654   }
1655
1656   void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
1657   {
1658     mImpl->ProgramBinary(program, binaryFormat, binary, length);
1659   }
1660
1661   void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
1662   {
1663     mImpl->ProgramParameteri(program, pname, value);
1664   }
1665
1666   void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
1667   {
1668     mImpl->InvalidateFramebuffer(target, numAttachments, attachments);
1669   }
1670
1671   void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
1672   {
1673     mImpl->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
1674   }
1675
1676   void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
1677   {
1678     mImpl->TexStorage2D(target, levels, internalformat, width, height);
1679   }
1680
1681   void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
1682   {
1683     mImpl->TexStorage3D(target, levels, internalformat, width, height, depth);
1684   }
1685
1686   void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
1687   {
1688     mImpl->GetInternalformativ(target, internalformat, pname, bufSize, params);
1689   }
1690
1691   void BlendBarrier(void)
1692   {
1693     if(mGlExtensionSupportedCacheList.GetSupported(GlExtensionCache::GlExtensionCheckerType::BLEND_EQUATION_ADVANCED))
1694     {
1695       mImpl->BlendBarrier();
1696     }
1697   }
1698
1699 private:
1700   std::unique_ptr<GlesAbstraction> mImpl;
1701
1702   GlExtensionCache::GlExtensionSupportedCacheList mGlExtensionSupportedCacheList;
1703
1704   ConditionalWait mContextCreatedWaitCondition;
1705   GLint           mMaxTextureSize;
1706   GLint           mMaxTextureSamples;
1707   std::string     mShaderVersionPrefix;
1708   std::string     mVertexShaderPrefix;
1709   std::string     mFragmentShaderPrefix;
1710   int32_t         mGlesVersion;
1711   int32_t         mShadingLanguageVersion;
1712   bool            mShadingLanguageVersionCached;
1713   bool            mIsSurfacelessContextSupported;
1714   bool            mIsContextCreated;
1715 };
1716
1717 } // namespace Adaptor
1718
1719 } // namespace Internal
1720
1721 } // namespace Dali
1722
1723 #endif // DALI_INTERNAL_GL_IMPLEMENTATION_H