-#ifndef __DALI_INTERNAL_CONTEXT_H__
-#define __DALI_INTERNAL_CONTEXT_H__
+#ifndef DALI_INTERNAL_CONTEXT_H
+#define DALI_INTERNAL_CONTEXT_H
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/actors/renderable-actor.h>
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/math/rect.h>
#include <dali/public-api/math/vector4.h>
+#include <dali/public-api/rendering/renderer.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/integration-api/debug.h>
#include <dali/integration-api/gl-abstraction.h>
#include <dali/integration-api/gl-defines.h>
static const unsigned int MAX_TEXTURE_UNITS = 8; // for GLES 2.0 8 is guaranteed, which is more than DALi uses anyways
/**
- * Creates the Dali Context object.
+ * Creates the Dali Context object for surface rendering only.
* This method does not create an OpenGL context i.e. that is done from outside dali-core.
* @pre Context has not been created.
* @exception Context already created.
Context( Integration::GlAbstraction& glAbstraction );
/**
+ * Creates the Dali Context object for texture (and surface rendering if required).
+ * This method does not create an OpenGL context i.e. that is done from outside dali-core.
+ * @pre Context has not been created.
+ * @exception Context already created.
+ * @param glAbstraction the gl abstraction.
+ * @param contexts The list of scene contexts (for surface rendering)
+ */
+ Context( Integration::GlAbstraction& glAbstraction, std::vector< Context* >* contexts );
+
+ /**
* Destructor
*/
~Context();
*/
void PrintGlString(const char* stringName, GLenum stringId)
{
- DALI_LOG_INFO(Debug::Filter::gRender, Debug::General, "GL %s = %s\n", stringName, (const char *)GetString( stringId ) );
+ DALI_LOG_INFO(Debug::Filter::gRender, Debug::General, "GL %s = %s\n", stringName, reinterpret_cast< const char * >( GetString( stringId ) ) );
+ }
+
+ void ResetBufferCache()
+ {
+ // reset the cached buffer id's
+ // fixes problem where some drivers will a generate a buffer with the
+ // same id, as the last deleted buffer id.
+ mBoundArrayBufferId = 0;
+ mBoundElementArrayBufferId = 0;
+ mBoundTransformFeedbackBufferId = 0;
+ }
+
+ void ResetTextureCache()
+ {
+ // reset the cached texture id's in case the driver re-uses them
+ // when creating new textures
+ for( unsigned int i=0; i < MAX_TEXTURE_UNITS; ++i )
+ {
+ mBoundTextureId[ i ] = 0;
+ }
}
/****************************************************************************************
****************************************************************************************/
/**
+ * Wrapper for IsSurfacelessContextSupported of Dali::Integration::GlAbstraction
+ */
+ bool IsSurfacelessContextSupported() const
+ {
+ return mGlAbstraction.IsSurfacelessContextSupported();
+ }
+
+ /**
+ * Wrapper for TextureRequiresConverting of Dali::Integration::GlAbstraction
+ */
+ bool TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const
+ {
+ return mGlAbstraction.TextureRequiresConverting( imageGlFormat, textureGlFormat, isSubImage );
+ }
+
+ /**
* Wrapper for OpenGL ES 2.0 glActiveTexture()
*/
void ActiveTexture( TextureUnit textureUnit )
* @param textureunit to bind to
* @param texture to bind
*/
- void BindTextureForUnit( TextureUnit textureunit, GLuint texture )
+ void BindTextureForUnit( TextureUnit textureunit, int target, GLuint texture )
{
- if( mBound2dTextureId[ textureunit ] != texture )
+ if( mBoundTextureId[ textureunit ] != texture )
{
ActiveTexture( textureunit );
- Bind2dTexture( texture );
+ BindTexture( target, texture );
}
}
/**
- * Wrapper for OpenGL ES 2.0 glBindTexture(GL_TEXTURE_2D)
+ * Wrapper for OpenGL ES 2.0 glBindTexture( target )
*/
- void Bind2dTexture( GLuint texture )
+ void BindTexture( int target, GLuint texture )
{
- if (mBound2dTextureId[ mActiveTextureUnit ] != texture)
+ if (mBoundTextureId[ mActiveTextureUnit ] != texture)
{
- mBound2dTextureId[ mActiveTextureUnit ] = texture;
+ mBoundTextureId[ mActiveTextureUnit ] = texture;
- LOG_GL("BindTexture GL_TEXTURE_2D %d\n", texture);
- CHECK_GL( mGlAbstraction, mGlAbstraction.BindTexture(GL_TEXTURE_2D, texture) );
+ LOG_GL("BindTexture target(%d) %d\n", target, texture);
+ CHECK_GL( mGlAbstraction, mGlAbstraction.BindTexture(target, texture) );
}
}
* enables GL_CULL_FACE if in any of the face culling modes
* otherwise disables GL_CULL_FACE
*/
- void CullFace(CullFaceMode mode)
+ void CullFace( Dali::FaceCullingMode::Type mode )
{
// Avoid unnecessary calls to gl
if(mCullFaceMode != mode)
mCullFaceMode = mode;
switch(mode)
{
- case CullNone:
+ case Dali::FaceCullingMode::NONE:
{
LOG_GL("Disable GL_CULL_FACE\n");
CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_CULL_FACE) );
break;
}
- case CullFront:
+ case Dali::FaceCullingMode::FRONT:
{
LOG_GL("Enable GL_CULL_FACE\n");
CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
break;
}
- case CullBack:
+ case Dali::FaceCullingMode::BACK:
{
LOG_GL("Enable GL_CULL_FACE\n");
CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
break;
}
- case CullFrontAndBack:
+ case Dali::FaceCullingMode::FRONT_AND_BACK:
{
LOG_GL("Enable GL_CULL_FACE\n");
CHECK_GL( mGlAbstraction, mGlAbstraction.Enable(GL_CULL_FACE) );
*/
void DeleteBuffers(GLsizei n, const GLuint* buffers)
{
- // @todo: this is to prevent mesh destructor from doing GL calls when DALi core is being deleted
- // can be taken out once render manages either knows about meshes or gpubuffers and can tell them directly that context is lost
if( this->IsGlContextCreated() )
{
LOG_GL("DeleteBuffers %d %p\n", n, buffers);
CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteBuffers(n, buffers) );
}
- // reset the cached buffer id's
- // fixes problem where some drivers will a generate a buffer with the
- // same id, as the last deleted buffer id.
- mBoundArrayBufferId = 0;
- mBoundElementArrayBufferId = 0;
- mBoundTransformFeedbackBufferId = 0;
+
+ ResetBufferCache();
+
+ // Need to reset the buffer cache in the surface contexts
+ // This will only be executed by the surfaceless context when there are contexts for surface rendering
+ if ( mSceneContexts )
+ {
+ for ( auto&& context : *mSceneContexts )
+ {
+ if ( context )
+ {
+ context->ResetBufferCache();
+ }
+ }
+ }
}
/**
LOG_GL("DeleteTextures %d %p\n", n, textures);
CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteTextures(n, textures) );
- // reset the cached texture id's incase the driver re-uses them
- // when creating new textures
- for( unsigned int i=0; i < MAX_TEXTURE_UNITS; ++i )
+ ResetTextureCache();
+
+ // Need to reset the texture cache in the scene contexts
+ // This will only be executed by the surfaceless context when there are contexts for surface rendering
+ if ( mSceneContexts )
{
- mBound2dTextureId[ i ] = 0;
+ for ( auto&& context : *mSceneContexts )
+ {
+ if ( context )
+ {
+ context->ResetTextureCache();
+ }
+ }
}
}
*/
void DepthFunc(GLenum func)
{
- LOG_GL("DepthFunc %x\n", func);
- CHECK_GL( mGlAbstraction, mGlAbstraction.DepthFunc(func) );
+ if( func != mDepthFunction )
+ {
+ mDepthFunction = func;
+ LOG_GL("DepthFunc %x\n", func);
+ CHECK_GL( mGlAbstraction, mGlAbstraction.DepthFunc(func) );
+ }
}
/**
*/
void DepthMask(GLboolean flag)
{
+ bool booleanFlag = flag != GL_FALSE;
// only change state if needed
- if( flag != mDepthMaskEnabled )
+ if( booleanFlag != mDepthMaskEnabled )
{
- mDepthMaskEnabled = flag;
- LOG_GL("DepthMask %s\n", flag ? "True" : "False");
+ mDepthMaskEnabled = booleanFlag;
+ LOG_GL("DepthMask %s\n", booleanFlag ? "True" : "False");
CHECK_GL( mGlAbstraction, mGlAbstraction.DepthMask( mDepthMaskEnabled ) );
}
}
*/
void StencilFunc(GLenum func, GLint ref, GLuint mask)
{
+ if( ( func != mStencilFunc ) || ( ref != mStencilFuncRef ) || ( mask != mStencilFuncMask ) )
+ {
+ mStencilFunc = func;
+ mStencilFuncRef = ref;
+ mStencilFuncMask = mask;
-
- LOG_GL("StencilFunc %x %d %d\n", func, ref, mask);
- CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFunc(func, ref, mask) );
+ LOG_GL("StencilFunc %x %d %d\n", func, ref, mask);
+ CHECK_GL( mGlAbstraction, mGlAbstraction.StencilFunc(func, ref, mask) );
+ }
}
/**
*/
void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
- LOG_GL("StencilOp %x %x %x\n", fail, zfail, zpass);
- CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOp(fail, zfail, zpass) );
+ if( ( fail != mStencilOpFail ) || ( zfail != mStencilOpDepthFail ) || ( zpass != mStencilOpDepthPass ) )
+ {
+ mStencilOpFail = fail;
+ mStencilOpDepthFail = zfail;
+ mStencilOpDepthPass = zpass;
+
+ LOG_GL("StencilOp %x %x %x\n", fail, zfail, zpass);
+ CHECK_GL( mGlAbstraction, mGlAbstraction.StencilOp(fail, zfail, zpass) );
+ }
}
/**
{
// check if its same as already set
Rect<int> newViewport( x, y, width, height );
- if( mViewPort != newViewport )
+
+ // Temporarily disable the viewport caching, as the implementation of GLES driver in Tizen platform
+ // share a global viewport between multiple contexts, therefore glViewport has to be called every
+ // time after glBindFramebuffer regardless of the same vewport size in the same context.
+// if( mViewPort != newViewport )
{
// set new one
LOG_GL("Viewport %d %d %d %d\n", x, y, width, height);
*/
const Rect< int >& GetViewport();
- /**
- * Set the frame count of render thread
- */
- inline void SetFrameCount(unsigned int frameCount)
- {
- mFrameCount = frameCount;
- }
-
- /**
- * Get the frame count
- */
- inline unsigned int GetFrameCount()
- {
- return mFrameCount;
- }
-
- /**
- * Increment the count of culled renderers
- */
- inline void IncrementCulledCount()
- {
- mCulledCount++;
- }
-
- /**
- * Clear the count of culled renderers
- */
- inline void ClearCulledCount()
- {
- mCulledCount = 0;
- }
-
- /**
- * Get the count of culled renderers in this frame
- */
- inline unsigned int GetCulledCount()
- {
- return mCulledCount;
- }
-
- /**
- * Increment the count of culled renderers
- */
- inline void IncrementRendererCount()
- {
- mRendererCount++;
- }
-
- /**
- * Clear the count of image renderers
- */
- inline void ClearRendererCount()
- {
- mRendererCount = 0;
- }
-
- /**
- * Get the count of image renderers in this frame
- */
- inline unsigned int GetRendererCount()
- {
- return mRendererCount;
- }
-
private: // Implementation
/**
void FlushVertexAttributeLocations();
/**
- * Reset the cached internal vertex attribute state
- */
- void ResetVertexAttributeState();
-
- /**
* Either enables or disables a vertex attribute location in the cache
* The cahnges won't take affect until FlushVertexAttributeLocations is called
* @param location attribute location
/**
* Sets the initial GL state.
*/
- void ResetGlState();
+ void InitializeGlState();
private: // Data
// glBindTexture() state
TextureUnit mActiveTextureUnit;
- GLuint mBound2dTextureId[ MAX_TEXTURE_UNITS ]; ///< The ID passed to glBindTexture(GL_TEXTURE_2D)
+ GLuint mBoundTextureId[ MAX_TEXTURE_UNITS ]; ///< The ID passed to glBindTexture()
// glBlendColor() state
Vector4 mBlendColor; ///< Blend color
GLenum mBlendEquationSeparateModeRGB; ///< Controls RGB blend mode
GLenum mBlendEquationSeparateModeAlpha; ///< Controls Alpha blend mode
+ // glStencilFunc() and glStencilOp() state.
+ GLenum mStencilFunc;
+ GLint mStencilFuncRef;
+ GLuint mStencilFuncMask;
+ GLenum mStencilOpFail;
+ GLenum mStencilOpDepthFail;
+ GLenum mStencilOpDepthPass;
+
+ GLenum mDepthFunction; ///The depth function
+
GLint mMaxTextureSize; ///< return value from GetIntegerv(GL_MAX_TEXTURE_SIZE)
Vector4 mClearColor; ///< clear color
// Face culling mode
- CullFaceMode mCullFaceMode;
+ Dali::FaceCullingMode::Type mCullFaceMode;
// cached viewport size
Rect< int > mViewPort;
bool mVertexAttributeCachedState[ MAX_ATTRIBUTE_CACHE_SIZE ]; ///< Value cache for Enable Vertex Attribute
bool mVertexAttributeCurrentState[ MAX_ATTRIBUTE_CACHE_SIZE ]; ///< Current state on the driver for Enable Vertex Attribute
- unsigned int mFrameCount; ///< Number of render frames
- unsigned int mCulledCount; ///< Number of culled renderers per frame
- unsigned int mRendererCount; ///< Number of image renderers per frame
FrameBufferStateCache mFrameBufferStateCache; ///< frame buffer state cache
+
+ std::vector< Context* >* mSceneContexts; ///< The pointer of the container of contexts for surface rendering
};
} // namespace Internal
} // namespace Dali
-#endif // __DALI_INTERNAL_CONTEXT_H__
+#endif // DALI_INTERNAL_CONTEXT_H
projects / platform / core / uifw / dali-core.git / blobdiff