X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fgraphics%2Fgles%2Fgl-implementation.h;h=4f3b8dca701d507a14d0c6eb53448f47431a64cb;hb=a82c4156e6f21ef623354cce5679319a5081c74d;hp=be324764cef80e4133eafb2ca06950d045653aa9;hpb=0cf21c8af6a919c263b00d22cb205df2964d0b04;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/dali/internal/graphics/gles/gl-implementation.h b/dali/internal/graphics/gles/gl-implementation.h index be32476..4f3b8dc 100644 --- a/dali/internal/graphics/gles/gl-implementation.h +++ b/dali/internal/graphics/gles/gl-implementation.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_GL_IMPLEMENTATION_H /* - * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,10 +19,13 @@ */ // EXTERNAL INCLUDES -#include -#include #include +#include +#include #include +#include +#include +#include // INTERNAL INCLUDES #include @@ -31,12 +34,26 @@ namespace Dali { - namespace Internal { - namespace Adaptor { +namespace +{ +const int32_t INITIAL_GLES_VERSION = 30; +const int32_t GLES_VERSION_SUPPORT_BLEND_EQUATION_ADVANCED = 32; +const char* KHR_BLEND_EQUATION_ADVANCED = "GL_KHR_blend_equation_advanced"; + +const char* FRAGMENT_SHADER_ADVANCED_BLEND_EQUATION_PREFIX = + "#extension GL_KHR_blend_equation_advanced : enable\n" + + "#if GL_KHR_blend_equation_advanced==1 || __VERSION__>=320\n" + " layout(blend_support_all_equations) out;\n" + "#endif\n"; + +const char* FRAGMENT_SHADER_OUTPUT_COLOR_STRING = + "out mediump vec4 fragColor;\n"; +} // namespace /** * GlImplementation is a concrete implementation for GlAbstraction. @@ -45,1295 +62,1554 @@ namespace Adaptor */ class GlImplementation : public Dali::Integration::GlAbstraction { - public: GlImplementation() - : mGlesVersion( 30 ) + : mContextCreatedWaitCondition(), + mMaxTextureSize(0), + mVertexShaderPrefix(""), + mGlesVersion(INITIAL_GLES_VERSION), + mShadingLanguageVersion(100), + mShadingLanguageVersionCached(false), + mIsSurfacelessContextSupported(false), + mIsAdvancedBlendEquationSupportedCached(false), + mIsAdvancedBlendEquationSupported(false), + mIsContextCreated(false) { - mImpl.reset( new Gles3Implementation() ); + mImpl.reset(new Gles3Implementation()); } - virtual ~GlImplementation() {} + virtual ~GlImplementation() + { + } - void PreRender() + void PreRender() override { /* Do nothing in main implementation */ } - void PostRender() + void PostRender() override { /* Do nothing in main implementation */ } - void SetGlesVersion( const int32_t glesVersion ) + void ContextCreated() { - if( mGlesVersion != glesVersion ) + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize); + + // Only change gles version for the device that support above gles 3.0. + if(mGlesVersion >= INITIAL_GLES_VERSION) + { + GLint majorVersion, minorVersion; + glGetIntegerv(GL_MAJOR_VERSION, &majorVersion); + glGetIntegerv(GL_MINOR_VERSION, &minorVersion); + mGlesVersion = majorVersion * 10 + minorVersion; + } + + if(mGlesVersion >= GLES_VERSION_SUPPORT_BLEND_EQUATION_ADVANCED) + { + mIsAdvancedBlendEquationSupported = true; + } + else + { + // when mIsAdvancedBlendEquationSupported is cached, we don't need to check all the extensions. + if(!mIsAdvancedBlendEquationSupportedCached) + { + const char* const extensionStr = reinterpret_cast(glGetString(GL_EXTENSIONS)); + std::istringstream stream(extensionStr); + std::string currentExtension; + while(std::getline(stream, currentExtension, ' ')) + { + if(currentExtension == KHR_BLEND_EQUATION_ADVANCED) + { + mIsAdvancedBlendEquationSupported = true; + break; + } + } + } + } + + if(!mShadingLanguageVersionCached) + { + std::istringstream shadingLanguageVersionStream(reinterpret_cast(glGetString(GL_SHADING_LANGUAGE_VERSION))); + std::string token; + uint32_t tokenCount = 0; + while(std::getline(shadingLanguageVersionStream, token, ' ')) + { + if(tokenCount == 3 && token == "ES") + { + std::getline(shadingLanguageVersionStream, token, '.'); + mShadingLanguageVersion = std::atoi(token.c_str()); + mShadingLanguageVersion *= 100; + std::getline(shadingLanguageVersionStream, token, '.'); + mShadingLanguageVersion += std::atoi(token.c_str()); + break; + } + tokenCount++; + } + } + + { + ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition); + mIsContextCreated = true; + mContextCreatedWaitCondition.Notify(lock); + } + } + + void SetGlesVersion(const int32_t glesVersion) + { + if(mGlesVersion / 10 != glesVersion / 10) { mGlesVersion = glesVersion; - if( mGlesVersion >= 30 ) + if(mGlesVersion >= 30) + { + mImpl.reset(new Gles3Implementation()); + } + else + { + mImpl.reset(new Gles2Implementation()); + } + } + } + + void SetIsSurfacelessContextSupported(const bool isSupported) + { + mIsSurfacelessContextSupported = isSupported; + } + + bool IsSurfacelessContextSupported() const override + { + return mIsSurfacelessContextSupported; + } + + void SetIsAdvancedBlendEquationSupported(const bool isSupported) + { + mIsAdvancedBlendEquationSupported = isSupported; + mIsAdvancedBlendEquationSupportedCached = true; + } + + bool IsAdvancedBlendEquationSupported() + { + ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition); + if(!mIsContextCreated && !mIsAdvancedBlendEquationSupportedCached) + { + mContextCreatedWaitCondition.Wait(lock); + } + return mIsAdvancedBlendEquationSupported; + } + + bool IsBlendEquationSupported(DevelBlendEquation::Type blendEquation) + { + switch(blendEquation) + { + case DevelBlendEquation::ADD: + case DevelBlendEquation::SUBTRACT: + case DevelBlendEquation::REVERSE_SUBTRACT: + { + return true; + } + case DevelBlendEquation::MIN: + case DevelBlendEquation::MAX: + { + return (GetGlesVersion() >= 30); + } + case DevelBlendEquation::MULTIPLY: + case DevelBlendEquation::SCREEN: + case DevelBlendEquation::OVERLAY: + case DevelBlendEquation::DARKEN: + case DevelBlendEquation::LIGHTEN: + case DevelBlendEquation::COLOR_DODGE: + case DevelBlendEquation::COLOR_BURN: + case DevelBlendEquation::HARD_LIGHT: + case DevelBlendEquation::SOFT_LIGHT: + case DevelBlendEquation::DIFFERENCE: + case DevelBlendEquation::EXCLUSION: + case DevelBlendEquation::HUE: + case DevelBlendEquation::SATURATION: + case DevelBlendEquation::COLOR: + case DevelBlendEquation::LUMINOSITY: + { + return IsAdvancedBlendEquationSupported(); + } + + default: { - mImpl.reset( new Gles3Implementation() ); + return false; + } + } + + return false; + } + + std::string GetShaderVersionPrefix() + { + if(mShaderVersionPrefix == "") + { + mShaderVersionPrefix = "#version " + std::to_string(GetShadingLanguageVersion()); + if(GetShadingLanguageVersion() < 300) + { + mShaderVersionPrefix += "\n"; } else { - mImpl.reset( new Gles2Implementation() ); + mShaderVersionPrefix += " es\n"; } } + return mShaderVersionPrefix; } - bool IsSurfacelessContextSupported() const + std::string GetVertexShaderPrefix() { - return ( mGlesVersion >= 30 ); + if(mVertexShaderPrefix == "") + { + mVertexShaderPrefix = GetShaderVersionPrefix(); + + if(GetShadingLanguageVersion() < 300) + { + mVertexShaderPrefix += "#define INPUT attribute\n"; + mVertexShaderPrefix += "#define OUTPUT varying\n"; + } + else + { + mVertexShaderPrefix += "#define INPUT in\n"; + mVertexShaderPrefix += "#define OUTPUT out\n"; + } + } + return mVertexShaderPrefix; } - bool TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const + std::string GetFragmentShaderPrefix() { - bool convert = ( ( imageGlFormat == GL_RGB ) && ( textureGlFormat == GL_RGBA ) ); - if( mGlesVersion >= 30 ) + if(mFragmentShaderPrefix == "") + { + mFragmentShaderPrefix = GetShaderVersionPrefix(); + + if(GetShadingLanguageVersion() < 300) + { + mFragmentShaderPrefix += "#define INPUT varying\n"; + mFragmentShaderPrefix += "#define OUT_COLOR gl_FragColor\n"; + mFragmentShaderPrefix += "#define TEXTURE texture2D\n"; + } + else + { + mFragmentShaderPrefix += "#define INPUT in\n"; + mFragmentShaderPrefix += "#define OUT_COLOR fragColor\n"; + mFragmentShaderPrefix += "#define TEXTURE texture\n"; + + if(IsAdvancedBlendEquationSupported()) + { + mFragmentShaderPrefix += FRAGMENT_SHADER_ADVANCED_BLEND_EQUATION_PREFIX; + } + + mFragmentShaderPrefix += FRAGMENT_SHADER_OUTPUT_COLOR_STRING; + } + } + return mFragmentShaderPrefix; + } + + bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override + { + bool convert = ((imageGlFormat == GL_RGB) && (textureGlFormat == GL_RGBA)); + if(mGlesVersion >= 30) { // Don't convert manually from RGB to RGBA if GLES >= 3.0 and a sub-image is uploaded. - convert = ( convert && !isSubImage ); + convert = (convert && !isSubImage); } return convert; } + int GetMaxTextureSize() + { + ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition); + if(!mIsContextCreated) + { + mContextCreatedWaitCondition.Wait(lock); + } + return mMaxTextureSize; + } + + int GetGlesVersion() + { + ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition); + if(!mIsContextCreated) + { + mContextCreatedWaitCondition.Wait(lock); + } + return mGlesVersion; + } + + void SetShadingLanguageVersion(int shadingLanguageVersion) + { + mShadingLanguageVersion = shadingLanguageVersion; + mShadingLanguageVersionCached = true; + } + + int GetShadingLanguageVersion() + { + ConditionalWait::ScopedLock lock(mContextCreatedWaitCondition); + if(!mIsContextCreated && !mShadingLanguageVersionCached) + { + mContextCreatedWaitCondition.Wait(lock); + } + return mShadingLanguageVersion; + } + /* OpenGL ES 2.0 */ - void ActiveTexture( GLenum texture ) + void ActiveTexture(GLenum texture) override { - glActiveTexture( texture ); + glActiveTexture(texture); } - void AttachShader( GLuint program, GLuint shader ) + void AttachShader(GLuint program, GLuint shader) override { - glAttachShader( program, shader ); + glAttachShader(program, shader); } - void BindAttribLocation( GLuint program, GLuint index, const char* name ) + void BindAttribLocation(GLuint program, GLuint index, const char* name) override { - glBindAttribLocation( program, index, name ); + glBindAttribLocation(program, index, name); } - void BindBuffer( GLenum target, GLuint buffer ) + void BindBuffer(GLenum target, GLuint buffer) override { - glBindBuffer( target, buffer ); + glBindBuffer(target, buffer); } - void BindFramebuffer( GLenum target, GLuint framebuffer ) + void BindFramebuffer(GLenum target, GLuint framebuffer) override { - glBindFramebuffer( target, framebuffer ); + glBindFramebuffer(target, framebuffer); } - void BindRenderbuffer( GLenum target, GLuint renderbuffer ) + void BindRenderbuffer(GLenum target, GLuint renderbuffer) override { - glBindRenderbuffer( target, renderbuffer ); + glBindRenderbuffer(target, renderbuffer); } - void BindTexture( GLenum target, GLuint texture ) + void BindTexture(GLenum target, GLuint texture) override { - glBindTexture( target, texture ); + glBindTexture(target, texture); } - void BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) + void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override { - glBlendColor( red, green, blue, alpha ); + glBlendColor(red, green, blue, alpha); } - void BlendEquation( GLenum mode ) + void BlendEquation(GLenum mode) override { - glBlendEquation( mode ); + glBlendEquation(mode); } - void BlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha ) + void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) override { - glBlendEquationSeparate( modeRGB, modeAlpha ); + glBlendEquationSeparate(modeRGB, modeAlpha); } - void BlendFunc( GLenum sfactor, GLenum dfactor ) + void BlendFunc(GLenum sfactor, GLenum dfactor) override { - glBlendFunc( sfactor, dfactor ); + glBlendFunc(sfactor, dfactor); } - void BlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) + void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override { - glBlendFuncSeparate( srcRGB, dstRGB, srcAlpha, dstAlpha ); + glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); } - void BufferData( GLenum target, GLsizeiptr size, const void* data, GLenum usage ) + void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override { - glBufferData( target, size, data, usage ); + glBufferData(target, size, data, usage); } - void BufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void* data ) + void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override { - glBufferSubData( target, offset, size, data ); + glBufferSubData(target, offset, size, data); } - GLenum CheckFramebufferStatus( GLenum target ) + GLenum CheckFramebufferStatus(GLenum target) override { - return glCheckFramebufferStatus( target ); + return glCheckFramebufferStatus(target); } - void Clear( GLbitfield mask ) + void Clear(GLbitfield mask) override { - glClear( mask ); + glClear(mask); } - void ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) + void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override { - glClearColor( red, green, blue, alpha ); + glClearColor(red, green, blue, alpha); } - void ClearDepthf( GLclampf depth ) + void ClearDepthf(GLclampf depth) override { - glClearDepthf( depth ); + glClearDepthf(depth); } - void ClearStencil( GLint s ) + void ClearStencil(GLint s) override { - glClearStencil( s ); + glClearStencil(s); } - void ColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) + void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override { - glColorMask( red, green, blue, alpha ); + glColorMask(red, green, blue, alpha); } - void CompileShader( GLuint shader ) + void CompileShader(GLuint shader) override { - glCompileShader( shader ); + glCompileShader(shader); } - void CompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data ) + void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override { - glCompressedTexImage2D( target, level, internalformat, width, height, border, imageSize, data ); + glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); } - void CompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data ) + void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override { - glCompressedTexSubImage2D( target, level, xoffset, yoffset, width, height, format, imageSize, data ); + glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); } - void CopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) + void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override { - glCopyTexImage2D( target, level, internalformat, x, y, width, height, border ); + glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); } - void CopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) + void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override { - glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height ); + glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); } - GLuint CreateProgram( void ) + GLuint CreateProgram(void) override { return glCreateProgram(); } - GLuint CreateShader( GLenum type ) + GLuint CreateShader(GLenum type) override { - return glCreateShader( type ); + return glCreateShader(type); } - void CullFace( GLenum mode ) + void CullFace(GLenum mode) override { - glCullFace( mode ); + glCullFace(mode); } - void DeleteBuffers( GLsizei n, const GLuint* buffers ) + void DeleteBuffers(GLsizei n, const GLuint* buffers) override { - glDeleteBuffers( n, buffers ); + glDeleteBuffers(n, buffers); } - void DeleteFramebuffers( GLsizei n, const GLuint* framebuffers ) + void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override { - glDeleteFramebuffers( n, framebuffers ); + glDeleteFramebuffers(n, framebuffers); } - void DeleteProgram( GLuint program ) + void DeleteProgram(GLuint program) override { - glDeleteProgram( program ); + glDeleteProgram(program); } - void DeleteRenderbuffers( GLsizei n, const GLuint* renderbuffers ) + void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override { - glDeleteRenderbuffers( n, renderbuffers ); + glDeleteRenderbuffers(n, renderbuffers); } - void DeleteShader( GLuint shader ) + void DeleteShader(GLuint shader) override { - glDeleteShader( shader ); + glDeleteShader(shader); } - void DeleteTextures( GLsizei n, const GLuint* textures ) + void DeleteTextures(GLsizei n, const GLuint* textures) override { - glDeleteTextures( n, textures ); + glDeleteTextures(n, textures); } - void DepthFunc( GLenum func ) + void DepthFunc(GLenum func) override { - glDepthFunc( func ); + glDepthFunc(func); } - void DepthMask( GLboolean flag ) + void DepthMask(GLboolean flag) override { - glDepthMask( flag ); + glDepthMask(flag); } - void DepthRangef( GLclampf zNear, GLclampf zFar ) + void DepthRangef(GLclampf zNear, GLclampf zFar) override { - glDepthRangef( zNear, zFar ); + glDepthRangef(zNear, zFar); } - void DetachShader( GLuint program, GLuint shader ) + void DetachShader(GLuint program, GLuint shader) override { - glDetachShader( program, shader ); + glDetachShader(program, shader); } - void Disable( GLenum cap ) + void Disable(GLenum cap) override { - glDisable( cap ); + glDisable(cap); } - void DisableVertexAttribArray( GLuint index ) + void DisableVertexAttribArray(GLuint index) override { - glDisableVertexAttribArray( index ); + glDisableVertexAttribArray(index); } - void DrawArrays( GLenum mode, GLint first, GLsizei count ) + void DrawArrays(GLenum mode, GLint first, GLsizei count) override { - glDrawArrays( mode, first, count ); + glDrawArrays(mode, first, count); } - void DrawElements( GLenum mode, GLsizei count, GLenum type, const void* indices ) + void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override { - glDrawElements( mode, count, type, indices ); + glDrawElements(mode, count, type, indices); } - void Enable( GLenum cap ) + void Enable(GLenum cap) override { - glEnable( cap ); + glEnable(cap); } - void EnableVertexAttribArray( GLuint index ) + void EnableVertexAttribArray(GLuint index) override { - glEnableVertexAttribArray( index ); + glEnableVertexAttribArray(index); } - void Finish( void ) + void Finish(void) override { glFinish(); } - void Flush( void ) + void Flush(void) override { glFlush(); } - void FramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) + void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override { - glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer ); + glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); } - void FramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) + void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override { - glFramebufferTexture2D( target, attachment, textarget, texture, level ); + glFramebufferTexture2D(target, attachment, textarget, texture, level); } - void FrontFace( GLenum mode ) + void FrontFace(GLenum mode) override { - glFrontFace( mode ); + glFrontFace(mode); } - void GenBuffers( GLsizei n, GLuint* buffers ) + void GenBuffers(GLsizei n, GLuint* buffers) override { - glGenBuffers( n, buffers ); + glGenBuffers(n, buffers); } - void GenerateMipmap( GLenum target ) + void GenerateMipmap(GLenum target) override { - glGenerateMipmap( target ); + glGenerateMipmap(target); } - void GenFramebuffers( GLsizei n, GLuint* framebuffers ) + void GenFramebuffers(GLsizei n, GLuint* framebuffers) override { - glGenFramebuffers( n, framebuffers ); + glGenFramebuffers(n, framebuffers); } - void GenRenderbuffers( GLsizei n, GLuint* renderbuffers ) + void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override { - glGenRenderbuffers( n, renderbuffers ); + glGenRenderbuffers(n, renderbuffers); } - void GenTextures( GLsizei n, GLuint* textures ) + void GenTextures(GLsizei n, GLuint* textures) override { - glGenTextures( n, textures ); + glGenTextures(n, textures); } - void GetActiveAttrib( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name ) + void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override { - glGetActiveAttrib( program, index, bufsize, length, size, type, name ); + glGetActiveAttrib(program, index, bufsize, length, size, type, name); } - void GetActiveUniform( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name ) + void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override { - glGetActiveUniform( program, index, bufsize, length, size, type, name ); + glGetActiveUniform(program, index, bufsize, length, size, type, name); } - void GetAttachedShaders( GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders ) + void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override { - glGetAttachedShaders( program, maxcount, count, shaders ); + glGetAttachedShaders(program, maxcount, count, shaders); } - int GetAttribLocation( GLuint program, const char* name ) + int GetAttribLocation(GLuint program, const char* name) override { - return glGetAttribLocation( program, name ); + return glGetAttribLocation(program, name); } - void GetBooleanv( GLenum pname, GLboolean* params ) + void GetBooleanv(GLenum pname, GLboolean* params) override { - glGetBooleanv( pname, params ); + glGetBooleanv(pname, params); } - void GetBufferParameteriv( GLenum target, GLenum pname, GLint* params ) + void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override { - glGetBufferParameteriv( target, pname, params ); + glGetBufferParameteriv(target, pname, params); } - GLenum GetError( void ) + GLenum GetError(void) override { return glGetError(); } - void GetFloatv( GLenum pname, GLfloat* params ) + void GetFloatv(GLenum pname, GLfloat* params) override { - glGetFloatv( pname, params ); + glGetFloatv(pname, params); } - void GetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint* params ) + void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override { - glGetFramebufferAttachmentParameteriv( target, attachment, pname, params ); + glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); } - void GetIntegerv( GLenum pname, GLint* params ) + void GetIntegerv(GLenum pname, GLint* params) override { - glGetIntegerv( pname, params ); + glGetIntegerv(pname, params); } - void GetProgramiv( GLuint program, GLenum pname, GLint* params ) + void GetProgramiv(GLuint program, GLenum pname, GLint* params) override { - glGetProgramiv( program, pname, params ); + glGetProgramiv(program, pname, params); } - void GetProgramInfoLog( GLuint program, GLsizei bufsize, GLsizei* length, char* infolog ) + void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override { - glGetProgramInfoLog( program, bufsize, length, infolog ); + glGetProgramInfoLog(program, bufsize, length, infolog); } - void GetRenderbufferParameteriv( GLenum target, GLenum pname, GLint* params ) + void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override { - glGetRenderbufferParameteriv( target, pname, params ); + glGetRenderbufferParameteriv(target, pname, params); } - void GetShaderiv( GLuint shader, GLenum pname, GLint* params ) + void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override { - glGetShaderiv( shader, pname, params ); + glGetShaderiv(shader, pname, params); } - void GetShaderInfoLog( GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog ) + void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override { - glGetShaderInfoLog( shader, bufsize, length, infolog ); + glGetShaderInfoLog(shader, bufsize, length, infolog); } - void GetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision ) + void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override { - glGetShaderPrecisionFormat( shadertype, precisiontype, range, precision ); + glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); } - void GetShaderSource( GLuint shader, GLsizei bufsize, GLsizei* length, char* source ) + void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override { - glGetShaderSource( shader, bufsize, length, source ); + glGetShaderSource(shader, bufsize, length, source); } - const GLubyte* GetString( GLenum name ) + const GLubyte* GetString(GLenum name) override { - return glGetString( name ); + return glGetString(name); } - void GetTexParameterfv( GLenum target, GLenum pname, GLfloat* params ) + void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override { - glGetTexParameterfv( target, pname, params ); + glGetTexParameterfv(target, pname, params); } - void GetTexParameteriv( GLenum target, GLenum pname, GLint* params ) + void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override { - glGetTexParameteriv( target, pname, params ); + glGetTexParameteriv(target, pname, params); } - void GetUniformfv( GLuint program, GLint location, GLfloat* params ) + void GetUniformfv(GLuint program, GLint location, GLfloat* params) override { - glGetUniformfv( program, location, params ); + glGetUniformfv(program, location, params); } - void GetUniformiv( GLuint program, GLint location, GLint* params ) + void GetUniformiv(GLuint program, GLint location, GLint* params) override { - glGetUniformiv( program, location, params ); + glGetUniformiv(program, location, params); } - int GetUniformLocation( GLuint program, const char* name ) + int GetUniformLocation(GLuint program, const char* name) override { - return glGetUniformLocation( program, name ); + return glGetUniformLocation(program, name); } - void GetVertexAttribfv( GLuint index, GLenum pname, GLfloat* params ) + void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override { - glGetVertexAttribfv( index, pname, params ); + glGetVertexAttribfv(index, pname, params); } - void GetVertexAttribiv( GLuint index, GLenum pname, GLint* params ) + void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override { - glGetVertexAttribiv( index, pname, params ); + glGetVertexAttribiv(index, pname, params); } - void GetVertexAttribPointerv( GLuint index, GLenum pname, void** pointer ) + void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override { - glGetVertexAttribPointerv( index, pname, pointer ); + glGetVertexAttribPointerv(index, pname, pointer); } - void Hint( GLenum target, GLenum mode ) + void Hint(GLenum target, GLenum mode) override { - glHint( target, mode ); + glHint(target, mode); } - GLboolean IsBuffer( GLuint buffer ) + GLboolean IsBuffer(GLuint buffer) override { - return glIsBuffer( buffer ); + return glIsBuffer(buffer); } - GLboolean IsEnabled( GLenum cap ) + GLboolean IsEnabled(GLenum cap) override { - return glIsEnabled( cap ); + return glIsEnabled(cap); } - GLboolean IsFramebuffer( GLuint framebuffer ) + GLboolean IsFramebuffer(GLuint framebuffer) override { - return glIsFramebuffer( framebuffer ); + return glIsFramebuffer(framebuffer); } - GLboolean IsProgram( GLuint program ) + GLboolean IsProgram(GLuint program) override { - return glIsProgram( program ); + return glIsProgram(program); } - GLboolean IsRenderbuffer( GLuint renderbuffer ) + GLboolean IsRenderbuffer(GLuint renderbuffer) override { - return glIsRenderbuffer( renderbuffer ); + return glIsRenderbuffer(renderbuffer); } - GLboolean IsShader( GLuint shader ) + GLboolean IsShader(GLuint shader) override { - return glIsShader( shader ); + return glIsShader(shader); } - GLboolean IsTexture( GLuint texture ) + GLboolean IsTexture(GLuint texture) override { - return glIsTexture( texture ); + return glIsTexture(texture); } - void LineWidth( GLfloat width ) + void LineWidth(GLfloat width) override { - glLineWidth( width ); + glLineWidth(width); } - void LinkProgram( GLuint program ) + void LinkProgram(GLuint program) override { - glLinkProgram( program ); + glLinkProgram(program); } - void PixelStorei( GLenum pname, GLint param ) + void PixelStorei(GLenum pname, GLint param) override { - glPixelStorei( pname, param ); + glPixelStorei(pname, param); } - void PolygonOffset( GLfloat factor, GLfloat units ) + void PolygonOffset(GLfloat factor, GLfloat units) override { - glPolygonOffset( factor, units ); + glPolygonOffset(factor, units); } - void ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels ) + void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override { - glReadPixels( x, y, width, height, format, type, pixels ); + glReadPixels(x, y, width, height, format, type, pixels); } - void ReleaseShaderCompiler( void ) + void ReleaseShaderCompiler(void) override { glReleaseShaderCompiler(); } - void RenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) + void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override { - glRenderbufferStorage( target, internalformat, width, height ); + glRenderbufferStorage(target, internalformat, width, height); } - void SampleCoverage( GLclampf value, GLboolean invert ) + void SampleCoverage(GLclampf value, GLboolean invert) override { - glSampleCoverage( value, invert ); + glSampleCoverage(value, invert); } - void Scissor( GLint x, GLint y, GLsizei width, GLsizei height ) + void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override { - glScissor( x, y, width, height ); + glScissor(x, y, width, height); } - void ShaderBinary( GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length ) + void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override { - glShaderBinary( n, shaders, binaryformat, binary, length ); + glShaderBinary(n, shaders, binaryformat, binary, length); } - void ShaderSource( GLuint shader, GLsizei count, const char** string, const GLint* length ) + void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override { - glShaderSource( shader, count, string, length ); + glShaderSource(shader, count, string, length); } - void StencilFunc( GLenum func, GLint ref, GLuint mask ) + void StencilFunc(GLenum func, GLint ref, GLuint mask) override { - glStencilFunc( func, ref, mask ); + glStencilFunc(func, ref, mask); } - void StencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask ) + void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override { - glStencilFuncSeparate( face, func, ref, mask ); + glStencilFuncSeparate(face, func, ref, mask); } - void StencilMask( GLuint mask ) + void StencilMask(GLuint mask) override { - glStencilMask( mask ); + glStencilMask(mask); } - void StencilMaskSeparate( GLenum face, GLuint mask ) + void StencilMaskSeparate(GLenum face, GLuint mask) override { - glStencilMaskSeparate( face, mask ); + glStencilMaskSeparate(face, mask); } - void StencilOp( GLenum fail, GLenum zfail, GLenum zpass ) + void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override { - glStencilOp( fail, zfail, zpass ); + glStencilOp(fail, zfail, zpass); } - void StencilOpSeparate( GLenum face, GLenum fail, GLenum zfail, GLenum zpass ) + void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override { - glStencilOpSeparate( face, fail, zfail, zpass ); + glStencilOpSeparate(face, fail, zfail, zpass); } - void TexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels ) + void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override { - glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels ); + glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); } - void TexParameterf( GLenum target, GLenum pname, GLfloat param ) + void TexParameterf(GLenum target, GLenum pname, GLfloat param) override { - glTexParameterf( target, pname, param ); + glTexParameterf(target, pname, param); } - void TexParameterfv( GLenum target, GLenum pname, const GLfloat* params ) + void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override { - glTexParameterfv( target, pname, params ); + glTexParameterfv(target, pname, params); } - void TexParameteri( GLenum target, GLenum pname, GLint param ) + void TexParameteri(GLenum target, GLenum pname, GLint param) override { - glTexParameteri( target, pname, param ); + glTexParameteri(target, pname, param); } - void TexParameteriv( GLenum target, GLenum pname, const GLint* params ) + void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override { - glTexParameteriv( target, pname, params ); + glTexParameteriv(target, pname, params); } - void TexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) + void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override { - glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels ); + glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); } - void Uniform1f( GLint location, GLfloat x ) + void Uniform1f(GLint location, GLfloat x) override { - glUniform1f( location, x ); + glUniform1f(location, x); } - void Uniform1fv( GLint location, GLsizei count, const GLfloat* v ) + void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override { - glUniform1fv( location, count, v ); + glUniform1fv(location, count, v); } - void Uniform1i( GLint location, GLint x ) + void Uniform1i(GLint location, GLint x) override { - glUniform1i( location, x ); + glUniform1i(location, x); } - void Uniform1iv( GLint location, GLsizei count, const GLint* v ) + void Uniform1iv(GLint location, GLsizei count, const GLint* v) override { - glUniform1iv( location, count, v ); + glUniform1iv(location, count, v); } - void Uniform2f( GLint location, GLfloat x, GLfloat y ) + void Uniform2f(GLint location, GLfloat x, GLfloat y) override { - glUniform2f( location, x, y ); + glUniform2f(location, x, y); } - void Uniform2fv( GLint location, GLsizei count, const GLfloat* v ) + void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override { - glUniform2fv( location, count, v ); + glUniform2fv(location, count, v); } - void Uniform2i( GLint location, GLint x, GLint y ) + void Uniform2i(GLint location, GLint x, GLint y) override { - glUniform2i( location, x, y ); + glUniform2i(location, x, y); } - void Uniform2iv( GLint location, GLsizei count, const GLint* v ) + void Uniform2iv(GLint location, GLsizei count, const GLint* v) override { - glUniform2iv( location, count, v ); + glUniform2iv(location, count, v); } - void Uniform3f( GLint location, GLfloat x, GLfloat y, GLfloat z ) + void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override { - glUniform3f( location, x, y, z ); + glUniform3f(location, x, y, z); } - void Uniform3fv( GLint location, GLsizei count, const GLfloat* v ) + void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override { - glUniform3fv( location, count, v ); + glUniform3fv(location, count, v); } - void Uniform3i( GLint location, GLint x, GLint y, GLint z ) + void Uniform3i(GLint location, GLint x, GLint y, GLint z) override { - glUniform3i( location, x, y, z ); + glUniform3i(location, x, y, z); } - void Uniform3iv( GLint location, GLsizei count, const GLint* v ) + void Uniform3iv(GLint location, GLsizei count, const GLint* v) override { - glUniform3iv( location, count, v ); + glUniform3iv(location, count, v); } - void Uniform4f( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) + void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override { - glUniform4f( location, x, y, z, w ); + glUniform4f(location, x, y, z, w); } - void Uniform4fv( GLint location, GLsizei count, const GLfloat* v ) + void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override { - glUniform4fv( location, count, v ); + glUniform4fv(location, count, v); } - void Uniform4i( GLint location, GLint x, GLint y, GLint z, GLint w ) + void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override { - glUniform4i( location, x, y, z, w ); + glUniform4i(location, x, y, z, w); } - void Uniform4iv( GLint location, GLsizei count, const GLint* v ) + void Uniform4iv(GLint location, GLsizei count, const GLint* v) override { - glUniform4iv( location, count, v ); + glUniform4iv(location, count, v); } - void UniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - glUniformMatrix2fv( location, count, transpose, value ); + glUniformMatrix2fv(location, count, transpose, value); } - void UniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - glUniformMatrix3fv( location, count, transpose, value ); + glUniformMatrix3fv(location, count, transpose, value); } - void UniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - glUniformMatrix4fv( location, count, transpose, value ); + glUniformMatrix4fv(location, count, transpose, value); } - void UseProgram( GLuint program ) + void UseProgram(GLuint program) override { - glUseProgram( program ); + glUseProgram(program); } - void ValidateProgram( GLuint program ) + void ValidateProgram(GLuint program) override { - glValidateProgram( program ); + glValidateProgram(program); } - void VertexAttrib1f( GLuint indx, GLfloat x ) + void VertexAttrib1f(GLuint indx, GLfloat x) override { - glVertexAttrib1f( indx, x ); + glVertexAttrib1f(indx, x); } - void VertexAttrib1fv( GLuint indx, const GLfloat* values ) + void VertexAttrib1fv(GLuint indx, const GLfloat* values) override { - glVertexAttrib1fv( indx, values ); + glVertexAttrib1fv(indx, values); } - void VertexAttrib2f( GLuint indx, GLfloat x, GLfloat y ) + void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override { - glVertexAttrib2f( indx, x, y ); + glVertexAttrib2f(indx, x, y); } - void VertexAttrib2fv( GLuint indx, const GLfloat* values ) + void VertexAttrib2fv(GLuint indx, const GLfloat* values) override { - glVertexAttrib2fv( indx, values ); + glVertexAttrib2fv(indx, values); } - void VertexAttrib3f( GLuint indx, GLfloat x, GLfloat y, GLfloat z ) + void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override { - glVertexAttrib3f( indx, x, y, z ); + glVertexAttrib3f(indx, x, y, z); } - void VertexAttrib3fv( GLuint indx, const GLfloat* values ) + void VertexAttrib3fv(GLuint indx, const GLfloat* values) override { - glVertexAttrib3fv( indx, values ); + glVertexAttrib3fv(indx, values); } - void VertexAttrib4f( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) + void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override { - glVertexAttrib4f( indx, x, y, z, w ); + glVertexAttrib4f(indx, x, y, z, w); } - void VertexAttrib4fv( GLuint indx, const GLfloat* values ) + void VertexAttrib4fv(GLuint indx, const GLfloat* values) override { - glVertexAttrib4fv( indx, values ); + glVertexAttrib4fv(indx, values); } - void VertexAttribPointer( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr ) + void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override { - glVertexAttribPointer( indx, size, type, normalized, stride, ptr ); + glVertexAttribPointer(indx, size, type, normalized, stride, ptr); } - void Viewport( GLint x, GLint y, GLsizei width, GLsizei height ) + void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override { - glViewport( x, y, width, height ); + glViewport(x, y, width, height); } /* OpenGL ES 3.0 */ - void ReadBuffer( GLenum mode ) + void ReadBuffer(GLenum mode) override { - mImpl->ReadBuffer( mode ); + mImpl->ReadBuffer(mode); } - void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices ) + void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override { - mImpl->DrawRangeElements( mode, start, end, count, type, indices ); + mImpl->DrawRangeElements(mode, start, end, count, type, indices); } - void TexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels ) + void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) override { - mImpl->TexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels ); + mImpl->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); } - 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 ) + 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 { - mImpl->TexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); + mImpl->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); } - void CopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) + void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override { - mImpl->CopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height ); + mImpl->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); } - void CompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data ) + void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override { - mImpl->CompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data ); + mImpl->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); } - 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 ) + 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 { - mImpl->CompressedTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data ); + mImpl->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); } - void GenQueries( GLsizei n, GLuint* ids ) + void GenQueries(GLsizei n, GLuint* ids) override { - mImpl->GenQueries( n, ids ); + mImpl->GenQueries(n, ids); } - void DeleteQueries( GLsizei n, const GLuint* ids ) + void DeleteQueries(GLsizei n, const GLuint* ids) override { - mImpl->DeleteQueries( n, ids ); + mImpl->DeleteQueries(n, ids); } - GLboolean IsQuery( GLuint id ) + GLboolean IsQuery(GLuint id) override { - return mImpl->IsQuery( id ); + return mImpl->IsQuery(id); } - void BeginQuery( GLenum target, GLuint id ) + void BeginQuery(GLenum target, GLuint id) override { - mImpl->BeginQuery( target, id ); + mImpl->BeginQuery(target, id); } - void EndQuery( GLenum target ) + void EndQuery(GLenum target) override { - mImpl->EndQuery( target ); + mImpl->EndQuery(target); } - void GetQueryiv( GLenum target, GLenum pname, GLint* params ) + void GetQueryiv(GLenum target, GLenum pname, GLint* params) override { - mImpl->GetQueryiv( target, pname, params ); + mImpl->GetQueryiv(target, pname, params); } - void GetQueryObjectuiv( GLuint id, GLenum pname, GLuint* params ) + void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override { - mImpl->GetQueryObjectuiv( id, pname, params ); + mImpl->GetQueryObjectuiv(id, pname, params); } - GLboolean UnmapBuffer( GLenum target ) + GLboolean UnmapBuffer(GLenum target) override { - return mImpl->UnmapBuffer( target ); + return mImpl->UnmapBuffer(target); } - void GetBufferPointerv( GLenum target, GLenum pname, GLvoid** params ) + void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override { - mImpl->GetBufferPointerv( target, pname, params ); + mImpl->GetBufferPointerv(target, pname, params); } - void DrawBuffers( GLsizei n, const GLenum* bufs ) + void DrawBuffers(GLsizei n, const GLenum* bufs) override { - mImpl->DrawBuffers( n, bufs ); + mImpl->DrawBuffers(n, bufs); } - void UniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - mImpl->UniformMatrix2x3fv( location, count, transpose, value ); + mImpl->UniformMatrix2x3fv(location, count, transpose, value); } - void UniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - mImpl->UniformMatrix3x2fv( location, count, transpose, value ); + mImpl->UniformMatrix3x2fv(location, count, transpose, value); } - void UniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - mImpl->UniformMatrix2x4fv( location, count, transpose, value ); + mImpl->UniformMatrix2x4fv(location, count, transpose, value); } - void UniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - mImpl->UniformMatrix4x2fv( location, count, transpose, value ); + mImpl->UniformMatrix4x2fv(location, count, transpose, value); } - void UniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - mImpl->UniformMatrix3x4fv( location, count, transpose, value ); + mImpl->UniformMatrix3x4fv(location, count, transpose, value); } - void UniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) + void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override { - mImpl->UniformMatrix4x3fv( location, count, transpose, value ); + mImpl->UniformMatrix4x3fv(location, count, transpose, value); } - void BlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) + void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override { - mImpl->BlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ); + mImpl->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } - void RenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) + void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override { - mImpl->RenderbufferStorageMultisample( target, samples, internalformat, width, height ); + mImpl->RenderbufferStorageMultisample(target, samples, internalformat, width, height); } - void FramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) + void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override { - mImpl->FramebufferTextureLayer( target, attachment, texture, level, layer ); + mImpl->FramebufferTextureLayer(target, attachment, texture, level, layer); } - GLvoid* MapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access ) + GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override { - return mImpl->MapBufferRange( target, offset, length, access ); + return mImpl->MapBufferRange(target, offset, length, access); } - void FlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length ) + void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override { - mImpl->FlushMappedBufferRange( target, offset, length ); + mImpl->FlushMappedBufferRange(target, offset, length); } - void BindVertexArray( GLuint array ) + void BindVertexArray(GLuint array) override { - mImpl->BindVertexArray( array ); + mImpl->BindVertexArray(array); } - void DeleteVertexArrays( GLsizei n, const GLuint* arrays ) + void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override { - mImpl->DeleteVertexArrays( n, arrays ); + mImpl->DeleteVertexArrays(n, arrays); } - void GenVertexArrays( GLsizei n, GLuint* arrays ) + void GenVertexArrays(GLsizei n, GLuint* arrays) override { - mImpl->GenVertexArrays( n, arrays ); + mImpl->GenVertexArrays(n, arrays); } - GLboolean IsVertexArray( GLuint array ) + GLboolean IsVertexArray(GLuint array) override { - return mImpl->IsVertexArray( array ); + return mImpl->IsVertexArray(array); } - void GetIntegeri_v( GLenum target, GLuint index, GLint* data ) + void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override { - mImpl->GetIntegeri_v( target, index, data ); + mImpl->GetIntegeri_v(target, index, data); } - void BeginTransformFeedback( GLenum primitiveMode ) + void BeginTransformFeedback(GLenum primitiveMode) override { - mImpl->BeginTransformFeedback( primitiveMode ); + mImpl->BeginTransformFeedback(primitiveMode); } - void EndTransformFeedback( void ) + void EndTransformFeedback(void) override { mImpl->EndTransformFeedback(); } - void BindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) + void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override { - mImpl->BindBufferRange( target, index, buffer, offset, size ); + mImpl->BindBufferRange(target, index, buffer, offset, size); } - void BindBufferBase( GLenum target, GLuint index, GLuint buffer ) + void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override { - mImpl->BindBufferBase( target, index, buffer ); + mImpl->BindBufferBase(target, index, buffer); } - void TransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode ) + void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override { - mImpl->TransformFeedbackVaryings( program, count, varyings, bufferMode ); + mImpl->TransformFeedbackVaryings(program, count, varyings, bufferMode); } - void GetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) + void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override { - mImpl->GetTransformFeedbackVarying( program, index, bufSize, length, size, type, name ); + mImpl->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); } - void VertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) + void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override { - mImpl->VertexAttribIPointer( index, size, type, stride, pointer ); + mImpl->VertexAttribIPointer(index, size, type, stride, pointer); } - void GetVertexAttribIiv( GLuint index, GLenum pname, GLint* params ) + void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override { - mImpl->GetVertexAttribIiv( index, pname, params ); + mImpl->GetVertexAttribIiv(index, pname, params); } - void GetVertexAttribIuiv( GLuint index, GLenum pname, GLuint* params ) + void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override { - mImpl->GetVertexAttribIuiv( index, pname, params ); + mImpl->GetVertexAttribIuiv(index, pname, params); } - void VertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w ) + void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override { - mImpl->VertexAttribI4i( index, x, y, z, w ); + mImpl->VertexAttribI4i(index, x, y, z, w); } - void VertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) + void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override { - mImpl->VertexAttribI4ui( index, x, y, z, w ); + mImpl->VertexAttribI4ui(index, x, y, z, w); } - void VertexAttribI4iv( GLuint index, const GLint* v ) + void VertexAttribI4iv(GLuint index, const GLint* v) override { - mImpl->VertexAttribI4iv( index, v ); + mImpl->VertexAttribI4iv(index, v); } - void VertexAttribI4uiv( GLuint index, const GLuint* v ) + void VertexAttribI4uiv(GLuint index, const GLuint* v) override { - mImpl->VertexAttribI4uiv( index, v ); + mImpl->VertexAttribI4uiv(index, v); } - void GetUniformuiv( GLuint program, GLint location, GLuint* params ) + void GetUniformuiv(GLuint program, GLint location, GLuint* params) override { - mImpl->GetUniformuiv( program, location, params ); + mImpl->GetUniformuiv(program, location, params); } - GLint GetFragDataLocation( GLuint program, const GLchar *name ) + GLint GetFragDataLocation(GLuint program, const GLchar* name) override { - return mImpl->GetFragDataLocation( program, name ); + return mImpl->GetFragDataLocation(program, name); } - void Uniform1ui( GLint location, GLuint v0 ) + void Uniform1ui(GLint location, GLuint v0) override { - mImpl->Uniform1ui( location, v0 ); + mImpl->Uniform1ui(location, v0); } - void Uniform2ui( GLint location, GLuint v0, GLuint v1 ) + void Uniform2ui(GLint location, GLuint v0, GLuint v1) override { - mImpl->Uniform2ui( location, v0, v1 ); + mImpl->Uniform2ui(location, v0, v1); } - void Uniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 ) + void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override { - mImpl->Uniform3ui( location, v0, v1, v2 ); + mImpl->Uniform3ui(location, v0, v1, v2); } - void Uniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) + void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override { - mImpl->Uniform4ui( location, v0, v1, v2, v3 ); + mImpl->Uniform4ui(location, v0, v1, v2, v3); } - void Uniform1uiv( GLint location, GLsizei count, const GLuint* value ) + void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override { - mImpl->Uniform1uiv( location, count, value ); + mImpl->Uniform1uiv(location, count, value); } - void Uniform2uiv( GLint location, GLsizei count, const GLuint* value ) + void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override { - mImpl->Uniform2uiv( location, count, value ); + mImpl->Uniform2uiv(location, count, value); } - void Uniform3uiv( GLint location, GLsizei count, const GLuint* value ) + void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override { - mImpl->Uniform3uiv( location, count, value ); + mImpl->Uniform3uiv(location, count, value); } - void Uniform4uiv( GLint location, GLsizei count, const GLuint* value ) + void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override { - mImpl->Uniform4uiv( location, count, value ); + mImpl->Uniform4uiv(location, count, value); } - void ClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint* value ) + void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override { - mImpl->ClearBufferiv( buffer, drawbuffer, value ); + mImpl->ClearBufferiv(buffer, drawbuffer, value); } - void ClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint* value ) + void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override { - mImpl->ClearBufferuiv( buffer, drawbuffer, value ); + mImpl->ClearBufferuiv(buffer, drawbuffer, value); } - void ClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat* value ) + void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override { - mImpl->ClearBufferfv( buffer, drawbuffer, value ); + mImpl->ClearBufferfv(buffer, drawbuffer, value); } - void ClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil ) + void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override { - mImpl->ClearBufferfi( buffer, drawbuffer, depth, stencil ); + mImpl->ClearBufferfi(buffer, drawbuffer, depth, stencil); } - const GLubyte* GetStringi( GLenum name, GLuint index ) + const GLubyte* GetStringi(GLenum name, GLuint index) override { - return mImpl->GetStringi( name, index ); + return mImpl->GetStringi(name, index); } - void CopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) + void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override { - mImpl->CopyBufferSubData( readTarget, writeTarget, readOffset, writeOffset, size ); + mImpl->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); } - void GetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices ) + void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override { - mImpl->GetUniformIndices( program, uniformCount, uniformNames, uniformIndices ); + mImpl->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices); } - void GetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params ) + void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override { - mImpl->GetActiveUniformsiv( program, uniformCount, uniformIndices, pname, params ); + mImpl->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); } - GLuint GetUniformBlockIndex( GLuint program, const GLchar* uniformBlockName ) + GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override { - return mImpl->GetUniformBlockIndex( program, uniformBlockName ); + return mImpl->GetUniformBlockIndex(program, uniformBlockName); } - void GetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params ) + void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override { - mImpl->GetActiveUniformBlockiv( program, uniformBlockIndex, pname, params ); + mImpl->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); } - void GetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName ) + void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override { - mImpl->GetActiveUniformBlockName( program, uniformBlockIndex, bufSize, length, uniformBlockName ); + mImpl->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); } - void UniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding ) + void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override { - mImpl->UniformBlockBinding( program, uniformBlockIndex, uniformBlockBinding ); + mImpl->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); } - void DrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instanceCount ) + void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override { - mImpl->DrawArraysInstanced( mode, first, count, instanceCount ); + mImpl->DrawArraysInstanced(mode, first, count, instanceCount); } - void DrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount ) + void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override { - mImpl->DrawElementsInstanced( mode, count, type, indices, instanceCount ); + mImpl->DrawElementsInstanced(mode, count, type, indices, instanceCount); } - GLsync FenceSync( GLenum condition, GLbitfield flags ) + GLsync FenceSync(GLenum condition, GLbitfield flags) override { - return mImpl->FenceSync( condition, flags ); + return mImpl->FenceSync(condition, flags); } - GLboolean IsSync( GLsync sync ) + GLboolean IsSync(GLsync sync) override { - return mImpl->IsSync( sync ); + return mImpl->IsSync(sync); } - void DeleteSync( GLsync sync ) + void DeleteSync(GLsync sync) override { - mImpl->DeleteSync( sync ); + mImpl->DeleteSync(sync); } - GLenum ClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) + GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override { - return mImpl->ClientWaitSync( sync, flags, timeout ); + return mImpl->ClientWaitSync(sync, flags, timeout); } - void WaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) + void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override { - mImpl->WaitSync( sync, flags, timeout ); + mImpl->WaitSync(sync, flags, timeout); } - void GetInteger64v( GLenum pname, GLint64* params ) + void GetInteger64v(GLenum pname, GLint64* params) override { - mImpl->GetInteger64v( pname, params ); + mImpl->GetInteger64v(pname, params); } - void GetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) + void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override { - mImpl->GetSynciv( sync, pname, bufSize, length, values ); + mImpl->GetSynciv(sync, pname, bufSize, length, values); } - void GetInteger64i_v( GLenum target, GLuint index, GLint64* data ) + void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override { - mImpl->GetInteger64i_v( target, index, data ); + mImpl->GetInteger64i_v(target, index, data); } - void GetBufferParameteri64v( GLenum target, GLenum pname, GLint64* params ) + void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override { - mImpl->GetBufferParameteri64v( target, pname, params ); + mImpl->GetBufferParameteri64v(target, pname, params); } - void GenSamplers( GLsizei count, GLuint* samplers ) + void GenSamplers(GLsizei count, GLuint* samplers) override { - mImpl->GenSamplers( count, samplers ); + mImpl->GenSamplers(count, samplers); } - void DeleteSamplers( GLsizei count, const GLuint* samplers ) + void DeleteSamplers(GLsizei count, const GLuint* samplers) override { - mImpl->DeleteSamplers( count, samplers ); + mImpl->DeleteSamplers(count, samplers); } - GLboolean IsSampler( GLuint sampler ) + GLboolean IsSampler(GLuint sampler) override { - return mImpl->IsSampler( sampler ); + return mImpl->IsSampler(sampler); } - void BindSampler( GLuint unit, GLuint sampler ) + void BindSampler(GLuint unit, GLuint sampler) override { - mImpl->BindSampler( unit, sampler ); + mImpl->BindSampler(unit, sampler); } - void SamplerParameteri( GLuint sampler, GLenum pname, GLint param ) + void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override { - mImpl->SamplerParameteri( sampler, pname, param ); + mImpl->SamplerParameteri(sampler, pname, param); } - void SamplerParameteriv( GLuint sampler, GLenum pname, const GLint* param ) + void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override { - mImpl->SamplerParameteriv( sampler, pname, param ); + mImpl->SamplerParameteriv(sampler, pname, param); } - void SamplerParameterf( GLuint sampler, GLenum pname, GLfloat param ) + void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override { - mImpl->SamplerParameterf( sampler, pname, param ); + mImpl->SamplerParameterf(sampler, pname, param); } - void SamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat* param ) + void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override { - mImpl->SamplerParameterfv( sampler, pname, param ); + mImpl->SamplerParameterfv(sampler, pname, param); } - void GetSamplerParameteriv( GLuint sampler, GLenum pname, GLint* params ) + void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override { - mImpl->GetSamplerParameteriv( sampler, pname, params ); + mImpl->GetSamplerParameteriv(sampler, pname, params); } - void GetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* params ) + void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override { - mImpl->GetSamplerParameterfv( sampler, pname, params ); + mImpl->GetSamplerParameterfv(sampler, pname, params); } - void VertexAttribDivisor( GLuint index, GLuint divisor ) + void VertexAttribDivisor(GLuint index, GLuint divisor) override { - mImpl->VertexAttribDivisor( index, divisor ); + mImpl->VertexAttribDivisor(index, divisor); } - void BindTransformFeedback( GLenum target, GLuint id ) + void BindTransformFeedback(GLenum target, GLuint id) override { - mImpl->BindTransformFeedback( target, id ); + mImpl->BindTransformFeedback(target, id); } - void DeleteTransformFeedbacks( GLsizei n, const GLuint* ids ) + void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override { - mImpl->DeleteTransformFeedbacks( n, ids ); + mImpl->DeleteTransformFeedbacks(n, ids); } - void GenTransformFeedbacks( GLsizei n, GLuint* ids ) + void GenTransformFeedbacks(GLsizei n, GLuint* ids) override { - mImpl->GenTransformFeedbacks( n, ids ); + mImpl->GenTransformFeedbacks(n, ids); } - GLboolean IsTransformFeedback( GLuint id ) + GLboolean IsTransformFeedback(GLuint id) override { - return mImpl->IsTransformFeedback( id ); + return mImpl->IsTransformFeedback(id); } - void PauseTransformFeedback( void ) + void PauseTransformFeedback(void) override { mImpl->PauseTransformFeedback(); } - void ResumeTransformFeedback( void ) + void ResumeTransformFeedback(void) override { mImpl->ResumeTransformFeedback(); } - void GetProgramBinary( GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary ) + void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override { - mImpl->GetProgramBinary( program, bufSize, length, binaryFormat, binary ); + mImpl->GetProgramBinary(program, bufSize, length, binaryFormat, binary); } - void ProgramBinary( GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length ) + void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override { - mImpl->ProgramBinary( program, binaryFormat, binary, length ); + mImpl->ProgramBinary(program, binaryFormat, binary, length); } - void ProgramParameteri( GLuint program, GLenum pname, GLint value ) + void ProgramParameteri(GLuint program, GLenum pname, GLint value) override { - mImpl->ProgramParameteri( program, pname, value ); + mImpl->ProgramParameteri(program, pname, value); } - void InvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments ) + void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override { - mImpl->InvalidateFramebuffer( target, numAttachments, attachments ); + mImpl->InvalidateFramebuffer(target, numAttachments, attachments); } - void InvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height ) + void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override { - mImpl->InvalidateSubFramebuffer( target, numAttachments, attachments, x, y, width, height ); + mImpl->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); } - void TexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) + void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override { - mImpl->TexStorage2D( target, levels, internalformat, width, height ); + mImpl->TexStorage2D(target, levels, internalformat, width, height); } - void TexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth ) + void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override { - mImpl->TexStorage3D( target, levels, internalformat, width, height, depth ); + mImpl->TexStorage3D(target, levels, internalformat, width, height, depth); } - void GetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params ) + void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override { - mImpl->GetInternalformativ( target, internalformat, pname, bufSize, params ); + mImpl->GetInternalformativ(target, internalformat, pname, bufSize, params); + } + + void BlendBarrier(void) + { + if(mIsAdvancedBlendEquationSupported) + { + mImpl->BlendBarrier(); + } } private: - int32_t mGlesVersion; std::unique_ptr mImpl; + + ConditionalWait mContextCreatedWaitCondition; + GLint mMaxTextureSize; + std::string mShaderVersionPrefix; + std::string mVertexShaderPrefix; + std::string mFragmentShaderPrefix; + int32_t mGlesVersion; + int32_t mShadingLanguageVersion; + bool mShadingLanguageVersionCached; + bool mIsSurfacelessContextSupported; + bool mIsAdvancedBlendEquationSupportedCached; + bool mIsAdvancedBlendEquationSupported; + bool mIsContextCreated; }; } // namespace Adaptor