1 #ifndef __DALI_INTERNAL_CONTEXT_H__
2 #define __DALI_INTERNAL_CONTEXT_H__
5 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
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/integration-api/debug.h>
27 #include <dali/integration-api/gl-abstraction.h>
28 #include <dali/integration-api/gl-defines.h>
29 #include <dali/devel-api/rendering/material.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>
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.
50 * FrameBuffer Clear mode
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
59 * Size of the VertexAttributeArray enables
60 * GLES specification states that there's minimum of 8
62 static const unsigned int MAX_ATTRIBUTE_CACHE_SIZE = 8;
64 static const unsigned int MAX_TEXTURE_UNITS = 8; // for GLES 2.0 8 is guaranteed, which is more than DALi uses anyways
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.
73 Context( Integration::GlAbstraction& glAbstraction );
81 * Called when the GL context has been created.
83 void GlContextCreated();
86 * Called when the GL context has been destroyed.
88 void GlContextDestroyed();
91 * Query whether the OpenGL context has been created.
92 * @return True if the OpenGL context has been created.
94 bool IsGlContextCreated() { return mGlContextCreated; }
97 * @return the GLAbstraction
99 Integration::GlAbstraction& GetAbstraction() { return mGlAbstraction; }
104 * Debug helper which prints the currently cached GL state.
106 void PrintCurrentState();
111 * Helper to convert GL error code to string
112 * @param errorCode to convert
115 const char* ErrorToString( GLenum errorCode );
118 * Helper to print GL string to debug log
120 void PrintGlString(const char* stringName, GLenum stringId)
122 DALI_LOG_INFO(Debug::Filter::gRender, Debug::General, "GL %s = %s\n", stringName, (const char *)GetString( stringId ) );
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 ****************************************************************************************/
133 * Wrapper for OpenGL ES 2.0 glActiveTexture()
135 void ActiveTexture( TextureUnit textureUnit )
137 if ( textureUnit != mActiveTextureUnit )
139 mActiveTextureUnit = textureUnit;
140 LOG_GL("ActiveTexture %x\n", textureUnit);
141 CHECK_GL( mGlAbstraction, mGlAbstraction.ActiveTexture(TextureUnitAsGLenum(textureUnit)) );
146 * Wrapper for OpenGL ES 3.0 glBeginQuery()
148 void BeginQuery(GLenum target, GLuint id)
150 LOG_GL("BeginQuery %d %d\n", target, id);
151 CHECK_GL( mGlAbstraction, mGlAbstraction.BeginQuery(target, id) );
155 * Wrapper for OpenGL ES 3.0 glBeginTransformFeedback()
157 void BeginTransformFeedback(GLenum primitiveMode)
159 LOG_GL("BeginTransformFeedback %x\n", primitiveMode);
160 CHECK_GL( mGlAbstraction, mGlAbstraction.BeginTransformFeedback(primitiveMode) );
164 * The wrapper for OpenGL ES 2.0 glBindBuffer() has been replaced by BindArrayBuffer & BindElementArrayBuffer & BindTransformFeedbackBuffer.
168 * Wrapper for OpenGL ES 2.0 glBindBuffer(GL_ARRAY_BUFFER, ...)
170 void BindArrayBuffer(GLuint buffer)
172 // Avoid unecessary calls to BindBuffer
173 if (mBoundArrayBufferId != buffer)
175 mBoundArrayBufferId = buffer;
177 LOG_GL("BindBuffer GL_ARRAY_BUFFER %d\n", buffer);
178 CHECK_GL( mGlAbstraction, mGlAbstraction.BindBuffer(GL_ARRAY_BUFFER, buffer) );
183 * Wrapper for OpenGL ES 2.0 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ...)
185 void BindElementArrayBuffer(GLuint buffer)
187 // Avoid unecessary calls to BindBuffer
188 if (mBoundElementArrayBufferId!= buffer)
190 mBoundElementArrayBufferId = buffer;
192 LOG_GL("BindBuffer GL_ELEMENT_ARRAY_BUFFER %d\n", buffer);
193 CHECK_GL( mGlAbstraction, mGlAbstraction.BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer) );
198 * Wrapper for OpenGL ES 3.0 glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, ...)
200 void BindTransformFeedbackBuffer(GLuint buffer)
202 // Avoid unecessary calls to BindBuffer
203 if (mBoundTransformFeedbackBufferId != buffer)
205 mBoundTransformFeedbackBufferId = buffer;
207 LOG_GL("BindBuffer GL_TRANSFORM_FEEDBACK_BUFFER %d\n", buffer);
208 CHECK_GL( mGlAbstraction, mGlAbstraction.BindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER , buffer) );
213 * Wrapper for OpenGL ES 3.0 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, ...)
215 void BindTransformFeedbackBufferBase(GLuint index, GLuint buffer)
217 // Avoid unecessary calls to BindBufferBase
218 if (mBoundTransformFeedbackBufferId != buffer)
220 mBoundTransformFeedbackBufferId = buffer;
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) );
228 * Wrapper for OpenGL ES 2.0 glBindFramebuffer()
230 void BindFramebuffer(GLenum target, GLuint framebuffer)
232 mFrameBufferStateCache.SetCurrentFrameBuffer( framebuffer );
234 LOG_GL("BindFramebuffer %d %d\n", target, framebuffer);
235 CHECK_GL( mGlAbstraction, mGlAbstraction.BindFramebuffer(target, framebuffer) );
239 * Wrapper for OpenGL ES 2.0 glBindRenderbuffer()
241 void BindRenderbuffer(GLenum target, GLuint renderbuffer)
243 LOG_GL("BindRenderbuffer %d %d\n", target, renderbuffer);
244 CHECK_GL( mGlAbstraction, mGlAbstraction.BindRenderbuffer(target, renderbuffer) );
248 * Wrapper for OpenGL ES 3.0 glBindTransformFeedback()
250 void BindTransformFeedback(GLenum target, GLuint id)
252 LOG_GL("BindTransformFeedback %d %d\n", target, id);
253 CHECK_GL( mGlAbstraction, mGlAbstraction.BindTransformFeedback(target, id) );
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
265 void BindTextureForUnit( TextureUnit textureunit, GLuint texture )
267 if( mBound2dTextureId[ textureunit ] != texture )
269 ActiveTexture( textureunit );
270 Bind2dTexture( texture );
275 * Wrapper for OpenGL ES 2.0 glBindTexture(GL_TEXTURE_2D)
277 void Bind2dTexture( GLuint texture )
279 if (mBound2dTextureId[ mActiveTextureUnit ] != texture)
281 mBound2dTextureId[ mActiveTextureUnit ] = texture;
283 LOG_GL("BindTexture GL_TEXTURE_2D %d\n", texture);
284 CHECK_GL( mGlAbstraction, mGlAbstraction.BindTexture(GL_TEXTURE_2D, texture) );
289 * Wrapper for OpenGL ES 2.0 glBlendColor()
291 void SetDefaultBlendColor()
293 if( ! mUsingDefaultBlendColor )
295 SetCustomBlendColor( Color::TRANSPARENT );
296 mUsingDefaultBlendColor = true;
301 * Wrapper for OpenGL ES 2.0 glBlendColor()
303 void SetCustomBlendColor( const Vector4& color )
305 if( mUsingDefaultBlendColor || mBlendColor != color )
307 LOG_GL( "BlendColor %f %f %f %f\n", color.r, color.g, color.b, color.a );
308 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendColor( color.r, color.g, color.b, color.a ) );
309 mUsingDefaultBlendColor = false;
315 * Wrapper for OpenGL ES 2.0 glBlendEquation()
317 void BlendEquation(GLenum mode)
319 // use BlendEquationSeparate to set the rgb and alpha modes the same
320 BlendEquationSeparate( mode, mode );
324 * Wrapper for OpenGL ES 2.0 glBlendEquationSeparate()
326 void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
328 if( ( modeRGB != mBlendEquationSeparateModeRGB ) ||
329 ( modeAlpha != mBlendEquationSeparateModeAlpha ) )
331 mBlendEquationSeparateModeRGB = modeRGB;
332 mBlendEquationSeparateModeAlpha = modeAlpha;
333 LOG_GL("BlendEquationSeparate %d %d\n", modeRGB, modeAlpha);
334 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendEquationSeparate(modeRGB, modeAlpha) );
339 * Wrapper for OpenGL ES 2.0 glBlendFunc()
341 void BlendFunc(GLenum sfactor, GLenum dfactor)
343 // reuse the BlendFuncSeparate as thats what the DDK does anyways
344 BlendFuncSeparate( sfactor, dfactor, sfactor, dfactor );
348 * Wrapper for OpenGL ES 2.0 glBlendFuncSeparate()
350 void BlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
352 if( ( mBlendFuncSeparateSrcRGB != srcRGB )||( mBlendFuncSeparateDstRGB != dstRGB )||
353 ( mBlendFuncSeparateSrcAlpha != srcAlpha )||( mBlendFuncSeparateDstAlpha != dstAlpha ) )
355 mBlendFuncSeparateSrcRGB = srcRGB;
356 mBlendFuncSeparateDstRGB = dstRGB;
357 mBlendFuncSeparateSrcAlpha = srcAlpha;
358 mBlendFuncSeparateDstAlpha = dstAlpha;
360 LOG_GL( "BlendFuncSeparate %d %d %d %d\n", srcRGB, dstRGB, srcAlpha, dstAlpha );
361 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendFuncSeparate( srcRGB, dstRGB, srcAlpha, dstAlpha ) );
366 * Wrapper for OpenGL ES 3.0 glBlitFramebuffer()
368 void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
370 LOG_GL( "BlitFramebuffer %d %d %d %d %d %d %d %d %x %d\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
371 CHECK_GL( mGlAbstraction, mGlAbstraction.BlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ) );
375 * Wrapper for OpenGL ES 2.0 glBufferData()
377 void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
379 LOG_GL("BufferData %d %d %p %d\n", target, size, data, usage);
380 CHECK_GL( mGlAbstraction, mGlAbstraction.BufferData(target, size, data, usage) );
384 * Wrapper for OpenGL ES 2.0 glBufferSubData()
386 void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
388 LOG_GL("BufferSubData %d %d %d %p\n", target, offset, size, data);
389 CHECK_GL( mGlAbstraction, mGlAbstraction.BufferSubData(target, offset, size, data) );
393 * Wrapper for OpenGL ES 2.0 glCheckFramebufferStatus()
395 GLenum CheckFramebufferStatus(GLenum target)
397 LOG_GL("CheckFramebufferStatus %d\n", target);
398 GLenum value = CHECK_GL( mGlAbstraction, mGlAbstraction.CheckFramebufferStatus(target) );
403 * Wrapper for OpenGL ES 2.0 glClear()
405 void Clear(GLbitfield mask, ClearMode mode )
407 bool forceClear = (mode == FORCE_CLEAR );
408 mask = mFrameBufferStateCache.GetClearMask( mask, forceClear , mScissorTestEnabled );
412 LOG_GL("Clear %d\n", mask);
413 CHECK_GL( mGlAbstraction, mGlAbstraction.Clear( mask ) );
418 * Wrapper for OpenGL ES 2.0 glClearColor()
420 void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
422 Vector4 newCol(red,green,blue,alpha);
424 if (!mClearColorSet || mClearColor !=newCol )
426 LOG_GL("ClearColor %f %f %f %f\n", red, green, blue, alpha);
427 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearColor(red, green, blue, alpha) );
429 mClearColorSet = true;
430 mClearColor = newCol;
435 * Wrapper for OpenGL ES 2.0 glClearDepthf()
437 void ClearDepthf(GLclampf depth)
439 LOG_GL("ClearDepthf %f\n", depth);
440 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearDepthf(depth) );
444 * Wrapper for OpenGL ES 2.0 glClearStencil()
446 void ClearStencil(GLint s)
448 LOG_GL("ClearStencil %d\n", s);
449 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearStencil(s) );
453 * Wrapper for OpenGL ES 2.0 glColorMask()
454 * @note This has been optimized to a single boolean value (masking individual channels is not required)
456 void ColorMask( bool flag )
458 // only change state if needed
459 if( flag != mColorMask )
462 LOG_GL("ColorMask %s %s %s %s\n", flag ? "True" : "False", flag ? "True" : "False", flag ? "True" : "False", flag ? "True" : "False");
463 CHECK_GL( mGlAbstraction, mGlAbstraction.ColorMask(flag, flag, flag, flag) );
468 * Wrapper for OpenGL ES 2.0 glCompressedTexImage2D()
470 void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
471 GLint border, GLsizei imageSize, const void* data)
473 LOG_GL("CompressedTexImage2D %d %d %x %d %d %d %d %p\n", target, level, internalformat, width, height, border, imageSize, data);
474 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data) );
478 * Wrapper for OpenGL ES 3.0 glCompressedTexImage3D()
480 void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
481 GLint border, GLsizei imageSize, const void* data)
483 LOG_GL("CompressedTexImage3D %d %d %x %d %d %d %d %d %p\n", target, level, internalformat, width, height, depth, border, imageSize, data);
484 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data) );
488 * Wrapper for OpenGL ES 2.0 glCompressedTexSubImage2D()
490 void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
491 GLenum format, GLsizei imageSize, const void* data)
493 LOG_GL("CompressedTexSubImage2D %x %d %d %d %d %d %x %d %p\n", target, level, xoffset, yoffset, width, height, format, imageSize, data);
494 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) );
498 * Wrapper for OpenGL ES 3.0 glCompressedTexSubImage3D()
500 void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
501 GLsizei width, GLsizei height, GLsizei depth,
502 GLenum format, GLsizei imageSize, const void* data)
504 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);
505 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) );
509 * Wrapper for OpenGL ES 2.0 glCopyTexImage2D()
511 void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
513 LOG_GL("CopyTexImage2D %x %d %x %d %d %d %d %d\n", target, level, internalformat, x, y, width, height, border);
514 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexImage2D(target, level, internalformat, x, y, width, height, border) );
518 * Wrapper for OpenGL ES 2.0 glCopyTexSubImage2D()
520 void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
522 LOG_GL("CopyTexSubImage2D %x %d %d %d %d %d %d %d\n", target, level, xoffset, yoffset, x, y, width, height);
523 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) );
527 * Wrapper for OpenGL ES 3.0 glCopyTexSubImage3D()
529 void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
531 LOG_GL("CopyTexSubImage3D %x %d %d %d %d %d %d %d %d\n", target, level, xoffset, yoffset, zoffset, x, y, width, height);
532 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) );
536 * Wrapper for OpenGL ES 2.0 glCullFace()
537 * enables GL_CULL_FACE if in any of the face culling modes
538 * otherwise disables GL_CULL_FACE
540 void CullFace( Dali::Material::FaceCullingMode mode )
542 // Avoid unnecessary calls to gl
543 if(mCullFaceMode != mode)
545 mCullFaceMode = mode;
548 case Dali::Material::NONE:
550 LOG_GL("Disable GL_CULL_FACE\n");
551 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_CULL_FACE) );
555 case Dali::Material::CULL_FRONT:
557 LOG_GL("Enable GL_CULL_FACE\n");
558 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
559 LOG_GL("Enable GL_FRONT\n");
560 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_FRONT) );
564 case Dali::Material::CULL_BACK:
566 LOG_GL("Enable GL_CULL_FACE\n");
567 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
568 LOG_GL("Enable GL_BACK\n");
569 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_BACK) );
573 case Dali::Material::CULL_BACK_AND_FRONT:
575 LOG_GL("Enable GL_CULL_FACE\n");
576 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
577 LOG_GL("Enable GL_FRONT_AND_BACK\n");
578 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_FRONT_AND_BACK) );
589 * Wrapper for OpenGL ES 2.0 glDeleteBuffers()
591 void DeleteBuffers(GLsizei n, const GLuint* buffers)
593 // @todo: this is to prevent mesh destructor from doing GL calls when DALi core is being deleted
594 // can be taken out once render manages either knows about meshes or gpubuffers and can tell them directly that context is lost
595 if( this->IsGlContextCreated() )
597 LOG_GL("DeleteBuffers %d %p\n", n, buffers);
598 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteBuffers(n, buffers) );
600 // reset the cached buffer id's
601 // fixes problem where some drivers will a generate a buffer with the
602 // same id, as the last deleted buffer id.
603 mBoundArrayBufferId = 0;
604 mBoundElementArrayBufferId = 0;
605 mBoundTransformFeedbackBufferId = 0;
609 * Wrapper for OpenGL ES 2.0 glDeleteFramebuffers()
611 void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
613 mFrameBufferStateCache.FrameBuffersDeleted( n, framebuffers );
615 LOG_GL("DeleteFramebuffers %d %p\n", n, framebuffers);
616 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteFramebuffers(n, framebuffers) );
620 * Wrapper for OpenGL ES 3.0 glDeleteQueries()
622 void DeleteQueries(GLsizei n, GLuint* ids)
624 LOG_GL("DeleteQueries %d %p\n", n, ids);
625 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteQueries(n, ids) );
629 * Wrapper for OpenGL ES 2.0 glDeleteRenderbuffers()
631 void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
633 LOG_GL("DeleteRenderbuffers %d %p\n", n, renderbuffers);
634 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteRenderbuffers(n, renderbuffers) );
638 * Wrapper for OpenGL ES 2.0 glDeleteTextures()
640 void DeleteTextures(GLsizei n, const GLuint* textures)
642 LOG_GL("DeleteTextures %d %p\n", n, textures);
643 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTextures(n, textures) );
645 // reset the cached texture id's incase the driver re-uses them
646 // when creating new textures
647 for( unsigned int i=0; i < MAX_TEXTURE_UNITS; ++i )
649 mBound2dTextureId[ i ] = 0;
654 * Wrapper for OpenGL ES 3.0 glDeleteTransformFeedbacks()
656 void DeleteTransformFeedbacks(GLsizei n, GLuint* ids)
658 LOG_GL("DeleteTransformFeedbacks %d %p\n", n, ids);
659 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTransformFeedbacks(n, ids) );
663 * Wrapper for OpenGL ES 2.0 glDepthFunc()
665 void DepthFunc(GLenum func)
667 LOG_GL("DepthFunc %x\n", func);
668 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthFunc(func) );
672 * Wrapper for OpenGL ES 2.0 glDepthMask()
674 void DepthMask(GLboolean flag)
676 // only change state if needed
677 if( flag != mDepthMaskEnabled )
679 mDepthMaskEnabled = flag;
680 LOG_GL("DepthMask %s\n", flag ? "True" : "False");
681 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthMask( mDepthMaskEnabled ) );
686 * Wrapper for OpenGL ES 2.0 glDepthRangef()
688 void DepthRangef(GLclampf zNear, GLclampf zFar)
690 LOG_GL("DepthRangef %f %f\n", zNear, zFar);
691 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthRangef(zNear, zFar) );
695 * The wrapper for OpenGL ES 2.0 glDisable() has been replaced by SetBlend, SetCullFace, SetDepthTest,
696 * SetDither, SetPolygonOffsetFill, SetSampleAlphaToCoverage, SetSampleCoverage, SetScissorTest & SetStencilTest.
700 * Wrapper for OpenGL ES 2.0 glDrawArrays()
702 void DrawArrays(GLenum mode, GLint first, GLsizei count)
704 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
705 FlushVertexAttributeLocations();
707 LOG_GL("DrawArrays %x %d %d\n", mode, first, count);
708 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawArrays(mode, first, count) );
712 * Wrapper for OpenGL ES 3.0 glDrawArraysInstanced()
714 void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
716 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
717 FlushVertexAttributeLocations();
719 LOG_GL("DrawArraysInstanced %x %d %d %d\n", mode, first, count, instanceCount);
720 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawArraysInstanced(mode, first, count,instanceCount) );
724 * Wrapper for OpenGL ES 3.0 glDrawBuffers()
726 void DrawBuffers(GLsizei n, const GLenum* bufs)
728 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
729 LOG_GL("DrawBuffers %d %p\n", n, bufs);
730 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawBuffers(n, bufs) );
734 * Wrapper for OpenGL ES 2.0 glDrawElements()
736 void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
738 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
740 FlushVertexAttributeLocations();
742 LOG_GL("DrawElements %x %d %d %p\n", mode, count, type, indices);
743 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawElements(mode, count, type, indices) );
747 * Wrapper for OpenGL ES 3.0 glDrawElementsInstanced()
749 void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instanceCount)
751 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
753 FlushVertexAttributeLocations();
755 LOG_GL("DrawElementsInstanced %x %d %d %p %d\n", mode, count, type, indices, instanceCount);
756 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawElementsInstanced(mode, count, type, indices, instanceCount) );
760 * Wrapper for OpenGL ES 3.0 glDrawRangeElements()
762 void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices)
764 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
765 FlushVertexAttributeLocations();
767 LOG_GL("DrawRangeElements %x %u %u %d %d %p\n", mode, start, end, count, type, indices);
768 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawRangeElements(mode, start, end, count, type, indices) );
772 * Wrapper for OpenGL ES 3.0 glGenQuerieS()
774 void GenQueries(GLsizei n, GLuint* ids)
776 LOG_GL("GenQueries %d %p\n", n, ids);
777 CHECK_GL( mGlAbstraction, mGlAbstraction.GenQueries(n, ids) );
781 * Wrapper for OpenGL ES 3.0 glGenTransformFeedbacks()
783 void GenTransformFeedbacks(GLsizei n, GLuint* ids)
785 LOG_GL("GenTransformFeedbacks %d %p\n", n, ids);
786 CHECK_GL( mGlAbstraction, mGlAbstraction.GenTransformFeedbacks(n, ids) );
790 * @return the current buffer bound for a given target
792 GLuint GetCurrentBoundArrayBuffer(GLenum target)
797 case GL_ARRAY_BUFFER:
799 result = mBoundArrayBufferId;
802 case GL_ELEMENT_ARRAY_BUFFER:
804 result = mBoundElementArrayBufferId;
807 case GL_TRANSFORM_FEEDBACK_BUFFER:
809 result = mBoundTransformFeedbackBufferId;
814 DALI_ASSERT_DEBUG(0 && "target buffer type not supported");
820 void EnableVertexAttributeArray( GLuint location )
822 SetVertexAttributeLocation( location, true);
825 void DisableVertexAttributeArray( GLuint location )
827 SetVertexAttributeLocation( location, false);
831 * Wrapper for OpenGL ES 3.0 glVertexAttribDivisor()
833 void VertexAttribDivisor ( GLuint index, GLuint divisor )
835 LOG_GL("VertexAttribDivisor(%d, %d)\n", index, divisor );
836 CHECK_GL( mGlAbstraction, mGlAbstraction.VertexAttribDivisor( index, divisor ) );
840 * Wrapper for OpenGL ES 2.0 glVertexAttribPointer()
842 void VertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr )
844 LOG_GL("VertexAttribPointer(%d, %d, %d, %d, %d, %x)\n", index, size, type, normalized, stride, ptr );
845 CHECK_GL( mGlAbstraction, mGlAbstraction.VertexAttribPointer( index, size, type, normalized, stride, ptr ) );
849 * Wrapper for OpenGL ES 3.0 glInvalidateFramebuffer()
851 void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
853 LOG_GL("InvalidateFramebuffer\n");
854 CHECK_GL( mGlAbstraction, mGlAbstraction.InvalidateFramebuffer(target, numAttachments, attachments) );
858 * The wrapper for OpenGL ES 2.0 glEnable() has been replaced by SetBlend, SetCullFace, SetDepthTest,
859 * SetDither, SetPolygonOffsetFill, SetSampleAlphaToCoverage, SetSampleCoverage, SetScissorTest & SetStencilTest.
863 * This method replaces glEnable(GL_BLEND) and glDisable(GL_BLEND).
864 * @param[in] enable True if GL_BLEND should be enabled.
866 void SetBlend(bool enable)
868 // Avoid unecessary calls to glEnable/glDisable
869 if (enable != mBlendEnabled)
871 mBlendEnabled = enable;
875 LOG_GL("Enable GL_BLEND\n");
876 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_BLEND) );
880 LOG_GL("Disable GL_BLEND\n");
881 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_BLEND) );
887 * This method replaces glEnable(GL_DEPTH_TEST) and glDisable(GL_DEPTH_TEST).
888 * Note GL_DEPTH_TEST means enable the depth buffer for writing and or testing.
889 * glDepthMask is used to enable / disable writing to depth buffer.
890 * glDepthFunc us used to control if testing is enabled and how it is performed ( default GL_LESS)
892 * @param[in] enable True if GL_DEPTH_TEST should be enabled.
894 void EnableDepthBuffer( bool enable )
896 // Avoid unecessary calls to glEnable/glDisable
897 if( enable != mDepthBufferEnabled )
899 mDepthBufferEnabled = enable;
903 LOG_GL("Enable GL_DEPTH_TEST\n");
904 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_DEPTH_TEST) );
908 LOG_GL("Disable GL_DEPTH_TEST\n");
909 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_DEPTH_TEST) );
915 * This method replaces glEnable(GL_DITHER) and glDisable(GL_DITHER).
916 * @param[in] enable True if GL_DITHER should be enabled.
918 void SetDither(bool enable)
920 // Avoid unecessary calls to glEnable/glDisable
921 if (enable != mDitherEnabled)
923 mDitherEnabled = enable;
927 LOG_GL("Enable GL_DITHER\n");
928 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_DITHER) );
932 LOG_GL("Disable GL_DITHER\n");
933 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_DITHER) );
939 * This method replaces glEnable(GL_POLYGON_OFFSET_FILL) and glDisable(GL_POLYGON_OFFSET_FILL).
940 * @param[in] enable True if GL_POLYGON_OFFSET_FILL should be enabled.
942 void SetPolygonOffsetFill(bool enable)
944 // Avoid unecessary calls to glEnable/glDisable
945 if (enable != mPolygonOffsetFillEnabled)
947 mPolygonOffsetFillEnabled = enable;
951 LOG_GL("Enable GL_POLYGON_OFFSET_FILL\n");
952 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_POLYGON_OFFSET_FILL) );
956 LOG_GL("Disable GL_POLYGON_OFFSET_FILL\n");
957 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_POLYGON_OFFSET_FILL) );
963 * This method replaces glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE) and glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE).
964 * @param[in] enable True if GL_SAMPLE_ALPHA_TO_COVERAGE should be enabled.
966 void SetSampleAlphaToCoverage(bool enable)
968 // Avoid unecessary calls to glEnable/glDisable
969 if (enable != mSampleAlphaToCoverageEnabled)
971 mSampleAlphaToCoverageEnabled = enable;
975 LOG_GL("Enable GL_SAMPLE_ALPHA_TO_COVERAGE\n");
976 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SAMPLE_ALPHA_TO_COVERAGE) );
980 LOG_GL("Disable GL_SAMPLE_ALPHA_TO_COVERAGE\n");
981 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SAMPLE_ALPHA_TO_COVERAGE) );
987 * This method replaces glEnable(GL_SAMPLE_COVERAGE) and glDisable(GL_SAMPLE_COVERAGE).
988 * @param[in] enable True if GL_SAMPLE_COVERAGE should be enabled.
990 void SetSampleCoverage(bool enable)
992 // Avoid unecessary calls to glEnable/glDisable
993 if (enable != mSampleCoverageEnabled)
995 mSampleCoverageEnabled = enable;
999 LOG_GL("Enable GL_SAMPLE_COVERAGE\n");
1000 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SAMPLE_COVERAGE) );
1004 LOG_GL("Disable GL_SAMPLE_COVERAGE\n");
1005 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SAMPLE_COVERAGE) );
1011 * This method replaces glEnable(GL_SCISSOR_TEST) and glDisable(GL_SCISSOR_TEST).
1012 * @param[in] enable True if GL_SCISSOR_TEST should be enabled.
1014 void SetScissorTest(bool enable)
1016 // Avoid unecessary calls to glEnable/glDisable
1017 if (enable != mScissorTestEnabled)
1019 mScissorTestEnabled = enable;
1023 LOG_GL("Enable GL_SCISSOR_TEST\n");
1024 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SCISSOR_TEST) );
1028 LOG_GL("Disable GL_SCISSOR_TEST\n");
1029 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SCISSOR_TEST) );
1035 * This method replaces glEnable(GL_STENCIL_TEST) and glDisable(GL_STENCIL_TEST).
1036 * Note GL_STENCIL_TEST means enable the stencil buffer for writing and or testing.
1037 * glStencilMask is used to control how bits are written to the stencil buffer.
1038 * glStencilFunc is used to control if testing is enabled and how it is performed ( default GL_ALWAYS )
1039 * @param[in] enable True if GL_STENCIL_TEST should be enabled.
1041 void EnableStencilBuffer(bool enable)
1043 // Avoid unecessary calls to glEnable/glDisable
1044 if( enable != mStencilBufferEnabled )
1046 mStencilBufferEnabled = enable;
1050 LOG_GL("Enable GL_STENCIL_TEST\n");
1051 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_STENCIL_TEST) );
1055 LOG_GL("Disable GL_STENCIL_TEST\n");
1056 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_STENCIL_TEST) );
1062 * Wrapper for OpenGL ES 3.0 glEndQuery()
1064 void EndQuery(GLenum target)
1066 LOG_GL("EndQuery %d\n", target);
1067 CHECK_GL( mGlAbstraction, mGlAbstraction.EndQuery(target) );
1071 * Wrapper for OpenGL ES 3.0 glEndTransformFeedback()
1073 void EndTransformFeedback()
1075 LOG_GL("EndTransformFeedback\n");
1076 CHECK_GL( mGlAbstraction, mGlAbstraction.EndTransformFeedback() );
1080 * Wrapper for OpenGL ES 2.0 glFinish()
1085 CHECK_GL( mGlAbstraction, mGlAbstraction.Finish() );
1089 * Wrapper for OpenGL ES 2.0 glFlush()
1094 CHECK_GL( mGlAbstraction, mGlAbstraction.Flush() );
1098 * Wrapper for OpenGL ES 2.0 glFramebufferRenderbuffer()
1100 void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1102 LOG_GL("FramebufferRenderbuffer %x %x %x %d\n", target, attachment, renderbuffertarget, renderbuffer);
1103 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) );
1107 * Wrapper for OpenGL ES 2.0 glFramebufferTexture2D()
1109 void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1111 LOG_GL("FramebufferTexture2D %x %x %x %d %d\n", target, attachment, textarget, texture, level);
1112 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferTexture2D(target, attachment, textarget, texture, level) );
1116 * Wrapper for OpenGL ES 3.0 glFramebufferTextureLayer()
1118 void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1120 LOG_GL("FramebufferTextureLayer %x %x %d %d %d\n", target, attachment, texture, level, layer);
1121 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferTextureLayer(target, attachment, texture, level, layer) );
1125 * Wrapper for OpenGL ES 2.0 glFrontFace()
1127 void FrontFace(GLenum mode)
1129 LOG_GL("FrontFace %x\n", mode);
1130 CHECK_GL( mGlAbstraction, mGlAbstraction.FrontFace(mode) );
1134 * Wrapper for OpenGL ES 2.0 glGenBuffers()
1136 void GenBuffers(GLsizei n, GLuint* buffers)
1138 LOG_GL("GenBuffers %d\n", n, buffers);
1139 CHECK_GL( mGlAbstraction, mGlAbstraction.GenBuffers(n, buffers) );
1143 * Wrapper for OpenGL ES 2.0 glGenerateMipmap()
1145 void GenerateMipmap(GLenum target)
1147 LOG_GL("GenerateMipmap %x\n", target);
1148 CHECK_GL( mGlAbstraction, mGlAbstraction.GenerateMipmap(target) );
1152 * Wrapper for OpenGL ES 2.0 glGenFramebuffers()
1154 void GenFramebuffers(GLsizei n, GLuint* framebuffers)
1156 LOG_GL("GenFramebuffers %d %p\n", n, framebuffers);
1157 CHECK_GL( mGlAbstraction, mGlAbstraction.GenFramebuffers(n, framebuffers) );
1159 mFrameBufferStateCache.FrameBuffersCreated( n, framebuffers );
1163 * Wrapper for OpenGL ES 2.0 glGenRenderbuffers()
1165 void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
1167 LOG_GL("GenRenderbuffers %d %p\n", n, renderbuffers);
1168 CHECK_GL( mGlAbstraction, mGlAbstraction.GenRenderbuffers(n, renderbuffers) );
1172 * Wrapper for OpenGL ES 2.0 glGenTextures()
1174 void GenTextures(GLsizei n, GLuint* textures)
1176 LOG_GL("GenTextures %d %p\n", n, textures);
1177 CHECK_GL( mGlAbstraction, mGlAbstraction.GenTextures(n, textures) );
1181 * Wrapper for OpenGL ES 2.0 glGetBooleanv()
1183 void GetBooleanv(GLenum pname, GLboolean* params)
1185 LOG_GL("GetBooleanv %x\n", pname);
1186 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBooleanv(pname, params) );
1190 * Wrapper for OpenGL ES 2.0 glGetBufferParameteriv()
1192 void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
1194 LOG_GL("GetBufferParameteriv %x %x %p\n", target, pname, params);
1195 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBufferParameteriv(target, pname, params) );
1199 * Wrapper for OpenGL ES 3.0 glGetBufferPointer()
1201 void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
1203 LOG_GL("GetBufferPointerv %x %x %p\n", target, pname, params);
1204 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBufferPointerv(target, pname, params) );
1208 * Wrapper for OpenGL ES 2.0 glGetError()
1210 GLenum GetError(void)
1212 // Not worth logging here
1213 return mGlAbstraction.GetError();
1217 * Wrapper for OpenGL ES 2.0 glGetFloatv()
1219 void GetFloatv(GLenum pname, GLfloat* params)
1221 LOG_GL("GetFloatv %x\n", pname);
1222 CHECK_GL( mGlAbstraction, mGlAbstraction.GetFloatv(pname, params) );
1226 * Wrapper for OpenGL ES 2.0 glGetFramebufferAttachmentParameteriv()
1228 void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1230 LOG_GL("GetFramebufferAttachmentParameteriv %x %x %x\n", target, attachment, pname);
1231 CHECK_GL( mGlAbstraction, mGlAbstraction.GetFramebufferAttachmentParameteriv(target, attachment, pname, params) );
1235 * Wrapper for OpenGL ES 2.0 glGetIntegerv()
1237 void GetIntegerv(GLenum pname, GLint* params)
1239 LOG_GL("GetIntegerv %x\n", pname);
1240 CHECK_GL( mGlAbstraction, mGlAbstraction.GetIntegerv(pname, params) );
1244 * Wrapper for OpenGL ES 3.0 glGetQueryiv()
1246 void GetQueryiv(GLenum target, GLenum pname, GLint* params)
1248 LOG_GL("GetQueryiv %x %x\n", target, pname);
1249 CHECK_GL( mGlAbstraction, mGlAbstraction.GetQueryiv(target, pname, params) );
1253 * Wrapper for OpenGL ES 3.0 glGetQueryObjectuiv()
1255 void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
1257 LOG_GL("GetQueryObjectuiv %u %x %p\n", id, pname, params);
1258 CHECK_GL( mGlAbstraction, mGlAbstraction.GetQueryObjectuiv(id, pname, params) );
1262 * Wrapper for OpenGL ES 2.0 glGetRenderbufferParameteriv()
1264 void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1266 LOG_GL("GetRenderbufferParameteriv %x %x\n", target, pname);
1267 CHECK_GL( mGlAbstraction, mGlAbstraction.GetRenderbufferParameteriv(target, pname, params) );
1271 * Wrapper for OpenGL ES 2.0 glGetString()
1273 const GLubyte* GetString(GLenum name)
1275 LOG_GL("GetString %x\n", name);
1276 const GLubyte* str = CHECK_GL( mGlAbstraction, mGlAbstraction.GetString(name) );
1281 * Wrapper for OpenGL ES 2.0 glGetTexParameterfv()
1283 void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
1285 LOG_GL("GetTexParameterfv %x %x\n", target, pname);
1286 CHECK_GL( mGlAbstraction, mGlAbstraction.GetTexParameterfv(target, pname, params) );
1290 * Wrapper for OpenGL ES 2.0 glGetTexParameteriv()
1292 void GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
1294 LOG_GL("GetTexParameteriv %x %x\n", target, pname);
1295 CHECK_GL( mGlAbstraction, mGlAbstraction.GetTexParameteriv(target, pname, params) );
1299 * Wrapper for OpenGL ES 2.0 glHint()
1301 void Hint(GLenum target, GLenum mode)
1303 LOG_GL("Hint %x %x\n", target, mode);
1304 CHECK_GL( mGlAbstraction, mGlAbstraction.Hint(target, mode) );
1308 * Wrapper for OpenGL ES 2.0 glIsBuffer()
1310 GLboolean IsBuffer(GLuint buffer)
1312 LOG_GL("IsBuffer %d\n", buffer);
1313 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsBuffer(buffer) );
1318 * Wrapper for OpenGL ES 2.0 glIsEnabled()
1320 GLboolean IsEnabled(GLenum cap)
1322 LOG_GL("IsEnabled %x\n", cap);
1323 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsEnabled(cap) );
1328 * Wrapper for OpenGL ES 2.0 glIsFramebuffer()
1330 GLboolean IsFramebuffer(GLuint framebuffer)
1332 LOG_GL("IsFramebuffer %d\n", framebuffer);
1333 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsFramebuffer(framebuffer) );
1338 * Wrapper for OpenGL ES 3.0 glIsQuery()
1340 GLboolean IsQuery(GLuint id)
1342 LOG_GL("IsQuery %u\n", id);
1343 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsQuery(id) );
1348 * Wrapper for OpenGL ES 2.0 glIsRenderbuffer()
1350 GLboolean IsRenderbuffer(GLuint renderbuffer)
1352 LOG_GL("IsRenderbuffer %d\n", renderbuffer);
1353 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsRenderbuffer(renderbuffer) );
1358 * Wrapper for OpenGL ES 2.0 glIsTexture()
1360 GLboolean IsTexture(GLuint texture)
1362 LOG_GL("IsTexture %d\n", texture);
1363 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsTexture(texture) );
1368 * Wrapper for OpenGL ES 3.0 glIsTransformFeedback()
1370 GLboolean IsTransformFeedback(GLuint id)
1372 LOG_GL("IsTransformFeedback %u\n", id);
1373 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsTransformFeedback(id) );
1378 * Wrapper for OpenGL ES 2.0 glLineWidth()
1380 void LineWidth(GLfloat width)
1382 LOG_GL("LineWidth %f\n", width);
1383 CHECK_GL( mGlAbstraction, mGlAbstraction.LineWidth(width) );
1387 * Wrapper for OpenGL ES 3.0 glPauseTransformFeedback()
1389 void PauseTransformFeedback()
1391 LOG_GL("PauseTransformFeedback\n");
1392 CHECK_GL( mGlAbstraction, mGlAbstraction.PauseTransformFeedback() );
1396 * Wrapper for OpenGL ES 2.0 glPixelStorei()
1398 void PixelStorei(GLenum pname, GLint param)
1400 LOG_GL("PixelStorei %x %d\n", pname, param);
1401 CHECK_GL( mGlAbstraction, mGlAbstraction.PixelStorei(pname, param) );
1405 * Wrapper for OpenGL ES 2.0 glPolygonOffset()
1407 void PolygonOffset(GLfloat factor, GLfloat units)
1409 LOG_GL("PolygonOffset %f %f\n", factor, units);
1410 CHECK_GL( mGlAbstraction, mGlAbstraction.PolygonOffset(factor, units) );
1414 * Wrapper for OpenGL ES 2.0 glReadPixels()
1416 void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
1418 LOG_GL("ReadPixels %d %d %d %d %x %x\n", x, y, width, height, format, type);
1419 CHECK_GL( mGlAbstraction, mGlAbstraction.ReadPixels(x, y, width, height, format, type, pixels) );
1423 * Wrapper for OpenGL ES 2.0 glRenderbufferStorage()
1425 void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1427 LOG_GL("RenderbufferStorage %x %x %d %d\n", target, internalformat, width, height);
1428 CHECK_GL( mGlAbstraction, mGlAbstraction.RenderbufferStorage(target, internalformat, width, height) );
1432 * Wrapper for OpenGL ES 3.0 glRenderbufferStorageMultisample()
1434 void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1436 LOG_GL("RenderbufferStorageMultisample %x %u %x %d %d\n", target, samples, internalformat, width, height);
1437 CHECK_GL( mGlAbstraction, mGlAbstraction.RenderbufferStorageMultisample(target, samples, internalformat, width, height) );
1441 * Wrapper for OpenGL ES 3.0 glResumeTransformFeedback()
1443 void ResumeTransformFeedback()
1445 LOG_GL("ResumeTransformFeedback\n");
1446 CHECK_GL( mGlAbstraction, mGlAbstraction.ResumeTransformFeedback() );
1450 * Wrapper for OpenGL ES 2.0 glSampleCoverage()
1452 void SampleCoverage(GLclampf value, GLboolean invert)
1454 LOG_GL("SampleCoverage %f %s\n", value, invert ? "True" : "False");
1455 CHECK_GL( mGlAbstraction, mGlAbstraction.SampleCoverage(value, invert) );
1459 * Wrapper for OpenGL ES 2.0 glScissor()
1461 void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
1463 LOG_GL("Scissor %d %d %d %d\n", x, y, width, height);
1464 CHECK_GL( mGlAbstraction, mGlAbstraction.Scissor(x, y, width, height) );
1468 * Wrapper for OpenGL ES 2.0 glStencilFunc()
1470 void StencilFunc(GLenum func, GLint ref, GLuint mask)
1474 LOG_GL("StencilFunc %x %d %d\n", func, ref, mask);
1475 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFunc(func, ref, mask) );
1479 * Wrapper for OpenGL ES 2.0 glStencilFuncSeparate()
1481 void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1483 LOG_GL("StencilFuncSeparate %x %x %d %d\n", face, func, ref, mask);
1484 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFuncSeparate(face, func, ref, mask) );
1488 * Wrapper for OpenGL ES 2.0 glStencilMask()
1490 void StencilMask(GLuint mask)
1492 if( mask != mStencilMask )
1494 mStencilMask = mask;
1496 LOG_GL("StencilMask %d\n", mask);
1497 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilMask(mask) );
1502 * Wrapper for OpenGL ES 2.0 glStencilMaskSeparate()
1504 void StencilMaskSeparate(GLenum face, GLuint mask)
1506 LOG_GL("StencilMaskSeparate %x %d\n", face, mask);
1507 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilMaskSeparate(face, mask) );
1511 * Wrapper for OpenGL ES 2.0 glStencilOp()
1513 void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1515 LOG_GL("StencilOp %x %x %x\n", fail, zfail, zpass);
1516 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOp(fail, zfail, zpass) );
1520 * Wrapper for OpenGL ES 2.0 glStencilOpSeparate()
1522 void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1524 LOG_GL("StencilOpSeparate %x %x %x %x\n", face, fail, zfail, zpass);
1525 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOpSeparate(face, fail, zfail, zpass) );
1529 * Wrapper for OpenGL ES 2.0 glTexImage2D()
1531 void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
1532 GLint border, GLenum format, GLenum type, const void* pixels)
1534 LOG_GL("TexImage2D %x %d %d %dx%d %d %x %x %p\n", target, level, internalformat, width, height, border, format, type, pixels);
1535 CHECK_GL( mGlAbstraction, mGlAbstraction.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels) );
1539 * Wrapper for OpenGL ES 3.0 glTexImage3D()
1541 void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth,
1542 GLint border, GLenum format, GLenum type, const void* pixels)
1544 LOG_GL("TexImage3D %x %d %d %dx%dx%d %d %x %x %p\n", target, level, internalformat, width, height, depth, border, format, type, pixels);
1545 CHECK_GL( mGlAbstraction, mGlAbstraction.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels) );
1549 * Wrapper for OpenGL ES 2.0 glTexParameterf()
1551 void TexParameterf(GLenum target, GLenum pname, GLfloat param)
1553 LOG_GL("TexParameterf %x %x %f\n", target, pname, param);
1554 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameterf(target, pname, param) );
1558 * Wrapper for OpenGL ES 2.0 glTexParameterfv()
1560 void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
1562 LOG_GL("TexParameterfv %x %x\n", target, pname);
1563 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameterfv(target, pname, params) );
1567 * Wrapper for OpenGL ES 2.0 glTexParameteri()
1569 void TexParameteri(GLenum target, GLenum pname, GLint param)
1571 LOG_GL("TexParameteri %x %x %d\n", target, pname, param);
1572 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameteri(target, pname, param) );
1576 * Wrapper for OpenGL ES 2.0 glTexParameteriv()
1578 void TexParameteriv(GLenum target, GLenum pname, const GLint* params)
1580 LOG_GL("TexParameteriv %x %x\n", target, pname);
1581 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameteriv(target, pname, params) );
1585 * Wrapper for OpenGL ES 2.0 glTexSubImage2D()
1587 void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
1588 GLenum format, GLenum type, const void* pixels)
1590 LOG_GL("TexSubImage2D %x %d %d %d %d %d %x %x %p\n", target, level, xoffset, yoffset, width, height, format, type, pixels);
1591 CHECK_GL( mGlAbstraction, mGlAbstraction.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) );
1595 * Wrapper for OpenGL ES 3.0 glTexSubImage3D()
1597 void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
1598 GLsizei width, GLsizei height, GLsizei depth,
1599 GLenum format, GLenum type, const void* pixels)
1601 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);
1602 CHECK_GL( mGlAbstraction, mGlAbstraction.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) );
1606 * Wrapper for OpenGL ES 3.0 glUnmapBubffer()
1608 GLboolean UnmapBuffer(GLenum target)
1610 LOG_GL("UnmapBuffer %x \n", target);
1611 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.UnmapBuffer(target) );
1615 * Wrapper for OpenGL ES 2.0 glViewport()
1617 void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
1619 // check if its same as already set
1620 Rect<int> newViewport( x, y, width, height );
1621 if( mViewPort != newViewport )
1624 LOG_GL("Viewport %d %d %d %d\n", x, y, width, height);
1625 CHECK_GL( mGlAbstraction, mGlAbstraction.Viewport(x, y, width, height) );
1626 mViewPort = newViewport; // remember new one
1631 * Get the implementation defined MAX_TEXTURE_SIZE. This values is cached when the context is created
1632 * @return The implementation defined MAX_TEXTURE_SIZE
1634 GLint CachedMaxTextureSize() const
1636 return mMaxTextureSize;
1640 * Get the current viewport.
1641 * @return Viewport rectangle.
1643 const Rect< int >& GetViewport();
1645 private: // Implementation
1648 * @return true if next draw operation will write to depth buffer
1650 bool DepthBufferWriteEnabled() const
1652 return mDepthBufferEnabled && mDepthMaskEnabled;
1656 * @return true if next draw operation will write to stencil buffer
1658 bool StencilBufferWriteEnabled() const
1660 return mStencilBufferEnabled && ( mStencilMask > 0 );
1664 * Flushes vertex attribute location changes to the driver
1666 void FlushVertexAttributeLocations();
1669 * Either enables or disables a vertex attribute location in the cache
1670 * The cahnges won't take affect until FlushVertexAttributeLocations is called
1671 * @param location attribute location
1672 * @param state attribute state
1674 void SetVertexAttributeLocation(unsigned int location, bool state);
1677 * Sets the initial GL state.
1679 void InitializeGlState();
1683 Integration::GlAbstraction& mGlAbstraction;
1685 bool mGlContextCreated; ///< True if the OpenGL context has been created
1687 // glEnable/glDisable states
1689 GLuint mStencilMask;
1691 bool mDepthBufferEnabled;
1692 bool mDepthMaskEnabled;
1693 bool mDitherEnabled;
1694 bool mPolygonOffsetFillEnabled;
1695 bool mSampleAlphaToCoverageEnabled;
1696 bool mSampleCoverageEnabled;
1697 bool mScissorTestEnabled;
1698 bool mStencilBufferEnabled;
1699 bool mClearColorSet;
1700 bool mUsingDefaultBlendColor;
1702 // glBindBuffer() state
1703 GLuint mBoundArrayBufferId; ///< The ID passed to glBindBuffer(GL_ARRAY_BUFFER)
1704 GLuint mBoundElementArrayBufferId; ///< The ID passed to glBindBuffer(GL_ELEMENT_ARRAY_BUFFER)
1705 GLuint mBoundTransformFeedbackBufferId; ///< The ID passed to glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER)
1707 // glBindTexture() state
1708 TextureUnit mActiveTextureUnit;
1709 GLuint mBound2dTextureId[ MAX_TEXTURE_UNITS ]; ///< The ID passed to glBindTexture(GL_TEXTURE_2D)
1711 // glBlendColor() state
1712 Vector4 mBlendColor; ///< Blend color
1714 // glBlendFuncSeparate() state
1715 GLenum mBlendFuncSeparateSrcRGB; ///< The srcRGB parameter passed to glBlendFuncSeparate()
1716 GLenum mBlendFuncSeparateDstRGB; ///< The dstRGB parameter passed to glBlendFuncSeparate()
1717 GLenum mBlendFuncSeparateSrcAlpha; ///< The srcAlpha parameter passed to glBlendFuncSeparate()
1718 GLenum mBlendFuncSeparateDstAlpha; ///< The dstAlpha parameter passed to glBlendFuncSeparate()
1720 // glBlendEquationSeparate state
1721 GLenum mBlendEquationSeparateModeRGB; ///< Controls RGB blend mode
1722 GLenum mBlendEquationSeparateModeAlpha; ///< Controls Alpha blend mode
1724 GLint mMaxTextureSize; ///< return value from GetIntegerv(GL_MAX_TEXTURE_SIZE)
1725 Vector4 mClearColor; ///< clear color
1727 // Face culling mode
1728 Dali::Material::FaceCullingMode mCullFaceMode;
1730 // cached viewport size
1731 Rect< int > mViewPort;
1733 // Vertex Attribute Buffer enable caching
1734 bool mVertexAttributeCachedState[ MAX_ATTRIBUTE_CACHE_SIZE ]; ///< Value cache for Enable Vertex Attribute
1735 bool mVertexAttributeCurrentState[ MAX_ATTRIBUTE_CACHE_SIZE ]; ///< Current state on the driver for Enable Vertex Attribute
1737 FrameBufferStateCache mFrameBufferStateCache; ///< frame buffer state cache
1740 } // namespace Internal
1744 #endif // __DALI_INTERNAL_CONTEXT_H__