1 #ifndef __DALI_INTERNAL_CONTEXT_H__
2 #define __DALI_INTERNAL_CONTEXT_H__
5 * Copyright (c) 2014 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/actors/renderable-actor.h>
23 #include <dali/public-api/common/dali-vector.h>
24 #include <dali/public-api/common/dali-common.h>
25 #include <dali/public-api/math/rect.h>
26 #include <dali/public-api/math/vector4.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>
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 LOG_GL( "BlendColor %f %f %f %f\n", 0.0f, 0.0f, 0.0f, 0.0f );
296 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendColor( 0.0f, 0.0f, 0.0f, 0.0f ) );
297 mUsingDefaultBlendColor = true;
302 * Wrapper for OpenGL ES 2.0 glBlendColor()
304 void SetCustomBlendColor( const Vector4& color )
306 LOG_GL( "BlendColor %f %f %f %f\n", color.r, color.g, color.b, color.a );
307 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendColor(color.r, color.g, color.b, color.a) );
308 mUsingDefaultBlendColor = false;
312 * Wrapper for OpenGL ES 2.0 glBlendEquation()
314 void BlendEquation(GLenum mode)
316 // use BlendEquationSeparate to set the rgb and alpha modes the same
317 BlendEquationSeparate( mode, mode );
321 * Wrapper for OpenGL ES 2.0 glBlendEquationSeparate()
323 void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
325 if( ( modeRGB != mBlendEquationSeparateModeRGB ) ||
326 ( modeAlpha != mBlendEquationSeparateModeAlpha ) )
328 mBlendEquationSeparateModeRGB = modeRGB;
329 mBlendEquationSeparateModeAlpha = modeAlpha;
330 LOG_GL("BlendEquationSeparate %d %d\n", modeRGB, modeAlpha);
331 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendEquationSeparate(modeRGB, modeAlpha) );
336 * Wrapper for OpenGL ES 2.0 glBlendFunc()
338 void BlendFunc(GLenum sfactor, GLenum dfactor)
340 // reuse the BlendFuncSeparate as thats what the DDK does anyways
341 BlendFuncSeparate( sfactor, dfactor, sfactor, dfactor );
345 * Wrapper for OpenGL ES 2.0 glBlendFuncSeparate()
347 void BlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
349 if( ( mBlendFuncSeparateSrcRGB != srcRGB )||( mBlendFuncSeparateDstRGB != dstRGB )||
350 ( mBlendFuncSeparateSrcAlpha != srcAlpha )||( mBlendFuncSeparateDstAlpha != dstAlpha ) )
352 mBlendFuncSeparateSrcRGB = srcRGB;
353 mBlendFuncSeparateDstRGB = dstRGB;
354 mBlendFuncSeparateSrcAlpha = srcAlpha;
355 mBlendFuncSeparateDstAlpha = dstAlpha;
357 LOG_GL( "BlendFuncSeparate %d %d %d %d\n", srcRGB, dstRGB, srcAlpha, dstAlpha );
358 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendFuncSeparate( srcRGB, dstRGB, srcAlpha, dstAlpha ) );
363 * Wrapper for OpenGL ES 3.0 glBlitFramebuffer()
365 void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
367 LOG_GL( "BlitFramebuffer %d %d %d %d %d %d %d %d %x %d\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
368 CHECK_GL( mGlAbstraction, mGlAbstraction.BlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ) );
372 * Wrapper for OpenGL ES 2.0 glBufferData()
374 void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
376 LOG_GL("BufferData %d %d %p %d\n", target, size, data, usage);
377 CHECK_GL( mGlAbstraction, mGlAbstraction.BufferData(target, size, data, usage) );
381 * Wrapper for OpenGL ES 2.0 glBufferSubData()
383 void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
385 LOG_GL("BufferSubData %d %d %d %p\n", target, offset, size, data);
386 CHECK_GL( mGlAbstraction, mGlAbstraction.BufferSubData(target, offset, size, data) );
390 * Wrapper for OpenGL ES 2.0 glCheckFramebufferStatus()
392 GLenum CheckFramebufferStatus(GLenum target)
394 LOG_GL("CheckFramebufferStatus %d\n", target);
395 GLenum value = CHECK_GL( mGlAbstraction, mGlAbstraction.CheckFramebufferStatus(target) );
400 * Wrapper for OpenGL ES 2.0 glClear()
402 void Clear(GLbitfield mask, ClearMode mode )
404 bool forceClear = (mode == FORCE_CLEAR );
405 mask = mFrameBufferStateCache.GetClearMask( mask, forceClear , mScissorTestEnabled );
409 LOG_GL("Clear %d\n", mask);
410 CHECK_GL( mGlAbstraction, mGlAbstraction.Clear( mask ) );
415 * Wrapper for OpenGL ES 2.0 glClearColor()
417 void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
419 Vector4 newCol(red,green,blue,alpha);
421 if (!mClearColorSet || mClearColor !=newCol )
423 LOG_GL("ClearColor %f %f %f %f\n", red, green, blue, alpha);
424 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearColor(red, green, blue, alpha) );
426 mClearColorSet = true;
427 mClearColor = newCol;
432 * Wrapper for OpenGL ES 2.0 glClearDepthf()
434 void ClearDepthf(GLclampf depth)
436 LOG_GL("ClearDepthf %f\n", depth);
437 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearDepthf(depth) );
441 * Wrapper for OpenGL ES 2.0 glClearStencil()
443 void ClearStencil(GLint s)
445 LOG_GL("ClearStencil %d\n", s);
446 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearStencil(s) );
450 * Wrapper for OpenGL ES 2.0 glColorMask()
451 * @note This has been optimized to a single boolean value (masking individual channels is not required)
453 void ColorMask( bool flag )
455 // only change state if needed
456 if( flag != mColorMask )
459 LOG_GL("ColorMask %s %s %s %s\n", flag ? "True" : "False", flag ? "True" : "False", flag ? "True" : "False", flag ? "True" : "False");
460 CHECK_GL( mGlAbstraction, mGlAbstraction.ColorMask(flag, flag, flag, flag) );
465 * Wrapper for OpenGL ES 2.0 glCompressedTexImage2D()
467 void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
468 GLint border, GLsizei imageSize, const void* data)
470 LOG_GL("CompressedTexImage2D %d %d %x %d %d %d %d %p\n", target, level, internalformat, width, height, border, imageSize, data);
471 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data) );
475 * Wrapper for OpenGL ES 3.0 glCompressedTexImage3D()
477 void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
478 GLint border, GLsizei imageSize, const void* data)
480 LOG_GL("CompressedTexImage3D %d %d %x %d %d %d %d %d %p\n", target, level, internalformat, width, height, depth, border, imageSize, data);
481 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data) );
485 * Wrapper for OpenGL ES 2.0 glCompressedTexSubImage2D()
487 void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
488 GLenum format, GLsizei imageSize, const void* data)
490 LOG_GL("CompressedTexSubImage2D %x %d %d %d %d %d %x %d %p\n", target, level, xoffset, yoffset, width, height, format, imageSize, data);
491 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) );
495 * Wrapper for OpenGL ES 3.0 glCompressedTexSubImage3D()
497 void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
498 GLsizei width, GLsizei height, GLsizei depth,
499 GLenum format, GLsizei imageSize, const void* data)
501 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);
502 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) );
506 * Wrapper for OpenGL ES 2.0 glCopyTexImage2D()
508 void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
510 LOG_GL("CopyTexImage2D %x %d %x %d %d %d %d %d\n", target, level, internalformat, x, y, width, height, border);
511 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexImage2D(target, level, internalformat, x, y, width, height, border) );
515 * Wrapper for OpenGL ES 2.0 glCopyTexSubImage2D()
517 void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
519 LOG_GL("CopyTexSubImage2D %x %d %d %d %d %d %d %d\n", target, level, xoffset, yoffset, x, y, width, height);
520 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) );
524 * Wrapper for OpenGL ES 3.0 glCopyTexSubImage3D()
526 void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
528 LOG_GL("CopyTexSubImage3D %x %d %d %d %d %d %d %d %d\n", target, level, xoffset, yoffset, zoffset, x, y, width, height);
529 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) );
533 * Wrapper for OpenGL ES 2.0 glCullFace()
534 * enables GL_CULL_FACE if in any of the face culling modes
535 * otherwise disables GL_CULL_FACE
537 void CullFace(CullFaceMode mode)
539 // Avoid unnecessary calls to gl
540 if(mCullFaceMode != mode)
542 mCullFaceMode = mode;
547 LOG_GL("Disable GL_CULL_FACE\n");
548 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_CULL_FACE) );
554 LOG_GL("Enable GL_CULL_FACE\n");
555 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
556 LOG_GL("Enable GL_FRONT\n");
557 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_FRONT) );
563 LOG_GL("Enable GL_CULL_FACE\n");
564 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
565 LOG_GL("Enable GL_BACK\n");
566 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_BACK) );
570 case CullFrontAndBack:
572 LOG_GL("Enable GL_CULL_FACE\n");
573 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
574 LOG_GL("Enable GL_FRONT_AND_BACK\n");
575 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_FRONT_AND_BACK) );
586 * Wrapper for OpenGL ES 2.0 glDeleteBuffers()
588 void DeleteBuffers(GLsizei n, const GLuint* buffers)
590 // @todo: this is to prevent mesh destructor from doing GL calls when DALi core is being deleted
591 // can be taken out once render manages either knows about meshes or gpubuffers and can tell them directly that context is lost
592 if( this->IsGlContextCreated() )
594 LOG_GL("DeleteBuffers %d %p\n", n, buffers);
595 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteBuffers(n, buffers) );
597 // reset the cached buffer id's
598 // fixes problem where some drivers will a generate a buffer with the
599 // same id, as the last deleted buffer id.
600 mBoundArrayBufferId = 0;
601 mBoundElementArrayBufferId = 0;
602 mBoundTransformFeedbackBufferId = 0;
606 * Wrapper for OpenGL ES 2.0 glDeleteFramebuffers()
608 void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
610 mFrameBufferStateCache.FrameBuffersDeleted( n, framebuffers );
612 LOG_GL("DeleteFramebuffers %d %p\n", n, framebuffers);
613 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteFramebuffers(n, framebuffers) );
617 * Wrapper for OpenGL ES 3.0 glDeleteQueries()
619 void DeleteQueries(GLsizei n, GLuint* ids)
621 LOG_GL("DeleteQueries %d %p\n", n, ids);
622 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteQueries(n, ids) );
626 * Wrapper for OpenGL ES 2.0 glDeleteRenderbuffers()
628 void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
630 LOG_GL("DeleteRenderbuffers %d %p\n", n, renderbuffers);
631 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteRenderbuffers(n, renderbuffers) );
635 * Wrapper for OpenGL ES 2.0 glDeleteTextures()
637 void DeleteTextures(GLsizei n, const GLuint* textures)
639 LOG_GL("DeleteTextures %d %p\n", n, textures);
640 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTextures(n, textures) );
642 // reset the cached texture id's incase the driver re-uses them
643 // when creating new textures
644 for( unsigned int i=0; i < MAX_TEXTURE_UNITS; ++i )
646 mBound2dTextureId[ i ] = 0;
651 * Wrapper for OpenGL ES 3.0 glDeleteTransformFeedbacks()
653 void DeleteTransformFeedbacks(GLsizei n, GLuint* ids)
655 LOG_GL("DeleteTransformFeedbacks %d %p\n", n, ids);
656 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTransformFeedbacks(n, ids) );
660 * Wrapper for OpenGL ES 2.0 glDepthFunc()
662 void DepthFunc(GLenum func)
664 LOG_GL("DepthFunc %x\n", func);
665 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthFunc(func) );
669 * Wrapper for OpenGL ES 2.0 glDepthMask()
671 void DepthMask(GLboolean flag)
673 // only change state if needed
674 if( flag != mDepthMaskEnabled )
676 mDepthMaskEnabled = flag;
677 LOG_GL("DepthMask %s\n", flag ? "True" : "False");
678 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthMask( mDepthMaskEnabled ) );
683 * Wrapper for OpenGL ES 2.0 glDepthRangef()
685 void DepthRangef(GLclampf zNear, GLclampf zFar)
687 LOG_GL("DepthRangef %f %f\n", zNear, zFar);
688 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthRangef(zNear, zFar) );
692 * The wrapper for OpenGL ES 2.0 glDisable() has been replaced by SetBlend, SetCullFace, SetDepthTest,
693 * SetDither, SetPolygonOffsetFill, SetSampleAlphaToCoverage, SetSampleCoverage, SetScissorTest & SetStencilTest.
697 * Wrapper for OpenGL ES 2.0 glDrawArrays()
699 void DrawArrays(GLenum mode, GLint first, GLsizei count)
701 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
702 FlushVertexAttributeLocations();
704 LOG_GL("DrawArrays %x %d %d\n", mode, first, count);
705 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawArrays(mode, first, count) );
709 * Wrapper for OpenGL ES 3.0 glDrawArraysInstanced()
711 void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
713 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
714 FlushVertexAttributeLocations();
716 LOG_GL("DrawArraysInstanced %x %d %d %d\n", mode, first, count, instanceCount);
717 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawArraysInstanced(mode, first, count,instanceCount) );
721 * Wrapper for OpenGL ES 3.0 glDrawBuffers()
723 void DrawBuffers(GLsizei n, const GLenum* bufs)
725 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
726 LOG_GL("DrawBuffers %d %p\n", n, bufs);
727 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawBuffers(n, bufs) );
731 * Wrapper for OpenGL ES 2.0 glDrawElements()
733 void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
735 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
737 FlushVertexAttributeLocations();
739 LOG_GL("DrawElements %x %d %d %p\n", mode, count, type, indices);
740 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawElements(mode, count, type, indices) );
744 * Wrapper for OpenGL ES 3.0 glDrawElementsInstanced()
746 void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instanceCount)
748 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
750 FlushVertexAttributeLocations();
752 LOG_GL("DrawElementsInstanced %x %d %d %p %d\n", mode, count, type, indices, instanceCount);
753 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawElementsInstanced(mode, count, type, indices, instanceCount) );
757 * Wrapper for OpenGL ES 3.0 glDrawRangeElements()
759 void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices)
761 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
762 FlushVertexAttributeLocations();
764 LOG_GL("DrawRangeElements %x %u %u %d %d %p\n", mode, start, end, count, type, indices);
765 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawRangeElements(mode, start, end, count, type, indices) );
769 * Wrapper for OpenGL ES 3.0 glGenQuerieS()
771 void GenQueries(GLsizei n, GLuint* ids)
773 LOG_GL("GenQueries %d %p\n", n, ids);
774 CHECK_GL( mGlAbstraction, mGlAbstraction.GenQueries(n, ids) );
778 * Wrapper for OpenGL ES 3.0 glGenTransformFeedbacks()
780 void GenTransformFeedbacks(GLsizei n, GLuint* ids)
782 LOG_GL("GenTransformFeedbacks %d %p\n", n, ids);
783 CHECK_GL( mGlAbstraction, mGlAbstraction.GenTransformFeedbacks(n, ids) );
787 * @return the current buffer bound for a given target
789 GLuint GetCurrentBoundArrayBuffer(GLenum target)
794 case GL_ARRAY_BUFFER:
796 result = mBoundArrayBufferId;
799 case GL_ELEMENT_ARRAY_BUFFER:
801 result = mBoundElementArrayBufferId;
804 case GL_TRANSFORM_FEEDBACK_BUFFER:
806 result = mBoundTransformFeedbackBufferId;
811 DALI_ASSERT_DEBUG(0 && "target buffer type not supported");
817 void EnableVertexAttributeArray( GLuint location )
819 SetVertexAttributeLocation( location, true);
822 void DisableVertexAttributeArray( GLuint location )
824 SetVertexAttributeLocation( location, false);
828 * Wrapper for OpenGL ES 3.0 glVertexAttribDivisor()
830 void VertexAttribDivisor ( GLuint index, GLuint divisor )
832 LOG_GL("VertexAttribDivisor(%d, %d)\n", index, divisor );
833 CHECK_GL( mGlAbstraction, mGlAbstraction.VertexAttribDivisor( index, divisor ) );
837 * Wrapper for OpenGL ES 2.0 glVertexAttribPointer()
839 void VertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr )
841 LOG_GL("VertexAttribPointer(%d, %d, %d, %d, %d, %x)\n", index, size, type, normalized, stride, ptr );
842 CHECK_GL( mGlAbstraction, mGlAbstraction.VertexAttribPointer( index, size, type, normalized, stride, ptr ) );
846 * Wrapper for OpenGL ES 3.0 glInvalidateFramebuffer()
848 void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
850 LOG_GL("InvalidateFramebuffer\n");
851 CHECK_GL( mGlAbstraction, mGlAbstraction.InvalidateFramebuffer(target, numAttachments, attachments) );
855 * The wrapper for OpenGL ES 2.0 glEnable() has been replaced by SetBlend, SetCullFace, SetDepthTest,
856 * SetDither, SetPolygonOffsetFill, SetSampleAlphaToCoverage, SetSampleCoverage, SetScissorTest & SetStencilTest.
860 * This method replaces glEnable(GL_BLEND) and glDisable(GL_BLEND).
861 * @param[in] enable True if GL_BLEND should be enabled.
863 void SetBlend(bool enable)
865 // Avoid unecessary calls to glEnable/glDisable
866 if (enable != mBlendEnabled)
868 mBlendEnabled = enable;
872 LOG_GL("Enable GL_BLEND\n");
873 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_BLEND) );
877 LOG_GL("Disable GL_BLEND\n");
878 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_BLEND) );
884 * This method replaces glEnable(GL_DEPTH_TEST) and glDisable(GL_DEPTH_TEST).
885 * Note GL_DEPTH_TEST means enable the depth buffer for writing and or testing.
886 * glDepthMask is used to enable / disable writing to depth buffer.
887 * glDepthFunc us used to control if testing is enabled and how it is performed ( default GL_LESS)
889 * @param[in] enable True if GL_DEPTH_TEST should be enabled.
891 void EnableDepthBuffer( bool enable )
893 // Avoid unecessary calls to glEnable/glDisable
894 if( enable != mDepthBufferEnabled )
896 mDepthBufferEnabled = enable;
900 LOG_GL("Enable GL_DEPTH_TEST\n");
901 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_DEPTH_TEST) );
905 LOG_GL("Disable GL_DEPTH_TEST\n");
906 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_DEPTH_TEST) );
912 * This method replaces glEnable(GL_DITHER) and glDisable(GL_DITHER).
913 * @param[in] enable True if GL_DITHER should be enabled.
915 void SetDither(bool enable)
917 // Avoid unecessary calls to glEnable/glDisable
918 if (enable != mDitherEnabled)
920 mDitherEnabled = enable;
924 LOG_GL("Enable GL_DITHER\n");
925 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_DITHER) );
929 LOG_GL("Disable GL_DITHER\n");
930 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_DITHER) );
936 * This method replaces glEnable(GL_POLYGON_OFFSET_FILL) and glDisable(GL_POLYGON_OFFSET_FILL).
937 * @param[in] enable True if GL_POLYGON_OFFSET_FILL should be enabled.
939 void SetPolygonOffsetFill(bool enable)
941 // Avoid unecessary calls to glEnable/glDisable
942 if (enable != mPolygonOffsetFillEnabled)
944 mPolygonOffsetFillEnabled = enable;
948 LOG_GL("Enable GL_POLYGON_OFFSET_FILL\n");
949 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_POLYGON_OFFSET_FILL) );
953 LOG_GL("Disable GL_POLYGON_OFFSET_FILL\n");
954 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_POLYGON_OFFSET_FILL) );
960 * This method replaces glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE) and glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE).
961 * @param[in] enable True if GL_SAMPLE_ALPHA_TO_COVERAGE should be enabled.
963 void SetSampleAlphaToCoverage(bool enable)
965 // Avoid unecessary calls to glEnable/glDisable
966 if (enable != mSampleAlphaToCoverageEnabled)
968 mSampleAlphaToCoverageEnabled = enable;
972 LOG_GL("Enable GL_SAMPLE_ALPHA_TO_COVERAGE\n");
973 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SAMPLE_ALPHA_TO_COVERAGE) );
977 LOG_GL("Disable GL_SAMPLE_ALPHA_TO_COVERAGE\n");
978 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SAMPLE_ALPHA_TO_COVERAGE) );
984 * This method replaces glEnable(GL_SAMPLE_COVERAGE) and glDisable(GL_SAMPLE_COVERAGE).
985 * @param[in] enable True if GL_SAMPLE_COVERAGE should be enabled.
987 void SetSampleCoverage(bool enable)
989 // Avoid unecessary calls to glEnable/glDisable
990 if (enable != mSampleCoverageEnabled)
992 mSampleCoverageEnabled = enable;
996 LOG_GL("Enable GL_SAMPLE_COVERAGE\n");
997 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SAMPLE_COVERAGE) );
1001 LOG_GL("Disable GL_SAMPLE_COVERAGE\n");
1002 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SAMPLE_COVERAGE) );
1008 * This method replaces glEnable(GL_SCISSOR_TEST) and glDisable(GL_SCISSOR_TEST).
1009 * @param[in] enable True if GL_SCISSOR_TEST should be enabled.
1011 void SetScissorTest(bool enable)
1013 // Avoid unecessary calls to glEnable/glDisable
1014 if (enable != mScissorTestEnabled)
1016 mScissorTestEnabled = enable;
1020 LOG_GL("Enable GL_SCISSOR_TEST\n");
1021 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SCISSOR_TEST) );
1025 LOG_GL("Disable GL_SCISSOR_TEST\n");
1026 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SCISSOR_TEST) );
1032 * This method replaces glEnable(GL_STENCIL_TEST) and glDisable(GL_STENCIL_TEST).
1033 * Note GL_STENCIL_TEST means enable the stencil buffer for writing and or testing.
1034 * glStencilMask is used to control how bits are written to the stencil buffer.
1035 * glStencilFunc is used to control if testing is enabled and how it is performed ( default GL_ALWAYS )
1036 * @param[in] enable True if GL_STENCIL_TEST should be enabled.
1038 void EnableStencilBuffer(bool enable)
1040 // Avoid unecessary calls to glEnable/glDisable
1041 if( enable != mStencilBufferEnabled )
1043 mStencilBufferEnabled = enable;
1047 LOG_GL("Enable GL_STENCIL_TEST\n");
1048 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_STENCIL_TEST) );
1052 LOG_GL("Disable GL_STENCIL_TEST\n");
1053 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_STENCIL_TEST) );
1059 * Wrapper for OpenGL ES 3.0 glEndQuery()
1061 void EndQuery(GLenum target)
1063 LOG_GL("EndQuery %d\n", target);
1064 CHECK_GL( mGlAbstraction, mGlAbstraction.EndQuery(target) );
1068 * Wrapper for OpenGL ES 3.0 glEndTransformFeedback()
1070 void EndTransformFeedback()
1072 LOG_GL("EndTransformFeedback\n");
1073 CHECK_GL( mGlAbstraction, mGlAbstraction.EndTransformFeedback() );
1077 * Wrapper for OpenGL ES 2.0 glFinish()
1082 CHECK_GL( mGlAbstraction, mGlAbstraction.Finish() );
1086 * Wrapper for OpenGL ES 2.0 glFlush()
1091 CHECK_GL( mGlAbstraction, mGlAbstraction.Flush() );
1095 * Wrapper for OpenGL ES 2.0 glFramebufferRenderbuffer()
1097 void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1099 LOG_GL("FramebufferRenderbuffer %x %x %x %d\n", target, attachment, renderbuffertarget, renderbuffer);
1100 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) );
1104 * Wrapper for OpenGL ES 2.0 glFramebufferTexture2D()
1106 void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1108 LOG_GL("FramebufferTexture2D %x %x %x %d %d\n", target, attachment, textarget, texture, level);
1109 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferTexture2D(target, attachment, textarget, texture, level) );
1113 * Wrapper for OpenGL ES 3.0 glFramebufferTextureLayer()
1115 void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1117 LOG_GL("FramebufferTextureLayer %x %x %d %d %d\n", target, attachment, texture, level, layer);
1118 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferTextureLayer(target, attachment, texture, level, layer) );
1122 * Wrapper for OpenGL ES 2.0 glFrontFace()
1124 void FrontFace(GLenum mode)
1126 LOG_GL("FrontFace %x\n", mode);
1127 CHECK_GL( mGlAbstraction, mGlAbstraction.FrontFace(mode) );
1131 * Wrapper for OpenGL ES 2.0 glGenBuffers()
1133 void GenBuffers(GLsizei n, GLuint* buffers)
1135 LOG_GL("GenBuffers %d\n", n, buffers);
1136 CHECK_GL( mGlAbstraction, mGlAbstraction.GenBuffers(n, buffers) );
1140 * Wrapper for OpenGL ES 2.0 glGenerateMipmap()
1142 void GenerateMipmap(GLenum target)
1144 LOG_GL("GenerateMipmap %x\n", target);
1145 CHECK_GL( mGlAbstraction, mGlAbstraction.GenerateMipmap(target) );
1149 * Wrapper for OpenGL ES 2.0 glGenFramebuffers()
1151 void GenFramebuffers(GLsizei n, GLuint* framebuffers)
1153 LOG_GL("GenFramebuffers %d %p\n", n, framebuffers);
1154 CHECK_GL( mGlAbstraction, mGlAbstraction.GenFramebuffers(n, framebuffers) );
1156 mFrameBufferStateCache.FrameBuffersCreated( n, framebuffers );
1160 * Wrapper for OpenGL ES 2.0 glGenRenderbuffers()
1162 void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
1164 LOG_GL("GenRenderbuffers %d %p\n", n, renderbuffers);
1165 CHECK_GL( mGlAbstraction, mGlAbstraction.GenRenderbuffers(n, renderbuffers) );
1169 * Wrapper for OpenGL ES 2.0 glGenTextures()
1171 void GenTextures(GLsizei n, GLuint* textures)
1173 LOG_GL("GenTextures %d %p\n", n, textures);
1174 CHECK_GL( mGlAbstraction, mGlAbstraction.GenTextures(n, textures) );
1178 * Wrapper for OpenGL ES 2.0 glGetBooleanv()
1180 void GetBooleanv(GLenum pname, GLboolean* params)
1182 LOG_GL("GetBooleanv %x\n", pname);
1183 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBooleanv(pname, params) );
1187 * Wrapper for OpenGL ES 2.0 glGetBufferParameteriv()
1189 void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
1191 LOG_GL("GetBufferParameteriv %x %x %p\n", target, pname, params);
1192 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBufferParameteriv(target, pname, params) );
1196 * Wrapper for OpenGL ES 3.0 glGetBufferPointer()
1198 void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
1200 LOG_GL("GetBufferPointerv %x %x %p\n", target, pname, params);
1201 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBufferPointerv(target, pname, params) );
1205 * Wrapper for OpenGL ES 2.0 glGetError()
1207 GLenum GetError(void)
1209 // Not worth logging here
1210 return mGlAbstraction.GetError();
1214 * Wrapper for OpenGL ES 2.0 glGetFloatv()
1216 void GetFloatv(GLenum pname, GLfloat* params)
1218 LOG_GL("GetFloatv %x\n", pname);
1219 CHECK_GL( mGlAbstraction, mGlAbstraction.GetFloatv(pname, params) );
1223 * Wrapper for OpenGL ES 2.0 glGetFramebufferAttachmentParameteriv()
1225 void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1227 LOG_GL("GetFramebufferAttachmentParameteriv %x %x %x\n", target, attachment, pname);
1228 CHECK_GL( mGlAbstraction, mGlAbstraction.GetFramebufferAttachmentParameteriv(target, attachment, pname, params) );
1232 * Wrapper for OpenGL ES 2.0 glGetIntegerv()
1234 void GetIntegerv(GLenum pname, GLint* params)
1236 LOG_GL("GetIntegerv %x\n", pname);
1237 CHECK_GL( mGlAbstraction, mGlAbstraction.GetIntegerv(pname, params) );
1241 * Wrapper for OpenGL ES 3.0 glGetQueryiv()
1243 void GetQueryiv(GLenum target, GLenum pname, GLint* params)
1245 LOG_GL("GetQueryiv %x %x\n", target, pname);
1246 CHECK_GL( mGlAbstraction, mGlAbstraction.GetQueryiv(target, pname, params) );
1250 * Wrapper for OpenGL ES 3.0 glGetQueryObjectuiv()
1252 void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
1254 LOG_GL("GetQueryObjectuiv %u %x %p\n", id, pname, params);
1255 CHECK_GL( mGlAbstraction, mGlAbstraction.GetQueryObjectuiv(id, pname, params) );
1259 * Wrapper for OpenGL ES 2.0 glGetRenderbufferParameteriv()
1261 void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1263 LOG_GL("GetRenderbufferParameteriv %x %x\n", target, pname);
1264 CHECK_GL( mGlAbstraction, mGlAbstraction.GetRenderbufferParameteriv(target, pname, params) );
1268 * Wrapper for OpenGL ES 2.0 glGetString()
1270 const GLubyte* GetString(GLenum name)
1272 LOG_GL("GetString %x\n", name);
1273 const GLubyte* str = CHECK_GL( mGlAbstraction, mGlAbstraction.GetString(name) );
1278 * Wrapper for OpenGL ES 2.0 glGetTexParameterfv()
1280 void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
1282 LOG_GL("GetTexParameterfv %x %x\n", target, pname);
1283 CHECK_GL( mGlAbstraction, mGlAbstraction.GetTexParameterfv(target, pname, params) );
1287 * Wrapper for OpenGL ES 2.0 glGetTexParameteriv()
1289 void GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
1291 LOG_GL("GetTexParameteriv %x %x\n", target, pname);
1292 CHECK_GL( mGlAbstraction, mGlAbstraction.GetTexParameteriv(target, pname, params) );
1296 * Wrapper for OpenGL ES 2.0 glHint()
1298 void Hint(GLenum target, GLenum mode)
1300 LOG_GL("Hint %x %x\n", target, mode);
1301 CHECK_GL( mGlAbstraction, mGlAbstraction.Hint(target, mode) );
1305 * Wrapper for OpenGL ES 2.0 glIsBuffer()
1307 GLboolean IsBuffer(GLuint buffer)
1309 LOG_GL("IsBuffer %d\n", buffer);
1310 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsBuffer(buffer) );
1315 * Wrapper for OpenGL ES 2.0 glIsEnabled()
1317 GLboolean IsEnabled(GLenum cap)
1319 LOG_GL("IsEnabled %x\n", cap);
1320 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsEnabled(cap) );
1325 * Wrapper for OpenGL ES 2.0 glIsFramebuffer()
1327 GLboolean IsFramebuffer(GLuint framebuffer)
1329 LOG_GL("IsFramebuffer %d\n", framebuffer);
1330 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsFramebuffer(framebuffer) );
1335 * Wrapper for OpenGL ES 3.0 glIsQuery()
1337 GLboolean IsQuery(GLuint id)
1339 LOG_GL("IsQuery %u\n", id);
1340 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsQuery(id) );
1345 * Wrapper for OpenGL ES 2.0 glIsRenderbuffer()
1347 GLboolean IsRenderbuffer(GLuint renderbuffer)
1349 LOG_GL("IsRenderbuffer %d\n", renderbuffer);
1350 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsRenderbuffer(renderbuffer) );
1355 * Wrapper for OpenGL ES 2.0 glIsTexture()
1357 GLboolean IsTexture(GLuint texture)
1359 LOG_GL("IsTexture %d\n", texture);
1360 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsTexture(texture) );
1365 * Wrapper for OpenGL ES 3.0 glIsTransformFeedback()
1367 GLboolean IsTransformFeedback(GLuint id)
1369 LOG_GL("IsTransformFeedback %u\n", id);
1370 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsTransformFeedback(id) );
1375 * Wrapper for OpenGL ES 2.0 glLineWidth()
1377 void LineWidth(GLfloat width)
1379 LOG_GL("LineWidth %f\n", width);
1380 CHECK_GL( mGlAbstraction, mGlAbstraction.LineWidth(width) );
1384 * Wrapper for OpenGL ES 3.0 glPauseTransformFeedback()
1386 void PauseTransformFeedback()
1388 LOG_GL("PauseTransformFeedback\n");
1389 CHECK_GL( mGlAbstraction, mGlAbstraction.PauseTransformFeedback() );
1393 * Wrapper for OpenGL ES 2.0 glPixelStorei()
1395 void PixelStorei(GLenum pname, GLint param)
1397 LOG_GL("PixelStorei %x %d\n", pname, param);
1398 CHECK_GL( mGlAbstraction, mGlAbstraction.PixelStorei(pname, param) );
1402 * Wrapper for OpenGL ES 2.0 glPolygonOffset()
1404 void PolygonOffset(GLfloat factor, GLfloat units)
1406 LOG_GL("PolygonOffset %f %f\n", factor, units);
1407 CHECK_GL( mGlAbstraction, mGlAbstraction.PolygonOffset(factor, units) );
1411 * Wrapper for OpenGL ES 2.0 glReadPixels()
1413 void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
1415 LOG_GL("ReadPixels %d %d %d %d %x %x\n", x, y, width, height, format, type);
1416 CHECK_GL( mGlAbstraction, mGlAbstraction.ReadPixels(x, y, width, height, format, type, pixels) );
1420 * Wrapper for OpenGL ES 2.0 glRenderbufferStorage()
1422 void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1424 LOG_GL("RenderbufferStorage %x %x %d %d\n", target, internalformat, width, height);
1425 CHECK_GL( mGlAbstraction, mGlAbstraction.RenderbufferStorage(target, internalformat, width, height) );
1429 * Wrapper for OpenGL ES 3.0 glRenderbufferStorageMultisample()
1431 void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1433 LOG_GL("RenderbufferStorageMultisample %x %u %x %d %d\n", target, samples, internalformat, width, height);
1434 CHECK_GL( mGlAbstraction, mGlAbstraction.RenderbufferStorageMultisample(target, samples, internalformat, width, height) );
1438 * Wrapper for OpenGL ES 3.0 glResumeTransformFeedback()
1440 void ResumeTransformFeedback()
1442 LOG_GL("ResumeTransformFeedback\n");
1443 CHECK_GL( mGlAbstraction, mGlAbstraction.ResumeTransformFeedback() );
1447 * Wrapper for OpenGL ES 2.0 glSampleCoverage()
1449 void SampleCoverage(GLclampf value, GLboolean invert)
1451 LOG_GL("SampleCoverage %f %s\n", value, invert ? "True" : "False");
1452 CHECK_GL( mGlAbstraction, mGlAbstraction.SampleCoverage(value, invert) );
1456 * Wrapper for OpenGL ES 2.0 glScissor()
1458 void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
1460 LOG_GL("Scissor %d %d %d %d\n", x, y, width, height);
1461 CHECK_GL( mGlAbstraction, mGlAbstraction.Scissor(x, y, width, height) );
1465 * Wrapper for OpenGL ES 2.0 glStencilFunc()
1467 void StencilFunc(GLenum func, GLint ref, GLuint mask)
1471 LOG_GL("StencilFunc %x %d %d\n", func, ref, mask);
1472 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFunc(func, ref, mask) );
1476 * Wrapper for OpenGL ES 2.0 glStencilFuncSeparate()
1478 void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1480 LOG_GL("StencilFuncSeparate %x %x %d %d\n", face, func, ref, mask);
1481 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFuncSeparate(face, func, ref, mask) );
1485 * Wrapper for OpenGL ES 2.0 glStencilMask()
1487 void StencilMask(GLuint mask)
1489 if( mask != mStencilMask )
1491 mStencilMask = mask;
1493 LOG_GL("StencilMask %d\n", mask);
1494 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilMask(mask) );
1499 * Wrapper for OpenGL ES 2.0 glStencilMaskSeparate()
1501 void StencilMaskSeparate(GLenum face, GLuint mask)
1503 LOG_GL("StencilMaskSeparate %x %d\n", face, mask);
1504 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilMaskSeparate(face, mask) );
1508 * Wrapper for OpenGL ES 2.0 glStencilOp()
1510 void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1512 LOG_GL("StencilOp %x %x %x\n", fail, zfail, zpass);
1513 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOp(fail, zfail, zpass) );
1517 * Wrapper for OpenGL ES 2.0 glStencilOpSeparate()
1519 void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1521 LOG_GL("StencilOpSeparate %x %x %x %x\n", face, fail, zfail, zpass);
1522 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOpSeparate(face, fail, zfail, zpass) );
1526 * Wrapper for OpenGL ES 2.0 glTexImage2D()
1528 void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
1529 GLint border, GLenum format, GLenum type, const void* pixels)
1531 LOG_GL("TexImage2D %x %d %d %dx%d %d %x %x %p\n", target, level, internalformat, width, height, border, format, type, pixels);
1532 CHECK_GL( mGlAbstraction, mGlAbstraction.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels) );
1536 * Wrapper for OpenGL ES 3.0 glTexImage3D()
1538 void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth,
1539 GLint border, GLenum format, GLenum type, const void* pixels)
1541 LOG_GL("TexImage3D %x %d %d %dx%dx%d %d %x %x %p\n", target, level, internalformat, width, height, depth, border, format, type, pixels);
1542 CHECK_GL( mGlAbstraction, mGlAbstraction.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels) );
1546 * Wrapper for OpenGL ES 2.0 glTexParameterf()
1548 void TexParameterf(GLenum target, GLenum pname, GLfloat param)
1550 LOG_GL("TexParameterf %x %x %f\n", target, pname, param);
1551 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameterf(target, pname, param) );
1555 * Wrapper for OpenGL ES 2.0 glTexParameterfv()
1557 void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
1559 LOG_GL("TexParameterfv %x %x\n", target, pname);
1560 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameterfv(target, pname, params) );
1564 * Wrapper for OpenGL ES 2.0 glTexParameteri()
1566 void TexParameteri(GLenum target, GLenum pname, GLint param)
1568 LOG_GL("TexParameteri %x %x %d\n", target, pname, param);
1569 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameteri(target, pname, param) );
1573 * Wrapper for OpenGL ES 2.0 glTexParameteriv()
1575 void TexParameteriv(GLenum target, GLenum pname, const GLint* params)
1577 LOG_GL("TexParameteriv %x %x\n", target, pname);
1578 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameteriv(target, pname, params) );
1582 * Wrapper for OpenGL ES 2.0 glTexSubImage2D()
1584 void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
1585 GLenum format, GLenum type, const void* pixels)
1587 LOG_GL("TexSubImage2D %x %d %d %d %d %d %x %x %p\n", target, level, xoffset, yoffset, width, height, format, type, pixels);
1588 CHECK_GL( mGlAbstraction, mGlAbstraction.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) );
1592 * Wrapper for OpenGL ES 3.0 glTexSubImage3D()
1594 void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
1595 GLsizei width, GLsizei height, GLsizei depth,
1596 GLenum format, GLenum type, const void* pixels)
1598 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);
1599 CHECK_GL( mGlAbstraction, mGlAbstraction.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) );
1603 * Wrapper for OpenGL ES 3.0 glUnmapBubffer()
1605 GLboolean UnmapBuffer(GLenum target)
1607 LOG_GL("UnmapBuffer %x \n", target);
1608 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.UnmapBuffer(target) );
1612 * Wrapper for OpenGL ES 2.0 glViewport()
1614 void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
1616 // check if its same as already set
1617 Rect<int> newViewport( x, y, width, height );
1618 if( mViewPort != newViewport )
1621 LOG_GL("Viewport %d %d %d %d\n", x, y, width, height);
1622 CHECK_GL( mGlAbstraction, mGlAbstraction.Viewport(x, y, width, height) );
1623 mViewPort = newViewport; // remember new one
1628 * Get the implementation defined MAX_TEXTURE_SIZE. This values is cached when the context is created
1629 * @return The implementation defined MAX_TEXTURE_SIZE
1631 GLint CachedMaxTextureSize() const
1633 return mMaxTextureSize;
1637 * Get the current viewport.
1638 * @return Viewport rectangle.
1640 const Rect< int >& GetViewport();
1643 * Set the frame count of render thread
1645 inline void SetFrameCount(unsigned int frameCount)
1647 mFrameCount = frameCount;
1651 * Get the frame count
1653 inline unsigned int GetFrameCount()
1659 * Increment the count of culled renderers
1661 inline void IncrementCulledCount()
1667 * Clear the count of culled renderers
1669 inline void ClearCulledCount()
1675 * Get the count of culled renderers in this frame
1677 inline unsigned int GetCulledCount()
1679 return mCulledCount;
1683 * Increment the count of culled renderers
1685 inline void IncrementRendererCount()
1691 * Clear the count of image renderers
1693 inline void ClearRendererCount()
1699 * Get the count of image renderers in this frame
1701 inline unsigned int GetRendererCount()
1703 return mRendererCount;
1706 private: // Implementation
1709 * @return true if next draw operation will write to depth buffer
1711 bool DepthBufferWriteEnabled() const
1713 return mDepthBufferEnabled && mDepthMaskEnabled;
1717 * @return true if next draw operation will write to stencil buffer
1719 bool StencilBufferWriteEnabled() const
1721 return mStencilBufferEnabled && ( mStencilMask > 0 );
1725 * Flushes vertex attribute location changes to the driver
1727 void FlushVertexAttributeLocations();
1730 * Reset the cached internal vertex attribute state
1732 void ResetVertexAttributeState();
1735 * Either enables or disables a vertex attribute location in the cache
1736 * The cahnges won't take affect until FlushVertexAttributeLocations is called
1737 * @param location attribute location
1738 * @param state attribute state
1740 void SetVertexAttributeLocation(unsigned int location, bool state);
1743 * Sets the initial GL state.
1745 void ResetGlState();
1749 Integration::GlAbstraction& mGlAbstraction;
1751 bool mGlContextCreated; ///< True if the OpenGL context has been created
1753 // glEnable/glDisable states
1755 GLuint mStencilMask;
1757 bool mDepthBufferEnabled;
1758 bool mDepthMaskEnabled;
1759 bool mDitherEnabled;
1760 bool mPolygonOffsetFillEnabled;
1761 bool mSampleAlphaToCoverageEnabled;
1762 bool mSampleCoverageEnabled;
1763 bool mScissorTestEnabled;
1764 bool mStencilBufferEnabled;
1765 bool mClearColorSet;
1767 // glBindBuffer() state
1768 GLuint mBoundArrayBufferId; ///< The ID passed to glBindBuffer(GL_ARRAY_BUFFER)
1769 GLuint mBoundElementArrayBufferId; ///< The ID passed to glBindBuffer(GL_ELEMENT_ARRAY_BUFFER)
1770 GLuint mBoundTransformFeedbackBufferId; ///< The ID passed to glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER)
1772 // glBindTexture() state
1773 TextureUnit mActiveTextureUnit;
1774 GLuint mBound2dTextureId[ MAX_TEXTURE_UNITS ]; ///< The ID passed to glBindTexture(GL_TEXTURE_2D)
1776 // glBlendColor() state
1777 bool mUsingDefaultBlendColor;
1779 // glBlendFuncSeparate() state
1780 GLenum mBlendFuncSeparateSrcRGB; ///< The srcRGB parameter passed to glBlendFuncSeparate()
1781 GLenum mBlendFuncSeparateDstRGB; ///< The dstRGB parameter passed to glBlendFuncSeparate()
1782 GLenum mBlendFuncSeparateSrcAlpha; ///< The srcAlpha parameter passed to glBlendFuncSeparate()
1783 GLenum mBlendFuncSeparateDstAlpha; ///< The dstAlpha parameter passed to glBlendFuncSeparate()
1785 // glBlendEquationSeparate state
1786 GLenum mBlendEquationSeparateModeRGB; ///< Controls RGB blend mode
1787 GLenum mBlendEquationSeparateModeAlpha; ///< Controls Alpha blend mode
1789 GLint mMaxTextureSize; ///< return value from GetIntegerv(GL_MAX_TEXTURE_SIZE)
1790 Vector4 mClearColor; ///< clear color
1792 // Face culling mode
1793 CullFaceMode mCullFaceMode;
1795 // cached viewport size
1796 Rect< int > mViewPort;
1798 // Vertex Attribute Buffer enable caching
1799 bool mVertexAttributeCachedState[ MAX_ATTRIBUTE_CACHE_SIZE ]; ///< Value cache for Enable Vertex Attribute
1800 bool mVertexAttributeCurrentState[ MAX_ATTRIBUTE_CACHE_SIZE ]; ///< Current state on the driver for Enable Vertex Attribute
1802 unsigned int mFrameCount; ///< Number of render frames
1803 unsigned int mCulledCount; ///< Number of culled renderers per frame
1804 unsigned int mRendererCount; ///< Number of image renderers per frame
1805 FrameBufferStateCache mFrameBufferStateCache; ///< frame buffer state cache
1808 } // namespace Internal
1812 #endif // __DALI_INTERNAL_CONTEXT_H__