src/type3_AndroidCloud/anbox-master/android/opengl/system/GLESv1_enc/gl_entry.cpp

   1 // Generated Code - DO NOT EDIT !!
   2 // generated by 'emugen'
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include "gl_client_context.h"
   6
   7 #ifndef GL_TRUE
   8 extern "C" {
   9         void glAlphaFunc(GLenum func, GLclampf ref);
  10         void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
  11         void glClearDepthf(GLclampf depth);
  12         void glClipPlanef(GLenum plane, const GLfloat* equation);
  13         void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  14         void glDepthRangef(GLclampf zNear, GLclampf zFar);
  15         void glFogf(GLenum pname, GLfloat param);
  16         void glFogfv(GLenum pname, const GLfloat* params);
  17         void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
  18         void glGetClipPlanef(GLenum pname, GLfloat* eqn);
  19         void glGetFloatv(GLenum pname, GLfloat* params);
  20         void glGetLightfv(GLenum light, GLenum pname, GLfloat* params);
  21         void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params);
  22         void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params);
  23         void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);
  24         void glLightModelf(GLenum pname, GLfloat param);
  25         void glLightModelfv(GLenum pname, const GLfloat* params);
  26         void glLightf(GLenum light, GLenum pname, GLfloat param);
  27         void glLightfv(GLenum light, GLenum pname, const GLfloat* params);
  28         void glLineWidth(GLfloat width);
  29         void glLoadMatrixf(const GLfloat* m);
  30         void glMaterialf(GLenum face, GLenum pname, GLfloat param);
  31         void glMaterialfv(GLenum face, GLenum pname, const GLfloat* params);
  32         void glMultMatrixf(const GLfloat* m);
  33         void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
  34         void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
  35         void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
  36         void glPointParameterf(GLenum pname, GLfloat param);
  37         void glPointParameterfv(GLenum pname, const GLfloat* params);
  38         void glPointSize(GLfloat size);
  39         void glPolygonOffset(GLfloat factor, GLfloat units);
  40         void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
  41         void glScalef(GLfloat x, GLfloat y, GLfloat z);
  42         void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
  43         void glTexEnvfv(GLenum target, GLenum pname, const GLfloat* params);
  44         void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
  45         void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
  46         void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
  47         void glActiveTexture(GLenum texture);
  48         void glAlphaFuncx(GLenum func, GLclampx ref);
  49         void glBindBuffer(GLenum target, GLuint buffer);
  50         void glBindTexture(GLenum target, GLuint texture);
  51         void glBlendFunc(GLenum sfactor, GLenum dfactor);
  52         void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
  53         void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
  54         void glClear(GLbitfield mask);
  55         void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
  56         void glClearDepthx(GLclampx depth);
  57         void glClearStencil(GLint s);
  58         void glClientActiveTexture(GLenum texture);
  59         void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
  60         void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
  61         void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
  62         void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
  63         void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data);
  64         void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data);
  65         void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
  66         void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
  67         void glCullFace(GLenum mode);
  68         void glDeleteBuffers(GLsizei n, const GLuint* buffers);
  69         void glDeleteTextures(GLsizei n, const GLuint* textures);
  70         void glDepthFunc(GLenum func);
  71         void glDepthMask(GLboolean flag);
  72         void glDepthRangex(GLclampx zNear, GLclampx zFar);
  73         void glDisable(GLenum cap);
  74         void glDisableClientState(GLenum array);
  75         void glDrawArrays(GLenum mode, GLint first, GLsizei count);
  76         void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
  77         void glEnable(GLenum cap);
  78         void glEnableClientState(GLenum array);
  79         void glFinish();
  80         void glFlush();
  81         void glFogx(GLenum pname, GLfixed param);
  82         void glFogxv(GLenum pname, const GLfixed* params);
  83         void glFrontFace(GLenum mode);
  84         void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
  85         void glGetBooleanv(GLenum pname, GLboolean* params);
  86         void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
  87         void glClipPlanex(GLenum pname, const GLfixed* eqn);
  88         void glGenBuffers(GLsizei n, GLuint* buffers);
  89         void glGenTextures(GLsizei n, GLuint* textures);
  90         GLenum glGetError();
  91         void glGetFixedv(GLenum pname, GLfixed* params);
  92         void glGetIntegerv(GLenum pname, GLint* params);
  93         void glGetLightxv(GLenum light, GLenum pname, GLfixed* params);
  94         void glGetMaterialxv(GLenum face, GLenum pname, GLfixed* params);
  95         void glGetPointerv(GLenum pname, GLvoid** params);
  96         const GLubyte* glGetString(GLenum name);
  97         void glGetTexEnviv(GLenum env, GLenum pname, GLint* params);
  98         void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed* params);
  99         void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params);
 100         void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed* params);
 101         void glHint(GLenum target, GLenum mode);
 102         GLboolean glIsBuffer(GLuint buffer);
 103         GLboolean glIsEnabled(GLenum cap);
 104         GLboolean glIsTexture(GLuint texture);
 105         void glLightModelx(GLenum pname, GLfixed param);
 106         void glLightModelxv(GLenum pname, const GLfixed* params);
 107         void glLightx(GLenum light, GLenum pname, GLfixed param);
 108         void glLightxv(GLenum light, GLenum pname, const GLfixed* params);
 109         void glLineWidthx(GLfixed width);
 110         void glLoadIdentity();
 111         void glLoadMatrixx(const GLfixed* m);
 112         void glLogicOp(GLenum opcode);
 113         void glMaterialx(GLenum face, GLenum pname, GLfixed param);
 114         void glMaterialxv(GLenum face, GLenum pname, const GLfixed* params);
 115         void glMatrixMode(GLenum mode);
 116         void glMultMatrixx(const GLfixed* m);
 117         void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
 118         void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz);
 119         void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer);
 120         void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
 121         void glPixelStorei(GLenum pname, GLint param);
 122         void glPointParameterx(GLenum pname, GLfixed param);
 123         void glPointParameterxv(GLenum pname, const GLfixed* params);
 124         void glPointSizex(GLfixed size);
 125         void glPolygonOffsetx(GLfixed factor, GLfixed units);
 126         void glPopMatrix();
 127         void glPushMatrix();
 128         void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
 129         void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
 130         void glSampleCoverage(GLclampf value, GLboolean invert);
 131         void glSampleCoveragex(GLclampx value, GLboolean invert);
 132         void glScalex(GLfixed x, GLfixed y, GLfixed z);
 133         void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
 134         void glShadeModel(GLenum mode);
 135         void glStencilFunc(GLenum func, GLint ref, GLuint mask);
 136         void glStencilMask(GLuint mask);
 137         void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
 138         void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
 139         void glTexEnvi(GLenum target, GLenum pname, GLint param);
 140         void glTexEnvx(GLenum target, GLenum pname, GLfixed param);
 141         void glTexEnviv(GLenum target, GLenum pname, const GLint* params);
 142         void glTexEnvxv(GLenum target, GLenum pname, const GLfixed* params);
 143         void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
 144         void glTexParameteri(GLenum target, GLenum pname, GLint param);
 145         void glTexParameterx(GLenum target, GLenum pname, GLfixed param);
 146         void glTexParameteriv(GLenum target, GLenum pname, const GLint* params);
 147         void glTexParameterxv(GLenum target, GLenum pname, const GLfixed* params);
 148         void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
 149         void glTranslatex(GLfixed x, GLfixed y, GLfixed z);
 150         void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
 151         void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
 152         void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid* pointer);
 153         void glVertexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset);
 154         void glColorPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset);
 155         void glNormalPointerOffset(GLenum type, GLsizei stride, GLuint offset);
 156         void glPointSizePointerOffset(GLenum type, GLsizei stride, GLuint offset);
 157         void glTexCoordPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset);
 158         void glWeightPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset);
 159         void glMatrixIndexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset);
 160         void glVertexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
 161         void glColorPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
 162         void glNormalPointerData(GLenum type, GLsizei stride, void* data, GLuint datalen);
 163         void glTexCoordPointerData(GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
 164         void glPointSizePointerData(GLenum type, GLsizei stride, void* data, GLuint datalen);
 165         void glWeightPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
 166         void glMatrixIndexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
 167         void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset);
 168         void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen);
 169         void glGetCompressedTextureFormats(int count, GLint* formats);
 170         int glFinishRoundTrip();
 171         void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha);
 172         void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
 173         void glBlendEquationOES(GLenum mode);
 174         void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
 175         void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height);
 176         void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
 177         void glDrawTexsvOES(const GLshort* coords);
 178         void glDrawTexivOES(const GLint* coords);
 179         void glDrawTexxvOES(const GLfixed* coords);
 180         void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
 181         void glDrawTexfvOES(const GLfloat* coords);
 182         void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);
 183         void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image);
 184         void glAlphaFuncxOES(GLenum func, GLclampx ref);
 185         void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
 186         void glClearDepthxOES(GLclampx depth);
 187         void glClipPlanexOES(GLenum plane, const GLfixed* equation);
 188         void glClipPlanexIMG(GLenum plane, const GLfixed* equation);
 189         void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
 190         void glDepthRangexOES(GLclampx zNear, GLclampx zFar);
 191         void glFogxOES(GLenum pname, GLfixed param);
 192         void glFogxvOES(GLenum pname, const GLfixed* params);
 193         void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
 194         void glGetClipPlanexOES(GLenum pname, GLfixed* eqn);
 195         void glGetClipPlanex(GLenum pname, GLfixed* eqn);
 196         void glGetFixedvOES(GLenum pname, GLfixed* params);
 197         void glGetLightxvOES(GLenum light, GLenum pname, GLfixed* params);
 198         void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed* params);
 199         void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed* params);
 200         void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed* params);
 201         void glLightModelxOES(GLenum pname, GLfixed param);
 202         void glLightModelxvOES(GLenum pname, const GLfixed* params);
 203         void glLightxOES(GLenum light, GLenum pname, GLfixed param);
 204         void glLightxvOES(GLenum light, GLenum pname, const GLfixed* params);
 205         void glLineWidthxOES(GLfixed width);
 206         void glLoadMatrixxOES(const GLfixed* m);
 207         void glMaterialxOES(GLenum face, GLenum pname, GLfixed param);
 208         void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed* params);
 209         void glMultMatrixxOES(const GLfixed* m);
 210         void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
 211         void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz);
 212         void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
 213         void glPointParameterxOES(GLenum pname, GLfixed param);
 214         void glPointParameterxvOES(GLenum pname, const GLfixed* params);
 215         void glPointSizexOES(GLfixed size);
 216         void glPolygonOffsetxOES(GLfixed factor, GLfixed units);
 217         void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
 218         void glSampleCoveragexOES(GLclampx value, GLboolean invert);
 219         void glScalexOES(GLfixed x, GLfixed y, GLfixed z);
 220         void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param);
 221         void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed* params);
 222         void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param);
 223         void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed* params);
 224         void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z);
 225         GLboolean glIsRenderbufferOES(GLuint renderbuffer);
 226         void glBindRenderbufferOES(GLenum target, GLuint renderbuffer);
 227         void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers);
 228         void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers);
 229         void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
 230         void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params);
 231         GLboolean glIsFramebufferOES(GLuint framebuffer);
 232         void glBindFramebufferOES(GLenum target, GLuint framebuffer);
 233         void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers);
 234         void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers);
 235         GLenum glCheckFramebufferStatusOES(GLenum target);
 236         void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
 237         void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
 238         void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params);
 239         void glGenerateMipmapOES(GLenum target);
 240         void* glMapBufferOES(GLenum target, GLenum access);
 241         GLboolean glUnmapBufferOES(GLenum target);
 242         void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params);
 243         void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex);
 244         void glLoadPaletteFromModelViewMatrixOES();
 245         void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
 246         void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
 247         GLbitfield glQueryMatrixxOES(GLfixed* mantissa, GLint* exponent);
 248         void glDepthRangefOES(GLclampf zNear, GLclampf zFar);
 249         void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
 250         void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
 251         void glClipPlanefOES(GLenum plane, const GLfloat* equation);
 252         void glClipPlanefIMG(GLenum plane, const GLfloat* equation);
 253         void glGetClipPlanefOES(GLenum pname, GLfloat* eqn);
 254         void glClearDepthfOES(GLclampf depth);
 255         void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param);
 256         void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat* params);
 257         void glTexGeniOES(GLenum coord, GLenum pname, GLint param);
 258         void glTexGenivOES(GLenum coord, GLenum pname, const GLint* params);
 259         void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param);
 260         void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed* params);
 261         void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat* params);
 262         void glGetTexGenivOES(GLenum coord, GLenum pname, GLint* params);
 263         void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed* params);
 264         void glBindVertexArrayOES(GLuint array);
 265         void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays);
 266         void glGenVertexArraysOES(GLsizei n, GLuint* arrays);
 267         GLboolean glIsVertexArrayOES(GLuint array);
 268         void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments);
 269         void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount);
 270         void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount);
 271         void glMultiDrawArraysSUN(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount);
 272         void glMultiDrawElementsSUN(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount);
 273         void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
 274         void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
 275         void glDeleteFencesNV(GLsizei n, const GLuint* fences);
 276         void glGenFencesNV(GLsizei n, GLuint* fences);
 277         GLboolean glIsFenceNV(GLuint fence);
 278         GLboolean glTestFenceNV(GLuint fence);
 279         void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params);
 280         void glFinishFenceNV(GLuint fence);
 281         void glSetFenceNV(GLuint fence, GLenum condition);
 282         void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls);
 283         void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString);
 284         void glEnableDriverControlQCOM(GLuint driverControl);
 285         void glDisableDriverControlQCOM(GLuint driverControl);
 286         void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures);
 287         void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers);
 288         void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers);
 289         void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers);
 290         void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params);
 291         void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param);
 292         void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels);
 293         void glExtGetBufferPointervQCOM(GLenum target, GLvoid** params);
 294         void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders);
 295         void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms);
 296         GLboolean glExtIsProgramBinaryQCOM(GLuint program);
 297         void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length);
 298         void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask);
 299         void glEndTilingQCOM(GLbitfield preserveMask);
 300 };
 301
 302 #endif
 303 #ifndef GET_CONTEXT
 304 static gl_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL;
 305 void gl_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; }
 306 #define GET_CONTEXT gl_client_context_t * ctx = getCurrentContext()
 307 #endif
 308
 309 void glAlphaFunc(GLenum func, GLclampf ref)
 310 {
 311         GET_CONTEXT;
 312         ctx->glAlphaFunc(ctx, func, ref);
 313 }
 314
 315 void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 316 {
 317         GET_CONTEXT;
 318         ctx->glClearColor(ctx, red, green, blue, alpha);
 319 }
 320
 321 void glClearDepthf(GLclampf depth)
 322 {
 323         GET_CONTEXT;
 324         ctx->glClearDepthf(ctx, depth);
 325 }
 326
 327 void glClipPlanef(GLenum plane, const GLfloat* equation)
 328 {
 329         GET_CONTEXT;
 330         ctx->glClipPlanef(ctx, plane, equation);
 331 }
 332
 333 void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 334 {
 335         GET_CONTEXT;
 336         ctx->glColor4f(ctx, red, green, blue, alpha);
 337 }
 338
 339 void glDepthRangef(GLclampf zNear, GLclampf zFar)
 340 {
 341         GET_CONTEXT;
 342         ctx->glDepthRangef(ctx, zNear, zFar);
 343 }
 344
 345 void glFogf(GLenum pname, GLfloat param)
 346 {
 347         GET_CONTEXT;
 348         ctx->glFogf(ctx, pname, param);
 349 }
 350
 351 void glFogfv(GLenum pname, const GLfloat* params)
 352 {
 353         GET_CONTEXT;
 354         ctx->glFogfv(ctx, pname, params);
 355 }
 356
 357 void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 358 {
 359         GET_CONTEXT;
 360         ctx->glFrustumf(ctx, left, right, bottom, top, zNear, zFar);
 361 }
 362
 363 void glGetClipPlanef(GLenum pname, GLfloat* eqn)
 364 {
 365         GET_CONTEXT;
 366         ctx->glGetClipPlanef(ctx, pname, eqn);
 367 }
 368
 369 void glGetFloatv(GLenum pname, GLfloat* params)
 370 {
 371         GET_CONTEXT;
 372         ctx->glGetFloatv(ctx, pname, params);
 373 }
 374
 375 void glGetLightfv(GLenum light, GLenum pname, GLfloat* params)
 376 {
 377         GET_CONTEXT;
 378         ctx->glGetLightfv(ctx, light, pname, params);
 379 }
 380
 381 void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params)
 382 {
 383         GET_CONTEXT;
 384         ctx->glGetMaterialfv(ctx, face, pname, params);
 385 }
 386
 387 void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params)
 388 {
 389         GET_CONTEXT;
 390         ctx->glGetTexEnvfv(ctx, env, pname, params);
 391 }
 392
 393 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 394 {
 395         GET_CONTEXT;
 396         ctx->glGetTexParameterfv(ctx, target, pname, params);
 397 }
 398
 399 void glLightModelf(GLenum pname, GLfloat param)
 400 {
 401         GET_CONTEXT;
 402         ctx->glLightModelf(ctx, pname, param);
 403 }
 404
 405 void glLightModelfv(GLenum pname, const GLfloat* params)
 406 {
 407         GET_CONTEXT;
 408         ctx->glLightModelfv(ctx, pname, params);
 409 }
 410
 411 void glLightf(GLenum light, GLenum pname, GLfloat param)
 412 {
 413         GET_CONTEXT;
 414         ctx->glLightf(ctx, light, pname, param);
 415 }
 416
 417 void glLightfv(GLenum light, GLenum pname, const GLfloat* params)
 418 {
 419         GET_CONTEXT;
 420         ctx->glLightfv(ctx, light, pname, params);
 421 }
 422
 423 void glLineWidth(GLfloat width)
 424 {
 425         GET_CONTEXT;
 426         ctx->glLineWidth(ctx, width);
 427 }
 428
 429 void glLoadMatrixf(const GLfloat* m)
 430 {
 431         GET_CONTEXT;
 432         ctx->glLoadMatrixf(ctx, m);
 433 }
 434
 435 void glMaterialf(GLenum face, GLenum pname, GLfloat param)
 436 {
 437         GET_CONTEXT;
 438         ctx->glMaterialf(ctx, face, pname, param);
 439 }
 440
 441 void glMaterialfv(GLenum face, GLenum pname, const GLfloat* params)
 442 {
 443         GET_CONTEXT;
 444         ctx->glMaterialfv(ctx, face, pname, params);
 445 }
 446
 447 void glMultMatrixf(const GLfloat* m)
 448 {
 449         GET_CONTEXT;
 450         ctx->glMultMatrixf(ctx, m);
 451 }
 452
 453 void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 454 {
 455         GET_CONTEXT;
 456         ctx->glMultiTexCoord4f(ctx, target, s, t, r, q);
 457 }
 458
 459 void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 460 {
 461         GET_CONTEXT;
 462         ctx->glNormal3f(ctx, nx, ny, nz);
 463 }
 464
 465 void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 466 {
 467         GET_CONTEXT;
 468         ctx->glOrthof(ctx, left, right, bottom, top, zNear, zFar);
 469 }
 470
 471 void glPointParameterf(GLenum pname, GLfloat param)
 472 {
 473         GET_CONTEXT;
 474         ctx->glPointParameterf(ctx, pname, param);
 475 }
 476
 477 void glPointParameterfv(GLenum pname, const GLfloat* params)
 478 {
 479         GET_CONTEXT;
 480         ctx->glPointParameterfv(ctx, pname, params);
 481 }
 482
 483 void glPointSize(GLfloat size)
 484 {
 485         GET_CONTEXT;
 486         ctx->glPointSize(ctx, size);
 487 }
 488
 489 void glPolygonOffset(GLfloat factor, GLfloat units)
 490 {
 491         GET_CONTEXT;
 492         ctx->glPolygonOffset(ctx, factor, units);
 493 }
 494
 495 void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 496 {
 497         GET_CONTEXT;
 498         ctx->glRotatef(ctx, angle, x, y, z);
 499 }
 500
 501 void glScalef(GLfloat x, GLfloat y, GLfloat z)
 502 {
 503         GET_CONTEXT;
 504         ctx->glScalef(ctx, x, y, z);
 505 }
 506
 507 void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 508 {
 509         GET_CONTEXT;
 510         ctx->glTexEnvf(ctx, target, pname, param);
 511 }
 512
 513 void glTexEnvfv(GLenum target, GLenum pname, const GLfloat* params)
 514 {
 515         GET_CONTEXT;
 516         ctx->glTexEnvfv(ctx, target, pname, params);
 517 }
 518
 519 void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 520 {
 521         GET_CONTEXT;
 522         ctx->glTexParameterf(ctx, target, pname, param);
 523 }
 524
 525 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 526 {
 527         GET_CONTEXT;
 528         ctx->glTexParameterfv(ctx, target, pname, params);
 529 }
 530
 531 void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 532 {
 533         GET_CONTEXT;
 534         ctx->glTranslatef(ctx, x, y, z);
 535 }
 536
 537 void glActiveTexture(GLenum texture)
 538 {
 539         GET_CONTEXT;
 540         ctx->glActiveTexture(ctx, texture);
 541 }
 542
 543 void glAlphaFuncx(GLenum func, GLclampx ref)
 544 {
 545         GET_CONTEXT;
 546         ctx->glAlphaFuncx(ctx, func, ref);
 547 }
 548
 549 void glBindBuffer(GLenum target, GLuint buffer)
 550 {
 551         GET_CONTEXT;
 552         ctx->glBindBuffer(ctx, target, buffer);
 553 }
 554
 555 void glBindTexture(GLenum target, GLuint texture)
 556 {
 557         GET_CONTEXT;
 558         ctx->glBindTexture(ctx, target, texture);
 559 }
 560
 561 void glBlendFunc(GLenum sfactor, GLenum dfactor)
 562 {
 563         GET_CONTEXT;
 564         ctx->glBlendFunc(ctx, sfactor, dfactor);
 565 }
 566
 567 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
 568 {
 569         GET_CONTEXT;
 570         ctx->glBufferData(ctx, target, size, data, usage);
 571 }
 572
 573 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
 574 {
 575         GET_CONTEXT;
 576         ctx->glBufferSubData(ctx, target, offset, size, data);
 577 }
 578
 579 void glClear(GLbitfield mask)
 580 {
 581         GET_CONTEXT;
 582         ctx->glClear(ctx, mask);
 583 }
 584
 585 void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 586 {
 587         GET_CONTEXT;
 588         ctx->glClearColorx(ctx, red, green, blue, alpha);
 589 }
 590
 591 void glClearDepthx(GLclampx depth)
 592 {
 593         GET_CONTEXT;
 594         ctx->glClearDepthx(ctx, depth);
 595 }
 596
 597 void glClearStencil(GLint s)
 598 {
 599         GET_CONTEXT;
 600         ctx->glClearStencil(ctx, s);
 601 }
 602
 603 void glClientActiveTexture(GLenum texture)
 604 {
 605         GET_CONTEXT;
 606         ctx->glClientActiveTexture(ctx, texture);
 607 }
 608
 609 void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 610 {
 611         GET_CONTEXT;
 612         ctx->glColor4ub(ctx, red, green, blue, alpha);
 613 }
 614
 615 void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 616 {
 617         GET_CONTEXT;
 618         ctx->glColor4x(ctx, red, green, blue, alpha);
 619 }
 620
 621 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 622 {
 623         GET_CONTEXT;
 624         ctx->glColorMask(ctx, red, green, blue, alpha);
 625 }
 626
 627 void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 628 {
 629         GET_CONTEXT;
 630         ctx->glColorPointer(ctx, size, type, stride, pointer);
 631 }
 632
 633 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
 634 {
 635         GET_CONTEXT;
 636         ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data);
 637 }
 638
 639 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
 640 {
 641         GET_CONTEXT;
 642         ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data);
 643 }
 644
 645 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 646 {
 647         GET_CONTEXT;
 648         ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border);
 649 }
 650
 651 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 652 {
 653         GET_CONTEXT;
 654         ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
 655 }
 656
 657 void glCullFace(GLenum mode)
 658 {
 659         GET_CONTEXT;
 660         ctx->glCullFace(ctx, mode);
 661 }
 662
 663 void glDeleteBuffers(GLsizei n, const GLuint* buffers)
 664 {
 665         GET_CONTEXT;
 666          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 667         ctx->glDeleteBuffers(ctx, n, buffers);
 668 }
 669
 670 void glDeleteTextures(GLsizei n, const GLuint* textures)
 671 {
 672         GET_CONTEXT;
 673          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 674         ctx->glDeleteTextures(ctx, n, textures);
 675 }
 676
 677 void glDepthFunc(GLenum func)
 678 {
 679         GET_CONTEXT;
 680         ctx->glDepthFunc(ctx, func);
 681 }
 682
 683 void glDepthMask(GLboolean flag)
 684 {
 685         GET_CONTEXT;
 686         ctx->glDepthMask(ctx, flag);
 687 }
 688
 689 void glDepthRangex(GLclampx zNear, GLclampx zFar)
 690 {
 691         GET_CONTEXT;
 692         ctx->glDepthRangex(ctx, zNear, zFar);
 693 }
 694
 695 void glDisable(GLenum cap)
 696 {
 697         GET_CONTEXT;
 698         ctx->glDisable(ctx, cap);
 699 }
 700
 701 void glDisableClientState(GLenum array)
 702 {
 703         GET_CONTEXT;
 704         ctx->glDisableClientState(ctx, array);
 705 }
 706
 707 void glDrawArrays(GLenum mode, GLint first, GLsizei count)
 708 {
 709         GET_CONTEXT;
 710         ctx->glDrawArrays(ctx, mode, first, count);
 711 }
 712
 713 void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
 714 {
 715         GET_CONTEXT;
 716         ctx->glDrawElements(ctx, mode, count, type, indices);
 717 }
 718
 719 void glEnable(GLenum cap)
 720 {
 721         GET_CONTEXT;
 722         ctx->glEnable(ctx, cap);
 723 }
 724
 725 void glEnableClientState(GLenum array)
 726 {
 727         GET_CONTEXT;
 728         ctx->glEnableClientState(ctx, array);
 729 }
 730
 731 void glFinish()
 732 {
 733         GET_CONTEXT;
 734         ctx->glFinish(ctx);
 735 }
 736
 737 void glFlush()
 738 {
 739         GET_CONTEXT;
 740         ctx->glFlush(ctx);
 741 }
 742
 743 void glFogx(GLenum pname, GLfixed param)
 744 {
 745         GET_CONTEXT;
 746         ctx->glFogx(ctx, pname, param);
 747 }
 748
 749 void glFogxv(GLenum pname, const GLfixed* params)
 750 {
 751         GET_CONTEXT;
 752         ctx->glFogxv(ctx, pname, params);
 753 }
 754
 755 void glFrontFace(GLenum mode)
 756 {
 757         GET_CONTEXT;
 758         ctx->glFrontFace(ctx, mode);
 759 }
 760
 761 void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 762 {
 763         GET_CONTEXT;
 764         ctx->glFrustumx(ctx, left, right, bottom, top, zNear, zFar);
 765 }
 766
 767 void glGetBooleanv(GLenum pname, GLboolean* params)
 768 {
 769         GET_CONTEXT;
 770         ctx->glGetBooleanv(ctx, pname, params);
 771 }
 772
 773 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 774 {
 775         GET_CONTEXT;
 776         ctx->glGetBufferParameteriv(ctx, target, pname, params);
 777 }
 778
 779 void glClipPlanex(GLenum pname, const GLfixed* eqn)
 780 {
 781         GET_CONTEXT;
 782         ctx->glClipPlanex(ctx, pname, eqn);
 783 }
 784
 785 void glGenBuffers(GLsizei n, GLuint* buffers)
 786 {
 787         GET_CONTEXT;
 788          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 789         ctx->glGenBuffers(ctx, n, buffers);
 790 }
 791
 792 void glGenTextures(GLsizei n, GLuint* textures)
 793 {
 794         GET_CONTEXT;
 795          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
 796         ctx->glGenTextures(ctx, n, textures);
 797 }
 798
 799 GLenum glGetError()
 800 {
 801         GET_CONTEXT;
 802         return ctx->glGetError(ctx);
 803 }
 804
 805 void glGetFixedv(GLenum pname, GLfixed* params)
 806 {
 807         GET_CONTEXT;
 808         ctx->glGetFixedv(ctx, pname, params);
 809 }
 810
 811 void glGetIntegerv(GLenum pname, GLint* params)
 812 {
 813         GET_CONTEXT;
 814         ctx->glGetIntegerv(ctx, pname, params);
 815 }
 816
 817 void glGetLightxv(GLenum light, GLenum pname, GLfixed* params)
 818 {
 819         GET_CONTEXT;
 820         ctx->glGetLightxv(ctx, light, pname, params);
 821 }
 822
 823 void glGetMaterialxv(GLenum face, GLenum pname, GLfixed* params)
 824 {
 825         GET_CONTEXT;
 826         ctx->glGetMaterialxv(ctx, face, pname, params);
 827 }
 828
 829 void glGetPointerv(GLenum pname, GLvoid** params)
 830 {
 831         GET_CONTEXT;
 832         ctx->glGetPointerv(ctx, pname, params);
 833 }
 834
 835 const GLubyte* glGetString(GLenum name)
 836 {
 837         GET_CONTEXT;
 838         return ctx->glGetString(ctx, name);
 839 }
 840
 841 void glGetTexEnviv(GLenum env, GLenum pname, GLint* params)
 842 {
 843         GET_CONTEXT;
 844         ctx->glGetTexEnviv(ctx, env, pname, params);
 845 }
 846
 847 void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed* params)
 848 {
 849         GET_CONTEXT;
 850         ctx->glGetTexEnvxv(ctx, env, pname, params);
 851 }
 852
 853 void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 854 {
 855         GET_CONTEXT;
 856         ctx->glGetTexParameteriv(ctx, target, pname, params);
 857 }
 858
 859 void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed* params)
 860 {
 861         GET_CONTEXT;
 862         ctx->glGetTexParameterxv(ctx, target, pname, params);
 863 }
 864
 865 void glHint(GLenum target, GLenum mode)
 866 {
 867         GET_CONTEXT;
 868         ctx->glHint(ctx, target, mode);
 869 }
 870
 871 GLboolean glIsBuffer(GLuint buffer)
 872 {
 873         GET_CONTEXT;
 874         return ctx->glIsBuffer(ctx, buffer);
 875 }
 876
 877 GLboolean glIsEnabled(GLenum cap)
 878 {
 879         GET_CONTEXT;
 880         return ctx->glIsEnabled(ctx, cap);
 881 }
 882
 883 GLboolean glIsTexture(GLuint texture)
 884 {
 885         GET_CONTEXT;
 886         return ctx->glIsTexture(ctx, texture);
 887 }
 888
 889 void glLightModelx(GLenum pname, GLfixed param)
 890 {
 891         GET_CONTEXT;
 892         ctx->glLightModelx(ctx, pname, param);
 893 }
 894
 895 void glLightModelxv(GLenum pname, const GLfixed* params)
 896 {
 897         GET_CONTEXT;
 898         ctx->glLightModelxv(ctx, pname, params);
 899 }
 900
 901 void glLightx(GLenum light, GLenum pname, GLfixed param)
 902 {
 903         GET_CONTEXT;
 904         ctx->glLightx(ctx, light, pname, param);
 905 }
 906
 907 void glLightxv(GLenum light, GLenum pname, const GLfixed* params)
 908 {
 909         GET_CONTEXT;
 910         ctx->glLightxv(ctx, light, pname, params);
 911 }
 912
 913 void glLineWidthx(GLfixed width)
 914 {
 915         GET_CONTEXT;
 916         ctx->glLineWidthx(ctx, width);
 917 }
 918
 919 void glLoadIdentity()
 920 {
 921         GET_CONTEXT;
 922         ctx->glLoadIdentity(ctx);
 923 }
 924
 925 void glLoadMatrixx(const GLfixed* m)
 926 {
 927         GET_CONTEXT;
 928         ctx->glLoadMatrixx(ctx, m);
 929 }
 930
 931 void glLogicOp(GLenum opcode)
 932 {
 933         GET_CONTEXT;
 934         ctx->glLogicOp(ctx, opcode);
 935 }
 936
 937 void glMaterialx(GLenum face, GLenum pname, GLfixed param)
 938 {
 939         GET_CONTEXT;
 940         ctx->glMaterialx(ctx, face, pname, param);
 941 }
 942
 943 void glMaterialxv(GLenum face, GLenum pname, const GLfixed* params)
 944 {
 945         GET_CONTEXT;
 946         ctx->glMaterialxv(ctx, face, pname, params);
 947 }
 948
 949 void glMatrixMode(GLenum mode)
 950 {
 951         GET_CONTEXT;
 952         ctx->glMatrixMode(ctx, mode);
 953 }
 954
 955 void glMultMatrixx(const GLfixed* m)
 956 {
 957         GET_CONTEXT;
 958         ctx->glMultMatrixx(ctx, m);
 959 }
 960
 961 void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 962 {
 963         GET_CONTEXT;
 964         ctx->glMultiTexCoord4x(ctx, target, s, t, r, q);
 965 }
 966
 967 void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
 968 {
 969         GET_CONTEXT;
 970         ctx->glNormal3x(ctx, nx, ny, nz);
 971 }
 972
 973 void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer)
 974 {
 975         GET_CONTEXT;
 976         ctx->glNormalPointer(ctx, type, stride, pointer);
 977 }
 978
 979 void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 980 {
 981         GET_CONTEXT;
 982         ctx->glOrthox(ctx, left, right, bottom, top, zNear, zFar);
 983 }
 984
 985 void glPixelStorei(GLenum pname, GLint param)
 986 {
 987         GET_CONTEXT;
 988         ctx->glPixelStorei(ctx, pname, param);
 989 }
 990
 991 void glPointParameterx(GLenum pname, GLfixed param)
 992 {
 993         GET_CONTEXT;
 994         ctx->glPointParameterx(ctx, pname, param);
 995 }
 996
 997 void glPointParameterxv(GLenum pname, const GLfixed* params)
 998 {
 999         GET_CONTEXT;
1000         ctx->glPointParameterxv(ctx, pname, params);
1001 }
1002
1003 void glPointSizex(GLfixed size)
1004 {
1005         GET_CONTEXT;
1006         ctx->glPointSizex(ctx, size);
1007 }
1008
1009 void glPolygonOffsetx(GLfixed factor, GLfixed units)
1010 {
1011         GET_CONTEXT;
1012         ctx->glPolygonOffsetx(ctx, factor, units);
1013 }
1014
1015 void glPopMatrix()
1016 {
1017         GET_CONTEXT;
1018         ctx->glPopMatrix(ctx);
1019 }
1020
1021 void glPushMatrix()
1022 {
1023         GET_CONTEXT;
1024         ctx->glPushMatrix(ctx);
1025 }
1026
1027 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
1028 {
1029         GET_CONTEXT;
1030         ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
1031 }
1032
1033 void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
1034 {
1035         GET_CONTEXT;
1036         ctx->glRotatex(ctx, angle, x, y, z);
1037 }
1038
1039 void glSampleCoverage(GLclampf value, GLboolean invert)
1040 {
1041         GET_CONTEXT;
1042         ctx->glSampleCoverage(ctx, value, invert);
1043 }
1044
1045 void glSampleCoveragex(GLclampx value, GLboolean invert)
1046 {
1047         GET_CONTEXT;
1048         ctx->glSampleCoveragex(ctx, value, invert);
1049 }
1050
1051 void glScalex(GLfixed x, GLfixed y, GLfixed z)
1052 {
1053         GET_CONTEXT;
1054         ctx->glScalex(ctx, x, y, z);
1055 }
1056
1057 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
1058 {
1059         GET_CONTEXT;
1060         ctx->glScissor(ctx, x, y, width, height);
1061 }
1062
1063 void glShadeModel(GLenum mode)
1064 {
1065         GET_CONTEXT;
1066         ctx->glShadeModel(ctx, mode);
1067 }
1068
1069 void glStencilFunc(GLenum func, GLint ref, GLuint mask)
1070 {
1071         GET_CONTEXT;
1072         ctx->glStencilFunc(ctx, func, ref, mask);
1073 }
1074
1075 void glStencilMask(GLuint mask)
1076 {
1077         GET_CONTEXT;
1078         ctx->glStencilMask(ctx, mask);
1079 }
1080
1081 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1082 {
1083         GET_CONTEXT;
1084         ctx->glStencilOp(ctx, fail, zfail, zpass);
1085 }
1086
1087 void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
1088 {
1089         GET_CONTEXT;
1090         ctx->glTexCoordPointer(ctx, size, type, stride, pointer);
1091 }
1092
1093 void glTexEnvi(GLenum target, GLenum pname, GLint param)
1094 {
1095         GET_CONTEXT;
1096         ctx->glTexEnvi(ctx, target, pname, param);
1097 }
1098
1099 void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
1100 {
1101         GET_CONTEXT;
1102         ctx->glTexEnvx(ctx, target, pname, param);
1103 }
1104
1105 void glTexEnviv(GLenum target, GLenum pname, const GLint* params)
1106 {
1107         GET_CONTEXT;
1108         ctx->glTexEnviv(ctx, target, pname, params);
1109 }
1110
1111 void glTexEnvxv(GLenum target, GLenum pname, const GLfixed* params)
1112 {
1113         GET_CONTEXT;
1114         ctx->glTexEnvxv(ctx, target, pname, params);
1115 }
1116
1117 void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
1118 {
1119         GET_CONTEXT;
1120         ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
1121 }
1122
1123 void glTexParameteri(GLenum target, GLenum pname, GLint param)
1124 {
1125         GET_CONTEXT;
1126         ctx->glTexParameteri(ctx, target, pname, param);
1127 }
1128
1129 void glTexParameterx(GLenum target, GLenum pname, GLfixed param)
1130 {
1131         GET_CONTEXT;
1132         ctx->glTexParameterx(ctx, target, pname, param);
1133 }
1134
1135 void glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
1136 {
1137         GET_CONTEXT;
1138         ctx->glTexParameteriv(ctx, target, pname, params);
1139 }
1140
1141 void glTexParameterxv(GLenum target, GLenum pname, const GLfixed* params)
1142 {
1143         GET_CONTEXT;
1144         ctx->glTexParameterxv(ctx, target, pname, params);
1145 }
1146
1147 void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
1148 {
1149         GET_CONTEXT;
1150         ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
1151 }
1152
1153 void glTranslatex(GLfixed x, GLfixed y, GLfixed z)
1154 {
1155         GET_CONTEXT;
1156         ctx->glTranslatex(ctx, x, y, z);
1157 }
1158
1159 void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
1160 {
1161         GET_CONTEXT;
1162         ctx->glVertexPointer(ctx, size, type, stride, pointer);
1163 }
1164
1165 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
1166 {
1167         GET_CONTEXT;
1168         ctx->glViewport(ctx, x, y, width, height);
1169 }
1170
1171 void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid* pointer)
1172 {
1173         GET_CONTEXT;
1174         ctx->glPointSizePointerOES(ctx, type, stride, pointer);
1175 }
1176
1177 void glVertexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
1178 {
1179         GET_CONTEXT;
1180         ctx->glVertexPointerOffset(ctx, size, type, stride, offset);
1181 }
1182
1183 void glColorPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
1184 {
1185         GET_CONTEXT;
1186         ctx->glColorPointerOffset(ctx, size, type, stride, offset);
1187 }
1188
1189 void glNormalPointerOffset(GLenum type, GLsizei stride, GLuint offset)
1190 {
1191         GET_CONTEXT;
1192         ctx->glNormalPointerOffset(ctx, type, stride, offset);
1193 }
1194
1195 void glPointSizePointerOffset(GLenum type, GLsizei stride, GLuint offset)
1196 {
1197         GET_CONTEXT;
1198         ctx->glPointSizePointerOffset(ctx, type, stride, offset);
1199 }
1200
1201 void glTexCoordPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
1202 {
1203         GET_CONTEXT;
1204         ctx->glTexCoordPointerOffset(ctx, size, type, stride, offset);
1205 }
1206
1207 void glWeightPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
1208 {
1209         GET_CONTEXT;
1210         ctx->glWeightPointerOffset(ctx, size, type, stride, offset);
1211 }
1212
1213 void glMatrixIndexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
1214 {
1215         GET_CONTEXT;
1216         ctx->glMatrixIndexPointerOffset(ctx, size, type, stride, offset);
1217 }
1218
1219 void glVertexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
1220 {
1221         GET_CONTEXT;
1222         ctx->glVertexPointerData(ctx, size, type, stride, data, datalen);
1223 }
1224
1225 void glColorPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
1226 {
1227         GET_CONTEXT;
1228         ctx->glColorPointerData(ctx, size, type, stride, data, datalen);
1229 }
1230
1231 void glNormalPointerData(GLenum type, GLsizei stride, void* data, GLuint datalen)
1232 {
1233         GET_CONTEXT;
1234         ctx->glNormalPointerData(ctx, type, stride, data, datalen);
1235 }
1236
1237 void glTexCoordPointerData(GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
1238 {
1239         GET_CONTEXT;
1240         ctx->glTexCoordPointerData(ctx, unit, size, type, stride, data, datalen);
1241 }
1242
1243 void glPointSizePointerData(GLenum type, GLsizei stride, void* data, GLuint datalen)
1244 {
1245         GET_CONTEXT;
1246         ctx->glPointSizePointerData(ctx, type, stride, data, datalen);
1247 }
1248
1249 void glWeightPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
1250 {
1251         GET_CONTEXT;
1252         ctx->glWeightPointerData(ctx, size, type, stride, data, datalen);
1253 }
1254
1255 void glMatrixIndexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
1256 {
1257         GET_CONTEXT;
1258         ctx->glMatrixIndexPointerData(ctx, size, type, stride, data, datalen);
1259 }
1260
1261 void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset)
1262 {
1263         GET_CONTEXT;
1264         ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
1265 }
1266
1267 void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen)
1268 {
1269         GET_CONTEXT;
1270         ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
1271 }
1272
1273 void glGetCompressedTextureFormats(int count, GLint* formats)
1274 {
1275         GET_CONTEXT;
1276         ctx->glGetCompressedTextureFormats(ctx, count, formats);
1277 }
1278
1279 int glFinishRoundTrip()
1280 {
1281         GET_CONTEXT;
1282         return ctx->glFinishRoundTrip(ctx);
1283 }
1284
1285 void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)
1286 {
1287         GET_CONTEXT;
1288         ctx->glBlendEquationSeparateOES(ctx, modeRGB, modeAlpha);
1289 }
1290
1291 void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
1292 {
1293         GET_CONTEXT;
1294         ctx->glBlendFuncSeparateOES(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
1295 }
1296
1297 void glBlendEquationOES(GLenum mode)
1298 {
1299         GET_CONTEXT;
1300         ctx->glBlendEquationOES(ctx, mode);
1301 }
1302
1303 void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
1304 {
1305         GET_CONTEXT;
1306         ctx->glDrawTexsOES(ctx, x, y, z, width, height);
1307 }
1308
1309 void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
1310 {
1311         GET_CONTEXT;
1312         ctx->glDrawTexiOES(ctx, x, y, z, width, height);
1313 }
1314
1315 void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
1316 {
1317         GET_CONTEXT;
1318         ctx->glDrawTexxOES(ctx, x, y, z, width, height);
1319 }
1320
1321 void glDrawTexsvOES(const GLshort* coords)
1322 {
1323         GET_CONTEXT;
1324         ctx->glDrawTexsvOES(ctx, coords);
1325 }
1326
1327 void glDrawTexivOES(const GLint* coords)
1328 {
1329         GET_CONTEXT;
1330         ctx->glDrawTexivOES(ctx, coords);
1331 }
1332
1333 void glDrawTexxvOES(const GLfixed* coords)
1334 {
1335         GET_CONTEXT;
1336         ctx->glDrawTexxvOES(ctx, coords);
1337 }
1338
1339 void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
1340 {
1341         GET_CONTEXT;
1342         ctx->glDrawTexfOES(ctx, x, y, z, width, height);
1343 }
1344
1345 void glDrawTexfvOES(const GLfloat* coords)
1346 {
1347         GET_CONTEXT;
1348         ctx->glDrawTexfvOES(ctx, coords);
1349 }
1350
1351 void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
1352 {
1353         GET_CONTEXT;
1354         ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
1355 }
1356
1357 void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
1358 {
1359         GET_CONTEXT;
1360         ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
1361 }
1362
1363 void glAlphaFuncxOES(GLenum func, GLclampx ref)
1364 {
1365         GET_CONTEXT;
1366         ctx->glAlphaFuncxOES(ctx, func, ref);
1367 }
1368
1369 void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
1370 {
1371         GET_CONTEXT;
1372         ctx->glClearColorxOES(ctx, red, green, blue, alpha);
1373 }
1374
1375 void glClearDepthxOES(GLclampx depth)
1376 {
1377         GET_CONTEXT;
1378         ctx->glClearDepthxOES(ctx, depth);
1379 }
1380
1381 void glClipPlanexOES(GLenum plane, const GLfixed* equation)
1382 {
1383         GET_CONTEXT;
1384         ctx->glClipPlanexOES(ctx, plane, equation);
1385 }
1386
1387 void glClipPlanexIMG(GLenum plane, const GLfixed* equation)
1388 {
1389         GET_CONTEXT;
1390         ctx->glClipPlanexIMG(ctx, plane, equation);
1391 }
1392
1393 void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
1394 {
1395         GET_CONTEXT;
1396         ctx->glColor4xOES(ctx, red, green, blue, alpha);
1397 }
1398
1399 void glDepthRangexOES(GLclampx zNear, GLclampx zFar)
1400 {
1401         GET_CONTEXT;
1402         ctx->glDepthRangexOES(ctx, zNear, zFar);
1403 }
1404
1405 void glFogxOES(GLenum pname, GLfixed param)
1406 {
1407         GET_CONTEXT;
1408         ctx->glFogxOES(ctx, pname, param);
1409 }
1410
1411 void glFogxvOES(GLenum pname, const GLfixed* params)
1412 {
1413         GET_CONTEXT;
1414         ctx->glFogxvOES(ctx, pname, params);
1415 }
1416
1417 void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
1418 {
1419         GET_CONTEXT;
1420         ctx->glFrustumxOES(ctx, left, right, bottom, top, zNear, zFar);
1421 }
1422
1423 void glGetClipPlanexOES(GLenum pname, GLfixed* eqn)
1424 {
1425         GET_CONTEXT;
1426         ctx->glGetClipPlanexOES(ctx, pname, eqn);
1427 }
1428
1429 void glGetClipPlanex(GLenum pname, GLfixed* eqn)
1430 {
1431         GET_CONTEXT;
1432         ctx->glGetClipPlanex(ctx, pname, eqn);
1433 }
1434
1435 void glGetFixedvOES(GLenum pname, GLfixed* params)
1436 {
1437         GET_CONTEXT;
1438         ctx->glGetFixedvOES(ctx, pname, params);
1439 }
1440
1441 void glGetLightxvOES(GLenum light, GLenum pname, GLfixed* params)
1442 {
1443         GET_CONTEXT;
1444         ctx->glGetLightxvOES(ctx, light, pname, params);
1445 }
1446
1447 void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed* params)
1448 {
1449         GET_CONTEXT;
1450         ctx->glGetMaterialxvOES(ctx, face, pname, params);
1451 }
1452
1453 void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed* params)
1454 {
1455         GET_CONTEXT;
1456         ctx->glGetTexEnvxvOES(ctx, env, pname, params);
1457 }
1458
1459 void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed* params)
1460 {
1461         GET_CONTEXT;
1462         ctx->glGetTexParameterxvOES(ctx, target, pname, params);
1463 }
1464
1465 void glLightModelxOES(GLenum pname, GLfixed param)
1466 {
1467         GET_CONTEXT;
1468         ctx->glLightModelxOES(ctx, pname, param);
1469 }
1470
1471 void glLightModelxvOES(GLenum pname, const GLfixed* params)
1472 {
1473         GET_CONTEXT;
1474         ctx->glLightModelxvOES(ctx, pname, params);
1475 }
1476
1477 void glLightxOES(GLenum light, GLenum pname, GLfixed param)
1478 {
1479         GET_CONTEXT;
1480         ctx->glLightxOES(ctx, light, pname, param);
1481 }
1482
1483 void glLightxvOES(GLenum light, GLenum pname, const GLfixed* params)
1484 {
1485         GET_CONTEXT;
1486         ctx->glLightxvOES(ctx, light, pname, params);
1487 }
1488
1489 void glLineWidthxOES(GLfixed width)
1490 {
1491         GET_CONTEXT;
1492         ctx->glLineWidthxOES(ctx, width);
1493 }
1494
1495 void glLoadMatrixxOES(const GLfixed* m)
1496 {
1497         GET_CONTEXT;
1498         ctx->glLoadMatrixxOES(ctx, m);
1499 }
1500
1501 void glMaterialxOES(GLenum face, GLenum pname, GLfixed param)
1502 {
1503         GET_CONTEXT;
1504         ctx->glMaterialxOES(ctx, face, pname, param);
1505 }
1506
1507 void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed* params)
1508 {
1509         GET_CONTEXT;
1510         ctx->glMaterialxvOES(ctx, face, pname, params);
1511 }
1512
1513 void glMultMatrixxOES(const GLfixed* m)
1514 {
1515         GET_CONTEXT;
1516         ctx->glMultMatrixxOES(ctx, m);
1517 }
1518
1519 void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
1520 {
1521         GET_CONTEXT;
1522         ctx->glMultiTexCoord4xOES(ctx, target, s, t, r, q);
1523 }
1524
1525 void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz)
1526 {
1527         GET_CONTEXT;
1528         ctx->glNormal3xOES(ctx, nx, ny, nz);
1529 }
1530
1531 void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
1532 {
1533         GET_CONTEXT;
1534         ctx->glOrthoxOES(ctx, left, right, bottom, top, zNear, zFar);
1535 }
1536
1537 void glPointParameterxOES(GLenum pname, GLfixed param)
1538 {
1539         GET_CONTEXT;
1540         ctx->glPointParameterxOES(ctx, pname, param);
1541 }
1542
1543 void glPointParameterxvOES(GLenum pname, const GLfixed* params)
1544 {
1545         GET_CONTEXT;
1546         ctx->glPointParameterxvOES(ctx, pname, params);
1547 }
1548
1549 void glPointSizexOES(GLfixed size)
1550 {
1551         GET_CONTEXT;
1552         ctx->glPointSizexOES(ctx, size);
1553 }
1554
1555 void glPolygonOffsetxOES(GLfixed factor, GLfixed units)
1556 {
1557         GET_CONTEXT;
1558         ctx->glPolygonOffsetxOES(ctx, factor, units);
1559 }
1560
1561 void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
1562 {
1563         GET_CONTEXT;
1564         ctx->glRotatexOES(ctx, angle, x, y, z);
1565 }
1566
1567 void glSampleCoveragexOES(GLclampx value, GLboolean invert)
1568 {
1569         GET_CONTEXT;
1570         ctx->glSampleCoveragexOES(ctx, value, invert);
1571 }
1572
1573 void glScalexOES(GLfixed x, GLfixed y, GLfixed z)
1574 {
1575         GET_CONTEXT;
1576         ctx->glScalexOES(ctx, x, y, z);
1577 }
1578
1579 void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param)
1580 {
1581         GET_CONTEXT;
1582         ctx->glTexEnvxOES(ctx, target, pname, param);
1583 }
1584
1585 void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed* params)
1586 {
1587         GET_CONTEXT;
1588         ctx->glTexEnvxvOES(ctx, target, pname, params);
1589 }
1590
1591 void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param)
1592 {
1593         GET_CONTEXT;
1594         ctx->glTexParameterxOES(ctx, target, pname, param);
1595 }
1596
1597 void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed* params)
1598 {
1599         GET_CONTEXT;
1600         ctx->glTexParameterxvOES(ctx, target, pname, params);
1601 }
1602
1603 void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z)
1604 {
1605         GET_CONTEXT;
1606         ctx->glTranslatexOES(ctx, x, y, z);
1607 }
1608
1609 GLboolean glIsRenderbufferOES(GLuint renderbuffer)
1610 {
1611         GET_CONTEXT;
1612         return ctx->glIsRenderbufferOES(ctx, renderbuffer);
1613 }
1614
1615 void glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
1616 {
1617         GET_CONTEXT;
1618         ctx->glBindRenderbufferOES(ctx, target, renderbuffer);
1619 }
1620
1621 void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers)
1622 {
1623         GET_CONTEXT;
1624          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
1625         ctx->glDeleteRenderbuffersOES(ctx, n, renderbuffers);
1626 }
1627
1628 void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers)
1629 {
1630         GET_CONTEXT;
1631          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
1632         ctx->glGenRenderbuffersOES(ctx, n, renderbuffers);
1633 }
1634
1635 void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1636 {
1637         GET_CONTEXT;
1638         ctx->glRenderbufferStorageOES(ctx, target, internalformat, width, height);
1639 }
1640
1641 void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params)
1642 {
1643         GET_CONTEXT;
1644         ctx->glGetRenderbufferParameterivOES(ctx, target, pname, params);
1645 }
1646
1647 GLboolean glIsFramebufferOES(GLuint framebuffer)
1648 {
1649         GET_CONTEXT;
1650         return ctx->glIsFramebufferOES(ctx, framebuffer);
1651 }
1652
1653 void glBindFramebufferOES(GLenum target, GLuint framebuffer)
1654 {
1655         GET_CONTEXT;
1656         ctx->glBindFramebufferOES(ctx, target, framebuffer);
1657 }
1658
1659 void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers)
1660 {
1661         GET_CONTEXT;
1662          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
1663         ctx->glDeleteFramebuffersOES(ctx, n, framebuffers);
1664 }
1665
1666 void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers)
1667 {
1668         GET_CONTEXT;
1669          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
1670         ctx->glGenFramebuffersOES(ctx, n, framebuffers);
1671 }
1672
1673 GLenum glCheckFramebufferStatusOES(GLenum target)
1674 {
1675         GET_CONTEXT;
1676         return ctx->glCheckFramebufferStatusOES(ctx, target);
1677 }
1678
1679 void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1680 {
1681         GET_CONTEXT;
1682         ctx->glFramebufferRenderbufferOES(ctx, target, attachment, renderbuffertarget, renderbuffer);
1683 }
1684
1685 void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1686 {
1687         GET_CONTEXT;
1688         ctx->glFramebufferTexture2DOES(ctx, target, attachment, textarget, texture, level);
1689 }
1690
1691 void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1692 {
1693         GET_CONTEXT;
1694         ctx->glGetFramebufferAttachmentParameterivOES(ctx, target, attachment, pname, params);
1695 }
1696
1697 void glGenerateMipmapOES(GLenum target)
1698 {
1699         GET_CONTEXT;
1700         ctx->glGenerateMipmapOES(ctx, target);
1701 }
1702
1703 void* glMapBufferOES(GLenum target, GLenum access)
1704 {
1705         GET_CONTEXT;
1706         return ctx->glMapBufferOES(ctx, target, access);
1707 }
1708
1709 GLboolean glUnmapBufferOES(GLenum target)
1710 {
1711         GET_CONTEXT;
1712         return ctx->glUnmapBufferOES(ctx, target);
1713 }
1714
1715 void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params)
1716 {
1717         GET_CONTEXT;
1718         ctx->glGetBufferPointervOES(ctx, target, pname, params);
1719 }
1720
1721 void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex)
1722 {
1723         GET_CONTEXT;
1724         ctx->glCurrentPaletteMatrixOES(ctx, matrixpaletteindex);
1725 }
1726
1727 void glLoadPaletteFromModelViewMatrixOES()
1728 {
1729         GET_CONTEXT;
1730         ctx->glLoadPaletteFromModelViewMatrixOES(ctx);
1731 }
1732
1733 void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
1734 {
1735         GET_CONTEXT;
1736         ctx->glMatrixIndexPointerOES(ctx, size, type, stride, pointer);
1737 }
1738
1739 void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
1740 {
1741         GET_CONTEXT;
1742         ctx->glWeightPointerOES(ctx, size, type, stride, pointer);
1743 }
1744
1745 GLbitfield glQueryMatrixxOES(GLfixed* mantissa, GLint* exponent)
1746 {
1747         GET_CONTEXT;
1748         return ctx->glQueryMatrixxOES(ctx, mantissa, exponent);
1749 }
1750
1751 void glDepthRangefOES(GLclampf zNear, GLclampf zFar)
1752 {
1753         GET_CONTEXT;
1754         ctx->glDepthRangefOES(ctx, zNear, zFar);
1755 }
1756
1757 void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1758 {
1759         GET_CONTEXT;
1760         ctx->glFrustumfOES(ctx, left, right, bottom, top, zNear, zFar);
1761 }
1762
1763 void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1764 {
1765         GET_CONTEXT;
1766         ctx->glOrthofOES(ctx, left, right, bottom, top, zNear, zFar);
1767 }
1768
1769 void glClipPlanefOES(GLenum plane, const GLfloat* equation)
1770 {
1771         GET_CONTEXT;
1772         ctx->glClipPlanefOES(ctx, plane, equation);
1773 }
1774
1775 void glClipPlanefIMG(GLenum plane, const GLfloat* equation)
1776 {
1777         GET_CONTEXT;
1778         ctx->glClipPlanefIMG(ctx, plane, equation);
1779 }
1780
1781 void glGetClipPlanefOES(GLenum pname, GLfloat* eqn)
1782 {
1783         GET_CONTEXT;
1784         ctx->glGetClipPlanefOES(ctx, pname, eqn);
1785 }
1786
1787 void glClearDepthfOES(GLclampf depth)
1788 {
1789         GET_CONTEXT;
1790         ctx->glClearDepthfOES(ctx, depth);
1791 }
1792
1793 void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param)
1794 {
1795         GET_CONTEXT;
1796         ctx->glTexGenfOES(ctx, coord, pname, param);
1797 }
1798
1799 void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat* params)
1800 {
1801         GET_CONTEXT;
1802         ctx->glTexGenfvOES(ctx, coord, pname, params);
1803 }
1804
1805 void glTexGeniOES(GLenum coord, GLenum pname, GLint param)
1806 {
1807         GET_CONTEXT;
1808         ctx->glTexGeniOES(ctx, coord, pname, param);
1809 }
1810
1811 void glTexGenivOES(GLenum coord, GLenum pname, const GLint* params)
1812 {
1813         GET_CONTEXT;
1814         ctx->glTexGenivOES(ctx, coord, pname, params);
1815 }
1816
1817 void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
1818 {
1819         GET_CONTEXT;
1820         ctx->glTexGenxOES(ctx, coord, pname, param);
1821 }
1822
1823 void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed* params)
1824 {
1825         GET_CONTEXT;
1826         ctx->glTexGenxvOES(ctx, coord, pname, params);
1827 }
1828
1829 void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat* params)
1830 {
1831         GET_CONTEXT;
1832         ctx->glGetTexGenfvOES(ctx, coord, pname, params);
1833 }
1834
1835 void glGetTexGenivOES(GLenum coord, GLenum pname, GLint* params)
1836 {
1837         GET_CONTEXT;
1838         ctx->glGetTexGenivOES(ctx, coord, pname, params);
1839 }
1840
1841 void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed* params)
1842 {
1843         GET_CONTEXT;
1844         ctx->glGetTexGenxvOES(ctx, coord, pname, params);
1845 }
1846
1847 void glBindVertexArrayOES(GLuint array)
1848 {
1849         GET_CONTEXT;
1850         ctx->glBindVertexArrayOES(ctx, array);
1851 }
1852
1853 void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays)
1854 {
1855         GET_CONTEXT;
1856          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
1857         ctx->glDeleteVertexArraysOES(ctx, n, arrays);
1858 }
1859
1860 void glGenVertexArraysOES(GLsizei n, GLuint* arrays)
1861 {
1862         GET_CONTEXT;
1863          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
1864         ctx->glGenVertexArraysOES(ctx, n, arrays);
1865 }
1866
1867 GLboolean glIsVertexArrayOES(GLuint array)
1868 {
1869         GET_CONTEXT;
1870         return ctx->glIsVertexArrayOES(ctx, array);
1871 }
1872
1873 void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments)
1874 {
1875         GET_CONTEXT;
1876         ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
1877 }
1878
1879 void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount)
1880 {
1881         GET_CONTEXT;
1882         ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount);
1883 }
1884
1885 void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount)
1886 {
1887         GET_CONTEXT;
1888         ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
1889 }
1890
1891 void glMultiDrawArraysSUN(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount)
1892 {
1893         GET_CONTEXT;
1894         ctx->glMultiDrawArraysSUN(ctx, mode, first, count, primcount);
1895 }
1896
1897 void glMultiDrawElementsSUN(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount)
1898 {
1899         GET_CONTEXT;
1900         ctx->glMultiDrawElementsSUN(ctx, mode, count, type, indices, primcount);
1901 }
1902
1903 void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1904 {
1905         GET_CONTEXT;
1906         ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
1907 }
1908
1909 void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
1910 {
1911         GET_CONTEXT;
1912         ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
1913 }
1914
1915 void glDeleteFencesNV(GLsizei n, const GLuint* fences)
1916 {
1917         GET_CONTEXT;
1918          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
1919         ctx->glDeleteFencesNV(ctx, n, fences);
1920 }
1921
1922 void glGenFencesNV(GLsizei n, GLuint* fences)
1923 {
1924         GET_CONTEXT;
1925          if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
1926         ctx->glGenFencesNV(ctx, n, fences);
1927 }
1928
1929 GLboolean glIsFenceNV(GLuint fence)
1930 {
1931         GET_CONTEXT;
1932         return ctx->glIsFenceNV(ctx, fence);
1933 }
1934
1935 GLboolean glTestFenceNV(GLuint fence)
1936 {
1937         GET_CONTEXT;
1938         return ctx->glTestFenceNV(ctx, fence);
1939 }
1940
1941 void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params)
1942 {
1943         GET_CONTEXT;
1944         ctx->glGetFenceivNV(ctx, fence, pname, params);
1945 }
1946
1947 void glFinishFenceNV(GLuint fence)
1948 {
1949         GET_CONTEXT;
1950         ctx->glFinishFenceNV(ctx, fence);
1951 }
1952
1953 void glSetFenceNV(GLuint fence, GLenum condition)
1954 {
1955         GET_CONTEXT;
1956         ctx->glSetFenceNV(ctx, fence, condition);
1957 }
1958
1959 void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls)
1960 {
1961         GET_CONTEXT;
1962         ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
1963 }
1964
1965 void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString)
1966 {
1967         GET_CONTEXT;
1968         ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
1969 }
1970
1971 void glEnableDriverControlQCOM(GLuint driverControl)
1972 {
1973         GET_CONTEXT;
1974         ctx->glEnableDriverControlQCOM(ctx, driverControl);
1975 }
1976
1977 void glDisableDriverControlQCOM(GLuint driverControl)
1978 {
1979         GET_CONTEXT;
1980         ctx->glDisableDriverControlQCOM(ctx, driverControl);
1981 }
1982
1983 void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures)
1984 {
1985         GET_CONTEXT;
1986         ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
1987 }
1988
1989 void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers)
1990 {
1991         GET_CONTEXT;
1992         ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
1993 }
1994
1995 void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers)
1996 {
1997         GET_CONTEXT;
1998         ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
1999 }
2000
2001 void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers)
2002 {
2003         GET_CONTEXT;
2004         ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
2005 }
2006
2007 void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params)
2008 {
2009         GET_CONTEXT;
2010         ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
2011 }
2012
2013 void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
2014 {
2015         GET_CONTEXT;
2016         ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
2017 }
2018
2019 void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels)
2020 {
2021         GET_CONTEXT;
2022         ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
2023 }
2024
2025 void glExtGetBufferPointervQCOM(GLenum target, GLvoid** params)
2026 {
2027         GET_CONTEXT;
2028         ctx->glExtGetBufferPointervQCOM(ctx, target, params);
2029 }
2030
2031 void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders)
2032 {
2033         GET_CONTEXT;
2034         ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
2035 }
2036
2037 void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms)
2038 {
2039         GET_CONTEXT;
2040         ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
2041 }
2042
2043 GLboolean glExtIsProgramBinaryQCOM(GLuint program)
2044 {
2045         GET_CONTEXT;
2046         return ctx->glExtIsProgramBinaryQCOM(ctx, program);
2047 }
2048
2049 void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length)
2050 {
2051         GET_CONTEXT;
2052         ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
2053 }
2054
2055 void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
2056 {
2057         GET_CONTEXT;
2058         ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
2059 }
2060
2061 void glEndTilingQCOM(GLbitfield preserveMask)
2062 {
2063         GET_CONTEXT;
2064         ctx->glEndTilingQCOM(ctx, preserveMask);
2065 }
2066