glshim update

project/jni/glshim/flags.cmake

@@ -1,6 +0,0 @@
-add_definitions(-g -funwind-tables -ffast-math)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive")
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm")
-    add_definitions(-fsingle-precision-constant -mfpu=neon -march=armv7-a -mcpu=cortex-a8 -mtune=cortex-a8)
-endif()

project/jni/glshim/include/GL/glx.h

@@ -35,8 +35,10 @@
 #pragma message disable nosimpint
 #endif
 #endif
-//#include <X11/Xlib.h>
+#ifndef ANDROID
-//#include <X11/Xutil.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif //ANDROID
 #ifdef __VMS
 # ifdef __cplusplus
 #pragma message enable nosimpint

project/jni/glshim/spec/build

@@ -2,18 +2,25 @@
 cd "$(dirname "$0")"
 
 base=../src/
-gles="yml/gles-1.1.yml,yml/oes.yml"
+gles1=$(ls -1 yml/*-1.1.yml | tr '\n' ',' | sed -e 's/,$//')
-gles2="yml/gles-2.0.yml"
+gles=$(ls -1 yml/*es-1.1.yml | tr '\n' ',' | sed -e 's/,$//')
-opengl="yml/opengl.yml"
+glext=$(ls -1 yml/*ext-1.1.yml | tr '\n' ',' | sed -e 's/,$//')
-cats="VERSION_1_0,VERSION_1_1,VERSION_1_2,VERSION_1_3,VERSION_1_4,VERSION_1_5,EXT_swap_control"
+gles2=$(ls -1 yml/*-2.0.yml | tr '\n' ',' | sed -e 's/,$//')
 
-./gen.py "$gles" mock.c.j2 mock.c mock.h > "$base/../test/util/mock.c" &
+./gen.py "$gles" --ifndef USE_ES2 gleswrap.c.j2 gleswrap.c gles.h > "$base/gl/wrap/gles.c"
-./gen.py "$gles" --ifndef USE_ES2 mock.h.j2 mock.h "gl_str.h" "wrap/gles.h" > "$base/../test/util/mock.h"
+./gen.py "$glext" --ifndef USE_ES2 glextwrap.c.j2 glextwrap.c gles.h > "$base/gl/wrap/glesext.c"
+./gen.py "$gles1" --ifndef USE_ES2 glwrap.h.j2 gleswrap.h ../gl.h > "$base/gl/wrap/gles.h"
+./gen.py "$gles1" --ifndef USE_ES2 glxfuncs.j2 glxfuncs.inc ../gl/gl.h > "$base/glx/glesfuncs.inc"
 
-./gen.py "$gles" --ifndef USE_ES2 gleswrap.c.j2 gleswrap.c gles.h ../loader.h ../skip.h > "$base/gl/wrap/gles.c" &
+./gen.py "$gles2" --ifdef USE_ES2 gleswrap.c.j2 gles2wrap.c gles2.h > "$base/gl/wrap/gles2.c"
-./gen.py --deep "$opengl,$gles" --ifndef USE_ES2 glwrap.h.j2 gleswrap.h ../types.h > "$base/gl/wrap/gles.h"
+./gen.py "$gles2" --ifdef USE_ES2 glwrap.h.j2 gles2wrap.h ../gl.h > "$base/gl/wrap/gles2.h"
+./gen.py "$gles2" --ifdef USE_ES2 glxfuncs.j2 gles2funcs.inc ../gl/gl.h > "$base/glx/gles2funcs.inc"
 
-./gen.py "$gles2" --ifdef USE_ES2 gleswrap.c.j2 gles2wrap.c gles2.h ../loader.h > "$base/gl/wrap/gles2.c"
+# ./gen.py "yml/egl.yml" eglwrap.c.j2 eglwrap.c "<GLES/egl.h>" > "$base/gl/wrap/egl.c" &
-./gen.py "$gles2" --ifdef USE_ES2 glwrap.h.j2 gles2wrap.h > "$base/gl/wrap/gles2.h"
 
-rm -rf "$base/../test/build"
+cats="VERSION_1_0,VERSION_1_1,VERSION_1_2,VERSION_1_3,VERSION_1_4,VERSION_1_5,glx"
+proxy='yml/opengl.yml,yml/my_glx.yml,yml/glxext.yml,yml/alsa.yml'
+./gen.py --deep --cats "$cats" "$proxy" proxy.h.j2 proxy.h "<GL/gl.h>" "<GL/glx.h>" "<stdlib.h>" "<alsa/asoundlib.h>" "../gl/defines.h" "../config.h" "config.h" > "$base/proxy/proxy.h"
+./gen.py --deep --cats "$cats" "$proxy" client.c.j2 client.c "../proxy.h" > "$base/proxy/client/src/client.c"
+./gen.py --deep --cats "$cats" "$proxy" host.c.j2 host.c "../proxy.h" > "$base/proxy/host/host.c"
+#wait

project/jni/glshim/spec/gen.py

@@ -8,6 +8,7 @@ from yaml import load
 split_re = re.compile(r'^(?P<type>.*?)\s*(?P<name>\w+)$')
 env = jinja2.Environment(
     trim_blocks=True,
+    lstrip_blocks=True,
     loader=jinja2.FileSystemLoader('template'),
 )
 
@@ -19,30 +20,27 @@ def args(args, add_type=True):
 
 f = '0.2f'
 printf_lookup = {
-    'GLbitfield':    'd',
+    'GLbitfield': 'd',
-    'GLboolean':     'd',
+    'GLboolean': 'd',
-    'GLbyte':        'c',
+    'GLbyte': 'c',
-    'GLubyte':       'c',
+    'GLubyte': 'c',
-    'GLchar':        'c',
+    'GLchar': 'c',
-    'GLdouble':      '0.2f',
+    'GLdouble': '0.2f',
-    'GLenum':        '0x%04X',
+    'GLenum': 'u',
-    'GLfloat':       '0.2f',
+    'GLfloat': '0.2f',
-    'GLint':         'd',
+    'GLint': 'd',
-    'GLintptr':      'd',
+    'GLintptr': 'd',
-    'GLintptrARB':   'd',
+    'GLintptrARB': 'd',
-    'GLshort':       'd',
+    'GLshort': 'd',
-    'GLsizei':       'd',
+    'GLsizei': 'd',
-    'GLsizeiptr':    'd',
+    'GLsizeiptr': 'd',
     'GLsizeiptrARB': 'd',
-    'GLuint':        'u',
+    'GLuint': 'u',
-    'GLushort':      'u',
+    'GLushort': 'u',
-    'GLvoid':        'p',
+    'GLvoid': 'p',
 }
 
 def printf(args):
-    if isinstance(args, dict):
-        args = (args,)
-
     types = []
     for arg in args:
         typ = arg['type']
@@ -50,11 +48,10 @@ def printf(args):
             t = 'p'
         else:
             t = printf_lookup.get(typ, 'p')
-        if not '%' in t:
+
-            t = '%' + t
         types.append(t)
 
-    return ', '.join(types)
+    return ', '.join('%' + t for t in types)
 
 def unconst(s):
     split = s.split(' ')

project/jni/glshim/spec/template/base/base.j2

@@ -3,5 +3,6 @@
 {% if ifndef %}#ifndef {{ ifndef }}
 {% endif %}
 {% block main %}{% endblock %}
+{% block content %}{% endblock %}
 {% if ifdef %}#endif{% endif %}
 {% if ifndef %}#endif{% endif %}

project/jni/glshim/spec/template/base/headers.j2

@@ -1,3 +1,4 @@
+{% block headers %}
 {% for header in headers %}
 {% if "<" in header %}
 #include {{ header }}
@@ -5,3 +6,4 @@
 #include "{{ header }}"
 {% endif %}
 {% endfor %}
+{% endblock %}

project/jni/glshim/spec/template/base/wrap.c.j2

@@ -1,11 +1,9 @@
 {% extends "base/base.j2" %}
 {% block main %}
-{% block headers %}
 {% include "base/headers.j2" %}
-{% endblock %}
 {% for func in functions %}
 {% block definition scoped %}
-{{ func.return }} {% block func_prefix %}{% endblock %}{{ func.name }}({{ func.args|args }}) {
+{{ func.return }} {{ func.name }}({{ func.args|args }}) {
     {% block load scoped %}{% endblock %}
     {% block call scoped %}
     {% if not func.void %}return {% endif %}{% block prefix %}wrap{% endblock %}_{{ func.name }}({{ func.args|args(0) }});

project/jni/glshim/spec/template/base/wrap.h.j2

@@ -1,6 +1,17 @@
 {% extends "base/header.j2" %}
 {% block content %}
 
+typedef struct {
+    int format;
+    void *func;
+    void *args;
+} packed_call_t;
+
+typedef struct {
+    int func;
+    void *args;
+} indexed_call_t;
+
 enum FORMAT {
 {% for f in formats %}
     FORMAT_{{ f.types }},
@@ -19,7 +30,6 @@ typedef struct {
 typedef struct {
     int format;
     FUNC_{{ f.types }} func;
-    int refs;
     {% if f.args %}
     ARGS_{{ f.types }} args;
     {% endif %}

project/jni/glshim/spec/template/client.c.j2

@@ -0,0 +1,52 @@
+{% extends "base/wrap.c.j2" %}
+{% block headers %}
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+{{ super() }}
+
+{% endblock %}
+
+{% block main %}
+{{ super() }}
+
+snd_config_t *snd_config = NULL;
+
+__GLXextFuncPtr glXGetProcAddressARB(const GLubyte *name) {
+    {% for func in functions %}
+    {% if not func.name.startswith('snd_') %}
+    if (strcmp(name, "{{ func.name }}") == 0) {
+        return (void *){{ func.name }};
+    }
+    {% endif %}
+    {% endfor %}
+    printf("glXGetProcAddress(%s) not found\n", name);
+    return NULL;
+}
+
+__GLXextFuncPtr glXGetProcAddress(const GLubyte *name) {
+    return glXGetProcAddressARB(name);
+}
+{% endblock %}
+
+{% block definition %}
+#if !defined(skip_client_{{ func.name }}) && !defined(skip_index_{{ func.name }})
+{{ super() -}}
+#endif
+{% endblock %}
+
+{% block call %}
+    {{ func.name }}_INDEXED packed_data;
+    packed_data.func = {{ func.name }}_INDEX;
+    {% for arg in func.args %}
+    packed_data.args.a{{ loop.index }} = ({{ arg.type|unconst }}){{ arg.name }};
+    {% endfor %}
+    {% if not func.void %}
+    {{ func.return }} ret;
+    syscall(SYS_proxy, (void *)&packed_data, &ret);
+    return ret;
+    {% else %}
+    syscall(SYS_proxy, (void *)&packed_data, NULL);
+    {% endif %}
+{% endblock %}

project/jni/glshim/spec/template/eglwrap.c.j2

@@ -0,0 +1,23 @@
+{% extends "base/wrap.c.j2" %}
+{% block headers %}
+{{ super() }}
+void *egl_lib;
+#define WARN_NULL(name) if (name == NULL) printf("libGL: warning, " #name " is NULL\n");
+#define LOAD_EGL(type, name, args...)                               \
+    typedef type (*eglptr_##name)(args);                            \
+    static eglptr_##name egl_##name;                                \
+    if (egl##name == NULL) {                                        \
+        if (egl_lib == NULL) {                                      \
+            egl_lib = dlopen("libEGL.so", RTLD_LOCAL | RTLD_LAZY);  \
+            WARN_NULL(egl_lib);                                     \
+        }                                                           \
+        egl_##name = (eglptr_##name)dlsym(egl_lib, #name);          \
+        WARN_NULL(egl_lib_##name);                                  \
+    }                                                               \
+{% endblock %}
+
+{% block load %}
+    LOAD_EGL({{ func.return }}, {{ func.name }}
+        {%- if func.args %}, {{ func.args|args }}{% endif %});
+{% endblock %}
+{% block prefix %}egl{% endblock %}

project/jni/glshim/spec/template/gleswrap.c.j2

@@ -1,9 +1,13 @@
 {% extends "base/wrap.c.j2" %}
 {% block headers %}
 {{ super() }}
+
+{% endblock %}
+{% block content %}
 {% include "base/packed_call.j2" %}
 
 {% endblock %}
+
 {% block definition %}
 #ifndef skip_{{ func.name }}
 {{ super() -}}
@@ -14,7 +18,7 @@
 {% endblock %}
 {% block call %}
 #ifndef direct_{{ func.name }}
-    PUSH_IF_COMPILING({{ func.name }});
+    PUSH_IF_COMPILING({{ func.name }})
 #endif
     {{ super() }}
 {% endblock %}

project/jni/glshim/spec/template/glextwrap.c.j2

@@ -0,0 +1,20 @@
+{% extends "base/wrap.c.j2" %}
+{% block headers %}
+{{ super() }}
+
+{% endblock %}
+{% block definition %}
+#ifndef skip_{{ func.name }}
+{{ super() -}}
+#endif
+{% endblock %}
+{% block load %}
+    LOAD_GLES_OES({{ func.name }});
+{% endblock %}
+{% block call %}
+#ifndef direct_{{ func.name }}
+    PUSH_IF_COMPILING({{ func.name }})
+#endif
+    {{ super() }}
+{% endblock %}
+{% block prefix %}gles{% endblock %}

project/jni/glshim/spec/template/glwrap.h.j2

@@ -8,7 +8,6 @@
     {{ func.name }}_PACKED *packed_data = malloc(sizeof({{ func.name }}_PACKED)); \
     packed_data->format = {{ func.name }}_FORMAT; \
     packed_data->func = {{ func.name }}; \
-    packed_data->refs = 0; \
     {% if func.args %}
     {% for arg in func.args %}
     packed_data->args.a{{ loop.index }} = ({{ arg.type|unconst }}){{ arg.name }}; \
@@ -18,4 +17,4 @@
 }
 #endif
 {% endfor %}
-{% endblock %}
+{% endblock %}

project/jni/glshim/spec/template/glxfuncs.j2

@@ -0,0 +1,3 @@
+{% for func in functions %}
+EX({{ func.name }});
+{% endfor %}

project/jni/glshim/spec/template/host.c.j2

@@ -0,0 +1,6 @@
+{% extends "base/header.j2" %}
+
+{% block content %}
+{% include "base/indexed_call.j2" %}
+
+{% endblock %}

project/jni/glshim/spec/template/mock.c.j2

@@ -1,83 +0,0 @@
-{% extends "base/wrap.c.j2" %}
-{% block headers %}
-{{ super() }}
-#include <stdio.h>
-#include "tack.h"
-
-static tack_t mock = {0};
-
-const char *mock_name(int func) {
-    switch (func) {
-        {% for f in functions %}
-        case {{ f.name }}_INDEX: return "{{ f.name }}";
-        {% endfor %}
-    }
-}
-
-void mock_print(const indexed_call_t *packed) {
-    if (packed == NULL) {
-        printf("NULL()\n");
-        return;
-    }
-    switch (packed->func) {
-        {% for f in functions %}
-        case {{ f.name }}_INDEX: {
-            INDEXED_{{ f.types }} *unpacked = (INDEXED_{{ f.types }} *)packed;
-            {% if f.args %}
-            ARGS_{{ f.types }} args = unpacked->args;
-            {% endif %}
-            printf("{{ f.name }}({{ f.args|printf }});\n"
-            {%- for arg in f.args %}, args.a{{ loop.index }}{% endfor -%});
-            break;
-        }
-        {% endfor %}
-    }
-}
-
-void *mock_get(int idx) {
-    return tack_get(&mock, idx);
-}
-
-void *mock_peek() {
-    return tack_peek(&mock);
-}
-
-void *mock_cur() {
-    return tack_cur(&mock);
-}
-
-void *mock_shift() {
-    return tack_shift(&mock);
-}
-
-void *mock_slide(int func) {
-    if (mock.pos >= mock.len) {
-        return NULL;
-    }
-    indexed_call_t **stack = (indexed_call_t **)mock.data;
-    for (int i = mock.pos; i < mock.len; i++) {
-        if (stack[i]->func == func) {
-            mock.pos = i + 1;
-            return stack[i];
-        }
-    }
-    return NULL;
-}
-
-void mock_push(void *call) {
-    tack_push(&mock, call);
-}
-
-void *mock_pop() {
-    return tack_pop(&mock);
-}
-
-{% endblock %}
-
-{% block func_prefix %}gles_{% endblock %}
-{% block call %}
-    emit_{{ func.name }}({{ func.args|args(0) }});
-    {% if not func.void %}
-    return ({{ func.return }})0;
-    {% endif %}
-{% endblock %}

project/jni/glshim/spec/template/mock.h.j2

@@ -1,132 +0,0 @@
-{% extends "base/header.j2" %}
-{% block main %}
-#ifdef __cplusplus
-extern "C" {
-#endif
-{{ super() }}
-#ifdef __cplusplus
-} // extern "C"
-#endif
-{% endblock %}
-
-{% block content %}
-{{ super() }}
-const char *mock_name(int func);
-void *mock_cur();
-void *mock_get(int idx);
-void *mock_peek();
-void *mock_shift();
-void *mock_slide(int func);
-void mock_print(const indexed_call_t *packed);
-void mock_push(void *call);
-
-static int verbose_test = 0;
-static int failed_test = 0;
-#define verbose { verbose_test = 1; }
-
-#define mock_warningf(...) { printf("WARNING: "), printf(__VA_ARGS__); }
-#define mock_errorf(...) { printf("ERROR: "); printf(__VA_ARGS__); failed_test = 1; }
-#define mock_assert(cond, ...) { if (!(cond)) { mock_errorf(__VA_ARGS__); }}
-#define assert(cond) mock_assert(cond, "%s\n", #cond)
-
-#define mock_print_ptr(prefix, ptr, size) \
-    printf("%s ", prefix); \
-    if (ptr == NULL) { \
-        printf("NULL"); \
-    } else { \
-        for (size_t i = 0; i < size; i++) { \
-            if (i > 0 && i % 4 == 0) printf(" "); \
-            printf("%02X", *(uint8_t *)(ptr+i)); \
-        } \
-    } \
-    printf("\n");
-
-#define mock_return { \
-    indexed_call_t *call = NULL; \
-    while ((call = mock_shift()) != NULL) { \
-        mock_warningf("extra "); \
-        mock_print(call); \
-    } \
-    if (state.error) { \
-        mock_warningf("Ended with GL error flag: %s\n", gl_str(state.error)); \
-    } \
-    return failed_test; \
-}
-
-{% for func in functions %}
-#define pack_{{ func.name }}({{ func.args|args(0) }}) ({ \
-    {{ func.name }}_INDEXED *packed_data = malloc(sizeof({{ func.name }}_INDEXED)); \
-    packed_data->func = {{ func.name }}_INDEX; \
-    {% if func.args %}
-    {% for arg in func.args %}
-    packed_data->args.a{{ loop.index }} = ({{ arg.type|unconst }}){{ arg.name }}; \
-    {% endfor %}
-    {% endif %}
-    packed_data; \
-})
-#define emit_{{ func.name }}({{ func.args|args(0) }}) { \
-    mock_push(pack_{{ func.name }}({{ func.args|args(0) }})); \
-}
-#define test_{{ func.name }}({{ func.args|args(0) }}) { \
-    {{ func.name }}_INDEXED *packed = mock_cur(); \
-    if (packed == NULL) { \
-        mock_errorf("{{ func.name }} missing (no calls left)\n"); \
-    } else if (packed->func != {{ func.name }}_INDEX) { \
-        if (verbose_test) { \
-            mock_print(mock_cur()); \
-        } \
-        indexed_call_t *tmp = (indexed_call_t *)packed; \
-        packed = mock_slide({{ func.name }}_INDEX); \
-        if (! packed) { \
-            mock_errorf("{{ func.name }} missing\n"); \
-        } else { \
-            mock_warningf("unexpected call while looking for {{ func.name }}:\n  "); \
-            mock_print(tmp); \
-        }\
-    } else { \
-        if (verbose_test) { \
-            mock_print(mock_cur()); \
-        } \
-        mock_shift(); \
-    } \
-    if (packed) { \
-        int match = 1; \
-        void *a, *b; \
-        {% for arg in func.args %}
-        {% if '*' in arg.type %}
-        a = packed->args.a{{ loop.index }}, b = {{ arg.name }}; \
-        if (b == NULL && a != NULL || (a != NULL && b != NULL && (memcmp(a, b, sizeof({{ arg.name }})) != 0))) { \
-            printf("  ERROR: arg mismatch: {{ arg.name }}\n"); \
-            mock_print_ptr("  expected:", b, sizeof({{ arg.name }})); \
-            mock_print_ptr("     found:", a, sizeof({{ arg.name }})); \
-        {% elif 'float' in arg.type or 'double' in arg.type %}
-        if (packed->args.a{{ loop.index }} - {{ arg.name }} >= 0.01) { \
-        {% else %}
-        if (packed->args.a{{ loop.index }} != {{ arg.name }}) { \
-        {% endif %}
-            match = 0; \
-        } \
-        {% endfor %}
-        if (! match) { \
-            mock_errorf("calls do not match:\n"); \
-            printf("  have: "); mock_print((const indexed_call_t *)packed); \
-            printf("  want: {{ func.name }}({{ func.args|printf }});\n", {{ func.args|args(0) }}); \
-        } \
-    } \
-}
-{% endfor %}
-
-{% for func in functions %}
-#define gles_{{ func.name }}_INDEX {{ loop.index }}
-#define gles_{{ func.name }}_RETURN {{ func.return }}
-#define gles_{{ func.name }}_ARG_NAMES {{ func.args|args(0) }}
-#define gles_{{ func.name }}_ARG_EXPAND {{ func.args|args }}
-#define gles_{{ func.name }}_PACKED PACKED_{{ func.types }}
-#define gles_{{ func.name }}_INDEXED INDEXED_{{ func.types }}
-#define gles_{{ func.name }}_FORMAT FORMAT_{{ func.types }}
-{% endfor %}
-
-{% for func in functions %}
-{{ func.return }} gles_{{ func.name }}({{ func.name }}_ARG_EXPAND);
-{% endfor %}
-{% endblock %}

project/jni/glshim/spec/template/proxy.h.j2

@@ -0,0 +1 @@
+{% extends "base/wrap.h.j2" %}

project/jni/glshim/spec/yml/egl.yml

@@ -0,0 +1,108 @@
+eglBindAPI: [EGLBoolean, EGLenum api]
+eglBindTexImage: [EGLBoolean, EGLDisplay dpy, EGLSurface surface, EGLint buffer]
+eglChooseConfig: [EGLBoolean, EGLDisplay dpy, const EGLint * attrib_list, EGLConfig
+    * configs, EGLint config_size, EGLint * num_config]
+eglClientWaitSyncKHR: [EGLint, EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR
+    timeout]
+eglClientWaitSyncNV: [EGLint, EGLSyncNV sync, EGLint flags, EGLTimeNV timeout]
+eglCopyBuffers: [EGLBoolean, EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType
+    target]
+eglCreateContext: [EGLContext, EGLDisplay dpy, EGLConfig config, EGLContext share_context,
+  const EGLint * attrib_list]
+eglCreateDRMImageMESA: [EGLImageKHR, EGLDisplay dpy, const EGLint * attrib_list]
+eglCreateFenceSyncNV: [EGLSyncNV, EGLDisplay dpy, EGLenum condition, const EGLint
+    * attrib_list]
+eglCreateImageKHR: [EGLImageKHR, EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer
+    buffer, const EGLint * attrib_list]
+eglCreatePbufferFromClientBuffer: [EGLSurface, EGLDisplay dpy, EGLenum buftype, EGLClientBuffer
+    buffer, EGLConfig config, const EGLint * attrib_list]
+eglCreatePbufferSurface: [EGLSurface, EGLDisplay dpy, EGLConfig config, const EGLint
+    * attrib_list]
+eglCreatePixmapSurface: [EGLSurface, EGLDisplay dpy, EGLConfig config, EGLNativePixmapType
+    pixmap, const EGLint * attrib_list]
+eglCreatePixmapSurfaceHI: [EGLSurface, EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI
+    * pixmap]
+eglCreateStreamFromFileDescriptorKHR: [EGLStreamKHR, EGLDisplay dpy, EGLNativeFileDescriptorKHR
+    file_descriptor]
+eglCreateStreamKHR: [EGLStreamKHR, EGLDisplay dpy, const EGLint * attrib_list]
+eglCreateStreamProducerSurfaceKHR: [EGLSurface, EGLDisplay dpy, EGLConfig config,
+  EGLStreamKHR stream, const EGLint * attrib_list]
+eglCreateSyncKHR: [EGLSyncKHR, EGLDisplay dpy, EGLenum type, const EGLint * attrib_list]
+eglCreateWindowSurface: [EGLSurface, EGLDisplay dpy, EGLConfig config, EGLNativeWindowType
+    win, const EGLint * attrib_list]
+eglDestroyContext: [EGLBoolean, EGLDisplay dpy, EGLContext ctx]
+eglDestroyImageKHR: [EGLBoolean, EGLDisplay dpy, EGLImageKHR image]
+eglDestroyStreamKHR: [EGLBoolean, EGLDisplay dpy, EGLStreamKHR stream]
+eglDestroySurface: [EGLBoolean, EGLDisplay dpy, EGLSurface surface]
+eglDestroySyncKHR: [EGLBoolean, EGLDisplay dpy, EGLSyncKHR sync]
+eglDestroySyncNV: [EGLBoolean, EGLSyncNV sync]
+eglDupNativeFenceFDANDROID: [EGLint, EGLDisplay dpy, EGLSyncKHR sync]
+eglExportDRMImageMESA: [EGLBoolean, EGLDisplay dpy, EGLImageKHR image, EGLint * name,
+  EGLint * handle, EGLint * stride]
+eglFenceNV: [EGLBoolean, EGLSyncNV sync]
+eglGetConfigAttrib: [EGLBoolean, EGLDisplay dpy, EGLConfig config, EGLint attribute,
+  EGLint * value]
+eglGetConfigs: [EGLBoolean, EGLDisplay dpy, EGLConfig * configs, EGLint config_size,
+  EGLint * num_config]
+eglGetCurrentContext: [EGLContext]
+eglGetCurrentDisplay: [EGLDisplay]
+eglGetCurrentSurface: [EGLSurface, EGLint readdraw]
+eglGetDisplay: [EGLDisplay, EGLNativeDisplayType display_id]
+eglGetError: [EGLint]
+eglGetProcAddress: [__eglMustCastToProperFunctionPointerType, const char * procname]
+eglGetStreamFileDescriptorKHR: [EGLNativeFileDescriptorKHR, EGLDisplay dpy, EGLStreamKHR
+    stream]
+eglGetSyncAttribKHR: [EGLBoolean, EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute,
+  EGLint * value]
+eglGetSyncAttribNV: [EGLBoolean, EGLSyncNV sync, EGLint attribute, EGLint * value]
+eglGetSystemTimeFrequencyNV: [EGLuint64NV]
+eglGetSystemTimeNV: [EGLuint64NV]
+eglInitialize: [EGLBoolean, EGLDisplay dpy, EGLint * major, EGLint * minor]
+eglLockSurfaceKHR: [EGLBoolean, EGLDisplay display, EGLSurface surface, const EGLint
+    * attrib_list]
+eglMakeCurrent: [EGLBoolean, EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext
+    ctx]
+eglPostSubBufferNV: [EGLBoolean, EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint
+    y, EGLint width, EGLint height]
+eglQueryAPI: [EGLenum]
+eglQueryContext: [EGLBoolean, EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint
+    * value]
+eglQueryNativeDisplayNV: [EGLBoolean, EGLDisplay dpy, EGLNativeDisplayType * display_id]
+eglQueryNativePixmapNV: [EGLBoolean, EGLDisplay dpy, EGLSurface surf, EGLNativePixmapType
+    * pixmap]
+eglQueryNativeWindowNV: [EGLBoolean, EGLDisplay dpy, EGLSurface surf, EGLNativeWindowType
+    * window]
+eglQueryStreamKHR: [EGLBoolean, EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
+  EGLint * value]
+eglQueryStreamTimeKHR: [EGLBoolean, EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
+  EGLTimeKHR * value]
+eglQueryStreamu64KHR: [EGLBoolean, EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
+  EGLuint64KHR * value]
+eglQueryString: [const char *, EGLDisplay dpy, EGLint name]
+eglQuerySurface: [EGLBoolean, EGLDisplay dpy, EGLSurface surface, EGLint attribute,
+  EGLint * value]
+eglQuerySurfacePointerANGLE: [EGLBoolean, EGLDisplay dpy, EGLSurface surface, EGLint
+    attribute, void ** value]
+eglReleaseTexImage: [EGLBoolean, EGLDisplay dpy, EGLSurface surface, EGLint buffer]
+eglReleaseThread: [EGLBoolean]
+eglSetBlobCacheFuncsANDROID: ['void ', EGLDisplay dpy, EGLSetBlobFuncANDROID set,
+  EGLGetBlobFuncANDROID get]
+eglSignalSyncKHR: [EGLBoolean, EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode]
+eglSignalSyncNV: [EGLBoolean, EGLSyncNV sync, EGLenum mode]
+eglStreamAttribKHR: [EGLBoolean, EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute,
+  EGLint value]
+eglStreamConsumerAcquireKHR: [EGLBoolean, EGLDisplay dpy, EGLStreamKHR stream]
+eglStreamConsumerGLTextureExternalKHR: [EGLBoolean, EGLDisplay dpy, EGLStreamKHR stream]
+eglStreamConsumerReleaseKHR: [EGLBoolean, EGLDisplay dpy, EGLStreamKHR stream]
+eglSurfaceAttrib: [EGLBoolean, EGLDisplay dpy, EGLSurface surface, EGLint attribute,
+  EGLint value]
+eglSwapBuffers: [EGLBoolean, EGLDisplay dpy, EGLSurface surface]
+eglSwapBuffersWithDamageEXT: [EGLBoolean, EGLDisplay dpy, EGLSurface surface, EGLint
+    * rects, EGLint n_rects]
+eglSwapInterval: [EGLBoolean, EGLDisplay dpy, EGLint interval]
+eglTerminate: [EGLBoolean, EGLDisplay dpy]
+eglUnlockSurfaceKHR: [EGLBoolean, EGLDisplay display, EGLSurface surface]
+eglWaitClient: [EGLBoolean]
+eglWaitGL: [EGLBoolean]
+eglWaitNative: [EGLBoolean, EGLint engine]
+eglWaitSyncKHR: [EGLint, EGLDisplay dpy, EGLSyncKHR sync, EGLint flags]

project/jni/glshim/spec/yml/glext-1.1.yml

@@ -1,4 +1,27 @@
+glBlendColor: [void, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha]
+glBlendEquation: [void, GLenum mode]
+glBlendEquationSeparate: [void, GLenum modeRGB, GLenum modeA]
+glBlendFuncSeparate: [void, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha]
 # glTexGenfOES: [void, GLenum coord, GLenum pname, GLfloat param]
-# glTexGenfvOES: [void, GLenum coord, GLenum pname, "const GLfloat *params"]
+glTexGenfv: [void, GLenum coord, GLenum pname, "const GLfloat *params"]
-# glTexGeniOES: [void, GLenum coord, GLenum pname, GLint param]
+glTexGeni: [void, GLenum coord, GLenum pname, GLint param]
 # glTexGenivOES: [void, GLenum coord, GLenum pname, "const GLint *params"]
+
+glGenFramebuffers: [void, GLsizei n, "GLuint *ids"]
+glDeleteFramebuffers: [void, GLsizei n, "GLuint *framebuffers"]
+glIsFramebuffer: [GLboolean, GLuint framebuffer]
+glCheckFramebufferStatus: [GLenum, GLenum target]
+glBindFramebuffer: [void, GLenum target, GLuint framebuffer]
+glFramebufferTexture2D: [void, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level]
+glGenRenderbuffers: [void, GLsizei n, "GLuint *renderbuffers"]
+glFramebufferRenderbuffer: [void, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer]
+glDeleteRenderbuffers: [void, GLsizei n, "GLuint *renderbuffers"]
+glRenderbufferStorage: [void, GLenum target, GLenum internalformat, GLsizei width, GLsizei height]
+glBindRenderbuffer: [void, GLenum target, GLuint renderbuffer]
+glIsRenderbuffer: [GLboolean, GLuint renderbuffer]
+glGenerateMipmap: [void, GLenum target]
+glGetFramebufferAttachmentParameteriv: [void, GLenum target, GLenum attachment, GLenum pname, "GLint *params"]
+glGetRenderbufferParameteriv: [void, GLenum target, GLenum pname, "GLint * params"]
+
+glDrawTexi: [void, GLint x, GLint y, GLint z, GLint width, GLint height]
+glDrawTexf: [void, GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height]

project/jni/glshim/spec/yml/glx.yml

@@ -0,0 +1,68 @@
+glx:
+  glXBindHyperpipeSGIX: [int, Display *dpy, int hpId]
+  glXBindSwapBarrierSGIX: [void, uint32_t window, uint32_t barrier]
+  glXChangeDrawableAttributes: [void, uint32_t drawable]
+  glXChangeDrawableAttributesSGIX: [void, uint32_t drawable]
+  glXClientInfo: [void]
+  glXCopyContext: [void, uint32_t source, uint32_t dest, uint32_t mask]
+  glXCreateContext: [void, uint32_t gc_id, uint32_t screen, uint32_t visual, uint32_t
+      share_list]
+  glXCreateContextWithConfigSGIX: [void, uint32_t gc_id, uint32_t screen, uint32_t
+      config, uint32_t share_list]
+  glXCreateGLXPbufferSGIX: [void, uint32_t config, uint32_t pbuffer]
+  glXCreateGLXPixmap: [void, uint32_t visual, uint32_t pixmap, uint32_t glxpixmap]
+  glXCreateGLXPixmapWithConfigSGIX: [void, uint32_t config, uint32_t pixmap, uint32_t
+      glxpixmap]
+  glXCreateGLXVideoSourceSGIX: [void, uint32_t dpy, uint32_t screen, uint32_t server,
+    uint32_t path, uint32_t class, uint32_t node]
+  glXCreateNewContext: [void, uint32_t config, uint32_t render_type, uint32_t share_list,
+    uint32_t direct]
+  glXCreatePbuffer: [void, uint32_t config, uint32_t pbuffer]
+  glXCreatePixmap: [void, uint32_t config, uint32_t pixmap, uint32_t glxpixmap]
+  glXCreateWindow: [void, uint32_t config, uint32_t window, uint32_t glxwindow]
+  glXDestroyContext: [void, uint32_t context]
+  glXDestroyGLXPbufferSGIX: [void, uint32_t pbuffer]
+  glXDestroyGLXPixmap: [void, uint32_t pixmap]
+  glXDestroyGLXVideoSourceSGIX: [void, uint32_t dpy, uint32_t glxvideosource]
+  glXDestroyHyperpipeConfigSGIX: [int, Display *dpy, int hpId]
+  glXDestroyPbuffer: [void, uint32_t pbuffer]
+  glXDestroyPixmap: [void, uint32_t glxpixmap]
+  glXDestroyWindow: [void, uint32_t glxwindow]
+  glXGetDrawableAttributes: [void, uint32_t drawable]
+  glXGetDrawableAttributesSGIX: [void, uint32_t drawable]
+  glXGetFBConfigs: [void]
+  glXGetFBConfigsSGIX: [void]
+  glXGetVisualConfigs: [void]
+  glXHyperpipeAttribSGIX: [int, Display *dpy, int timeSlice, int attrib, int size,
+    const void *attribList]
+  glXHyperpipeConfigSGIX: [int, Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX
+      cfg, int *hpId]
+  glXIsDirect: [void, uint32_t dpy, uint32_t context]
+  glXJoinSwapGroupSGIX: [void, uint32_t window, uint32_t group]
+  glXMakeContextCurrent: [void, uint32_t drawable, uint32_t readdrawable, uint32_t
+      context]
+  glXMakeCurrent: [void, uint32_t drawable, uint32_t context]
+  glXMakeCurrentReadSGI: [void, uint32_t drawable, uint32_t readdrawable, uint32_t
+      context]
+  glXQueryContext: [void]
+  glXQueryContextInfoEXT: [void]
+  glXQueryExtensionsString: [void, uint32_t screen]
+  glXQueryHyperpipeAttribSGIX: [int, Display *dpy, int timeSlice, int attrib, int
+      size, const void *returnAttribList]
+  glXQueryHyperpipeBestAttribSGIX: [int, Display *dpy, int timeSlice, int attrib,
+    int size, const void *attribList, void *returnAttribList]
+  glXQueryHyperpipeConfigSGIX: [GLXHyperpipeConfigSGIX *, Display *dpy, int hpId,
+    int *npipes]
+  glXQueryHyperpipeNetworkSGIX: [GLXHyperpipeNetworkSGIX *, Display *dpy, int *npipes]
+  glXQueryMaxSwapBarriersSGIX: [void]
+  glXQueryServerString: [void, uint32_t screen, uint32_t name]
+  glXQueryVersion: [void, uint32_t *major, uint32_t *minor]
+  glXRender: [void]
+  glXRenderLarge: [void]
+  glXSwapBuffers: [void, uint32_t drawable]
+  glXSwapIntervalSGI: [void]
+  glXUseXFont: [void, uint32_t font, uint32_t first, uint32_t count, uint32_t list_base]
+  glXVendorPrivate: [void]
+  glXVendorPrivateWithReply: [void]
+  glXWaitGL: [void, uint32_t context]
+  glXWaitX: [void]

project/jni/glshim/spec/yml/glxext.yml

@@ -0,0 +1,178 @@
+ARB_create_context:
+  glXCreateContextAttribsARB: [GLXContext, Display *dpy, GLXFBConfig config, GLXContext
+      share_context, Bool direct, const int *attrib_list]
+ARB_get_proc_address:
+  glXGetProcAddressARB: [__GLXextFuncPtr, const GLubyte *procName]
+EXT_import_context:
+  glXFreeContextEXT: [void, Display *dpy, GLXContext context]
+  glXGetContextIDEXT: [GLXContextID, const GLXContext context]
+  glXGetCurrentDisplayEXT: [Display *]
+  glXImportContextEXT: [GLXContext, Display *dpy, GLXContextID contextID]
+  glXQueryContextInfoEXT: [int, Display *dpy, GLXContext context, int attribute, int
+      *value]
+EXT_swap_control:
+  glXSwapIntervalEXT: [void, Display *dpy, GLXDrawable drawable, int interval]
+EXT_texture_from_pixmap:
+  glXBindTexImageEXT: [void, Display *dpy, GLXDrawable drawable, int buffer, const
+      int *attrib_list]
+  glXReleaseTexImageEXT: [void, Display *dpy, GLXDrawable drawable, int buffer]
+MESA_agp_offset:
+  glXGetAGPOffsetMESA: [unsigned int, const void *pointer]
+MESA_copy_sub_buffer:
+  glXCopySubBufferMESA: [void, Display *dpy, GLXDrawable drawable, int x, int y, int
+      width, int height]
+MESA_pixmap_colormap:
+  glXCreateGLXPixmapMESA: [GLXPixmap, Display *dpy, XVisualInfo *visual, Pixmap pixmap,
+    Colormap cmap]
+MESA_release_buffers:
+  glXReleaseBuffersMESA: [Bool, Display *dpy, GLXDrawable drawable]
+MESA_set_3dfx_mode:
+  glXSet3DfxModeMESA: [Bool, int mode]
+NV_copy_image:
+  glXCopyImageSubDataNV: [void, Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum
+      srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx,
+    GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint
+      dstZ, GLsizei width, GLsizei height, GLsizei depth]
+NV_present_video:
+  glXBindVideoDeviceNV: [int, Display *dpy, unsigned int video_slot, unsigned int
+      video_device, const int *attrib_list]
+  glXEnumerateVideoDevicesNV: [unsigned int *, Display *dpy, int screen, int *nelements]
+NV_swap_group:
+  glXBindSwapBarrierNV: [Bool, Display *dpy, GLuint group, GLuint barrier]
+  glXJoinSwapGroupNV: [Bool, Display *dpy, GLXDrawable drawable, GLuint group]
+  glXQueryFrameCountNV: [Bool, Display *dpy, int screen, GLuint *count]
+  glXQueryMaxSwapGroupsNV: [Bool, Display *dpy, int screen, GLuint *maxGroups, GLuint
+      *maxBarriers]
+  glXQuerySwapGroupNV: [Bool, Display *dpy, GLXDrawable drawable, GLuint *group, GLuint
+      *barrier]
+  glXResetFrameCountNV: [Bool, Display *dpy, int screen]
+NV_video_capture:
+  glXBindVideoCaptureDeviceNV: [int, Display *dpy, unsigned int video_capture_slot,
+    GLXVideoCaptureDeviceNV device]
+  glXEnumerateVideoCaptureDevicesNV: [GLXVideoCaptureDeviceNV *, Display *dpy, int
+      screen, int *nelements]
+  glXLockVideoCaptureDeviceNV: [void, Display *dpy, GLXVideoCaptureDeviceNV device]
+  glXQueryVideoCaptureDeviceNV: [int, Display *dpy, GLXVideoCaptureDeviceNV device,
+    int attribute, int *value]
+  glXReleaseVideoCaptureDeviceNV: [void, Display *dpy, GLXVideoCaptureDeviceNV device]
+NV_video_output:
+  glXBindVideoImageNV: [int, Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer
+      pbuf, int iVideoBuffer]
+  glXGetVideoDeviceNV: [int, Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV
+      *pVideoDevice]
+  glXGetVideoInfoNV: [int, Display *dpy, int screen, GLXVideoDeviceNV VideoDevice,
+    unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo]
+  glXReleaseVideoDeviceNV: [int, Display *dpy, int screen, GLXVideoDeviceNV VideoDevice]
+  glXReleaseVideoImageNV: [int, Display *dpy, GLXPbuffer pbuf]
+  glXSendPbufferToVideoNV: [int, Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned
+      long *pulCounterPbuffer, GLboolean bBlock]
+OML_sync_control:
+  glXGetMscRateOML: [Bool, Display *dpy, GLXDrawable drawable, int32_t *numerator,
+    int32_t *denominator]
+  glXGetSyncValuesOML: [Bool, Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t
+      *msc, int64_t *sbc]
+  glXSwapBuffersMscOML: [int64_t, Display *dpy, GLXDrawable drawable, int64_t target_msc,
+    int64_t divisor, int64_t remainder]
+  glXWaitForMscOML: [Bool, Display *dpy, GLXDrawable drawable, int64_t target_msc,
+    int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc]
+  glXWaitForSbcOML: [Bool, Display *dpy, GLXDrawable drawable, int64_t target_sbc,
+    int64_t *ust, int64_t *msc, int64_t *sbc]
+SGIX_dmbuffer:
+  glXAssociateDMPbufferSGIX: [Bool, Display *dpy, GLXPbufferSGIX pbuffer, DMparams
+      *params, DMbuffer dmbuffer]
+SGIX_fbconfig:
+  glXChooseFBConfigSGIX: [GLXFBConfigSGIX *, Display *dpy, int screen, int *attrib_list,
+    int *nelements]
+  glXCreateContextWithConfigSGIX: [GLXContext, Display *dpy, GLXFBConfigSGIX config,
+    int render_type, GLXContext share_list, Bool direct]
+  glXCreateGLXPixmapWithConfigSGIX: [GLXPixmap, Display *dpy, GLXFBConfigSGIX config,
+    Pixmap pixmap]
+  glXGetFBConfigAttribSGIX: [int, Display *dpy, GLXFBConfigSGIX config, int attribute,
+    int *value]
+  glXGetFBConfigFromVisualSGIX: [GLXFBConfigSGIX, Display *dpy, XVisualInfo *vis]
+  glXGetVisualFromFBConfigSGIX: [XVisualInfo *, Display *dpy, GLXFBConfigSGIX config]
+SGIX_hyperpipe:
+  glXBindHyperpipeSGIX: [int, Display *dpy, int hpId]
+  glXDestroyHyperpipeConfigSGIX: [int, Display *dpy, int hpId]
+  glXHyperpipeAttribSGIX: [int, Display *dpy, int timeSlice, int attrib, int size,
+    void *attribList]
+  glXHyperpipeConfigSGIX: [int, Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX
+      *cfg, int *hpId]
+  glXQueryHyperpipeAttribSGIX: [int, Display *dpy, int timeSlice, int attrib, int
+      size, void *returnAttribList]
+  glXQueryHyperpipeBestAttribSGIX: [int, Display *dpy, int timeSlice, int attrib,
+    int size, void *attribList, void *returnAttribList]
+  glXQueryHyperpipeConfigSGIX: [GLXHyperpipeConfigSGIX *, Display *dpy, int hpId,
+    int *npipes]
+  glXQueryHyperpipeNetworkSGIX: [GLXHyperpipeNetworkSGIX *, Display *dpy, int *npipes]
+SGIX_pbuffer:
+  glXCreateGLXPbufferSGIX: [GLXPbufferSGIX, Display *dpy, GLXFBConfigSGIX config,
+    unsigned int width, unsigned int height, int *attrib_list]
+  glXDestroyGLXPbufferSGIX: [void, Display *dpy, GLXPbufferSGIX pbuf]
+  glXGetSelectedEventSGIX: [void, Display *dpy, GLXDrawable drawable, unsigned long
+      *mask]
+  glXQueryGLXPbufferSGIX: [int, Display *dpy, GLXPbufferSGIX pbuf, int attribute,
+    unsigned int *value]
+  glXSelectEventSGIX: [void, Display *dpy, GLXDrawable drawable, unsigned long mask]
+SGIX_swap_barrier:
+  glXBindSwapBarrierSGIX: [void, Display *dpy, GLXDrawable drawable, int barrier]
+  glXQueryMaxSwapBarriersSGIX: [Bool, Display *dpy, int screen, int *max]
+SGIX_swap_group:
+  glXJoinSwapGroupSGIX: [void, Display *dpy, GLXDrawable drawable, GLXDrawable member]
+SGIX_video_resize:
+  glXBindChannelToWindowSGIX: [int, Display *display, int screen, int channel, Window
+      window]
+  glXChannelRectSGIX: [int, Display *display, int screen, int channel, int x, int
+      y, int w, int h]
+  glXChannelRectSyncSGIX: [int, Display *display, int screen, int channel, GLenum
+      synctype]
+  glXQueryChannelDeltasSGIX: [int, Display *display, int screen, int channel, int
+      *x, int *y, int *w, int *h]
+  glXQueryChannelRectSGIX: [int, Display *display, int screen, int channel, int *dx,
+    int *dy, int *dw, int *dh]
+SGIX_video_source:
+  glXCreateGLXVideoSourceSGIX: [GLXVideoSourceSGIX, Display *display, int screen,
+    VLServer server, VLPath path, int nodeClass, VLNode drainNode]
+  glXDestroyGLXVideoSourceSGIX: [void, Display *dpy, GLXVideoSourceSGIX glxvideosource]
+SGI_cushion:
+  glXCushionSGI: [void, Display *dpy, Window window, float cushion]
+SGI_make_current_read:
+  glXGetCurrentReadDrawableSGI: [GLXDrawable]
+  glXMakeCurrentReadSGI: [Bool, Display *dpy, GLXDrawable draw, GLXDrawable read,
+    GLXContext ctx]
+SGI_swap_control:
+  glXSwapIntervalSGI: [int, int interval]
+SGI_video_sync:
+  glXGetVideoSyncSGI: [int, unsigned int *count]
+  glXWaitVideoSyncSGI: [int, int divisor, int remainder, unsigned int *count]
+SUN_get_transparent_index:
+  glXGetTransparentIndexSUN: [Status, Display *dpy, Window overlay, Window underlay,
+    long *pTransparentIndex]
+VERSION_1_3:
+  glXChooseFBConfig: [GLXFBConfig *, Display *dpy, int screen, const int *attrib_list,
+    int *nelements]
+  glXCreateNewContext: [GLXContext, Display *dpy, GLXFBConfig config, int render_type,
+    GLXContext share_list, Bool direct]
+  glXCreatePbuffer: [GLXPbuffer, Display *dpy, GLXFBConfig config, const int *attrib_list]
+  glXCreatePixmap: [GLXPixmap, Display *dpy, GLXFBConfig config, Pixmap pixmap, const
+      int *attrib_list]
+  glXCreateWindow: [GLXWindow, Display *dpy, GLXFBConfig config, Window win, const
+      int *attrib_list]
+  glXDestroyPbuffer: [void, Display *dpy, GLXPbuffer pbuf]
+  glXDestroyPixmap: [void, Display *dpy, GLXPixmap pixmap]
+  glXDestroyWindow: [void, Display *dpy, GLXWindow win]
+  glXGetCurrentDisplay: [Display *]
+  glXGetCurrentReadDrawable: [GLXDrawable]
+  glXGetFBConfigAttrib: [int, Display *dpy, GLXFBConfig config, int attribute, int
+      *value]
+  glXGetFBConfigs: [GLXFBConfig *, Display *dpy, int screen, int *nelements]
+  glXGetSelectedEvent: [void, Display *dpy, GLXDrawable draw, unsigned long *event_mask]
+  glXGetVisualFromFBConfig: [XVisualInfo *, Display *dpy, GLXFBConfig config]
+  glXMakeContextCurrent: [Bool, Display *dpy, GLXDrawable draw, GLXDrawable read,
+    GLXContext ctx]
+  glXQueryContext: [int, Display *dpy, GLXContext ctx, int attribute, int *value]
+  glXQueryDrawable: [void, Display *dpy, GLXDrawable draw, int attribute, unsigned
+      int *value]
+  glXSelectEvent: [void, Display *dpy, GLXDrawable draw, unsigned long event_mask]
+VERSION_1_4:
+  glXGetProcAddress: [__GLXextFuncPtr, const GLubyte *procName]

project/jni/glshim/spec/yml/my_glx.yml

@@ -0,0 +1,76 @@
+glx:
+  glXChooseVisual: [XVisualInfo *, Display *dpy, int screen, int *attribList]
+  glXBindHyperpipeSGIX: [int, Display *dpy, int hpId]
+  glXBindSwapBarrierSGIX: [void, uint32_t window, uint32_t barrier]
+  glXChangeDrawableAttributes: [void, uint32_t drawable]
+  glXChangeDrawableAttributesSGIX: [void, uint32_t drawable]
+  glXClientInfo: [void]
+  glXCopyContext: [void, Display *dpy, GLXContext src, GLXContext dst, unsigned long mask]
+  glXCreateContext: [GLXContext, Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct]
+  glXCreateContextAttribsARB: [GLXContext, Display *display, void *config, GLXContext share_context, Bool direct, const int *attrib_list]
+  glXCreateContextWithConfigSGIX: [void, uint32_t gc_id, uint32_t screen, uint32_t
+      config, uint32_t share_list]
+  glXCreateGLXPbufferSGIX: [void, uint32_t config, uint32_t pbuffer]
+  glXCreateGLXPixmap: [GLXPixmap, Display *dpy, XVisualInfo *visual, Pixmap pixmap]
+  glXCreateGLXPixmapWithConfigSGIX: [void, uint32_t config, uint32_t pixmap, uint32_t
+      glxpixmap]
+  glXCreateGLXVideoSourceSGIX: [void, Display *dpy, uint32_t screen, uint32_t server,
+    uint32_t path, uint32_t class, uint32_t node]
+  glXCreateNewContext: [void, uint32_t config, uint32_t render_type, uint32_t share_list,
+    uint32_t direct]
+  glXCreatePbuffer: [void, uint32_t config, uint32_t pbuffer]
+  glXCreatePixmap: [void, uint32_t config, uint32_t pixmap, uint32_t glxpixmap]
+  glXCreateWindow: [void, uint32_t config, uint32_t window, uint32_t glxwindow]
+  glXDestroyContext: [void, Display *dpy, GLXContext ctx]
+  glXDestroyGLXPbufferSGIX: [void, uint32_t pbuffer]
+  glXDestroyGLXPixmap: [void, Display *dpy, GLXPixmap pixmap]
+  glXDestroyGLXVideoSourceSGIX: [void, Display *dpy, uint32_t glxvideosource]
+  glXDestroyHyperpipeConfigSGIX: [int, Display *dpy, int hpId]
+  glXDestroyPbuffer: [void, uint32_t pbuffer]
+  glXDestroyPixmap: [void, uint32_t glxpixmap]
+  glXDestroyWindow: [void, uint32_t glxwindow]
+  glXGetDrawableAttributes: [void, uint32_t drawable]
+  glXGetDrawableAttributesSGIX: [void, uint32_t drawable]
+  glXGetClientString: [const char *, Display *display, int name]
+  glXGetCurrentContext: [GLXContext]
+  glXGetCurrentDrawable: [GLXDrawable]
+  glXGetConfig: [int, Display *display, XVisualInfo *visual, int attribute, int *value]
+  glXGetFBConfigs: [void]
+  glXGetFBConfigsSGIX: [void]
+  glXGetVisualConfigs: [void]
+  glXHyperpipeAttribSGIX: [int, Display *dpy, int timeSlice, int attrib, int size,
+    const void *attribList]
+  glXHyperpipeConfigSGIX: [int, Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX
+      cfg, int *hpId]
+  glXIsDirect: [Bool, Display *dpy, GLXContext ctx]
+  glXJoinSwapGroupSGIX: [void, uint32_t window, uint32_t group]
+  glXMakeContextCurrent: [void, uint32_t drawable, uint32_t readdrawable, uint32_t
+      context]
+  glXMakeCurrent: [Bool, Display *dpy, GLXDrawable drawable, GLXContext ctx]
+  glXMakeCurrentReadSGI: [void, uint32_t drawable, uint32_t readdrawable, uint32_t
+      context]
+  glXQueryContext: [void]
+  glXQueryContextInfoEXT: [void]
+  glXQueryExtension: [Bool, Display *display, int *errorBase, int *eventBase]
+  glXQueryExtensionsString: [const char *, Display *dpy, int screen]
+  glXQueryHyperpipeAttribSGIX: [int, Display *dpy, int timeSlice, int attrib, int
+      size, const void *returnAttribList]
+  glXQueryHyperpipeBestAttribSGIX: [int, Display *dpy, int timeSlice, int attrib,
+    int size, const void *attribList, void *returnAttribList]
+  glXQueryHyperpipeConfigSGIX: [GLXHyperpipeConfigSGIX *, Display *dpy, int hpId,
+    int *npipes]
+  glXQueryHyperpipeNetworkSGIX: [GLXHyperpipeNetworkSGIX *, Display *dpy, int *npipes]
+  glXQueryMaxSwapBarriersSGIX: [void]
+  glXQueryServerString: [const char *, Display *dpy, int screen, int name]
+  glXQueryVersion: [Bool, Display *dpy, int *maj, int *min]
+  glXReleaseBuffersMESA: [Bool, Display *dpy, GLXDrawable drawable]
+  glXRender: [void]
+  glXRenderLarge: [void]
+  glXSwapBuffers: [void, Display *dpy, GLXDrawable drawable]
+  glXSwapIntervalSGI: [void, unsigned int interval]
+  glXSwapIntervalMESA: [int, unsigned int interval]
+  glXUseXFont: [void, Font font, int first, int count, int list]
+  glXVendorPrivate: [void]
+  glXVendorPrivateWithReply: [void]
+  glXWaitGL: [void]
+  glXWaitX: [void]

project/jni/glshim/spec/yml/oes.yml

@@ -1,4 +0,0 @@
-glBlendColorOES: [void, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha]
-glBlendEquationOES: [void, GLenum mode]
-glBlendEquationSeparateOES: [void, GLenum modeRGB, GLenum modeAlpha]
-glBlendFuncSeparateOES: [void, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha]

project/jni/glshim/spec/yml/wgl.yml

@@ -0,0 +1,177 @@
+3DL_stereo_control:
+  wglSetStereoEmitterState3DL: [BOOL, HDC hDC, UINT uState]
+AMD_gpu_association:
+  wglBlitContextFramebufferAMD: [VOID, HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint
+      srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield
+      mask, GLenum filter]
+  wglCreateAssociatedContextAMD: [HGLRC, UINT id]
+  wglCreateAssociatedContextAttribsAMD: [HGLRC, UINT id, HGLRC hShareContext, const
+      int *attribList]
+  wglDeleteAssociatedContextAMD: [BOOL, HGLRC hglrc]
+  wglGetContextGPUIDAMD: [UINT, HGLRC hglrc]
+  wglGetCurrentAssociatedContextAMD: [HGLRC]
+  wglGetGPUIDsAMD: [UINT, UINT maxCount, UINT *ids]
+  wglGetGPUInfoAMD: [INT, UINT id, int property, GLenum dataType, UINT size, void
+      *data]
+  wglMakeAssociatedContextCurrentAMD: [BOOL, HGLRC hglrc]
+ARB_buffer_region:
+  wglCreateBufferRegionARB: [HANDLE, HDC hDC, int iLayerPlane, UINT uType]
+  wglDeleteBufferRegionARB: [VOID, HANDLE hRegion]
+  wglRestoreBufferRegionARB: [BOOL, HANDLE hRegion, int x, int y, int width, int height,
+    int xSrc, int ySrc]
+  wglSaveBufferRegionARB: [BOOL, HANDLE hRegion, int x, int y, int width, int height]
+ARB_create_context:
+  wglCreateContextAttribsARB: [HGLRC, HDC hDC, HGLRC hShareContext, const int *attribList]
+ARB_extensions_string:
+  wglGetExtensionsStringARB: [const char *, HDC hdc]
+ARB_make_current_read:
+  wglGetCurrentReadDCARB: [HDC]
+  wglMakeContextCurrentARB: [BOOL, HDC hDrawDC, HDC hReadDC, HGLRC hglrc]
+ARB_pbuffer:
+  wglCreatePbufferARB: [HPBUFFERARB, HDC hDC, int iPixelFormat, int iWidth, int iHeight,
+    const int *piAttribList]
+  wglDestroyPbufferARB: [BOOL, HPBUFFERARB hPbuffer]
+  wglGetPbufferDCARB: [HDC, HPBUFFERARB hPbuffer]
+  wglQueryPbufferARB: [BOOL, HPBUFFERARB hPbuffer, int iAttribute, int *piValue]
+  wglReleasePbufferDCARB: [int, HPBUFFERARB hPbuffer, HDC hDC]
+ARB_pixel_format:
+  wglChoosePixelFormatARB: [BOOL, HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList,
+    UINT nMaxFormats, int *piFormats, UINT *nNumFormats]
+  wglGetPixelFormatAttribfvARB: [BOOL, HDC hdc, int iPixelFormat, int iLayerPlane,
+    UINT nAttributes, const int *piAttributes, FLOAT *pfValues]
+  wglGetPixelFormatAttribivARB: [BOOL, HDC hdc, int iPixelFormat, int iLayerPlane,
+    UINT nAttributes, const int *piAttributes, int *piValues]
+ARB_render_texture:
+  wglBindTexImageARB: [BOOL, HPBUFFERARB hPbuffer, int iBuffer]
+  wglReleaseTexImageARB: [BOOL, HPBUFFERARB hPbuffer, int iBuffer]
+  wglSetPbufferAttribARB: [BOOL, HPBUFFERARB hPbuffer, const int *piAttribList]
+EXT_display_color_table:
+  wglBindDisplayColorTableEXT: [GLboolean, GLushort id]
+  wglCreateDisplayColorTableEXT: [GLboolean, GLushort id]
+  wglDestroyDisplayColorTableEXT: [VOID, GLushort id]
+  wglLoadDisplayColorTableEXT: [GLboolean, const GLushort *table, GLuint length]
+EXT_extensions_string:
+  wglGetExtensionsStringEXT: [const char *]
+EXT_make_current_read:
+  wglGetCurrentReadDCEXT: [HDC]
+  wglMakeContextCurrentEXT: [BOOL, HDC hDrawDC, HDC hReadDC, HGLRC hglrc]
+EXT_pbuffer:
+  wglCreatePbufferEXT: [HPBUFFEREXT, HDC hDC, int iPixelFormat, int iWidth, int iHeight,
+    const int *piAttribList]
+  wglDestroyPbufferEXT: [BOOL, HPBUFFEREXT hPbuffer]
+  wglGetPbufferDCEXT: [HDC, HPBUFFEREXT hPbuffer]
+  wglQueryPbufferEXT: [BOOL, HPBUFFEREXT hPbuffer, int iAttribute, int *piValue]
+  wglReleasePbufferDCEXT: [int, HPBUFFEREXT hPbuffer, HDC hDC]
+EXT_pixel_format:
+  wglChoosePixelFormatEXT: [BOOL, HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList,
+    UINT nMaxFormats, int *piFormats, UINT *nNumFormats]
+  wglGetPixelFormatAttribfvEXT: [BOOL, HDC hdc, int iPixelFormat, int iLayerPlane,
+    UINT nAttributes, int *piAttributes, FLOAT *pfValues]
+  wglGetPixelFormatAttribivEXT: [BOOL, HDC hdc, int iPixelFormat, int iLayerPlane,
+    UINT nAttributes, int *piAttributes, int *piValues]
+EXT_swap_control:
+  wglGetSwapIntervalEXT: [int]
+  wglSwapIntervalEXT: [BOOL, int interval]
+I3D_digital_video_control:
+  wglGetDigitalVideoParametersI3D: [BOOL, HDC hDC, int iAttribute, int *piValue]
+  wglSetDigitalVideoParametersI3D: [BOOL, HDC hDC, int iAttribute, const int *piValue]
+I3D_gamma:
+  wglGetGammaTableI3D: [BOOL, HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen,
+    USHORT *puBlue]
+  wglGetGammaTableParametersI3D: [BOOL, HDC hDC, int iAttribute, int *piValue]
+  wglSetGammaTableI3D: [BOOL, HDC hDC, int iEntries, const USHORT *puRed, const USHORT
+      *puGreen, const USHORT *puBlue]
+  wglSetGammaTableParametersI3D: [BOOL, HDC hDC, int iAttribute, const int *piValue]
+I3D_genlock:
+  wglDisableGenlockI3D: [BOOL, HDC hDC]
+  wglEnableGenlockI3D: [BOOL, HDC hDC]
+  wglGenlockSampleRateI3D: [BOOL, HDC hDC, UINT uRate]
+  wglGenlockSourceDelayI3D: [BOOL, HDC hDC, UINT uDelay]
+  wglGenlockSourceEdgeI3D: [BOOL, HDC hDC, UINT uEdge]
+  wglGenlockSourceI3D: [BOOL, HDC hDC, UINT uSource]
+  wglGetGenlockSampleRateI3D: [BOOL, HDC hDC, UINT *uRate]
+  wglGetGenlockSourceDelayI3D: [BOOL, HDC hDC, UINT *uDelay]
+  wglGetGenlockSourceEdgeI3D: [BOOL, HDC hDC, UINT *uEdge]
+  wglGetGenlockSourceI3D: [BOOL, HDC hDC, UINT *uSource]
+  wglIsEnabledGenlockI3D: [BOOL, HDC hDC, BOOL *pFlag]
+  wglQueryGenlockMaxSourceDelayI3D: [BOOL, HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay]
+I3D_image_buffer:
+  wglAssociateImageBufferEventsI3D: [BOOL, HDC hDC, const HANDLE *pEvent, const LPVOID
+      *pAddress, const DWORD *pSize, UINT count]
+  wglCreateImageBufferI3D: [LPVOID, HDC hDC, DWORD dwSize, UINT uFlags]
+  wglDestroyImageBufferI3D: [BOOL, HDC hDC, LPVOID pAddress]
+  wglReleaseImageBufferEventsI3D: [BOOL, HDC hDC, const LPVOID *pAddress, UINT count]
+I3D_swap_frame_lock:
+  wglDisableFrameLockI3D: [BOOL]
+  wglEnableFrameLockI3D: [BOOL]
+  wglIsEnabledFrameLockI3D: [BOOL, BOOL *pFlag]
+  wglQueryFrameLockMasterI3D: [BOOL, BOOL *pFlag]
+I3D_swap_frame_usage:
+  wglBeginFrameTrackingI3D: [BOOL]
+  wglEndFrameTrackingI3D: [BOOL]
+  wglGetFrameUsageI3D: [BOOL, float *pUsage]
+  wglQueryFrameTrackingI3D: [BOOL, DWORD *pFrameCount, DWORD *pMissedFrames, float
+      *pLastMissedUsage]
+NV_DX_interop:
+  wglDXCloseDeviceNV: [BOOL, HANDLE hDevice]
+  wglDXLockObjectsNV: [BOOL, HANDLE hDevice, GLint count, HANDLE *hObjects]
+  wglDXObjectAccessNV: [BOOL, HANDLE hObject, GLenum access]
+  wglDXOpenDeviceNV: [HANDLE, void *dxDevice]
+  wglDXRegisterObjectNV: [HANDLE, HANDLE hDevice, void *dxObject, GLuint name, GLenum
+      type, GLenum access]
+  wglDXSetResourceShareHandleNV: [BOOL, void *dxObject, HANDLE shareHandle]
+  wglDXUnlockObjectsNV: [BOOL, HANDLE hDevice, GLint count, HANDLE *hObjects]
+  wglDXUnregisterObjectNV: [BOOL, HANDLE hDevice, HANDLE hObject]
+NV_copy_image:
+  wglCopyImageSubDataNV: [BOOL, HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint
+      srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName,
+    GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei
+      width, GLsizei height, GLsizei depth]
+NV_gpu_affinity:
+  wglCreateAffinityDCNV: [HDC, const HGPUNV *phGpuList]
+  wglDeleteDCNV: [BOOL, HDC hdc]
+  wglEnumGpuDevicesNV: [BOOL, HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice]
+  wglEnumGpusFromAffinityDCNV: [BOOL, HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu]
+  wglEnumGpusNV: [BOOL, UINT iGpuIndex, HGPUNV *phGpu]
+NV_present_video:
+  wglBindVideoDeviceNV: [BOOL, HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV
+      hVideoDevice, const int *piAttribList]
+  wglEnumerateVideoDevicesNV: [int, HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList]
+  wglQueryCurrentContextNV: [BOOL, int iAttribute, int *piValue]
+NV_swap_group:
+  wglBindSwapBarrierNV: [BOOL, GLuint group, GLuint barrier]
+  wglJoinSwapGroupNV: [BOOL, HDC hDC, GLuint group]
+  wglQueryFrameCountNV: [BOOL, HDC hDC, GLuint *count]
+  wglQueryMaxSwapGroupsNV: [BOOL, HDC hDC, GLuint *maxGroups, GLuint *maxBarriers]
+  wglQuerySwapGroupNV: [BOOL, HDC hDC, GLuint *group, GLuint *barrier]
+  wglResetFrameCountNV: [BOOL, HDC hDC]
+NV_vertex_array_range:
+  wglAllocateMemoryNV: [void *, GLsizei size, GLfloat readfreq, GLfloat writefreq,
+    GLfloat priority]
+  wglFreeMemoryNV: [void *, void *pointer]
+NV_video_capture:
+  wglBindVideoCaptureDeviceNV: [BOOL, UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice]
+  wglEnumerateVideoCaptureDevicesNV: [UINT, HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList]
+  wglLockVideoCaptureDeviceNV: [BOOL, HDC hDc, HVIDEOINPUTDEVICENV hDevice]
+  wglQueryVideoCaptureDeviceNV: [BOOL, HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute,
+    int *piValue]
+  wglReleaseVideoCaptureDeviceNV: [BOOL, HDC hDc, HVIDEOINPUTDEVICENV hDevice]
+NV_video_output:
+  wglBindVideoImageNV: [BOOL, HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer]
+  wglGetVideoDeviceNV: [BOOL, HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice]
+  wglGetVideoInfoNV: [BOOL, HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer,
+    unsigned long *pulCounterOutputVideo]
+  wglReleaseVideoDeviceNV: [BOOL, HPVIDEODEV hVideoDevice]
+  wglReleaseVideoImageNV: [BOOL, HPBUFFERARB hPbuffer, int iVideoBuffer]
+  wglSendPbufferToVideoNV: [BOOL, HPBUFFERARB hPbuffer, int iBufferType, unsigned
+      long *pulCounterPbuffer, BOOL bBlock]
+OML_sync_control:
+  wglGetMscRateOML: [BOOL, HDC hdc, INT32 *numerator, INT32 *denominator]
+  wglGetSyncValuesOML: [BOOL, HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc]
+  wglSwapBuffersMscOML: [INT64, HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder]
+  wglSwapLayerBuffersMscOML: [INT64, HDC hdc, int fuPlanes, INT64 target_msc, INT64
+      divisor, INT64 remainder]
+  wglWaitForMscOML: [BOOL, HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder,
+    INT64 *ust, INT64 *msc, INT64 *sbc]
+  wglWaitForSbcOML: [BOOL, HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64
+      *sbc]

project/jni/glshim/src/CMakeLists.txt

@@ -15,11 +15,10 @@ add_library(GL SHARED ${GL_SOURCES})
 if(BCMHOST)
     set(PI_LIBS bcm_host vcos pthread)
     target_link_libraries(GL ${PI_LIBS} GLESv1_CM)
-    target_link_libraries(GL2 ${PI_LIBS} GLESv2)
 endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-    target_link_libraries(GL X11 dl)
+    target_link_libraries(GL X11 m dl)
 endif()
 
 if(CMAKE_SHARED_LIBRARY_SUFFIX MATCHES ".so")

project/jni/glshim/src/gl/gl.c

@@ -1667,12 +1667,12 @@ void glBlendFunc(GLenum sfactor, GLenum dfactor) {
         default:
             break;
     }
-/*
+/*    
     if ((sfactor==GL_SRC_ALPHA) && (dfactor==GL_ONE)) {
         // special case, as seen in Xash3D, but it breaks torus_trooper, so disabled
         sfactor = GL_ONE;
     }
-*/
+*/    
     gles_glBlendFunc(sfactor, dfactor);
 }
 

project/jni/glshim/src/glx/glx.h

@@ -245,7 +245,6 @@ Display *glXGetCurrentDisplay();
 
 // GLX 1.3
 GLXContext glXGetCurrentContext();
-
 XVisualInfo *glXGetVisualFromFBConfig(Display *display, GLXFBConfig config);
 GLXFBConfig *glXChooseFBConfig(Display *display, int screen, const int *attrib_list, int *count);
 GLXFBConfig *glXGetFBConfigs(Display *display, int screen, int *count);

project/jni/glshim/src/glx/lookup.c

@@ -310,7 +310,7 @@ void *glXGetProcAddressARB(const char *name) {
     EX(glDrawBuffer);
     EX(glDrawPixels);
     EX(glDrawRangeElements);
-    EXT(glDrawRangeElements);
+    EX(glDrawRangeElementsEXT);
     EX(glEdgeFlag);
     EX(glEnd);
     EX(glEndList);
@@ -465,7 +465,6 @@ void *glXGetProcAddressARB(const char *name) {
     STUB(glIndexPointer);
 
     printf("glXGetProcAddress: %s not found.\n", name);
-
     return NULL;
 }
 

project/jni/glshim/test/requirements.txt

@@ -1,2 +0,0 @@
-Jinja2
-blessings

project/jni/glshim/test/run

@@ -1,4 +0,0 @@
-#!/bin/bash -u
-
-cd $(dirname "$0")
-python util/run.py --project="$(pwd)/.." --base "$(pwd)/tests" "$@"

project/jni/glshim/test/tests/array/skip.c

@@ -1,27 +0,0 @@
-int main() {
-#define STRIDE 0, 0, 0, 0, 0, 0, 0, 0, 0
-    GLfloat vert[] = {
-        0, 0, 0, STRIDE,
-        1, 1, 1, STRIDE,
-        2, 2, 2, STRIDE,
-        3, 3, 3, STRIDE,
-        4, 4, 4, STRIDE,
-        5, 5, 5, STRIDE,
-    };
-    glEnableClientState(GL_VERTEX_ARRAY);
-    glVertexPointer(3, GL_FLOAT, 12 * sizeof(GLfloat), vert);
-    glDrawArrays(GL_QUADS, 2, 4);
-
-    GLfloat vert_out[] = {
-        2, 2, 2,
-        3, 3, 3,
-        4, 4, 4,
-        5, 5, 5,
-    };
-    GLushort indices[] = {0, 1, 3, 1, 2, 3};
-    test_glEnableClientState(GL_VERTEX_ARRAY);
-    test_glVertexPointer(3, GL_FLOAT, 12 * 4, vert);
-    test_glVertexPointer(3, GL_FLOAT, 0, vert_out);
-    test_glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
-    mock_return;
-}

project/jni/glshim/test/tests/block/quads.c

@@ -1,52 +0,0 @@
-int main() {
-    glBegin(GL_QUADS);
-    glColor4f(0, 0.1, 0.2, 0.3);
-    glTexCoord2f(0.4, 0.5);
-    glVertex3f(0, 1, 2);
-    glVertex3f(3, 4, 5);
-    glVertex3f(6, 7, 8);
-    glVertex3f(9, 10, 11);
-    glEnd();
-
-    GLfloat verts[] = {
-        0, 1, 2,
-        3, 4, 5,
-        6, 7, 8,
-        9, 10, 11,
-    };
-
-    GLfloat color[] = {
-        0, 0.1, 0.2, 0.3,
-        0, 0.1, 0.2, 0.3,
-        0, 0.1, 0.2, 0.3,
-        0, 0.1, 0.2, 0.3,
-    };
-
-    GLfloat tex[] = {
-        0.4, 0.5,
-        0.4, 0.5,
-        0.4, 0.5,
-        0.4, 0.5,
-    };
-
-    GLushort indices[] = {
-        0, 1, 3,
-        1, 2, 3,
-    };
-
-    // TODO: out of order glEnableClientState?
-    test_glColor4f(0.0, 0.1, 0.2, 0.3);
-
-    test_glEnableClientState(GL_VERTEX_ARRAY);
-    test_glVertexPointer(3, GL_FLOAT, 0, verts);
-    test_glEnableClientState(GL_COLOR_ARRAY);
-    test_glColorPointer(4, GL_FLOAT, 0, color);
-    test_glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-    test_glTexCoordPointer(2, GL_FLOAT, 0, tex);
-    test_glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
-
-    test_glDisableClientState(GL_VERTEX_ARRAY);
-    test_glDisableClientState(GL_COLOR_ARRAY);
-    test_glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-    mock_return;
-}

project/jni/glshim/test/tests/block/rect.c

@@ -1,18 +0,0 @@
-int main() {
-    for (int i = 0; i < 3; i++) {
-        glRectf(0, 0, 1, 1);
-
-        test_glEnableClientState(GL_VERTEX_ARRAY);
-        // TODO: pointers are skipped in verification
-        GLfloat verts[] = {
-            0, 0, 0,
-            1, 0, 0,
-            1, 1, 0,
-            0, 1, 0,
-        };
-        test_glVertexPointer(3, GL_FLOAT, 0, verts);
-        test_glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-        test_glDisableClientState(GL_VERTEX_ARRAY);
-    }
-    mock_return;
-}

project/jni/glshim/test/tests/block/tri.c

@@ -1,18 +0,0 @@
-int main() {
-    glBegin(GL_TRIANGLES);
-    glVertex3f(0, 1, 2);
-    glVertex3f(3, 4, 5);
-    glVertex3f(6, 7, 8);
-    glEnd();
-
-    test_glEnableClientState(GL_VERTEX_ARRAY);
-    GLfloat verts[] = {
-        0, 1, 2,
-        3, 4, 5,
-        6, 7, 8,
-    };
-    test_glVertexPointer(3, GL_FLOAT, 0, verts);
-    test_glDrawArrays(GL_TRIANGLES, 0, 3);
-    test_glDisableClientState(GL_VERTEX_ARRAY);
-    mock_return;
-}

project/jni/glshim/test/tests/list/nested.c

@@ -1,30 +0,0 @@
-int main() {
-    GLuint list = glGenLists(3);
-    glNewList(list, GL_COMPILE);
-    glRectf(0, 0, 1, 1);
-    glEndList();
-
-    glNewList(list + 1, GL_COMPILE);
-    glCallList(list);
-    glEndList();
-
-    glNewList(list + 2, GL_COMPILE);
-    glCallList(list + 1);
-    glEndList();
-
-    glCallList(list + 2);
-
-    GLfloat verts[] = {
-        0, 0, 0,
-        1, 0, 0,
-        1, 1, 0,
-        0, 1, 0,
-    };
-
-    test_glEnableClientState(GL_VERTEX_ARRAY);
-    test_glVertexPointer(3, GL_FLOAT, 0, verts);
-    test_glDrawArrays(6, 0, 4);
-    test_glDisableClientState(GL_VERTEX_ARRAY);
-
-    mock_return;
-}

project/jni/glshim/test/tests/list/new.c

@@ -1,6 +0,0 @@
-int main() {
-    int list = glGenLists(1);
-    glNewList(list, GL_COMPILE);
-    mock_assert(state.list.active, "glNewList failed\n");
-    mock_return;
-}

project/jni/glshim/test/tests/meta/test.py

@@ -1,20 +0,0 @@
-import os
-import sys
-
-def walk(base):
-    for root, _, files in os.walk(base):
-        for name in files:
-            yield os.path.join(root, name)
-
-if __name__ == '__main__':
-    failed = False
-    for name in walk('tests'):
-        if name.endswith('.c'):
-            with open(name, 'r') as f:
-                data = f.read()
-            if not 'mock_return;' in data:
-                print 'ERROR: "{}" has no mock_return;'.format(name)
-                failed = True
-
-    if failed:
-        sys.exit(1)

project/jni/glshim/test/tests/render/feedback.c

@@ -1,35 +0,0 @@
-#include "tack.h"
-
-int main() {
-    GLfloat buffer[4096];
-    glFeedbackBuffer(4096, GL_2D, buffer);
-    glRenderMode(GL_FEEDBACK);
-
-    glPassThrough(7);
-    glRectf(0, 0, 1, 1);
-
-    int size = glRenderMode(GL_RENDER);
-    assert(size == 15);
-
-    GLfloat *pos = buffer;
-#define _(val) assert(*pos++ == val)
-    _(GL_PASS_THROUGH_TOKEN);
-    _(7.0f);
-    _(GL_POLYGON_TOKEN);
-    _(3.0f);
-    _(1.0f);
-    _(0.0f);
-    _(1.0f);
-    _(1.0f);
-    _(0.0f);
-    _(0.0f);
-    _(GL_POLYGON_TOKEN);
-    _(3.0f);
-    _(1.0f);
-    _(1.0f);
-    _(0.0f);
-    _(1.0f);
-    _(0.0f);
-    _(0.0f);
-    mock_return;
-}

project/jni/glshim/test/tests/state/default.c

@@ -1,17 +0,0 @@
-#define check(name, ...) { \
-    GLfloat tmp[] = __VA_ARGS__; \
-    assert(memcmp(state.name, tmp, sizeof(tmp)) == 0);}
-
-int main() {
-    check(current.color, {1.0f, 1.0f, 1.0f, 1.0f});
-    check(current.normal, {0.0f, 0.0f, 1.0f});
-    for (int i = 0; i < MAX_TEX; i++) {
-        check(current.tex[i], {0, 0});
-        texgen_state_t *t = &state.texgen[i];
-        assert(t->R == GL_EYE_LINEAR);
-        assert(t->Q == GL_EYE_LINEAR);
-        assert(t->S == GL_EYE_LINEAR);
-        assert(t->T == GL_EYE_LINEAR);
-    }
-    mock_return;
-}

project/jni/glshim/test/tests/util/gl_str.c

@@ -1,10 +0,0 @@
-#include "gl_str.h"
-
-int main() {
-#define check(func, name) assert(strcmp(func(name), #name) == 0);
-    check(gl_str_primitive, GL_QUADS);
-    check(gl_str, GL_FLOAT);
-    check(gl_bits_glPushClientAttrib, GL_CLIENT_ALL_ATTRIB_BITS);
-    check(gl_bits_glPushAttrib, GL_CURRENT_BIT | GL_POINT_BIT);
-    mock_return;
-}

project/jni/glshim/test/tests/util/tack.c

@@ -1,30 +0,0 @@
-int main() {
-    tack_t stack = {0};
-    tack_push(&stack, 1);
-    assert(tack_peek(&stack) == 1);
-    assert(tack_len(&stack) == 1);
-
-    tack_push(&stack, 2);
-    tack_push(&stack, 3);
-    assert(tack_get(&stack, 0) == 1);
-    assert(tack_peek(&stack) == 3);
-    assert(tack_pop(&stack) == 3);
-    assert(tack_peek(&stack) == 2);
-
-    tack_clear(&stack);
-    assert(tack_len(&stack) == 0);
-
-    for (int i = 0; i < 10000; i++) {
-        tack_push(&stack, i);
-        assert(tack_peek(&stack) == i);
-    }
-    for (int i = 0; i < 10000; i++) {
-        assert(tack_shift(&stack) == i);
-    }
-
-    tack_clear(&stack);
-    tack_set(&stack, 1, "test");
-    assert(tack_get(&stack, 0) == NULL);
-    assert(strcmp(tack_get(&stack, 1), "test") == 0);
-    mock_return;
-}