EglInterface* eglInterface = &eglGraphics->GetEglInterface();
Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( *eglInterface );
+
// Try to use OpenGL es 3.0
// ChooseConfig returns false here when the device only support gles 2.0.
// Because eglChooseConfig with gles 3.0 setting fails when the device only support gles 2.0 and Our default setting is gles 3.0.
- if( eglImpl.ChooseConfig( true, COLOR_DEPTH_32 ) )
+ if( !eglImpl.ChooseConfig( true, COLOR_DEPTH_32 ) )
+ {
+ // Retry to use OpenGL es 2.0
+ eglGraphics->SetGlesVersion( 20 );
+ eglImpl.ChooseConfig( true, COLOR_DEPTH_32 );
+ }
+
+ // Check whether surfaceless context is supported
+ bool isSurfacelessContextSupported = eglImpl.IsSurfacelessContextSupported();
+ eglGraphics->SetIsSurfacelessContextSupported( isSurfacelessContextSupported );
+
+ if ( isSurfacelessContextSupported )
{
// Create a surfaceless OpenGL context for shared resources
eglImpl.CreateContext();
eglImpl.MakeContextCurrent( EGL_NO_SURFACE, eglImpl.GetContext() );
}
- else // Retry to use OpenGL es 2.0
+ else
{
- eglGraphics->SetGlesVersion( 20 );
currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
if( currentSurface )
{
}
}
- if( eglImpl.GetGlesVersion() >= 30 )
+ if( eglImpl.IsSurfacelessContextSupported() )
{
// Make the shared surfaceless context as current before rendering
eglImpl.MakeContextCurrent( EGL_NO_SURFACE, eglImpl.GetContext() );
mGLES->SetGlesVersion( glesVersion );
}
+void EglGraphics::SetIsSurfacelessContextSupported( const bool isSupported )
+{
+ mGLES->SetIsSurfacelessContextSupported( isSupported );
+}
+
void EglGraphics::Initialize( EnvironmentOptions* environmentOptions )
{
if( environmentOptions->GetGlesCallTime() > 0 )
void SetGlesVersion( const int32_t glesVersion );
/**
+ * Set whether the surfaceless context is supported
+ * @param[in] isSupported Whether the surfaceless context is supported
+ */
+ void SetIsSurfacelessContextSupported( const bool isSupported );
+
+ /**
* Gets the GL abstraction
* @return The GL abstraction
*/
#include <dali/internal/graphics/gles/egl-implementation.h>
// EXTERNAL INCLUDES
+#include <sstream>
#include <dali/integration-api/debug.h>
#include <dali/public-api/common/dali-vector.h>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
+namespace
+{
+ const std::string EGL_KHR_SURFACELESS_CONTEXT = "EGL_KHR_surfaceless_context";
+}
+
namespace Dali
{
mIsOwnSurface( true ),
mIsWindow( true ),
mDepthBufferRequired( depthBufferRequired == Integration::DepthBufferAvailable::TRUE ),
- mStencilBufferRequired( stencilBufferRequired == Integration::StencilBufferAvailable::TRUE )
+ mStencilBufferRequired( stencilBufferRequired == Integration::StencilBufferAvailable::TRUE ),
+ mIsSurfacelessContextSupported( false )
{
}
mIsOwnSurface = isOwnSurface;
}
+ // Query EGL extensions to check whether surfaceless context is supported
+ const char* const extensionStr = eglQueryString( mEglDisplay, EGL_EXTENSIONS );
+ std::istringstream stream(extensionStr);
+ std::string currentExtension;
+ while ( std::getline( stream, currentExtension, ' ' ) )
+ {
+ if ( currentExtension == EGL_KHR_SURFACELESS_CONTEXT )
+ {
+ mIsSurfacelessContextSupported = true;
+ break;
+ }
+ }
+
// We want to display this information all the time, so use the LogMessage directly
Integration::Log::LogMessage(Integration::Log::DebugInfo, "EGL Information\n"
" Vendor: %s\n"
eglQueryString( mEglDisplay, EGL_VENDOR ),
eglQueryString( mEglDisplay, EGL_VERSION ),
eglQueryString( mEglDisplay, EGL_CLIENT_APIS ),
- eglQueryString( mEglDisplay, EGL_EXTENSIONS ));
+ extensionStr);
return mGlesInitialized;
}
return mGlesVersion;
}
+bool EglImplementation::IsSurfacelessContextSupported() const
+{
+ return mIsSurfacelessContextSupported;
+}
+
} // namespace Adaptor
} // namespace Internal
*/
int32_t GetGlesVersion() const;
+ /**
+ * Returns whether the surfaceless context is supported
+ * @return true if the surfaceless context is supported
+ */
+ bool IsSurfacelessContextSupported() const;
+
private:
Vector<EGLint> mContextAttribs;
bool mIsWindow;
bool mDepthBufferRequired;
bool mStencilBufferRequired;
+ bool mIsSurfacelessContextSupported;
};
} // namespace Adaptor
public:
GlImplementation()
- : mGlesVersion( 30 )
+ : mGlesVersion( 30 ),
+ mIsSurfacelessContextSupported( false )
{
mImpl.reset( new Gles3Implementation() );
}
}
}
+ void SetIsSurfacelessContextSupported( const bool isSupported )
+ {
+ mIsSurfacelessContextSupported = isSupported;
+ }
+
bool IsSurfacelessContextSupported() const
{
- return ( mGlesVersion >= 30 );
+ return mIsSurfacelessContextSupported;
}
bool TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const
private:
int32_t mGlesVersion;
+ bool mIsSurfacelessContextSupported;
std::unique_ptr<GlesAbstraction> mImpl;
};