miguel.horta/commandergenius
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

glshim updated, added latest changes by ptitSeb

Browse Source
This commit is contained in:
lubomyr
2016-09-07 23:14:58 +03:00
parent 7dd8376526
commit a3bdacdf62
28 changed files with 2670 additions and 2469 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
project/jni/glshim/CMakeLists.txt
View File

@@ -12,6 +12,8 @@ option(PANDORA "Set to ON if targeting an OpenPandora device" ${PANDORA})
option(BCMHOST "Set to ON if targeting an RPi(2) device" ${BCMHOST})
option(ODROID "Set to ON if targeting an ODroid device" ${ODROID})
option(USE_DRAWTEX "Set to ON to use the glDrawTexiOES extension" ${USE_DRAWTEX})
# Raspberry PI
if(BCMHOST)
include_directories(/opt/vc/include /opt/vc/include/interface/vcos/pthreads /opt/vc/include/interface/vmcs_host/linux)
@@ -22,14 +24,19 @@ endif()
if(PANDORA)
add_definitions(-DPANDORA)
add_definitions(-DTEXSTREAM)
add_definitions(-mcpu=cortex-a8 -mfpu=neon -mfloat-abi=softfp -ftree-vectorize -fsingle-precision-constant -ffast-math)
endif()
if(ODROID)
add_definitions(-DODROID)
endif()
if(USE_DRAWTEX)
add_definitions(-DUSE_DRAWTEX)
endif()
link_directories(${CMAKE_BINARY_DIR}/lib)
add_definitions(-g -std=gnu99 -funwind-tables -O3)
add_definitions(-g -std=gnu99 -funwind-tables -O3 -fvisibility=hidden)
include_directories(include)
add_subdirectory(src)

8
project/jni/glshim/spec/build
View File

@@ -5,16 +5,16 @@ base=../src/
gles1=$(ls -1 yml/*-1.1.yml | tr '\n' ',' | sed -e 's/,$//')
gles=$(ls -1 yml/*es-1.1.yml | tr '\n' ',' | sed -e 's/,$//')
glext=$(ls -1 yml/*ext-1.1.yml | tr '\n' ',' | sed -e 's/,$//')
gles2=$(ls -1 yml/*-2.0.yml | tr '\n' ',' | sed -e 's/,$//')
#gles2=$(ls -1 yml/*-2.0.yml | tr '\n' ',' | sed -e 's/,$//')
./gen.py "$gles" --ifndef USE_ES2 gleswrap.c.j2 gleswrap.c gles.h > "$base/gl/wrap/gles.c"
./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 "$gles2" --ifdef USE_ES2 gleswrap.c.j2 gles2wrap.c gles2.h > "$base/gl/wrap/gles2.c"
./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 > "$base/gl/wrap/gles2.c"
#./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 "yml/egl.yml" eglwrap.c.j2 eglwrap.c "<GLES/egl.h>" > "$base/gl/wrap/egl.c" &

2
project/jni/glshim/spec/template/base/wrap.c.j2
View File

@@ -9,7 +9,7 @@
{% if not func.void %}return {% endif %}{% block prefix %}wrap{% endblock %}_{{ func.name }}({{ func.args|args(0) }});
{%- endblock %}
}
{{ func.return }} {{ func.name }}({{ func.args|args }}) __attribute__((alias("glshim_{{ func.name }}")));
{{ func.return }} {{ func.name }}({{ func.args|args }}) __attribute__((alias("glshim_{{ func.name }}"))) __attribute__((visibility("default")));
{% endblock %}
{% endfor %}
{% endblock %}

2
project/jni/glshim/spec/template/glxfuncs.j2 Normal file → Executable file
View File

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

3
project/jni/glshim/spec/yml/glext-1.1.yml
View File

@@ -25,3 +25,6 @@ glGetRenderbufferParameteriv: [void, GLenum target, GLenum pname, "GLint * param
glDrawTexi: [void, GLint x, GLint y, GLint z, GLint width, GLint height]
glDrawTexf: [void, GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height]
glMultiDrawArrays: [void, GLenum mode, "const GLint *first", "const GLsizei *count", GLsizei primcount]
glMultiDrawElements: [void, GLenum mode, "GLsizei *count", GLenum type, "const void * const *indices", GLsizei primcount]

4
project/jni/glshim/src/config.h
View File

@@ -117,6 +117,10 @@
#define skip_glLoadMatrixf
#define skip_glMultMatrixf
// MultiDrawArrays
#define skip_glMultiDrawArrays
#define skip_glMultiDrawElements
// don't compile these into display lists
#define direct_glColorPointer
#define direct_glDeleteLists

52
project/jni/glshim/src/gl/buffers.c
View File

@@ -308,30 +308,30 @@ void glshim_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid ** params) {
}
//Direct wrapper
void glGenBuffers(GLsizei n, GLuint * buffers) __attribute__((alias("glshim_glGenBuffers")));
void glBindBuffer(GLenum target, GLuint buffer) __attribute__((alias("glshim_glBindBuffer")));
void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) __attribute__((alias("glshim_glBufferData")));
void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) __attribute__((alias("glshim_glBufferSubData")));
void glDeleteBuffers(GLsizei n, const GLuint * buffers) __attribute__((alias("glshim_glDeleteBuffers")));
GLboolean glIsBuffer(GLuint buffer) __attribute__((alias("glshim_glIsBuffer")));
void glGetBufferParameteriv(GLenum target, GLenum value, GLint * data) __attribute__((alias("glshim_glGetBufferParameteriv")));
void *glMapBuffer(GLenum target, GLenum access) __attribute__((alias("glshim_glMapBuffer")));
GLboolean glUnmapBuffer(GLenum target) __attribute__((alias("glshim_glUnmapBuffer")));
void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data) __attribute__((alias("glshim_glGetBufferSubData")));
void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid ** params) __attribute__((alias("glshim_glGetBufferPointerv")));
void glGenBuffers(GLsizei n, GLuint * buffers) AliasExport("glshim_glGenBuffers");
void glBindBuffer(GLenum target, GLuint buffer) AliasExport("glshim_glBindBuffer");
void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) AliasExport("glshim_glBufferData");
void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) AliasExport("glshim_glBufferSubData");
void glDeleteBuffers(GLsizei n, const GLuint * buffers) AliasExport("glshim_glDeleteBuffers");
GLboolean glIsBuffer(GLuint buffer) AliasExport("glshim_glIsBuffer");
void glGetBufferParameteriv(GLenum target, GLenum value, GLint * data) AliasExport("glshim_glGetBufferParameteriv");
void *glMapBuffer(GLenum target, GLenum access) AliasExport("glshim_glMapBuffer");
GLboolean glUnmapBuffer(GLenum target) AliasExport("glshim_glUnmapBuffer");
void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data) AliasExport("glshim_glGetBufferSubData");
void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid ** params) AliasExport("glshim_glGetBufferPointerv");
//ARB wrapper
void glGenBuffersARB(GLsizei n, GLuint * buffers) __attribute__((alias("glshim_glGenBuffers")));
void glBindBufferARB(GLenum target, GLuint buffer) __attribute__((alias("glshim_glBindBuffer")));
void glBufferDataARB(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) __attribute__((alias("glshim_glBufferData")));
void glBufferSubDataARB(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) __attribute__((alias("glshim_glBufferSubData")));
void glDeleteBuffersARB(GLsizei n, const GLuint * buffers) __attribute__((alias("glshim_glDeleteBuffers")));
GLboolean glIsBufferARB(GLuint buffer) __attribute__((alias("glshim_glIsBuffer")));
void glGetBufferParameterivARB(GLenum target, GLenum value, GLint * data) __attribute__((alias("glshim_glGetBufferParameteriv")));
void *glMapBufferARB(GLenum target, GLenum access) __attribute__((alias("glshim_glMapBuffer")));
GLboolean glUnmapBufferARB(GLenum target) __attribute__((alias("glshim_glUnmapBuffer")));
void glGetBufferSubDataARB(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data) __attribute__((alias("glshim_glGetBufferSubData")));
void glGetBufferPointervARB(GLenum target, GLenum pname, GLvoid ** params) __attribute__((alias("glshim_glGetBufferPointerv")));
void glGenBuffersARB(GLsizei n, GLuint * buffers) AliasExport("glshim_glGenBuffers");
void glBindBufferARB(GLenum target, GLuint buffer) AliasExport("glshim_glBindBuffer");
void glBufferDataARB(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) AliasExport("glshim_glBufferData");
void glBufferSubDataARB(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) AliasExport("glshim_glBufferSubData");
void glDeleteBuffersARB(GLsizei n, const GLuint * buffers) AliasExport("glshim_glDeleteBuffers");
GLboolean glIsBufferARB(GLuint buffer) AliasExport("glshim_glIsBuffer");
void glGetBufferParameterivARB(GLenum target, GLenum value, GLint * data) AliasExport("glshim_glGetBufferParameteriv");
void *glMapBufferARB(GLenum target, GLenum access) AliasExport("glshim_glMapBuffer");
GLboolean glUnmapBufferARB(GLenum target) AliasExport("glshim_glUnmapBuffer");
void glGetBufferSubDataARB(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data) AliasExport("glshim_glGetBufferSubData");
void glGetBufferPointervARB(GLenum target, GLenum pname, GLvoid ** params) AliasExport("glshim_glGetBufferPointerv");
// VAO ****************
static GLuint lastvao = 1;
@@ -429,8 +429,8 @@ GLboolean glshim_glIsVertexArray(GLuint array) {
}
//Dirzct wrapper
void glGenVertexArrays(GLsizei n, GLuint *arrays) __attribute__((alias("glshim_glGenVertexArrays")));
void glBindVertexArray(GLuint array) __attribute__((alias("glshim_glBindVertexArray")));
void glDeleteVertexArrays(GLsizei n, const GLuint *arrays) __attribute__((alias("glshim_glDeleteVertexArrays")));
GLboolean glIsVertexArray(GLuint array) __attribute__((alias("glshim_glIsVertexArray")));
void glGenVertexArrays(GLsizei n, GLuint *arrays) AliasExport("glshim_glGenVertexArrays");
void glBindVertexArray(GLuint array) AliasExport("glshim_glBindVertexArray");
void glDeleteVertexArrays(GLsizei n, const GLuint *arrays) AliasExport("glshim_glDeleteVertexArrays");
GLboolean glIsVertexArray(GLuint array) AliasExport("glshim_glIsVertexArray");

184
project/jni/glshim/src/gl/directstate.c
View File

@@ -342,98 +342,98 @@ void glshim_glGetCompressedMultiTexImage(GLenum texunit, GLenum target, GLint le
}
//EXT wrapper
void glClientAttribDefaultEXT(GLbitfield mask) __attribute__((alias("glshim_glClientAttribDefault")));
void glPushClientAttribDefaultEXT(GLbitfield mask) __attribute__((alias("glshim_glPushClientAttribDefault")));
void glMatrixLoadfEXT(GLenum matrixMode, const GLfloat *m) __attribute__((alias("glshim_glMatrixLoadf")));
void glMatrixLoaddEXT(GLenum matrixMode, const GLdouble *m) __attribute__((alias("glshim_glMatrixLoadd")));
void glMatrixMultfEXT(GLenum matrixMode, const GLfloat *m) __attribute__((alias("glshim_glMatrixMultf")));
void glMatrixMultdEXT(GLenum matrixMode, const GLdouble *m) __attribute__((alias("glshim_glMatrixMultd")));
void glMatrixLoadIdentityEXT(GLenum matrixMode) __attribute__((alias("glshim_glMatrixLoadIdentity")));
void glMatrixRotatefEXT(GLenum matrixMode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) __attribute__((alias("glshim_glMatrixRotatef")));
void glMatrixRotatedEXT(GLenum matrixMode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) __attribute__((alias("glshim_glMatrixRotated")));
void glMatrixScalefEXT(GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z) __attribute__((alias("glshim_glMatrixScalef")));
void glMatrixScaledEXT(GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z) __attribute__((alias("glshim_glMatrixScaled")));
void glMatrixTranslatefEXT(GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z) __attribute__((alias("glshim_glMatrixTranslatef")));
void glMatrixTranslatedEXT(GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z) __attribute__((alias("glshim_glMatrixTranslated")));
void glMatrixOrthoEXT(GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f) __attribute__((alias("glshim_glMatrixOrtho")));
void glMatrixFrustumEXT(GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f) __attribute__((alias("glshim_glMatrixFrustum")));
void glMatrixPushEXT(GLenum matrixMode) __attribute__((alias("glshim_glMatrixPush")));
void glMatrixPopEXT(GLenum matrixMode) __attribute__((alias("glshim_glMatrixPop")));
void glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) __attribute__((alias("glshim_glTextureParameteri")));
void glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *param) __attribute__((alias("glshim_glTextureParameteriv")));
void glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param) __attribute__((alias("glshim_glTextureParameterf")));
void glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *param) __attribute__((alias("glshim_glTextureParameterfv")));
void glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glTextureImage1D")));
void glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glTextureImage2D")));
void glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glTextureSubImage1D")));
void glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glTextureSubImage2D")));
void glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) __attribute__((alias("glshim_glCopyTextureImage1D")));
void glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) __attribute__((alias("glshim_glCopyTextureImage2D")));
void glCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) __attribute__((alias("glshim_glCopyTextureSubImage1D")));
void glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glCopyTextureSubImage2D")));
void glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) __attribute__((alias("glshim_glGetTextureImage")));
void glGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat *params) __attribute__((alias("glshim_glGetTextureParameterfv")));
void glGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetTextureParameteriv")));
void glGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params) __attribute__((alias("glshim_glGetTextureLevelParameterfv")));
void glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetTextureLevelParameteriv")));
void glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glTextureImage3D")));
void glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glTextureSubImage3D")));
void glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glCopyTextureSubImage3D")));
void glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture) __attribute__((alias("glshim_glBindMultiTexture")));
void glMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) __attribute__((alias("glshim_glMultiTexCoordPointer")));
void glMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) __attribute__((alias("glshim_glMultiTexEnvf")));
void glMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params) __attribute__((alias("glshim_glMultiTexEnvfv")));
void glMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) __attribute__((alias("glshim_glMultiTexEnvi")));
void glMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params) __attribute__((alias("glshim_glMultiTexEnviv")));
void glMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param) __attribute__((alias("glshim_glMultiTexGend")));
void glMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params) __attribute__((alias("glshim_glMultiTexGendv")));
void glMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param) __attribute__((alias("glshim_glMultiTexGenf")));
void glMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params) __attribute__((alias("glshim_glMultiTexGenfv")));
void glMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param) __attribute__((alias("glshim_glMultiTexGeni")));
void glMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint *params) __attribute__((alias("glshim_glMultiTexGeniv")));
void glGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params) __attribute__((alias("glshim_glGetMultiTexEnvfv")));
void glGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetMultiTexEnviv")));
void glGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble *params) __attribute__((alias("glshim_glGetMultiTexGendv")));
void glGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat *params) __attribute__((alias("glshim_glGetMultiTexGenfv")));
void glGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetMultiTexGeniv")));
void glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) __attribute__((alias("glshim_glMultiTexParameteri")));
void glMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *param) __attribute__((alias("glshim_glMultiTexParameteriv")));
void glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) __attribute__((alias("glshim_glMultiTexParameterf")));
void glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *param) __attribute__((alias("glshim_glMultiTexParameterfv")));
void glMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glMultiTexImage1D")));
void glMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glMultiTexImage2D")));
void glMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glMultiTexSubImage1D")));
void glMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glMultiTexSubImage2D")));
void glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) __attribute__((alias("glshim_glCopyMultiTexImage1D")));
void glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) __attribute__((alias("glshim_glCopyMultiTexImage2D")));
void glCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) __attribute__((alias("glshim_glCopyMultiTexSubImage1D")));
void glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glCopyMultiTexSubImage2D")));
void glGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) __attribute__((alias("glshim_glGetMultiTexImage")));
void glGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params) __attribute__((alias("glshim_glGetMultiTexParameterfv")));
void glGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetMultiTexParameteriv")));
void glGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params) __attribute__((alias("glshim_glGetMultiTexLevelParameterfv")));
void glGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetMultiTexLevelParameteriv")));
void glMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glMultiTexImage3D")));
void glMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) __attribute__((alias("glshim_glMultiTexSubImage3D")));
void glCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glCopyMultiTexSubImage3D")));
void glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTextureImage3D")));
void glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTextureImage2D")));
void glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTextureImage1D")));
void glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTextureSubImage3D")));
void glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTextureSubImage2D")));
void glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTextureSubImage1D")));
void glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint level, GLvoid *img) __attribute__((alias("glshim_glGetCompressedTextureImage")));
void glCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedMultiTexImage3D")));
void glCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedMultiTexImage2D")));
void glCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedMultiTexImage1D")));
void glCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedMultiTexSubImage3D")));
void glCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedMultiTexSubImage2D")));
void glCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedMultiTexSubImage1D")));
void glGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLvoid *img) __attribute__((alias("glshim_glGetCompressedMultiTexImage")));
void glMatrixLoadTransposefEXT(GLenum matrixMode, const GLfloat *m) __attribute__((alias("glshim_glMatrixLoadTransposef")));
void glMatrixLoadTransposedEXT(GLenum matrixMode, const GLdouble *m) __attribute__((alias("glshim_glMatrixLoadTransposed")));
void glMatrixMultTransposefEXT(GLenum matrixMode, const GLfloat *m) __attribute__((alias("glshim_glMatrixMultTransposef")));
void glMatrixMultTransposedEXT(GLenum matrixMode, const GLdouble *m) __attribute__((alias("glshim_glMatrixMultTransposed")));
void glClientAttribDefaultEXT(GLbitfield mask) AliasExport("glshim_glClientAttribDefault");
void glPushClientAttribDefaultEXT(GLbitfield mask) AliasExport("glshim_glPushClientAttribDefault");
void glMatrixLoadfEXT(GLenum matrixMode, const GLfloat *m) AliasExport("glshim_glMatrixLoadf");
void glMatrixLoaddEXT(GLenum matrixMode, const GLdouble *m) AliasExport("glshim_glMatrixLoadd");
void glMatrixMultfEXT(GLenum matrixMode, const GLfloat *m) AliasExport("glshim_glMatrixMultf");
void glMatrixMultdEXT(GLenum matrixMode, const GLdouble *m) AliasExport("glshim_glMatrixMultd");
void glMatrixLoadIdentityEXT(GLenum matrixMode) AliasExport("glshim_glMatrixLoadIdentity");
void glMatrixRotatefEXT(GLenum matrixMode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) AliasExport("glshim_glMatrixRotatef");
void glMatrixRotatedEXT(GLenum matrixMode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) AliasExport("glshim_glMatrixRotated");
void glMatrixScalefEXT(GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z) AliasExport("glshim_glMatrixScalef");
void glMatrixScaledEXT(GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z) AliasExport("glshim_glMatrixScaled");
void glMatrixTranslatefEXT(GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z) AliasExport("glshim_glMatrixTranslatef");
void glMatrixTranslatedEXT(GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z) AliasExport("glshim_glMatrixTranslated");
void glMatrixOrthoEXT(GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f) AliasExport("glshim_glMatrixOrtho");
void glMatrixFrustumEXT(GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f) AliasExport("glshim_glMatrixFrustum");
void glMatrixPushEXT(GLenum matrixMode) AliasExport("glshim_glMatrixPush");
void glMatrixPopEXT(GLenum matrixMode) AliasExport("glshim_glMatrixPop");
void glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) AliasExport("glshim_glTextureParameteri");
void glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *param) AliasExport("glshim_glTextureParameteriv");
void glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param) AliasExport("glshim_glTextureParameterf");
void glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *param) AliasExport("glshim_glTextureParameterfv");
void glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glTextureImage1D");
void glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glTextureImage2D");
void glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glTextureSubImage1D");
void glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glTextureSubImage2D");
void glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) AliasExport("glshim_glCopyTextureImage1D");
void glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) AliasExport("glshim_glCopyTextureImage2D");
void glCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) AliasExport("glshim_glCopyTextureSubImage1D");
void glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glCopyTextureSubImage2D");
void glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) AliasExport("glshim_glGetTextureImage");
void glGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat *params) AliasExport("glshim_glGetTextureParameterfv");
void glGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint *params) AliasExport("glshim_glGetTextureParameteriv");
void glGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params) AliasExport("glshim_glGetTextureLevelParameterfv");
void glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params) AliasExport("glshim_glGetTextureLevelParameteriv");
void glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glTextureImage3D");
void glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glTextureSubImage3D");
void glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glCopyTextureSubImage3D");
void glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture) AliasExport("glshim_glBindMultiTexture");
void glMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) AliasExport("glshim_glMultiTexCoordPointer");
void glMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) AliasExport("glshim_glMultiTexEnvf");
void glMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params) AliasExport("glshim_glMultiTexEnvfv");
void glMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) AliasExport("glshim_glMultiTexEnvi");
void glMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params) AliasExport("glshim_glMultiTexEnviv");
void glMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param) AliasExport("glshim_glMultiTexGend");
void glMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params) AliasExport("glshim_glMultiTexGendv");
void glMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param) AliasExport("glshim_glMultiTexGenf");
void glMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params) AliasExport("glshim_glMultiTexGenfv");
void glMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param) AliasExport("glshim_glMultiTexGeni");
void glMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint *params) AliasExport("glshim_glMultiTexGeniv");
void glGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params) AliasExport("glshim_glGetMultiTexEnvfv");
void glGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params) AliasExport("glshim_glGetMultiTexEnviv");
void glGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble *params) AliasExport("glshim_glGetMultiTexGendv");
void glGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat *params) AliasExport("glshim_glGetMultiTexGenfv");
void glGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint *params) AliasExport("glshim_glGetMultiTexGeniv");
void glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) AliasExport("glshim_glMultiTexParameteri");
void glMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *param) AliasExport("glshim_glMultiTexParameteriv");
void glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) AliasExport("glshim_glMultiTexParameterf");
void glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *param) AliasExport("glshim_glMultiTexParameterfv");
void glMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glMultiTexImage1D");
void glMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glMultiTexImage2D");
void glMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glMultiTexSubImage1D");
void glMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glMultiTexSubImage2D");
void glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) AliasExport("glshim_glCopyMultiTexImage1D");
void glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) AliasExport("glshim_glCopyMultiTexImage2D");
void glCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) AliasExport("glshim_glCopyMultiTexSubImage1D");
void glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glCopyMultiTexSubImage2D");
void glGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) AliasExport("glshim_glGetMultiTexImage");
void glGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params) AliasExport("glshim_glGetMultiTexParameterfv");
void glGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params) AliasExport("glshim_glGetMultiTexParameteriv");
void glGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params) AliasExport("glshim_glGetMultiTexLevelParameterfv");
void glGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params) AliasExport("glshim_glGetMultiTexLevelParameteriv");
void glMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glMultiTexImage3D");
void glMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) AliasExport("glshim_glMultiTexSubImage3D");
void glCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glCopyMultiTexSubImage3D");
void glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTextureImage3D");
void glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTextureImage2D");
void glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTextureImage1D");
void glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTextureSubImage3D");
void glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTextureSubImage2D");
void glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTextureSubImage1D");
void glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint level, GLvoid *img) AliasExport("glshim_glGetCompressedTextureImage");
void glCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedMultiTexImage3D");
void glCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedMultiTexImage2D");
void glCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedMultiTexImage1D");
void glCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedMultiTexSubImage3D");
void glCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedMultiTexSubImage2D");
void glCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedMultiTexSubImage1D");
void glGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLvoid *img) AliasExport("glshim_glGetCompressedMultiTexImage");
void glMatrixLoadTransposefEXT(GLenum matrixMode, const GLfloat *m) AliasExport("glshim_glMatrixLoadTransposef");
void glMatrixLoadTransposedEXT(GLenum matrixMode, const GLdouble *m) AliasExport("glshim_glMatrixLoadTransposed");
void glMatrixMultTransposefEXT(GLenum matrixMode, const GLfloat *m) AliasExport("glshim_glMatrixMultTransposef");
void glMatrixMultTransposedEXT(GLenum matrixMode, const GLdouble *m) AliasExport("glshim_glMatrixMultTransposed");
#undef text
#undef texc

30
project/jni/glshim/src/gl/eval.c
View File

@@ -317,18 +317,18 @@ GL_GET_MAP(d, GLdouble)
#undef GL_GET_MAP
//Direct wrapper
void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) __attribute__((alias("glshim_glMap1d")));
void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) __attribute__((alias("glshim_glMap1f")));
void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) __attribute__((alias("glshim_glMap2d")));
void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) __attribute__((alias("glshim_glMap2f")));
void glEvalCoord1f(GLfloat u) __attribute__((alias("glshim_glEvalCoord1f")));
void glEvalCoord2f(GLfloat u, GLfloat v) __attribute__((alias("glshim_glEvalCoord2f")));
void glEvalMesh1(GLenum mode, GLint i1, GLint i2) __attribute__((alias("glshim_glEvalMesh1")));
void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) __attribute__((alias("glshim_glEvalMesh2")));
void glEvalPoint1(GLint i) __attribute__((alias("glshim_glEvalPoint1")));
void glEvalPoint2(GLint i, GLint j) __attribute__((alias("glshim_glEvalPoint2")));
void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) __attribute__((alias("glshim_glMapGrid1f")));
void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) __attribute__((alias("glshim_glMapGrid2f")));
void glGetMapdv(GLenum target, GLenum query, GLdouble *v) __attribute__((alias("glshim_glGetMapdv")));
void glGetMapfv(GLenum target, GLenum query, GLfloat *v) __attribute__((alias("glshim_glGetMapfv")));
void glGetMapiv(GLenum target, GLenum query, GLint *v) __attribute__((alias("glshim_glGetMapiv")));
void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) AliasExport("glshim_glMap1d");
void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) AliasExport("glshim_glMap1f");
void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) AliasExport("glshim_glMap2d");
void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) AliasExport("glshim_glMap2f");
void glEvalCoord1f(GLfloat u) AliasExport("glshim_glEvalCoord1f");
void glEvalCoord2f(GLfloat u, GLfloat v) AliasExport("glshim_glEvalCoord2f");
void glEvalMesh1(GLenum mode, GLint i1, GLint i2) AliasExport("glshim_glEvalMesh1");
void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) AliasExport("glshim_glEvalMesh2");
void glEvalPoint1(GLint i) AliasExport("glshim_glEvalPoint1");
void glEvalPoint2(GLint i, GLint j) AliasExport("glshim_glEvalPoint2");
void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) AliasExport("glshim_glMapGrid1f");
void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) AliasExport("glshim_glMapGrid2f");
void glGetMapdv(GLenum target, GLenum query, GLdouble *v) AliasExport("glshim_glGetMapdv");
void glGetMapfv(GLenum target, GLenum query, GLfloat *v) AliasExport("glshim_glGetMapfv");
void glGetMapiv(GLenum target, GLenum query, GLint *v) AliasExport("glshim_glGetMapiv");

76
project/jni/glshim/src/gl/framebuffers.c
View File

@@ -742,43 +742,43 @@ printf("glBlitFramebuffer(%d, %d, %d, %d, %d, %d, %d, %d, 0x%04X, 0x%04X)\n",
// direct wrapper
void glGenFramebuffers(GLsizei n, GLuint *ids) __attribute__((alias ("glshim_glGenFramebuffers")));
void glDeleteFramebuffers(GLsizei n, GLuint *framebuffers) __attribute__((alias ("glshim_glDeleteFramebuffers")));
GLboolean glIsFramebuffer(GLuint framebuffer) __attribute__((alias ("glshim_glIsFramebuffer")));
GLenum glCheckFramebufferStatus(GLenum target) __attribute__((alias ("glshim_glCheckFramebufferStatus")));
void glBindFramebuffer(GLenum target, GLuint framebuffer) __attribute__((alias ("glshim_glBindFramebuffer")));
void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) __attribute__((alias ("glshim_glFramebufferTexture1D")));
void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) __attribute__((alias ("glshim_glFramebufferTexture2D")));
void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer) __attribute__((alias ("glshim_glFramebufferTexture3D")));
void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers) __attribute__((alias ("glshim_glGenRenderbuffers")));
void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) __attribute__((alias ("glshim_glFramebufferRenderbuffer")));
void glDeleteRenderbuffers(GLsizei n, GLuint *renderbuffers) __attribute__((alias ("glshim_glDeleteRenderbuffers")));
void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) __attribute__((alias ("glshim_glRenderbufferStorage")));
void glBindRenderbuffer(GLenum target, GLuint renderbuffer) __attribute__((alias ("glshim_glBindRenderbuffer")));
GLboolean glIsRenderbuffer(GLuint renderbuffer) __attribute__((alias ("glshim_glIsRenderbuffer")));
void glGenerateMipmap(GLenum target) __attribute__((alias ("glshim_glGenerateMipmap")));
void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) __attribute__((alias ("glshim_glGetFramebufferAttachmentParameteriv")));
void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params) __attribute__((alias ("glshim_glGetRenderbufferParameteriv")));
void glFramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) __attribute__((alias ("glshim_glFramebufferTextureLayer")));
void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) __attribute__((alias ("glshim_glBlitFramebuffer")));
void glGenFramebuffers(GLsizei n, GLuint *ids) AliasExport("glshim_glGenFramebuffers");
void glDeleteFramebuffers(GLsizei n, GLuint *framebuffers) AliasExport("glshim_glDeleteFramebuffers");
GLboolean glIsFramebuffer(GLuint framebuffer) AliasExport("glshim_glIsFramebuffer");
GLenum glCheckFramebufferStatus(GLenum target) AliasExport("glshim_glCheckFramebufferStatus");
void glBindFramebuffer(GLenum target, GLuint framebuffer) AliasExport("glshim_glBindFramebuffer");
void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) AliasExport("glshim_glFramebufferTexture1D");
void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) AliasExport("glshim_glFramebufferTexture2D");
void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer) AliasExport("glshim_glFramebufferTexture3D");
void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers) AliasExport("glshim_glGenRenderbuffers");
void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) AliasExport("glshim_glFramebufferRenderbuffer");
void glDeleteRenderbuffers(GLsizei n, GLuint *renderbuffers) AliasExport("glshim_glDeleteRenderbuffers");
void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) AliasExport("glshim_glRenderbufferStorage");
void glBindRenderbuffer(GLenum target, GLuint renderbuffer) AliasExport("glshim_glBindRenderbuffer");
GLboolean glIsRenderbuffer(GLuint renderbuffer) AliasExport("glshim_glIsRenderbuffer");
void glGenerateMipmap(GLenum target) AliasExport("glshim_glGenerateMipmap");
void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) AliasExport("glshim_glGetFramebufferAttachmentParameteriv");
void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params) AliasExport("glshim_glGetRenderbufferParameteriv");
void glFramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) AliasExport("glshim_glFramebufferTextureLayer");
void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) AliasExport("glshim_glBlitFramebuffer");
// EXT direct wrapper
void glGenFramebuffersEXT(GLsizei n, GLuint *ids) __attribute__((alias ("glshim_glGenFramebuffers")));
void glDeleteFramebuffersEXT(GLsizei n, GLuint *framebuffers) __attribute__((alias ("glshim_glDeleteFramebuffers")));
GLboolean glIsFramebufferEXT(GLuint framebuffer) __attribute__((alias ("glshim_glIsFramebuffer")));
GLenum glCheckFramebufferStatusEXT(GLenum target) __attribute__((alias ("glshim_glCheckFramebufferStatus")));
void glBindFramebufferEXT(GLenum target, GLuint framebuffer) __attribute__((alias ("glshim_glBindFramebuffer")));
void glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) __attribute__((alias ("glshim_glFramebufferTexture1D")));
void glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) __attribute__((alias ("glshim_glFramebufferTexture2D")));
void glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer) __attribute__((alias ("glshim_glFramebufferTexture3D")));
void glGenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers) __attribute__((alias ("glshim_glGenRenderbuffers")));
void glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) __attribute__((alias ("glshim_glFramebufferRenderbuffer")));
void glDeleteRenderbuffersEXT(GLsizei n, GLuint *renderbuffers) __attribute__((alias ("glshim_glDeleteRenderbuffers")));
void glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) __attribute__((alias ("glshim_glRenderbufferStorage")));
void glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) __attribute__((alias ("glshim_glBindRenderbuffer")));
GLboolean glIsRenderbufferEXT(GLuint renderbuffer) __attribute__((alias ("glshim_glIsRenderbuffer")));
void glGenerateMipmapEXT(GLenum target) __attribute__((alias ("glshim_glGenerateMipmap")));
void glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint *params) __attribute__((alias ("glshim_glGetFramebufferAttachmentParameteriv")));
void glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params) __attribute__((alias ("glshim_glGetRenderbufferParameteriv")));
void glFramebufferTextureLayerEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) __attribute__((alias ("glshim_glFramebufferTextureLayer")));
void glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) __attribute__((alias ("glshim_glBlitFramebuffer")));
void glGenFramebuffersEXT(GLsizei n, GLuint *ids) AliasExport("glshim_glGenFramebuffers");
void glDeleteFramebuffersEXT(GLsizei n, GLuint *framebuffers) AliasExport("glshim_glDeleteFramebuffers");
GLboolean glIsFramebufferEXT(GLuint framebuffer) AliasExport("glshim_glIsFramebuffer");
GLenum glCheckFramebufferStatusEXT(GLenum target) AliasExport("glshim_glCheckFramebufferStatus");
void glBindFramebufferEXT(GLenum target, GLuint framebuffer) AliasExport("glshim_glBindFramebuffer");
void glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) AliasExport("glshim_glFramebufferTexture1D");
void glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) AliasExport("glshim_glFramebufferTexture2D");
void glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer) AliasExport("glshim_glFramebufferTexture3D");
void glGenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers) AliasExport("glshim_glGenRenderbuffers");
void glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) AliasExport("glshim_glFramebufferRenderbuffer");
void glDeleteRenderbuffersEXT(GLsizei n, GLuint *renderbuffers) AliasExport("glshim_glDeleteRenderbuffers");
void glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) AliasExport("glshim_glRenderbufferStorage");
void glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) AliasExport("glshim_glBindRenderbuffer");
GLboolean glIsRenderbufferEXT(GLuint renderbuffer) AliasExport("glshim_glIsRenderbuffer");
void glGenerateMipmapEXT(GLenum target) AliasExport("glshim_glGenerateMipmap");
void glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint *params) AliasExport("glshim_glGetFramebufferAttachmentParameteriv");
void glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params) AliasExport("glshim_glGetRenderbufferParameteriv");
void glFramebufferTextureLayerEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) AliasExport("glshim_glFramebufferTextureLayer");
void glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) AliasExport("glshim_glBlitFramebuffer");

179
project/jni/glshim/src/gl/gl.c
View File

@@ -167,6 +167,8 @@ const GLubyte *glshim_glGetString(GLenum name) {
#endif
"GL_ARB_draw_buffers "
"GL_EXT_direct_state_access "
"GL_EXT_multi_draw_arrays "
"GL_SUN_multi_draw_arrays "
// "GL_EXT_blend_logic_op "
// "GL_EXT_blend_color "
// "GL_ARB_texture_cube_map "
@@ -182,7 +184,7 @@ const GLubyte *glshim_glGetString(GLenum name) {
return (str)?str:(GLubyte*)"";
}
}
const GLubyte *glGetString(GLenum name) __attribute__((alias("glshim_glGetString")));
const GLubyte *glGetString(GLenum name) AliasExport("glshim_glGetString");
void transposeMatrix(float *matrix)
{
@@ -323,7 +325,7 @@ void glshim_glGetIntegerv(GLenum pname, GLint *params) {
gles_glGetIntegerv(pname, params);
}
}
void glGetIntegerv(GLenum pname, GLint *params) __attribute__((alias("glshim_glGetIntegerv")));
void glGetIntegerv(GLenum pname, GLint *params) AliasExport("glshim_glGetIntegerv");
void glshim_glGetFloatv(GLenum pname, GLfloat *params) {
LOAD_GLES(glGetFloatv);
@@ -447,7 +449,7 @@ void glshim_glGetFloatv(GLenum pname, GLfloat *params) {
gles_glGetFloatv(pname, params);
}
}
void glGetFloatv(GLenum pname, GLfloat *params) __attribute__((alias("glshim_glGetFloatv")));
void glGetFloatv(GLenum pname, GLfloat *params) AliasExport("glshim_glGetFloatv");
extern int alphahack;
extern int texstream;
@@ -548,7 +550,7 @@ void glshim_glEnable(GLenum cap) {
LOAD_GLES(glEnable);
proxy_glEnable(cap, true, gles_glEnable);
}
void glEnable(GLenum cap) __attribute__((alias("glshim_glEnable")));
void glEnable(GLenum cap) AliasExport("glshim_glEnable");
void glshim_glDisable(GLenum cap) {
if (glstate.list.active && (glstate.gl_batch && !glstate.list.compiling)) {
@@ -584,19 +586,19 @@ void glshim_glDisable(GLenum cap) {
LOAD_GLES(glDisable);
proxy_glEnable(cap, false, gles_glDisable);
}
void glDisable(GLenum cap) __attribute__((alias("glshim_glDisable")));
void glDisable(GLenum cap) AliasExport("glshim_glDisable");
void glshim_glEnableClientState(GLenum cap) {
LOAD_GLES(glEnableClientState);
proxy_glEnable(cap, true, gles_glEnableClientState);
}
void glEnableClientState(GLenum cap) __attribute__((alias("glshim_glEnableClientState")));
void glEnableClientState(GLenum cap) AliasExport("glshim_glEnableClientState");
void glshim_glDisableClientState(GLenum cap) {
LOAD_GLES(glDisableClientState);
proxy_glEnable(cap, false, gles_glDisableClientState);
}
void glDisableClientState(GLenum cap) __attribute__((alias("glshim_glDisableClientState")));
void glDisableClientState(GLenum cap) AliasExport("glshim_glDisableClientState");
#define isenabled(what, where) \
@@ -630,7 +632,7 @@ GLboolean glshim_glIsEnabled(GLenum cap) {
}
#undef isenabled
#undef clientisenabled
GLboolean glIsEnabled(GLenum cap) __attribute__((alias("glshim_glIsEnabled")));
GLboolean glIsEnabled(GLenum cap) AliasExport("glshim_glIsEnabled");
static renderlist_t *arrays_to_renderlist(renderlist_t *list, GLenum mode,
GLsizei skip, GLsizei count) {
@@ -884,7 +886,7 @@ void glshim_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid
free(sindices);
}
}
void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) __attribute__((alias("glshim_glDrawElements")));
void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) AliasExport("glshim_glDrawElements");
void glshim_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
// special check for QUADS and TRIANGLES that need multiple of 4 or 3 vertex...
@@ -1068,7 +1070,7 @@ void glshim_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
}
}
#undef client_state
void glDrawArrays(GLenum mode, GLint first, GLsizei count) __attribute__((alias("glshim_glDrawArrays")));
void glDrawArrays(GLenum mode, GLint first, GLsizei count) AliasExport("glshim_glDrawArrays");
#ifndef USE_ES2
#define clone_gl_pointer(t, s)\
@@ -1102,11 +1104,11 @@ void glshim_glSecondaryColorPointer(GLint size, GLenum type,
#undef clone_gl_pointer
#endif
void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) __attribute__((alias("glshim_glVertexPointer")));
void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) __attribute__((alias("glshim_glColorPointer")));
void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) __attribute__((alias("glshim_glNormalPointer")));
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) __attribute__((alias("glshim_glTexCoordPointer")));
void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) __attribute__((alias("glshim_glSecondaryColorPointer")));
void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) AliasExport("glshim_glVertexPointer");
void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) AliasExport("glshim_glColorPointer");
void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) AliasExport("glshim_glNormalPointer");
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) AliasExport("glshim_glTexCoordPointer");
void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) AliasExport("glshim_glSecondaryColorPointer");
void glshim_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) {
uintptr_t ptr = (uintptr_t)pointer;
@@ -1204,7 +1206,7 @@ void glshim_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *poi
glshim_glVertexPointer(vert, vf, stride, (GLvoid *)ptr);
}
}
void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) __attribute__((alias("glshim_glInterleavedArrays")));
void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) AliasExport("glshim_glInterleavedArrays");
// immediate mode functions
void glshim_glBegin(GLenum mode) {
@@ -1215,7 +1217,7 @@ void glshim_glBegin(GLenum mode) {
glstate.list.active->mode_init = mode;
noerrorShim(); // TODO, check Enum validity
}
void glBegin(GLenum mode) __attribute__((alias("glshim_glBegin")));
void glBegin(GLenum mode) AliasExport("glshim_glBegin");
void glshim_glEnd() {
if (!glstate.list.active) return;
@@ -1235,7 +1237,7 @@ void glshim_glEnd() {
}
noerrorShim();
}
void glEnd() __attribute__((alias("glshim_glEnd")));
void glEnd() AliasExport("glshim_glEnd");
void glshim_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
if (glstate.list.active) {
@@ -1261,7 +1263,7 @@ void glshim_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
#endif
glstate.normal[0] = nx; glstate.normal[1] = ny; glstate.normal[2] = nz;
}
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) __attribute__((alias("glshim_glNormal3f")));
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) AliasExport("glshim_glNormal3f");
void glshim_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
if (glstate.list.active) {
@@ -1269,7 +1271,7 @@ void glshim_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
noerrorShim();
}
}
void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) __attribute__((alias("glshim_glVertex4f")));
void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) AliasExport("glshim_glVertex4f");
void glshim_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
if (glstate.list.active) {
@@ -1296,7 +1298,7 @@ void glshim_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
glstate.color[0] = red; glstate.color[1] = green;
glstate.color[2] = blue; glstate.color[3] = alpha;
}
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) __attribute__((alias("glshim_glColor4f")));
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) AliasExport("glshim_glColor4f");
void glshim_glSecondaryColor3f(GLfloat r, GLfloat g, GLfloat b) {
if (glstate.list.active) {
@@ -1311,7 +1313,7 @@ void glshim_glSecondaryColor3f(GLfloat r, GLfloat g, GLfloat b) {
glstate.secondary[0] = r; glstate.secondary[1] = g;
glstate.secondary[2] = b;
}
void glSecondaryColor3f(GLfloat r, GLfloat g, GLfloat b) __attribute__((alias("glshim_glSecondaryColor3f")));
void glSecondaryColor3f(GLfloat r, GLfloat g, GLfloat b) AliasExport("glshim_glSecondaryColor3f");
#ifndef USE_ES2
void glshim_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
@@ -1329,7 +1331,7 @@ void glshim_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
errorGL();
}
}
void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) __attribute__((alias("glshim_glMaterialfv")));
void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) AliasExport("glshim_glMaterialfv");
void glshim_glMaterialf(GLenum face, GLenum pname, const GLfloat param) {
LOAD_GLES(glMaterialf);
if ((glstate.list.compiling || glstate.gl_batch) && glstate.list.active) {
@@ -1347,7 +1349,7 @@ void glshim_glMaterialf(GLenum face, GLenum pname, const GLfloat param) {
errorGL();
}
}
void glMaterialf(GLenum face, GLenum pname, const GLfloat param) __attribute__((alias("glshim_glMaterialf")));
void glMaterialf(GLenum face, GLenum pname, const GLfloat param) AliasExport("glshim_glMaterialf");
#endif
void glshim_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
@@ -1360,7 +1362,7 @@ void glshim_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
glstate.texcoord[0][0] = s; glstate.texcoord[0][1] = t;
glstate.texcoord[0][2] = r; glstate.texcoord[0][3] = q;
}
void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) __attribute__((alias("glshim_glTexCoord4f")));
void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) AliasExport("glshim_glTexCoord4f");
void glshim_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
// TODO, error if target is unsuported texture....
@@ -1373,8 +1375,8 @@ void glshim_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GL
glstate.texcoord[target-GL_TEXTURE0][0] = s; glstate.texcoord[target-GL_TEXTURE0][1] = t;
glstate.texcoord[target-GL_TEXTURE0][2] = r; glstate.texcoord[target-GL_TEXTURE0][3] = q;
}
void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) __attribute__((alias("glshim_glMultiTexCoord4f")));
void glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) __attribute__((alias("glshim_glMultiTexCoord4f")));
void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) AliasExport("glshim_glMultiTexCoord4f");
void glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) AliasExport("glshim_glMultiTexCoord4f");
void glshim_glArrayElement(GLint i) {
GLfloat *v;
@@ -1440,7 +1442,7 @@ void glshim_glArrayElement(GLint i) {
}
}
}
void glArrayElement(GLint i) __attribute__((alias("glshim_glArrayElement")));
void glArrayElement(GLint i) AliasExport("glshim_glArrayElement");
// TODO: between a lock and unlock, I can assume the array pointers are unchanged
// so I can build a renderlist_t on the first call and hold onto it
@@ -1449,12 +1451,12 @@ void glshim_glLockArrays(GLint first, GLsizei count) {
glstate.list.locked = true;
noerrorShim();
}
void glLockArraysEXT(GLint first, GLsizei count) __attribute__((alias("glshim_glLockArrays")));
void glLockArraysEXT(GLint first, GLsizei count) AliasExport("glshim_glLockArrays");
void glshim_glUnlockArrays() {
glstate.list.locked = false;
noerrorShim();
}
void glUnlockArraysEXT() __attribute__((alias("glshim_glUnlockArrays")));
void glUnlockArraysEXT() AliasExport("glshim_glUnlockArrays");
// display lists
static renderlist_t *glshim_glGetList(GLuint list) {
@@ -1485,7 +1487,7 @@ GLuint glshim_glGenLists(GLsizei range) {
}
return start + 1;
}
GLuint glGenLists(GLsizei range) __attribute__((alias("glshim_glGenLists")));
GLuint glGenLists(GLsizei range) AliasExport("glshim_glGenLists");
void glshim_glNewList(GLuint list, GLenum mode) {
@@ -1505,7 +1507,7 @@ void glshim_glNewList(GLuint list, GLenum mode) {
glstate.list.active = alloc_renderlist();
glstate.list.compiling = true;
}
void glNewList(GLuint list, GLenum mode) __attribute__((alias("glshim_glNewList")));
void glNewList(GLuint list, GLenum mode) AliasExport("glshim_glNewList");
void glshim_glEndList() {
noerrorShim();
@@ -1525,7 +1527,7 @@ void glshim_glEndList() {
}
}
}
void glEndList() __attribute__((alias("glshim_glEndList")));
void glEndList() AliasExport("glshim_glEndList");
void glshim_glCallList(GLuint list) {
noerrorShim();
@@ -1539,7 +1541,7 @@ void glshim_glCallList(GLuint list) {
if (l)
draw_renderlist(l);
}
void glCallList(GLuint list) __attribute__((alias("glshim_glCallList")));
void glCallList(GLuint list) AliasExport("glshim_glCallList");
void glPushCall(void *call) {
if ((glstate.list.compiling || glstate.gl_batch) && glstate.list.active) {
@@ -1583,7 +1585,7 @@ void glshim_glCallLists(GLsizei n, GLenum type, const GLvoid *lists) {
#undef call
#undef call_bytes
}
void glCallLists(GLsizei n, GLenum type, const GLvoid *lists) __attribute__((alias("glshim_glCallLists")));
void glCallLists(GLsizei n, GLenum type, const GLvoid *lists) AliasExport("glshim_glCallLists");
void glshim_glDeleteList(GLuint list) {
if(glstate.gl_batch) {
@@ -1604,13 +1606,13 @@ void glshim_glDeleteLists(GLuint list, GLsizei range) {
glshim_glDeleteList(list+i);
}
}
void glDeleteLists(GLuint list, GLsizei range) __attribute__((alias("glshim_glDeleteLists")));
void glDeleteLists(GLuint list, GLsizei range) AliasExport("glshim_glDeleteLists");
void glshim_glListBase(GLuint base) {
noerrorShim();
glstate.list.base = base;
}
void glListBase(GLuint base) __attribute__((alias("glshim_glListBase")));
void glListBase(GLuint base) AliasExport("glshim_glListBase");
GLboolean glshim_glIsList(GLuint list) {
noerrorShim();
@@ -1619,7 +1621,7 @@ GLboolean glshim_glIsList(GLuint list) {
}
return false;
}
GLboolean glIsList(GLuint list) __attribute__((alias("glshim_glIsList")));
GLboolean glIsList(GLuint list) AliasExport("glshim_glIsList");
void glshim_glPolygonMode(GLenum face, GLenum mode) {
noerrorShim();
@@ -1646,7 +1648,7 @@ void glshim_glPolygonMode(GLenum face, GLenum mode) {
glstate.polygon_mode = 0;
}
}
void glPolygonMode(GLenum face, GLenum mode) __attribute__((alias("glshim_glPolygonMode")));
void glPolygonMode(GLenum face, GLenum mode) AliasExport("glshim_glPolygonMode");
void alloc_matrix(matrixstack_t **matrixstack, int depth) {
*matrixstack = (matrixstack_t*)malloc(sizeof(matrixstack_t));
@@ -1699,7 +1701,7 @@ void glshim_glPushMatrix() {
//gles_glPushMatrix();
}
}
void glPushMatrix() __attribute__((alias("glshim_glPushMatrix")));
void glPushMatrix() AliasExport("glshim_glPushMatrix");
void glshim_glPopMatrix() {
PUSH_IF_COMPILING(glPopMatrix);
@@ -1746,7 +1748,7 @@ void glshim_glPopMatrix() {
//gles_glPopMatrix();
}
}
void glPopMatrix() __attribute__((alias("glshim_glPopMatrix")));
void glPopMatrix() AliasExport("glshim_glPopMatrix");
GLenum glshim_glGetError() {
LOAD_GLES(glGetError);
@@ -1759,7 +1761,7 @@ GLenum glshim_glGetError() {
}
return gles_glGetError();
}
GLenum glGetError() __attribute__((alias("glshim_glGetError")));
GLenum glGetError() AliasExport("glshim_glGetError");
void glshim_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
PUSH_IF_COMPILING(glBlendColor);
@@ -1774,9 +1776,9 @@ void glshim_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf a
}
}
}
void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) __attribute__((alias("glshim_glBlendColor")));
void glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) __attribute__((alias("glshim_glBlendColor")));
void glBlendColorARB(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) __attribute__((alias("glshim_glBlendColor")));
void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) AliasExport("glshim_glBlendColor");
void glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) AliasExport("glshim_glBlendColor");
void glBlendColorARB(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) AliasExport("glshim_glBlendColor");
void glshim_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
@@ -1787,8 +1789,8 @@ void glshim_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfa
#endif
gles_glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) __attribute__((alias("glshim_glBlendFuncSeparate")));
void glBlendFuncSeparateEXT (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) __attribute__((alias("glshim_glBlendFuncSeparate")));
void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) AliasExport("glshim_glBlendFuncSeparate");
void glBlendFuncSeparateEXT (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) AliasExport("glshim_glBlendFuncSeparate");
void glshim_glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) {
PUSH_IF_COMPILING(glBlendEquationSeparate);
@@ -1798,8 +1800,8 @@ void glshim_glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) {
#endif
gles_glBlendEquationSeparate(modeRGB, modeA);
}
void glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) __attribute__((alias("glshim_glBlendEquationSeparate")));
void glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA) __attribute__((alias("glshim_glBlendEquationSeparate")));
void glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) AliasExport("glshim_glBlendEquationSeparate");
void glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA) AliasExport("glshim_glBlendEquationSeparate");
void glshim_glBlendFunc(GLenum sfactor, GLenum dfactor) {
if (glstate.list.active && (glstate.gl_batch && !glstate.list.compiling)) {
@@ -1875,7 +1877,7 @@ void glshim_glBlendFunc(GLenum sfactor, GLenum dfactor) {
#endif
gles_glBlendFunc(sfactor, dfactor);
}
void glBlendFunc(GLenum sfactor, GLenum dfactor) __attribute__((alias("glshim_glBlendFunc")));
void glBlendFunc(GLenum sfactor, GLenum dfactor) AliasExport("glshim_glBlendFunc");
void glshim_glStencilMaskSeparate(GLenum face, GLuint mask) {
@@ -1883,7 +1885,7 @@ void glshim_glStencilMaskSeparate(GLenum face, GLuint mask) {
if ((face==GL_FRONT) || (face==GL_FRONT_AND_BACK))
glshim_glStencilMask(mask);
}
void glStencilMaskSeparate(GLenum face, GLuint mask) __attribute__((alias("glshim_glStencilMaskSeparate")));
void glStencilMaskSeparate(GLenum face, GLuint mask) AliasExport("glshim_glStencilMaskSeparate");
void init_statebatch() {
@@ -1926,7 +1928,7 @@ void glshim_glFlush() {
gles_glFlush();
errorGL();
}
void glFlush() __attribute__((alias("glshim_glFlush")));
void glFlush() AliasExport("glshim_glFlush");
void glshim_glFinish() {
LOAD_GLES(glFinish);
@@ -1940,7 +1942,7 @@ void glshim_glFinish() {
gles_glFinish();
errorGL();
}
void glFinish() __attribute__((alias("glshim_glFinish")));
void glFinish() AliasExport("glshim_glFinish");
void glshim_glLoadMatrixf(const GLfloat * m) {
LOAD_GLES(glLoadMatrixf);
@@ -1953,7 +1955,7 @@ void glshim_glLoadMatrixf(const GLfloat * m) {
}
gles_glLoadMatrixf(m);
}
void glLoadMatrixf(const GLfloat * m) __attribute__((alias("glshim_glLoadMatrixf")));
void glLoadMatrixf(const GLfloat * m) AliasExport("glshim_glLoadMatrixf");
void glshim_glMultMatrixf(const GLfloat * m) {
LOAD_GLES(glMultMatrixf);
@@ -1966,7 +1968,7 @@ void glshim_glMultMatrixf(const GLfloat * m) {
}
gles_glMultMatrixf(m);
}
void glMultMatrixf(const GLfloat * m) __attribute__((alias("glshim_glMultMatrixf")));
void glMultMatrixf(const GLfloat * m) AliasExport("glshim_glMultMatrixf");
void glshim_glFogfv(GLenum pname, const GLfloat* params) {
LOAD_GLES(glFogfv);
@@ -1982,7 +1984,7 @@ void glshim_glFogfv(GLenum pname, const GLfloat* params) {
gles_glFogfv(pname, params);
}
void glFogfv(GLenum pname, const GLfloat* params) __attribute__((alias("glshim_glFogfv")));
void glFogfv(GLenum pname, const GLfloat* params) AliasExport("glshim_glFogfv");
void glshim_glIndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer) {
static bool warning = false;
@@ -1991,7 +1993,7 @@ void glshim_glIndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer)
warning = true;
}
}
void glIndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer) __attribute__((alias("glshim_glIndexPointer")));
void glIndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer) AliasExport("glshim_glIndexPointer");
void glshim_glEdgeFlagPointer(GLsizei stride, const GLvoid * pointer) {
static bool warning = false;
@@ -2000,7 +2002,7 @@ void glshim_glEdgeFlagPointer(GLsizei stride, const GLvoid * pointer) {
warning = true;
}
}
void glEdgeFlagPointer(GLsizei stride, const GLvoid * pointer) __attribute__((alias("glshim_glEdgeFlagPointer")));
void glEdgeFlagPointer(GLsizei stride, const GLvoid * pointer) AliasExport("glshim_glEdgeFlagPointer");
void glshim_glGetPointerv(GLenum pname, GLvoid* *params) {
noerrorShim();
@@ -2032,4 +2034,63 @@ void glshim_glGetPointerv(GLenum pname, GLvoid* *params) {
errorShim(GL_INVALID_ENUM);
}
}
void glGetPointerv(GLenum pname, GLvoid* *params) __attribute__((alias("glshim_glGetPointerv")));
void glGetPointerv(GLenum pname, GLvoid* *params) AliasExport("glshim_glGetPointerv");
void glshim_glPointParameteri(GLenum pname, GLint param)
{
glshim_glPointParameterf(pname, param);
}
void glPointParameteri(GLenum pname, GLint param) AliasExport("glshim_glPointParameteri");
void glshim_glPointParameteriv(GLenum pname, const GLint * params)
{
GLfloat tmp[3];
int v=(pname==GL_POINT_DISTANCE_ATTENUATION)?3:1;
for (int i=0; i<v; i++) tmp[i] = params[i];
glshim_glPointParameterfv(pname, tmp);
}
void glPointParameteriv(GLenum pname, const GLint * params) AliasExport("glshim_glPointParameteriv");
void glshim_glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
{
LOAD_GLES_OES(glMultiDrawArrays);
if((!gles_glMultiDrawArrays) || should_intercept_render(mode) || (glstate.list.active && (glstate.list.compiling || glstate.gl_batch))
|| (glstate.render_mode == GL_SELECT) || ((glstate.polygon_mode == GL_LINE) || (glstate.polygon_mode == GL_POINT)) )
{
// divide the call
// TODO optimize with forcing Batch mode
for (int i=0; i<primcount; i++)
glshim_glDrawArrays(mode, first[i], count[i]);
}
else
{
if(mode==GL_QUAD_STRIP) mode=GL_TRIANGLE_STRIP;
else if(mode==GL_POLYGON) mode=GL_TRIANGLE_FAN;
gles_glMultiDrawArrays(mode, first, count, primcount);
errorGL();
}
}
void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) AliasExport("glshim_glMultiDrawArrays");
void glshim_glMultiDrawElements( GLenum mode, GLsizei *count, GLenum type, const void * const *indices, GLsizei primcount)
{
LOAD_GLES_OES(glMultiDrawElements);
if((!gles_glMultiDrawElements) || should_intercept_render(mode) || (glstate.list.active && (glstate.list.compiling || glstate.gl_batch))
|| (glstate.render_mode == GL_SELECT) || ((glstate.polygon_mode == GL_LINE) || (glstate.polygon_mode == GL_POINT)) || (type != GL_UNSIGNED_SHORT) )
{
// divide the call
// TODO optimize with forcing Batch mode
for (int i=0; i<primcount; i++)
glshim_glDrawElements(mode, count[i], type, indices[i]);
}
else
{
if(mode==GL_QUAD_STRIP) mode=GL_TRIANGLE_STRIP;
else if(mode==GL_POLYGON) mode=GL_TRIANGLE_FAN;
gles_glMultiDrawElements(mode, count, type, indices, primcount);
errorGL();
}
}
void glMultiDrawElements( GLenum mode, GLsizei *count, GLenum type, const void * const *indices, GLsizei primcount) AliasExport("glshim_glMultiDrawElements");

11
project/jni/glshim/src/gl/gl.h
View File

@@ -17,6 +17,10 @@
#include <arm_neon.h>
#endif
#ifndef AliasExport
#define AliasExport(name) __attribute__((alias(name))) __attribute__((visibility("default")))
#endif
#ifndef GL_H
#define GL_H
@@ -370,6 +374,10 @@ void glshim_glPushMatrix();
void glshim_glPopMatrix();
GLenum glshim_glGetError();
void glshim_glPointParameteri(GLenum pname, GLint param);
void glshim_glPointParameteriv(GLenum pname, const GLint * params);
void glshim_glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
void glshim_glIndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer);
void glshim_glEdgeFlagPointer(GLsizei stride, const GLvoid * pointer);
@@ -386,6 +394,9 @@ void glshim_glFogfv(GLenum pname, const GLfloat* params);
void glshim_glStencilMaskSeparate(GLenum face, GLuint mask);
void glshim_glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
void glshim_glMultiDrawElements( GLenum mode, GLsizei *count, GLenum type, const void * const *indices, GLsizei primcount);
void flush();
void init_batch();

8
project/jni/glshim/src/gl/light.c
View File

@@ -69,8 +69,8 @@ void glshim_glLightf(GLenum light, GLenum pname, const GLfloat params) {
errorGL();
}
void glLightModelf(GLenum pname, GLfloat param) __attribute__((alias("glshim_glLightModelf")));
void glLightModelfv(GLenum pname, const GLfloat* params) __attribute__((alias("glshim_glLightModelfv")));
void glLightfv(GLenum light, GLenum pname, const GLfloat* params) __attribute__((alias("glshim_glLightfv")));
void glLightf(GLenum light, GLenum pname, const GLfloat params) __attribute__((alias("glshim_glLightf")));
void glLightModelf(GLenum pname, GLfloat param) AliasExport("glshim_glLightModelf");
void glLightModelfv(GLenum pname, const GLfloat* params) AliasExport("glshim_glLightModelfv");
void glLightfv(GLenum light, GLenum pname, const GLfloat* params) AliasExport("glshim_glLightfv");
void glLightf(GLenum light, GLenum pname, const GLfloat params) AliasExport("glshim_glLightf");
#endif

2
project/jni/glshim/src/gl/line.c
View File

@@ -30,7 +30,7 @@ void glshim_glLineStipple(GLuint factor, GLushort pattern) {
glshim_glPopAttrib();
noerrorShim();
}
void glLineStipple(GLuint factor, GLushort pattern) __attribute__((alias("glshim_glLineStipple")));
void glLineStipple(GLuint factor, GLushort pattern) AliasExport("glshim_glLineStipple");
void bind_stipple_tex() {
glshim_glBindTexture(GL_TEXTURE_2D, stippleTexture);

14
project/jni/glshim/src/gl/raster.c
View File

@@ -535,10 +535,10 @@ void render_raster_list(rasterlist_t* rast) {
}
//Direct wrapper
void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) __attribute__((alias("glshim_glBitmap")));
void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glDrawPixels")));
void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) __attribute__((alias("glshim_glRasterPos3f")));
void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) __attribute__((alias("glshim_glWindowPos3f")));
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glViewport")));
void glPixelZoom(GLfloat xfactor, GLfloat yfactor) __attribute__((alias("glshim_glPixelZoom")));
void glPixelTransferf(GLenum pname, GLfloat param) __attribute__((alias("glshim_glPixelTransferf")));
void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) AliasExport("glshim_glBitmap");
void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glDrawPixels");
void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) AliasExport("glshim_glRasterPos3f");
void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) AliasExport("glshim_glWindowPos3f");
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glViewport");
void glPixelZoom(GLfloat xfactor, GLfloat yfactor) AliasExport("glshim_glPixelZoom");
void glPixelTransferf(GLenum pname, GLfloat param) AliasExport("glshim_glPixelTransferf");

12
project/jni/glshim/src/gl/render.c
View File

@@ -364,9 +364,9 @@ void select_glDrawElements(const pointer_state_t* vtx, GLenum mode, GLuint count
}
//Direct wrapper
GLint glRenderMode(GLenum mode) __attribute__((alias("glshim_glRenderMode")));
void glInitNames() __attribute__((alias("glshim_glInitNames")));
void glPopName() __attribute__((alias("glshim_glPopName")));
void glPushName(GLuint name) __attribute__((alias("glshim_glPushName")));
void glLoadName(GLuint name) __attribute__((alias("glshim_glLoadName")));
void glSelectBuffer(GLsizei size, GLuint *buffer) __attribute__((alias("glshim_glSelectBuffer")));
GLint glRenderMode(GLenum mode) AliasExport("glshim_glRenderMode");
void glInitNames() AliasExport("glshim_glInitNames");
void glPopName() AliasExport("glshim_glPopName");
void glPushName(GLuint name) AliasExport("glshim_glPushName");
void glLoadName(GLuint name) AliasExport("glshim_glLoadName");
void glSelectBuffer(GLsizei size, GLuint *buffer) AliasExport("glshim_glSelectBuffer");

8
project/jni/glshim/src/gl/stack.c
View File

@@ -584,7 +584,7 @@ void glshim_glPopClientAttrib() {
#undef v4
//Direct wrapper
void glPushClientAttrib(GLbitfield mask) __attribute__((alias("glshim_glPushClientAttrib")));
void glPopClientAttrib() __attribute__((alias("glshim_glPopClientAttrib")));
void glPushAttrib(GLbitfield mask) __attribute__((alias("glshim_glPushAttrib")));
void glPopAttrib() __attribute__((alias("glshim_glPopAttrib")));
void glPushClientAttrib(GLbitfield mask) AliasExport("glshim_glPushClientAttrib");
void glPopClientAttrib() AliasExport("glshim_glPopClientAttrib");
void glPushAttrib(GLbitfield mask) AliasExport("glshim_glPushAttrib");
void glPopAttrib() AliasExport("glshim_glPopAttrib");

14
project/jni/glshim/src/gl/texgen.c
View File

@@ -440,11 +440,11 @@ void glshim_glMultTransposeMatrixf(const GLfloat *m) {
errorGL();
}
void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) __attribute__((alias("glshim_glTexGenfv")));
void glTexGeni(GLenum coord, GLenum pname, GLint param) __attribute__((alias("glshim_glTexGeni")));
void glGetTexGenfv(GLenum coord,GLenum pname,GLfloat *params) __attribute__((alias("glshim_glGetTexGenfv")));
void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) AliasExport("glshim_glTexGenfv");
void glTexGeni(GLenum coord, GLenum pname, GLint param) AliasExport("glshim_glTexGeni");
void glGetTexGenfv(GLenum coord,GLenum pname,GLfloat *params) AliasExport("glshim_glGetTexGenfv");
void glLoadTransposeMatrixf(const GLfloat *m) __attribute__((alias("glshim_glLoadTransposeMatrixf")));
void glLoadTransposeMatrixd(const GLdouble *m) __attribute__((alias("glshim_glLoadTransposeMatrixd")));
void glMultTransposeMatrixd(const GLdouble *m) __attribute__((alias("glshim_glMultTransposeMatrixd")));
void glMultTransposeMatrixf(const GLfloat *m) __attribute__((alias("glshim_glMultTransposeMatrixf")));
void glLoadTransposeMatrixf(const GLfloat *m) AliasExport("glshim_glLoadTransposeMatrixf");
void glLoadTransposeMatrixd(const GLdouble *m) AliasExport("glshim_glLoadTransposeMatrixd");
void glMultTransposeMatrixd(const GLdouble *m) AliasExport("glshim_glMultTransposeMatrixd");
void glMultTransposeMatrixf(const GLfloat *m) AliasExport("glshim_glMultTransposeMatrixf");

102
project/jni/glshim/src/gl/texture.c
View File

@@ -2081,57 +2081,57 @@ void glshim_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
//Direct wrapper
void glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glTexImage2D")));
void glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glTexImage1D")));
void glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glTexImage3D")));
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glTexSubImage2D")));
void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glTexSubImage1D")));
void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glTexSubImage3D")));
void glBindTexture(GLenum target, GLuint texture) __attribute__((alias("glshim_glBindTexture")));
void glGenTextures(GLsizei n, GLuint * textures) __attribute__((alias("glshim_glGenTextures")));
void glDeleteTextures(GLsizei n, const GLuint * textures) __attribute__((alias("glshim_glDeleteTextures")));
void glTexParameteri(GLenum target, GLenum pname, GLint param) __attribute__((alias("glshim_glTexParameteri")));
void glTexParameterf(GLenum target, GLenum pname, GLfloat param) __attribute__((alias("glshim_glTexParameterf")));
GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) __attribute__((alias("glshim_glAreTexturesResident")));
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetTexLevelParameteriv")));
void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * img) __attribute__((alias("glshim_glGetTexImage")));
void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * data) __attribute__((alias("glshim_glReadPixels")));
void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage2D")));
void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage1D")));
void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage3D")));
void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage2D")));
void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage1D")));
void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage3D")));
void glGetCompressedTexImage(GLenum target, GLint lod, GLvoid *img) __attribute__((alias("glshim_glGetCompressedTexImage")));
void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) __attribute__((alias("glshim_glCopyTexImage1D")));
void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) __attribute__((alias("glshim_glCopyTexImage2D")));
void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glCopyTexSubImage2D")));
void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) __attribute__((alias("glshim_glCopyTexSubImage1D")));
void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glCopyTexSubImage3D")));
void glActiveTexture( GLenum texture ) __attribute__((alias("glshim_glActiveTexture")));
void glClientActiveTexture( GLenum texture ) __attribute__((alias("glshim_glClientActiveTexture")));
GLboolean glIsTexture( GLuint texture ) __attribute__((alias("glshim_glIsTexture")));
void glPixelStorei(GLenum pname, GLint param) __attribute__((alias("glshim_glPixelStorei")));
void glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glTexImage2D");
void glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glTexImage1D");
void glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glTexImage3D");
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glTexSubImage2D");
void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glTexSubImage1D");
void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glTexSubImage3D");
void glBindTexture(GLenum target, GLuint texture) AliasExport("glshim_glBindTexture");
void glGenTextures(GLsizei n, GLuint * textures) AliasExport("glshim_glGenTextures");
void glDeleteTextures(GLsizei n, const GLuint * textures) AliasExport("glshim_glDeleteTextures");
void glTexParameteri(GLenum target, GLenum pname, GLint param) AliasExport("glshim_glTexParameteri");
void glTexParameterf(GLenum target, GLenum pname, GLfloat param) AliasExport("glshim_glTexParameterf");
GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) AliasExport("glshim_glAreTexturesResident");
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) AliasExport("glshim_glGetTexLevelParameteriv");
void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * img) AliasExport("glshim_glGetTexImage");
void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * data) AliasExport("glshim_glReadPixels");
void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage2D");
void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage1D");
void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage3D");
void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage2D");
void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage1D");
void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage3D");
void glGetCompressedTexImage(GLenum target, GLint lod, GLvoid *img) AliasExport("glshim_glGetCompressedTexImage");
void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) AliasExport("glshim_glCopyTexImage1D");
void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) AliasExport("glshim_glCopyTexImage2D");
void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glCopyTexSubImage2D");
void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) AliasExport("glshim_glCopyTexSubImage1D");
void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glCopyTexSubImage3D");
void glActiveTexture( GLenum texture ) AliasExport("glshim_glActiveTexture");
void glClientActiveTexture( GLenum texture ) AliasExport("glshim_glClientActiveTexture");
GLboolean glIsTexture( GLuint texture ) AliasExport("glshim_glIsTexture");
void glPixelStorei(GLenum pname, GLint param) AliasExport("glshim_glPixelStorei");
//EXT mapper
void glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glTexSubImage3D")));
void glCompressedTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage2D")));
void glCompressedTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage1D")));
void glCompressedTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage3D")));
void glCompressedTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage2D")));
void glCompressedTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage1D")));
void glCompressedTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage3D")));
void glGetCompressedTexImageEXT(GLenum target, GLint lod, GLvoid *img) __attribute__((alias("glshim_glGetCompressedTexImage")));
void glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glCopyTexSubImage3D")));
void glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glTexSubImage3D");
void glCompressedTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage2D");
void glCompressedTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage1D");
void glCompressedTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage3D");
void glCompressedTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage2D");
void glCompressedTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage1D");
void glCompressedTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage3D");
void glGetCompressedTexImageEXT(GLenum target, GLint lod, GLvoid *img) AliasExport("glshim_glGetCompressedTexImage");
void glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glCopyTexSubImage3D");
//ARB mapper
void glActiveTextureARB(GLenum texture) __attribute__((alias("glshim_glActiveTexture")));
void glClientActiveTextureARB(GLenum texture) __attribute__((alias("glshim_glClientActiveTexture")));
void glTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *data) __attribute__((alias("glshim_glTexSubImage3D")));
void glCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage2D")));
void glCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage1D")));
void glCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexImage3D")));
void glCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage2D")));
void glCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage1D")));
void glCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) __attribute__((alias("glshim_glCompressedTexSubImage3D")));
void glGetCompressedTexImageARB(GLenum target, GLint lod, GLvoid *img) __attribute__((alias("glshim_glGetCompressedTexImage")));
void glCopyTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) __attribute__((alias("glshim_glCopyTexSubImage3D")));
void glActiveTextureARB(GLenum texture) AliasExport("glshim_glActiveTexture");
void glClientActiveTextureARB(GLenum texture) AliasExport("glshim_glClientActiveTexture");
void glTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *data) AliasExport("glshim_glTexSubImage3D");
void glCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage2D");
void glCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage1D");
void glCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexImage3D");
void glCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage2D");
void glCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage1D");
void glCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) AliasExport("glshim_glCompressedTexSubImage3D");
void glGetCompressedTexImageARB(GLenum target, GLint lod, GLvoid *img) AliasExport("glshim_glGetCompressedTexImage");
void glCopyTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) AliasExport("glshim_glCopyTexSubImage3D");

278
project/jni/glshim/src/gl/wrap/gl.c
View File

@@ -722,68 +722,68 @@ void glshim_glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenu
//Direct wrapper
#ifdef USE_ES2
void glCompileShader(GLuint shader) __attribute__((alias("glshim_glCompileShader")));
GLuint glCreateShaderObject(GLenum shaderType) __attribute__((alias("glshim_glCreateShaderObject")));
void glGetObjectParameteriv(GLuint shader, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetObjectParameteriv")));
void glShaderSource(GLuint shader, GLsizei count, const GLchar **string, const GLint *length) __attribute__((alias("glshim_glShaderSource")));
void glCompileShader(GLuint shader) AliasExport("glshim_glCompileShader");
GLuint glCreateShaderObject(GLenum shaderType) AliasExport("glshim_glCreateShaderObject");
void glGetObjectParameteriv(GLuint shader, GLenum pname, GLint *params) AliasExport("glshim_glGetObjectParameteriv");
void glShaderSource(GLuint shader, GLsizei count, const GLchar **string, const GLint *length) AliasExport("glshim_glShaderSource");
void glCompileShaderARB(GLuint shader) __attribute__((alias("glshim_glCompileShader")));
GLuint glCreateShaderObjectARB(GLenum shaderType) __attribute__((alias("glshim_glCreateShaderObject")));
void glGetObjectParameterivARB(GLuint shader, GLenum pname, GLint *params) __attribute__((alias("glshim_glGetObjectParameteriv")));
void glShaderSourceARB(GLuint shader, GLsizei count, const GLchar **string, const GLint *length) __attribute__((alias("glshim_glShaderSource")));
void glCompileShaderARB(GLuint shader) AliasExport("glshim_glCompileShader");
GLuint glCreateShaderObjectARB(GLenum shaderType) AliasExport("glshim_glCreateShaderObject");
void glGetObjectParameterivARB(GLuint shader, GLenum pname, GLint *params) AliasExport("glshim_glGetObjectParameteriv");
void glShaderSourceARB(GLuint shader, GLsizei count, const GLchar **string, const GLint *length) AliasExport("glshim_glShaderSource");
#endif
void glClearDepth(GLdouble depth) __attribute__((alias("glshim_glClearDepth")));
void glClipPlane(GLenum plane, const GLdouble *equation) __attribute__((alias("glshim_glClipPlane")));
void glDepthRange(GLdouble nearVal, GLdouble farVal) __attribute__((alias("glshim_glDepthRange")));
void glFogi(GLenum pname, GLint param) __attribute__((alias("glshim_glFogi")));
void glFogiv(GLenum pname, GLint *params) __attribute__((alias("glshim_glFogiv")));
void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) __attribute__((alias("glshim_glFrustum")));
void glGetDoublev(GLenum pname, GLdouble *params) __attribute__((alias("glshim_glGetDoublev")));
void glLighti(GLenum light, GLenum pname, GLint param) __attribute__((alias("glshim_glLighti")));
void glLightiv(GLenum light, GLenum pname, GLint *iparams) __attribute__((alias("glshim_glLightiv")));
void glLightModeli(GLenum pname, GLint param) __attribute__((alias("glshim_glLightModeli")));
void glLightModeliv(GLenum pname, GLint *iparams) __attribute__((alias("glshim_glLightModeliv")));
void glMateriali(GLenum face, GLenum pname, GLint param) __attribute__((alias("glshim_glMateriali")));
void glMaterialiv(GLenum face, GLenum pname, GLint *param) __attribute__((alias("glshim_glMaterialiv")));
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) __attribute__((alias("glshim_glOrtho")));
void glGetMaterialiv(GLenum face, GLenum pname, GLint * params) __attribute__((alias("glshim_glGetMaterialiv")));
void glGetLightiv(GLenum light, GLenum pname, GLint * params) __attribute__((alias("glshim_glGetLightiv")));
void glGetClipPlane(GLenum plane, GLdouble *equation) __attribute__((alias("glshim_glGetClipPlane")));
void glDrawRangeElements(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void *indices) __attribute__((alias("glshim_glDrawRangeElements")));
void glColor3f(GLfloat r, GLfloat g, GLfloat b) __attribute__((alias("glshim_glColor3f")));
void glColor3fv(GLfloat *c) __attribute__((alias("glshim_glColor3fv")));
void glColor4fv(GLfloat *c) __attribute__((alias("glshim_glColor4fv")));
void glIndexfv(const GLfloat *c) __attribute__((alias("glshim_glIndexfv")));
void glSecondaryColor3fv(const GLfloat *v) __attribute__((alias("glshim_glSecondaryColor3fv")));
void glRasterPos2f(GLfloat x, GLfloat y) __attribute__((alias("glshim_glRasterPos2f")));
void glRasterPos2fv(const GLfloat *v) __attribute__((alias("glshim_glRasterPos2fv")));
void glRasterPos3fv(const GLfloat *v) __attribute__((alias("glshim_glRasterPos3fv")));
void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) __attribute__((alias("glshim_glRasterPos4f")));
void glRasterPos4fv(const GLfloat *v) __attribute__((alias("glshim_glRasterPos4fv")));
void glWindowPos2f(GLfloat x, GLfloat y) __attribute__((alias("glshim_glWindowPos2f")));
void glWindowPos2fv(const GLfloat *v) __attribute__((alias("glshim_glWindowPos2fv")));
void glWindowPos3fv(const GLfloat *v) __attribute__((alias("glshim_glWindowPos3fv")));
void glPixelStoref(GLenum pname, GLfloat param) __attribute__((alias("glshim_glPixelStoref")));
void glGetTexGendv(GLenum coord,GLenum pname,GLdouble *params) __attribute__((alias("glshim_glGetTexGendv")));
void glGetTexGeniv(GLenum coord,GLenum pname,GLint *params) __attribute__((alias("glshim_glGetTexGeniv")));
void glPixelTransferi(GLenum pname, GLint param) __attribute__((alias("glshim_glPixelTransferi")));
void glEvalCoord1d(GLdouble u) __attribute__((alias("glshim_glEvalCoord1d")));
void glEvalCoord1dv(GLdouble *v) __attribute__((alias("glshim_glEvalCoord1dv")));
void glEvalCoord1fv(GLfloat *v) __attribute__((alias("glshim_glEvalCoord1fv")));
void glEvalCoord2d(GLdouble u, GLdouble v) __attribute__((alias("glshim_glEvalCoord2d")));
void glEvalCoord2dv(GLdouble *v) __attribute__((alias("glshim_glEvalCoord2dv")));
void glEvalCoord2fv(GLfloat *v) __attribute__((alias("glshim_glEvalCoord2fv")));
void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) __attribute__((alias("glshim_glMapGrid1d")));
void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) __attribute__((alias("glshim_glMapGrid2d")));
void glLoadMatrixd(const GLdouble *m) __attribute__((alias("glshim_glLoadMatrixd")));
void glMultMatrixd(const GLdouble *m) __attribute__((alias("glshim_glMultMatrixd")));
void glNormal3fv(GLfloat *v) __attribute__((alias("glshim_glNormal3fv")));
void glClearDepth(GLdouble depth) AliasExport("glshim_glClearDepth");
void glClipPlane(GLenum plane, const GLdouble *equation) AliasExport("glshim_glClipPlane");
void glDepthRange(GLdouble nearVal, GLdouble farVal) AliasExport("glshim_glDepthRange");
void glFogi(GLenum pname, GLint param) AliasExport("glshim_glFogi");
void glFogiv(GLenum pname, GLint *params) AliasExport("glshim_glFogiv");
void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) AliasExport("glshim_glFrustum");
void glGetDoublev(GLenum pname, GLdouble *params) AliasExport("glshim_glGetDoublev");
void glLighti(GLenum light, GLenum pname, GLint param) AliasExport("glshim_glLighti");
void glLightiv(GLenum light, GLenum pname, GLint *iparams) AliasExport("glshim_glLightiv");
void glLightModeli(GLenum pname, GLint param) AliasExport("glshim_glLightModeli");
void glLightModeliv(GLenum pname, GLint *iparams) AliasExport("glshim_glLightModeliv");
void glMateriali(GLenum face, GLenum pname, GLint param) AliasExport("glshim_glMateriali");
void glMaterialiv(GLenum face, GLenum pname, GLint *param) AliasExport("glshim_glMaterialiv");
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) AliasExport("glshim_glOrtho");
void glGetMaterialiv(GLenum face, GLenum pname, GLint * params) AliasExport("glshim_glGetMaterialiv");
void glGetLightiv(GLenum light, GLenum pname, GLint * params) AliasExport("glshim_glGetLightiv");
void glGetClipPlane(GLenum plane, GLdouble *equation) AliasExport("glshim_glGetClipPlane");
void glDrawRangeElements(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void *indices) AliasExport("glshim_glDrawRangeElements");
void glColor3f(GLfloat r, GLfloat g, GLfloat b) AliasExport("glshim_glColor3f");
void glColor3fv(GLfloat *c) AliasExport("glshim_glColor3fv");
void glColor4fv(GLfloat *c) AliasExport("glshim_glColor4fv");
void glIndexfv(const GLfloat *c) AliasExport("glshim_glIndexfv");
void glSecondaryColor3fv(const GLfloat *v) AliasExport("glshim_glSecondaryColor3fv");
void glRasterPos2f(GLfloat x, GLfloat y) AliasExport("glshim_glRasterPos2f");
void glRasterPos2fv(const GLfloat *v) AliasExport("glshim_glRasterPos2fv");
void glRasterPos3fv(const GLfloat *v) AliasExport("glshim_glRasterPos3fv");
void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) AliasExport("glshim_glRasterPos4f");
void glRasterPos4fv(const GLfloat *v) AliasExport("glshim_glRasterPos4fv");
void glWindowPos2f(GLfloat x, GLfloat y) AliasExport("glshim_glWindowPos2f");
void glWindowPos2fv(const GLfloat *v) AliasExport("glshim_glWindowPos2fv");
void glWindowPos3fv(const GLfloat *v) AliasExport("glshim_glWindowPos3fv");
void glPixelStoref(GLenum pname, GLfloat param) AliasExport("glshim_glPixelStoref");
void glGetTexGendv(GLenum coord,GLenum pname,GLdouble *params) AliasExport("glshim_glGetTexGendv");
void glGetTexGeniv(GLenum coord,GLenum pname,GLint *params) AliasExport("glshim_glGetTexGeniv");
void glPixelTransferi(GLenum pname, GLint param) AliasExport("glshim_glPixelTransferi");
void glEvalCoord1d(GLdouble u) AliasExport("glshim_glEvalCoord1d");
void glEvalCoord1dv(GLdouble *v) AliasExport("glshim_glEvalCoord1dv");
void glEvalCoord1fv(GLfloat *v) AliasExport("glshim_glEvalCoord1fv");
void glEvalCoord2d(GLdouble u, GLdouble v) AliasExport("glshim_glEvalCoord2d");
void glEvalCoord2dv(GLdouble *v) AliasExport("glshim_glEvalCoord2dv");
void glEvalCoord2fv(GLfloat *v) AliasExport("glshim_glEvalCoord2fv");
void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) AliasExport("glshim_glMapGrid1d");
void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) AliasExport("glshim_glMapGrid2d");
void glLoadMatrixd(const GLdouble *m) AliasExport("glshim_glLoadMatrixd");
void glMultMatrixd(const GLdouble *m) AliasExport("glshim_glMultMatrixd");
void glNormal3fv(GLfloat *v) AliasExport("glshim_glNormal3fv");
// rect
#define GL_RECT(suffix, type) \
void glRect##suffix(type x1, type y1, type x2, type y2) __attribute__((alias("glshim_glRect" #suffix))); \
void glRect##suffix##v(const type *v)__attribute__((alias("glshim_glRect" #suffix "v")));
void glRect##suffix(type x1, type y1, type x2, type y2) AliasExport("glshim_glRect" #suffix); \
void glRect##suffix##v(const type *v)AliasExport("glshim_glRect" #suffix "v");
GL_RECT(d, GLdouble)
GL_RECT(f, GLfloat)
@@ -791,87 +791,87 @@ GL_RECT(i, GLint)
GL_RECT(s, GLshort)
#undef GL_RECT
void glTexCoord1f(GLfloat s) __attribute__((alias("glshim_glTexCoord1f")));
void glTexCoord1fv(GLfloat *t) __attribute__((alias("glshim_glTexCoord1fv")));
void glTexCoord2f(GLfloat s, GLfloat t) __attribute__((alias("glshim_glTexCoord2f")));
void glTexCoord2fv(GLfloat *t) __attribute__((alias("glshim_glTexCoord2fv")));
void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) __attribute__((alias("glshim_glTexCoord3f")));
void glTexCoord3fv(GLfloat *t) __attribute__((alias("glshim_glTexCoord3fv")));
void glTexCoord4fv(GLfloat *t) __attribute__((alias("glshim_glTexCoord4fv")));
void glMultiTexCoord1f(GLenum target, GLfloat s) __attribute__((alias("glshim_glMultiTexCoord1f")));
void glMultiTexCoord1fv(GLenum target, GLfloat *t) __attribute__((alias("glshim_glMultiTexCoord1fv")));
void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) __attribute__((alias("glshim_glMultiTexCoord2f")));
void glMultiTexCoord2fv(GLenum target, GLfloat *t) __attribute__((alias("glshim_glMultiTexCoord2fv")));
void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) __attribute__((alias("glshim_glMultiTexCoord3f")));
void glMultiTexCoord3fv(GLenum target, GLfloat *t) __attribute__((alias("glshim_glMultiTexCoord3fv")));
void glMultiTexCoord4fv(GLenum target, GLfloat *t) __attribute__((alias("glshim_glMultiTexCoord4fv")));
void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) __attribute__((alias("glshim_glGetTexLevelParameterfv")));
void glTexGend(GLenum coord, GLenum pname, GLdouble param) __attribute__((alias("glshim_glTexGend")));
void glTexGenf(GLenum coord, GLenum pname, GLfloat param) __attribute__((alias("glshim_glTexGenf")));
void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) __attribute__((alias("glshim_glTexGendv")));
void glTexGeniv(GLenum coord, GLenum pname, const GLint *params) __attribute__((alias("glshim_glTexGeniv")));
void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) __attribute__((alias("glshim_glRotated")));
void glScaled(GLdouble x, GLdouble y, GLdouble z) __attribute__((alias("glshim_glScaled")));
void glTranslated(GLdouble x, GLdouble y, GLdouble z) __attribute__((alias("glshim_glTranslated")));
void glVertex2f(GLfloat x, GLfloat y) __attribute__((alias("glshim_glVertex2f")));
void glVertex2fv(GLfloat *v) __attribute__((alias("glshim_glVertex2fv")));
void glVertex3f(GLfloat r, GLfloat g, GLfloat b) __attribute__((alias("glshim_glVertex3f")));
void glVertex3fv(GLfloat *v) __attribute__((alias("glshim_glVertex3fv")));
void glVertex4fv(GLfloat *v) __attribute__((alias("glshim_glVertex4fv")));
void glTexCoord1f(GLfloat s) AliasExport("glshim_glTexCoord1f");
void glTexCoord1fv(GLfloat *t) AliasExport("glshim_glTexCoord1fv");
void glTexCoord2f(GLfloat s, GLfloat t) AliasExport("glshim_glTexCoord2f");
void glTexCoord2fv(GLfloat *t) AliasExport("glshim_glTexCoord2fv");
void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) AliasExport("glshim_glTexCoord3f");
void glTexCoord3fv(GLfloat *t) AliasExport("glshim_glTexCoord3fv");
void glTexCoord4fv(GLfloat *t) AliasExport("glshim_glTexCoord4fv");
void glMultiTexCoord1f(GLenum target, GLfloat s) AliasExport("glshim_glMultiTexCoord1f");
void glMultiTexCoord1fv(GLenum target, GLfloat *t) AliasExport("glshim_glMultiTexCoord1fv");
void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) AliasExport("glshim_glMultiTexCoord2f");
void glMultiTexCoord2fv(GLenum target, GLfloat *t) AliasExport("glshim_glMultiTexCoord2fv");
void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) AliasExport("glshim_glMultiTexCoord3f");
void glMultiTexCoord3fv(GLenum target, GLfloat *t) AliasExport("glshim_glMultiTexCoord3fv");
void glMultiTexCoord4fv(GLenum target, GLfloat *t) AliasExport("glshim_glMultiTexCoord4fv");
void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) AliasExport("glshim_glGetTexLevelParameterfv");
void glTexGend(GLenum coord, GLenum pname, GLdouble param) AliasExport("glshim_glTexGend");
void glTexGenf(GLenum coord, GLenum pname, GLfloat param) AliasExport("glshim_glTexGenf");
void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) AliasExport("glshim_glTexGendv");
void glTexGeniv(GLenum coord, GLenum pname, const GLint *params) AliasExport("glshim_glTexGeniv");
void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) AliasExport("glshim_glRotated");
void glScaled(GLdouble x, GLdouble y, GLdouble z) AliasExport("glshim_glScaled");
void glTranslated(GLdouble x, GLdouble y, GLdouble z) AliasExport("glshim_glTranslated");
void glVertex2f(GLfloat x, GLfloat y) AliasExport("glshim_glVertex2f");
void glVertex2fv(GLfloat *v) AliasExport("glshim_glVertex2fv");
void glVertex3f(GLfloat r, GLfloat g, GLfloat b) AliasExport("glshim_glVertex3f");
void glVertex3fv(GLfloat *v) AliasExport("glshim_glVertex3fv");
void glVertex4fv(GLfloat *v) AliasExport("glshim_glVertex4fv");
// basic thunking
#define THUNK(suffix, type) \
void glColor3##suffix##v(const type *v) __attribute__((alias("glshim_glColor3"#suffix "v"))); \
void glColor3##suffix(type r, type g, type b) __attribute__((alias("glshim_glColor3"#suffix))); \
void glColor4##suffix##v(const type *v) __attribute__((alias("glshim_glColor4"#suffix "v"))); \
void glColor4##suffix(type r, type g, type b, type a) __attribute__((alias("glshim_glColor4"#suffix))); \
void glSecondaryColor3##suffix##v(const type *v) __attribute__((alias("glshim_glSecondaryColor3"#suffix "v"))); \
void glSecondaryColor3##suffix(type r, type g, type b) __attribute__((alias("glshim_glSecondaryColor3"#suffix))); \
void glIndex##suffix##v(const type *c) __attribute__((alias("glshim_glIndex"#suffix"v"))); \
void glIndex##suffix(type c) __attribute__((alias("glshim_glIndex"#suffix))); \
void glNormal3##suffix##v(const type *v) __attribute__((alias("glshim_glNormal3"#suffix"v"))); \
void glNormal3##suffix(type x, type y, type z) __attribute__((alias("glshim_glNormal3"#suffix))); \
void glRasterPos2##suffix##v(type *v) __attribute__((alias("glshim_glRasterPos2"#suffix"v"))); \
void glRasterPos2##suffix(type x, type y) __attribute__((alias("glshim_glRasterPos2"#suffix))); \
void glRasterPos3##suffix##v(type *v) __attribute__((alias("glshim_glRasterPos3"#suffix"v"))); \
void glRasterPos3##suffix(type x, type y, type z) __attribute__((alias("glshim_glRasterPos3"#suffix))); \
void glRasterPos4##suffix##v(type *v) __attribute__((alias("glshim_glRasterPos4"#suffix"v"))); \
void glRasterPos4##suffix(type x, type y, type z, type w)__attribute__((alias("glshim_glRasterPos4"#suffix))); \
void glWindowPos2##suffix##v(type *v) __attribute__((alias("glshim_glWindowPos2"#suffix"v"))); \
void glWindowPos2##suffix(type x, type y) __attribute__((alias("glshim_glWindowPos2"#suffix))); \
void glWindowPos3##suffix##v(type *v) __attribute__((alias("glshim_glWindowPos3"#suffix"v"))); \
void glWindowPos3##suffix(type x, type y, type z) __attribute__((alias("glshim_glWindowPos3"#suffix))); \
void glVertex2##suffix##v(type *v) __attribute__((alias("glshim_glVertex2"#suffix"v"))); \
void glVertex2##suffix(type x, type y) __attribute__((alias("glshim_glVertex2"#suffix))); \
void glVertex3##suffix##v(type *v) __attribute__((alias("glshim_glVertex3"#suffix"v"))); \
void glVertex3##suffix(type x, type y, type z) __attribute__((alias("glshim_glVertex3"#suffix))); \
void glVertex4##suffix(type x, type y, type z, type w) __attribute__((alias("glshim_glVertex4"#suffix))); \
void glVertex4##suffix##v(type *v) __attribute__((alias("glshim_glVertex4"#suffix"v"))); \
void glTexCoord1##suffix(type s) __attribute__((alias("glshim_glTexCoord1"#suffix))); \
void glTexCoord1##suffix##v(type *t) __attribute__((alias("glshim_glTexCoord1"#suffix"v"))); \
void glTexCoord2##suffix(type s, type t) __attribute__((alias("glshim_glTexCoord2"#suffix))); \
void glTexCoord2##suffix##v(type *t) __attribute__((alias("glshim_glTexCoord2"#suffix"v"))); \
void glTexCoord3##suffix(type s, type t, type r) __attribute__((alias("glshim_glTexCoord3"#suffix))); \
void glTexCoord3##suffix##v(type *t) __attribute__((alias("glshim_glTexCoord3"#suffix"v"))); \
void glTexCoord4##suffix(type s, type t, type r, type q)__attribute__((alias("glshim_glTexCoord4"#suffix))); \
void glTexCoord4##suffix##v(type *t) __attribute__((alias("glshim_glTexCoord4"#suffix"v"))); \
void glMultiTexCoord1##suffix(GLenum target, type s) __attribute__((alias("glshim_glMultiTexCoord1"#suffix))); \
void glMultiTexCoord1##suffix##v(GLenum target, type *t)__attribute__((alias("glshim_glMultiTexCoord1"#suffix"v"))); \
void glMultiTexCoord2##suffix(GLenum target, type s, type t) __attribute__((alias("glshim_glMultiTexCoord2"#suffix))); \
void glMultiTexCoord2##suffix##v(GLenum target, type *t) __attribute__((alias("glshim_glMultiTexCoord2"#suffix"v"))); \
void glMultiTexCoord3##suffix(GLenum target, type s, type t, type r)__attribute__((alias("glshim_glMultiTexCoord3"#suffix))); \
void glMultiTexCoord3##suffix##v(GLenum target, type *t) __attribute__((alias("glshim_glMultiTexCoord3"#suffix"v"))); \
void glMultiTexCoord4##suffix(GLenum target, type s, type t, type r, type q) __attribute__((alias("glshim_glMultiTexCoord4"#suffix))); \
void glMultiTexCoord4##suffix##v(GLenum target, type *t) __attribute__((alias("glshim_glMultiTexCoord4"#suffix"v"))); \
void glMultiTexCoord1##suffix##ARB(GLenum target, type s) __attribute__((alias("glshim_glMultiTexCoord1"#suffix))); \
void glMultiTexCoord1##suffix##vARB(GLenum target, type *t) __attribute__((alias("glshim_glMultiTexCoord1"#suffix"v"))); \
void glMultiTexCoord2##suffix##ARB(GLenum target, type s, type t) __attribute__((alias("glshim_glMultiTexCoord2"#suffix))); \
void glMultiTexCoord2##suffix##vARB(GLenum target, type *t) __attribute__((alias("glshim_glMultiTexCoord2"#suffix"v"))); \
void glMultiTexCoord3##suffix##ARB(GLenum target, type s, type t, type r) __attribute__((alias("glshim_glMultiTexCoord3"#suffix))); \
void glMultiTexCoord3##suffix##vARB(GLenum target, type *t) __attribute__((alias("glshim_glMultiTexCoord3"#suffix"v"))); \
void glMultiTexCoord4##suffix##ARB(GLenum target, type s, type t, type r, type q) __attribute__((alias("glshim_glMultiTexCoord4"#suffix))); \
void glMultiTexCoord4##suffix##vARB(GLenum target, type *t)__attribute__((alias("glshim_glMultiTexCoord4"#suffix"v")));
void glColor3##suffix##v(const type *v) AliasExport("glshim_glColor3"#suffix "v"); \
void glColor3##suffix(type r, type g, type b) AliasExport("glshim_glColor3"#suffix); \
void glColor4##suffix##v(const type *v) AliasExport("glshim_glColor4"#suffix "v"); \
void glColor4##suffix(type r, type g, type b, type a) AliasExport("glshim_glColor4"#suffix); \
void glSecondaryColor3##suffix##v(const type *v) AliasExport("glshim_glSecondaryColor3"#suffix "v"); \
void glSecondaryColor3##suffix(type r, type g, type b) AliasExport("glshim_glSecondaryColor3"#suffix); \
void glIndex##suffix##v(const type *c) AliasExport("glshim_glIndex"#suffix"v"); \
void glIndex##suffix(type c) AliasExport("glshim_glIndex"#suffix); \
void glNormal3##suffix##v(const type *v) AliasExport("glshim_glNormal3"#suffix"v"); \
void glNormal3##suffix(type x, type y, type z) AliasExport("glshim_glNormal3"#suffix); \
void glRasterPos2##suffix##v(type *v) AliasExport("glshim_glRasterPos2"#suffix"v"); \
void glRasterPos2##suffix(type x, type y) AliasExport("glshim_glRasterPos2"#suffix); \
void glRasterPos3##suffix##v(type *v) AliasExport("glshim_glRasterPos3"#suffix"v"); \
void glRasterPos3##suffix(type x, type y, type z) AliasExport("glshim_glRasterPos3"#suffix); \
void glRasterPos4##suffix##v(type *v) AliasExport("glshim_glRasterPos4"#suffix"v"); \
void glRasterPos4##suffix(type x, type y, type z, type w)AliasExport("glshim_glRasterPos4"#suffix); \
void glWindowPos2##suffix##v(type *v) AliasExport("glshim_glWindowPos2"#suffix"v"); \
void glWindowPos2##suffix(type x, type y) AliasExport("glshim_glWindowPos2"#suffix); \
void glWindowPos3##suffix##v(type *v) AliasExport("glshim_glWindowPos3"#suffix"v"); \
void glWindowPos3##suffix(type x, type y, type z) AliasExport("glshim_glWindowPos3"#suffix); \
void glVertex2##suffix##v(type *v) AliasExport("glshim_glVertex2"#suffix"v"); \
void glVertex2##suffix(type x, type y) AliasExport("glshim_glVertex2"#suffix); \
void glVertex3##suffix##v(type *v) AliasExport("glshim_glVertex3"#suffix"v"); \
void glVertex3##suffix(type x, type y, type z) AliasExport("glshim_glVertex3"#suffix); \
void glVertex4##suffix(type x, type y, type z, type w) AliasExport("glshim_glVertex4"#suffix); \
void glVertex4##suffix##v(type *v) AliasExport("glshim_glVertex4"#suffix"v"); \
void glTexCoord1##suffix(type s) AliasExport("glshim_glTexCoord1"#suffix); \
void glTexCoord1##suffix##v(type *t) AliasExport("glshim_glTexCoord1"#suffix"v"); \
void glTexCoord2##suffix(type s, type t) AliasExport("glshim_glTexCoord2"#suffix); \
void glTexCoord2##suffix##v(type *t) AliasExport("glshim_glTexCoord2"#suffix"v"); \
void glTexCoord3##suffix(type s, type t, type r) AliasExport("glshim_glTexCoord3"#suffix); \
void glTexCoord3##suffix##v(type *t) AliasExport("glshim_glTexCoord3"#suffix"v"); \
void glTexCoord4##suffix(type s, type t, type r, type q)AliasExport("glshim_glTexCoord4"#suffix); \
void glTexCoord4##suffix##v(type *t) AliasExport("glshim_glTexCoord4"#suffix"v"); \
void glMultiTexCoord1##suffix(GLenum target, type s) AliasExport("glshim_glMultiTexCoord1"#suffix); \
void glMultiTexCoord1##suffix##v(GLenum target, type *t)AliasExport("glshim_glMultiTexCoord1"#suffix"v"); \
void glMultiTexCoord2##suffix(GLenum target, type s, type t) AliasExport("glshim_glMultiTexCoord2"#suffix); \
void glMultiTexCoord2##suffix##v(GLenum target, type *t) AliasExport("glshim_glMultiTexCoord2"#suffix"v"); \
void glMultiTexCoord3##suffix(GLenum target, type s, type t, type r)AliasExport("glshim_glMultiTexCoord3"#suffix); \
void glMultiTexCoord3##suffix##v(GLenum target, type *t) AliasExport("glshim_glMultiTexCoord3"#suffix"v"); \
void glMultiTexCoord4##suffix(GLenum target, type s, type t, type r, type q) AliasExport("glshim_glMultiTexCoord4"#suffix); \
void glMultiTexCoord4##suffix##v(GLenum target, type *t) AliasExport("glshim_glMultiTexCoord4"#suffix"v"); \
void glMultiTexCoord1##suffix##ARB(GLenum target, type s) AliasExport("glshim_glMultiTexCoord1"#suffix); \
void glMultiTexCoord1##suffix##vARB(GLenum target, type *t) AliasExport("glshim_glMultiTexCoord1"#suffix"v"); \
void glMultiTexCoord2##suffix##ARB(GLenum target, type s, type t) AliasExport("glshim_glMultiTexCoord2"#suffix); \
void glMultiTexCoord2##suffix##vARB(GLenum target, type *t) AliasExport("glshim_glMultiTexCoord2"#suffix"v"); \
void glMultiTexCoord3##suffix##ARB(GLenum target, type s, type t, type r) AliasExport("glshim_glMultiTexCoord3"#suffix); \
void glMultiTexCoord3##suffix##vARB(GLenum target, type *t) AliasExport("glshim_glMultiTexCoord3"#suffix"v"); \
void glMultiTexCoord4##suffix##ARB(GLenum target, type s, type t, type r, type q) AliasExport("glshim_glMultiTexCoord4"#suffix); \
void glMultiTexCoord4##suffix##vARB(GLenum target, type *t)AliasExport("glshim_glMultiTexCoord4"#suffix"v");
THUNK(b, GLbyte)
THUNK(d, GLdouble)
@@ -890,9 +890,9 @@ THUNK(Integer, GLint)
THUNK(Float, GLfloat)
#undef THUNK
void glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) __attribute__((alias("glshim_glMultiTexCoord2f")));
void glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) __attribute__((alias("glshim_glMultiTexCoord3f")));
void glMultiTexCoord2fvARB(GLenum target, GLfloat *t) __attribute__((alias("glshim_glMultiTexCoord2fv")));
void glMultiTexCoord3fvARB(GLenum target, GLfloat *t) __attribute__((alias("glshim_glMultiTexCoord3fv")));
void glMultiTexCoord4fvARB(GLenum target, GLfloat *t) __attribute__((alias("glshim_glMultiTexCoord4fv")));
void glDrawRangeElementsEXT(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void *indices) __attribute__((alias("glshim_glDrawRangeElements")));
void glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) AliasExport("glshim_glMultiTexCoord2f");
void glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) AliasExport("glshim_glMultiTexCoord3f");
void glMultiTexCoord2fvARB(GLenum target, GLfloat *t) AliasExport("glshim_glMultiTexCoord2fv");
void glMultiTexCoord3fvARB(GLenum target, GLfloat *t) AliasExport("glshim_glMultiTexCoord3fv");
void glMultiTexCoord4fvARB(GLenum target, GLfloat *t) AliasExport("glshim_glMultiTexCoord4fv");
void glDrawRangeElementsEXT(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void *indices) AliasExport("glshim_glDrawRangeElements");

290
project/jni/glshim/src/gl/wrap/gles.c
View File

File diff suppressed because it is too large Load Diff

184
project/jni/glshim/src/gl/wrap/gles.h
View File

@@ -98,6 +98,8 @@ enum FORMAT {
FORMAT_void_GLenum_GLenum_GLenum_GLuint,
FORMAT_void_GLenum_GLenum_GLenum_GLuint_GLint,
FORMAT_void_GLenum_GLenum_GLenum_GLint___GENPT__,
FORMAT_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei,
FORMAT_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei,
FORMAT_void_GLenum_GLenum_GLsizei_GLsizei,
};
@@ -1332,6 +1334,39 @@ typedef struct {
int func;
ARGS_void_GLenum_GLenum_GLenum_GLint___GENPT__ args;
} INDEXED_void_GLenum_GLenum_GLenum_GLint___GENPT__;
typedef void (*FUNC_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount);
typedef struct {
GLenum a1;
GLint * a2;
GLsizei * a3;
GLsizei a4;
} ARGS_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei;
typedef struct {
int format;
FUNC_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei func;
ARGS_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei args;
} PACKED_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei;
typedef struct {
int func;
ARGS_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei args;
} INDEXED_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei;
typedef void (*FUNC_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei)(GLenum mode, GLsizei * count, GLenum type, const void * const * indices, GLsizei primcount);
typedef struct {
GLenum a1;
GLsizei * a2;
GLenum a3;
void * * a4;
GLsizei a5;
} ARGS_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei;
typedef struct {
int format;
FUNC_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei func;
ARGS_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei args;
} PACKED_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei;
typedef struct {
int func;
ARGS_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei args;
} INDEXED_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei;
typedef void (*FUNC_void_GLenum_GLenum_GLsizei_GLsizei)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
typedef struct {
GLenum a1;
@@ -2158,371 +2193,385 @@ void glIndexedCall(const indexed_call_t *packed, void *ret_v);
#define glMultMatrixx_PACKED PACKED_void_const_GLfixed___GENPT__
#define glMultMatrixx_INDEXED INDEXED_void_const_GLfixed___GENPT__
#define glMultMatrixx_FORMAT FORMAT_void_const_GLfixed___GENPT__
#define glMultiTexCoord4f_INDEX 116
#define glMultiDrawArrays_INDEX 116
#define glMultiDrawArrays_RETURN void
#define glMultiDrawArrays_ARG_NAMES mode, first, count, primcount
#define glMultiDrawArrays_ARG_EXPAND GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount
#define glMultiDrawArrays_PACKED PACKED_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei
#define glMultiDrawArrays_INDEXED INDEXED_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei
#define glMultiDrawArrays_FORMAT FORMAT_void_GLenum_const_GLint___GENPT___const_GLsizei___GENPT___GLsizei
#define glMultiDrawElements_INDEX 117
#define glMultiDrawElements_RETURN void
#define glMultiDrawElements_ARG_NAMES mode, count, type, indices, primcount
#define glMultiDrawElements_ARG_EXPAND GLenum mode, GLsizei * count, GLenum type, const void * const * indices, GLsizei primcount
#define glMultiDrawElements_PACKED PACKED_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei
#define glMultiDrawElements_INDEXED INDEXED_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei
#define glMultiDrawElements_FORMAT FORMAT_void_GLenum_GLsizei___GENPT___GLenum_const_void___GENPT___const___GENPT___GLsizei
#define glMultiTexCoord4f_INDEX 118
#define glMultiTexCoord4f_RETURN void
#define glMultiTexCoord4f_ARG_NAMES target, s, t, r, q
#define glMultiTexCoord4f_ARG_EXPAND GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q
#define glMultiTexCoord4f_PACKED PACKED_void_GLenum_GLfloat_GLfloat_GLfloat_GLfloat
#define glMultiTexCoord4f_INDEXED INDEXED_void_GLenum_GLfloat_GLfloat_GLfloat_GLfloat
#define glMultiTexCoord4f_FORMAT FORMAT_void_GLenum_GLfloat_GLfloat_GLfloat_GLfloat
#define glMultiTexCoord4x_INDEX 117
#define glMultiTexCoord4x_INDEX 119
#define glMultiTexCoord4x_RETURN void
#define glMultiTexCoord4x_ARG_NAMES target, s, t, r, q
#define glMultiTexCoord4x_ARG_EXPAND GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q
#define glMultiTexCoord4x_PACKED PACKED_void_GLenum_GLfixed_GLfixed_GLfixed_GLfixed
#define glMultiTexCoord4x_INDEXED INDEXED_void_GLenum_GLfixed_GLfixed_GLfixed_GLfixed
#define glMultiTexCoord4x_FORMAT FORMAT_void_GLenum_GLfixed_GLfixed_GLfixed_GLfixed
#define glNormal3f_INDEX 118
#define glNormal3f_INDEX 120
#define glNormal3f_RETURN void
#define glNormal3f_ARG_NAMES nx, ny, nz
#define glNormal3f_ARG_EXPAND GLfloat nx, GLfloat ny, GLfloat nz
#define glNormal3f_PACKED PACKED_void_GLfloat_GLfloat_GLfloat
#define glNormal3f_INDEXED INDEXED_void_GLfloat_GLfloat_GLfloat
#define glNormal3f_FORMAT FORMAT_void_GLfloat_GLfloat_GLfloat
#define glNormal3x_INDEX 119
#define glNormal3x_INDEX 121
#define glNormal3x_RETURN void
#define glNormal3x_ARG_NAMES nx, ny, nz
#define glNormal3x_ARG_EXPAND GLfixed nx, GLfixed ny, GLfixed nz
#define glNormal3x_PACKED PACKED_void_GLfixed_GLfixed_GLfixed
#define glNormal3x_INDEXED INDEXED_void_GLfixed_GLfixed_GLfixed
#define glNormal3x_FORMAT FORMAT_void_GLfixed_GLfixed_GLfixed
#define glNormalPointer_INDEX 120
#define glNormalPointer_INDEX 122
#define glNormalPointer_RETURN void
#define glNormalPointer_ARG_NAMES type, stride, pointer
#define glNormalPointer_ARG_EXPAND GLenum type, GLsizei stride, const GLvoid * pointer
#define glNormalPointer_PACKED PACKED_void_GLenum_GLsizei_const_GLvoid___GENPT__
#define glNormalPointer_INDEXED INDEXED_void_GLenum_GLsizei_const_GLvoid___GENPT__
#define glNormalPointer_FORMAT FORMAT_void_GLenum_GLsizei_const_GLvoid___GENPT__
#define glOrthof_INDEX 121
#define glOrthof_INDEX 123
#define glOrthof_RETURN void
#define glOrthof_ARG_NAMES left, right, bottom, top, near, far
#define glOrthof_ARG_EXPAND GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near, GLfloat far
#define glOrthof_PACKED PACKED_void_GLfloat_GLfloat_GLfloat_GLfloat_GLfloat_GLfloat
#define glOrthof_INDEXED INDEXED_void_GLfloat_GLfloat_GLfloat_GLfloat_GLfloat_GLfloat
#define glOrthof_FORMAT FORMAT_void_GLfloat_GLfloat_GLfloat_GLfloat_GLfloat_GLfloat
#define glOrthox_INDEX 122
#define glOrthox_INDEX 124
#define glOrthox_RETURN void
#define glOrthox_ARG_NAMES left, right, bottom, top, near, far
#define glOrthox_ARG_EXPAND GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed near, GLfixed far
#define glOrthox_PACKED PACKED_void_GLfixed_GLfixed_GLfixed_GLfixed_GLfixed_GLfixed
#define glOrthox_INDEXED INDEXED_void_GLfixed_GLfixed_GLfixed_GLfixed_GLfixed_GLfixed
#define glOrthox_FORMAT FORMAT_void_GLfixed_GLfixed_GLfixed_GLfixed_GLfixed_GLfixed
#define glPixelStorei_INDEX 123
#define glPixelStorei_INDEX 125
#define glPixelStorei_RETURN void
#define glPixelStorei_ARG_NAMES pname, param
#define glPixelStorei_ARG_EXPAND GLenum pname, GLint param
#define glPixelStorei_PACKED PACKED_void_GLenum_GLint
#define glPixelStorei_INDEXED INDEXED_void_GLenum_GLint
#define glPixelStorei_FORMAT FORMAT_void_GLenum_GLint
#define glPointParameterf_INDEX 124
#define glPointParameterf_INDEX 126
#define glPointParameterf_RETURN void
#define glPointParameterf_ARG_NAMES pname, param
#define glPointParameterf_ARG_EXPAND GLenum pname, GLfloat param
#define glPointParameterf_PACKED PACKED_void_GLenum_GLfloat
#define glPointParameterf_INDEXED INDEXED_void_GLenum_GLfloat
#define glPointParameterf_FORMAT FORMAT_void_GLenum_GLfloat
#define glPointParameterfv_INDEX 125
#define glPointParameterfv_INDEX 127
#define glPointParameterfv_RETURN void
#define glPointParameterfv_ARG_NAMES pname, params
#define glPointParameterfv_ARG_EXPAND GLenum pname, const GLfloat * params
#define glPointParameterfv_PACKED PACKED_void_GLenum_const_GLfloat___GENPT__
#define glPointParameterfv_INDEXED INDEXED_void_GLenum_const_GLfloat___GENPT__
#define glPointParameterfv_FORMAT FORMAT_void_GLenum_const_GLfloat___GENPT__
#define glPointParameterx_INDEX 126
#define glPointParameterx_INDEX 128
#define glPointParameterx_RETURN void
#define glPointParameterx_ARG_NAMES pname, param
#define glPointParameterx_ARG_EXPAND GLenum pname, GLfixed param
#define glPointParameterx_PACKED PACKED_void_GLenum_GLfixed
#define glPointParameterx_INDEXED INDEXED_void_GLenum_GLfixed
#define glPointParameterx_FORMAT FORMAT_void_GLenum_GLfixed
#define glPointParameterxv_INDEX 127
#define glPointParameterxv_INDEX 129
#define glPointParameterxv_RETURN void
#define glPointParameterxv_ARG_NAMES pname, params
#define glPointParameterxv_ARG_EXPAND GLenum pname, const GLfixed * params
#define glPointParameterxv_PACKED PACKED_void_GLenum_const_GLfixed___GENPT__
#define glPointParameterxv_INDEXED INDEXED_void_GLenum_const_GLfixed___GENPT__
#define glPointParameterxv_FORMAT FORMAT_void_GLenum_const_GLfixed___GENPT__
#define glPointSize_INDEX 128
#define glPointSize_INDEX 130
#define glPointSize_RETURN void
#define glPointSize_ARG_NAMES size
#define glPointSize_ARG_EXPAND GLfloat size
#define glPointSize_PACKED PACKED_void_GLfloat
#define glPointSize_INDEXED INDEXED_void_GLfloat
#define glPointSize_FORMAT FORMAT_void_GLfloat
#define glPointSizePointerOES_INDEX 129
#define glPointSizePointerOES_INDEX 131
#define glPointSizePointerOES_RETURN void
#define glPointSizePointerOES_ARG_NAMES type, stride, pointer
#define glPointSizePointerOES_ARG_EXPAND GLenum type, GLsizei stride, const GLvoid * pointer
#define glPointSizePointerOES_PACKED PACKED_void_GLenum_GLsizei_const_GLvoid___GENPT__
#define glPointSizePointerOES_INDEXED INDEXED_void_GLenum_GLsizei_const_GLvoid___GENPT__
#define glPointSizePointerOES_FORMAT FORMAT_void_GLenum_GLsizei_const_GLvoid___GENPT__
#define glPointSizex_INDEX 130
#define glPointSizex_INDEX 132
#define glPointSizex_RETURN void
#define glPointSizex_ARG_NAMES size
#define glPointSizex_ARG_EXPAND GLfixed size
#define glPointSizex_PACKED PACKED_void_GLfixed
#define glPointSizex_INDEXED INDEXED_void_GLfixed
#define glPointSizex_FORMAT FORMAT_void_GLfixed
#define glPolygonOffset_INDEX 131
#define glPolygonOffset_INDEX 133
#define glPolygonOffset_RETURN void
#define glPolygonOffset_ARG_NAMES factor, units
#define glPolygonOffset_ARG_EXPAND GLfloat factor, GLfloat units
#define glPolygonOffset_PACKED PACKED_void_GLfloat_GLfloat
#define glPolygonOffset_INDEXED INDEXED_void_GLfloat_GLfloat
#define glPolygonOffset_FORMAT FORMAT_void_GLfloat_GLfloat
#define glPolygonOffsetx_INDEX 132
#define glPolygonOffsetx_INDEX 134
#define glPolygonOffsetx_RETURN void
#define glPolygonOffsetx_ARG_NAMES factor, units
#define glPolygonOffsetx_ARG_EXPAND GLfixed factor, GLfixed units
#define glPolygonOffsetx_PACKED PACKED_void_GLfixed_GLfixed
#define glPolygonOffsetx_INDEXED INDEXED_void_GLfixed_GLfixed
#define glPolygonOffsetx_FORMAT FORMAT_void_GLfixed_GLfixed
#define glPopMatrix_INDEX 133
#define glPopMatrix_INDEX 135
#define glPopMatrix_RETURN void
#define glPopMatrix_ARG_NAMES
#define glPopMatrix_ARG_EXPAND
#define glPopMatrix_PACKED PACKED_void
#define glPopMatrix_INDEXED INDEXED_void
#define glPopMatrix_FORMAT FORMAT_void
#define glPushMatrix_INDEX 134
#define glPushMatrix_INDEX 136
#define glPushMatrix_RETURN void
#define glPushMatrix_ARG_NAMES
#define glPushMatrix_ARG_EXPAND
#define glPushMatrix_PACKED PACKED_void
#define glPushMatrix_INDEXED INDEXED_void
#define glPushMatrix_FORMAT FORMAT_void
#define glReadPixels_INDEX 135
#define glReadPixels_INDEX 137
#define glReadPixels_RETURN void
#define glReadPixels_ARG_NAMES x, y, width, height, format, type, pixels
#define glReadPixels_ARG_EXPAND GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels
#define glReadPixels_PACKED PACKED_void_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_GLvoid___GENPT__
#define glReadPixels_INDEXED INDEXED_void_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_GLvoid___GENPT__
#define glReadPixels_FORMAT FORMAT_void_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_GLvoid___GENPT__
#define glRenderbufferStorage_INDEX 136
#define glRenderbufferStorage_INDEX 138
#define glRenderbufferStorage_RETURN void
#define glRenderbufferStorage_ARG_NAMES target, internalformat, width, height
#define glRenderbufferStorage_ARG_EXPAND GLenum target, GLenum internalformat, GLsizei width, GLsizei height
#define glRenderbufferStorage_PACKED PACKED_void_GLenum_GLenum_GLsizei_GLsizei
#define glRenderbufferStorage_INDEXED INDEXED_void_GLenum_GLenum_GLsizei_GLsizei
#define glRenderbufferStorage_FORMAT FORMAT_void_GLenum_GLenum_GLsizei_GLsizei
#define glRotatef_INDEX 137
#define glRotatef_INDEX 139
#define glRotatef_RETURN void
#define glRotatef_ARG_NAMES angle, x, y, z
#define glRotatef_ARG_EXPAND GLfloat angle, GLfloat x, GLfloat y, GLfloat z
#define glRotatef_PACKED PACKED_void_GLfloat_GLfloat_GLfloat_GLfloat
#define glRotatef_INDEXED INDEXED_void_GLfloat_GLfloat_GLfloat_GLfloat
#define glRotatef_FORMAT FORMAT_void_GLfloat_GLfloat_GLfloat_GLfloat
#define glRotatex_INDEX 138
#define glRotatex_INDEX 140
#define glRotatex_RETURN void
#define glRotatex_ARG_NAMES angle, x, y, z
#define glRotatex_ARG_EXPAND GLfixed angle, GLfixed x, GLfixed y, GLfixed z
#define glRotatex_PACKED PACKED_void_GLfixed_GLfixed_GLfixed_GLfixed
#define glRotatex_INDEXED INDEXED_void_GLfixed_GLfixed_GLfixed_GLfixed
#define glRotatex_FORMAT FORMAT_void_GLfixed_GLfixed_GLfixed_GLfixed
#define glSampleCoverage_INDEX 139
#define glSampleCoverage_INDEX 141
#define glSampleCoverage_RETURN void
#define glSampleCoverage_ARG_NAMES value, invert
#define glSampleCoverage_ARG_EXPAND GLclampf value, GLboolean invert
#define glSampleCoverage_PACKED PACKED_void_GLclampf_GLboolean
#define glSampleCoverage_INDEXED INDEXED_void_GLclampf_GLboolean
#define glSampleCoverage_FORMAT FORMAT_void_GLclampf_GLboolean
#define glSampleCoveragex_INDEX 140
#define glSampleCoveragex_INDEX 142
#define glSampleCoveragex_RETURN void
#define glSampleCoveragex_ARG_NAMES value, invert
#define glSampleCoveragex_ARG_EXPAND GLclampx value, GLboolean invert
#define glSampleCoveragex_PACKED PACKED_void_GLclampx_GLboolean
#define glSampleCoveragex_INDEXED INDEXED_void_GLclampx_GLboolean
#define glSampleCoveragex_FORMAT FORMAT_void_GLclampx_GLboolean
#define glScalef_INDEX 141
#define glScalef_INDEX 143
#define glScalef_RETURN void
#define glScalef_ARG_NAMES x, y, z
#define glScalef_ARG_EXPAND GLfloat x, GLfloat y, GLfloat z
#define glScalef_PACKED PACKED_void_GLfloat_GLfloat_GLfloat
#define glScalef_INDEXED INDEXED_void_GLfloat_GLfloat_GLfloat
#define glScalef_FORMAT FORMAT_void_GLfloat_GLfloat_GLfloat
#define glScalex_INDEX 142
#define glScalex_INDEX 144
#define glScalex_RETURN void
#define glScalex_ARG_NAMES x, y, z
#define glScalex_ARG_EXPAND GLfixed x, GLfixed y, GLfixed z
#define glScalex_PACKED PACKED_void_GLfixed_GLfixed_GLfixed
#define glScalex_INDEXED INDEXED_void_GLfixed_GLfixed_GLfixed
#define glScalex_FORMAT FORMAT_void_GLfixed_GLfixed_GLfixed
#define glScissor_INDEX 143
#define glScissor_INDEX 145
#define glScissor_RETURN void
#define glScissor_ARG_NAMES x, y, width, height
#define glScissor_ARG_EXPAND GLint x, GLint y, GLsizei width, GLsizei height
#define glScissor_PACKED PACKED_void_GLint_GLint_GLsizei_GLsizei
#define glScissor_INDEXED INDEXED_void_GLint_GLint_GLsizei_GLsizei
#define glScissor_FORMAT FORMAT_void_GLint_GLint_GLsizei_GLsizei
#define glShadeModel_INDEX 144
#define glShadeModel_INDEX 146
#define glShadeModel_RETURN void
#define glShadeModel_ARG_NAMES mode
#define glShadeModel_ARG_EXPAND GLenum mode
#define glShadeModel_PACKED PACKED_void_GLenum
#define glShadeModel_INDEXED INDEXED_void_GLenum
#define glShadeModel_FORMAT FORMAT_void_GLenum
#define glStencilFunc_INDEX 145
#define glStencilFunc_INDEX 147
#define glStencilFunc_RETURN void
#define glStencilFunc_ARG_NAMES func, ref, mask
#define glStencilFunc_ARG_EXPAND GLenum func, GLint ref, GLuint mask
#define glStencilFunc_PACKED PACKED_void_GLenum_GLint_GLuint
#define glStencilFunc_INDEXED INDEXED_void_GLenum_GLint_GLuint
#define glStencilFunc_FORMAT FORMAT_void_GLenum_GLint_GLuint
#define glStencilMask_INDEX 146
#define glStencilMask_INDEX 148
#define glStencilMask_RETURN void
#define glStencilMask_ARG_NAMES mask
#define glStencilMask_ARG_EXPAND GLuint mask
#define glStencilMask_PACKED PACKED_void_GLuint
#define glStencilMask_INDEXED INDEXED_void_GLuint
#define glStencilMask_FORMAT FORMAT_void_GLuint
#define glStencilOp_INDEX 147
#define glStencilOp_INDEX 149
#define glStencilOp_RETURN void
#define glStencilOp_ARG_NAMES fail, zfail, zpass
#define glStencilOp_ARG_EXPAND GLenum fail, GLenum zfail, GLenum zpass
#define glStencilOp_PACKED PACKED_void_GLenum_GLenum_GLenum
#define glStencilOp_INDEXED INDEXED_void_GLenum_GLenum_GLenum
#define glStencilOp_FORMAT FORMAT_void_GLenum_GLenum_GLenum
#define glTexCoordPointer_INDEX 148
#define glTexCoordPointer_INDEX 150
#define glTexCoordPointer_RETURN void
#define glTexCoordPointer_ARG_NAMES size, type, stride, pointer
#define glTexCoordPointer_ARG_EXPAND GLint size, GLenum type, GLsizei stride, const GLvoid * pointer
#define glTexCoordPointer_PACKED PACKED_void_GLint_GLenum_GLsizei_const_GLvoid___GENPT__
#define glTexCoordPointer_INDEXED INDEXED_void_GLint_GLenum_GLsizei_const_GLvoid___GENPT__
#define glTexCoordPointer_FORMAT FORMAT_void_GLint_GLenum_GLsizei_const_GLvoid___GENPT__
#define glTexEnvf_INDEX 149
#define glTexEnvf_INDEX 151
#define glTexEnvf_RETURN void
#define glTexEnvf_ARG_NAMES target, pname, param
#define glTexEnvf_ARG_EXPAND GLenum target, GLenum pname, GLfloat param
#define glTexEnvf_PACKED PACKED_void_GLenum_GLenum_GLfloat
#define glTexEnvf_INDEXED INDEXED_void_GLenum_GLenum_GLfloat
#define glTexEnvf_FORMAT FORMAT_void_GLenum_GLenum_GLfloat
#define glTexEnvfv_INDEX 150
#define glTexEnvfv_INDEX 152
#define glTexEnvfv_RETURN void
#define glTexEnvfv_ARG_NAMES target, pname, params
#define glTexEnvfv_ARG_EXPAND GLenum target, GLenum pname, const GLfloat * params
#define glTexEnvfv_PACKED PACKED_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexEnvfv_INDEXED INDEXED_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexEnvfv_FORMAT FORMAT_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexEnvi_INDEX 151
#define glTexEnvi_INDEX 153
#define glTexEnvi_RETURN void
#define glTexEnvi_ARG_NAMES target, pname, param
#define glTexEnvi_ARG_EXPAND GLenum target, GLenum pname, GLint param
#define glTexEnvi_PACKED PACKED_void_GLenum_GLenum_GLint
#define glTexEnvi_INDEXED INDEXED_void_GLenum_GLenum_GLint
#define glTexEnvi_FORMAT FORMAT_void_GLenum_GLenum_GLint
#define glTexEnviv_INDEX 152
#define glTexEnviv_INDEX 154
#define glTexEnviv_RETURN void
#define glTexEnviv_ARG_NAMES target, pname, params
#define glTexEnviv_ARG_EXPAND GLenum target, GLenum pname, const GLint * params
#define glTexEnviv_PACKED PACKED_void_GLenum_GLenum_const_GLint___GENPT__
#define glTexEnviv_INDEXED INDEXED_void_GLenum_GLenum_const_GLint___GENPT__
#define glTexEnviv_FORMAT FORMAT_void_GLenum_GLenum_const_GLint___GENPT__
#define glTexEnvx_INDEX 153
#define glTexEnvx_INDEX 155
#define glTexEnvx_RETURN void
#define glTexEnvx_ARG_NAMES target, pname, param
#define glTexEnvx_ARG_EXPAND GLenum target, GLenum pname, GLfixed param
#define glTexEnvx_PACKED PACKED_void_GLenum_GLenum_GLfixed
#define glTexEnvx_INDEXED INDEXED_void_GLenum_GLenum_GLfixed
#define glTexEnvx_FORMAT FORMAT_void_GLenum_GLenum_GLfixed
#define glTexEnvxv_INDEX 154
#define glTexEnvxv_INDEX 156
#define glTexEnvxv_RETURN void
#define glTexEnvxv_ARG_NAMES target, pname, params
#define glTexEnvxv_ARG_EXPAND GLenum target, GLenum pname, const GLfixed * params
#define glTexEnvxv_PACKED PACKED_void_GLenum_GLenum_const_GLfixed___GENPT__
#define glTexEnvxv_INDEXED INDEXED_void_GLenum_GLenum_const_GLfixed___GENPT__
#define glTexEnvxv_FORMAT FORMAT_void_GLenum_GLenum_const_GLfixed___GENPT__
#define glTexGenfv_INDEX 155
#define glTexGenfv_INDEX 157
#define glTexGenfv_RETURN void
#define glTexGenfv_ARG_NAMES coord, pname, params
#define glTexGenfv_ARG_EXPAND GLenum coord, GLenum pname, const GLfloat * params
#define glTexGenfv_PACKED PACKED_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexGenfv_INDEXED INDEXED_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexGenfv_FORMAT FORMAT_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexGeni_INDEX 156
#define glTexGeni_INDEX 158
#define glTexGeni_RETURN void
#define glTexGeni_ARG_NAMES coord, pname, param
#define glTexGeni_ARG_EXPAND GLenum coord, GLenum pname, GLint param
#define glTexGeni_PACKED PACKED_void_GLenum_GLenum_GLint
#define glTexGeni_INDEXED INDEXED_void_GLenum_GLenum_GLint
#define glTexGeni_FORMAT FORMAT_void_GLenum_GLenum_GLint
#define glTexImage2D_INDEX 157
#define glTexImage2D_INDEX 159
#define glTexImage2D_RETURN void
#define glTexImage2D_ARG_NAMES target, level, internalformat, width, height, border, format, type, pixels
#define glTexImage2D_ARG_EXPAND GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels
#define glTexImage2D_PACKED PACKED_void_GLenum_GLint_GLint_GLsizei_GLsizei_GLint_GLenum_GLenum_const_GLvoid___GENPT__
#define glTexImage2D_INDEXED INDEXED_void_GLenum_GLint_GLint_GLsizei_GLsizei_GLint_GLenum_GLenum_const_GLvoid___GENPT__
#define glTexImage2D_FORMAT FORMAT_void_GLenum_GLint_GLint_GLsizei_GLsizei_GLint_GLenum_GLenum_const_GLvoid___GENPT__
#define glTexParameterf_INDEX 158
#define glTexParameterf_INDEX 160
#define glTexParameterf_RETURN void
#define glTexParameterf_ARG_NAMES target, pname, param
#define glTexParameterf_ARG_EXPAND GLenum target, GLenum pname, GLfloat param
#define glTexParameterf_PACKED PACKED_void_GLenum_GLenum_GLfloat
#define glTexParameterf_INDEXED INDEXED_void_GLenum_GLenum_GLfloat
#define glTexParameterf_FORMAT FORMAT_void_GLenum_GLenum_GLfloat
#define glTexParameterfv_INDEX 159
#define glTexParameterfv_INDEX 161
#define glTexParameterfv_RETURN void
#define glTexParameterfv_ARG_NAMES target, pname, params
#define glTexParameterfv_ARG_EXPAND GLenum target, GLenum pname, const GLfloat * params
#define glTexParameterfv_PACKED PACKED_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexParameterfv_INDEXED INDEXED_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexParameterfv_FORMAT FORMAT_void_GLenum_GLenum_const_GLfloat___GENPT__
#define glTexParameteri_INDEX 160
#define glTexParameteri_INDEX 162
#define glTexParameteri_RETURN void
#define glTexParameteri_ARG_NAMES target, pname, param
#define glTexParameteri_ARG_EXPAND GLenum target, GLenum pname, GLint param
#define glTexParameteri_PACKED PACKED_void_GLenum_GLenum_GLint
#define glTexParameteri_INDEXED INDEXED_void_GLenum_GLenum_GLint
#define glTexParameteri_FORMAT FORMAT_void_GLenum_GLenum_GLint
#define glTexParameteriv_INDEX 161
#define glTexParameteriv_INDEX 163
#define glTexParameteriv_RETURN void
#define glTexParameteriv_ARG_NAMES target, pname, params
#define glTexParameteriv_ARG_EXPAND GLenum target, GLenum pname, const GLint * params
#define glTexParameteriv_PACKED PACKED_void_GLenum_GLenum_const_GLint___GENPT__
#define glTexParameteriv_INDEXED INDEXED_void_GLenum_GLenum_const_GLint___GENPT__
#define glTexParameteriv_FORMAT FORMAT_void_GLenum_GLenum_const_GLint___GENPT__
#define glTexParameterx_INDEX 162
#define glTexParameterx_INDEX 164
#define glTexParameterx_RETURN void
#define glTexParameterx_ARG_NAMES target, pname, param
#define glTexParameterx_ARG_EXPAND GLenum target, GLenum pname, GLfixed param
#define glTexParameterx_PACKED PACKED_void_GLenum_GLenum_GLfixed
#define glTexParameterx_INDEXED INDEXED_void_GLenum_GLenum_GLfixed
#define glTexParameterx_FORMAT FORMAT_void_GLenum_GLenum_GLfixed
#define glTexParameterxv_INDEX 163
#define glTexParameterxv_INDEX 165
#define glTexParameterxv_RETURN void
#define glTexParameterxv_ARG_NAMES target, pname, params
#define glTexParameterxv_ARG_EXPAND GLenum target, GLenum pname, const GLfixed * params
#define glTexParameterxv_PACKED PACKED_void_GLenum_GLenum_const_GLfixed___GENPT__
#define glTexParameterxv_INDEXED INDEXED_void_GLenum_GLenum_const_GLfixed___GENPT__
#define glTexParameterxv_FORMAT FORMAT_void_GLenum_GLenum_const_GLfixed___GENPT__
#define glTexSubImage2D_INDEX 164
#define glTexSubImage2D_INDEX 166
#define glTexSubImage2D_RETURN void
#define glTexSubImage2D_ARG_NAMES target, level, xoffset, yoffset, width, height, format, type, pixels
#define glTexSubImage2D_ARG_EXPAND GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels
#define glTexSubImage2D_PACKED PACKED_void_GLenum_GLint_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid___GENPT__
#define glTexSubImage2D_INDEXED INDEXED_void_GLenum_GLint_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid___GENPT__
#define glTexSubImage2D_FORMAT FORMAT_void_GLenum_GLint_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid___GENPT__
#define glTranslatef_INDEX 165
#define glTranslatef_INDEX 167
#define glTranslatef_RETURN void
#define glTranslatef_ARG_NAMES x, y, z
#define glTranslatef_ARG_EXPAND GLfloat x, GLfloat y, GLfloat z
#define glTranslatef_PACKED PACKED_void_GLfloat_GLfloat_GLfloat
#define glTranslatef_INDEXED INDEXED_void_GLfloat_GLfloat_GLfloat
#define glTranslatef_FORMAT FORMAT_void_GLfloat_GLfloat_GLfloat
#define glTranslatex_INDEX 166
#define glTranslatex_INDEX 168
#define glTranslatex_RETURN void
#define glTranslatex_ARG_NAMES x, y, z
#define glTranslatex_ARG_EXPAND GLfixed x, GLfixed y, GLfixed z
#define glTranslatex_PACKED PACKED_void_GLfixed_GLfixed_GLfixed
#define glTranslatex_INDEXED INDEXED_void_GLfixed_GLfixed_GLfixed
#define glTranslatex_FORMAT FORMAT_void_GLfixed_GLfixed_GLfixed
#define glVertexPointer_INDEX 167
#define glVertexPointer_INDEX 169
#define glVertexPointer_RETURN void
#define glVertexPointer_ARG_NAMES size, type, stride, pointer
#define glVertexPointer_ARG_EXPAND GLint size, GLenum type, GLsizei stride, const GLvoid * pointer
#define glVertexPointer_PACKED PACKED_void_GLint_GLenum_GLsizei_const_GLvoid___GENPT__
#define glVertexPointer_INDEXED INDEXED_void_GLint_GLenum_GLsizei_const_GLvoid___GENPT__
#define glVertexPointer_FORMAT FORMAT_void_GLint_GLenum_GLsizei_const_GLvoid___GENPT__
#define glViewport_INDEX 168
#define glViewport_INDEX 170
#define glViewport_RETURN void
#define glViewport_ARG_NAMES x, y, width, height
#define glViewport_ARG_EXPAND GLint x, GLint y, GLsizei width, GLsizei height
@@ -2760,6 +2809,10 @@ void glshim_glMultMatrixf(glMultMatrixf_ARG_EXPAND);
typedef void (*glMultMatrixf_PTR)(glMultMatrixf_ARG_EXPAND);
void glshim_glMultMatrixx(glMultMatrixx_ARG_EXPAND);
typedef void (*glMultMatrixx_PTR)(glMultMatrixx_ARG_EXPAND);
void glshim_glMultiDrawArrays(glMultiDrawArrays_ARG_EXPAND);
typedef void (*glMultiDrawArrays_PTR)(glMultiDrawArrays_ARG_EXPAND);
void glshim_glMultiDrawElements(glMultiDrawElements_ARG_EXPAND);
typedef void (*glMultiDrawElements_PTR)(glMultiDrawElements_ARG_EXPAND);
void glshim_glMultiTexCoord4f(glMultiTexCoord4f_ARG_EXPAND);
typedef void (*glMultiTexCoord4f_PTR)(glMultiTexCoord4f_ARG_EXPAND);
void glshim_glMultiTexCoord4x(glMultiTexCoord4x_ARG_EXPAND);
@@ -4071,6 +4124,31 @@ typedef void (*glViewport_PTR)(glViewport_ARG_EXPAND);
glPushCall((void *)packed_data); \
}
#endif
#ifndef direct_glMultiDrawArrays
#define push_glMultiDrawArrays(mode, first, count, primcount) { \
glMultiDrawArrays_PACKED *packed_data = malloc(sizeof(glMultiDrawArrays_PACKED)); \
packed_data->format = glMultiDrawArrays_FORMAT; \
packed_data->func = glshim_glMultiDrawArrays; \
packed_data->args.a1 = (GLenum)mode; \
packed_data->args.a2 = (GLint *)first; \
packed_data->args.a3 = (GLsizei *)count; \
packed_data->args.a4 = (GLsizei)primcount; \
glPushCall((void *)packed_data); \
}
#endif
#ifndef direct_glMultiDrawElements
#define push_glMultiDrawElements(mode, count, type, indices, primcount) { \
glMultiDrawElements_PACKED *packed_data = malloc(sizeof(glMultiDrawElements_PACKED)); \
packed_data->format = glMultiDrawElements_FORMAT; \
packed_data->func = glshim_glMultiDrawElements; \
packed_data->args.a1 = (GLenum)mode; \
packed_data->args.a2 = (GLsizei *)count; \
packed_data->args.a3 = (GLenum)type; \
packed_data->args.a4 = (void * *)indices; \
packed_data->args.a5 = (GLsizei)primcount; \
glPushCall((void *)packed_data); \
}
#endif
#ifndef direct_glMultiTexCoord4f
#define push_glMultiTexCoord4f(target, s, t, r, q) { \
glMultiTexCoord4f_PACKED *packed_data = malloc(sizeof(glMultiTexCoord4f_PACKED)); \

66
project/jni/glshim/src/gl/wrap/glesext.c
View File

@@ -8,7 +8,7 @@ void glshim_glBindFramebuffer(GLenum target, GLuint framebuffer) {
#endif
gles_glBindFramebuffer(target, framebuffer);
}
void glBindFramebuffer(GLenum target, GLuint framebuffer) __attribute__((alias("glshim_glBindFramebuffer")));
void glBindFramebuffer(GLenum target, GLuint framebuffer) __attribute__((alias("glshim_glBindFramebuffer"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glBindRenderbuffer
void glshim_glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
@@ -18,7 +18,7 @@ void glshim_glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
#endif
gles_glBindRenderbuffer(target, renderbuffer);
}
void glBindRenderbuffer(GLenum target, GLuint renderbuffer) __attribute__((alias("glshim_glBindRenderbuffer")));
void glBindRenderbuffer(GLenum target, GLuint renderbuffer) __attribute__((alias("glshim_glBindRenderbuffer"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glBlendColor
void glshim_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
@@ -28,7 +28,7 @@ void glshim_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf a
#endif
gles_glBlendColor(red, green, blue, alpha);
}
void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) __attribute__((alias("glshim_glBlendColor")));
void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) __attribute__((alias("glshim_glBlendColor"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glBlendEquation
void glshim_glBlendEquation(GLenum mode) {
@@ -38,7 +38,7 @@ void glshim_glBlendEquation(GLenum mode) {
#endif
gles_glBlendEquation(mode);
}
void glBlendEquation(GLenum mode) __attribute__((alias("glshim_glBlendEquation")));
void glBlendEquation(GLenum mode) __attribute__((alias("glshim_glBlendEquation"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glBlendEquationSeparate
void glshim_glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) {
@@ -48,7 +48,7 @@ void glshim_glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) {
#endif
gles_glBlendEquationSeparate(modeRGB, modeA);
}
void glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) __attribute__((alias("glshim_glBlendEquationSeparate")));
void glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) __attribute__((alias("glshim_glBlendEquationSeparate"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glBlendFuncSeparate
void glshim_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
@@ -58,7 +58,7 @@ void glshim_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfa
#endif
gles_glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) __attribute__((alias("glshim_glBlendFuncSeparate")));
void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) __attribute__((alias("glshim_glBlendFuncSeparate"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glCheckFramebufferStatus
GLenum glshim_glCheckFramebufferStatus(GLenum target) {
@@ -68,7 +68,7 @@ GLenum glshim_glCheckFramebufferStatus(GLenum target) {
#endif
return gles_glCheckFramebufferStatus(target);
}
GLenum glCheckFramebufferStatus(GLenum target) __attribute__((alias("glshim_glCheckFramebufferStatus")));
GLenum glCheckFramebufferStatus(GLenum target) __attribute__((alias("glshim_glCheckFramebufferStatus"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glDeleteFramebuffers
void glshim_glDeleteFramebuffers(GLsizei n, GLuint * framebuffers) {
@@ -78,7 +78,7 @@ void glshim_glDeleteFramebuffers(GLsizei n, GLuint * framebuffers) {
#endif
gles_glDeleteFramebuffers(n, framebuffers);
}
void glDeleteFramebuffers(GLsizei n, GLuint * framebuffers) __attribute__((alias("glshim_glDeleteFramebuffers")));
void glDeleteFramebuffers(GLsizei n, GLuint * framebuffers) __attribute__((alias("glshim_glDeleteFramebuffers"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glDeleteRenderbuffers
void glshim_glDeleteRenderbuffers(GLsizei n, GLuint * renderbuffers) {
@@ -88,7 +88,7 @@ void glshim_glDeleteRenderbuffers(GLsizei n, GLuint * renderbuffers) {
#endif
gles_glDeleteRenderbuffers(n, renderbuffers);
}
void glDeleteRenderbuffers(GLsizei n, GLuint * renderbuffers) __attribute__((alias("glshim_glDeleteRenderbuffers")));
void glDeleteRenderbuffers(GLsizei n, GLuint * renderbuffers) __attribute__((alias("glshim_glDeleteRenderbuffers"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glDrawTexf
void glshim_glDrawTexf(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) {
@@ -98,7 +98,7 @@ void glshim_glDrawTexf(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat h
#endif
gles_glDrawTexf(x, y, z, width, height);
}
void glDrawTexf(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) __attribute__((alias("glshim_glDrawTexf")));
void glDrawTexf(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) __attribute__((alias("glshim_glDrawTexf"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glDrawTexi
void glshim_glDrawTexi(GLint x, GLint y, GLint z, GLint width, GLint height) {
@@ -108,7 +108,7 @@ void glshim_glDrawTexi(GLint x, GLint y, GLint z, GLint width, GLint height) {
#endif
gles_glDrawTexi(x, y, z, width, height);
}
void glDrawTexi(GLint x, GLint y, GLint z, GLint width, GLint height) __attribute__((alias("glshim_glDrawTexi")));
void glDrawTexi(GLint x, GLint y, GLint z, GLint width, GLint height) __attribute__((alias("glshim_glDrawTexi"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glFramebufferRenderbuffer
void glshim_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
@@ -118,7 +118,7 @@ void glshim_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum r
#endif
gles_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) __attribute__((alias("glshim_glFramebufferRenderbuffer")));
void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) __attribute__((alias("glshim_glFramebufferRenderbuffer"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glFramebufferTexture2D
void glshim_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
@@ -128,7 +128,7 @@ void glshim_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum text
#endif
gles_glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) __attribute__((alias("glshim_glFramebufferTexture2D")));
void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) __attribute__((alias("glshim_glFramebufferTexture2D"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glGenFramebuffers
void glshim_glGenFramebuffers(GLsizei n, GLuint * ids) {
@@ -138,7 +138,7 @@ void glshim_glGenFramebuffers(GLsizei n, GLuint * ids) {
#endif
gles_glGenFramebuffers(n, ids);
}
void glGenFramebuffers(GLsizei n, GLuint * ids) __attribute__((alias("glshim_glGenFramebuffers")));
void glGenFramebuffers(GLsizei n, GLuint * ids) __attribute__((alias("glshim_glGenFramebuffers"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glGenRenderbuffers
void glshim_glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) {
@@ -148,7 +148,7 @@ void glshim_glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) {
#endif
gles_glGenRenderbuffers(n, renderbuffers);
}
void glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) __attribute__((alias("glshim_glGenRenderbuffers")));
void glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) __attribute__((alias("glshim_glGenRenderbuffers"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glGenerateMipmap
void glshim_glGenerateMipmap(GLenum target) {
@@ -158,7 +158,7 @@ void glshim_glGenerateMipmap(GLenum target) {
#endif
gles_glGenerateMipmap(target);
}
void glGenerateMipmap(GLenum target) __attribute__((alias("glshim_glGenerateMipmap")));
void glGenerateMipmap(GLenum target) __attribute__((alias("glshim_glGenerateMipmap"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glGetFramebufferAttachmentParameteriv
void glshim_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params) {
@@ -168,7 +168,7 @@ void glshim_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachme
#endif
gles_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params) __attribute__((alias("glshim_glGetFramebufferAttachmentParameteriv")));
void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params) __attribute__((alias("glshim_glGetFramebufferAttachmentParameteriv"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glGetRenderbufferParameteriv
void glshim_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params) {
@@ -178,7 +178,7 @@ void glshim_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * pa
#endif
gles_glGetRenderbufferParameteriv(target, pname, params);
}
void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params) __attribute__((alias("glshim_glGetRenderbufferParameteriv")));
void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params) __attribute__((alias("glshim_glGetRenderbufferParameteriv"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glIsFramebuffer
GLboolean glshim_glIsFramebuffer(GLuint framebuffer) {
@@ -188,7 +188,7 @@ GLboolean glshim_glIsFramebuffer(GLuint framebuffer) {
#endif
return gles_glIsFramebuffer(framebuffer);
}
GLboolean glIsFramebuffer(GLuint framebuffer) __attribute__((alias("glshim_glIsFramebuffer")));
GLboolean glIsFramebuffer(GLuint framebuffer) __attribute__((alias("glshim_glIsFramebuffer"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glIsRenderbuffer
GLboolean glshim_glIsRenderbuffer(GLuint renderbuffer) {
@@ -198,7 +198,27 @@ GLboolean glshim_glIsRenderbuffer(GLuint renderbuffer) {
#endif
return gles_glIsRenderbuffer(renderbuffer);
}
GLboolean glIsRenderbuffer(GLuint renderbuffer) __attribute__((alias("glshim_glIsRenderbuffer")));
GLboolean glIsRenderbuffer(GLuint renderbuffer) __attribute__((alias("glshim_glIsRenderbuffer"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glMultiDrawArrays
void glshim_glMultiDrawArrays(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount) {
LOAD_GLES_OES(glMultiDrawArrays);
#ifndef direct_glMultiDrawArrays
PUSH_IF_COMPILING(glMultiDrawArrays)
#endif
gles_glMultiDrawArrays(mode, first, count, primcount);
}
void glMultiDrawArrays(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount) __attribute__((alias("glshim_glMultiDrawArrays"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glMultiDrawElements
void glshim_glMultiDrawElements(GLenum mode, GLsizei * count, GLenum type, const void * const * indices, GLsizei primcount) {
LOAD_GLES_OES(glMultiDrawElements);
#ifndef direct_glMultiDrawElements
PUSH_IF_COMPILING(glMultiDrawElements)
#endif
gles_glMultiDrawElements(mode, count, type, indices, primcount);
}
void glMultiDrawElements(GLenum mode, GLsizei * count, GLenum type, const void * const * indices, GLsizei primcount) __attribute__((alias("glshim_glMultiDrawElements"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glRenderbufferStorage
void glshim_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
@@ -208,7 +228,7 @@ void glshim_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei
#endif
gles_glRenderbufferStorage(target, internalformat, width, height);
}
void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) __attribute__((alias("glshim_glRenderbufferStorage")));
void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) __attribute__((alias("glshim_glRenderbufferStorage"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glTexGenfv
void glshim_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params) {
@@ -218,7 +238,7 @@ void glshim_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params) {
#endif
gles_glTexGenfv(coord, pname, params);
}
void glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params) __attribute__((alias("glshim_glTexGenfv")));
void glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params) __attribute__((alias("glshim_glTexGenfv"))) __attribute__((visibility("default")));
#endif
#ifndef skip_glTexGeni
void glshim_glTexGeni(GLenum coord, GLenum pname, GLint param) {
@@ -228,6 +248,6 @@ void glshim_glTexGeni(GLenum coord, GLenum pname, GLint param) {
#endif
gles_glTexGeni(coord, pname, param);
}
void glTexGeni(GLenum coord, GLenum pname, GLint param) __attribute__((alias("glshim_glTexGeni")));
void glTexGeni(GLenum coord, GLenum pname, GLint param) __attribute__((alias("glshim_glTexGeni"))) __attribute__((visibility("default")));
#endif
#endif

2
project/jni/glshim/src/gl/wrap/glstub.c
View File

@@ -6,7 +6,7 @@ ret glshim_ ## def args {\
if (debug && strcmp(debug, "1") == 0)\
printf("stub: %s;\n", #def);\
} \
ret def args __attribute((alias("glshim_"#def)));
ret def args __attribute((alias("glshim_"#def))) __attribute__((visibility("default")));
STUB(void,glFogCoordd,(GLdouble coord));
STUB(void,glFogCoordf,(GLfloat coord));

4
project/jni/glshim/src/glx/glesfuncs.inc
View File

@@ -5,7 +5,7 @@ _EX(glBindBuffer);
_EX(glBindFramebuffer);
_EX(glBindRenderbuffer);
_EX(glBindTexture);
//_EX(glBlendColor);
_EX(glBlendColor);
_EX(glBlendEquation);
_EX(glBlendEquationSeparate);
_EX(glBlendFunc);
@@ -113,6 +113,8 @@ _EX(glMaterialxv);
_EX(glMatrixMode);
_EX(glMultMatrixf);
_EX(glMultMatrixx);
_EX(glMultiDrawArrays);
_EX(glMultiDrawElements);
_EX(glMultiTexCoord4f);
_EX(glMultiTexCoord4x);
_EX(glNormal3f);

83
project/jni/glshim/src/glx/glx.c
View File

@@ -24,6 +24,8 @@
#include "../gl/gl.h"
#include "../glx/streaming.h"
#define EXPORT __attribute__((visibility("default")))
#ifndef EGL_GL_COLORSPACE_KHR
#define EGL_GL_COLORSPACE_KHR 0x309D
#define EGL_GL_COLORSPACE_SRGB_KHR 0x3089
@@ -516,7 +518,7 @@ static void scan_env() {
printf("LIBGL: Current folder is:%s\n", cwd);
}
#ifndef ANDROID
GLXContext glXCreateContext(Display *display,
EXPORT GLXContext glXCreateContext(Display *display,
XVisualInfo *visual,
GLXContext shareList,
Bool isDirect) {
@@ -660,13 +662,13 @@ GLXContext glXCreateContext(Display *display,
return fake;
}
GLXContext glXCreateContextAttribsARB(Display *display, void *config,
EXPORT GLXContext glXCreateContextAttribsARB(Display *display, void *config,
GLXContext share_context, Bool direct,
const int *attrib_list) {
return glXCreateContext(display, NULL, NULL, direct);
}
void glXDestroyContext(Display *display, GLXContext ctx) {
EXPORT void glXDestroyContext(Display *display, GLXContext ctx) {
//printf("glXDestroyContext(%p, %p)\n", display, ctx);
if (g_usefb) {
if (fbcontext_count==0)
@@ -706,7 +708,7 @@ void glXDestroyContext(Display *display, GLXContext ctx) {
return;
}
Display *glXGetCurrentDisplay() {
EXPORT Display *glXGetCurrentDisplay() {
if (!g_usefb)
return XOpenDisplay(NULL);
else
@@ -716,7 +718,7 @@ Display *glXGetCurrentDisplay() {
return XOpenDisplay(NULL);
}
XVisualInfo *glXChooseVisual(Display *display,
EXPORT XVisualInfo *glXChooseVisual(Display *display,
int screen,
int *attributes) {
@@ -746,7 +748,7 @@ EGL_NO_SURFACE, or if draw or read are set to EGL_NO_SURFACE and context is
not set to EGL_NO_CONTEXT.
*/
Bool glXMakeCurrent(Display *display,
EXPORT Bool glXMakeCurrent(Display *display,
GLXDrawable drawable,
GLXContext context) {
//printf("glXMakeCurrent(%p, %p, %p)\n", display, drawable, context);
@@ -826,12 +828,12 @@ Bool glXMakeCurrent(Display *display,
return false;
}
Bool glXMakeContextCurrent(Display *display, int drawable,
EXPORT Bool glXMakeContextCurrent(Display *display, int drawable,
int readable, GLXContext context) {
return glXMakeCurrent(display, drawable, context);
}
void glXSwapBuffers(Display *display,
EXPORT void glXSwapBuffers(Display *display,
int drawable) {
static int frames = 0;
@@ -901,14 +903,14 @@ void glXSwapBuffers(Display *display,
}
}
int glXGetConfig(Display *display,
EXPORT int glXGetConfig(Display *display,
XVisualInfo *visual,
int attribute,
int *value) {
return get_config_default(attribute, value);
}
const char *glXQueryExtensionsString(Display *display, int screen) {
EXPORT const char *glXQueryExtensionsString(Display *display, int screen) {
const char *extensions = {
"GLX_ARB_create_context "
"GLX_ARB_create_context_profile "
@@ -918,11 +920,11 @@ const char *glXQueryExtensionsString(Display *display, int screen) {
return extensions;
}
const char *glXQueryServerString(Display *display, int screen, int name) {
EXPORT const char *glXQueryServerString(Display *display, int screen, int name) {
return "";
}
Bool glXQueryExtension(Display *display, int *errorBase, int *eventBase) {
EXPORT Bool glXQueryExtension(Display *display, int *errorBase, int *eventBase) {
if (errorBase)
*errorBase = 0;
@@ -932,14 +934,14 @@ Bool glXQueryExtension(Display *display, int *errorBase, int *eventBase) {
return true;
}
Bool glXQueryVersion(Display *display, int *major, int *minor) {
EXPORT Bool glXQueryVersion(Display *display, int *major, int *minor) {
// TODO: figure out which version we want to pretend to implement
*major = 1;
*minor = 4;
return true;
}
const char *glXGetClientString(Display *display, int name) {
EXPORT const char *glXGetClientString(Display *display, int name) {
// TODO: return actual data here
switch (name) {
case GLX_VENDOR: return "ptitSeb";
@@ -949,7 +951,7 @@ const char *glXGetClientString(Display *display, int name) {
return "";
}
int glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value ){
EXPORT int glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value ){
*value=0;
if (ctx) switch (attribute) {
case GLX_FBCONFIG_ID: *value=ctx->xid; break;
@@ -960,13 +962,13 @@ int glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value ){
}
/*
void glXQueryDrawable( Display *dpy, int draw, int attribute,
EXPORT void glXQueryDrawable( Display *dpy, int draw, int attribute,
unsigned int *value ) {
*value=0;
}
*/
// stubs for glfw (GLX 1.3)
GLXContext glXGetCurrentContext() {
EXPORT GLXContext glXGetCurrentContext() {
// hack to make some games start
if (g_usefb)
return glxContext ? glxContext : fbContext;
@@ -974,28 +976,28 @@ GLXContext glXGetCurrentContext() {
return glxContext;
}
GLXFBConfig *glXChooseFBConfig(Display *display, int screen,
EXPORT GLXFBConfig *glXChooseFBConfig(Display *display, int screen,
const int *attrib_list, int *count) {
*count = 1;
GLXFBConfig *configs = malloc(sizeof(GLXFBConfig) * *count);
return configs;
}
GLXFBConfig *glXChooseFBConfigSGIX(Display *display, int screen,
EXPORT GLXFBConfig *glXChooseFBConfigSGIX(Display *display, int screen,
const int *attrib_list, int *count) {
return glXChooseFBConfig(display, screen, attrib_list, count);
}
GLXFBConfig *glXGetFBConfigs(Display *display, int screen, int *count) {
EXPORT GLXFBConfig *glXGetFBConfigs(Display *display, int screen, int *count) {
*count = 1;
GLXFBConfig *configs = malloc(sizeof(GLXFBConfig) * *count);
return configs;
}
int glXGetFBConfigAttrib(Display *display, GLXFBConfig config, int attribute, int *value) {
EXPORT int glXGetFBConfigAttrib(Display *display, GLXFBConfig config, int attribute, int *value) {
return get_config_default(attribute, value);
}
XVisualInfo *glXGetVisualFromFBConfig(Display *display, GLXFBConfig config) {
EXPORT XVisualInfo *glXGetVisualFromFBConfig(Display *display, GLXFBConfig config) {
/*if (g_display == NULL) {
g_display = XOpenDisplay(NULL);
}*/
@@ -1006,13 +1008,14 @@ XVisualInfo *glXGetVisualFromFBConfig(Display *display, GLXFBConfig config) {
return visual;
}
GLXContext glXCreateNewContext(Display *display, GLXFBConfig config,
EXPORT GLXContext glXCreateNewContext(Display *display, GLXFBConfig config,
int render_type, GLXContext share_list,
Bool is_direct) {
printf("glXCreateNewContext(%p, %p, %d, %p, %i)\n", display, config, render_type, share_list, is_direct);
return glXCreateContext(display, 0, share_list, is_direct);
}
#endif //ANDROID
void glXSwapIntervalMESA(int interval) {
EXPORT void glXSwapIntervalMESA(int interval) {
printf("glXSwapInterval(%i)\n", interval);
#ifdef USE_FBIO
if (! g_vsync)
@@ -1024,37 +1027,37 @@ void glXSwapIntervalMESA(int interval) {
#endif
}
void glXSwapIntervalSGI(int interval) {
EXPORT void glXSwapIntervalSGI(int interval) {
glXSwapIntervalMESA(interval);
}
#ifndef ANDROID
void glXSwapIntervalEXT(Display *display, int drawable, int interval) {
EXPORT void glXSwapIntervalEXT(Display *display, int drawable, int interval) {
glXSwapIntervalMESA(interval);
}
// misc stubs
void glXCopyContext(Display *display, GLXContext src, GLXContext dst, GLuint mask) {
EXPORT void glXCopyContext(Display *display, GLXContext src, GLXContext dst, GLuint mask) {
// mask is ignored for now, but should include glPushAttrib / glPopAttrib
memcpy(dst, src, sizeof(struct __GLXContextRec));
}
void glXCreateGLXPixmap(Display *display, XVisualInfo * visual, Pixmap pixmap) {} // should return GLXPixmap
void glXDestroyGLXPixmap(Display *display, void *pixmap) {} // really wants a GLXpixmap
Window glXCreateWindow(Display *display, GLXFBConfig config, Window win, int *attrib_list) {return win;} // should return GLXWindow
void glXDestroyWindow(Display *display, void *win) {} // really wants a GLXWindow
EXPORT void glXCreateGLXPixmap(Display *display, XVisualInfo * visual, Pixmap pixmap) {} // should return GLXPixmap
EXPORT void glXDestroyGLXPixmap(Display *display, void *pixmap) {} // really wants a GLXpixmap
EXPORT Window glXCreateWindow(Display *display, GLXFBConfig config, Window win, int *attrib_list) {return win;} // should return GLXWindow
EXPORT void glXDestroyWindow(Display *display, void *win) {} // really wants a GLXWindow
GLXDrawable glXGetCurrentDrawable() {
EXPORT GLXDrawable glXGetCurrentDrawable() {
if (glxContext)
return glxContext->drawable;
else
return 0;
} // this should actually return GLXDrawable.
Bool glXIsDirect(Display * display, GLXContext ctx) {
EXPORT Bool glXIsDirect(Display * display, GLXContext ctx) {
return true;
}
void glXUseXFont(Font font, int first, int count, int listBase) {
EXPORT void glXUseXFont(Font font, int first, int count, int listBase) {
/* Mostly from MesaGL-9.0.1
*
*/
@@ -1181,12 +1184,12 @@ void glXUseXFont(Font font, int first, int count, int listBase) {
// All done
}
#endif //ANDROID
void glXWaitGL() {}
void glXWaitX() {}
void glXReleaseBuffersMESA() {}
EXPORT void glXWaitGL() {}
EXPORT void glXWaitX() {}
EXPORT void glXReleaseBuffersMESA() {}
#ifndef ANDROID
/* TODO proper implementation */
int glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) {
EXPORT int glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) {
*value = 0;
switch(attribute) {
case GLX_WIDTH:
@@ -1206,10 +1209,10 @@ int glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int
return 0;
}
void glXDestroyPbuffer(Display * dpy, GLXPbuffer pbuf) {
EXPORT void glXDestroyPbuffer(Display * dpy, GLXPbuffer pbuf) {
printf("LIBGL: Warning, stub glxDestroyPBuffer called\n");
}
GLXPbuffer glXCreatePbuffer(Display * dpy, GLXFBConfig config, const int * attrib_list) {
EXPORT GLXPbuffer glXCreatePbuffer(Display * dpy, GLXFBConfig config, const int * attrib_list) {
printf("LIBGL: Warning, stub glxCreatePBuffer called\n");
return 0;
}

16
project/jni/glshim/src/glx/lookup.c
View File

@@ -4,6 +4,9 @@
#include "glx.h"
#include "../gl/directstate.h"
#define EXPORT __attribute__((visibility("default")))
//#define DEBUG_ADDRESS
extern int export_blendcolor;
@@ -42,7 +45,8 @@ void glXStub(void *x, ...) {
return;
}
void *glXGetProcAddressARB(const char *name) {
EXPORT void *glXGetProcAddressARB(const char *name) {
LOAD_EGL(eglGetProcAddress);
#ifdef DEBUG_ADDRESS
static int cnt = 0;
@@ -494,6 +498,14 @@ void *glXGetProcAddressARB(const char *name) {
_EX(glPixelStoref);
STUB(glPrioritizeTextures);
STUB(glSelectBuffer); //TODO
_EX(glMultiDrawArrays);
_EXT(glMultiDrawArrays);
_EX(glMultiDrawElements);
_EXT(glMultiDrawElements);
_EX(glPointParameteri);
_EX(glPointParameteriv);
STUB(glFogCoordPointer);
/*STUB(glEdgeFlagPointerEXT);
@@ -607,6 +619,6 @@ void *glXGetProcAddressARB(const char *name) {
return NULL;
}
void *glXGetProcAddress(const char *name) {
EXPORT void *glXGetProcAddress(const char *name) {
return glXGetProcAddressARB(name);
}

3496
project/jni/glshim/src/proxy/client/src/client.c
View File

File diff suppressed because it is too large Load Diff