Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

switched to new glad2

Browse Source
This commit is contained in:
Max Argus
2018-06-15 11:01:11 +02:00
parent 5dbf2373ad
commit f0e7f266ef
9 changed files with 9538 additions and 9259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
examples/OpenGLWindow/EGLOpenGLWindow.cpp
View File

@@ -102,7 +102,7 @@ void EGLOpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci) {
}; };
// Load EGL functions // Load EGL functions
int egl_version = gladLoadEGLInternalLoader(NULL); int egl_version = gladLoaderLoadEGL(NULL);
if(!egl_version) { if(!egl_version) {
fprintf(stderr, "failed to EGL with glad.\n"); fprintf(stderr, "failed to EGL with glad.\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
@@ -157,7 +157,7 @@ void EGLOpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci) {
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
egl_version = gladLoadEGLInternalLoader(m_data->egl_display); egl_version = gladLoaderLoadEGL(m_data->egl_display);
if (!egl_version) { if (!egl_version) {
fprintf(stderr, "Unable to reload EGL.\n"); fprintf(stderr, "Unable to reload EGL.\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
@@ -187,7 +187,7 @@ void EGLOpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci) {
fprintf(stderr, "Didn't get exactly one config, but %d\n", m_data->num_configs); fprintf(stderr, "Didn't get exactly one config, but %d\n", m_data->num_configs);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
m_data->egl_surface = eglCreatePbufferSurface( m_data->egl_surface = eglCreatePbufferSurface(
m_data->egl_display, m_data->egl_config, egl_pbuffer_attribs); m_data->egl_display, m_data->egl_config, egl_pbuffer_attribs);
if (m_data->egl_surface == EGL_NO_SURFACE) { if (m_data->egl_surface == EGL_NO_SURFACE) {
@@ -202,15 +202,20 @@ void EGLOpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci) {
fprintf(stderr, "Unable to create EGL context (eglError: %d)\n",eglGetError()); fprintf(stderr, "Unable to create EGL context (eglError: %d)\n",eglGetError());
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
eglMakeCurrent(m_data->egl_display, m_data->egl_surface, m_data->egl_surface, m_data->success =
eglMakeCurrent(m_data->egl_display, m_data->egl_surface, m_data->egl_surface,
m_data->egl_context); m_data->egl_context);
printf("Finish creating EGL OpenGL window.\n"); if (!m_data->success) {
fprintf(stderr, "Failed to make context current (eglError: %d)\n", eglGetError());
if (!gladLoadGL(eglGetProcAddress)) {
fprintf(stderr, "failed to GL with glad.\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if (!gladLoadGL(eglGetProcAddress)) {
fprintf(stderr, "failed to load GL with glad.\n");
exit(EXIT_FAILURE);
}
const GLubyte* ven = glGetString(GL_VENDOR); const GLubyte* ven = glGetString(GL_VENDOR);
printf("GL_VENDOR=%s\n", ven); printf("GL_VENDOR=%s\n", ven);

4
examples/OpenGLWindow/X11OpenGLWindow.cpp
View File

@@ -473,7 +473,7 @@ void X11OpenGLWindow::enableOpenGL()
glXMakeCurrent(m_data->m_dpy, m_data->m_win, m_data->m_glc); glXMakeCurrent(m_data->m_dpy, m_data->m_win, m_data->m_glc);
} }
if(!gladLoadGLInternalLoader()) { if(!gladLoaderLoadGL()) {
printf("gladLoadGL failed!\n"); printf("gladLoadGL failed!\n");
exit(-1); exit(-1);
} }
@@ -524,7 +524,7 @@ void X11OpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci)
#ifdef GLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS #ifdef GLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS
int res=gladLoadGLXInternalLoader(m_data->m_dpy,DefaultScreen(m_data->m_dpy)); int res=gladLoaderLoadGLX(m_data->m_dpy,DefaultScreen(m_data->m_dpy));
if (!res) if (!res)
{ {
printf("Error in gladLoadGLX\n"); printf("Error in gladLoadGLX\n");

376
examples/ThirdPartyLibs/glad/egl.c
View File

@@ -3,6 +3,23 @@
#include <string.h> #include <string.h>
#include <glad/egl.h> #include <glad/egl.h>
#ifndef GLAD_IMPL_UTIL_C_
#define GLAD_IMPL_UTIL_C_
#if _MSC_VER >= 1400
#define GLAD_IMPL_UTIL_STRNCPY(dest, source, len) strncpy_s(dest, len, source, len-1);
#else
#define GLAD_IMPL_UTIL_STRNCPY(dest, source, len) strncpy(dest, source, len);
#endif
#ifdef _MSC_VER
#define GLAD_IMPL_UTIL_SSCANF sscanf_s
#else
#define GLAD_IMPL_UTIL_SSCANF sscanf
#endif
#endif /* GLAD_IMPL_UTIL_C_ */
int GLAD_EGL_VERSION_1_0; int GLAD_EGL_VERSION_1_0;
int GLAD_EGL_VERSION_1_1; int GLAD_EGL_VERSION_1_1;
@@ -10,177 +27,175 @@ int GLAD_EGL_VERSION_1_2;
int GLAD_EGL_VERSION_1_3; int GLAD_EGL_VERSION_1_3;
int GLAD_EGL_VERSION_1_4; int GLAD_EGL_VERSION_1_4;
int GLAD_EGL_VERSION_1_5; int GLAD_EGL_VERSION_1_5;
int GLAD_EGL_EXT_device_base; int GLAD_EGL_EXT_platform_device;
int GLAD_EGL_EXT_platform_base;
int GLAD_EGL_NV_device_cuda;
int GLAD_EGL_EXT_device_enumeration; int GLAD_EGL_EXT_device_enumeration;
int GLAD_EGL_EXT_device_query; int GLAD_EGL_EXT_device_query;
int GLAD_EGL_EXT_platform_base; int GLAD_EGL_EXT_device_base;
int GLAD_EGL_EXT_platform_device;
int GLAD_EGL_NV_cuda_event; int GLAD_EGL_NV_cuda_event;
int GLAD_EGL_NV_device_cuda;
PFNEGLWAITNATIVEPROC glad_eglWaitNative;
PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface; PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT;
PFNEGLQUERYSTRINGPROC glad_eglQueryString; PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface;
PFNEGLINITIALIZEPROC glad_eglInitialize; PFNEGLGETERRORPROC glad_eglGetError;
PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress;
PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay;
PFNEGLQUERYAPIPROC glad_eglQueryAPI;
PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface;
PFNEGLQUERYDISPLAYATTRIBKHRPROC glad_eglQueryDisplayAttribKHR;
PFNEGLDESTROYSYNCPROC glad_eglDestroySync;
PFNEGLCREATEIMAGEPROC glad_eglCreateImage;
PFNEGLQUERYCONTEXTPROC glad_eglQueryContext; PFNEGLQUERYCONTEXTPROC glad_eglQueryContext;
PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers;
PFNEGLCREATECONTEXTPROC glad_eglCreateContext;
PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig;
PFNEGLBINDAPIPROC glad_eglBindAPI;
PFNEGLWAITNATIVEPROC glad_eglWaitNative;
PFNEGLTERMINATEPROC glad_eglTerminate;
PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT;
PFNEGLRELEASETHREADPROC glad_eglReleaseThread;
PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface;
PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib;
PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface; PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface;
PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers;
PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT;
PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT;
PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface;
PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage;
PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay;
PFNEGLGETDISPLAYPROC glad_eglGetDisplay;
PFNEGLQUERYSTRINGPROC glad_eglQueryString;
PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync;
PFNEGLWAITSYNCPROC glad_eglWaitSync;
PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage;
PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage;
PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT;
PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext;
PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT;
PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface;
PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext;
PFNEGLINITIALIZEPROC glad_eglInitialize;
PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface;
PFNEGLMAKECURRENTPROC glad_eglMakeCurrent;
PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT;
PFNEGLSWAPINTERVALPROC glad_eglSwapInterval; PFNEGLSWAPINTERVALPROC glad_eglSwapInterval;
PFNEGLCREATESYNCPROC glad_eglCreateSync; PFNEGLCREATESYNCPROC glad_eglCreateSync;
PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig;
PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface;
PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib;
PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT;
PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface;
PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer;
PFNEGLMAKECURRENTPROC glad_eglMakeCurrent;
PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay;
PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage;
PFNEGLGETERRORPROC glad_eglGetError;
PFNEGLWAITSYNCPROC glad_eglWaitSync;
PFNEGLWAITGLPROC glad_eglWaitGL;
PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress;
PFNEGLCREATECONTEXTPROC glad_eglCreateContext;
PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext;
PFNEGLBINDAPIPROC glad_eglBindAPI;
PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext;
PFNEGLGETCONFIGSPROC glad_eglGetConfigs;
PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT;
PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface;
PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib; PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib;
PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT;
PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT;
PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage;
PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface;
PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers;
PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT;
PFNEGLGETDISPLAYPROC glad_eglGetDisplay;
PFNEGLCREATEIMAGEPROC glad_eglCreateImage;
PFNEGLWAITCLIENTPROC glad_eglWaitClient;
PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay;
PFNEGLTERMINATEPROC glad_eglTerminate;
PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage;
PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT;
PFNEGLQUERYSURFACEPROC glad_eglQuerySurface;
PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers;
PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync;
PFNEGLRELEASETHREADPROC glad_eglReleaseThread;
PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface;
PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT;
PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib; PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib;
PFNEGLQUERYAPIPROC glad_eglQueryAPI; PFNEGLWAITGLPROC glad_eglWaitGL;
PFNEGLDESTROYSYNCPROC glad_eglDestroySync; PFNEGLQUERYSURFACEPROC glad_eglQuerySurface;
PFNEGLGETCONFIGSPROC glad_eglGetConfigs;
PFNEGLWAITCLIENTPROC glad_eglWaitClient;
PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer;
static void load_EGL_VERSION_1_0(GLADloadproc load, void* userptr) {
static void load_EGL_VERSION_1_0( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_EGL_VERSION_1_0) return; if(!GLAD_EGL_VERSION_1_0) return;
glad_eglWaitNative = (PFNEGLWAITNATIVEPROC)load("eglWaitNative", userptr); eglCreatePbufferSurface = (PFNEGLCREATEPBUFFERSURFACEPROC) load("eglCreatePbufferSurface", userptr);
glad_eglCreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)load("eglCreateWindowSurface", userptr); eglGetError = (PFNEGLGETERRORPROC) load("eglGetError", userptr);
glad_eglQueryString = (PFNEGLQUERYSTRINGPROC)load("eglQueryString", userptr); eglGetProcAddress = (PFNEGLGETPROCADDRESSPROC) load("eglGetProcAddress", userptr);
glad_eglInitialize = (PFNEGLINITIALIZEPROC)load("eglInitialize", userptr); eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) load("eglGetCurrentDisplay", userptr);
glad_eglQueryContext = (PFNEGLQUERYCONTEXTPROC)load("eglQueryContext", userptr); eglQueryContext = (PFNEGLQUERYCONTEXTPROC) load("eglQueryContext", userptr);
glad_eglGetCurrentSurface = (PFNEGLGETCURRENTSURFACEPROC)load("eglGetCurrentSurface", userptr); eglSwapBuffers = (PFNEGLSWAPBUFFERSPROC) load("eglSwapBuffers", userptr);
glad_eglChooseConfig = (PFNEGLCHOOSECONFIGPROC)load("eglChooseConfig", userptr); eglCreateContext = (PFNEGLCREATECONTEXTPROC) load("eglCreateContext", userptr);
glad_eglCreatePixmapSurface = (PFNEGLCREATEPIXMAPSURFACEPROC)load("eglCreatePixmapSurface", userptr); eglChooseConfig = (PFNEGLCHOOSECONFIGPROC) load("eglChooseConfig", userptr);
glad_eglGetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)load("eglGetConfigAttrib", userptr); eglWaitNative = (PFNEGLWAITNATIVEPROC) load("eglWaitNative", userptr);
glad_eglCreatePbufferSurface = (PFNEGLCREATEPBUFFERSURFACEPROC)load("eglCreatePbufferSurface", userptr); eglTerminate = (PFNEGLTERMINATEPROC) load("eglTerminate", userptr);
glad_eglMakeCurrent = (PFNEGLMAKECURRENTPROC)load("eglMakeCurrent", userptr); eglCopyBuffers = (PFNEGLCOPYBUFFERSPROC) load("eglCopyBuffers", userptr);
glad_eglGetError = (PFNEGLGETERRORPROC)load("eglGetError", userptr); eglGetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC) load("eglGetConfigAttrib", userptr);
glad_eglWaitGL = (PFNEGLWAITGLPROC)load("eglWaitGL", userptr); eglGetCurrentSurface = (PFNEGLGETCURRENTSURFACEPROC) load("eglGetCurrentSurface", userptr);
glad_eglGetProcAddress = (PFNEGLGETPROCADDRESSPROC)load("eglGetProcAddress", userptr); eglCreatePixmapSurface = (PFNEGLCREATEPIXMAPSURFACEPROC) load("eglCreatePixmapSurface", userptr);
glad_eglCreateContext = (PFNEGLCREATECONTEXTPROC)load("eglCreateContext", userptr); eglGetDisplay = (PFNEGLGETDISPLAYPROC) load("eglGetDisplay", userptr);
glad_eglDestroyContext = (PFNEGLDESTROYCONTEXTPROC)load("eglDestroyContext", userptr); eglQueryString = (PFNEGLQUERYSTRINGPROC) load("eglQueryString", userptr);
glad_eglGetConfigs = (PFNEGLGETCONFIGSPROC)load("eglGetConfigs", userptr); eglDestroyContext = (PFNEGLDESTROYCONTEXTPROC) load("eglDestroyContext", userptr);
glad_eglCopyBuffers = (PFNEGLCOPYBUFFERSPROC)load("eglCopyBuffers", userptr); eglCreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC) load("eglCreateWindowSurface", userptr);
glad_eglGetDisplay = (PFNEGLGETDISPLAYPROC)load("eglGetDisplay", userptr); eglInitialize = (PFNEGLINITIALIZEPROC) load("eglInitialize", userptr);
glad_eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC)load("eglGetCurrentDisplay", userptr); eglDestroySurface = (PFNEGLDESTROYSURFACEPROC) load("eglDestroySurface", userptr);
glad_eglQuerySurface = (PFNEGLQUERYSURFACEPROC)load("eglQuerySurface", userptr); eglMakeCurrent = (PFNEGLMAKECURRENTPROC) load("eglMakeCurrent", userptr);
glad_eglSwapBuffers = (PFNEGLSWAPBUFFERSPROC)load("eglSwapBuffers", userptr); eglWaitGL = (PFNEGLWAITGLPROC) load("eglWaitGL", userptr);
glad_eglTerminate = (PFNEGLTERMINATEPROC)load("eglTerminate", userptr); eglQuerySurface = (PFNEGLQUERYSURFACEPROC) load("eglQuerySurface", userptr);
glad_eglDestroySurface = (PFNEGLDESTROYSURFACEPROC)load("eglDestroySurface", userptr); eglGetConfigs = (PFNEGLGETCONFIGSPROC) load("eglGetConfigs", userptr);
} }
static void load_EGL_VERSION_1_1(GLADloadproc load, void* userptr) { static void load_EGL_VERSION_1_1( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_EGL_VERSION_1_1) return; if(!GLAD_EGL_VERSION_1_1) return;
glad_eglSwapInterval = (PFNEGLSWAPINTERVALPROC)load("eglSwapInterval", userptr); eglReleaseTexImage = (PFNEGLRELEASETEXIMAGEPROC) load("eglReleaseTexImage", userptr);
glad_eglSurfaceAttrib = (PFNEGLSURFACEATTRIBPROC)load("eglSurfaceAttrib", userptr); eglSurfaceAttrib = (PFNEGLSURFACEATTRIBPROC) load("eglSurfaceAttrib", userptr);
glad_eglReleaseTexImage = (PFNEGLRELEASETEXIMAGEPROC)load("eglReleaseTexImage", userptr); eglBindTexImage = (PFNEGLBINDTEXIMAGEPROC) load("eglBindTexImage", userptr);
glad_eglBindTexImage = (PFNEGLBINDTEXIMAGEPROC)load("eglBindTexImage", userptr); eglSwapInterval = (PFNEGLSWAPINTERVALPROC) load("eglSwapInterval", userptr);
} }
static void load_EGL_VERSION_1_2(GLADloadproc load, void* userptr) { static void load_EGL_VERSION_1_2( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_EGL_VERSION_1_2) return; if(!GLAD_EGL_VERSION_1_2) return;
glad_eglBindAPI = (PFNEGLBINDAPIPROC)load("eglBindAPI", userptr); eglBindAPI = (PFNEGLBINDAPIPROC) load("eglBindAPI", userptr);
glad_eglWaitClient = (PFNEGLWAITCLIENTPROC)load("eglWaitClient", userptr); eglQueryAPI = (PFNEGLQUERYAPIPROC) load("eglQueryAPI", userptr);
glad_eglReleaseThread = (PFNEGLRELEASETHREADPROC)load("eglReleaseThread", userptr); eglWaitClient = (PFNEGLWAITCLIENTPROC) load("eglWaitClient", userptr);
glad_eglQueryAPI = (PFNEGLQUERYAPIPROC)load("eglQueryAPI", userptr); eglCreatePbufferFromClientBuffer = (PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC) load("eglCreatePbufferFromClientBuffer", userptr);
glad_eglCreatePbufferFromClientBuffer = (PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)load("eglCreatePbufferFromClientBuffer", userptr); eglReleaseThread = (PFNEGLRELEASETHREADPROC) load("eglReleaseThread", userptr);
} }
static void load_EGL_VERSION_1_3(GLADloadproc load, void* userptr) { static void load_EGL_VERSION_1_4( GLADuserptrloadfunc load, void* userptr) {
}
static void load_EGL_VERSION_1_4(GLADloadproc load, void* userptr) {
if(!GLAD_EGL_VERSION_1_4) return; if(!GLAD_EGL_VERSION_1_4) return;
glad_eglGetCurrentContext = (PFNEGLGETCURRENTCONTEXTPROC)load("eglGetCurrentContext", userptr); eglGetCurrentContext = (PFNEGLGETCURRENTCONTEXTPROC) load("eglGetCurrentContext", userptr);
} }
static void load_EGL_VERSION_1_5(GLADloadproc load, void* userptr) { static void load_EGL_VERSION_1_5( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_EGL_VERSION_1_5) return; if(!GLAD_EGL_VERSION_1_5) return;
glad_eglCreatePlatformWindowSurface = (PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)load("eglCreatePlatformWindowSurface", userptr); eglDestroySync = (PFNEGLDESTROYSYNCPROC) load("eglDestroySync", userptr);
glad_eglWaitSync = (PFNEGLWAITSYNCPROC)load("eglWaitSync", userptr); eglCreateImage = (PFNEGLCREATEIMAGEPROC) load("eglCreateImage", userptr);
glad_eglCreateImage = (PFNEGLCREATEIMAGEPROC)load("eglCreateImage", userptr); eglGetPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYPROC) load("eglGetPlatformDisplay", userptr);
glad_eglDestroyImage = (PFNEGLDESTROYIMAGEPROC)load("eglDestroyImage", userptr); eglDestroyImage = (PFNEGLDESTROYIMAGEPROC) load("eglDestroyImage", userptr);
glad_eglGetPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYPROC)load("eglGetPlatformDisplay", userptr); eglClientWaitSync = (PFNEGLCLIENTWAITSYNCPROC) load("eglClientWaitSync", userptr);
glad_eglClientWaitSync = (PFNEGLCLIENTWAITSYNCPROC)load("eglClientWaitSync", userptr); eglWaitSync = (PFNEGLWAITSYNCPROC) load("eglWaitSync", userptr);
glad_eglCreatePlatformPixmapSurface = (PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)load("eglCreatePlatformPixmapSurface", userptr); eglCreateSync = (PFNEGLCREATESYNCPROC) load("eglCreateSync", userptr);
glad_eglGetSyncAttrib = (PFNEGLGETSYNCATTRIBPROC)load("eglGetSyncAttrib", userptr); eglGetSyncAttrib = (PFNEGLGETSYNCATTRIBPROC) load("eglGetSyncAttrib", userptr);
glad_eglDestroySync = (PFNEGLDESTROYSYNCPROC)load("eglDestroySync", userptr); eglCreatePlatformWindowSurface = (PFNEGLCREATEPLATFORMWINDOWSURFACEPROC) load("eglCreatePlatformWindowSurface", userptr);
glad_eglCreateSync = (PFNEGLCREATESYNCPROC)load("eglCreateSync", userptr); eglCreatePlatformPixmapSurface = (PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC) load("eglCreatePlatformPixmapSurface", userptr);
} }
static void load_EGL_EXT_device_base(GLADloadproc load, void* userptr) { static void load_EGL_EXT_platform_base( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_EGL_EXT_device_base) return;
glad_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)load("eglQueryDevicesEXT", userptr);
glad_eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)load("eglQueryDisplayAttribEXT", userptr);
glad_eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)load("eglQueryDeviceAttribEXT", userptr);
glad_eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)load("eglQueryDeviceStringEXT", userptr);
}
static void load_EGL_EXT_device_enumeration(GLADloadproc load, void* userptr) {
if(!GLAD_EGL_EXT_device_enumeration) return;
glad_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)load("eglQueryDevicesEXT", userptr);
}
static void load_EGL_EXT_device_query(GLADloadproc load, void* userptr) {
if(!GLAD_EGL_EXT_device_query) return;
glad_eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)load("eglQueryDeviceAttribEXT", userptr);
glad_eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)load("eglQueryDisplayAttribEXT", userptr);
glad_eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)load("eglQueryDeviceStringEXT", userptr);
}
static void load_EGL_EXT_platform_base(GLADloadproc load, void* userptr) {
if(!GLAD_EGL_EXT_platform_base) return; if(!GLAD_EGL_EXT_platform_base) return;
glad_eglCreatePlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)load("eglCreatePlatformPixmapSurfaceEXT", userptr); eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC) load("eglCreatePlatformWindowSurfaceEXT", userptr);
glad_eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC)load("eglGetPlatformDisplayEXT", userptr); eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC) load("eglGetPlatformDisplayEXT", userptr);
glad_eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)load("eglCreatePlatformWindowSurfaceEXT", userptr); eglCreatePlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC) load("eglCreatePlatformPixmapSurfaceEXT", userptr);
} }
static void load_EGL_EXT_platform_device(GLADloadproc load, void* userptr) { static void load_EGL_EXT_device_enumeration( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_EGL_EXT_device_enumeration) return;
eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC) load("eglQueryDevicesEXT", userptr);
} }
static void load_EGL_NV_cuda_event(GLADloadproc load, void* userptr) { static void load_EGL_EXT_device_query( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_EGL_EXT_device_query) return;
eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC) load("eglQueryDisplayAttribEXT", userptr);
eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC) load("eglQueryDeviceStringEXT", userptr);
eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC) load("eglQueryDeviceAttribEXT", userptr);
eglQueryDisplayAttribKHR = (PFNEGLQUERYDISPLAYATTRIBKHRPROC) load("eglQueryDisplayAttribKHR", userptr);
} }
static void load_EGL_NV_device_cuda(GLADloadproc load, void* userptr) { static void load_EGL_EXT_device_base( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_EGL_EXT_device_base) return;
eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC) load("eglQueryDisplayAttribEXT", userptr);
eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC) load("eglQueryDevicesEXT", userptr);
eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC) load("eglQueryDeviceStringEXT", userptr);
eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC) load("eglQueryDeviceAttribEXT", userptr);
eglQueryDisplayAttribKHR = (PFNEGLQUERYDISPLAYATTRIBKHRPROC) load("eglQueryDisplayAttribKHR", userptr);
} }
static int get_exts(EGLDisplay display, const char **extensions) { static int get_exts(EGLDisplay display, const char **extensions) {
*extensions = eglQueryString(display, EGL_EXTENSIONS); *extensions = eglQueryString(display, EGL_EXTENSIONS);
return extensions != NULL; return extensions != NULL;
} }
static int has_ext(const char *extensions, const char *name) { static int has_ext(const char *extensions, const char *ext) {
const char *loc; const char *loc;
const char *terminator; const char *terminator;
if(extensions == NULL) { if(extensions == NULL) {
return 0; return 0;
} }
while(1) { while(1) {
loc = strstr(extensions, extensions); loc = strstr(extensions, ext);
if(loc == NULL) { if(loc == NULL) {
return 0; return 0;
} }
terminator = loc + strlen(extensions); terminator = loc + strlen(ext);
if((loc == extensions || *(loc - 1) == ' ') && if((loc == extensions || *(loc - 1) == ' ') &&
(*terminator == ' ' || *terminator == '\0')) { (*terminator == ' ' || *terminator == '\0')) {
return 1; return 1;
@@ -189,17 +204,21 @@ static int has_ext(const char *extensions, const char *name) {
} }
} }
static GLADapiproc glad_egl_get_proc_from_userptr(const char *name, void *userptr) {
return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
}
static int find_extensionsEGL(EGLDisplay display) { static int find_extensionsEGL(EGLDisplay display) {
const char *extensions; const char *extensions;
if (!get_exts(display, &extensions)) return 0; if (!get_exts(display, &extensions)) return 0;
GLAD_EGL_EXT_device_base = has_ext(extensions, "EGL_EXT_device_base"); GLAD_EGL_EXT_platform_device = has_ext(extensions, "EGL_EXT_platform_device");
GLAD_EGL_EXT_platform_base = has_ext(extensions, "EGL_EXT_platform_base");
GLAD_EGL_NV_device_cuda = has_ext(extensions, "EGL_NV_device_cuda");
GLAD_EGL_EXT_device_enumeration = has_ext(extensions, "EGL_EXT_device_enumeration"); GLAD_EGL_EXT_device_enumeration = has_ext(extensions, "EGL_EXT_device_enumeration");
GLAD_EGL_EXT_device_query = has_ext(extensions, "EGL_EXT_device_query"); GLAD_EGL_EXT_device_query = has_ext(extensions, "EGL_EXT_device_query");
GLAD_EGL_EXT_platform_base = has_ext(extensions, "EGL_EXT_platform_base"); GLAD_EGL_EXT_device_base = has_ext(extensions, "EGL_EXT_device_base");
GLAD_EGL_EXT_platform_device = has_ext(extensions, "EGL_EXT_platform_device");
GLAD_EGL_NV_cuda_event = has_ext(extensions, "EGL_NV_cuda_event"); GLAD_EGL_NV_cuda_event = has_ext(extensions, "EGL_NV_cuda_event");
GLAD_EGL_NV_device_cuda = has_ext(extensions, "EGL_NV_device_cuda");
return 1; return 1;
} }
@@ -228,11 +247,7 @@ static int find_coreEGL(EGLDisplay display) {
major = 1; major = 1;
minor = 0; minor = 0;
} else { } else {
#ifdef _MSC_VER GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor);
sscanf_s(version, "%d.%d", &major, &minor);
#else
sscanf(version, "%d.%d", &major, &minor);
#endif
} }
GLAD_EGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; GLAD_EGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
@@ -242,15 +257,15 @@ static int find_coreEGL(EGLDisplay display) {
GLAD_EGL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; GLAD_EGL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
GLAD_EGL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; GLAD_EGL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
return major * 10 + minor; return GLAD_MAKE_VERSION(major, minor);
} }
int gladLoadEGL(EGLDisplay display, GLADloadproc load, void* userptr) { int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void* userptr) {
int version; int version;
eglGetDisplay = (PFNEGLGETDISPLAYPROC)load("eglGetDisplay", userptr); eglGetDisplay = (PFNEGLGETDISPLAYPROC) load("eglGetDisplay", userptr);
eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC)load("eglGetCurrentDisplay", userptr); eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) load("eglGetCurrentDisplay", userptr);
eglQueryString = (PFNEGLQUERYSTRINGPROC)load("eglQueryString", userptr); eglQueryString = (PFNEGLQUERYSTRINGPROC) load("eglQueryString", userptr);
eglGetError = (PFNEGLGETERRORPROC)load("eglGetError", userptr); eglGetError = (PFNEGLGETERRORPROC) load("eglGetError", userptr);
if (eglGetDisplay == NULL || eglGetCurrentDisplay == NULL || eglQueryString == NULL || eglGetError == NULL) return 0; if (eglGetDisplay == NULL || eglGetCurrentDisplay == NULL || eglQueryString == NULL || eglGetError == NULL) return 0;
version = find_coreEGL(display); version = find_coreEGL(display);
@@ -258,39 +273,32 @@ int gladLoadEGL(EGLDisplay display, GLADloadproc load, void* userptr) {
load_EGL_VERSION_1_0(load, userptr); load_EGL_VERSION_1_0(load, userptr);
load_EGL_VERSION_1_1(load, userptr); load_EGL_VERSION_1_1(load, userptr);
load_EGL_VERSION_1_2(load, userptr); load_EGL_VERSION_1_2(load, userptr);
load_EGL_VERSION_1_3(load, userptr);
load_EGL_VERSION_1_4(load, userptr); load_EGL_VERSION_1_4(load, userptr);
load_EGL_VERSION_1_5(load, userptr); load_EGL_VERSION_1_5(load, userptr);
if (!find_extensionsEGL(display)) return 0; if (!find_extensionsEGL(display)) return 0;
load_EGL_EXT_device_base(load, userptr); load_EGL_EXT_platform_base(load, userptr);
load_EGL_EXT_device_enumeration(load, userptr); load_EGL_EXT_device_enumeration(load, userptr);
load_EGL_EXT_device_query(load, userptr); load_EGL_EXT_device_query(load, userptr);
load_EGL_EXT_platform_base(load, userptr); load_EGL_EXT_device_base(load, userptr);
load_EGL_EXT_platform_device(load, userptr);
load_EGL_NV_cuda_event(load, userptr);
load_EGL_NV_device_cuda(load, userptr);
return version; return version;
} }
static void* glad_egl_get_proc_from_userptr(const char* name, void *userptr) { int gladLoadEGL(EGLDisplay display, GLADloadfunc load) {
return ((void* (*)(const char *name))userptr)(name); return gladLoadEGLUserPtr(display, glad_egl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
}
int gladLoadEGLSimple(EGLDisplay display, GLADsimpleloadproc load) {
return gladLoadEGL(display, glad_egl_get_proc_from_userptr, (void*) load);
} }
#ifdef GLAD_EGL #ifdef GLAD_EGL
#ifndef __glad_loader_library_c_ #ifndef GLAD_LOADER_LIBRARY_C_
#define __glad_loader_library_c_ #define GLAD_LOADER_LIBRARY_C_
#include <stddef.h> #include <stddef.h>
#include <stdlib.h>
#ifdef _WIN32 #if GLAD_PLATFORM_WIN32
#include <windows.h> #include <windows.h>
#else #else
#include <dlfcn.h> #include <dlfcn.h>
@@ -298,12 +306,24 @@ int gladLoadEGLSimple(EGLDisplay display, GLADsimpleloadproc load) {
static void* glad_get_dlopen_handle(const char *lib_names[], int length) { static void* glad_get_dlopen_handle(const char *lib_names[], int length) {
void *handle = NULL;
int i; int i;
void *handle;
for (i = 0; i < length; ++i) { for (i = 0; i < length; ++i) {
#ifdef _WIN32 #if GLAD_PLATFORM_WIN32
handle = LoadLibraryA(lib_names[i]); #if GLAD_PLATFORM_UWP
size_t buffer_size = (strlen(lib_names[i]) + 1) * sizeof(WCHAR);
LPWSTR buffer = (LPWSTR) malloc(buffer_size);
if (buffer != NULL) {
int ret = MultiByteToWideChar(CP_ACP, 0, lib_names[i], -1, buffer, buffer_size);
if (ret != 0) {
handle = (void*) LoadPackagedLibrary(buffer, 0);
}
free((void*) buffer);
}
#else
handle = (void*) LoadLibraryA(lib_names[i]);
#endif
#else #else
handle = dlopen(lib_names[i], RTLD_LAZY | RTLD_LOCAL); handle = dlopen(lib_names[i], RTLD_LAZY | RTLD_LOCAL);
#endif #endif
@@ -317,7 +337,7 @@ static void* glad_get_dlopen_handle(const char *lib_names[], int length) {
static void glad_close_dlopen_handle(void* handle) { static void glad_close_dlopen_handle(void* handle) {
if (handle != NULL) { if (handle != NULL) {
#ifdef _WIN32 #if GLAD_PLATFORM_WIN32
FreeLibrary((HMODULE) handle); FreeLibrary((HMODULE) handle);
#else #else
dlclose(handle); dlclose(handle);
@@ -325,32 +345,32 @@ static void glad_close_dlopen_handle(void* handle) {
} }
} }
static void* glad_dlsym_handle(void* handle, const char *name) { static GLADapiproc glad_dlsym_handle(void* handle, const char *name) {
if (handle == NULL) { if (handle == NULL) {
return NULL; return NULL;
} }
#ifdef _WIN32 #if GLAD_PLATFORM_WIN32
return (void*) GetProcAddress((HMODULE) handle, name); return (GLADapiproc) GetProcAddress((HMODULE) handle, name);
#else #else
return dlsym(handle, name); return GLAD_GNUC_EXTENSION (GLADapiproc) dlsym(handle, name);
#endif #endif
} }
#endif /* __glad_loader_library_c_ */ #endif /* GLAD_LOADER_LIBRARY_C_ */
typedef __eglMustCastToProperFunctionPointerType (APIENTRYP GLAD_EGL_PFNGETPROCADDRESSPROC_PRIVATE)(const char*);
struct _glad_egl_userptr { struct _glad_egl_userptr {
void *handle; void *handle;
GLAD_EGL_PFNGETPROCADDRESSPROC_PRIVATE get_proc_address_ptr; PFNEGLGETPROCADDRESSPROC get_proc_address_ptr;
}; };
static void* glad_egl_get_proc(const char* name, void *vuserptr) { static GLADapiproc glad_egl_get_proc(const char* name, void *vuserptr) {
struct _glad_egl_userptr userptr = *(struct _glad_egl_userptr*) vuserptr; struct _glad_egl_userptr userptr = *(struct _glad_egl_userptr*) vuserptr;
void* result = NULL; GLADapiproc result = NULL;
result = (void*) glad_dlsym_handle(userptr.handle, name); result = glad_dlsym_handle(userptr.handle, name);
if (result == NULL) { if (result == NULL) {
result = (void*) userptr.get_proc_address_ptr(name); result = GLAD_GNUC_EXTENSION (GLADapiproc) userptr.get_proc_address_ptr(name);
} }
return result; return result;
@@ -358,10 +378,10 @@ static void* glad_egl_get_proc(const char* name, void *vuserptr) {
static void* _egl_handle = NULL; static void* _egl_handle = NULL;
int gladLoadEGLInternalLoader(EGLDisplay display) { int gladLoaderLoadEGL(EGLDisplay display) {
#ifdef __APPLE__ #ifdef __APPLE__
static const char *NAMES[] = {"libEGL.dylib"}; static const char *NAMES[] = {"libEGL.dylib"};
#elif defined _WIN32 #elif GLAD_PLATFORM_WIN32
static const char *NAMES[] = {"libEGL.dll", "EGL.dll"}; static const char *NAMES[] = {"libEGL.dll", "EGL.dll"};
#else #else
static const char *NAMES[] = {"libEGL.so.1", "libEGL.so"}; static const char *NAMES[] = {"libEGL.so.1", "libEGL.so"};
@@ -378,9 +398,9 @@ int gladLoadEGLInternalLoader(EGLDisplay display) {
if (_egl_handle != NULL) { if (_egl_handle != NULL) {
userptr.handle = _egl_handle; userptr.handle = _egl_handle;
userptr.get_proc_address_ptr = (GLAD_EGL_PFNGETPROCADDRESSPROC_PRIVATE) glad_dlsym_handle(_egl_handle, "eglGetProcAddress"); userptr.get_proc_address_ptr = (PFNEGLGETPROCADDRESSPROC) glad_dlsym_handle(_egl_handle, "eglGetProcAddress");
if (userptr.get_proc_address_ptr != NULL) { if (userptr.get_proc_address_ptr != NULL) {
version = gladLoadEGL(display, (GLADloadproc) glad_egl_get_proc, &userptr); version = gladLoadEGLUserPtr(display, glad_egl_get_proc, &userptr);
} }
if (!version && did_load) { if (!version && did_load) {
@@ -392,11 +412,11 @@ int gladLoadEGLInternalLoader(EGLDisplay display) {
return version; return version;
} }
void gladUnloadEGLInternalLoader() { void gladLoaderUnloadEGL() {
if (_egl_handle != NULL) { if (_egl_handle != NULL) {
glad_close_dlopen_handle(_egl_handle); glad_close_dlopen_handle(_egl_handle);
_egl_handle = NULL; _egl_handle = NULL;
} }
} }
#endif /* GLAD_EGL */ #endif /* GLAD_EGL */

4383
examples/ThirdPartyLibs/glad/gl.c
View File

File diff suppressed because it is too large Load Diff

888
examples/ThirdPartyLibs/glad/glad/egl.h
View File

@@ -1,86 +1,318 @@
#ifndef __glad_egl_h_ /**
#define __glad_egl_h_ * Loader generated by glad 0.1.11a0 on Wed Jun 13 07:59:54 2018
*
* Generator: C/C++
* Specification: egl
* Extensions: 7
*
* APIs:
* - egl=1.5
*
* Options:
* - HEADER_ONLY = False
* - DEBUG = False
* - MX = False
* - LOADER = True
* - MX_GLOBAL = False
* - ALIAS = False
*
* Commandline:
* --api='egl=1.5' --extensions='EGL_EXT_platform_device,EGL_EXT_platform_base,EGL_NV_device_cuda,EGL_EXT_device_enumeration,EGL_EXT_device_query,EGL_EXT_device_base,EGL_NV_cuda_event' c --loader
*
* Online:
* http://glad2.dav1d.de/#merge=off&api=egl%3D1.5&extensions=EGL_EXT_platform_device%2CEGL_EXT_platform_base%2CEGL_NV_device_cuda%2CEGL_EXT_device_enumeration%2CEGL_EXT_device_query%2CEGL_EXT_device_base%2CEGL_NV_cuda_event&generator=c&header_only=off&debug=off&mx=off&loader=on&mx_global=off&alias=off
*
*/
#ifdef __egl_h_ #ifndef GLAD_EGL_H_
#error EGL header already included (API: egl), remove previous include! #define GLAD_EGL_H_
#endif
#define __egl_h_
#define GLAD_EGL #define GLAD_EGL
#define GLAD_OPTION_EGL_LOADER
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1
#endif
#include <windows.h>
#endif
#ifndef APIENTRY
#define APIENTRY
#endif
#ifndef APIENTRYP
#define APIENTRYP APIENTRY *
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef GLAPI #ifndef GLAD_PLATFORM_H_
# if defined(GLAD_GLAPI_EXPORT) #define GLAD_PLATFORM_H_
# if defined(_WIN32) || defined(__CYGWIN__)
# if defined(GLAD_GLAPI_EXPORT_BUILD) #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
# if defined(__GNUC__) #define GLAD_PLATFORM_WIN32 1
# define GLAPI __attribute__ ((dllexport)) extern #else
# else #define GLAD_PLATFORM_WIN32 0
# define GLAPI __declspec(dllexport) extern
# endif
# else
# if defined(__GNUC__)
# define GLAPI __attribute__ ((dllimport)) extern
# else
# define GLAPI __declspec(dllimport) extern
# endif
# endif
# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD)
# define GLAPI __attribute__ ((visibility ("default"))) extern
# else
# define GLAPI extern
# endif
# else
# define GLAPI extern
# endif
#endif #endif
#define EGL_VERSION_1_0 1
GLAPI int GLAD_EGL_VERSION_1_0; #ifndef GLAD_PLATFORM_UWP
#define EGL_VERSION_1_1 1 #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
GLAPI int GLAD_EGL_VERSION_1_1; #ifdef __has_include
#define EGL_VERSION_1_2 1 #if __has_include(<winapifamily.h>)
GLAPI int GLAD_EGL_VERSION_1_2; #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
#define EGL_VERSION_1_3 1 #endif
GLAPI int GLAD_EGL_VERSION_1_3; #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
#define EGL_VERSION_1_4 1 #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
GLAPI int GLAD_EGL_VERSION_1_4; #endif
#define EGL_VERSION_1_5 1 #endif
GLAPI int GLAD_EGL_VERSION_1_5;
#define EGL_EXT_device_base 1 #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
GLAPI int GLAD_EGL_EXT_device_base; #include <winapifamily.h>
#define EGL_EXT_device_enumeration 1 #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
GLAPI int GLAD_EGL_EXT_device_enumeration; #define GLAD_PLATFORM_UWP 1
#define EGL_EXT_device_query 1 #endif
GLAPI int GLAD_EGL_EXT_device_query; #endif
#define EGL_EXT_platform_base 1
GLAPI int GLAD_EGL_EXT_platform_base; #ifndef GLAD_PLATFORM_UWP
#define EGL_EXT_platform_device 1 #define GLAD_PLATFORM_UWP 0
GLAPI int GLAD_EGL_EXT_platform_device; #endif
#define EGL_NV_cuda_event 1 #endif
GLAPI int GLAD_EGL_NV_cuda_event;
#define EGL_NV_device_cuda 1 #ifdef __GNUC__
GLAPI int GLAD_EGL_NV_device_cuda; #define GLAD_GNUC_EXTENSION __extension__
#else
#define GLAD_GNUC_EXTENSION
#endif
#ifndef GLAD_API_CALL
#if defined(GLAD_API_CALL_EXPORT)
#if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
#if defined(GLAD_API_CALL_EXPORT_BUILD)
#if defined(__GNUC__)
#define GLAD_API_CALL __attribute__ ((dllexport)) extern
#else
#define GLAD_API_CALL __declspec(dllexport) extern
#endif
#else
#if defined(__GNUC__)
#define GLAD_API_CALL __attribute__ ((dllimport)) extern
#else
#define GLAD_API_CALL __declspec(dllimport) extern
#endif
#endif
#elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
#define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern
#else
#define GLAD_API_CALL extern
#endif
#else
#define GLAD_API_CALL extern
#endif
#endif
#ifdef APIENTRY
#define GLAD_API_PTR APIENTRY
#elif GLAD_PLATFORM_WIN32
#define GLAD_API_PTR __stdcall
#else
#define GLAD_API_PTR
#endif
#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
#define GLAD_VERSION_MAJOR(version) (version / 10000)
#define GLAD_VERSION_MINOR(version) (version % 10000)
typedef void (*GLADapiproc)(void);
typedef GLADapiproc (*GLADloadfunc)(const char *name);
typedef GLADapiproc (*GLADuserptrloadfunc)(const char *name, void *userptr);
typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
#endif /* GLAD_PLATFORM_H_ */
#define EGL_VERSION 0x3054
#define EGL_CONFIG_CAVEAT 0x3027
#define EGL_NATIVE_VISUAL_ID 0x302E
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS 0x31B2
#define EGL_NATIVE_RENDERABLE 0x302D
#define EGL_BAD_SURFACE 0x300D
#define EGL_MULTISAMPLE_RESOLVE 0x3099
#define EGL_PIXEL_ASPECT_RATIO 0x3092
#define EGL_BLUE_SIZE 0x3022
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD
#define EGL_BAD_ALLOC 0x3003
#define EGL_SAMPLES 0x3031
#define EGL_SYNC_TYPE 0x30F7
#define EGL_LUMINANCE_SIZE 0x303D
#define EGL_PBUFFER_BIT 0x0001
#define EGL_ALPHA_FORMAT_NONPRE EGL_VG_ALPHA_FORMAT_NONPRE
#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B
#define EGL_CONTEXT_LOST 0x300E
#define EGL_BUFFER_PRESERVED 0x3094
#define EGL_GL_COLORSPACE_LINEAR EGL_COLORSPACE_LINEAR
#define EGL_SAMPLE_BUFFERS 0x3032
#define EGL_GL_RENDERBUFFER 0x30B9
#define EGL_UNSIGNALED 0x30F3
#define EGL_OPENGL_ES_API 0x30A0
#define EGL_EXTENSIONS 0x3055
#define EGL_GL_TEXTURE_2D 0x30B1
#define EGL_BACK_BUFFER 0x3084
#define EGL_SYNC_CONDITION 0x30F8
#define EGL_BAD_NATIVE_PIXMAP 0x300A
#define EGL_CONTEXT_OPENGL_DEBUG 0x31B0
#define EGL_TEXTURE_2D 0x305F
#define EGL_CONFORMANT 0x3042
#define EGL_PIXMAP_BIT 0x0002
#define EGL_SLOW_CONFIG 0x3050
#define EGL_CL_EVENT_HANDLE 0x309C
#define EGL_BAD_CURRENT_SURFACE 0x3007
#define EGL_BIND_TO_TEXTURE_RGBA 0x303A
#define EGL_VG_COLORSPACE_sRGB EGL_COLORSPACE_sRGB
#define EGL_IMAGE_PRESERVED 0x30D2
#define EGL_SURFACE_TYPE 0x3033
#define EGL_OPENVG_BIT 0x0002
#define EGL_VERTICAL_RESOLUTION 0x3091
#define EGL_MAX_PBUFFER_PIXELS 0x302B
#define EGL_DEVICE_EXT 0x322C
#define EGL_SWAP_BEHAVIOR 0x3093
#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200
#define EGL_VG_ALPHA_FORMAT 0x3088
#define EGL_RENDER_BUFFER 0x3086
#define EGL_VG_COLORSPACE 0x3087
#define EGL_NO_CONTEXT EGL_CAST(EGLContext,0)
#define EGL_OPENGL_API 0x30A2
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
#define EGL_LUMINANCE_BUFFER 0x308F
#define EGL_NO_RESET_NOTIFICATION 0x31BE
#define EGL_COLORSPACE_sRGB 0x3089
#define EGL_OPENGL_ES_BIT 0x0001
#define EGL_BAD_ACCESS 0x3002
#define EGL_OPENGL_ES2_BIT 0x0004
#define EGL_LOSE_CONTEXT_ON_RESET 0x31BF
#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay,0)
#define EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT,0)
#define EGL_BAD_CONFIG 0x3005
#define EGL_NO_TEXTURE 0x305C
#define EGL_LARGEST_PBUFFER 0x3058
#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400
#define EGL_ALPHA_FORMAT EGL_VG_ALPHA_FORMAT
#define EGL_ALPHA_MASK_SIZE 0x303E
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4
#define EGL_CUDA_DEVICE_NV 0x323A
#define EGL_VENDOR 0x3053
#define EGL_STENCIL_SIZE 0x3026
#define EGL_BAD_ATTRIBUTE 0x3004
#define EGL_DRAW 0x3059
#define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001
#define EGL_COLORSPACE EGL_VG_COLORSPACE
#define EGL_SYNC_CUDA_EVENT_NV 0x323C
#define EGL_OPENVG_IMAGE 0x3096
#define EGL_NO_IMAGE EGL_CAST(EGLImage,0)
#define EGL_TEXTURE_TARGET 0x3081
#define EGL_CORE_NATIVE_ENGINE 0x305B
#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType,0)
#define EGL_SIGNALED 0x30F2
#define EGL_GL_COLORSPACE 0x309D
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE 0x30F0
#define EGL_WIDTH 0x3057
#define EGL_TRANSPARENT_RGB 0x3052
#define EGL_SYNC_FENCE 0x30F9
#define EGL_RENDERABLE_TYPE 0x3040
#define EGL_TRANSPARENT_BLUE_VALUE 0x3035
#define EGL_MAX_SWAP_INTERVAL 0x303C
#define EGL_HEIGHT 0x3056
#define EGL_TRANSPARENT_TYPE 0x3034
#define EGL_DEPTH_SIZE 0x3025
#define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD
#define EGL_FOREVER 0xFFFFFFFFFFFFFFFF
#define EGL_NATIVE_VISUAL_TYPE 0x302F
#define EGL_GREEN_SIZE 0x3023
#define EGL_DISPLAY_SCALING 10000
#define EGL_WINDOW_BIT 0x0004
#define EGL_BIND_TO_TEXTURE_RGB 0x3039
#define EGL_VG_COLORSPACE_LINEAR EGL_COLORSPACE_LINEAR
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
#define EGL_BAD_DISPLAY 0x3008
#define EGL_CONDITION_SATISFIED 0x30F6
#define EGL_SYNC_CL_EVENT 0x30FE
#define EGL_COLORSPACE_LINEAR 0x308A
#define EGL_NONE 0x3038
#define EGL_MATCH_NATIVE_PIXMAP 0x3041
#define EGL_MIPMAP_LEVEL 0x3083
#define EGL_PLATFORM_DEVICE_EXT 0x313F
#define EGL_BAD_CONTEXT 0x3006
#define EGL_MIN_SWAP_INTERVAL 0x303B
#define EGL_BAD_DEVICE_EXT 0x322B
#define EGL_FALSE 0
#define EGL_TEXTURE_FORMAT 0x3080
#define EGL_GL_TEXTURE_3D 0x30B2
#define EGL_COLOR_BUFFER_TYPE 0x303F
#define EGL_MAX_PBUFFER_WIDTH 0x302C
#define EGL_SINGLE_BUFFER 0x3085
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002
#define EGL_ALPHA_SIZE 0x3021
#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A
#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020
#define EGL_SYNC_STATUS 0x30F1
#define EGL_TRUE 1
#define EGL_TIMEOUT_EXPIRED 0x30F5
#define EGL_NO_SURFACE EGL_CAST(EGLSurface,0)
#define EGL_RED_SIZE 0x3024
#define EGL_TEXTURE_RGBA 0x305E
#define EGL_TRANSPARENT_GREEN_VALUE 0x3036
#define EGL_GL_TEXTURE_ZOFFSET 0x30BD
#define EGL_ALPHA_FORMAT_PRE EGL_VG_ALPHA_FORMAT_PRE
#define EGL_UNKNOWN EGL_CAST(EGLint,-1)
#define EGL_SUCCESS 0x3000
#define EGL_CONTEXT_CLIENT_VERSION 0x3098
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3
#define EGL_SYNC_CUDA_EVENT_COMPLETE_NV 0x323D
#define EGL_BUFFER_SIZE 0x3020
#define EGL_MAX_PBUFFER_HEIGHT 0x302A
#define EGL_HORIZONTAL_RESOLUTION 0x3090
#define EGL_SYNC_CL_EVENT_COMPLETE 0x30FF
#define EGL_LEVEL 0x3029
#define EGL_CONTEXT_MAJOR_VERSION EGL_CONTEXT_CLIENT_VERSION
#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
#define EGL_READ 0x305A
#define EGL_BAD_PARAMETER 0x300C
#define EGL_RGB_BUFFER 0x308E
#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B
#define EGL_NON_CONFORMANT_CONFIG 0x3051
#define EGL_MIPMAP_TEXTURE 0x3082
#define EGL_CONFIG_ID 0x3028
#define EGL_CONTEXT_MINOR_VERSION 0x30FB
#define EGL_TRANSPARENT_RED_VALUE 0x3037
#define EGL_BUFFER_DESTROYED 0x3095
#define EGL_CONTEXT_CLIENT_TYPE 0x3097
#define EGL_BAD_NATIVE_WINDOW 0x300B
#define EGL_OPENGL_BIT 0x0008
#define EGL_OPENVG_API 0x30A1
#define EGL_OPENGL_ES3_BIT 0x00000040
#define EGL_BAD_MATCH 0x3009
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1
#define EGL_TEXTURE_RGB 0x305D
#define EGL_CLIENT_APIS 0x308D
#define EGL_GL_TEXTURE_LEVEL 0x30BC
#define EGL_NOT_INITIALIZED 0x3001
#define EGL_NO_SYNC EGL_CAST(EGLSync,0)
#define EGL_VG_ALPHA_FORMAT_PRE 0x308C
#define EGL_DONT_CARE EGL_CAST(EGLint,-1)
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6
#define EGL_GL_COLORSPACE_SRGB EGL_COLORSPACE_sRGB
#define EGL_CUDA_EVENT_HANDLE_NV 0x323B
#include <KHR/khrplatform.h> #include <KHR/khrplatform.h>
#include <EGL/eglplatform.h> #include <EGL/eglplatform.h>
struct AHardwareBuffer; struct AHardwareBuffer;
typedef unsigned int EGLBoolean; typedef unsigned int EGLBoolean;
typedef unsigned int EGLenum; typedef unsigned int EGLenum;
typedef intptr_t EGLAttribKHR; typedef intptr_t EGLAttribKHR;
@@ -118,352 +350,210 @@ struct EGLClientPixmapHI {
EGLint iHeight; EGLint iHeight;
EGLint iStride; EGLint iStride;
}; };
typedef void (APIENTRY *EGLDEBUGPROCKHR)(EGLenum error,const char *command,EGLint messageType,EGLLabelKHR threadLabel,EGLLabelKHR objectLabel,const char* message); typedef void (GLAD_API_PTR *EGLDEBUGPROCKHR)(EGLenum error,const char *command,EGLint messageType,EGLLabelKHR threadLabel,EGLLabelKHR objectLabel,const char* message);
#define EGL_FALSE 0
#define EGL_BACK_BUFFER 0x3084
#define EGL_GL_COLORSPACE_LINEAR 0x308A
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4
#define EGL_TEXTURE_RGB 0x305D
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD
#define EGL_VG_ALPHA_FORMAT_PRE 0x308C
#define EGL_LEVEL 0x3029
#define EGL_COLORSPACE_LINEAR 0x308A
#define EGL_DONT_CARE EGL_CAST(EGLint,-1)
#define EGL_OPENVG_IMAGE 0x3096
#define EGL_ALPHA_FORMAT_PRE 0x308C
#define EGL_SLOW_CONFIG 0x3050
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5
#define EGL_GREEN_SIZE 0x3023
#define EGL_CONTEXT_MINOR_VERSION 0x30FB
#define EGL_CUDA_DEVICE_NV 0x323A
#define EGL_BAD_CONFIG 0x3005
#define EGL_RENDERABLE_TYPE 0x3040
#define EGL_CONDITION_SATISFIED 0x30F6
#define EGL_OPENGL_ES_BIT 0x0001
#define EGL_VERTICAL_RESOLUTION 0x3091
#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType,0)
#define EGL_BAD_PARAMETER 0x300C
#define EGL_DEPTH_SIZE 0x3025
#define EGL_CONTEXT_MAJOR_VERSION 0x3098
#define EGL_HEIGHT 0x3056
#define EGL_OPENGL_ES3_BIT 0x00000040
#define EGL_BAD_ALLOC 0x3003
#define EGL_BAD_DISPLAY 0x3008
#define EGL_CLIENT_APIS 0x308D
#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B
#define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD
#define EGL_MAX_PBUFFER_HEIGHT 0x302A
#define EGL_SURFACE_TYPE 0x3033
#define EGL_VENDOR 0x3053
#define EGL_GL_COLORSPACE 0x309D
#define EGL_BAD_SURFACE 0x300D
#define EGL_GL_RENDERBUFFER 0x30B9
#define EGL_SAMPLE_BUFFERS 0x3032
#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040
#define EGL_VG_ALPHA_FORMAT 0x3088
#define EGL_PIXMAP_BIT 0x0002
#define EGL_NATIVE_RENDERABLE 0x302D
#define EGL_TEXTURE_RGBA 0x305E
#define EGL_NATIVE_VISUAL_ID 0x302E
#define EGL_VERSION 0x3054
#define EGL_TRANSPARENT_RED_VALUE 0x3037
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6
#define EGL_BLUE_SIZE 0x3022
#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400
#define EGL_PIXEL_ASPECT_RATIO 0x3092
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
#define EGL_STENCIL_SIZE 0x3026
#define EGL_CONFORMANT 0x3042
#define EGL_EXTENSIONS 0x3055
#define EGL_SYNC_CL_EVENT_COMPLETE 0x30FF
#define EGL_BAD_ATTRIBUTE 0x3004
#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay,0)
#define EGL_TEXTURE_TARGET 0x3081
#define EGL_IMAGE_PRESERVED 0x30D2
#define EGL_COLOR_BUFFER_TYPE 0x303F
#define EGL_VG_COLORSPACE_sRGB 0x3089
#define EGL_GL_TEXTURE_3D 0x30B2
#define EGL_MULTISAMPLE_RESOLVE 0x3099
#define EGL_CL_EVENT_HANDLE 0x309C
#define EGL_GL_TEXTURE_2D 0x30B1
#define EGL_CORE_NATIVE_ENGINE 0x305B
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
#define EGL_UNKNOWN EGL_CAST(EGLint,-1)
#define EGL_TRANSPARENT_TYPE 0x3034
#define EGL_LUMINANCE_SIZE 0x303D
#define EGL_LARGEST_PBUFFER 0x3058
#define EGL_VG_COLORSPACE 0x3087
#define EGL_GL_COLORSPACE_SRGB 0x3089
#define EGL_LUMINANCE_BUFFER 0x308F
#define EGL_FOREVER 0xFFFFFFFFFFFFFFFF
#define EGL_NO_SYNC EGL_CAST(EGLSync,0)
#define EGL_WIDTH 0x3057
#define EGL_ALPHA_FORMAT_NONPRE 0x308B
#define EGL_BUFFER_SIZE 0x3020
#define EGL_NO_CONTEXT EGL_CAST(EGLContext,0)
#define EGL_MIPMAP_LEVEL 0x3083
#define EGL_NO_TEXTURE 0x305C
#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200
#define EGL_SINGLE_BUFFER 0x3085
#define EGL_NONE 0x3038
#define EGL_NOT_INITIALIZED 0x3001
#define EGL_VG_COLORSPACE_LINEAR 0x308A
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
#define EGL_OPENVG_API 0x30A1
#define EGL_DRAW 0x3059
#define EGL_OPENGL_BIT 0x0008
#define EGL_PBUFFER_BIT 0x0001
#define EGL_ALPHA_SIZE 0x3021
#define EGL_TRANSPARENT_RGB 0x3052
#define EGL_TRANSPARENT_GREEN_VALUE 0x3036
#define EGL_SWAP_BEHAVIOR 0x3093
#define EGL_SIGNALED 0x30F2
#define EGL_CONFIG_ID 0x3028
#define EGL_SYNC_CUDA_EVENT_COMPLETE_NV 0x323D
#define EGL_GL_TEXTURE_LEVEL 0x30BC
#define EGL_BAD_ACCESS 0x3002
#define EGL_MAX_PBUFFER_PIXELS 0x302B
#define EGL_DEVICE_EXT 0x322C
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3
#define EGL_ALPHA_FORMAT 0x3088
#define EGL_TRUE 1
#define EGL_MIPMAP_TEXTURE 0x3082
#define EGL_LOSE_CONTEXT_ON_RESET 0x31BF
#define EGL_GL_TEXTURE_ZOFFSET 0x30BD
#define EGL_MIN_SWAP_INTERVAL 0x303B
#define EGL_BAD_CURRENT_SURFACE 0x3007
#define EGL_RED_SIZE 0x3024
#define EGL_BAD_DEVICE_EXT 0x322B
#define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001
#define EGL_PLATFORM_DEVICE_EXT 0x313F
#define EGL_READ 0x305A
#define EGL_OPENGL_ES_API 0x30A0
#define EGL_OPENGL_API 0x30A2
#define EGL_SYNC_TYPE 0x30F7
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE 0x30F0
#define EGL_MAX_SWAP_INTERVAL 0x303C
#define EGL_RGB_BUFFER 0x308E
#define EGL_OPENGL_ES2_BIT 0x0004
#define EGL_BAD_NATIVE_WINDOW 0x300B
#define EGL_CONTEXT_LOST 0x300E
#define EGL_TIMEOUT_EXPIRED 0x30F5
#define EGL_TEXTURE_2D 0x305F
#define EGL_RENDER_BUFFER 0x3086
#define EGL_BAD_NATIVE_PIXMAP 0x300A
#define EGL_MATCH_NATIVE_PIXMAP 0x3041
#define EGL_NO_IMAGE EGL_CAST(EGLImage,0)
#define EGL_SUCCESS 0x3000
#define EGL_OPENVG_BIT 0x0002
#define EGL_BIND_TO_TEXTURE_RGB 0x3039
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS 0x31B2
#define EGL_CONTEXT_OPENGL_DEBUG 0x31B0
#define EGL_BAD_CONTEXT 0x3006
#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1
#define EGL_ALPHA_MASK_SIZE 0x303E
#define EGL_CONFIG_CAVEAT 0x3027
#define EGL_BAD_MATCH 0x3009
#define EGL_SYNC_CL_EVENT 0x30FE
#define EGL_CONTEXT_CLIENT_TYPE 0x3097
#define EGL_CONTEXT_CLIENT_VERSION 0x3098
#define EGL_CUDA_EVENT_HANDLE_NV 0x323B
#define EGL_BIND_TO_TEXTURE_RGBA 0x303A
#define EGL_COLORSPACE 0x3087
#define EGL_TEXTURE_FORMAT 0x3080
#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B
#define EGL_SYNC_STATUS 0x30F1
#define EGL_UNSIGNALED 0x30F3
#define EGL_SYNC_CUDA_EVENT_NV 0x323C
#define EGL_NO_SURFACE EGL_CAST(EGLSurface,0)
#define EGL_TRANSPARENT_BLUE_VALUE 0x3035
#define EGL_WINDOW_BIT 0x0004
#define EGL_NATIVE_VISUAL_TYPE 0x302F
#define EGL_SAMPLES 0x3031
#define EGL_SYNC_CONDITION 0x30F8
#define EGL_NON_CONFORMANT_CONFIG 0x3051
#define EGL_HORIZONTAL_RESOLUTION 0x3090
#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A
#define EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT,0)
#define EGL_SYNC_FENCE 0x30F9
#define EGL_DISPLAY_SCALING 10000
#define EGL_BUFFER_DESTROYED 0x3095
#define EGL_MAX_PBUFFER_WIDTH 0x302C
#define EGL_BUFFER_PRESERVED 0x3094
#define EGL_COLORSPACE_sRGB 0x3089
#define EGL_NO_RESET_NOTIFICATION 0x31BE
typedef EGLBoolean (APIENTRYP PFNEGLWAITNATIVEPROC)(EGLint engine); #define EGL_VERSION_1_0 1
typedef EGLSurface (APIENTRYP PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list); GLAD_API_CALL int GLAD_EGL_VERSION_1_0;
typedef const char * (APIENTRYP PFNEGLQUERYSTRINGPROC)(EGLDisplay dpy, EGLint name); #define EGL_VERSION_1_1 1
typedef EGLBoolean (APIENTRYP PFNEGLINITIALIZEPROC)(EGLDisplay dpy, EGLint *major, EGLint *minor); GLAD_API_CALL int GLAD_EGL_VERSION_1_1;
typedef EGLBoolean (APIENTRYP PFNEGLQUERYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value); #define EGL_VERSION_1_2 1
typedef EGLSurface (APIENTRYP PFNEGLGETCURRENTSURFACEPROC)(EGLint readdraw); GLAD_API_CALL int GLAD_EGL_VERSION_1_2;
typedef EGLBoolean (APIENTRYP PFNEGLSWAPINTERVALPROC)(EGLDisplay dpy, EGLint interval); #define EGL_VERSION_1_3 1
typedef EGLSync (APIENTRYP PFNEGLCREATESYNCPROC)(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list); GLAD_API_CALL int GLAD_EGL_VERSION_1_3;
typedef EGLBoolean (APIENTRYP PFNEGLCHOOSECONFIGPROC)(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config); #define EGL_VERSION_1_4 1
typedef EGLSurface (APIENTRYP PFNEGLCREATEPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list); GLAD_API_CALL int GLAD_EGL_VERSION_1_4;
typedef EGLBoolean (APIENTRYP PFNEGLGETCONFIGATTRIBPROC)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value); #define EGL_VERSION_1_5 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDEVICEATTRIBEXTPROC)(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value); GLAD_API_CALL int GLAD_EGL_VERSION_1_5;
typedef EGLSurface (APIENTRYP PFNEGLCREATEPBUFFERSURFACEPROC)(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list); #define EGL_EXT_platform_device 1
typedef EGLSurface (APIENTRYP PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list); GLAD_API_CALL int GLAD_EGL_EXT_platform_device;
typedef EGLBoolean (APIENTRYP PFNEGLMAKECURRENTPROC)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); #define EGL_EXT_platform_base 1
typedef EGLDisplay (APIENTRYP PFNEGLGETPLATFORMDISPLAYPROC)(EGLenum platform, void *native_display, const EGLAttrib *attrib_list); GLAD_API_CALL int GLAD_EGL_EXT_platform_base;
typedef EGLBoolean (APIENTRYP PFNEGLRELEASETEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer); #define EGL_NV_device_cuda 1
typedef EGLint (APIENTRYP PFNEGLGETERRORPROC)(); GLAD_API_CALL int GLAD_EGL_NV_device_cuda;
typedef EGLBoolean (APIENTRYP PFNEGLWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags); #define EGL_EXT_device_enumeration 1
typedef EGLBoolean (APIENTRYP PFNEGLWAITGLPROC)(); GLAD_API_CALL int GLAD_EGL_EXT_device_enumeration;
typedef __eglMustCastToProperFunctionPointerType (APIENTRYP PFNEGLGETPROCADDRESSPROC)(const char *procname); #define EGL_EXT_device_query 1
typedef EGLContext (APIENTRYP PFNEGLCREATECONTEXTPROC)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list); GLAD_API_CALL int GLAD_EGL_EXT_device_query;
typedef EGLBoolean (APIENTRYP PFNEGLDESTROYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx); #define EGL_EXT_device_base 1
typedef EGLBoolean (APIENTRYP PFNEGLBINDAPIPROC)(EGLenum api); GLAD_API_CALL int GLAD_EGL_EXT_device_base;
typedef EGLContext (APIENTRYP PFNEGLGETCURRENTCONTEXTPROC)(); #define EGL_NV_cuda_event 1
typedef EGLBoolean (APIENTRYP PFNEGLGETCONFIGSPROC)(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config); GLAD_API_CALL int GLAD_EGL_NV_cuda_event;
typedef const char * (APIENTRYP PFNEGLQUERYDEVICESTRINGEXTPROC)(EGLDeviceEXT device, EGLint name);
typedef EGLSurface (APIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
typedef EGLBoolean (APIENTRYP PFNEGLGETSYNCATTRIBPROC)(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value);
typedef EGLDisplay (APIENTRYP PFNEGLGETPLATFORMDISPLAYEXTPROC)(EGLenum platform, void *native_display, const EGLint *attrib_list);
typedef EGLSurface (APIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);
typedef EGLBoolean (APIENTRYP PFNEGLBINDTEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
typedef EGLSurface (APIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
typedef EGLBoolean (APIENTRYP PFNEGLCOPYBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
typedef EGLSurface (APIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);
typedef EGLDisplay (APIENTRYP PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType display_id);
typedef EGLImage (APIENTRYP PFNEGLCREATEIMAGEPROC)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
typedef EGLBoolean (APIENTRYP PFNEGLWAITCLIENTPROC)();
typedef EGLDisplay (APIENTRYP PFNEGLGETCURRENTDISPLAYPROC)();
typedef EGLBoolean (APIENTRYP PFNEGLTERMINATEPROC)(EGLDisplay dpy);
typedef EGLBoolean (APIENTRYP PFNEGLDESTROYIMAGEPROC)(EGLDisplay dpy, EGLImage image);
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDISPLAYATTRIBEXTPROC)(EGLDisplay dpy, EGLint attribute, EGLAttrib *value);
typedef EGLBoolean (APIENTRYP PFNEGLQUERYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
typedef EGLBoolean (APIENTRYP PFNEGLSWAPBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface);
typedef EGLint (APIENTRYP PFNEGLCLIENTWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
typedef EGLBoolean (APIENTRYP PFNEGLRELEASETHREADPROC)();
typedef EGLBoolean (APIENTRYP PFNEGLDESTROYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface);
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDEVICESEXTPROC)(EGLint max_devices, EGLDeviceEXT *devices, EGLint *num_devices);
typedef EGLBoolean (APIENTRYP PFNEGLSURFACEATTRIBPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
typedef EGLenum (APIENTRYP PFNEGLQUERYAPIPROC)();
typedef EGLBoolean (APIENTRYP PFNEGLDESTROYSYNCPROC)(EGLDisplay dpy, EGLSync sync);
GLAPI PFNEGLWAITNATIVEPROC glad_eglWaitNative;
#define eglWaitNative glad_eglWaitNative typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYDEVICESEXTPROC)(EGLint max_devices, EGLDeviceEXT * devices, EGLint * num_devices);
GLAPI PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface; typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPBUFFERSURFACEPROC)(EGLDisplay dpy, EGLConfig config, const EGLint * attrib_list);
#define eglCreateWindowSurface glad_eglCreateWindowSurface typedef EGLint (GLAD_API_PTR *PFNEGLGETERRORPROC)(void);
GLAPI PFNEGLQUERYSTRINGPROC glad_eglQueryString; typedef __eglMustCastToProperFunctionPointerType (GLAD_API_PTR *PFNEGLGETPROCADDRESSPROC)(const char * procname);
#define eglQueryString glad_eglQueryString typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETCURRENTDISPLAYPROC)(void);
GLAPI PFNEGLINITIALIZEPROC glad_eglInitialize; typedef EGLenum (GLAD_API_PTR *PFNEGLQUERYAPIPROC)(void);
#define eglInitialize glad_eglInitialize typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void * native_pixmap, const EGLAttrib * attrib_list);
GLAPI PFNEGLQUERYCONTEXTPROC glad_eglQueryContext; typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYDISPLAYATTRIBKHRPROC)(EGLDisplay dpy, EGLint name, EGLAttrib * value);
#define eglQueryContext glad_eglQueryContext typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYSYNCPROC)(EGLDisplay dpy, EGLSync sync);
GLAPI PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface; typedef EGLImage (GLAD_API_PTR *PFNEGLCREATEIMAGEPROC)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib * attrib_list);
#define eglGetCurrentSurface glad_eglGetCurrentSurface typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint * value);
GLAPI PFNEGLSWAPINTERVALPROC glad_eglSwapInterval; typedef EGLBoolean (GLAD_API_PTR *PFNEGLSWAPBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface);
#define eglSwapInterval glad_eglSwapInterval typedef EGLContext (GLAD_API_PTR *PFNEGLCREATECONTEXTPROC)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint * attrib_list);
GLAPI PFNEGLCREATESYNCPROC glad_eglCreateSync; typedef EGLBoolean (GLAD_API_PTR *PFNEGLCHOOSECONFIGPROC)(EGLDisplay dpy, const EGLint * attrib_list, EGLConfig * configs, EGLint config_size, EGLint * num_config);
#define eglCreateSync glad_eglCreateSync typedef EGLBoolean (GLAD_API_PTR *PFNEGLBINDAPIPROC)(EGLenum api);
GLAPI PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig; typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITNATIVEPROC)(EGLint engine);
#define eglChooseConfig glad_eglChooseConfig typedef EGLBoolean (GLAD_API_PTR *PFNEGLTERMINATEPROC)(EGLDisplay dpy);
GLAPI PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface; typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void * native_pixmap, const EGLint * attrib_list);
#define eglCreatePixmapSurface glad_eglCreatePixmapSurface typedef EGLBoolean (GLAD_API_PTR *PFNEGLRELEASETHREADPROC)(void);
GLAPI PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib; typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void * native_window, const EGLAttrib * attrib_list);
#define eglGetConfigAttrib glad_eglGetConfigAttrib typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETCONFIGATTRIBPROC)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint * value);
GLAPI PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT; typedef EGLSurface (GLAD_API_PTR *PFNEGLGETCURRENTSURFACEPROC)(EGLint readdraw);
#define eglQueryDeviceAttribEXT glad_eglQueryDeviceAttribEXT typedef EGLBoolean (GLAD_API_PTR *PFNEGLCOPYBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
GLAPI PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface; typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETPLATFORMDISPLAYEXTPROC)(EGLenum platform, void * native_display, const EGLint * attrib_list);
#define eglCreatePbufferSurface glad_eglCreatePbufferSurface typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYDEVICEATTRIBEXTPROC)(EGLDeviceEXT device, EGLint attribute, EGLAttrib * value);
GLAPI PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer; typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint * attrib_list);
#define eglCreatePbufferFromClientBuffer glad_eglCreatePbufferFromClientBuffer typedef EGLBoolean (GLAD_API_PTR *PFNEGLBINDTEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
GLAPI PFNEGLMAKECURRENTPROC glad_eglMakeCurrent; typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETPLATFORMDISPLAYPROC)(EGLenum platform, void * native_display, const EGLAttrib * attrib_list);
#define eglMakeCurrent glad_eglMakeCurrent typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType display_id);
GLAPI PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay; typedef const char * (GLAD_API_PTR *PFNEGLQUERYSTRINGPROC)(EGLDisplay dpy, EGLint name);
#define eglGetPlatformDisplay glad_eglGetPlatformDisplay typedef EGLint (GLAD_API_PTR *PFNEGLCLIENTWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
GLAPI PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage; typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags);
#define eglReleaseTexImage glad_eglReleaseTexImage typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYIMAGEPROC)(EGLDisplay dpy, EGLImage image);
GLAPI PFNEGLGETERRORPROC glad_eglGetError; typedef EGLBoolean (GLAD_API_PTR *PFNEGLRELEASETEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
#define eglGetError glad_eglGetError typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYDISPLAYATTRIBEXTPROC)(EGLDisplay dpy, EGLint attribute, EGLAttrib * value);
GLAPI PFNEGLWAITSYNCPROC glad_eglWaitSync; typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx);
#define eglWaitSync glad_eglWaitSync typedef const char * (GLAD_API_PTR *PFNEGLQUERYDEVICESTRINGEXTPROC)(EGLDeviceEXT device, EGLint name);
GLAPI PFNEGLWAITGLPROC glad_eglWaitGL; typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint * attrib_list);
#define eglWaitGL glad_eglWaitGL typedef EGLContext (GLAD_API_PTR *PFNEGLGETCURRENTCONTEXTPROC)(void);
GLAPI PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress; typedef EGLBoolean (GLAD_API_PTR *PFNEGLINITIALIZEPROC)(EGLDisplay dpy, EGLint * major, EGLint * minor);
#define eglGetProcAddress glad_eglGetProcAddress typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface);
GLAPI PFNEGLCREATECONTEXTPROC glad_eglCreateContext; typedef EGLBoolean (GLAD_API_PTR *PFNEGLMAKECURRENTPROC)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
#define eglCreateContext glad_eglCreateContext typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void * native_window, const EGLint * attrib_list);
GLAPI PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext; typedef EGLBoolean (GLAD_API_PTR *PFNEGLSWAPINTERVALPROC)(EGLDisplay dpy, EGLint interval);
#define eglDestroyContext glad_eglDestroyContext typedef EGLSync (GLAD_API_PTR *PFNEGLCREATESYNCPROC)(EGLDisplay dpy, EGLenum type, const EGLAttrib * attrib_list);
GLAPI PFNEGLBINDAPIPROC glad_eglBindAPI; typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETSYNCATTRIBPROC)(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib * value);
#define eglBindAPI glad_eglBindAPI typedef EGLBoolean (GLAD_API_PTR *PFNEGLSURFACEATTRIBPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
GLAPI PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext; typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITGLPROC)(void);
#define eglGetCurrentContext glad_eglGetCurrentContext typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint * value);
GLAPI PFNEGLGETCONFIGSPROC glad_eglGetConfigs; typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETCONFIGSPROC)(EGLDisplay dpy, EGLConfig * configs, EGLint config_size, EGLint * num_config);
#define eglGetConfigs glad_eglGetConfigs typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITCLIENTPROC)(void);
GLAPI PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT; typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint * attrib_list);
#define eglQueryDeviceStringEXT glad_eglQueryDeviceStringEXT
GLAPI PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface; GLAD_API_CALL PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT;
#define eglCreatePlatformPixmapSurface glad_eglCreatePlatformPixmapSurface
GLAPI PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib;
#define eglGetSyncAttrib glad_eglGetSyncAttrib
GLAPI PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT;
#define eglGetPlatformDisplayEXT glad_eglGetPlatformDisplayEXT
GLAPI PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT;
#define eglCreatePlatformWindowSurfaceEXT glad_eglCreatePlatformWindowSurfaceEXT
GLAPI PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage;
#define eglBindTexImage glad_eglBindTexImage
GLAPI PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface;
#define eglCreatePlatformWindowSurface glad_eglCreatePlatformWindowSurface
GLAPI PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers;
#define eglCopyBuffers glad_eglCopyBuffers
GLAPI PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT;
#define eglCreatePlatformPixmapSurfaceEXT glad_eglCreatePlatformPixmapSurfaceEXT
GLAPI PFNEGLGETDISPLAYPROC glad_eglGetDisplay;
#define eglGetDisplay glad_eglGetDisplay
GLAPI PFNEGLCREATEIMAGEPROC glad_eglCreateImage;
#define eglCreateImage glad_eglCreateImage
GLAPI PFNEGLWAITCLIENTPROC glad_eglWaitClient;
#define eglWaitClient glad_eglWaitClient
GLAPI PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay;
#define eglGetCurrentDisplay glad_eglGetCurrentDisplay
GLAPI PFNEGLTERMINATEPROC glad_eglTerminate;
#define eglTerminate glad_eglTerminate
GLAPI PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage;
#define eglDestroyImage glad_eglDestroyImage
GLAPI PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT;
#define eglQueryDisplayAttribEXT glad_eglQueryDisplayAttribEXT
GLAPI PFNEGLQUERYSURFACEPROC glad_eglQuerySurface;
#define eglQuerySurface glad_eglQuerySurface
GLAPI PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers;
#define eglSwapBuffers glad_eglSwapBuffers
GLAPI PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync;
#define eglClientWaitSync glad_eglClientWaitSync
GLAPI PFNEGLRELEASETHREADPROC glad_eglReleaseThread;
#define eglReleaseThread glad_eglReleaseThread
GLAPI PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface;
#define eglDestroySurface glad_eglDestroySurface
GLAPI PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT;
#define eglQueryDevicesEXT glad_eglQueryDevicesEXT #define eglQueryDevicesEXT glad_eglQueryDevicesEXT
GLAPI PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib; GLAD_API_CALL PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface;
#define eglSurfaceAttrib glad_eglSurfaceAttrib #define eglCreatePbufferSurface glad_eglCreatePbufferSurface
GLAPI PFNEGLQUERYAPIPROC glad_eglQueryAPI; GLAD_API_CALL PFNEGLGETERRORPROC glad_eglGetError;
#define eglGetError glad_eglGetError
GLAD_API_CALL PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress;
#define eglGetProcAddress glad_eglGetProcAddress
GLAD_API_CALL PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay;
#define eglGetCurrentDisplay glad_eglGetCurrentDisplay
GLAD_API_CALL PFNEGLQUERYAPIPROC glad_eglQueryAPI;
#define eglQueryAPI glad_eglQueryAPI #define eglQueryAPI glad_eglQueryAPI
GLAPI PFNEGLDESTROYSYNCPROC glad_eglDestroySync; GLAD_API_CALL PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface;
#define eglCreatePlatformPixmapSurface glad_eglCreatePlatformPixmapSurface
GLAD_API_CALL PFNEGLQUERYDISPLAYATTRIBKHRPROC glad_eglQueryDisplayAttribKHR;
#define eglQueryDisplayAttribKHR glad_eglQueryDisplayAttribKHR
GLAD_API_CALL PFNEGLDESTROYSYNCPROC glad_eglDestroySync;
#define eglDestroySync glad_eglDestroySync #define eglDestroySync glad_eglDestroySync
GLAD_API_CALL PFNEGLCREATEIMAGEPROC glad_eglCreateImage;
#define eglCreateImage glad_eglCreateImage
GLAD_API_CALL PFNEGLQUERYCONTEXTPROC glad_eglQueryContext;
#define eglQueryContext glad_eglQueryContext
GLAD_API_CALL PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers;
#define eglSwapBuffers glad_eglSwapBuffers
GLAD_API_CALL PFNEGLCREATECONTEXTPROC glad_eglCreateContext;
#define eglCreateContext glad_eglCreateContext
GLAD_API_CALL PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig;
#define eglChooseConfig glad_eglChooseConfig
GLAD_API_CALL PFNEGLBINDAPIPROC glad_eglBindAPI;
#define eglBindAPI glad_eglBindAPI
GLAD_API_CALL PFNEGLWAITNATIVEPROC glad_eglWaitNative;
#define eglWaitNative glad_eglWaitNative
GLAD_API_CALL PFNEGLTERMINATEPROC glad_eglTerminate;
#define eglTerminate glad_eglTerminate
GLAD_API_CALL PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT;
#define eglCreatePlatformPixmapSurfaceEXT glad_eglCreatePlatformPixmapSurfaceEXT
GLAD_API_CALL PFNEGLRELEASETHREADPROC glad_eglReleaseThread;
#define eglReleaseThread glad_eglReleaseThread
GLAD_API_CALL PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface;
#define eglCreatePlatformWindowSurface glad_eglCreatePlatformWindowSurface
GLAD_API_CALL PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib;
#define eglGetConfigAttrib glad_eglGetConfigAttrib
GLAD_API_CALL PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface;
#define eglGetCurrentSurface glad_eglGetCurrentSurface
GLAD_API_CALL PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers;
#define eglCopyBuffers glad_eglCopyBuffers
GLAD_API_CALL PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT;
#define eglGetPlatformDisplayEXT glad_eglGetPlatformDisplayEXT
GLAD_API_CALL PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT;
#define eglQueryDeviceAttribEXT glad_eglQueryDeviceAttribEXT
GLAD_API_CALL PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface;
#define eglCreatePixmapSurface glad_eglCreatePixmapSurface
GLAD_API_CALL PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage;
#define eglBindTexImage glad_eglBindTexImage
GLAD_API_CALL PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay;
#define eglGetPlatformDisplay glad_eglGetPlatformDisplay
GLAD_API_CALL PFNEGLGETDISPLAYPROC glad_eglGetDisplay;
#define eglGetDisplay glad_eglGetDisplay
GLAD_API_CALL PFNEGLQUERYSTRINGPROC glad_eglQueryString;
#define eglQueryString glad_eglQueryString
GLAD_API_CALL PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync;
#define eglClientWaitSync glad_eglClientWaitSync
GLAD_API_CALL PFNEGLWAITSYNCPROC glad_eglWaitSync;
#define eglWaitSync glad_eglWaitSync
GLAD_API_CALL PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage;
#define eglDestroyImage glad_eglDestroyImage
GLAD_API_CALL PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage;
#define eglReleaseTexImage glad_eglReleaseTexImage
GLAD_API_CALL PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT;
#define eglQueryDisplayAttribEXT glad_eglQueryDisplayAttribEXT
GLAD_API_CALL PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext;
#define eglDestroyContext glad_eglDestroyContext
GLAD_API_CALL PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT;
#define eglQueryDeviceStringEXT glad_eglQueryDeviceStringEXT
GLAD_API_CALL PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface;
#define eglCreateWindowSurface glad_eglCreateWindowSurface
GLAD_API_CALL PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext;
#define eglGetCurrentContext glad_eglGetCurrentContext
GLAD_API_CALL PFNEGLINITIALIZEPROC glad_eglInitialize;
#define eglInitialize glad_eglInitialize
GLAD_API_CALL PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface;
#define eglDestroySurface glad_eglDestroySurface
GLAD_API_CALL PFNEGLMAKECURRENTPROC glad_eglMakeCurrent;
#define eglMakeCurrent glad_eglMakeCurrent
GLAD_API_CALL PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT;
#define eglCreatePlatformWindowSurfaceEXT glad_eglCreatePlatformWindowSurfaceEXT
GLAD_API_CALL PFNEGLSWAPINTERVALPROC glad_eglSwapInterval;
#define eglSwapInterval glad_eglSwapInterval
GLAD_API_CALL PFNEGLCREATESYNCPROC glad_eglCreateSync;
#define eglCreateSync glad_eglCreateSync
GLAD_API_CALL PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib;
#define eglGetSyncAttrib glad_eglGetSyncAttrib
GLAD_API_CALL PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib;
#define eglSurfaceAttrib glad_eglSurfaceAttrib
GLAD_API_CALL PFNEGLWAITGLPROC glad_eglWaitGL;
#define eglWaitGL glad_eglWaitGL
GLAD_API_CALL PFNEGLQUERYSURFACEPROC glad_eglQuerySurface;
#define eglQuerySurface glad_eglQuerySurface
GLAD_API_CALL PFNEGLGETCONFIGSPROC glad_eglGetConfigs;
#define eglGetConfigs glad_eglGetConfigs
GLAD_API_CALL PFNEGLWAITCLIENTPROC glad_eglWaitClient;
#define eglWaitClient glad_eglWaitClient
GLAD_API_CALL PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer;
#define eglCreatePbufferFromClientBuffer glad_eglCreatePbufferFromClientBuffer
GLAD_API_CALL int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void *userptr);
GLAD_API_CALL int gladLoadEGL(EGLDisplay display, GLADloadfunc load);
typedef void* (* GLADloadproc)(const char *name, void* userptr);
typedef void* (* GLADsimpleloadproc)(const char *name);
GLAPI int gladLoadEGL(EGLDisplay display, GLADloadproc load, void* userptr);
GLAPI int gladLoadEGLSimple(EGLDisplay display, GLADsimpleloadproc load);
#ifdef GLAD_EGL #ifdef GLAD_EGL
GLAPI int gladLoadEGLInternalLoader(EGLDisplay display); GLAD_API_CALL int gladLoaderLoadEGL(EGLDisplay display);
GLAPI void gladUnloadEGLInternalLoader(void); GLAD_API_CALL void gladLoaderUnloadEGL(void);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif

10136
examples/ThirdPartyLibs/glad/glad/gl.h
View File

File diff suppressed because it is too large Load Diff

1819
examples/ThirdPartyLibs/glad/glad/glx.h
View File

File diff suppressed because it is too large Load Diff

1166
examples/ThirdPartyLibs/glad/glx.c → examples/ThirdPartyLibs/glad/glx_dyn.c
View File

File diff suppressed because it is too large Load Diff

2
setup.py
View File

@@ -397,7 +397,7 @@ if _platform == "linux" or _platform == "linux2":
sources = sources + ["examples/ThirdPartyLibs/enet/unix.c"]\ sources = sources + ["examples/ThirdPartyLibs/enet/unix.c"]\
+["examples/OpenGLWindow/X11OpenGLWindow.cpp"]\ +["examples/OpenGLWindow/X11OpenGLWindow.cpp"]\
+["examples/ThirdPartyLibs/glad/gl.c"]\ +["examples/ThirdPartyLibs/glad/gl.c"]\
+["examples/ThirdPartyLibs/glad/glx.c"] +["examples/ThirdPartyLibs/glad/glx_dyn.c"]
include_dirs += ["examples/ThirdPartyLibs/optionalX11"] include_dirs += ["examples/ThirdPartyLibs/optionalX11"]
if 'BT_USE_EGL' in CXX_FLAGS: if 'BT_USE_EGL' in CXX_FLAGS:
# linking with bullet's Glew libraries causes segfault # linking with bullet's Glew libraries causes segfault