dali/internal/render/gl-resources/context.h

   1 #ifndef __DALI_INTERNAL_CONTEXT_H__
   2 #define __DALI_INTERNAL_CONTEXT_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 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/dali-vector.h>
  23 #include <dali/public-api/common/dali-common.h>
  24 #include <dali/public-api/math/rect.h>
  25 #include <dali/public-api/math/vector4.h>
  26 #include <dali/public-api/rendering/renderer.h>
  27 #include <dali/integration-api/debug.h>
  28 #include <dali/integration-api/gl-abstraction.h>
  29 #include <dali/integration-api/gl-defines.h>
  30 #include <dali/internal/render/common/performance-monitor.h>
  31 #include <dali/internal/render/gl-resources/texture-units.h>
  32 #include <dali/internal/render/gl-resources/frame-buffer-state-cache.h>
  33 #include <dali/internal/render/gl-resources/gl-call-debug.h>
  34
  35 namespace Dali
  36 {
  37
  38 namespace Internal
  39 {
  40
  41 /**
  42  * Context records the current GL state, and provides access to the OpenGL ES 2.0 API.
  43  * Context avoids duplicate GL calls, if the same setting etc. is requested repeatedly.
  44  */
  45 class Context
  46 {
  47 public:
  48
  49   /**
  50    * FrameBuffer Clear mode
  51    */
  52   enum ClearMode
  53   {
  54     FORCE_CLEAR,        ///< always perform the glClear regardless of current state
  55     CHECK_CACHED_VALUES ///< check the Frame buffers cached state to see if a clear is required
  56   };
  57
  58   /**
  59    * Size of the VertexAttributeArray enables
  60    * GLES specification states that there's minimum of 8
  61    */
  62   static const unsigned int MAX_ATTRIBUTE_CACHE_SIZE = 8;
  63
  64   static const unsigned int MAX_TEXTURE_UNITS = 8; // for GLES 2.0 8 is guaranteed, which is more than DALi uses anyways
  65
  66   /**
  67    * Creates the Dali Context object.
  68    * This method does not create an OpenGL context i.e. that is done from outside dali-core.
  69    * @pre Context has not been created.
  70    * @exception Context already created.
  71    * @param glAbstraction the gl abstraction.
  72    */
  73   Context( Integration::GlAbstraction& glAbstraction );
  74
  75   /**
  76    * Destructor
  77    */
  78   ~Context();
  79
  80   /**
  81    * Called when the GL context has been created.
  82    */
  83   void GlContextCreated();
  84
  85   /**
  86    * Called when the GL context has been destroyed.
  87    */
  88   void GlContextDestroyed();
  89
  90   /**
  91    * Query whether the OpenGL context has been created.
  92    * @return True if the OpenGL context has been created.
  93    */
  94   bool IsGlContextCreated() { return mGlContextCreated; }
  95
  96   /**
  97    * @return the GLAbstraction
  98    */
  99   Integration::GlAbstraction& GetAbstraction() { return mGlAbstraction; }
 100
 101 #ifdef DEBUG_ENABLED
 102
 103   /**
 104    * Debug helper which prints the currently cached GL state.
 105    */
 106   void PrintCurrentState();
 107
 108 #endif
 109
 110   /**
 111    * Helper to convert GL error code to string
 112    * @param errorCode to convert
 113    * @return C string
 114    */
 115   const char* ErrorToString( GLenum errorCode );
 116
 117   /**
 118    * Helper to print GL string to debug log
 119    */
 120   void PrintGlString(const char* stringName, GLenum stringId)
 121   {
 122     DALI_LOG_INFO(Debug::Filter::gRender, Debug::General, "GL %s = %s\n", stringName, reinterpret_cast< const char * >( GetString( stringId ) ) );
 123   }
 124
 125   /****************************************************************************************
 126    * The following methods are forwarded to Dali::Integration::GlAbstraction.
 127    * In some cases the GL state is recorded, to avoid duplicate calls with the same state.
 128    * All Shader, Program, Uniform and Attribute related calls are not here, Program class
 129    * handles them and optimizes any program related state changes
 130    ****************************************************************************************/
 131
 132   /**
 133    * Wrapper for OpenGL ES 2.0 glActiveTexture()
 134    */
 135   void ActiveTexture( TextureUnit textureUnit )
 136   {
 137     if ( textureUnit != mActiveTextureUnit )
 138     {
 139       mActiveTextureUnit = textureUnit;
 140       LOG_GL("ActiveTexture %x\n", textureUnit);
 141       CHECK_GL( mGlAbstraction, mGlAbstraction.ActiveTexture(TextureUnitAsGLenum(textureUnit)) );
 142     }
 143   }
 144
 145   /**
 146    * Wrapper for OpenGL ES 3.0 glBeginQuery()
 147    */
 148   void BeginQuery(GLenum target, GLuint id)
 149   {
 150     LOG_GL("BeginQuery %d %d\n", target, id);
 151     CHECK_GL( mGlAbstraction, mGlAbstraction.BeginQuery(target, id) );
 152   }
 153
 154   /**
 155    * Wrapper for OpenGL ES 3.0 glBeginTransformFeedback()
 156    */
 157   void BeginTransformFeedback(GLenum primitiveMode)
 158   {
 159     LOG_GL("BeginTransformFeedback %x\n", primitiveMode);
 160     CHECK_GL( mGlAbstraction, mGlAbstraction.BeginTransformFeedback(primitiveMode) );
 161   }
 162
 163   /**
 164    * The wrapper for OpenGL ES 2.0 glBindBuffer() has been replaced by BindArrayBuffer & BindElementArrayBuffer & BindTransformFeedbackBuffer.
 165    */
 166
 167   /**
 168    * Wrapper for OpenGL ES 2.0 glBindBuffer(GL_ARRAY_BUFFER, ...)
 169    */
 170   void BindArrayBuffer(GLuint buffer)
 171   {
 172     // Avoid unecessary calls to BindBuffer
 173     if (mBoundArrayBufferId != buffer)
 174     {
 175       mBoundArrayBufferId = buffer;
 176
 177       LOG_GL("BindBuffer GL_ARRAY_BUFFER %d\n", buffer);
 178       CHECK_GL( mGlAbstraction, mGlAbstraction.BindBuffer(GL_ARRAY_BUFFER, buffer) );
 179     }
 180   }
 181
 182   /**
 183    * Wrapper for OpenGL ES 2.0 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ...)
 184    */
 185   void BindElementArrayBuffer(GLuint buffer)
 186   {
 187     // Avoid unecessary calls to BindBuffer
 188     if (mBoundElementArrayBufferId!= buffer)
 189     {
 190       mBoundElementArrayBufferId = buffer;
 191
 192       LOG_GL("BindBuffer GL_ELEMENT_ARRAY_BUFFER %d\n", buffer);
 193       CHECK_GL( mGlAbstraction, mGlAbstraction.BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer) );
 194     }
 195   }
 196
 197   /**
 198    * Wrapper for OpenGL ES 3.0 glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, ...)
 199    */
 200   void BindTransformFeedbackBuffer(GLuint buffer)
 201   {
 202     // Avoid unecessary calls to BindBuffer
 203     if (mBoundTransformFeedbackBufferId != buffer)
 204     {
 205       mBoundTransformFeedbackBufferId = buffer;
 206
 207       LOG_GL("BindBuffer GL_TRANSFORM_FEEDBACK_BUFFER %d\n", buffer);
 208       CHECK_GL( mGlAbstraction, mGlAbstraction.BindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER , buffer) );
 209     }
 210   }
 211
 212   /**
 213    * Wrapper for OpenGL ES 3.0 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, ...)
 214    */
 215   void BindTransformFeedbackBufferBase(GLuint index, GLuint buffer)
 216   {
 217     // Avoid unecessary calls to BindBufferBase
 218     if (mBoundTransformFeedbackBufferId != buffer)
 219     {
 220       mBoundTransformFeedbackBufferId = buffer;
 221
 222       LOG_GL("BindBufferBase GL_TRANSFORM_FEEDBACK_BUFFER %d %d\n", index, buffer);
 223       CHECK_GL( mGlAbstraction, mGlAbstraction.BindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, index, buffer) );
 224     }
 225   }
 226
 227   /**
 228    * Wrapper for OpenGL ES 2.0 glBindFramebuffer()
 229    */
 230   void BindFramebuffer(GLenum target, GLuint framebuffer)
 231   {
 232     mFrameBufferStateCache.SetCurrentFrameBuffer( framebuffer );
 233
 234     LOG_GL("BindFramebuffer %d %d\n", target, framebuffer);
 235     CHECK_GL( mGlAbstraction, mGlAbstraction.BindFramebuffer(target, framebuffer) );
 236   }
 237
 238   /**
 239    * Wrapper for OpenGL ES 2.0 glBindRenderbuffer()
 240    */
 241   void BindRenderbuffer(GLenum target, GLuint renderbuffer)
 242   {
 243     LOG_GL("BindRenderbuffer %d %d\n", target, renderbuffer);
 244     CHECK_GL( mGlAbstraction, mGlAbstraction.BindRenderbuffer(target, renderbuffer) );
 245   }
 246
 247   /**
 248    * Wrapper for OpenGL ES 3.0 glBindTransformFeedback()
 249    */
 250   void BindTransformFeedback(GLenum target, GLuint id)
 251   {
 252     LOG_GL("BindTransformFeedback %d %d\n", target, id);
 253     CHECK_GL( mGlAbstraction, mGlAbstraction.BindTransformFeedback(target, id) );
 254   }
 255
 256   /**
 257    * Helper to bind texture for rendering. If given texture is
 258    * already bound in the given textureunit, this method does nothing.
 259    * Otherwise changes the active texture unit and binds the texture.
 260    * Note! after this call active texture unit may not necessarily be the one
 261    * passed in as argument so you cannot change texture unit state!!
 262    * @param textureunit to bind to
 263    * @param texture to bind
 264    */
 265   void BindTextureForUnit( TextureUnit textureunit, GLuint texture )
 266   {
 267     if( mBound2dTextureId[ textureunit ] != texture )
 268     {
 269       ActiveTexture( textureunit );
 270       Bind2dTexture( texture );
 271     }
 272   }
 273
 274   /**
 275    * Wrapper for OpenGL ES 2.0 glBindTexture(GL_TEXTURE_2D)
 276    */
 277   void Bind2dTexture( GLuint texture )
 278   {
 279     if (mBound2dTextureId[ mActiveTextureUnit ] != texture)
 280     {
 281       mBound2dTextureId[ mActiveTextureUnit ] = texture;
 282
 283       LOG_GL("BindTexture GL_TEXTURE_2D %d\n", texture);
 284       CHECK_GL( mGlAbstraction, mGlAbstraction.BindTexture(GL_TEXTURE_2D, texture) );
 285     }
 286   }
 287
 288   /**
 289    * Wrapper for OpenGL ES 2.0 glBindTexture( target )
 290    */
 291   void BindTexture( int target, GLuint texture )
 292   {
 293     if (mBound2dTextureId[ mActiveTextureUnit ] != texture)
 294     {
 295       mBound2dTextureId[ mActiveTextureUnit ] = texture;
 296
 297       LOG_GL("BindTexture target(%d) %d\n", target, texture);
 298       CHECK_GL( mGlAbstraction, mGlAbstraction.BindTexture(target, texture) );
 299     }
 300   }
 301
 302   /**
 303    * Wrapper for OpenGL ES 2.0 glBindTexture(GL_TEXTURE_CUBE_MAP)
 304    */
 305   void BindCubeMapTexture( GLuint texture )
 306   {
 307     LOG_GL("BindTexture GL_TEXTURE_CUBE_MAP %d\n", texture);
 308     CHECK_GL( mGlAbstraction, mGlAbstraction.BindTexture(GL_TEXTURE_CUBE_MAP, texture) );
 309   }
 310
 311   /**
 312    * Wrapper for OpenGL ES 2.0 glBlendColor()
 313    */
 314   void SetDefaultBlendColor()
 315   {
 316     if( ! mUsingDefaultBlendColor )
 317     {
 318       SetCustomBlendColor( Color::TRANSPARENT );
 319       mUsingDefaultBlendColor = true;
 320     }
 321   }
 322
 323   /**
 324    * Wrapper for OpenGL ES 2.0 glBlendColor()
 325    */
 326   void SetCustomBlendColor( const Vector4& color )
 327   {
 328     if( mUsingDefaultBlendColor || mBlendColor != color )
 329     {
 330       LOG_GL( "BlendColor %f %f %f %f\n", color.r, color.g, color.b, color.a );
 331       CHECK_GL( mGlAbstraction, mGlAbstraction.BlendColor( color.r, color.g, color.b, color.a ) );
 332       mUsingDefaultBlendColor = false;
 333       mBlendColor = color;
 334     }
 335   }
 336
 337   /**
 338    * Wrapper for OpenGL ES 2.0 glBlendEquation()
 339    */
 340   void BlendEquation(GLenum mode)
 341   {
 342     // use BlendEquationSeparate to set the rgb and alpha modes the same
 343     BlendEquationSeparate( mode, mode );
 344   }
 345
 346   /**
 347    * Wrapper for OpenGL ES 2.0 glBlendEquationSeparate()
 348    */
 349   void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 350   {
 351     if( ( modeRGB != mBlendEquationSeparateModeRGB ) ||
 352         ( modeAlpha != mBlendEquationSeparateModeAlpha ) )
 353     {
 354       mBlendEquationSeparateModeRGB = modeRGB;
 355       mBlendEquationSeparateModeAlpha = modeAlpha;
 356       LOG_GL("BlendEquationSeparate %d %d\n", modeRGB, modeAlpha);
 357       CHECK_GL( mGlAbstraction, mGlAbstraction.BlendEquationSeparate(modeRGB, modeAlpha) );
 358     }
 359   }
 360
 361   /**
 362    * Wrapper for OpenGL ES 2.0 glBlendFunc()
 363    */
 364   void BlendFunc(GLenum sfactor, GLenum dfactor)
 365   {
 366     // reuse the BlendFuncSeparate as thats what the DDK does anyways
 367     BlendFuncSeparate( sfactor, dfactor, sfactor, dfactor );
 368   }
 369
 370   /**
 371    * Wrapper for OpenGL ES 2.0 glBlendFuncSeparate()
 372    */
 373   void BlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
 374   {
 375     if( ( mBlendFuncSeparateSrcRGB != srcRGB )||( mBlendFuncSeparateDstRGB != dstRGB )||
 376         ( mBlendFuncSeparateSrcAlpha != srcAlpha )||( mBlendFuncSeparateDstAlpha != dstAlpha ) )
 377     {
 378       mBlendFuncSeparateSrcRGB = srcRGB;
 379       mBlendFuncSeparateDstRGB = dstRGB;
 380       mBlendFuncSeparateSrcAlpha = srcAlpha;
 381       mBlendFuncSeparateDstAlpha = dstAlpha;
 382
 383       LOG_GL( "BlendFuncSeparate %d %d %d %d\n", srcRGB, dstRGB, srcAlpha, dstAlpha );
 384       CHECK_GL( mGlAbstraction, mGlAbstraction.BlendFuncSeparate( srcRGB, dstRGB, srcAlpha, dstAlpha ) );
 385     }
 386   }
 387
 388   /**
 389    * Wrapper for OpenGL ES 3.0 glBlitFramebuffer()
 390    */
 391   void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 392   {
 393     LOG_GL( "BlitFramebuffer %d %d %d %d %d %d %d %d %x %d\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
 394     CHECK_GL( mGlAbstraction, mGlAbstraction.BlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ) );
 395   }
 396
 397   /**
 398    * Wrapper for OpenGL ES 2.0 glBufferData()
 399    */
 400   void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
 401   {
 402     LOG_GL("BufferData %d %d %p %d\n", target, size, data, usage);
 403     CHECK_GL( mGlAbstraction, mGlAbstraction.BufferData(target, size, data, usage) );
 404   }
 405
 406   /**
 407    * Wrapper for OpenGL ES 2.0 glBufferSubData()
 408    */
 409   void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
 410   {
 411     LOG_GL("BufferSubData %d %d %d %p\n", target, offset, size, data);
 412     CHECK_GL( mGlAbstraction, mGlAbstraction.BufferSubData(target, offset, size, data) );
 413   }
 414
 415   /**
 416    * Wrapper for OpenGL ES 2.0  glCheckFramebufferStatus()
 417    */
 418   GLenum CheckFramebufferStatus(GLenum target)
 419   {
 420     LOG_GL("CheckFramebufferStatus %d\n", target);
 421     GLenum value = CHECK_GL( mGlAbstraction, mGlAbstraction.CheckFramebufferStatus(target) );
 422     return value;
 423   }
 424
 425   /**
 426    * Wrapper for OpenGL ES 2.0 glClear()
 427    */
 428   void Clear(GLbitfield mask, ClearMode mode )
 429   {
 430     bool forceClear = (mode == FORCE_CLEAR );
 431     mask = mFrameBufferStateCache.GetClearMask( mask, forceClear , mScissorTestEnabled );
 432
 433     if( mask > 0 )
 434     {
 435       LOG_GL("Clear %d\n", mask);
 436       CHECK_GL( mGlAbstraction, mGlAbstraction.Clear( mask ) );
 437     }
 438   }
 439
 440   /**
 441    * Wrapper for OpenGL ES 2.0 glClearColor()
 442    */
 443   void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 444   {
 445     Vector4 newCol(red,green,blue,alpha);
 446
 447     if (!mClearColorSet || mClearColor !=newCol )
 448     {
 449       LOG_GL("ClearColor %f %f %f %f\n", red, green, blue, alpha);
 450       CHECK_GL( mGlAbstraction, mGlAbstraction.ClearColor(red, green, blue, alpha) );
 451
 452       mClearColorSet = true;
 453       mClearColor = newCol;
 454     }
 455   }
 456
 457   /**
 458    * Wrapper for OpenGL ES 2.0 glClearDepthf()
 459    */
 460   void ClearDepthf(GLclampf depth)
 461   {
 462     LOG_GL("ClearDepthf %f\n", depth);
 463     CHECK_GL( mGlAbstraction, mGlAbstraction.ClearDepthf(depth) );
 464   }
 465
 466   /**
 467    * Wrapper for OpenGL ES 2.0 glClearStencil()
 468    */
 469   void ClearStencil(GLint s)
 470   {
 471     LOG_GL("ClearStencil %d\n", s);
 472     CHECK_GL( mGlAbstraction, mGlAbstraction.ClearStencil(s) );
 473   }
 474
 475   /**
 476    * Wrapper for OpenGL ES 2.0 glColorMask()
 477    * @note This has been optimized to a single boolean value (masking individual channels is not required)
 478    */
 479   void ColorMask( bool flag )
 480   {
 481     // only change state if needed
 482     if( flag != mColorMask )
 483     {
 484       mColorMask = flag;
 485       LOG_GL("ColorMask %s %s %s %s\n", flag ? "True" : "False", flag ? "True" : "False", flag ? "True" : "False", flag ? "True" : "False");
 486       CHECK_GL( mGlAbstraction, mGlAbstraction.ColorMask(flag, flag, flag, flag) );
 487     }
 488   }
 489
 490   /**
 491    * Wrapper for OpenGL ES 2.0 glCompressedTexImage2D()
 492    */
 493   void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
 494                             GLint border, GLsizei imageSize, const void* data)
 495   {
 496     LOG_GL("CompressedTexImage2D %d %d %x %d %d %d %d %p\n", target, level, internalformat, width, height, border, imageSize, data);
 497     CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data) );
 498   }
 499
 500   /**
 501    * Wrapper for OpenGL ES 3.0 glCompressedTexImage3D()
 502    */
 503   void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
 504                             GLint border, GLsizei imageSize, const void* data)
 505   {
 506     LOG_GL("CompressedTexImage3D %d %d %x %d %d %d %d %d %p\n", target, level, internalformat, width, height, depth, border, imageSize, data);
 507     CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data) );
 508   }
 509
 510   /**
 511    * Wrapper for OpenGL ES 2.0 glCompressedTexSubImage2D()
 512    */
 513   void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
 514                                GLenum format, GLsizei imageSize, const void* data)
 515   {
 516     LOG_GL("CompressedTexSubImage2D %x %d %d %d %d %d %x %d %p\n", target, level, xoffset, yoffset, width, height, format, imageSize, data);
 517     CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) );
 518   }
 519
 520   /**
 521    * Wrapper for OpenGL ES 3.0 glCompressedTexSubImage3D()
 522    */
 523   void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
 524                                GLsizei width, GLsizei height, GLsizei depth,
 525                                GLenum format, GLsizei imageSize, const void* data)
 526   {
 527     LOG_GL("CompressedTexSubImage3D %x %d %d %d %d %d %d %d %x %d %p\n", target, level, xoffset, yoffset, xoffset, width, height, depth, format, imageSize, data);
 528     CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) );
 529   }
 530
 531   /**
 532    * Wrapper for OpenGL ES 2.0 glCopyTexImage2D()
 533    */
 534   void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 535   {
 536     LOG_GL("CopyTexImage2D %x %d %x %d %d %d %d %d\n", target, level, internalformat, x, y, width, height, border);
 537     CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexImage2D(target, level, internalformat, x, y, width, height, border) );
 538   }
 539
 540   /**
 541    * Wrapper for OpenGL ES 2.0 glCopyTexSubImage2D()
 542    */
 543   void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 544   {
 545     LOG_GL("CopyTexSubImage2D %x %d %d %d %d %d %d %d\n", target, level, xoffset, yoffset, x, y, width, height);
 546     CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) );
 547   }
 548
 549   /**
 550    * Wrapper for OpenGL ES 3.0 glCopyTexSubImage3D()
 551    */
 552   void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 553   {
 554     LOG_GL("CopyTexSubImage3D %x %d %d %d %d %d %d %d %d\n", target, level, xoffset, yoffset, zoffset, x, y, width, height);
 555     CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) );
 556   }
 557
 558   /**
 559    * Wrapper for OpenGL ES 2.0 glCullFace()
 560    * enables GL_CULL_FACE if in any of the face culling modes
 561    * otherwise disables GL_CULL_FACE
 562    */
 563   void CullFace( Dali::FaceCullingMode::Type mode )
 564   {
 565     // Avoid unnecessary calls to gl
 566     if(mCullFaceMode != mode)
 567     {
 568       mCullFaceMode = mode;
 569       switch(mode)
 570       {
 571         case Dali::FaceCullingMode::NONE:
 572         {
 573           LOG_GL("Disable GL_CULL_FACE\n");
 574           CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_CULL_FACE) );
 575           break;
 576         }
 577
 578         case Dali::FaceCullingMode::FRONT:
 579         {
 580           LOG_GL("Enable GL_CULL_FACE\n");
 581           CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
 582           LOG_GL("Enable GL_FRONT\n");
 583           CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_FRONT) );
 584           break;
 585         }
 586
 587         case Dali::FaceCullingMode::BACK:
 588         {
 589           LOG_GL("Enable GL_CULL_FACE\n");
 590           CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
 591           LOG_GL("Enable GL_BACK\n");
 592           CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_BACK) );
 593           break;
 594         }
 595
 596         case Dali::FaceCullingMode::FRONT_AND_BACK:
 597         {
 598           LOG_GL("Enable GL_CULL_FACE\n");
 599           CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
 600           LOG_GL("Enable GL_FRONT_AND_BACK\n");
 601           CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_FRONT_AND_BACK) );
 602           break;
 603         }
 604
 605         default:
 606           break;
 607       }
 608     }
 609   }
 610
 611   /**
 612    * Wrapper for OpenGL ES 2.0 glDeleteBuffers()
 613    */
 614   void DeleteBuffers(GLsizei n, const GLuint* buffers)
 615   {
 616     // @todo: this is to prevent mesh destructor from doing GL calls when DALi core is being deleted
 617     // can be taken out once render manages either knows about meshes or gpubuffers and can tell them directly that context is lost
 618     if( this->IsGlContextCreated() )
 619     {
 620       LOG_GL("DeleteBuffers %d %p\n", n, buffers);
 621       CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteBuffers(n, buffers) );
 622     }
 623     // reset the cached buffer id's
 624     // fixes problem where some drivers will a generate a buffer with the
 625     // same id, as the last deleted buffer id.
 626     mBoundArrayBufferId = 0;
 627     mBoundElementArrayBufferId = 0;
 628     mBoundTransformFeedbackBufferId = 0;
 629   }
 630
 631   /**
 632    * Wrapper for OpenGL ES 2.0 glDeleteFramebuffers()
 633    */
 634   void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 635   {
 636     mFrameBufferStateCache.FrameBuffersDeleted( n, framebuffers );
 637
 638     LOG_GL("DeleteFramebuffers %d %p\n", n, framebuffers);
 639     CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteFramebuffers(n, framebuffers) );
 640   }
 641
 642   /**
 643    * Wrapper for OpenGL ES 3.0 glDeleteQueries()
 644    */
 645   void DeleteQueries(GLsizei n, GLuint* ids)
 646   {
 647     LOG_GL("DeleteQueries %d %p\n", n, ids);
 648     CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteQueries(n, ids) );
 649   }
 650
 651   /**
 652    * Wrapper for OpenGL ES 2.0 glDeleteRenderbuffers()
 653    */
 654   void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 655   {
 656     LOG_GL("DeleteRenderbuffers %d %p\n", n, renderbuffers);
 657     CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteRenderbuffers(n, renderbuffers) );
 658   }
 659
 660   /**
 661    * Wrapper for OpenGL ES 2.0 glDeleteTextures()
 662    */
 663   void DeleteTextures(GLsizei n, const GLuint* textures)
 664   {
 665     LOG_GL("DeleteTextures %d %p\n", n, textures);
 666     CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTextures(n, textures) );
 667
 668     // reset the cached texture id's incase the driver re-uses them
 669     // when creating new textures
 670     for( unsigned int i=0; i < MAX_TEXTURE_UNITS; ++i )
 671     {
 672        mBound2dTextureId[ i ] = 0;
 673     }
 674   }
 675
 676   /**
 677    * Wrapper for OpenGL ES 3.0 glDeleteTransformFeedbacks()
 678    */
 679   void DeleteTransformFeedbacks(GLsizei n, GLuint* ids)
 680   {
 681     LOG_GL("DeleteTransformFeedbacks %d %p\n", n, ids);
 682     CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTransformFeedbacks(n, ids) );
 683   }
 684
 685   /**
 686    * Wrapper for OpenGL ES 2.0 glDepthFunc()
 687    */
 688   void DepthFunc(GLenum func)
 689   {
 690     if( func != mDepthFunction )
 691     {
 692       mDepthFunction = func;
 693       LOG_GL("DepthFunc %x\n", func);
 694       CHECK_GL( mGlAbstraction, mGlAbstraction.DepthFunc(func) );
 695     }
 696   }
 697
 698   /**
 699    * Wrapper for OpenGL ES 2.0 glDepthMask()
 700    */
 701   void DepthMask(GLboolean flag)
 702   {
 703     bool booleanFlag = flag != GL_FALSE;
 704     // only change state if needed
 705     if( booleanFlag != mDepthMaskEnabled )
 706     {
 707       mDepthMaskEnabled = booleanFlag;
 708       LOG_GL("DepthMask %s\n", booleanFlag ? "True" : "False");
 709       CHECK_GL( mGlAbstraction, mGlAbstraction.DepthMask( mDepthMaskEnabled ) );
 710     }
 711   }
 712
 713   /**
 714    * Wrapper for OpenGL ES 2.0 glDepthRangef()
 715    */
 716   void DepthRangef(GLclampf zNear, GLclampf zFar)
 717   {
 718     LOG_GL("DepthRangef %f %f\n", zNear, zFar);
 719     CHECK_GL( mGlAbstraction, mGlAbstraction.DepthRangef(zNear, zFar) );
 720   }
 721
 722   /**
 723    * The wrapper for OpenGL ES 2.0 glDisable() has been replaced by SetBlend, SetCullFace, SetDepthTest,
 724    * SetDither, SetPolygonOffsetFill, SetSampleAlphaToCoverage, SetSampleCoverage, SetScissorTest & SetStencilTest.
 725    */
 726
 727   /**
 728    * Wrapper for OpenGL ES 2.0 glDrawArrays()
 729    */
 730   void DrawArrays(GLenum mode, GLint first, GLsizei count)
 731   {
 732     mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
 733     FlushVertexAttributeLocations();
 734
 735     LOG_GL("DrawArrays %x %d %d\n", mode, first, count);
 736     CHECK_GL( mGlAbstraction, mGlAbstraction.DrawArrays(mode, first, count) );
 737   }
 738
 739   /**
 740    * Wrapper for OpenGL ES 3.0 glDrawArraysInstanced()
 741    */
 742   void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
 743   {
 744     mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
 745     FlushVertexAttributeLocations();
 746
 747     LOG_GL("DrawArraysInstanced %x %d %d %d\n", mode, first, count, instanceCount);
 748     CHECK_GL( mGlAbstraction, mGlAbstraction.DrawArraysInstanced(mode, first, count,instanceCount) );
 749   }
 750
 751   /**
 752    * Wrapper for OpenGL ES 3.0 glDrawBuffers()
 753    */
 754   void DrawBuffers(GLsizei n, const GLenum* bufs)
 755   {
 756     mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
 757     LOG_GL("DrawBuffers %d %p\n", n, bufs);
 758     CHECK_GL( mGlAbstraction, mGlAbstraction.DrawBuffers(n, bufs) );
 759   }
 760
 761   /**
 762    * Wrapper for OpenGL ES 2.0 glDrawElements()
 763    */
 764   void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
 765   {
 766     mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
 767
 768     FlushVertexAttributeLocations();
 769
 770     LOG_GL("DrawElements %x %d %d %p\n", mode, count, type, indices);
 771     CHECK_GL( mGlAbstraction, mGlAbstraction.DrawElements(mode, count, type, indices) );
 772   }
 773
 774   /**
 775    * Wrapper for OpenGL ES 3.0 glDrawElementsInstanced()
 776    */
 777   void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instanceCount)
 778   {
 779     mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
 780
 781     FlushVertexAttributeLocations();
 782
 783     LOG_GL("DrawElementsInstanced %x %d %d %p %d\n", mode, count, type, indices, instanceCount);
 784     CHECK_GL( mGlAbstraction, mGlAbstraction.DrawElementsInstanced(mode, count, type, indices, instanceCount) );
 785   }
 786
 787   /**
 788    * Wrapper for OpenGL ES 3.0 glDrawRangeElements()
 789    */
 790   void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices)
 791   {
 792     mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
 793     FlushVertexAttributeLocations();
 794
 795     LOG_GL("DrawRangeElements %x %u %u %d %d %p\n", mode, start, end, count, type, indices);
 796     CHECK_GL( mGlAbstraction, mGlAbstraction.DrawRangeElements(mode, start, end, count, type, indices) );
 797   }
 798
 799   /**
 800    * Wrapper for OpenGL ES 3.0 glGenQuerieS()
 801    */
 802   void GenQueries(GLsizei n, GLuint* ids)
 803   {
 804     LOG_GL("GenQueries %d %p\n", n, ids);
 805     CHECK_GL( mGlAbstraction, mGlAbstraction.GenQueries(n, ids) );
 806   }
 807
 808   /**
 809    * Wrapper for OpenGL ES 3.0 glGenTransformFeedbacks()
 810    */
 811   void GenTransformFeedbacks(GLsizei n, GLuint* ids)
 812   {
 813     LOG_GL("GenTransformFeedbacks %d %p\n", n, ids);
 814     CHECK_GL( mGlAbstraction, mGlAbstraction.GenTransformFeedbacks(n, ids) );
 815   }
 816
 817   /**
 818    * @return the current buffer bound for a given target
 819    */
 820   GLuint GetCurrentBoundArrayBuffer(GLenum target)
 821   {
 822     GLuint result(0);
 823     switch(target)
 824     {
 825       case GL_ARRAY_BUFFER:
 826       {
 827         result = mBoundArrayBufferId;
 828         break;
 829       }
 830       case GL_ELEMENT_ARRAY_BUFFER:
 831       {
 832         result = mBoundElementArrayBufferId;
 833         break;
 834       }
 835       case GL_TRANSFORM_FEEDBACK_BUFFER:
 836       {
 837         result = mBoundTransformFeedbackBufferId;
 838         break;
 839       }
 840       default:
 841       {
 842         DALI_ASSERT_DEBUG(0 && "target buffer type not supported");
 843       }
 844     }
 845     return result;
 846   }
 847
 848   void EnableVertexAttributeArray( GLuint location )
 849   {
 850     SetVertexAttributeLocation( location, true);
 851   }
 852
 853   void DisableVertexAttributeArray( GLuint location )
 854   {
 855     SetVertexAttributeLocation( location, false);
 856   }
 857
 858   /**
 859    * Wrapper for OpenGL ES 3.0 glVertexAttribDivisor()
 860    */
 861   void VertexAttribDivisor ( GLuint index, GLuint divisor )
 862   {
 863     LOG_GL("VertexAttribDivisor(%d, %d)\n", index, divisor );
 864     CHECK_GL( mGlAbstraction, mGlAbstraction.VertexAttribDivisor( index, divisor ) );
 865   }
 866
 867   /**
 868    * Wrapper for OpenGL ES 2.0 glVertexAttribPointer()
 869    */
 870   void VertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr )
 871   {
 872     LOG_GL("VertexAttribPointer(%d, %d, %d, %d, %d, %x)\n", index, size, type, normalized, stride, ptr );
 873     CHECK_GL( mGlAbstraction, mGlAbstraction.VertexAttribPointer( index, size, type, normalized, stride, ptr ) );
 874   }
 875
 876   /**
 877    * Wrapper for OpenGL ES 3.0 glInvalidateFramebuffer()
 878    */
 879   void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 880   {
 881     LOG_GL("InvalidateFramebuffer\n");
 882     CHECK_GL( mGlAbstraction, mGlAbstraction.InvalidateFramebuffer(target, numAttachments, attachments) );
 883   }
 884
 885   /**
 886    * The wrapper for OpenGL ES 2.0 glEnable() has been replaced by SetBlend, SetCullFace, SetDepthTest,
 887    * SetDither, SetPolygonOffsetFill, SetSampleAlphaToCoverage, SetSampleCoverage, SetScissorTest & SetStencilTest.
 888    */
 889
 890   /**
 891    * This method replaces glEnable(GL_BLEND) and glDisable(GL_BLEND).
 892    * @param[in] enable True if GL_BLEND should be enabled.
 893    */
 894   void SetBlend(bool enable)
 895   {
 896     // Avoid unecessary calls to glEnable/glDisable
 897     if (enable != mBlendEnabled)
 898     {
 899       mBlendEnabled = enable;
 900
 901       if (enable)
 902       {
 903         LOG_GL("Enable GL_BLEND\n");
 904         CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_BLEND) );
 905       }
 906       else
 907       {
 908         LOG_GL("Disable GL_BLEND\n");
 909         CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_BLEND) );
 910       }
 911     }
 912   }
 913
 914   /**
 915    * This method replaces glEnable(GL_DEPTH_TEST) and glDisable(GL_DEPTH_TEST).
 916    * Note GL_DEPTH_TEST means enable the depth buffer for writing and or testing.
 917    * glDepthMask is used to enable / disable writing to depth buffer.
 918    * glDepthFunc us used to control if testing is enabled and how it is performed ( default GL_LESS)
 919    *
 920    * @param[in] enable True if GL_DEPTH_TEST should be enabled.
 921    */
 922   void EnableDepthBuffer( bool enable )
 923   {
 924     // Avoid unecessary calls to glEnable/glDisable
 925     if( enable != mDepthBufferEnabled )
 926     {
 927       mDepthBufferEnabled = enable;
 928
 929       if (enable)
 930       {
 931         LOG_GL("Enable GL_DEPTH_TEST\n");
 932         CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_DEPTH_TEST) );
 933       }
 934       else
 935       {
 936         LOG_GL("Disable GL_DEPTH_TEST\n");
 937         CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_DEPTH_TEST) );
 938       }
 939     }
 940   }
 941
 942   /**
 943    * This method replaces glEnable(GL_DITHER) and glDisable(GL_DITHER).
 944    * @param[in] enable True if GL_DITHER should be enabled.
 945    */
 946   void SetDither(bool enable)
 947   {
 948     // Avoid unecessary calls to glEnable/glDisable
 949     if (enable != mDitherEnabled)
 950     {
 951       mDitherEnabled = enable;
 952
 953       if (enable)
 954       {
 955         LOG_GL("Enable GL_DITHER\n");
 956         CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_DITHER) );
 957       }
 958       else
 959       {
 960         LOG_GL("Disable GL_DITHER\n");
 961         CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_DITHER) );
 962       }
 963     }
 964   }
 965
 966   /**
 967    * This method replaces glEnable(GL_POLYGON_OFFSET_FILL) and glDisable(GL_POLYGON_OFFSET_FILL).
 968    * @param[in] enable True if GL_POLYGON_OFFSET_FILL should be enabled.
 969    */
 970   void SetPolygonOffsetFill(bool enable)
 971   {
 972     // Avoid unecessary calls to glEnable/glDisable
 973     if (enable != mPolygonOffsetFillEnabled)
 974     {
 975       mPolygonOffsetFillEnabled = enable;
 976
 977       if (enable)
 978       {
 979         LOG_GL("Enable GL_POLYGON_OFFSET_FILL\n");
 980         CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_POLYGON_OFFSET_FILL) );
 981       }
 982       else
 983       {
 984         LOG_GL("Disable GL_POLYGON_OFFSET_FILL\n");
 985         CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_POLYGON_OFFSET_FILL) );
 986       }
 987     }
 988   }
 989
 990   /**
 991    * This method replaces glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE) and glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE).
 992    * @param[in] enable True if GL_SAMPLE_ALPHA_TO_COVERAGE should be enabled.
 993    */
 994   void SetSampleAlphaToCoverage(bool enable)
 995   {
 996     // Avoid unecessary calls to glEnable/glDisable
 997     if (enable != mSampleAlphaToCoverageEnabled)
 998     {
 999       mSampleAlphaToCoverageEnabled = enable;
1000
1001       if (enable)
1002       {
1003         LOG_GL("Enable GL_SAMPLE_ALPHA_TO_COVERAGE\n");
1004         CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SAMPLE_ALPHA_TO_COVERAGE) );
1005       }
1006       else
1007       {
1008         LOG_GL("Disable GL_SAMPLE_ALPHA_TO_COVERAGE\n");
1009         CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SAMPLE_ALPHA_TO_COVERAGE) );
1010       }
1011     }
1012   }
1013
1014   /**
1015    * This method replaces glEnable(GL_SAMPLE_COVERAGE) and glDisable(GL_SAMPLE_COVERAGE).
1016    * @param[in] enable True if GL_SAMPLE_COVERAGE should be enabled.
1017    */
1018   void SetSampleCoverage(bool enable)
1019   {
1020     // Avoid unecessary calls to glEnable/glDisable
1021     if (enable != mSampleCoverageEnabled)
1022     {
1023       mSampleCoverageEnabled = enable;
1024
1025       if (enable)
1026       {
1027         LOG_GL("Enable GL_SAMPLE_COVERAGE\n");
1028         CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SAMPLE_COVERAGE) );
1029       }
1030       else
1031       {
1032         LOG_GL("Disable GL_SAMPLE_COVERAGE\n");
1033         CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SAMPLE_COVERAGE) );
1034       }
1035     }
1036   }
1037
1038   /**
1039    * This method replaces glEnable(GL_SCISSOR_TEST) and glDisable(GL_SCISSOR_TEST).
1040    * @param[in] enable True if GL_SCISSOR_TEST should be enabled.
1041    */
1042   void SetScissorTest(bool enable)
1043   {
1044     // Avoid unecessary calls to glEnable/glDisable
1045     if (enable != mScissorTestEnabled)
1046     {
1047       mScissorTestEnabled = enable;
1048
1049       if (enable)
1050       {
1051         LOG_GL("Enable GL_SCISSOR_TEST\n");
1052         CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SCISSOR_TEST) );
1053       }
1054       else
1055       {
1056         LOG_GL("Disable GL_SCISSOR_TEST\n");
1057         CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SCISSOR_TEST) );
1058       }
1059     }
1060   }
1061
1062   /**
1063    * This method replaces glEnable(GL_STENCIL_TEST) and glDisable(GL_STENCIL_TEST).
1064    * Note GL_STENCIL_TEST means enable the stencil buffer for writing and or testing.
1065    * glStencilMask is used to control how bits are written to the stencil buffer.
1066    * glStencilFunc is used to control if testing is enabled and how it is performed ( default GL_ALWAYS )
1067    * @param[in] enable True if GL_STENCIL_TEST should be enabled.
1068    */
1069   void EnableStencilBuffer(bool enable)
1070   {
1071     // Avoid unecessary calls to glEnable/glDisable
1072     if( enable != mStencilBufferEnabled )
1073     {
1074       mStencilBufferEnabled = enable;
1075
1076       if (enable)
1077       {
1078         LOG_GL("Enable GL_STENCIL_TEST\n");
1079         CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_STENCIL_TEST) );
1080       }
1081       else
1082       {
1083         LOG_GL("Disable GL_STENCIL_TEST\n");
1084         CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_STENCIL_TEST) );
1085       }
1086     }
1087   }
1088
1089   /**
1090    * Wrapper for OpenGL ES 3.0 glEndQuery()
1091    */
1092   void EndQuery(GLenum target)
1093   {
1094     LOG_GL("EndQuery %d\n", target);
1095     CHECK_GL( mGlAbstraction, mGlAbstraction.EndQuery(target) );
1096   }
1097
1098   /**
1099    * Wrapper for OpenGL ES 3.0 glEndTransformFeedback()
1100    */
1101   void EndTransformFeedback()
1102   {
1103     LOG_GL("EndTransformFeedback\n");
1104     CHECK_GL( mGlAbstraction, mGlAbstraction.EndTransformFeedback() );
1105   }
1106
1107   /**
1108    * Wrapper for OpenGL ES 2.0 glFinish()
1109    */
1110   void Finish(void)
1111   {
1112     LOG_GL("Finish\n");
1113     CHECK_GL( mGlAbstraction, mGlAbstraction.Finish() );
1114   }
1115
1116   /**
1117    * Wrapper for OpenGL ES 2.0 glFlush()
1118    */
1119   void Flush(void)
1120   {
1121     LOG_GL("Flush\n");
1122     CHECK_GL( mGlAbstraction, mGlAbstraction.Flush() );
1123   }
1124
1125   /**
1126    * Wrapper for OpenGL ES 2.0 glFramebufferRenderbuffer()
1127    */
1128   void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1129   {
1130     LOG_GL("FramebufferRenderbuffer %x %x %x %d\n", target, attachment, renderbuffertarget, renderbuffer);
1131     CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) );
1132   }
1133
1134   /**
1135    * Wrapper for OpenGL ES 2.0 glFramebufferTexture2D()
1136    */
1137   void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1138   {
1139     LOG_GL("FramebufferTexture2D %x %x %x %d %d\n", target, attachment, textarget, texture, level);
1140     CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferTexture2D(target, attachment, textarget, texture, level) );
1141   }
1142
1143   /**
1144    * Wrapper for OpenGL ES 3.0 glFramebufferTextureLayer()
1145    */
1146   void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1147   {
1148     LOG_GL("FramebufferTextureLayer %x %x %d %d %d\n", target, attachment, texture, level, layer);
1149     CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferTextureLayer(target, attachment, texture, level, layer) );
1150   }
1151
1152   /**
1153    * Wrapper for OpenGL ES 2.0 glFrontFace()
1154    */
1155   void FrontFace(GLenum mode)
1156   {
1157     LOG_GL("FrontFace %x\n", mode);
1158     CHECK_GL( mGlAbstraction, mGlAbstraction.FrontFace(mode) );
1159   }
1160
1161   /**
1162    * Wrapper for OpenGL ES 2.0 glGenBuffers()
1163    */
1164   void GenBuffers(GLsizei n, GLuint* buffers)
1165   {
1166     LOG_GL("GenBuffers %d\n", n, buffers);
1167     CHECK_GL( mGlAbstraction, mGlAbstraction.GenBuffers(n, buffers) );
1168   }
1169
1170   /**
1171    * Wrapper for OpenGL ES 2.0 glGenerateMipmap()
1172    */
1173   void GenerateMipmap(GLenum target)
1174   {
1175     LOG_GL("GenerateMipmap %x\n", target);
1176     CHECK_GL( mGlAbstraction, mGlAbstraction.GenerateMipmap(target) );
1177   }
1178
1179   /**
1180    * Wrapper for OpenGL ES 2.0 glGenFramebuffers()
1181    */
1182   void GenFramebuffers(GLsizei n, GLuint* framebuffers)
1183   {
1184     LOG_GL("GenFramebuffers %d %p\n", n, framebuffers);
1185     CHECK_GL( mGlAbstraction, mGlAbstraction.GenFramebuffers(n, framebuffers) );
1186
1187     mFrameBufferStateCache.FrameBuffersCreated( n, framebuffers );
1188   }
1189
1190   /**
1191    * Wrapper for OpenGL ES 2.0 glGenRenderbuffers()
1192    */
1193   void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
1194   {
1195     LOG_GL("GenRenderbuffers %d %p\n", n, renderbuffers);
1196     CHECK_GL( mGlAbstraction, mGlAbstraction.GenRenderbuffers(n, renderbuffers) );
1197   }
1198
1199   /**
1200    * Wrapper for OpenGL ES 2.0 glGenTextures()
1201    */
1202   void GenTextures(GLsizei n, GLuint* textures)
1203   {
1204     LOG_GL("GenTextures %d %p\n", n, textures);
1205     CHECK_GL( mGlAbstraction, mGlAbstraction.GenTextures(n, textures) );
1206   }
1207
1208   /**
1209    * Wrapper for OpenGL ES 2.0 glGetBooleanv()
1210    */
1211   void GetBooleanv(GLenum pname, GLboolean* params)
1212   {
1213     LOG_GL("GetBooleanv %x\n", pname);
1214     CHECK_GL( mGlAbstraction, mGlAbstraction.GetBooleanv(pname, params) );
1215   }
1216
1217   /**
1218    * Wrapper for OpenGL ES 2.0 glGetBufferParameteriv()
1219    */
1220   void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
1221   {
1222     LOG_GL("GetBufferParameteriv %x %x %p\n", target, pname, params);
1223     CHECK_GL( mGlAbstraction, mGlAbstraction.GetBufferParameteriv(target, pname, params) );
1224   }
1225
1226   /**
1227    * Wrapper for OpenGL ES 3.0 glGetBufferPointer()
1228    */
1229   void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
1230   {
1231     LOG_GL("GetBufferPointerv %x %x %p\n", target, pname, params);
1232     CHECK_GL( mGlAbstraction, mGlAbstraction.GetBufferPointerv(target, pname, params) );
1233   }
1234
1235   /**
1236    * Wrapper for OpenGL ES 2.0 glGetError()
1237    */
1238   GLenum GetError(void)
1239   {
1240     // Not worth logging here
1241     return mGlAbstraction.GetError();
1242   }
1243
1244   /**
1245    * Wrapper for OpenGL ES 2.0 glGetFloatv()
1246    */
1247   void GetFloatv(GLenum pname, GLfloat* params)
1248   {
1249     LOG_GL("GetFloatv %x\n", pname);
1250     CHECK_GL( mGlAbstraction, mGlAbstraction.GetFloatv(pname, params) );
1251   }
1252
1253   /**
1254    * Wrapper for OpenGL ES 2.0 glGetFramebufferAttachmentParameteriv()
1255    */
1256   void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1257   {
1258     LOG_GL("GetFramebufferAttachmentParameteriv %x %x %x\n", target, attachment, pname);
1259     CHECK_GL( mGlAbstraction, mGlAbstraction.GetFramebufferAttachmentParameteriv(target, attachment, pname, params) );
1260   }
1261
1262   /**
1263    * Wrapper for OpenGL ES 2.0 glGetIntegerv()
1264    */
1265   void GetIntegerv(GLenum pname, GLint* params)
1266   {
1267     LOG_GL("GetIntegerv %x\n", pname);
1268     CHECK_GL( mGlAbstraction, mGlAbstraction.GetIntegerv(pname, params) );
1269   }
1270
1271   /**
1272    * Wrapper for OpenGL ES 3.0 glGetQueryiv()
1273    */
1274   void GetQueryiv(GLenum target, GLenum pname, GLint* params)
1275   {
1276     LOG_GL("GetQueryiv %x %x\n", target, pname);
1277     CHECK_GL( mGlAbstraction, mGlAbstraction.GetQueryiv(target, pname, params) );
1278   }
1279
1280   /**
1281    * Wrapper for OpenGL ES 3.0 glGetQueryObjectuiv()
1282    */
1283   void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
1284   {
1285     LOG_GL("GetQueryObjectuiv %u %x %p\n", id, pname, params);
1286     CHECK_GL( mGlAbstraction, mGlAbstraction.GetQueryObjectuiv(id, pname, params) );
1287   }
1288
1289   /**
1290    * Wrapper for OpenGL ES 2.0 glGetRenderbufferParameteriv()
1291    */
1292   void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1293   {
1294     LOG_GL("GetRenderbufferParameteriv %x %x\n", target, pname);
1295     CHECK_GL( mGlAbstraction, mGlAbstraction.GetRenderbufferParameteriv(target, pname, params) );
1296   }
1297
1298   /**
1299    * Wrapper for OpenGL ES 2.0 glGetString()
1300    */
1301   const GLubyte* GetString(GLenum name)
1302   {
1303     LOG_GL("GetString %x\n", name);
1304     const GLubyte* str = CHECK_GL( mGlAbstraction, mGlAbstraction.GetString(name) );
1305     return str;
1306   }
1307
1308   /**
1309    * Wrapper for OpenGL ES 2.0 glGetTexParameterfv()
1310    */
1311   void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
1312   {
1313     LOG_GL("GetTexParameterfv %x %x\n", target, pname);
1314     CHECK_GL( mGlAbstraction, mGlAbstraction.GetTexParameterfv(target, pname, params) );
1315   }
1316
1317   /**
1318    * Wrapper for OpenGL ES 2.0 glGetTexParameteriv()
1319    */
1320   void GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
1321   {
1322     LOG_GL("GetTexParameteriv %x %x\n", target, pname);
1323     CHECK_GL( mGlAbstraction, mGlAbstraction.GetTexParameteriv(target, pname, params) );
1324   }
1325
1326   /**
1327    * Wrapper for OpenGL ES 2.0 glHint()
1328    */
1329   void Hint(GLenum target, GLenum mode)
1330   {
1331     LOG_GL("Hint %x %x\n", target, mode);
1332     CHECK_GL( mGlAbstraction, mGlAbstraction.Hint(target, mode) );
1333   }
1334
1335   /**
1336    * Wrapper for OpenGL ES 2.0 glIsBuffer()
1337    */
1338   GLboolean IsBuffer(GLuint buffer)
1339   {
1340     LOG_GL("IsBuffer %d\n", buffer);
1341     GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsBuffer(buffer) );
1342     return val;
1343   }
1344
1345   /**
1346    * Wrapper for OpenGL ES 2.0 glIsEnabled()
1347    */
1348   GLboolean IsEnabled(GLenum cap)
1349   {
1350     LOG_GL("IsEnabled %x\n", cap);
1351     GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsEnabled(cap) );
1352     return val;
1353   }
1354
1355   /**
1356    * Wrapper for OpenGL ES 2.0 glIsFramebuffer()
1357    */
1358   GLboolean IsFramebuffer(GLuint framebuffer)
1359   {
1360     LOG_GL("IsFramebuffer %d\n", framebuffer);
1361     GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsFramebuffer(framebuffer) );
1362     return val;
1363   }
1364
1365   /**
1366    * Wrapper for OpenGL ES 3.0 glIsQuery()
1367    */
1368   GLboolean IsQuery(GLuint id)
1369   {
1370     LOG_GL("IsQuery %u\n", id);
1371     GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsQuery(id) );
1372     return val;
1373   }
1374
1375   /**
1376    * Wrapper for OpenGL ES 2.0 glIsRenderbuffer()
1377    */
1378   GLboolean IsRenderbuffer(GLuint renderbuffer)
1379   {
1380     LOG_GL("IsRenderbuffer %d\n", renderbuffer);
1381     GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsRenderbuffer(renderbuffer) );
1382     return val;
1383   }
1384
1385   /**
1386    * Wrapper for OpenGL ES 2.0 glIsTexture()
1387    */
1388   GLboolean IsTexture(GLuint texture)
1389   {
1390     LOG_GL("IsTexture %d\n", texture);
1391     GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsTexture(texture) );
1392     return val;
1393   }
1394
1395   /**
1396    * Wrapper for OpenGL ES 3.0 glIsTransformFeedback()
1397    */
1398   GLboolean IsTransformFeedback(GLuint id)
1399   {
1400     LOG_GL("IsTransformFeedback %u\n", id);
1401     GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsTransformFeedback(id) );
1402     return val;
1403   }
1404
1405   /**
1406    * Wrapper for OpenGL ES 2.0 glLineWidth()
1407    */
1408   void LineWidth(GLfloat width)
1409   {
1410     LOG_GL("LineWidth %f\n", width);
1411     CHECK_GL( mGlAbstraction, mGlAbstraction.LineWidth(width) );
1412   }
1413
1414   /**
1415    * Wrapper for OpenGL ES 3.0 glPauseTransformFeedback()
1416    */
1417   void PauseTransformFeedback()
1418   {
1419     LOG_GL("PauseTransformFeedback\n");
1420     CHECK_GL( mGlAbstraction, mGlAbstraction.PauseTransformFeedback() );
1421   }
1422
1423   /**
1424    * Wrapper for OpenGL ES 2.0 glPixelStorei()
1425    */
1426   void PixelStorei(GLenum pname, GLint param)
1427   {
1428     LOG_GL("PixelStorei %x %d\n", pname, param);
1429     CHECK_GL( mGlAbstraction, mGlAbstraction.PixelStorei(pname, param) );
1430   }
1431
1432   /**
1433    * Wrapper for OpenGL ES 2.0 glPolygonOffset()
1434    */
1435   void PolygonOffset(GLfloat factor, GLfloat units)
1436   {
1437     LOG_GL("PolygonOffset %f %f\n", factor, units);
1438     CHECK_GL( mGlAbstraction, mGlAbstraction.PolygonOffset(factor, units) );
1439   }
1440
1441   /**
1442    * Wrapper for OpenGL ES 2.0 glReadPixels()
1443    */
1444   void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
1445   {
1446     LOG_GL("ReadPixels %d %d %d %d %x %x\n", x, y, width, height, format, type);
1447     CHECK_GL( mGlAbstraction, mGlAbstraction.ReadPixels(x, y, width, height, format, type, pixels) );
1448   }
1449
1450   /**
1451    * Wrapper for OpenGL ES 2.0 glRenderbufferStorage()
1452    */
1453   void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1454   {
1455     LOG_GL("RenderbufferStorage %x %x %d %d\n", target, internalformat, width, height);
1456     CHECK_GL( mGlAbstraction, mGlAbstraction.RenderbufferStorage(target, internalformat, width, height) );
1457   }
1458
1459   /**
1460    * Wrapper for OpenGL ES 3.0 glRenderbufferStorageMultisample()
1461    */
1462   void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1463   {
1464     LOG_GL("RenderbufferStorageMultisample %x %u %x %d %d\n", target, samples, internalformat, width, height);
1465     CHECK_GL( mGlAbstraction, mGlAbstraction.RenderbufferStorageMultisample(target, samples, internalformat, width, height) );
1466   }
1467
1468   /**
1469    * Wrapper for OpenGL ES 3.0 glResumeTransformFeedback()
1470    */
1471   void ResumeTransformFeedback()
1472   {
1473     LOG_GL("ResumeTransformFeedback\n");
1474     CHECK_GL( mGlAbstraction, mGlAbstraction.ResumeTransformFeedback() );
1475   }
1476
1477   /**
1478    * Wrapper for OpenGL ES 2.0 glSampleCoverage()
1479    */
1480   void SampleCoverage(GLclampf value, GLboolean invert)
1481   {
1482     LOG_GL("SampleCoverage %f %s\n", value, invert ? "True" : "False");
1483     CHECK_GL( mGlAbstraction, mGlAbstraction.SampleCoverage(value, invert) );
1484   }
1485
1486   /**
1487    * Wrapper for OpenGL ES 2.0 glScissor()
1488    */
1489   void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
1490   {
1491     LOG_GL("Scissor %d %d %d %d\n", x, y, width, height);
1492     CHECK_GL( mGlAbstraction, mGlAbstraction.Scissor(x, y, width, height) );
1493   }
1494
1495   /**
1496    * Wrapper for OpenGL ES 2.0 glStencilFunc()
1497    */
1498   void StencilFunc(GLenum func, GLint ref, GLuint mask)
1499   {
1500
1501
1502     LOG_GL("StencilFunc %x %d %d\n", func, ref, mask);
1503     CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFunc(func, ref, mask) );
1504   }
1505
1506   /**
1507    * Wrapper for OpenGL ES 2.0 glStencilFuncSeparate()
1508    */
1509   void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1510   {
1511     LOG_GL("StencilFuncSeparate %x %x %d %d\n", face, func, ref, mask);
1512     CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFuncSeparate(face, func, ref, mask) );
1513   }
1514
1515   /**
1516    * Wrapper for OpenGL ES 2.0 glStencilMask()
1517    */
1518   void StencilMask(GLuint mask)
1519   {
1520     if( mask != mStencilMask )
1521     {
1522       mStencilMask = mask;
1523
1524       LOG_GL("StencilMask %d\n", mask);
1525       CHECK_GL( mGlAbstraction, mGlAbstraction.StencilMask(mask) );
1526     }
1527   }
1528
1529   /**
1530    * Wrapper for OpenGL ES 2.0 glStencilMaskSeparate()
1531    */
1532   void StencilMaskSeparate(GLenum face, GLuint mask)
1533   {
1534     LOG_GL("StencilMaskSeparate %x %d\n", face, mask);
1535     CHECK_GL( mGlAbstraction, mGlAbstraction.StencilMaskSeparate(face, mask) );
1536   }
1537
1538   /**
1539    * Wrapper for OpenGL ES 2.0 glStencilOp()
1540    */
1541   void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1542   {
1543     LOG_GL("StencilOp %x %x %x\n", fail, zfail, zpass);
1544     CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOp(fail, zfail, zpass) );
1545   }
1546
1547   /**
1548    * Wrapper for OpenGL ES 2.0 glStencilOpSeparate()
1549    */
1550   void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1551   {
1552     LOG_GL("StencilOpSeparate %x %x %x %x\n", face, fail, zfail, zpass);
1553     CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOpSeparate(face, fail, zfail, zpass) );
1554   }
1555
1556   /**
1557    * Wrapper for OpenGL ES 2.0 glTexImage2D()
1558    */
1559   void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
1560                   GLint border, GLenum format, GLenum type, const void* pixels)
1561   {
1562     LOG_GL("TexImage2D %x %d %d %dx%d %d %x %x %p\n", target, level, internalformat, width, height, border, format, type, pixels);
1563     CHECK_GL( mGlAbstraction, mGlAbstraction.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels) );
1564   }
1565
1566   /**
1567    * Wrapper for OpenGL ES 3.0 glTexImage3D()
1568    */
1569   void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth,
1570                   GLint border, GLenum format, GLenum type, const void* pixels)
1571   {
1572     LOG_GL("TexImage3D %x %d %d %dx%dx%d %d %x %x %p\n", target, level, internalformat, width, height, depth, border, format, type, pixels);
1573     CHECK_GL( mGlAbstraction, mGlAbstraction.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels) );
1574   }
1575
1576   /**
1577    * Wrapper for OpenGL ES 2.0 glTexParameterf()
1578    */
1579   void TexParameterf(GLenum target, GLenum pname, GLfloat param)
1580   {
1581     LOG_GL("TexParameterf %x %x %f\n", target, pname, param);
1582     CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameterf(target, pname, param) );
1583   }
1584
1585   /**
1586    * Wrapper for OpenGL ES 2.0 glTexParameterfv()
1587    */
1588   void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
1589   {
1590     LOG_GL("TexParameterfv %x %x\n", target, pname);
1591     CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameterfv(target, pname, params) );
1592   }
1593
1594   /**
1595    * Wrapper for OpenGL ES 2.0 glTexParameteri()
1596    */
1597   void TexParameteri(GLenum target, GLenum pname, GLint param)
1598   {
1599     LOG_GL("TexParameteri %x %x %d\n", target, pname, param);
1600     CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameteri(target, pname, param) );
1601   }
1602
1603   /**
1604    * Wrapper for OpenGL ES 2.0 glTexParameteriv()
1605    */
1606   void TexParameteriv(GLenum target, GLenum pname, const GLint* params)
1607   {
1608     LOG_GL("TexParameteriv %x %x\n", target, pname);
1609     CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameteriv(target, pname, params) );
1610   }
1611
1612   /**
1613    * Wrapper for OpenGL ES 2.0 glTexSubImage2D()
1614    */
1615   void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
1616                      GLenum format, GLenum type, const void* pixels)
1617   {
1618     LOG_GL("TexSubImage2D %x %d %d %d %d %d %x %x %p\n", target, level, xoffset, yoffset, width, height, format, type, pixels);
1619     CHECK_GL( mGlAbstraction, mGlAbstraction.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) );
1620   }
1621
1622   /**
1623    * Wrapper for OpenGL ES 3.0 glTexSubImage3D()
1624    */
1625   void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
1626                      GLsizei width, GLsizei height, GLsizei depth,
1627                      GLenum format, GLenum type, const void* pixels)
1628   {
1629     LOG_GL("TexSubImage3D %x %d %d %d %d %d %d %d %x %x %p\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
1630     CHECK_GL( mGlAbstraction, mGlAbstraction.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) );
1631   }
1632
1633   /**
1634    * Wrapper for OpenGL ES 3.0 glUnmapBubffer()
1635    */
1636   GLboolean UnmapBuffer(GLenum target)
1637   {
1638     LOG_GL("UnmapBuffer %x \n", target);
1639     GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.UnmapBuffer(target) );
1640     return val;
1641   }
1642   /**
1643    * Wrapper for OpenGL ES 2.0 glViewport()
1644    */
1645   void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
1646   {
1647     // check if its same as already set
1648     Rect<int> newViewport( x, y, width, height );
1649     if( mViewPort != newViewport )
1650     {
1651       // set new one
1652       LOG_GL("Viewport %d %d %d %d\n", x, y, width, height);
1653       CHECK_GL( mGlAbstraction, mGlAbstraction.Viewport(x, y, width, height) );
1654       mViewPort = newViewport; // remember new one
1655     }
1656   }
1657
1658   /**
1659    * Get the implementation defined MAX_TEXTURE_SIZE. This values is cached when the context is created
1660    * @return The implementation defined MAX_TEXTURE_SIZE
1661    */
1662   GLint CachedMaxTextureSize() const
1663   {
1664     return mMaxTextureSize;
1665   }
1666
1667   /**
1668    * Get the current viewport.
1669    * @return Viewport rectangle.
1670    */
1671   const Rect< int >& GetViewport();
1672
1673 private: // Implementation
1674
1675   /**
1676    * @return true if next draw operation will write to depth buffer
1677    */
1678   bool DepthBufferWriteEnabled() const
1679   {
1680     return mDepthBufferEnabled && mDepthMaskEnabled;
1681   }
1682
1683   /**
1684    * @return true if next draw operation will write to stencil buffer
1685    */
1686   bool StencilBufferWriteEnabled() const
1687   {
1688     return mStencilBufferEnabled && ( mStencilMask > 0 );
1689   }
1690
1691   /**
1692    * Flushes vertex attribute location changes to the driver
1693    */
1694   void FlushVertexAttributeLocations();
1695
1696   /**
1697    * Either enables or disables a vertex attribute location in the cache
1698    * The cahnges won't take affect until FlushVertexAttributeLocations is called
1699    * @param location attribute location
1700    * @param state attribute state
1701    */
1702   void SetVertexAttributeLocation(unsigned int location, bool state);
1703
1704   /**
1705    * Sets the initial GL state.
1706    */
1707   void InitializeGlState();
1708
1709 private: // Data
1710
1711   Integration::GlAbstraction& mGlAbstraction;
1712
1713   bool mGlContextCreated; ///< True if the OpenGL context has been created
1714
1715   // glEnable/glDisable states
1716   bool mColorMask;
1717   GLuint mStencilMask;
1718   bool mBlendEnabled;
1719   bool mDepthBufferEnabled;
1720   bool mDepthMaskEnabled;
1721   bool mDitherEnabled;
1722   bool mPolygonOffsetFillEnabled;
1723   bool mSampleAlphaToCoverageEnabled;
1724   bool mSampleCoverageEnabled;
1725   bool mScissorTestEnabled;
1726   bool mStencilBufferEnabled;
1727   bool mClearColorSet;
1728   bool mUsingDefaultBlendColor;
1729
1730   // glBindBuffer() state
1731   GLuint mBoundArrayBufferId;        ///< The ID passed to glBindBuffer(GL_ARRAY_BUFFER)
1732   GLuint mBoundElementArrayBufferId; ///< The ID passed to glBindBuffer(GL_ELEMENT_ARRAY_BUFFER)
1733   GLuint mBoundTransformFeedbackBufferId; ///< The ID passed to glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER)
1734
1735   // glBindTexture() state
1736   TextureUnit mActiveTextureUnit;
1737   GLuint mBound2dTextureId[ MAX_TEXTURE_UNITS ];  ///< The ID passed to glBindTexture(GL_TEXTURE_2D)
1738
1739   // glBlendColor() state
1740   Vector4 mBlendColor; ///< Blend color
1741
1742   // glBlendFuncSeparate() state
1743   GLenum mBlendFuncSeparateSrcRGB;   ///< The srcRGB parameter passed to glBlendFuncSeparate()
1744   GLenum mBlendFuncSeparateDstRGB;   ///< The dstRGB parameter passed to glBlendFuncSeparate()
1745   GLenum mBlendFuncSeparateSrcAlpha; ///< The srcAlpha parameter passed to glBlendFuncSeparate()
1746   GLenum mBlendFuncSeparateDstAlpha; ///< The dstAlpha parameter passed to glBlendFuncSeparate()
1747
1748   // glBlendEquationSeparate state
1749   GLenum mBlendEquationSeparateModeRGB;    ///< Controls RGB blend mode
1750   GLenum mBlendEquationSeparateModeAlpha;  ///< Controls Alpha blend mode
1751
1752   GLenum mDepthFunction;  ///The depth function
1753
1754   GLint mMaxTextureSize;      ///< return value from GetIntegerv(GL_MAX_TEXTURE_SIZE)
1755   Vector4 mClearColor;        ///< clear color
1756
1757   // Face culling mode
1758   Dali::FaceCullingMode::Type mCullFaceMode;
1759
1760   // cached viewport size
1761   Rect< int > mViewPort;
1762
1763   // Vertex Attribute Buffer enable caching
1764   bool mVertexAttributeCachedState[ MAX_ATTRIBUTE_CACHE_SIZE ];    ///< Value cache for Enable Vertex Attribute
1765   bool mVertexAttributeCurrentState[ MAX_ATTRIBUTE_CACHE_SIZE ];   ///< Current state on the driver for Enable Vertex Attribute
1766
1767   FrameBufferStateCache mFrameBufferStateCache;   ///< frame buffer state cache
1768 };
1769
1770 } // namespace Internal
1771
1772 } // namespace Dali
1773
1774 #endif // __DALI_INTERNAL_CONTEXT_H__