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/public-api/rendering/renderer.h>
27 #include <dali/integration-api/debug.h>
28 #include <dali/integration-api/gl-abstraction.h>
29 #include <dali/integration-api/gl-defines.h>
30 #include <dali/internal/render/common/performance-monitor.h>
31 #include <dali/internal/render/gl-resources/texture-units.h>
32 #include <dali/internal/render/gl-resources/frame-buffer-state-cache.h>
33 #include <dali/internal/render/gl-resources/gl-call-debug.h>
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 glBindTexture(GL_TEXTURE_CUBE_MAP)
291 void BindCubeMapTexture( GLuint texture )
293 LOG_GL("BindTexture GL_TEXTURE_CUBE_MAP %d\n", texture);
294 CHECK_GL( mGlAbstraction, mGlAbstraction.BindTexture(GL_TEXTURE_CUBE_MAP, texture) );
298 * Wrapper for OpenGL ES 2.0 glBlendColor()
300 void SetDefaultBlendColor()
302 if( ! mUsingDefaultBlendColor )
304 SetCustomBlendColor( Color::TRANSPARENT );
305 mUsingDefaultBlendColor = true;
310 * Wrapper for OpenGL ES 2.0 glBlendColor()
312 void SetCustomBlendColor( const Vector4& color )
314 if( mUsingDefaultBlendColor || mBlendColor != color )
316 LOG_GL( "BlendColor %f %f %f %f\n", color.r, color.g, color.b, color.a );
317 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendColor( color.r, color.g, color.b, color.a ) );
318 mUsingDefaultBlendColor = false;
324 * Wrapper for OpenGL ES 2.0 glBlendEquation()
326 void BlendEquation(GLenum mode)
328 // use BlendEquationSeparate to set the rgb and alpha modes the same
329 BlendEquationSeparate( mode, mode );
333 * Wrapper for OpenGL ES 2.0 glBlendEquationSeparate()
335 void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
337 if( ( modeRGB != mBlendEquationSeparateModeRGB ) ||
338 ( modeAlpha != mBlendEquationSeparateModeAlpha ) )
340 mBlendEquationSeparateModeRGB = modeRGB;
341 mBlendEquationSeparateModeAlpha = modeAlpha;
342 LOG_GL("BlendEquationSeparate %d %d\n", modeRGB, modeAlpha);
343 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendEquationSeparate(modeRGB, modeAlpha) );
348 * Wrapper for OpenGL ES 2.0 glBlendFunc()
350 void BlendFunc(GLenum sfactor, GLenum dfactor)
352 // reuse the BlendFuncSeparate as thats what the DDK does anyways
353 BlendFuncSeparate( sfactor, dfactor, sfactor, dfactor );
357 * Wrapper for OpenGL ES 2.0 glBlendFuncSeparate()
359 void BlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
361 if( ( mBlendFuncSeparateSrcRGB != srcRGB )||( mBlendFuncSeparateDstRGB != dstRGB )||
362 ( mBlendFuncSeparateSrcAlpha != srcAlpha )||( mBlendFuncSeparateDstAlpha != dstAlpha ) )
364 mBlendFuncSeparateSrcRGB = srcRGB;
365 mBlendFuncSeparateDstRGB = dstRGB;
366 mBlendFuncSeparateSrcAlpha = srcAlpha;
367 mBlendFuncSeparateDstAlpha = dstAlpha;
369 LOG_GL( "BlendFuncSeparate %d %d %d %d\n", srcRGB, dstRGB, srcAlpha, dstAlpha );
370 CHECK_GL( mGlAbstraction, mGlAbstraction.BlendFuncSeparate( srcRGB, dstRGB, srcAlpha, dstAlpha ) );
375 * Wrapper for OpenGL ES 3.0 glBlitFramebuffer()
377 void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
379 LOG_GL( "BlitFramebuffer %d %d %d %d %d %d %d %d %x %d\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
380 CHECK_GL( mGlAbstraction, mGlAbstraction.BlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ) );
384 * Wrapper for OpenGL ES 2.0 glBufferData()
386 void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
388 LOG_GL("BufferData %d %d %p %d\n", target, size, data, usage);
389 CHECK_GL( mGlAbstraction, mGlAbstraction.BufferData(target, size, data, usage) );
393 * Wrapper for OpenGL ES 2.0 glBufferSubData()
395 void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
397 LOG_GL("BufferSubData %d %d %d %p\n", target, offset, size, data);
398 CHECK_GL( mGlAbstraction, mGlAbstraction.BufferSubData(target, offset, size, data) );
402 * Wrapper for OpenGL ES 2.0 glCheckFramebufferStatus()
404 GLenum CheckFramebufferStatus(GLenum target)
406 LOG_GL("CheckFramebufferStatus %d\n", target);
407 GLenum value = CHECK_GL( mGlAbstraction, mGlAbstraction.CheckFramebufferStatus(target) );
412 * Wrapper for OpenGL ES 2.0 glClear()
414 void Clear(GLbitfield mask, ClearMode mode )
416 bool forceClear = (mode == FORCE_CLEAR );
417 mask = mFrameBufferStateCache.GetClearMask( mask, forceClear , mScissorTestEnabled );
421 LOG_GL("Clear %d\n", mask);
422 CHECK_GL( mGlAbstraction, mGlAbstraction.Clear( mask ) );
427 * Wrapper for OpenGL ES 2.0 glClearColor()
429 void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
431 Vector4 newCol(red,green,blue,alpha);
433 if (!mClearColorSet || mClearColor !=newCol )
435 LOG_GL("ClearColor %f %f %f %f\n", red, green, blue, alpha);
436 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearColor(red, green, blue, alpha) );
438 mClearColorSet = true;
439 mClearColor = newCol;
444 * Wrapper for OpenGL ES 2.0 glClearDepthf()
446 void ClearDepthf(GLclampf depth)
448 LOG_GL("ClearDepthf %f\n", depth);
449 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearDepthf(depth) );
453 * Wrapper for OpenGL ES 2.0 glClearStencil()
455 void ClearStencil(GLint s)
457 LOG_GL("ClearStencil %d\n", s);
458 CHECK_GL( mGlAbstraction, mGlAbstraction.ClearStencil(s) );
462 * Wrapper for OpenGL ES 2.0 glColorMask()
463 * @note This has been optimized to a single boolean value (masking individual channels is not required)
465 void ColorMask( bool flag )
467 // only change state if needed
468 if( flag != mColorMask )
471 LOG_GL("ColorMask %s %s %s %s\n", flag ? "True" : "False", flag ? "True" : "False", flag ? "True" : "False", flag ? "True" : "False");
472 CHECK_GL( mGlAbstraction, mGlAbstraction.ColorMask(flag, flag, flag, flag) );
477 * Wrapper for OpenGL ES 2.0 glCompressedTexImage2D()
479 void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
480 GLint border, GLsizei imageSize, const void* data)
482 LOG_GL("CompressedTexImage2D %d %d %x %d %d %d %d %p\n", target, level, internalformat, width, height, border, imageSize, data);
483 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data) );
487 * Wrapper for OpenGL ES 3.0 glCompressedTexImage3D()
489 void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
490 GLint border, GLsizei imageSize, const void* data)
492 LOG_GL("CompressedTexImage3D %d %d %x %d %d %d %d %d %p\n", target, level, internalformat, width, height, depth, border, imageSize, data);
493 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data) );
497 * Wrapper for OpenGL ES 2.0 glCompressedTexSubImage2D()
499 void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
500 GLenum format, GLsizei imageSize, const void* data)
502 LOG_GL("CompressedTexSubImage2D %x %d %d %d %d %d %x %d %p\n", target, level, xoffset, yoffset, width, height, format, imageSize, data);
503 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) );
507 * Wrapper for OpenGL ES 3.0 glCompressedTexSubImage3D()
509 void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
510 GLsizei width, GLsizei height, GLsizei depth,
511 GLenum format, GLsizei imageSize, const void* data)
513 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);
514 CHECK_GL( mGlAbstraction, mGlAbstraction.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) );
518 * Wrapper for OpenGL ES 2.0 glCopyTexImage2D()
520 void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
522 LOG_GL("CopyTexImage2D %x %d %x %d %d %d %d %d\n", target, level, internalformat, x, y, width, height, border);
523 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexImage2D(target, level, internalformat, x, y, width, height, border) );
527 * Wrapper for OpenGL ES 2.0 glCopyTexSubImage2D()
529 void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
531 LOG_GL("CopyTexSubImage2D %x %d %d %d %d %d %d %d\n", target, level, xoffset, yoffset, x, y, width, height);
532 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) );
536 * Wrapper for OpenGL ES 3.0 glCopyTexSubImage3D()
538 void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
540 LOG_GL("CopyTexSubImage3D %x %d %d %d %d %d %d %d %d\n", target, level, xoffset, yoffset, zoffset, x, y, width, height);
541 CHECK_GL( mGlAbstraction, mGlAbstraction.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) );
545 * Wrapper for OpenGL ES 2.0 glCullFace()
546 * enables GL_CULL_FACE if in any of the face culling modes
547 * otherwise disables GL_CULL_FACE
549 void CullFace( Dali::FaceCullingMode::Type mode )
551 // Avoid unnecessary calls to gl
552 if(mCullFaceMode != mode)
554 mCullFaceMode = mode;
557 case Dali::FaceCullingMode::NONE:
559 LOG_GL("Disable GL_CULL_FACE\n");
560 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_CULL_FACE) );
564 case Dali::FaceCullingMode::FRONT:
566 LOG_GL("Enable GL_CULL_FACE\n");
567 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
568 LOG_GL("Enable GL_FRONT\n");
569 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_FRONT) );
573 case Dali::FaceCullingMode::BACK:
575 LOG_GL("Enable GL_CULL_FACE\n");
576 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
577 LOG_GL("Enable GL_BACK\n");
578 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_BACK) );
582 case Dali::FaceCullingMode::FRONT_AND_BACK:
584 LOG_GL("Enable GL_CULL_FACE\n");
585 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
586 LOG_GL("Enable GL_FRONT_AND_BACK\n");
587 CHECK_GL( mGlAbstraction, mGlAbstraction.CullFace(GL_FRONT_AND_BACK) );
598 * Wrapper for OpenGL ES 2.0 glDeleteBuffers()
600 void DeleteBuffers(GLsizei n, const GLuint* buffers)
602 // @todo: this is to prevent mesh destructor from doing GL calls when DALi core is being deleted
603 // can be taken out once render manages either knows about meshes or gpubuffers and can tell them directly that context is lost
604 if( this->IsGlContextCreated() )
606 LOG_GL("DeleteBuffers %d %p\n", n, buffers);
607 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteBuffers(n, buffers) );
609 // reset the cached buffer id's
610 // fixes problem where some drivers will a generate a buffer with the
611 // same id, as the last deleted buffer id.
612 mBoundArrayBufferId = 0;
613 mBoundElementArrayBufferId = 0;
614 mBoundTransformFeedbackBufferId = 0;
618 * Wrapper for OpenGL ES 2.0 glDeleteFramebuffers()
620 void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
622 mFrameBufferStateCache.FrameBuffersDeleted( n, framebuffers );
624 LOG_GL("DeleteFramebuffers %d %p\n", n, framebuffers);
625 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteFramebuffers(n, framebuffers) );
629 * Wrapper for OpenGL ES 3.0 glDeleteQueries()
631 void DeleteQueries(GLsizei n, GLuint* ids)
633 LOG_GL("DeleteQueries %d %p\n", n, ids);
634 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteQueries(n, ids) );
638 * Wrapper for OpenGL ES 2.0 glDeleteRenderbuffers()
640 void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
642 LOG_GL("DeleteRenderbuffers %d %p\n", n, renderbuffers);
643 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteRenderbuffers(n, renderbuffers) );
647 * Wrapper for OpenGL ES 2.0 glDeleteTextures()
649 void DeleteTextures(GLsizei n, const GLuint* textures)
651 LOG_GL("DeleteTextures %d %p\n", n, textures);
652 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTextures(n, textures) );
654 // reset the cached texture id's incase the driver re-uses them
655 // when creating new textures
656 for( unsigned int i=0; i < MAX_TEXTURE_UNITS; ++i )
658 mBound2dTextureId[ i ] = 0;
663 * Wrapper for OpenGL ES 3.0 glDeleteTransformFeedbacks()
665 void DeleteTransformFeedbacks(GLsizei n, GLuint* ids)
667 LOG_GL("DeleteTransformFeedbacks %d %p\n", n, ids);
668 CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTransformFeedbacks(n, ids) );
672 * Wrapper for OpenGL ES 2.0 glDepthFunc()
674 void DepthFunc(GLenum func)
676 if( func != mDepthFunction )
678 mDepthFunction = func;
679 LOG_GL("DepthFunc %x\n", func);
680 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthFunc(func) );
685 * Wrapper for OpenGL ES 2.0 glDepthMask()
687 void DepthMask(GLboolean flag)
689 // only change state if needed
690 if( flag != mDepthMaskEnabled )
692 mDepthMaskEnabled = flag;
693 LOG_GL("DepthMask %s\n", flag ? "True" : "False");
694 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthMask( mDepthMaskEnabled ) );
699 * Wrapper for OpenGL ES 2.0 glDepthRangef()
701 void DepthRangef(GLclampf zNear, GLclampf zFar)
703 LOG_GL("DepthRangef %f %f\n", zNear, zFar);
704 CHECK_GL( mGlAbstraction, mGlAbstraction.DepthRangef(zNear, zFar) );
708 * The wrapper for OpenGL ES 2.0 glDisable() has been replaced by SetBlend, SetCullFace, SetDepthTest,
709 * SetDither, SetPolygonOffsetFill, SetSampleAlphaToCoverage, SetSampleCoverage, SetScissorTest & SetStencilTest.
713 * Wrapper for OpenGL ES 2.0 glDrawArrays()
715 void DrawArrays(GLenum mode, GLint first, GLsizei count)
717 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
718 FlushVertexAttributeLocations();
720 LOG_GL("DrawArrays %x %d %d\n", mode, first, count);
721 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawArrays(mode, first, count) );
725 * Wrapper for OpenGL ES 3.0 glDrawArraysInstanced()
727 void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
729 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
730 FlushVertexAttributeLocations();
732 LOG_GL("DrawArraysInstanced %x %d %d %d\n", mode, first, count, instanceCount);
733 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawArraysInstanced(mode, first, count,instanceCount) );
737 * Wrapper for OpenGL ES 3.0 glDrawBuffers()
739 void DrawBuffers(GLsizei n, const GLenum* bufs)
741 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
742 LOG_GL("DrawBuffers %d %p\n", n, bufs);
743 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawBuffers(n, bufs) );
747 * Wrapper for OpenGL ES 2.0 glDrawElements()
749 void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
751 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
753 FlushVertexAttributeLocations();
755 LOG_GL("DrawElements %x %d %d %p\n", mode, count, type, indices);
756 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawElements(mode, count, type, indices) );
760 * Wrapper for OpenGL ES 3.0 glDrawElementsInstanced()
762 void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instanceCount)
764 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
766 FlushVertexAttributeLocations();
768 LOG_GL("DrawElementsInstanced %x %d %d %p %d\n", mode, count, type, indices, instanceCount);
769 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawElementsInstanced(mode, count, type, indices, instanceCount) );
773 * Wrapper for OpenGL ES 3.0 glDrawRangeElements()
775 void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices)
777 mFrameBufferStateCache.DrawOperation( mColorMask, DepthBufferWriteEnabled(), StencilBufferWriteEnabled() );
778 FlushVertexAttributeLocations();
780 LOG_GL("DrawRangeElements %x %u %u %d %d %p\n", mode, start, end, count, type, indices);
781 CHECK_GL( mGlAbstraction, mGlAbstraction.DrawRangeElements(mode, start, end, count, type, indices) );
785 * Wrapper for OpenGL ES 3.0 glGenQuerieS()
787 void GenQueries(GLsizei n, GLuint* ids)
789 LOG_GL("GenQueries %d %p\n", n, ids);
790 CHECK_GL( mGlAbstraction, mGlAbstraction.GenQueries(n, ids) );
794 * Wrapper for OpenGL ES 3.0 glGenTransformFeedbacks()
796 void GenTransformFeedbacks(GLsizei n, GLuint* ids)
798 LOG_GL("GenTransformFeedbacks %d %p\n", n, ids);
799 CHECK_GL( mGlAbstraction, mGlAbstraction.GenTransformFeedbacks(n, ids) );
803 * @return the current buffer bound for a given target
805 GLuint GetCurrentBoundArrayBuffer(GLenum target)
810 case GL_ARRAY_BUFFER:
812 result = mBoundArrayBufferId;
815 case GL_ELEMENT_ARRAY_BUFFER:
817 result = mBoundElementArrayBufferId;
820 case GL_TRANSFORM_FEEDBACK_BUFFER:
822 result = mBoundTransformFeedbackBufferId;
827 DALI_ASSERT_DEBUG(0 && "target buffer type not supported");
833 void EnableVertexAttributeArray( GLuint location )
835 SetVertexAttributeLocation( location, true);
838 void DisableVertexAttributeArray( GLuint location )
840 SetVertexAttributeLocation( location, false);
844 * Wrapper for OpenGL ES 3.0 glVertexAttribDivisor()
846 void VertexAttribDivisor ( GLuint index, GLuint divisor )
848 LOG_GL("VertexAttribDivisor(%d, %d)\n", index, divisor );
849 CHECK_GL( mGlAbstraction, mGlAbstraction.VertexAttribDivisor( index, divisor ) );
853 * Wrapper for OpenGL ES 2.0 glVertexAttribPointer()
855 void VertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr )
857 LOG_GL("VertexAttribPointer(%d, %d, %d, %d, %d, %x)\n", index, size, type, normalized, stride, ptr );
858 CHECK_GL( mGlAbstraction, mGlAbstraction.VertexAttribPointer( index, size, type, normalized, stride, ptr ) );
862 * Wrapper for OpenGL ES 3.0 glInvalidateFramebuffer()
864 void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
866 LOG_GL("InvalidateFramebuffer\n");
867 CHECK_GL( mGlAbstraction, mGlAbstraction.InvalidateFramebuffer(target, numAttachments, attachments) );
871 * The wrapper for OpenGL ES 2.0 glEnable() has been replaced by SetBlend, SetCullFace, SetDepthTest,
872 * SetDither, SetPolygonOffsetFill, SetSampleAlphaToCoverage, SetSampleCoverage, SetScissorTest & SetStencilTest.
876 * This method replaces glEnable(GL_BLEND) and glDisable(GL_BLEND).
877 * @param[in] enable True if GL_BLEND should be enabled.
879 void SetBlend(bool enable)
881 // Avoid unecessary calls to glEnable/glDisable
882 if (enable != mBlendEnabled)
884 mBlendEnabled = enable;
888 LOG_GL("Enable GL_BLEND\n");
889 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_BLEND) );
893 LOG_GL("Disable GL_BLEND\n");
894 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_BLEND) );
900 * This method replaces glEnable(GL_DEPTH_TEST) and glDisable(GL_DEPTH_TEST).
901 * Note GL_DEPTH_TEST means enable the depth buffer for writing and or testing.
902 * glDepthMask is used to enable / disable writing to depth buffer.
903 * glDepthFunc us used to control if testing is enabled and how it is performed ( default GL_LESS)
905 * @param[in] enable True if GL_DEPTH_TEST should be enabled.
907 void EnableDepthBuffer( bool enable )
909 // Avoid unecessary calls to glEnable/glDisable
910 if( enable != mDepthBufferEnabled )
912 mDepthBufferEnabled = enable;
916 LOG_GL("Enable GL_DEPTH_TEST\n");
917 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_DEPTH_TEST) );
921 LOG_GL("Disable GL_DEPTH_TEST\n");
922 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_DEPTH_TEST) );
928 * This method replaces glEnable(GL_DITHER) and glDisable(GL_DITHER).
929 * @param[in] enable True if GL_DITHER should be enabled.
931 void SetDither(bool enable)
933 // Avoid unecessary calls to glEnable/glDisable
934 if (enable != mDitherEnabled)
936 mDitherEnabled = enable;
940 LOG_GL("Enable GL_DITHER\n");
941 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_DITHER) );
945 LOG_GL("Disable GL_DITHER\n");
946 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_DITHER) );
952 * This method replaces glEnable(GL_POLYGON_OFFSET_FILL) and glDisable(GL_POLYGON_OFFSET_FILL).
953 * @param[in] enable True if GL_POLYGON_OFFSET_FILL should be enabled.
955 void SetPolygonOffsetFill(bool enable)
957 // Avoid unecessary calls to glEnable/glDisable
958 if (enable != mPolygonOffsetFillEnabled)
960 mPolygonOffsetFillEnabled = enable;
964 LOG_GL("Enable GL_POLYGON_OFFSET_FILL\n");
965 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_POLYGON_OFFSET_FILL) );
969 LOG_GL("Disable GL_POLYGON_OFFSET_FILL\n");
970 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_POLYGON_OFFSET_FILL) );
976 * This method replaces glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE) and glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE).
977 * @param[in] enable True if GL_SAMPLE_ALPHA_TO_COVERAGE should be enabled.
979 void SetSampleAlphaToCoverage(bool enable)
981 // Avoid unecessary calls to glEnable/glDisable
982 if (enable != mSampleAlphaToCoverageEnabled)
984 mSampleAlphaToCoverageEnabled = enable;
988 LOG_GL("Enable GL_SAMPLE_ALPHA_TO_COVERAGE\n");
989 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SAMPLE_ALPHA_TO_COVERAGE) );
993 LOG_GL("Disable GL_SAMPLE_ALPHA_TO_COVERAGE\n");
994 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SAMPLE_ALPHA_TO_COVERAGE) );
1000 * This method replaces glEnable(GL_SAMPLE_COVERAGE) and glDisable(GL_SAMPLE_COVERAGE).
1001 * @param[in] enable True if GL_SAMPLE_COVERAGE should be enabled.
1003 void SetSampleCoverage(bool enable)
1005 // Avoid unecessary calls to glEnable/glDisable
1006 if (enable != mSampleCoverageEnabled)
1008 mSampleCoverageEnabled = enable;
1012 LOG_GL("Enable GL_SAMPLE_COVERAGE\n");
1013 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SAMPLE_COVERAGE) );
1017 LOG_GL("Disable GL_SAMPLE_COVERAGE\n");
1018 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SAMPLE_COVERAGE) );
1024 * This method replaces glEnable(GL_SCISSOR_TEST) and glDisable(GL_SCISSOR_TEST).
1025 * @param[in] enable True if GL_SCISSOR_TEST should be enabled.
1027 void SetScissorTest(bool enable)
1029 // Avoid unecessary calls to glEnable/glDisable
1030 if (enable != mScissorTestEnabled)
1032 mScissorTestEnabled = enable;
1036 LOG_GL("Enable GL_SCISSOR_TEST\n");
1037 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_SCISSOR_TEST) );
1041 LOG_GL("Disable GL_SCISSOR_TEST\n");
1042 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_SCISSOR_TEST) );
1048 * This method replaces glEnable(GL_STENCIL_TEST) and glDisable(GL_STENCIL_TEST).
1049 * Note GL_STENCIL_TEST means enable the stencil buffer for writing and or testing.
1050 * glStencilMask is used to control how bits are written to the stencil buffer.
1051 * glStencilFunc is used to control if testing is enabled and how it is performed ( default GL_ALWAYS )
1052 * @param[in] enable True if GL_STENCIL_TEST should be enabled.
1054 void EnableStencilBuffer(bool enable)
1056 // Avoid unecessary calls to glEnable/glDisable
1057 if( enable != mStencilBufferEnabled )
1059 mStencilBufferEnabled = enable;
1063 LOG_GL("Enable GL_STENCIL_TEST\n");
1064 CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_STENCIL_TEST) );
1068 LOG_GL("Disable GL_STENCIL_TEST\n");
1069 CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_STENCIL_TEST) );
1075 * Wrapper for OpenGL ES 3.0 glEndQuery()
1077 void EndQuery(GLenum target)
1079 LOG_GL("EndQuery %d\n", target);
1080 CHECK_GL( mGlAbstraction, mGlAbstraction.EndQuery(target) );
1084 * Wrapper for OpenGL ES 3.0 glEndTransformFeedback()
1086 void EndTransformFeedback()
1088 LOG_GL("EndTransformFeedback\n");
1089 CHECK_GL( mGlAbstraction, mGlAbstraction.EndTransformFeedback() );
1093 * Wrapper for OpenGL ES 2.0 glFinish()
1098 CHECK_GL( mGlAbstraction, mGlAbstraction.Finish() );
1102 * Wrapper for OpenGL ES 2.0 glFlush()
1107 CHECK_GL( mGlAbstraction, mGlAbstraction.Flush() );
1111 * Wrapper for OpenGL ES 2.0 glFramebufferRenderbuffer()
1113 void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1115 LOG_GL("FramebufferRenderbuffer %x %x %x %d\n", target, attachment, renderbuffertarget, renderbuffer);
1116 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) );
1120 * Wrapper for OpenGL ES 2.0 glFramebufferTexture2D()
1122 void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1124 LOG_GL("FramebufferTexture2D %x %x %x %d %d\n", target, attachment, textarget, texture, level);
1125 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferTexture2D(target, attachment, textarget, texture, level) );
1129 * Wrapper for OpenGL ES 3.0 glFramebufferTextureLayer()
1131 void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1133 LOG_GL("FramebufferTextureLayer %x %x %d %d %d\n", target, attachment, texture, level, layer);
1134 CHECK_GL( mGlAbstraction, mGlAbstraction.FramebufferTextureLayer(target, attachment, texture, level, layer) );
1138 * Wrapper for OpenGL ES 2.0 glFrontFace()
1140 void FrontFace(GLenum mode)
1142 LOG_GL("FrontFace %x\n", mode);
1143 CHECK_GL( mGlAbstraction, mGlAbstraction.FrontFace(mode) );
1147 * Wrapper for OpenGL ES 2.0 glGenBuffers()
1149 void GenBuffers(GLsizei n, GLuint* buffers)
1151 LOG_GL("GenBuffers %d\n", n, buffers);
1152 CHECK_GL( mGlAbstraction, mGlAbstraction.GenBuffers(n, buffers) );
1156 * Wrapper for OpenGL ES 2.0 glGenerateMipmap()
1158 void GenerateMipmap(GLenum target)
1160 LOG_GL("GenerateMipmap %x\n", target);
1161 CHECK_GL( mGlAbstraction, mGlAbstraction.GenerateMipmap(target) );
1165 * Wrapper for OpenGL ES 2.0 glGenFramebuffers()
1167 void GenFramebuffers(GLsizei n, GLuint* framebuffers)
1169 LOG_GL("GenFramebuffers %d %p\n", n, framebuffers);
1170 CHECK_GL( mGlAbstraction, mGlAbstraction.GenFramebuffers(n, framebuffers) );
1172 mFrameBufferStateCache.FrameBuffersCreated( n, framebuffers );
1176 * Wrapper for OpenGL ES 2.0 glGenRenderbuffers()
1178 void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
1180 LOG_GL("GenRenderbuffers %d %p\n", n, renderbuffers);
1181 CHECK_GL( mGlAbstraction, mGlAbstraction.GenRenderbuffers(n, renderbuffers) );
1185 * Wrapper for OpenGL ES 2.0 glGenTextures()
1187 void GenTextures(GLsizei n, GLuint* textures)
1189 LOG_GL("GenTextures %d %p\n", n, textures);
1190 CHECK_GL( mGlAbstraction, mGlAbstraction.GenTextures(n, textures) );
1194 * Wrapper for OpenGL ES 2.0 glGetBooleanv()
1196 void GetBooleanv(GLenum pname, GLboolean* params)
1198 LOG_GL("GetBooleanv %x\n", pname);
1199 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBooleanv(pname, params) );
1203 * Wrapper for OpenGL ES 2.0 glGetBufferParameteriv()
1205 void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
1207 LOG_GL("GetBufferParameteriv %x %x %p\n", target, pname, params);
1208 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBufferParameteriv(target, pname, params) );
1212 * Wrapper for OpenGL ES 3.0 glGetBufferPointer()
1214 void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
1216 LOG_GL("GetBufferPointerv %x %x %p\n", target, pname, params);
1217 CHECK_GL( mGlAbstraction, mGlAbstraction.GetBufferPointerv(target, pname, params) );
1221 * Wrapper for OpenGL ES 2.0 glGetError()
1223 GLenum GetError(void)
1225 // Not worth logging here
1226 return mGlAbstraction.GetError();
1230 * Wrapper for OpenGL ES 2.0 glGetFloatv()
1232 void GetFloatv(GLenum pname, GLfloat* params)
1234 LOG_GL("GetFloatv %x\n", pname);
1235 CHECK_GL( mGlAbstraction, mGlAbstraction.GetFloatv(pname, params) );
1239 * Wrapper for OpenGL ES 2.0 glGetFramebufferAttachmentParameteriv()
1241 void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1243 LOG_GL("GetFramebufferAttachmentParameteriv %x %x %x\n", target, attachment, pname);
1244 CHECK_GL( mGlAbstraction, mGlAbstraction.GetFramebufferAttachmentParameteriv(target, attachment, pname, params) );
1248 * Wrapper for OpenGL ES 2.0 glGetIntegerv()
1250 void GetIntegerv(GLenum pname, GLint* params)
1252 LOG_GL("GetIntegerv %x\n", pname);
1253 CHECK_GL( mGlAbstraction, mGlAbstraction.GetIntegerv(pname, params) );
1257 * Wrapper for OpenGL ES 3.0 glGetQueryiv()
1259 void GetQueryiv(GLenum target, GLenum pname, GLint* params)
1261 LOG_GL("GetQueryiv %x %x\n", target, pname);
1262 CHECK_GL( mGlAbstraction, mGlAbstraction.GetQueryiv(target, pname, params) );
1266 * Wrapper for OpenGL ES 3.0 glGetQueryObjectuiv()
1268 void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
1270 LOG_GL("GetQueryObjectuiv %u %x %p\n", id, pname, params);
1271 CHECK_GL( mGlAbstraction, mGlAbstraction.GetQueryObjectuiv(id, pname, params) );
1275 * Wrapper for OpenGL ES 2.0 glGetRenderbufferParameteriv()
1277 void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1279 LOG_GL("GetRenderbufferParameteriv %x %x\n", target, pname);
1280 CHECK_GL( mGlAbstraction, mGlAbstraction.GetRenderbufferParameteriv(target, pname, params) );
1284 * Wrapper for OpenGL ES 2.0 glGetString()
1286 const GLubyte* GetString(GLenum name)
1288 LOG_GL("GetString %x\n", name);
1289 const GLubyte* str = CHECK_GL( mGlAbstraction, mGlAbstraction.GetString(name) );
1294 * Wrapper for OpenGL ES 2.0 glGetTexParameterfv()
1296 void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
1298 LOG_GL("GetTexParameterfv %x %x\n", target, pname);
1299 CHECK_GL( mGlAbstraction, mGlAbstraction.GetTexParameterfv(target, pname, params) );
1303 * Wrapper for OpenGL ES 2.0 glGetTexParameteriv()
1305 void GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
1307 LOG_GL("GetTexParameteriv %x %x\n", target, pname);
1308 CHECK_GL( mGlAbstraction, mGlAbstraction.GetTexParameteriv(target, pname, params) );
1312 * Wrapper for OpenGL ES 2.0 glHint()
1314 void Hint(GLenum target, GLenum mode)
1316 LOG_GL("Hint %x %x\n", target, mode);
1317 CHECK_GL( mGlAbstraction, mGlAbstraction.Hint(target, mode) );
1321 * Wrapper for OpenGL ES 2.0 glIsBuffer()
1323 GLboolean IsBuffer(GLuint buffer)
1325 LOG_GL("IsBuffer %d\n", buffer);
1326 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsBuffer(buffer) );
1331 * Wrapper for OpenGL ES 2.0 glIsEnabled()
1333 GLboolean IsEnabled(GLenum cap)
1335 LOG_GL("IsEnabled %x\n", cap);
1336 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsEnabled(cap) );
1341 * Wrapper for OpenGL ES 2.0 glIsFramebuffer()
1343 GLboolean IsFramebuffer(GLuint framebuffer)
1345 LOG_GL("IsFramebuffer %d\n", framebuffer);
1346 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsFramebuffer(framebuffer) );
1351 * Wrapper for OpenGL ES 3.0 glIsQuery()
1353 GLboolean IsQuery(GLuint id)
1355 LOG_GL("IsQuery %u\n", id);
1356 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsQuery(id) );
1361 * Wrapper for OpenGL ES 2.0 glIsRenderbuffer()
1363 GLboolean IsRenderbuffer(GLuint renderbuffer)
1365 LOG_GL("IsRenderbuffer %d\n", renderbuffer);
1366 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsRenderbuffer(renderbuffer) );
1371 * Wrapper for OpenGL ES 2.0 glIsTexture()
1373 GLboolean IsTexture(GLuint texture)
1375 LOG_GL("IsTexture %d\n", texture);
1376 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsTexture(texture) );
1381 * Wrapper for OpenGL ES 3.0 glIsTransformFeedback()
1383 GLboolean IsTransformFeedback(GLuint id)
1385 LOG_GL("IsTransformFeedback %u\n", id);
1386 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.IsTransformFeedback(id) );
1391 * Wrapper for OpenGL ES 2.0 glLineWidth()
1393 void LineWidth(GLfloat width)
1395 LOG_GL("LineWidth %f\n", width);
1396 CHECK_GL( mGlAbstraction, mGlAbstraction.LineWidth(width) );
1400 * Wrapper for OpenGL ES 3.0 glPauseTransformFeedback()
1402 void PauseTransformFeedback()
1404 LOG_GL("PauseTransformFeedback\n");
1405 CHECK_GL( mGlAbstraction, mGlAbstraction.PauseTransformFeedback() );
1409 * Wrapper for OpenGL ES 2.0 glPixelStorei()
1411 void PixelStorei(GLenum pname, GLint param)
1413 LOG_GL("PixelStorei %x %d\n", pname, param);
1414 CHECK_GL( mGlAbstraction, mGlAbstraction.PixelStorei(pname, param) );
1418 * Wrapper for OpenGL ES 2.0 glPolygonOffset()
1420 void PolygonOffset(GLfloat factor, GLfloat units)
1422 LOG_GL("PolygonOffset %f %f\n", factor, units);
1423 CHECK_GL( mGlAbstraction, mGlAbstraction.PolygonOffset(factor, units) );
1427 * Wrapper for OpenGL ES 2.0 glReadPixels()
1429 void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
1431 LOG_GL("ReadPixels %d %d %d %d %x %x\n", x, y, width, height, format, type);
1432 CHECK_GL( mGlAbstraction, mGlAbstraction.ReadPixels(x, y, width, height, format, type, pixels) );
1436 * Wrapper for OpenGL ES 2.0 glRenderbufferStorage()
1438 void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1440 LOG_GL("RenderbufferStorage %x %x %d %d\n", target, internalformat, width, height);
1441 CHECK_GL( mGlAbstraction, mGlAbstraction.RenderbufferStorage(target, internalformat, width, height) );
1445 * Wrapper for OpenGL ES 3.0 glRenderbufferStorageMultisample()
1447 void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1449 LOG_GL("RenderbufferStorageMultisample %x %u %x %d %d\n", target, samples, internalformat, width, height);
1450 CHECK_GL( mGlAbstraction, mGlAbstraction.RenderbufferStorageMultisample(target, samples, internalformat, width, height) );
1454 * Wrapper for OpenGL ES 3.0 glResumeTransformFeedback()
1456 void ResumeTransformFeedback()
1458 LOG_GL("ResumeTransformFeedback\n");
1459 CHECK_GL( mGlAbstraction, mGlAbstraction.ResumeTransformFeedback() );
1463 * Wrapper for OpenGL ES 2.0 glSampleCoverage()
1465 void SampleCoverage(GLclampf value, GLboolean invert)
1467 LOG_GL("SampleCoverage %f %s\n", value, invert ? "True" : "False");
1468 CHECK_GL( mGlAbstraction, mGlAbstraction.SampleCoverage(value, invert) );
1472 * Wrapper for OpenGL ES 2.0 glScissor()
1474 void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
1476 LOG_GL("Scissor %d %d %d %d\n", x, y, width, height);
1477 CHECK_GL( mGlAbstraction, mGlAbstraction.Scissor(x, y, width, height) );
1481 * Wrapper for OpenGL ES 2.0 glStencilFunc()
1483 void StencilFunc(GLenum func, GLint ref, GLuint mask)
1487 LOG_GL("StencilFunc %x %d %d\n", func, ref, mask);
1488 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFunc(func, ref, mask) );
1492 * Wrapper for OpenGL ES 2.0 glStencilFuncSeparate()
1494 void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1496 LOG_GL("StencilFuncSeparate %x %x %d %d\n", face, func, ref, mask);
1497 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFuncSeparate(face, func, ref, mask) );
1501 * Wrapper for OpenGL ES 2.0 glStencilMask()
1503 void StencilMask(GLuint mask)
1505 if( mask != mStencilMask )
1507 mStencilMask = mask;
1509 LOG_GL("StencilMask %d\n", mask);
1510 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilMask(mask) );
1515 * Wrapper for OpenGL ES 2.0 glStencilMaskSeparate()
1517 void StencilMaskSeparate(GLenum face, GLuint mask)
1519 LOG_GL("StencilMaskSeparate %x %d\n", face, mask);
1520 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilMaskSeparate(face, mask) );
1524 * Wrapper for OpenGL ES 2.0 glStencilOp()
1526 void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1528 LOG_GL("StencilOp %x %x %x\n", fail, zfail, zpass);
1529 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOp(fail, zfail, zpass) );
1533 * Wrapper for OpenGL ES 2.0 glStencilOpSeparate()
1535 void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1537 LOG_GL("StencilOpSeparate %x %x %x %x\n", face, fail, zfail, zpass);
1538 CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOpSeparate(face, fail, zfail, zpass) );
1542 * Wrapper for OpenGL ES 2.0 glTexImage2D()
1544 void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
1545 GLint border, GLenum format, GLenum type, const void* pixels)
1547 LOG_GL("TexImage2D %x %d %d %dx%d %d %x %x %p\n", target, level, internalformat, width, height, border, format, type, pixels);
1548 CHECK_GL( mGlAbstraction, mGlAbstraction.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels) );
1552 * Wrapper for OpenGL ES 3.0 glTexImage3D()
1554 void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth,
1555 GLint border, GLenum format, GLenum type, const void* pixels)
1557 LOG_GL("TexImage3D %x %d %d %dx%dx%d %d %x %x %p\n", target, level, internalformat, width, height, depth, border, format, type, pixels);
1558 CHECK_GL( mGlAbstraction, mGlAbstraction.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels) );
1562 * Wrapper for OpenGL ES 2.0 glTexParameterf()
1564 void TexParameterf(GLenum target, GLenum pname, GLfloat param)
1566 LOG_GL("TexParameterf %x %x %f\n", target, pname, param);
1567 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameterf(target, pname, param) );
1571 * Wrapper for OpenGL ES 2.0 glTexParameterfv()
1573 void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
1575 LOG_GL("TexParameterfv %x %x\n", target, pname);
1576 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameterfv(target, pname, params) );
1580 * Wrapper for OpenGL ES 2.0 glTexParameteri()
1582 void TexParameteri(GLenum target, GLenum pname, GLint param)
1584 LOG_GL("TexParameteri %x %x %d\n", target, pname, param);
1585 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameteri(target, pname, param) );
1589 * Wrapper for OpenGL ES 2.0 glTexParameteriv()
1591 void TexParameteriv(GLenum target, GLenum pname, const GLint* params)
1593 LOG_GL("TexParameteriv %x %x\n", target, pname);
1594 CHECK_GL( mGlAbstraction, mGlAbstraction.TexParameteriv(target, pname, params) );
1598 * Wrapper for OpenGL ES 2.0 glTexSubImage2D()
1600 void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
1601 GLenum format, GLenum type, const void* pixels)
1603 LOG_GL("TexSubImage2D %x %d %d %d %d %d %x %x %p\n", target, level, xoffset, yoffset, width, height, format, type, pixels);
1604 CHECK_GL( mGlAbstraction, mGlAbstraction.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) );
1608 * Wrapper for OpenGL ES 3.0 glTexSubImage3D()
1610 void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
1611 GLsizei width, GLsizei height, GLsizei depth,
1612 GLenum format, GLenum type, const void* pixels)
1614 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);
1615 CHECK_GL( mGlAbstraction, mGlAbstraction.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) );
1619 * Wrapper for OpenGL ES 3.0 glUnmapBubffer()
1621 GLboolean UnmapBuffer(GLenum target)
1623 LOG_GL("UnmapBuffer %x \n", target);
1624 GLboolean val = CHECK_GL( mGlAbstraction, mGlAbstraction.UnmapBuffer(target) );
1628 * Wrapper for OpenGL ES 2.0 glViewport()
1630 void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
1632 // check if its same as already set
1633 Rect<int> newViewport( x, y, width, height );
1634 if( mViewPort != newViewport )
1637 LOG_GL("Viewport %d %d %d %d\n", x, y, width, height);
1638 CHECK_GL( mGlAbstraction, mGlAbstraction.Viewport(x, y, width, height) );
1639 mViewPort = newViewport; // remember new one
1644 * Get the implementation defined MAX_TEXTURE_SIZE. This values is cached when the context is created
1645 * @return The implementation defined MAX_TEXTURE_SIZE
1647 GLint CachedMaxTextureSize() const
1649 return mMaxTextureSize;
1653 * Get the current viewport.
1654 * @return Viewport rectangle.
1656 const Rect< int >& GetViewport();
1658 private: // Implementation
1661 * @return true if next draw operation will write to depth buffer
1663 bool DepthBufferWriteEnabled() const
1665 return mDepthBufferEnabled && mDepthMaskEnabled;
1669 * @return true if next draw operation will write to stencil buffer
1671 bool StencilBufferWriteEnabled() const
1673 return mStencilBufferEnabled && ( mStencilMask > 0 );
1677 * Flushes vertex attribute location changes to the driver
1679 void FlushVertexAttributeLocations();
1682 * Either enables or disables a vertex attribute location in the cache
1683 * The cahnges won't take affect until FlushVertexAttributeLocations is called
1684 * @param location attribute location
1685 * @param state attribute state
1687 void SetVertexAttributeLocation(unsigned int location, bool state);
1690 * Sets the initial GL state.
1692 void InitializeGlState();
1696 Integration::GlAbstraction& mGlAbstraction;
1698 bool mGlContextCreated; ///< True if the OpenGL context has been created
1700 // glEnable/glDisable states
1702 GLuint mStencilMask;
1704 bool mDepthBufferEnabled;
1705 bool mDepthMaskEnabled;
1706 bool mDitherEnabled;
1707 bool mPolygonOffsetFillEnabled;
1708 bool mSampleAlphaToCoverageEnabled;
1709 bool mSampleCoverageEnabled;
1710 bool mScissorTestEnabled;
1711 bool mStencilBufferEnabled;
1712 bool mClearColorSet;
1713 bool mUsingDefaultBlendColor;
1715 // glBindBuffer() state
1716 GLuint mBoundArrayBufferId; ///< The ID passed to glBindBuffer(GL_ARRAY_BUFFER)
1717 GLuint mBoundElementArrayBufferId; ///< The ID passed to glBindBuffer(GL_ELEMENT_ARRAY_BUFFER)
1718 GLuint mBoundTransformFeedbackBufferId; ///< The ID passed to glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER)
1720 // glBindTexture() state
1721 TextureUnit mActiveTextureUnit;
1722 GLuint mBound2dTextureId[ MAX_TEXTURE_UNITS ]; ///< The ID passed to glBindTexture(GL_TEXTURE_2D)
1724 // glBlendColor() state
1725 Vector4 mBlendColor; ///< Blend color
1727 // glBlendFuncSeparate() state
1728 GLenum mBlendFuncSeparateSrcRGB; ///< The srcRGB parameter passed to glBlendFuncSeparate()
1729 GLenum mBlendFuncSeparateDstRGB; ///< The dstRGB parameter passed to glBlendFuncSeparate()
1730 GLenum mBlendFuncSeparateSrcAlpha; ///< The srcAlpha parameter passed to glBlendFuncSeparate()
1731 GLenum mBlendFuncSeparateDstAlpha; ///< The dstAlpha parameter passed to glBlendFuncSeparate()
1733 // glBlendEquationSeparate state
1734 GLenum mBlendEquationSeparateModeRGB; ///< Controls RGB blend mode
1735 GLenum mBlendEquationSeparateModeAlpha; ///< Controls Alpha blend mode
1737 GLenum mDepthFunction; ///The depth function
1739 GLint mMaxTextureSize; ///< return value from GetIntegerv(GL_MAX_TEXTURE_SIZE)
1740 Vector4 mClearColor; ///< clear color
1742 // Face culling mode
1743 Dali::FaceCullingMode::Type mCullFaceMode;
1745 // cached viewport size
1746 Rect< int > mViewPort;
1748 // Vertex Attribute Buffer enable caching
1749 bool mVertexAttributeCachedState[ MAX_ATTRIBUTE_CACHE_SIZE ]; ///< Value cache for Enable Vertex Attribute
1750 bool mVertexAttributeCurrentState[ MAX_ATTRIBUTE_CACHE_SIZE ]; ///< Current state on the driver for Enable Vertex Attribute
1752 FrameBufferStateCache mFrameBufferStateCache; ///< frame buffer state cache
1755 } // namespace Internal
1759 #endif // __DALI_INTERNAL_CONTEXT_H__