X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=blobdiff_plain;f=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fandroid%2Fopengl%2Ftests%2Fgles_android_wrapper%2Fgles.cpp;fp=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fandroid%2Fopengl%2Ftests%2Fgles_android_wrapper%2Fgles.cpp;h=c0949c8c3cfebba66c24830fea53538cba11b5ca;hb=e26c1ec581be598521517829adba8c8dd23a768f;hp=0000000000000000000000000000000000000000;hpb=6699c1aea74eeb0eb400e6299079f0c7576f716f;p=iec.git

diff --git a/src/type3_AndroidCloud/anbox-master/android/opengl/tests/gles_android_wrapper/gles.cpp b/src/type3_AndroidCloud/anbox-master/android/opengl/tests/gles_android_wrapper/gles.cpp
new file mode 100644
index 0000000..c0949c8
--- /dev/null
+++ b/src/type3_AndroidCloud/anbox-master/android/opengl/tests/gles_android_wrapper/gles.cpp
@@ -0,0 +1,1410 @@
+/*
+* Copyright (C) 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "gles_dispatch.h"
+#include "gles_ftable.h"
+#include <EGL/egl.h>
+#include <cutils/log.h>
+
+static struct gles_dispatch *s_dispatch = NULL;
+
+void init_gles(void *gles_android)
+{
+    s_dispatch = create_gles_dispatch(gles_android);
+    if (s_dispatch == NULL) {
+        ALOGE("failed to create gles dispatch\n");
+    }
+}
+
+static struct gles_dispatch *getDispatch()
+{
+    if (!s_dispatch) {
+        fprintf(stderr,"FATAL ERROR: GLES has not been initialized\n");
+        exit(-1);
+    }
+
+    return s_dispatch;
+}
+
+__eglMustCastToProperFunctionPointerType gles_getProcAddress(const char *procname)
+{
+     for (int i=0; i<gles_num_funcs; i++) {
+         if (!strcmp(gles_funcs_by_name[i].name, procname)) {
+             return (__eglMustCastToProperFunctionPointerType)gles_funcs_by_name[i].proc;
+         }
+     }
+
+     return NULL;
+}
+
+///////////// Path-through functions ///////////////
+void glAlphaFunc(GLenum func, GLclampf ref)
+{
+     getDispatch()->glAlphaFunc(func, ref);
+}
+
+void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+     getDispatch()->glClearColor(red, green, blue, alpha);
+}
+
+void glClearDepthf(GLclampf depth)
+{
+     getDispatch()->glClearDepthf(depth);
+}
+
+void glClipPlanef(GLenum plane, const GLfloat *equation)
+{
+     getDispatch()->glClipPlanef(plane, equation);
+}
+
+void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+     getDispatch()->glColor4f(red, green, blue, alpha);
+}
+
+void glDepthRangef(GLclampf zNear, GLclampf zFar)
+{
+     getDispatch()->glDepthRangef(zNear, zFar);
+}
+
+void glFogf(GLenum pname, GLfloat param)
+{
+     getDispatch()->glFogf(pname, param);
+}
+
+void glFogfv(GLenum pname, const GLfloat *params)
+{
+     getDispatch()->glFogfv(pname, params);
+}
+
+void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+{
+     getDispatch()->glFrustumf(left, right, bottom, top, zNear, zFar);
+}
+
+void glGetClipPlanef(GLenum pname, GLfloat eqn[4])
+{
+     getDispatch()->glGetClipPlanef(pname, eqn);
+}
+
+void glGetFloatv(GLenum pname, GLfloat *params)
+{
+     getDispatch()->glGetFloatv(pname, params);
+}
+
+void glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+     getDispatch()->glGetLightfv(light, pname, params);
+}
+
+void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+     getDispatch()->glGetMaterialfv(face, pname, params);
+}
+
+void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params)
+{
+     getDispatch()->glGetTexEnvfv(env, pname, params);
+}
+
+void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+     getDispatch()->glGetTexParameterfv(target, pname, params);
+}
+
+void glLightModelf(GLenum pname, GLfloat param)
+{
+     getDispatch()->glLightModelf(pname, param);
+}
+
+void glLightModelfv(GLenum pname, const GLfloat *params)
+{
+     getDispatch()->glLightModelfv(pname, params);
+}
+
+void glLightf(GLenum light, GLenum pname, GLfloat param)
+{
+     getDispatch()->glLightf(light, pname, param);
+}
+
+void glLightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+     getDispatch()->glLightfv(light, pname, params);
+}
+
+void glLineWidth(GLfloat width)
+{
+     getDispatch()->glLineWidth(width);
+}
+
+void glLoadMatrixf(const GLfloat *m)
+{
+     getDispatch()->glLoadMatrixf(m);
+}
+
+void glMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+     getDispatch()->glMaterialf(face, pname, param);
+}
+
+void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+     getDispatch()->glMaterialfv(face, pname, params);
+}
+
+void glMultMatrixf(const GLfloat *m)
+{
+     getDispatch()->glMultMatrixf(m);
+}
+
+void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+     getDispatch()->glMultiTexCoord4f(target, s, t, r, q);
+}
+
+void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+     getDispatch()->glNormal3f(nx, ny, nz);
+}
+
+void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+{
+     getDispatch()->glOrthof(left, right, bottom, top, zNear, zFar);
+}
+
+void glPointParameterf(GLenum pname, GLfloat param)
+{
+     getDispatch()->glPointParameterf(pname, param);
+}
+
+void glPointParameterfv(GLenum pname, const GLfloat *params)
+{
+     getDispatch()->glPointParameterfv(pname, params);
+}
+
+void glPointSize(GLfloat size)
+{
+     getDispatch()->glPointSize(size);
+}
+
+void glPolygonOffset(GLfloat factor, GLfloat units)
+{
+     getDispatch()->glPolygonOffset(factor, units);
+}
+
+void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+     getDispatch()->glRotatef(angle, x, y, z);
+}
+
+void glScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+     getDispatch()->glScalef(x, y, z);
+}
+
+void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+     getDispatch()->glTexEnvf(target, pname, param);
+}
+
+void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+     getDispatch()->glTexEnvfv(target, pname, params);
+}
+
+void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+     getDispatch()->glTexParameterf(target, pname, param);
+}
+
+void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+     getDispatch()->glTexParameterfv(target, pname, params);
+}
+
+void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+     getDispatch()->glTranslatef(x, y, z);
+}
+
+void glActiveTexture(GLenum texture)
+{
+     getDispatch()->glActiveTexture(texture);
+}
+
+void glAlphaFuncx(GLenum func, GLclampx ref)
+{
+     getDispatch()->glAlphaFuncx(func, ref);
+}
+
+void glBindBuffer(GLenum target, GLuint buffer)
+{
+     getDispatch()->glBindBuffer(target, buffer);
+}
+
+void glBindTexture(GLenum target, GLuint texture)
+{
+     getDispatch()->glBindTexture(target, texture);
+}
+
+void glBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+     getDispatch()->glBlendFunc(sfactor, dfactor);
+}
+
+void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
+{
+     getDispatch()->glBufferData(target, size, data, usage);
+}
+
+void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
+{
+     getDispatch()->glBufferSubData(target, offset, size, data);
+}
+
+void glClear(GLbitfield mask)
+{
+     getDispatch()->glClear(mask);
+}
+
+void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
+{
+     getDispatch()->glClearColorx(red, green, blue, alpha);
+}
+
+void glClearDepthx(GLclampx depth)
+{
+     getDispatch()->glClearDepthx(depth);
+}
+
+void glClearStencil(GLint s)
+{
+     getDispatch()->glClearStencil(s);
+}
+
+void glClientActiveTexture(GLenum texture)
+{
+     getDispatch()->glClientActiveTexture(texture);
+}
+
+void glClipPlanex(GLenum plane, const GLfixed *equation)
+{
+     getDispatch()->glClipPlanex(plane, equation);
+}
+
+void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+     getDispatch()->glColor4ub(red, green, blue, alpha);
+}
+
+void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+     getDispatch()->glColor4x(red, green, blue, alpha);
+}
+
+void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+     getDispatch()->glColorMask(red, green, blue, alpha);
+}
+
+void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+     getDispatch()->glColorPointer(size, type, stride, pointer);
+}
+
+void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
+{
+     getDispatch()->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+}
+
+void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
+{
+     getDispatch()->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+}
+
+void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+     getDispatch()->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+}
+
+void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+     getDispatch()->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+}
+
+void glCullFace(GLenum mode)
+{
+     getDispatch()->glCullFace(mode);
+}
+
+void glDeleteBuffers(GLsizei n, const GLuint *buffers)
+{
+     getDispatch()->glDeleteBuffers(n, buffers);
+}
+
+void glDeleteTextures(GLsizei n, const GLuint *textures)
+{
+     getDispatch()->glDeleteTextures(n, textures);
+}
+
+void glDepthFunc(GLenum func)
+{
+     getDispatch()->glDepthFunc(func);
+}
+
+void glDepthMask(GLboolean flag)
+{
+     getDispatch()->glDepthMask(flag);
+}
+
+void glDepthRangex(GLclampx zNear, GLclampx zFar)
+{
+     getDispatch()->glDepthRangex(zNear, zFar);
+}
+
+void glDisable(GLenum cap)
+{
+     getDispatch()->glDisable(cap);
+}
+
+void glDisableClientState(GLenum array)
+{
+     getDispatch()->glDisableClientState(array);
+}
+
+void glDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+     getDispatch()->glDrawArrays(mode, first, count);
+}
+
+void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
+{
+     getDispatch()->glDrawElements(mode, count, type, indices);
+}
+
+void glEnable(GLenum cap)
+{
+     getDispatch()->glEnable(cap);
+}
+
+void glEnableClientState(GLenum array)
+{
+     getDispatch()->glEnableClientState(array);
+}
+
+void glFinish()
+{
+     getDispatch()->glFinish();
+}
+
+void glFlush()
+{
+     getDispatch()->glFlush();
+}
+
+void glFogx(GLenum pname, GLfixed param)
+{
+     getDispatch()->glFogx(pname, param);
+}
+
+void glFogxv(GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glFogxv(pname, params);
+}
+
+void glFrontFace(GLenum mode)
+{
+     getDispatch()->glFrontFace(mode);
+}
+
+void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+{
+     getDispatch()->glFrustumx(left, right, bottom, top, zNear, zFar);
+}
+
+void glGetBooleanv(GLenum pname, GLboolean *params)
+{
+     getDispatch()->glGetBooleanv(pname, params);
+}
+
+void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+     getDispatch()->glGetBufferParameteriv(target, pname, params);
+}
+
+void glGetClipPlanex(GLenum pname, GLfixed eqn[4])
+{
+     getDispatch()->glGetClipPlanex(pname, eqn);
+}
+
+void glGenBuffers(GLsizei n, GLuint *buffers)
+{
+     getDispatch()->glGenBuffers(n, buffers);
+}
+
+void glGenTextures(GLsizei n, GLuint *textures)
+{
+     getDispatch()->glGenTextures(n, textures);
+}
+
+GLenum glGetError()
+{
+     return getDispatch()->glGetError();
+}
+
+void glGetFixedv(GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetFixedv(pname, params);
+}
+
+void glGetIntegerv(GLenum pname, GLint *params)
+{
+     getDispatch()->glGetIntegerv(pname, params);
+}
+
+void glGetLightxv(GLenum light, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetLightxv(light, pname, params);
+}
+
+void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetMaterialxv(face, pname, params);
+}
+
+void glGetPointerv(GLenum pname, GLvoid **params)
+{
+     getDispatch()->glGetPointerv(pname, params);
+}
+
+const GLubyte* glGetString(GLenum name)
+{
+     return getDispatch()->glGetString(name);
+}
+
+void glGetTexEnviv(GLenum env, GLenum pname, GLint *params)
+{
+     getDispatch()->glGetTexEnviv(env, pname, params);
+}
+
+void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetTexEnvxv(env, pname, params);
+}
+
+void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+     getDispatch()->glGetTexParameteriv(target, pname, params);
+}
+
+void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetTexParameterxv(target, pname, params);
+}
+
+void glHint(GLenum target, GLenum mode)
+{
+     getDispatch()->glHint(target, mode);
+}
+
+GLboolean glIsBuffer(GLuint buffer)
+{
+     return getDispatch()->glIsBuffer(buffer);
+}
+
+GLboolean glIsEnabled(GLenum cap)
+{
+     return getDispatch()->glIsEnabled(cap);
+}
+
+GLboolean glIsTexture(GLuint texture)
+{
+     return getDispatch()->glIsTexture(texture);
+}
+
+void glLightModelx(GLenum pname, GLfixed param)
+{
+     getDispatch()->glLightModelx(pname, param);
+}
+
+void glLightModelxv(GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glLightModelxv(pname, params);
+}
+
+void glLightx(GLenum light, GLenum pname, GLfixed param)
+{
+     getDispatch()->glLightx(light, pname, param);
+}
+
+void glLightxv(GLenum light, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glLightxv(light, pname, params);
+}
+
+void glLineWidthx(GLfixed width)
+{
+     getDispatch()->glLineWidthx(width);
+}
+
+void glLoadIdentity()
+{
+     getDispatch()->glLoadIdentity();
+}
+
+void glLoadMatrixx(const GLfixed *m)
+{
+     getDispatch()->glLoadMatrixx(m);
+}
+
+void glLogicOp(GLenum opcode)
+{
+     getDispatch()->glLogicOp(opcode);
+}
+
+void glMaterialx(GLenum face, GLenum pname, GLfixed param)
+{
+     getDispatch()->glMaterialx(face, pname, param);
+}
+
+void glMaterialxv(GLenum face, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glMaterialxv(face, pname, params);
+}
+
+void glMatrixMode(GLenum mode)
+{
+     getDispatch()->glMatrixMode(mode);
+}
+
+void glMultMatrixx(const GLfixed *m)
+{
+     getDispatch()->glMultMatrixx(m);
+}
+
+void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
+{
+     getDispatch()->glMultiTexCoord4x(target, s, t, r, q);
+}
+
+void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
+{
+     getDispatch()->glNormal3x(nx, ny, nz);
+}
+
+void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+     getDispatch()->glNormalPointer(type, stride, pointer);
+}
+
+void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+{
+     getDispatch()->glOrthox(left, right, bottom, top, zNear, zFar);
+}
+
+void glPixelStorei(GLenum pname, GLint param)
+{
+     getDispatch()->glPixelStorei(pname, param);
+}
+
+void glPointParameterx(GLenum pname, GLfixed param)
+{
+     getDispatch()->glPointParameterx(pname, param);
+}
+
+void glPointParameterxv(GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glPointParameterxv(pname, params);
+}
+
+void glPointSizex(GLfixed size)
+{
+     getDispatch()->glPointSizex(size);
+}
+
+void glPolygonOffsetx(GLfixed factor, GLfixed units)
+{
+     getDispatch()->glPolygonOffsetx(factor, units);
+}
+
+void glPopMatrix()
+{
+     getDispatch()->glPopMatrix();
+}
+
+void glPushMatrix()
+{
+     getDispatch()->glPushMatrix();
+}
+
+void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
+{
+     getDispatch()->glReadPixels(x, y, width, height, format, type, pixels);
+}
+
+void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
+{
+     getDispatch()->glRotatex(angle, x, y, z);
+}
+
+void glSampleCoverage(GLclampf value, GLboolean invert)
+{
+     getDispatch()->glSampleCoverage(value, invert);
+}
+
+void glSampleCoveragex(GLclampx value, GLboolean invert)
+{
+     getDispatch()->glSampleCoveragex(value, invert);
+}
+
+void glScalex(GLfixed x, GLfixed y, GLfixed z)
+{
+     getDispatch()->glScalex(x, y, z);
+}
+
+void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+     getDispatch()->glScissor(x, y, width, height);
+}
+
+void glShadeModel(GLenum mode)
+{
+     getDispatch()->glShadeModel(mode);
+}
+
+void glStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+     getDispatch()->glStencilFunc(func, ref, mask);
+}
+
+void glStencilMask(GLuint mask)
+{
+     getDispatch()->glStencilMask(mask);
+}
+
+void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+     getDispatch()->glStencilOp(fail, zfail, zpass);
+}
+
+void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+     getDispatch()->glTexCoordPointer(size, type, stride, pointer);
+}
+
+void glTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+     getDispatch()->glTexEnvi(target, pname, param);
+}
+
+void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
+{
+     getDispatch()->glTexEnvx(target, pname, param);
+}
+
+void glTexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+     getDispatch()->glTexEnviv(target, pname, params);
+}
+
+void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glTexEnvxv(target, pname, params);
+}
+
+void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+{
+     getDispatch()->glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+}
+
+void glTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+     getDispatch()->glTexParameteri(target, pname, param);
+}
+
+void glTexParameterx(GLenum target, GLenum pname, GLfixed param)
+{
+     getDispatch()->glTexParameterx(target, pname, param);
+}
+
+void glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+     getDispatch()->glTexParameteriv(target, pname, params);
+}
+
+void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glTexParameterxv(target, pname, params);
+}
+
+void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
+{
+     getDispatch()->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+}
+
+void glTranslatex(GLfixed x, GLfixed y, GLfixed z)
+{
+     getDispatch()->glTranslatex(x, y, z);
+}
+
+void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+     getDispatch()->glVertexPointer(size, type, stride, pointer);
+}
+
+void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+     getDispatch()->glViewport(x, y, width, height);
+}
+
+void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+     getDispatch()->glPointSizePointerOES(type, stride, pointer);
+}
+
+void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)
+{
+     getDispatch()->glBlendEquationSeparateOES(modeRGB, modeAlpha);
+}
+
+void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+{
+     getDispatch()->glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void glBlendEquationOES(GLenum mode)
+{
+     getDispatch()->glBlendEquationOES(mode);
+}
+
+void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
+{
+     getDispatch()->glDrawTexsOES(x, y, z, width, height);
+}
+
+void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
+{
+     getDispatch()->glDrawTexiOES(x, y, z, width, height);
+}
+
+void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
+{
+     getDispatch()->glDrawTexxOES(x, y, z, width, height);
+}
+
+void glDrawTexsvOES(const GLshort *coords)
+{
+     getDispatch()->glDrawTexsvOES(coords);
+}
+
+void glDrawTexivOES(const GLint *coords)
+{
+     getDispatch()->glDrawTexivOES(coords);
+}
+
+void glDrawTexxvOES(const GLfixed *coords)
+{
+     getDispatch()->glDrawTexxvOES(coords);
+}
+
+void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
+{
+     getDispatch()->glDrawTexfOES(x, y, z, width, height);
+}
+
+void glDrawTexfvOES(const GLfloat *coords)
+{
+     getDispatch()->glDrawTexfvOES(coords);
+}
+
+void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
+{
+     getDispatch()->glEGLImageTargetTexture2DOES(target, image);
+}
+
+void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
+{
+     getDispatch()->glEGLImageTargetRenderbufferStorageOES(target, image);
+}
+
+void glAlphaFuncxOES(GLenum func, GLclampx ref)
+{
+     getDispatch()->glAlphaFuncxOES(func, ref);
+}
+
+void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
+{
+     getDispatch()->glClearColorxOES(red, green, blue, alpha);
+}
+
+void glClearDepthxOES(GLclampx depth)
+{
+     getDispatch()->glClearDepthxOES(depth);
+}
+
+void glClipPlanexOES(GLenum plane, const GLfixed *equation)
+{
+     getDispatch()->glClipPlanexOES(plane, equation);
+}
+
+void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+     getDispatch()->glColor4xOES(red, green, blue, alpha);
+}
+
+void glDepthRangexOES(GLclampx zNear, GLclampx zFar)
+{
+     getDispatch()->glDepthRangexOES(zNear, zFar);
+}
+
+void glFogxOES(GLenum pname, GLfixed param)
+{
+     getDispatch()->glFogxOES(pname, param);
+}
+
+void glFogxvOES(GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glFogxvOES(pname, params);
+}
+
+void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+{
+     getDispatch()->glFrustumxOES(left, right, bottom, top, zNear, zFar);
+}
+
+void glGetClipPlanexOES(GLenum pname, GLfixed eqn[4])
+{
+     getDispatch()->glGetClipPlanexOES(pname, eqn);
+}
+
+void glGetFixedvOES(GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetFixedvOES(pname, params);
+}
+
+void glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetLightxvOES(light, pname, params);
+}
+
+void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetMaterialxvOES(face, pname, params);
+}
+
+void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetTexEnvxvOES(env, pname, params);
+}
+
+void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetTexParameterxvOES(target, pname, params);
+}
+
+void glLightModelxOES(GLenum pname, GLfixed param)
+{
+     getDispatch()->glLightModelxOES(pname, param);
+}
+
+void glLightModelxvOES(GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glLightModelxvOES(pname, params);
+}
+
+void glLightxOES(GLenum light, GLenum pname, GLfixed param)
+{
+     getDispatch()->glLightxOES(light, pname, param);
+}
+
+void glLightxvOES(GLenum light, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glLightxvOES(light, pname, params);
+}
+
+void glLineWidthxOES(GLfixed width)
+{
+     getDispatch()->glLineWidthxOES(width);
+}
+
+void glLoadMatrixxOES(const GLfixed *m)
+{
+     getDispatch()->glLoadMatrixxOES(m);
+}
+
+void glMaterialxOES(GLenum face, GLenum pname, GLfixed param)
+{
+     getDispatch()->glMaterialxOES(face, pname, param);
+}
+
+void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glMaterialxvOES(face, pname, params);
+}
+
+void glMultMatrixxOES(const GLfixed *m)
+{
+     getDispatch()->glMultMatrixxOES(m);
+}
+
+void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
+{
+     getDispatch()->glMultiTexCoord4xOES(target, s, t, r, q);
+}
+
+void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz)
+{
+     getDispatch()->glNormal3xOES(nx, ny, nz);
+}
+
+void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+{
+     getDispatch()->glOrthoxOES(left, right, bottom, top, zNear, zFar);
+}
+
+void glPointParameterxOES(GLenum pname, GLfixed param)
+{
+     getDispatch()->glPointParameterxOES(pname, param);
+}
+
+void glPointParameterxvOES(GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glPointParameterxvOES(pname, params);
+}
+
+void glPointSizexOES(GLfixed size)
+{
+     getDispatch()->glPointSizexOES(size);
+}
+
+void glPolygonOffsetxOES(GLfixed factor, GLfixed units)
+{
+     getDispatch()->glPolygonOffsetxOES(factor, units);
+}
+
+void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
+{
+     getDispatch()->glRotatexOES(angle, x, y, z);
+}
+
+void glSampleCoveragexOES(GLclampx value, GLboolean invert)
+{
+     getDispatch()->glSampleCoveragexOES(value, invert);
+}
+
+void glScalexOES(GLfixed x, GLfixed y, GLfixed z)
+{
+     getDispatch()->glScalexOES(x, y, z);
+}
+
+void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param)
+{
+     getDispatch()->glTexEnvxOES(target, pname, param);
+}
+
+void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glTexEnvxvOES(target, pname, params);
+}
+
+void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param)
+{
+     getDispatch()->glTexParameterxOES(target, pname, param);
+}
+
+void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glTexParameterxvOES(target, pname, params);
+}
+
+void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z)
+{
+     getDispatch()->glTranslatexOES(x, y, z);
+}
+
+GLboolean glIsRenderbufferOES(GLuint renderbuffer)
+{
+     return getDispatch()->glIsRenderbufferOES(renderbuffer);
+}
+
+void glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
+{
+     getDispatch()->glBindRenderbufferOES(target, renderbuffer);
+}
+
+void glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
+{
+     getDispatch()->glDeleteRenderbuffersOES(n, renderbuffers);
+}
+
+void glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
+{
+     getDispatch()->glGenRenderbuffersOES(n, renderbuffers);
+}
+
+void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+{
+     getDispatch()->glRenderbufferStorageOES(target, internalformat, width, height);
+}
+
+void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
+{
+     getDispatch()->glGetRenderbufferParameterivOES(target, pname, params);
+}
+
+GLboolean glIsFramebufferOES(GLuint framebuffer)
+{
+     return getDispatch()->glIsFramebufferOES(framebuffer);
+}
+
+void glBindFramebufferOES(GLenum target, GLuint framebuffer)
+{
+     getDispatch()->glBindFramebufferOES(target, framebuffer);
+}
+
+void glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
+{
+     getDispatch()->glDeleteFramebuffersOES(n, framebuffers);
+}
+
+void glGenFramebuffersOES(GLsizei n, GLuint *framebuffers)
+{
+     getDispatch()->glGenFramebuffersOES(n, framebuffers);
+}
+
+GLenum glCheckFramebufferStatusOES(GLenum target)
+{
+     return getDispatch()->glCheckFramebufferStatusOES(target);
+}
+
+void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+{
+     getDispatch()->glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
+}
+
+void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+{
+     getDispatch()->glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
+}
+
+void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params)
+{
+     getDispatch()->glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
+}
+
+void glGenerateMipmapOES(GLenum target)
+{
+     getDispatch()->glGenerateMipmapOES(target);
+}
+
+void* glMapBufferOES(GLenum target, GLenum access)
+{
+     return getDispatch()->glMapBufferOES(target, access);
+}
+
+GLboolean glUnmapBufferOES(GLenum target)
+{
+     return getDispatch()->glUnmapBufferOES(target);
+}
+
+void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid **ptr)
+{
+     getDispatch()->glGetBufferPointervOES(target, pname, ptr);
+}
+
+void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex)
+{
+     getDispatch()->glCurrentPaletteMatrixOES(matrixpaletteindex);
+}
+
+void glLoadPaletteFromModelViewMatrixOES()
+{
+     getDispatch()->glLoadPaletteFromModelViewMatrixOES();
+}
+
+void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+     getDispatch()->glMatrixIndexPointerOES(size, type, stride, pointer);
+}
+
+void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+     getDispatch()->glWeightPointerOES(size, type, stride, pointer);
+}
+
+GLbitfield glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16])
+{
+     return getDispatch()->glQueryMatrixxOES(mantissa, exponent);
+}
+
+void glDepthRangefOES(GLclampf zNear, GLclampf zFar)
+{
+     getDispatch()->glDepthRangefOES(zNear, zFar);
+}
+
+void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+{
+     getDispatch()->glFrustumfOES(left, right, bottom, top, zNear, zFar);
+}
+
+void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+{
+     getDispatch()->glOrthofOES(left, right, bottom, top, zNear, zFar);
+}
+
+void glClipPlanefOES(GLenum plane, const GLfloat *equation)
+{
+     getDispatch()->glClipPlanefOES(plane, equation);
+}
+
+void glGetClipPlanefOES(GLenum pname, GLfloat eqn[4])
+{
+     getDispatch()->glGetClipPlanefOES(pname, eqn);
+}
+
+void glClearDepthfOES(GLclampf depth)
+{
+     getDispatch()->glClearDepthfOES(depth);
+}
+
+void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param)
+{
+     getDispatch()->glTexGenfOES(coord, pname, param);
+}
+
+void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
+{
+     getDispatch()->glTexGenfvOES(coord, pname, params);
+}
+
+void glTexGeniOES(GLenum coord, GLenum pname, GLint param)
+{
+     getDispatch()->glTexGeniOES(coord, pname, param);
+}
+
+void glTexGenivOES(GLenum coord, GLenum pname, const GLint *params)
+{
+     getDispatch()->glTexGenivOES(coord, pname, params);
+}
+
+void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
+{
+     getDispatch()->glTexGenxOES(coord, pname, param);
+}
+
+void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
+{
+     getDispatch()->glTexGenxvOES(coord, pname, params);
+}
+
+void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
+{
+     getDispatch()->glGetTexGenfvOES(coord, pname, params);
+}
+
+void glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
+{
+     getDispatch()->glGetTexGenivOES(coord, pname, params);
+}
+
+void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
+{
+     getDispatch()->glGetTexGenxvOES(coord, pname, params);
+}
+
+void glBindVertexArrayOES(GLuint array)
+{
+     getDispatch()->glBindVertexArrayOES(array);
+}
+
+void glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
+{
+     getDispatch()->glDeleteVertexArraysOES(n, arrays);
+}
+
+void glGenVertexArraysOES(GLsizei n, GLuint *arrays)
+{
+     getDispatch()->glGenVertexArraysOES(n, arrays);
+}
+
+GLboolean glIsVertexArrayOES(GLuint array)
+{
+     return getDispatch()->glIsVertexArrayOES(array);
+}
+
+void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments)
+{
+     getDispatch()->glDiscardFramebufferEXT(target, numAttachments, attachments);
+}
+
+void glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount)
+{
+     getDispatch()->glMultiDrawArraysEXT(mode, first, count, primcount);
+}
+
+void glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount)
+{
+     getDispatch()->glMultiDrawElementsEXT(mode, count, type, indices, primcount);
+}
+
+void glClipPlanefIMG(GLenum p, const GLfloat *eqn)
+{
+     getDispatch()->glClipPlanefIMG(p, eqn);
+}
+
+void glClipPlanexIMG(GLenum p, const GLfixed *eqn)
+{
+     getDispatch()->glClipPlanexIMG(p, eqn);
+}
+
+void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
+{
+     getDispatch()->glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
+}
+
+void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
+{
+     getDispatch()->glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
+}
+
+void glDeleteFencesNV(GLsizei n, const GLuint *fences)
+{
+     getDispatch()->glDeleteFencesNV(n, fences);
+}
+
+void glGenFencesNV(GLsizei n, GLuint *fences)
+{
+     getDispatch()->glGenFencesNV(n, fences);
+}
+
+GLboolean glIsFenceNV(GLuint fence)
+{
+     return getDispatch()->glIsFenceNV(fence);
+}
+
+GLboolean glTestFenceNV(GLuint fence)
+{
+     return getDispatch()->glTestFenceNV(fence);
+}
+
+void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
+{
+     getDispatch()->glGetFenceivNV(fence, pname, params);
+}
+
+void glFinishFenceNV(GLuint fence)
+{
+     getDispatch()->glFinishFenceNV(fence);
+}
+
+void glSetFenceNV(GLuint fence, GLenum condition)
+{
+     getDispatch()->glSetFenceNV(fence, condition);
+}
+
+void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls)
+{
+     getDispatch()->glGetDriverControlsQCOM(num, size, driverControls);
+}
+
+void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString)
+{
+     getDispatch()->glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString);
+}
+
+void glEnableDriverControlQCOM(GLuint driverControl)
+{
+     getDispatch()->glEnableDriverControlQCOM(driverControl);
+}
+
+void glDisableDriverControlQCOM(GLuint driverControl)
+{
+     getDispatch()->glDisableDriverControlQCOM(driverControl);
+}
+
+void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures)
+{
+     getDispatch()->glExtGetTexturesQCOM(textures, maxTextures, numTextures);
+}
+
+void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers)
+{
+     getDispatch()->glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
+}
+
+void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers)
+{
+     getDispatch()->glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
+}
+
+void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers)
+{
+     getDispatch()->glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
+}
+
+void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params)
+{
+     getDispatch()->glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params);
+}
+
+void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
+{
+     getDispatch()->glExtTexObjectStateOverrideiQCOM(target, pname, param);
+}
+
+void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels)
+{
+     getDispatch()->glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
+}
+
+void glExtGetBufferPointervQCOM(GLenum target, GLvoid **params)
+{
+     getDispatch()->glExtGetBufferPointervQCOM(target, params);
+}
+
+void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders)
+{
+     getDispatch()->glExtGetShadersQCOM(shaders, maxShaders, numShaders);
+}
+
+void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms)
+{
+     getDispatch()->glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
+}
+
+GLboolean glExtIsProgramBinaryQCOM(GLuint program)
+{
+     return getDispatch()->glExtIsProgramBinaryQCOM(program);
+}
+
+void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length)
+{
+     getDispatch()->glExtGetProgramBinarySourceQCOM(program, shadertype, source, length);
+}
+
+void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
+{
+     getDispatch()->glStartTilingQCOM(x, y, width, height, preserveMask);
+}
+
+void glEndTilingQCOM(GLbitfield preserveMask)
+{
+     getDispatch()->glEndTilingQCOM(preserveMask);
+}
+