-#ifndef __DALI_INTERNAL_GL_IMPLEMENTATION_H__
-#define __DALI_INTERNAL_GL_IMPLEMENTATION_H__
+#ifndef DALI_INTERNAL_GL_IMPLEMENTATION_H
+#define DALI_INTERNAL_GL_IMPLEMENTATION_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#ifndef DALI_GLES_VERSION
-#error "OpenGL ES version not specified"
-#endif
-
-#if DALI_GLES_VERSION >= 31
-#include <GLES3/gl31.h>
-#elif DALI_GLES_VERSION >= 30
-#include <GLES3/gl3.h>
-#else
+#include <memory>
#include <cstdlib>
#include <GLES2/gl2.h>
-#endif
-
+#include <GLES2/gl2ext.h>
#include <dali/integration-api/gl-abstraction.h>
+#include <dali/devel-api/threading/conditional-wait.h>
+#include <dali/internal/graphics/common/egl-include.h>
// INTERNAL INCLUDES
-#include <dali/internal/graphics/gles/gl-extensions.h>
+#include <dali/internal/graphics/gles/gles-abstraction.h>
+#include <dali/internal/graphics/gles/gles2-implementation.h>
+#include <dali/internal/graphics/gles/gles3-implementation.h>
namespace Dali
{
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";
+}
+
/**
* GlImplementation is a concrete implementation for GlAbstraction.
- * The class provides an OpenGL-ES 2.0 implementation.
+ * The class provides an OpenGL-ES 2.0 or 3.0 implementation.
* The class is provided when creating the Integration::Core object.
*/
-class GlImplementation: public Dali::Integration::GlAbstraction
+class GlImplementation : public Dali::Integration::GlAbstraction
{
public:
+ GlImplementation()
+ : mContextCreatedWaitCondition(),
+ mMaxTextureSize( 0 ),
+ mVertexShaderPrefix(""),
+ mGlesVersion( INITIAL_GLES_VERSION ),
+ mShadingLanguageVersion( 100 ),
+ mShadingLanguageVersionCached( false ),
+ mIsSurfacelessContextSupported( false ),
+ mIsAdvancedBlendEquationSupportedCached( false ),
+ mIsAdvancedBlendEquationSupported( false ),
+ mIsContextCreated( false )
+ {
+ mImpl.reset( new Gles3Implementation() );
+ }
+
virtual ~GlImplementation() {}
- void PreRender()
+ void PreRender() override
{
/* Do nothing in main implementation */
}
- void PostRender()
+ void PostRender() override
{
/* Do nothing in main implementation */
}
+ void ContextCreated()
+ {
+ glGetIntegerv( GL_MAX_TEXTURE_SIZE, &mMaxTextureSize );
+
+ 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<const char*>(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<const char*>(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 )
+ {
+ 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:
+ {
+ return false;
+ }
+ }
+
+ return false;
+ }
+
+ std::string GetShaderVersionPrefix()
+ {
+ if(mShaderVersionPrefix == "")
+ {
+ mShaderVersionPrefix = "#version " + std::to_string( GetShadingLanguageVersion() );
+ if(GetShadingLanguageVersion() < 300)
+ {
+ mShaderVersionPrefix += "\n";
+ }
+ else
+ {
+ mShaderVersionPrefix += " es\n";
+ }
+ }
+ return mShaderVersionPrefix;
+ }
+
+ std::string GetVertexShaderPrefix()
+ {
+ 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;
+ }
+
+ std::string GetFragmentShaderPrefix()
+ {
+ 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 );
+ }
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glReadBuffer(mode);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glDrawRangeElements(mode,start,end,count,type,indices);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glTexImage3D(target,level,internalformat,width,height,depth,border,format,type,pixels);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glCompressedTexImage3D(target,level,internalformat,width,height,depth,border,imageSize,data);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glCompressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGenQueries(n,ids);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GenQueries( n, ids );
}
- void DeleteQueries(GLsizei n, const GLuint* ids)
+ void DeleteQueries( GLsizei n, const GLuint* ids ) override
{
-#if DALI_GLES_VERSION >= 30
- glDeleteQueries(n,ids);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->DeleteQueries( n, ids );
}
- GLboolean IsQuery(GLuint id)
+ GLboolean IsQuery( GLuint id ) override
{
-#if DALI_GLES_VERSION >= 30
- return glIsQuery(id);
-#else
- return 0;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->IsQuery( id );
}
- void BeginQuery(GLenum target, GLuint id)
+ void BeginQuery( GLenum target, GLuint id ) override
{
-#if DALI_GLES_VERSION >= 30
- glBeginQuery(target,id);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->BeginQuery( target, id );
}
- void EndQuery(GLenum target)
+ void EndQuery( GLenum target ) override
{
-#if DALI_GLES_VERSION >= 30
- glEndQuery(target);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->EndQuery( target );
}
- void GetQueryiv(GLenum target, GLenum pname, GLint* params)
+ void GetQueryiv( GLenum target, GLenum pname, GLint* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetQueryiv(target,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetQueryiv( target, pname, params );
}
- void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
+ void GetQueryObjectuiv( GLuint id, GLenum pname, GLuint* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetQueryObjectuiv(id,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetQueryObjectuiv( id, pname, params );
}
- GLboolean UnmapBuffer(GLenum target)
+ GLboolean UnmapBuffer( GLenum target ) override
{
-#if DALI_GLES_VERSION >= 30
- return glUnmapBuffer(target);
-#else
- return 0;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->UnmapBuffer( target );
}
- void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
+ void GetBufferPointerv( GLenum target, GLenum pname, GLvoid** params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetBufferPointerv(target,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetBufferPointerv( target, pname, params );
}
- void DrawBuffers(GLsizei n, const GLenum* bufs)
+ void DrawBuffers( GLsizei n, const GLenum* bufs ) override
{
-#if DALI_GLES_VERSION >= 30
- glDrawBuffers(n,bufs);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniformMatrix2x3fv(location,count,transpose,value);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniformMatrix3x2fv(location,count,transpose,value);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniformMatrix2x4fv(location,count,transpose,value);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniformMatrix4x2fv(location,count,transpose,value);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniformMatrix3x4fv(location,count,transpose,value);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniformMatrix4x3fv(location,count,transpose,value);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glBlitFramebuffer(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glRenderbufferStorageMultisample(target,samples,internalformat,width,height);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glFramebufferTextureLayer(target,attachment,texture,level,layer);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- return glMapBufferRange(target,offset,length,access);
-#else
- return NULL;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->MapBufferRange( target, offset, length, access );
}
- void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
+ void FlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length ) override
{
-#if DALI_GLES_VERSION >= 30
- glFlushMappedBufferRange(target,offset,length);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->FlushMappedBufferRange( target, offset, length );
}
- void BindVertexArray(GLuint array)
+ void BindVertexArray( GLuint array ) override
{
-#if DALI_GLES_VERSION >= 30
- glBindVertexArray(array);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->BindVertexArray( array );
}
- void DeleteVertexArrays(GLsizei n, const GLuint* arrays)
+ void DeleteVertexArrays( GLsizei n, const GLuint* arrays ) override
{
-#if DALI_GLES_VERSION >= 30
- glDeleteVertexArrays(n,arrays);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->DeleteVertexArrays( n, arrays );
}
- void GenVertexArrays(GLsizei n, GLuint* arrays)
+ void GenVertexArrays( GLsizei n, GLuint* arrays ) override
{
-#if DALI_GLES_VERSION >= 30
- glGenVertexArrays(n,arrays);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GenVertexArrays( n, arrays );
}
- GLboolean IsVertexArray(GLuint array)
+ GLboolean IsVertexArray( GLuint array ) override
{
-#if DALI_GLES_VERSION >= 30
- return glIsVertexArray(array);
-#else
- return 0;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->IsVertexArray( array );
}
- void GetIntegeri_v(GLenum target, GLuint index, GLint* data)
+ void GetIntegeri_v( GLenum target, GLuint index, GLint* data ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetIntegeri_v(target,index,data);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetIntegeri_v( target, index, data );
}
- void BeginTransformFeedback(GLenum primitiveMode)
+ void BeginTransformFeedback( GLenum primitiveMode ) override
{
-#if DALI_GLES_VERSION >= 30
- glBeginTransformFeedback(primitiveMode);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->BeginTransformFeedback( primitiveMode );
}
- void EndTransformFeedback(void)
+ void EndTransformFeedback( void ) override
{
-#if DALI_GLES_VERSION >= 30
- glEndTransformFeedback();
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glBindBufferRange(target,index,buffer,offset,size);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->BindBufferRange( target, index, buffer, offset, size );
}
- void BindBufferBase(GLenum target, GLuint index, GLuint buffer)
+ void BindBufferBase( GLenum target, GLuint index, GLuint buffer ) override
{
-#if DALI_GLES_VERSION >= 30
- glBindBufferBase(target,index,buffer);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glTransformFeedbackVaryings(program,count,varyings,bufferMode);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGetTransformFeedbackVarying(program,index,bufSize,length,size,type,name);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glVertexAttribIPointer(index,size,type,stride,pointer);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->VertexAttribIPointer( index, size, type, stride, pointer );
}
- void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
+ void GetVertexAttribIiv( GLuint index, GLenum pname, GLint* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetVertexAttribIiv(index,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetVertexAttribIiv( index, pname, params );
}
- void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
+ void GetVertexAttribIuiv( GLuint index, GLenum pname, GLuint* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetVertexAttribIuiv(index,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glVertexAttribI4i(index,x,y,z,w);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glVertexAttribI4ui(index,x,y,z,w);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->VertexAttribI4ui( index, x, y, z, w );
}
- void VertexAttribI4iv(GLuint index, const GLint* v)
+ void VertexAttribI4iv( GLuint index, const GLint* v ) override
{
-#if DALI_GLES_VERSION >= 30
- glVertexAttribI4iv(index,v);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->VertexAttribI4iv( index, v );
}
- void VertexAttribI4uiv(GLuint index, const GLuint* v)
+ void VertexAttribI4uiv( GLuint index, const GLuint* v ) override
{
-#if DALI_GLES_VERSION >= 30
- glVertexAttribI4uiv(index,v);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->VertexAttribI4uiv( index, v );
}
- void GetUniformuiv(GLuint program, GLint location, GLuint* params)
+ void GetUniformuiv( GLuint program, GLint location, GLuint* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetUniformuiv(program,location,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetUniformuiv( program, location, params );
}
- GLint GetFragDataLocation(GLuint program, const GLchar *name)
+ GLint GetFragDataLocation( GLuint program, const GLchar *name ) override
{
-#if DALI_GLES_VERSION >= 30
- return glGetFragDataLocation(program,name);
-#else
- return -1;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->GetFragDataLocation( program, name );
}
- void Uniform1ui(GLint location, GLuint v0)
+ void Uniform1ui( GLint location, GLuint v0 ) override
{
-#if DALI_GLES_VERSION >= 30
- glUniform1ui(location,v0);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->Uniform1ui( location, v0 );
}
- void Uniform2ui(GLint location, GLuint v0, GLuint v1)
+ void Uniform2ui( GLint location, GLuint v0, GLuint v1 ) override
{
-#if DALI_GLES_VERSION >= 30
- glUniform2ui(location,v0,v1);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniform3ui(location,v0,v1,v2);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniform4ui(location,v0,v1,v2,v3);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glUniform1uiv(location,count,value);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->Uniform1uiv( location, count, value );
}
- void Uniform2uiv(GLint location, GLsizei count, const GLuint* value)
+ void Uniform2uiv( GLint location, GLsizei count, const GLuint* value ) override
{
-#if DALI_GLES_VERSION >= 30
- glUniform2uiv(location,count,value);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->Uniform2uiv( location, count, value );
}
- void Uniform3uiv(GLint location, GLsizei count, const GLuint* value)
+ void Uniform3uiv( GLint location, GLsizei count, const GLuint* value ) override
{
-#if DALI_GLES_VERSION >= 30
- glUniform3uiv(location,count,value);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->Uniform3uiv( location, count, value );
}
- void Uniform4uiv(GLint location, GLsizei count, const GLuint* value)
+ void Uniform4uiv( GLint location, GLsizei count, const GLuint* value ) override
{
-#if DALI_GLES_VERSION >= 30
- glUniform4uiv(location,count,value);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->Uniform4uiv( location, count, value );
}
- void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
+ void ClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint* value ) override
{
-#if DALI_GLES_VERSION >= 30
- glClearBufferiv(buffer,drawbuffer,value);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->ClearBufferiv( buffer, drawbuffer, value );
}
- void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
+ void ClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint* value ) override
{
-#if DALI_GLES_VERSION >= 30
- glClearBufferuiv(buffer,drawbuffer,value);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->ClearBufferuiv( buffer, drawbuffer, value );
}
- void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
+ void ClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat* value ) override
{
-#if DALI_GLES_VERSION >= 30
- glClearBufferfv(buffer,drawbuffer,value);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glClearBufferfi(buffer,drawbuffer,depth,stencil);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->ClearBufferfi( buffer, drawbuffer, depth, stencil );
}
- const GLubyte* GetStringi(GLenum name, GLuint index)
+ const GLubyte* GetStringi( GLenum name, GLuint index ) override
{
-#if DALI_GLES_VERSION >= 30
- return glGetStringi(name,index);
-#else
- return NULL;
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glCopyBufferSubData(readTarget,writeTarget,readOffset,writeOffset,size);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGetUniformIndices(program,uniformCount,uniformNames,uniformIndices);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGetActiveUniformsiv(program,uniformCount,uniformIndices,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetActiveUniformsiv( program, uniformCount, uniformIndices, pname, params );
}
- GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
+ GLuint GetUniformBlockIndex( GLuint program, const GLchar* uniformBlockName ) override
{
-#if DALI_GLES_VERSION >= 30
- return glGetUniformBlockIndex(program,uniformBlockName);
-#else
- return 0;
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGetActiveUniformBlockiv(program,uniformBlockIndex,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGetActiveUniformBlockName(program,uniformBlockIndex,bufSize,length,uniformBlockName);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetActiveUniformBlockName( program, uniformBlockIndex, bufSize, length, uniformBlockName );
}
- void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
+ void UniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding ) override
{
-#if DALI_GLES_VERSION >= 30
- glUniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glDrawArraysInstanced(mode,first,count,instanceCount);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glDrawElementsInstanced(mode,count,type,indices,instanceCount);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->DrawElementsInstanced( mode, count, type, indices, instanceCount );
}
- GLsync FenceSync(GLenum condition, GLbitfield flags)
+ GLsync FenceSync( GLenum condition, GLbitfield flags ) override
{
-#if DALI_GLES_VERSION >= 30
- return glFenceSync(condition,flags);
-#else
- return NULL;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->FenceSync( condition, flags );
}
- GLboolean IsSync(GLsync sync)
+ GLboolean IsSync( GLsync sync ) override
{
-#if DALI_GLES_VERSION >= 30
- return glIsSync(sync);
-#else
- return 0;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->IsSync( sync );
}
- void DeleteSync(GLsync sync)
+ void DeleteSync( GLsync sync ) override
{
-#if DALI_GLES_VERSION >= 30
- glDeleteSync(sync);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->DeleteSync( sync );
}
- GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+ GLenum ClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) override
{
-#if DALI_GLES_VERSION >= 30
- return glClientWaitSync(sync,flags,timeout);
-#else
- return 0;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->ClientWaitSync( sync, flags, timeout );
}
- void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+ void WaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) override
{
-#if DALI_GLES_VERSION >= 30
- glWaitSync(sync,flags,timeout);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->WaitSync( sync, flags, timeout );
}
- void GetInteger64v(GLenum pname, GLint64* params)
+ void GetInteger64v( GLenum pname, GLint64* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetInteger64v(pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGetSynciv(sync,pname,bufSize,length,values);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGetInteger64i_v(target,index,data);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetInteger64i_v( target, index, data );
}
- void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
+ void GetBufferParameteri64v( GLenum target, GLenum pname, GLint64* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetBufferParameteri64v(target,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetBufferParameteri64v( target, pname, params );
}
- void GenSamplers(GLsizei count, GLuint* samplers)
+ void GenSamplers( GLsizei count, GLuint* samplers ) override
{
-#if DALI_GLES_VERSION >= 30
- glGenSamplers(count,samplers);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GenSamplers( count, samplers );
}
- void DeleteSamplers(GLsizei count, const GLuint* samplers)
+ void DeleteSamplers( GLsizei count, const GLuint* samplers ) override
{
-#if DALI_GLES_VERSION >= 30
- glDeleteSamplers(count,samplers);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->DeleteSamplers( count, samplers );
}
- GLboolean IsSampler(GLuint sampler)
+ GLboolean IsSampler( GLuint sampler ) override
{
-#if DALI_GLES_VERSION >= 30
- return glIsSampler(sampler);
-#else
- return 0;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->IsSampler( sampler );
}
- void BindSampler(GLuint unit, GLuint sampler)
+ void BindSampler( GLuint unit, GLuint sampler ) override
{
-#if DALI_GLES_VERSION >= 30
- glBindSampler(unit,sampler);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->BindSampler( unit, sampler );
}
- void SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
+ void SamplerParameteri( GLuint sampler, GLenum pname, GLint param ) override
{
-#if DALI_GLES_VERSION >= 30
- glSamplerParameteri(sampler,pname,param);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->SamplerParameteri( sampler, pname, param );
}
- void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
+ void SamplerParameteriv( GLuint sampler, GLenum pname, const GLint* param ) override
{
-#if DALI_GLES_VERSION >= 30
- glSamplerParameteriv(sampler,pname,param);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->SamplerParameteriv( sampler, pname, param );
}
- void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
+ void SamplerParameterf( GLuint sampler, GLenum pname, GLfloat param ) override
{
-#if DALI_GLES_VERSION >= 30
- glSamplerParameterf(sampler,pname,param);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->SamplerParameterf( sampler, pname, param );
}
- void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
+ void SamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat* param ) override
{
-#if DALI_GLES_VERSION >= 30
- glSamplerParameterfv(sampler,pname,param);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->SamplerParameterfv( sampler, pname, param );
}
- void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
+ void GetSamplerParameteriv( GLuint sampler, GLenum pname, GLint* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetSamplerParameteriv(sampler,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetSamplerParameteriv( sampler, pname, params );
}
- void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
+ void GetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* params ) override
{
-#if DALI_GLES_VERSION >= 30
- glGetSamplerParameterfv(sampler,pname,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetSamplerParameterfv( sampler, pname, params );
}
- void VertexAttribDivisor(GLuint index, GLuint divisor)
+ void VertexAttribDivisor( GLuint index, GLuint divisor ) override
{
-#if DALI_GLES_VERSION >= 30
- glVertexAttribDivisor(index,divisor);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->VertexAttribDivisor( index, divisor );
}
- void BindTransformFeedback(GLenum target, GLuint id)
+ void BindTransformFeedback( GLenum target, GLuint id ) override
{
-#if DALI_GLES_VERSION >= 30
- glBindTransformFeedback(target,id);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->BindTransformFeedback( target, id );
}
- void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
+ void DeleteTransformFeedbacks( GLsizei n, const GLuint* ids ) override
{
-#if DALI_GLES_VERSION >= 30
- glDeleteTransformFeedbacks(n,ids);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->DeleteTransformFeedbacks( n, ids );
}
- void GenTransformFeedbacks(GLsizei n, GLuint* ids)
+ void GenTransformFeedbacks( GLsizei n, GLuint* ids ) override
{
-#if DALI_GLES_VERSION >= 30
- glGenTransformFeedbacks(n,ids);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GenTransformFeedbacks( n, ids );
}
- GLboolean IsTransformFeedback(GLuint id)
+ GLboolean IsTransformFeedback( GLuint id ) override
{
-#if DALI_GLES_VERSION >= 30
- return glIsTransformFeedback(id);
-#else
- return 0;
-#endif // DALI_GLES_VERSION >= 30
+ return mImpl->IsTransformFeedback( id );
}
- void PauseTransformFeedback(void)
+ void PauseTransformFeedback( void ) override
{
-#if DALI_GLES_VERSION >= 30
- glPauseTransformFeedback();
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->PauseTransformFeedback();
}
- void ResumeTransformFeedback(void)
+ void ResumeTransformFeedback( void ) override
{
-#if DALI_GLES_VERSION >= 30
- glResumeTransformFeedback();
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- // if OpenGL ES 2.0 compatibility is need this can be implemented with
- // glGetProgramBinaryOES
- glGetProgramBinary(program,bufSize,length,binaryFormat,binary);
-#else
- mGlExtensions.GetProgramBinaryOES(program, bufSize, length, binaryFormat, binary);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- // if OpenGL ES 2.0 compatibility is need this can be implemented with
- // glProgramBinaryOES
- glProgramBinary(program,binaryFormat,binary,length);
-#else
- mGlExtensions.ProgramBinaryOES(program, binaryFormat, binary, length);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->ProgramBinary( program, binaryFormat, binary, length );
}
- void ProgramParameteri(GLuint program, GLenum pname, GLint value)
+ void ProgramParameteri( GLuint program, GLenum pname, GLint value ) override
{
-#if DALI_GLES_VERSION >= 30
- glProgramParameteri(program,pname,value);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->ProgramParameteri( program, pname, value );
}
- void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
+ void InvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments ) override
{
-#if DALI_GLES_VERSION >= 30
- glInvalidateFramebuffer(target,numAttachments,attachments);
-#else
- mGlExtensions.DiscardFrameBuffer(target, numAttachments, attachments);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glInvalidateSubFramebuffer(target,numAttachments,attachments,x,y,width,height);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glTexStorage2D(target,levels,internalformat,width,height);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glTexStorage3D(target,levels,internalformat,width,height,depth);
-#endif // DALI_GLES_VERSION >= 30
+ 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
{
-#if DALI_GLES_VERSION >= 30
- glGetInternalformativ(target,internalformat,pname,bufSize,params);
-#endif // DALI_GLES_VERSION >= 30
+ mImpl->GetInternalformativ( target, internalformat, pname, bufSize, params );
}
-private:
- ECoreX::GlExtensions mGlExtensions;
+ void BlendBarrier(void)
+ {
+ if(mIsAdvancedBlendEquationSupported)
+ {
+ mImpl->BlendBarrier();
+ }
+ }
+private:
+ std::unique_ptr<GlesAbstraction> 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
} // namespace Dali
-#endif // __DALI_INTERNAL_GL_IMPLEMENTATION_H__
+#endif // DALI_INTERNAL_GL_IMPLEMENTATION_H
projects / platform / core / uifw / dali-adaptor.git / blobdiff