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

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