#include <float.h>
#include "../ref_gl/gl_local.h"
#include "glw_win.h"
int(WINAPI *qwglChoosePixelFormat)(HDC, CONST PIXELFORMATDESCRIPTOR *);
int(WINAPI *qwglDescribePixelFormat)(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
int(WINAPI *qwglGetPixelFormat)(HDC);
BOOL(WINAPI *qwglSetPixelFormat)(HDC, int, CONST PIXELFORMATDESCRIPTOR *);
BOOL(WINAPI *qwglSwapBuffers)(HDC);
BOOL(WINAPI *qwglCopyContext)(HGLRC, HGLRC, UINT);
HGLRC(WINAPI *qwglCreateContext)(HDC);
HGLRC(WINAPI *qwglCreateLayerContext)(HDC, int);
BOOL(WINAPI *qwglDeleteContext)(HGLRC);
HGLRC(WINAPI *qwglGetCurrentContext)(VOID);
HDC(WINAPI *qwglGetCurrentDC)(VOID);
PROC(WINAPI *qwglGetProcAddress)(LPCSTR);
BOOL(WINAPI *qwglMakeCurrent)(HDC, HGLRC);
BOOL(WINAPI *qwglShareLists)(HGLRC, HGLRC);
BOOL(WINAPI *qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
BOOL(WINAPI *qwglUseFontOutlines)(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT);
BOOL(WINAPI *qwglDescribeLayerPlane)(HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR);
int(WINAPI *qwglSetLayerPaletteEntries)(HDC, int, int, int, CONST COLORREF *);
int(WINAPI *qwglGetLayerPaletteEntries)(HDC, int, int, int, COLORREF *);
BOOL(WINAPI *qwglRealizeLayerPalette)(HDC, int, BOOL);
BOOL(WINAPI *qwglSwapLayerBuffers)(HDC, UINT);
void(APIENTRY *qglAccum)(GLenum op, GLfloat value);
void(APIENTRY *qglAlphaFunc)(GLenum func, GLclampf ref);
GLboolean(APIENTRY *qglAreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences);
void(APIENTRY *qglArrayElement)(GLint i);
void(APIENTRY *qglBegin)(GLenum mode);
void(APIENTRY *qglBindTexture)(GLenum target, GLuint texture);
void(APIENTRY *qglBitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
const GLubyte *bitmap);
void(APIENTRY *qglBlendFunc)(GLenum sfactor, GLenum dfactor);
void(APIENTRY *qglCallList)(GLuint list);
void(APIENTRY *qglCallLists)(GLsizei n, GLenum type, const GLvoid *lists);
void(APIENTRY *qglClear)(GLbitfield mask);
void(APIENTRY *qglClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
void(APIENTRY *qglClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
void(APIENTRY *qglClearDepth)(GLclampd depth);
void(APIENTRY *qglClearIndex)(GLfloat c);
void(APIENTRY *qglClearStencil)(GLint s);
void(APIENTRY *qglClipPlane)(GLenum plane, const GLdouble *equation);
void(APIENTRY *qglColor3b)(GLbyte red, GLbyte green, GLbyte blue);
void(APIENTRY *qglColor3bv)(const GLbyte *v);
void(APIENTRY *qglColor3d)(GLdouble red, GLdouble green, GLdouble blue);
void(APIENTRY *qglColor3dv)(const GLdouble *v);
void(APIENTRY *qglColor3f)(GLfloat red, GLfloat green, GLfloat blue);
void(APIENTRY *qglColor3fv)(const GLfloat *v);
void(APIENTRY *qglColor3i)(GLint red, GLint green, GLint blue);
void(APIENTRY *qglColor3iv)(const GLint *v);
void(APIENTRY *qglColor3s)(GLshort red, GLshort green, GLshort blue);
void(APIENTRY *qglColor3sv)(const GLshort *v);
void(APIENTRY *qglColor3ub)(GLubyte red, GLubyte green, GLubyte blue);
void(APIENTRY *qglColor3ubv)(const GLubyte *v);
void(APIENTRY *qglColor3ui)(GLuint red, GLuint green, GLuint blue);
void(APIENTRY *qglColor3uiv)(const GLuint *v);
void(APIENTRY *qglColor3us)(GLushort red, GLushort green, GLushort blue);
void(APIENTRY *qglColor3usv)(const GLushort *v);
void(APIENTRY *qglColor4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
void(APIENTRY *qglColor4bv)(const GLbyte *v);
void(APIENTRY *qglColor4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
void(APIENTRY *qglColor4dv)(const GLdouble *v);
void(APIENTRY *qglColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
void(APIENTRY *qglColor4fv)(const GLfloat *v);
void(APIENTRY *qglColor4i)(GLint red, GLint green, GLint blue, GLint alpha);
void(APIENTRY *qglColor4iv)(const GLint *v);
void(APIENTRY *qglColor4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha);
void(APIENTRY *qglColor4sv)(const GLshort *v);
void(APIENTRY *qglColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
void(APIENTRY *qglColor4ubv)(const GLubyte *v);
void(APIENTRY *qglColor4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha);
void(APIENTRY *qglColor4uiv)(const GLuint *v);
void(APIENTRY *qglColor4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha);
void(APIENTRY *qglColor4usv)(const GLushort *v);
void(APIENTRY *qglColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
void(APIENTRY *qglColorMaterial)(GLenum face, GLenum mode);
void(APIENTRY *qglColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
void(APIENTRY *qglCopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
void(APIENTRY *qglCopyTexImage1D)(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width,
GLint border);
void(APIENTRY *qglCopyTexImage2D)(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width,
GLsizei height, GLint border);
void(APIENTRY *qglCopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
void(APIENTRY *qglCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
GLsizei width, GLsizei height);
void(APIENTRY *qglCullFace)(GLenum mode);
void(APIENTRY *qglDeleteLists)(GLuint list, GLsizei range);
void(APIENTRY *qglDeleteTextures)(GLsizei n, const GLuint *textures);
void(APIENTRY *qglDepthFunc)(GLenum func);
void(APIENTRY *qglDepthMask)(GLboolean flag);
void(APIENTRY *qglDepthRange)(GLclampd zNear, GLclampd zFar);
void(APIENTRY *qglDisable)(GLenum cap);
void(APIENTRY *qglDisableClientState)(GLenum array);
void(APIENTRY *qglDrawArrays)(GLenum mode, GLint first, GLsizei count);
void(APIENTRY *qglDrawBuffer)(GLenum mode);
void(APIENTRY *qglDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
void(APIENTRY *qglDrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
void(APIENTRY *qglEdgeFlag)(GLboolean flag);
void(APIENTRY *qglEdgeFlagPointer)(GLsizei stride, const GLvoid *pointer);
void(APIENTRY *qglEdgeFlagv)(const GLboolean *flag);
void(APIENTRY *qglEnable)(GLenum cap);
void(APIENTRY *qglEnableClientState)(GLenum array);
void(APIENTRY *qglEnd)(void);
void(APIENTRY *qglEndList)(void);
void(APIENTRY *qglEvalCoord1d)(GLdouble u);
void(APIENTRY *qglEvalCoord1dv)(const GLdouble *u);
void(APIENTRY *qglEvalCoord1f)(GLfloat u);
void(APIENTRY *qglEvalCoord1fv)(const GLfloat *u);
void(APIENTRY *qglEvalCoord2d)(GLdouble u, GLdouble v);
void(APIENTRY *qglEvalCoord2dv)(const GLdouble *u);
void(APIENTRY *qglEvalCoord2f)(GLfloat u, GLfloat v);
void(APIENTRY *qglEvalCoord2fv)(const GLfloat *u);
void(APIENTRY *qglEvalMesh1)(GLenum mode, GLint i1, GLint i2);
void(APIENTRY *qglEvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
void(APIENTRY *qglEvalPoint1)(GLint i);
void(APIENTRY *qglEvalPoint2)(GLint i, GLint j);
void(APIENTRY *qglFeedbackBuffer)(GLsizei size, GLenum type, GLfloat *buffer);
void(APIENTRY *qglFinish)(void);
void(APIENTRY *qglFlush)(void);
void(APIENTRY *qglFogf)(GLenum pname, GLfloat param);
void(APIENTRY *qglFogfv)(GLenum pname, const GLfloat *params);
void(APIENTRY *qglFogi)(GLenum pname, GLint param);
void(APIENTRY *qglFogiv)(GLenum pname, const GLint *params);
void(APIENTRY *qglFrontFace)(GLenum mode);
void(APIENTRY *qglFrustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
GLuint(APIENTRY *qglGenLists)(GLsizei range);
void(APIENTRY *qglGenTextures)(GLsizei n, GLuint *textures);
void(APIENTRY *qglGetBooleanv)(GLenum pname, GLboolean *params);
void(APIENTRY *qglGetClipPlane)(GLenum plane, GLdouble *equation);
void(APIENTRY *qglGetDoublev)(GLenum pname, GLdouble *params);
GLenum(APIENTRY *qglGetError)(void);
void(APIENTRY *qglGetFloatv)(GLenum pname, GLfloat *params);
void(APIENTRY *qglGetIntegerv)(GLenum pname, GLint *params);
void(APIENTRY *qglGetLightfv)(GLenum light, GLenum pname, GLfloat *params);
void(APIENTRY *qglGetLightiv)(GLenum light, GLenum pname, GLint *params);
void(APIENTRY *qglGetMapdv)(GLenum target, GLenum query, GLdouble *v);
void(APIENTRY *qglGetMapfv)(GLenum target, GLenum query, GLfloat *v);
void(APIENTRY *qglGetMapiv)(GLenum target, GLenum query, GLint *v);
void(APIENTRY *qglGetMaterialfv)(GLenum face, GLenum pname, GLfloat *params);
void(APIENTRY *qglGetMaterialiv)(GLenum face, GLenum pname, GLint *params);
void(APIENTRY *qglGetPixelMapfv)(GLenum map, GLfloat *values);
void(APIENTRY *qglGetPixelMapuiv)(GLenum map, GLuint *values);
void(APIENTRY *qglGetPixelMapusv)(GLenum map, GLushort *values);
void(APIENTRY *qglGetPointerv)(GLenum pname, GLvoid **params);
void(APIENTRY *qglGetPolygonStipple)(GLubyte *mask);
const GLubyte *(APIENTRY *qglGetString)(GLenum name);
void(APIENTRY *qglGetTexEnvfv)(GLenum target, GLenum pname, GLfloat *params);
void(APIENTRY *qglGetTexEnviv)(GLenum target, GLenum pname, GLint *params);
void(APIENTRY *qglGetTexGendv)(GLenum coord, GLenum pname, GLdouble *params);
void(APIENTRY *qglGetTexGenfv)(GLenum coord, GLenum pname, GLfloat *params);
void(APIENTRY *qglGetTexGeniv)(GLenum coord, GLenum pname, GLint *params);
void(APIENTRY *qglGetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
void(APIENTRY *qglGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
void(APIENTRY *qglGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
void(APIENTRY *qglGetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void(APIENTRY *qglGetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
void(APIENTRY *qglHint)(GLenum target, GLenum mode);
void(APIENTRY *qglIndexMask)(GLuint mask);
void(APIENTRY *qglIndexPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
void(APIENTRY *qglIndexd)(GLdouble c);
void(APIENTRY *qglIndexdv)(const GLdouble *c);
void(APIENTRY *qglIndexf)(GLfloat c);
void(APIENTRY *qglIndexfv)(const GLfloat *c);
void(APIENTRY *qglIndexi)(GLint c);
void(APIENTRY *qglIndexiv)(const GLint *c);
void(APIENTRY *qglIndexs)(GLshort c);
void(APIENTRY *qglIndexsv)(const GLshort *c);
void(APIENTRY *qglIndexub)(GLubyte c);
void(APIENTRY *qglIndexubv)(const GLubyte *c);
void(APIENTRY *qglInitNames)(void);
void(APIENTRY *qglInterleavedArrays)(GLenum format, GLsizei stride, const GLvoid *pointer);
GLboolean(APIENTRY *qglIsEnabled)(GLenum cap);
GLboolean(APIENTRY *qglIsList)(GLuint list);
GLboolean(APIENTRY *qglIsTexture)(GLuint texture);
void(APIENTRY *qglLightModelf)(GLenum pname, GLfloat param);
void(APIENTRY *qglLightModelfv)(GLenum pname, const GLfloat *params);
void(APIENTRY *qglLightModeli)(GLenum pname, GLint param);
void(APIENTRY *qglLightModeliv)(GLenum pname, const GLint *params);
void(APIENTRY *qglLightf)(GLenum light, GLenum pname, GLfloat param);
void(APIENTRY *qglLightfv)(GLenum light, GLenum pname, const GLfloat *params);
void(APIENTRY *qglLighti)(GLenum light, GLenum pname, GLint param);
void(APIENTRY *qglLightiv)(GLenum light, GLenum pname, const GLint *params);
void(APIENTRY *qglLineStipple)(GLint factor, GLushort pattern);
void(APIENTRY *qglLineWidth)(GLfloat width);
void(APIENTRY *qglListBase)(GLuint base);
void(APIENTRY *qglLoadIdentity)(void);
void(APIENTRY *qglLoadMatrixd)(const GLdouble *m);
void(APIENTRY *qglLoadMatrixf)(const GLfloat *m);
void(APIENTRY *qglLoadName)(GLuint name);
void(APIENTRY *qglLogicOp)(GLenum opcode);
void(APIENTRY *qglMap1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
void(APIENTRY *qglMap1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
void(APIENTRY *qglMap2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2,
GLint vstride, GLint vorder, const GLdouble *points);
void(APIENTRY *qglMap2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2,
GLint vstride, GLint vorder, const GLfloat *points);
void(APIENTRY *qglMapGrid1d)(GLint un, GLdouble u1, GLdouble u2);
void(APIENTRY *qglMapGrid1f)(GLint un, GLfloat u1, GLfloat u2);
void(APIENTRY *qglMapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
void(APIENTRY *qglMapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
void(APIENTRY *qglMaterialf)(GLenum face, GLenum pname, GLfloat param);
void(APIENTRY *qglMaterialfv)(GLenum face, GLenum pname, const GLfloat *params);
void(APIENTRY *qglMateriali)(GLenum face, GLenum pname, GLint param);
void(APIENTRY *qglMaterialiv)(GLenum face, GLenum pname, const GLint *params);
void(APIENTRY *qglMatrixMode)(GLenum mode);
void(APIENTRY *qglMultMatrixd)(const GLdouble *m);
void(APIENTRY *qglMultMatrixf)(const GLfloat *m);
void(APIENTRY *qglNewList)(GLuint list, GLenum mode);
void(APIENTRY *qglNormal3b)(GLbyte nx, GLbyte ny, GLbyte nz);
void(APIENTRY *qglNormal3bv)(const GLbyte *v);
void(APIENTRY *qglNormal3d)(GLdouble nx, GLdouble ny, GLdouble nz);
void(APIENTRY *qglNormal3dv)(const GLdouble *v);
void(APIENTRY *qglNormal3f)(GLfloat nx, GLfloat ny, GLfloat nz);
void(APIENTRY *qglNormal3fv)(const GLfloat *v);
void(APIENTRY *qglNormal3i)(GLint nx, GLint ny, GLint nz);
void(APIENTRY *qglNormal3iv)(const GLint *v);
void(APIENTRY *qglNormal3s)(GLshort nx, GLshort ny, GLshort nz);
void(APIENTRY *qglNormal3sv)(const GLshort *v);
void(APIENTRY *qglNormalPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
void(APIENTRY *qglOrtho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
void(APIENTRY *qglPassThrough)(GLfloat token);
void(APIENTRY *qglPixelMapfv)(GLenum map, GLsizei mapsize, const GLfloat *values);
void(APIENTRY *qglPixelMapuiv)(GLenum map, GLsizei mapsize, const GLuint *values);
void(APIENTRY *qglPixelMapusv)(GLenum map, GLsizei mapsize, const GLushort *values);
void(APIENTRY *qglPixelStoref)(GLenum pname, GLfloat param);
void(APIENTRY *qglPixelStorei)(GLenum pname, GLint param);
void(APIENTRY *qglPixelTransferf)(GLenum pname, GLfloat param);
void(APIENTRY *qglPixelTransferi)(GLenum pname, GLint param);
void(APIENTRY *qglPixelZoom)(GLfloat xfactor, GLfloat yfactor);
void(APIENTRY *qglPointSize)(GLfloat size);
void(APIENTRY *qglPolygonMode)(GLenum face, GLenum mode);
void(APIENTRY *qglPolygonOffset)(GLfloat factor, GLfloat units);
void(APIENTRY *qglPolygonStipple)(const GLubyte *mask);
void(APIENTRY *qglPopAttrib)(void);
void(APIENTRY *qglPopClientAttrib)(void);
void(APIENTRY *qglPopMatrix)(void);
void(APIENTRY *qglPopName)(void);
void(APIENTRY *qglPrioritizeTextures)(GLsizei n, const GLuint *textures, const GLclampf *priorities);
void(APIENTRY *qglPushAttrib)(GLbitfield mask);
void(APIENTRY *qglPushClientAttrib)(GLbitfield mask);
void(APIENTRY *qglPushMatrix)(void);
void(APIENTRY *qglPushName)(GLuint name);
void(APIENTRY *qglRasterPos2d)(GLdouble x, GLdouble y);
void(APIENTRY *qglRasterPos2dv)(const GLdouble *v);
void(APIENTRY *qglRasterPos2f)(GLfloat x, GLfloat y);
void(APIENTRY *qglRasterPos2fv)(const GLfloat *v);
void(APIENTRY *qglRasterPos2i)(GLint x, GLint y);
void(APIENTRY *qglRasterPos2iv)(const GLint *v);
void(APIENTRY *qglRasterPos2s)(GLshort x, GLshort y);
void(APIENTRY *qglRasterPos2sv)(const GLshort *v);
void(APIENTRY *qglRasterPos3d)(GLdouble x, GLdouble y, GLdouble z);
void(APIENTRY *qglRasterPos3dv)(const GLdouble *v);
void(APIENTRY *qglRasterPos3f)(GLfloat x, GLfloat y, GLfloat z);
void(APIENTRY *qglRasterPos3fv)(const GLfloat *v);
void(APIENTRY *qglRasterPos3i)(GLint x, GLint y, GLint z);
void(APIENTRY *qglRasterPos3iv)(const GLint *v);
void(APIENTRY *qglRasterPos3s)(GLshort x, GLshort y, GLshort z);
void(APIENTRY *qglRasterPos3sv)(const GLshort *v);
void(APIENTRY *qglRasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
void(APIENTRY *qglRasterPos4dv)(const GLdouble *v);
void(APIENTRY *qglRasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
void(APIENTRY *qglRasterPos4fv)(const GLfloat *v);
void(APIENTRY *qglRasterPos4i)(GLint x, GLint y, GLint z, GLint w);
void(APIENTRY *qglRasterPos4iv)(const GLint *v);
void(APIENTRY *qglRasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w);
void(APIENTRY *qglRasterPos4sv)(const GLshort *v);
void(APIENTRY *qglReadBuffer)(GLenum mode);
void(APIENTRY *qglReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
GLvoid *pixels);
void(APIENTRY *qglRectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
void(APIENTRY *qglRectdv)(const GLdouble *v1, const GLdouble *v2);
void(APIENTRY *qglRectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
void(APIENTRY *qglRectfv)(const GLfloat *v1, const GLfloat *v2);
void(APIENTRY *qglRecti)(GLint x1, GLint y1, GLint x2, GLint y2);
void(APIENTRY *qglRectiv)(const GLint *v1, const GLint *v2);
void(APIENTRY *qglRects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
void(APIENTRY *qglRectsv)(const GLshort *v1, const GLshort *v2);
GLint(APIENTRY *qglRenderMode)(GLenum mode);
void(APIENTRY *qglRotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
void(APIENTRY *qglRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
void(APIENTRY *qglScaled)(GLdouble x, GLdouble y, GLdouble z);
void(APIENTRY *qglScalef)(GLfloat x, GLfloat y, GLfloat z);
void(APIENTRY *qglScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
void(APIENTRY *qglSelectBuffer)(GLsizei size, GLuint *buffer);
void(APIENTRY *qglShadeModel)(GLenum mode);
void(APIENTRY *qglStencilFunc)(GLenum func, GLint ref, GLuint mask);
void(APIENTRY *qglStencilMask)(GLuint mask);
void(APIENTRY *qglStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
void(APIENTRY *qglTexCoord1d)(GLdouble s);
void(APIENTRY *qglTexCoord1dv)(const GLdouble *v);
void(APIENTRY *qglTexCoord1f)(GLfloat s);
void(APIENTRY *qglTexCoord1fv)(const GLfloat *v);
void(APIENTRY *qglTexCoord1i)(GLint s);
void(APIENTRY *qglTexCoord1iv)(const GLint *v);
void(APIENTRY *qglTexCoord1s)(GLshort s);
void(APIENTRY *qglTexCoord1sv)(const GLshort *v);
void(APIENTRY *qglTexCoord2d)(GLdouble s, GLdouble t);
void(APIENTRY *qglTexCoord2dv)(const GLdouble *v);
void(APIENTRY *qglTexCoord2f)(GLfloat s, GLfloat t);
void(APIENTRY *qglTexCoord2fv)(const GLfloat *v);
void(APIENTRY *qglTexCoord2i)(GLint s, GLint t);
void(APIENTRY *qglTexCoord2iv)(const GLint *v);
void(APIENTRY *qglTexCoord2s)(GLshort s, GLshort t);
void(APIENTRY *qglTexCoord2sv)(const GLshort *v);
void(APIENTRY *qglTexCoord3d)(GLdouble s, GLdouble t, GLdouble r);
void(APIENTRY *qglTexCoord3dv)(const GLdouble *v);
void(APIENTRY *qglTexCoord3f)(GLfloat s, GLfloat t, GLfloat r);
void(APIENTRY *qglTexCoord3fv)(const GLfloat *v);
void(APIENTRY *qglTexCoord3i)(GLint s, GLint t, GLint r);
void(APIENTRY *qglTexCoord3iv)(const GLint *v);
void(APIENTRY *qglTexCoord3s)(GLshort s, GLshort t, GLshort r);
void(APIENTRY *qglTexCoord3sv)(const GLshort *v);
void(APIENTRY *qglTexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
void(APIENTRY *qglTexCoord4dv)(const GLdouble *v);
void(APIENTRY *qglTexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
void(APIENTRY *qglTexCoord4fv)(const GLfloat *v);
void(APIENTRY *qglTexCoord4i)(GLint s, GLint t, GLint r, GLint q);
void(APIENTRY *qglTexCoord4iv)(const GLint *v);
void(APIENTRY *qglTexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q);
void(APIENTRY *qglTexCoord4sv)(const GLshort *v);
void(APIENTRY *qglTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
void(APIENTRY *qglTexEnvf)(GLenum target, GLenum pname, GLfloat param);
void(APIENTRY *qglTexEnvfv)(GLenum target, GLenum pname, const GLfloat *params);
void(APIENTRY *qglTexEnvi)(GLenum target, GLenum pname, GLint param);
void(APIENTRY *qglTexEnviv)(GLenum target, GLenum pname, const GLint *params);
void(APIENTRY *qglTexGend)(GLenum coord, GLenum pname, GLdouble param);
void(APIENTRY *qglTexGendv)(GLenum coord, GLenum pname, const GLdouble *params);
void(APIENTRY *qglTexGenf)(GLenum coord, GLenum pname, GLfloat param);
void(APIENTRY *qglTexGenfv)(GLenum coord, GLenum pname, const GLfloat *params);
void(APIENTRY *qglTexGeni)(GLenum coord, GLenum pname, GLint param);
void(APIENTRY *qglTexGeniv)(GLenum coord, GLenum pname, const GLint *params);
void(APIENTRY *qglTexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border,
GLenum format, GLenum type, const GLvoid *pixels);
void(APIENTRY *qglTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const GLvoid *pixels);
void(APIENTRY *qglTexParameterf)(GLenum target, GLenum pname, GLfloat param);
void(APIENTRY *qglTexParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
void(APIENTRY *qglTexParameteri)(GLenum target, GLenum pname, GLint param);
void(APIENTRY *qglTexParameteriv)(GLenum target, GLenum pname, const GLint *params);
void(APIENTRY *qglTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type,
const GLvoid *pixels);
void(APIENTRY *qglTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
void(APIENTRY *qglTranslated)(GLdouble x, GLdouble y, GLdouble z);
void(APIENTRY *qglTranslatef)(GLfloat x, GLfloat y, GLfloat z);
void(APIENTRY *qglVertex2d)(GLdouble x, GLdouble y);
void(APIENTRY *qglVertex2dv)(const GLdouble *v);
void(APIENTRY *qglVertex2f)(GLfloat x, GLfloat y);
void(APIENTRY *qglVertex2fv)(const GLfloat *v);
void(APIENTRY *qglVertex2i)(GLint x, GLint y);
void(APIENTRY *qglVertex2iv)(const GLint *v);
void(APIENTRY *qglVertex2s)(GLshort x, GLshort y);
void(APIENTRY *qglVertex2sv)(const GLshort *v);
void(APIENTRY *qglVertex3d)(GLdouble x, GLdouble y, GLdouble z);
void(APIENTRY *qglVertex3dv)(const GLdouble *v);
void(APIENTRY *qglVertex3f)(GLfloat x, GLfloat y, GLfloat z);
void(APIENTRY *qglVertex3fv)(const GLfloat *v);
void(APIENTRY *qglVertex3i)(GLint x, GLint y, GLint z);
void(APIENTRY *qglVertex3iv)(const GLint *v);
void(APIENTRY *qglVertex3s)(GLshort x, GLshort y, GLshort z);
void(APIENTRY *qglVertex3sv)(const GLshort *v);
void(APIENTRY *qglVertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
void(APIENTRY *qglVertex4dv)(const GLdouble *v);
void(APIENTRY *qglVertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
void(APIENTRY *qglVertex4fv)(const GLfloat *v);
void(APIENTRY *qglVertex4i)(GLint x, GLint y, GLint z, GLint w);
void(APIENTRY *qglVertex4iv)(const GLint *v);
void(APIENTRY *qglVertex4s)(GLshort x, GLshort y, GLshort z, GLshort w);
void(APIENTRY *qglVertex4sv)(const GLshort *v);
void(APIENTRY *qglVertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
void(APIENTRY *qglViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
void(APIENTRY *qglLockArraysEXT)(int, int);
void(APIENTRY *qglUnlockArraysEXT)(void);
BOOL(WINAPI *qwglSwapIntervalEXT)(int interval);
BOOL(WINAPI *qwglGetDeviceGammaRampEXT)(unsigned char *, unsigned char *, unsigned char *);
BOOL(WINAPI *qwglSetDeviceGammaRampEXT)(const unsigned char *, const unsigned char *, const unsigned char *);
void(APIENTRY *qglPointParameterfEXT)(GLenum param, GLfloat value);
void(APIENTRY *qglPointParameterfvEXT)(GLenum param, const GLfloat *value);
void(APIENTRY *qglColorTableEXT)(int, int, int, int, int, const void *);
void(APIENTRY *qglSelectTextureSGIS)(GLenum);
void(APIENTRY *qglMTexCoord2fSGIS)(GLenum, GLfloat, GLfloat);
static void(APIENTRY *dllAccum)(GLenum op, GLfloat value);
static void(APIENTRY *dllAlphaFunc)(GLenum func, GLclampf ref);
GLboolean(APIENTRY *dllAreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences);
static void(APIENTRY *dllArrayElement)(GLint i);
static void(APIENTRY *dllBegin)(GLenum mode);
static void(APIENTRY *dllBindTexture)(GLenum target, GLuint texture);
static void(APIENTRY *dllBitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove,
GLfloat ymove, const GLubyte *bitmap);
static void(APIENTRY *dllBlendFunc)(GLenum sfactor, GLenum dfactor);
static void(APIENTRY *dllCallList)(GLuint list);
static void(APIENTRY *dllCallLists)(GLsizei n, GLenum type, const GLvoid *lists);
static void(APIENTRY *dllClear)(GLbitfield mask);
static void(APIENTRY *dllClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
static void(APIENTRY *dllClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
static void(APIENTRY *dllClearDepth)(GLclampd depth);
static void(APIENTRY *dllClearIndex)(GLfloat c);
static void(APIENTRY *dllClearStencil)(GLint s);
static void(APIENTRY *dllClipPlane)(GLenum plane, const GLdouble *equation);
static void(APIENTRY *dllColor3b)(GLbyte red, GLbyte green, GLbyte blue);
static void(APIENTRY *dllColor3bv)(const GLbyte *v);
static void(APIENTRY *dllColor3d)(GLdouble red, GLdouble green, GLdouble blue);
static void(APIENTRY *dllColor3dv)(const GLdouble *v);
static void(APIENTRY *dllColor3f)(GLfloat red, GLfloat green, GLfloat blue);
static void(APIENTRY *dllColor3fv)(const GLfloat *v);
static void(APIENTRY *dllColor3i)(GLint red, GLint green, GLint blue);
static void(APIENTRY *dllColor3iv)(const GLint *v);
static void(APIENTRY *dllColor3s)(GLshort red, GLshort green, GLshort blue);
static void(APIENTRY *dllColor3sv)(const GLshort *v);
static void(APIENTRY *dllColor3ub)(GLubyte red, GLubyte green, GLubyte blue);
static void(APIENTRY *dllColor3ubv)(const GLubyte *v);
static void(APIENTRY *dllColor3ui)(GLuint red, GLuint green, GLuint blue);
static void(APIENTRY *dllColor3uiv)(const GLuint *v);
static void(APIENTRY *dllColor3us)(GLushort red, GLushort green, GLushort blue);
static void(APIENTRY *dllColor3usv)(const GLushort *v);
static void(APIENTRY *dllColor4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
static void(APIENTRY *dllColor4bv)(const GLbyte *v);
static void(APIENTRY *dllColor4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
static void(APIENTRY *dllColor4dv)(const GLdouble *v);
static void(APIENTRY *dllColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
static void(APIENTRY *dllColor4fv)(const GLfloat *v);
static void(APIENTRY *dllColor4i)(GLint red, GLint green, GLint blue, GLint alpha);
static void(APIENTRY *dllColor4iv)(const GLint *v);
static void(APIENTRY *dllColor4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha);
static void(APIENTRY *dllColor4sv)(const GLshort *v);
static void(APIENTRY *dllColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
static void(APIENTRY *dllColor4ubv)(const GLubyte *v);
static void(APIENTRY *dllColor4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha);
static void(APIENTRY *dllColor4uiv)(const GLuint *v);
static void(APIENTRY *dllColor4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha);
static void(APIENTRY *dllColor4usv)(const GLushort *v);
static void(APIENTRY *dllColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
static void(APIENTRY *dllColorMaterial)(GLenum face, GLenum mode);
static void(APIENTRY *dllColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static void(APIENTRY *dllCopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
static void(APIENTRY *dllCopyTexImage1D)(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y,
GLsizei width, GLint border);
static void(APIENTRY *dllCopyTexImage2D)(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y,
GLsizei width, GLsizei height, GLint border);
static void(APIENTRY *dllCopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
static void(APIENTRY *dllCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
GLsizei width, GLsizei height);
static void(APIENTRY *dllCullFace)(GLenum mode);
static void(APIENTRY *dllDeleteLists)(GLuint list, GLsizei range);
static void(APIENTRY *dllDeleteTextures)(GLsizei n, const GLuint *textures);
static void(APIENTRY *dllDepthFunc)(GLenum func);
static void(APIENTRY *dllDepthMask)(GLboolean flag);
static void(APIENTRY *dllDepthRange)(GLclampd zNear, GLclampd zFar);
static void(APIENTRY *dllDisable)(GLenum cap);
static void(APIENTRY *dllDisableClientState)(GLenum array);
static void(APIENTRY *dllDrawArrays)(GLenum mode, GLint first, GLsizei count);
static void(APIENTRY *dllDrawBuffer)(GLenum mode);
static void(APIENTRY *dllDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
static void(APIENTRY *dllDrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
static void(APIENTRY *dllEdgeFlag)(GLboolean flag);
static void(APIENTRY *dllEdgeFlagPointer)(GLsizei stride, const GLvoid *pointer);
static void(APIENTRY *dllEdgeFlagv)(const GLboolean *flag);
static void(APIENTRY *dllEnable)(GLenum cap);
static void(APIENTRY *dllEnableClientState)(GLenum array);
static void(APIENTRY *dllEnd)(void);
static void(APIENTRY *dllEndList)(void);
static void(APIENTRY *dllEvalCoord1d)(GLdouble u);
static void(APIENTRY *dllEvalCoord1dv)(const GLdouble *u);
static void(APIENTRY *dllEvalCoord1f)(GLfloat u);
static void(APIENTRY *dllEvalCoord1fv)(const GLfloat *u);
static void(APIENTRY *dllEvalCoord2d)(GLdouble u, GLdouble v);
static void(APIENTRY *dllEvalCoord2dv)(const GLdouble *u);
static void(APIENTRY *dllEvalCoord2f)(GLfloat u, GLfloat v);
static void(APIENTRY *dllEvalCoord2fv)(const GLfloat *u);
static void(APIENTRY *dllEvalMesh1)(GLenum mode, GLint i1, GLint i2);
static void(APIENTRY *dllEvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
static void(APIENTRY *dllEvalPoint1)(GLint i);
static void(APIENTRY *dllEvalPoint2)(GLint i, GLint j);
static void(APIENTRY *dllFeedbackBuffer)(GLsizei size, GLenum type, GLfloat *buffer);
static void(APIENTRY *dllFinish)(void);
static void(APIENTRY *dllFlush)(void);
static void(APIENTRY *dllFogf)(GLenum pname, GLfloat param);
static void(APIENTRY *dllFogfv)(GLenum pname, const GLfloat *params);
static void(APIENTRY *dllFogi)(GLenum pname, GLint param);
static void(APIENTRY *dllFogiv)(GLenum pname, const GLint *params);
static void(APIENTRY *dllFrontFace)(GLenum mode);
static void(APIENTRY *dllFrustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear,
GLdouble zFar);
GLuint(APIENTRY *dllGenLists)(GLsizei range);
static void(APIENTRY *dllGenTextures)(GLsizei n, GLuint *textures);
static void(APIENTRY *dllGetBooleanv)(GLenum pname, GLboolean *params);
static void(APIENTRY *dllGetClipPlane)(GLenum plane, GLdouble *equation);
static void(APIENTRY *dllGetDoublev)(GLenum pname, GLdouble *params);
GLenum(APIENTRY *dllGetError)(void);
static void(APIENTRY *dllGetFloatv)(GLenum pname, GLfloat *params);
static void(APIENTRY *dllGetIntegerv)(GLenum pname, GLint *params);
static void(APIENTRY *dllGetLightfv)(GLenum light, GLenum pname, GLfloat *params);
static void(APIENTRY *dllGetLightiv)(GLenum light, GLenum pname, GLint *params);
static void(APIENTRY *dllGetMapdv)(GLenum target, GLenum query, GLdouble *v);
static void(APIENTRY *dllGetMapfv)(GLenum target, GLenum query, GLfloat *v);
static void(APIENTRY *dllGetMapiv)(GLenum target, GLenum query, GLint *v);
static void(APIENTRY *dllGetMaterialfv)(GLenum face, GLenum pname, GLfloat *params);
static void(APIENTRY *dllGetMaterialiv)(GLenum face, GLenum pname, GLint *params);
static void(APIENTRY *dllGetPixelMapfv)(GLenum map, GLfloat *values);
static void(APIENTRY *dllGetPixelMapuiv)(GLenum map, GLuint *values);
static void(APIENTRY *dllGetPixelMapusv)(GLenum map, GLushort *values);
static void(APIENTRY *dllGetPointerv)(GLenum pname, GLvoid **params);
static void(APIENTRY *dllGetPolygonStipple)(GLubyte *mask);
const GLubyte *(APIENTRY *dllGetString)(GLenum name);
static void(APIENTRY *dllGetTexEnvfv)(GLenum target, GLenum pname, GLfloat *params);
static void(APIENTRY *dllGetTexEnviv)(GLenum target, GLenum pname, GLint *params);
static void(APIENTRY *dllGetTexGendv)(GLenum coord, GLenum pname, GLdouble *params);
static void(APIENTRY *dllGetTexGenfv)(GLenum coord, GLenum pname, GLfloat *params);
static void(APIENTRY *dllGetTexGeniv)(GLenum coord, GLenum pname, GLint *params);
static void(APIENTRY *dllGetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
static void(APIENTRY *dllGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
static void(APIENTRY *dllGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
static void(APIENTRY *dllGetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
static void(APIENTRY *dllGetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
static void(APIENTRY *dllHint)(GLenum target, GLenum mode);
static void(APIENTRY *dllIndexMask)(GLuint mask);
static void(APIENTRY *dllIndexPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
static void(APIENTRY *dllIndexd)(GLdouble c);
static void(APIENTRY *dllIndexdv)(const GLdouble *c);
static void(APIENTRY *dllIndexf)(GLfloat c);
static void(APIENTRY *dllIndexfv)(const GLfloat *c);
static void(APIENTRY *dllIndexi)(GLint c);
static void(APIENTRY *dllIndexiv)(const GLint *c);
static void(APIENTRY *dllIndexs)(GLshort c);
static void(APIENTRY *dllIndexsv)(const GLshort *c);
static void(APIENTRY *dllIndexub)(GLubyte c);
static void(APIENTRY *dllIndexubv)(const GLubyte *c);
static void(APIENTRY *dllInitNames)(void);
static void(APIENTRY *dllInterleavedArrays)(GLenum format, GLsizei stride, const GLvoid *pointer);
GLboolean(APIENTRY *dllIsEnabled)(GLenum cap);
GLboolean(APIENTRY *dllIsList)(GLuint list);
GLboolean(APIENTRY *dllIsTexture)(GLuint texture);
static void(APIENTRY *dllLightModelf)(GLenum pname, GLfloat param);
static void(APIENTRY *dllLightModelfv)(GLenum pname, const GLfloat *params);
static void(APIENTRY *dllLightModeli)(GLenum pname, GLint param);
static void(APIENTRY *dllLightModeliv)(GLenum pname, const GLint *params);
static void(APIENTRY *dllLightf)(GLenum light, GLenum pname, GLfloat param);
static void(APIENTRY *dllLightfv)(GLenum light, GLenum pname, const GLfloat *params);
static void(APIENTRY *dllLighti)(GLenum light, GLenum pname, GLint param);
static void(APIENTRY *dllLightiv)(GLenum light, GLenum pname, const GLint *params);
static void(APIENTRY *dllLineStipple)(GLint factor, GLushort pattern);
static void(APIENTRY *dllLineWidth)(GLfloat width);
static void(APIENTRY *dllListBase)(GLuint base);
static void(APIENTRY *dllLoadIdentity)(void);
static void(APIENTRY *dllLoadMatrixd)(const GLdouble *m);
static void(APIENTRY *dllLoadMatrixf)(const GLfloat *m);
static void(APIENTRY *dllLoadName)(GLuint name);
static void(APIENTRY *dllLogicOp)(GLenum opcode);
static void(APIENTRY *dllMap1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order,
const GLdouble *points);
static void(APIENTRY *dllMap1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order,
const GLfloat *points);
static void(APIENTRY *dllMap2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1,
GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
static void(APIENTRY *dllMap2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1,
GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
static void(APIENTRY *dllMapGrid1d)(GLint un, GLdouble u1, GLdouble u2);
static void(APIENTRY *dllMapGrid1f)(GLint un, GLfloat u1, GLfloat u2);
static void(APIENTRY *dllMapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
static void(APIENTRY *dllMapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
static void(APIENTRY *dllMaterialf)(GLenum face, GLenum pname, GLfloat param);
static void(APIENTRY *dllMaterialfv)(GLenum face, GLenum pname, const GLfloat *params);
static void(APIENTRY *dllMateriali)(GLenum face, GLenum pname, GLint param);
static void(APIENTRY *dllMaterialiv)(GLenum face, GLenum pname, const GLint *params);
static void(APIENTRY *dllMatrixMode)(GLenum mode);
static void(APIENTRY *dllMultMatrixd)(const GLdouble *m);
static void(APIENTRY *dllMultMatrixf)(const GLfloat *m);
static void(APIENTRY *dllNewList)(GLuint list, GLenum mode);
static void(APIENTRY *dllNormal3b)(GLbyte nx, GLbyte ny, GLbyte nz);
static void(APIENTRY *dllNormal3bv)(const GLbyte *v);
static void(APIENTRY *dllNormal3d)(GLdouble nx, GLdouble ny, GLdouble nz);
static void(APIENTRY *dllNormal3dv)(const GLdouble *v);
static void(APIENTRY *dllNormal3f)(GLfloat nx, GLfloat ny, GLfloat nz);
static void(APIENTRY *dllNormal3fv)(const GLfloat *v);
static void(APIENTRY *dllNormal3i)(GLint nx, GLint ny, GLint nz);
static void(APIENTRY *dllNormal3iv)(const GLint *v);
static void(APIENTRY *dllNormal3s)(GLshort nx, GLshort ny, GLshort nz);
static void(APIENTRY *dllNormal3sv)(const GLshort *v);
static void(APIENTRY *dllNormalPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
static void(APIENTRY *dllOrtho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear,
GLdouble zFar);
static void(APIENTRY *dllPassThrough)(GLfloat token);
static void(APIENTRY *dllPixelMapfv)(GLenum map, GLsizei mapsize, const GLfloat *values);
static void(APIENTRY *dllPixelMapuiv)(GLenum map, GLsizei mapsize, const GLuint *values);
static void(APIENTRY *dllPixelMapusv)(GLenum map, GLsizei mapsize, const GLushort *values);
static void(APIENTRY *dllPixelStoref)(GLenum pname, GLfloat param);
static void(APIENTRY *dllPixelStorei)(GLenum pname, GLint param);
static void(APIENTRY *dllPixelTransferf)(GLenum pname, GLfloat param);
static void(APIENTRY *dllPixelTransferi)(GLenum pname, GLint param);
static void(APIENTRY *dllPixelZoom)(GLfloat xfactor, GLfloat yfactor);
static void(APIENTRY *dllPointSize)(GLfloat size);
static void(APIENTRY *dllPolygonMode)(GLenum face, GLenum mode);
static void(APIENTRY *dllPolygonOffset)(GLfloat factor, GLfloat units);
static void(APIENTRY *dllPolygonStipple)(const GLubyte *mask);
static void(APIENTRY *dllPopAttrib)(void);
static void(APIENTRY *dllPopClientAttrib)(void);
static void(APIENTRY *dllPopMatrix)(void);
static void(APIENTRY *dllPopName)(void);
static void(APIENTRY *dllPrioritizeTextures)(GLsizei n, const GLuint *textures, const GLclampf *priorities);
static void(APIENTRY *dllPushAttrib)(GLbitfield mask);
static void(APIENTRY *dllPushClientAttrib)(GLbitfield mask);
static void(APIENTRY *dllPushMatrix)(void);
static void(APIENTRY *dllPushName)(GLuint name);
static void(APIENTRY *dllRasterPos2d)(GLdouble x, GLdouble y);
static void(APIENTRY *dllRasterPos2dv)(const GLdouble *v);
static void(APIENTRY *dllRasterPos2f)(GLfloat x, GLfloat y);
static void(APIENTRY *dllRasterPos2fv)(const GLfloat *v);
static void(APIENTRY *dllRasterPos2i)(GLint x, GLint y);
static void(APIENTRY *dllRasterPos2iv)(const GLint *v);
static void(APIENTRY *dllRasterPos2s)(GLshort x, GLshort y);
static void(APIENTRY *dllRasterPos2sv)(const GLshort *v);
static void(APIENTRY *dllRasterPos3d)(GLdouble x, GLdouble y, GLdouble z);
static void(APIENTRY *dllRasterPos3dv)(const GLdouble *v);
static void(APIENTRY *dllRasterPos3f)(GLfloat x, GLfloat y, GLfloat z);
static void(APIENTRY *dllRasterPos3fv)(const GLfloat *v);
static void(APIENTRY *dllRasterPos3i)(GLint x, GLint y, GLint z);
static void(APIENTRY *dllRasterPos3iv)(const GLint *v);
static void(APIENTRY *dllRasterPos3s)(GLshort x, GLshort y, GLshort z);
static void(APIENTRY *dllRasterPos3sv)(const GLshort *v);
static void(APIENTRY *dllRasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
static void(APIENTRY *dllRasterPos4dv)(const GLdouble *v);
static void(APIENTRY *dllRasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
static void(APIENTRY *dllRasterPos4fv)(const GLfloat *v);
static void(APIENTRY *dllRasterPos4i)(GLint x, GLint y, GLint z, GLint w);
static void(APIENTRY *dllRasterPos4iv)(const GLint *v);
static void(APIENTRY *dllRasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w);
static void(APIENTRY *dllRasterPos4sv)(const GLshort *v);
static void(APIENTRY *dllReadBuffer)(GLenum mode);
static void(APIENTRY *dllReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
GLvoid *pixels);
static void(APIENTRY *dllRectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
static void(APIENTRY *dllRectdv)(const GLdouble *v1, const GLdouble *v2);
static void(APIENTRY *dllRectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
static void(APIENTRY *dllRectfv)(const GLfloat *v1, const GLfloat *v2);
static void(APIENTRY *dllRecti)(GLint x1, GLint y1, GLint x2, GLint y2);
static void(APIENTRY *dllRectiv)(const GLint *v1, const GLint *v2);
static void(APIENTRY *dllRects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
static void(APIENTRY *dllRectsv)(const GLshort *v1, const GLshort *v2);
GLint(APIENTRY *dllRenderMode)(GLenum mode);
static void(APIENTRY *dllRotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
static void(APIENTRY *dllRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
static void(APIENTRY *dllScaled)(GLdouble x, GLdouble y, GLdouble z);
static void(APIENTRY *dllScalef)(GLfloat x, GLfloat y, GLfloat z);
static void(APIENTRY *dllScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
static void(APIENTRY *dllSelectBuffer)(GLsizei size, GLuint *buffer);
static void(APIENTRY *dllShadeModel)(GLenum mode);
static void(APIENTRY *dllStencilFunc)(GLenum func, GLint ref, GLuint mask);
static void(APIENTRY *dllStencilMask)(GLuint mask);
static void(APIENTRY *dllStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
static void(APIENTRY *dllTexCoord1d)(GLdouble s);
static void(APIENTRY *dllTexCoord1dv)(const GLdouble *v);
static void(APIENTRY *dllTexCoord1f)(GLfloat s);
static void(APIENTRY *dllTexCoord1fv)(const GLfloat *v);
static void(APIENTRY *dllTexCoord1i)(GLint s);
static void(APIENTRY *dllTexCoord1iv)(const GLint *v);
static void(APIENTRY *dllTexCoord1s)(GLshort s);
static void(APIENTRY *dllTexCoord1sv)(const GLshort *v);
static void(APIENTRY *dllTexCoord2d)(GLdouble s, GLdouble t);
static void(APIENTRY *dllTexCoord2dv)(const GLdouble *v);
static void(APIENTRY *dllTexCoord2f)(GLfloat s, GLfloat t);
static void(APIENTRY *dllTexCoord2fv)(const GLfloat *v);
static void(APIENTRY *dllTexCoord2i)(GLint s, GLint t);
static void(APIENTRY *dllTexCoord2iv)(const GLint *v);
static void(APIENTRY *dllTexCoord2s)(GLshort s, GLshort t);
static void(APIENTRY *dllTexCoord2sv)(const GLshort *v);
static void(APIENTRY *dllTexCoord3d)(GLdouble s, GLdouble t, GLdouble r);
static void(APIENTRY *dllTexCoord3dv)(const GLdouble *v);
static void(APIENTRY *dllTexCoord3f)(GLfloat s, GLfloat t, GLfloat r);
static void(APIENTRY *dllTexCoord3fv)(const GLfloat *v);
static void(APIENTRY *dllTexCoord3i)(GLint s, GLint t, GLint r);
static void(APIENTRY *dllTexCoord3iv)(const GLint *v);
static void(APIENTRY *dllTexCoord3s)(GLshort s, GLshort t, GLshort r);
static void(APIENTRY *dllTexCoord3sv)(const GLshort *v);
static void(APIENTRY *dllTexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
static void(APIENTRY *dllTexCoord4dv)(const GLdouble *v);
static void(APIENTRY *dllTexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
static void(APIENTRY *dllTexCoord4fv)(const GLfloat *v);
static void(APIENTRY *dllTexCoord4i)(GLint s, GLint t, GLint r, GLint q);
static void(APIENTRY *dllTexCoord4iv)(const GLint *v);
static void(APIENTRY *dllTexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q);
static void(APIENTRY *dllTexCoord4sv)(const GLshort *v);
static void(APIENTRY *dllTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static void(APIENTRY *dllTexEnvf)(GLenum target, GLenum pname, GLfloat param);
static void(APIENTRY *dllTexEnvfv)(GLenum target, GLenum pname, const GLfloat *params);
static void(APIENTRY *dllTexEnvi)(GLenum target, GLenum pname, GLint param);
static void(APIENTRY *dllTexEnviv)(GLenum target, GLenum pname, const GLint *params);
static void(APIENTRY *dllTexGend)(GLenum coord, GLenum pname, GLdouble param);
static void(APIENTRY *dllTexGendv)(GLenum coord, GLenum pname, const GLdouble *params);
static void(APIENTRY *dllTexGenf)(GLenum coord, GLenum pname, GLfloat param);
static void(APIENTRY *dllTexGenfv)(GLenum coord, GLenum pname, const GLfloat *params);
static void(APIENTRY *dllTexGeni)(GLenum coord, GLenum pname, GLint param);
static void(APIENTRY *dllTexGeniv)(GLenum coord, GLenum pname, const GLint *params);
static void(APIENTRY *dllTexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border,
GLenum format, GLenum type, const GLvoid *pixels);
static void(APIENTRY *dllTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const GLvoid *pixels);
static void(APIENTRY *dllTexParameterf)(GLenum target, GLenum pname, GLfloat param);
static void(APIENTRY *dllTexParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
static void(APIENTRY *dllTexParameteri)(GLenum target, GLenum pname, GLint param);
static void(APIENTRY *dllTexParameteriv)(GLenum target, GLenum pname, const GLint *params);
static void(APIENTRY *dllTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format,
GLenum type, const GLvoid *pixels);
static void(APIENTRY *dllTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
static void(APIENTRY *dllTranslated)(GLdouble x, GLdouble y, GLdouble z);
static void(APIENTRY *dllTranslatef)(GLfloat x, GLfloat y, GLfloat z);
static void(APIENTRY *dllVertex2d)(GLdouble x, GLdouble y);
static void(APIENTRY *dllVertex2dv)(const GLdouble *v);
static void(APIENTRY *dllVertex2f)(GLfloat x, GLfloat y);
static void(APIENTRY *dllVertex2fv)(const GLfloat *v);
static void(APIENTRY *dllVertex2i)(GLint x, GLint y);
static void(APIENTRY *dllVertex2iv)(const GLint *v);
static void(APIENTRY *dllVertex2s)(GLshort x, GLshort y);
static void(APIENTRY *dllVertex2sv)(const GLshort *v);
static void(APIENTRY *dllVertex3d)(GLdouble x, GLdouble y, GLdouble z);
static void(APIENTRY *dllVertex3dv)(const GLdouble *v);
static void(APIENTRY *dllVertex3f)(GLfloat x, GLfloat y, GLfloat z);
static void(APIENTRY *dllVertex3fv)(const GLfloat *v);
static void(APIENTRY *dllVertex3i)(GLint x, GLint y, GLint z);
static void(APIENTRY *dllVertex3iv)(const GLint *v);
static void(APIENTRY *dllVertex3s)(GLshort x, GLshort y, GLshort z);
static void(APIENTRY *dllVertex3sv)(const GLshort *v);
static void(APIENTRY *dllVertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
static void(APIENTRY *dllVertex4dv)(const GLdouble *v);
static void(APIENTRY *dllVertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
static void(APIENTRY *dllVertex4fv)(const GLfloat *v);
static void(APIENTRY *dllVertex4i)(GLint x, GLint y, GLint z, GLint w);
static void(APIENTRY *dllVertex4iv)(const GLint *v);
static void(APIENTRY *dllVertex4s)(GLshort x, GLshort y, GLshort z, GLshort w);
static void(APIENTRY *dllVertex4sv)(const GLshort *v);
static void(APIENTRY *dllVertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static void(APIENTRY *dllViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
static void APIENTRY logAccum(GLenum op, GLfloat value) {
fprintf(glw_state.log_fp, "glAccum\n");
dllAccum(op, value);
}
static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref) {
fprintf(glw_state.log_fp, "glAlphaFunc( 0x%x, %f )\n", func, ref);
dllAlphaFunc(func, ref);
}
static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) {
fprintf(glw_state.log_fp, "glAreTexturesResident\n");
return dllAreTexturesResident(n, textures, residences);
}
static void APIENTRY logArrayElement(GLint i) {
fprintf(glw_state.log_fp, "glArrayElement\n");
dllArrayElement(i);
}
static void APIENTRY logBegin(GLenum mode) {
fprintf(glw_state.log_fp, "glBegin( 0x%x )\n", mode);
dllBegin(mode);
}
static void APIENTRY logBindTexture(GLenum target, GLuint texture) {
fprintf(glw_state.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture);
dllBindTexture(target, texture);
}
static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove,
GLfloat ymove, const GLubyte *bitmap) {
fprintf(glw_state.log_fp, "glBitmap\n");
dllBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
}
static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor) {
fprintf(glw_state.log_fp, "glBlendFunc( 0x%x, 0x%x )\n", sfactor, dfactor);
dllBlendFunc(sfactor, dfactor);
}
static void APIENTRY logCallList(GLuint list) {
fprintf(glw_state.log_fp, "glCallList( %u )\n", list);
dllCallList(list);
}
static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists) {
fprintf(glw_state.log_fp, "glCallLists\n");
dllCallLists(n, type, lists);
}
static void APIENTRY logClear(GLbitfield mask) {
fprintf(glw_state.log_fp, "glClear\n");
dllClear(mask);
}
static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
fprintf(glw_state.log_fp, "glClearAccum\n");
dllClearAccum(red, green, blue, alpha);
}
static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
fprintf(glw_state.log_fp, "glClearColor\n");
dllClearColor(red, green, blue, alpha);
}
static void APIENTRY logClearDepth(GLclampd depth) {
fprintf(glw_state.log_fp, "glClearDepth\n");
dllClearDepth(depth);
}
static void APIENTRY logClearIndex(GLfloat c) {
fprintf(glw_state.log_fp, "glClearIndex\n");
dllClearIndex(c);
}
static void APIENTRY logClearStencil(GLint s) {
fprintf(glw_state.log_fp, "glClearStencil\n");
dllClearStencil(s);
}
static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation) {
fprintf(glw_state.log_fp, "glClipPlane\n");
dllClipPlane(plane, equation);
}
static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue) {
fprintf(glw_state.log_fp, "glColor3b\n");
dllColor3b(red, green, blue);
}
static void APIENTRY logColor3bv(const GLbyte *v) {
fprintf(glw_state.log_fp, "glColor3bv\n");
dllColor3bv(v);
}
static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue) {
fprintf(glw_state.log_fp, "glColor3d\n");
dllColor3d(red, green, blue);
}
static void APIENTRY logColor3dv(const GLdouble *v) {
fprintf(glw_state.log_fp, "glColor3dv\n");
dllColor3dv(v);
}
static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue) {
fprintf(glw_state.log_fp, "glColor3f\n");
dllColor3f(red, green, blue);
}
static void APIENTRY logColor3fv(const GLfloat *v) {
fprintf(glw_state.log_fp, "glColor3fv\n");
dllColor3fv(v);
}
static void APIENTRY logColor3i(GLint red, GLint green, GLint blue) {
fprintf(glw_state.log_fp, "glColor3i\n");
dllColor3i(red, green, blue);
}
static void APIENTRY logColor3iv(const GLint *v) {
fprintf(glw_state.log_fp, "glColor3iv\n");
dllColor3iv(v);
}
static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue) {
fprintf(glw_state.log_fp, "glColor3s\n");
dllColor3s(red, green, blue);
}
static void APIENTRY logColor3sv(const GLshort *v) {
fprintf(glw_state.log_fp, "glColor3sv\n");
dllColor3sv(v);
}
static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
fprintf(glw_state.log_fp, "glColor3ub\n");
dllColor3ub(red, green, blue);
}
static void APIENTRY logColor3ubv(const GLubyte *v) {
fprintf(glw_state.log_fp, "glColor3ubv\n");
dllColor3ubv(v);
}
#define SIG(x) fprintf(glw_state.log_fp, x "\n")
static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue) {
SIG("glColor3ui");
dllColor3ui(red, green, blue);
}
static void APIENTRY logColor3uiv(const GLuint *v) {
SIG("glColor3uiv");
dllColor3uiv(v);
}
static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue) {
SIG("glColor3us");
dllColor3us(red, green, blue);
}
static void APIENTRY logColor3usv(const GLushort *v) {
SIG("glColor3usv");
dllColor3usv(v);
}
static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) {
SIG("glColor4b");
dllColor4b(red, green, blue, alpha);
}
static void APIENTRY logColor4bv(const GLbyte *v) {
SIG("glColor4bv");
dllColor4bv(v);
}
static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) {
SIG("glColor4d");
dllColor4d(red, green, blue, alpha);
}
static void APIENTRY logColor4dv(const GLdouble *v) {
SIG("glColor4dv");
dllColor4dv(v);
}
static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
fprintf(glw_state.log_fp, "glColor4f( %f,%f,%f,%f )\n", red, green, blue, alpha);
dllColor4f(red, green, blue, alpha);
}
static void APIENTRY logColor4fv(const GLfloat *v) {
fprintf(glw_state.log_fp, "glColor4fv( %f,%f,%f,%f )\n", v[0], v[1], v[2], v[3]);
dllColor4fv(v);
}
static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha) {
SIG("glColor4i");
dllColor4i(red, green, blue, alpha);
}
static void APIENTRY logColor4iv(const GLint *v) {
SIG("glColor4iv");
dllColor4iv(v);
}
static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) {
SIG("glColor4s");
dllColor4s(red, green, blue, alpha);
}
static void APIENTRY logColor4sv(const GLshort *v) {
SIG("glColor4sv");
dllColor4sv(v);
}
static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
SIG("glColor4b");
dllColor4b(red, green, blue, alpha);
}
static void APIENTRY logColor4ubv(const GLubyte *v) {
SIG("glColor4ubv");
dllColor4ubv(v);
}
static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) {
SIG("glColor4ui");
dllColor4ui(red, green, blue, alpha);
}
static void APIENTRY logColor4uiv(const GLuint *v) {
SIG("glColor4uiv");
dllColor4uiv(v);
}
static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) {
SIG("glColor4us");
dllColor4us(red, green, blue, alpha);
}
static void APIENTRY logColor4usv(const GLushort *v) {
SIG("glColor4usv");
dllColor4usv(v);
}
static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
SIG("glColorMask");
dllColorMask(red, green, blue, alpha);
}
static void APIENTRY logColorMaterial(GLenum face, GLenum mode) {
SIG("glColorMaterial");
dllColorMaterial(face, mode);
}
static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
SIG("glColorPointer");
dllColorPointer(size, type, stride, pointer);
}
static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) {
SIG("glCopyPixels");
dllCopyPixels(x, y, width, height, type);
}
static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y,
GLsizei width, GLint border) {
SIG("glCopyTexImage1D");
dllCopyTexImage1D(target, level, internalFormat, x, y, width, border);
}
static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y,
GLsizei width, GLsizei height, GLint border) {
SIG("glCopyTexImage2D");
dllCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
}
static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
SIG("glCopyTexSubImage1D");
dllCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
GLsizei width, GLsizei height) {
SIG("glCopyTexSubImage2D");
dllCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
static void APIENTRY logCullFace(GLenum mode) {
SIG("glCullFace");
dllCullFace(mode);
}
static void APIENTRY logDeleteLists(GLuint list, GLsizei range) {
SIG("glDeleteLists");
dllDeleteLists(list, range);
}
static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures) {
SIG("glDeleteTextures");
dllDeleteTextures(n, textures);
}
static void APIENTRY logDepthFunc(GLenum func) {
SIG("glDepthFunc");
dllDepthFunc(func);
}
static void APIENTRY logDepthMask(GLboolean flag) {
SIG("glDepthMask");
dllDepthMask(flag);
}
static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar) {
SIG("glDepthRange");
dllDepthRange(zNear, zFar);
}
static void APIENTRY logDisable(GLenum cap) {
fprintf(glw_state.log_fp, "glDisable( 0x%x )\n", cap);
dllDisable(cap);
}
static void APIENTRY logDisableClientState(GLenum array) {
SIG("glDisableClientState");
dllDisableClientState(array);
}
static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count) {
SIG("glDrawArrays");
dllDrawArrays(mode, first, count);
}
static void APIENTRY logDrawBuffer(GLenum mode) {
SIG("glDrawBuffer");
dllDrawBuffer(mode);
}
static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) {
SIG("glDrawElements");
dllDrawElements(mode, count, type, indices);
}
static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) {
SIG("glDrawPixels");
dllDrawPixels(width, height, format, type, pixels);
}
static void APIENTRY logEdgeFlag(GLboolean flag) {
SIG("glEdgeFlag");
dllEdgeFlag(flag);
}
static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer) {
SIG("glEdgeFlagPointer");
dllEdgeFlagPointer(stride, pointer);
}
static void APIENTRY logEdgeFlagv(const GLboolean *flag) {
SIG("glEdgeFlagv");
dllEdgeFlagv(flag);
}
static void APIENTRY logEnable(GLenum cap) {
fprintf(glw_state.log_fp, "glEnable( 0x%x )\n", cap);
dllEnable(cap);
}
static void APIENTRY logEnableClientState(GLenum array) {
SIG("glEnableClientState");
dllEnableClientState(array);
}
static void APIENTRY logEnd(void) {
SIG("glEnd");
dllEnd();
}
static void APIENTRY logEndList(void) {
SIG("glEndList");
dllEndList();
}
static void APIENTRY logEvalCoord1d(GLdouble u) {
SIG("glEvalCoord1d");
dllEvalCoord1d(u);
}
static void APIENTRY logEvalCoord1dv(const GLdouble *u) {
SIG("glEvalCoord1dv");
dllEvalCoord1dv(u);
}
static void APIENTRY logEvalCoord1f(GLfloat u) {
SIG("glEvalCoord1f");
dllEvalCoord1f(u);
}
static void APIENTRY logEvalCoord1fv(const GLfloat *u) {
SIG("glEvalCoord1fv");
dllEvalCoord1fv(u);
}
static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v) {
SIG("glEvalCoord2d");
dllEvalCoord2d(u, v);
}
static void APIENTRY logEvalCoord2dv(const GLdouble *u) {
SIG("glEvalCoord2dv");
dllEvalCoord2dv(u);
}
static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v) {
SIG("glEvalCoord2f");
dllEvalCoord2f(u, v);
}
static void APIENTRY logEvalCoord2fv(const GLfloat *u) {
SIG("glEvalCoord2fv");
dllEvalCoord2fv(u);
}
static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2) {
SIG("glEvalMesh1");
dllEvalMesh1(mode, i1, i2);
}
static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) {
SIG("glEvalMesh2");
dllEvalMesh2(mode, i1, i2, j1, j2);
}
static void APIENTRY logEvalPoint1(GLint i) {
SIG("glEvalPoint1");
dllEvalPoint1(i);
}
static void APIENTRY logEvalPoint2(GLint i, GLint j) {
SIG("glEvalPoint2");
dllEvalPoint2(i, j);
}
static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) {
SIG("glFeedbackBuffer");
dllFeedbackBuffer(size, type, buffer);
}
static void APIENTRY logFinish(void) {
SIG("glFinish");
dllFinish();
}
static void APIENTRY logFlush(void) {
SIG("glFlush");
dllFlush();
}
static void APIENTRY logFogf(GLenum pname, GLfloat param) {
SIG("glFogf");
dllFogf(pname, param);
}
static void APIENTRY logFogfv(GLenum pname, const GLfloat *params) {
SIG("glFogfv");
dllFogfv(pname, params);
}
static void APIENTRY logFogi(GLenum pname, GLint param) {
SIG("glFogi");
dllFogi(pname, param);
}
static void APIENTRY logFogiv(GLenum pname, const GLint *params) {
SIG("glFogiv");
dllFogiv(pname, params);
}
static void APIENTRY logFrontFace(GLenum mode) {
SIG("glFrontFace");
dllFrontFace(mode);
}
static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear,
GLdouble zFar) {
SIG("glFrustum");
dllFrustum(left, right, bottom, top, zNear, zFar);
}
static GLuint APIENTRY logGenLists(GLsizei range) {
SIG("glGenLists");
return dllGenLists(range);
}
static void APIENTRY logGenTextures(GLsizei n, GLuint *textures) {
SIG("glGenTextures");
dllGenTextures(n, textures);
}
static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params) {
SIG("glGetBooleanv");
dllGetBooleanv(pname, params);
}
static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation) {
SIG("glGetClipPlane");
dllGetClipPlane(plane, equation);
}
static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params) {
SIG("glGetDoublev");
dllGetDoublev(pname, params);
}
static GLenum APIENTRY logGetError(void) {
SIG("glGetError");
return dllGetError();
}
static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params) {
SIG("glGetFloatv");
dllGetFloatv(pname, params);
}
static void APIENTRY logGetIntegerv(GLenum pname, GLint *params) {
SIG("glGetIntegerv");
dllGetIntegerv(pname, params);
}
static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params) {
SIG("glGetLightfv");
dllGetLightfv(light, pname, params);
}
static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params) {
SIG("glGetLightiv");
dllGetLightiv(light, pname, params);
}
static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v) {
SIG("glGetMapdv");
dllGetMapdv(target, query, v);
}
static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v) {
SIG("glGetMapfv");
dllGetMapfv(target, query, v);
}
static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v) {
SIG("glGetMapiv");
dllGetMapiv(target, query, v);
}
static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) {
SIG("glGetMaterialfv");
dllGetMaterialfv(face, pname, params);
}
static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params) {
SIG("glGetMaterialiv");
dllGetMaterialiv(face, pname, params);
}
static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values) {
SIG("glGetPixelMapfv");
dllGetPixelMapfv(map, values);
}
static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values) {
SIG("glGetPixelMapuiv");
dllGetPixelMapuiv(map, values);
}
static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values) {
SIG("glGetPixelMapusv");
dllGetPixelMapusv(map, values);
}
static void APIENTRY logGetPointerv(GLenum pname, GLvoid **params) {
SIG("glGetPointerv");
dllGetPointerv(pname, params);
}
static void APIENTRY logGetPolygonStipple(GLubyte *mask) {
SIG("glGetPolygonStipple");
dllGetPolygonStipple(mask);
}
static const GLubyte *APIENTRY logGetString(GLenum name) {
SIG("glGetString");
return dllGetString(name);
}
static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) {
SIG("glGetTexEnvfv");
dllGetTexEnvfv(target, pname, params);
}
static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params) {
SIG("glGetTexEnviv");
dllGetTexEnviv(target, pname, params);
}
static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) {
SIG("glGetTexGendv");
dllGetTexGendv(coord, pname, params);
}
static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) {
SIG("glGetTexGenfv");
dllGetTexGenfv(coord, pname, params);
}
static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params) {
SIG("glGetTexGeniv");
dllGetTexGeniv(coord, pname, params);
}
static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) {
SIG("glGetTexImage");
dllGetTexImage(target, level, format, type, pixels);
}
static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {
SIG("glGetTexLevelParameterfv");
dllGetTexLevelParameterfv(target, level, pname, params);
}
static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {
SIG("glGetTexLevelParameteriv");
dllGetTexLevelParameteriv(target, level, pname, params);
}
static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {
SIG("glGetTexParameterfv");
dllGetTexParameterfv(target, pname, params);
}
static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {
SIG("glGetTexParameteriv");
dllGetTexParameteriv(target, pname, params);
}
static void APIENTRY logHint(GLenum target, GLenum mode) {
fprintf(glw_state.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode);
dllHint(target, mode);
}
static void APIENTRY logIndexMask(GLuint mask) {
SIG("glIndexMask");
dllIndexMask(mask);
}
static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer) {
SIG("glIndexPointer");
dllIndexPointer(type, stride, pointer);
}
static void APIENTRY logIndexd(GLdouble c) {
SIG("glIndexd");
dllIndexd(c);
}
static void APIENTRY logIndexdv(const GLdouble *c) {
SIG("glIndexdv");
dllIndexdv(c);
}
static void APIENTRY logIndexf(GLfloat c) {
SIG("glIndexf");
dllIndexf(c);
}
static void APIENTRY logIndexfv(const GLfloat *c) {
SIG("glIndexfv");
dllIndexfv(c);
}
static void APIENTRY logIndexi(GLint c) {
SIG("glIndexi");
dllIndexi(c);
}
static void APIENTRY logIndexiv(const GLint *c) {
SIG("glIndexiv");
dllIndexiv(c);
}
static void APIENTRY logIndexs(GLshort c) {
SIG("glIndexs");
dllIndexs(c);
}
static void APIENTRY logIndexsv(const GLshort *c) {
SIG("glIndexsv");
dllIndexsv(c);
}
static void APIENTRY logIndexub(GLubyte c) {
SIG("glIndexub");
dllIndexub(c);
}
static void APIENTRY logIndexubv(const GLubyte *c) {
SIG("glIndexubv");
dllIndexubv(c);
}
static void APIENTRY logInitNames(void) {
SIG("glInitNames");
dllInitNames();
}
static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer) {
SIG("glInterleavedArrays");
dllInterleavedArrays(format, stride, pointer);
}
static GLboolean APIENTRY logIsEnabled(GLenum cap) {
SIG("glIsEnabled");
return dllIsEnabled(cap);
}
static GLboolean APIENTRY logIsList(GLuint list) {
SIG("glIsList");
return dllIsList(list);
}
static GLboolean APIENTRY logIsTexture(GLuint texture) {
SIG("glIsTexture");
return dllIsTexture(texture);
}
static void APIENTRY logLightModelf(GLenum pname, GLfloat param) {
SIG("glLightModelf");
dllLightModelf(pname, param);
}
static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params) {
SIG("glLightModelfv");
dllLightModelfv(pname, params);
}
static void APIENTRY logLightModeli(GLenum pname, GLint param) {
SIG("glLightModeli");
dllLightModeli(pname, param);
}
static void APIENTRY logLightModeliv(GLenum pname, const GLint *params) {
SIG("glLightModeliv");
dllLightModeliv(pname, params);
}
static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param) {
SIG("glLightf");
dllLightf(light, pname, param);
}
static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params) {
SIG("glLightfv");
dllLightfv(light, pname, params);
}
static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param) {
SIG("glLighti");
dllLighti(light, pname, param);
}
static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params) {
SIG("glLightiv");
dllLightiv(light, pname, params);
}
static void APIENTRY logLineStipple(GLint factor, GLushort pattern) {
SIG("glLineStipple");
dllLineStipple(factor, pattern);
}
static void APIENTRY logLineWidth(GLfloat width) {
SIG("glLineWidth");
dllLineWidth(width);
}
static void APIENTRY logListBase(GLuint base) {
SIG("glListBase");
dllListBase(base);
}
static void APIENTRY logLoadIdentity(void) {
SIG("glLoadIdentity");
dllLoadIdentity();
}
static void APIENTRY logLoadMatrixd(const GLdouble *m) {
SIG("glLoadMatrixd");
dllLoadMatrixd(m);
}
static void APIENTRY logLoadMatrixf(const GLfloat *m) {
SIG("glLoadMatrixf");
dllLoadMatrixf(m);
}
static void APIENTRY logLoadName(GLuint name) {
SIG("glLoadName");
dllLoadName(name);
}
static void APIENTRY logLogicOp(GLenum opcode) {
SIG("glLogicOp");
dllLogicOp(opcode);
}
static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order,
const GLdouble *points) {
SIG("glMap1d");
dllMap1d(target, u1, u2, stride, order, points);
}
static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) {
SIG("glMap1f");
dllMap1f(target, u1, u2, stride, order, points);
}
static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1,
GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) {
SIG("glMap2d");
dllMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1,
GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) {
SIG("glMap2f");
dllMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2) {
SIG("glMapGrid1d");
dllMapGrid1d(un, u1, u2);
}
static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2) {
SIG("glMapGrid1f");
dllMapGrid1f(un, u1, u2);
}
static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) {
SIG("glMapGrid2d");
dllMapGrid2d(un, u1, u2, vn, v1, v2);
}
static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) {
SIG("glMapGrid2f");
dllMapGrid2f(un, u1, u2, vn, v1, v2);
}
static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param) {
SIG("glMaterialf");
dllMaterialf(face, pname, param);
}
static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
SIG("glMaterialfv");
dllMaterialfv(face, pname, params);
}
static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param) {
SIG("glMateriali");
dllMateriali(face, pname, param);
}
static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params) {
SIG("glMaterialiv");
dllMaterialiv(face, pname, params);
}
static void APIENTRY logMatrixMode(GLenum mode) {
SIG("glMatrixMode");
dllMatrixMode(mode);
}
static void APIENTRY logMultMatrixd(const GLdouble *m) {
SIG("glMultMatrixd");
dllMultMatrixd(m);
}
static void APIENTRY logMultMatrixf(const GLfloat *m) {
SIG("glMultMatrixf");
dllMultMatrixf(m);
}
static void APIENTRY logNewList(GLuint list, GLenum mode) {
SIG("glNewList");
dllNewList(list, mode);
}
static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) {
SIG("glNormal3b");
dllNormal3b(nx, ny, nz);
}
static void APIENTRY logNormal3bv(const GLbyte *v) {
SIG("glNormal3bv");
dllNormal3bv(v);
}
static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) {
SIG("glNormal3d");
dllNormal3d(nx, ny, nz);
}
static void APIENTRY logNormal3dv(const GLdouble *v) {
SIG("glNormal3dv");
dllNormal3dv(v);
}
static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
SIG("glNormal3f");
dllNormal3f(nx, ny, nz);
}
static void APIENTRY logNormal3fv(const GLfloat *v) {
SIG("glNormal3fv");
dllNormal3fv(v);
}
static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz) {
SIG("glNormal3i");
dllNormal3i(nx, ny, nz);
}
static void APIENTRY logNormal3iv(const GLint *v) {
SIG("glNormal3iv");
dllNormal3iv(v);
}
static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz) {
SIG("glNormal3s");
dllNormal3s(nx, ny, nz);
}
static void APIENTRY logNormal3sv(const GLshort *v) {
SIG("glNormal3sv");
dllNormal3sv(v);
}
static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer) {
SIG("glNormalPointer");
dllNormalPointer(type, stride, pointer);
}
static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear,
GLdouble zFar) {
SIG("glOrtho");
dllOrtho(left, right, bottom, top, zNear, zFar);
}
static void APIENTRY logPassThrough(GLfloat token) {
SIG("glPassThrough");
dllPassThrough(token);
}
static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values) {
SIG("glPixelMapfv");
dllPixelMapfv(map, mapsize, values);
}
static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values) {
SIG("glPixelMapuiv");
dllPixelMapuiv(map, mapsize, values);
}
static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values) {
SIG("glPixelMapusv");
dllPixelMapusv(map, mapsize, values);
}
static void APIENTRY logPixelStoref(GLenum pname, GLfloat param) {
SIG("glPixelStoref");
dllPixelStoref(pname, param);
}
static void APIENTRY logPixelStorei(GLenum pname, GLint param) {
SIG("glPixelStorei");
dllPixelStorei(pname, param);
}
static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param) {
SIG("glPixelTransferf");
dllPixelTransferf(pname, param);
}
static void APIENTRY logPixelTransferi(GLenum pname, GLint param) {
SIG("glPixelTransferi");
dllPixelTransferi(pname, param);
}
static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor) {
SIG("glPixelZoom");
dllPixelZoom(xfactor, yfactor);
}
static void APIENTRY logPointSize(GLfloat size) {
SIG("glPointSize");
dllPointSize(size);
}
static void APIENTRY logPolygonMode(GLenum face, GLenum mode) {
fprintf(glw_state.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode);
dllPolygonMode(face, mode);
}
static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units) {
SIG("glPolygonOffset");
dllPolygonOffset(factor, units);
}
static void APIENTRY logPolygonStipple(const GLubyte *mask) {
SIG("glPolygonStipple");
dllPolygonStipple(mask);
}
static void APIENTRY logPopAttrib(void) {
SIG("glPopAttrib");
dllPopAttrib();
}
static void APIENTRY logPopClientAttrib(void) {
SIG("glPopClientAttrib");
dllPopClientAttrib();
}
static void APIENTRY logPopMatrix(void) {
SIG("glPopMatrix");
dllPopMatrix();
}
static void APIENTRY logPopName(void) {
SIG("glPopName");
dllPopName();
}
static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) {
SIG("glPrioritizeTextures");
dllPrioritizeTextures(n, textures, priorities);
}
static void APIENTRY logPushAttrib(GLbitfield mask) {
SIG("glPushAttrib");
dllPushAttrib(mask);
}
static void APIENTRY logPushClientAttrib(GLbitfield mask) {
SIG("glPushClientAttrib");
dllPushClientAttrib(mask);
}
static void APIENTRY logPushMatrix(void) {
SIG("glPushMatrix");
dllPushMatrix();
}
static void APIENTRY logPushName(GLuint name) {
SIG("glPushName");
dllPushName(name);
}
static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y) {
SIG("glRasterPot2d");
dllRasterPos2d(x, y);
}
static void APIENTRY logRasterPos2dv(const GLdouble *v) {
SIG("glRasterPos2dv");
dllRasterPos2dv(v);
}
static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y) {
SIG("glRasterPos2f");
dllRasterPos2f(x, y);
}
static void APIENTRY logRasterPos2fv(const GLfloat *v) {
SIG("glRasterPos2dv");
dllRasterPos2fv(v);
}
static void APIENTRY logRasterPos2i(GLint x, GLint y) {
SIG("glRasterPos2if");
dllRasterPos2i(x, y);
}
static void APIENTRY logRasterPos2iv(const GLint *v) {
SIG("glRasterPos2iv");
dllRasterPos2iv(v);
}
static void APIENTRY logRasterPos2s(GLshort x, GLshort y) {
SIG("glRasterPos2s");
dllRasterPos2s(x, y);
}
static void APIENTRY logRasterPos2sv(const GLshort *v) {
SIG("glRasterPos2sv");
dllRasterPos2sv(v);
}
static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z) {
SIG("glRasterPos3d");
dllRasterPos3d(x, y, z);
}
static void APIENTRY logRasterPos3dv(const GLdouble *v) {
SIG("glRasterPos3dv");
dllRasterPos3dv(v);
}
static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z) {
SIG("glRasterPos3f");
dllRasterPos3f(x, y, z);
}
static void APIENTRY logRasterPos3fv(const GLfloat *v) {
SIG("glRasterPos3fv");
dllRasterPos3fv(v);
}
static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z) {
SIG("glRasterPos3i");
dllRasterPos3i(x, y, z);
}
static void APIENTRY logRasterPos3iv(const GLint *v) {
SIG("glRasterPos3iv");
dllRasterPos3iv(v);
}
static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z) {
SIG("glRasterPos3s");
dllRasterPos3s(x, y, z);
}
static void APIENTRY logRasterPos3sv(const GLshort *v) {
SIG("glRasterPos3sv");
dllRasterPos3sv(v);
}
static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
SIG("glRasterPos4d");
dllRasterPos4d(x, y, z, w);
}
static void APIENTRY logRasterPos4dv(const GLdouble *v) {
SIG("glRasterPos4dv");
dllRasterPos4dv(v);
}
static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
SIG("glRasterPos4f");
dllRasterPos4f(x, y, z, w);
}
static void APIENTRY logRasterPos4fv(const GLfloat *v) {
SIG("glRasterPos4fv");
dllRasterPos4fv(v);
}
static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w) {
SIG("glRasterPos4i");
dllRasterPos4i(x, y, z, w);
}
static void APIENTRY logRasterPos4iv(const GLint *v) {
SIG("glRasterPos4iv");
dllRasterPos4iv(v);
}
static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) {
SIG("glRasterPos4s");
dllRasterPos4s(x, y, z, w);
}
static void APIENTRY logRasterPos4sv(const GLshort *v) {
SIG("glRasterPos4sv");
dllRasterPos4sv(v);
}
static void APIENTRY logReadBuffer(GLenum mode) {
SIG("glReadBuffer");
dllReadBuffer(mode);
}
static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
void *pixels) {
SIG("glReadPixels");
dllReadPixels(x, y, width, height, format, type, pixels);
}
static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) {
SIG("glRectd");
dllRectd(x1, y1, x2, y2);
}
static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2) {
SIG("glRectdv");
dllRectdv(v1, v2);
}
static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {
SIG("glRectf");
dllRectf(x1, y1, x2, y2);
}
static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2) {
SIG("glRectfv");
dllRectfv(v1, v2);
}
static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2) {
SIG("glRecti");
dllRecti(x1, y1, x2, y2);
}
static void APIENTRY logRectiv(const GLint *v1, const GLint *v2) {
SIG("glRectiv");
dllRectiv(v1, v2);
}
static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) {
SIG("glRects");
dllRects(x1, y1, x2, y2);
}
static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2) {
SIG("glRectsv");
dllRectsv(v1, v2);
}
static GLint APIENTRY logRenderMode(GLenum mode) {
SIG("glRenderMode");
return dllRenderMode(mode);
}
static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {
SIG("glRotated");
dllRotated(angle, x, y, z);
}
static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
SIG("glRotatef");
dllRotatef(angle, x, y, z);
}
static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z) {
SIG("glScaled");
dllScaled(x, y, z);
}
static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z) {
SIG("glScalef");
dllScalef(x, y, z);
}
static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
SIG("glScissor");
dllScissor(x, y, width, height);
}
static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer) {
SIG("glSelectBuffer");
dllSelectBuffer(size, buffer);
}
static void APIENTRY logShadeModel(GLenum mode) {
SIG("glShadeModel");
dllShadeModel(mode);
}
static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask) {
SIG("glStencilFunc");
dllStencilFunc(func, ref, mask);
}
static void APIENTRY logStencilMask(GLuint mask) {
SIG("glStencilMask");
dllStencilMask(mask);
}
static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
SIG("glStencilOp");
dllStencilOp(fail, zfail, zpass);
}
static void APIENTRY logTexCoord1d(GLdouble s) {
SIG("glTexCoord1d");
dllTexCoord1d(s);
}
static void APIENTRY logTexCoord1dv(const GLdouble *v) {
SIG("glTexCoord1dv");
dllTexCoord1dv(v);
}
static void APIENTRY logTexCoord1f(GLfloat s) {
SIG("glTexCoord1f");
dllTexCoord1f(s);
}
static void APIENTRY logTexCoord1fv(const GLfloat *v) {
SIG("glTexCoord1fv");
dllTexCoord1fv(v);
}
static void APIENTRY logTexCoord1i(GLint s) {
SIG("glTexCoord1i");
dllTexCoord1i(s);
}
static void APIENTRY logTexCoord1iv(const GLint *v) {
SIG("glTexCoord1iv");
dllTexCoord1iv(v);
}
static void APIENTRY logTexCoord1s(GLshort s) {
SIG("glTexCoord1s");
dllTexCoord1s(s);
}
static void APIENTRY logTexCoord1sv(const GLshort *v) {
SIG("glTexCoord1sv");
dllTexCoord1sv(v);
}
static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t) {
SIG("glTexCoord2d");
dllTexCoord2d(s, t);
}
static void APIENTRY logTexCoord2dv(const GLdouble *v) {
SIG("glTexCoord2dv");
dllTexCoord2dv(v);
}
static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t) {
SIG("glTexCoord2f");
dllTexCoord2f(s, t);
}
static void APIENTRY logTexCoord2fv(const GLfloat *v) {
SIG("glTexCoord2fv");
dllTexCoord2fv(v);
}
static void APIENTRY logTexCoord2i(GLint s, GLint t) {
SIG("glTexCoord2i");
dllTexCoord2i(s, t);
}
static void APIENTRY logTexCoord2iv(const GLint *v) {
SIG("glTexCoord2iv");
dllTexCoord2iv(v);
}
static void APIENTRY logTexCoord2s(GLshort s, GLshort t) {
SIG("glTexCoord2s");
dllTexCoord2s(s, t);
}
static void APIENTRY logTexCoord2sv(const GLshort *v) {
SIG("glTexCoord2sv");
dllTexCoord2sv(v);
}
static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r) {
SIG("glTexCoord3d");
dllTexCoord3d(s, t, r);
}
static void APIENTRY logTexCoord3dv(const GLdouble *v) {
SIG("glTexCoord3dv");
dllTexCoord3dv(v);
}
static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {
SIG("glTexCoord3f");
dllTexCoord3f(s, t, r);
}
static void APIENTRY logTexCoord3fv(const GLfloat *v) {
SIG("glTexCoord3fv");
dllTexCoord3fv(v);
}
static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r) {
SIG("glTexCoord3i");
dllTexCoord3i(s, t, r);
}
static void APIENTRY logTexCoord3iv(const GLint *v) {
SIG("glTexCoord3iv");
dllTexCoord3iv(v);
}
static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r) {
SIG("glTexCoord3s");
dllTexCoord3s(s, t, r);
}
static void APIENTRY logTexCoord3sv(const GLshort *v) {
SIG("glTexCoord3sv");
dllTexCoord3sv(v);
}
static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
SIG("glTexCoord4d");
dllTexCoord4d(s, t, r, q);
}
static void APIENTRY logTexCoord4dv(const GLdouble *v) {
SIG("glTexCoord4dv");
dllTexCoord4dv(v);
}
static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
SIG("glTexCoord4f");
dllTexCoord4f(s, t, r, q);
}
static void APIENTRY logTexCoord4fv(const GLfloat *v) {
SIG("glTexCoord4fv");
dllTexCoord4fv(v);
}
static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q) {
SIG("glTexCoord4i");
dllTexCoord4i(s, t, r, q);
}
static void APIENTRY logTexCoord4iv(const GLint *v) {
SIG("glTexCoord4iv");
dllTexCoord4iv(v);
}
static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) {
SIG("glTexCoord4s");
dllTexCoord4s(s, t, r, q);
}
static void APIENTRY logTexCoord4sv(const GLshort *v) {
SIG("glTexCoord4sv");
dllTexCoord4sv(v);
}
static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
SIG("glTexCoordPointer");
dllTexCoordPointer(size, type, stride, pointer);
}
static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param) {
fprintf(glw_state.log_fp, "glTexEnvf( 0x%x, 0x%x, %f )\n", target, pname, param);
dllTexEnvf(target, pname, param);
}
static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {
SIG("glTexEnvfv");
dllTexEnvfv(target, pname, params);
}
static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param) {
fprintf(glw_state.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param);
dllTexEnvi(target, pname, param);
}
static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params) {
SIG("glTexEnviv");
dllTexEnviv(target, pname, params);
}
static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param) {
SIG("glTexGend");
dllTexGend(coord, pname, param);
}
static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params) {
SIG("glTexGendv");
dllTexGendv(coord, pname, params);
}
static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param) {
SIG("glTexGenf");
dllTexGenf(coord, pname, param);
}
static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) {
SIG("glTexGenfv");
dllTexGenfv(coord, pname, params);
}
static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param) {
SIG("glTexGeni");
dllTexGeni(coord, pname, param);
}
static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params) {
SIG("glTexGeniv");
dllTexGeniv(coord, pname, params);
}
static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border,
GLenum format, GLenum type, const void *pixels) {
SIG("glTexImage1D");
dllTexImage1D(target, level, internalformat, width, border, format, type, pixels);
}
static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const void *pixels) {
SIG("glTexImage2D");
dllTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
}
static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param) {
fprintf(glw_state.log_fp, "glTexParameterf( 0x%x, 0x%x, %f )\n", target, pname, param);
dllTexParameterf(target, pname, param);
}
static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
SIG("glTexParameterfv");
dllTexParameterfv(target, pname, params);
}
static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param) {
fprintf(glw_state.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param);
dllTexParameteri(target, pname, param);
}
static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params) {
SIG("glTexParameteriv");
dllTexParameteriv(target, pname, params);
}
static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format,
GLenum type, const void *pixels) {
SIG("glTexSubImage1D");
dllTexSubImage1D(target, level, xoffset, width, format, type, pixels);
}
static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
GLsizei height, GLenum format, GLenum type, const void *pixels) {
SIG("glTexSubImage2D");
dllTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}
static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z) {
SIG("glTranslated");
dllTranslated(x, y, z);
}
static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z) {
SIG("glTranslatef");
dllTranslatef(x, y, z);
}
static void APIENTRY logVertex2d(GLdouble x, GLdouble y) {
SIG("glVertex2d");
dllVertex2d(x, y);
}
static void APIENTRY logVertex2dv(const GLdouble *v) {
SIG("glVertex2dv");
dllVertex2dv(v);
}
static void APIENTRY logVertex2f(GLfloat x, GLfloat y) {
SIG("glVertex2f");
dllVertex2f(x, y);
}
static void APIENTRY logVertex2fv(const GLfloat *v) {
SIG("glVertex2fv");
dllVertex2fv(v);
}
static void APIENTRY logVertex2i(GLint x, GLint y) {
SIG("glVertex2i");
dllVertex2i(x, y);
}
static void APIENTRY logVertex2iv(const GLint *v) {
SIG("glVertex2iv");
dllVertex2iv(v);
}
static void APIENTRY logVertex2s(GLshort x, GLshort y) {
SIG("glVertex2s");
dllVertex2s(x, y);
}
static void APIENTRY logVertex2sv(const GLshort *v) {
SIG("glVertex2sv");
dllVertex2sv(v);
}
static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z) {
SIG("glVertex3d");
dllVertex3d(x, y, z);
}
static void APIENTRY logVertex3dv(const GLdouble *v) {
SIG("glVertex3dv");
dllVertex3dv(v);
}
static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z) {
SIG("glVertex3f");
dllVertex3f(x, y, z);
}
static void APIENTRY logVertex3fv(const GLfloat *v) {
SIG("glVertex3fv");
dllVertex3fv(v);
}
static void APIENTRY logVertex3i(GLint x, GLint y, GLint z) {
SIG("glVertex3i");
dllVertex3i(x, y, z);
}
static void APIENTRY logVertex3iv(const GLint *v) {
SIG("glVertex3iv");
dllVertex3iv(v);
}
static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z) {
SIG("glVertex3s");
dllVertex3s(x, y, z);
}
static void APIENTRY logVertex3sv(const GLshort *v) {
SIG("glVertex3sv");
dllVertex3sv(v);
}
static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
SIG("glVertex4d");
dllVertex4d(x, y, z, w);
}
static void APIENTRY logVertex4dv(const GLdouble *v) {
SIG("glVertex4dv");
dllVertex4dv(v);
}
static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
SIG("glVertex4f");
dllVertex4f(x, y, z, w);
}
static void APIENTRY logVertex4fv(const GLfloat *v) {
SIG("glVertex4fv");
dllVertex4fv(v);
}
static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w) {
SIG("glVertex4i");
dllVertex4i(x, y, z, w);
}
static void APIENTRY logVertex4iv(const GLint *v) {
SIG("glVertex4iv");
dllVertex4iv(v);
}
static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) {
SIG("glVertex4s");
dllVertex4s(x, y, z, w);
}
static void APIENTRY logVertex4sv(const GLshort *v) {
SIG("glVertex4sv");
dllVertex4sv(v);
}
static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
SIG("glVertexPointer");
dllVertexPointer(size, type, stride, pointer);
}
static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
SIG("glViewport");
dllViewport(x, y, width, height);
}
void QGL_Shutdown(void) {
if(glw_state.hinstOpenGL) {
FreeLibrary(glw_state.hinstOpenGL);
glw_state.hinstOpenGL = NULL;
}
glw_state.hinstOpenGL = NULL;
qglAccum = NULL;
qglAlphaFunc = NULL;
qglAreTexturesResident = NULL;
qglArrayElement = NULL;
qglBegin = NULL;
qglBindTexture = NULL;
qglBitmap = NULL;
qglBlendFunc = NULL;
qglCallList = NULL;
qglCallLists = NULL;
qglClear = NULL;
qglClearAccum = NULL;
qglClearColor = NULL;
qglClearDepth = NULL;
qglClearIndex = NULL;
qglClearStencil = NULL;
qglClipPlane = NULL;
qglColor3b = NULL;
qglColor3bv = NULL;
qglColor3d = NULL;
qglColor3dv = NULL;
qglColor3f = NULL;
qglColor3fv = NULL;
qglColor3i = NULL;
qglColor3iv = NULL;
qglColor3s = NULL;
qglColor3sv = NULL;
qglColor3ub = NULL;
qglColor3ubv = NULL;
qglColor3ui = NULL;
qglColor3uiv = NULL;
qglColor3us = NULL;
qglColor3usv = NULL;
qglColor4b = NULL;
qglColor4bv = NULL;
qglColor4d = NULL;
qglColor4dv = NULL;
qglColor4f = NULL;
qglColor4fv = NULL;
qglColor4i = NULL;
qglColor4iv = NULL;
qglColor4s = NULL;
qglColor4sv = NULL;
qglColor4ub = NULL;
qglColor4ubv = NULL;
qglColor4ui = NULL;
qglColor4uiv = NULL;
qglColor4us = NULL;
qglColor4usv = NULL;
qglColorMask = NULL;
qglColorMaterial = NULL;
qglColorPointer = NULL;
qglCopyPixels = NULL;
qglCopyTexImage1D = NULL;
qglCopyTexImage2D = NULL;
qglCopyTexSubImage1D = NULL;
qglCopyTexSubImage2D = NULL;
qglCullFace = NULL;
qglDeleteLists = NULL;
qglDeleteTextures = NULL;
qglDepthFunc = NULL;
qglDepthMask = NULL;
qglDepthRange = NULL;
qglDisable = NULL;
qglDisableClientState = NULL;
qglDrawArrays = NULL;
qglDrawBuffer = NULL;
qglDrawElements = NULL;
qglDrawPixels = NULL;
qglEdgeFlag = NULL;
qglEdgeFlagPointer = NULL;
qglEdgeFlagv = NULL;
qglEnable = NULL;
qglEnableClientState = NULL;
qglEnd = NULL;
qglEndList = NULL;
qglEvalCoord1d = NULL;
qglEvalCoord1dv = NULL;
qglEvalCoord1f = NULL;
qglEvalCoord1fv = NULL;
qglEvalCoord2d = NULL;
qglEvalCoord2dv = NULL;
qglEvalCoord2f = NULL;
qglEvalCoord2fv = NULL;
qglEvalMesh1 = NULL;
qglEvalMesh2 = NULL;
qglEvalPoint1 = NULL;
qglEvalPoint2 = NULL;
qglFeedbackBuffer = NULL;
qglFinish = NULL;
qglFlush = NULL;
qglFogf = NULL;
qglFogfv = NULL;
qglFogi = NULL;
qglFogiv = NULL;
qglFrontFace = NULL;
qglFrustum = NULL;
qglGenLists = NULL;
qglGenTextures = NULL;
qglGetBooleanv = NULL;
qglGetClipPlane = NULL;
qglGetDoublev = NULL;
qglGetError = NULL;
qglGetFloatv = NULL;
qglGetIntegerv = NULL;
qglGetLightfv = NULL;
qglGetLightiv = NULL;
qglGetMapdv = NULL;
qglGetMapfv = NULL;
qglGetMapiv = NULL;
qglGetMaterialfv = NULL;
qglGetMaterialiv = NULL;
qglGetPixelMapfv = NULL;
qglGetPixelMapuiv = NULL;
qglGetPixelMapusv = NULL;
qglGetPointerv = NULL;
qglGetPolygonStipple = NULL;
qglGetString = NULL;
qglGetTexEnvfv = NULL;
qglGetTexEnviv = NULL;
qglGetTexGendv = NULL;
qglGetTexGenfv = NULL;
qglGetTexGeniv = NULL;
qglGetTexImage = NULL;
qglGetTexLevelParameterfv = NULL;
qglGetTexLevelParameteriv = NULL;
qglGetTexParameterfv = NULL;
qglGetTexParameteriv = NULL;
qglHint = NULL;
qglIndexMask = NULL;
qglIndexPointer = NULL;
qglIndexd = NULL;
qglIndexdv = NULL;
qglIndexf = NULL;
qglIndexfv = NULL;
qglIndexi = NULL;
qglIndexiv = NULL;
qglIndexs = NULL;
qglIndexsv = NULL;
qglIndexub = NULL;
qglIndexubv = NULL;
qglInitNames = NULL;
qglInterleavedArrays = NULL;
qglIsEnabled = NULL;
qglIsList = NULL;
qglIsTexture = NULL;
qglLightModelf = NULL;
qglLightModelfv = NULL;
qglLightModeli = NULL;
qglLightModeliv = NULL;
qglLightf = NULL;
qglLightfv = NULL;
qglLighti = NULL;
qglLightiv = NULL;
qglLineStipple = NULL;
qglLineWidth = NULL;
qglListBase = NULL;
qglLoadIdentity = NULL;
qglLoadMatrixd = NULL;
qglLoadMatrixf = NULL;
qglLoadName = NULL;
qglLogicOp = NULL;
qglMap1d = NULL;
qglMap1f = NULL;
qglMap2d = NULL;
qglMap2f = NULL;
qglMapGrid1d = NULL;
qglMapGrid1f = NULL;
qglMapGrid2d = NULL;
qglMapGrid2f = NULL;
qglMaterialf = NULL;
qglMaterialfv = NULL;
qglMateriali = NULL;
qglMaterialiv = NULL;
qglMatrixMode = NULL;
qglMultMatrixd = NULL;
qglMultMatrixf = NULL;
qglNewList = NULL;
qglNormal3b = NULL;
qglNormal3bv = NULL;
qglNormal3d = NULL;
qglNormal3dv = NULL;
qglNormal3f = NULL;
qglNormal3fv = NULL;
qglNormal3i = NULL;
qglNormal3iv = NULL;
qglNormal3s = NULL;
qglNormal3sv = NULL;
qglNormalPointer = NULL;
qglOrtho = NULL;
qglPassThrough = NULL;
qglPixelMapfv = NULL;
qglPixelMapuiv = NULL;
qglPixelMapusv = NULL;
qglPixelStoref = NULL;
qglPixelStorei = NULL;
qglPixelTransferf = NULL;
qglPixelTransferi = NULL;
qglPixelZoom = NULL;
qglPointSize = NULL;
qglPolygonMode = NULL;
qglPolygonOffset = NULL;
qglPolygonStipple = NULL;
qglPopAttrib = NULL;
qglPopClientAttrib = NULL;
qglPopMatrix = NULL;
qglPopName = NULL;
qglPrioritizeTextures = NULL;
qglPushAttrib = NULL;
qglPushClientAttrib = NULL;
qglPushMatrix = NULL;
qglPushName = NULL;
qglRasterPos2d = NULL;
qglRasterPos2dv = NULL;
qglRasterPos2f = NULL;
qglRasterPos2fv = NULL;
qglRasterPos2i = NULL;
qglRasterPos2iv = NULL;
qglRasterPos2s = NULL;
qglRasterPos2sv = NULL;
qglRasterPos3d = NULL;
qglRasterPos3dv = NULL;
qglRasterPos3f = NULL;
qglRasterPos3fv = NULL;
qglRasterPos3i = NULL;
qglRasterPos3iv = NULL;
qglRasterPos3s = NULL;
qglRasterPos3sv = NULL;
qglRasterPos4d = NULL;
qglRasterPos4dv = NULL;
qglRasterPos4f = NULL;
qglRasterPos4fv = NULL;
qglRasterPos4i = NULL;
qglRasterPos4iv = NULL;
qglRasterPos4s = NULL;
qglRasterPos4sv = NULL;
qglReadBuffer = NULL;
qglReadPixels = NULL;
qglRectd = NULL;
qglRectdv = NULL;
qglRectf = NULL;
qglRectfv = NULL;
qglRecti = NULL;
qglRectiv = NULL;
qglRects = NULL;
qglRectsv = NULL;
qglRenderMode = NULL;
qglRotated = NULL;
qglRotatef = NULL;
qglScaled = NULL;
qglScalef = NULL;
qglScissor = NULL;
qglSelectBuffer = NULL;
qglShadeModel = NULL;
qglStencilFunc = NULL;
qglStencilMask = NULL;
qglStencilOp = NULL;
qglTexCoord1d = NULL;
qglTexCoord1dv = NULL;
qglTexCoord1f = NULL;
qglTexCoord1fv = NULL;
qglTexCoord1i = NULL;
qglTexCoord1iv = NULL;
qglTexCoord1s = NULL;
qglTexCoord1sv = NULL;
qglTexCoord2d = NULL;
qglTexCoord2dv = NULL;
qglTexCoord2f = NULL;
qglTexCoord2fv = NULL;
qglTexCoord2i = NULL;
qglTexCoord2iv = NULL;
qglTexCoord2s = NULL;
qglTexCoord2sv = NULL;
qglTexCoord3d = NULL;
qglTexCoord3dv = NULL;
qglTexCoord3f = NULL;
qglTexCoord3fv = NULL;
qglTexCoord3i = NULL;
qglTexCoord3iv = NULL;
qglTexCoord3s = NULL;
qglTexCoord3sv = NULL;
qglTexCoord4d = NULL;
qglTexCoord4dv = NULL;
qglTexCoord4f = NULL;
qglTexCoord4fv = NULL;
qglTexCoord4i = NULL;
qglTexCoord4iv = NULL;
qglTexCoord4s = NULL;
qglTexCoord4sv = NULL;
qglTexCoordPointer = NULL;
qglTexEnvf = NULL;
qglTexEnvfv = NULL;
qglTexEnvi = NULL;
qglTexEnviv = NULL;
qglTexGend = NULL;
qglTexGendv = NULL;
qglTexGenf = NULL;
qglTexGenfv = NULL;
qglTexGeni = NULL;
qglTexGeniv = NULL;
qglTexImage1D = NULL;
qglTexImage2D = NULL;
qglTexParameterf = NULL;
qglTexParameterfv = NULL;
qglTexParameteri = NULL;
qglTexParameteriv = NULL;
qglTexSubImage1D = NULL;
qglTexSubImage2D = NULL;
qglTranslated = NULL;
qglTranslatef = NULL;
qglVertex2d = NULL;
qglVertex2dv = NULL;
qglVertex2f = NULL;
qglVertex2fv = NULL;
qglVertex2i = NULL;
qglVertex2iv = NULL;
qglVertex2s = NULL;
qglVertex2sv = NULL;
qglVertex3d = NULL;
qglVertex3dv = NULL;
qglVertex3f = NULL;
qglVertex3fv = NULL;
qglVertex3i = NULL;
qglVertex3iv = NULL;
qglVertex3s = NULL;
qglVertex3sv = NULL;
qglVertex4d = NULL;
qglVertex4dv = NULL;
qglVertex4f = NULL;
qglVertex4fv = NULL;
qglVertex4i = NULL;
qglVertex4iv = NULL;
qglVertex4s = NULL;
qglVertex4sv = NULL;
qglVertexPointer = NULL;
qglViewport = NULL;
qwglCopyContext = NULL;
qwglCreateContext = NULL;
qwglCreateLayerContext = NULL;
qwglDeleteContext = NULL;
qwglDescribeLayerPlane = NULL;
qwglGetCurrentContext = NULL;
qwglGetCurrentDC = NULL;
qwglGetLayerPaletteEntries = NULL;
qwglGetProcAddress = NULL;
qwglMakeCurrent = NULL;
qwglRealizeLayerPalette = NULL;
qwglSetLayerPaletteEntries = NULL;
qwglShareLists = NULL;
qwglSwapLayerBuffers = NULL;
qwglUseFontBitmaps = NULL;
qwglUseFontOutlines = NULL;
qwglChoosePixelFormat = NULL;
qwglDescribePixelFormat = NULL;
qwglGetPixelFormat = NULL;
qwglSetPixelFormat = NULL;
qwglSwapBuffers = NULL;
qwglSwapIntervalEXT = NULL;
qwglGetDeviceGammaRampEXT = NULL;
qwglSetDeviceGammaRampEXT = NULL;
}
#pragma warning(disable : 4113 4133 4047)
#define GPA(a) GetProcAddress(glw_state.hinstOpenGL, a)
bool QGL_Init(const char *dllname) {
{
char envbuffer[1024];
float g;
g = 2.00 * (0.8 - (vid_gamma->value - 0.5)) + 1.0F;
Com_sprintf(envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g);
putenv(envbuffer);
Com_sprintf(envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g);
putenv(envbuffer);
}
if((glw_state.hinstOpenGL = LoadLibrary(dllname)) == 0) {
char *buf = NULL;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&buf, 0, NULL);
ri.Con_Printf(PRINT_ALL, "%s\n", buf);
return false;
}
gl_config.allow_cds = true;
#define INIT_DLL_TO_QGL(a) \
do { \
*(void **)&dll##a = GPA("gl" #a); \
qgl##a = dll##a; \
} while(false)
INIT_DLL_TO_QGL(Accum);
INIT_DLL_TO_QGL(AlphaFunc);
INIT_DLL_TO_QGL(AreTexturesResident);
INIT_DLL_TO_QGL(ArrayElement);
INIT_DLL_TO_QGL(Begin);
INIT_DLL_TO_QGL(BindTexture);
INIT_DLL_TO_QGL(Bitmap);
INIT_DLL_TO_QGL(BlendFunc);
INIT_DLL_TO_QGL(CallList);
INIT_DLL_TO_QGL(CallLists);
INIT_DLL_TO_QGL(Clear);
INIT_DLL_TO_QGL(ClearAccum);
INIT_DLL_TO_QGL(ClearColor);
INIT_DLL_TO_QGL(ClearDepth);
INIT_DLL_TO_QGL(ClearIndex);
INIT_DLL_TO_QGL(ClearStencil);
INIT_DLL_TO_QGL(ClipPlane);
INIT_DLL_TO_QGL(Color3b);
INIT_DLL_TO_QGL(Color3bv);
INIT_DLL_TO_QGL(Color3d);
INIT_DLL_TO_QGL(Color3dv);
INIT_DLL_TO_QGL(Color3f);
INIT_DLL_TO_QGL(Color3fv);
INIT_DLL_TO_QGL(Color3i);
INIT_DLL_TO_QGL(Color3iv);
INIT_DLL_TO_QGL(Color3s);
INIT_DLL_TO_QGL(Color3sv);
INIT_DLL_TO_QGL(Color3ub);
INIT_DLL_TO_QGL(Color3ubv);
INIT_DLL_TO_QGL(Color3ui);
INIT_DLL_TO_QGL(Color3uiv);
INIT_DLL_TO_QGL(Color3us);
INIT_DLL_TO_QGL(Color3usv);
INIT_DLL_TO_QGL(Color4b);
INIT_DLL_TO_QGL(Color4bv);
INIT_DLL_TO_QGL(Color4d);
INIT_DLL_TO_QGL(Color4dv);
INIT_DLL_TO_QGL(Color4f);
INIT_DLL_TO_QGL(Color4fv);
INIT_DLL_TO_QGL(Color4i);
INIT_DLL_TO_QGL(Color4iv);
INIT_DLL_TO_QGL(Color4s);
INIT_DLL_TO_QGL(Color4sv);
INIT_DLL_TO_QGL(Color4ub);
INIT_DLL_TO_QGL(Color4ubv);
INIT_DLL_TO_QGL(Color4ui);
INIT_DLL_TO_QGL(Color4uiv);
INIT_DLL_TO_QGL(Color4us);
INIT_DLL_TO_QGL(Color4usv);
INIT_DLL_TO_QGL(ColorMask);
INIT_DLL_TO_QGL(ColorMaterial);
INIT_DLL_TO_QGL(ColorPointer);
INIT_DLL_TO_QGL(CopyPixels);
INIT_DLL_TO_QGL(CopyTexImage1D);
INIT_DLL_TO_QGL(CopyTexImage2D);
INIT_DLL_TO_QGL(CopyTexSubImage1D);
INIT_DLL_TO_QGL(CopyTexSubImage2D);
INIT_DLL_TO_QGL(CullFace);
INIT_DLL_TO_QGL(DeleteLists);
INIT_DLL_TO_QGL(DeleteTextures);
INIT_DLL_TO_QGL(DepthFunc);
INIT_DLL_TO_QGL(DepthMask);
INIT_DLL_TO_QGL(DepthRange);
INIT_DLL_TO_QGL(Disable);
INIT_DLL_TO_QGL(DisableClientState);
INIT_DLL_TO_QGL(DrawArrays);
INIT_DLL_TO_QGL(DrawBuffer);
INIT_DLL_TO_QGL(DrawElements);
INIT_DLL_TO_QGL(DrawPixels);
INIT_DLL_TO_QGL(EdgeFlag);
INIT_DLL_TO_QGL(EdgeFlagPointer);
INIT_DLL_TO_QGL(EdgeFlagv);
INIT_DLL_TO_QGL(Enable);
INIT_DLL_TO_QGL(EnableClientState);
INIT_DLL_TO_QGL(End);
INIT_DLL_TO_QGL(EndList);
INIT_DLL_TO_QGL(EvalCoord1d);
INIT_DLL_TO_QGL(EvalCoord1dv);
INIT_DLL_TO_QGL(EvalCoord1f);
INIT_DLL_TO_QGL(EvalCoord1fv);
INIT_DLL_TO_QGL(EvalCoord2d);
INIT_DLL_TO_QGL(EvalCoord2dv);
INIT_DLL_TO_QGL(EvalCoord2f);
INIT_DLL_TO_QGL(EvalCoord2fv);
INIT_DLL_TO_QGL(EvalMesh1);
INIT_DLL_TO_QGL(EvalMesh2);
INIT_DLL_TO_QGL(EvalPoint1);
INIT_DLL_TO_QGL(EvalPoint2);
INIT_DLL_TO_QGL(FeedbackBuffer);
INIT_DLL_TO_QGL(Finish);
INIT_DLL_TO_QGL(Flush);
INIT_DLL_TO_QGL(Fogf);
INIT_DLL_TO_QGL(Fogfv);
INIT_DLL_TO_QGL(Fogi);
INIT_DLL_TO_QGL(Fogiv);
INIT_DLL_TO_QGL(FrontFace);
INIT_DLL_TO_QGL(Frustum);
INIT_DLL_TO_QGL(GenLists);
INIT_DLL_TO_QGL(GenTextures);
INIT_DLL_TO_QGL(GetBooleanv);
INIT_DLL_TO_QGL(GetClipPlane);
INIT_DLL_TO_QGL(GetDoublev);
INIT_DLL_TO_QGL(GetError);
INIT_DLL_TO_QGL(GetFloatv);
INIT_DLL_TO_QGL(GetIntegerv);
INIT_DLL_TO_QGL(GetLightfv);
INIT_DLL_TO_QGL(GetLightiv);
INIT_DLL_TO_QGL(GetMapdv);
INIT_DLL_TO_QGL(GetMapfv);
INIT_DLL_TO_QGL(GetMapiv);
INIT_DLL_TO_QGL(GetMaterialfv);
INIT_DLL_TO_QGL(GetMaterialiv);
INIT_DLL_TO_QGL(GetPixelMapfv);
INIT_DLL_TO_QGL(GetPixelMapuiv);
INIT_DLL_TO_QGL(GetPixelMapusv);
INIT_DLL_TO_QGL(GetPointerv);
INIT_DLL_TO_QGL(GetPolygonStipple);
INIT_DLL_TO_QGL(GetString);
INIT_DLL_TO_QGL(GetTexEnvfv);
INIT_DLL_TO_QGL(GetTexEnviv);
INIT_DLL_TO_QGL(GetTexGendv);
INIT_DLL_TO_QGL(GetTexGenfv);
INIT_DLL_TO_QGL(GetTexGeniv);
INIT_DLL_TO_QGL(GetTexImage);
INIT_DLL_TO_QGL(GetTexLevelParameterfv);
INIT_DLL_TO_QGL(GetTexLevelParameteriv);
INIT_DLL_TO_QGL(GetTexParameterfv);
INIT_DLL_TO_QGL(GetTexParameteriv);
INIT_DLL_TO_QGL(Hint);
INIT_DLL_TO_QGL(IndexMask);
INIT_DLL_TO_QGL(IndexPointer);
INIT_DLL_TO_QGL(Indexd);
INIT_DLL_TO_QGL(Indexdv);
INIT_DLL_TO_QGL(Indexf);
INIT_DLL_TO_QGL(Indexfv);
INIT_DLL_TO_QGL(Indexi);
INIT_DLL_TO_QGL(Indexiv);
INIT_DLL_TO_QGL(Indexs);
INIT_DLL_TO_QGL(Indexsv);
INIT_DLL_TO_QGL(Indexub);
INIT_DLL_TO_QGL(Indexubv);
INIT_DLL_TO_QGL(InitNames);
INIT_DLL_TO_QGL(InterleavedArrays);
INIT_DLL_TO_QGL(IsEnabled);
INIT_DLL_TO_QGL(IsList);
INIT_DLL_TO_QGL(IsTexture);
INIT_DLL_TO_QGL(LightModelf);
INIT_DLL_TO_QGL(LightModelfv);
INIT_DLL_TO_QGL(LightModeli);
INIT_DLL_TO_QGL(LightModeliv);
INIT_DLL_TO_QGL(Lightf);
INIT_DLL_TO_QGL(Lightfv);
INIT_DLL_TO_QGL(Lighti);
INIT_DLL_TO_QGL(Lightiv);
INIT_DLL_TO_QGL(LineStipple);
INIT_DLL_TO_QGL(LineWidth);
INIT_DLL_TO_QGL(ListBase);
INIT_DLL_TO_QGL(LoadIdentity);
INIT_DLL_TO_QGL(LoadMatrixd);
INIT_DLL_TO_QGL(LoadMatrixf);
INIT_DLL_TO_QGL(LoadName);
INIT_DLL_TO_QGL(LogicOp);
INIT_DLL_TO_QGL(Map1d);
INIT_DLL_TO_QGL(Map1f);
INIT_DLL_TO_QGL(Map2d);
INIT_DLL_TO_QGL(Map2f);
INIT_DLL_TO_QGL(MapGrid1d);
INIT_DLL_TO_QGL(MapGrid1f);
INIT_DLL_TO_QGL(MapGrid2d);
INIT_DLL_TO_QGL(MapGrid2f);
INIT_DLL_TO_QGL(Materialf);
INIT_DLL_TO_QGL(Materialfv);
INIT_DLL_TO_QGL(Materiali);
INIT_DLL_TO_QGL(Materialiv);
INIT_DLL_TO_QGL(MatrixMode);
INIT_DLL_TO_QGL(MultMatrixd);
INIT_DLL_TO_QGL(MultMatrixf);
INIT_DLL_TO_QGL(NewList);
INIT_DLL_TO_QGL(Normal3b);
INIT_DLL_TO_QGL(Normal3bv);
INIT_DLL_TO_QGL(Normal3d);
INIT_DLL_TO_QGL(Normal3dv);
INIT_DLL_TO_QGL(Normal3f);
INIT_DLL_TO_QGL(Normal3fv);
INIT_DLL_TO_QGL(Normal3i);
INIT_DLL_TO_QGL(Normal3iv);
INIT_DLL_TO_QGL(Normal3s);
INIT_DLL_TO_QGL(Normal3sv);
INIT_DLL_TO_QGL(NormalPointer);
INIT_DLL_TO_QGL(Ortho);
INIT_DLL_TO_QGL(PassThrough);
INIT_DLL_TO_QGL(PixelMapfv);
INIT_DLL_TO_QGL(PixelMapuiv);
INIT_DLL_TO_QGL(PixelMapusv);
INIT_DLL_TO_QGL(PixelStoref);
INIT_DLL_TO_QGL(PixelStorei);
INIT_DLL_TO_QGL(PixelTransferf);
INIT_DLL_TO_QGL(PixelTransferi);
INIT_DLL_TO_QGL(PixelZoom);
INIT_DLL_TO_QGL(PointSize);
INIT_DLL_TO_QGL(PolygonMode);
INIT_DLL_TO_QGL(PolygonOffset);
INIT_DLL_TO_QGL(PolygonStipple);
INIT_DLL_TO_QGL(PopAttrib);
INIT_DLL_TO_QGL(PopClientAttrib);
INIT_DLL_TO_QGL(PopMatrix);
INIT_DLL_TO_QGL(PopName);
INIT_DLL_TO_QGL(PrioritizeTextures);
INIT_DLL_TO_QGL(PushAttrib);
INIT_DLL_TO_QGL(PushClientAttrib);
INIT_DLL_TO_QGL(PushMatrix);
INIT_DLL_TO_QGL(PushName);
INIT_DLL_TO_QGL(RasterPos2d);
INIT_DLL_TO_QGL(RasterPos2dv);
INIT_DLL_TO_QGL(RasterPos2f);
INIT_DLL_TO_QGL(RasterPos2fv);
INIT_DLL_TO_QGL(RasterPos2i);
INIT_DLL_TO_QGL(RasterPos2iv);
INIT_DLL_TO_QGL(RasterPos2s);
INIT_DLL_TO_QGL(RasterPos2sv);
INIT_DLL_TO_QGL(RasterPos3d);
INIT_DLL_TO_QGL(RasterPos3dv);
INIT_DLL_TO_QGL(RasterPos3f);
INIT_DLL_TO_QGL(RasterPos3fv);
INIT_DLL_TO_QGL(RasterPos3i);
INIT_DLL_TO_QGL(RasterPos3iv);
INIT_DLL_TO_QGL(RasterPos3s);
INIT_DLL_TO_QGL(RasterPos3sv);
INIT_DLL_TO_QGL(RasterPos4d);
INIT_DLL_TO_QGL(RasterPos4dv);
INIT_DLL_TO_QGL(RasterPos4f);
INIT_DLL_TO_QGL(RasterPos4fv);
INIT_DLL_TO_QGL(RasterPos4i);
INIT_DLL_TO_QGL(RasterPos4iv);
INIT_DLL_TO_QGL(RasterPos4s);
INIT_DLL_TO_QGL(RasterPos4sv);
INIT_DLL_TO_QGL(ReadBuffer);
INIT_DLL_TO_QGL(ReadPixels);
INIT_DLL_TO_QGL(Rectd);
INIT_DLL_TO_QGL(Rectdv);
INIT_DLL_TO_QGL(Rectf);
INIT_DLL_TO_QGL(Rectfv);
INIT_DLL_TO_QGL(Recti);
INIT_DLL_TO_QGL(Rectiv);
INIT_DLL_TO_QGL(Rects);
INIT_DLL_TO_QGL(Rectsv);
INIT_DLL_TO_QGL(RenderMode);
INIT_DLL_TO_QGL(Rotated);
INIT_DLL_TO_QGL(Rotatef);
INIT_DLL_TO_QGL(Scaled);
INIT_DLL_TO_QGL(Scalef);
INIT_DLL_TO_QGL(Scissor);
INIT_DLL_TO_QGL(SelectBuffer);
INIT_DLL_TO_QGL(ShadeModel);
INIT_DLL_TO_QGL(StencilFunc);
INIT_DLL_TO_QGL(StencilMask);
INIT_DLL_TO_QGL(StencilOp);
INIT_DLL_TO_QGL(TexCoord1d);
INIT_DLL_TO_QGL(TexCoord1dv);
INIT_DLL_TO_QGL(TexCoord1f);
INIT_DLL_TO_QGL(TexCoord1fv);
INIT_DLL_TO_QGL(TexCoord1i);
INIT_DLL_TO_QGL(TexCoord1iv);
INIT_DLL_TO_QGL(TexCoord1s);
INIT_DLL_TO_QGL(TexCoord1sv);
INIT_DLL_TO_QGL(TexCoord2d);
INIT_DLL_TO_QGL(TexCoord2dv);
INIT_DLL_TO_QGL(TexCoord2f);
INIT_DLL_TO_QGL(TexCoord2fv);
INIT_DLL_TO_QGL(TexCoord2i);
INIT_DLL_TO_QGL(TexCoord2iv);
INIT_DLL_TO_QGL(TexCoord2s);
INIT_DLL_TO_QGL(TexCoord2sv);
INIT_DLL_TO_QGL(TexCoord3d);
INIT_DLL_TO_QGL(TexCoord3dv);
INIT_DLL_TO_QGL(TexCoord3f);
INIT_DLL_TO_QGL(TexCoord3fv);
INIT_DLL_TO_QGL(TexCoord3i);
INIT_DLL_TO_QGL(TexCoord3iv);
INIT_DLL_TO_QGL(TexCoord3s);
INIT_DLL_TO_QGL(TexCoord3sv);
INIT_DLL_TO_QGL(TexCoord4d);
INIT_DLL_TO_QGL(TexCoord4dv);
INIT_DLL_TO_QGL(TexCoord4f);
INIT_DLL_TO_QGL(TexCoord4fv);
INIT_DLL_TO_QGL(TexCoord4i);
INIT_DLL_TO_QGL(TexCoord4iv);
INIT_DLL_TO_QGL(TexCoord4s);
INIT_DLL_TO_QGL(TexCoord4sv);
INIT_DLL_TO_QGL(TexCoordPointer);
INIT_DLL_TO_QGL(TexEnvf);
INIT_DLL_TO_QGL(TexEnvfv);
INIT_DLL_TO_QGL(TexEnvi);
INIT_DLL_TO_QGL(TexEnviv);
INIT_DLL_TO_QGL(TexGend);
INIT_DLL_TO_QGL(TexGendv);
INIT_DLL_TO_QGL(TexGenf);
INIT_DLL_TO_QGL(TexGenfv);
INIT_DLL_TO_QGL(TexGeni);
INIT_DLL_TO_QGL(TexGeniv);
INIT_DLL_TO_QGL(TexImage1D);
INIT_DLL_TO_QGL(TexImage2D);
INIT_DLL_TO_QGL(TexParameterf);
INIT_DLL_TO_QGL(TexParameterfv);
INIT_DLL_TO_QGL(TexParameteri);
INIT_DLL_TO_QGL(TexParameteriv);
INIT_DLL_TO_QGL(TexSubImage1D);
INIT_DLL_TO_QGL(TexSubImage2D);
INIT_DLL_TO_QGL(Translated);
INIT_DLL_TO_QGL(Translatef);
INIT_DLL_TO_QGL(Vertex2d);
INIT_DLL_TO_QGL(Vertex2dv);
INIT_DLL_TO_QGL(Vertex2f);
INIT_DLL_TO_QGL(Vertex2fv);
INIT_DLL_TO_QGL(Vertex2i);
INIT_DLL_TO_QGL(Vertex2iv);
INIT_DLL_TO_QGL(Vertex2s);
INIT_DLL_TO_QGL(Vertex2sv);
INIT_DLL_TO_QGL(Vertex3d);
INIT_DLL_TO_QGL(Vertex3dv);
INIT_DLL_TO_QGL(Vertex3f);
INIT_DLL_TO_QGL(Vertex3fv);
INIT_DLL_TO_QGL(Vertex3i);
INIT_DLL_TO_QGL(Vertex3iv);
INIT_DLL_TO_QGL(Vertex3s);
INIT_DLL_TO_QGL(Vertex3sv);
INIT_DLL_TO_QGL(Vertex4d);
INIT_DLL_TO_QGL(Vertex4dv);
INIT_DLL_TO_QGL(Vertex4f);
INIT_DLL_TO_QGL(Vertex4fv);
INIT_DLL_TO_QGL(Vertex4i);
INIT_DLL_TO_QGL(Vertex4iv);
INIT_DLL_TO_QGL(Vertex4s);
INIT_DLL_TO_QGL(Vertex4sv);
INIT_DLL_TO_QGL(VertexPointer);
INIT_DLL_TO_QGL(Viewport);
#undef INIT_DLL_TO_QGL
*(void **)&qwglCopyContext = GPA("wglCopyContext");
*(void **)&qwglCreateContext = GPA("wglCreateContext");
*(void **)&qwglCreateLayerContext = GPA("wglCreateLayerContext");
*(void **)&qwglDeleteContext = GPA("wglDeleteContext");
*(void **)&qwglDescribeLayerPlane = GPA("wglDescribeLayerPlane");
*(void **)&qwglGetCurrentContext = GPA("wglGetCurrentContext");
*(void **)&qwglGetCurrentDC = GPA("wglGetCurrentDC");
*(void **)&qwglGetLayerPaletteEntries = GPA("wglGetLayerPaletteEntries");
*(void **)&qwglGetProcAddress = GPA("wglGetProcAddress");
*(void **)&qwglMakeCurrent = GPA("wglMakeCurrent");
*(void **)&qwglRealizeLayerPalette = GPA("wglRealizeLayerPalette");
*(void **)&qwglSetLayerPaletteEntries = GPA("wglSetLayerPaletteEntries");
*(void **)&qwglShareLists = GPA("wglShareLists");
*(void **)&qwglSwapLayerBuffers = GPA("wglSwapLayerBuffers");
*(void **)&qwglUseFontBitmaps = GPA("wglUseFontBitmapsA");
*(void **)&qwglUseFontOutlines = GPA("wglUseFontOutlinesA");
*(void **)&qwglChoosePixelFormat = GPA("wglChoosePixelFormat");
*(void **)&qwglDescribePixelFormat = GPA("wglDescribePixelFormat");
*(void **)&qwglGetPixelFormat = GPA("wglGetPixelFormat");
*(void **)&qwglSetPixelFormat = GPA("wglSetPixelFormat");
*(void **)&qwglSwapBuffers = GPA("wglSwapBuffers");
qwglSwapIntervalEXT = 0;
qglPointParameterfEXT = 0;
qglPointParameterfvEXT = 0;
qglColorTableEXT = 0;
qglSelectTextureSGIS = 0;
qglMTexCoord2fSGIS = 0;
return true;
}
void GLimp_EnableLogging(bool enable) {
if(enable) {
if(!glw_state.log_fp) {
struct tm *newtime;
time_t aclock;
char buffer[1024];
time(&aclock);
newtime = localtime(&aclock);
asctime(newtime);
Com_sprintf(buffer, sizeof(buffer), "%s/gl.log", ri.FS_Gamedir());
glw_state.log_fp = fopen(buffer, "wt");
fprintf(glw_state.log_fp, "%s\n", asctime(newtime));
}
qglAccum = logAccum;
qglAlphaFunc = logAlphaFunc;
qglAreTexturesResident = logAreTexturesResident;
qglArrayElement = logArrayElement;
qglBegin = logBegin;
qglBindTexture = logBindTexture;
qglBitmap = logBitmap;
qglBlendFunc = logBlendFunc;
qglCallList = logCallList;
qglCallLists = logCallLists;
qglClear = logClear;
qglClearAccum = logClearAccum;
qglClearColor = logClearColor;
qglClearDepth = logClearDepth;
qglClearIndex = logClearIndex;
qglClearStencil = logClearStencil;
qglClipPlane = logClipPlane;
qglColor3b = logColor3b;
qglColor3bv = logColor3bv;
qglColor3d = logColor3d;
qglColor3dv = logColor3dv;
qglColor3f = logColor3f;
qglColor3fv = logColor3fv;
qglColor3i = logColor3i;
qglColor3iv = logColor3iv;
qglColor3s = logColor3s;
qglColor3sv = logColor3sv;
qglColor3ub = logColor3ub;
qglColor3ubv = logColor3ubv;
qglColor3ui = logColor3ui;
qglColor3uiv = logColor3uiv;
qglColor3us = logColor3us;
qglColor3usv = logColor3usv;
qglColor4b = logColor4b;
qglColor4bv = logColor4bv;
qglColor4d = logColor4d;
qglColor4dv = logColor4dv;
qglColor4f = logColor4f;
qglColor4fv = logColor4fv;
qglColor4i = logColor4i;
qglColor4iv = logColor4iv;
qglColor4s = logColor4s;
qglColor4sv = logColor4sv;
qglColor4ub = logColor4ub;
qglColor4ubv = logColor4ubv;
qglColor4ui = logColor4ui;
qglColor4uiv = logColor4uiv;
qglColor4us = logColor4us;
qglColor4usv = logColor4usv;
qglColorMask = logColorMask;
qglColorMaterial = logColorMaterial;
qglColorPointer = logColorPointer;
qglCopyPixels = logCopyPixels;
qglCopyTexImage1D = logCopyTexImage1D;
qglCopyTexImage2D = logCopyTexImage2D;
qglCopyTexSubImage1D = logCopyTexSubImage1D;
qglCopyTexSubImage2D = logCopyTexSubImage2D;
qglCullFace = logCullFace;
qglDeleteLists = logDeleteLists;
qglDeleteTextures = logDeleteTextures;
qglDepthFunc = logDepthFunc;
qglDepthMask = logDepthMask;
qglDepthRange = logDepthRange;
qglDisable = logDisable;
qglDisableClientState = logDisableClientState;
qglDrawArrays = logDrawArrays;
qglDrawBuffer = logDrawBuffer;
qglDrawElements = logDrawElements;
qglDrawPixels = logDrawPixels;
qglEdgeFlag = logEdgeFlag;
qglEdgeFlagPointer = logEdgeFlagPointer;
qglEdgeFlagv = logEdgeFlagv;
qglEnable = logEnable;
qglEnableClientState = logEnableClientState;
qglEnd = logEnd;
qglEndList = logEndList;
qglEvalCoord1d = logEvalCoord1d;
qglEvalCoord1dv = logEvalCoord1dv;
qglEvalCoord1f = logEvalCoord1f;
qglEvalCoord1fv = logEvalCoord1fv;
qglEvalCoord2d = logEvalCoord2d;
qglEvalCoord2dv = logEvalCoord2dv;
qglEvalCoord2f = logEvalCoord2f;
qglEvalCoord2fv = logEvalCoord2fv;
qglEvalMesh1 = logEvalMesh1;
qglEvalMesh2 = logEvalMesh2;
qglEvalPoint1 = logEvalPoint1;
qglEvalPoint2 = logEvalPoint2;
qglFeedbackBuffer = logFeedbackBuffer;
qglFinish = logFinish;
qglFlush = logFlush;
qglFogf = logFogf;
qglFogfv = logFogfv;
qglFogi = logFogi;
qglFogiv = logFogiv;
qglFrontFace = logFrontFace;
qglFrustum = logFrustum;
qglGenLists = logGenLists;
qglGenTextures = logGenTextures;
qglGetBooleanv = logGetBooleanv;
qglGetClipPlane = logGetClipPlane;
qglGetDoublev = logGetDoublev;
qglGetError = logGetError;
qglGetFloatv = logGetFloatv;
qglGetIntegerv = logGetIntegerv;
qglGetLightfv = logGetLightfv;
qglGetLightiv = logGetLightiv;
qglGetMapdv = logGetMapdv;
qglGetMapfv = logGetMapfv;
qglGetMapiv = logGetMapiv;
qglGetMaterialfv = logGetMaterialfv;
qglGetMaterialiv = logGetMaterialiv;
qglGetPixelMapfv = logGetPixelMapfv;
qglGetPixelMapuiv = logGetPixelMapuiv;
qglGetPixelMapusv = logGetPixelMapusv;
qglGetPointerv = logGetPointerv;
qglGetPolygonStipple = logGetPolygonStipple;
qglGetString = logGetString;
qglGetTexEnvfv = logGetTexEnvfv;
qglGetTexEnviv = logGetTexEnviv;
qglGetTexGendv = logGetTexGendv;
qglGetTexGenfv = logGetTexGenfv;
qglGetTexGeniv = logGetTexGeniv;
qglGetTexImage = logGetTexImage;
qglGetTexLevelParameterfv = logGetTexLevelParameterfv;
qglGetTexLevelParameteriv = logGetTexLevelParameteriv;
qglGetTexParameterfv = logGetTexParameterfv;
qglGetTexParameteriv = logGetTexParameteriv;
qglHint = logHint;
qglIndexMask = logIndexMask;
qglIndexPointer = logIndexPointer;
qglIndexd = logIndexd;
qglIndexdv = logIndexdv;
qglIndexf = logIndexf;
qglIndexfv = logIndexfv;
qglIndexi = logIndexi;
qglIndexiv = logIndexiv;
qglIndexs = logIndexs;
qglIndexsv = logIndexsv;
qglIndexub = logIndexub;
qglIndexubv = logIndexubv;
qglInitNames = logInitNames;
qglInterleavedArrays = logInterleavedArrays;
qglIsEnabled = logIsEnabled;
qglIsList = logIsList;
qglIsTexture = logIsTexture;
qglLightModelf = logLightModelf;
qglLightModelfv = logLightModelfv;
qglLightModeli = logLightModeli;
qglLightModeliv = logLightModeliv;
qglLightf = logLightf;
qglLightfv = logLightfv;
qglLighti = logLighti;
qglLightiv = logLightiv;
qglLineStipple = logLineStipple;
qglLineWidth = logLineWidth;
qglListBase = logListBase;
qglLoadIdentity = logLoadIdentity;
qglLoadMatrixd = logLoadMatrixd;
qglLoadMatrixf = logLoadMatrixf;
qglLoadName = logLoadName;
qglLogicOp = logLogicOp;
qglMap1d = logMap1d;
qglMap1f = logMap1f;
qglMap2d = logMap2d;
qglMap2f = logMap2f;
qglMapGrid1d = logMapGrid1d;
qglMapGrid1f = logMapGrid1f;
qglMapGrid2d = logMapGrid2d;
qglMapGrid2f = logMapGrid2f;
qglMaterialf = logMaterialf;
qglMaterialfv = logMaterialfv;
qglMateriali = logMateriali;
qglMaterialiv = logMaterialiv;
qglMatrixMode = logMatrixMode;
qglMultMatrixd = logMultMatrixd;
qglMultMatrixf = logMultMatrixf;
qglNewList = logNewList;
qglNormal3b = logNormal3b;
qglNormal3bv = logNormal3bv;
qglNormal3d = logNormal3d;
qglNormal3dv = logNormal3dv;
qglNormal3f = logNormal3f;
qglNormal3fv = logNormal3fv;
qglNormal3i = logNormal3i;
qglNormal3iv = logNormal3iv;
qglNormal3s = logNormal3s;
qglNormal3sv = logNormal3sv;
qglNormalPointer = logNormalPointer;
qglOrtho = logOrtho;
qglPassThrough = logPassThrough;
qglPixelMapfv = logPixelMapfv;
qglPixelMapuiv = logPixelMapuiv;
qglPixelMapusv = logPixelMapusv;
qglPixelStoref = logPixelStoref;
qglPixelStorei = logPixelStorei;
qglPixelTransferf = logPixelTransferf;
qglPixelTransferi = logPixelTransferi;
qglPixelZoom = logPixelZoom;
qglPointSize = logPointSize;
qglPolygonMode = logPolygonMode;
qglPolygonOffset = logPolygonOffset;
qglPolygonStipple = logPolygonStipple;
qglPopAttrib = logPopAttrib;
qglPopClientAttrib = logPopClientAttrib;
qglPopMatrix = logPopMatrix;
qglPopName = logPopName;
qglPrioritizeTextures = logPrioritizeTextures;
qglPushAttrib = logPushAttrib;
qglPushClientAttrib = logPushClientAttrib;
qglPushMatrix = logPushMatrix;
qglPushName = logPushName;
qglRasterPos2d = logRasterPos2d;
qglRasterPos2dv = logRasterPos2dv;
qglRasterPos2f = logRasterPos2f;
qglRasterPos2fv = logRasterPos2fv;
qglRasterPos2i = logRasterPos2i;
qglRasterPos2iv = logRasterPos2iv;
qglRasterPos2s = logRasterPos2s;
qglRasterPos2sv = logRasterPos2sv;
qglRasterPos3d = logRasterPos3d;
qglRasterPos3dv = logRasterPos3dv;
qglRasterPos3f = logRasterPos3f;
qglRasterPos3fv = logRasterPos3fv;
qglRasterPos3i = logRasterPos3i;
qglRasterPos3iv = logRasterPos3iv;
qglRasterPos3s = logRasterPos3s;
qglRasterPos3sv = logRasterPos3sv;
qglRasterPos4d = logRasterPos4d;
qglRasterPos4dv = logRasterPos4dv;
qglRasterPos4f = logRasterPos4f;
qglRasterPos4fv = logRasterPos4fv;
qglRasterPos4i = logRasterPos4i;
qglRasterPos4iv = logRasterPos4iv;
qglRasterPos4s = logRasterPos4s;
qglRasterPos4sv = logRasterPos4sv;
qglReadBuffer = logReadBuffer;
qglReadPixels = logReadPixels;
qglRectd = logRectd;
qglRectdv = logRectdv;
qglRectf = logRectf;
qglRectfv = logRectfv;
qglRecti = logRecti;
qglRectiv = logRectiv;
qglRects = logRects;
qglRectsv = logRectsv;
qglRenderMode = logRenderMode;
qglRotated = logRotated;
qglRotatef = logRotatef;
qglScaled = logScaled;
qglScalef = logScalef;
qglScissor = logScissor;
qglSelectBuffer = logSelectBuffer;
qglShadeModel = logShadeModel;
qglStencilFunc = logStencilFunc;
qglStencilMask = logStencilMask;
qglStencilOp = logStencilOp;
qglTexCoord1d = logTexCoord1d;
qglTexCoord1dv = logTexCoord1dv;
qglTexCoord1f = logTexCoord1f;
qglTexCoord1fv = logTexCoord1fv;
qglTexCoord1i = logTexCoord1i;
qglTexCoord1iv = logTexCoord1iv;
qglTexCoord1s = logTexCoord1s;
qglTexCoord1sv = logTexCoord1sv;
qglTexCoord2d = logTexCoord2d;
qglTexCoord2dv = logTexCoord2dv;
qglTexCoord2f = logTexCoord2f;
qglTexCoord2fv = logTexCoord2fv;
qglTexCoord2i = logTexCoord2i;
qglTexCoord2iv = logTexCoord2iv;
qglTexCoord2s = logTexCoord2s;
qglTexCoord2sv = logTexCoord2sv;
qglTexCoord3d = logTexCoord3d;
qglTexCoord3dv = logTexCoord3dv;
qglTexCoord3f = logTexCoord3f;
qglTexCoord3fv = logTexCoord3fv;
qglTexCoord3i = logTexCoord3i;
qglTexCoord3iv = logTexCoord3iv;
qglTexCoord3s = logTexCoord3s;
qglTexCoord3sv = logTexCoord3sv;
qglTexCoord4d = logTexCoord4d;
qglTexCoord4dv = logTexCoord4dv;
qglTexCoord4f = logTexCoord4f;
qglTexCoord4fv = logTexCoord4fv;
qglTexCoord4i = logTexCoord4i;
qglTexCoord4iv = logTexCoord4iv;
qglTexCoord4s = logTexCoord4s;
qglTexCoord4sv = logTexCoord4sv;
qglTexCoordPointer = logTexCoordPointer;
qglTexEnvf = logTexEnvf;
qglTexEnvfv = logTexEnvfv;
qglTexEnvi = logTexEnvi;
qglTexEnviv = logTexEnviv;
qglTexGend = logTexGend;
qglTexGendv = logTexGendv;
qglTexGenf = logTexGenf;
qglTexGenfv = logTexGenfv;
qglTexGeni = logTexGeni;
qglTexGeniv = logTexGeniv;
qglTexImage1D = logTexImage1D;
qglTexImage2D = logTexImage2D;
qglTexParameterf = logTexParameterf;
qglTexParameterfv = logTexParameterfv;
qglTexParameteri = logTexParameteri;
qglTexParameteriv = logTexParameteriv;
qglTexSubImage1D = logTexSubImage1D;
qglTexSubImage2D = logTexSubImage2D;
qglTranslated = logTranslated;
qglTranslatef = logTranslatef;
qglVertex2d = logVertex2d;
qglVertex2dv = logVertex2dv;
qglVertex2f = logVertex2f;
qglVertex2fv = logVertex2fv;
qglVertex2i = logVertex2i;
qglVertex2iv = logVertex2iv;
qglVertex2s = logVertex2s;
qglVertex2sv = logVertex2sv;
qglVertex3d = logVertex3d;
qglVertex3dv = logVertex3dv;
qglVertex3f = logVertex3f;
qglVertex3fv = logVertex3fv;
qglVertex3i = logVertex3i;
qglVertex3iv = logVertex3iv;
qglVertex3s = logVertex3s;
qglVertex3sv = logVertex3sv;
qglVertex4d = logVertex4d;
qglVertex4dv = logVertex4dv;
qglVertex4f = logVertex4f;
qglVertex4fv = logVertex4fv;
qglVertex4i = logVertex4i;
qglVertex4iv = logVertex4iv;
qglVertex4s = logVertex4s;
qglVertex4sv = logVertex4sv;
qglVertexPointer = logVertexPointer;
qglViewport = logViewport;
} else {
qglAccum = dllAccum;
qglAlphaFunc = dllAlphaFunc;
qglAreTexturesResident = dllAreTexturesResident;
qglArrayElement = dllArrayElement;
qglBegin = dllBegin;
qglBindTexture = dllBindTexture;
qglBitmap = dllBitmap;
qglBlendFunc = dllBlendFunc;
qglCallList = dllCallList;
qglCallLists = dllCallLists;
qglClear = dllClear;
qglClearAccum = dllClearAccum;
qglClearColor = dllClearColor;
qglClearDepth = dllClearDepth;
qglClearIndex = dllClearIndex;
qglClearStencil = dllClearStencil;
qglClipPlane = dllClipPlane;
qglColor3b = dllColor3b;
qglColor3bv = dllColor3bv;
qglColor3d = dllColor3d;
qglColor3dv = dllColor3dv;
qglColor3f = dllColor3f;
qglColor3fv = dllColor3fv;
qglColor3i = dllColor3i;
qglColor3iv = dllColor3iv;
qglColor3s = dllColor3s;
qglColor3sv = dllColor3sv;
qglColor3ub = dllColor3ub;
qglColor3ubv = dllColor3ubv;
qglColor3ui = dllColor3ui;
qglColor3uiv = dllColor3uiv;
qglColor3us = dllColor3us;
qglColor3usv = dllColor3usv;
qglColor4b = dllColor4b;
qglColor4bv = dllColor4bv;
qglColor4d = dllColor4d;
qglColor4dv = dllColor4dv;
qglColor4f = dllColor4f;
qglColor4fv = dllColor4fv;
qglColor4i = dllColor4i;
qglColor4iv = dllColor4iv;
qglColor4s = dllColor4s;
qglColor4sv = dllColor4sv;
qglColor4ub = dllColor4ub;
qglColor4ubv = dllColor4ubv;
qglColor4ui = dllColor4ui;
qglColor4uiv = dllColor4uiv;
qglColor4us = dllColor4us;
qglColor4usv = dllColor4usv;
qglColorMask = dllColorMask;
qglColorMaterial = dllColorMaterial;
qglColorPointer = dllColorPointer;
qglCopyPixels = dllCopyPixels;
qglCopyTexImage1D = dllCopyTexImage1D;
qglCopyTexImage2D = dllCopyTexImage2D;
qglCopyTexSubImage1D = dllCopyTexSubImage1D;
qglCopyTexSubImage2D = dllCopyTexSubImage2D;
qglCullFace = dllCullFace;
qglDeleteLists = dllDeleteLists;
qglDeleteTextures = dllDeleteTextures;
qglDepthFunc = dllDepthFunc;
qglDepthMask = dllDepthMask;
qglDepthRange = dllDepthRange;
qglDisable = dllDisable;
qglDisableClientState = dllDisableClientState;
qglDrawArrays = dllDrawArrays;
qglDrawBuffer = dllDrawBuffer;
qglDrawElements = dllDrawElements;
qglDrawPixels = dllDrawPixels;
qglEdgeFlag = dllEdgeFlag;
qglEdgeFlagPointer = dllEdgeFlagPointer;
qglEdgeFlagv = dllEdgeFlagv;
qglEnable = dllEnable;
qglEnableClientState = dllEnableClientState;
qglEnd = dllEnd;
qglEndList = dllEndList;
qglEvalCoord1d = dllEvalCoord1d;
qglEvalCoord1dv = dllEvalCoord1dv;
qglEvalCoord1f = dllEvalCoord1f;
qglEvalCoord1fv = dllEvalCoord1fv;
qglEvalCoord2d = dllEvalCoord2d;
qglEvalCoord2dv = dllEvalCoord2dv;
qglEvalCoord2f = dllEvalCoord2f;
qglEvalCoord2fv = dllEvalCoord2fv;
qglEvalMesh1 = dllEvalMesh1;
qglEvalMesh2 = dllEvalMesh2;
qglEvalPoint1 = dllEvalPoint1;
qglEvalPoint2 = dllEvalPoint2;
qglFeedbackBuffer = dllFeedbackBuffer;
qglFinish = dllFinish;
qglFlush = dllFlush;
qglFogf = dllFogf;
qglFogfv = dllFogfv;
qglFogi = dllFogi;
qglFogiv = dllFogiv;
qglFrontFace = dllFrontFace;
qglFrustum = dllFrustum;
qglGenLists = dllGenLists;
qglGenTextures = dllGenTextures;
qglGetBooleanv = dllGetBooleanv;
qglGetClipPlane = dllGetClipPlane;
qglGetDoublev = dllGetDoublev;
qglGetError = dllGetError;
qglGetFloatv = dllGetFloatv;
qglGetIntegerv = dllGetIntegerv;
qglGetLightfv = dllGetLightfv;
qglGetLightiv = dllGetLightiv;
qglGetMapdv = dllGetMapdv;
qglGetMapfv = dllGetMapfv;
qglGetMapiv = dllGetMapiv;
qglGetMaterialfv = dllGetMaterialfv;
qglGetMaterialiv = dllGetMaterialiv;
qglGetPixelMapfv = dllGetPixelMapfv;
qglGetPixelMapuiv = dllGetPixelMapuiv;
qglGetPixelMapusv = dllGetPixelMapusv;
qglGetPointerv = dllGetPointerv;
qglGetPolygonStipple = dllGetPolygonStipple;
qglGetString = dllGetString;
qglGetTexEnvfv = dllGetTexEnvfv;
qglGetTexEnviv = dllGetTexEnviv;
qglGetTexGendv = dllGetTexGendv;
qglGetTexGenfv = dllGetTexGenfv;
qglGetTexGeniv = dllGetTexGeniv;
qglGetTexImage = dllGetTexImage;
qglGetTexLevelParameterfv = dllGetTexLevelParameterfv;
qglGetTexLevelParameteriv = dllGetTexLevelParameteriv;
qglGetTexParameterfv = dllGetTexParameterfv;
qglGetTexParameteriv = dllGetTexParameteriv;
qglHint = dllHint;
qglIndexMask = dllIndexMask;
qglIndexPointer = dllIndexPointer;
qglIndexd = dllIndexd;
qglIndexdv = dllIndexdv;
qglIndexf = dllIndexf;
qglIndexfv = dllIndexfv;
qglIndexi = dllIndexi;
qglIndexiv = dllIndexiv;
qglIndexs = dllIndexs;
qglIndexsv = dllIndexsv;
qglIndexub = dllIndexub;
qglIndexubv = dllIndexubv;
qglInitNames = dllInitNames;
qglInterleavedArrays = dllInterleavedArrays;
qglIsEnabled = dllIsEnabled;
qglIsList = dllIsList;
qglIsTexture = dllIsTexture;
qglLightModelf = dllLightModelf;
qglLightModelfv = dllLightModelfv;
qglLightModeli = dllLightModeli;
qglLightModeliv = dllLightModeliv;
qglLightf = dllLightf;
qglLightfv = dllLightfv;
qglLighti = dllLighti;
qglLightiv = dllLightiv;
qglLineStipple = dllLineStipple;
qglLineWidth = dllLineWidth;
qglListBase = dllListBase;
qglLoadIdentity = dllLoadIdentity;
qglLoadMatrixd = dllLoadMatrixd;
qglLoadMatrixf = dllLoadMatrixf;
qglLoadName = dllLoadName;
qglLogicOp = dllLogicOp;
qglMap1d = dllMap1d;
qglMap1f = dllMap1f;
qglMap2d = dllMap2d;
qglMap2f = dllMap2f;
qglMapGrid1d = dllMapGrid1d;
qglMapGrid1f = dllMapGrid1f;
qglMapGrid2d = dllMapGrid2d;
qglMapGrid2f = dllMapGrid2f;
qglMaterialf = dllMaterialf;
qglMaterialfv = dllMaterialfv;
qglMateriali = dllMateriali;
qglMaterialiv = dllMaterialiv;
qglMatrixMode = dllMatrixMode;
qglMultMatrixd = dllMultMatrixd;
qglMultMatrixf = dllMultMatrixf;
qglNewList = dllNewList;
qglNormal3b = dllNormal3b;
qglNormal3bv = dllNormal3bv;
qglNormal3d = dllNormal3d;
qglNormal3dv = dllNormal3dv;
qglNormal3f = dllNormal3f;
qglNormal3fv = dllNormal3fv;
qglNormal3i = dllNormal3i;
qglNormal3iv = dllNormal3iv;
qglNormal3s = dllNormal3s;
qglNormal3sv = dllNormal3sv;
qglNormalPointer = dllNormalPointer;
qglOrtho = dllOrtho;
qglPassThrough = dllPassThrough;
qglPixelMapfv = dllPixelMapfv;
qglPixelMapuiv = dllPixelMapuiv;
qglPixelMapusv = dllPixelMapusv;
qglPixelStoref = dllPixelStoref;
qglPixelStorei = dllPixelStorei;
qglPixelTransferf = dllPixelTransferf;
qglPixelTransferi = dllPixelTransferi;
qglPixelZoom = dllPixelZoom;
qglPointSize = dllPointSize;
qglPolygonMode = dllPolygonMode;
qglPolygonOffset = dllPolygonOffset;
qglPolygonStipple = dllPolygonStipple;
qglPopAttrib = dllPopAttrib;
qglPopClientAttrib = dllPopClientAttrib;
qglPopMatrix = dllPopMatrix;
qglPopName = dllPopName;
qglPrioritizeTextures = dllPrioritizeTextures;
qglPushAttrib = dllPushAttrib;
qglPushClientAttrib = dllPushClientAttrib;
qglPushMatrix = dllPushMatrix;
qglPushName = dllPushName;
qglRasterPos2d = dllRasterPos2d;
qglRasterPos2dv = dllRasterPos2dv;
qglRasterPos2f = dllRasterPos2f;
qglRasterPos2fv = dllRasterPos2fv;
qglRasterPos2i = dllRasterPos2i;
qglRasterPos2iv = dllRasterPos2iv;
qglRasterPos2s = dllRasterPos2s;
qglRasterPos2sv = dllRasterPos2sv;
qglRasterPos3d = dllRasterPos3d;
qglRasterPos3dv = dllRasterPos3dv;
qglRasterPos3f = dllRasterPos3f;
qglRasterPos3fv = dllRasterPos3fv;
qglRasterPos3i = dllRasterPos3i;
qglRasterPos3iv = dllRasterPos3iv;
qglRasterPos3s = dllRasterPos3s;
qglRasterPos3sv = dllRasterPos3sv;
qglRasterPos4d = dllRasterPos4d;
qglRasterPos4dv = dllRasterPos4dv;
qglRasterPos4f = dllRasterPos4f;
qglRasterPos4fv = dllRasterPos4fv;
qglRasterPos4i = dllRasterPos4i;
qglRasterPos4iv = dllRasterPos4iv;
qglRasterPos4s = dllRasterPos4s;
qglRasterPos4sv = dllRasterPos4sv;
qglReadBuffer = dllReadBuffer;
qglReadPixels = dllReadPixels;
qglRectd = dllRectd;
qglRectdv = dllRectdv;
qglRectf = dllRectf;
qglRectfv = dllRectfv;
qglRecti = dllRecti;
qglRectiv = dllRectiv;
qglRects = dllRects;
qglRectsv = dllRectsv;
qglRenderMode = dllRenderMode;
qglRotated = dllRotated;
qglRotatef = dllRotatef;
qglScaled = dllScaled;
qglScalef = dllScalef;
qglScissor = dllScissor;
qglSelectBuffer = dllSelectBuffer;
qglShadeModel = dllShadeModel;
qglStencilFunc = dllStencilFunc;
qglStencilMask = dllStencilMask;
qglStencilOp = dllStencilOp;
qglTexCoord1d = dllTexCoord1d;
qglTexCoord1dv = dllTexCoord1dv;
qglTexCoord1f = dllTexCoord1f;
qglTexCoord1fv = dllTexCoord1fv;
qglTexCoord1i = dllTexCoord1i;
qglTexCoord1iv = dllTexCoord1iv;
qglTexCoord1s = dllTexCoord1s;
qglTexCoord1sv = dllTexCoord1sv;
qglTexCoord2d = dllTexCoord2d;
qglTexCoord2dv = dllTexCoord2dv;
qglTexCoord2f = dllTexCoord2f;
qglTexCoord2fv = dllTexCoord2fv;
qglTexCoord2i = dllTexCoord2i;
qglTexCoord2iv = dllTexCoord2iv;
qglTexCoord2s = dllTexCoord2s;
qglTexCoord2sv = dllTexCoord2sv;
qglTexCoord3d = dllTexCoord3d;
qglTexCoord3dv = dllTexCoord3dv;
qglTexCoord3f = dllTexCoord3f;
qglTexCoord3fv = dllTexCoord3fv;
qglTexCoord3i = dllTexCoord3i;
qglTexCoord3iv = dllTexCoord3iv;
qglTexCoord3s = dllTexCoord3s;
qglTexCoord3sv = dllTexCoord3sv;
qglTexCoord4d = dllTexCoord4d;
qglTexCoord4dv = dllTexCoord4dv;
qglTexCoord4f = dllTexCoord4f;
qglTexCoord4fv = dllTexCoord4fv;
qglTexCoord4i = dllTexCoord4i;
qglTexCoord4iv = dllTexCoord4iv;
qglTexCoord4s = dllTexCoord4s;
qglTexCoord4sv = dllTexCoord4sv;
qglTexCoordPointer = dllTexCoordPointer;
qglTexEnvf = dllTexEnvf;
qglTexEnvfv = dllTexEnvfv;
qglTexEnvi = dllTexEnvi;
qglTexEnviv = dllTexEnviv;
qglTexGend = dllTexGend;
qglTexGendv = dllTexGendv;
qglTexGenf = dllTexGenf;
qglTexGenfv = dllTexGenfv;
qglTexGeni = dllTexGeni;
qglTexGeniv = dllTexGeniv;
qglTexImage1D = dllTexImage1D;
qglTexImage2D = dllTexImage2D;
qglTexParameterf = dllTexParameterf;
qglTexParameterfv = dllTexParameterfv;
qglTexParameteri = dllTexParameteri;
qglTexParameteriv = dllTexParameteriv;
qglTexSubImage1D = dllTexSubImage1D;
qglTexSubImage2D = dllTexSubImage2D;
qglTranslated = dllTranslated;
qglTranslatef = dllTranslatef;
qglVertex2d = dllVertex2d;
qglVertex2dv = dllVertex2dv;
qglVertex2f = dllVertex2f;
qglVertex2fv = dllVertex2fv;
qglVertex2i = dllVertex2i;
qglVertex2iv = dllVertex2iv;
qglVertex2s = dllVertex2s;
qglVertex2sv = dllVertex2sv;
qglVertex3d = dllVertex3d;
qglVertex3dv = dllVertex3dv;
qglVertex3f = dllVertex3f;
qglVertex3fv = dllVertex3fv;
qglVertex3i = dllVertex3i;
qglVertex3iv = dllVertex3iv;
qglVertex3s = dllVertex3s;
qglVertex3sv = dllVertex3sv;
qglVertex4d = dllVertex4d;
qglVertex4dv = dllVertex4dv;
qglVertex4f = dllVertex4f;
qglVertex4fv = dllVertex4fv;
qglVertex4i = dllVertex4i;
qglVertex4iv = dllVertex4iv;
qglVertex4s = dllVertex4s;
qglVertex4sv = dllVertex4sv;
qglVertexPointer = dllVertexPointer;
qglViewport = dllViewport;
}
}
void GLimp_LogNewFrame(void) { fprintf(glw_state.log_fp, "*** R_BeginFrame ***\n"); }
#pragma warning(default : 4113 4133 4047)