/*
 * Copyright (C) 1997-2001 Id Software, Inc.
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59
 * Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

/*
 * * QGL_WIN.C *
 *
 * This file implements the operating system binding of GL to QGL function *
 * pointers.  When doing a port of Quake2 you must implement the following *
 * two functions: *
 *
 * QGL_Init() - loads libraries, assigns function pointers, etc. *
 * QGL_Shutdown() - unloads libraries, NULLs function pointers
 */
#include "../ref_gl/gl_local.h"
#include "../unix/glw_unix.h"

#include <dlfcn.h>


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);

void            (APIENTRY * qglPointParameterfEXT) (GLenum param, GLfloat value);
void            (APIENTRY * qglPointParameterfvEXT) (GLenum param, const GLfloat * value);
void            (APIENTRY * qglColorTableEXT) (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);

void            (APIENTRY * qgl3DfxSetPaletteEXT) (GLuint *);
void            (APIENTRY * qglSelectTextureSGIS) (GLenum);
void            (APIENTRY * qglMTexCoord2fSGIS) (GLenum, GLfloat, GLfloat);
void            (APIENTRY * qglActiveTextureARB) (GLenum);
void            (APIENTRY * qglClientActiveTextureARB) (GLenum);
void            (APIENTRY * qglMultiTexCoord3fvARB) (GLenum target, const GLfloat * v);	/* mpo */

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);
}

/*
 * * QGL_Shutdown *
 *
 * Unloads the specified DLL then nulls out all the proc pointers.
 */
void
QGL_Shutdown(void)
{
	if (glw_state.OpenGLLib) {
		dlclose(glw_state.OpenGLLib);
		glw_state.OpenGLLib = NULL;
	}
	glw_state.OpenGLLib = 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;
}

#define GPA( a ) dlsym( glw_state.OpenGLLib, a )

void           *
qwglGetProcAddress(char *symbol)
{
	if (glw_state.OpenGLLib)
		return GPA(symbol);
	return NULL;
}

/*
 * * QGL_Init *
 *
 * This is responsible for binding our qgl function pointers to * the
 * appropriate GL stuff.  In Windows this means doing a * LoadLibrary and a
 * bunch of calls to GetProcAddress.  On other * operating systems we need to
 * do the right thing, whatever that * might be. *
 *
 */

qboolean
QGL_Init(const char *dllname)
{
	/* update 3Dfx gamma irrespective of underlying DLL */
	{
		char		envbuffer [1024];
		float		g;

		g = 2.00 * (0.8 - (vid_gamma->value - 0.5)) + 1.0;
		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.OpenGLLib)
		QGL_Shutdown();

	if ((glw_state.OpenGLLib = dlopen(dllname, RTLD_LAZY)) == 0) {
		char		fn[MAX_OSPATH];
		char           *path;

		/*
		 * ri.Con_Printf(PRINT_ALL, "QGL_Init: Can't load %s from
		 * /etc/ld.so.conf: %s\n",
		 */
		/* dllname, dlerror()); */

		/* try basedir next */
		path = ri.Cvar_Get("basedir", ".", CVAR_NOSET)->string;

		Com_sprintf(fn, sizeof(fn), "%s/%s", path, dllname);

		if ((glw_state.OpenGLLib = dlopen(fn, RTLD_LAZY)) == 0) {
			ri.Con_Printf(PRINT_ALL, "%s\n", dlerror());
			return false;
		}
		Com_Printf("Using %s for OpenGL...\n", fn);
	} else {
		Com_Printf("Using %s for OpenGL...\n", dllname);
	}

	if ((dlopen("libGLU.so", RTLD_LAZY)) == 0) {
		ri.Con_Printf(PRINT_ALL, "%s\n", dlerror());
		return false;
	} else {
		Com_Printf("Opened GLU sucessfully OpenGLU...\n", dllname);
	}

	qglAccum = dllAccum = GPA("glAccum");
	qglAlphaFunc = dllAlphaFunc = GPA("glAlphaFunc");
	qglAreTexturesResident = dllAreTexturesResident = GPA("glAreTexturesResident");
	qglArrayElement = dllArrayElement = GPA("glArrayElement");
	qglBegin = dllBegin = GPA("glBegin");
	qglBindTexture = dllBindTexture = GPA("glBindTexture");
	qglBitmap = dllBitmap = GPA("glBitmap");
	qglBlendFunc = dllBlendFunc = GPA("glBlendFunc");
	qglCallList = dllCallList = GPA("glCallList");
	qglCallLists = dllCallLists = GPA("glCallLists");
	qglClear = dllClear = GPA("glClear");
	qglClearAccum = dllClearAccum = GPA("glClearAccum");
	qglClearColor = dllClearColor = GPA("glClearColor");
	qglClearDepth = dllClearDepth = GPA("glClearDepth");
	qglClearIndex = dllClearIndex = GPA("glClearIndex");
	qglClearStencil = dllClearStencil = GPA("glClearStencil");
	qglClipPlane = dllClipPlane = GPA("glClipPlane");
	qglColor3b = dllColor3b = GPA("glColor3b");
	qglColor3bv = dllColor3bv = GPA("glColor3bv");
	qglColor3d = dllColor3d = GPA("glColor3d");
	qglColor3dv = dllColor3dv = GPA("glColor3dv");
	qglColor3f = dllColor3f = GPA("glColor3f");
	qglColor3fv = dllColor3fv = GPA("glColor3fv");
	qglColor3i = dllColor3i = GPA("glColor3i");
	qglColor3iv = dllColor3iv = GPA("glColor3iv");
	qglColor3s = dllColor3s = GPA("glColor3s");
	qglColor3sv = dllColor3sv = GPA("glColor3sv");
	qglColor3ub = dllColor3ub = GPA("glColor3ub");
	qglColor3ubv = dllColor3ubv = GPA("glColor3ubv");
	qglColor3ui = dllColor3ui = GPA("glColor3ui");
	qglColor3uiv = dllColor3uiv = GPA("glColor3uiv");
	qglColor3us = dllColor3us = GPA("glColor3us");
	qglColor3usv = dllColor3usv = GPA("glColor3usv");
	qglColor4b = dllColor4b = GPA("glColor4b");
	qglColor4bv = dllColor4bv = GPA("glColor4bv");
	qglColor4d = dllColor4d = GPA("glColor4d");
	qglColor4dv = dllColor4dv = GPA("glColor4dv");
	qglColor4f = dllColor4f = GPA("glColor4f");
	qglColor4fv = dllColor4fv = GPA("glColor4fv");
	qglColor4i = dllColor4i = GPA("glColor4i");
	qglColor4iv = dllColor4iv = GPA("glColor4iv");
	qglColor4s = dllColor4s = GPA("glColor4s");
	qglColor4sv = dllColor4sv = GPA("glColor4sv");
	qglColor4ub = dllColor4ub = GPA("glColor4ub");
	qglColor4ubv = dllColor4ubv = GPA("glColor4ubv");
	qglColor4ui = dllColor4ui = GPA("glColor4ui");
	qglColor4uiv = dllColor4uiv = GPA("glColor4uiv");
	qglColor4us = dllColor4us = GPA("glColor4us");
	qglColor4usv = dllColor4usv = GPA("glColor4usv");
	qglColorMask = dllColorMask = GPA("glColorMask");
	qglColorMaterial = dllColorMaterial = GPA("glColorMaterial");
	qglColorPointer = dllColorPointer = GPA("glColorPointer");
	qglCopyPixels = dllCopyPixels = GPA("glCopyPixels");
	qglCopyTexImage1D = dllCopyTexImage1D = GPA("glCopyTexImage1D");
	qglCopyTexImage2D = dllCopyTexImage2D = GPA("glCopyTexImage2D");
	qglCopyTexSubImage1D = dllCopyTexSubImage1D = GPA("glCopyTexSubImage1D");
	qglCopyTexSubImage2D = dllCopyTexSubImage2D = GPA("glCopyTexSubImage2D");
	qglCullFace = dllCullFace = GPA("glCullFace");
	qglDeleteLists = dllDeleteLists = GPA("glDeleteLists");
	qglDeleteTextures = dllDeleteTextures = GPA("glDeleteTextures");
	qglDepthFunc = dllDepthFunc = GPA("glDepthFunc");
	qglDepthMask = dllDepthMask = GPA("glDepthMask");
	qglDepthRange = dllDepthRange = GPA("glDepthRange");
	qglDisable = dllDisable = GPA("glDisable");
	qglDisableClientState = dllDisableClientState = GPA("glDisableClientState");
	qglDrawArrays = dllDrawArrays = GPA("glDrawArrays");
	qglDrawBuffer = dllDrawBuffer = GPA("glDrawBuffer");
	qglDrawElements = dllDrawElements = GPA("glDrawElements");
	qglDrawPixels = dllDrawPixels = GPA("glDrawPixels");
	qglEdgeFlag = dllEdgeFlag = GPA("glEdgeFlag");
	qglEdgeFlagPointer = dllEdgeFlagPointer = GPA("glEdgeFlagPointer");
	qglEdgeFlagv = dllEdgeFlagv = GPA("glEdgeFlagv");
	qglEnable = dllEnable = GPA("glEnable");
	qglEnableClientState = dllEnableClientState = GPA("glEnableClientState");
	qglEnd = dllEnd = GPA("glEnd");
	qglEndList = dllEndList = GPA("glEndList");
	qglEvalCoord1d = dllEvalCoord1d = GPA("glEvalCoord1d");
	qglEvalCoord1dv = dllEvalCoord1dv = GPA("glEvalCoord1dv");
	qglEvalCoord1f = dllEvalCoord1f = GPA("glEvalCoord1f");
	qglEvalCoord1fv = dllEvalCoord1fv = GPA("glEvalCoord1fv");
	qglEvalCoord2d = dllEvalCoord2d = GPA("glEvalCoord2d");
	qglEvalCoord2dv = dllEvalCoord2dv = GPA("glEvalCoord2dv");
	qglEvalCoord2f = dllEvalCoord2f = GPA("glEvalCoord2f");
	qglEvalCoord2fv = dllEvalCoord2fv = GPA("glEvalCoord2fv");
	qglEvalMesh1 = dllEvalMesh1 = GPA("glEvalMesh1");
	qglEvalMesh2 = dllEvalMesh2 = GPA("glEvalMesh2");
	qglEvalPoint1 = dllEvalPoint1 = GPA("glEvalPoint1");
	qglEvalPoint2 = dllEvalPoint2 = GPA("glEvalPoint2");
	qglFeedbackBuffer = dllFeedbackBuffer = GPA("glFeedbackBuffer");
	qglFinish = dllFinish = GPA("glFinish");
	qglFlush = dllFlush = GPA("glFlush");
	qglFogf = dllFogf = GPA("glFogf");
	qglFogfv = dllFogfv = GPA("glFogfv");
	qglFogi = dllFogi = GPA("glFogi");
	qglFogiv = dllFogiv = GPA("glFogiv");
	qglFrontFace = dllFrontFace = GPA("glFrontFace");
	qglFrustum = dllFrustum = GPA("glFrustum");
	qglGenLists = dllGenLists = GPA("glGenLists");
	qglGenTextures = dllGenTextures = GPA("glGenTextures");
	qglGetBooleanv = dllGetBooleanv = GPA("glGetBooleanv");
	qglGetClipPlane = dllGetClipPlane = GPA("glGetClipPlane");
	qglGetDoublev = dllGetDoublev = GPA("glGetDoublev");
	qglGetError = dllGetError = GPA("glGetError");
	qglGetFloatv = dllGetFloatv = GPA("glGetFloatv");
	qglGetIntegerv = dllGetIntegerv = GPA("glGetIntegerv");
	qglGetLightfv = dllGetLightfv = GPA("glGetLightfv");
	qglGetLightiv = dllGetLightiv = GPA("glGetLightiv");
	qglGetMapdv = dllGetMapdv = GPA("glGetMapdv");
	qglGetMapfv = dllGetMapfv = GPA("glGetMapfv");
	qglGetMapiv = dllGetMapiv = GPA("glGetMapiv");
	qglGetMaterialfv = dllGetMaterialfv = GPA("glGetMaterialfv");
	qglGetMaterialiv = dllGetMaterialiv = GPA("glGetMaterialiv");
	qglGetPixelMapfv = dllGetPixelMapfv = GPA("glGetPixelMapfv");
	qglGetPixelMapuiv = dllGetPixelMapuiv = GPA("glGetPixelMapuiv");
	qglGetPixelMapusv = dllGetPixelMapusv = GPA("glGetPixelMapusv");
	qglGetPointerv = dllGetPointerv = GPA("glGetPointerv");
	qglGetPolygonStipple = dllGetPolygonStipple = GPA("glGetPolygonStipple");
	qglGetString = dllGetString = GPA("glGetString");
	qglGetTexEnvfv = dllGetTexEnvfv = GPA("glGetTexEnvfv");
	qglGetTexEnviv = dllGetTexEnviv = GPA("glGetTexEnviv");
	qglGetTexGendv = dllGetTexGendv = GPA("glGetTexGendv");
	qglGetTexGenfv = dllGetTexGenfv = GPA("glGetTexGenfv");
	qglGetTexGeniv = dllGetTexGeniv = GPA("glGetTexGeniv");
	qglGetTexImage = dllGetTexImage = GPA("glGetTexImage");

	/*
	 * Ben Lane 30 March 2005: Fixed a minor Quake 2 bug whereby the next 2 
	 * qgl function pointers were loaded with invalid addresses. Original
	 * code attempted to initialise them with GPA( "glGetLevelParameterfv" )
	 * and GPA( "glGetLevelParameteriv" ) crucially missing the "Tex". 
	 */
	 
	qglGetTexLevelParameterfv = dllGetTexLevelParameterfv = GPA("glGetTexLevelParameterfv");
	qglGetTexLevelParameteriv = dllGetTexLevelParameteriv = GPA("glGetTexLevelParameteriv");
	qglGetTexParameterfv = dllGetTexParameterfv = GPA("glGetTexParameterfv");
	qglGetTexParameteriv = dllGetTexParameteriv = GPA("glGetTexParameteriv");
	qglHint = dllHint = GPA("glHint");
	qglIndexMask = dllIndexMask = GPA("glIndexMask");
	qglIndexPointer = dllIndexPointer = GPA("glIndexPointer");
	qglIndexd = dllIndexd = GPA("glIndexd");
	qglIndexdv = dllIndexdv = GPA("glIndexdv");
	qglIndexf = dllIndexf = GPA("glIndexf");
	qglIndexfv = dllIndexfv = GPA("glIndexfv");
	qglIndexi = dllIndexi = GPA("glIndexi");
	qglIndexiv = dllIndexiv = GPA("glIndexiv");
	qglIndexs = dllIndexs = GPA("glIndexs");
	qglIndexsv = dllIndexsv = GPA("glIndexsv");
	qglIndexub = dllIndexub = GPA("glIndexub");
	qglIndexubv = dllIndexubv = GPA("glIndexubv");
	qglInitNames = dllInitNames = GPA("glInitNames");
	qglInterleavedArrays = dllInterleavedArrays = GPA("glInterleavedArrays");
	qglIsEnabled = dllIsEnabled = GPA("glIsEnabled");
	qglIsList = dllIsList = GPA("glIsList");
	qglIsTexture = dllIsTexture = GPA("glIsTexture");
	qglLightModelf = dllLightModelf = GPA("glLightModelf");
	qglLightModelfv = dllLightModelfv = GPA("glLightModelfv");
	qglLightModeli = dllLightModeli = GPA("glLightModeli");
	qglLightModeliv = dllLightModeliv = GPA("glLightModeliv");
	qglLightf = dllLightf = GPA("glLightf");
	qglLightfv = dllLightfv = GPA("glLightfv");
	qglLighti = dllLighti = GPA("glLighti");
	qglLightiv = dllLightiv = GPA("glLightiv");
	qglLineStipple = dllLineStipple = GPA("glLineStipple");
	qglLineWidth = dllLineWidth = GPA("glLineWidth");
	qglListBase = dllListBase = GPA("glListBase");
	qglLoadIdentity = dllLoadIdentity = GPA("glLoadIdentity");
	qglLoadMatrixd = dllLoadMatrixd = GPA("glLoadMatrixd");
	qglLoadMatrixf = dllLoadMatrixf = GPA("glLoadMatrixf");
	qglLoadName = dllLoadName = GPA("glLoadName");
	qglLogicOp = dllLogicOp = GPA("glLogicOp");
	qglMap1d = dllMap1d = GPA("glMap1d");
	qglMap1f = dllMap1f = GPA("glMap1f");
	qglMap2d = dllMap2d = GPA("glMap2d");
	qglMap2f = dllMap2f = GPA("glMap2f");
	qglMapGrid1d = dllMapGrid1d = GPA("glMapGrid1d");
	qglMapGrid1f = dllMapGrid1f = GPA("glMapGrid1f");
	qglMapGrid2d = dllMapGrid2d = GPA("glMapGrid2d");
	qglMapGrid2f = dllMapGrid2f = GPA("glMapGrid2f");
	qglMaterialf = dllMaterialf = GPA("glMaterialf");
	qglMaterialfv = dllMaterialfv = GPA("glMaterialfv");
	qglMateriali = dllMateriali = GPA("glMateriali");
	qglMaterialiv = dllMaterialiv = GPA("glMaterialiv");
	qglMatrixMode = dllMatrixMode = GPA("glMatrixMode");
	qglMultMatrixd = dllMultMatrixd = GPA("glMultMatrixd");
	qglMultMatrixf = dllMultMatrixf = GPA("glMultMatrixf");
	qglNewList = dllNewList = GPA("glNewList");
	qglNormal3b = dllNormal3b = GPA("glNormal3b");
	qglNormal3bv = dllNormal3bv = GPA("glNormal3bv");
	qglNormal3d = dllNormal3d = GPA("glNormal3d");
	qglNormal3dv = dllNormal3dv = GPA("glNormal3dv");
	qglNormal3f = dllNormal3f = GPA("glNormal3f");
	qglNormal3fv = dllNormal3fv = GPA("glNormal3fv");
	qglNormal3i = dllNormal3i = GPA("glNormal3i");
	qglNormal3iv = dllNormal3iv = GPA("glNormal3iv");
	qglNormal3s = dllNormal3s = GPA("glNormal3s");
	qglNormal3sv = dllNormal3sv = GPA("glNormal3sv");
	qglNormalPointer = dllNormalPointer = GPA("glNormalPointer");
	qglOrtho = dllOrtho = GPA("glOrtho");
	qglPassThrough = dllPassThrough = GPA("glPassThrough");
	qglPixelMapfv = dllPixelMapfv = GPA("glPixelMapfv");
	qglPixelMapuiv = dllPixelMapuiv = GPA("glPixelMapuiv");
	qglPixelMapusv = dllPixelMapusv = GPA("glPixelMapusv");
	qglPixelStoref = dllPixelStoref = GPA("glPixelStoref");
	qglPixelStorei = dllPixelStorei = GPA("glPixelStorei");
	qglPixelTransferf = dllPixelTransferf = GPA("glPixelTransferf");
	qglPixelTransferi = dllPixelTransferi = GPA("glPixelTransferi");
	qglPixelZoom = dllPixelZoom = GPA("glPixelZoom");
	qglPointSize = dllPointSize = GPA("glPointSize");
	qglPolygonMode = dllPolygonMode = GPA("glPolygonMode");
	qglPolygonOffset = dllPolygonOffset = GPA("glPolygonOffset");
	qglPolygonStipple = dllPolygonStipple = GPA("glPolygonStipple");
	qglPopAttrib = dllPopAttrib = GPA("glPopAttrib");
	qglPopClientAttrib = dllPopClientAttrib = GPA("glPopClientAttrib");
	qglPopMatrix = dllPopMatrix = GPA("glPopMatrix");
	qglPopName = dllPopName = GPA("glPopName");
	qglPrioritizeTextures = dllPrioritizeTextures = GPA("glPrioritizeTextures");
	qglPushAttrib = dllPushAttrib = GPA("glPushAttrib");
	qglPushClientAttrib = dllPushClientAttrib = GPA("glPushClientAttrib");
	qglPushMatrix = dllPushMatrix = GPA("glPushMatrix");
	qglPushName = dllPushName = GPA("glPushName");
	qglRasterPos2d = dllRasterPos2d = GPA("glRasterPos2d");
	qglRasterPos2dv = dllRasterPos2dv = GPA("glRasterPos2dv");
	qglRasterPos2f = dllRasterPos2f = GPA("glRasterPos2f");
	qglRasterPos2fv = dllRasterPos2fv = GPA("glRasterPos2fv");
	qglRasterPos2i = dllRasterPos2i = GPA("glRasterPos2i");
	qglRasterPos2iv = dllRasterPos2iv = GPA("glRasterPos2iv");
	qglRasterPos2s = dllRasterPos2s = GPA("glRasterPos2s");
	qglRasterPos2sv = dllRasterPos2sv = GPA("glRasterPos2sv");
	qglRasterPos3d = dllRasterPos3d = GPA("glRasterPos3d");
	qglRasterPos3dv = dllRasterPos3dv = GPA("glRasterPos3dv");
	qglRasterPos3f = dllRasterPos3f = GPA("glRasterPos3f");
	qglRasterPos3fv = dllRasterPos3fv = GPA("glRasterPos3fv");
	qglRasterPos3i = dllRasterPos3i = GPA("glRasterPos3i");
	qglRasterPos3iv = dllRasterPos3iv = GPA("glRasterPos3iv");
	qglRasterPos3s = dllRasterPos3s = GPA("glRasterPos3s");
	qglRasterPos3sv = dllRasterPos3sv = GPA("glRasterPos3sv");
	qglRasterPos4d = dllRasterPos4d = GPA("glRasterPos4d");
	qglRasterPos4dv = dllRasterPos4dv = GPA("glRasterPos4dv");
	qglRasterPos4f = dllRasterPos4f = GPA("glRasterPos4f");
	qglRasterPos4fv = dllRasterPos4fv = GPA("glRasterPos4fv");
	qglRasterPos4i = dllRasterPos4i = GPA("glRasterPos4i");
	qglRasterPos4iv = dllRasterPos4iv = GPA("glRasterPos4iv");
	qglRasterPos4s = dllRasterPos4s = GPA("glRasterPos4s");
	qglRasterPos4sv = dllRasterPos4sv = GPA("glRasterPos4sv");
	qglReadBuffer = dllReadBuffer = GPA("glReadBuffer");
	qglReadPixels = dllReadPixels = GPA("glReadPixels");
	qglRectd = dllRectd = GPA("glRectd");
	qglRectdv = dllRectdv = GPA("glRectdv");
	qglRectf = dllRectf = GPA("glRectf");
	qglRectfv = dllRectfv = GPA("glRectfv");
	qglRecti = dllRecti = GPA("glRecti");
	qglRectiv = dllRectiv = GPA("glRectiv");
	qglRects = dllRects = GPA("glRects");
	qglRectsv = dllRectsv = GPA("glRectsv");
	qglRenderMode = dllRenderMode = GPA("glRenderMode");
	qglRotated = dllRotated = GPA("glRotated");
	qglRotatef = dllRotatef = GPA("glRotatef");
	qglScaled = dllScaled = GPA("glScaled");
	qglScalef = dllScalef = GPA("glScalef");
	qglScissor = dllScissor = GPA("glScissor");
	qglSelectBuffer = dllSelectBuffer = GPA("glSelectBuffer");
	qglShadeModel = dllShadeModel = GPA("glShadeModel");
	qglStencilFunc = dllStencilFunc = GPA("glStencilFunc");
	qglStencilMask = dllStencilMask = GPA("glStencilMask");
	qglStencilOp = dllStencilOp = GPA("glStencilOp");
	qglTexCoord1d = dllTexCoord1d = GPA("glTexCoord1d");
	qglTexCoord1dv = dllTexCoord1dv = GPA("glTexCoord1dv");
	qglTexCoord1f = dllTexCoord1f = GPA("glTexCoord1f");
	qglTexCoord1fv = dllTexCoord1fv = GPA("glTexCoord1fv");
	qglTexCoord1i = dllTexCoord1i = GPA("glTexCoord1i");
	qglTexCoord1iv = dllTexCoord1iv = GPA("glTexCoord1iv");
	qglTexCoord1s = dllTexCoord1s = GPA("glTexCoord1s");
	qglTexCoord1sv = dllTexCoord1sv = GPA("glTexCoord1sv");
	qglTexCoord2d = dllTexCoord2d = GPA("glTexCoord2d");
	qglTexCoord2dv = dllTexCoord2dv = GPA("glTexCoord2dv");
	qglTexCoord2f = dllTexCoord2f = GPA("glTexCoord2f");
	qglTexCoord2fv = dllTexCoord2fv = GPA("glTexCoord2fv");
	qglTexCoord2i = dllTexCoord2i = GPA("glTexCoord2i");
	qglTexCoord2iv = dllTexCoord2iv = GPA("glTexCoord2iv");
	qglTexCoord2s = dllTexCoord2s = GPA("glTexCoord2s");
	qglTexCoord2sv = dllTexCoord2sv = GPA("glTexCoord2sv");
	qglTexCoord3d = dllTexCoord3d = GPA("glTexCoord3d");
	qglTexCoord3dv = dllTexCoord3dv = GPA("glTexCoord3dv");
	qglTexCoord3f = dllTexCoord3f = GPA("glTexCoord3f");
	qglTexCoord3fv = dllTexCoord3fv = GPA("glTexCoord3fv");
	qglTexCoord3i = dllTexCoord3i = GPA("glTexCoord3i");
	qglTexCoord3iv = dllTexCoord3iv = GPA("glTexCoord3iv");
	qglTexCoord3s = dllTexCoord3s = GPA("glTexCoord3s");
	qglTexCoord3sv = dllTexCoord3sv = GPA("glTexCoord3sv");
	qglTexCoord4d = dllTexCoord4d = GPA("glTexCoord4d");
	qglTexCoord4dv = dllTexCoord4dv = GPA("glTexCoord4dv");
	qglTexCoord4f = dllTexCoord4f = GPA("glTexCoord4f");
	qglTexCoord4fv = dllTexCoord4fv = GPA("glTexCoord4fv");
	qglTexCoord4i = dllTexCoord4i = GPA("glTexCoord4i");
	qglTexCoord4iv = dllTexCoord4iv = GPA("glTexCoord4iv");
	qglTexCoord4s = dllTexCoord4s = GPA("glTexCoord4s");
	qglTexCoord4sv = dllTexCoord4sv = GPA("glTexCoord4sv");
	qglTexCoordPointer = dllTexCoordPointer = GPA("glTexCoordPointer");
	qglTexEnvf = dllTexEnvf = GPA("glTexEnvf");
	qglTexEnvfv = dllTexEnvfv = GPA("glTexEnvfv");
	qglTexEnvi = dllTexEnvi = GPA("glTexEnvi");
	qglTexEnviv = dllTexEnviv = GPA("glTexEnviv");
	qglTexGend = dllTexGend = GPA("glTexGend");
	qglTexGendv = dllTexGendv = GPA("glTexGendv");
	qglTexGenf = dllTexGenf = GPA("glTexGenf");
	qglTexGenfv = dllTexGenfv = GPA("glTexGenfv");
	qglTexGeni = dllTexGeni = GPA("glTexGeni");
	qglTexGeniv = dllTexGeniv = GPA("glTexGeniv");
	qglTexImage1D = dllTexImage1D = GPA("glTexImage1D");
	qglTexImage2D = dllTexImage2D = GPA("glTexImage2D");
	qglTexParameterf = dllTexParameterf = GPA("glTexParameterf");
	qglTexParameterfv = dllTexParameterfv = GPA("glTexParameterfv");
	qglTexParameteri = dllTexParameteri = GPA("glTexParameteri");
	qglTexParameteriv = dllTexParameteriv = GPA("glTexParameteriv");
	qglTexSubImage1D = dllTexSubImage1D = GPA("glTexSubImage1D");
	qglTexSubImage2D = dllTexSubImage2D = GPA("glTexSubImage2D");
	qglTranslated = dllTranslated = GPA("glTranslated");
	qglTranslatef = dllTranslatef = GPA("glTranslatef");
	qglVertex2d = dllVertex2d = GPA("glVertex2d");
	qglVertex2dv = dllVertex2dv = GPA("glVertex2dv");
	qglVertex2f = dllVertex2f = GPA("glVertex2f");
	qglVertex2fv = dllVertex2fv = GPA("glVertex2fv");
	qglVertex2i = dllVertex2i = GPA("glVertex2i");
	qglVertex2iv = dllVertex2iv = GPA("glVertex2iv");
	qglVertex2s = dllVertex2s = GPA("glVertex2s");
	qglVertex2sv = dllVertex2sv = GPA("glVertex2sv");
	qglVertex3d = dllVertex3d = GPA("glVertex3d");
	qglVertex3dv = dllVertex3dv = GPA("glVertex3dv");
	qglVertex3f = dllVertex3f = GPA("glVertex3f");
	qglVertex3fv = dllVertex3fv = GPA("glVertex3fv");
	qglVertex3i = dllVertex3i = GPA("glVertex3i");
	qglVertex3iv = dllVertex3iv = GPA("glVertex3iv");
	qglVertex3s = dllVertex3s = GPA("glVertex3s");
	qglVertex3sv = dllVertex3sv = GPA("glVertex3sv");
	qglVertex4d = dllVertex4d = GPA("glVertex4d");
	qglVertex4dv = dllVertex4dv = GPA("glVertex4dv");
	qglVertex4f = dllVertex4f = GPA("glVertex4f");
	qglVertex4fv = dllVertex4fv = GPA("glVertex4fv");
	qglVertex4i = dllVertex4i = GPA("glVertex4i");
	qglVertex4iv = dllVertex4iv = GPA("glVertex4iv");
	qglVertex4s = dllVertex4s = GPA("glVertex4s");
	qglVertex4sv = dllVertex4sv = GPA("glVertex4sv");
	qglVertexPointer = dllVertexPointer = GPA("glVertexPointer");
	qglViewport = dllViewport = GPA("glViewport");

	qglLockArraysEXT = 0;
	qglUnlockArraysEXT = 0;
	qglPointParameterfEXT = 0;
	qglPointParameterfvEXT = 0;
	qglColorTableEXT = 0;
	qgl3DfxSetPaletteEXT = 0;
	qglSelectTextureSGIS = 0;
	qglMTexCoord2fSGIS = 0;
	qglActiveTextureARB = 0;
	qglClientActiveTextureARB = 0;

	return true;
}

void
GLimp_EnableLogging(qboolean 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");
}
