--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hostsupport/hostopengles11/src/EGLInterface.cpp Wed Oct 06 17:59:01 2010 +0100
@@ -0,0 +1,426 @@
+/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ *
+ */
+
+#include "EGLInterface.h"
+#include <new>
+#include "glesInternal.h"
+#include "GLESContext.h"
+#include "SurfaceDescriptor.h"
+#include "GLESTexture.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace
+{
+EGLtoGLESInterface g_EGLtoGLESInterface;
+}
+
+GLES_API_CALL IEGLtoGLESInterface* getGLESInterface(void)
+{
+ return &g_EGLtoGLESInterface;
+}
+
+void glesReleaseTexImage(void* surface, int name, int level)
+{
+ EGLtoGLESInterface::GetEGLInterface()->ReleaseTexImage(surface, name, level);
+}
+
+EGLtoGLESInterface::EGLtoGLESInterface() :
+ m_egl(NULL)
+{
+}
+
+void EGLtoGLESInterface::SetEGLInterface( IGLEStoEGLInterface* egl )
+{
+ m_egl = egl;
+}
+
+void* EGLtoGLESInterface::CreateContext(void* nativeContext)
+{
+ GLESContext* newContext = NULL;
+
+ newContext = GLES_NEW GLESContext(nativeContext);
+ if(newContext == NULL)
+ {
+ return NULL;
+ }
+ m_contexts.insert(newContext);
+ return newContext;
+}
+
+bool EGLtoGLESInterface::ReleaseContext(void* context)
+{
+ GLES_ASSERT(context != NULL);
+
+ GLESContext* ctx = static_cast<GLESContext*>(context);
+ if(m_contexts.find(ctx) == m_contexts.end())
+ {
+ return false;
+ }
+
+ delete ctx;
+ m_contexts.erase(ctx);
+
+ return true;
+}
+
+void* EGLtoGLESInterface::GetNativeContext(void* context)
+{
+ GLES_ASSERT(context != NULL);
+
+ GLESContext* ctx = static_cast<GLESContext*>(context);
+ if(m_contexts.find(ctx) == m_contexts.end())
+ {
+ return false;
+ }
+
+ return ctx->NativeContext();
+}
+
+fpGLProc EGLtoGLESInterface::GetGLProcAddress( const char *procname )
+{
+ if(strcmp(procname, "glPointSizePointerOES") == 0)
+ {
+ return (fpGLProc)glPointSizePointerOES;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+static SurfaceDescriptor createSurfaceDescriptor(int redBits, int redShift, int greenBits, int greenShift, int blueBits, int blueShift, int alphaBits, int alphaShift, int luminanceBits, int luminanceShift, CColorDescriptor::ColorFormat format, int bpp)
+{
+ SurfaceDescriptor desc;
+ desc.m_colorDescriptor.m_redSize = redBits;
+ desc.m_colorDescriptor.m_greenSize = greenBits;
+ desc.m_colorDescriptor.m_blueSize = blueBits;
+ desc.m_colorDescriptor.m_alphaSize = alphaBits;
+ desc.m_colorDescriptor.m_luminanceSize = luminanceBits;
+ desc.m_redShift = redShift;
+ desc.m_greenShift = greenShift;
+ desc.m_blueShift = blueShift;
+ desc.m_alphaShift = alphaShift;
+ desc.m_luminanceShift = luminanceShift;
+ desc.m_colorDescriptor.m_format = format;
+ desc.m_colorDescriptor.m_bpp = bpp;
+ return desc;
+}
+
+typedef struct
+{
+ SurfaceDescriptor desc;
+ GLenum internal_format;
+ GLenum data_format;
+ GLenum data_type;
+} DescToEnumMapping;
+
+static bool isDescEqualToMapping(const SurfaceDescriptor& desc, const DescToEnumMapping& mapping)
+{
+ if ((desc.m_colorDescriptor.m_redSize == mapping.desc.m_colorDescriptor.m_redSize) &&
+ (desc.m_colorDescriptor.m_greenSize == mapping.desc.m_colorDescriptor.m_greenSize) &&
+ (desc.m_colorDescriptor.m_blueSize == mapping.desc.m_colorDescriptor.m_blueSize) &&
+ (desc.m_colorDescriptor.m_alphaSize == mapping.desc.m_colorDescriptor.m_alphaSize) &&
+ (desc.m_colorDescriptor.m_luminanceSize == mapping.desc.m_colorDescriptor.m_luminanceSize) &&
+ (desc.m_redShift == mapping.desc.m_redShift) &&
+ (desc.m_greenShift == mapping.desc.m_greenShift) &&
+ (desc.m_blueShift == mapping.desc.m_blueShift) &&
+ (desc.m_alphaShift == mapping.desc.m_alphaShift) &&
+ (desc.m_luminanceShift == mapping.desc.m_luminanceShift) &&
+ (desc.m_colorDescriptor.m_format == mapping.desc.m_colorDescriptor.m_format) &&
+ (desc.m_colorDescriptor.m_bpp == mapping.desc.m_colorDescriptor.m_bpp))
+ return true;
+
+ return false;
+}
+
+static void surfaceDescriptorToGLEnums(const SurfaceDescriptor& desc, GLenum& internal_format, GLenum& data_format, GLenum& data_type)
+{
+ static const DescToEnumMapping map[] = {
+ /* RGB{A,X} channel ordering */
+ // sRGBX_8888
+ {createSurfaceDescriptor(8, 24, 8, 16, 8, 8, 0, 0, 0, 0, CColorDescriptor::sRGBA, 32), GL_SRGB8, GL_RGBA, GL_UNSIGNED_BYTE},
+ // sRGBA_8888
+ {createSurfaceDescriptor(8, 24, 8, 16, 8, 8, 8, 0, 0, 0, CColorDescriptor::sRGBA, 32), GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE},
+ // sRGBA_8888_PRE
+ {createSurfaceDescriptor(8, 24, 8, 16, 8, 8, 8, 0, 0, 0, CColorDescriptor::sRGBA_PRE, 32), GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE},
+ // sRGB_565
+ {createSurfaceDescriptor(5, 11, 6, 5, 5, 0, 0, 0, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8, GL_RGB, GL_UNSIGNED_SHORT_5_6_5},
+ // sRGBA_5551
+ {createSurfaceDescriptor(5, 11, 5, 6, 5, 1, 1, 0, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1},
+ // sRGBA_4444
+ {createSurfaceDescriptor(4, 12, 4, 8, 4, 4, 4, 0, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4},
+ // sL_8
+ {createSurfaceDescriptor(0, 0, 0, 0, 0, 0, 0, 0, 8, 0, CColorDescriptor::sLA, 8), GL_SLUMINANCE8, GL_LUMINANCE, GL_UNSIGNED_BYTE},
+ // lRGBX_8888
+ {createSurfaceDescriptor(8, 24, 8, 16, 8, 8, 0, 0, 0, 0, CColorDescriptor::lRGBA, 32), GL_RGB8, GL_RGBA, GL_UNSIGNED_BYTE},
+ // lRGBA_8888
+ {createSurfaceDescriptor(8, 24, 8, 16, 8, 8, 8, 0, 0, 0, CColorDescriptor::lRGBA, 32), GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},
+ // lRGBA_8888_PRE
+ {createSurfaceDescriptor(8, 24, 8, 16, 8, 8, 8, 0, 0, 0, CColorDescriptor::lRGBA_PRE, 32), GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},
+ // lL_8
+ {createSurfaceDescriptor(0, 0, 0, 0, 0, 0, 0, 0, 8, 0, CColorDescriptor::lLA, 8), GL_LUMINANCE8, GL_LUMINANCE, GL_UNSIGNED_BYTE},
+ // A_8
+ {createSurfaceDescriptor(0, 0, 0, 0, 0, 0, 8, 0, 0, 0, CColorDescriptor::lRGBA, 8), GL_ALPHA8, GL_ALPHA, GL_UNSIGNED_BYTE},
+ // These should be converted to a compatible format by VG.
+ /*
+ // BW_1
+ {createSurfaceDescriptor(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, CColorDescriptor::lLA, 1), 0, 0, 0},
+ // A_1
+ {createSurfaceDescriptor(0, 0, 0, 0, 0, 0, 1, 0, 0, 0, CColorDescriptor::lRGBA, 1), 0, 0, 0},
+ // A_4
+ {createSurfaceDescriptor(0, 0, 0, 0, 0, 0, 4, 0, 0, 0, CColorDescriptor::lRGBA, 4), 0, 0, 0},
+ */
+
+ /* {A,X}RGB channel ordering */
+ // sXRGB_8888
+ {createSurfaceDescriptor(8, 16, 8, 8, 8, 0, 0, 0, 0, 0, CColorDescriptor::sRGBA, 32), GL_SRGB8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // sARGB_8888
+ {createSurfaceDescriptor(8, 16, 8, 8, 8, 0, 8, 24, 0, 0, CColorDescriptor::sRGBA, 32), GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // sARGB_8888_PRE
+ {createSurfaceDescriptor(8, 16, 8, 8, 8, 0, 8, 24, 0, 0, CColorDescriptor::sRGBA_PRE, 32), GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // sARGB_1555
+ {createSurfaceDescriptor(5, 10, 5, 5, 5, 0, 1, 15, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV},
+ // sARGB_4444
+ {createSurfaceDescriptor(4, 8, 4, 4, 4, 0, 4, 12, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV},
+ // lXRGB_8888
+ {createSurfaceDescriptor(8, 16, 8, 8, 8, 0, 0, 0, 0, 0, CColorDescriptor::lRGBA, 32), GL_RGB8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // lARGB_8888
+ {createSurfaceDescriptor(8, 16, 8, 8, 8, 0, 8, 24, 0, 0, CColorDescriptor::lRGBA, 32), GL_RGBA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // lARGB_8888_PRE
+ {createSurfaceDescriptor(8, 16, 8, 8, 8, 0, 8, 24, 0, 0, CColorDescriptor::lRGBA_PRE, 32), GL_RGBA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},
+
+ /* BGR{A,X} channel ordering */
+ // sBGRX_8888
+ {createSurfaceDescriptor(8, 8, 8, 16, 8, 24, 0, 0, 0, 0, CColorDescriptor::sRGBA, 32), GL_SRGB8, GL_BGRA, GL_UNSIGNED_BYTE},
+ // sBGRA_8888
+ {createSurfaceDescriptor(8, 8, 8, 16, 8, 24, 8, 0, 0, 0, CColorDescriptor::sRGBA, 32), GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE},
+ // sBGRA_8888_PRE
+ {createSurfaceDescriptor(8, 8, 8, 16, 8, 24, 8, 0, 0, 0, CColorDescriptor::sRGBA_PRE, 32), GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE},
+ // sBGR_565
+ {createSurfaceDescriptor(5, 0, 6, 5, 5, 11, 0, 0, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8, GL_BGR, GL_UNSIGNED_SHORT_5_6_5},
+ // sBGRA_5551
+ {createSurfaceDescriptor(5, 1, 5, 6, 5, 11, 1, 0, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_SHORT_5_5_5_1},
+ // sBGRA_4444
+ {createSurfaceDescriptor(4, 4, 4, 8, 4, 12, 4, 0, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4},
+ // lBGRX_8888
+ {createSurfaceDescriptor(8, 8, 8, 16, 8, 24, 0, 0, 0, 0, CColorDescriptor::lRGBA, 32), GL_RGB8, GL_BGRA, GL_UNSIGNED_BYTE},
+ // lBGRA_8888
+ {createSurfaceDescriptor(8, 8, 8, 16, 8, 24, 8, 0, 0, 0, CColorDescriptor::lRGBA, 32), GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE},
+ // lBGRA_8888_PRE
+ {createSurfaceDescriptor(8, 8, 8, 16, 8, 24, 8, 0, 0, 0, CColorDescriptor::lRGBA_PRE, 32), GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE},
+
+ /* {A,X}BGR channel ordering */
+ // sXBGR_8888
+ {createSurfaceDescriptor(8, 0, 8, 8, 8, 16, 0, 0, 0, 0, CColorDescriptor::sRGBA, 32), GL_SRGB8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // sABGR_8888
+ {createSurfaceDescriptor(8, 0, 8, 8, 8, 16, 8, 24, 0, 0, CColorDescriptor::sRGBA, 32), GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // sABGR_8888_PRE
+ {createSurfaceDescriptor(8, 0, 8, 8, 8, 16, 8, 24, 0, 0, CColorDescriptor::sRGBA_PRE, 32), GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // sABGR_1555
+ {createSurfaceDescriptor(5, 0, 5, 5, 5, 10, 1, 15, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV},
+ // sABGR_4444
+ {createSurfaceDescriptor(4, 0, 4, 4, 4, 8, 4, 12, 0, 0, CColorDescriptor::sRGBA, 16), GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV},
+ // lXBGR_8888
+ {createSurfaceDescriptor(8, 0, 8, 8, 8, 16, 0, 0, 0, 0, CColorDescriptor::lRGBA, 32), GL_RGB8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // lABGR_8888
+ {createSurfaceDescriptor(8, 0, 8, 8, 8, 16, 8, 24, 0, 0, CColorDescriptor::lRGBA, 32), GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
+ // lABGR_8888_PRE:
+ {createSurfaceDescriptor(8, 0, 8, 8, 8, 16, 8, 24, 0, 0, CColorDescriptor::lRGBA_PRE, 32), GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV}};
+
+ for (size_t i = 0; i < sizeof(map)/sizeof(map[0]); i++)
+ {
+ if (isDescEqualToMapping(desc, map[i]))
+ {
+ internal_format = map[i].internal_format;
+ data_format = map[i].data_format;
+ data_type = map[i].data_type;
+ GLES_ASSERT(internal_format != 0 && data_format != 0 && data_type != 0);
+ return;
+ }
+ }
+ GLES_ASSERT(false);
+ return;
+}
+
+int EGLtoGLESInterface::BindTexImage( void* surface, int level, bool generateMipmap, const SurfaceDescriptor* desc, void* buffer )
+{
+ GLES_ENTER_RET(NULL);
+
+ GLuint ret = 0;
+
+ // Store the current error and clear the error flag.
+ ctx->GetHostError();
+
+ if(level < 0)
+ {
+ level = 0;
+ }
+ else if(level > (int)ctx->MaxTextureLevel())
+ {
+ level = ctx->MaxTextureLevel();
+ }
+
+ GLint origGenMipmapParam;
+ ctx->DGL().glGetTexParameteriv(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &origGenMipmapParam);
+
+ if(!generateMipmap)
+ {
+ // Disable automatic mipmap generation.
+ ctx->DGL().glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
+ }
+
+ // Clear all mipmap levels.
+ for(unsigned int i = 0; i < ctx->MaxTextureLevel(); i++)
+ {
+ ctx->DGL().glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+ }
+
+ GLenum internalFormat, dataFormat, dataType;
+ surfaceDescriptorToGLEnums(*desc, internalFormat, dataFormat, dataType);
+ ctx->DGL().glTexImage2D(GL_TEXTURE_2D, level, internalFormat, desc->m_width, desc->m_height, 0,
+ dataFormat, dataType, buffer);
+
+ if(!generateMipmap)
+ {
+ // Restore original state.
+ ctx->DGL().glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, origGenMipmapParam);
+ }
+
+ // Clear any possible error flag.
+ if(ctx->DGL().glGetError() == GL_NO_ERROR)
+ {
+ GLESTexture* texture = ctx->Texture(ctx->TextureBinding());
+ GLES_ASSERT(texture != NULL);
+ texture->SetLevel(level, GL_RGBA, desc->m_width, desc->m_height);
+
+ if(generateMipmap && origGenMipmapParam && level == 0)
+ {
+ texture->GenerateMipmap();
+ }
+
+ if(texture->Level(level)->boundSurface != NULL)
+ {
+ glesReleaseTexImage(texture->Level(level)->boundSurface, texture->Name(), level);
+ }
+ texture->Level(level)->boundSurface = surface;
+
+ ret = texture->Name();
+ }
+
+ GLES_LEAVE_NO_ERROR_CHECK_RET(ret);
+}
+
+bool EGLtoGLESInterface::ReleaseTexImage( int name, int level )
+{
+ GLES_ENTER_RET(false);
+
+ ctx->GetHostError();
+
+ GLuint binding;
+ ctx->DGL().glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&binding);
+ ctx->DGL().glBindTexture(GL_TEXTURE_2D, (GLuint)name);
+ ctx->DGL().glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+ ctx->DGL().glBindTexture(GL_TEXTURE_2D, binding);
+
+ GLES_LEAVE_NO_ERROR_CHECK_RET(ctx->DGL().glGetError() == GL_NO_ERROR);
+}
+
+bool EGLtoGLESInterface::CopyBuffers( void* buf, const SurfaceDescriptor* desc )
+{
+ GLES_ENTER_RET(false);
+
+ // Store the current error and clear the error flag.
+ ctx->GetHostError();
+
+ GLenum internal_format, data_format, data_type;
+ surfaceDescriptorToGLEnums(*desc, internal_format, data_format, data_type);
+
+ GLint pack_alignment;
+ ctx->DGL().glGetIntegerv(GL_PACK_ALIGNMENT, &pack_alignment);
+ ctx->DGL().glPixelStorei(GL_PACK_ALIGNMENT, 1);
+ ctx->DGL().glReadPixels(0, 0, desc->m_width, desc->m_height, data_format, data_type, buf);
+ ctx->DGL().glPixelStorei(GL_PACK_ALIGNMENT, pack_alignment);
+
+ GLES_LEAVE_NO_ERROR_CHECK_RET(ctx->DGL().glGetError() == GL_NO_ERROR);
+}
+
+bool EGLtoGLESInterface::UpdateBuffers( void* buf, const SurfaceDescriptor* desc )
+{
+ GLES_ENTER_RET(false);
+
+ // Store the current error and clear the error flag.
+ ctx->GetHostError();
+
+ GLenum internal_format, data_format, data_type;
+ surfaceDescriptorToGLEnums(*desc, internal_format, data_format, data_type);
+
+ GLint unpack_alignment;
+ ctx->DGL().glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpack_alignment);
+ ctx->DGL().glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+ ctx->DGL().glDrawPixels( desc->m_width, desc->m_height, data_format, data_type, buf );
+ ctx->DGL().glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment);
+
+ GLES_LEAVE_NO_ERROR_CHECK_RET(ctx->DGL().glGetError() == GL_NO_ERROR);
+}
+
+void EGLtoGLESInterface::Flush()
+{
+ GLES_ENTER();
+
+ // Store the current error and clear the error flag.
+ ctx->GetHostError();
+
+ ctx->DGL().glFlush();
+
+ ctx->DGL().glGetError();
+
+ GLES_LEAVE();
+}
+
+void EGLtoGLESInterface::Finish()
+{
+ GLES_ENTER();
+
+ // Store the current error and clear the error flag.
+ ctx->GetHostError();
+
+ ctx->DGL().glFinish();
+
+ ctx->DGL().glGetError();
+
+ GLES_LEAVE();
+}
+
+/*static*/ IGLEStoEGLInterface* EGLtoGLESInterface::GetEGLInterface()
+{
+ return g_EGLtoGLESInterface.m_egl;
+}