radiant/qgl.c

   1 /*
   2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 /*
  23 ** QGL_WIN.C
  24 **
  25 ** This file implements the operating system binding of GL to QGL function
  26 ** pointers.  When doing a port of Quake2 you must implement the following
  27 ** two functions:
  28 **
  29 ** QGL_Init() - loads libraries, assigns function pointers, etc.
  30 ** QGL_Shutdown() - unloads libraries, NULLs function pointers
  31 */
  32
  33 /*
  34  * This causes glDisable(), glEnable(), glCullFace() and glPolygonMode() to
  35  * be wrapped in order to get around a bug in ATI's FireGL drivers.
  36  */
  37 #include <stdio.h>
  38 #include <float.h>
  39 #include <string.h>
  40 #if defined (__linux__) || defined (__APPLE__)
  41 #include <dlfcn.h>
  42 #endif
  43
  44 #ifdef _WIN32
  45 #include <windows.h>
  46 #endif
  47
  48 #include "qgl.h"
  49 void Sys_Printf(const char *format, ...);
  50
  51 #ifdef _WIN32
  52 HMODULE g_hGLDLL = NULL;
  53
  54 #pragma warning (disable : 4113 4133 4047 4018 )
  55
  56 int   ( WINAPI * qwglChoosePixelFormat )(HDC, CONST PIXELFORMATDESCRIPTOR *);
  57 int   ( WINAPI * qwglDescribePixelFormat) (HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
  58 int   ( WINAPI * qwglGetPixelFormat)(HDC);
  59 BOOL  ( WINAPI * qwglSetPixelFormat)(HDC, int, CONST PIXELFORMATDESCRIPTOR *);
  60 BOOL  ( WINAPI * qwglSwapBuffers)(HDC);
  61
  62 BOOL  ( WINAPI * qwglCopyContext)(HGLRC, HGLRC, UINT);
  63 HGLRC ( WINAPI * qwglCreateContext)(HDC);
  64 HGLRC ( WINAPI * qwglCreateLayerContext)(HDC, int);
  65 BOOL  ( WINAPI * qwglDeleteContext)(HGLRC);
  66 HGLRC ( WINAPI * qwglGetCurrentContext)(VOID);
  67 HDC   ( WINAPI * qwglGetCurrentDC)(VOID);
  68 PROC  ( WINAPI * qwglGetProcAddress)(LPCSTR);
  69 BOOL  ( WINAPI * qwglMakeCurrent)(HDC, HGLRC);
  70 BOOL  ( WINAPI * qwglShareLists)(HGLRC, HGLRC);
  71 BOOL  ( WINAPI * qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
  72
  73 BOOL  ( WINAPI * qwglUseFontOutlines)(HDC, DWORD, DWORD, DWORD, FLOAT,
  74                                       FLOAT, int, LPGLYPHMETRICSFLOAT);
  75
  76 BOOL ( WINAPI * qwglDescribeLayerPlane)(HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR);
  77 int  ( WINAPI * qwglSetLayerPaletteEntries)(HDC, int, int, int, CONST COLORREF *);
  78 int  ( WINAPI * qwglGetLayerPaletteEntries)(HDC, int, int, int, COLORREF *);
  79 BOOL ( WINAPI * qwglRealizeLayerPalette)(HDC, int, BOOL);
  80 BOOL ( WINAPI * qwglSwapLayerBuffers)(HDC, UINT);
  81
  82 BOOL ( WINAPI * qwglGetDeviceGammaRampEXT)( unsigned char *, unsigned char *, unsigned char * );
  83 BOOL ( WINAPI * qwglSetDeviceGammaRampEXT)( const unsigned char *, const unsigned char *,
  84                                             const unsigned char * );
  85 BOOL ( WINAPI * qwglSwapIntervalEXT)( int interval );
  86
  87 #else
  88 #define WINAPI
  89 #endif
  90
  91 #if defined (__linux__) || defined (__APPLE__)
  92 void* g_hGLDLL;
  93
  94 XVisualInfo* (*qglXChooseVisual)(Display *dpy, int screen, int *attribList);
  95 GLXContext   (*qglXCreateContext)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
  96 void         (*qglXDestroyContext)(Display *dpy, GLXContext ctx);
  97 Bool         (*qglXMakeCurrent)(Display *dpy, GLXDrawable drawable, GLXContext ctx);
  98 void         (*qglXCopyContext)(Display *dpy, GLXContext src, GLXContext dst, GLuint mask);
  99 void         (*qglXSwapBuffers)( Display *dpy, GLXDrawable drawable );
 100 GLXPixmap    (*qglXCreateGLXPixmap)( Display *dpy, XVisualInfo *visual, Pixmap pixmap );
 101 void         (*qglXDestroyGLXPixmap)( Display *dpy, GLXPixmap pixmap );
 102 Bool         (*qglXQueryExtension)( Display *dpy, int *errorb, int *event );
 103 Bool         (*qglXQueryVersion)( Display *dpy, int *maj, int *min );
 104 Bool         (*qglXIsDirect)( Display *dpy, GLXContext ctx );
 105 int          (*qglXGetConfig)( Display *dpy, XVisualInfo *visual, int attrib, int *value );
 106 GLXContext   (*qglXGetCurrentContext)( void );
 107 GLXDrawable  (*qglXGetCurrentDrawable)( void );
 108 void         (*qglXWaitGL)( void );
 109 void         (*qglXWaitX)( void );
 110 void         (*qglXUseXFont)( Font font, int first, int count, int list );
 111 void*        (*qglXGetProcAddressARB) (const GLubyte *procName);
 112 #endif
 113
 114 void ( APIENTRY * qglAccum )(GLenum op, GLfloat value);
 115 void ( APIENTRY * qglAlphaFunc )(GLenum func, GLclampf ref);
 116 GLboolean ( APIENTRY * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
 117 void ( APIENTRY * qglArrayElement )(GLint i);
 118 void ( APIENTRY * qglBegin )(GLenum mode);
 119 void ( APIENTRY * qglBindTexture )(GLenum target, GLuint texture);
 120 void ( APIENTRY * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
 121 void ( APIENTRY * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
 122 void ( APIENTRY * qglCallList )(GLuint list);
 123 void ( APIENTRY * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
 124 void ( APIENTRY * qglClear )(GLbitfield mask);
 125 void ( APIENTRY * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
 126 void ( APIENTRY * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
 127 void ( APIENTRY * qglClearDepth )(GLclampd depth);
 128 void ( APIENTRY * qglClearIndex )(GLfloat c);
 129 void ( APIENTRY * qglClearStencil )(GLint s);
 130 void ( APIENTRY * qglClipPlane )(GLenum plane, const GLdouble *equation);
 131 void ( APIENTRY * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
 132 void ( APIENTRY * qglColor3bv )(const GLbyte *v);
 133 void ( APIENTRY * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
 134 void ( APIENTRY * qglColor3dv )(const GLdouble *v);
 135 void ( APIENTRY * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
 136 void ( APIENTRY * qglColor3fv )(const GLfloat *v);
 137 void ( APIENTRY * qglColor3i )(GLint red, GLint green, GLint blue);
 138 void ( APIENTRY * qglColor3iv )(const GLint *v);
 139 void ( APIENTRY * qglColor3s )(GLshort red, GLshort green, GLshort blue);
 140 void ( APIENTRY * qglColor3sv )(const GLshort *v);
 141 void ( APIENTRY * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
 142 void ( APIENTRY * qglColor3ubv )(const GLubyte *v);
 143 void ( APIENTRY * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
 144 void ( APIENTRY * qglColor3uiv )(const GLuint *v);
 145 void ( APIENTRY * qglColor3us )(GLushort red, GLushort green, GLushort blue);
 146 void ( APIENTRY * qglColor3usv )(const GLushort *v);
 147 void ( APIENTRY * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
 148 void ( APIENTRY * qglColor4bv )(const GLbyte *v);
 149 void ( APIENTRY * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
 150 void ( APIENTRY * qglColor4dv )(const GLdouble *v);
 151 void ( APIENTRY * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
 152 void ( APIENTRY * qglColor4fv )(const GLfloat *v);
 153 void ( APIENTRY * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
 154 void ( APIENTRY * qglColor4iv )(const GLint *v);
 155 void ( APIENTRY * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
 156 void ( APIENTRY * qglColor4sv )(const GLshort *v);
 157 void ( APIENTRY * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
 158 void ( APIENTRY * qglColor4ubv )(const GLubyte *v);
 159 void ( APIENTRY * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
 160 void ( APIENTRY * qglColor4uiv )(const GLuint *v);
 161 void ( APIENTRY * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
 162 void ( APIENTRY * qglColor4usv )(const GLushort *v);
 163 void ( APIENTRY * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
 164 void ( APIENTRY * qglColorMaterial )(GLenum face, GLenum mode);
 165 void ( APIENTRY * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
 166 void ( APIENTRY * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
 167 void ( APIENTRY * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
 168 void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
 169 void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
 170 void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
 171 void ( APIENTRY * qglCullFace )(GLenum mode);
 172 void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);
 173 void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);
 174 void ( APIENTRY * qglDepthFunc )(GLenum func);
 175 void ( APIENTRY * qglDepthMask )(GLboolean flag);
 176 void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);
 177 void ( APIENTRY * qglDisable )(GLenum cap);
 178 void ( APIENTRY * qglDisableClientState )(GLenum array);
 179 void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
 180 void ( APIENTRY * qglDrawBuffer )(GLenum mode);
 181 void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
 182 void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
 183 void ( APIENTRY * qglEdgeFlag )(GLboolean flag);
 184 void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
 185 void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);
 186 void ( APIENTRY * qglEnable )(GLenum cap);
 187 void ( APIENTRY * qglEnableClientState )(GLenum array);
 188 void ( APIENTRY * qglEnd )(void);
 189 void ( APIENTRY * qglEndList )(void);
 190 void ( APIENTRY * qglEvalCoord1d )(GLdouble u);
 191 void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);
 192 void ( APIENTRY * qglEvalCoord1f )(GLfloat u);
 193 void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);
 194 void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);
 195 void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);
 196 void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);
 197 void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);
 198 void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
 199 void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
 200 void ( APIENTRY * qglEvalPoint1 )(GLint i);
 201 void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);
 202 void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
 203 void ( APIENTRY * qglFinish )(void);
 204 void ( APIENTRY * qglFlush )(void);
 205 void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);
 206 void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);
 207 void ( APIENTRY * qglFogi )(GLenum pname, GLint param);
 208 void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);
 209 void ( APIENTRY * qglFrontFace )(GLenum mode);
 210 void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
 211 GLuint ( APIENTRY * qglGenLists )(GLsizei range);
 212 void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);
 213 void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);
 214 void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);
 215 void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);
 216 GLenum ( APIENTRY * qglGetError )(void);
 217 void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);
 218 void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);
 219 void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
 220 void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
 221 void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
 222 void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
 223 void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
 224 void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
 225 void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
 226 void ( APIENTRY * qglGetPixelMapfv )(GLenum map, GLfloat *values);
 227 void ( APIENTRY * qglGetPixelMapuiv )(GLenum map, GLuint *values);
 228 void ( APIENTRY * qglGetPixelMapusv )(GLenum map, GLushort *values);
 229 void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);
 230 void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);
 231 const GLubyte * ( APIENTRY * qglGetString )(GLenum name);
 232 void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
 233 void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
 234 void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
 235 void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
 236 void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
 237 void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
 238 void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
 239 void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
 240 void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
 241 void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
 242 void ( APIENTRY * qglHint )(GLenum target, GLenum mode);
 243 void ( APIENTRY * qglIndexMask )(GLuint mask);
 244 void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
 245 void ( APIENTRY * qglIndexd )(GLdouble c);
 246 void ( APIENTRY * qglIndexdv )(const GLdouble *c);
 247 void ( APIENTRY * qglIndexf )(GLfloat c);
 248 void ( APIENTRY * qglIndexfv )(const GLfloat *c);
 249 void ( APIENTRY * qglIndexi )(GLint c);
 250 void ( APIENTRY * qglIndexiv )(const GLint *c);
 251 void ( APIENTRY * qglIndexs )(GLshort c);
 252 void ( APIENTRY * qglIndexsv )(const GLshort *c);
 253 void ( APIENTRY * qglIndexub )(GLubyte c);
 254 void ( APIENTRY * qglIndexubv )(const GLubyte *c);
 255 void ( APIENTRY * qglInitNames )(void);
 256 void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
 257 GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);
 258 GLboolean ( APIENTRY * qglIsList )(GLuint list);
 259 GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);
 260 void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);
 261 void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);
 262 void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);
 263 void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);
 264 void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);
 265 void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
 266 void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);
 267 void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
 268 void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);
 269 void ( APIENTRY * qglLineWidth )(GLfloat width);
 270 void ( APIENTRY * qglListBase )(GLuint base);
 271 void ( APIENTRY * qglLoadIdentity )(void);
 272 void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);
 273 void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);
 274 void ( APIENTRY * qglLoadName )(GLuint name);
 275 void ( APIENTRY * qglLogicOp )(GLenum opcode);
 276 void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
 277 void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
 278 void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
 279 void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
 280 void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
 281 void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
 282 void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
 283 void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
 284 void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
 285 void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
 286 void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);
 287 void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
 288 void ( APIENTRY * qglMatrixMode )(GLenum mode);
 289 void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);
 290 void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);
 291 void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);
 292 void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
 293 void ( APIENTRY * qglNormal3bv )(const GLbyte *v);
 294 void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
 295 void ( APIENTRY * qglNormal3dv )(const GLdouble *v);
 296 void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
 297 void ( APIENTRY * qglNormal3fv )(const GLfloat *v);
 298 void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);
 299 void ( APIENTRY * qglNormal3iv )(const GLint *v);
 300 void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
 301 void ( APIENTRY * qglNormal3sv )(const GLshort *v);
 302 void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
 303 void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
 304 void ( APIENTRY * qglPassThrough )(GLfloat token);
 305 void ( APIENTRY * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
 306 void ( APIENTRY * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
 307 void ( APIENTRY * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
 308 void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);
 309 void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);
 310 void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);
 311 void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);
 312 void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
 313 void ( APIENTRY * qglPointSize )(GLfloat size);
 314 void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);
 315 void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);
 316 void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);
 317 void ( APIENTRY * qglPopAttrib )(void);
 318 void ( APIENTRY * qglPopClientAttrib )(void);
 319 void ( APIENTRY * qglPopMatrix )(void);
 320 void ( APIENTRY * qglPopName )(void);
 321 void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
 322 void ( APIENTRY * qglPushAttrib )(GLbitfield mask);
 323 void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);
 324 void ( APIENTRY * qglPushMatrix )(void);
 325 void ( APIENTRY * qglPushName )(GLuint name);
 326 void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);
 327 void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);
 328 void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);
 329 void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);
 330 void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);
 331 void ( APIENTRY * qglRasterPos2iv )(const GLint *v);
 332 void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);
 333 void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);
 334 void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
 335 void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);
 336 void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
 337 void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);
 338 void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);
 339 void ( APIENTRY * qglRasterPos3iv )(const GLint *v);
 340 void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
 341 void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);
 342 void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
 343 void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);
 344 void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 345 void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);
 346 void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
 347 void ( APIENTRY * qglRasterPos4iv )(const GLint *v);
 348 void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
 349 void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);
 350 void ( APIENTRY * qglReadBuffer )(GLenum mode);
 351 void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
 352 void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
 353 void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
 354 void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
 355 void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
 356 void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
 357 void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);
 358 void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
 359 void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);
 360 GLint ( APIENTRY * qglRenderMode )(GLenum mode);
 361 void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
 362 void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
 363 void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
 364 void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
 365 void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
 366 void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);
 367 void ( APIENTRY * qglShadeModel )(GLenum mode);
 368 void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
 369 void ( APIENTRY * qglStencilMask )(GLuint mask);
 370 void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
 371 void ( APIENTRY * qglTexCoord1d )(GLdouble s);
 372 void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);
 373 void ( APIENTRY * qglTexCoord1f )(GLfloat s);
 374 void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);
 375 void ( APIENTRY * qglTexCoord1i )(GLint s);
 376 void ( APIENTRY * qglTexCoord1iv )(const GLint *v);
 377 void ( APIENTRY * qglTexCoord1s )(GLshort s);
 378 void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);
 379 void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);
 380 void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);
 381 void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);
 382 void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);
 383 void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);
 384 void ( APIENTRY * qglTexCoord2iv )(const GLint *v);
 385 void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);
 386 void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);
 387 void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
 388 void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);
 389 void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
 390 void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);
 391 void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);
 392 void ( APIENTRY * qglTexCoord3iv )(const GLint *v);
 393 void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
 394 void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);
 395 void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
 396 void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);
 397 void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
 398 void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);
 399 void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
 400 void ( APIENTRY * qglTexCoord4iv )(const GLint *v);
 401 void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
 402 void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);
 403 void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
 404 void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
 405 void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
 406 void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
 407 void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
 408 void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
 409 void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
 410 void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
 411 void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
 412 void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
 413 void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
 414 void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
 415 void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
 416 void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
 417 void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
 418 void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
 419 void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
 420 void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
 421 void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
 422 void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
 423 void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
 424 void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);
 425 void ( APIENTRY * qglVertex2dv )(const GLdouble *v);
 426 void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);
 427 void ( APIENTRY * qglVertex2fv )(const GLfloat *v);
 428 void ( APIENTRY * qglVertex2i )(GLint x, GLint y);
 429 void ( APIENTRY * qglVertex2iv )(const GLint *v);
 430 void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);
 431 void ( APIENTRY * qglVertex2sv )(const GLshort *v);
 432 void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
 433 void ( APIENTRY * qglVertex3dv )(const GLdouble *v);
 434 void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
 435 void ( APIENTRY * qglVertex3fv )(const GLfloat *v);
 436 void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);
 437 void ( APIENTRY * qglVertex3iv )(const GLint *v);
 438 void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);
 439 void ( APIENTRY * qglVertex3sv )(const GLshort *v);
 440 void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
 441 void ( APIENTRY * qglVertex4dv )(const GLdouble *v);
 442 void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 443 void ( APIENTRY * qglVertex4fv )(const GLfloat *v);
 444 void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
 445 void ( APIENTRY * qglVertex4iv )(const GLint *v);
 446 void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
 447 void ( APIENTRY * qglVertex4sv )(const GLshort *v);
 448 void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
 449 void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
 450
 451 void ( APIENTRY * qglPointParameterfEXT)( GLenum param, GLfloat value );
 452 void ( APIENTRY * qglPointParameterfvEXT)( GLenum param, const GLfloat *value );
 453 void ( APIENTRY * qglColorTableEXT)( int, int, int, int, int, const void * );
 454 void ( APIENTRY * qglSelectTextureSGIS)( GLenum );
 455 void ( APIENTRY * qglMTexCoord2fSGIS)( GLenum, GLfloat, GLfloat );
 456
 457 void ( APIENTRY * qglActiveTextureARB) (GLenum texture);
 458 void ( APIENTRY * qglClientActiveTextureARB) (GLenum texture);
 459 void ( APIENTRY * qglMultiTexCoord1dARB) (GLenum target, GLdouble s);
 460 void ( APIENTRY * qglMultiTexCoord1dvARB) (GLenum target, const GLdouble *v);
 461 void ( APIENTRY * qglMultiTexCoord1fARB) (GLenum target, GLfloat s);
 462 void ( APIENTRY * qglMultiTexCoord1fvARB) (GLenum target, const GLfloat *v);
 463 void ( APIENTRY * qglMultiTexCoord1iARB) (GLenum target, GLint s);
 464 void ( APIENTRY * qglMultiTexCoord1ivARB) (GLenum target, const GLint *v);
 465 void ( APIENTRY * qglMultiTexCoord1sARB) (GLenum target, GLshort s);
 466 void ( APIENTRY * qglMultiTexCoord1svARB) (GLenum target, const GLshort *v);
 467 void ( APIENTRY * qglMultiTexCoord2dARB) (GLenum target, GLdouble s);
 468 void ( APIENTRY * qglMultiTexCoord2dvARB) (GLenum target, const GLdouble *v);
 469 void ( APIENTRY * qglMultiTexCoord2fARB) (GLenum target, GLfloat s);
 470 void ( APIENTRY * qglMultiTexCoord2fvARB) (GLenum target, const GLfloat *v);
 471 void ( APIENTRY * qglMultiTexCoord2iARB) (GLenum target, GLint s);
 472 void ( APIENTRY * qglMultiTexCoord2ivARB) (GLenum target, const GLint *v);
 473 void ( APIENTRY * qglMultiTexCoord2sARB) (GLenum target, GLshort s);
 474 void ( APIENTRY * qglMultiTexCoord2svARB) (GLenum target, const GLshort *v);
 475 void ( APIENTRY * qglMultiTexCoord3dARB) (GLenum target, GLdouble s);
 476 void ( APIENTRY * qglMultiTexCoord3dvARB) (GLenum target, const GLdouble *v);
 477 void ( APIENTRY * qglMultiTexCoord3fARB) (GLenum target, GLfloat s);
 478 void ( APIENTRY * qglMultiTexCoord3fvARB) (GLenum target, const GLfloat *v);
 479 void ( APIENTRY * qglMultiTexCoord3iARB) (GLenum target, GLint s);
 480 void ( APIENTRY * qglMultiTexCoord3ivARB) (GLenum target, const GLint *v);
 481 void ( APIENTRY * qglMultiTexCoord3sARB) (GLenum target, GLshort s);
 482 void ( APIENTRY * qglMultiTexCoord3svARB) (GLenum target, const GLshort *v);
 483 void ( APIENTRY * qglMultiTexCoord4dARB) (GLenum target, GLdouble s);
 484 void ( APIENTRY * qglMultiTexCoord4dvARB) (GLenum target, const GLdouble *v);
 485 void ( APIENTRY * qglMultiTexCoord4fARB) (GLenum target, GLfloat s);
 486 void ( APIENTRY * qglMultiTexCoord4fvARB) (GLenum target, const GLfloat *v);
 487 void ( APIENTRY * qglMultiTexCoord4iARB) (GLenum target, GLint s);
 488 void ( APIENTRY * qglMultiTexCoord4ivARB) (GLenum target, const GLint *v);
 489 void ( APIENTRY * qglMultiTexCoord4sARB) (GLenum target, GLshort s);
 490 void ( APIENTRY * qglMultiTexCoord4svARB) (GLenum target, const GLshort *v);
 491
 492 // glu stuff
 493 void (APIENTRY * qgluPerspective) (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);
 494
 495 // added for plugins
 496 void (APIENTRY * qgluLookAt)(
 497   GLdouble eyex,
 498   GLdouble eyey,
 499   GLdouble eyez,
 500   GLdouble centerx,
 501   GLdouble centery,
 502   GLdouble centerz,
 503   GLdouble upx,
 504   GLdouble upy,
 505   GLdouble upz);
 506 const GLubyte* (APIENTRY * qgluErrorString) (GLenum errCode );
 507
 508 #ifdef ATIHACK_812
 509 void ( APIENTRY * qglCullFace_real )(GLenum mode);
 510 void ( APIENTRY * qglDisable_real )(GLenum cap);
 511 void ( APIENTRY * qglEnable_real )(GLenum cap);
 512 void ( APIENTRY * qglPolygonMode_real )(GLenum face, GLenum mode);
 513 #endif
 514
 515 /*
 516 ** QGL_Shutdown
 517 **
 518 ** Unloads the specified DLL then nulls out all the proc pointers.
 519 */
 520 void QGL_Shutdown()
 521 {
 522   Sys_Printf("Shutting down GL ...");
 523
 524   if (g_hGLDLL)
 525   {
 526 #ifdef _WIN32
 527     FreeLibrary(g_hGLDLL);
 528 #endif
 529
 530 #if defined (__linux__) || defined (__APPLE__)
 531     dlclose (g_hGLDLL);
 532 #endif
 533
 534     g_hGLDLL = NULL;
 535   }
 536
 537   Sys_Printf("Done.\n");
 538
 539   qglAccum                     = NULL;
 540   qglAlphaFunc                 = NULL;
 541   qglAreTexturesResident       = NULL;
 542   qglArrayElement              = NULL;
 543   qglBegin                     = NULL;
 544   qglBindTexture               = NULL;
 545   qglBitmap                    = NULL;
 546   qglBlendFunc                 = NULL;
 547   qglCallList                  = NULL;
 548   qglCallLists                 = NULL;
 549   qglClear                     = NULL;
 550   qglClearAccum                = NULL;
 551   qglClearColor                = NULL;
 552   qglClearDepth                = NULL;
 553   qglClearIndex                = NULL;
 554   qglClearStencil              = NULL;
 555   qglClipPlane                 = NULL;
 556   qglColor3b                   = NULL;
 557   qglColor3bv                  = NULL;
 558   qglColor3d                   = NULL;
 559   qglColor3dv                  = NULL;
 560   qglColor3f                   = NULL;
 561   qglColor3fv                  = NULL;
 562   qglColor3i                   = NULL;
 563   qglColor3iv                  = NULL;
 564   qglColor3s                   = NULL;
 565   qglColor3sv                  = NULL;
 566   qglColor3ub                  = NULL;
 567   qglColor3ubv                 = NULL;
 568   qglColor3ui                  = NULL;
 569   qglColor3uiv                 = NULL;
 570   qglColor3us                  = NULL;
 571   qglColor3usv                 = NULL;
 572   qglColor4b                   = NULL;
 573   qglColor4bv                  = NULL;
 574   qglColor4d                   = NULL;
 575   qglColor4dv                  = NULL;
 576   qglColor4f                   = NULL;
 577   qglColor4fv                  = NULL;
 578   qglColor4i                   = NULL;
 579   qglColor4iv                  = NULL;
 580   qglColor4s                   = NULL;
 581   qglColor4sv                  = NULL;
 582   qglColor4ub                  = NULL;
 583   qglColor4ubv                 = NULL;
 584   qglColor4ui                  = NULL;
 585   qglColor4uiv                 = NULL;
 586   qglColor4us                  = NULL;
 587   qglColor4usv                 = NULL;
 588   qglColorMask                 = NULL;
 589   qglColorMaterial             = NULL;
 590   qglColorPointer              = NULL;
 591   qglCopyPixels                = NULL;
 592   qglCopyTexImage1D            = NULL;
 593   qglCopyTexImage2D            = NULL;
 594   qglCopyTexSubImage1D         = NULL;
 595   qglCopyTexSubImage2D         = NULL;
 596   qglCullFace                  = NULL;
 597   qglDeleteLists               = NULL;
 598   qglDeleteTextures            = NULL;
 599   qglDepthFunc                 = NULL;
 600   qglDepthMask                 = NULL;
 601   qglDepthRange                = NULL;
 602   qglDisable                   = NULL;
 603   qglDisableClientState        = NULL;
 604   qglDrawArrays                = NULL;
 605   qglDrawBuffer                = NULL;
 606   qglDrawElements              = NULL;
 607   qglDrawPixels                = NULL;
 608   qglEdgeFlag                  = NULL;
 609   qglEdgeFlagPointer           = NULL;
 610   qglEdgeFlagv                 = NULL;
 611   qglEnable                    = NULL;
 612   qglEnableClientState         = NULL;
 613   qglEnd                       = NULL;
 614   qglEndList                   = NULL;
 615   qglEvalCoord1d               = NULL;
 616   qglEvalCoord1dv              = NULL;
 617   qglEvalCoord1f               = NULL;
 618   qglEvalCoord1fv              = NULL;
 619   qglEvalCoord2d               = NULL;
 620   qglEvalCoord2dv              = NULL;
 621   qglEvalCoord2f               = NULL;
 622   qglEvalCoord2fv              = NULL;
 623   qglEvalMesh1                 = NULL;
 624   qglEvalMesh2                 = NULL;
 625   qglEvalPoint1                = NULL;
 626   qglEvalPoint2                = NULL;
 627   qglFeedbackBuffer            = NULL;
 628   qglFinish                    = NULL;
 629   qglFlush                     = NULL;
 630   qglFogf                      = NULL;
 631   qglFogfv                     = NULL;
 632   qglFogi                      = NULL;
 633   qglFogiv                     = NULL;
 634   qglFrontFace                 = NULL;
 635   qglFrustum                   = NULL;
 636   qglGenLists                  = NULL;
 637   qglGenTextures               = NULL;
 638   qglGetBooleanv               = NULL;
 639   qglGetClipPlane              = NULL;
 640   qglGetDoublev                = NULL;
 641   qglGetError                  = NULL;
 642   qglGetFloatv                 = NULL;
 643   qglGetIntegerv               = NULL;
 644   qglGetLightfv                = NULL;
 645   qglGetLightiv                = NULL;
 646   qglGetMapdv                  = NULL;
 647   qglGetMapfv                  = NULL;
 648   qglGetMapiv                  = NULL;
 649   qglGetMaterialfv             = NULL;
 650   qglGetMaterialiv             = NULL;
 651   qglGetPixelMapfv             = NULL;
 652   qglGetPixelMapuiv            = NULL;
 653   qglGetPixelMapusv            = NULL;
 654   qglGetPointerv               = NULL;
 655   qglGetPolygonStipple         = NULL;
 656   qglGetString                 = NULL;
 657   qglGetTexEnvfv               = NULL;
 658   qglGetTexEnviv               = NULL;
 659   qglGetTexGendv               = NULL;
 660   qglGetTexGenfv               = NULL;
 661   qglGetTexGeniv               = NULL;
 662   qglGetTexImage               = NULL;
 663   qglGetTexLevelParameterfv    = NULL;
 664   qglGetTexLevelParameteriv    = NULL;
 665   qglGetTexParameterfv         = NULL;
 666   qglGetTexParameteriv         = NULL;
 667   qglHint                      = NULL;
 668   qglIndexMask                 = NULL;
 669   qglIndexPointer              = NULL;
 670   qglIndexd                    = NULL;
 671   qglIndexdv                   = NULL;
 672   qglIndexf                    = NULL;
 673   qglIndexfv                   = NULL;
 674   qglIndexi                    = NULL;
 675   qglIndexiv                   = NULL;
 676   qglIndexs                    = NULL;
 677   qglIndexsv                   = NULL;
 678   qglIndexub                   = NULL;
 679   qglIndexubv                  = NULL;
 680   qglInitNames                 = NULL;
 681   qglInterleavedArrays         = NULL;
 682   qglIsEnabled                 = NULL;
 683   qglIsList                    = NULL;
 684   qglIsTexture                 = NULL;
 685   qglLightModelf               = NULL;
 686   qglLightModelfv              = NULL;
 687   qglLightModeli               = NULL;
 688   qglLightModeliv              = NULL;
 689   qglLightf                    = NULL;
 690   qglLightfv                   = NULL;
 691   qglLighti                    = NULL;
 692   qglLightiv                   = NULL;
 693   qglLineStipple               = NULL;
 694   qglLineWidth                 = NULL;
 695   qglListBase                  = NULL;
 696   qglLoadIdentity              = NULL;
 697   qglLoadMatrixd               = NULL;
 698   qglLoadMatrixf               = NULL;
 699   qglLoadName                  = NULL;
 700   qglLogicOp                   = NULL;
 701   qglMap1d                     = NULL;
 702   qglMap1f                     = NULL;
 703   qglMap2d                     = NULL;
 704   qglMap2f                     = NULL;
 705   qglMapGrid1d                 = NULL;
 706   qglMapGrid1f                 = NULL;
 707   qglMapGrid2d                 = NULL;
 708   qglMapGrid2f                 = NULL;
 709   qglMaterialf                 = NULL;
 710   qglMaterialfv                = NULL;
 711   qglMateriali                 = NULL;
 712   qglMaterialiv                = NULL;
 713   qglMatrixMode                = NULL;
 714   qglMultMatrixd               = NULL;
 715   qglMultMatrixf               = NULL;
 716   qglNewList                   = NULL;
 717   qglNormal3b                  = NULL;
 718   qglNormal3bv                 = NULL;
 719   qglNormal3d                  = NULL;
 720   qglNormal3dv                 = NULL;
 721   qglNormal3f                  = NULL;
 722   qglNormal3fv                 = NULL;
 723   qglNormal3i                  = NULL;
 724   qglNormal3iv                 = NULL;
 725   qglNormal3s                  = NULL;
 726   qglNormal3sv                 = NULL;
 727   qglNormalPointer             = NULL;
 728   qglOrtho                     = NULL;
 729   qglPassThrough               = NULL;
 730   qglPixelMapfv                = NULL;
 731   qglPixelMapuiv               = NULL;
 732   qglPixelMapusv               = NULL;
 733   qglPixelStoref               = NULL;
 734   qglPixelStorei               = NULL;
 735   qglPixelTransferf            = NULL;
 736   qglPixelTransferi            = NULL;
 737   qglPixelZoom                 = NULL;
 738   qglPointSize                 = NULL;
 739   qglPolygonMode               = NULL;
 740   qglPolygonOffset             = NULL;
 741   qglPolygonStipple            = NULL;
 742   qglPopAttrib                 = NULL;
 743   qglPopClientAttrib           = NULL;
 744   qglPopMatrix                 = NULL;
 745   qglPopName                   = NULL;
 746   qglPrioritizeTextures        = NULL;
 747   qglPushAttrib                = NULL;
 748   qglPushClientAttrib          = NULL;
 749   qglPushMatrix                = NULL;
 750   qglPushName                  = NULL;
 751   qglRasterPos2d               = NULL;
 752   qglRasterPos2dv              = NULL;
 753   qglRasterPos2f               = NULL;
 754   qglRasterPos2fv              = NULL;
 755   qglRasterPos2i               = NULL;
 756   qglRasterPos2iv              = NULL;
 757   qglRasterPos2s               = NULL;
 758   qglRasterPos2sv              = NULL;
 759   qglRasterPos3d               = NULL;
 760   qglRasterPos3dv              = NULL;
 761   qglRasterPos3f               = NULL;
 762   qglRasterPos3fv              = NULL;
 763   qglRasterPos3i               = NULL;
 764   qglRasterPos3iv              = NULL;
 765   qglRasterPos3s               = NULL;
 766   qglRasterPos3sv              = NULL;
 767   qglRasterPos4d               = NULL;
 768   qglRasterPos4dv              = NULL;
 769   qglRasterPos4f               = NULL;
 770   qglRasterPos4fv              = NULL;
 771   qglRasterPos4i               = NULL;
 772   qglRasterPos4iv              = NULL;
 773   qglRasterPos4s               = NULL;
 774   qglRasterPos4sv              = NULL;
 775   qglReadBuffer                = NULL;
 776   qglReadPixels                = NULL;
 777   qglRectd                     = NULL;
 778   qglRectdv                    = NULL;
 779   qglRectf                     = NULL;
 780   qglRectfv                    = NULL;
 781   qglRecti                     = NULL;
 782   qglRectiv                    = NULL;
 783   qglRects                     = NULL;
 784   qglRectsv                    = NULL;
 785   qglRenderMode                = NULL;
 786   qglRotated                   = NULL;
 787   qglRotatef                   = NULL;
 788   qglScaled                    = NULL;
 789   qglScalef                    = NULL;
 790   qglScissor                   = NULL;
 791   qglSelectBuffer              = NULL;
 792   qglShadeModel                = NULL;
 793   qglStencilFunc               = NULL;
 794   qglStencilMask               = NULL;
 795   qglStencilOp                 = NULL;
 796   qglTexCoord1d                = NULL;
 797   qglTexCoord1dv               = NULL;
 798   qglTexCoord1f                = NULL;
 799   qglTexCoord1fv               = NULL;
 800   qglTexCoord1i                = NULL;
 801   qglTexCoord1iv               = NULL;
 802   qglTexCoord1s                = NULL;
 803   qglTexCoord1sv               = NULL;
 804   qglTexCoord2d                = NULL;
 805   qglTexCoord2dv               = NULL;
 806   qglTexCoord2f                = NULL;
 807   qglTexCoord2fv               = NULL;
 808   qglTexCoord2i                = NULL;
 809   qglTexCoord2iv               = NULL;
 810   qglTexCoord2s                = NULL;
 811   qglTexCoord2sv               = NULL;
 812   qglTexCoord3d                = NULL;
 813   qglTexCoord3dv               = NULL;
 814   qglTexCoord3f                = NULL;
 815   qglTexCoord3fv               = NULL;
 816   qglTexCoord3i                = NULL;
 817   qglTexCoord3iv               = NULL;
 818   qglTexCoord3s                = NULL;
 819   qglTexCoord3sv               = NULL;
 820   qglTexCoord4d                = NULL;
 821   qglTexCoord4dv               = NULL;
 822   qglTexCoord4f                = NULL;
 823   qglTexCoord4fv               = NULL;
 824   qglTexCoord4i                = NULL;
 825   qglTexCoord4iv               = NULL;
 826   qglTexCoord4s                = NULL;
 827   qglTexCoord4sv               = NULL;
 828   qglTexCoordPointer           = NULL;
 829   qglTexEnvf                   = NULL;
 830   qglTexEnvfv                  = NULL;
 831   qglTexEnvi                   = NULL;
 832   qglTexEnviv                  = NULL;
 833   qglTexGend                   = NULL;
 834   qglTexGendv                  = NULL;
 835   qglTexGenf                   = NULL;
 836   qglTexGenfv                  = NULL;
 837   qglTexGeni                   = NULL;
 838   qglTexGeniv                  = NULL;
 839   qglTexImage1D                = NULL;
 840   qglTexImage2D                = NULL;
 841   qglTexParameterf             = NULL;
 842   qglTexParameterfv            = NULL;
 843   qglTexParameteri             = NULL;
 844   qglTexParameteriv            = NULL;
 845   qglTexSubImage1D             = NULL;
 846   qglTexSubImage2D             = NULL;
 847   qglTranslated                = NULL;
 848   qglTranslatef                = NULL;
 849   qglVertex2d                  = NULL;
 850   qglVertex2dv                 = NULL;
 851   qglVertex2f                  = NULL;
 852   qglVertex2fv                 = NULL;
 853   qglVertex2i                  = NULL;
 854   qglVertex2iv                 = NULL;
 855   qglVertex2s                  = NULL;
 856   qglVertex2sv                 = NULL;
 857   qglVertex3d                  = NULL;
 858   qglVertex3dv                 = NULL;
 859   qglVertex3f                  = NULL;
 860   qglVertex3fv                 = NULL;
 861   qglVertex3i                  = NULL;
 862   qglVertex3iv                 = NULL;
 863   qglVertex3s                  = NULL;
 864   qglVertex3sv                 = NULL;
 865   qglVertex4d                  = NULL;
 866   qglVertex4dv                 = NULL;
 867   qglVertex4f                  = NULL;
 868   qglVertex4fv                 = NULL;
 869   qglVertex4i                  = NULL;
 870   qglVertex4iv                 = NULL;
 871   qglVertex4s                  = NULL;
 872   qglVertex4sv                 = NULL;
 873   qglVertexPointer             = NULL;
 874   qglViewport                  = NULL;
 875
 876   qglActiveTextureARB = NULL;
 877   qglClientActiveTextureARB = NULL;
 878   qglMultiTexCoord1dARB = NULL;
 879   qglMultiTexCoord1dvARB = NULL;
 880   qglMultiTexCoord1fARB = NULL;
 881   qglMultiTexCoord1fvARB = NULL;
 882   qglMultiTexCoord1iARB = NULL;
 883   qglMultiTexCoord1ivARB = NULL;
 884   qglMultiTexCoord1sARB = NULL;
 885   qglMultiTexCoord1svARB = NULL;
 886   qglMultiTexCoord2dARB = NULL;
 887   qglMultiTexCoord2dvARB = NULL;
 888   qglMultiTexCoord2fARB = NULL;
 889   qglMultiTexCoord2fvARB = NULL;
 890   qglMultiTexCoord2iARB = NULL;
 891   qglMultiTexCoord2ivARB = NULL;
 892   qglMultiTexCoord2sARB = NULL;
 893   qglMultiTexCoord2svARB = NULL;
 894   qglMultiTexCoord3dARB = NULL;
 895   qglMultiTexCoord3dvARB = NULL;
 896   qglMultiTexCoord3fARB = NULL;
 897   qglMultiTexCoord3fvARB = NULL;
 898   qglMultiTexCoord3iARB = NULL;
 899   qglMultiTexCoord3ivARB = NULL;
 900   qglMultiTexCoord3sARB = NULL;
 901   qglMultiTexCoord3svARB = NULL;
 902   qglMultiTexCoord4dARB = NULL;
 903   qglMultiTexCoord4dvARB = NULL;
 904   qglMultiTexCoord4fARB = NULL;
 905   qglMultiTexCoord4fvARB = NULL;
 906   qglMultiTexCoord4iARB = NULL;
 907   qglMultiTexCoord4ivARB = NULL;
 908   qglMultiTexCoord4sARB = NULL;
 909   qglMultiTexCoord4svARB = NULL;
 910
 911 #ifdef _WIN32
 912   qwglCopyContext              = NULL;
 913   qwglCreateContext            = NULL;
 914   qwglCreateLayerContext       = NULL;
 915   qwglDeleteContext            = NULL;
 916   qwglDescribeLayerPlane       = NULL;
 917   qwglGetCurrentContext        = NULL;
 918   qwglGetCurrentDC             = NULL;
 919   qwglGetLayerPaletteEntries   = NULL;
 920   qwglGetProcAddress           = NULL;
 921   qwglMakeCurrent              = NULL;
 922   qwglRealizeLayerPalette      = NULL;
 923   qwglSetLayerPaletteEntries   = NULL;
 924   qwglShareLists               = NULL;
 925   qwglSwapLayerBuffers         = NULL;
 926   qwglUseFontBitmaps           = NULL;
 927   qwglUseFontOutlines          = NULL;
 928
 929   qwglChoosePixelFormat        = NULL;
 930   qwglDescribePixelFormat      = NULL;
 931   qwglGetPixelFormat           = NULL;
 932   qwglSetPixelFormat           = NULL;
 933   qwglSwapBuffers              = NULL;
 934
 935   qwglSwapIntervalEXT          = NULL;
 936
 937   qwglGetDeviceGammaRampEXT    = NULL;
 938   qwglSetDeviceGammaRampEXT    = NULL;
 939 #endif
 940
 941 #if defined (__linux__) || defined (__APPLE__)
 942   qglXChooseVisual             = NULL;
 943   qglXCreateContext            = NULL;
 944   qglXDestroyContext           = NULL;
 945   qglXMakeCurrent              = NULL;
 946   qglXCopyContext              = NULL;
 947   qglXSwapBuffers              = NULL;
 948   qglXCreateGLXPixmap          = NULL;
 949   qglXDestroyGLXPixmap         = NULL;
 950   qglXQueryExtension           = NULL;
 951   qglXQueryVersion             = NULL;
 952   qglXIsDirect                 = NULL;
 953   qglXGetConfig                = NULL;
 954   qglXGetCurrentContext        = NULL;
 955   qglXGetCurrentDrawable       = NULL;
 956   qglXWaitGL                   = NULL;
 957   qglXWaitX                    = NULL;
 958   qglXUseXFont                 = NULL;
 959   qglXGetProcAddressARB        = NULL;
 960 #endif
 961
 962   qgluPerspective = NULL;
 963   qgluErrorString = NULL;
 964   qgluLookAt = NULL;
 965
 966 #ifdef ATIHACK_812
 967   qglCullFace_real              = NULL;
 968   qglDisable_real               = NULL;
 969   qglEnable_real                = NULL;
 970   qglPolygonMode_real           = NULL;
 971 #endif
 972 }
 973
 974 /*
 975 ** QGL_Init
 976 **
 977 ** This is responsible for binding our qgl function pointers to
 978 ** the appropriate GL stuff.  In Windows this means doing a
 979 ** LoadLibrary and a bunch of calls to GetProcAddress.  On other
 980 ** operating systems we need to do the right thing, whatever that
 981 ** might be.
 982 **
 983 */
 984 static int init_error;
 985
 986 static void* safe_dlsym (void *handle, char *symbol)
 987 {
 988 #ifdef _WIN32
 989   return GetProcAddress (handle, symbol);
 990 #endif
 991
 992 #if defined (__linux__) || defined (__APPLE__)
 993   void* ret = dlsym (handle, symbol);
 994   const char *err = dlerror();
 995   if (err)
 996   {
 997     init_error = 1;
 998 #ifndef __APPLE__
 999     printf ("Error loading OpenGL libraries: %s\n", err);
1000 #else
1001     printf ("Error loading OpenGL libraries: %s %s\n", err, symbol);
1002 #endif
1003   }
1004   return ret;
1005 #endif
1006 }
1007
1008 #include <math.h>
1009 #include <stdlib.h>
1010 #ifdef _WIN32
1011 #define M_PI 3.14159
1012 #endif
1013
1014 void WINAPI gluLookAt2 (GLdouble ex, GLdouble ey, GLdouble ez, GLdouble cx, GLdouble cy, GLdouble cz,
1015                  GLdouble ux, GLdouble uy, GLdouble uz)
1016 {
1017    GLdouble x[3], y[3], z[3] = { ex-cx, ey-cy, ez-cz };
1018    GLdouble inv;
1019
1020    inv = sqrt (z[0]*z[0] + z[1]*z[1] + z[2]*z[2]);
1021    if (inv)
1022    {
1023      inv = 1.0/inv;
1024      z[0] *= inv;
1025      z[1] *= inv;
1026      z[2] *= inv;
1027    }
1028
1029    x[0] =  uy*z[2] - uz*z[1];
1030    x[1] = -ux*z[2] + uz*z[0];
1031    x[2] =  ux*z[1] - uy*z[0];
1032
1033    y[0] =  z[1]*x[2] - z[2]*x[1];
1034    y[1] = -z[0]*x[2] + z[2]*x[0];
1035    y[2] =  z[0]*x[1] - z[1]*x[0];
1036
1037    inv = sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
1038    if (inv)
1039    {
1040      x[0] *= inv;
1041      x[1] *= inv;
1042      x[2] *= inv;
1043    }
1044
1045    inv = sqrt(y[0]*y[0] + y[1]*y[1] + y[2]*y[2]);
1046    if (inv)
1047    {
1048       y[0] *= inv;
1049       y[1] *= inv;
1050       y[2] *= inv;
1051    }
1052
1053    {
1054    GLdouble m[16] = { x[0], y[0], z[0], 0, x[1], y[1], z[1], 0, x[2], y[2], z[2], 0, 0, 0, 0, 1 };
1055    qglMultMatrixd(m);
1056    qglTranslated(-ex, -ey, -ez);
1057    }
1058 }
1059
1060 void WINAPI gluPerspective2 (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
1061 {
1062    GLdouble y = zNear * tan (fovy * M_PI / 360.0);
1063    qglFrustum (-y*aspect, y*aspect, -y, y, zNear, zFar);
1064 }
1065
1066 static void* WINAPI ResizeImage (GLubyte* old_image, int srcw, int srch, int destw, int desth)
1067 {
1068   int i, j;
1069   float sx, sy;
1070   GLubyte* new_image = (GLubyte *)malloc (destw*desth*4*sizeof(GLubyte));
1071   if (new_image == NULL)
1072     return NULL;
1073
1074   if (destw > 1)
1075     sx = (GLfloat) (srcw-1) / (GLfloat) (destw-1);
1076   else
1077     sx = (GLfloat) (srcw-1);
1078   if (desth > 1)
1079     sy = (GLfloat) (srch-1) / (GLfloat) (desth-1);
1080   else
1081     sy = (GLfloat) (srch-1);
1082
1083   for (i = 0; i < desth; i++)
1084   {
1085     GLint ii = (GLint)(i * sy);
1086     for (j = 0; j < destw; j++)
1087     {
1088       GLint jj = (GLint)(j * sx);
1089       GLubyte *src = old_image + (ii * srcw + jj) * 4;
1090       GLubyte *dst = new_image + (i * destw + j) * 4;
1091
1092       *dst++ = *src++;
1093       *dst++ = *src++;
1094       *dst++ = *src++;
1095       *dst++ = *src++;
1096     }
1097   }
1098
1099   return new_image;
1100 }
1101
1102 #define CEILING(A, B)  ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
1103
1104 typedef struct glu_error_struct
1105 {
1106     int     errnum;
1107     const char *errstr;
1108 } GLU_ERROR_STRUCT;
1109
1110 GLU_ERROR_STRUCT glu_errlist[] = {
1111   {GL_NO_ERROR, "GL_NO_ERROR - no error"},
1112   {GL_INVALID_ENUM, "GL_INVALID_ENUM - An unacceptable value is specified for an enumerated argument."},
1113   {GL_INVALID_VALUE, "GL_INVALID_VALUE - A numeric argument is out of range."},
1114   {GL_INVALID_OPERATION, "GL_INVALID_OPERATION - The specified operation is not allowed in the current state."},
1115   {GL_STACK_OVERFLOW, "GL_STACK_OVERFLOW - Function would cause a stack overflow."},
1116   {GL_STACK_UNDERFLOW, "GL_STACK_UNDERFLOW - Function would cause a stack underflow."},
1117   {GL_OUT_OF_MEMORY, "GL_OUT_OF_MEMORY - There is not enough memory left to execute the function."},
1118   {-1, NULL}
1119 };
1120
1121 const GLubyte* WINAPI gluErrorString(GLenum errCode )
1122 {
1123   int search = 0;
1124   for (search = 0; glu_errlist[search].errstr; search++)
1125   {
1126     if (errCode == glu_errlist[search].errnum)
1127       return (const char *)glu_errlist[search].errstr;
1128   } //end for
1129   return "Unknown error";
1130 }
1131
1132 #ifdef ATIHACK_812
1133 int ATIhack_culling;
1134 GLenum ATIhack_cullmode;
1135 GLenum ATIhack_backmode;
1136 GLenum ATIhack_frontmode;
1137
1138 static void ATIhack_update(void)
1139 {
1140   if(!ATIhack_culling || (GL_FRONT_AND_BACK == ATIhack_cullmode))
1141   {
1142     qglPolygonMode_real(GL_FRONT, ATIhack_frontmode);
1143     qglPolygonMode_real(GL_BACK, ATIhack_backmode);
1144   }
1145   else
1146     switch(ATIhack_cullmode)
1147     {
1148       case GL_FRONT:
1149         qglPolygonMode_real(GL_FRONT_AND_BACK, ATIhack_backmode);
1150         break;
1151       case GL_BACK:
1152         qglPolygonMode_real(GL_FRONT_AND_BACK, ATIhack_frontmode);
1153       default:
1154         break;
1155     }
1156 }
1157
1158 void APIENTRY qglEnable_ATIHack(GLenum cap)
1159 {
1160   qglEnable_real(cap);
1161   if(GL_CULL_FACE != cap)
1162     return;
1163   if(ATIhack_culling)
1164     return;
1165   ATIhack_culling = 1;
1166   ATIhack_update();
1167 }
1168
1169 void APIENTRY qglDisable_ATIHack(GLenum cap)
1170 {
1171   qglDisable_real(cap);
1172   if(GL_CULL_FACE != cap)
1173     return;
1174   if(!ATIhack_culling)
1175     return;
1176   ATIhack_culling = 0;
1177   ATIhack_update();
1178 }
1179
1180 void APIENTRY qglCullFace_ATIHack(GLenum mode)
1181 {
1182   if(ATIhack_cullmode == mode)
1183     return;
1184   qglCullFace_real(mode);
1185   ATIhack_cullmode = mode;
1186   ATIhack_update();
1187 }
1188
1189 void APIENTRY qglPolygonMode_ATIHack(GLenum face, GLenum mode)
1190 {
1191   switch(face)
1192   {
1193     case GL_FRONT:
1194       if(ATIhack_frontmode == mode)
1195         return;
1196       ATIhack_frontmode = mode;
1197       break;
1198     case GL_BACK:
1199       if(ATIhack_backmode == mode)
1200         return;
1201       ATIhack_backmode = mode;
1202       break;
1203     case GL_FRONT_AND_BACK:
1204       if((ATIhack_frontmode == mode) && (ATIhack_backmode == mode))
1205         return;
1206       ATIhack_frontmode = ATIhack_backmode = mode;
1207     default:
1208       break;
1209   }
1210   ATIhack_update();
1211 }
1212 #endif
1213
1214 int QGL_Init(const char *dllname, const char* gluname)
1215 {
1216 #ifdef _WIN32
1217   g_hGLDLL = LoadLibrary(dllname);
1218 #endif
1219
1220 #if defined (__linux__) || (__APPLE__)
1221   const char *err;
1222
1223   // NOTE TTimo
1224   // I don't like RTLD_LAZY|RTLD_GLOBAL too much .. it's dangerous
1225   // maybe try RTLD_NOW? or would that break compatibility .. you never know when that stuff is going to explode
1226   g_hGLDLL = dlopen(dllname, RTLD_LAZY|RTLD_GLOBAL);
1227   err = dlerror();
1228   if (err)
1229     printf ("Error loading GL lib:\n%s\n", err);
1230 #endif
1231   init_error = 0;
1232
1233   if (g_hGLDLL == NULL)
1234     return 0;
1235
1236   Sys_Printf ("Loading GL library: %s ...", dllname);
1237
1238   qgluPerspective              = &gluPerspective2;
1239
1240   qgluLookAt                   = &gluLookAt2;
1241   qgluErrorString              = &gluErrorString;
1242   qglAccum                     = safe_dlsym (g_hGLDLL, "glAccum" );
1243   qglAlphaFunc                 = safe_dlsym (g_hGLDLL, "glAlphaFunc" );
1244   qglAreTexturesResident       = safe_dlsym (g_hGLDLL, "glAreTexturesResident" );
1245   qglArrayElement              = safe_dlsym (g_hGLDLL, "glArrayElement" );
1246   qglBegin                     = safe_dlsym (g_hGLDLL, "glBegin" );
1247   qglBindTexture               = safe_dlsym (g_hGLDLL, "glBindTexture" );
1248   qglBitmap                    = safe_dlsym (g_hGLDLL, "glBitmap" );
1249   qglBlendFunc                 = safe_dlsym (g_hGLDLL, "glBlendFunc" );
1250   qglCallList                  = safe_dlsym (g_hGLDLL, "glCallList" );
1251   qglCallLists                 = safe_dlsym (g_hGLDLL, "glCallLists" );
1252   qglClear                     = safe_dlsym (g_hGLDLL, "glClear" );
1253   qglClearAccum                = safe_dlsym (g_hGLDLL, "glClearAccum" );
1254   qglClearColor                = safe_dlsym (g_hGLDLL, "glClearColor" );
1255   qglClearDepth                = safe_dlsym (g_hGLDLL, "glClearDepth" );
1256   qglClearIndex                = safe_dlsym (g_hGLDLL, "glClearIndex" );
1257   qglClearStencil              = safe_dlsym (g_hGLDLL, "glClearStencil" );
1258   qglClipPlane                 = safe_dlsym (g_hGLDLL, "glClipPlane" );
1259   qglColor3b                   = safe_dlsym (g_hGLDLL, "glColor3b" );
1260   qglColor3bv                  = safe_dlsym (g_hGLDLL, "glColor3bv" );
1261   qglColor3d                   = safe_dlsym (g_hGLDLL, "glColor3d" );
1262   qglColor3dv                  = safe_dlsym (g_hGLDLL, "glColor3dv" );
1263   qglColor3f                   = safe_dlsym (g_hGLDLL, "glColor3f" );
1264   qglColor3fv                  = safe_dlsym (g_hGLDLL, "glColor3fv" );
1265   qglColor3i                   = safe_dlsym (g_hGLDLL, "glColor3i" );
1266   qglColor3iv                  = safe_dlsym (g_hGLDLL, "glColor3iv" );
1267   qglColor3s                   = safe_dlsym (g_hGLDLL, "glColor3s" );
1268   qglColor3sv                  = safe_dlsym (g_hGLDLL, "glColor3sv" );
1269   qglColor3ub                  = safe_dlsym (g_hGLDLL, "glColor3ub" );
1270   qglColor3ubv                 = safe_dlsym (g_hGLDLL, "glColor3ubv" );
1271   qglColor3ui                  = safe_dlsym (g_hGLDLL, "glColor3ui" );
1272   qglColor3uiv                 = safe_dlsym (g_hGLDLL, "glColor3uiv" );
1273   qglColor3us                  = safe_dlsym (g_hGLDLL, "glColor3us" );
1274   qglColor3usv                 = safe_dlsym (g_hGLDLL, "glColor3usv" );
1275   qglColor4b                   = safe_dlsym (g_hGLDLL, "glColor4b" );
1276   qglColor4bv                  = safe_dlsym (g_hGLDLL, "glColor4bv" );
1277   qglColor4d                   = safe_dlsym (g_hGLDLL, "glColor4d" );
1278   qglColor4dv                  = safe_dlsym (g_hGLDLL, "glColor4dv" );
1279   qglColor4f                   = safe_dlsym (g_hGLDLL, "glColor4f" );
1280   qglColor4fv                  = safe_dlsym (g_hGLDLL, "glColor4fv" );
1281   qglColor4i                   = safe_dlsym (g_hGLDLL, "glColor4i" );
1282   qglColor4iv                  = safe_dlsym (g_hGLDLL, "glColor4iv" );
1283   qglColor4s                   = safe_dlsym (g_hGLDLL, "glColor4s" );
1284   qglColor4sv                  = safe_dlsym (g_hGLDLL, "glColor4sv" );
1285   qglColor4ub                  = safe_dlsym (g_hGLDLL, "glColor4ub" );
1286   qglColor4ubv                 = safe_dlsym (g_hGLDLL, "glColor4ubv" );
1287   qglColor4ui                  = safe_dlsym (g_hGLDLL, "glColor4ui" );
1288   qglColor4uiv                 = safe_dlsym (g_hGLDLL, "glColor4uiv" );
1289   qglColor4us                  = safe_dlsym (g_hGLDLL, "glColor4us" );
1290   qglColor4usv                 = safe_dlsym (g_hGLDLL, "glColor4usv" );
1291   qglColorMask                 = safe_dlsym (g_hGLDLL, "glColorMask" );
1292   qglColorMaterial             = safe_dlsym (g_hGLDLL, "glColorMaterial" );
1293   qglColorPointer              = safe_dlsym (g_hGLDLL, "glColorPointer" );
1294   qglCopyPixels                = safe_dlsym (g_hGLDLL, "glCopyPixels" );
1295   qglCopyTexImage1D            = safe_dlsym (g_hGLDLL, "glCopyTexImage1D" );
1296   qglCopyTexImage2D            = safe_dlsym (g_hGLDLL, "glCopyTexImage2D" );
1297   qglCopyTexSubImage1D         = safe_dlsym (g_hGLDLL, "glCopyTexSubImage1D" );
1298   qglCopyTexSubImage2D         = safe_dlsym (g_hGLDLL, "glCopyTexSubImage2D" );
1299 #ifdef ATIHACK_812
1300   qglCullFace_real              = safe_dlsym (g_hGLDLL, "glCullFace" );
1301   qglCullFace                  = qglCullFace_real;
1302 #else
1303   qglCullFace                  = safe_dlsym (g_hGLDLL, "glCullFace" );
1304 #endif
1305   qglDeleteLists               = safe_dlsym (g_hGLDLL, "glDeleteLists" );
1306   qglDeleteTextures            = safe_dlsym (g_hGLDLL, "glDeleteTextures" );
1307   qglDepthFunc                 = safe_dlsym (g_hGLDLL, "glDepthFunc" );
1308   qglDepthMask                 = safe_dlsym (g_hGLDLL, "glDepthMask" );
1309   qglDepthRange                = safe_dlsym (g_hGLDLL, "glDepthRange" );
1310 #ifdef ATIHACK_812
1311   qglDisable_real               = safe_dlsym (g_hGLDLL, "glDisable" );
1312   qglDisable                   = qglDisable_real;
1313 #else
1314   qglDisable                   = safe_dlsym (g_hGLDLL, "glDisable" );
1315 #endif
1316   qglDisableClientState        = safe_dlsym (g_hGLDLL, "glDisableClientState" );
1317   qglDrawArrays                = safe_dlsym (g_hGLDLL, "glDrawArrays" );
1318   qglDrawBuffer                = safe_dlsym (g_hGLDLL, "glDrawBuffer" );
1319   qglDrawElements              = safe_dlsym (g_hGLDLL, "glDrawElements" );
1320   qglDrawPixels                = safe_dlsym (g_hGLDLL, "glDrawPixels" );
1321   qglEdgeFlag                  = safe_dlsym (g_hGLDLL, "glEdgeFlag" );
1322   qglEdgeFlagPointer           = safe_dlsym (g_hGLDLL, "glEdgeFlagPointer" );
1323   qglEdgeFlagv                 = safe_dlsym (g_hGLDLL, "glEdgeFlagv" );
1324 #ifdef ATIHACK_812
1325   qglEnable_real                = safe_dlsym (g_hGLDLL, "glEnable" );
1326   qglEnable                    = qglEnable_real;
1327 #else
1328   qglEnable                    = safe_dlsym (g_hGLDLL, "glEnable" );
1329 #endif
1330   qglEnableClientState         = safe_dlsym (g_hGLDLL, "glEnableClientState" );
1331   qglEnd                       = safe_dlsym (g_hGLDLL, "glEnd" );
1332   qglEndList                   = safe_dlsym (g_hGLDLL, "glEndList" );
1333   qglEvalCoord1d               = safe_dlsym (g_hGLDLL, "glEvalCoord1d" );
1334   qglEvalCoord1dv              = safe_dlsym (g_hGLDLL, "glEvalCoord1dv" );
1335   qglEvalCoord1f               = safe_dlsym (g_hGLDLL, "glEvalCoord1f" );
1336   qglEvalCoord1fv              = safe_dlsym (g_hGLDLL, "glEvalCoord1fv" );
1337   qglEvalCoord2d               = safe_dlsym (g_hGLDLL, "glEvalCoord2d" );
1338   qglEvalCoord2dv              = safe_dlsym (g_hGLDLL, "glEvalCoord2dv" );
1339   qglEvalCoord2f               = safe_dlsym (g_hGLDLL, "glEvalCoord2f" );
1340   qglEvalCoord2fv              = safe_dlsym (g_hGLDLL, "glEvalCoord2fv" );
1341   qglEvalMesh1                 = safe_dlsym (g_hGLDLL, "glEvalMesh1" );
1342   qglEvalMesh2                 = safe_dlsym (g_hGLDLL, "glEvalMesh2" );
1343   qglEvalPoint1                = safe_dlsym (g_hGLDLL, "glEvalPoint1" );
1344   qglEvalPoint2                = safe_dlsym (g_hGLDLL, "glEvalPoint2" );
1345   qglFeedbackBuffer            = safe_dlsym (g_hGLDLL, "glFeedbackBuffer" );
1346   qglFinish                    = safe_dlsym (g_hGLDLL, "glFinish" );
1347   qglFlush                     = safe_dlsym (g_hGLDLL, "glFlush" );
1348   qglFogf                      = safe_dlsym (g_hGLDLL, "glFogf" );
1349   qglFogfv                     = safe_dlsym (g_hGLDLL, "glFogfv" );
1350   qglFogi                      = safe_dlsym (g_hGLDLL, "glFogi" );
1351   qglFogiv                     = safe_dlsym (g_hGLDLL, "glFogiv" );
1352   qglFrontFace                 = safe_dlsym (g_hGLDLL, "glFrontFace" );
1353   qglFrustum                   = safe_dlsym (g_hGLDLL, "glFrustum" );
1354   qglGenLists                  = safe_dlsym (g_hGLDLL, "glGenLists" );
1355   qglGenTextures               = safe_dlsym (g_hGLDLL, "glGenTextures" );
1356   qglGetBooleanv               = safe_dlsym (g_hGLDLL, "glGetBooleanv" );
1357   qglGetClipPlane              = safe_dlsym (g_hGLDLL, "glGetClipPlane" );
1358   qglGetDoublev                = safe_dlsym (g_hGLDLL, "glGetDoublev" );
1359   qglGetError                  = safe_dlsym (g_hGLDLL, "glGetError" );
1360   qglGetFloatv                 = safe_dlsym (g_hGLDLL, "glGetFloatv" );
1361   qglGetIntegerv               = safe_dlsym (g_hGLDLL, "glGetIntegerv" );
1362   qglGetLightfv                = safe_dlsym (g_hGLDLL, "glGetLightfv" );
1363   qglGetLightiv                = safe_dlsym (g_hGLDLL, "glGetLightiv" );
1364   qglGetMapdv                  = safe_dlsym (g_hGLDLL, "glGetMapdv" );
1365   qglGetMapfv                  = safe_dlsym (g_hGLDLL, "glGetMapfv" );
1366   qglGetMapiv                  = safe_dlsym (g_hGLDLL, "glGetMapiv" );
1367   qglGetMaterialfv             = safe_dlsym (g_hGLDLL, "glGetMaterialfv" );
1368   qglGetMaterialiv             = safe_dlsym (g_hGLDLL, "glGetMaterialiv" );
1369   qglGetPixelMapfv             = safe_dlsym (g_hGLDLL, "glGetPixelMapfv" );
1370   qglGetPixelMapuiv            = safe_dlsym (g_hGLDLL, "glGetPixelMapuiv" );
1371   qglGetPixelMapusv            = safe_dlsym (g_hGLDLL, "glGetPixelMapusv" );
1372   qglGetPointerv               = safe_dlsym (g_hGLDLL, "glGetPointerv" );
1373   qglGetPolygonStipple         = safe_dlsym (g_hGLDLL, "glGetPolygonStipple" );
1374   qglGetString                 = safe_dlsym (g_hGLDLL, "glGetString" );
1375   qglGetTexEnvfv               = safe_dlsym (g_hGLDLL, "glGetTexEnvfv" );
1376   qglGetTexEnviv               = safe_dlsym (g_hGLDLL, "glGetTexEnviv" );
1377   qglGetTexGendv               = safe_dlsym (g_hGLDLL, "glGetTexGendv" );
1378   qglGetTexGenfv               = safe_dlsym (g_hGLDLL, "glGetTexGenfv" );
1379   qglGetTexGeniv               = safe_dlsym (g_hGLDLL, "glGetTexGeniv" );
1380   qglGetTexImage               = safe_dlsym (g_hGLDLL, "glGetTexImage" );
1381   qglGetTexLevelParameterfv    = safe_dlsym (g_hGLDLL, "glGetTexLevelParameterfv" );
1382   qglGetTexLevelParameteriv    = safe_dlsym (g_hGLDLL, "glGetTexLevelParameteriv" );
1383   qglGetTexParameterfv         = safe_dlsym (g_hGLDLL, "glGetTexParameterfv" );
1384   qglGetTexParameteriv         = safe_dlsym (g_hGLDLL, "glGetTexParameteriv" );
1385   qglHint                      = safe_dlsym (g_hGLDLL, "glHint" );
1386   qglIndexMask                 = safe_dlsym (g_hGLDLL, "glIndexMask" );
1387   qglIndexPointer              = safe_dlsym (g_hGLDLL, "glIndexPointer" );
1388   qglIndexd                    = safe_dlsym (g_hGLDLL, "glIndexd" );
1389   qglIndexdv                   = safe_dlsym (g_hGLDLL, "glIndexdv" );
1390   qglIndexf                    = safe_dlsym (g_hGLDLL, "glIndexf" );
1391   qglIndexfv                   = safe_dlsym (g_hGLDLL, "glIndexfv" );
1392   qglIndexi                    = safe_dlsym (g_hGLDLL, "glIndexi" );
1393   qglIndexiv                   = safe_dlsym (g_hGLDLL, "glIndexiv" );
1394   qglIndexs                    = safe_dlsym (g_hGLDLL, "glIndexs" );
1395   qglIndexsv                   = safe_dlsym (g_hGLDLL, "glIndexsv" );
1396   qglIndexub                   = safe_dlsym (g_hGLDLL, "glIndexub" );
1397   qglIndexubv                  = safe_dlsym (g_hGLDLL, "glIndexubv" );
1398   qglInitNames                 = safe_dlsym (g_hGLDLL, "glInitNames" );
1399   qglInterleavedArrays         = safe_dlsym (g_hGLDLL, "glInterleavedArrays" );
1400   qglIsEnabled                 = safe_dlsym (g_hGLDLL, "glIsEnabled" );
1401   qglIsList                    = safe_dlsym (g_hGLDLL, "glIsList" );
1402   qglIsTexture                 = safe_dlsym (g_hGLDLL, "glIsTexture" );
1403   qglLightModelf               = safe_dlsym (g_hGLDLL, "glLightModelf" );
1404   qglLightModelfv              = safe_dlsym (g_hGLDLL, "glLightModelfv" );
1405   qglLightModeli               = safe_dlsym (g_hGLDLL, "glLightModeli" );
1406   qglLightModeliv              = safe_dlsym (g_hGLDLL, "glLightModeliv" );
1407   qglLightf                    = safe_dlsym (g_hGLDLL, "glLightf" );
1408   qglLightfv                   = safe_dlsym (g_hGLDLL, "glLightfv" );
1409   qglLighti                    = safe_dlsym (g_hGLDLL, "glLighti" );
1410   qglLightiv                   = safe_dlsym (g_hGLDLL, "glLightiv" );
1411   qglLineStipple               = safe_dlsym (g_hGLDLL, "glLineStipple" );
1412   qglLineWidth                 = safe_dlsym (g_hGLDLL, "glLineWidth" );
1413   qglListBase                  = safe_dlsym (g_hGLDLL, "glListBase" );
1414   qglLoadIdentity              = safe_dlsym (g_hGLDLL, "glLoadIdentity" );
1415   qglLoadMatrixd               = safe_dlsym (g_hGLDLL, "glLoadMatrixd" );
1416   qglLoadMatrixf               = safe_dlsym (g_hGLDLL, "glLoadMatrixf" );
1417   qglLoadName                  = safe_dlsym (g_hGLDLL, "glLoadName" );
1418   qglLogicOp                   = safe_dlsym (g_hGLDLL, "glLogicOp" );
1419   qglMap1d                     = safe_dlsym (g_hGLDLL, "glMap1d" );
1420   qglMap1f                     = safe_dlsym (g_hGLDLL, "glMap1f" );
1421   qglMap2d                     = safe_dlsym (g_hGLDLL, "glMap2d" );
1422   qglMap2f                     = safe_dlsym (g_hGLDLL, "glMap2f" );
1423   qglMapGrid1d                 = safe_dlsym (g_hGLDLL, "glMapGrid1d" );
1424   qglMapGrid1f                 = safe_dlsym (g_hGLDLL, "glMapGrid1f" );
1425   qglMapGrid2d                 = safe_dlsym (g_hGLDLL, "glMapGrid2d" );
1426   qglMapGrid2f                 = safe_dlsym (g_hGLDLL, "glMapGrid2f" );
1427   qglMaterialf                 = safe_dlsym (g_hGLDLL, "glMaterialf" );
1428   qglMaterialfv                = safe_dlsym (g_hGLDLL, "glMaterialfv" );
1429   qglMateriali                 = safe_dlsym (g_hGLDLL, "glMateriali" );
1430   qglMaterialiv                = safe_dlsym (g_hGLDLL, "glMaterialiv" );
1431   qglMatrixMode                = safe_dlsym (g_hGLDLL, "glMatrixMode" );
1432   qglMultMatrixd               = safe_dlsym (g_hGLDLL, "glMultMatrixd" );
1433   qglMultMatrixf               = safe_dlsym (g_hGLDLL, "glMultMatrixf" );
1434   qglNewList                   = safe_dlsym (g_hGLDLL, "glNewList" );
1435   qglNormal3b                  = safe_dlsym (g_hGLDLL, "glNormal3b" );
1436   qglNormal3bv                 = safe_dlsym (g_hGLDLL, "glNormal3bv" );
1437   qglNormal3d                  = safe_dlsym (g_hGLDLL, "glNormal3d" );
1438   qglNormal3dv                 = safe_dlsym (g_hGLDLL, "glNormal3dv" );
1439   qglNormal3f                  = safe_dlsym (g_hGLDLL, "glNormal3f" );
1440   qglNormal3fv                 = safe_dlsym (g_hGLDLL, "glNormal3fv" );
1441   qglNormal3i                  = safe_dlsym (g_hGLDLL, "glNormal3i" );
1442   qglNormal3iv                 = safe_dlsym (g_hGLDLL, "glNormal3iv" );
1443   qglNormal3s                  = safe_dlsym (g_hGLDLL, "glNormal3s" );
1444   qglNormal3sv                 = safe_dlsym (g_hGLDLL, "glNormal3sv" );
1445   qglNormalPointer             = safe_dlsym (g_hGLDLL, "glNormalPointer" );
1446   qglOrtho                     = safe_dlsym (g_hGLDLL, "glOrtho" );
1447   qglPassThrough               = safe_dlsym (g_hGLDLL, "glPassThrough" );
1448   qglPixelMapfv                = safe_dlsym (g_hGLDLL, "glPixelMapfv" );
1449   qglPixelMapuiv               = safe_dlsym (g_hGLDLL, "glPixelMapuiv" );
1450   qglPixelMapusv               = safe_dlsym (g_hGLDLL, "glPixelMapusv" );
1451   qglPixelStoref               = safe_dlsym (g_hGLDLL, "glPixelStoref" );
1452   qglPixelStorei               = safe_dlsym (g_hGLDLL, "glPixelStorei" );
1453   qglPixelTransferf            = safe_dlsym (g_hGLDLL, "glPixelTransferf" );
1454   qglPixelTransferi            = safe_dlsym (g_hGLDLL, "glPixelTransferi" );
1455   qglPixelZoom                 = safe_dlsym (g_hGLDLL, "glPixelZoom" );
1456   qglPointSize                 = safe_dlsym (g_hGLDLL, "glPointSize" );
1457 #ifdef ATIHACK_812
1458   qglPolygonMode_real           = safe_dlsym (g_hGLDLL, "glPolygonMode" );
1459   qglPolygonMode               = qglPolygonMode_real;
1460 #else
1461   qglPolygonMode               = safe_dlsym (g_hGLDLL, "glPolygonMode" );
1462 #endif
1463   qglPolygonOffset             = safe_dlsym (g_hGLDLL, "glPolygonOffset" );
1464   qglPolygonStipple            = safe_dlsym (g_hGLDLL, "glPolygonStipple" );
1465   qglPopAttrib                 = safe_dlsym (g_hGLDLL, "glPopAttrib" );
1466   qglPopClientAttrib           = safe_dlsym (g_hGLDLL, "glPopClientAttrib" );
1467   qglPopMatrix                 = safe_dlsym (g_hGLDLL, "glPopMatrix" );
1468   qglPopName                   = safe_dlsym (g_hGLDLL, "glPopName" );
1469   qglPrioritizeTextures        = safe_dlsym (g_hGLDLL, "glPrioritizeTextures" );
1470   qglPushAttrib                = safe_dlsym (g_hGLDLL, "glPushAttrib" );
1471   qglPushClientAttrib          = safe_dlsym (g_hGLDLL, "glPushClientAttrib" );
1472   qglPushMatrix                = safe_dlsym (g_hGLDLL, "glPushMatrix" );
1473   qglPushName                  = safe_dlsym (g_hGLDLL, "glPushName" );
1474   qglRasterPos2d               = safe_dlsym (g_hGLDLL, "glRasterPos2d" );
1475   qglRasterPos2dv              = safe_dlsym (g_hGLDLL, "glRasterPos2dv" );
1476   qglRasterPos2f               = safe_dlsym (g_hGLDLL, "glRasterPos2f" );
1477   qglRasterPos2fv              = safe_dlsym (g_hGLDLL, "glRasterPos2fv" );
1478   qglRasterPos2i               = safe_dlsym (g_hGLDLL, "glRasterPos2i" );
1479   qglRasterPos2iv              = safe_dlsym (g_hGLDLL, "glRasterPos2iv" );
1480   qglRasterPos2s               = safe_dlsym (g_hGLDLL, "glRasterPos2s" );
1481   qglRasterPos2sv              = safe_dlsym (g_hGLDLL, "glRasterPos2sv" );
1482   qglRasterPos3d               = safe_dlsym (g_hGLDLL, "glRasterPos3d" );
1483   qglRasterPos3dv              = safe_dlsym (g_hGLDLL, "glRasterPos3dv" );
1484   qglRasterPos3f               = safe_dlsym (g_hGLDLL, "glRasterPos3f" );
1485   qglRasterPos3fv              = safe_dlsym (g_hGLDLL, "glRasterPos3fv" );
1486   qglRasterPos3i               = safe_dlsym (g_hGLDLL, "glRasterPos3i" );
1487   qglRasterPos3iv              = safe_dlsym (g_hGLDLL, "glRasterPos3iv" );
1488   qglRasterPos3s               = safe_dlsym (g_hGLDLL, "glRasterPos3s" );
1489   qglRasterPos3sv              = safe_dlsym (g_hGLDLL, "glRasterPos3sv" );
1490   qglRasterPos4d               = safe_dlsym (g_hGLDLL, "glRasterPos4d" );
1491   qglRasterPos4dv              = safe_dlsym (g_hGLDLL, "glRasterPos4dv" );
1492   qglRasterPos4f               = safe_dlsym (g_hGLDLL, "glRasterPos4f" );
1493   qglRasterPos4fv              = safe_dlsym (g_hGLDLL, "glRasterPos4fv" );
1494   qglRasterPos4i               = safe_dlsym (g_hGLDLL, "glRasterPos4i" );
1495   qglRasterPos4iv              = safe_dlsym (g_hGLDLL, "glRasterPos4iv" );
1496   qglRasterPos4s               = safe_dlsym (g_hGLDLL, "glRasterPos4s" );
1497   qglRasterPos4sv              = safe_dlsym (g_hGLDLL, "glRasterPos4sv" );
1498   qglReadBuffer                = safe_dlsym (g_hGLDLL, "glReadBuffer" );
1499   qglReadPixels                = safe_dlsym (g_hGLDLL, "glReadPixels" );
1500   qglRectd                     = safe_dlsym (g_hGLDLL, "glRectd" );
1501   qglRectdv                    = safe_dlsym (g_hGLDLL, "glRectdv" );
1502   qglRectf                     = safe_dlsym (g_hGLDLL, "glRectf" );
1503   qglRectfv                    = safe_dlsym (g_hGLDLL, "glRectfv" );
1504   qglRecti                     = safe_dlsym (g_hGLDLL, "glRecti" );
1505   qglRectiv                    = safe_dlsym (g_hGLDLL, "glRectiv" );
1506   qglRects                     = safe_dlsym (g_hGLDLL, "glRects" );
1507   qglRectsv                    = safe_dlsym (g_hGLDLL, "glRectsv" );
1508   qglRenderMode                = safe_dlsym (g_hGLDLL, "glRenderMode" );
1509   qglRotated                   = safe_dlsym (g_hGLDLL, "glRotated" );
1510   qglRotatef                   = safe_dlsym (g_hGLDLL, "glRotatef" );
1511   qglScaled                    = safe_dlsym (g_hGLDLL, "glScaled" );
1512   qglScalef                    = safe_dlsym (g_hGLDLL, "glScalef" );
1513   qglScissor                   = safe_dlsym (g_hGLDLL, "glScissor" );
1514   qglSelectBuffer              = safe_dlsym (g_hGLDLL, "glSelectBuffer" );
1515   qglShadeModel                = safe_dlsym (g_hGLDLL, "glShadeModel" );
1516   qglStencilFunc               = safe_dlsym (g_hGLDLL, "glStencilFunc" );
1517   qglStencilMask               = safe_dlsym (g_hGLDLL, "glStencilMask" );
1518   qglStencilOp                 = safe_dlsym (g_hGLDLL, "glStencilOp" );
1519   qglTexCoord1d                = safe_dlsym (g_hGLDLL, "glTexCoord1d" );
1520   qglTexCoord1dv               = safe_dlsym (g_hGLDLL, "glTexCoord1dv" );
1521   qglTexCoord1f                = safe_dlsym (g_hGLDLL, "glTexCoord1f" );
1522   qglTexCoord1fv               = safe_dlsym (g_hGLDLL, "glTexCoord1fv" );
1523   qglTexCoord1i                = safe_dlsym (g_hGLDLL, "glTexCoord1i" );
1524   qglTexCoord1iv               = safe_dlsym (g_hGLDLL, "glTexCoord1iv" );
1525   qglTexCoord1s                = safe_dlsym (g_hGLDLL, "glTexCoord1s" );
1526   qglTexCoord1sv               = safe_dlsym (g_hGLDLL, "glTexCoord1sv" );
1527   qglTexCoord2d                = safe_dlsym (g_hGLDLL, "glTexCoord2d" );
1528   qglTexCoord2dv               = safe_dlsym (g_hGLDLL, "glTexCoord2dv" );
1529   qglTexCoord2f                = safe_dlsym (g_hGLDLL, "glTexCoord2f" );
1530   qglTexCoord2fv               = safe_dlsym (g_hGLDLL, "glTexCoord2fv" );
1531   qglTexCoord2i                = safe_dlsym (g_hGLDLL, "glTexCoord2i" );
1532   qglTexCoord2iv               = safe_dlsym (g_hGLDLL, "glTexCoord2iv" );
1533   qglTexCoord2s                = safe_dlsym (g_hGLDLL, "glTexCoord2s" );
1534   qglTexCoord2sv               = safe_dlsym (g_hGLDLL, "glTexCoord2sv" );
1535   qglTexCoord3d                = safe_dlsym (g_hGLDLL, "glTexCoord3d" );
1536   qglTexCoord3dv               = safe_dlsym (g_hGLDLL, "glTexCoord3dv" );
1537   qglTexCoord3f                = safe_dlsym (g_hGLDLL, "glTexCoord3f" );
1538   qglTexCoord3fv               = safe_dlsym (g_hGLDLL, "glTexCoord3fv" );
1539   qglTexCoord3i                = safe_dlsym (g_hGLDLL, "glTexCoord3i" );
1540   qglTexCoord3iv               = safe_dlsym (g_hGLDLL, "glTexCoord3iv" );
1541   qglTexCoord3s                = safe_dlsym (g_hGLDLL, "glTexCoord3s" );
1542   qglTexCoord3sv               = safe_dlsym (g_hGLDLL, "glTexCoord3sv" );
1543   qglTexCoord4d                = safe_dlsym (g_hGLDLL, "glTexCoord4d" );
1544   qglTexCoord4dv               = safe_dlsym (g_hGLDLL, "glTexCoord4dv" );
1545   qglTexCoord4f                = safe_dlsym (g_hGLDLL, "glTexCoord4f" );
1546   qglTexCoord4fv               = safe_dlsym (g_hGLDLL, "glTexCoord4fv" );
1547   qglTexCoord4i                = safe_dlsym (g_hGLDLL, "glTexCoord4i" );
1548   qglTexCoord4iv               = safe_dlsym (g_hGLDLL, "glTexCoord4iv" );
1549   qglTexCoord4s                = safe_dlsym (g_hGLDLL, "glTexCoord4s" );
1550   qglTexCoord4sv               = safe_dlsym (g_hGLDLL, "glTexCoord4sv" );
1551   qglTexCoordPointer           = safe_dlsym (g_hGLDLL, "glTexCoordPointer" );
1552   qglTexEnvf                   = safe_dlsym (g_hGLDLL, "glTexEnvf" );
1553   qglTexEnvfv                  = safe_dlsym (g_hGLDLL, "glTexEnvfv" );
1554   qglTexEnvi                   = safe_dlsym (g_hGLDLL, "glTexEnvi" );
1555   qglTexEnviv                  = safe_dlsym (g_hGLDLL, "glTexEnviv" );
1556   qglTexGend                   = safe_dlsym (g_hGLDLL, "glTexGend" );
1557   qglTexGendv                  = safe_dlsym (g_hGLDLL, "glTexGendv" );
1558   qglTexGenf                   = safe_dlsym (g_hGLDLL, "glTexGenf" );
1559   qglTexGenfv                  = safe_dlsym (g_hGLDLL, "glTexGenfv" );
1560   qglTexGeni                   = safe_dlsym (g_hGLDLL, "glTexGeni" );
1561   qglTexGeniv                  = safe_dlsym (g_hGLDLL, "glTexGeniv" );
1562   qglTexImage1D                = safe_dlsym (g_hGLDLL, "glTexImage1D" );
1563   qglTexImage2D                = safe_dlsym (g_hGLDLL, "glTexImage2D" );
1564   qglTexParameterf             = safe_dlsym (g_hGLDLL, "glTexParameterf" );
1565   qglTexParameterfv            = safe_dlsym (g_hGLDLL, "glTexParameterfv" );
1566   qglTexParameteri             = safe_dlsym (g_hGLDLL, "glTexParameteri" );
1567   qglTexParameteriv            = safe_dlsym (g_hGLDLL, "glTexParameteriv" );
1568   qglTexSubImage1D             = safe_dlsym (g_hGLDLL, "glTexSubImage1D" );
1569   qglTexSubImage2D             = safe_dlsym (g_hGLDLL, "glTexSubImage2D" );
1570   qglTranslated                = safe_dlsym (g_hGLDLL, "glTranslated" );
1571   qglTranslatef                = safe_dlsym (g_hGLDLL, "glTranslatef" );
1572   qglVertex2d                  = safe_dlsym (g_hGLDLL, "glVertex2d" );
1573   qglVertex2dv                 = safe_dlsym (g_hGLDLL, "glVertex2dv" );
1574   qglVertex2f                  = safe_dlsym (g_hGLDLL, "glVertex2f" );
1575   qglVertex2fv                 = safe_dlsym (g_hGLDLL, "glVertex2fv" );
1576   qglVertex2i                  = safe_dlsym (g_hGLDLL, "glVertex2i" );
1577   qglVertex2iv                 = safe_dlsym (g_hGLDLL, "glVertex2iv" );
1578   qglVertex2s                  = safe_dlsym (g_hGLDLL, "glVertex2s" );
1579   qglVertex2sv                 = safe_dlsym (g_hGLDLL, "glVertex2sv" );
1580   qglVertex3d                  = safe_dlsym (g_hGLDLL, "glVertex3d" );
1581   qglVertex3dv                 = safe_dlsym (g_hGLDLL, "glVertex3dv" );
1582   qglVertex3f                  = safe_dlsym (g_hGLDLL, "glVertex3f" );
1583   qglVertex3fv                 = safe_dlsym (g_hGLDLL, "glVertex3fv" );
1584   qglVertex3i                  = safe_dlsym (g_hGLDLL, "glVertex3i" );
1585   qglVertex3iv                 = safe_dlsym (g_hGLDLL, "glVertex3iv" );
1586   qglVertex3s                  = safe_dlsym (g_hGLDLL, "glVertex3s" );
1587   qglVertex3sv                 = safe_dlsym (g_hGLDLL, "glVertex3sv" );
1588   qglVertex4d                  = safe_dlsym (g_hGLDLL, "glVertex4d" );
1589   qglVertex4dv                 = safe_dlsym (g_hGLDLL, "glVertex4dv" );
1590   qglVertex4f                  = safe_dlsym (g_hGLDLL, "glVertex4f" );
1591   qglVertex4fv                 = safe_dlsym (g_hGLDLL, "glVertex4fv" );
1592   qglVertex4i                  = safe_dlsym (g_hGLDLL, "glVertex4i" );
1593   qglVertex4iv                 = safe_dlsym (g_hGLDLL, "glVertex4iv" );
1594   qglVertex4s                  = safe_dlsym (g_hGLDLL, "glVertex4s" );
1595   qglVertex4sv                 = safe_dlsym (g_hGLDLL, "glVertex4sv" );
1596   qglVertexPointer             = safe_dlsym (g_hGLDLL, "glVertexPointer" );
1597   qglViewport                  = safe_dlsym (g_hGLDLL, "glViewport" );
1598
1599   // must be init with an active context
1600   qglActiveTextureARB = NULL;
1601   qglClientActiveTextureARB = NULL;
1602   qglMultiTexCoord1dARB = NULL;
1603   qglMultiTexCoord1dvARB = NULL;
1604   qglMultiTexCoord1fARB = NULL;
1605   qglMultiTexCoord1fvARB = NULL;
1606   qglMultiTexCoord1iARB = NULL;
1607   qglMultiTexCoord1ivARB = NULL;
1608   qglMultiTexCoord1sARB = NULL;
1609   qglMultiTexCoord1svARB = NULL;
1610   qglMultiTexCoord2dARB = NULL;
1611   qglMultiTexCoord2dvARB = NULL;
1612   qglMultiTexCoord2fARB = NULL;
1613   qglMultiTexCoord2fvARB = NULL;
1614   qglMultiTexCoord2iARB = NULL;
1615   qglMultiTexCoord2ivARB = NULL;
1616   qglMultiTexCoord2sARB = NULL;
1617   qglMultiTexCoord2svARB = NULL;
1618   qglMultiTexCoord3dARB = NULL;
1619   qglMultiTexCoord3dvARB = NULL;
1620   qglMultiTexCoord3fARB = NULL;
1621   qglMultiTexCoord3fvARB = NULL;
1622   qglMultiTexCoord3iARB = NULL;
1623   qglMultiTexCoord3ivARB = NULL;
1624   qglMultiTexCoord3sARB = NULL;
1625   qglMultiTexCoord3svARB = NULL;
1626   qglMultiTexCoord4dARB = NULL;
1627   qglMultiTexCoord4dvARB = NULL;
1628   qglMultiTexCoord4fARB = NULL;
1629   qglMultiTexCoord4fvARB = NULL;
1630   qglMultiTexCoord4iARB = NULL;
1631   qglMultiTexCoord4ivARB = NULL;
1632   qglMultiTexCoord4sARB = NULL;
1633   qglMultiTexCoord4svARB = NULL;
1634
1635 #ifdef _WIN32
1636     qwglCopyContext              = safe_dlsym(g_hGLDLL, "wglCopyContext" );
1637     qwglCreateContext            = safe_dlsym(g_hGLDLL, "wglCreateContext");
1638     qwglCreateLayerContext       = safe_dlsym(g_hGLDLL, "wglCreateLayerContext" );
1639     qwglDeleteContext            = safe_dlsym(g_hGLDLL, "wglDeleteContext");
1640     qwglDescribeLayerPlane       = safe_dlsym(g_hGLDLL, "wglDescribeLayerPlane" );
1641     qwglGetCurrentContext        = safe_dlsym(g_hGLDLL, "wglGetCurrentContext" );
1642     qwglGetCurrentDC             = safe_dlsym(g_hGLDLL, "wglGetCurrentDC" );
1643     qwglGetLayerPaletteEntries   = safe_dlsym(g_hGLDLL, "wglGetLayerPaletteEntries" );
1644     qwglGetProcAddress           = safe_dlsym(g_hGLDLL, "wglGetProcAddress" );
1645     qwglMakeCurrent              = safe_dlsym(g_hGLDLL, "wglMakeCurrent" );
1646     qwglRealizeLayerPalette      = safe_dlsym(g_hGLDLL, "wglRealizeLayerPalette" );
1647     qwglSetLayerPaletteEntries   = safe_dlsym(g_hGLDLL, "wglSetLayerPaletteEntries" );
1648     qwglShareLists               = safe_dlsym(g_hGLDLL, "wglShareLists" );
1649     qwglSwapLayerBuffers         = safe_dlsym(g_hGLDLL, "wglSwapLayerBuffers" );
1650     qwglUseFontBitmaps           = safe_dlsym(g_hGLDLL, "wglUseFontBitmapsA" );
1651     qwglUseFontOutlines          = safe_dlsym(g_hGLDLL, "wglUseFontOutlinesA" );
1652
1653     qwglChoosePixelFormat        = safe_dlsym(g_hGLDLL, "wglChoosePixelFormat" );
1654     qwglDescribePixelFormat      = safe_dlsym(g_hGLDLL, "wglDescribePixelFormat" );
1655     qwglGetPixelFormat           = safe_dlsym(g_hGLDLL, "wglGetPixelFormat" );
1656     qwglSetPixelFormat           = safe_dlsym(g_hGLDLL, "wglSetPixelFormat" );
1657     qwglSwapBuffers              = safe_dlsym(g_hGLDLL, "wglSwapBuffers" );
1658
1659     qwglSwapIntervalEXT = 0;
1660     qglPointParameterfEXT = 0;
1661     qglPointParameterfvEXT = 0;
1662     qglColorTableEXT = 0;
1663     qglSelectTextureSGIS = 0;
1664     qglMTexCoord2fSGIS = 0;
1665 #endif
1666
1667 #if defined (__linux__) || defined (__APPLE__)
1668   qglXChooseVisual             = safe_dlsym (g_hGLDLL, "glXChooseVisual");
1669   qglXCreateContext            = safe_dlsym (g_hGLDLL, "glXCreateContext");
1670   qglXDestroyContext           = safe_dlsym (g_hGLDLL, "glXDestroyContext");
1671   qglXMakeCurrent              = safe_dlsym (g_hGLDLL, "glXMakeCurrent");
1672   qglXCopyContext              = safe_dlsym (g_hGLDLL, "glXCopyContext");
1673   qglXSwapBuffers              = safe_dlsym (g_hGLDLL, "glXSwapBuffers");
1674   qglXCreateGLXPixmap          = safe_dlsym (g_hGLDLL, "glXCreateGLXPixmap");
1675   qglXDestroyGLXPixmap         = safe_dlsym (g_hGLDLL, "glXDestroyGLXPixmap");
1676   qglXQueryExtension           = safe_dlsym (g_hGLDLL, "glXQueryExtension");
1677   qglXQueryVersion             = safe_dlsym (g_hGLDLL, "glXQueryVersion");
1678   qglXIsDirect                 = safe_dlsym (g_hGLDLL, "glXIsDirect");
1679   qglXGetConfig                = safe_dlsym (g_hGLDLL, "glXGetConfig");
1680   qglXGetCurrentContext        = safe_dlsym (g_hGLDLL, "glXGetCurrentContext");
1681   qglXGetCurrentDrawable       = safe_dlsym (g_hGLDLL, "glXGetCurrentDrawable");
1682   qglXWaitGL                   = safe_dlsym (g_hGLDLL, "glXWaitGL");
1683   qglXWaitX                    = safe_dlsym (g_hGLDLL, "glXWaitX");
1684   qglXUseXFont                 = safe_dlsym (g_hGLDLL, "glXUseXFont");
1685 //  qglXGetProcAddressARB        = dlsym (g_hGLDLL, "glXGetProcAddressARB"); // Utah-GLX fix
1686 #endif
1687
1688   qglPointParameterfEXT = 0;
1689   qglPointParameterfvEXT = 0;
1690   qglColorTableEXT = 0;
1691   qglSelectTextureSGIS = 0;
1692   qglMTexCoord2fSGIS = 0;
1693
1694   // texture compression
1695   Sys_Printf ("Done.\n");
1696
1697 #ifdef ATIHACK_812
1698   ATIhack_culling = 0;
1699   ATIhack_cullmode = GL_BACK;
1700   ATIhack_backmode = GL_FILL;
1701   ATIhack_frontmode = GL_FILL;
1702 #endif
1703
1704   if (init_error == 1)
1705     return 0;
1706
1707   return 1;
1708 }
1709
1710 int GL_ExtensionSupported (const char *extension)
1711 {
1712   const GLubyte *extensions = NULL;
1713   const GLubyte *start;
1714   GLubyte *where, *terminator;
1715
1716   // Extension names should not have spaces.
1717   where = (GLubyte *) strchr (extension, ' ');
1718   if (where || *extension == '\0')
1719     return 0;
1720
1721   extensions = qglGetString (GL_EXTENSIONS);
1722 #ifndef __APPLE__
1723   if (!extensions)
1724     return 0;
1725 #endif
1726
1727   // It takes a bit of care to be fool-proof about parsing the
1728   // OpenGL extensions string. Don't be fooled by sub-strings, etc.
1729   for (start = extensions; ;)
1730   {
1731     where = (GLubyte *) strstr ((const char *) start, extension);
1732     if (!where)
1733       break;
1734
1735     terminator = where + strlen (extension);
1736     if (where == start || *(where - 1) == ' ')
1737       if (*terminator == ' ' || *terminator == '\0')
1738         return 1;
1739
1740     start = terminator;
1741   }
1742
1743   return 0;
1744 }
1745
1746 void* Sys_GLGetExtension (const char *symbol)
1747 {
1748 #if defined (__linux__) || defined (__APPLE__)
1749   if (qglXGetProcAddressARB == NULL)
1750     return NULL;
1751   else
1752     return qglXGetProcAddressARB ((GLubyte*)symbol);
1753 #else
1754   return qwglGetProcAddress (symbol);
1755 #endif
1756 }
1757
1758 void QGL_InitExtensions ()
1759 {
1760   if (GL_ExtensionSupported ("GL_ARB_multitexture"))
1761   {
1762     qglActiveTextureARB = Sys_GLGetExtension ("glActiveTextureARB");
1763     qglClientActiveTextureARB = Sys_GLGetExtension ("glClientActiveTextureARB");
1764     qglMultiTexCoord1dARB = Sys_GLGetExtension ("glMultiTexCoord1dARB");
1765     qglMultiTexCoord1dvARB = Sys_GLGetExtension ("glMultiTexCoord1dvARB");
1766     qglMultiTexCoord1fARB = Sys_GLGetExtension ("glMultiTexCoord1fARB");
1767     qglMultiTexCoord1fvARB = Sys_GLGetExtension ("glMultiTexCoord1fvARB");
1768     qglMultiTexCoord1iARB = Sys_GLGetExtension ("glMultiTexCoord1iARB");
1769     qglMultiTexCoord1ivARB = Sys_GLGetExtension ("glMultiTexCoord1ivARB");
1770     qglMultiTexCoord1sARB = Sys_GLGetExtension ("glMultiTexCoord1sARB");
1771     qglMultiTexCoord1svARB = Sys_GLGetExtension ("glMultiTexCoord1svARB");
1772     qglMultiTexCoord2dARB = Sys_GLGetExtension ("glMultiTexCoord2dARB");
1773     qglMultiTexCoord2dvARB = Sys_GLGetExtension ("glMultiTexCoord2dvARB");
1774     qglMultiTexCoord2fARB = Sys_GLGetExtension ("glMultiTexCoord2fARB");
1775     qglMultiTexCoord2fvARB = Sys_GLGetExtension ("glMultiTexCoord2fvARB");
1776     qglMultiTexCoord2iARB = Sys_GLGetExtension ("glMultiTexCoord2iARB");
1777     qglMultiTexCoord2ivARB = Sys_GLGetExtension ("glMultiTexCoord2ivARB");
1778     qglMultiTexCoord2sARB = Sys_GLGetExtension ("glMultiTexCoord2sARB");
1779     qglMultiTexCoord2svARB = Sys_GLGetExtension ("glMultiTexCoord2svARB");
1780     qglMultiTexCoord3dARB = Sys_GLGetExtension ("glMultiTexCoord3dARB");
1781     qglMultiTexCoord3dvARB = Sys_GLGetExtension ("glMultiTexCoord3dvARB");
1782     qglMultiTexCoord3fARB = Sys_GLGetExtension ("glMultiTexCoord3fARB");
1783     qglMultiTexCoord3fvARB = Sys_GLGetExtension ("glMultiTexCoord3fvARB");
1784     qglMultiTexCoord3iARB = Sys_GLGetExtension ("glMultiTexCoord3iARB");
1785     qglMultiTexCoord3ivARB = Sys_GLGetExtension ("glMultiTexCoord3ivARB");
1786     qglMultiTexCoord3sARB = Sys_GLGetExtension ("glMultiTexCoord3sARB");
1787     qglMultiTexCoord3svARB = Sys_GLGetExtension ("glMultiTexCoord3svARB");
1788     qglMultiTexCoord4dARB = Sys_GLGetExtension ("glMultiTexCoord4dARB");
1789     qglMultiTexCoord4dvARB = Sys_GLGetExtension ("glMultiTexCoord4dvARB");
1790     qglMultiTexCoord4fARB = Sys_GLGetExtension ("glMultiTexCoord4fARB");
1791     qglMultiTexCoord4fvARB = Sys_GLGetExtension ("glMultiTexCoord4fvARB");
1792     qglMultiTexCoord4iARB = Sys_GLGetExtension ("glMultiTexCoord4iARB");
1793     qglMultiTexCoord4ivARB = Sys_GLGetExtension ("glMultiTexCoord4ivARB");
1794     qglMultiTexCoord4sARB = Sys_GLGetExtension ("glMultiTexCoord4sARB");
1795     qglMultiTexCoord4svARB = Sys_GLGetExtension ("glMultiTexCoord4svARB");
1796   }
1797 }