blob: 4987237dc780cb0f0ba2d2610da35351076fbf68 [file] [log] [blame]
/*
* 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) {
LOGE("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[4]);
}
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[4]);
}
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[4]);
}
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[16], exponent[16]);
}
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[4]);
}
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);
}