added glad generator and a glad runtime

tools/glad-0.1.14a0/glad/lang/c/loader/__init__.py

@@ -0,0 +1,132 @@
+
+LOAD_OPENGL_DLL = '''
+%(pre)s void* %(proc)s(const char *namez);
+
+#ifdef _WIN32
+#include <windows.h>
+static HMODULE libGL;
+
+typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*);
+static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
+
+%(pre)s
+int %(init)s(void) {
+    libGL = LoadLibraryW(L"opengl32.dll");
+    if(libGL != NULL) {
+        gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE)GetProcAddress(
+                libGL, "wglGetProcAddress");
+        return gladGetProcAddressPtr != NULL;
+    }
+
+    return 0;
+}
+
+%(pre)s
+void %(terminate)s(void) {
+    if(libGL != NULL) {
+        FreeLibrary(libGL);
+        libGL = NULL;
+    }
+}
+#else
+#include <dlfcn.h>
+static void* libGL;
+
+#ifndef __APPLE__
+typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*);
+static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
+#endif
+
+%(pre)s
+int %(init)s(void) {
+#ifdef __APPLE__
+    static const char *NAMES[] = {
+        "../Frameworks/OpenGL.framework/OpenGL",
+        "/Library/Frameworks/OpenGL.framework/OpenGL",
+        "/System/Library/Frameworks/OpenGL.framework/OpenGL",
+        "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
+    };
+#else
+    static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
+#endif
+
+    unsigned int index = 0;
+    for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
+        libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
+
+        if(libGL != NULL) {
+#ifdef __APPLE__
+            return 1;
+#else
+            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
+                "glXGetProcAddressARB");
+            return gladGetProcAddressPtr != NULL;
+#endif
+        }
+    }
+
+    return 0;
+}
+
+%(pre)s
+void %(terminate)s() {
+    if(libGL != NULL) {
+        dlclose(libGL);
+        libGL = NULL;
+    }
+}
+#endif
+
+%(pre)s
+void* %(proc)s(const char *namez) {
+    void* result = NULL;
+    if(libGL == NULL) return NULL;
+
+#ifndef __APPLE__
+    if(gladGetProcAddressPtr != NULL) {
+        result = gladGetProcAddressPtr(namez);
+    }
+#endif
+    if(result == NULL) {
+#ifdef _WIN32
+        result = (void*)GetProcAddress(libGL, namez);
+#else
+        result = dlsym(libGL, namez);
+#endif
+    }
+
+    return result;
+}
+'''
+
+LOAD_OPENGL_DLL_H = '''
+'''
+
+LOAD_OPENGL_GLAPI_H = '''
+#ifndef GLAPI
+# if defined(GLAD_GLAPI_EXPORT)
+#  if defined(_WIN32) || defined(__CYGWIN__)
+#   if defined(GLAD_GLAPI_EXPORT_BUILD)
+#    if defined(__GNUC__)
+#     define GLAPI __attribute__ ((dllexport)) extern
+#    else
+#     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
+'''
+

tools/glad-0.1.14a0/glad/lang/c/loader/egl.py

@@ -0,0 +1,85 @@
+from glad.lang.common.loader import BaseLoader
+
+
+_EGL_LOADER = '''
+int gladLoadEGL(void) {
+    return gladLoadEGLLoader((GLADloadproc)eglGetProcAddress);
+}
+'''
+
+_EGL_HEADER = '''
+#ifndef __glad_egl_h_
+
+#ifdef __egl_h_
+#error EGL header already included, remove this include, glad already provides it
+#endif
+
+#define __glad_egl_h_
+#define __egl_h_
+
+#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
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* (* GLADloadproc)(const char *name);
+'''
+
+_EGL_HEADER_LOADER = '''
+GLAPI int gladLoadEGL(void);
+'''
+
+_EGL_HEADER_END = '''
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+'''
+
+_EGL_HAS_EXT = '''
+'''
+
+
+class EGLCLoader(BaseLoader):
+    def write(self, fobj):
+        if not self.disabled:
+            fobj.write(_EGL_LOADER)
+
+    def write_begin_load(self, fobj):
+        # suppress unused warnings
+        fobj.write('\t(void) load;\n')
+
+    def write_end_load(self, fobj):
+        fobj.write('\treturn 1;\n')
+
+    def write_find_core(self, fobj):
+        pass
+
+    def write_has_ext(self, fobj):
+        fobj.write(_EGL_HAS_EXT)
+
+    def write_header(self, fobj):
+        fobj.write(_EGL_HEADER)
+        if not self.disabled:
+            fobj.write(_EGL_HEADER_LOADER)
+
+    def write_header_end(self, fobj):
+        fobj.write(_EGL_HEADER_END)
+

tools/glad-0.1.14a0/glad/lang/c/loader/gl.py

@@ -0,0 +1,242 @@
+from glad.lang.common.loader import BaseLoader
+from glad.lang.c.loader import LOAD_OPENGL_DLL, LOAD_OPENGL_DLL_H, LOAD_OPENGL_GLAPI_H
+
+
+_OPENGL_LOADER = \
+    LOAD_OPENGL_DLL % {'pre':'static', 'init':'open_gl',
+                       'proc':'get_proc', 'terminate':'close_gl'} + '''
+int gladLoadGL(void) {
+    int status = 0;
+
+    if(open_gl()) {
+        status = gladLoadGLLoader(&get_proc);
+        close_gl();
+    }
+
+    return status;
+}
+'''
+
+_OPENGL_HAS_EXT = '''
+struct gladGLversionStruct GLVersion;
+
+#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
+#define _GLAD_IS_SOME_NEW_VERSION 1
+#endif
+
+static int max_loaded_major;
+static int max_loaded_minor;
+
+static const char *exts = NULL;
+static int num_exts_i = 0;
+static const char **exts_i = NULL;
+
+static int get_exts(void) {
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    if(max_loaded_major < 3) {
+#endif
+        exts = (const char *)glGetString(GL_EXTENSIONS);
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    } else {
+        unsigned int index;
+
+        num_exts_i = 0;
+        glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
+        if (num_exts_i > 0) {
+            exts_i = (const char **)realloc((void *)exts_i, (size_t)num_exts_i * (sizeof *exts_i));
+        }
+
+        if (exts_i == NULL) {
+            return 0;
+        }
+
+        for(index = 0; index < (unsigned)num_exts_i; index++) {
+            exts_i[index] = (const char*)glGetStringi(GL_EXTENSIONS, index);
+        }
+    }
+#endif
+    return 1;
+}
+
+static void free_exts(void) {
+    if (exts_i != NULL) {
+        free(exts_i);
+        exts_i = NULL;
+    }
+}
+
+static int has_ext(const char *ext) {
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    if(max_loaded_major < 3) {
+#endif
+        const char *extensions;
+        const char *loc;
+        const char *terminator;
+        extensions = exts;
+        if(extensions == NULL || ext == NULL) {
+            return 0;
+        }
+
+        while(1) {
+            loc = strstr(extensions, ext);
+            if(loc == NULL) {
+                return 0;
+            }
+
+            terminator = loc + strlen(ext);
+            if((loc == extensions || *(loc - 1) == ' ') &&
+                (*terminator == ' ' || *terminator == '\\0')) {
+                return 1;
+            }
+            extensions = terminator;
+        }
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    } else {
+        int index;
+
+        for(index = 0; index < num_exts_i; index++) {
+            const char *e = exts_i[index];
+
+            if(strcmp(e, ext) == 0) {
+                return 1;
+            }
+        }
+    }
+#endif
+
+    return 0;
+}
+'''
+
+
+_OPENGL_HEADER_START = '''
+#ifndef __glad_h_
+#define __glad_h_
+'''
+
+_OPENGL_HEADER_INCLUDE_ERROR = '''
+#ifdef __{0}_h_
+#error {1} header already included, remove this include, glad already provides it
+#endif
+#define __{0}_h_
+'''
+
+_OPENGL_HEADER = '''
+#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
+extern "C" {
+#endif
+
+struct gladGLversionStruct {
+    int major;
+    int minor;
+};
+
+typedef void* (* GLADloadproc)(const char *name);
+''' + LOAD_OPENGL_GLAPI_H + '''
+GLAPI struct gladGLversionStruct GLVersion;
+'''
+
+_OPENGL_HEADER_LOADER = '''
+GLAPI int gladLoadGL(void);
+''' + LOAD_OPENGL_DLL_H
+
+_OPENGL_HEADER_END = '''
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+'''
+
+_FIND_VERSION = '''
+    /* Thank you @elmindreda
+     * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176
+     * https://github.com/glfw/glfw/blob/master/src/context.c#L36
+     */
+    int i, major, minor;
+
+    const char* version;
+    const char* prefixes[] = {
+        "OpenGL ES-CM ",
+        "OpenGL ES-CL ",
+        "OpenGL ES ",
+        NULL
+    };
+
+    version = (const char*) glGetString(GL_VERSION);
+    if (!version) return;
+
+    for (i = 0;  prefixes[i];  i++) {
+        const size_t length = strlen(prefixes[i]);
+        if (strncmp(version, prefixes[i], length) == 0) {
+            version += length;
+            break;
+        }
+    }
+
+/* PR #18 */
+#ifdef _MSC_VER
+    sscanf_s(version, "%d.%d", &major, &minor);
+#else
+    sscanf(version, "%d.%d", &major, &minor);
+#endif
+
+    GLVersion.major = major; GLVersion.minor = minor;
+    max_loaded_major = major; max_loaded_minor = minor;
+'''
+
+
+class OpenGLCLoader(BaseLoader):
+    def write(self, fobj):
+        if not self.disabled and 'gl' in self.apis:
+            fobj.write(_OPENGL_LOADER)
+
+    def write_begin_load(self, fobj):
+        fobj.write('\tGLVersion.major = 0; GLVersion.minor = 0;\n')
+        fobj.write('\tglGetString = (PFNGLGETSTRINGPROC)load("glGetString");\n')
+        fobj.write('\tif(glGetString == NULL) return 0;\n')
+        fobj.write('\tif(glGetString(GL_VERSION) == NULL) return 0;\n')
+
+    def write_end_load(self, fobj):
+        fobj.write('\treturn GLVersion.major != 0 || GLVersion.minor != 0;\n')
+
+    def write_find_core(self, fobj):
+        fobj.write(_FIND_VERSION)
+
+    def write_find_core_end(self, fobj):
+        fobj.write(_FIND_VERSION)
+
+    def write_has_ext(self, fobj):
+        fobj.write(_OPENGL_HAS_EXT)
+
+    def write_header(self, fobj):
+        fobj.write(_OPENGL_HEADER_START)
+        written = set()
+        for api, hname, name in [
+            ('gl', 'gl', 'OpenGL'), ('gles1', 'gl', 'OpenGL ES 1'),
+            ('gles2', 'gl2', 'OpenGL ES 2'), ('gles2', 'gl3', 'OpenGL ES 3')
+        ]:
+            if api in self.apis and hname not in written:
+                fobj.write(_OPENGL_HEADER_INCLUDE_ERROR.format(hname, name))
+                written.add(hname)
+
+        fobj.write(_OPENGL_HEADER)
+        if not self.disabled and 'gl' in self.apis:
+            fobj.write(_OPENGL_HEADER_LOADER)
+
+    def write_header_end(self, fobj):
+        fobj.write(_OPENGL_HEADER_END)

tools/glad-0.1.14a0/glad/lang/c/loader/glx.py

@@ -0,0 +1,148 @@
+from glad.lang.common.loader import BaseLoader
+from glad.lang.c.loader import LOAD_OPENGL_DLL, LOAD_OPENGL_DLL_H, LOAD_OPENGL_GLAPI_H
+
+_GLX_LOADER = \
+    LOAD_OPENGL_DLL % {'pre':'static', 'init':'open_gl',
+                       'proc':'get_proc', 'terminate':'close_gl'} + '''
+int gladLoadGLX(Display *dpy, int screen) {
+    int status = 0;
+
+    if(open_gl()) {
+        status = gladLoadGLXLoader((GLADloadproc)get_proc, dpy, screen);
+        close_gl();
+    }
+
+    return status;
+}
+'''
+
+_GLX_HEADER_START = '''
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+'''
+
+#include <glad/glad.h>
+
+_WGL_HEADER_MID = '''
+#ifndef __glad_glxext_h_
+
+#ifdef __glxext_h_
+#error GLX header already included, remove this include, glad already provides it
+#endif
+
+#define __glad_glxext_h_
+#define __glxext_h_
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* (* GLADloadproc)(const char *name);
+''' + LOAD_OPENGL_GLAPI_H
+
+_GLX_HEADER_LOADER = '''
+GLAPI int gladLoadGLX(Display *dpy, int screen);
+''' + LOAD_OPENGL_DLL_H
+
+_GLX_HEADER_END = '''
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+'''
+
+_GLX_HAS_EXT = '''
+static Display *GLADGLXDisplay = 0;
+static int GLADGLXscreen = 0;
+
+static int get_exts(void) {
+    return 1;
+}
+
+static void free_exts(void) {
+    return;
+}
+
+static int has_ext(const char *ext) {
+    const char *terminator;
+    const char *loc;
+    const char *extensions;
+
+    if(!GLAD_GLX_VERSION_1_1)
+        return 0;
+
+    extensions = glXQueryExtensionsString(GLADGLXDisplay, GLADGLXscreen);
+
+    if(extensions == NULL || ext == NULL)
+        return 0;
+
+    while(1) {
+        loc = strstr(extensions, ext);
+        if(loc == NULL)
+            break;
+
+        terminator = loc + strlen(ext);
+        if((loc == extensions || *(loc - 1) == ' ') &&
+            (*terminator == ' ' || *terminator == '\\0'))
+        {
+            return 1;
+        }
+        extensions = terminator;
+    }
+
+    return 0;
+}
+
+'''
+
+
+class GLXCLoader(BaseLoader):
+    def write(self, fobj):
+        if not self.disabled:
+            fobj.write(_GLX_LOADER)
+
+    def write_begin_load(self, fobj):
+        fobj.write('\tglXQueryVersion = (PFNGLXQUERYVERSIONPROC)load("glXQueryVersion");\n')
+        fobj.write('\tif(glXQueryVersion == NULL) return 0;\n')
+
+    def write_end_load(self, fobj):
+        fobj.write('\treturn 1;\n')
+
+    def write_find_core(self, fobj):
+        fobj.write('\tint major = 0, minor = 0;\n')
+        fobj.write('\tif(dpy == 0 && GLADGLXDisplay == 0) {\n')
+        fobj.write('\t\tdpy = XOpenDisplay(0);\n')
+        fobj.write('\t\tscreen = XScreenNumberOfScreen(XDefaultScreenOfDisplay(dpy));\n')
+        fobj.write('\t} else if(dpy == 0) {\n')
+        fobj.write('\t\tdpy = GLADGLXDisplay;\n')
+        fobj.write('\t\tscreen = GLADGLXscreen;\n')
+        fobj.write('\t}\n')
+        fobj.write('\tglXQueryVersion(dpy, &major, &minor);\n')
+        fobj.write('\tGLADGLXDisplay = dpy;\n')
+        fobj.write('\tGLADGLXscreen = screen;\n')
+
+    def write_has_ext(self, fobj):
+        fobj.write(_GLX_HAS_EXT)
+
+    def write_header(self, fobj):
+        fobj.write(_GLX_HEADER_START)
+        if self.local_files:
+            fobj.write('#include "glad.h"\n')
+        else:
+            fobj.write('#include <glad/glad.h>\n')
+        fobj.write(_WGL_HEADER_MID)
+        if not self.disabled:
+            fobj.write(_GLX_HEADER_LOADER)
+
+    def write_header_end(self, fobj):
+        fobj.write(_GLX_HEADER_END)
+

tools/glad-0.1.14a0/glad/lang/c/loader/wgl.py

@@ -0,0 +1,142 @@
+from glad.lang.common.loader import BaseLoader
+from glad.lang.c.loader import LOAD_OPENGL_DLL, LOAD_OPENGL_DLL_H, LOAD_OPENGL_GLAPI_H
+
+_WGL_LOADER = \
+    LOAD_OPENGL_DLL % {'pre':'static', 'init':'open_gl',
+                       'proc':'get_proc', 'terminate':'close_gl'} + '''
+int gladLoadWGL(HDC hdc) {
+    int status = 0;
+
+    if(open_gl()) {
+        status = gladLoadWGLLoader((GLADloadproc)get_proc, hdc);
+        close_gl();
+    }
+
+    return status;
+}
+'''
+
+_WGL_HEADER_START = '''
+#ifndef WINAPI
+# ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN 1
+# endif
+# include <windows.h>
+#endif
+
+'''
+
+#include <glad/glad.h>
+
+_WGL_HEADER_MID = '''
+#ifndef __glad_wglext_h_
+
+#ifdef __wglext_h_
+#error WGL header already included, remove this include, glad already provides it
+#endif
+
+#define __glad_wglext_h_
+#define __wglext_h_
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* (* GLADloadproc)(const char *name);
+''' + LOAD_OPENGL_GLAPI_H
+
+_WGL_HEADER_LOADER = '''
+GLAPI int gladLoadWGL(HDC hdc);
+''' + LOAD_OPENGL_DLL_H
+
+_WGL_HEADER_END = '''
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+'''
+
+_WGL_HAS_EXT = '''
+static HDC GLADWGLhdc = (HDC)INVALID_HANDLE_VALUE;
+
+static int get_exts(void) {
+    return 1;
+}
+
+static void free_exts(void) {
+    return;
+}
+
+static int has_ext(const char *ext) {
+    const char *terminator;
+    const char *loc;
+    const char *extensions;
+
+    if(wglGetExtensionsStringEXT == NULL && wglGetExtensionsStringARB == NULL)
+        return 0;
+
+    if(wglGetExtensionsStringARB == NULL || GLADWGLhdc == INVALID_HANDLE_VALUE)
+        extensions = wglGetExtensionsStringEXT();
+    else
+        extensions = wglGetExtensionsStringARB(GLADWGLhdc);
+
+    if(extensions == NULL || ext == NULL)
+        return 0;
+
+    while(1) {
+        loc = strstr(extensions, ext);
+        if(loc == NULL)
+            break;
+
+        terminator = loc + strlen(ext);
+        if((loc == extensions || *(loc - 1) == ' ') &&
+            (*terminator == ' ' || *terminator == '\\0'))
+        {
+            return 1;
+        }
+        extensions = terminator;
+    }
+
+    return 0;
+}
+'''
+
+class WGLCLoader(BaseLoader):
+    def write(self, fobj):
+        if not self.disabled:
+            fobj.write(_WGL_LOADER)
+
+    def write_begin_load(self, fobj):
+        fobj.write('\twglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)load("wglGetExtensionsStringARB");\n')
+        fobj.write('\twglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)load("wglGetExtensionsStringEXT");\n')
+        fobj.write('\tif(wglGetExtensionsStringARB == NULL && wglGetExtensionsStringEXT == NULL) return 0;\n')
+
+    def write_end_load(self, fobj):
+        fobj.write('\treturn 1;\n')
+
+    def write_find_core(self, fobj):
+        fobj.write('\tGLADWGLhdc = hdc;\n')
+
+    def write_has_ext(self, fobj):
+        fobj.write(_WGL_HAS_EXT)
+
+    def write_header(self, fobj):
+        fobj.write(_WGL_HEADER_START)
+        if self.local_files:
+            fobj.write('#include "glad.h"\n')
+        else:
+            fobj.write('#include <glad/glad.h>\n')
+        fobj.write(_WGL_HEADER_MID)
+        if not self.disabled:
+            fobj.write(_WGL_HEADER_LOADER)
+
+    def write_header_end(self, fobj):
+        fobj.write(_WGL_HEADER_END)