/* * 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 #include #include #include "gles_dispatch.h" #include "gles_ftable.h" #include #include 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; iglAlphaFunc(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); }