diff --git a/src/OpenGL/libGLES_CM/Context.cpp b/src/OpenGL/libGLES_CM/Context.cpp
index 0ca4654..337b406 100644
--- a/src/OpenGL/libGLES_CM/Context.cpp
+++ b/src/OpenGL/libGLES_CM/Context.cpp
@@ -255,7 +255,7 @@
     markAllStateDirty();
 }
 
-int Context::getClientVersion()
+int Context::getClientVersion() const
 {
 	return 1;
 }
@@ -2807,11 +2807,8 @@
 
 }
 
-// Exported functions for use by EGL
-extern "C"
+egl::Context *es1CreateContext(const egl::Config *config, const egl::Context *shareContext)
 {
-	es1::Context *glCreateContext(const egl::Config *config, const es1::Context *shareContext)
-	{
-		return new es1::Context(config, shareContext);
-	}
+	ASSERT(!shareContext || shareContext->getClientVersion() == 1);   // Should be checked by eglCreateContext
+	return new es1::Context(config, static_cast<const es1::Context*>(shareContext));
 }
diff --git a/src/OpenGL/libGLES_CM/Context.h b/src/OpenGL/libGLES_CM/Context.h
index 9d6c074..387c527 100644
--- a/src/OpenGL/libGLES_CM/Context.h
+++ b/src/OpenGL/libGLES_CM/Context.h
@@ -25,6 +25,7 @@
 
 #define GL_API
 #include <GLES/gl.h>
+#define GL_GLEXT_PROTOTYPES
 #include <GLES/glext.h>
 #define EGLAPI
 #include <EGL/egl.h>
@@ -263,7 +264,7 @@
     Context(const egl::Config *config, const Context *shareContext);
 
 	virtual void makeCurrent(egl::Surface *surface);
-	virtual int getClientVersion();
+	virtual int getClientVersion() const;
 
     void markAllStateDirty();
 
diff --git a/src/OpenGL/libGLES_CM/Texture.cpp b/src/OpenGL/libGLES_CM/Texture.cpp
index 7b767e2..cd2c35b 100644
--- a/src/OpenGL/libGLES_CM/Texture.cpp
+++ b/src/OpenGL/libGLES_CM/Texture.cpp
@@ -758,60 +758,56 @@
 
 }
 
-// Exported functions for use by EGL
-extern "C"
+egl::Image *createBackBuffer(int width, int height, const egl::Config *config)
 {
-	egl::Image *createBackBuffer(int width, int height, const egl::Config *config)
+	if(config)
 	{
-		if(config)
-		{
-			return new es1::Image(0, width, height, config->mAlphaSize ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE);
-		}
+		return new es1::Image(0, width, height, config->mAlphaSize ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE);
+	}
 
+	return 0;
+}
+
+egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)
+{
+	if(width == 0 || height == 0 || height > OUTLINE_RESOLUTION)
+	{
+		ERR("Invalid parameters");
 		return 0;
 	}
 
-	egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)
+	bool lockable = true;
+
+	switch(format)
 	{
-		if(width == 0 || height == 0 || height > OUTLINE_RESOLUTION)
-		{
-			ERR("Invalid parameters");
-			return 0;
-		}
-
-		bool lockable = true;
-
-		switch(format)
-		{
-	//	case sw::FORMAT_D15S1:
-		case sw::FORMAT_D24S8:
-		case sw::FORMAT_D24X8:
-	//	case sw::FORMAT_D24X4S4:
-		case sw::FORMAT_D24FS8:
-		case sw::FORMAT_D32:
-		case sw::FORMAT_D16:
-			lockable = false;
-			break;
-	//	case sw::FORMAT_S8_LOCKABLE:
-	//	case sw::FORMAT_D16_LOCKABLE:
-		case sw::FORMAT_D32F_LOCKABLE:
-	//	case sw::FORMAT_D32_LOCKABLE:
-		case sw::FORMAT_DF24S8:
-		case sw::FORMAT_DF16S8:
-			lockable = true;
-			break;
-		default:
-			UNREACHABLE();
-		}
-
-		es1::Image *surface = new es1::Image(0, width, height, format, multiSampleDepth, lockable, true);
-
-		if(!surface)
-		{
-			ERR("Out of memory");
-			return 0;
-		}
-
-		return surface;
+//	case sw::FORMAT_D15S1:
+	case sw::FORMAT_D24S8:
+	case sw::FORMAT_D24X8:
+//	case sw::FORMAT_D24X4S4:
+	case sw::FORMAT_D24FS8:
+	case sw::FORMAT_D32:
+	case sw::FORMAT_D16:
+		lockable = false;
+		break;
+//	case sw::FORMAT_S8_LOCKABLE:
+//	case sw::FORMAT_D16_LOCKABLE:
+	case sw::FORMAT_D32F_LOCKABLE:
+//	case sw::FORMAT_D32_LOCKABLE:
+	case sw::FORMAT_DF24S8:
+	case sw::FORMAT_DF16S8:
+		lockable = true;
+		break;
+	default:
+		UNREACHABLE();
 	}
+
+	es1::Image *surface = new es1::Image(0, width, height, format, multiSampleDepth, lockable, true);
+
+	if(!surface)
+	{
+		ERR("Out of memory");
+		return 0;
+	}
+
+	return surface;
 }
diff --git a/src/OpenGL/libGLES_CM/exports.map b/src/OpenGL/libGLES_CM/exports.map
index 565d1bc..4f05484 100644
--- a/src/OpenGL/libGLES_CM/exports.map
+++ b/src/OpenGL/libGLES_CM/exports.map
@@ -205,13 +205,7 @@
     glDrawTexfOES;
     glDrawTexfvOES;
 
-    # EGL dependencies
-    glCreateContext;
-    glGetProcAddress;
-
-	createFrameBuffer;
-	createBackBuffer;
-	createDepthStencil;
+    libGLES_CMexports;
 
 	Register;
 
diff --git a/src/OpenGL/libGLES_CM/libGLES_CM.cbp b/src/OpenGL/libGLES_CM/libGLES_CM.cbp
index 7041a83..c0cbc51 100644
--- a/src/OpenGL/libGLES_CM/libGLES_CM.cbp
+++ b/src/OpenGL/libGLES_CM/libGLES_CM.cbp
@@ -286,6 +286,7 @@
 		<Unit filename="VertexDataManager.h" />
 		<Unit filename="exports.map" />
 		<Unit filename="libGLES_CM.cpp" />
+		<Unit filename="libGLES_CM.hpp" />
 		<Unit filename="main.cpp" />
 		<Unit filename="main.h" />
 		<Unit filename="mathutil.h" />
diff --git a/src/OpenGL/libGLES_CM/libGLES_CM.cpp b/src/OpenGL/libGLES_CM/libGLES_CM.cpp
index 907030e..96323f0 100644
--- a/src/OpenGL/libGLES_CM/libGLES_CM.cpp
+++ b/src/OpenGL/libGLES_CM/libGLES_CM.cpp
@@ -34,6 +34,8 @@
 
 #include <limits>
 
+using namespace es1;
+
 static bool validImageSize(GLint level, GLsizei width, GLsizei height)
 {
 	if(level < 0 || level >= es1::IMPLEMENTATION_MAX_TEXTURE_LEVELS || width < 0 || height < 0)
@@ -84,218 +86,182 @@
 
 EGLint EGLAPIENTRY eglGetError(void)
 {
-	static auto eglGetError = (EGLint (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglGetError");
-	return eglGetError();
+	return libEGL->eglGetError();
 }
 
 EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)
 {
-	static auto eglGetDisplay = (EGLDisplay (EGLAPIENTRY*)(EGLNativeDisplayType display_id))getProcAddress(libEGL, "eglGetDisplay");
-	return eglGetDisplay(display_id);
+	return libEGL->eglGetDisplay(display_id);
 }
 
 EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
 {
-	static auto eglInitialize = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLint *major, EGLint *minor))getProcAddress(libEGL, "eglInitialize");
-	return eglInitialize(dpy, major, minor);
+	return libEGL->eglInitialize(dpy, major, minor);
 }
 
 EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)
 {
-	static auto eglTerminate = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy))getProcAddress(libEGL, "eglTerminate");
-	return eglTerminate(dpy);
+	return libEGL->eglTerminate(dpy);
 }
 
 const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)
 {
-	static auto eglQueryString = (const char *(EGLAPIENTRY*)(EGLDisplay dpy, EGLint name))getProcAddress(libEGL, "eglQueryString");
-	return eglQueryString(dpy, name);
+	return libEGL->eglQueryString(dpy, name);
 }
 
 EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
 {
-	static auto eglGetConfigs = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config))getProcAddress(libEGL, "eglGetConfigs");
-	return eglGetConfigs(dpy, configs, config_size, num_config);
+	return libEGL->eglGetConfigs(dpy, configs, config_size, num_config);
 }
 
 EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
 {
-	static auto eglChooseConfig = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config))getProcAddress(libEGL, "eglChooseConfig");
-	return eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
+	return libEGL->eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
 }
 
 EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
 {
-	static auto eglGetConfigAttrib = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value))getProcAddress(libEGL, "eglGetConfigAttrib");
-	return eglGetConfigAttrib(dpy, config, attribute, value);
+	return libEGL->eglGetConfigAttrib(dpy, config, attribute, value);
 }
 
 EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list)
 {
-	static auto eglCreateWindowSurface = (EGLSurface (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreateWindowSurface");
-	return eglCreateWindowSurface(dpy, config, window, attrib_list);
+	return libEGL->eglCreateWindowSurface(dpy, config, window, attrib_list);
 }
 
 EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
 {
-	static auto eglCreatePbufferSurface = (EGLSurface (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreatePbufferSurface");
-	return eglCreatePbufferSurface(dpy, config, attrib_list);
+	return libEGL->eglCreatePbufferSurface(dpy, config, attrib_list);
 }
 
 EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
 {
-	static auto eglCreatePixmapSurface = (EGLSurface (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreatePixmapSurface");
-	return eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
+	return libEGL->eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
 }
 
 EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 {
-	static auto eglDestroySurface = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface))getProcAddress(libEGL, "eglDestroySurface");
-	return eglDestroySurface(dpy, surface);
+	return libEGL->eglDestroySurface(dpy, surface);
 }
 
 EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
 {
-	static auto eglQuerySurface = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value))getProcAddress(libEGL, "eglQuerySurface");
-	return eglQuerySurface(dpy, surface, attribute, value);
+	return libEGL->eglQuerySurface(dpy, surface, attribute, value);
 }
 
 EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)
 {
-	static auto eglBindAPI = (EGLBoolean (EGLAPIENTRY*)(EGLenum api))getProcAddress(libEGL, "eglBindAPI");
-	return eglBindAPI(api);
+	return libEGL->eglBindAPI(api);
 }
 
 EGLenum EGLAPIENTRY eglQueryAPI(void)
 {
-	static auto eglQueryAPI = (EGLenum (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglQueryAPI");
-	return eglQueryAPI();
+	return libEGL->eglQueryAPI();
 }
 
 EGLBoolean EGLAPIENTRY eglWaitClient(void)
 {
-	static auto eglWaitClient = (EGLBoolean (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglWaitClient");
-	return eglWaitClient();
+	return libEGL->eglWaitClient();
 }
 
 EGLBoolean EGLAPIENTRY eglReleaseThread(void)
 {
-	static auto eglReleaseThread = (EGLBoolean (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglReleaseThread");
-	return eglReleaseThread();
+	return libEGL->eglReleaseThread();
 }
 
 EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
 {
-	static auto eglCreatePbufferFromClientBuffer = (EGLSurface (EGLAPIENTRY*)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreatePbufferFromClientBuffer");
-	return eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
+	return libEGL->eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
 }
 
 EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
 {
-	static auto eglSurfaceAttrib = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value))getProcAddress(libEGL, "eglSurfaceAttrib");
-	return eglSurfaceAttrib(dpy, surface, attribute, value);
+	return libEGL->eglSurfaceAttrib(dpy, surface, attribute, value);
 }
 
 EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
-	static auto eglBindTexImage = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLint buffer))getProcAddress(libEGL, "eglBindTexImage");
-	return eglBindTexImage(dpy, surface, buffer);
+	return libEGL->eglBindTexImage(dpy, surface, buffer);
 }
 
 EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
-	static auto eglReleaseTexImage = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLint buffer))getProcAddress(libEGL, "eglReleaseTexImage");
-	return eglReleaseTexImage(dpy, surface, buffer);
+	return libEGL->eglReleaseTexImage(dpy, surface, buffer);
 }
 
 EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)
 {
-	static auto eglSwapInterval = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLint interval))getProcAddress(libEGL, "eglSwapInterval");
-	return eglSwapInterval(dpy, interval);
+	return libEGL->eglSwapInterval(dpy, interval);
 }
 
 EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
 {
-	static auto eglCreateContext = (EGLContext (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreateContext");
-	return eglCreateContext(dpy, config, share_context, attrib_list);
+	return libEGL->eglCreateContext(dpy, config, share_context, attrib_list);
 }
 
 EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 {
-	static auto eglDestroyContext = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLContext ctx))getProcAddress(libEGL, "eglDestroyContext");
-	return eglDestroyContext(dpy, ctx);
+	return libEGL->eglDestroyContext(dpy, ctx);
 }
 
 EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
 {
-	static auto eglMakeCurrent = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx))getProcAddress(libEGL, "eglMakeCurrent");
-	return eglMakeCurrent(dpy, draw, read, ctx);
+	return libEGL->eglMakeCurrent(dpy, draw, read, ctx);
 }
 
 EGLContext EGLAPIENTRY eglGetCurrentContext(void)
 {
-	static auto eglGetCurrentContext = (EGLContext (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglGetCurrentContext");
-	return eglGetCurrentContext();
+	return libEGL->eglGetCurrentContext();
 }
 
 EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)
 {
-	static auto eglGetCurrentSurface = (EGLSurface (EGLAPIENTRY*)(EGLint readdraw))getProcAddress(libEGL, "eglGetCurrentSurface");
-	return eglGetCurrentSurface(readdraw);
+	return libEGL->eglGetCurrentSurface(readdraw);
 }
 
 EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)
 {
-	static auto eglGetCurrentDisplay = (EGLDisplay (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglGetCurrentDisplay");
-	return eglGetCurrentDisplay();
+	return libEGL->eglGetCurrentDisplay();
 }
 
 EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
 {
-	static auto eglQueryContext = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value))getProcAddress(libEGL, "eglQueryContext");
-	return eglQueryContext(dpy, ctx, attribute, value);
+	return libEGL->eglQueryContext(dpy, ctx, attribute, value);
 }
 
 EGLBoolean EGLAPIENTRY eglWaitGL(void)
 {
-	static auto eglWaitGL = (EGLBoolean (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglWaitGL");
-	return eglWaitGL();
+	return libEGL->eglWaitGL();
 }
 
 EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)
 {
-	static auto eglWaitNative = (EGLBoolean (EGLAPIENTRY*)(EGLint engine))getProcAddress(libEGL, "eglWaitNative");
-	return eglWaitNative(engine);
+	return libEGL->eglWaitNative(engine);
 }
 
 EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
 {
-	static auto eglSwapBuffers = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface))getProcAddress(libEGL, "eglSwapBuffers");
-	return eglSwapBuffers(dpy, surface);
+	return libEGL->eglSwapBuffers(dpy, surface);
 }
 
 EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
 {
-	static auto eglCopyBuffers = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target))getProcAddress(libEGL, "eglCopyBuffers");
-	return eglCopyBuffers(dpy, surface, target);
+	return libEGL->eglCopyBuffers(dpy, surface, target);
 }
 
 EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
 {
-	static auto eglCreateImageKHR = (EGLImageKHR (EGLAPIENTRY*)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreateImageKHR");
-	return eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
+	return libEGL->eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
 }
 
 EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
 {
-	static auto eglDestroyImageKHR = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLImageKHR image))getProcAddress(libEGL, "eglDestroyImageKHR");
-	return eglDestroyImageKHR(dpy, image);
+	return libEGL->eglDestroyImageKHR(dpy, image);
 }
 
 __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)
 {
-	static auto eglGetProcAddress = (__eglMustCastToProperFunctionPointerType (EGLAPIENTRY*)(const char*))getProcAddress(libEGL, "eglGetProcAddress");
-	return eglGetProcAddress(procname);
+	return libEGL->eglGetProcAddress(procname);
 }
 
 void GL_APIENTRY glActiveTexture(GLenum texture)
@@ -3898,7 +3864,7 @@
 	UNIMPLEMENTED();
 }
 
-__eglMustCastToProperFunctionPointerType glGetProcAddress(const char *procname)
+__eglMustCastToProperFunctionPointerType es1GetProcAddress(const char *procname)
 {
 	struct Extension
 	{
diff --git a/src/OpenGL/libGLES_CM/libGLES_CM.def b/src/OpenGL/libGLES_CM/libGLES_CM.def
index 6ab41db..3efec4d 100644
--- a/src/OpenGL/libGLES_CM/libGLES_CM.def
+++ b/src/OpenGL/libGLES_CM/libGLES_CM.def
@@ -205,12 +205,6 @@
     glDrawTexfOES
     glDrawTexfvOES
 
-    ; EGL dependencies
-    glCreateContext
-    glGetProcAddress
-
-	createFrameBuffer
-	createBackBuffer
-	createDepthStencil
+	libGLES_CMexports
 
 	Register
\ No newline at end of file
diff --git a/src/OpenGL/libGLES_CM/libGLES_CM.hpp b/src/OpenGL/libGLES_CM/libGLES_CM.hpp
new file mode 100644
index 0000000..dd2d23a
--- /dev/null
+++ b/src/OpenGL/libGLES_CM/libGLES_CM.hpp
@@ -0,0 +1,95 @@
+#ifndef libGLES_CM_hpp
+#define libGLES_CM_hpp
+
+#define GL_API
+#include <GLES/gl.h>
+#define GL_GLEXT_PROTOTYPES
+#include <GLES/glext.h>
+#define EGLAPI
+#include <EGL/egl.h>
+
+#include "Common/SharedLibrary.hpp"
+
+namespace sw
+{
+class FrameBuffer;
+enum Format : unsigned char;
+}
+
+namespace egl
+{
+class Context;
+class Image;
+class Config;
+}
+
+class LibGLES_CMexports
+{
+public:
+	LibGLES_CMexports();
+
+	egl::Context *(*es1CreateContext)(const egl::Config *config, const egl::Context *shareContext);
+	__eglMustCastToProperFunctionPointerType (*es1GetProcAddress)(const char *procname);
+	egl::Image *(*createBackBuffer)(int width, int height, const egl::Config *config);
+	egl::Image *(*createDepthStencil)(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);
+	sw::FrameBuffer *(*createFrameBuffer)(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);
+
+	void (GL_APIENTRY *glEGLImageTargetTexture2DOES)(GLenum target, GLeglImageOES image);
+};
+
+class LibGLES_CM
+{
+public:
+	LibGLES_CM()
+	{
+		libGLES_CM = nullptr;
+		libGLES_CMexports = nullptr;
+	}
+
+	~LibGLES_CM()
+	{
+		freeLibrary(libGLES_CM);
+	}
+
+	operator bool()
+	{
+		return loadExports();
+	}
+
+	LibGLES_CMexports *operator->()
+	{
+		return loadExports();
+	}
+
+private:
+	LibGLES_CMexports *loadExports()
+	{
+		if(!libGLES_CM)
+		{
+			#if defined(_WIN32)
+			const char *libGLES_CM_lib[] = {"libGLES_CM.dll", "libGLES_CM_translator.dll"};
+			#elif defined(__ANDROID__)
+			const char *libGLES_CM_lib[] = {"/vendor/lib/egl/libGLESv1_CM_swiftshader.so"};
+			#elif defined(__LP64__)
+			const char *libGLES_CM_lib[] = {"lib64GLES_CM_translator.so", "libGLES_CM.so.1", "libGLES_CM.so"};
+			#else
+			const char *libGLES_CM_lib[] = {"libGLES_CM_translator.so", "libGLES_CM.so.1", "libGLES_CM.so"};
+			#endif
+
+			libGLES_CM = loadLibrary(libGLES_CM_lib);
+
+			if(libGLES_CM)
+			{
+				auto libGLES_CMexportsProc = (LibGLES_CMexports *(*)())getProcAddress(libGLES_CM, "libGLES_CMexports");
+				libGLES_CMexports = libGLES_CMexportsProc();
+			}
+		}
+
+		return libGLES_CMexports;
+	}
+
+	void *libGLES_CM;
+	LibGLES_CMexports *libGLES_CMexports;
+};
+
+#endif libGLES_CM_hpp
diff --git a/src/OpenGL/libGLES_CM/libGLES_CM.vcxproj b/src/OpenGL/libGLES_CM/libGLES_CM.vcxproj
index c591b19..ce35b8d 100644
--- a/src/OpenGL/libGLES_CM/libGLES_CM.vcxproj
+++ b/src/OpenGL/libGLES_CM/libGLES_CM.vcxproj
@@ -351,6 +351,7 @@
     <ClInclude Include="Framebuffer.h" />
     <ClInclude Include="Image.hpp" />
     <ClInclude Include="IndexDataManager.h" />
+    <ClInclude Include="libGLES_CM.hpp" />
     <ClInclude Include="main.h" />
     <ClInclude Include="mathutil.h" />
     <ClInclude Include="Renderbuffer.h" />
diff --git a/src/OpenGL/libGLES_CM/libGLES_CM.vcxproj.filters b/src/OpenGL/libGLES_CM/libGLES_CM.vcxproj.filters
index 0ccb31a..47f9aaa 100644
--- a/src/OpenGL/libGLES_CM/libGLES_CM.vcxproj.filters
+++ b/src/OpenGL/libGLES_CM/libGLES_CM.vcxproj.filters
@@ -130,6 +130,9 @@
     <ClInclude Include="..\common\MatrixStack.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="libGLES_CM.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="libGLES_CM.rc" />
diff --git a/src/OpenGL/libGLES_CM/main.cpp b/src/OpenGL/libGLES_CM/main.cpp
index 0927c65..0044dbf 100644
--- a/src/OpenGL/libGLES_CM/main.cpp
+++ b/src/OpenGL/libGLES_CM/main.cpp
@@ -13,12 +13,16 @@
 
 #include "main.h"
 
+#include "libGLES_CM.hpp"
 #include "Framebuffer.h"
 #include "libEGL/Surface.h"
 #include "Common/Thread.hpp"
 #include "Common/SharedLibrary.hpp"
 #include "common/debug.h"
 
+#define GL_GLEXT_PROTOTYPES
+#include <GLES/glext.h>
+
 #if !defined(_MSC_VER)
 #define CONSTRUCTOR __attribute__((constructor))
 #define DESTRUCTOR __attribute__((destructor))
@@ -37,27 +41,11 @@
     TRACE("()");
 }
 
-CONSTRUCTOR static bool glAttachProcess()
+CONSTRUCTOR static void glAttachProcess()
 {
     TRACE("()");
 
     glAttachThread();
-
-	#if defined(_WIN32)
-	const char *libEGL_lib[] = {"libEGL.dll", "libEGL_translator.dll"};
-	#elif defined(__ANDROID__)
-	const char *libEGL_lib[] = {"/vendor/lib/egl/libEGL_swiftshader.so"};
-	#elif defined(__LP64__)
-	const char *libEGL_lib[] = {"lib64EGL_translator.so", "libEGL.so.1", "libEGL.so"};
-	#else
-	const char *libEGL_lib[] = {"libEGL_translator.so", "libEGL.so.1", "libEGL.so"};
-	#endif
-
-	libEGL = loadLibrary(libEGL_lib);
-	egl::getCurrentContext = (egl::Context *(*)())getProcAddress(libEGL, "clientGetCurrentContext");
-	egl::getCurrentDisplay = (egl::Display *(*)())getProcAddress(libEGL, "clientGetCurrentDisplay");
-
-    return libEGL != 0;
 }
 
 DESTRUCTOR static void glDetachProcess()
@@ -65,7 +53,6 @@
     TRACE("()");
 
 	glDetachThread();
-	freeLibrary(libEGL);
 }
 
 #if defined(_WIN32)
@@ -74,7 +61,7 @@
     switch(reason)
     {
     case DLL_PROCESS_ATTACH:
-        return glAttachProcess();
+        glAttachProcess();
         break;
     case DLL_THREAD_ATTACH:
         glAttachThread();
@@ -97,7 +84,7 @@
 {
 es1::Context *getContext()
 {
-	egl::Context *context = egl::getCurrentContext();
+	egl::Context *context = libEGL->clientGetCurrentContext();
 
 	if(context && context->getClientVersion() == 1)
 	{
@@ -109,7 +96,7 @@
 
 egl::Display *getDisplay()
 {
-    return egl::getCurrentDisplay();
+    return libEGL->clientGetCurrentDisplay();
 }
 
 Device *getDevice()
@@ -118,7 +105,6 @@
 
     return context ? context->getDevice() : 0;
 }
-}
 
 // Records an error code
 void error(GLenum errorCode)
@@ -153,11 +139,28 @@
         }
     }
 }
-
-namespace egl
-{
-	egl::Context *(*getCurrentContext)() = 0;
-	egl::Display *(*getCurrentDisplay)() = 0;
 }
 
-void *libEGL = 0;   // Handle to the libEGL module
+egl::Context *es1CreateContext(const egl::Config *config, const egl::Context *shareContext);
+extern "C" __eglMustCastToProperFunctionPointerType es1GetProcAddress(const char *procname);
+egl::Image *createBackBuffer(int width, int height, const egl::Config *config);
+egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);
+sw::FrameBuffer *createFrameBuffer(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);
+
+LibGLES_CMexports::LibGLES_CMexports()
+{
+	this->es1CreateContext = ::es1CreateContext;
+	this->es1GetProcAddress = ::es1GetProcAddress;
+	this->createBackBuffer = ::createBackBuffer;
+	this->createDepthStencil = ::createDepthStencil;
+	this->createFrameBuffer = ::createFrameBuffer;
+	this->glEGLImageTargetTexture2DOES = ::glEGLImageTargetTexture2DOES;
+}
+
+extern "C" LibGLES_CMexports *libGLES_CMexports()
+{
+	static LibGLES_CMexports libGLES_CM;
+	return &libGLES_CM;
+}
+
+LibEGL libEGL;
\ No newline at end of file
diff --git a/src/OpenGL/libGLES_CM/main.h b/src/OpenGL/libGLES_CM/main.h
index 4b5648a..a5d1aad 100644
--- a/src/OpenGL/libGLES_CM/main.h
+++ b/src/OpenGL/libGLES_CM/main.h
@@ -17,6 +17,7 @@
 #include "Context.h"
 #include "Device.hpp"
 #include "common/debug.h"
+#include "libEGL/libEGL.hpp"
 #include "libEGL/Display.h"
 
 #define GL_API
@@ -29,25 +30,18 @@
 	Context *getContext();
 	egl::Display *getDisplay();
 	Device *getDevice();
+
+	void error(GLenum errorCode);
+
+	template<class T>
+	const T &error(GLenum errorCode, const T &returnValue)
+	{
+		error(errorCode);
+
+		return returnValue;
+	}
 }
 
-void error(GLenum errorCode);
-
-template<class T>
-const T &error(GLenum errorCode, const T &returnValue)
-{
-    error(errorCode);
-
-    return returnValue;
-}
-
-// libEGL dependencies
-namespace egl
-{
-	extern egl::Context *(*getCurrentContext)();
-	extern egl::Display *(*getCurrentDisplay)();
-}
-
-extern void *libEGL;   // Handle to the libEGL module
+extern LibEGL libEGL;
 
 #endif   // LIBGLES_CM_MAIN_H_