// or implied, including but not limited to any patent rights, are granted to you.\r
//\r
\r
+#ifndef SharedLibrary_hpp\r
+#define SharedLibrary_hpp\r
+\r
#if defined(_WIN32)\r
#include <Windows.h>\r
#else\r
return library ? dlsym(library, name) : 0;\r
}\r
#endif\r
+\r
+#endif // SharedLibrary_hpp\r
}
}
-extern "C"
+sw::FrameBuffer *createFrameBuffer(void *display, ANativeWindow* window, int width, int height)
{
- sw::FrameBuffer *createFrameBuffer(void *display, void* window, int width, int height)
- {
- return new sw::FrameBufferAndroid((ANativeWindow*)window, width, height);
- }
+ return new sw::FrameBufferAndroid(window, width, height);
}
#include "FrameBufferGDI.hpp"\r
#include "Common/Configurator.hpp"\r
\r
-extern "C"\r
+sw::FrameBufferWin *createFrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin)\r
{\r
- sw::FrameBufferWin *createFrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin)\r
- {\r
- sw::Configurator ini("SwiftShader.ini");\r
- int api = ini.getInteger("Testing", "FrameBufferAPI", 0);\r
-\r
- if(api == 0 && topLeftOrigin)\r
- {\r
- return new sw::FrameBufferDD(windowHandle, width, height, fullscreen, topLeftOrigin);\r
- }\r
- else\r
- {\r
- return new sw::FrameBufferGDI(windowHandle, width, height, fullscreen, topLeftOrigin);\r
- }\r
+ sw::Configurator ini("SwiftShader.ini");\r
+ int api = ini.getInteger("Testing", "FrameBufferAPI", 0);\r
\r
- return 0;\r
+ if(api == 0 && topLeftOrigin)\r
+ {\r
+ return new sw::FrameBufferDD(windowHandle, width, height, fullscreen, topLeftOrigin);\r
}\r
-\r
- sw::FrameBuffer *createFrameBuffer(HDC display, HWND window, int width, int height)\r
+ else\r
{\r
- return createFrameBufferWin(window, width, height, false, false);\r
+ return new sw::FrameBufferGDI(windowHandle, width, height, fullscreen, topLeftOrigin);\r
}\r
+\r
+ return 0;\r
+}\r
+\r
+sw::FrameBuffer *createFrameBuffer(HDC display, HWND window, int width, int height)\r
+{\r
+ return createFrameBufferWin(window, width, height, false, false);\r
}\r
};\r
}\r
\r
-extern "C"\r
-{\r
- sw::FrameBufferWin *createFrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin);\r
-}\r
-\r
#endif // sw_FrameBufferWin_hpp\r
}\r
}\r
\r
-extern "C"\r
+sw::FrameBuffer *createFrameBuffer(Display *display, Window window, int width, int height)\r
{\r
- sw::FrameBuffer *createFrameBuffer(void *display, Window window, int width, int height)\r
- {\r
- return new sw::FrameBufferX11((Display*)display, window, width, height);\r
- }\r
+ return new sw::FrameBufferX11(display, window, width, height);\r
}\r
virtual void bindTexImage(Surface *surface) = 0;\r
virtual EGLenum validateSharedImage(EGLenum target, GLuint name, GLuint textureLevel) = 0;\r
virtual Image *createSharedImage(EGLenum target, GLuint name, GLuint textureLevel) = 0;\r
- virtual int getClientVersion() = 0;\r
+ virtual int getClientVersion() const = 0;\r
\r
protected:\r
virtual ~Context() {};\r
if(clientVersion == 1 && config->mRenderableType & EGL_OPENGL_ES_BIT)
{
- if(es1::createContext != 0)
+ if(libGLES_CM)
{
- context = es1::createContext(config, shareContext);
+ context = libGLES_CM->es1CreateContext(config, shareContext);
}
}
else if((clientVersion == 2 && config->mRenderableType & EGL_OPENGL_ES2_BIT) ||
(clientVersion == 3 && config->mRenderableType & EGL_OPENGL_ES3_BIT))
{
- if(es2::createContext != 0)
+ if(libGLESv2)
{
- context = es2::createContext(config, shareContext, clientVersion);
+ context = libGLESv2->es2CreateContext(config, shareContext, clientVersion);
}
}
else
deleteResources();\r
\r
if(mWindow)\r
- {\r
- frameBuffer = es::createFrameBuffer(mDisplay->getNativeDisplay(), mWindow, backBufferWidth, backBufferHeight);\r
+ {
+ if(libGLES_CM)
+ {\r
+ frameBuffer = libGLES_CM->createFrameBuffer(mDisplay->getNativeDisplay(), mWindow, backBufferWidth, backBufferHeight);
+ }
+ else if(libGLESv2)
+ {\r
+ frameBuffer = libGLESv2->createFrameBuffer(mDisplay->getNativeDisplay(), mWindow, backBufferWidth, backBufferHeight);
+ }\r
\r
if(!frameBuffer)\r
{\r
return error(EGL_BAD_ALLOC, false);\r
}\r
}\r
-\r
- backBuffer = es::createBackBuffer(backBufferWidth, backBufferHeight, mConfig);\r
+
+ if(libGLES_CM)
+ {\r
+ backBuffer = libGLES_CM->createBackBuffer(backBufferWidth, backBufferHeight, mConfig);
+ }
+ else if(libGLESv2)
+ {
+ backBuffer = libGLESv2->createBackBuffer(backBufferWidth, backBufferHeight, mConfig);
+ }\r
\r
if(!backBuffer)\r
{\r
}\r
\r
if(mConfig->mDepthStencilFormat != sw::FORMAT_NULL)\r
- {\r
- mDepthStencil = es::createDepthStencil(backBufferWidth, backBufferHeight, mConfig->mDepthStencilFormat, 1, false);\r
+ {
+
+ if(libGLES_CM)
+ {\r
+ mDepthStencil = libGLES_CM->createDepthStencil(backBufferWidth, backBufferHeight, mConfig->mDepthStencilFormat, 1, false);
+ }
+ else if(libGLESv2)
+ {
+ mDepthStencil = libGLESv2->createDepthStencil(backBufferWidth, backBufferHeight, mConfig->mDepthStencilFormat, 1, false);
+ }\r
\r
if(!mDepthStencil)\r
{\r
eglCreatePlatformWindowSurfaceEXT;\r
eglCreatePlatformPixmapSurfaceEXT;\r
\r
- # Functions that don't change the error code, for use by client APIs\r
- clientGetCurrentContext;\r
- clientGetCurrentDisplay;\r
+ libEGLexports;\r
\r
local:\r
*;\r
<Unit filename="Surface.h" />
<Unit filename="exports.map" />
<Unit filename="libEGL.cpp" />
+ <Unit filename="libEGL.hpp" />
<Unit filename="main.cpp" />
<Unit filename="main.h" />
<Extensions>
\r
#include <string.h>\r
\r
+using namespace egl;\r
+\r
static bool validateDisplay(egl::Display *display)\r
{\r
if(display == EGL_NO_DISPLAY)\r
}\r
\r
egl::Display *display = static_cast<egl::Display*>(dpy);\r
+ egl::Context *shareContext = static_cast<egl::Context*>(share_context);\r
\r
if(!validateConfig(display, config))\r
{\r
return EGL_NO_CONTEXT;\r
}\r
\r
- return display->createContext(config, static_cast<egl::Context*>(share_context), clientVersion);\r
+ if(shareContext && shareContext->getClientVersion() != clientVersion)\r
+ {\r
+ return error(EGL_BAD_CONTEXT, EGL_NO_CONTEXT);\r
+ }\r
+\r
+ return display->createContext(config, shareContext, clientVersion);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)\r
}\r
}\r
\r
- if(es2::getProcAddress != 0)\r
+ if(libGLESv2)\r
{\r
- __eglMustCastToProperFunctionPointerType proc = es2::getProcAddress(procname);\r
+ __eglMustCastToProperFunctionPointerType proc = libGLESv2->es2GetProcAddress(procname);\r
if(proc) return proc;\r
}\r
\r
- if(es1::getProcAddress != 0)\r
+ if(libGLES_CM)\r
{\r
- __eglMustCastToProperFunctionPointerType proc = es1::getProcAddress(procname);\r
+ __eglMustCastToProperFunctionPointerType proc = libGLES_CM->es1GetProcAddress(procname);\r
if(proc) return proc;\r
}\r
\r
eglCreatePlatformWindowSurfaceEXT\r
eglCreatePlatformPixmapSurfaceEXT\r
\r
- ; Functions that don't change the error code, for use by client APIs\r
- clientGetCurrentContext\r
- clientGetCurrentDisplay
\ No newline at end of file
+ libEGLexports
\ No newline at end of file
--- /dev/null
+#ifndef libEGL_hpp
+#define libEGL_hpp
+
+#define EGLAPI
+#include <EGL/egl.h>
+#define EGL_EGLEXT_PROTOTYPES
+#include <EGL/eglext.h>
+
+#include "Common/SharedLibrary.hpp"
+
+class LibEGLexports
+{
+public:
+ LibEGLexports();
+
+ EGLint (EGLAPIENTRY *eglGetError)(void);
+ EGLDisplay (EGLAPIENTRY *eglGetDisplay)(EGLNativeDisplayType display_id);
+ EGLBoolean (EGLAPIENTRY *eglInitialize)(EGLDisplay dpy, EGLint *major, EGLint *minor);
+ EGLBoolean (EGLAPIENTRY *eglTerminate)(EGLDisplay dpy);
+ const char *(EGLAPIENTRY *eglQueryString)(EGLDisplay dpy, EGLint name);
+ EGLBoolean (EGLAPIENTRY *eglGetConfigs)(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+ EGLBoolean (EGLAPIENTRY *eglChooseConfig)(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+ EGLBoolean (EGLAPIENTRY *eglGetConfigAttrib)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+ EGLSurface (EGLAPIENTRY *eglCreateWindowSurface)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list);
+ EGLSurface (EGLAPIENTRY *eglCreatePbufferSurface)(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+ EGLSurface (EGLAPIENTRY *eglCreatePixmapSurface)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
+ EGLBoolean (EGLAPIENTRY *eglDestroySurface)(EGLDisplay dpy, EGLSurface surface);
+ EGLBoolean (EGLAPIENTRY *eglQuerySurface)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+ EGLBoolean (EGLAPIENTRY *eglBindAPI)(EGLenum api);
+ EGLenum (EGLAPIENTRY *eglQueryAPI)(void);
+ EGLBoolean (EGLAPIENTRY *eglWaitClient)(void);
+ EGLBoolean (EGLAPIENTRY *eglReleaseThread)(void);
+ EGLSurface (EGLAPIENTRY *eglCreatePbufferFromClientBuffer)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
+ EGLBoolean (EGLAPIENTRY *eglSurfaceAttrib)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+ EGLBoolean (EGLAPIENTRY *eglBindTexImage)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+ EGLBoolean (EGLAPIENTRY *eglReleaseTexImage)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+ EGLBoolean (EGLAPIENTRY *eglSwapInterval)(EGLDisplay dpy, EGLint interval);
+ EGLContext (EGLAPIENTRY *eglCreateContext)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
+ EGLBoolean (EGLAPIENTRY *eglDestroyContext)(EGLDisplay dpy, EGLContext ctx);
+ EGLBoolean (EGLAPIENTRY *eglMakeCurrent)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+ EGLContext (EGLAPIENTRY *eglGetCurrentContext)(void);
+ EGLSurface (EGLAPIENTRY *eglGetCurrentSurface)(EGLint readdraw);
+ EGLDisplay (EGLAPIENTRY *eglGetCurrentDisplay)(void);
+ EGLBoolean (EGLAPIENTRY *eglQueryContext)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+ EGLBoolean (EGLAPIENTRY *eglWaitGL)(void);
+ EGLBoolean (EGLAPIENTRY *eglWaitNative)(EGLint engine);
+ EGLBoolean (EGLAPIENTRY *eglSwapBuffers)(EGLDisplay dpy, EGLSurface surface);
+ EGLBoolean (EGLAPIENTRY *eglCopyBuffers)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+ EGLImageKHR (EGLAPIENTRY *eglCreateImageKHR)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
+ EGLBoolean (EGLAPIENTRY *eglDestroyImageKHR)(EGLDisplay dpy, EGLImageKHR image);
+ __eglMustCastToProperFunctionPointerType (EGLAPIENTRY *eglGetProcAddress)(const char*);
+
+ // Functions that don't change the error code, for use by client APIs
+ egl::Context *(*clientGetCurrentContext)();
+ egl::Display *(*clientGetCurrentDisplay)();
+};
+
+class LibEGL
+{
+public:
+ LibEGL()
+ {
+ libEGL = nullptr;
+ libEGLexports = nullptr;
+ }
+
+ ~LibEGL()
+ {
+ freeLibrary(libEGL);
+ }
+
+ LibEGLexports *operator->()
+ {
+ return loadExports();
+ }
+
+private:
+ LibEGLexports *loadExports()
+ {
+ if(!libEGL)
+ {
+ #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);
+
+ if(libEGL)
+ {
+ auto libEGLexportsProc = (LibEGLexports *(*)())getProcAddress(libEGL, "libEGLexports");
+ libEGLexports = libEGLexportsProc();
+ }
+ }
+
+ return libEGLexports;
+ }
+
+ void *libEGL;
+ LibEGLexports *libEGLexports;
+};
+
+#endif // libEGL_hpp
<ClInclude Include="Context.hpp" />\r
<ClInclude Include="Display.h" />\r
<ClInclude Include="Image.hpp" />\r
+ <ClInclude Include="libEGL.hpp" />\r
<ClInclude Include="main.h" />\r
<ClInclude Include="resource.h" />\r
<ClInclude Include="Surface.h" />\r
<ClInclude Include="..\common\Object.hpp">\r
<Filter>Header Files</Filter>\r
</ClInclude>\r
+ <ClInclude Include="libEGL.hpp">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
</ItemGroup>\r
<ItemGroup>\r
<ResourceCompile Include="libEGL.rc" />\r
\r
#include "main.h"\r
\r
+#include "libEGL.hpp"\r
#include "Context.hpp"\r
#include "Surface.h"\r
\r
#include "Common/SharedLibrary.hpp"\r
#include "common/debug.h"\r
\r
+#define EGL_EGLEXT_PROTOTYPES\r
+#include <EGL/eglext.h>\r
+\r
static sw::Thread::LocalStorageKey currentTLS = TLS_OUT_OF_INDEXES;\r
\r
#if !defined(_MSC_VER)\r
}\r
}\r
\r
-CONSTRUCTOR static bool eglAttachProcess()\r
+CONSTRUCTOR static void eglAttachProcess()\r
{\r
TRACE("()");\r
\r
\r
if(currentTLS == TLS_OUT_OF_INDEXES)\r
{\r
- return false;\r
+ return;\r
}\r
\r
eglAttachThread();\r
-\r
- #if defined(_WIN32)\r
- const char *libGLES_CM_lib[] = {"libGLES_CM.dll", "libGLES_CM_translator.dll"};\r
- #elif defined(__ANDROID__)\r
- const char *libGLES_CM_lib[] = {"/vendor/lib/egl/libGLESv1_CM_swiftshader.so"};\r
- #elif defined(__LP64__)\r
- const char *libGLES_CM_lib[] = {"lib64GLES_CM_translator.so", "libGLES_CM.so.1", "libGLES_CM.so"};\r
- #else\r
- const char *libGLES_CM_lib[] = {"libGLES_CM_translator.so", "libGLES_CM.so.1", "libGLES_CM.so"};\r
- #endif\r
-\r
- libGLES_CM = loadLibrary(libGLES_CM_lib);\r
- es1::createContext = (egl::Context *(*)(const egl::Config*, const egl::Context*))getProcAddress(libGLES_CM, "glCreateContext");\r
- es1::getProcAddress = (__eglMustCastToProperFunctionPointerType (*)(const char*))getProcAddress(libGLES_CM, "glGetProcAddress");\r
-\r
- #if defined(_WIN32)\r
- const char *libGLESv2_lib[] = {"libGLESv2.dll", "libGLES_V2_translator.dll"};\r
- #elif defined(__ANDROID__)\r
- const char *libGLESv2_lib[] = {"/vendor/lib/egl/libGLESv2_swiftshader.so"};\r
- #elif defined(__LP64__)\r
- const char *libGLESv2_lib[] = {"lib64GLES_V2_translator.so", "libGLESv2.so.2", "libGLESv2.so"};\r
- #else\r
- const char *libGLESv2_lib[] = {"libGLES_V2_translator.so", "libGLESv2.so.2", "libGLESv2.so"};\r
- #endif\r
-\r
- libGLESv2 = loadLibrary(libGLESv2_lib);\r
- es2::createContext = (egl::Context *(*)(const egl::Config*, const egl::Context*, EGLint))getProcAddress(libGLESv2, "glCreateContext");\r
- es2::getProcAddress = (__eglMustCastToProperFunctionPointerType (*)(const char*))getProcAddress(libGLESv2, "glGetProcAddress");\r
-\r
- es::createBackBuffer = (egl::Image *(*)(int, int, const egl::Config*))getProcAddress(libGLES_CM, "createBackBuffer");\r
- es::createDepthStencil = (egl::Image *(*)(unsigned int, unsigned int, sw::Format, int, bool))getProcAddress(libGLES_CM, "createDepthStencil");\r
- es::createFrameBuffer = (sw::FrameBuffer *(*)(EGLNativeDisplayType, EGLNativeWindowType, int, int))getProcAddress(libGLES_CM, "createFrameBuffer");\r
-\r
- if(!es::createBackBuffer)\r
- {\r
- es::createBackBuffer = (egl::Image *(*)(int, int, const egl::Config*))getProcAddress(libGLESv2, "createBackBuffer");\r
- es::createDepthStencil = (egl::Image *(*)(unsigned int, unsigned int, sw::Format, int, bool))getProcAddress(libGLESv2, "createDepthStencil");\r
- es::createFrameBuffer = (sw::FrameBuffer *(*)(EGLNativeDisplayType, EGLNativeWindowType, int, int))getProcAddress(libGLESv2, "createFrameBuffer");\r
- }\r
-\r
- return libGLES_CM != 0 || libGLESv2 != 0;\r
}\r
\r
DESTRUCTOR static void eglDetachProcess()\r
\r
eglDetachThread();\r
sw::Thread::freeLocalStorageKey(currentTLS);\r
- freeLibrary(libGLESv2);\r
}\r
\r
#if defined(_WIN32)\r
#ifndef NDEBUG\r
WaitForDebugger(instance);\r
#endif\r
- return eglAttachProcess();\r
+ eglAttachProcess();\r
break;\r
case DLL_THREAD_ATTACH:\r
eglAttachThread();\r
\r
return current->readSurface;\r
}\r
-}\r
\r
void error(EGLint errorCode)\r
{\r
}\r
}\r
}\r
-\r
-extern "C"\r
-{\r
-EGLContext clientGetCurrentContext()\r
-{\r
- return egl::getCurrentContext();\r
-}\r
-\r
-EGLContext clientGetCurrentDisplay()\r
-{\r
- return egl::getCurrentDisplay();\r
-}\r
-}\r
-\r
-namespace es1\r
-{\r
- egl::Context *(*createContext)(const egl::Config *config, const egl::Context *shareContext) = 0;\r
- __eglMustCastToProperFunctionPointerType (*getProcAddress)(const char *procname) = 0;\r
}\r
\r
-namespace es2\r
+LibEGLexports::LibEGLexports()\r
{\r
- egl::Context *(*createContext)(const egl::Config *config, const egl::Context *shareContext, EGLint clientVersion) = 0;\r
- __eglMustCastToProperFunctionPointerType (*getProcAddress)(const char *procname) = 0;\r
+ this->eglGetError = ::eglGetError;\r
+ this->eglGetDisplay = ::eglGetDisplay;\r
+ this->eglInitialize = ::eglInitialize;\r
+ this->eglTerminate = ::eglTerminate;\r
+ this->eglQueryString = ::eglQueryString;\r
+ this->eglGetConfigs = ::eglGetConfigs;\r
+ this->eglChooseConfig = ::eglChooseConfig;\r
+ this->eglGetConfigAttrib = ::eglGetConfigAttrib;\r
+ this->eglCreateWindowSurface = ::eglCreateWindowSurface;\r
+ this->eglCreatePbufferSurface = ::eglCreatePbufferSurface;\r
+ this->eglCreatePixmapSurface = ::eglCreatePixmapSurface;\r
+ this->eglDestroySurface = ::eglDestroySurface;\r
+ this->eglQuerySurface = ::eglQuerySurface;\r
+ this->eglBindAPI = ::eglBindAPI;\r
+ this->eglQueryAPI = ::eglQueryAPI;\r
+ this->eglWaitClient = ::eglWaitClient;\r
+ this->eglReleaseThread = ::eglReleaseThread;\r
+ this->eglCreatePbufferFromClientBuffer = ::eglCreatePbufferFromClientBuffer;\r
+ this->eglSurfaceAttrib = ::eglSurfaceAttrib;\r
+ this->eglBindTexImage = ::eglBindTexImage;\r
+ this->eglReleaseTexImage = ::eglReleaseTexImage;\r
+ this->eglSwapInterval = ::eglSwapInterval;\r
+ this->eglCreateContext = ::eglCreateContext;\r
+ this->eglDestroyContext = ::eglDestroyContext;\r
+ this->eglMakeCurrent = ::eglMakeCurrent;\r
+ this->eglGetCurrentContext = ::eglGetCurrentContext;\r
+ this->eglGetCurrentSurface = ::eglGetCurrentSurface;\r
+ this->eglGetCurrentDisplay = ::eglGetCurrentDisplay;\r
+ this->eglQueryContext = ::eglQueryContext;\r
+ this->eglWaitGL = ::eglWaitGL;\r
+ this->eglWaitNative = ::eglWaitNative;\r
+ this->eglSwapBuffers = ::eglSwapBuffers;\r
+ this->eglCopyBuffers = ::eglCopyBuffers;\r
+ this->eglCreateImageKHR = ::eglCreateImageKHR;\r
+ this->eglDestroyImageKHR = ::eglDestroyImageKHR;\r
+ this->eglGetProcAddress = ::eglGetProcAddress;\r
+\r
+ this->clientGetCurrentContext = egl::getCurrentContext;\r
+ this->clientGetCurrentDisplay = egl::getCurrentDisplay;\r
}\r
\r
-namespace es\r
+extern "C" LibEGLexports *libEGLexports()\r
{\r
- egl::Image *(*createBackBuffer)(int width, int height, const egl::Config *config) = 0;\r
- egl::Image *(*createDepthStencil)(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard) = 0;\r
- sw::FrameBuffer *(*createFrameBuffer)(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height) = 0;\r
+ static LibEGLexports libEGL;\r
+ return &libEGL;\r
}\r
\r
-void *libGLES_CM = 0; // Handle to the libGLES_CM module\r
-void *libGLESv2 = 0; // Handle to the libGLESv2 module\r
+LibGLES_CM libGLES_CM;\r
+LibGLESv2 libGLESv2;\r
#ifndef LIBEGL_MAIN_H_
#define LIBEGL_MAIN_H_
+#include "libGLES_CM/libGLES_CM.hpp"
+#include "libGLESv2/libGLESv2.hpp"
+
#define EGLAPI
#include <EGL/egl.h>
+#define EGL_EGLEXT_PROTOTYPES
#include <EGL/eglext.h>
namespace egl
void setCurrentReadSurface(Surface *surface);
Surface *getCurrentReadSurface();
-}
-
-void error(EGLint errorCode);
-template<class T>
-const T &error(EGLint errorCode, const T &returnValue)
-{
- error(errorCode);
+ void error(EGLint errorCode);
+
+ template<class T>
+ const T &error(EGLint errorCode, const T &returnValue)
+ {
+ egl::error(errorCode);
- return returnValue;
-}
+ return returnValue;
+ }
-template<class T>
-const T &success(const T &returnValue)
-{
- egl::setCurrentError(EGL_SUCCESS);
+ template<class T>
+ const T &success(const T &returnValue)
+ {
+ egl::setCurrentError(EGL_SUCCESS);
- return returnValue;
-}
+ return returnValue;
+ }
-namespace egl
-{
class Config;
class Surface;
class Display;
class Image;
}
-namespace sw
-{
- class FrameBuffer;
- enum Format : unsigned char;
-}
-
-// libGLES_CM dependencies
-namespace es1
-{
- extern egl::Context *(*createContext)(const egl::Config *config, const egl::Context *shareContext);
- extern __eglMustCastToProperFunctionPointerType (*getProcAddress)(const char *procname);
-}
-
-// libGLESv2 dependencies
-namespace es2
-{
- extern egl::Context *(*createContext)(const egl::Config *config, const egl::Context *shareContext, EGLint clientVersion);
- extern __eglMustCastToProperFunctionPointerType (*getProcAddress)(const char *procname);
-}
-
-namespace es
-{
- extern egl::Image *(*createBackBuffer)(int width, int height, const egl::Config *config);
- extern egl::Image *(*createDepthStencil)(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);
- extern sw::FrameBuffer *(*createFrameBuffer)(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);
-}
-
-extern void *libGLES_CM; // Handle to the libGLES_CM module
-extern void *libGLESv2; // Handle to the libGLESv2 module
+extern LibGLES_CM libGLES_CM;
+extern LibGLESv2 libGLESv2;
#endif // LIBEGL_MAIN_H_
return returnValue;
}
-extern "C" sw::FrameBuffer *createFrameBuffer(NativeDisplayType display, NativeWindowType window, int width, int height);
+extern sw::FrameBuffer *createFrameBuffer(NativeDisplayType display, NativeWindowType window, int width, int height);
#endif // LIBGL_MAIN_H_
markAllStateDirty();\r
}\r
\r
-int Context::getClientVersion()\r
+int Context::getClientVersion() const\r
{\r
return 1;\r
}\r
\r
}\r
\r
-// Exported functions for use by EGL\r
-extern "C"\r
+egl::Context *es1CreateContext(const egl::Config *config, const egl::Context *shareContext)\r
{\r
- es1::Context *glCreateContext(const egl::Config *config, const es1::Context *shareContext)\r
- {\r
- return new es1::Context(config, shareContext);\r
- }\r
+ ASSERT(!shareContext || shareContext->getClientVersion() == 1); // Should be checked by eglCreateContext\r
+ return new es1::Context(config, static_cast<const es1::Context*>(shareContext));\r
}\r
\r
#define GL_API\r
#include <GLES/gl.h>\r
+#define GL_GLEXT_PROTOTYPES\r
#include <GLES/glext.h>\r
#define EGLAPI\r
#include <EGL/egl.h>\r
Context(const egl::Config *config, const Context *shareContext);\r
\r
virtual void makeCurrent(egl::Surface *surface);\r
- virtual int getClientVersion();\r
+ virtual int getClientVersion() const;\r
\r
void markAllStateDirty();\r
\r
\r
}\r
\r
-// Exported functions for use by EGL\r
-extern "C"\r
+egl::Image *createBackBuffer(int width, int height, const egl::Config *config)\r
{\r
- egl::Image *createBackBuffer(int width, int height, const egl::Config *config)\r
+ if(config)\r
{\r
- if(config)\r
- {\r
- return new es1::Image(0, width, height, config->mAlphaSize ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE);\r
- }\r
-\r
- return 0;\r
+ return new es1::Image(0, width, height, config->mAlphaSize ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE);\r
}\r
\r
- egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)\r
- {\r
- if(width == 0 || height == 0 || height > OUTLINE_RESOLUTION)\r
- {\r
- ERR("Invalid parameters");\r
- return 0;\r
- }\r
+ return 0;\r
+}\r
\r
- bool lockable = true;\r
+egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)\r
+{\r
+ if(width == 0 || height == 0 || height > OUTLINE_RESOLUTION)\r
+ {\r
+ ERR("Invalid parameters");\r
+ return 0;\r
+ }\r
\r
- switch(format)\r
- {\r
- // case sw::FORMAT_D15S1:\r
- case sw::FORMAT_D24S8:\r
- case sw::FORMAT_D24X8:\r
- // case sw::FORMAT_D24X4S4:\r
- case sw::FORMAT_D24FS8:\r
- case sw::FORMAT_D32:\r
- case sw::FORMAT_D16:\r
- lockable = false;\r
- break;\r
- // case sw::FORMAT_S8_LOCKABLE:\r
- // case sw::FORMAT_D16_LOCKABLE:\r
- case sw::FORMAT_D32F_LOCKABLE:\r
- // case sw::FORMAT_D32_LOCKABLE:\r
- case sw::FORMAT_DF24S8:\r
- case sw::FORMAT_DF16S8:\r
- lockable = true;\r
- break;\r
- default:\r
- UNREACHABLE();\r
- }\r
+ bool lockable = true;\r
\r
- es1::Image *surface = new es1::Image(0, width, height, format, multiSampleDepth, lockable, true);\r
+ switch(format)\r
+ {\r
+// case sw::FORMAT_D15S1:\r
+ case sw::FORMAT_D24S8:\r
+ case sw::FORMAT_D24X8:\r
+// case sw::FORMAT_D24X4S4:\r
+ case sw::FORMAT_D24FS8:\r
+ case sw::FORMAT_D32:\r
+ case sw::FORMAT_D16:\r
+ lockable = false;\r
+ break;\r
+// case sw::FORMAT_S8_LOCKABLE:\r
+// case sw::FORMAT_D16_LOCKABLE:\r
+ case sw::FORMAT_D32F_LOCKABLE:\r
+// case sw::FORMAT_D32_LOCKABLE:\r
+ case sw::FORMAT_DF24S8:\r
+ case sw::FORMAT_DF16S8:\r
+ lockable = true;\r
+ break;\r
+ default:\r
+ UNREACHABLE();\r
+ }\r
\r
- if(!surface)\r
- {\r
- ERR("Out of memory");\r
- return 0;\r
- }\r
+ es1::Image *surface = new es1::Image(0, width, height, format, multiSampleDepth, lockable, true);\r
\r
- return surface;\r
+ if(!surface)\r
+ {\r
+ ERR("Out of memory");\r
+ return 0;\r
}\r
+\r
+ return surface;\r
}\r
glDrawTexfOES;
glDrawTexfvOES;
- # EGL dependencies
- glCreateContext;
- glGetProcAddress;
-
- createFrameBuffer;
- createBackBuffer;
- createDepthStencil;
+ libGLES_CMexports;
Register;
<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" />
\r
#include <limits>\r
\r
+using namespace es1;\r
+\r
static bool validImageSize(GLint level, GLsizei width, GLsizei height)\r
{\r
if(level < 0 || level >= es1::IMPLEMENTATION_MAX_TEXTURE_LEVELS || width < 0 || height < 0)\r
\r
EGLint EGLAPIENTRY eglGetError(void)\r
{\r
- static auto eglGetError = (EGLint (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglGetError");\r
- return eglGetError();\r
+ return libEGL->eglGetError();\r
}\r
\r
EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)\r
{\r
- static auto eglGetDisplay = (EGLDisplay (EGLAPIENTRY*)(EGLNativeDisplayType display_id))getProcAddress(libEGL, "eglGetDisplay");\r
- return eglGetDisplay(display_id);\r
+ return libEGL->eglGetDisplay(display_id);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)\r
{\r
- static auto eglInitialize = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLint *major, EGLint *minor))getProcAddress(libEGL, "eglInitialize");\r
- return eglInitialize(dpy, major, minor);\r
+ return libEGL->eglInitialize(dpy, major, minor);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)\r
{\r
- static auto eglTerminate = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy))getProcAddress(libEGL, "eglTerminate");\r
- return eglTerminate(dpy);\r
+ return libEGL->eglTerminate(dpy);\r
}\r
\r
const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)\r
{\r
- static auto eglQueryString = (const char *(EGLAPIENTRY*)(EGLDisplay dpy, EGLint name))getProcAddress(libEGL, "eglQueryString");\r
- return eglQueryString(dpy, name);\r
+ return libEGL->eglQueryString(dpy, name);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)\r
{\r
- static auto eglGetConfigs = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config))getProcAddress(libEGL, "eglGetConfigs");\r
- return eglGetConfigs(dpy, configs, config_size, num_config);\r
+ return libEGL->eglGetConfigs(dpy, configs, config_size, num_config);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)\r
{\r
- static auto eglChooseConfig = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config))getProcAddress(libEGL, "eglChooseConfig");\r
- return eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);\r
+ return libEGL->eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)\r
{\r
- static auto eglGetConfigAttrib = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value))getProcAddress(libEGL, "eglGetConfigAttrib");\r
- return eglGetConfigAttrib(dpy, config, attribute, value);\r
+ return libEGL->eglGetConfigAttrib(dpy, config, attribute, value);\r
}\r
\r
EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list)\r
{\r
- static auto eglCreateWindowSurface = (EGLSurface (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreateWindowSurface");\r
- return eglCreateWindowSurface(dpy, config, window, attrib_list);\r
+ return libEGL->eglCreateWindowSurface(dpy, config, window, attrib_list);\r
}\r
\r
EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)\r
{\r
- static auto eglCreatePbufferSurface = (EGLSurface (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreatePbufferSurface");\r
- return eglCreatePbufferSurface(dpy, config, attrib_list);\r
+ return libEGL->eglCreatePbufferSurface(dpy, config, attrib_list);\r
}\r
\r
EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)\r
{\r
- static auto eglCreatePixmapSurface = (EGLSurface (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreatePixmapSurface");\r
- return eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);\r
+ return libEGL->eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)\r
{\r
- static auto eglDestroySurface = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface))getProcAddress(libEGL, "eglDestroySurface");\r
- return eglDestroySurface(dpy, surface);\r
+ return libEGL->eglDestroySurface(dpy, surface);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)\r
{\r
- static auto eglQuerySurface = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value))getProcAddress(libEGL, "eglQuerySurface");\r
- return eglQuerySurface(dpy, surface, attribute, value);\r
+ return libEGL->eglQuerySurface(dpy, surface, attribute, value);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)\r
{\r
- static auto eglBindAPI = (EGLBoolean (EGLAPIENTRY*)(EGLenum api))getProcAddress(libEGL, "eglBindAPI");\r
- return eglBindAPI(api);\r
+ return libEGL->eglBindAPI(api);\r
}\r
\r
EGLenum EGLAPIENTRY eglQueryAPI(void)\r
{\r
- static auto eglQueryAPI = (EGLenum (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglQueryAPI");\r
- return eglQueryAPI();\r
+ return libEGL->eglQueryAPI();\r
}\r
\r
EGLBoolean EGLAPIENTRY eglWaitClient(void)\r
{\r
- static auto eglWaitClient = (EGLBoolean (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglWaitClient");\r
- return eglWaitClient();\r
+ return libEGL->eglWaitClient();\r
}\r
\r
EGLBoolean EGLAPIENTRY eglReleaseThread(void)\r
{\r
- static auto eglReleaseThread = (EGLBoolean (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglReleaseThread");\r
- return eglReleaseThread();\r
+ return libEGL->eglReleaseThread();\r
}\r
\r
EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)\r
{\r
- static auto eglCreatePbufferFromClientBuffer = (EGLSurface (EGLAPIENTRY*)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreatePbufferFromClientBuffer");\r
- return eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);\r
+ return libEGL->eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)\r
{\r
- static auto eglSurfaceAttrib = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value))getProcAddress(libEGL, "eglSurfaceAttrib");\r
- return eglSurfaceAttrib(dpy, surface, attribute, value);\r
+ return libEGL->eglSurfaceAttrib(dpy, surface, attribute, value);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)\r
{\r
- static auto eglBindTexImage = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLint buffer))getProcAddress(libEGL, "eglBindTexImage");\r
- return eglBindTexImage(dpy, surface, buffer);\r
+ return libEGL->eglBindTexImage(dpy, surface, buffer);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)\r
{\r
- static auto eglReleaseTexImage = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLint buffer))getProcAddress(libEGL, "eglReleaseTexImage");\r
- return eglReleaseTexImage(dpy, surface, buffer);\r
+ return libEGL->eglReleaseTexImage(dpy, surface, buffer);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)\r
{\r
- static auto eglSwapInterval = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLint interval))getProcAddress(libEGL, "eglSwapInterval");\r
- return eglSwapInterval(dpy, interval);\r
+ return libEGL->eglSwapInterval(dpy, interval);\r
}\r
\r
EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)\r
{\r
- static auto eglCreateContext = (EGLContext (EGLAPIENTRY*)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreateContext");\r
- return eglCreateContext(dpy, config, share_context, attrib_list);\r
+ return libEGL->eglCreateContext(dpy, config, share_context, attrib_list);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)\r
{\r
- static auto eglDestroyContext = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLContext ctx))getProcAddress(libEGL, "eglDestroyContext");\r
- return eglDestroyContext(dpy, ctx);\r
+ return libEGL->eglDestroyContext(dpy, ctx);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)\r
{\r
- static auto eglMakeCurrent = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx))getProcAddress(libEGL, "eglMakeCurrent");\r
- return eglMakeCurrent(dpy, draw, read, ctx);\r
+ return libEGL->eglMakeCurrent(dpy, draw, read, ctx);\r
}\r
\r
EGLContext EGLAPIENTRY eglGetCurrentContext(void)\r
{\r
- static auto eglGetCurrentContext = (EGLContext (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglGetCurrentContext");\r
- return eglGetCurrentContext();\r
+ return libEGL->eglGetCurrentContext();\r
}\r
\r
EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)\r
{\r
- static auto eglGetCurrentSurface = (EGLSurface (EGLAPIENTRY*)(EGLint readdraw))getProcAddress(libEGL, "eglGetCurrentSurface");\r
- return eglGetCurrentSurface(readdraw);\r
+ return libEGL->eglGetCurrentSurface(readdraw);\r
}\r
\r
EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)\r
{\r
- static auto eglGetCurrentDisplay = (EGLDisplay (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglGetCurrentDisplay");\r
- return eglGetCurrentDisplay();\r
+ return libEGL->eglGetCurrentDisplay();\r
}\r
\r
EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)\r
{\r
- static auto eglQueryContext = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value))getProcAddress(libEGL, "eglQueryContext");\r
- return eglQueryContext(dpy, ctx, attribute, value);\r
+ return libEGL->eglQueryContext(dpy, ctx, attribute, value);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglWaitGL(void)\r
{\r
- static auto eglWaitGL = (EGLBoolean (EGLAPIENTRY*)(void))getProcAddress(libEGL, "eglWaitGL");\r
- return eglWaitGL();\r
+ return libEGL->eglWaitGL();\r
}\r
\r
EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)\r
{\r
- static auto eglWaitNative = (EGLBoolean (EGLAPIENTRY*)(EGLint engine))getProcAddress(libEGL, "eglWaitNative");\r
- return eglWaitNative(engine);\r
+ return libEGL->eglWaitNative(engine);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)\r
{\r
- static auto eglSwapBuffers = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface))getProcAddress(libEGL, "eglSwapBuffers");\r
- return eglSwapBuffers(dpy, surface);\r
+ return libEGL->eglSwapBuffers(dpy, surface);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)\r
{\r
- static auto eglCopyBuffers = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target))getProcAddress(libEGL, "eglCopyBuffers");\r
- return eglCopyBuffers(dpy, surface, target);\r
+ return libEGL->eglCopyBuffers(dpy, surface, target);\r
}\r
\r
EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)\r
{\r
- static auto eglCreateImageKHR = (EGLImageKHR (EGLAPIENTRY*)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list))getProcAddress(libEGL, "eglCreateImageKHR");\r
- return eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);\r
+ return libEGL->eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);\r
}\r
\r
EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)\r
{\r
- static auto eglDestroyImageKHR = (EGLBoolean (EGLAPIENTRY*)(EGLDisplay dpy, EGLImageKHR image))getProcAddress(libEGL, "eglDestroyImageKHR");\r
- return eglDestroyImageKHR(dpy, image);\r
+ return libEGL->eglDestroyImageKHR(dpy, image);\r
}\r
\r
__eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)\r
{\r
- static auto eglGetProcAddress = (__eglMustCastToProperFunctionPointerType (EGLAPIENTRY*)(const char*))getProcAddress(libEGL, "eglGetProcAddress");\r
- return eglGetProcAddress(procname);\r
+ return libEGL->eglGetProcAddress(procname);\r
}\r
\r
void GL_APIENTRY glActiveTexture(GLenum texture)\r
UNIMPLEMENTED();\r
}\r
\r
-__eglMustCastToProperFunctionPointerType glGetProcAddress(const char *procname)\r
+__eglMustCastToProperFunctionPointerType es1GetProcAddress(const char *procname)\r
{\r
struct Extension\r
{\r
glDrawTexfOES
glDrawTexfvOES
- ; EGL dependencies
- glCreateContext
- glGetProcAddress
-
- createFrameBuffer
- createBackBuffer
- createDepthStencil
+ libGLES_CMexports
Register
\ No newline at end of file
--- /dev/null
+#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
<ClInclude Include="Framebuffer.h" />\r
<ClInclude Include="Image.hpp" />\r
<ClInclude Include="IndexDataManager.h" />\r
+ <ClInclude Include="libGLES_CM.hpp" />\r
<ClInclude Include="main.h" />\r
<ClInclude Include="mathutil.h" />\r
<ClInclude Include="Renderbuffer.h" />\r
<ClInclude Include="..\common\MatrixStack.hpp">\r
<Filter>Header Files</Filter>\r
</ClInclude>\r
+ <ClInclude Include="libGLES_CM.hpp">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
</ItemGroup>\r
<ItemGroup>\r
<ResourceCompile Include="libGLES_CM.rc" />\r
\r
#include "main.h"\r
\r
+#include "libGLES_CM.hpp"\r
#include "Framebuffer.h"\r
#include "libEGL/Surface.h"\r
#include "Common/Thread.hpp"\r
#include "Common/SharedLibrary.hpp"\r
#include "common/debug.h"\r
\r
+#define GL_GLEXT_PROTOTYPES\r
+#include <GLES/glext.h>\r
+\r
#if !defined(_MSC_VER)\r
#define CONSTRUCTOR __attribute__((constructor))\r
#define DESTRUCTOR __attribute__((destructor))\r
TRACE("()");\r
}\r
\r
-CONSTRUCTOR static bool glAttachProcess()\r
+CONSTRUCTOR static void glAttachProcess()\r
{\r
TRACE("()");\r
\r
glAttachThread();\r
-\r
- #if defined(_WIN32)\r
- const char *libEGL_lib[] = {"libEGL.dll", "libEGL_translator.dll"};\r
- #elif defined(__ANDROID__)\r
- const char *libEGL_lib[] = {"/vendor/lib/egl/libEGL_swiftshader.so"};\r
- #elif defined(__LP64__)\r
- const char *libEGL_lib[] = {"lib64EGL_translator.so", "libEGL.so.1", "libEGL.so"};\r
- #else\r
- const char *libEGL_lib[] = {"libEGL_translator.so", "libEGL.so.1", "libEGL.so"};\r
- #endif\r
-\r
- libEGL = loadLibrary(libEGL_lib);\r
- egl::getCurrentContext = (egl::Context *(*)())getProcAddress(libEGL, "clientGetCurrentContext");\r
- egl::getCurrentDisplay = (egl::Display *(*)())getProcAddress(libEGL, "clientGetCurrentDisplay");\r
-\r
- return libEGL != 0;\r
}\r
\r
DESTRUCTOR static void glDetachProcess()\r
TRACE("()");\r
\r
glDetachThread();\r
- freeLibrary(libEGL);\r
}\r
\r
#if defined(_WIN32)\r
switch(reason)\r
{\r
case DLL_PROCESS_ATTACH:\r
- return glAttachProcess();\r
+ glAttachProcess();\r
break;\r
case DLL_THREAD_ATTACH:\r
glAttachThread();\r
{\r
es1::Context *getContext()\r
{\r
- egl::Context *context = egl::getCurrentContext();\r
+ egl::Context *context = libEGL->clientGetCurrentContext();\r
\r
if(context && context->getClientVersion() == 1)\r
{\r
\r
egl::Display *getDisplay()\r
{\r
- return egl::getCurrentDisplay();\r
+ return libEGL->clientGetCurrentDisplay();\r
}\r
\r
Device *getDevice()\r
\r
return context ? context->getDevice() : 0;\r
}\r
-}\r
\r
// Records an error code\r
void error(GLenum errorCode)\r
}\r
}\r
}\r
+}\r
+\r
+egl::Context *es1CreateContext(const egl::Config *config, const egl::Context *shareContext);\r
+extern "C" __eglMustCastToProperFunctionPointerType es1GetProcAddress(const char *procname);\r
+egl::Image *createBackBuffer(int width, int height, const egl::Config *config);\r
+egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);\r
+sw::FrameBuffer *createFrameBuffer(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);\r
+\r
+LibGLES_CMexports::LibGLES_CMexports()\r
+{\r
+ this->es1CreateContext = ::es1CreateContext;\r
+ this->es1GetProcAddress = ::es1GetProcAddress;\r
+ this->createBackBuffer = ::createBackBuffer;\r
+ this->createDepthStencil = ::createDepthStencil;\r
+ this->createFrameBuffer = ::createFrameBuffer;\r
+ this->glEGLImageTargetTexture2DOES = ::glEGLImageTargetTexture2DOES;\r
+}\r
\r
-namespace egl\r
+extern "C" LibGLES_CMexports *libGLES_CMexports()\r
{\r
- egl::Context *(*getCurrentContext)() = 0;\r
- egl::Display *(*getCurrentDisplay)() = 0;\r
+ static LibGLES_CMexports libGLES_CM;\r
+ return &libGLES_CM;\r
}\r
\r
-void *libEGL = 0; // Handle to the libEGL module\r
+LibEGL libEGL;
\ No newline at end of file
#include "Context.h"
#include "Device.hpp"
#include "common/debug.h"
+#include "libEGL/libEGL.hpp"
#include "libEGL/Display.h"
#define GL_API
Context *getContext();
egl::Display *getDisplay();
Device *getDevice();
-}
-void error(GLenum errorCode);
+ void error(GLenum errorCode);
-template<class T>
-const T &error(GLenum errorCode, const T &returnValue)
-{
- error(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)();
+ return returnValue;
+ }
}
-extern void *libEGL; // Handle to the libEGL module
+extern LibEGL libEGL;
#endif // LIBGLES_CM_MAIN_H_
markAllStateDirty();\r
}\r
\r
-EGLint Context::getClientVersion()\r
+EGLint Context::getClientVersion() const\r
{\r
return clientVersion;\r
}\r
\r
}\r
\r
-// Exported functions for use by EGL\r
-extern "C"\r
+egl::Context *es2CreateContext(const egl::Config *config, const egl::Context *shareContext, int clientVersion)\r
{\r
- es2::Context *glCreateContext(const egl::Config *config, const es2::Context *shareContext, int clientVersion)\r
- {\r
- return new es2::Context(config, shareContext, clientVersion);\r
- }\r
+ ASSERT(!shareContext || shareContext->getClientVersion() == clientVersion); // Should be checked by eglCreateContext\r
+ return new es2::Context(config, static_cast<const es2::Context*>(shareContext), clientVersion);\r
}\r
Context(const egl::Config *config, const Context *shareContext, EGLint clientVersion);\r
\r
virtual void makeCurrent(egl::Surface *surface);\r
- virtual EGLint getClientVersion();\r
+ virtual EGLint getClientVersion() const;\r
\r
void markAllStateDirty();\r
\r
\r
}\r
\r
-// Exported functions for use by EGL\r
-extern "C"\r
+egl::Image *createBackBuffer(int width, int height, const egl::Config *config)\r
{\r
- egl::Image *createBackBuffer(int width, int height, const egl::Config *config)\r
+ if(config)\r
{\r
- if(config)\r
- {\r
- return new es2::Image(0, width, height, config->mAlphaSize ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE);\r
- }\r
-\r
- return 0;\r
+ return new es2::Image(0, width, height, config->mAlphaSize ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE);\r
}\r
\r
- egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)\r
+ return 0;\r
+}\r
+\r
+egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)\r
+{\r
+ if(width == 0 || height == 0 || height > OUTLINE_RESOLUTION)\r
{\r
- if(width == 0 || height == 0 || height > OUTLINE_RESOLUTION)\r
- {\r
- ERR("Invalid parameters");\r
- return 0;\r
- }\r
+ ERR("Invalid parameters");\r
+ return 0;\r
+ }\r
\r
- bool lockable = true;\r
-\r
- switch(format)\r
- {\r
- // case sw::FORMAT_D15S1:\r
- case sw::FORMAT_D24S8:\r
- case sw::FORMAT_D24X8:\r
- // case sw::FORMAT_D24X4S4:\r
- case sw::FORMAT_D24FS8:\r
- case sw::FORMAT_D32:\r
- case sw::FORMAT_D16:\r
- lockable = false;\r
- break;\r
- // case sw::FORMAT_S8_LOCKABLE:\r
- // case sw::FORMAT_D16_LOCKABLE:\r
- case sw::FORMAT_D32F_LOCKABLE:\r
- // case sw::FORMAT_D32_LOCKABLE:\r
- case sw::FORMAT_DF24S8:\r
- case sw::FORMAT_DF16S8:\r
- lockable = true;\r
- break;\r
- default:\r
- UNREACHABLE();\r
- }\r
-\r
- es2::Image *surface = new es2::Image(0, width, height, format, multiSampleDepth, lockable, true);\r
+ bool lockable = true;\r
+\r
+ switch(format)\r
+ {\r
+// case sw::FORMAT_D15S1:\r
+ case sw::FORMAT_D24S8:\r
+ case sw::FORMAT_D24X8:\r
+// case sw::FORMAT_D24X4S4:\r
+ case sw::FORMAT_D24FS8:\r
+ case sw::FORMAT_D32:\r
+ case sw::FORMAT_D16:\r
+ lockable = false;\r
+ break;\r
+// case sw::FORMAT_S8_LOCKABLE:\r
+// case sw::FORMAT_D16_LOCKABLE:\r
+ case sw::FORMAT_D32F_LOCKABLE:\r
+// case sw::FORMAT_D32_LOCKABLE:\r
+ case sw::FORMAT_DF24S8:\r
+ case sw::FORMAT_DF16S8:\r
+ lockable = true;\r
+ break;\r
+ default:\r
+ UNREACHABLE();\r
+ }\r
\r
- if(!surface)\r
- {\r
- ERR("Out of memory");\r
- return 0;\r
- }\r
+ es2::Image *surface = new es2::Image(0, width, height, format, multiSampleDepth, lockable, true);\r
\r
- return surface;\r
+ if(!surface)\r
+ {\r
+ ERR("Out of memory");\r
+ return 0;\r
}\r
+\r
+ return surface;\r
}\r
+\r
glEGLImageTargetTexture2DOES;
glEGLImageTargetRenderbufferStorageOES;
- # EGL dependencies
- glCreateContext;
- glGetProcAddress;
-
- createFrameBuffer;
- createBackBuffer;
- createDepthStencil;
+ libGLESv2exports;
Register;
<Unit filename="VertexDataManager.h" />
<Unit filename="exports.map" />
<Unit filename="libGLESv2.cpp" />
+ <Unit filename="libGLESv2.hpp" />
<Unit filename="main.cpp" />
<Unit filename="main.h" />
<Unit filename="mathutil.h" />
#include <cutils/log.h>\r
#endif\r
\r
+using namespace es2;\r
+\r
typedef std::pair<GLenum, GLenum> InternalFormatTypePair;\r
typedef std::map<InternalFormatTypePair, GLenum> FormatMap;\r
\r
{\r
if(egl::getClientVersion() == 1)\r
{\r
- static auto glEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)es1::getProcAddress("glEGLImageTargetTexture2DOES");\r
- return glEGLImageTargetTexture2DOES(target, image);\r
+ return libGLES_CM->glEGLImageTargetTexture2DOES(target, image);\r
}\r
\r
TRACE("(GLenum target = 0x%X, GLeglImageOES image = 0x%0.8p)", target, image);\r
UNIMPLEMENTED();\r
}\r
\r
-__eglMustCastToProperFunctionPointerType glGetProcAddress(const char *procname)\r
+__eglMustCastToProperFunctionPointerType es2GetProcAddress(const char *procname)\r
{\r
struct Extension\r
{\r
glTexStorage3D @304
glGetInternalformativ @308
- ; EGL dependencies
- glCreateContext
- glGetProcAddress
-
- createFrameBuffer
- createBackBuffer
- createDepthStencil
+ libGLESv2exports
Register
\ No newline at end of file
--- /dev/null
+#ifndef libGLESv2_hpp
+#define libGLESv2_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 LibGLESv2exports
+{
+public:
+ LibGLESv2exports();
+
+ egl::Context *(*es2CreateContext)(const egl::Config *config, const egl::Context *shareContext, int clientVersion);
+ __eglMustCastToProperFunctionPointerType (*es2GetProcAddress)(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);
+};
+
+class LibGLESv2
+{
+public:
+ LibGLESv2()
+ {
+ libGLESv2 = nullptr;
+ libGLESv2exports = nullptr;
+ }
+
+ ~LibGLESv2()
+ {
+ freeLibrary(libGLESv2);
+ }
+
+ operator bool()
+ {
+ return loadExports();
+ }
+
+ LibGLESv2exports *operator->()
+ {
+ return loadExports();
+ }
+
+private:
+ LibGLESv2exports *loadExports()
+ {
+ if(!libGLESv2)
+ {
+ #if defined(_WIN32)
+ const char *libGLESv2_lib[] = {"libGLESv2.dll", "libGLES_V2_translator.dll"};
+ #elif defined(__ANDROID__)
+ const char *libGLESv2_lib[] = {"/vendor/lib/egl/libGLESv2_swiftshader.so"};
+ #elif defined(__LP64__)
+ const char *libGLESv2_lib[] = {"lib64GLES_V2_translator.so", "libGLESv2.so.2", "libGLESv2.so"};
+ #else
+ const char *libGLESv2_lib[] = {"libGLES_V2_translator.so", "libGLESv2.so.2", "libGLESv2.so"};
+ #endif
+
+ libGLESv2 = loadLibrary(libGLESv2_lib);
+
+ if(libGLESv2)
+ {
+ auto libGLESv2exportsProc = (LibGLESv2exports *(*)())getProcAddress(libGLESv2, "libGLESv2exports");
+ libGLESv2exports = libGLESv2exportsProc();
+ }
+ }
+
+ return libGLESv2exports;
+ }
+
+ void *libGLESv2;
+ LibGLESv2exports *libGLESv2exports;
+};
+
+#endif // libGLESv2_hpp
<ClInclude Include="Framebuffer.h" />\r
<ClInclude Include="Image.hpp" />\r
<ClInclude Include="IndexDataManager.h" />\r
+ <ClInclude Include="libGLESv2.hpp" />\r
<ClInclude Include="main.h" />\r
<ClInclude Include="mathutil.h" />\r
<ClInclude Include="Program.h" />\r
<ClInclude Include="VertexArray.h">\r
<Filter>Header Files</Filter>\r
</ClInclude>\r
+ <ClInclude Include="libGLESv2.hpp">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
</ItemGroup>\r
<ItemGroup>\r
<ResourceCompile Include="libGLESv2.rc" />\r
#include <GLES3/gl3.h>\r
#include <GLES2/gl2ext.h>\r
\r
+using namespace es2;\r
+\r
typedef std::pair<GLenum, GLenum> InternalFormatTypePair;\r
typedef std::map<InternalFormatTypePair, GLenum> FormatMap;\r
\r
\r
#include "main.h"\r
\r
+#include "libGLESv2.hpp"\r
#include "Framebuffer.h"\r
+#include "libEGL/main.h"\r
#include "libEGL/Surface.h"\r
#include "Common/Thread.hpp"\r
#include "Common/SharedLibrary.hpp"\r
TRACE("()");\r
}\r
\r
-CONSTRUCTOR static bool glAttachProcess()\r
+CONSTRUCTOR static void glAttachProcess()\r
{\r
TRACE("()");\r
\r
glAttachThread();\r
-\r
- #if defined(_WIN32)\r
- const char *libEGL_lib[] = {"libEGL.dll", "libEGL_translator.dll"};\r
- #elif defined(__ANDROID__)\r
- const char *libEGL_lib[] = {"/vendor/lib/egl/libEGL_swiftshader.so"};\r
- #elif defined(__LP64__)\r
- const char *libEGL_lib[] = {"lib64EGL_translator.so", "libEGL.so.1", "libEGL.so"};\r
- #else\r
- const char *libEGL_lib[] = {"libEGL_translator.so", "libEGL.so.1", "libEGL.so"};\r
- #endif\r
-\r
- libEGL = loadLibrary(libEGL_lib);\r
- egl::getCurrentContext = (egl::Context *(*)())getProcAddress(libEGL, "clientGetCurrentContext");\r
- egl::getCurrentDisplay = (egl::Display *(*)())getProcAddress(libEGL, "clientGetCurrentDisplay");\r
-\r
- #if defined(_WIN32)\r
- const char *libGLES_CM_lib[] = {"libGLES_CM.dll", "libGLES_CM_translator.dll"};\r
- #elif defined(__ANDROID__)\r
- const char *libGLES_CM_lib[] = {"/vendor/lib/egl/libGLESv1_CM_swiftshader.so"};\r
- #elif defined(__LP64__)\r
- const char *libGLES_CM_lib[] = {"lib64GLES_CM_translator.so", "libGLES_CM.so.1", "libGLES_CM.so"};\r
- #else\r
- const char *libGLES_CM_lib[] = {"libGLES_CM_translator.so", "libGLES_CM.so.1", "libGLES_CM.so"};\r
- #endif\r
-\r
- libGLES_CM = loadLibrary(libGLES_CM_lib);\r
- es1::getProcAddress = (__eglMustCastToProperFunctionPointerType (*)(const char*))getProcAddress(libGLES_CM, "glGetProcAddress");\r
-\r
- return libEGL != 0;\r
}\r
\r
DESTRUCTOR static void glDetachProcess()\r
TRACE("()");\r
\r
glDetachThread();\r
- freeLibrary(libEGL);\r
- freeLibrary(libGLES_CM);\r
}\r
\r
#if defined(_WIN32)\r
switch(reason)\r
{\r
case DLL_PROCESS_ATTACH:\r
- return glAttachProcess();\r
+ glAttachProcess();\r
break;\r
case DLL_THREAD_ATTACH:\r
glAttachThread();\r
{\r
es2::Context *getContext()\r
{\r
- egl::Context *context = egl::getCurrentContext();\r
+ egl::Context *context = libEGL->clientGetCurrentContext();\r
\r
if(context && (context->getClientVersion() == 2 ||\r
context->getClientVersion() == 3))\r
\r
egl::Display *getDisplay()\r
{\r
- return egl::getCurrentDisplay();\r
+ return libEGL->clientGetCurrentDisplay();\r
}\r
\r
Device *getDevice()\r
\r
return context ? context->getDevice() : 0;\r
}\r
-}\r
-\r
-namespace egl\r
-{\r
-GLint getClientVersion()\r
-{\r
- Context *context = egl::getCurrentContext();\r
-\r
- return context ? context->getClientVersion() : 0;\r
-}\r
-}\r
\r
// Records an error code\r
void error(GLenum errorCode)\r
}\r
}\r
}\r
+}\r
\r
namespace egl\r
{\r
- egl::Context *(*getCurrentContext)() = 0;\r
- egl::Display *(*getCurrentDisplay)() = 0;\r
+GLint getClientVersion()\r
+{\r
+ Context *context = libEGL->clientGetCurrentContext();\r
+\r
+ return context ? context->getClientVersion() : 0;\r
+}\r
+}\r
+\r
+egl::Context *es2CreateContext(const egl::Config *config, const egl::Context *shareContext, int clientVersion);\r
+extern "C" __eglMustCastToProperFunctionPointerType es2GetProcAddress(const char *procname);\r
+egl::Image *createBackBuffer(int width, int height, const egl::Config *config);\r
+egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);\r
+sw::FrameBuffer *createFrameBuffer(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);\r
+\r
+LibGLESv2exports::LibGLESv2exports()\r
+{\r
+ this->es2CreateContext = ::es2CreateContext;\r
+ this->es2GetProcAddress = ::es2GetProcAddress;\r
+ this->createBackBuffer = ::createBackBuffer;\r
+ this->createDepthStencil = ::createDepthStencil;\r
+ this->createFrameBuffer = ::createFrameBuffer;\r
}\r
\r
-namespace es1\r
+extern "C" LibGLESv2exports *libGLESv2exports()\r
{\r
- __eglMustCastToProperFunctionPointerType (*getProcAddress)(const char *procname) = 0;\r
+ static LibGLESv2exports libGLESv2;\r
+ return &libGLESv2;\r
}\r
\r
-void *libEGL = 0; // Handle to the libEGL module\r
-void *libGLES_CM = 0; // Handle to the libGLES_CM module\r
+LibEGL libEGL;\r
+LibGLES_CM libGLES_CM;
\ No newline at end of file
#include "Context.h"
#include "Device.hpp"
#include "common/debug.h"
+#include "libEGL/libEGL.hpp"
#include "libEGL/Display.h"
+#include "libGLES_CM/libGLES_CM.hpp"
#define GL_APICALL
#include <GLES2/gl2.h>
Context *getContext();
egl::Display *getDisplay();
Device *getDevice();
-}
-namespace egl
-{
- GLint getClientVersion();
-}
+ void error(GLenum errorCode);
-void error(GLenum errorCode);
+ template<class T>
+ const T &error(GLenum errorCode, const T &returnValue)
+ {
+ error(errorCode);
-template<class T>
-const T &error(GLenum errorCode, const T &returnValue)
-{
- error(errorCode);
-
- return returnValue;
+ return returnValue;
+ }
}
-// libEGL dependencies
namespace egl
{
- extern egl::Context *(*getCurrentContext)();
- extern egl::Display *(*getCurrentDisplay)();
-}
-
-// libGLES_CM dependencies
-namespace es1
-{
- extern __eglMustCastToProperFunctionPointerType (*getProcAddress)(const char *procname);
+ GLint getClientVersion();
}
-extern void *libEGL; // Handle to the libEGL module
-extern void *libGLES_CM; // Handle to the libGLES_CM module
+extern LibEGL libEGL;
+extern LibGLES_CM libGLES_CM;
#endif // LIBGLESV2_MAIN_H_
{\r
es2::Image *createBackBuffer(int width, int height, const egl::Config *config);\r
es2::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);\r
- #if defined(_WIN32)\r
- sw::FrameBuffer *createFrameBuffer(HDC display, HWND window, int width, int height);\r
- #else\r
- sw::FrameBuffer *createFrameBuffer(void *display, Window window, int width, int height);\r
- #endif\r
-}\r
+}
+
+#if defined(_WIN32)\r
+sw::FrameBuffer *createFrameBuffer(HDC display, HWND window, int width, int height);\r
+#else\r
+sw::FrameBuffer *createFrameBuffer(Display *display, Window window, int width, int height);\r
+#endif\r
\r
namespace egl\r
{\r
<Add directory="./../../Shader/" />
<Add directory="./../../Main/" />
<Add directory="./../../OpenGL/" />
+ <Add directory="./../../OpenGL/include" />
</Compiler>
<Linker>
<Add option="-Wl,--version-script=./exports.map" />
OSDN Git Service
